sound/pci/hda/patch_realtek.c

   1 // SPDX-License-Identifier: GPL-2.0-or-later
   2 /*
   3  * Universal Interface for Intel High Definition Audio Codec
   4  *
   5  * HD audio interface patch for Realtek ALC codecs
   6  *
   7  * Copyright (c) 2004 Kailang Yang <kailang@realtek.com.tw>
   8  *                    PeiSen Hou <pshou@realtek.com.tw>
   9  *                    Takashi Iwai <tiwai@suse.de>
  10  *                    Jonathan Woithe <jwoithe@just42.net>
  11  */
  12
  13 #include <linux/acpi.h>
  14 #include <linux/init.h>
  15 #include <linux/delay.h>
  16 #include <linux/slab.h>
  17 #include <linux/pci.h>
  18 #include <linux/dmi.h>
  19 #include <linux/module.h>
  20 #include <linux/input.h>
  21 #include <linux/leds.h>
  22 #include <linux/ctype.h>
  23 #include <sound/core.h>
  24 #include <sound/jack.h>
  25 #include <sound/hda_codec.h>
  26 #include "hda_local.h"
  27 #include "hda_auto_parser.h"
  28 #include "hda_jack.h"
  29 #include "hda_generic.h"
  30 #include "hda_component.h"
  31
  32 /* keep halting ALC5505 DSP, for power saving */
  33 #define HALT_REALTEK_ALC5505
  34
  35 /* extra amp-initialization sequence types */
  36 enum {
  37         ALC_INIT_UNDEFINED,
  38         ALC_INIT_NONE,
  39         ALC_INIT_DEFAULT,
  40 };
  41
  42 enum {
  43         ALC_HEADSET_MODE_UNKNOWN,
  44         ALC_HEADSET_MODE_UNPLUGGED,
  45         ALC_HEADSET_MODE_HEADSET,
  46         ALC_HEADSET_MODE_MIC,
  47         ALC_HEADSET_MODE_HEADPHONE,
  48 };
  49
  50 enum {
  51         ALC_HEADSET_TYPE_UNKNOWN,
  52         ALC_HEADSET_TYPE_CTIA,
  53         ALC_HEADSET_TYPE_OMTP,
  54 };
  55
  56 enum {
  57         ALC_KEY_MICMUTE_INDEX,
  58 };
  59
  60 struct alc_customize_define {
  61         unsigned int  sku_cfg;
  62         unsigned char port_connectivity;
  63         unsigned char check_sum;
  64         unsigned char customization;
  65         unsigned char external_amp;
  66         unsigned int  enable_pcbeep:1;
  67         unsigned int  platform_type:1;
  68         unsigned int  swap:1;
  69         unsigned int  override:1;
  70         unsigned int  fixup:1; /* Means that this sku is set by driver, not read from hw */
  71 };
  72
  73 struct alc_coef_led {
  74         unsigned int idx;
  75         unsigned int mask;
  76         unsigned int on;
  77         unsigned int off;
  78 };
  79
  80 struct alc_spec {
  81         struct hda_gen_spec gen; /* must be at head */
  82
  83         /* codec parameterization */
  84         struct alc_customize_define cdefine;
  85         unsigned int parse_flags; /* flag for snd_hda_parse_pin_defcfg() */
  86
  87         /* GPIO bits */
  88         unsigned int gpio_mask;
  89         unsigned int gpio_dir;
  90         unsigned int gpio_data;
  91         bool gpio_write_delay;  /* add a delay before writing gpio_data */
  92
  93         /* mute LED for HP laptops, see vref_mute_led_set() */
  94         int mute_led_polarity;
  95         int micmute_led_polarity;
  96         hda_nid_t mute_led_nid;
  97         hda_nid_t cap_mute_led_nid;
  98
  99         unsigned int gpio_mute_led_mask;
 100         unsigned int gpio_mic_led_mask;
 101         struct alc_coef_led mute_led_coef;
 102         struct alc_coef_led mic_led_coef;
 103         struct mutex coef_mutex;
 104
 105         hda_nid_t headset_mic_pin;
 106         hda_nid_t headphone_mic_pin;
 107         int current_headset_mode;
 108         int current_headset_type;
 109
 110         /* hooks */
 111         void (*init_hook)(struct hda_codec *codec);
 112 #ifdef CONFIG_PM
 113         void (*power_hook)(struct hda_codec *codec);
 114 #endif
 115         void (*shutup)(struct hda_codec *codec);
 116
 117         int init_amp;
 118         int codec_variant;      /* flag for other variants */
 119         unsigned int has_alc5505_dsp:1;
 120         unsigned int no_depop_delay:1;
 121         unsigned int done_hp_init:1;
 122         unsigned int no_shutup_pins:1;
 123         unsigned int ultra_low_power:1;
 124         unsigned int has_hs_key:1;
 125         unsigned int no_internal_mic_pin:1;
 126         unsigned int en_3kpull_low:1;
 127
 128         /* for PLL fix */
 129         hda_nid_t pll_nid;
 130         unsigned int pll_coef_idx, pll_coef_bit;
 131         unsigned int coef0;
 132         struct input_dev *kb_dev;
 133         u8 alc_mute_keycode_map[1];
 134
 135         /* component binding */
 136         struct component_match *match;
 137         struct hda_component comps[HDA_MAX_COMPONENTS];
 138 };
 139
 140 /*
 141  * COEF access helper functions
 142  */
 143
 144 static void coef_mutex_lock(struct hda_codec *codec)
 145 {
 146         struct alc_spec *spec = codec->spec;
 147
 148         snd_hda_power_up_pm(codec);
 149         mutex_lock(&spec->coef_mutex);
 150 }
 151
 152 static void coef_mutex_unlock(struct hda_codec *codec)
 153 {
 154         struct alc_spec *spec = codec->spec;
 155
 156         mutex_unlock(&spec->coef_mutex);
 157         snd_hda_power_down_pm(codec);
 158 }
 159
 160 static int __alc_read_coefex_idx(struct hda_codec *codec, hda_nid_t nid,
 161                                  unsigned int coef_idx)
 162 {
 163         unsigned int val;
 164
 165         snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_COEF_INDEX, coef_idx);
 166         val = snd_hda_codec_read(codec, nid, 0, AC_VERB_GET_PROC_COEF, 0);
 167         return val;
 168 }
 169
 170 static int alc_read_coefex_idx(struct hda_codec *codec, hda_nid_t nid,
 171                                unsigned int coef_idx)
 172 {
 173         unsigned int val;
 174
 175         coef_mutex_lock(codec);
 176         val = __alc_read_coefex_idx(codec, nid, coef_idx);
 177         coef_mutex_unlock(codec);
 178         return val;
 179 }
 180
 181 #define alc_read_coef_idx(codec, coef_idx) \
 182         alc_read_coefex_idx(codec, 0x20, coef_idx)
 183
 184 static void __alc_write_coefex_idx(struct hda_codec *codec, hda_nid_t nid,
 185                                    unsigned int coef_idx, unsigned int coef_val)
 186 {
 187         snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_COEF_INDEX, coef_idx);
 188         snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_PROC_COEF, coef_val);
 189 }
 190
 191 static void alc_write_coefex_idx(struct hda_codec *codec, hda_nid_t nid,
 192                                  unsigned int coef_idx, unsigned int coef_val)
 193 {
 194         coef_mutex_lock(codec);
 195         __alc_write_coefex_idx(codec, nid, coef_idx, coef_val);
 196         coef_mutex_unlock(codec);
 197 }
 198
 199 #define alc_write_coef_idx(codec, coef_idx, coef_val) \
 200         alc_write_coefex_idx(codec, 0x20, coef_idx, coef_val)
 201
 202 static void __alc_update_coefex_idx(struct hda_codec *codec, hda_nid_t nid,
 203                                     unsigned int coef_idx, unsigned int mask,
 204                                     unsigned int bits_set)
 205 {
 206         unsigned int val = __alc_read_coefex_idx(codec, nid, coef_idx);
 207
 208         if (val != -1)
 209                 __alc_write_coefex_idx(codec, nid, coef_idx,
 210                                        (val & ~mask) | bits_set);
 211 }
 212
 213 static void alc_update_coefex_idx(struct hda_codec *codec, hda_nid_t nid,
 214                                   unsigned int coef_idx, unsigned int mask,
 215                                   unsigned int bits_set)
 216 {
 217         coef_mutex_lock(codec);
 218         __alc_update_coefex_idx(codec, nid, coef_idx, mask, bits_set);
 219         coef_mutex_unlock(codec);
 220 }
 221
 222 #define alc_update_coef_idx(codec, coef_idx, mask, bits_set)    \
 223         alc_update_coefex_idx(codec, 0x20, coef_idx, mask, bits_set)
 224
 225 /* a special bypass for COEF 0; read the cached value at the second time */
 226 static unsigned int alc_get_coef0(struct hda_codec *codec)
 227 {
 228         struct alc_spec *spec = codec->spec;
 229
 230         if (!spec->coef0)
 231                 spec->coef0 = alc_read_coef_idx(codec, 0);
 232         return spec->coef0;
 233 }
 234
 235 /* coef writes/updates batch */
 236 struct coef_fw {
 237         unsigned char nid;
 238         unsigned char idx;
 239         unsigned short mask;
 240         unsigned short val;
 241 };
 242
 243 #define UPDATE_COEFEX(_nid, _idx, _mask, _val) \
 244         { .nid = (_nid), .idx = (_idx), .mask = (_mask), .val = (_val) }
 245 #define WRITE_COEFEX(_nid, _idx, _val) UPDATE_COEFEX(_nid, _idx, -1, _val)
 246 #define WRITE_COEF(_idx, _val) WRITE_COEFEX(0x20, _idx, _val)
 247 #define UPDATE_COEF(_idx, _mask, _val) UPDATE_COEFEX(0x20, _idx, _mask, _val)
 248
 249 static void alc_process_coef_fw(struct hda_codec *codec,
 250                                 const struct coef_fw *fw)
 251 {
 252         coef_mutex_lock(codec);
 253         for (; fw->nid; fw++) {
 254                 if (fw->mask == (unsigned short)-1)
 255                         __alc_write_coefex_idx(codec, fw->nid, fw->idx, fw->val);
 256                 else
 257                         __alc_update_coefex_idx(codec, fw->nid, fw->idx,
 258                                                 fw->mask, fw->val);
 259         }
 260         coef_mutex_unlock(codec);
 261 }
 262
 263 /*
 264  * GPIO setup tables, used in initialization
 265  */
 266
 267 /* Enable GPIO mask and set output */
 268 static void alc_setup_gpio(struct hda_codec *codec, unsigned int mask)
 269 {
 270         struct alc_spec *spec = codec->spec;
 271
 272         spec->gpio_mask |= mask;
 273         spec->gpio_dir |= mask;
 274         spec->gpio_data |= mask;
 275 }
 276
 277 static void alc_write_gpio_data(struct hda_codec *codec)
 278 {
 279         struct alc_spec *spec = codec->spec;
 280
 281         snd_hda_codec_write(codec, 0x01, 0, AC_VERB_SET_GPIO_DATA,
 282                             spec->gpio_data);
 283 }
 284
 285 static void alc_update_gpio_data(struct hda_codec *codec, unsigned int mask,
 286                                  bool on)
 287 {
 288         struct alc_spec *spec = codec->spec;
 289         unsigned int oldval = spec->gpio_data;
 290
 291         if (on)
 292                 spec->gpio_data |= mask;
 293         else
 294                 spec->gpio_data &= ~mask;
 295         if (oldval != spec->gpio_data)
 296                 alc_write_gpio_data(codec);
 297 }
 298
 299 static void alc_write_gpio(struct hda_codec *codec)
 300 {
 301         struct alc_spec *spec = codec->spec;
 302
 303         if (!spec->gpio_mask)
 304                 return;
 305
 306         snd_hda_codec_write(codec, codec->core.afg, 0,
 307                             AC_VERB_SET_GPIO_MASK, spec->gpio_mask);
 308         snd_hda_codec_write(codec, codec->core.afg, 0,
 309                             AC_VERB_SET_GPIO_DIRECTION, spec->gpio_dir);
 310         if (spec->gpio_write_delay)
 311                 msleep(1);
 312         alc_write_gpio_data(codec);
 313 }
 314
 315 static void alc_fixup_gpio(struct hda_codec *codec, int action,
 316                            unsigned int mask)
 317 {
 318         if (action == HDA_FIXUP_ACT_PRE_PROBE)
 319                 alc_setup_gpio(codec, mask);
 320 }
 321
 322 static void alc_fixup_gpio1(struct hda_codec *codec,
 323                             const struct hda_fixup *fix, int action)
 324 {
 325         alc_fixup_gpio(codec, action, 0x01);
 326 }
 327
 328 static void alc_fixup_gpio2(struct hda_codec *codec,
 329                             const struct hda_fixup *fix, int action)
 330 {
 331         alc_fixup_gpio(codec, action, 0x02);
 332 }
 333
 334 static void alc_fixup_gpio3(struct hda_codec *codec,
 335                             const struct hda_fixup *fix, int action)
 336 {
 337         alc_fixup_gpio(codec, action, 0x03);
 338 }
 339
 340 static void alc_fixup_gpio4(struct hda_codec *codec,
 341                             const struct hda_fixup *fix, int action)
 342 {
 343         alc_fixup_gpio(codec, action, 0x04);
 344 }
 345
 346 static void alc_fixup_micmute_led(struct hda_codec *codec,
 347                                   const struct hda_fixup *fix, int action)
 348 {
 349         if (action == HDA_FIXUP_ACT_PRE_PROBE)
 350                 snd_hda_gen_add_micmute_led_cdev(codec, NULL);
 351 }
 352
 353 /*
 354  * Fix hardware PLL issue
 355  * On some codecs, the analog PLL gating control must be off while
 356  * the default value is 1.
 357  */
 358 static void alc_fix_pll(struct hda_codec *codec)
 359 {
 360         struct alc_spec *spec = codec->spec;
 361
 362         if (spec->pll_nid)
 363                 alc_update_coefex_idx(codec, spec->pll_nid, spec->pll_coef_idx,
 364                                       1 << spec->pll_coef_bit, 0);
 365 }
 366
 367 static void alc_fix_pll_init(struct hda_codec *codec, hda_nid_t nid,
 368                              unsigned int coef_idx, unsigned int coef_bit)
 369 {
 370         struct alc_spec *spec = codec->spec;
 371         spec->pll_nid = nid;
 372         spec->pll_coef_idx = coef_idx;
 373         spec->pll_coef_bit = coef_bit;
 374         alc_fix_pll(codec);
 375 }
 376
 377 /* update the master volume per volume-knob's unsol event */
 378 static void alc_update_knob_master(struct hda_codec *codec,
 379                                    struct hda_jack_callback *jack)
 380 {
 381         unsigned int val;
 382         struct snd_kcontrol *kctl;
 383         struct snd_ctl_elem_value *uctl;
 384
 385         kctl = snd_hda_find_mixer_ctl(codec, "Master Playback Volume");
 386         if (!kctl)
 387                 return;
 388         uctl = kzalloc(sizeof(*uctl), GFP_KERNEL);
 389         if (!uctl)
 390                 return;
 391         val = snd_hda_codec_read(codec, jack->nid, 0,
 392                                  AC_VERB_GET_VOLUME_KNOB_CONTROL, 0);
 393         val &= HDA_AMP_VOLMASK;
 394         uctl->value.integer.value[0] = val;
 395         uctl->value.integer.value[1] = val;
 396         kctl->put(kctl, uctl);
 397         kfree(uctl);
 398 }
 399
 400 static void alc880_unsol_event(struct hda_codec *codec, unsigned int res)
 401 {
 402         /* For some reason, the res given from ALC880 is broken.
 403            Here we adjust it properly. */
 404         snd_hda_jack_unsol_event(codec, res >> 2);
 405 }
 406
 407 /* Change EAPD to verb control */
 408 static void alc_fill_eapd_coef(struct hda_codec *codec)
 409 {
 410         int coef;
 411
 412         coef = alc_get_coef0(codec);
 413
 414         switch (codec->core.vendor_id) {
 415         case 0x10ec0262:
 416                 alc_update_coef_idx(codec, 0x7, 0, 1<<5);
 417                 break;
 418         case 0x10ec0267:
 419         case 0x10ec0268:
 420                 alc_update_coef_idx(codec, 0x7, 0, 1<<13);
 421                 break;
 422         case 0x10ec0269:
 423                 if ((coef & 0x00f0) == 0x0010)
 424                         alc_update_coef_idx(codec, 0xd, 0, 1<<14);
 425                 if ((coef & 0x00f0) == 0x0020)
 426                         alc_update_coef_idx(codec, 0x4, 1<<15, 0);
 427                 if ((coef & 0x00f0) == 0x0030)
 428                         alc_update_coef_idx(codec, 0x10, 1<<9, 0);
 429                 break;
 430         case 0x10ec0280:
 431         case 0x10ec0284:
 432         case 0x10ec0290:
 433         case 0x10ec0292:
 434                 alc_update_coef_idx(codec, 0x4, 1<<15, 0);
 435                 break;
 436         case 0x10ec0225:
 437         case 0x10ec0295:
 438         case 0x10ec0299:
 439                 alc_update_coef_idx(codec, 0x67, 0xf000, 0x3000);
 440                 fallthrough;
 441         case 0x10ec0215:
 442         case 0x10ec0230:
 443         case 0x10ec0233:
 444         case 0x10ec0235:
 445         case 0x10ec0236:
 446         case 0x10ec0245:
 447         case 0x10ec0255:
 448         case 0x10ec0256:
 449         case 0x19e58326:
 450         case 0x10ec0257:
 451         case 0x10ec0282:
 452         case 0x10ec0283:
 453         case 0x10ec0286:
 454         case 0x10ec0288:
 455         case 0x10ec0285:
 456         case 0x10ec0298:
 457         case 0x10ec0289:
 458         case 0x10ec0300:
 459                 alc_update_coef_idx(codec, 0x10, 1<<9, 0);
 460                 break;
 461         case 0x10ec0275:
 462                 alc_update_coef_idx(codec, 0xe, 0, 1<<0);
 463                 break;
 464         case 0x10ec0287:
 465                 alc_update_coef_idx(codec, 0x10, 1<<9, 0);
 466                 alc_write_coef_idx(codec, 0x8, 0x4ab7);
 467                 break;
 468         case 0x10ec0293:
 469                 alc_update_coef_idx(codec, 0xa, 1<<13, 0);
 470                 break;
 471         case 0x10ec0234:
 472         case 0x10ec0274:
 473         case 0x10ec0294:
 474         case 0x10ec0700:
 475         case 0x10ec0701:
 476         case 0x10ec0703:
 477         case 0x10ec0711:
 478                 alc_update_coef_idx(codec, 0x10, 1<<15, 0);
 479                 break;
 480         case 0x10ec0662:
 481                 if ((coef & 0x00f0) == 0x0030)
 482                         alc_update_coef_idx(codec, 0x4, 1<<10, 0); /* EAPD Ctrl */
 483                 break;
 484         case 0x10ec0272:
 485         case 0x10ec0273:
 486         case 0x10ec0663:
 487         case 0x10ec0665:
 488         case 0x10ec0670:
 489         case 0x10ec0671:
 490         case 0x10ec0672:
 491                 alc_update_coef_idx(codec, 0xd, 0, 1<<14); /* EAPD Ctrl */
 492                 break;
 493         case 0x10ec0222:
 494         case 0x10ec0623:
 495                 alc_update_coef_idx(codec, 0x19, 1<<13, 0);
 496                 break;
 497         case 0x10ec0668:
 498                 alc_update_coef_idx(codec, 0x7, 3<<13, 0);
 499                 break;
 500         case 0x10ec0867:
 501                 alc_update_coef_idx(codec, 0x4, 1<<10, 0);
 502                 break;
 503         case 0x10ec0888:
 504                 if ((coef & 0x00f0) == 0x0020 || (coef & 0x00f0) == 0x0030)
 505                         alc_update_coef_idx(codec, 0x7, 1<<5, 0);
 506                 break;
 507         case 0x10ec0892:
 508         case 0x10ec0897:
 509                 alc_update_coef_idx(codec, 0x7, 1<<5, 0);
 510                 break;
 511         case 0x10ec0899:
 512         case 0x10ec0900:
 513         case 0x10ec0b00:
 514         case 0x10ec1168:
 515         case 0x10ec1220:
 516                 alc_update_coef_idx(codec, 0x7, 1<<1, 0);
 517                 break;
 518         }
 519 }
 520
 521 /* additional initialization for ALC888 variants */
 522 static void alc888_coef_init(struct hda_codec *codec)
 523 {
 524         switch (alc_get_coef0(codec) & 0x00f0) {
 525         /* alc888-VA */
 526         case 0x00:
 527         /* alc888-VB */
 528         case 0x10:
 529                 alc_update_coef_idx(codec, 7, 0, 0x2030); /* Turn EAPD to High */
 530                 break;
 531         }
 532 }
 533
 534 /* turn on/off EAPD control (only if available) */
 535 static void set_eapd(struct hda_codec *codec, hda_nid_t nid, int on)
 536 {
 537         if (get_wcaps_type(get_wcaps(codec, nid)) != AC_WID_PIN)
 538                 return;
 539         if (snd_hda_query_pin_caps(codec, nid) & AC_PINCAP_EAPD)
 540                 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_EAPD_BTLENABLE,
 541                                     on ? 2 : 0);
 542 }
 543
 544 /* turn on/off EAPD controls of the codec */
 545 static void alc_auto_setup_eapd(struct hda_codec *codec, bool on)
 546 {
 547         /* We currently only handle front, HP */
 548         static const hda_nid_t pins[] = {
 549                 0x0f, 0x10, 0x14, 0x15, 0x17, 0
 550         };
 551         const hda_nid_t *p;
 552         for (p = pins; *p; p++)
 553                 set_eapd(codec, *p, on);
 554 }
 555
 556 static int find_ext_mic_pin(struct hda_codec *codec);
 557
 558 static void alc_headset_mic_no_shutup(struct hda_codec *codec)
 559 {
 560         const struct hda_pincfg *pin;
 561         int mic_pin = find_ext_mic_pin(codec);
 562         int i;
 563
 564         /* don't shut up pins when unloading the driver; otherwise it breaks
 565          * the default pin setup at the next load of the driver
 566          */
 567         if (codec->bus->shutdown)
 568                 return;
 569
 570         snd_array_for_each(&codec->init_pins, i, pin) {
 571                 /* use read here for syncing after issuing each verb */
 572                 if (pin->nid != mic_pin)
 573                         snd_hda_codec_read(codec, pin->nid, 0,
 574                                         AC_VERB_SET_PIN_WIDGET_CONTROL, 0);
 575         }
 576
 577         codec->pins_shutup = 1;
 578 }
 579
 580 static void alc_shutup_pins(struct hda_codec *codec)
 581 {
 582         struct alc_spec *spec = codec->spec;
 583
 584         switch (codec->core.vendor_id) {
 585         case 0x10ec0236:
 586         case 0x10ec0256:
 587         case 0x19e58326:
 588         case 0x10ec0283:
 589         case 0x10ec0286:
 590         case 0x10ec0288:
 591         case 0x10ec0298:
 592                 alc_headset_mic_no_shutup(codec);
 593                 break;
 594         default:
 595                 if (!spec->no_shutup_pins)
 596                         snd_hda_shutup_pins(codec);
 597                 break;
 598         }
 599 }
 600
 601 /* generic shutup callback;
 602  * just turning off EAPD and a little pause for avoiding pop-noise
 603  */
 604 static void alc_eapd_shutup(struct hda_codec *codec)
 605 {
 606         struct alc_spec *spec = codec->spec;
 607
 608         alc_auto_setup_eapd(codec, false);
 609         if (!spec->no_depop_delay)
 610                 msleep(200);
 611         alc_shutup_pins(codec);
 612 }
 613
 614 /* generic EAPD initialization */
 615 static void alc_auto_init_amp(struct hda_codec *codec, int type)
 616 {
 617         alc_auto_setup_eapd(codec, true);
 618         alc_write_gpio(codec);
 619         switch (type) {
 620         case ALC_INIT_DEFAULT:
 621                 switch (codec->core.vendor_id) {
 622                 case 0x10ec0260:
 623                         alc_update_coefex_idx(codec, 0x1a, 7, 0, 0x2010);
 624                         break;
 625                 case 0x10ec0880:
 626                 case 0x10ec0882:
 627                 case 0x10ec0883:
 628                 case 0x10ec0885:
 629                         alc_update_coef_idx(codec, 7, 0, 0x2030);
 630                         break;
 631                 case 0x10ec0888:
 632                         alc888_coef_init(codec);
 633                         break;
 634                 }
 635                 break;
 636         }
 637 }
 638
 639 /* get a primary headphone pin if available */
 640 static hda_nid_t alc_get_hp_pin(struct alc_spec *spec)
 641 {
 642         if (spec->gen.autocfg.hp_pins[0])
 643                 return spec->gen.autocfg.hp_pins[0];
 644         if (spec->gen.autocfg.line_out_type == AC_JACK_HP_OUT)
 645                 return spec->gen.autocfg.line_out_pins[0];
 646         return 0;
 647 }
 648
 649 /*
 650  * Realtek SSID verification
 651  */
 652
 653 /* Could be any non-zero and even value. When used as fixup, tells
 654  * the driver to ignore any present sku defines.
 655  */
 656 #define ALC_FIXUP_SKU_IGNORE (2)
 657
 658 static void alc_fixup_sku_ignore(struct hda_codec *codec,
 659                                  const struct hda_fixup *fix, int action)
 660 {
 661         struct alc_spec *spec = codec->spec;
 662         if (action == HDA_FIXUP_ACT_PRE_PROBE) {
 663                 spec->cdefine.fixup = 1;
 664                 spec->cdefine.sku_cfg = ALC_FIXUP_SKU_IGNORE;
 665         }
 666 }
 667
 668 static void alc_fixup_no_depop_delay(struct hda_codec *codec,
 669                                     const struct hda_fixup *fix, int action)
 670 {
 671         struct alc_spec *spec = codec->spec;
 672
 673         if (action == HDA_FIXUP_ACT_PROBE) {
 674                 spec->no_depop_delay = 1;
 675                 codec->depop_delay = 0;
 676         }
 677 }
 678
 679 static int alc_auto_parse_customize_define(struct hda_codec *codec)
 680 {
 681         unsigned int ass, tmp, i;
 682         unsigned nid = 0;
 683         struct alc_spec *spec = codec->spec;
 684
 685         spec->cdefine.enable_pcbeep = 1; /* assume always enabled */
 686
 687         if (spec->cdefine.fixup) {
 688                 ass = spec->cdefine.sku_cfg;
 689                 if (ass == ALC_FIXUP_SKU_IGNORE)
 690                         return -1;
 691                 goto do_sku;
 692         }
 693
 694         if (!codec->bus->pci)
 695                 return -1;
 696         ass = codec->core.subsystem_id & 0xffff;
 697         if (ass != codec->bus->pci->subsystem_device && (ass & 1))
 698                 goto do_sku;
 699
 700         nid = 0x1d;
 701         if (codec->core.vendor_id == 0x10ec0260)
 702                 nid = 0x17;
 703         ass = snd_hda_codec_get_pincfg(codec, nid);
 704
 705         if (!(ass & 1)) {
 706                 codec_info(codec, "%s: SKU not ready 0x%08x\n",
 707                            codec->core.chip_name, ass);
 708                 return -1;
 709         }
 710
 711         /* check sum */
 712         tmp = 0;
 713         for (i = 1; i < 16; i++) {
 714                 if ((ass >> i) & 1)
 715                         tmp++;
 716         }
 717         if (((ass >> 16) & 0xf) != tmp)
 718                 return -1;
 719
 720         spec->cdefine.port_connectivity = ass >> 30;
 721         spec->cdefine.enable_pcbeep = (ass & 0x100000) >> 20;
 722         spec->cdefine.check_sum = (ass >> 16) & 0xf;
 723         spec->cdefine.customization = ass >> 8;
 724 do_sku:
 725         spec->cdefine.sku_cfg = ass;
 726         spec->cdefine.external_amp = (ass & 0x38) >> 3;
 727         spec->cdefine.platform_type = (ass & 0x4) >> 2;
 728         spec->cdefine.swap = (ass & 0x2) >> 1;
 729         spec->cdefine.override = ass & 0x1;
 730
 731         codec_dbg(codec, "SKU: Nid=0x%x sku_cfg=0x%08x\n",
 732                    nid, spec->cdefine.sku_cfg);
 733         codec_dbg(codec, "SKU: port_connectivity=0x%x\n",
 734                    spec->cdefine.port_connectivity);
 735         codec_dbg(codec, "SKU: enable_pcbeep=0x%x\n", spec->cdefine.enable_pcbeep);
 736         codec_dbg(codec, "SKU: check_sum=0x%08x\n", spec->cdefine.check_sum);
 737         codec_dbg(codec, "SKU: customization=0x%08x\n", spec->cdefine.customization);
 738         codec_dbg(codec, "SKU: external_amp=0x%x\n", spec->cdefine.external_amp);
 739         codec_dbg(codec, "SKU: platform_type=0x%x\n", spec->cdefine.platform_type);
 740         codec_dbg(codec, "SKU: swap=0x%x\n", spec->cdefine.swap);
 741         codec_dbg(codec, "SKU: override=0x%x\n", spec->cdefine.override);
 742
 743         return 0;
 744 }
 745
 746 /* return the position of NID in the list, or -1 if not found */
 747 static int find_idx_in_nid_list(hda_nid_t nid, const hda_nid_t *list, int nums)
 748 {
 749         int i;
 750         for (i = 0; i < nums; i++)
 751                 if (list[i] == nid)
 752                         return i;
 753         return -1;
 754 }
 755 /* return true if the given NID is found in the list */
 756 static bool found_in_nid_list(hda_nid_t nid, const hda_nid_t *list, int nums)
 757 {
 758         return find_idx_in_nid_list(nid, list, nums) >= 0;
 759 }
 760
 761 /* check subsystem ID and set up device-specific initialization;
 762  * return 1 if initialized, 0 if invalid SSID
 763  */
 764 /* 32-bit subsystem ID for BIOS loading in HD Audio codec.
 765  *      31 ~ 16 :       Manufacture ID
 766  *      15 ~ 8  :       SKU ID
 767  *      7  ~ 0  :       Assembly ID
 768  *      port-A --> pin 39/41, port-E --> pin 14/15, port-D --> pin 35/36
 769  */
 770 static int alc_subsystem_id(struct hda_codec *codec, const hda_nid_t *ports)
 771 {
 772         unsigned int ass, tmp, i;
 773         unsigned nid;
 774         struct alc_spec *spec = codec->spec;
 775
 776         if (spec->cdefine.fixup) {
 777                 ass = spec->cdefine.sku_cfg;
 778                 if (ass == ALC_FIXUP_SKU_IGNORE)
 779                         return 0;
 780                 goto do_sku;
 781         }
 782
 783         ass = codec->core.subsystem_id & 0xffff;
 784         if (codec->bus->pci &&
 785             ass != codec->bus->pci->subsystem_device && (ass & 1))
 786                 goto do_sku;
 787
 788         /* invalid SSID, check the special NID pin defcfg instead */
 789         /*
 790          * 31~30        : port connectivity
 791          * 29~21        : reserve
 792          * 20           : PCBEEP input
 793          * 19~16        : Check sum (15:1)
 794          * 15~1         : Custom
 795          * 0            : override
 796         */
 797         nid = 0x1d;
 798         if (codec->core.vendor_id == 0x10ec0260)
 799                 nid = 0x17;
 800         ass = snd_hda_codec_get_pincfg(codec, nid);
 801         codec_dbg(codec,
 802                   "realtek: No valid SSID, checking pincfg 0x%08x for NID 0x%x\n",
 803                    ass, nid);
 804         if (!(ass & 1))
 805                 return 0;
 806         if ((ass >> 30) != 1)   /* no physical connection */
 807                 return 0;
 808
 809         /* check sum */
 810         tmp = 0;
 811         for (i = 1; i < 16; i++) {
 812                 if ((ass >> i) & 1)
 813                         tmp++;
 814         }
 815         if (((ass >> 16) & 0xf) != tmp)
 816                 return 0;
 817 do_sku:
 818         codec_dbg(codec, "realtek: Enabling init ASM_ID=0x%04x CODEC_ID=%08x\n",
 819                    ass & 0xffff, codec->core.vendor_id);
 820         /*
 821          * 0 : override
 822          * 1 :  Swap Jack
 823          * 2 : 0 --> Desktop, 1 --> Laptop
 824          * 3~5 : External Amplifier control
 825          * 7~6 : Reserved
 826         */
 827         tmp = (ass & 0x38) >> 3;        /* external Amp control */
 828         if (spec->init_amp == ALC_INIT_UNDEFINED) {
 829                 switch (tmp) {
 830                 case 1:
 831                         alc_setup_gpio(codec, 0x01);
 832                         break;
 833                 case 3:
 834                         alc_setup_gpio(codec, 0x02);
 835                         break;
 836                 case 7:
 837                         alc_setup_gpio(codec, 0x04);
 838                         break;
 839                 case 5:
 840                 default:
 841                         spec->init_amp = ALC_INIT_DEFAULT;
 842                         break;
 843                 }
 844         }
 845
 846         /* is laptop or Desktop and enable the function "Mute internal speaker
 847          * when the external headphone out jack is plugged"
 848          */
 849         if (!(ass & 0x8000))
 850                 return 1;
 851         /*
 852          * 10~8 : Jack location
 853          * 12~11: Headphone out -> 00: PortA, 01: PortE, 02: PortD, 03: Resvered
 854          * 14~13: Resvered
 855          * 15   : 1 --> enable the function "Mute internal speaker
 856          *              when the external headphone out jack is plugged"
 857          */
 858         if (!alc_get_hp_pin(spec)) {
 859                 hda_nid_t nid;
 860                 tmp = (ass >> 11) & 0x3;        /* HP to chassis */
 861                 nid = ports[tmp];
 862                 if (found_in_nid_list(nid, spec->gen.autocfg.line_out_pins,
 863                                       spec->gen.autocfg.line_outs))
 864                         return 1;
 865                 spec->gen.autocfg.hp_pins[0] = nid;
 866         }
 867         return 1;
 868 }
 869
 870 /* Check the validity of ALC subsystem-id
 871  * ports contains an array of 4 pin NIDs for port-A, E, D and I */
 872 static void alc_ssid_check(struct hda_codec *codec, const hda_nid_t *ports)
 873 {
 874         if (!alc_subsystem_id(codec, ports)) {
 875                 struct alc_spec *spec = codec->spec;
 876                 if (spec->init_amp == ALC_INIT_UNDEFINED) {
 877                         codec_dbg(codec,
 878                                   "realtek: Enable default setup for auto mode as fallback\n");
 879                         spec->init_amp = ALC_INIT_DEFAULT;
 880                 }
 881         }
 882 }
 883
 884 /*
 885  */
 886
 887 static void alc_fixup_inv_dmic(struct hda_codec *codec,
 888                                const struct hda_fixup *fix, int action)
 889 {
 890         struct alc_spec *spec = codec->spec;
 891
 892         spec->gen.inv_dmic_split = 1;
 893 }
 894
 895
 896 static int alc_build_controls(struct hda_codec *codec)
 897 {
 898         int err;
 899
 900         err = snd_hda_gen_build_controls(codec);
 901         if (err < 0)
 902                 return err;
 903
 904         snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_BUILD);
 905         return 0;
 906 }
 907
 908
 909 /*
 910  * Common callbacks
 911  */
 912
 913 static void alc_pre_init(struct hda_codec *codec)
 914 {
 915         alc_fill_eapd_coef(codec);
 916 }
 917
 918 #define is_s3_resume(codec) \
 919         ((codec)->core.dev.power.power_state.event == PM_EVENT_RESUME)
 920 #define is_s4_resume(codec) \
 921         ((codec)->core.dev.power.power_state.event == PM_EVENT_RESTORE)
 922
 923 static int alc_init(struct hda_codec *codec)
 924 {
 925         struct alc_spec *spec = codec->spec;
 926
 927         /* hibernation resume needs the full chip initialization */
 928         if (is_s4_resume(codec))
 929                 alc_pre_init(codec);
 930
 931         if (spec->init_hook)
 932                 spec->init_hook(codec);
 933
 934         spec->gen.skip_verbs = 1; /* applied in below */
 935         snd_hda_gen_init(codec);
 936         alc_fix_pll(codec);
 937         alc_auto_init_amp(codec, spec->init_amp);
 938         snd_hda_apply_verbs(codec); /* apply verbs here after own init */
 939
 940         snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_INIT);
 941
 942         return 0;
 943 }
 944
 945 #define alc_free        snd_hda_gen_free
 946
 947 #ifdef CONFIG_PM
 948 static inline void alc_shutup(struct hda_codec *codec)
 949 {
 950         struct alc_spec *spec = codec->spec;
 951
 952         if (!snd_hda_get_bool_hint(codec, "shutup"))
 953                 return; /* disabled explicitly by hints */
 954
 955         if (spec && spec->shutup)
 956                 spec->shutup(codec);
 957         else
 958                 alc_shutup_pins(codec);
 959 }
 960
 961 static void alc_power_eapd(struct hda_codec *codec)
 962 {
 963         alc_auto_setup_eapd(codec, false);
 964 }
 965
 966 static int alc_suspend(struct hda_codec *codec)
 967 {
 968         struct alc_spec *spec = codec->spec;
 969         alc_shutup(codec);
 970         if (spec && spec->power_hook)
 971                 spec->power_hook(codec);
 972         return 0;
 973 }
 974
 975 static int alc_resume(struct hda_codec *codec)
 976 {
 977         struct alc_spec *spec = codec->spec;
 978
 979         if (!spec->no_depop_delay)
 980                 msleep(150); /* to avoid pop noise */
 981         codec->patch_ops.init(codec);
 982         snd_hda_regmap_sync(codec);
 983         hda_call_check_power_status(codec, 0x01);
 984         return 0;
 985 }
 986 #endif
 987
 988 /*
 989  */
 990 static const struct hda_codec_ops alc_patch_ops = {
 991         .build_controls = alc_build_controls,
 992         .build_pcms = snd_hda_gen_build_pcms,
 993         .init = alc_init,
 994         .free = alc_free,
 995         .unsol_event = snd_hda_jack_unsol_event,
 996 #ifdef CONFIG_PM
 997         .resume = alc_resume,
 998         .suspend = alc_suspend,
 999         .check_power_status = snd_hda_gen_check_power_status,
1000 #endif
1001 };
1002
1003
1004 #define alc_codec_rename(codec, name) snd_hda_codec_set_name(codec, name)
1005
1006 /*
1007  * Rename codecs appropriately from COEF value or subvendor id
1008  */
1009 struct alc_codec_rename_table {
1010         unsigned int vendor_id;
1011         unsigned short coef_mask;
1012         unsigned short coef_bits;
1013         const char *name;
1014 };
1015
1016 struct alc_codec_rename_pci_table {
1017         unsigned int codec_vendor_id;
1018         unsigned short pci_subvendor;
1019         unsigned short pci_subdevice;
1020         const char *name;
1021 };
1022
1023 static const struct alc_codec_rename_table rename_tbl[] = {
1024         { 0x10ec0221, 0xf00f, 0x1003, "ALC231" },
1025         { 0x10ec0269, 0xfff0, 0x3010, "ALC277" },
1026         { 0x10ec0269, 0xf0f0, 0x2010, "ALC259" },
1027         { 0x10ec0269, 0xf0f0, 0x3010, "ALC258" },
1028         { 0x10ec0269, 0x00f0, 0x0010, "ALC269VB" },
1029         { 0x10ec0269, 0xffff, 0xa023, "ALC259" },
1030         { 0x10ec0269, 0xffff, 0x6023, "ALC281X" },
1031         { 0x10ec0269, 0x00f0, 0x0020, "ALC269VC" },
1032         { 0x10ec0269, 0x00f0, 0x0030, "ALC269VD" },
1033         { 0x10ec0662, 0xffff, 0x4020, "ALC656" },
1034         { 0x10ec0887, 0x00f0, 0x0030, "ALC887-VD" },
1035         { 0x10ec0888, 0x00f0, 0x0030, "ALC888-VD" },
1036         { 0x10ec0888, 0xf0f0, 0x3020, "ALC886" },
1037         { 0x10ec0899, 0x2000, 0x2000, "ALC899" },
1038         { 0x10ec0892, 0xffff, 0x8020, "ALC661" },
1039         { 0x10ec0892, 0xffff, 0x8011, "ALC661" },
1040         { 0x10ec0892, 0xffff, 0x4011, "ALC656" },
1041         { } /* terminator */
1042 };
1043
1044 static const struct alc_codec_rename_pci_table rename_pci_tbl[] = {
1045         { 0x10ec0280, 0x1028, 0, "ALC3220" },
1046         { 0x10ec0282, 0x1028, 0, "ALC3221" },
1047         { 0x10ec0283, 0x1028, 0, "ALC3223" },
1048         { 0x10ec0288, 0x1028, 0, "ALC3263" },
1049         { 0x10ec0292, 0x1028, 0, "ALC3226" },
1050         { 0x10ec0293, 0x1028, 0, "ALC3235" },
1051         { 0x10ec0255, 0x1028, 0, "ALC3234" },
1052         { 0x10ec0668, 0x1028, 0, "ALC3661" },
1053         { 0x10ec0275, 0x1028, 0, "ALC3260" },
1054         { 0x10ec0899, 0x1028, 0, "ALC3861" },
1055         { 0x10ec0298, 0x1028, 0, "ALC3266" },
1056         { 0x10ec0236, 0x1028, 0, "ALC3204" },
1057         { 0x10ec0256, 0x1028, 0, "ALC3246" },
1058         { 0x10ec0225, 0x1028, 0, "ALC3253" },
1059         { 0x10ec0295, 0x1028, 0, "ALC3254" },
1060         { 0x10ec0299, 0x1028, 0, "ALC3271" },
1061         { 0x10ec0670, 0x1025, 0, "ALC669X" },
1062         { 0x10ec0676, 0x1025, 0, "ALC679X" },
1063         { 0x10ec0282, 0x1043, 0, "ALC3229" },
1064         { 0x10ec0233, 0x1043, 0, "ALC3236" },
1065         { 0x10ec0280, 0x103c, 0, "ALC3228" },
1066         { 0x10ec0282, 0x103c, 0, "ALC3227" },
1067         { 0x10ec0286, 0x103c, 0, "ALC3242" },
1068         { 0x10ec0290, 0x103c, 0, "ALC3241" },
1069         { 0x10ec0668, 0x103c, 0, "ALC3662" },
1070         { 0x10ec0283, 0x17aa, 0, "ALC3239" },
1071         { 0x10ec0292, 0x17aa, 0, "ALC3232" },
1072         { } /* terminator */
1073 };
1074
1075 static int alc_codec_rename_from_preset(struct hda_codec *codec)
1076 {
1077         const struct alc_codec_rename_table *p;
1078         const struct alc_codec_rename_pci_table *q;
1079
1080         for (p = rename_tbl; p->vendor_id; p++) {
1081                 if (p->vendor_id != codec->core.vendor_id)
1082                         continue;
1083                 if ((alc_get_coef0(codec) & p->coef_mask) == p->coef_bits)
1084                         return alc_codec_rename(codec, p->name);
1085         }
1086
1087         if (!codec->bus->pci)
1088                 return 0;
1089         for (q = rename_pci_tbl; q->codec_vendor_id; q++) {
1090                 if (q->codec_vendor_id != codec->core.vendor_id)
1091                         continue;
1092                 if (q->pci_subvendor != codec->bus->pci->subsystem_vendor)
1093                         continue;
1094                 if (!q->pci_subdevice ||
1095                     q->pci_subdevice == codec->bus->pci->subsystem_device)
1096                         return alc_codec_rename(codec, q->name);
1097         }
1098
1099         return 0;
1100 }
1101
1102
1103 /*
1104  * Digital-beep handlers
1105  */
1106 #ifdef CONFIG_SND_HDA_INPUT_BEEP
1107
1108 /* additional beep mixers; private_value will be overwritten */
1109 static const struct snd_kcontrol_new alc_beep_mixer[] = {
1110         HDA_CODEC_VOLUME("Beep Playback Volume", 0, 0, HDA_INPUT),
1111         HDA_CODEC_MUTE_BEEP("Beep Playback Switch", 0, 0, HDA_INPUT),
1112 };
1113
1114 /* set up and create beep controls */
1115 static int set_beep_amp(struct alc_spec *spec, hda_nid_t nid,
1116                         int idx, int dir)
1117 {
1118         struct snd_kcontrol_new *knew;
1119         unsigned int beep_amp = HDA_COMPOSE_AMP_VAL(nid, 3, idx, dir);
1120         int i;
1121
1122         for (i = 0; i < ARRAY_SIZE(alc_beep_mixer); i++) {
1123                 knew = snd_hda_gen_add_kctl(&spec->gen, NULL,
1124                                             &alc_beep_mixer[i]);
1125                 if (!knew)
1126                         return -ENOMEM;
1127                 knew->private_value = beep_amp;
1128         }
1129         return 0;
1130 }
1131
1132 static const struct snd_pci_quirk beep_allow_list[] = {
1133         SND_PCI_QUIRK(0x1043, 0x103c, "ASUS", 1),
1134         SND_PCI_QUIRK(0x1043, 0x115d, "ASUS", 1),
1135         SND_PCI_QUIRK(0x1043, 0x829f, "ASUS", 1),
1136         SND_PCI_QUIRK(0x1043, 0x8376, "EeePC", 1),
1137         SND_PCI_QUIRK(0x1043, 0x83ce, "EeePC", 1),
1138         SND_PCI_QUIRK(0x1043, 0x831a, "EeePC", 1),
1139         SND_PCI_QUIRK(0x1043, 0x834a, "EeePC", 1),
1140         SND_PCI_QUIRK(0x1458, 0xa002, "GA-MA790X", 1),
1141         SND_PCI_QUIRK(0x8086, 0xd613, "Intel", 1),
1142         /* denylist -- no beep available */
1143         SND_PCI_QUIRK(0x17aa, 0x309e, "Lenovo ThinkCentre M73", 0),
1144         SND_PCI_QUIRK(0x17aa, 0x30a3, "Lenovo ThinkCentre M93", 0),
1145         {}
1146 };
1147
1148 static inline int has_cdefine_beep(struct hda_codec *codec)
1149 {
1150         struct alc_spec *spec = codec->spec;
1151         const struct snd_pci_quirk *q;
1152         q = snd_pci_quirk_lookup(codec->bus->pci, beep_allow_list);
1153         if (q)
1154                 return q->value;
1155         return spec->cdefine.enable_pcbeep;
1156 }
1157 #else
1158 #define set_beep_amp(spec, nid, idx, dir)       0
1159 #define has_cdefine_beep(codec)         0
1160 #endif
1161
1162 /* parse the BIOS configuration and set up the alc_spec */
1163 /* return 1 if successful, 0 if the proper config is not found,
1164  * or a negative error code
1165  */
1166 static int alc_parse_auto_config(struct hda_codec *codec,
1167                                  const hda_nid_t *ignore_nids,
1168                                  const hda_nid_t *ssid_nids)
1169 {
1170         struct alc_spec *spec = codec->spec;
1171         struct auto_pin_cfg *cfg = &spec->gen.autocfg;
1172         int err;
1173
1174         err = snd_hda_parse_pin_defcfg(codec, cfg, ignore_nids,
1175                                        spec->parse_flags);
1176         if (err < 0)
1177                 return err;
1178
1179         if (ssid_nids)
1180                 alc_ssid_check(codec, ssid_nids);
1181
1182         err = snd_hda_gen_parse_auto_config(codec, cfg);
1183         if (err < 0)
1184                 return err;
1185
1186         return 1;
1187 }
1188
1189 /* common preparation job for alc_spec */
1190 static int alc_alloc_spec(struct hda_codec *codec, hda_nid_t mixer_nid)
1191 {
1192         struct alc_spec *spec = kzalloc(sizeof(*spec), GFP_KERNEL);
1193         int err;
1194
1195         if (!spec)
1196                 return -ENOMEM;
1197         codec->spec = spec;
1198         snd_hda_gen_spec_init(&spec->gen);
1199         spec->gen.mixer_nid = mixer_nid;
1200         spec->gen.own_eapd_ctl = 1;
1201         codec->single_adc_amp = 1;
1202         /* FIXME: do we need this for all Realtek codec models? */
1203         codec->spdif_status_reset = 1;
1204         codec->forced_resume = 1;
1205         codec->patch_ops = alc_patch_ops;
1206         mutex_init(&spec->coef_mutex);
1207
1208         err = alc_codec_rename_from_preset(codec);
1209         if (err < 0) {
1210                 kfree(spec);
1211                 return err;
1212         }
1213         return 0;
1214 }
1215
1216 static int alc880_parse_auto_config(struct hda_codec *codec)
1217 {
1218         static const hda_nid_t alc880_ignore[] = { 0x1d, 0 };
1219         static const hda_nid_t alc880_ssids[] = { 0x15, 0x1b, 0x14, 0 };
1220         return alc_parse_auto_config(codec, alc880_ignore, alc880_ssids);
1221 }
1222
1223 /*
1224  * ALC880 fix-ups
1225  */
1226 enum {
1227         ALC880_FIXUP_GPIO1,
1228         ALC880_FIXUP_GPIO2,
1229         ALC880_FIXUP_MEDION_RIM,
1230         ALC880_FIXUP_LG,
1231         ALC880_FIXUP_LG_LW25,
1232         ALC880_FIXUP_W810,
1233         ALC880_FIXUP_EAPD_COEF,
1234         ALC880_FIXUP_TCL_S700,
1235         ALC880_FIXUP_VOL_KNOB,
1236         ALC880_FIXUP_FUJITSU,
1237         ALC880_FIXUP_F1734,
1238         ALC880_FIXUP_UNIWILL,
1239         ALC880_FIXUP_UNIWILL_DIG,
1240         ALC880_FIXUP_Z71V,
1241         ALC880_FIXUP_ASUS_W5A,
1242         ALC880_FIXUP_3ST_BASE,
1243         ALC880_FIXUP_3ST,
1244         ALC880_FIXUP_3ST_DIG,
1245         ALC880_FIXUP_5ST_BASE,
1246         ALC880_FIXUP_5ST,
1247         ALC880_FIXUP_5ST_DIG,
1248         ALC880_FIXUP_6ST_BASE,
1249         ALC880_FIXUP_6ST,
1250         ALC880_FIXUP_6ST_DIG,
1251         ALC880_FIXUP_6ST_AUTOMUTE,
1252 };
1253
1254 /* enable the volume-knob widget support on NID 0x21 */
1255 static void alc880_fixup_vol_knob(struct hda_codec *codec,
1256                                   const struct hda_fixup *fix, int action)
1257 {
1258         if (action == HDA_FIXUP_ACT_PROBE)
1259                 snd_hda_jack_detect_enable_callback(codec, 0x21,
1260                                                     alc_update_knob_master);
1261 }
1262
1263 static const struct hda_fixup alc880_fixups[] = {
1264         [ALC880_FIXUP_GPIO1] = {
1265                 .type = HDA_FIXUP_FUNC,
1266                 .v.func = alc_fixup_gpio1,
1267         },
1268         [ALC880_FIXUP_GPIO2] = {
1269                 .type = HDA_FIXUP_FUNC,
1270                 .v.func = alc_fixup_gpio2,
1271         },
1272         [ALC880_FIXUP_MEDION_RIM] = {
1273                 .type = HDA_FIXUP_VERBS,
1274                 .v.verbs = (const struct hda_verb[]) {
1275                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x07 },
1276                         { 0x20, AC_VERB_SET_PROC_COEF,  0x3060 },
1277                         { }
1278                 },
1279                 .chained = true,
1280                 .chain_id = ALC880_FIXUP_GPIO2,
1281         },
1282         [ALC880_FIXUP_LG] = {
1283                 .type = HDA_FIXUP_PINS,
1284                 .v.pins = (const struct hda_pintbl[]) {
1285                         /* disable bogus unused pins */
1286                         { 0x16, 0x411111f0 },
1287                         { 0x18, 0x411111f0 },
1288                         { 0x1a, 0x411111f0 },
1289                         { }
1290                 }
1291         },
1292         [ALC880_FIXUP_LG_LW25] = {
1293                 .type = HDA_FIXUP_PINS,
1294                 .v.pins = (const struct hda_pintbl[]) {
1295                         { 0x1a, 0x0181344f }, /* line-in */
1296                         { 0x1b, 0x0321403f }, /* headphone */
1297                         { }
1298                 }
1299         },
1300         [ALC880_FIXUP_W810] = {
1301                 .type = HDA_FIXUP_PINS,
1302                 .v.pins = (const struct hda_pintbl[]) {
1303                         /* disable bogus unused pins */
1304                         { 0x17, 0x411111f0 },
1305                         { }
1306                 },
1307                 .chained = true,
1308                 .chain_id = ALC880_FIXUP_GPIO2,
1309         },
1310         [ALC880_FIXUP_EAPD_COEF] = {
1311                 .type = HDA_FIXUP_VERBS,
1312                 .v.verbs = (const struct hda_verb[]) {
1313                         /* change to EAPD mode */
1314                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x07 },
1315                         { 0x20, AC_VERB_SET_PROC_COEF,  0x3060 },
1316                         {}
1317                 },
1318         },
1319         [ALC880_FIXUP_TCL_S700] = {
1320                 .type = HDA_FIXUP_VERBS,
1321                 .v.verbs = (const struct hda_verb[]) {
1322                         /* change to EAPD mode */
1323                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x07 },
1324                         { 0x20, AC_VERB_SET_PROC_COEF,  0x3070 },
1325                         {}
1326                 },
1327                 .chained = true,
1328                 .chain_id = ALC880_FIXUP_GPIO2,
1329         },
1330         [ALC880_FIXUP_VOL_KNOB] = {
1331                 .type = HDA_FIXUP_FUNC,
1332                 .v.func = alc880_fixup_vol_knob,
1333         },
1334         [ALC880_FIXUP_FUJITSU] = {
1335                 /* override all pins as BIOS on old Amilo is broken */
1336                 .type = HDA_FIXUP_PINS,
1337                 .v.pins = (const struct hda_pintbl[]) {
1338                         { 0x14, 0x0121401f }, /* HP */
1339                         { 0x15, 0x99030120 }, /* speaker */
1340                         { 0x16, 0x99030130 }, /* bass speaker */
1341                         { 0x17, 0x411111f0 }, /* N/A */
1342                         { 0x18, 0x411111f0 }, /* N/A */
1343                         { 0x19, 0x01a19950 }, /* mic-in */
1344                         { 0x1a, 0x411111f0 }, /* N/A */
1345                         { 0x1b, 0x411111f0 }, /* N/A */
1346                         { 0x1c, 0x411111f0 }, /* N/A */
1347                         { 0x1d, 0x411111f0 }, /* N/A */
1348                         { 0x1e, 0x01454140 }, /* SPDIF out */
1349                         { }
1350                 },
1351                 .chained = true,
1352                 .chain_id = ALC880_FIXUP_VOL_KNOB,
1353         },
1354         [ALC880_FIXUP_F1734] = {
1355                 /* almost compatible with FUJITSU, but no bass and SPDIF */
1356                 .type = HDA_FIXUP_PINS,
1357                 .v.pins = (const struct hda_pintbl[]) {
1358                         { 0x14, 0x0121401f }, /* HP */
1359                         { 0x15, 0x99030120 }, /* speaker */
1360                         { 0x16, 0x411111f0 }, /* N/A */
1361                         { 0x17, 0x411111f0 }, /* N/A */
1362                         { 0x18, 0x411111f0 }, /* N/A */
1363                         { 0x19, 0x01a19950 }, /* mic-in */
1364                         { 0x1a, 0x411111f0 }, /* N/A */
1365                         { 0x1b, 0x411111f0 }, /* N/A */
1366                         { 0x1c, 0x411111f0 }, /* N/A */
1367                         { 0x1d, 0x411111f0 }, /* N/A */
1368                         { 0x1e, 0x411111f0 }, /* N/A */
1369                         { }
1370                 },
1371                 .chained = true,
1372                 .chain_id = ALC880_FIXUP_VOL_KNOB,
1373         },
1374         [ALC880_FIXUP_UNIWILL] = {
1375                 /* need to fix HP and speaker pins to be parsed correctly */
1376                 .type = HDA_FIXUP_PINS,
1377                 .v.pins = (const struct hda_pintbl[]) {
1378                         { 0x14, 0x0121411f }, /* HP */
1379                         { 0x15, 0x99030120 }, /* speaker */
1380                         { 0x16, 0x99030130 }, /* bass speaker */
1381                         { }
1382                 },
1383         },
1384         [ALC880_FIXUP_UNIWILL_DIG] = {
1385                 .type = HDA_FIXUP_PINS,
1386                 .v.pins = (const struct hda_pintbl[]) {
1387                         /* disable bogus unused pins */
1388                         { 0x17, 0x411111f0 },
1389                         { 0x19, 0x411111f0 },
1390                         { 0x1b, 0x411111f0 },
1391                         { 0x1f, 0x411111f0 },
1392                         { }
1393                 }
1394         },
1395         [ALC880_FIXUP_Z71V] = {
1396                 .type = HDA_FIXUP_PINS,
1397                 .v.pins = (const struct hda_pintbl[]) {
1398                         /* set up the whole pins as BIOS is utterly broken */
1399                         { 0x14, 0x99030120 }, /* speaker */
1400                         { 0x15, 0x0121411f }, /* HP */
1401                         { 0x16, 0x411111f0 }, /* N/A */
1402                         { 0x17, 0x411111f0 }, /* N/A */
1403                         { 0x18, 0x01a19950 }, /* mic-in */
1404                         { 0x19, 0x411111f0 }, /* N/A */
1405                         { 0x1a, 0x01813031 }, /* line-in */
1406                         { 0x1b, 0x411111f0 }, /* N/A */
1407                         { 0x1c, 0x411111f0 }, /* N/A */
1408                         { 0x1d, 0x411111f0 }, /* N/A */
1409                         { 0x1e, 0x0144111e }, /* SPDIF */
1410                         { }
1411                 }
1412         },
1413         [ALC880_FIXUP_ASUS_W5A] = {
1414                 .type = HDA_FIXUP_PINS,
1415                 .v.pins = (const struct hda_pintbl[]) {
1416                         /* set up the whole pins as BIOS is utterly broken */
1417                         { 0x14, 0x0121411f }, /* HP */
1418                         { 0x15, 0x411111f0 }, /* N/A */
1419                         { 0x16, 0x411111f0 }, /* N/A */
1420                         { 0x17, 0x411111f0 }, /* N/A */
1421                         { 0x18, 0x90a60160 }, /* mic */
1422                         { 0x19, 0x411111f0 }, /* N/A */
1423                         { 0x1a, 0x411111f0 }, /* N/A */
1424                         { 0x1b, 0x411111f0 }, /* N/A */
1425                         { 0x1c, 0x411111f0 }, /* N/A */
1426                         { 0x1d, 0x411111f0 }, /* N/A */
1427                         { 0x1e, 0xb743111e }, /* SPDIF out */
1428                         { }
1429                 },
1430                 .chained = true,
1431                 .chain_id = ALC880_FIXUP_GPIO1,
1432         },
1433         [ALC880_FIXUP_3ST_BASE] = {
1434                 .type = HDA_FIXUP_PINS,
1435                 .v.pins = (const struct hda_pintbl[]) {
1436                         { 0x14, 0x01014010 }, /* line-out */
1437                         { 0x15, 0x411111f0 }, /* N/A */
1438                         { 0x16, 0x411111f0 }, /* N/A */
1439                         { 0x17, 0x411111f0 }, /* N/A */
1440                         { 0x18, 0x01a19c30 }, /* mic-in */
1441                         { 0x19, 0x0121411f }, /* HP */
1442                         { 0x1a, 0x01813031 }, /* line-in */
1443                         { 0x1b, 0x02a19c40 }, /* front-mic */
1444                         { 0x1c, 0x411111f0 }, /* N/A */
1445                         { 0x1d, 0x411111f0 }, /* N/A */
1446                         /* 0x1e is filled in below */
1447                         { 0x1f, 0x411111f0 }, /* N/A */
1448                         { }
1449                 }
1450         },
1451         [ALC880_FIXUP_3ST] = {
1452                 .type = HDA_FIXUP_PINS,
1453                 .v.pins = (const struct hda_pintbl[]) {
1454                         { 0x1e, 0x411111f0 }, /* N/A */
1455                         { }
1456                 },
1457                 .chained = true,
1458                 .chain_id = ALC880_FIXUP_3ST_BASE,
1459         },
1460         [ALC880_FIXUP_3ST_DIG] = {
1461                 .type = HDA_FIXUP_PINS,
1462                 .v.pins = (const struct hda_pintbl[]) {
1463                         { 0x1e, 0x0144111e }, /* SPDIF */
1464                         { }
1465                 },
1466                 .chained = true,
1467                 .chain_id = ALC880_FIXUP_3ST_BASE,
1468         },
1469         [ALC880_FIXUP_5ST_BASE] = {
1470                 .type = HDA_FIXUP_PINS,
1471                 .v.pins = (const struct hda_pintbl[]) {
1472                         { 0x14, 0x01014010 }, /* front */
1473                         { 0x15, 0x411111f0 }, /* N/A */
1474                         { 0x16, 0x01011411 }, /* CLFE */
1475                         { 0x17, 0x01016412 }, /* surr */
1476                         { 0x18, 0x01a19c30 }, /* mic-in */
1477                         { 0x19, 0x0121411f }, /* HP */
1478                         { 0x1a, 0x01813031 }, /* line-in */
1479                         { 0x1b, 0x02a19c40 }, /* front-mic */
1480                         { 0x1c, 0x411111f0 }, /* N/A */
1481                         { 0x1d, 0x411111f0 }, /* N/A */
1482                         /* 0x1e is filled in below */
1483                         { 0x1f, 0x411111f0 }, /* N/A */
1484                         { }
1485                 }
1486         },
1487         [ALC880_FIXUP_5ST] = {
1488                 .type = HDA_FIXUP_PINS,
1489                 .v.pins = (const struct hda_pintbl[]) {
1490                         { 0x1e, 0x411111f0 }, /* N/A */
1491                         { }
1492                 },
1493                 .chained = true,
1494                 .chain_id = ALC880_FIXUP_5ST_BASE,
1495         },
1496         [ALC880_FIXUP_5ST_DIG] = {
1497                 .type = HDA_FIXUP_PINS,
1498                 .v.pins = (const struct hda_pintbl[]) {
1499                         { 0x1e, 0x0144111e }, /* SPDIF */
1500                         { }
1501                 },
1502                 .chained = true,
1503                 .chain_id = ALC880_FIXUP_5ST_BASE,
1504         },
1505         [ALC880_FIXUP_6ST_BASE] = {
1506                 .type = HDA_FIXUP_PINS,
1507                 .v.pins = (const struct hda_pintbl[]) {
1508                         { 0x14, 0x01014010 }, /* front */
1509                         { 0x15, 0x01016412 }, /* surr */
1510                         { 0x16, 0x01011411 }, /* CLFE */
1511                         { 0x17, 0x01012414 }, /* side */
1512                         { 0x18, 0x01a19c30 }, /* mic-in */
1513                         { 0x19, 0x02a19c40 }, /* front-mic */
1514                         { 0x1a, 0x01813031 }, /* line-in */
1515                         { 0x1b, 0x0121411f }, /* HP */
1516                         { 0x1c, 0x411111f0 }, /* N/A */
1517                         { 0x1d, 0x411111f0 }, /* N/A */
1518                         /* 0x1e is filled in below */
1519                         { 0x1f, 0x411111f0 }, /* N/A */
1520                         { }
1521                 }
1522         },
1523         [ALC880_FIXUP_6ST] = {
1524                 .type = HDA_FIXUP_PINS,
1525                 .v.pins = (const struct hda_pintbl[]) {
1526                         { 0x1e, 0x411111f0 }, /* N/A */
1527                         { }
1528                 },
1529                 .chained = true,
1530                 .chain_id = ALC880_FIXUP_6ST_BASE,
1531         },
1532         [ALC880_FIXUP_6ST_DIG] = {
1533                 .type = HDA_FIXUP_PINS,
1534                 .v.pins = (const struct hda_pintbl[]) {
1535                         { 0x1e, 0x0144111e }, /* SPDIF */
1536                         { }
1537                 },
1538                 .chained = true,
1539                 .chain_id = ALC880_FIXUP_6ST_BASE,
1540         },
1541         [ALC880_FIXUP_6ST_AUTOMUTE] = {
1542                 .type = HDA_FIXUP_PINS,
1543                 .v.pins = (const struct hda_pintbl[]) {
1544                         { 0x1b, 0x0121401f }, /* HP with jack detect */
1545                         { }
1546                 },
1547                 .chained_before = true,
1548                 .chain_id = ALC880_FIXUP_6ST_BASE,
1549         },
1550 };
1551
1552 static const struct snd_pci_quirk alc880_fixup_tbl[] = {
1553         SND_PCI_QUIRK(0x1019, 0x0f69, "Coeus G610P", ALC880_FIXUP_W810),
1554         SND_PCI_QUIRK(0x1043, 0x10c3, "ASUS W5A", ALC880_FIXUP_ASUS_W5A),
1555         SND_PCI_QUIRK(0x1043, 0x1964, "ASUS Z71V", ALC880_FIXUP_Z71V),
1556         SND_PCI_QUIRK_VENDOR(0x1043, "ASUS", ALC880_FIXUP_GPIO1),
1557         SND_PCI_QUIRK(0x147b, 0x1045, "ABit AA8XE", ALC880_FIXUP_6ST_AUTOMUTE),
1558         SND_PCI_QUIRK(0x1558, 0x5401, "Clevo GPIO2", ALC880_FIXUP_GPIO2),
1559         SND_PCI_QUIRK_VENDOR(0x1558, "Clevo", ALC880_FIXUP_EAPD_COEF),
1560         SND_PCI_QUIRK(0x1584, 0x9050, "Uniwill", ALC880_FIXUP_UNIWILL_DIG),
1561         SND_PCI_QUIRK(0x1584, 0x9054, "Uniwill", ALC880_FIXUP_F1734),
1562         SND_PCI_QUIRK(0x1584, 0x9070, "Uniwill", ALC880_FIXUP_UNIWILL),
1563         SND_PCI_QUIRK(0x1584, 0x9077, "Uniwill P53", ALC880_FIXUP_VOL_KNOB),
1564         SND_PCI_QUIRK(0x161f, 0x203d, "W810", ALC880_FIXUP_W810),
1565         SND_PCI_QUIRK(0x161f, 0x205d, "Medion Rim 2150", ALC880_FIXUP_MEDION_RIM),
1566         SND_PCI_QUIRK(0x1631, 0xe011, "PB 13201056", ALC880_FIXUP_6ST_AUTOMUTE),
1567         SND_PCI_QUIRK(0x1734, 0x107c, "FSC Amilo M1437", ALC880_FIXUP_FUJITSU),
1568         SND_PCI_QUIRK(0x1734, 0x1094, "FSC Amilo M1451G", ALC880_FIXUP_FUJITSU),
1569         SND_PCI_QUIRK(0x1734, 0x10ac, "FSC AMILO Xi 1526", ALC880_FIXUP_F1734),
1570         SND_PCI_QUIRK(0x1734, 0x10b0, "FSC Amilo Pi1556", ALC880_FIXUP_FUJITSU),
1571         SND_PCI_QUIRK(0x1854, 0x003b, "LG", ALC880_FIXUP_LG),
1572         SND_PCI_QUIRK(0x1854, 0x005f, "LG P1 Express", ALC880_FIXUP_LG),
1573         SND_PCI_QUIRK(0x1854, 0x0068, "LG w1", ALC880_FIXUP_LG),
1574         SND_PCI_QUIRK(0x1854, 0x0077, "LG LW25", ALC880_FIXUP_LG_LW25),
1575         SND_PCI_QUIRK(0x19db, 0x4188, "TCL S700", ALC880_FIXUP_TCL_S700),
1576
1577         /* Below is the copied entries from alc880_quirks.c.
1578          * It's not quite sure whether BIOS sets the correct pin-config table
1579          * on these machines, thus they are kept to be compatible with
1580          * the old static quirks.  Once when it's confirmed to work without
1581          * these overrides, it'd be better to remove.
1582          */
1583         SND_PCI_QUIRK(0x1019, 0xa880, "ECS", ALC880_FIXUP_5ST_DIG),
1584         SND_PCI_QUIRK(0x1019, 0xa884, "Acer APFV", ALC880_FIXUP_6ST),
1585         SND_PCI_QUIRK(0x1025, 0x0070, "ULI", ALC880_FIXUP_3ST_DIG),
1586         SND_PCI_QUIRK(0x1025, 0x0077, "ULI", ALC880_FIXUP_6ST_DIG),
1587         SND_PCI_QUIRK(0x1025, 0x0078, "ULI", ALC880_FIXUP_6ST_DIG),
1588         SND_PCI_QUIRK(0x1025, 0x0087, "ULI", ALC880_FIXUP_6ST_DIG),
1589         SND_PCI_QUIRK(0x1025, 0xe309, "ULI", ALC880_FIXUP_3ST_DIG),
1590         SND_PCI_QUIRK(0x1025, 0xe310, "ULI", ALC880_FIXUP_3ST),
1591         SND_PCI_QUIRK(0x1039, 0x1234, NULL, ALC880_FIXUP_6ST_DIG),
1592         SND_PCI_QUIRK(0x104d, 0x81a0, "Sony", ALC880_FIXUP_3ST),
1593         SND_PCI_QUIRK(0x104d, 0x81d6, "Sony", ALC880_FIXUP_3ST),
1594         SND_PCI_QUIRK(0x107b, 0x3032, "Gateway", ALC880_FIXUP_5ST),
1595         SND_PCI_QUIRK(0x107b, 0x3033, "Gateway", ALC880_FIXUP_5ST),
1596         SND_PCI_QUIRK(0x107b, 0x4039, "Gateway", ALC880_FIXUP_5ST),
1597         SND_PCI_QUIRK(0x1297, 0xc790, "Shuttle ST20G5", ALC880_FIXUP_6ST_DIG),
1598         SND_PCI_QUIRK(0x1458, 0xa102, "Gigabyte K8", ALC880_FIXUP_6ST_DIG),
1599         SND_PCI_QUIRK(0x1462, 0x1150, "MSI", ALC880_FIXUP_6ST_DIG),
1600         SND_PCI_QUIRK(0x1509, 0x925d, "FIC P4M", ALC880_FIXUP_6ST_DIG),
1601         SND_PCI_QUIRK(0x1565, 0x8202, "Biostar", ALC880_FIXUP_5ST_DIG),
1602         SND_PCI_QUIRK(0x1695, 0x400d, "EPoX", ALC880_FIXUP_5ST_DIG),
1603         SND_PCI_QUIRK(0x1695, 0x4012, "EPox EP-5LDA", ALC880_FIXUP_5ST_DIG),
1604         SND_PCI_QUIRK(0x2668, 0x8086, NULL, ALC880_FIXUP_6ST_DIG), /* broken BIOS */
1605         SND_PCI_QUIRK(0x8086, 0x2668, NULL, ALC880_FIXUP_6ST_DIG),
1606         SND_PCI_QUIRK(0x8086, 0xa100, "Intel mobo", ALC880_FIXUP_5ST_DIG),
1607         SND_PCI_QUIRK(0x8086, 0xd400, "Intel mobo", ALC880_FIXUP_5ST_DIG),
1608         SND_PCI_QUIRK(0x8086, 0xd401, "Intel mobo", ALC880_FIXUP_5ST_DIG),
1609         SND_PCI_QUIRK(0x8086, 0xd402, "Intel mobo", ALC880_FIXUP_3ST_DIG),
1610         SND_PCI_QUIRK(0x8086, 0xe224, "Intel mobo", ALC880_FIXUP_5ST_DIG),
1611         SND_PCI_QUIRK(0x8086, 0xe305, "Intel mobo", ALC880_FIXUP_3ST_DIG),
1612         SND_PCI_QUIRK(0x8086, 0xe308, "Intel mobo", ALC880_FIXUP_3ST_DIG),
1613         SND_PCI_QUIRK(0x8086, 0xe400, "Intel mobo", ALC880_FIXUP_5ST_DIG),
1614         SND_PCI_QUIRK(0x8086, 0xe401, "Intel mobo", ALC880_FIXUP_5ST_DIG),
1615         SND_PCI_QUIRK(0x8086, 0xe402, "Intel mobo", ALC880_FIXUP_5ST_DIG),
1616         /* default Intel */
1617         SND_PCI_QUIRK_VENDOR(0x8086, "Intel mobo", ALC880_FIXUP_3ST),
1618         SND_PCI_QUIRK(0xa0a0, 0x0560, "AOpen i915GMm-HFS", ALC880_FIXUP_5ST_DIG),
1619         SND_PCI_QUIRK(0xe803, 0x1019, NULL, ALC880_FIXUP_6ST_DIG),
1620         {}
1621 };
1622
1623 static const struct hda_model_fixup alc880_fixup_models[] = {
1624         {.id = ALC880_FIXUP_3ST, .name = "3stack"},
1625         {.id = ALC880_FIXUP_3ST_DIG, .name = "3stack-digout"},
1626         {.id = ALC880_FIXUP_5ST, .name = "5stack"},
1627         {.id = ALC880_FIXUP_5ST_DIG, .name = "5stack-digout"},
1628         {.id = ALC880_FIXUP_6ST, .name = "6stack"},
1629         {.id = ALC880_FIXUP_6ST_DIG, .name = "6stack-digout"},
1630         {.id = ALC880_FIXUP_6ST_AUTOMUTE, .name = "6stack-automute"},
1631         {}
1632 };
1633
1634
1635 /*
1636  * OK, here we have finally the patch for ALC880
1637  */
1638 static int patch_alc880(struct hda_codec *codec)
1639 {
1640         struct alc_spec *spec;
1641         int err;
1642
1643         err = alc_alloc_spec(codec, 0x0b);
1644         if (err < 0)
1645                 return err;
1646
1647         spec = codec->spec;
1648         spec->gen.need_dac_fix = 1;
1649         spec->gen.beep_nid = 0x01;
1650
1651         codec->patch_ops.unsol_event = alc880_unsol_event;
1652
1653         alc_pre_init(codec);
1654
1655         snd_hda_pick_fixup(codec, alc880_fixup_models, alc880_fixup_tbl,
1656                        alc880_fixups);
1657         snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE);
1658
1659         /* automatic parse from the BIOS config */
1660         err = alc880_parse_auto_config(codec);
1661         if (err < 0)
1662                 goto error;
1663
1664         if (!spec->gen.no_analog) {
1665                 err = set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
1666                 if (err < 0)
1667                         goto error;
1668         }
1669
1670         snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE);
1671
1672         return 0;
1673
1674  error:
1675         alc_free(codec);
1676         return err;
1677 }
1678
1679
1680 /*
1681  * ALC260 support
1682  */
1683 static int alc260_parse_auto_config(struct hda_codec *codec)
1684 {
1685         static const hda_nid_t alc260_ignore[] = { 0x17, 0 };
1686         static const hda_nid_t alc260_ssids[] = { 0x10, 0x15, 0x0f, 0 };
1687         return alc_parse_auto_config(codec, alc260_ignore, alc260_ssids);
1688 }
1689
1690 /*
1691  * Pin config fixes
1692  */
1693 enum {
1694         ALC260_FIXUP_HP_DC5750,
1695         ALC260_FIXUP_HP_PIN_0F,
1696         ALC260_FIXUP_COEF,
1697         ALC260_FIXUP_GPIO1,
1698         ALC260_FIXUP_GPIO1_TOGGLE,
1699         ALC260_FIXUP_REPLACER,
1700         ALC260_FIXUP_HP_B1900,
1701         ALC260_FIXUP_KN1,
1702         ALC260_FIXUP_FSC_S7020,
1703         ALC260_FIXUP_FSC_S7020_JWSE,
1704         ALC260_FIXUP_VAIO_PINS,
1705 };
1706
1707 static void alc260_gpio1_automute(struct hda_codec *codec)
1708 {
1709         struct alc_spec *spec = codec->spec;
1710
1711         alc_update_gpio_data(codec, 0x01, spec->gen.hp_jack_present);
1712 }
1713
1714 static void alc260_fixup_gpio1_toggle(struct hda_codec *codec,
1715                                       const struct hda_fixup *fix, int action)
1716 {
1717         struct alc_spec *spec = codec->spec;
1718         if (action == HDA_FIXUP_ACT_PROBE) {
1719                 /* although the machine has only one output pin, we need to
1720                  * toggle GPIO1 according to the jack state
1721                  */
1722                 spec->gen.automute_hook = alc260_gpio1_automute;
1723                 spec->gen.detect_hp = 1;
1724                 spec->gen.automute_speaker = 1;
1725                 spec->gen.autocfg.hp_pins[0] = 0x0f; /* copy it for automute */
1726                 snd_hda_jack_detect_enable_callback(codec, 0x0f,
1727                                                     snd_hda_gen_hp_automute);
1728                 alc_setup_gpio(codec, 0x01);
1729         }
1730 }
1731
1732 static void alc260_fixup_kn1(struct hda_codec *codec,
1733                              const struct hda_fixup *fix, int action)
1734 {
1735         struct alc_spec *spec = codec->spec;
1736         static const struct hda_pintbl pincfgs[] = {
1737                 { 0x0f, 0x02214000 }, /* HP/speaker */
1738                 { 0x12, 0x90a60160 }, /* int mic */
1739                 { 0x13, 0x02a19000 }, /* ext mic */
1740                 { 0x18, 0x01446000 }, /* SPDIF out */
1741                 /* disable bogus I/O pins */
1742                 { 0x10, 0x411111f0 },
1743                 { 0x11, 0x411111f0 },
1744                 { 0x14, 0x411111f0 },
1745                 { 0x15, 0x411111f0 },
1746                 { 0x16, 0x411111f0 },
1747                 { 0x17, 0x411111f0 },
1748                 { 0x19, 0x411111f0 },
1749                 { }
1750         };
1751
1752         switch (action) {
1753         case HDA_FIXUP_ACT_PRE_PROBE:
1754                 snd_hda_apply_pincfgs(codec, pincfgs);
1755                 spec->init_amp = ALC_INIT_NONE;
1756                 break;
1757         }
1758 }
1759
1760 static void alc260_fixup_fsc_s7020(struct hda_codec *codec,
1761                                    const struct hda_fixup *fix, int action)
1762 {
1763         struct alc_spec *spec = codec->spec;
1764         if (action == HDA_FIXUP_ACT_PRE_PROBE)
1765                 spec->init_amp = ALC_INIT_NONE;
1766 }
1767
1768 static void alc260_fixup_fsc_s7020_jwse(struct hda_codec *codec,
1769                                    const struct hda_fixup *fix, int action)
1770 {
1771         struct alc_spec *spec = codec->spec;
1772         if (action == HDA_FIXUP_ACT_PRE_PROBE) {
1773                 spec->gen.add_jack_modes = 1;
1774                 spec->gen.hp_mic = 1;
1775         }
1776 }
1777
1778 static const struct hda_fixup alc260_fixups[] = {
1779         [ALC260_FIXUP_HP_DC5750] = {
1780                 .type = HDA_FIXUP_PINS,
1781                 .v.pins = (const struct hda_pintbl[]) {
1782                         { 0x11, 0x90130110 }, /* speaker */
1783                         { }
1784                 }
1785         },
1786         [ALC260_FIXUP_HP_PIN_0F] = {
1787                 .type = HDA_FIXUP_PINS,
1788                 .v.pins = (const struct hda_pintbl[]) {
1789                         { 0x0f, 0x01214000 }, /* HP */
1790                         { }
1791                 }
1792         },
1793         [ALC260_FIXUP_COEF] = {
1794                 .type = HDA_FIXUP_VERBS,
1795                 .v.verbs = (const struct hda_verb[]) {
1796                         { 0x1a, AC_VERB_SET_COEF_INDEX, 0x07 },
1797                         { 0x1a, AC_VERB_SET_PROC_COEF,  0x3040 },
1798                         { }
1799                 },
1800         },
1801         [ALC260_FIXUP_GPIO1] = {
1802                 .type = HDA_FIXUP_FUNC,
1803                 .v.func = alc_fixup_gpio1,
1804         },
1805         [ALC260_FIXUP_GPIO1_TOGGLE] = {
1806                 .type = HDA_FIXUP_FUNC,
1807                 .v.func = alc260_fixup_gpio1_toggle,
1808                 .chained = true,
1809                 .chain_id = ALC260_FIXUP_HP_PIN_0F,
1810         },
1811         [ALC260_FIXUP_REPLACER] = {
1812                 .type = HDA_FIXUP_VERBS,
1813                 .v.verbs = (const struct hda_verb[]) {
1814                         { 0x1a, AC_VERB_SET_COEF_INDEX, 0x07 },
1815                         { 0x1a, AC_VERB_SET_PROC_COEF,  0x3050 },
1816                         { }
1817                 },
1818                 .chained = true,
1819                 .chain_id = ALC260_FIXUP_GPIO1_TOGGLE,
1820         },
1821         [ALC260_FIXUP_HP_B1900] = {
1822                 .type = HDA_FIXUP_FUNC,
1823                 .v.func = alc260_fixup_gpio1_toggle,
1824                 .chained = true,
1825                 .chain_id = ALC260_FIXUP_COEF,
1826         },
1827         [ALC260_FIXUP_KN1] = {
1828                 .type = HDA_FIXUP_FUNC,
1829                 .v.func = alc260_fixup_kn1,
1830         },
1831         [ALC260_FIXUP_FSC_S7020] = {
1832                 .type = HDA_FIXUP_FUNC,
1833                 .v.func = alc260_fixup_fsc_s7020,
1834         },
1835         [ALC260_FIXUP_FSC_S7020_JWSE] = {
1836                 .type = HDA_FIXUP_FUNC,
1837                 .v.func = alc260_fixup_fsc_s7020_jwse,
1838                 .chained = true,
1839                 .chain_id = ALC260_FIXUP_FSC_S7020,
1840         },
1841         [ALC260_FIXUP_VAIO_PINS] = {
1842                 .type = HDA_FIXUP_PINS,
1843                 .v.pins = (const struct hda_pintbl[]) {
1844                         /* Pin configs are missing completely on some VAIOs */
1845                         { 0x0f, 0x01211020 },
1846                         { 0x10, 0x0001003f },
1847                         { 0x11, 0x411111f0 },
1848                         { 0x12, 0x01a15930 },
1849                         { 0x13, 0x411111f0 },
1850                         { 0x14, 0x411111f0 },
1851                         { 0x15, 0x411111f0 },
1852                         { 0x16, 0x411111f0 },
1853                         { 0x17, 0x411111f0 },
1854                         { 0x18, 0x411111f0 },
1855                         { 0x19, 0x411111f0 },
1856                         { }
1857                 }
1858         },
1859 };
1860
1861 static const struct snd_pci_quirk alc260_fixup_tbl[] = {
1862         SND_PCI_QUIRK(0x1025, 0x007b, "Acer C20x", ALC260_FIXUP_GPIO1),
1863         SND_PCI_QUIRK(0x1025, 0x007f, "Acer Aspire 9500", ALC260_FIXUP_COEF),
1864         SND_PCI_QUIRK(0x1025, 0x008f, "Acer", ALC260_FIXUP_GPIO1),
1865         SND_PCI_QUIRK(0x103c, 0x280a, "HP dc5750", ALC260_FIXUP_HP_DC5750),
1866         SND_PCI_QUIRK(0x103c, 0x30ba, "HP Presario B1900", ALC260_FIXUP_HP_B1900),
1867         SND_PCI_QUIRK(0x104d, 0x81bb, "Sony VAIO", ALC260_FIXUP_VAIO_PINS),
1868         SND_PCI_QUIRK(0x104d, 0x81e2, "Sony VAIO TX", ALC260_FIXUP_HP_PIN_0F),
1869         SND_PCI_QUIRK(0x10cf, 0x1326, "FSC LifeBook S7020", ALC260_FIXUP_FSC_S7020),
1870         SND_PCI_QUIRK(0x1509, 0x4540, "Favorit 100XS", ALC260_FIXUP_GPIO1),
1871         SND_PCI_QUIRK(0x152d, 0x0729, "Quanta KN1", ALC260_FIXUP_KN1),
1872         SND_PCI_QUIRK(0x161f, 0x2057, "Replacer 672V", ALC260_FIXUP_REPLACER),
1873         SND_PCI_QUIRK(0x1631, 0xc017, "PB V7900", ALC260_FIXUP_COEF),
1874         {}
1875 };
1876
1877 static const struct hda_model_fixup alc260_fixup_models[] = {
1878         {.id = ALC260_FIXUP_GPIO1, .name = "gpio1"},
1879         {.id = ALC260_FIXUP_COEF, .name = "coef"},
1880         {.id = ALC260_FIXUP_FSC_S7020, .name = "fujitsu"},
1881         {.id = ALC260_FIXUP_FSC_S7020_JWSE, .name = "fujitsu-jwse"},
1882         {}
1883 };
1884
1885 /*
1886  */
1887 static int patch_alc260(struct hda_codec *codec)
1888 {
1889         struct alc_spec *spec;
1890         int err;
1891
1892         err = alc_alloc_spec(codec, 0x07);
1893         if (err < 0)
1894                 return err;
1895
1896         spec = codec->spec;
1897         /* as quite a few machines require HP amp for speaker outputs,
1898          * it's easier to enable it unconditionally; even if it's unneeded,
1899          * it's almost harmless.
1900          */
1901         spec->gen.prefer_hp_amp = 1;
1902         spec->gen.beep_nid = 0x01;
1903
1904         spec->shutup = alc_eapd_shutup;
1905
1906         alc_pre_init(codec);
1907
1908         snd_hda_pick_fixup(codec, alc260_fixup_models, alc260_fixup_tbl,
1909                            alc260_fixups);
1910         snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE);
1911
1912         /* automatic parse from the BIOS config */
1913         err = alc260_parse_auto_config(codec);
1914         if (err < 0)
1915                 goto error;
1916
1917         if (!spec->gen.no_analog) {
1918                 err = set_beep_amp(spec, 0x07, 0x05, HDA_INPUT);
1919                 if (err < 0)
1920                         goto error;
1921         }
1922
1923         snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE);
1924
1925         return 0;
1926
1927  error:
1928         alc_free(codec);
1929         return err;
1930 }
1931
1932
1933 /*
1934  * ALC882/883/885/888/889 support
1935  *
1936  * ALC882 is almost identical with ALC880 but has cleaner and more flexible
1937  * configuration.  Each pin widget can choose any input DACs and a mixer.
1938  * Each ADC is connected from a mixer of all inputs.  This makes possible
1939  * 6-channel independent captures.
1940  *
1941  * In addition, an independent DAC for the multi-playback (not used in this
1942  * driver yet).
1943  */
1944
1945 /*
1946  * Pin config fixes
1947  */
1948 enum {
1949         ALC882_FIXUP_ABIT_AW9D_MAX,
1950         ALC882_FIXUP_LENOVO_Y530,
1951         ALC882_FIXUP_PB_M5210,
1952         ALC882_FIXUP_ACER_ASPIRE_7736,
1953         ALC882_FIXUP_ASUS_W90V,
1954         ALC889_FIXUP_CD,
1955         ALC889_FIXUP_FRONT_HP_NO_PRESENCE,
1956         ALC889_FIXUP_VAIO_TT,
1957         ALC888_FIXUP_EEE1601,
1958         ALC886_FIXUP_EAPD,
1959         ALC882_FIXUP_EAPD,
1960         ALC883_FIXUP_EAPD,
1961         ALC883_FIXUP_ACER_EAPD,
1962         ALC882_FIXUP_GPIO1,
1963         ALC882_FIXUP_GPIO2,
1964         ALC882_FIXUP_GPIO3,
1965         ALC889_FIXUP_COEF,
1966         ALC882_FIXUP_ASUS_W2JC,
1967         ALC882_FIXUP_ACER_ASPIRE_4930G,
1968         ALC882_FIXUP_ACER_ASPIRE_8930G,
1969         ALC882_FIXUP_ASPIRE_8930G_VERBS,
1970         ALC885_FIXUP_MACPRO_GPIO,
1971         ALC889_FIXUP_DAC_ROUTE,
1972         ALC889_FIXUP_MBP_VREF,
1973         ALC889_FIXUP_IMAC91_VREF,
1974         ALC889_FIXUP_MBA11_VREF,
1975         ALC889_FIXUP_MBA21_VREF,
1976         ALC889_FIXUP_MP11_VREF,
1977         ALC889_FIXUP_MP41_VREF,
1978         ALC882_FIXUP_INV_DMIC,
1979         ALC882_FIXUP_NO_PRIMARY_HP,
1980         ALC887_FIXUP_ASUS_BASS,
1981         ALC887_FIXUP_BASS_CHMAP,
1982         ALC1220_FIXUP_GB_DUAL_CODECS,
1983         ALC1220_FIXUP_GB_X570,
1984         ALC1220_FIXUP_CLEVO_P950,
1985         ALC1220_FIXUP_CLEVO_PB51ED,
1986         ALC1220_FIXUP_CLEVO_PB51ED_PINS,
1987         ALC887_FIXUP_ASUS_AUDIO,
1988         ALC887_FIXUP_ASUS_HMIC,
1989         ALCS1200A_FIXUP_MIC_VREF,
1990         ALC888VD_FIXUP_MIC_100VREF,
1991 };
1992
1993 static void alc889_fixup_coef(struct hda_codec *codec,
1994                               const struct hda_fixup *fix, int action)
1995 {
1996         if (action != HDA_FIXUP_ACT_INIT)
1997                 return;
1998         alc_update_coef_idx(codec, 7, 0, 0x2030);
1999 }
2000
2001 /* set up GPIO at initialization */
2002 static void alc885_fixup_macpro_gpio(struct hda_codec *codec,
2003                                      const struct hda_fixup *fix, int action)
2004 {
2005         struct alc_spec *spec = codec->spec;
2006
2007         spec->gpio_write_delay = true;
2008         alc_fixup_gpio3(codec, fix, action);
2009 }
2010
2011 /* Fix the connection of some pins for ALC889:
2012  * At least, Acer Aspire 5935 shows the connections to DAC3/4 don't
2013  * work correctly (bko#42740)
2014  */
2015 static void alc889_fixup_dac_route(struct hda_codec *codec,
2016                                    const struct hda_fixup *fix, int action)
2017 {
2018         if (action == HDA_FIXUP_ACT_PRE_PROBE) {
2019                 /* fake the connections during parsing the tree */
2020                 static const hda_nid_t conn1[] = { 0x0c, 0x0d };
2021                 static const hda_nid_t conn2[] = { 0x0e, 0x0f };
2022                 snd_hda_override_conn_list(codec, 0x14, ARRAY_SIZE(conn1), conn1);
2023                 snd_hda_override_conn_list(codec, 0x15, ARRAY_SIZE(conn1), conn1);
2024                 snd_hda_override_conn_list(codec, 0x18, ARRAY_SIZE(conn2), conn2);
2025                 snd_hda_override_conn_list(codec, 0x1a, ARRAY_SIZE(conn2), conn2);
2026         } else if (action == HDA_FIXUP_ACT_PROBE) {
2027                 /* restore the connections */
2028                 static const hda_nid_t conn[] = { 0x0c, 0x0d, 0x0e, 0x0f, 0x26 };
2029                 snd_hda_override_conn_list(codec, 0x14, ARRAY_SIZE(conn), conn);
2030                 snd_hda_override_conn_list(codec, 0x15, ARRAY_SIZE(conn), conn);
2031                 snd_hda_override_conn_list(codec, 0x18, ARRAY_SIZE(conn), conn);
2032                 snd_hda_override_conn_list(codec, 0x1a, ARRAY_SIZE(conn), conn);
2033         }
2034 }
2035
2036 /* Set VREF on HP pin */
2037 static void alc889_fixup_mbp_vref(struct hda_codec *codec,
2038                                   const struct hda_fixup *fix, int action)
2039 {
2040         static const hda_nid_t nids[] = { 0x14, 0x15, 0x19 };
2041         struct alc_spec *spec = codec->spec;
2042         int i;
2043
2044         if (action != HDA_FIXUP_ACT_INIT)
2045                 return;
2046         for (i = 0; i < ARRAY_SIZE(nids); i++) {
2047                 unsigned int val = snd_hda_codec_get_pincfg(codec, nids[i]);
2048                 if (get_defcfg_device(val) != AC_JACK_HP_OUT)
2049                         continue;
2050                 val = snd_hda_codec_get_pin_target(codec, nids[i]);
2051                 val |= AC_PINCTL_VREF_80;
2052                 snd_hda_set_pin_ctl(codec, nids[i], val);
2053                 spec->gen.keep_vref_in_automute = 1;
2054                 break;
2055         }
2056 }
2057
2058 static void alc889_fixup_mac_pins(struct hda_codec *codec,
2059                                   const hda_nid_t *nids, int num_nids)
2060 {
2061         struct alc_spec *spec = codec->spec;
2062         int i;
2063
2064         for (i = 0; i < num_nids; i++) {
2065                 unsigned int val;
2066                 val = snd_hda_codec_get_pin_target(codec, nids[i]);
2067                 val |= AC_PINCTL_VREF_50;
2068                 snd_hda_set_pin_ctl(codec, nids[i], val);
2069         }
2070         spec->gen.keep_vref_in_automute = 1;
2071 }
2072
2073 /* Set VREF on speaker pins on imac91 */
2074 static void alc889_fixup_imac91_vref(struct hda_codec *codec,
2075                                      const struct hda_fixup *fix, int action)
2076 {
2077         static const hda_nid_t nids[] = { 0x18, 0x1a };
2078
2079         if (action == HDA_FIXUP_ACT_INIT)
2080                 alc889_fixup_mac_pins(codec, nids, ARRAY_SIZE(nids));
2081 }
2082
2083 /* Set VREF on speaker pins on mba11 */
2084 static void alc889_fixup_mba11_vref(struct hda_codec *codec,
2085                                     const struct hda_fixup *fix, int action)
2086 {
2087         static const hda_nid_t nids[] = { 0x18 };
2088
2089         if (action == HDA_FIXUP_ACT_INIT)
2090                 alc889_fixup_mac_pins(codec, nids, ARRAY_SIZE(nids));
2091 }
2092
2093 /* Set VREF on speaker pins on mba21 */
2094 static void alc889_fixup_mba21_vref(struct hda_codec *codec,
2095                                     const struct hda_fixup *fix, int action)
2096 {
2097         static const hda_nid_t nids[] = { 0x18, 0x19 };
2098
2099         if (action == HDA_FIXUP_ACT_INIT)
2100                 alc889_fixup_mac_pins(codec, nids, ARRAY_SIZE(nids));
2101 }
2102
2103 /* Don't take HP output as primary
2104  * Strangely, the speaker output doesn't work on Vaio Z and some Vaio
2105  * all-in-one desktop PCs (for example VGC-LN51JGB) through DAC 0x05
2106  */
2107 static void alc882_fixup_no_primary_hp(struct hda_codec *codec,
2108                                        const struct hda_fixup *fix, int action)
2109 {
2110         struct alc_spec *spec = codec->spec;
2111         if (action == HDA_FIXUP_ACT_PRE_PROBE) {
2112                 spec->gen.no_primary_hp = 1;
2113                 spec->gen.no_multi_io = 1;
2114         }
2115 }
2116
2117 static void alc_fixup_bass_chmap(struct hda_codec *codec,
2118                                  const struct hda_fixup *fix, int action);
2119
2120 /* For dual-codec configuration, we need to disable some features to avoid
2121  * conflicts of kctls and PCM streams
2122  */
2123 static void alc_fixup_dual_codecs(struct hda_codec *codec,
2124                                   const struct hda_fixup *fix, int action)
2125 {
2126         struct alc_spec *spec = codec->spec;
2127
2128         if (action != HDA_FIXUP_ACT_PRE_PROBE)
2129                 return;
2130         /* disable vmaster */
2131         spec->gen.suppress_vmaster = 1;
2132         /* auto-mute and auto-mic switch don't work with multiple codecs */
2133         spec->gen.suppress_auto_mute = 1;
2134         spec->gen.suppress_auto_mic = 1;
2135         /* disable aamix as well */
2136         spec->gen.mixer_nid = 0;
2137         /* add location prefix to avoid conflicts */
2138         codec->force_pin_prefix = 1;
2139 }
2140
2141 static void rename_ctl(struct hda_codec *codec, const char *oldname,
2142                        const char *newname)
2143 {
2144         struct snd_kcontrol *kctl;
2145
2146         kctl = snd_hda_find_mixer_ctl(codec, oldname);
2147         if (kctl)
2148                 snd_ctl_rename(codec->card, kctl, newname);
2149 }
2150
2151 static void alc1220_fixup_gb_dual_codecs(struct hda_codec *codec,
2152                                          const struct hda_fixup *fix,
2153                                          int action)
2154 {
2155         alc_fixup_dual_codecs(codec, fix, action);
2156         switch (action) {
2157         case HDA_FIXUP_ACT_PRE_PROBE:
2158                 /* override card longname to provide a unique UCM profile */
2159                 strcpy(codec->card->longname, "HDAudio-Gigabyte-ALC1220DualCodecs");
2160                 break;
2161         case HDA_FIXUP_ACT_BUILD:
2162                 /* rename Capture controls depending on the codec */
2163                 rename_ctl(codec, "Capture Volume",
2164                            codec->addr == 0 ?
2165                            "Rear-Panel Capture Volume" :
2166                            "Front-Panel Capture Volume");
2167                 rename_ctl(codec, "Capture Switch",
2168                            codec->addr == 0 ?
2169                            "Rear-Panel Capture Switch" :
2170                            "Front-Panel Capture Switch");
2171                 break;
2172         }
2173 }
2174
2175 static void alc1220_fixup_gb_x570(struct hda_codec *codec,
2176                                      const struct hda_fixup *fix,
2177                                      int action)
2178 {
2179         static const hda_nid_t conn1[] = { 0x0c };
2180         static const struct coef_fw gb_x570_coefs[] = {
2181                 WRITE_COEF(0x07, 0x03c0),
2182                 WRITE_COEF(0x1a, 0x01c1),
2183                 WRITE_COEF(0x1b, 0x0202),
2184                 WRITE_COEF(0x43, 0x3005),
2185                 {}
2186         };
2187
2188         switch (action) {
2189         case HDA_FIXUP_ACT_PRE_PROBE:
2190                 snd_hda_override_conn_list(codec, 0x14, ARRAY_SIZE(conn1), conn1);
2191                 snd_hda_override_conn_list(codec, 0x1b, ARRAY_SIZE(conn1), conn1);
2192                 break;
2193         case HDA_FIXUP_ACT_INIT:
2194                 alc_process_coef_fw(codec, gb_x570_coefs);
2195                 break;
2196         }
2197 }
2198
2199 static void alc1220_fixup_clevo_p950(struct hda_codec *codec,
2200                                      const struct hda_fixup *fix,
2201                                      int action)
2202 {
2203         static const hda_nid_t conn1[] = { 0x0c };
2204
2205         if (action != HDA_FIXUP_ACT_PRE_PROBE)
2206                 return;
2207
2208         alc_update_coef_idx(codec, 0x7, 0, 0x3c3);
2209         /* We therefore want to make sure 0x14 (front headphone) and
2210          * 0x1b (speakers) use the stereo DAC 0x02
2211          */
2212         snd_hda_override_conn_list(codec, 0x14, ARRAY_SIZE(conn1), conn1);
2213         snd_hda_override_conn_list(codec, 0x1b, ARRAY_SIZE(conn1), conn1);
2214 }
2215
2216 static void alc_fixup_headset_mode_no_hp_mic(struct hda_codec *codec,
2217                                 const struct hda_fixup *fix, int action);
2218
2219 static void alc1220_fixup_clevo_pb51ed(struct hda_codec *codec,
2220                                      const struct hda_fixup *fix,
2221                                      int action)
2222 {
2223         alc1220_fixup_clevo_p950(codec, fix, action);
2224         alc_fixup_headset_mode_no_hp_mic(codec, fix, action);
2225 }
2226
2227 static void alc887_asus_hp_automute_hook(struct hda_codec *codec,
2228                                          struct hda_jack_callback *jack)
2229 {
2230         struct alc_spec *spec = codec->spec;
2231         unsigned int vref;
2232
2233         snd_hda_gen_hp_automute(codec, jack);
2234
2235         if (spec->gen.hp_jack_present)
2236                 vref = AC_PINCTL_VREF_80;
2237         else
2238                 vref = AC_PINCTL_VREF_HIZ;
2239         snd_hda_set_pin_ctl(codec, 0x19, PIN_HP | vref);
2240 }
2241
2242 static void alc887_fixup_asus_jack(struct hda_codec *codec,
2243                                      const struct hda_fixup *fix, int action)
2244 {
2245         struct alc_spec *spec = codec->spec;
2246         if (action != HDA_FIXUP_ACT_PROBE)
2247                 return;
2248         snd_hda_set_pin_ctl_cache(codec, 0x1b, PIN_HP);
2249         spec->gen.hp_automute_hook = alc887_asus_hp_automute_hook;
2250 }
2251
2252 static const struct hda_fixup alc882_fixups[] = {
2253         [ALC882_FIXUP_ABIT_AW9D_MAX] = {
2254                 .type = HDA_FIXUP_PINS,
2255                 .v.pins = (const struct hda_pintbl[]) {
2256                         { 0x15, 0x01080104 }, /* side */
2257                         { 0x16, 0x01011012 }, /* rear */
2258                         { 0x17, 0x01016011 }, /* clfe */
2259                         { }
2260                 }
2261         },
2262         [ALC882_FIXUP_LENOVO_Y530] = {
2263                 .type = HDA_FIXUP_PINS,
2264                 .v.pins = (const struct hda_pintbl[]) {
2265                         { 0x15, 0x99130112 }, /* rear int speakers */
2266                         { 0x16, 0x99130111 }, /* subwoofer */
2267                         { }
2268                 }
2269         },
2270         [ALC882_FIXUP_PB_M5210] = {
2271                 .type = HDA_FIXUP_PINCTLS,
2272                 .v.pins = (const struct hda_pintbl[]) {
2273                         { 0x19, PIN_VREF50 },
2274                         {}
2275                 }
2276         },
2277         [ALC882_FIXUP_ACER_ASPIRE_7736] = {
2278                 .type = HDA_FIXUP_FUNC,
2279                 .v.func = alc_fixup_sku_ignore,
2280         },
2281         [ALC882_FIXUP_ASUS_W90V] = {
2282                 .type = HDA_FIXUP_PINS,
2283                 .v.pins = (const struct hda_pintbl[]) {
2284                         { 0x16, 0x99130110 }, /* fix sequence for CLFE */
2285                         { }
2286                 }
2287         },
2288         [ALC889_FIXUP_CD] = {
2289                 .type = HDA_FIXUP_PINS,
2290                 .v.pins = (const struct hda_pintbl[]) {
2291                         { 0x1c, 0x993301f0 }, /* CD */
2292                         { }
2293                 }
2294         },
2295         [ALC889_FIXUP_FRONT_HP_NO_PRESENCE] = {
2296                 .type = HDA_FIXUP_PINS,
2297                 .v.pins = (const struct hda_pintbl[]) {
2298                         { 0x1b, 0x02214120 }, /* Front HP jack is flaky, disable jack detect */
2299                         { }
2300                 },
2301                 .chained = true,
2302                 .chain_id = ALC889_FIXUP_CD,
2303         },
2304         [ALC889_FIXUP_VAIO_TT] = {
2305                 .type = HDA_FIXUP_PINS,
2306                 .v.pins = (const struct hda_pintbl[]) {
2307                         { 0x17, 0x90170111 }, /* hidden surround speaker */
2308                         { }
2309                 }
2310         },
2311         [ALC888_FIXUP_EEE1601] = {
2312                 .type = HDA_FIXUP_VERBS,
2313                 .v.verbs = (const struct hda_verb[]) {
2314                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x0b },
2315                         { 0x20, AC_VERB_SET_PROC_COEF,  0x0838 },
2316                         { }
2317                 }
2318         },
2319         [ALC886_FIXUP_EAPD] = {
2320                 .type = HDA_FIXUP_VERBS,
2321                 .v.verbs = (const struct hda_verb[]) {
2322                         /* change to EAPD mode */
2323                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x07 },
2324                         { 0x20, AC_VERB_SET_PROC_COEF, 0x0068 },
2325                         { }
2326                 }
2327         },
2328         [ALC882_FIXUP_EAPD] = {
2329                 .type = HDA_FIXUP_VERBS,
2330                 .v.verbs = (const struct hda_verb[]) {
2331                         /* change to EAPD mode */
2332                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x07 },
2333                         { 0x20, AC_VERB_SET_PROC_COEF, 0x3060 },
2334                         { }
2335                 }
2336         },
2337         [ALC883_FIXUP_EAPD] = {
2338                 .type = HDA_FIXUP_VERBS,
2339                 .v.verbs = (const struct hda_verb[]) {
2340                         /* change to EAPD mode */
2341                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x07 },
2342                         { 0x20, AC_VERB_SET_PROC_COEF, 0x3070 },
2343                         { }
2344                 }
2345         },
2346         [ALC883_FIXUP_ACER_EAPD] = {
2347                 .type = HDA_FIXUP_VERBS,
2348                 .v.verbs = (const struct hda_verb[]) {
2349                         /* eanable EAPD on Acer laptops */
2350                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x07 },
2351                         { 0x20, AC_VERB_SET_PROC_COEF, 0x3050 },
2352                         { }
2353                 }
2354         },
2355         [ALC882_FIXUP_GPIO1] = {
2356                 .type = HDA_FIXUP_FUNC,
2357                 .v.func = alc_fixup_gpio1,
2358         },
2359         [ALC882_FIXUP_GPIO2] = {
2360                 .type = HDA_FIXUP_FUNC,
2361                 .v.func = alc_fixup_gpio2,
2362         },
2363         [ALC882_FIXUP_GPIO3] = {
2364                 .type = HDA_FIXUP_FUNC,
2365                 .v.func = alc_fixup_gpio3,
2366         },
2367         [ALC882_FIXUP_ASUS_W2JC] = {
2368                 .type = HDA_FIXUP_FUNC,
2369                 .v.func = alc_fixup_gpio1,
2370                 .chained = true,
2371                 .chain_id = ALC882_FIXUP_EAPD,
2372         },
2373         [ALC889_FIXUP_COEF] = {
2374                 .type = HDA_FIXUP_FUNC,
2375                 .v.func = alc889_fixup_coef,
2376         },
2377         [ALC882_FIXUP_ACER_ASPIRE_4930G] = {
2378                 .type = HDA_FIXUP_PINS,
2379                 .v.pins = (const struct hda_pintbl[]) {
2380                         { 0x16, 0x99130111 }, /* CLFE speaker */
2381                         { 0x17, 0x99130112 }, /* surround speaker */
2382                         { }
2383                 },
2384                 .chained = true,
2385                 .chain_id = ALC882_FIXUP_GPIO1,
2386         },
2387         [ALC882_FIXUP_ACER_ASPIRE_8930G] = {
2388                 .type = HDA_FIXUP_PINS,
2389                 .v.pins = (const struct hda_pintbl[]) {
2390                         { 0x16, 0x99130111 }, /* CLFE speaker */
2391                         { 0x1b, 0x99130112 }, /* surround speaker */
2392                         { }
2393                 },
2394                 .chained = true,
2395                 .chain_id = ALC882_FIXUP_ASPIRE_8930G_VERBS,
2396         },
2397         [ALC882_FIXUP_ASPIRE_8930G_VERBS] = {
2398                 /* additional init verbs for Acer Aspire 8930G */
2399                 .type = HDA_FIXUP_VERBS,
2400                 .v.verbs = (const struct hda_verb[]) {
2401                         /* Enable all DACs */
2402                         /* DAC DISABLE/MUTE 1? */
2403                         /*  setting bits 1-5 disables DAC nids 0x02-0x06
2404                          *  apparently. Init=0x38 */
2405                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x03 },
2406                         { 0x20, AC_VERB_SET_PROC_COEF, 0x0000 },
2407                         /* DAC DISABLE/MUTE 2? */
2408                         /*  some bit here disables the other DACs.
2409                          *  Init=0x4900 */
2410                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x08 },
2411                         { 0x20, AC_VERB_SET_PROC_COEF, 0x0000 },
2412                         /* DMIC fix
2413                          * This laptop has a stereo digital microphone.
2414                          * The mics are only 1cm apart which makes the stereo
2415                          * useless. However, either the mic or the ALC889
2416                          * makes the signal become a difference/sum signal
2417                          * instead of standard stereo, which is annoying.
2418                          * So instead we flip this bit which makes the
2419                          * codec replicate the sum signal to both channels,
2420                          * turning it into a normal mono mic.
2421                          */
2422                         /* DMIC_CONTROL? Init value = 0x0001 */
2423                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x0b },
2424                         { 0x20, AC_VERB_SET_PROC_COEF, 0x0003 },
2425                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x07 },
2426                         { 0x20, AC_VERB_SET_PROC_COEF, 0x3050 },
2427                         { }
2428                 },
2429                 .chained = true,
2430                 .chain_id = ALC882_FIXUP_GPIO1,
2431         },
2432         [ALC885_FIXUP_MACPRO_GPIO] = {
2433                 .type = HDA_FIXUP_FUNC,
2434                 .v.func = alc885_fixup_macpro_gpio,
2435         },
2436         [ALC889_FIXUP_DAC_ROUTE] = {
2437                 .type = HDA_FIXUP_FUNC,
2438                 .v.func = alc889_fixup_dac_route,
2439         },
2440         [ALC889_FIXUP_MBP_VREF] = {
2441                 .type = HDA_FIXUP_FUNC,
2442                 .v.func = alc889_fixup_mbp_vref,
2443                 .chained = true,
2444                 .chain_id = ALC882_FIXUP_GPIO1,
2445         },
2446         [ALC889_FIXUP_IMAC91_VREF] = {
2447                 .type = HDA_FIXUP_FUNC,
2448                 .v.func = alc889_fixup_imac91_vref,
2449                 .chained = true,
2450                 .chain_id = ALC882_FIXUP_GPIO1,
2451         },
2452         [ALC889_FIXUP_MBA11_VREF] = {
2453                 .type = HDA_FIXUP_FUNC,
2454                 .v.func = alc889_fixup_mba11_vref,
2455                 .chained = true,
2456                 .chain_id = ALC889_FIXUP_MBP_VREF,
2457         },
2458         [ALC889_FIXUP_MBA21_VREF] = {
2459                 .type = HDA_FIXUP_FUNC,
2460                 .v.func = alc889_fixup_mba21_vref,
2461                 .chained = true,
2462                 .chain_id = ALC889_FIXUP_MBP_VREF,
2463         },
2464         [ALC889_FIXUP_MP11_VREF] = {
2465                 .type = HDA_FIXUP_FUNC,
2466                 .v.func = alc889_fixup_mba11_vref,
2467                 .chained = true,
2468                 .chain_id = ALC885_FIXUP_MACPRO_GPIO,
2469         },
2470         [ALC889_FIXUP_MP41_VREF] = {
2471                 .type = HDA_FIXUP_FUNC,
2472                 .v.func = alc889_fixup_mbp_vref,
2473                 .chained = true,
2474                 .chain_id = ALC885_FIXUP_MACPRO_GPIO,
2475         },
2476         [ALC882_FIXUP_INV_DMIC] = {
2477                 .type = HDA_FIXUP_FUNC,
2478                 .v.func = alc_fixup_inv_dmic,
2479         },
2480         [ALC882_FIXUP_NO_PRIMARY_HP] = {
2481                 .type = HDA_FIXUP_FUNC,
2482                 .v.func = alc882_fixup_no_primary_hp,
2483         },
2484         [ALC887_FIXUP_ASUS_BASS] = {
2485                 .type = HDA_FIXUP_PINS,
2486                 .v.pins = (const struct hda_pintbl[]) {
2487                         {0x16, 0x99130130}, /* bass speaker */
2488                         {}
2489                 },
2490                 .chained = true,
2491                 .chain_id = ALC887_FIXUP_BASS_CHMAP,
2492         },
2493         [ALC887_FIXUP_BASS_CHMAP] = {
2494                 .type = HDA_FIXUP_FUNC,
2495                 .v.func = alc_fixup_bass_chmap,
2496         },
2497         [ALC1220_FIXUP_GB_DUAL_CODECS] = {
2498                 .type = HDA_FIXUP_FUNC,
2499                 .v.func = alc1220_fixup_gb_dual_codecs,
2500         },
2501         [ALC1220_FIXUP_GB_X570] = {
2502                 .type = HDA_FIXUP_FUNC,
2503                 .v.func = alc1220_fixup_gb_x570,
2504         },
2505         [ALC1220_FIXUP_CLEVO_P950] = {
2506                 .type = HDA_FIXUP_FUNC,
2507                 .v.func = alc1220_fixup_clevo_p950,
2508         },
2509         [ALC1220_FIXUP_CLEVO_PB51ED] = {
2510                 .type = HDA_FIXUP_FUNC,
2511                 .v.func = alc1220_fixup_clevo_pb51ed,
2512         },
2513         [ALC1220_FIXUP_CLEVO_PB51ED_PINS] = {
2514                 .type = HDA_FIXUP_PINS,
2515                 .v.pins = (const struct hda_pintbl[]) {
2516                         { 0x19, 0x01a1913c }, /* use as headset mic, without its own jack detect */
2517                         {}
2518                 },
2519                 .chained = true,
2520                 .chain_id = ALC1220_FIXUP_CLEVO_PB51ED,
2521         },
2522         [ALC887_FIXUP_ASUS_AUDIO] = {
2523                 .type = HDA_FIXUP_PINS,
2524                 .v.pins = (const struct hda_pintbl[]) {
2525                         { 0x15, 0x02a14150 }, /* use as headset mic, without its own jack detect */
2526                         { 0x19, 0x22219420 },
2527                         {}
2528                 },
2529         },
2530         [ALC887_FIXUP_ASUS_HMIC] = {
2531                 .type = HDA_FIXUP_FUNC,
2532                 .v.func = alc887_fixup_asus_jack,
2533                 .chained = true,
2534                 .chain_id = ALC887_FIXUP_ASUS_AUDIO,
2535         },
2536         [ALCS1200A_FIXUP_MIC_VREF] = {
2537                 .type = HDA_FIXUP_PINCTLS,
2538                 .v.pins = (const struct hda_pintbl[]) {
2539                         { 0x18, PIN_VREF50 }, /* rear mic */
2540                         { 0x19, PIN_VREF50 }, /* front mic */
2541                         {}
2542                 }
2543         },
2544         [ALC888VD_FIXUP_MIC_100VREF] = {
2545                 .type = HDA_FIXUP_PINCTLS,
2546                 .v.pins = (const struct hda_pintbl[]) {
2547                         { 0x18, PIN_VREF100 }, /* headset mic */
2548                         {}
2549                 }
2550         },
2551 };
2552
2553 static const struct snd_pci_quirk alc882_fixup_tbl[] = {
2554         SND_PCI_QUIRK(0x1025, 0x006c, "Acer Aspire 9810", ALC883_FIXUP_ACER_EAPD),
2555         SND_PCI_QUIRK(0x1025, 0x0090, "Acer Aspire", ALC883_FIXUP_ACER_EAPD),
2556         SND_PCI_QUIRK(0x1025, 0x0107, "Acer Aspire", ALC883_FIXUP_ACER_EAPD),
2557         SND_PCI_QUIRK(0x1025, 0x010a, "Acer Ferrari 5000", ALC883_FIXUP_ACER_EAPD),
2558         SND_PCI_QUIRK(0x1025, 0x0110, "Acer Aspire", ALC883_FIXUP_ACER_EAPD),
2559         SND_PCI_QUIRK(0x1025, 0x0112, "Acer Aspire 9303", ALC883_FIXUP_ACER_EAPD),
2560         SND_PCI_QUIRK(0x1025, 0x0121, "Acer Aspire 5920G", ALC883_FIXUP_ACER_EAPD),
2561         SND_PCI_QUIRK(0x1025, 0x013e, "Acer Aspire 4930G",
2562                       ALC882_FIXUP_ACER_ASPIRE_4930G),
2563         SND_PCI_QUIRK(0x1025, 0x013f, "Acer Aspire 5930G",
2564                       ALC882_FIXUP_ACER_ASPIRE_4930G),
2565         SND_PCI_QUIRK(0x1025, 0x0145, "Acer Aspire 8930G",
2566                       ALC882_FIXUP_ACER_ASPIRE_8930G),
2567         SND_PCI_QUIRK(0x1025, 0x0146, "Acer Aspire 6935G",
2568                       ALC882_FIXUP_ACER_ASPIRE_8930G),
2569         SND_PCI_QUIRK(0x1025, 0x0142, "Acer Aspire 7730G",
2570                       ALC882_FIXUP_ACER_ASPIRE_4930G),
2571         SND_PCI_QUIRK(0x1025, 0x0155, "Packard-Bell M5120", ALC882_FIXUP_PB_M5210),
2572         SND_PCI_QUIRK(0x1025, 0x015e, "Acer Aspire 6930G",
2573                       ALC882_FIXUP_ACER_ASPIRE_4930G),
2574         SND_PCI_QUIRK(0x1025, 0x0166, "Acer Aspire 6530G",
2575                       ALC882_FIXUP_ACER_ASPIRE_4930G),
2576         SND_PCI_QUIRK(0x1025, 0x021e, "Acer Aspire 5739G",
2577                       ALC882_FIXUP_ACER_ASPIRE_4930G),
2578         SND_PCI_QUIRK(0x1025, 0x0259, "Acer Aspire 5935", ALC889_FIXUP_DAC_ROUTE),
2579         SND_PCI_QUIRK(0x1025, 0x026b, "Acer Aspire 8940G", ALC882_FIXUP_ACER_ASPIRE_8930G),
2580         SND_PCI_QUIRK(0x1025, 0x0296, "Acer Aspire 7736z", ALC882_FIXUP_ACER_ASPIRE_7736),
2581         SND_PCI_QUIRK(0x1043, 0x13c2, "Asus A7M", ALC882_FIXUP_EAPD),
2582         SND_PCI_QUIRK(0x1043, 0x1873, "ASUS W90V", ALC882_FIXUP_ASUS_W90V),
2583         SND_PCI_QUIRK(0x1043, 0x1971, "Asus W2JC", ALC882_FIXUP_ASUS_W2JC),
2584         SND_PCI_QUIRK(0x1043, 0x2390, "Asus D700SA", ALC887_FIXUP_ASUS_HMIC),
2585         SND_PCI_QUIRK(0x1043, 0x835f, "Asus Eee 1601", ALC888_FIXUP_EEE1601),
2586         SND_PCI_QUIRK(0x1043, 0x84bc, "ASUS ET2700", ALC887_FIXUP_ASUS_BASS),
2587         SND_PCI_QUIRK(0x1043, 0x8691, "ASUS ROG Ranger VIII", ALC882_FIXUP_GPIO3),
2588         SND_PCI_QUIRK(0x1043, 0x8797, "ASUS TUF B550M-PLUS", ALCS1200A_FIXUP_MIC_VREF),
2589         SND_PCI_QUIRK(0x104d, 0x9043, "Sony Vaio VGC-LN51JGB", ALC882_FIXUP_NO_PRIMARY_HP),
2590         SND_PCI_QUIRK(0x104d, 0x9044, "Sony VAIO AiO", ALC882_FIXUP_NO_PRIMARY_HP),
2591         SND_PCI_QUIRK(0x104d, 0x9047, "Sony Vaio TT", ALC889_FIXUP_VAIO_TT),
2592         SND_PCI_QUIRK(0x104d, 0x905a, "Sony Vaio Z", ALC882_FIXUP_NO_PRIMARY_HP),
2593         SND_PCI_QUIRK(0x104d, 0x9060, "Sony Vaio VPCL14M1R", ALC882_FIXUP_NO_PRIMARY_HP),
2594
2595         /* All Apple entries are in codec SSIDs */
2596         SND_PCI_QUIRK(0x106b, 0x00a0, "MacBookPro 3,1", ALC889_FIXUP_MBP_VREF),
2597         SND_PCI_QUIRK(0x106b, 0x00a1, "Macbook", ALC889_FIXUP_MBP_VREF),
2598         SND_PCI_QUIRK(0x106b, 0x00a4, "MacbookPro 4,1", ALC889_FIXUP_MBP_VREF),
2599         SND_PCI_QUIRK(0x106b, 0x0c00, "Mac Pro", ALC889_FIXUP_MP11_VREF),
2600         SND_PCI_QUIRK(0x106b, 0x1000, "iMac 24", ALC885_FIXUP_MACPRO_GPIO),
2601         SND_PCI_QUIRK(0x106b, 0x2800, "AppleTV", ALC885_FIXUP_MACPRO_GPIO),
2602         SND_PCI_QUIRK(0x106b, 0x2c00, "MacbookPro rev3", ALC889_FIXUP_MBP_VREF),
2603         SND_PCI_QUIRK(0x106b, 0x3000, "iMac", ALC889_FIXUP_MBP_VREF),
2604         SND_PCI_QUIRK(0x106b, 0x3200, "iMac 7,1 Aluminum", ALC882_FIXUP_EAPD),
2605         SND_PCI_QUIRK(0x106b, 0x3400, "MacBookAir 1,1", ALC889_FIXUP_MBA11_VREF),
2606         SND_PCI_QUIRK(0x106b, 0x3500, "MacBookAir 2,1", ALC889_FIXUP_MBA21_VREF),
2607         SND_PCI_QUIRK(0x106b, 0x3600, "Macbook 3,1", ALC889_FIXUP_MBP_VREF),
2608         SND_PCI_QUIRK(0x106b, 0x3800, "MacbookPro 4,1", ALC889_FIXUP_MBP_VREF),
2609         SND_PCI_QUIRK(0x106b, 0x3e00, "iMac 24 Aluminum", ALC885_FIXUP_MACPRO_GPIO),
2610         SND_PCI_QUIRK(0x106b, 0x3f00, "Macbook 5,1", ALC889_FIXUP_IMAC91_VREF),
2611         SND_PCI_QUIRK(0x106b, 0x4000, "MacbookPro 5,1", ALC889_FIXUP_IMAC91_VREF),
2612         SND_PCI_QUIRK(0x106b, 0x4100, "Macmini 3,1", ALC889_FIXUP_IMAC91_VREF),
2613         SND_PCI_QUIRK(0x106b, 0x4200, "Mac Pro 4,1/5,1", ALC889_FIXUP_MP41_VREF),
2614         SND_PCI_QUIRK(0x106b, 0x4300, "iMac 9,1", ALC889_FIXUP_IMAC91_VREF),
2615         SND_PCI_QUIRK(0x106b, 0x4600, "MacbookPro 5,2", ALC889_FIXUP_IMAC91_VREF),
2616         SND_PCI_QUIRK(0x106b, 0x4900, "iMac 9,1 Aluminum", ALC889_FIXUP_IMAC91_VREF),
2617         SND_PCI_QUIRK(0x106b, 0x4a00, "Macbook 5,2", ALC889_FIXUP_MBA11_VREF),
2618
2619         SND_PCI_QUIRK(0x1071, 0x8258, "Evesham Voyaeger", ALC882_FIXUP_EAPD),
2620         SND_PCI_QUIRK(0x10ec, 0x12d8, "iBase Elo Touch", ALC888VD_FIXUP_MIC_100VREF),
2621         SND_PCI_QUIRK(0x13fe, 0x1009, "Advantech MIT-W101", ALC886_FIXUP_EAPD),
2622         SND_PCI_QUIRK(0x1458, 0xa002, "Gigabyte EP45-DS3/Z87X-UD3H", ALC889_FIXUP_FRONT_HP_NO_PRESENCE),
2623         SND_PCI_QUIRK(0x1458, 0xa0b8, "Gigabyte AZ370-Gaming", ALC1220_FIXUP_GB_DUAL_CODECS),
2624         SND_PCI_QUIRK(0x1458, 0xa0cd, "Gigabyte X570 Aorus Master", ALC1220_FIXUP_GB_X570),
2625         SND_PCI_QUIRK(0x1458, 0xa0ce, "Gigabyte X570 Aorus Xtreme", ALC1220_FIXUP_GB_X570),
2626         SND_PCI_QUIRK(0x1458, 0xa0d5, "Gigabyte X570S Aorus Master", ALC1220_FIXUP_GB_X570),
2627         SND_PCI_QUIRK(0x1462, 0x11f7, "MSI-GE63", ALC1220_FIXUP_CLEVO_P950),
2628         SND_PCI_QUIRK(0x1462, 0x1228, "MSI-GP63", ALC1220_FIXUP_CLEVO_P950),
2629         SND_PCI_QUIRK(0x1462, 0x1229, "MSI-GP73", ALC1220_FIXUP_CLEVO_P950),
2630         SND_PCI_QUIRK(0x1462, 0x1275, "MSI-GL63", ALC1220_FIXUP_CLEVO_P950),
2631         SND_PCI_QUIRK(0x1462, 0x1276, "MSI-GL73", ALC1220_FIXUP_CLEVO_P950),
2632         SND_PCI_QUIRK(0x1462, 0x1293, "MSI-GP65", ALC1220_FIXUP_CLEVO_P950),
2633         SND_PCI_QUIRK(0x1462, 0x7350, "MSI-7350", ALC889_FIXUP_CD),
2634         SND_PCI_QUIRK(0x1462, 0xcc34, "MSI Godlike X570", ALC1220_FIXUP_GB_DUAL_CODECS),
2635         SND_PCI_QUIRK(0x1462, 0xda57, "MSI Z270-Gaming", ALC1220_FIXUP_GB_DUAL_CODECS),
2636         SND_PCI_QUIRK_VENDOR(0x1462, "MSI", ALC882_FIXUP_GPIO3),
2637         SND_PCI_QUIRK(0x147b, 0x107a, "Abit AW9D-MAX", ALC882_FIXUP_ABIT_AW9D_MAX),
2638         SND_PCI_QUIRK(0x1558, 0x3702, "Clevo X370SN[VW]", ALC1220_FIXUP_CLEVO_PB51ED_PINS),
2639         SND_PCI_QUIRK(0x1558, 0x50d3, "Clevo PC50[ER][CDF]", ALC1220_FIXUP_CLEVO_PB51ED_PINS),
2640         SND_PCI_QUIRK(0x1558, 0x65d1, "Clevo PB51[ER][CDF]", ALC1220_FIXUP_CLEVO_PB51ED_PINS),
2641         SND_PCI_QUIRK(0x1558, 0x65d2, "Clevo PB51R[CDF]", ALC1220_FIXUP_CLEVO_PB51ED_PINS),
2642         SND_PCI_QUIRK(0x1558, 0x65e1, "Clevo PB51[ED][DF]", ALC1220_FIXUP_CLEVO_PB51ED_PINS),
2643         SND_PCI_QUIRK(0x1558, 0x65e5, "Clevo PC50D[PRS](?:-D|-G)?", ALC1220_FIXUP_CLEVO_PB51ED_PINS),
2644         SND_PCI_QUIRK(0x1558, 0x65f1, "Clevo PC50HS", ALC1220_FIXUP_CLEVO_PB51ED_PINS),
2645         SND_PCI_QUIRK(0x1558, 0x65f5, "Clevo PD50PN[NRT]", ALC1220_FIXUP_CLEVO_PB51ED_PINS),
2646         SND_PCI_QUIRK(0x1558, 0x66a2, "Clevo PE60RNE", ALC1220_FIXUP_CLEVO_PB51ED_PINS),
2647         SND_PCI_QUIRK(0x1558, 0x67d1, "Clevo PB71[ER][CDF]", ALC1220_FIXUP_CLEVO_PB51ED_PINS),
2648         SND_PCI_QUIRK(0x1558, 0x67e1, "Clevo PB71[DE][CDF]", ALC1220_FIXUP_CLEVO_PB51ED_PINS),
2649         SND_PCI_QUIRK(0x1558, 0x67e5, "Clevo PC70D[PRS](?:-D|-G)?", ALC1220_FIXUP_CLEVO_PB51ED_PINS),
2650         SND_PCI_QUIRK(0x1558, 0x67f1, "Clevo PC70H[PRS]", ALC1220_FIXUP_CLEVO_PB51ED_PINS),
2651         SND_PCI_QUIRK(0x1558, 0x67f5, "Clevo PD70PN[NRT]", ALC1220_FIXUP_CLEVO_PB51ED_PINS),
2652         SND_PCI_QUIRK(0x1558, 0x70d1, "Clevo PC70[ER][CDF]", ALC1220_FIXUP_CLEVO_PB51ED_PINS),
2653         SND_PCI_QUIRK(0x1558, 0x7714, "Clevo X170SM", ALC1220_FIXUP_CLEVO_PB51ED_PINS),
2654         SND_PCI_QUIRK(0x1558, 0x7715, "Clevo X170KM-G", ALC1220_FIXUP_CLEVO_PB51ED),
2655         SND_PCI_QUIRK(0x1558, 0x9501, "Clevo P950HR", ALC1220_FIXUP_CLEVO_P950),
2656         SND_PCI_QUIRK(0x1558, 0x9506, "Clevo P955HQ", ALC1220_FIXUP_CLEVO_P950),
2657         SND_PCI_QUIRK(0x1558, 0x950a, "Clevo P955H[PR]", ALC1220_FIXUP_CLEVO_P950),
2658         SND_PCI_QUIRK(0x1558, 0x95e1, "Clevo P95xER", ALC1220_FIXUP_CLEVO_P950),
2659         SND_PCI_QUIRK(0x1558, 0x95e2, "Clevo P950ER", ALC1220_FIXUP_CLEVO_P950),
2660         SND_PCI_QUIRK(0x1558, 0x95e3, "Clevo P955[ER]T", ALC1220_FIXUP_CLEVO_P950),
2661         SND_PCI_QUIRK(0x1558, 0x95e4, "Clevo P955ER", ALC1220_FIXUP_CLEVO_P950),
2662         SND_PCI_QUIRK(0x1558, 0x95e5, "Clevo P955EE6", ALC1220_FIXUP_CLEVO_P950),
2663         SND_PCI_QUIRK(0x1558, 0x95e6, "Clevo P950R[CDF]", ALC1220_FIXUP_CLEVO_P950),
2664         SND_PCI_QUIRK(0x1558, 0x96e1, "Clevo P960[ER][CDFN]-K", ALC1220_FIXUP_CLEVO_P950),
2665         SND_PCI_QUIRK(0x1558, 0x97e1, "Clevo P970[ER][CDFN]", ALC1220_FIXUP_CLEVO_P950),
2666         SND_PCI_QUIRK(0x1558, 0x97e2, "Clevo P970RC-M", ALC1220_FIXUP_CLEVO_P950),
2667         SND_PCI_QUIRK(0x1558, 0xd502, "Clevo PD50SNE", ALC1220_FIXUP_CLEVO_PB51ED_PINS),
2668         SND_PCI_QUIRK_VENDOR(0x1558, "Clevo laptop", ALC882_FIXUP_EAPD),
2669         SND_PCI_QUIRK(0x161f, 0x2054, "Medion laptop", ALC883_FIXUP_EAPD),
2670         SND_PCI_QUIRK(0x17aa, 0x3a0d, "Lenovo Y530", ALC882_FIXUP_LENOVO_Y530),
2671         SND_PCI_QUIRK(0x8086, 0x0022, "DX58SO", ALC889_FIXUP_COEF),
2672         {}
2673 };
2674
2675 static const struct hda_model_fixup alc882_fixup_models[] = {
2676         {.id = ALC882_FIXUP_ABIT_AW9D_MAX, .name = "abit-aw9d"},
2677         {.id = ALC882_FIXUP_LENOVO_Y530, .name = "lenovo-y530"},
2678         {.id = ALC882_FIXUP_ACER_ASPIRE_7736, .name = "acer-aspire-7736"},
2679         {.id = ALC882_FIXUP_ASUS_W90V, .name = "asus-w90v"},
2680         {.id = ALC889_FIXUP_CD, .name = "cd"},
2681         {.id = ALC889_FIXUP_FRONT_HP_NO_PRESENCE, .name = "no-front-hp"},
2682         {.id = ALC889_FIXUP_VAIO_TT, .name = "vaio-tt"},
2683         {.id = ALC888_FIXUP_EEE1601, .name = "eee1601"},
2684         {.id = ALC882_FIXUP_EAPD, .name = "alc882-eapd"},
2685         {.id = ALC883_FIXUP_EAPD, .name = "alc883-eapd"},
2686         {.id = ALC882_FIXUP_GPIO1, .name = "gpio1"},
2687         {.id = ALC882_FIXUP_GPIO2, .name = "gpio2"},
2688         {.id = ALC882_FIXUP_GPIO3, .name = "gpio3"},
2689         {.id = ALC889_FIXUP_COEF, .name = "alc889-coef"},
2690         {.id = ALC882_FIXUP_ASUS_W2JC, .name = "asus-w2jc"},
2691         {.id = ALC882_FIXUP_ACER_ASPIRE_4930G, .name = "acer-aspire-4930g"},
2692         {.id = ALC882_FIXUP_ACER_ASPIRE_8930G, .name = "acer-aspire-8930g"},
2693         {.id = ALC883_FIXUP_ACER_EAPD, .name = "acer-aspire"},
2694         {.id = ALC885_FIXUP_MACPRO_GPIO, .name = "macpro-gpio"},
2695         {.id = ALC889_FIXUP_DAC_ROUTE, .name = "dac-route"},
2696         {.id = ALC889_FIXUP_MBP_VREF, .name = "mbp-vref"},
2697         {.id = ALC889_FIXUP_IMAC91_VREF, .name = "imac91-vref"},
2698         {.id = ALC889_FIXUP_MBA11_VREF, .name = "mba11-vref"},
2699         {.id = ALC889_FIXUP_MBA21_VREF, .name = "mba21-vref"},
2700         {.id = ALC889_FIXUP_MP11_VREF, .name = "mp11-vref"},
2701         {.id = ALC889_FIXUP_MP41_VREF, .name = "mp41-vref"},
2702         {.id = ALC882_FIXUP_INV_DMIC, .name = "inv-dmic"},
2703         {.id = ALC882_FIXUP_NO_PRIMARY_HP, .name = "no-primary-hp"},
2704         {.id = ALC887_FIXUP_ASUS_BASS, .name = "asus-bass"},
2705         {.id = ALC1220_FIXUP_GB_DUAL_CODECS, .name = "dual-codecs"},
2706         {.id = ALC1220_FIXUP_GB_X570, .name = "gb-x570"},
2707         {.id = ALC1220_FIXUP_CLEVO_P950, .name = "clevo-p950"},
2708         {}
2709 };
2710
2711 static const struct snd_hda_pin_quirk alc882_pin_fixup_tbl[] = {
2712         SND_HDA_PIN_QUIRK(0x10ec1220, 0x1043, "ASUS", ALC1220_FIXUP_CLEVO_P950,
2713                 {0x14, 0x01014010},
2714                 {0x15, 0x01011012},
2715                 {0x16, 0x01016011},
2716                 {0x18, 0x01a19040},
2717                 {0x19, 0x02a19050},
2718                 {0x1a, 0x0181304f},
2719                 {0x1b, 0x0221401f},
2720                 {0x1e, 0x01456130}),
2721         SND_HDA_PIN_QUIRK(0x10ec1220, 0x1462, "MS-7C35", ALC1220_FIXUP_CLEVO_P950,
2722                 {0x14, 0x01015010},
2723                 {0x15, 0x01011012},
2724                 {0x16, 0x01011011},
2725                 {0x18, 0x01a11040},
2726                 {0x19, 0x02a19050},
2727                 {0x1a, 0x0181104f},
2728                 {0x1b, 0x0221401f},
2729                 {0x1e, 0x01451130}),
2730         {}
2731 };
2732
2733 /*
2734  * BIOS auto configuration
2735  */
2736 /* almost identical with ALC880 parser... */
2737 static int alc882_parse_auto_config(struct hda_codec *codec)
2738 {
2739         static const hda_nid_t alc882_ignore[] = { 0x1d, 0 };
2740         static const hda_nid_t alc882_ssids[] = { 0x15, 0x1b, 0x14, 0 };
2741         return alc_parse_auto_config(codec, alc882_ignore, alc882_ssids);
2742 }
2743
2744 /*
2745  */
2746 static int patch_alc882(struct hda_codec *codec)
2747 {
2748         struct alc_spec *spec;
2749         int err;
2750
2751         err = alc_alloc_spec(codec, 0x0b);
2752         if (err < 0)
2753                 return err;
2754
2755         spec = codec->spec;
2756
2757         switch (codec->core.vendor_id) {
2758         case 0x10ec0882:
2759         case 0x10ec0885:
2760         case 0x10ec0900:
2761         case 0x10ec0b00:
2762         case 0x10ec1220:
2763                 break;
2764         default:
2765                 /* ALC883 and variants */
2766                 alc_fix_pll_init(codec, 0x20, 0x0a, 10);
2767                 break;
2768         }
2769
2770         alc_pre_init(codec);
2771
2772         snd_hda_pick_fixup(codec, alc882_fixup_models, alc882_fixup_tbl,
2773                        alc882_fixups);
2774         snd_hda_pick_pin_fixup(codec, alc882_pin_fixup_tbl, alc882_fixups, true);
2775         snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE);
2776
2777         alc_auto_parse_customize_define(codec);
2778
2779         if (has_cdefine_beep(codec))
2780                 spec->gen.beep_nid = 0x01;
2781
2782         /* automatic parse from the BIOS config */
2783         err = alc882_parse_auto_config(codec);
2784         if (err < 0)
2785                 goto error;
2786
2787         if (!spec->gen.no_analog && spec->gen.beep_nid) {
2788                 err = set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
2789                 if (err < 0)
2790                         goto error;
2791         }
2792
2793         snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE);
2794
2795         return 0;
2796
2797  error:
2798         alc_free(codec);
2799         return err;
2800 }
2801
2802
2803 /*
2804  * ALC262 support
2805  */
2806 static int alc262_parse_auto_config(struct hda_codec *codec)
2807 {
2808         static const hda_nid_t alc262_ignore[] = { 0x1d, 0 };
2809         static const hda_nid_t alc262_ssids[] = { 0x15, 0x1b, 0x14, 0 };
2810         return alc_parse_auto_config(codec, alc262_ignore, alc262_ssids);
2811 }
2812
2813 /*
2814  * Pin config fixes
2815  */
2816 enum {
2817         ALC262_FIXUP_FSC_H270,
2818         ALC262_FIXUP_FSC_S7110,
2819         ALC262_FIXUP_HP_Z200,
2820         ALC262_FIXUP_TYAN,
2821         ALC262_FIXUP_LENOVO_3000,
2822         ALC262_FIXUP_BENQ,
2823         ALC262_FIXUP_BENQ_T31,
2824         ALC262_FIXUP_INV_DMIC,
2825         ALC262_FIXUP_INTEL_BAYLEYBAY,
2826 };
2827
2828 static const struct hda_fixup alc262_fixups[] = {
2829         [ALC262_FIXUP_FSC_H270] = {
2830                 .type = HDA_FIXUP_PINS,
2831                 .v.pins = (const struct hda_pintbl[]) {
2832                         { 0x14, 0x99130110 }, /* speaker */
2833                         { 0x15, 0x0221142f }, /* front HP */
2834                         { 0x1b, 0x0121141f }, /* rear HP */
2835                         { }
2836                 }
2837         },
2838         [ALC262_FIXUP_FSC_S7110] = {
2839                 .type = HDA_FIXUP_PINS,
2840                 .v.pins = (const struct hda_pintbl[]) {
2841                         { 0x15, 0x90170110 }, /* speaker */
2842                         { }
2843                 },
2844                 .chained = true,
2845                 .chain_id = ALC262_FIXUP_BENQ,
2846         },
2847         [ALC262_FIXUP_HP_Z200] = {
2848                 .type = HDA_FIXUP_PINS,
2849                 .v.pins = (const struct hda_pintbl[]) {
2850                         { 0x16, 0x99130120 }, /* internal speaker */
2851                         { }
2852                 }
2853         },
2854         [ALC262_FIXUP_TYAN] = {
2855                 .type = HDA_FIXUP_PINS,
2856                 .v.pins = (const struct hda_pintbl[]) {
2857                         { 0x14, 0x1993e1f0 }, /* int AUX */
2858                         { }
2859                 }
2860         },
2861         [ALC262_FIXUP_LENOVO_3000] = {
2862                 .type = HDA_FIXUP_PINCTLS,
2863                 .v.pins = (const struct hda_pintbl[]) {
2864                         { 0x19, PIN_VREF50 },
2865                         {}
2866                 },
2867                 .chained = true,
2868                 .chain_id = ALC262_FIXUP_BENQ,
2869         },
2870         [ALC262_FIXUP_BENQ] = {
2871                 .type = HDA_FIXUP_VERBS,
2872                 .v.verbs = (const struct hda_verb[]) {
2873                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x07 },
2874                         { 0x20, AC_VERB_SET_PROC_COEF, 0x3070 },
2875                         {}
2876                 }
2877         },
2878         [ALC262_FIXUP_BENQ_T31] = {
2879                 .type = HDA_FIXUP_VERBS,
2880                 .v.verbs = (const struct hda_verb[]) {
2881                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x07 },
2882                         { 0x20, AC_VERB_SET_PROC_COEF, 0x3050 },
2883                         {}
2884                 }
2885         },
2886         [ALC262_FIXUP_INV_DMIC] = {
2887                 .type = HDA_FIXUP_FUNC,
2888                 .v.func = alc_fixup_inv_dmic,
2889         },
2890         [ALC262_FIXUP_INTEL_BAYLEYBAY] = {
2891                 .type = HDA_FIXUP_FUNC,
2892                 .v.func = alc_fixup_no_depop_delay,
2893         },
2894 };
2895
2896 static const struct snd_pci_quirk alc262_fixup_tbl[] = {
2897         SND_PCI_QUIRK(0x103c, 0x170b, "HP Z200", ALC262_FIXUP_HP_Z200),
2898         SND_PCI_QUIRK(0x10cf, 0x1397, "Fujitsu Lifebook S7110", ALC262_FIXUP_FSC_S7110),
2899         SND_PCI_QUIRK(0x10cf, 0x142d, "Fujitsu Lifebook E8410", ALC262_FIXUP_BENQ),
2900         SND_PCI_QUIRK(0x10f1, 0x2915, "Tyan Thunder n6650W", ALC262_FIXUP_TYAN),
2901         SND_PCI_QUIRK(0x1734, 0x1141, "FSC ESPRIMO U9210", ALC262_FIXUP_FSC_H270),
2902         SND_PCI_QUIRK(0x1734, 0x1147, "FSC Celsius H270", ALC262_FIXUP_FSC_H270),
2903         SND_PCI_QUIRK(0x17aa, 0x384e, "Lenovo 3000", ALC262_FIXUP_LENOVO_3000),
2904         SND_PCI_QUIRK(0x17ff, 0x0560, "Benq ED8", ALC262_FIXUP_BENQ),
2905         SND_PCI_QUIRK(0x17ff, 0x058d, "Benq T31-16", ALC262_FIXUP_BENQ_T31),
2906         SND_PCI_QUIRK(0x8086, 0x7270, "BayleyBay", ALC262_FIXUP_INTEL_BAYLEYBAY),
2907         {}
2908 };
2909
2910 static const struct hda_model_fixup alc262_fixup_models[] = {
2911         {.id = ALC262_FIXUP_INV_DMIC, .name = "inv-dmic"},
2912         {.id = ALC262_FIXUP_FSC_H270, .name = "fsc-h270"},
2913         {.id = ALC262_FIXUP_FSC_S7110, .name = "fsc-s7110"},
2914         {.id = ALC262_FIXUP_HP_Z200, .name = "hp-z200"},
2915         {.id = ALC262_FIXUP_TYAN, .name = "tyan"},
2916         {.id = ALC262_FIXUP_LENOVO_3000, .name = "lenovo-3000"},
2917         {.id = ALC262_FIXUP_BENQ, .name = "benq"},
2918         {.id = ALC262_FIXUP_BENQ_T31, .name = "benq-t31"},
2919         {.id = ALC262_FIXUP_INTEL_BAYLEYBAY, .name = "bayleybay"},
2920         {}
2921 };
2922
2923 /*
2924  */
2925 static int patch_alc262(struct hda_codec *codec)
2926 {
2927         struct alc_spec *spec;
2928         int err;
2929
2930         err = alc_alloc_spec(codec, 0x0b);
2931         if (err < 0)
2932                 return err;
2933
2934         spec = codec->spec;
2935         spec->gen.shared_mic_vref_pin = 0x18;
2936
2937         spec->shutup = alc_eapd_shutup;
2938
2939 #if 0
2940         /* pshou 07/11/05  set a zero PCM sample to DAC when FIFO is
2941          * under-run
2942          */
2943         alc_update_coefex_idx(codec, 0x1a, 7, 0, 0x80);
2944 #endif
2945         alc_fix_pll_init(codec, 0x20, 0x0a, 10);
2946
2947         alc_pre_init(codec);
2948
2949         snd_hda_pick_fixup(codec, alc262_fixup_models, alc262_fixup_tbl,
2950                        alc262_fixups);
2951         snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE);
2952
2953         alc_auto_parse_customize_define(codec);
2954
2955         if (has_cdefine_beep(codec))
2956                 spec->gen.beep_nid = 0x01;
2957
2958         /* automatic parse from the BIOS config */
2959         err = alc262_parse_auto_config(codec);
2960         if (err < 0)
2961                 goto error;
2962
2963         if (!spec->gen.no_analog && spec->gen.beep_nid) {
2964                 err = set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
2965                 if (err < 0)
2966                         goto error;
2967         }
2968
2969         snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE);
2970
2971         return 0;
2972
2973  error:
2974         alc_free(codec);
2975         return err;
2976 }
2977
2978 /*
2979  *  ALC268
2980  */
2981 /* bind Beep switches of both NID 0x0f and 0x10 */
2982 static int alc268_beep_switch_put(struct snd_kcontrol *kcontrol,
2983                                   struct snd_ctl_elem_value *ucontrol)
2984 {
2985         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2986         unsigned long pval;
2987         int err;
2988
2989         mutex_lock(&codec->control_mutex);
2990         pval = kcontrol->private_value;
2991         kcontrol->private_value = (pval & ~0xff) | 0x0f;
2992         err = snd_hda_mixer_amp_switch_put(kcontrol, ucontrol);
2993         if (err >= 0) {
2994                 kcontrol->private_value = (pval & ~0xff) | 0x10;
2995                 err = snd_hda_mixer_amp_switch_put(kcontrol, ucontrol);
2996         }
2997         kcontrol->private_value = pval;
2998         mutex_unlock(&codec->control_mutex);
2999         return err;
3000 }
3001
3002 static const struct snd_kcontrol_new alc268_beep_mixer[] = {
3003         HDA_CODEC_VOLUME("Beep Playback Volume", 0x1d, 0x0, HDA_INPUT),
3004         {
3005                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3006                 .name = "Beep Playback Switch",
3007                 .subdevice = HDA_SUBDEV_AMP_FLAG,
3008                 .info = snd_hda_mixer_amp_switch_info,
3009                 .get = snd_hda_mixer_amp_switch_get,
3010                 .put = alc268_beep_switch_put,
3011                 .private_value = HDA_COMPOSE_AMP_VAL(0x0f, 3, 1, HDA_INPUT)
3012         },
3013 };
3014
3015 /* set PCBEEP vol = 0, mute connections */
3016 static const struct hda_verb alc268_beep_init_verbs[] = {
3017         {0x1d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
3018         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
3019         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
3020         { }
3021 };
3022
3023 enum {
3024         ALC268_FIXUP_INV_DMIC,
3025         ALC268_FIXUP_HP_EAPD,
3026         ALC268_FIXUP_SPDIF,
3027 };
3028
3029 static const struct hda_fixup alc268_fixups[] = {
3030         [ALC268_FIXUP_INV_DMIC] = {
3031                 .type = HDA_FIXUP_FUNC,
3032                 .v.func = alc_fixup_inv_dmic,
3033         },
3034         [ALC268_FIXUP_HP_EAPD] = {
3035                 .type = HDA_FIXUP_VERBS,
3036                 .v.verbs = (const struct hda_verb[]) {
3037                         {0x15, AC_VERB_SET_EAPD_BTLENABLE, 0},
3038                         {}
3039                 }
3040         },
3041         [ALC268_FIXUP_SPDIF] = {
3042                 .type = HDA_FIXUP_PINS,
3043                 .v.pins = (const struct hda_pintbl[]) {
3044                         { 0x1e, 0x014b1180 }, /* enable SPDIF out */
3045                         {}
3046                 }
3047         },
3048 };
3049
3050 static const struct hda_model_fixup alc268_fixup_models[] = {
3051         {.id = ALC268_FIXUP_INV_DMIC, .name = "inv-dmic"},
3052         {.id = ALC268_FIXUP_HP_EAPD, .name = "hp-eapd"},
3053         {.id = ALC268_FIXUP_SPDIF, .name = "spdif"},
3054         {}
3055 };
3056
3057 static const struct snd_pci_quirk alc268_fixup_tbl[] = {
3058         SND_PCI_QUIRK(0x1025, 0x0139, "Acer TravelMate 6293", ALC268_FIXUP_SPDIF),
3059         SND_PCI_QUIRK(0x1025, 0x015b, "Acer AOA 150 (ZG5)", ALC268_FIXUP_INV_DMIC),
3060         /* below is codec SSID since multiple Toshiba laptops have the
3061          * same PCI SSID 1179:ff00
3062          */
3063         SND_PCI_QUIRK(0x1179, 0xff06, "Toshiba P200", ALC268_FIXUP_HP_EAPD),
3064         {}
3065 };
3066
3067 /*
3068  * BIOS auto configuration
3069  */
3070 static int alc268_parse_auto_config(struct hda_codec *codec)
3071 {
3072         static const hda_nid_t alc268_ssids[] = { 0x15, 0x1b, 0x14, 0 };
3073         return alc_parse_auto_config(codec, NULL, alc268_ssids);
3074 }
3075
3076 /*
3077  */
3078 static int patch_alc268(struct hda_codec *codec)
3079 {
3080         struct alc_spec *spec;
3081         int i, err;
3082
3083         /* ALC268 has no aa-loopback mixer */
3084         err = alc_alloc_spec(codec, 0);
3085         if (err < 0)
3086                 return err;
3087
3088         spec = codec->spec;
3089         if (has_cdefine_beep(codec))
3090                 spec->gen.beep_nid = 0x01;
3091
3092         spec->shutup = alc_eapd_shutup;
3093
3094         alc_pre_init(codec);
3095
3096         snd_hda_pick_fixup(codec, alc268_fixup_models, alc268_fixup_tbl, alc268_fixups);
3097         snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE);
3098
3099         /* automatic parse from the BIOS config */
3100         err = alc268_parse_auto_config(codec);
3101         if (err < 0)
3102                 goto error;
3103
3104         if (err > 0 && !spec->gen.no_analog &&
3105             spec->gen.autocfg.speaker_pins[0] != 0x1d) {
3106                 for (i = 0; i < ARRAY_SIZE(alc268_beep_mixer); i++) {
3107                         if (!snd_hda_gen_add_kctl(&spec->gen, NULL,
3108                                                   &alc268_beep_mixer[i])) {
3109                                 err = -ENOMEM;
3110                                 goto error;
3111                         }
3112                 }
3113                 snd_hda_add_verbs(codec, alc268_beep_init_verbs);
3114                 if (!query_amp_caps(codec, 0x1d, HDA_INPUT))
3115                         /* override the amp caps for beep generator */
3116                         snd_hda_override_amp_caps(codec, 0x1d, HDA_INPUT,
3117                                           (0x0c << AC_AMPCAP_OFFSET_SHIFT) |
3118                                           (0x0c << AC_AMPCAP_NUM_STEPS_SHIFT) |
3119                                           (0x07 << AC_AMPCAP_STEP_SIZE_SHIFT) |
3120                                           (0 << AC_AMPCAP_MUTE_SHIFT));
3121         }
3122
3123         snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE);
3124
3125         return 0;
3126
3127  error:
3128         alc_free(codec);
3129         return err;
3130 }
3131
3132 /*
3133  * ALC269
3134  */
3135
3136 static const struct hda_pcm_stream alc269_44k_pcm_analog_playback = {
3137         .rates = SNDRV_PCM_RATE_44100, /* fixed rate */
3138 };
3139
3140 static const struct hda_pcm_stream alc269_44k_pcm_analog_capture = {
3141         .rates = SNDRV_PCM_RATE_44100, /* fixed rate */
3142 };
3143
3144 /* different alc269-variants */
3145 enum {
3146         ALC269_TYPE_ALC269VA,
3147         ALC269_TYPE_ALC269VB,
3148         ALC269_TYPE_ALC269VC,
3149         ALC269_TYPE_ALC269VD,
3150         ALC269_TYPE_ALC280,
3151         ALC269_TYPE_ALC282,
3152         ALC269_TYPE_ALC283,
3153         ALC269_TYPE_ALC284,
3154         ALC269_TYPE_ALC293,
3155         ALC269_TYPE_ALC286,
3156         ALC269_TYPE_ALC298,
3157         ALC269_TYPE_ALC255,
3158         ALC269_TYPE_ALC256,
3159         ALC269_TYPE_ALC257,
3160         ALC269_TYPE_ALC215,
3161         ALC269_TYPE_ALC225,
3162         ALC269_TYPE_ALC245,
3163         ALC269_TYPE_ALC287,
3164         ALC269_TYPE_ALC294,
3165         ALC269_TYPE_ALC300,
3166         ALC269_TYPE_ALC623,
3167         ALC269_TYPE_ALC700,
3168 };
3169
3170 /*
3171  * BIOS auto configuration
3172  */
3173 static int alc269_parse_auto_config(struct hda_codec *codec)
3174 {
3175         static const hda_nid_t alc269_ignore[] = { 0x1d, 0 };
3176         static const hda_nid_t alc269_ssids[] = { 0, 0x1b, 0x14, 0x21 };
3177         static const hda_nid_t alc269va_ssids[] = { 0x15, 0x1b, 0x14, 0 };
3178         struct alc_spec *spec = codec->spec;
3179         const hda_nid_t *ssids;
3180
3181         switch (spec->codec_variant) {
3182         case ALC269_TYPE_ALC269VA:
3183         case ALC269_TYPE_ALC269VC:
3184         case ALC269_TYPE_ALC280:
3185         case ALC269_TYPE_ALC284:
3186         case ALC269_TYPE_ALC293:
3187                 ssids = alc269va_ssids;
3188                 break;
3189         case ALC269_TYPE_ALC269VB:
3190         case ALC269_TYPE_ALC269VD:
3191         case ALC269_TYPE_ALC282:
3192         case ALC269_TYPE_ALC283:
3193         case ALC269_TYPE_ALC286:
3194         case ALC269_TYPE_ALC298:
3195         case ALC269_TYPE_ALC255:
3196         case ALC269_TYPE_ALC256:
3197         case ALC269_TYPE_ALC257:
3198         case ALC269_TYPE_ALC215:
3199         case ALC269_TYPE_ALC225:
3200         case ALC269_TYPE_ALC245:
3201         case ALC269_TYPE_ALC287:
3202         case ALC269_TYPE_ALC294:
3203         case ALC269_TYPE_ALC300:
3204         case ALC269_TYPE_ALC623:
3205         case ALC269_TYPE_ALC700:
3206                 ssids = alc269_ssids;
3207                 break;
3208         default:
3209                 ssids = alc269_ssids;
3210                 break;
3211         }
3212
3213         return alc_parse_auto_config(codec, alc269_ignore, ssids);
3214 }
3215
3216 static const struct hda_jack_keymap alc_headset_btn_keymap[] = {
3217         { SND_JACK_BTN_0, KEY_PLAYPAUSE },
3218         { SND_JACK_BTN_1, KEY_VOICECOMMAND },
3219         { SND_JACK_BTN_2, KEY_VOLUMEUP },
3220         { SND_JACK_BTN_3, KEY_VOLUMEDOWN },
3221         {}
3222 };
3223
3224 static void alc_headset_btn_callback(struct hda_codec *codec,
3225                                      struct hda_jack_callback *jack)
3226 {
3227         int report = 0;
3228
3229         if (jack->unsol_res & (7 << 13))
3230                 report |= SND_JACK_BTN_0;
3231
3232         if (jack->unsol_res  & (1 << 16 | 3 << 8))
3233                 report |= SND_JACK_BTN_1;
3234
3235         /* Volume up key */
3236         if (jack->unsol_res & (7 << 23))
3237                 report |= SND_JACK_BTN_2;
3238
3239         /* Volume down key */
3240         if (jack->unsol_res & (7 << 10))
3241                 report |= SND_JACK_BTN_3;
3242
3243         snd_hda_jack_set_button_state(codec, jack->nid, report);
3244 }
3245
3246 static void alc_disable_headset_jack_key(struct hda_codec *codec)
3247 {
3248         struct alc_spec *spec = codec->spec;
3249
3250         if (!spec->has_hs_key)
3251                 return;
3252
3253         switch (codec->core.vendor_id) {
3254         case 0x10ec0215:
3255         case 0x10ec0225:
3256         case 0x10ec0285:
3257         case 0x10ec0287:
3258         case 0x10ec0295:
3259         case 0x10ec0289:
3260         case 0x10ec0299:
3261                 alc_write_coef_idx(codec, 0x48, 0x0);
3262                 alc_update_coef_idx(codec, 0x49, 0x0045, 0x0);
3263                 alc_update_coef_idx(codec, 0x44, 0x0045 << 8, 0x0);
3264                 break;
3265         case 0x10ec0230:
3266         case 0x10ec0236:
3267         case 0x10ec0256:
3268         case 0x10ec0257:
3269         case 0x19e58326:
3270                 alc_write_coef_idx(codec, 0x48, 0x0);
3271                 alc_update_coef_idx(codec, 0x49, 0x0045, 0x0);
3272                 break;
3273         }
3274 }
3275
3276 static void alc_enable_headset_jack_key(struct hda_codec *codec)
3277 {
3278         struct alc_spec *spec = codec->spec;
3279
3280         if (!spec->has_hs_key)
3281                 return;
3282
3283         switch (codec->core.vendor_id) {
3284         case 0x10ec0215:
3285         case 0x10ec0225:
3286         case 0x10ec0285:
3287         case 0x10ec0287:
3288         case 0x10ec0295:
3289         case 0x10ec0289:
3290         case 0x10ec0299:
3291                 alc_write_coef_idx(codec, 0x48, 0xd011);
3292                 alc_update_coef_idx(codec, 0x49, 0x007f, 0x0045);
3293                 alc_update_coef_idx(codec, 0x44, 0x007f << 8, 0x0045 << 8);
3294                 break;
3295         case 0x10ec0230:
3296         case 0x10ec0236:
3297         case 0x10ec0256:
3298         case 0x10ec0257:
3299         case 0x19e58326:
3300                 alc_write_coef_idx(codec, 0x48, 0xd011);
3301                 alc_update_coef_idx(codec, 0x49, 0x007f, 0x0045);
3302                 break;
3303         }
3304 }
3305
3306 static void alc_fixup_headset_jack(struct hda_codec *codec,
3307                                     const struct hda_fixup *fix, int action)
3308 {
3309         struct alc_spec *spec = codec->spec;
3310         hda_nid_t hp_pin;
3311
3312         switch (action) {
3313         case HDA_FIXUP_ACT_PRE_PROBE:
3314                 spec->has_hs_key = 1;
3315                 snd_hda_jack_detect_enable_callback(codec, 0x55,
3316                                                     alc_headset_btn_callback);
3317                 break;
3318         case HDA_FIXUP_ACT_BUILD:
3319                 hp_pin = alc_get_hp_pin(spec);
3320                 if (!hp_pin || snd_hda_jack_bind_keymap(codec, 0x55,
3321                                                         alc_headset_btn_keymap,
3322                                                         hp_pin))
3323                         snd_hda_jack_add_kctl(codec, 0x55, "Headset Jack",
3324                                               false, SND_JACK_HEADSET,
3325                                               alc_headset_btn_keymap);
3326
3327                 alc_enable_headset_jack_key(codec);
3328                 break;
3329         }
3330 }
3331
3332 static void alc269vb_toggle_power_output(struct hda_codec *codec, int power_up)
3333 {
3334         alc_update_coef_idx(codec, 0x04, 1 << 11, power_up ? (1 << 11) : 0);
3335 }
3336
3337 static void alc269_shutup(struct hda_codec *codec)
3338 {
3339         struct alc_spec *spec = codec->spec;
3340
3341         if (spec->codec_variant == ALC269_TYPE_ALC269VB)
3342                 alc269vb_toggle_power_output(codec, 0);
3343         if (spec->codec_variant == ALC269_TYPE_ALC269VB &&
3344                         (alc_get_coef0(codec) & 0x00ff) == 0x018) {
3345                 msleep(150);
3346         }
3347         alc_shutup_pins(codec);
3348 }
3349
3350 static const struct coef_fw alc282_coefs[] = {
3351         WRITE_COEF(0x03, 0x0002), /* Power Down Control */
3352         UPDATE_COEF(0x05, 0xff3f, 0x0700), /* FIFO and filter clock */
3353         WRITE_COEF(0x07, 0x0200), /* DMIC control */
3354         UPDATE_COEF(0x06, 0x00f0, 0), /* Analog clock */
3355         UPDATE_COEF(0x08, 0xfffc, 0x0c2c), /* JD */
3356         WRITE_COEF(0x0a, 0xcccc), /* JD offset1 */
3357         WRITE_COEF(0x0b, 0xcccc), /* JD offset2 */
3358         WRITE_COEF(0x0e, 0x6e00), /* LDO1/2/3, DAC/ADC */
3359         UPDATE_COEF(0x0f, 0xf800, 0x1000), /* JD */
3360         UPDATE_COEF(0x10, 0xfc00, 0x0c00), /* Capless */
3361         WRITE_COEF(0x6f, 0x0), /* Class D test 4 */
3362         UPDATE_COEF(0x0c, 0xfe00, 0), /* IO power down directly */
3363         WRITE_COEF(0x34, 0xa0c0), /* ANC */
3364         UPDATE_COEF(0x16, 0x0008, 0), /* AGC MUX */
3365         UPDATE_COEF(0x1d, 0x00e0, 0), /* DAC simple content protection */
3366         UPDATE_COEF(0x1f, 0x00e0, 0), /* ADC simple content protection */
3367         WRITE_COEF(0x21, 0x8804), /* DAC ADC Zero Detection */
3368         WRITE_COEF(0x63, 0x2902), /* PLL */
3369         WRITE_COEF(0x68, 0xa080), /* capless control 2 */
3370         WRITE_COEF(0x69, 0x3400), /* capless control 3 */
3371         WRITE_COEF(0x6a, 0x2f3e), /* capless control 4 */
3372         WRITE_COEF(0x6b, 0x0), /* capless control 5 */
3373         UPDATE_COEF(0x6d, 0x0fff, 0x0900), /* class D test 2 */
3374         WRITE_COEF(0x6e, 0x110a), /* class D test 3 */
3375         UPDATE_COEF(0x70, 0x00f8, 0x00d8), /* class D test 5 */
3376         WRITE_COEF(0x71, 0x0014), /* class D test 6 */
3377         WRITE_COEF(0x72, 0xc2ba), /* classD OCP */
3378         UPDATE_COEF(0x77, 0x0f80, 0), /* classD pure DC test */
3379         WRITE_COEF(0x6c, 0xfc06), /* Class D amp control */
3380         {}
3381 };
3382
3383 static void alc282_restore_default_value(struct hda_codec *codec)
3384 {
3385         alc_process_coef_fw(codec, alc282_coefs);
3386 }
3387
3388 static void alc282_init(struct hda_codec *codec)
3389 {
3390         struct alc_spec *spec = codec->spec;
3391         hda_nid_t hp_pin = alc_get_hp_pin(spec);
3392         bool hp_pin_sense;
3393         int coef78;
3394
3395         alc282_restore_default_value(codec);
3396
3397         if (!hp_pin)
3398                 return;
3399         hp_pin_sense = snd_hda_jack_detect(codec, hp_pin);
3400         coef78 = alc_read_coef_idx(codec, 0x78);
3401
3402         /* Index 0x78 Direct Drive HP AMP LPM Control 1 */
3403         /* Headphone capless set to high power mode */
3404         alc_write_coef_idx(codec, 0x78, 0x9004);
3405
3406         if (hp_pin_sense)
3407                 msleep(2);
3408
3409         snd_hda_codec_write(codec, hp_pin, 0,
3410                             AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);
3411
3412         if (hp_pin_sense)
3413                 msleep(85);
3414
3415         snd_hda_codec_write(codec, hp_pin, 0,
3416                             AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT);
3417
3418         if (hp_pin_sense)
3419                 msleep(100);
3420
3421         /* Headphone capless set to normal mode */
3422         alc_write_coef_idx(codec, 0x78, coef78);
3423 }
3424
3425 static void alc282_shutup(struct hda_codec *codec)
3426 {
3427         struct alc_spec *spec = codec->spec;
3428         hda_nid_t hp_pin = alc_get_hp_pin(spec);
3429         bool hp_pin_sense;
3430         int coef78;
3431
3432         if (!hp_pin) {
3433                 alc269_shutup(codec);
3434                 return;
3435         }
3436
3437         hp_pin_sense = snd_hda_jack_detect(codec, hp_pin);
3438         coef78 = alc_read_coef_idx(codec, 0x78);
3439         alc_write_coef_idx(codec, 0x78, 0x9004);
3440
3441         if (hp_pin_sense)
3442                 msleep(2);
3443
3444         snd_hda_codec_write(codec, hp_pin, 0,
3445                             AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);
3446
3447         if (hp_pin_sense)
3448                 msleep(85);
3449
3450         if (!spec->no_shutup_pins)
3451                 snd_hda_codec_write(codec, hp_pin, 0,
3452                                     AC_VERB_SET_PIN_WIDGET_CONTROL, 0x0);
3453
3454         if (hp_pin_sense)
3455                 msleep(100);
3456
3457         alc_auto_setup_eapd(codec, false);
3458         alc_shutup_pins(codec);
3459         alc_write_coef_idx(codec, 0x78, coef78);
3460 }
3461
3462 static const struct coef_fw alc283_coefs[] = {
3463         WRITE_COEF(0x03, 0x0002), /* Power Down Control */
3464         UPDATE_COEF(0x05, 0xff3f, 0x0700), /* FIFO and filter clock */
3465         WRITE_COEF(0x07, 0x0200), /* DMIC control */
3466         UPDATE_COEF(0x06, 0x00f0, 0), /* Analog clock */
3467         UPDATE_COEF(0x08, 0xfffc, 0x0c2c), /* JD */
3468         WRITE_COEF(0x0a, 0xcccc), /* JD offset1 */
3469         WRITE_COEF(0x0b, 0xcccc), /* JD offset2 */
3470         WRITE_COEF(0x0e, 0x6fc0), /* LDO1/2/3, DAC/ADC */
3471         UPDATE_COEF(0x0f, 0xf800, 0x1000), /* JD */
3472         UPDATE_COEF(0x10, 0xfc00, 0x0c00), /* Capless */
3473         WRITE_COEF(0x3a, 0x0), /* Class D test 4 */
3474         UPDATE_COEF(0x0c, 0xfe00, 0x0), /* IO power down directly */
3475         WRITE_COEF(0x22, 0xa0c0), /* ANC */
3476         UPDATE_COEFEX(0x53, 0x01, 0x000f, 0x0008), /* AGC MUX */
3477         UPDATE_COEF(0x1d, 0x00e0, 0), /* DAC simple content protection */
3478         UPDATE_COEF(0x1f, 0x00e0, 0), /* ADC simple content protection */
3479         WRITE_COEF(0x21, 0x8804), /* DAC ADC Zero Detection */
3480         WRITE_COEF(0x2e, 0x2902), /* PLL */
3481         WRITE_COEF(0x33, 0xa080), /* capless control 2 */
3482         WRITE_COEF(0x34, 0x3400), /* capless control 3 */
3483         WRITE_COEF(0x35, 0x2f3e), /* capless control 4 */
3484         WRITE_COEF(0x36, 0x0), /* capless control 5 */
3485         UPDATE_COEF(0x38, 0x0fff, 0x0900), /* class D test 2 */
3486         WRITE_COEF(0x39, 0x110a), /* class D test 3 */
3487         UPDATE_COEF(0x3b, 0x00f8, 0x00d8), /* class D test 5 */
3488         WRITE_COEF(0x3c, 0x0014), /* class D test 6 */
3489         WRITE_COEF(0x3d, 0xc2ba), /* classD OCP */
3490         UPDATE_COEF(0x42, 0x0f80, 0x0), /* classD pure DC test */
3491         WRITE_COEF(0x49, 0x0), /* test mode */
3492         UPDATE_COEF(0x40, 0xf800, 0x9800), /* Class D DC enable */
3493         UPDATE_COEF(0x42, 0xf000, 0x2000), /* DC offset */
3494         WRITE_COEF(0x37, 0xfc06), /* Class D amp control */
3495         UPDATE_COEF(0x1b, 0x8000, 0), /* HP JD control */
3496         {}
3497 };
3498
3499 static void alc283_restore_default_value(struct hda_codec *codec)
3500 {
3501         alc_process_coef_fw(codec, alc283_coefs);
3502 }
3503
3504 static void alc283_init(struct hda_codec *codec)
3505 {
3506         struct alc_spec *spec = codec->spec;
3507         hda_nid_t hp_pin = alc_get_hp_pin(spec);
3508         bool hp_pin_sense;
3509
3510         alc283_restore_default_value(codec);
3511
3512         if (!hp_pin)
3513                 return;
3514
3515         msleep(30);
3516         hp_pin_sense = snd_hda_jack_detect(codec, hp_pin);
3517
3518         /* Index 0x43 Direct Drive HP AMP LPM Control 1 */
3519         /* Headphone capless set to high power mode */
3520         alc_write_coef_idx(codec, 0x43, 0x9004);
3521
3522         snd_hda_codec_write(codec, hp_pin, 0,
3523                             AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);
3524
3525         if (hp_pin_sense)
3526                 msleep(85);
3527
3528         snd_hda_codec_write(codec, hp_pin, 0,
3529                             AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT);
3530
3531         if (hp_pin_sense)
3532                 msleep(85);
3533         /* Index 0x46 Combo jack auto switch control 2 */
3534         /* 3k pull low control for Headset jack. */
3535         alc_update_coef_idx(codec, 0x46, 3 << 12, 0);
3536         /* Headphone capless set to normal mode */
3537         alc_write_coef_idx(codec, 0x43, 0x9614);
3538 }
3539
3540 static void alc283_shutup(struct hda_codec *codec)
3541 {
3542         struct alc_spec *spec = codec->spec;
3543         hda_nid_t hp_pin = alc_get_hp_pin(spec);
3544         bool hp_pin_sense;
3545
3546         if (!hp_pin) {
3547                 alc269_shutup(codec);
3548                 return;
3549         }
3550
3551         hp_pin_sense = snd_hda_jack_detect(codec, hp_pin);
3552
3553         alc_write_coef_idx(codec, 0x43, 0x9004);
3554
3555         /*depop hp during suspend*/
3556         alc_write_coef_idx(codec, 0x06, 0x2100);
3557
3558         snd_hda_codec_write(codec, hp_pin, 0,
3559                             AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);
3560
3561         if (hp_pin_sense)
3562                 msleep(100);
3563
3564         if (!spec->no_shutup_pins)
3565                 snd_hda_codec_write(codec, hp_pin, 0,
3566                                     AC_VERB_SET_PIN_WIDGET_CONTROL, 0x0);
3567
3568         alc_update_coef_idx(codec, 0x46, 0, 3 << 12);
3569
3570         if (hp_pin_sense)
3571                 msleep(100);
3572         alc_auto_setup_eapd(codec, false);
3573         alc_shutup_pins(codec);
3574         alc_write_coef_idx(codec, 0x43, 0x9614);
3575 }
3576
3577 static void alc256_init(struct hda_codec *codec)
3578 {
3579         struct alc_spec *spec = codec->spec;
3580         hda_nid_t hp_pin = alc_get_hp_pin(spec);
3581         bool hp_pin_sense;
3582
3583         if (spec->ultra_low_power) {
3584                 alc_update_coef_idx(codec, 0x03, 1<<1, 1<<1);
3585                 alc_update_coef_idx(codec, 0x08, 3<<2, 3<<2);
3586                 alc_update_coef_idx(codec, 0x08, 7<<4, 0);
3587                 alc_update_coef_idx(codec, 0x3b, 1<<15, 0);
3588                 alc_update_coef_idx(codec, 0x0e, 7<<6, 7<<6);
3589                 msleep(30);
3590         }
3591
3592         if (!hp_pin)
3593                 hp_pin = 0x21;
3594
3595         msleep(30);
3596
3597         hp_pin_sense = snd_hda_jack_detect(codec, hp_pin);
3598
3599         if (hp_pin_sense)
3600                 msleep(2);
3601
3602         alc_update_coefex_idx(codec, 0x57, 0x04, 0x0007, 0x1); /* Low power */
3603
3604         snd_hda_codec_write(codec, hp_pin, 0,
3605                             AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);
3606
3607         if (hp_pin_sense || spec->ultra_low_power)
3608                 msleep(85);
3609
3610         snd_hda_codec_write(codec, hp_pin, 0,
3611                             AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT);
3612
3613         if (hp_pin_sense || spec->ultra_low_power)
3614                 msleep(100);
3615
3616         alc_update_coef_idx(codec, 0x46, 3 << 12, 0);
3617         alc_update_coefex_idx(codec, 0x57, 0x04, 0x0007, 0x4); /* Hight power */
3618         alc_update_coefex_idx(codec, 0x53, 0x02, 0x8000, 1 << 15); /* Clear bit */
3619         alc_update_coefex_idx(codec, 0x53, 0x02, 0x8000, 0 << 15);
3620         /*
3621          * Expose headphone mic (or possibly Line In on some machines) instead
3622          * of PC Beep on 1Ah, and disable 1Ah loopback for all outputs. See
3623          * Documentation/sound/hd-audio/realtek-pc-beep.rst for details of
3624          * this register.
3625          */
3626         alc_write_coef_idx(codec, 0x36, 0x5757);
3627 }
3628
3629 static void alc256_shutup(struct hda_codec *codec)
3630 {
3631         struct alc_spec *spec = codec->spec;
3632         hda_nid_t hp_pin = alc_get_hp_pin(spec);
3633         bool hp_pin_sense;
3634
3635         if (!hp_pin)
3636                 hp_pin = 0x21;
3637
3638         alc_update_coefex_idx(codec, 0x57, 0x04, 0x0007, 0x1); /* Low power */
3639         hp_pin_sense = snd_hda_jack_detect(codec, hp_pin);
3640
3641         if (hp_pin_sense)
3642                 msleep(2);
3643
3644         snd_hda_codec_write(codec, hp_pin, 0,
3645                             AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);
3646
3647         if (hp_pin_sense || spec->ultra_low_power)
3648                 msleep(85);
3649
3650         /* 3k pull low control for Headset jack. */
3651         /* NOTE: call this before clearing the pin, otherwise codec stalls */
3652         /* If disable 3k pulldown control for alc257, the Mic detection will not work correctly
3653          * when booting with headset plugged. So skip setting it for the codec alc257
3654          */
3655         if (spec->en_3kpull_low)
3656                 alc_update_coef_idx(codec, 0x46, 0, 3 << 12);
3657
3658         if (!spec->no_shutup_pins)
3659                 snd_hda_codec_write(codec, hp_pin, 0,
3660                                     AC_VERB_SET_PIN_WIDGET_CONTROL, 0x0);
3661
3662         if (hp_pin_sense || spec->ultra_low_power)
3663                 msleep(100);
3664
3665         alc_auto_setup_eapd(codec, false);
3666         alc_shutup_pins(codec);
3667         if (spec->ultra_low_power) {
3668                 msleep(50);
3669                 alc_update_coef_idx(codec, 0x03, 1<<1, 0);
3670                 alc_update_coef_idx(codec, 0x08, 7<<4, 7<<4);
3671                 alc_update_coef_idx(codec, 0x08, 3<<2, 0);
3672                 alc_update_coef_idx(codec, 0x3b, 1<<15, 1<<15);
3673                 alc_update_coef_idx(codec, 0x0e, 7<<6, 0);
3674                 msleep(30);
3675         }
3676 }
3677
3678 static void alc285_hp_init(struct hda_codec *codec)
3679 {
3680         struct alc_spec *spec = codec->spec;
3681         hda_nid_t hp_pin = alc_get_hp_pin(spec);
3682         int i, val;
3683         int coef38, coef0d, coef36;
3684
3685         alc_update_coef_idx(codec, 0x4a, 1<<15, 1<<15); /* Reset HP JD */
3686         coef38 = alc_read_coef_idx(codec, 0x38); /* Amp control */
3687         coef0d = alc_read_coef_idx(codec, 0x0d); /* Digital Misc control */
3688         coef36 = alc_read_coef_idx(codec, 0x36); /* Passthrough Control */
3689         alc_update_coef_idx(codec, 0x38, 1<<4, 0x0);
3690         alc_update_coef_idx(codec, 0x0d, 0x110, 0x0);
3691
3692         alc_update_coef_idx(codec, 0x67, 0xf000, 0x3000);
3693
3694         if (hp_pin)
3695                 snd_hda_codec_write(codec, hp_pin, 0,
3696                             AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);
3697
3698         msleep(130);
3699         alc_update_coef_idx(codec, 0x36, 1<<14, 1<<14);
3700         alc_update_coef_idx(codec, 0x36, 1<<13, 0x0);
3701
3702         if (hp_pin)
3703                 snd_hda_codec_write(codec, hp_pin, 0,
3704                             AC_VERB_SET_PIN_WIDGET_CONTROL, 0x0);
3705         msleep(10);
3706         alc_write_coef_idx(codec, 0x67, 0x0); /* Set HP depop to manual mode */
3707         alc_write_coefex_idx(codec, 0x58, 0x00, 0x7880);
3708         alc_write_coefex_idx(codec, 0x58, 0x0f, 0xf049);
3709         alc_update_coefex_idx(codec, 0x58, 0x03, 0x00f0, 0x00c0);
3710
3711         alc_write_coefex_idx(codec, 0x58, 0x00, 0xf888); /* HP depop procedure start */
3712         val = alc_read_coefex_idx(codec, 0x58, 0x00);
3713         for (i = 0; i < 20 && val & 0x8000; i++) {
3714                 msleep(50);
3715                 val = alc_read_coefex_idx(codec, 0x58, 0x00);
3716         } /* Wait for depop procedure finish  */
3717
3718         alc_write_coefex_idx(codec, 0x58, 0x00, val); /* write back the result */
3719         alc_update_coef_idx(codec, 0x38, 1<<4, coef38);
3720         alc_update_coef_idx(codec, 0x0d, 0x110, coef0d);
3721         alc_update_coef_idx(codec, 0x36, 3<<13, coef36);
3722
3723         msleep(50);
3724         alc_update_coef_idx(codec, 0x4a, 1<<15, 0);
3725 }
3726
3727 static void alc225_init(struct hda_codec *codec)
3728 {
3729         struct alc_spec *spec = codec->spec;
3730         hda_nid_t hp_pin = alc_get_hp_pin(spec);
3731         bool hp1_pin_sense, hp2_pin_sense;
3732
3733         if (spec->ultra_low_power) {
3734                 alc_update_coef_idx(codec, 0x08, 0x0f << 2, 3<<2);
3735                 alc_update_coef_idx(codec, 0x0e, 7<<6, 7<<6);
3736                 alc_update_coef_idx(codec, 0x33, 1<<11, 0);
3737                 msleep(30);
3738         }
3739
3740         if (spec->codec_variant != ALC269_TYPE_ALC287 &&
3741                 spec->codec_variant != ALC269_TYPE_ALC245)
3742                 /* required only at boot or S3 and S4 resume time */
3743                 if (!spec->done_hp_init ||
3744                         is_s3_resume(codec) ||
3745                         is_s4_resume(codec)) {
3746                         alc285_hp_init(codec);
3747                         spec->done_hp_init = true;
3748                 }
3749
3750         if (!hp_pin)
3751                 hp_pin = 0x21;
3752         msleep(30);
3753
3754         hp1_pin_sense = snd_hda_jack_detect(codec, hp_pin);
3755         hp2_pin_sense = snd_hda_jack_detect(codec, 0x16);
3756
3757         if (hp1_pin_sense || hp2_pin_sense)
3758                 msleep(2);
3759
3760         alc_update_coefex_idx(codec, 0x57, 0x04, 0x0007, 0x1); /* Low power */
3761
3762         if (hp1_pin_sense || spec->ultra_low_power)
3763                 snd_hda_codec_write(codec, hp_pin, 0,
3764                             AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);
3765         if (hp2_pin_sense)
3766                 snd_hda_codec_write(codec, 0x16, 0,
3767                             AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);
3768
3769         if (hp1_pin_sense || hp2_pin_sense || spec->ultra_low_power)
3770                 msleep(85);
3771
3772         if (hp1_pin_sense || spec->ultra_low_power)
3773                 snd_hda_codec_write(codec, hp_pin, 0,
3774                             AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT);
3775         if (hp2_pin_sense)
3776                 snd_hda_codec_write(codec, 0x16, 0,
3777                             AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT);
3778
3779         if (hp1_pin_sense || hp2_pin_sense || spec->ultra_low_power)
3780                 msleep(100);
3781
3782         alc_update_coef_idx(codec, 0x4a, 3 << 10, 0);
3783         alc_update_coefex_idx(codec, 0x57, 0x04, 0x0007, 0x4); /* Hight power */
3784 }
3785
3786 static void alc225_shutup(struct hda_codec *codec)
3787 {
3788         struct alc_spec *spec = codec->spec;
3789         hda_nid_t hp_pin = alc_get_hp_pin(spec);
3790         bool hp1_pin_sense, hp2_pin_sense;
3791
3792         if (!hp_pin)
3793                 hp_pin = 0x21;
3794
3795         alc_disable_headset_jack_key(codec);
3796         /* 3k pull low control for Headset jack. */
3797         alc_update_coef_idx(codec, 0x4a, 0, 3 << 10);
3798
3799         hp1_pin_sense = snd_hda_jack_detect(codec, hp_pin);
3800         hp2_pin_sense = snd_hda_jack_detect(codec, 0x16);
3801
3802         if (hp1_pin_sense || hp2_pin_sense)
3803                 msleep(2);
3804
3805         if (hp1_pin_sense || spec->ultra_low_power)
3806                 snd_hda_codec_write(codec, hp_pin, 0,
3807                             AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);
3808         if (hp2_pin_sense)
3809                 snd_hda_codec_write(codec, 0x16, 0,
3810                             AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);
3811
3812         if (hp1_pin_sense || hp2_pin_sense || spec->ultra_low_power)
3813                 msleep(85);
3814
3815         if (hp1_pin_sense || spec->ultra_low_power)
3816                 snd_hda_codec_write(codec, hp_pin, 0,
3817                             AC_VERB_SET_PIN_WIDGET_CONTROL, 0x0);
3818         if (hp2_pin_sense)
3819                 snd_hda_codec_write(codec, 0x16, 0,
3820                             AC_VERB_SET_PIN_WIDGET_CONTROL, 0x0);
3821
3822         if (hp1_pin_sense || hp2_pin_sense || spec->ultra_low_power)
3823                 msleep(100);
3824
3825         alc_auto_setup_eapd(codec, false);
3826         alc_shutup_pins(codec);
3827         if (spec->ultra_low_power) {
3828                 msleep(50);
3829                 alc_update_coef_idx(codec, 0x08, 0x0f << 2, 0x0c << 2);
3830                 alc_update_coef_idx(codec, 0x0e, 7<<6, 0);
3831                 alc_update_coef_idx(codec, 0x33, 1<<11, 1<<11);
3832                 alc_update_coef_idx(codec, 0x4a, 3<<4, 2<<4);
3833                 msleep(30);
3834         }
3835
3836         alc_update_coef_idx(codec, 0x4a, 3 << 10, 0);
3837         alc_enable_headset_jack_key(codec);
3838 }
3839
3840 static void alc_default_init(struct hda_codec *codec)
3841 {
3842         struct alc_spec *spec = codec->spec;
3843         hda_nid_t hp_pin = alc_get_hp_pin(spec);
3844         bool hp_pin_sense;
3845
3846         if (!hp_pin)
3847                 return;
3848
3849         msleep(30);
3850
3851         hp_pin_sense = snd_hda_jack_detect(codec, hp_pin);
3852
3853         if (hp_pin_sense)
3854                 msleep(2);
3855
3856         snd_hda_codec_write(codec, hp_pin, 0,
3857                             AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);
3858
3859         if (hp_pin_sense)
3860                 msleep(85);
3861
3862         snd_hda_codec_write(codec, hp_pin, 0,
3863                             AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT);
3864
3865         if (hp_pin_sense)
3866                 msleep(100);
3867 }
3868
3869 static void alc_default_shutup(struct hda_codec *codec)
3870 {
3871         struct alc_spec *spec = codec->spec;
3872         hda_nid_t hp_pin = alc_get_hp_pin(spec);
3873         bool hp_pin_sense;
3874
3875         if (!hp_pin) {
3876                 alc269_shutup(codec);
3877                 return;
3878         }
3879
3880         hp_pin_sense = snd_hda_jack_detect(codec, hp_pin);
3881
3882         if (hp_pin_sense)
3883                 msleep(2);
3884
3885         snd_hda_codec_write(codec, hp_pin, 0,
3886                             AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);
3887
3888         if (hp_pin_sense)
3889                 msleep(85);
3890
3891         if (!spec->no_shutup_pins)
3892                 snd_hda_codec_write(codec, hp_pin, 0,
3893                                     AC_VERB_SET_PIN_WIDGET_CONTROL, 0x0);
3894
3895         if (hp_pin_sense)
3896                 msleep(100);
3897
3898         alc_auto_setup_eapd(codec, false);
3899         alc_shutup_pins(codec);
3900 }
3901
3902 static void alc294_hp_init(struct hda_codec *codec)
3903 {
3904         struct alc_spec *spec = codec->spec;
3905         hda_nid_t hp_pin = alc_get_hp_pin(spec);
3906         int i, val;
3907
3908         if (!hp_pin)
3909                 return;
3910
3911         snd_hda_codec_write(codec, hp_pin, 0,
3912                             AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);
3913
3914         msleep(100);
3915
3916         if (!spec->no_shutup_pins)
3917                 snd_hda_codec_write(codec, hp_pin, 0,
3918                                     AC_VERB_SET_PIN_WIDGET_CONTROL, 0x0);
3919
3920         alc_update_coef_idx(codec, 0x6f, 0x000f, 0);/* Set HP depop to manual mode */
3921         alc_update_coefex_idx(codec, 0x58, 0x00, 0x8000, 0x8000); /* HP depop procedure start */
3922
3923         /* Wait for depop procedure finish  */
3924         val = alc_read_coefex_idx(codec, 0x58, 0x01);
3925         for (i = 0; i < 20 && val & 0x0080; i++) {
3926                 msleep(50);
3927                 val = alc_read_coefex_idx(codec, 0x58, 0x01);
3928         }
3929         /* Set HP depop to auto mode */
3930         alc_update_coef_idx(codec, 0x6f, 0x000f, 0x000b);
3931         msleep(50);
3932 }
3933
3934 static void alc294_init(struct hda_codec *codec)
3935 {
3936         struct alc_spec *spec = codec->spec;
3937
3938         /* required only at boot or S4 resume time */
3939         if (!spec->done_hp_init ||
3940             codec->core.dev.power.power_state.event == PM_EVENT_RESTORE) {
3941                 alc294_hp_init(codec);
3942                 spec->done_hp_init = true;
3943         }
3944         alc_default_init(codec);
3945 }
3946
3947 static void alc5505_coef_set(struct hda_codec *codec, unsigned int index_reg,
3948                              unsigned int val)
3949 {
3950         snd_hda_codec_write(codec, 0x51, 0, AC_VERB_SET_COEF_INDEX, index_reg >> 1);
3951         snd_hda_codec_write(codec, 0x51, 0, AC_VERB_SET_PROC_COEF, val & 0xffff); /* LSB */
3952         snd_hda_codec_write(codec, 0x51, 0, AC_VERB_SET_PROC_COEF, val >> 16); /* MSB */
3953 }
3954
3955 static int alc5505_coef_get(struct hda_codec *codec, unsigned int index_reg)
3956 {
3957         unsigned int val;
3958
3959         snd_hda_codec_write(codec, 0x51, 0, AC_VERB_SET_COEF_INDEX, index_reg >> 1);
3960         val = snd_hda_codec_read(codec, 0x51, 0, AC_VERB_GET_PROC_COEF, 0)
3961                 & 0xffff;
3962         val |= snd_hda_codec_read(codec, 0x51, 0, AC_VERB_GET_PROC_COEF, 0)
3963                 << 16;
3964         return val;
3965 }
3966
3967 static void alc5505_dsp_halt(struct hda_codec *codec)
3968 {
3969         unsigned int val;
3970
3971         alc5505_coef_set(codec, 0x3000, 0x000c); /* DSP CPU stop */
3972         alc5505_coef_set(codec, 0x880c, 0x0008); /* DDR enter self refresh */
3973         alc5505_coef_set(codec, 0x61c0, 0x11110080); /* Clock control for PLL and CPU */
3974         alc5505_coef_set(codec, 0x6230, 0xfc0d4011); /* Disable Input OP */
3975         alc5505_coef_set(codec, 0x61b4, 0x040a2b03); /* Stop PLL2 */
3976         alc5505_coef_set(codec, 0x61b0, 0x00005b17); /* Stop PLL1 */
3977         alc5505_coef_set(codec, 0x61b8, 0x04133303); /* Stop PLL3 */
3978         val = alc5505_coef_get(codec, 0x6220);
3979         alc5505_coef_set(codec, 0x6220, (val | 0x3000)); /* switch Ringbuffer clock to DBUS clock */
3980 }
3981
3982 static void alc5505_dsp_back_from_halt(struct hda_codec *codec)
3983 {
3984         alc5505_coef_set(codec, 0x61b8, 0x04133302);
3985         alc5505_coef_set(codec, 0x61b0, 0x00005b16);
3986         alc5505_coef_set(codec, 0x61b4, 0x040a2b02);
3987         alc5505_coef_set(codec, 0x6230, 0xf80d4011);
3988         alc5505_coef_set(codec, 0x6220, 0x2002010f);
3989         alc5505_coef_set(codec, 0x880c, 0x00000004);
3990 }
3991
3992 static void alc5505_dsp_init(struct hda_codec *codec)
3993 {
3994         unsigned int val;
3995
3996         alc5505_dsp_halt(codec);
3997         alc5505_dsp_back_from_halt(codec);
3998         alc5505_coef_set(codec, 0x61b0, 0x5b14); /* PLL1 control */
3999         alc5505_coef_set(codec, 0x61b0, 0x5b16);
4000         alc5505_coef_set(codec, 0x61b4, 0x04132b00); /* PLL2 control */
4001         alc5505_coef_set(codec, 0x61b4, 0x04132b02);
4002         alc5505_coef_set(codec, 0x61b8, 0x041f3300); /* PLL3 control*/
4003         alc5505_coef_set(codec, 0x61b8, 0x041f3302);
4004         snd_hda_codec_write(codec, 0x51, 0, AC_VERB_SET_CODEC_RESET, 0); /* Function reset */
4005         alc5505_coef_set(codec, 0x61b8, 0x041b3302);
4006         alc5505_coef_set(codec, 0x61b8, 0x04173302);
4007         alc5505_coef_set(codec, 0x61b8, 0x04163302);
4008         alc5505_coef_set(codec, 0x8800, 0x348b328b); /* DRAM control */
4009         alc5505_coef_set(codec, 0x8808, 0x00020022); /* DRAM control */
4010         alc5505_coef_set(codec, 0x8818, 0x00000400); /* DRAM control */
4011
4012         val = alc5505_coef_get(codec, 0x6200) >> 16; /* Read revision ID */
4013         if (val <= 3)
4014                 alc5505_coef_set(codec, 0x6220, 0x2002010f); /* I/O PAD Configuration */
4015         else
4016                 alc5505_coef_set(codec, 0x6220, 0x6002018f);
4017
4018         alc5505_coef_set(codec, 0x61ac, 0x055525f0); /**/
4019         alc5505_coef_set(codec, 0x61c0, 0x12230080); /* Clock control */
4020         alc5505_coef_set(codec, 0x61b4, 0x040e2b02); /* PLL2 control */
4021         alc5505_coef_set(codec, 0x61bc, 0x010234f8); /* OSC Control */
4022         alc5505_coef_set(codec, 0x880c, 0x00000004); /* DRAM Function control */
4023         alc5505_coef_set(codec, 0x880c, 0x00000003);
4024         alc5505_coef_set(codec, 0x880c, 0x00000010);
4025
4026 #ifdef HALT_REALTEK_ALC5505
4027         alc5505_dsp_halt(codec);
4028 #endif
4029 }
4030
4031 #ifdef HALT_REALTEK_ALC5505
4032 #define alc5505_dsp_suspend(codec)      do { } while (0) /* NOP */
4033 #define alc5505_dsp_resume(codec)       do { } while (0) /* NOP */
4034 #else
4035 #define alc5505_dsp_suspend(codec)      alc5505_dsp_halt(codec)
4036 #define alc5505_dsp_resume(codec)       alc5505_dsp_back_from_halt(codec)
4037 #endif
4038
4039 #ifdef CONFIG_PM
4040 static int alc269_suspend(struct hda_codec *codec)
4041 {
4042         struct alc_spec *spec = codec->spec;
4043
4044         if (spec->has_alc5505_dsp)
4045                 alc5505_dsp_suspend(codec);
4046
4047         return alc_suspend(codec);
4048 }
4049
4050 static int alc269_resume(struct hda_codec *codec)
4051 {
4052         struct alc_spec *spec = codec->spec;
4053
4054         if (spec->codec_variant == ALC269_TYPE_ALC269VB)
4055                 alc269vb_toggle_power_output(codec, 0);
4056         if (spec->codec_variant == ALC269_TYPE_ALC269VB &&
4057                         (alc_get_coef0(codec) & 0x00ff) == 0x018) {
4058                 msleep(150);
4059         }
4060
4061         codec->patch_ops.init(codec);
4062
4063         if (spec->codec_variant == ALC269_TYPE_ALC269VB)
4064                 alc269vb_toggle_power_output(codec, 1);
4065         if (spec->codec_variant == ALC269_TYPE_ALC269VB &&
4066                         (alc_get_coef0(codec) & 0x00ff) == 0x017) {
4067                 msleep(200);
4068         }
4069
4070         snd_hda_regmap_sync(codec);
4071         hda_call_check_power_status(codec, 0x01);
4072
4073         /* on some machine, the BIOS will clear the codec gpio data when enter
4074          * suspend, and won't restore the data after resume, so we restore it
4075          * in the driver.
4076          */
4077         if (spec->gpio_data)
4078                 alc_write_gpio_data(codec);
4079
4080         if (spec->has_alc5505_dsp)
4081                 alc5505_dsp_resume(codec);
4082
4083         return 0;
4084 }
4085 #endif /* CONFIG_PM */
4086
4087 static void alc269_fixup_pincfg_no_hp_to_lineout(struct hda_codec *codec,
4088                                                  const struct hda_fixup *fix, int action)
4089 {
4090         struct alc_spec *spec = codec->spec;
4091
4092         if (action == HDA_FIXUP_ACT_PRE_PROBE)
4093                 spec->parse_flags = HDA_PINCFG_NO_HP_FIXUP;
4094 }
4095
4096 static void alc269_fixup_pincfg_U7x7_headset_mic(struct hda_codec *codec,
4097                                                  const struct hda_fixup *fix,
4098                                                  int action)
4099 {
4100         unsigned int cfg_headphone = snd_hda_codec_get_pincfg(codec, 0x21);
4101         unsigned int cfg_headset_mic = snd_hda_codec_get_pincfg(codec, 0x19);
4102
4103         if (cfg_headphone && cfg_headset_mic == 0x411111f0)
4104                 snd_hda_codec_set_pincfg(codec, 0x19,
4105                         (cfg_headphone & ~AC_DEFCFG_DEVICE) |
4106                         (AC_JACK_MIC_IN << AC_DEFCFG_DEVICE_SHIFT));
4107 }
4108
4109 static void alc269_fixup_hweq(struct hda_codec *codec,
4110                                const struct hda_fixup *fix, int action)
4111 {
4112         if (action == HDA_FIXUP_ACT_INIT)
4113                 alc_update_coef_idx(codec, 0x1e, 0, 0x80);
4114 }
4115
4116 static void alc269_fixup_headset_mic(struct hda_codec *codec,
4117                                        const struct hda_fixup *fix, int action)
4118 {
4119         struct alc_spec *spec = codec->spec;
4120
4121         if (action == HDA_FIXUP_ACT_PRE_PROBE)
4122                 spec->parse_flags |= HDA_PINCFG_HEADSET_MIC;
4123 }
4124
4125 static void alc271_fixup_dmic(struct hda_codec *codec,
4126                               const struct hda_fixup *fix, int action)
4127 {
4128         static const struct hda_verb verbs[] = {
4129                 {0x20, AC_VERB_SET_COEF_INDEX, 0x0d},
4130                 {0x20, AC_VERB_SET_PROC_COEF, 0x4000},
4131                 {}
4132         };
4133         unsigned int cfg;
4134
4135         if (strcmp(codec->core.chip_name, "ALC271X") &&
4136             strcmp(codec->core.chip_name, "ALC269VB"))
4137                 return;
4138         cfg = snd_hda_codec_get_pincfg(codec, 0x12);
4139         if (get_defcfg_connect(cfg) == AC_JACK_PORT_FIXED)
4140                 snd_hda_sequence_write(codec, verbs);
4141 }
4142
4143 /* Fix the speaker amp after resume, etc */
4144 static void alc269vb_fixup_aspire_e1_coef(struct hda_codec *codec,
4145                                           const struct hda_fixup *fix,
4146                                           int action)
4147 {
4148         if (action == HDA_FIXUP_ACT_INIT)
4149                 alc_update_coef_idx(codec, 0x0d, 0x6000, 0x6000);
4150 }
4151
4152 static void alc269_fixup_pcm_44k(struct hda_codec *codec,
4153                                  const struct hda_fixup *fix, int action)
4154 {
4155         struct alc_spec *spec = codec->spec;
4156
4157         if (action != HDA_FIXUP_ACT_PROBE)
4158                 return;
4159
4160         /* Due to a hardware problem on Lenovo Ideadpad, we need to
4161          * fix the sample rate of analog I/O to 44.1kHz
4162          */
4163         spec->gen.stream_analog_playback = &alc269_44k_pcm_analog_playback;
4164         spec->gen.stream_analog_capture = &alc269_44k_pcm_analog_capture;
4165 }
4166
4167 static void alc269_fixup_stereo_dmic(struct hda_codec *codec,
4168                                      const struct hda_fixup *fix, int action)
4169 {
4170         /* The digital-mic unit sends PDM (differential signal) instead of
4171          * the standard PCM, thus you can't record a valid mono stream as is.
4172          * Below is a workaround specific to ALC269 to control the dmic
4173          * signal source as mono.
4174          */
4175         if (action == HDA_FIXUP_ACT_INIT)
4176                 alc_update_coef_idx(codec, 0x07, 0, 0x80);
4177 }
4178
4179 static void alc269_quanta_automute(struct hda_codec *codec)
4180 {
4181         snd_hda_gen_update_outputs(codec);
4182
4183         alc_write_coef_idx(codec, 0x0c, 0x680);
4184         alc_write_coef_idx(codec, 0x0c, 0x480);
4185 }
4186
4187 static void alc269_fixup_quanta_mute(struct hda_codec *codec,
4188                                      const struct hda_fixup *fix, int action)
4189 {
4190         struct alc_spec *spec = codec->spec;
4191         if (action != HDA_FIXUP_ACT_PROBE)
4192                 return;
4193         spec->gen.automute_hook = alc269_quanta_automute;
4194 }
4195
4196 static void alc269_x101_hp_automute_hook(struct hda_codec *codec,
4197                                          struct hda_jack_callback *jack)
4198 {
4199         struct alc_spec *spec = codec->spec;
4200         int vref;
4201         msleep(200);
4202         snd_hda_gen_hp_automute(codec, jack);
4203
4204         vref = spec->gen.hp_jack_present ? PIN_VREF80 : 0;
4205         msleep(100);
4206         snd_hda_codec_write(codec, 0x18, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
4207                             vref);
4208         msleep(500);
4209         snd_hda_codec_write(codec, 0x18, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
4210                             vref);
4211 }
4212
4213 /*
4214  * Magic sequence to make Huawei Matebook X right speaker working (bko#197801)
4215  */
4216 struct hda_alc298_mbxinit {
4217         unsigned char value_0x23;
4218         unsigned char value_0x25;
4219 };
4220
4221 static void alc298_huawei_mbx_stereo_seq(struct hda_codec *codec,
4222                                          const struct hda_alc298_mbxinit *initval,
4223                                          bool first)
4224 {
4225         snd_hda_codec_write(codec, 0x06, 0, AC_VERB_SET_DIGI_CONVERT_3, 0x0);
4226         alc_write_coef_idx(codec, 0x26, 0xb000);
4227
4228         if (first)
4229                 snd_hda_codec_write(codec, 0x21, 0, AC_VERB_GET_PIN_SENSE, 0x0);
4230
4231         snd_hda_codec_write(codec, 0x6, 0, AC_VERB_SET_DIGI_CONVERT_3, 0x80);
4232         alc_write_coef_idx(codec, 0x26, 0xf000);
4233         alc_write_coef_idx(codec, 0x23, initval->value_0x23);
4234
4235         if (initval->value_0x23 != 0x1e)
4236                 alc_write_coef_idx(codec, 0x25, initval->value_0x25);
4237
4238         snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_COEF_INDEX, 0x26);
4239         snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_PROC_COEF, 0xb010);
4240 }
4241
4242 static void alc298_fixup_huawei_mbx_stereo(struct hda_codec *codec,
4243                                            const struct hda_fixup *fix,
4244                                            int action)
4245 {
4246         /* Initialization magic */
4247         static const struct hda_alc298_mbxinit dac_init[] = {
4248                 {0x0c, 0x00}, {0x0d, 0x00}, {0x0e, 0x00}, {0x0f, 0x00},
4249                 {0x10, 0x00}, {0x1a, 0x40}, {0x1b, 0x82}, {0x1c, 0x00},
4250                 {0x1d, 0x00}, {0x1e, 0x00}, {0x1f, 0x00},
4251                 {0x20, 0xc2}, {0x21, 0xc8}, {0x22, 0x26}, {0x23, 0x24},
4252                 {0x27, 0xff}, {0x28, 0xff}, {0x29, 0xff}, {0x2a, 0x8f},
4253                 {0x2b, 0x02}, {0x2c, 0x48}, {0x2d, 0x34}, {0x2e, 0x00},
4254                 {0x2f, 0x00},
4255                 {0x30, 0x00}, {0x31, 0x00}, {0x32, 0x00}, {0x33, 0x00},
4256                 {0x34, 0x00}, {0x35, 0x01}, {0x36, 0x93}, {0x37, 0x0c},
4257                 {0x38, 0x00}, {0x39, 0x00}, {0x3a, 0xf8}, {0x38, 0x80},
4258                 {}
4259         };
4260         const struct hda_alc298_mbxinit *seq;
4261
4262         if (action != HDA_FIXUP_ACT_INIT)
4263                 return;
4264
4265         /* Start */
4266         snd_hda_codec_write(codec, 0x06, 0, AC_VERB_SET_DIGI_CONVERT_3, 0x00);
4267         snd_hda_codec_write(codec, 0x06, 0, AC_VERB_SET_DIGI_CONVERT_3, 0x80);
4268         alc_write_coef_idx(codec, 0x26, 0xf000);
4269         alc_write_coef_idx(codec, 0x22, 0x31);
4270         alc_write_coef_idx(codec, 0x23, 0x0b);
4271         alc_write_coef_idx(codec, 0x25, 0x00);
4272         snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_COEF_INDEX, 0x26);
4273         snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_PROC_COEF, 0xb010);
4274
4275         for (seq = dac_init; seq->value_0x23; seq++)
4276                 alc298_huawei_mbx_stereo_seq(codec, seq, seq == dac_init);
4277 }
4278
4279 static void alc269_fixup_x101_headset_mic(struct hda_codec *codec,
4280                                      const struct hda_fixup *fix, int action)
4281 {
4282         struct alc_spec *spec = codec->spec;
4283         if (action == HDA_FIXUP_ACT_PRE_PROBE) {
4284                 spec->parse_flags |= HDA_PINCFG_HEADSET_MIC;
4285                 spec->gen.hp_automute_hook = alc269_x101_hp_automute_hook;
4286         }
4287 }
4288
4289 static void alc_update_vref_led(struct hda_codec *codec, hda_nid_t pin,
4290                                 bool polarity, bool on)
4291 {
4292         unsigned int pinval;
4293
4294         if (!pin)
4295                 return;
4296         if (polarity)
4297                 on = !on;
4298         pinval = snd_hda_codec_get_pin_target(codec, pin);
4299         pinval &= ~AC_PINCTL_VREFEN;
4300         pinval |= on ? AC_PINCTL_VREF_80 : AC_PINCTL_VREF_HIZ;
4301         /* temporarily power up/down for setting VREF */
4302         snd_hda_power_up_pm(codec);
4303         snd_hda_set_pin_ctl_cache(codec, pin, pinval);
4304         snd_hda_power_down_pm(codec);
4305 }
4306
4307 /* update mute-LED according to the speaker mute state via mic VREF pin */
4308 static int vref_mute_led_set(struct led_classdev *led_cdev,
4309                              enum led_brightness brightness)
4310 {
4311         struct hda_codec *codec = dev_to_hda_codec(led_cdev->dev->parent);
4312         struct alc_spec *spec = codec->spec;
4313
4314         alc_update_vref_led(codec, spec->mute_led_nid,
4315                             spec->mute_led_polarity, brightness);
4316         return 0;
4317 }
4318
4319 /* Make sure the led works even in runtime suspend */
4320 static unsigned int led_power_filter(struct hda_codec *codec,
4321                                                   hda_nid_t nid,
4322                                                   unsigned int power_state)
4323 {
4324         struct alc_spec *spec = codec->spec;
4325
4326         if (power_state != AC_PWRST_D3 || nid == 0 ||
4327             (nid != spec->mute_led_nid && nid != spec->cap_mute_led_nid))
4328                 return power_state;
4329
4330         /* Set pin ctl again, it might have just been set to 0 */
4331         snd_hda_set_pin_ctl(codec, nid,
4332                             snd_hda_codec_get_pin_target(codec, nid));
4333
4334         return snd_hda_gen_path_power_filter(codec, nid, power_state);
4335 }
4336
4337 static void alc269_fixup_hp_mute_led(struct hda_codec *codec,
4338                                      const struct hda_fixup *fix, int action)
4339 {
4340         struct alc_spec *spec = codec->spec;
4341         const struct dmi_device *dev = NULL;
4342
4343         if (action != HDA_FIXUP_ACT_PRE_PROBE)
4344                 return;
4345
4346         while ((dev = dmi_find_device(DMI_DEV_TYPE_OEM_STRING, NULL, dev))) {
4347                 int pol, pin;
4348                 if (sscanf(dev->name, "HP_Mute_LED_%d_%x", &pol, &pin) != 2)
4349                         continue;
4350                 if (pin < 0x0a || pin >= 0x10)
4351                         break;
4352                 spec->mute_led_polarity = pol;
4353                 spec->mute_led_nid = pin - 0x0a + 0x18;
4354                 snd_hda_gen_add_mute_led_cdev(codec, vref_mute_led_set);
4355                 codec->power_filter = led_power_filter;
4356                 codec_dbg(codec,
4357                           "Detected mute LED for %x:%d\n", spec->mute_led_nid,
4358                            spec->mute_led_polarity);
4359                 break;
4360         }
4361 }
4362
4363 static void alc269_fixup_hp_mute_led_micx(struct hda_codec *codec,
4364                                           const struct hda_fixup *fix,
4365                                           int action, hda_nid_t pin)
4366 {
4367         struct alc_spec *spec = codec->spec;
4368
4369         if (action == HDA_FIXUP_ACT_PRE_PROBE) {
4370                 spec->mute_led_polarity = 0;
4371                 spec->mute_led_nid = pin;
4372                 snd_hda_gen_add_mute_led_cdev(codec, vref_mute_led_set);
4373                 codec->power_filter = led_power_filter;
4374         }
4375 }
4376
4377 static void alc269_fixup_hp_mute_led_mic1(struct hda_codec *codec,
4378                                 const struct hda_fixup *fix, int action)
4379 {
4380         alc269_fixup_hp_mute_led_micx(codec, fix, action, 0x18);
4381 }
4382
4383 static void alc269_fixup_hp_mute_led_mic2(struct hda_codec *codec,
4384                                 const struct hda_fixup *fix, int action)
4385 {
4386         alc269_fixup_hp_mute_led_micx(codec, fix, action, 0x19);
4387 }
4388
4389 static void alc269_fixup_hp_mute_led_mic3(struct hda_codec *codec,
4390                                 const struct hda_fixup *fix, int action)
4391 {
4392         alc269_fixup_hp_mute_led_micx(codec, fix, action, 0x1b);
4393 }
4394
4395 /* update LED status via GPIO */
4396 static void alc_update_gpio_led(struct hda_codec *codec, unsigned int mask,
4397                                 int polarity, bool enabled)
4398 {
4399         if (polarity)
4400                 enabled = !enabled;
4401         alc_update_gpio_data(codec, mask, !enabled); /* muted -> LED on */
4402 }
4403
4404 /* turn on/off mute LED via GPIO per vmaster hook */
4405 static int gpio_mute_led_set(struct led_classdev *led_cdev,
4406                              enum led_brightness brightness)
4407 {
4408         struct hda_codec *codec = dev_to_hda_codec(led_cdev->dev->parent);
4409         struct alc_spec *spec = codec->spec;
4410
4411         alc_update_gpio_led(codec, spec->gpio_mute_led_mask,
4412                             spec->mute_led_polarity, !brightness);
4413         return 0;
4414 }
4415
4416 /* turn on/off mic-mute LED via GPIO per capture hook */
4417 static int micmute_led_set(struct led_classdev *led_cdev,
4418                            enum led_brightness brightness)
4419 {
4420         struct hda_codec *codec = dev_to_hda_codec(led_cdev->dev->parent);
4421         struct alc_spec *spec = codec->spec;
4422
4423         alc_update_gpio_led(codec, spec->gpio_mic_led_mask,
4424                             spec->micmute_led_polarity, !brightness);
4425         return 0;
4426 }
4427
4428 /* setup mute and mic-mute GPIO bits, add hooks appropriately */
4429 static void alc_fixup_hp_gpio_led(struct hda_codec *codec,
4430                                   int action,
4431                                   unsigned int mute_mask,
4432                                   unsigned int micmute_mask)
4433 {
4434         struct alc_spec *spec = codec->spec;
4435
4436         alc_fixup_gpio(codec, action, mute_mask | micmute_mask);
4437
4438         if (action != HDA_FIXUP_ACT_PRE_PROBE)
4439                 return;
4440         if (mute_mask) {
4441                 spec->gpio_mute_led_mask = mute_mask;
4442                 snd_hda_gen_add_mute_led_cdev(codec, gpio_mute_led_set);
4443         }
4444         if (micmute_mask) {
4445                 spec->gpio_mic_led_mask = micmute_mask;
4446                 snd_hda_gen_add_micmute_led_cdev(codec, micmute_led_set);
4447         }
4448 }
4449
4450 static void alc236_fixup_hp_gpio_led(struct hda_codec *codec,
4451                                 const struct hda_fixup *fix, int action)
4452 {
4453         alc_fixup_hp_gpio_led(codec, action, 0x02, 0x01);
4454 }
4455
4456 static void alc269_fixup_hp_gpio_led(struct hda_codec *codec,
4457                                 const struct hda_fixup *fix, int action)
4458 {
4459         alc_fixup_hp_gpio_led(codec, action, 0x08, 0x10);
4460 }
4461
4462 static void alc285_fixup_hp_gpio_led(struct hda_codec *codec,
4463                                 const struct hda_fixup *fix, int action)
4464 {
4465         alc_fixup_hp_gpio_led(codec, action, 0x04, 0x01);
4466 }
4467
4468 static void alc286_fixup_hp_gpio_led(struct hda_codec *codec,
4469                                 const struct hda_fixup *fix, int action)
4470 {
4471         alc_fixup_hp_gpio_led(codec, action, 0x02, 0x20);
4472 }
4473
4474 static void alc287_fixup_hp_gpio_led(struct hda_codec *codec,
4475                                 const struct hda_fixup *fix, int action)
4476 {
4477         alc_fixup_hp_gpio_led(codec, action, 0x10, 0);
4478 }
4479
4480 static void alc245_fixup_hp_gpio_led(struct hda_codec *codec,
4481                                 const struct hda_fixup *fix, int action)
4482 {
4483         struct alc_spec *spec = codec->spec;
4484
4485         if (action == HDA_FIXUP_ACT_PRE_PROBE)
4486                 spec->micmute_led_polarity = 1;
4487         alc_fixup_hp_gpio_led(codec, action, 0, 0x04);
4488 }
4489
4490 /* turn on/off mic-mute LED per capture hook via VREF change */
4491 static int vref_micmute_led_set(struct led_classdev *led_cdev,
4492                                 enum led_brightness brightness)
4493 {
4494         struct hda_codec *codec = dev_to_hda_codec(led_cdev->dev->parent);
4495         struct alc_spec *spec = codec->spec;
4496
4497         alc_update_vref_led(codec, spec->cap_mute_led_nid,
4498                             spec->micmute_led_polarity, brightness);
4499         return 0;
4500 }
4501
4502 static void alc269_fixup_hp_gpio_mic1_led(struct hda_codec *codec,
4503                                 const struct hda_fixup *fix, int action)
4504 {
4505         struct alc_spec *spec = codec->spec;
4506
4507         alc_fixup_hp_gpio_led(codec, action, 0x08, 0);
4508         if (action == HDA_FIXUP_ACT_PRE_PROBE) {
4509                 /* Like hp_gpio_mic1_led, but also needs GPIO4 low to
4510                  * enable headphone amp
4511                  */
4512                 spec->gpio_mask |= 0x10;
4513                 spec->gpio_dir |= 0x10;
4514                 spec->cap_mute_led_nid = 0x18;
4515                 snd_hda_gen_add_micmute_led_cdev(codec, vref_micmute_led_set);
4516                 codec->power_filter = led_power_filter;
4517         }
4518 }
4519
4520 static void alc280_fixup_hp_gpio4(struct hda_codec *codec,
4521                                    const struct hda_fixup *fix, int action)
4522 {
4523         struct alc_spec *spec = codec->spec;
4524
4525         alc_fixup_hp_gpio_led(codec, action, 0x08, 0);
4526         if (action == HDA_FIXUP_ACT_PRE_PROBE) {
4527                 spec->cap_mute_led_nid = 0x18;
4528                 snd_hda_gen_add_micmute_led_cdev(codec, vref_micmute_led_set);
4529                 codec->power_filter = led_power_filter;
4530         }
4531 }
4532
4533 /* HP Spectre x360 14 model needs a unique workaround for enabling the amp;
4534  * it needs to toggle the GPIO0 once on and off at each time (bko#210633)
4535  */
4536 static void alc245_fixup_hp_x360_amp(struct hda_codec *codec,
4537                                      const struct hda_fixup *fix, int action)
4538 {
4539         struct alc_spec *spec = codec->spec;
4540
4541         switch (action) {
4542         case HDA_FIXUP_ACT_PRE_PROBE:
4543                 spec->gpio_mask |= 0x01;
4544                 spec->gpio_dir |= 0x01;
4545                 break;
4546         case HDA_FIXUP_ACT_INIT:
4547                 /* need to toggle GPIO to enable the amp */
4548                 alc_update_gpio_data(codec, 0x01, true);
4549                 msleep(100);
4550                 alc_update_gpio_data(codec, 0x01, false);
4551                 break;
4552         }
4553 }
4554
4555 /* toggle GPIO2 at each time stream is started; we use PREPARE state instead */
4556 static void alc274_hp_envy_pcm_hook(struct hda_pcm_stream *hinfo,
4557                                     struct hda_codec *codec,
4558                                     struct snd_pcm_substream *substream,
4559                                     int action)
4560 {
4561         switch (action) {
4562         case HDA_GEN_PCM_ACT_PREPARE:
4563                 alc_update_gpio_data(codec, 0x04, true);
4564                 break;
4565         case HDA_GEN_PCM_ACT_CLEANUP:
4566                 alc_update_gpio_data(codec, 0x04, false);
4567                 break;
4568         }
4569 }
4570
4571 static void alc274_fixup_hp_envy_gpio(struct hda_codec *codec,
4572                                       const struct hda_fixup *fix,
4573                                       int action)
4574 {
4575         struct alc_spec *spec = codec->spec;
4576
4577         if (action == HDA_FIXUP_ACT_PROBE) {
4578                 spec->gpio_mask |= 0x04;
4579                 spec->gpio_dir |= 0x04;
4580                 spec->gen.pcm_playback_hook = alc274_hp_envy_pcm_hook;
4581         }
4582 }
4583
4584 static void alc_update_coef_led(struct hda_codec *codec,
4585                                 struct alc_coef_led *led,
4586                                 bool polarity, bool on)
4587 {
4588         if (polarity)
4589                 on = !on;
4590         /* temporarily power up/down for setting COEF bit */
4591         alc_update_coef_idx(codec, led->idx, led->mask,
4592                             on ? led->on : led->off);
4593 }
4594
4595 /* update mute-LED according to the speaker mute state via COEF bit */
4596 static int coef_mute_led_set(struct led_classdev *led_cdev,
4597                              enum led_brightness brightness)
4598 {
4599         struct hda_codec *codec = dev_to_hda_codec(led_cdev->dev->parent);
4600         struct alc_spec *spec = codec->spec;
4601
4602         alc_update_coef_led(codec, &spec->mute_led_coef,
4603                             spec->mute_led_polarity, brightness);
4604         return 0;
4605 }
4606
4607 static void alc285_fixup_hp_mute_led_coefbit(struct hda_codec *codec,
4608                                           const struct hda_fixup *fix,
4609                                           int action)
4610 {
4611         struct alc_spec *spec = codec->spec;
4612
4613         if (action == HDA_FIXUP_ACT_PRE_PROBE) {
4614                 spec->mute_led_polarity = 0;
4615                 spec->mute_led_coef.idx = 0x0b;
4616                 spec->mute_led_coef.mask = 1 << 3;
4617                 spec->mute_led_coef.on = 1 << 3;
4618                 spec->mute_led_coef.off = 0;
4619                 snd_hda_gen_add_mute_led_cdev(codec, coef_mute_led_set);
4620         }
4621 }
4622
4623 static void alc236_fixup_hp_mute_led_coefbit(struct hda_codec *codec,
4624                                           const struct hda_fixup *fix,
4625                                           int action)
4626 {
4627         struct alc_spec *spec = codec->spec;
4628
4629         if (action == HDA_FIXUP_ACT_PRE_PROBE) {
4630                 spec->mute_led_polarity = 0;
4631                 spec->mute_led_coef.idx = 0x34;
4632                 spec->mute_led_coef.mask = 1 << 5;
4633                 spec->mute_led_coef.on = 0;
4634                 spec->mute_led_coef.off = 1 << 5;
4635                 snd_hda_gen_add_mute_led_cdev(codec, coef_mute_led_set);
4636         }
4637 }
4638
4639 static void alc236_fixup_hp_mute_led_coefbit2(struct hda_codec *codec,
4640                                           const struct hda_fixup *fix, int action)
4641 {
4642         struct alc_spec *spec = codec->spec;
4643
4644         if (action == HDA_FIXUP_ACT_PRE_PROBE) {
4645                 spec->mute_led_polarity = 0;
4646                 spec->mute_led_coef.idx = 0x07;
4647                 spec->mute_led_coef.mask = 1;
4648                 spec->mute_led_coef.on = 1;
4649                 spec->mute_led_coef.off = 0;
4650                 snd_hda_gen_add_mute_led_cdev(codec, coef_mute_led_set);
4651         }
4652 }
4653
4654 static void alc245_fixup_hp_mute_led_coefbit(struct hda_codec *codec,
4655                                           const struct hda_fixup *fix,
4656                                           int action)
4657 {
4658         struct alc_spec *spec = codec->spec;
4659
4660         if (action == HDA_FIXUP_ACT_PRE_PROBE) {
4661                 spec->mute_led_polarity = 0;
4662                 spec->mute_led_coef.idx = 0x0b;
4663                 spec->mute_led_coef.mask = 3 << 2;
4664                 spec->mute_led_coef.on = 2 << 2;
4665                 spec->mute_led_coef.off = 1 << 2;
4666                 snd_hda_gen_add_mute_led_cdev(codec, coef_mute_led_set);
4667         }
4668 }
4669
4670 /* turn on/off mic-mute LED per capture hook by coef bit */
4671 static int coef_micmute_led_set(struct led_classdev *led_cdev,
4672                                 enum led_brightness brightness)
4673 {
4674         struct hda_codec *codec = dev_to_hda_codec(led_cdev->dev->parent);
4675         struct alc_spec *spec = codec->spec;
4676
4677         alc_update_coef_led(codec, &spec->mic_led_coef,
4678                             spec->micmute_led_polarity, brightness);
4679         return 0;
4680 }
4681
4682 static void alc285_fixup_hp_coef_micmute_led(struct hda_codec *codec,
4683                                 const struct hda_fixup *fix, int action)
4684 {
4685         struct alc_spec *spec = codec->spec;
4686
4687         if (action == HDA_FIXUP_ACT_PRE_PROBE) {
4688                 spec->mic_led_coef.idx = 0x19;
4689                 spec->mic_led_coef.mask = 1 << 13;
4690                 spec->mic_led_coef.on = 1 << 13;
4691                 spec->mic_led_coef.off = 0;
4692                 snd_hda_gen_add_micmute_led_cdev(codec, coef_micmute_led_set);
4693         }
4694 }
4695
4696 static void alc285_fixup_hp_gpio_micmute_led(struct hda_codec *codec,
4697                                 const struct hda_fixup *fix, int action)
4698 {
4699         struct alc_spec *spec = codec->spec;
4700
4701         if (action == HDA_FIXUP_ACT_PRE_PROBE)
4702                 spec->micmute_led_polarity = 1;
4703         alc_fixup_hp_gpio_led(codec, action, 0, 0x04);
4704 }
4705
4706 static void alc236_fixup_hp_coef_micmute_led(struct hda_codec *codec,
4707                                 const struct hda_fixup *fix, int action)
4708 {
4709         struct alc_spec *spec = codec->spec;
4710
4711         if (action == HDA_FIXUP_ACT_PRE_PROBE) {
4712                 spec->mic_led_coef.idx = 0x35;
4713                 spec->mic_led_coef.mask = 3 << 2;
4714                 spec->mic_led_coef.on = 2 << 2;
4715                 spec->mic_led_coef.off = 1 << 2;
4716                 snd_hda_gen_add_micmute_led_cdev(codec, coef_micmute_led_set);
4717         }
4718 }
4719
4720 static void alc285_fixup_hp_mute_led(struct hda_codec *codec,
4721                                 const struct hda_fixup *fix, int action)
4722 {
4723         alc285_fixup_hp_mute_led_coefbit(codec, fix, action);
4724         alc285_fixup_hp_coef_micmute_led(codec, fix, action);
4725 }
4726
4727 static void alc285_fixup_hp_spectre_x360_mute_led(struct hda_codec *codec,
4728                                 const struct hda_fixup *fix, int action)
4729 {
4730         alc285_fixup_hp_mute_led_coefbit(codec, fix, action);
4731         alc285_fixup_hp_gpio_micmute_led(codec, fix, action);
4732 }
4733
4734 static void alc236_fixup_hp_mute_led(struct hda_codec *codec,
4735                                 const struct hda_fixup *fix, int action)
4736 {
4737         alc236_fixup_hp_mute_led_coefbit(codec, fix, action);
4738         alc236_fixup_hp_coef_micmute_led(codec, fix, action);
4739 }
4740
4741 static void alc236_fixup_hp_micmute_led_vref(struct hda_codec *codec,
4742                                 const struct hda_fixup *fix, int action)
4743 {
4744         struct alc_spec *spec = codec->spec;
4745
4746         if (action == HDA_FIXUP_ACT_PRE_PROBE) {
4747                 spec->cap_mute_led_nid = 0x1a;
4748                 snd_hda_gen_add_micmute_led_cdev(codec, vref_micmute_led_set);
4749                 codec->power_filter = led_power_filter;
4750         }
4751 }
4752
4753 static void alc236_fixup_hp_mute_led_micmute_vref(struct hda_codec *codec,
4754                                 const struct hda_fixup *fix, int action)
4755 {
4756         alc236_fixup_hp_mute_led_coefbit(codec, fix, action);
4757         alc236_fixup_hp_micmute_led_vref(codec, fix, action);
4758 }
4759
4760 static inline void alc298_samsung_write_coef_pack(struct hda_codec *codec,
4761                                                   const unsigned short coefs[2])
4762 {
4763         alc_write_coef_idx(codec, 0x23, coefs[0]);
4764         alc_write_coef_idx(codec, 0x25, coefs[1]);
4765         alc_write_coef_idx(codec, 0x26, 0xb011);
4766 }
4767
4768 struct alc298_samsung_amp_desc {
4769         unsigned char nid;
4770         unsigned short init_seq[2][2];
4771 };
4772
4773 static void alc298_fixup_samsung_amp(struct hda_codec *codec,
4774                                      const struct hda_fixup *fix, int action)
4775 {
4776         int i, j;
4777         static const unsigned short init_seq[][2] = {
4778                 { 0x19, 0x00 }, { 0x20, 0xc0 }, { 0x22, 0x44 }, { 0x23, 0x08 },
4779                 { 0x24, 0x85 }, { 0x25, 0x41 }, { 0x35, 0x40 }, { 0x36, 0x01 },
4780                 { 0x38, 0x81 }, { 0x3a, 0x03 }, { 0x3b, 0x81 }, { 0x40, 0x3e },
4781                 { 0x41, 0x07 }, { 0x400, 0x1 }
4782         };
4783         static const struct alc298_samsung_amp_desc amps[] = {
4784                 { 0x3a, { { 0x18, 0x1 }, { 0x26, 0x0 } } },
4785                 { 0x39, { { 0x18, 0x2 }, { 0x26, 0x1 } } }
4786         };
4787
4788         if (action != HDA_FIXUP_ACT_INIT)
4789                 return;
4790
4791         for (i = 0; i < ARRAY_SIZE(amps); i++) {
4792                 alc_write_coef_idx(codec, 0x22, amps[i].nid);
4793
4794                 for (j = 0; j < ARRAY_SIZE(amps[i].init_seq); j++)
4795                         alc298_samsung_write_coef_pack(codec, amps[i].init_seq[j]);
4796
4797                 for (j = 0; j < ARRAY_SIZE(init_seq); j++)
4798                         alc298_samsung_write_coef_pack(codec, init_seq[j]);
4799         }
4800 }
4801
4802 #if IS_REACHABLE(CONFIG_INPUT)
4803 static void gpio2_mic_hotkey_event(struct hda_codec *codec,
4804                                    struct hda_jack_callback *event)
4805 {
4806         struct alc_spec *spec = codec->spec;
4807
4808         /* GPIO2 just toggles on a keypress/keyrelease cycle. Therefore
4809            send both key on and key off event for every interrupt. */
4810         input_report_key(spec->kb_dev, spec->alc_mute_keycode_map[ALC_KEY_MICMUTE_INDEX], 1);
4811         input_sync(spec->kb_dev);
4812         input_report_key(spec->kb_dev, spec->alc_mute_keycode_map[ALC_KEY_MICMUTE_INDEX], 0);
4813         input_sync(spec->kb_dev);
4814 }
4815
4816 static int alc_register_micmute_input_device(struct hda_codec *codec)
4817 {
4818         struct alc_spec *spec = codec->spec;
4819         int i;
4820
4821         spec->kb_dev = input_allocate_device();
4822         if (!spec->kb_dev) {
4823                 codec_err(codec, "Out of memory (input_allocate_device)\n");
4824                 return -ENOMEM;
4825         }
4826
4827         spec->alc_mute_keycode_map[ALC_KEY_MICMUTE_INDEX] = KEY_MICMUTE;
4828
4829         spec->kb_dev->name = "Microphone Mute Button";
4830         spec->kb_dev->evbit[0] = BIT_MASK(EV_KEY);
4831         spec->kb_dev->keycodesize = sizeof(spec->alc_mute_keycode_map[0]);
4832         spec->kb_dev->keycodemax = ARRAY_SIZE(spec->alc_mute_keycode_map);
4833         spec->kb_dev->keycode = spec->alc_mute_keycode_map;
4834         for (i = 0; i < ARRAY_SIZE(spec->alc_mute_keycode_map); i++)
4835                 set_bit(spec->alc_mute_keycode_map[i], spec->kb_dev->keybit);
4836
4837         if (input_register_device(spec->kb_dev)) {
4838                 codec_err(codec, "input_register_device failed\n");
4839                 input_free_device(spec->kb_dev);
4840                 spec->kb_dev = NULL;
4841                 return -ENOMEM;
4842         }
4843
4844         return 0;
4845 }
4846
4847 /* GPIO1 = set according to SKU external amp
4848  * GPIO2 = mic mute hotkey
4849  * GPIO3 = mute LED
4850  * GPIO4 = mic mute LED
4851  */
4852 static void alc280_fixup_hp_gpio2_mic_hotkey(struct hda_codec *codec,
4853                                              const struct hda_fixup *fix, int action)
4854 {
4855         struct alc_spec *spec = codec->spec;
4856
4857         alc_fixup_hp_gpio_led(codec, action, 0x08, 0x10);
4858         if (action == HDA_FIXUP_ACT_PRE_PROBE) {
4859                 spec->init_amp = ALC_INIT_DEFAULT;
4860                 if (alc_register_micmute_input_device(codec) != 0)
4861                         return;
4862
4863                 spec->gpio_mask |= 0x06;
4864                 spec->gpio_dir |= 0x02;
4865                 spec->gpio_data |= 0x02;
4866                 snd_hda_codec_write_cache(codec, codec->core.afg, 0,
4867                                           AC_VERB_SET_GPIO_UNSOLICITED_RSP_MASK, 0x04);
4868                 snd_hda_jack_detect_enable_callback(codec, codec->core.afg,
4869                                                     gpio2_mic_hotkey_event);
4870                 return;
4871         }
4872
4873         if (!spec->kb_dev)
4874                 return;
4875
4876         switch (action) {
4877         case HDA_FIXUP_ACT_FREE:
4878                 input_unregister_device(spec->kb_dev);
4879                 spec->kb_dev = NULL;
4880         }
4881 }
4882
4883 /* Line2 = mic mute hotkey
4884  * GPIO2 = mic mute LED
4885  */
4886 static void alc233_fixup_lenovo_line2_mic_hotkey(struct hda_codec *codec,
4887                                              const struct hda_fixup *fix, int action)
4888 {
4889         struct alc_spec *spec = codec->spec;
4890
4891         alc_fixup_hp_gpio_led(codec, action, 0, 0x04);
4892         if (action == HDA_FIXUP_ACT_PRE_PROBE) {
4893                 spec->init_amp = ALC_INIT_DEFAULT;
4894                 if (alc_register_micmute_input_device(codec) != 0)
4895                         return;
4896
4897                 snd_hda_jack_detect_enable_callback(codec, 0x1b,
4898                                                     gpio2_mic_hotkey_event);
4899                 return;
4900         }
4901
4902         if (!spec->kb_dev)
4903                 return;
4904
4905         switch (action) {
4906         case HDA_FIXUP_ACT_FREE:
4907                 input_unregister_device(spec->kb_dev);
4908                 spec->kb_dev = NULL;
4909         }
4910 }
4911 #else /* INPUT */
4912 #define alc280_fixup_hp_gpio2_mic_hotkey        NULL
4913 #define alc233_fixup_lenovo_line2_mic_hotkey    NULL
4914 #endif /* INPUT */
4915
4916 static void alc269_fixup_hp_line1_mic1_led(struct hda_codec *codec,
4917                                 const struct hda_fixup *fix, int action)
4918 {
4919         struct alc_spec *spec = codec->spec;
4920
4921         alc269_fixup_hp_mute_led_micx(codec, fix, action, 0x1a);
4922         if (action == HDA_FIXUP_ACT_PRE_PROBE) {
4923                 spec->cap_mute_led_nid = 0x18;
4924                 snd_hda_gen_add_micmute_led_cdev(codec, vref_micmute_led_set);
4925         }
4926 }
4927
4928 static const struct coef_fw alc225_pre_hsmode[] = {
4929         UPDATE_COEF(0x4a, 1<<8, 0),
4930         UPDATE_COEFEX(0x57, 0x05, 1<<14, 0),
4931         UPDATE_COEF(0x63, 3<<14, 3<<14),
4932         UPDATE_COEF(0x4a, 3<<4, 2<<4),
4933         UPDATE_COEF(0x4a, 3<<10, 3<<10),
4934         UPDATE_COEF(0x45, 0x3f<<10, 0x34<<10),
4935         UPDATE_COEF(0x4a, 3<<10, 0),
4936         {}
4937 };
4938
4939 static void alc_headset_mode_unplugged(struct hda_codec *codec)
4940 {
4941         struct alc_spec *spec = codec->spec;
4942         static const struct coef_fw coef0255[] = {
4943                 WRITE_COEF(0x1b, 0x0c0b), /* LDO and MISC control */
4944                 WRITE_COEF(0x45, 0xd089), /* UAJ function set to menual mode */
4945                 UPDATE_COEFEX(0x57, 0x05, 1<<14, 0), /* Direct Drive HP Amp control(Set to verb control)*/
4946                 WRITE_COEF(0x06, 0x6104), /* Set MIC2 Vref gate with HP */
4947                 WRITE_COEFEX(0x57, 0x03, 0x8aa6), /* Direct Drive HP Amp control */
4948                 {}
4949         };
4950         static const struct coef_fw coef0256[] = {
4951                 WRITE_COEF(0x1b, 0x0c4b), /* LDO and MISC control */
4952                 WRITE_COEF(0x45, 0xd089), /* UAJ function set to menual mode */
4953                 WRITE_COEF(0x06, 0x6104), /* Set MIC2 Vref gate with HP */
4954                 WRITE_COEFEX(0x57, 0x03, 0x09a3), /* Direct Drive HP Amp control */
4955                 UPDATE_COEFEX(0x57, 0x05, 1<<14, 0), /* Direct Drive HP Amp control(Set to verb control)*/
4956                 {}
4957         };
4958         static const struct coef_fw coef0233[] = {
4959                 WRITE_COEF(0x1b, 0x0c0b),
4960                 WRITE_COEF(0x45, 0xc429),
4961                 UPDATE_COEF(0x35, 0x4000, 0),
4962                 WRITE_COEF(0x06, 0x2104),
4963                 WRITE_COEF(0x1a, 0x0001),
4964                 WRITE_COEF(0x26, 0x0004),
4965                 WRITE_COEF(0x32, 0x42a3),
4966                 {}
4967         };
4968         static const struct coef_fw coef0288[] = {
4969                 UPDATE_COEF(0x4f, 0xfcc0, 0xc400),
4970                 UPDATE_COEF(0x50, 0x2000, 0x2000),
4971                 UPDATE_COEF(0x56, 0x0006, 0x0006),
4972                 UPDATE_COEF(0x66, 0x0008, 0),
4973                 UPDATE_COEF(0x67, 0x2000, 0),
4974                 {}
4975         };
4976         static const struct coef_fw coef0298[] = {
4977                 UPDATE_COEF(0x19, 0x1300, 0x0300),
4978                 {}
4979         };
4980         static const struct coef_fw coef0292[] = {
4981                 WRITE_COEF(0x76, 0x000e),
4982                 WRITE_COEF(0x6c, 0x2400),
4983                 WRITE_COEF(0x18, 0x7308),
4984                 WRITE_COEF(0x6b, 0xc429),
4985                 {}
4986         };
4987         static const struct coef_fw coef0293[] = {
4988                 UPDATE_COEF(0x10, 7<<8, 6<<8), /* SET Line1 JD to 0 */
4989                 UPDATE_COEFEX(0x57, 0x05, 1<<15|1<<13, 0x0), /* SET charge pump by verb */
4990                 UPDATE_COEFEX(0x57, 0x03, 1<<10, 1<<10), /* SET EN_OSW to 1 */
4991                 UPDATE_COEF(0x1a, 1<<3, 1<<3), /* Combo JD gating with LINE1-VREFO */
4992                 WRITE_COEF(0x45, 0xc429), /* Set to TRS type */
4993                 UPDATE_COEF(0x4a, 0x000f, 0x000e), /* Combo Jack auto detect */
4994                 {}
4995         };
4996         static const struct coef_fw coef0668[] = {
4997                 WRITE_COEF(0x15, 0x0d40),
4998                 WRITE_COEF(0xb7, 0x802b),
4999                 {}
5000         };
5001         static const struct coef_fw coef0225[] = {
5002                 UPDATE_COEF(0x63, 3<<14, 0),
5003                 {}
5004         };
5005         static const struct coef_fw coef0274[] = {
5006                 UPDATE_COEF(0x4a, 0x0100, 0),
5007                 UPDATE_COEFEX(0x57, 0x05, 0x4000, 0),
5008                 UPDATE_COEF(0x6b, 0xf000, 0x5000),
5009                 UPDATE_COEF(0x4a, 0x0010, 0),
5010                 UPDATE_COEF(0x4a, 0x0c00, 0x0c00),
5011                 WRITE_COEF(0x45, 0x5289),
5012                 UPDATE_COEF(0x4a, 0x0c00, 0),
5013                 {}
5014         };
5015
5016         if (spec->no_internal_mic_pin) {
5017                 alc_update_coef_idx(codec, 0x45, 0xf<<12 | 1<<10, 5<<12);
5018                 return;
5019         }
5020
5021         switch (codec->core.vendor_id) {
5022         case 0x10ec0255:
5023                 alc_process_coef_fw(codec, coef0255);
5024                 break;
5025         case 0x10ec0230:
5026         case 0x10ec0236:
5027         case 0x10ec0256:
5028         case 0x19e58326:
5029                 alc_process_coef_fw(codec, coef0256);
5030                 break;
5031         case 0x10ec0234:
5032         case 0x10ec0274:
5033         case 0x10ec0294:
5034                 alc_process_coef_fw(codec, coef0274);
5035                 break;
5036         case 0x10ec0233:
5037         case 0x10ec0283:
5038                 alc_process_coef_fw(codec, coef0233);
5039                 break;
5040         case 0x10ec0286:
5041         case 0x10ec0288:
5042                 alc_process_coef_fw(codec, coef0288);
5043                 break;
5044         case 0x10ec0298:
5045                 alc_process_coef_fw(codec, coef0298);
5046                 alc_process_coef_fw(codec, coef0288);
5047                 break;
5048         case 0x10ec0292:
5049                 alc_process_coef_fw(codec, coef0292);
5050                 break;
5051         case 0x10ec0293:
5052                 alc_process_coef_fw(codec, coef0293);
5053                 break;
5054         case 0x10ec0668:
5055                 alc_process_coef_fw(codec, coef0668);
5056                 break;
5057         case 0x10ec0215:
5058         case 0x10ec0225:
5059         case 0x10ec0285:
5060         case 0x10ec0295:
5061         case 0x10ec0289:
5062         case 0x10ec0299:
5063                 alc_process_coef_fw(codec, alc225_pre_hsmode);
5064                 alc_process_coef_fw(codec, coef0225);
5065                 break;
5066         case 0x10ec0867:
5067                 alc_update_coefex_idx(codec, 0x57, 0x5, 1<<14, 0);
5068                 break;
5069         }
5070         codec_dbg(codec, "Headset jack set to unplugged mode.\n");
5071 }
5072
5073
5074 static void alc_headset_mode_mic_in(struct hda_codec *codec, hda_nid_t hp_pin,
5075                                     hda_nid_t mic_pin)
5076 {
5077         static const struct coef_fw coef0255[] = {
5078                 WRITE_COEFEX(0x57, 0x03, 0x8aa6),
5079                 WRITE_COEF(0x06, 0x6100), /* Set MIC2 Vref gate to normal */
5080                 {}
5081         };
5082         static const struct coef_fw coef0256[] = {
5083                 UPDATE_COEFEX(0x57, 0x05, 1<<14, 1<<14), /* Direct Drive HP Amp control(Set to verb control)*/
5084                 WRITE_COEFEX(0x57, 0x03, 0x09a3),
5085                 WRITE_COEF(0x06, 0x6100), /* Set MIC2 Vref gate to normal */
5086                 {}
5087         };
5088         static const struct coef_fw coef0233[] = {
5089                 UPDATE_COEF(0x35, 0, 1<<14),
5090                 WRITE_COEF(0x06, 0x2100),
5091                 WRITE_COEF(0x1a, 0x0021),
5092                 WRITE_COEF(0x26, 0x008c),
5093                 {}
5094         };
5095         static const struct coef_fw coef0288[] = {
5096                 UPDATE_COEF(0x4f, 0x00c0, 0),
5097                 UPDATE_COEF(0x50, 0x2000, 0),
5098                 UPDATE_COEF(0x56, 0x0006, 0),
5099                 UPDATE_COEF(0x4f, 0xfcc0, 0xc400),
5100                 UPDATE_COEF(0x66, 0x0008, 0x0008),
5101                 UPDATE_COEF(0x67, 0x2000, 0x2000),
5102                 {}
5103         };
5104         static const struct coef_fw coef0292[] = {
5105                 WRITE_COEF(0x19, 0xa208),
5106                 WRITE_COEF(0x2e, 0xacf0),
5107                 {}
5108         };
5109         static const struct coef_fw coef0293[] = {
5110                 UPDATE_COEFEX(0x57, 0x05, 0, 1<<15|1<<13), /* SET charge pump by verb */
5111                 UPDATE_COEFEX(0x57, 0x03, 1<<10, 0), /* SET EN_OSW to 0 */
5112                 UPDATE_COEF(0x1a, 1<<3, 0), /* Combo JD gating without LINE1-VREFO */
5113                 {}
5114         };
5115         static const struct coef_fw coef0688[] = {
5116                 WRITE_COEF(0xb7, 0x802b),
5117                 WRITE_COEF(0xb5, 0x1040),
5118                 UPDATE_COEF(0xc3, 0, 1<<12),
5119                 {}
5120         };
5121         static const struct coef_fw coef0225[] = {
5122                 UPDATE_COEFEX(0x57, 0x05, 1<<14, 1<<14),
5123                 UPDATE_COEF(0x4a, 3<<4, 2<<4),
5124                 UPDATE_COEF(0x63, 3<<14, 0),
5125                 {}
5126         };
5127         static const struct coef_fw coef0274[] = {
5128                 UPDATE_COEFEX(0x57, 0x05, 0x4000, 0x4000),
5129                 UPDATE_COEF(0x4a, 0x0010, 0),
5130                 UPDATE_COEF(0x6b, 0xf000, 0),
5131                 {}
5132         };
5133
5134         switch (codec->core.vendor_id) {
5135         case 0x10ec0255:
5136                 alc_write_coef_idx(codec, 0x45, 0xc489);
5137                 snd_hda_set_pin_ctl_cache(codec, hp_pin, 0);
5138                 alc_process_coef_fw(codec, coef0255);
5139                 snd_hda_set_pin_ctl_cache(codec, mic_pin, PIN_VREF50);
5140                 break;
5141         case 0x10ec0230:
5142         case 0x10ec0236:
5143         case 0x10ec0256:
5144         case 0x19e58326:
5145                 alc_write_coef_idx(codec, 0x45, 0xc489);
5146                 snd_hda_set_pin_ctl_cache(codec, hp_pin, 0);
5147                 alc_process_coef_fw(codec, coef0256);
5148                 snd_hda_set_pin_ctl_cache(codec, mic_pin, PIN_VREF50);
5149                 break;
5150         case 0x10ec0234:
5151         case 0x10ec0274:
5152         case 0x10ec0294:
5153                 alc_write_coef_idx(codec, 0x45, 0x4689);
5154                 snd_hda_set_pin_ctl_cache(codec, hp_pin, 0);
5155                 alc_process_coef_fw(codec, coef0274);
5156                 snd_hda_set_pin_ctl_cache(codec, mic_pin, PIN_VREF50);
5157                 break;
5158         case 0x10ec0233:
5159         case 0x10ec0283:
5160                 alc_write_coef_idx(codec, 0x45, 0xc429);
5161                 snd_hda_set_pin_ctl_cache(codec, hp_pin, 0);
5162                 alc_process_coef_fw(codec, coef0233);
5163                 snd_hda_set_pin_ctl_cache(codec, mic_pin, PIN_VREF50);
5164                 break;
5165         case 0x10ec0286:
5166         case 0x10ec0288:
5167         case 0x10ec0298:
5168                 snd_hda_set_pin_ctl_cache(codec, hp_pin, 0);
5169                 alc_process_coef_fw(codec, coef0288);
5170                 snd_hda_set_pin_ctl_cache(codec, mic_pin, PIN_VREF50);
5171                 break;
5172         case 0x10ec0292:
5173                 snd_hda_set_pin_ctl_cache(codec, hp_pin, 0);
5174                 alc_process_coef_fw(codec, coef0292);
5175                 break;
5176         case 0x10ec0293:
5177                 /* Set to TRS mode */
5178                 alc_write_coef_idx(codec, 0x45, 0xc429);
5179                 snd_hda_set_pin_ctl_cache(codec, hp_pin, 0);
5180                 alc_process_coef_fw(codec, coef0293);
5181                 snd_hda_set_pin_ctl_cache(codec, mic_pin, PIN_VREF50);
5182                 break;
5183         case 0x10ec0867:
5184                 alc_update_coefex_idx(codec, 0x57, 0x5, 0, 1<<14);
5185                 fallthrough;
5186         case 0x10ec0221:
5187         case 0x10ec0662:
5188                 snd_hda_set_pin_ctl_cache(codec, hp_pin, 0);
5189                 snd_hda_set_pin_ctl_cache(codec, mic_pin, PIN_VREF50);
5190                 break;
5191         case 0x10ec0668:
5192                 alc_write_coef_idx(codec, 0x11, 0x0001);
5193                 snd_hda_set_pin_ctl_cache(codec, hp_pin, 0);
5194                 alc_process_coef_fw(codec, coef0688);
5195                 snd_hda_set_pin_ctl_cache(codec, mic_pin, PIN_VREF50);
5196                 break;
5197         case 0x10ec0215:
5198         case 0x10ec0225:
5199         case 0x10ec0285:
5200         case 0x10ec0295:
5201         case 0x10ec0289:
5202         case 0x10ec0299:
5203                 alc_process_coef_fw(codec, alc225_pre_hsmode);
5204                 alc_update_coef_idx(codec, 0x45, 0x3f<<10, 0x31<<10);
5205                 snd_hda_set_pin_ctl_cache(codec, hp_pin, 0);
5206                 alc_process_coef_fw(codec, coef0225);
5207                 snd_hda_set_pin_ctl_cache(codec, mic_pin, PIN_VREF50);
5208                 break;
5209         }
5210         codec_dbg(codec, "Headset jack set to mic-in mode.\n");
5211 }
5212
5213 static void alc_headset_mode_default(struct hda_codec *codec)
5214 {
5215         static const struct coef_fw coef0225[] = {
5216                 UPDATE_COEF(0x45, 0x3f<<10, 0x30<<10),
5217                 UPDATE_COEF(0x45, 0x3f<<10, 0x31<<10),
5218                 UPDATE_COEF(0x49, 3<<8, 0<<8),
5219                 UPDATE_COEF(0x4a, 3<<4, 3<<4),
5220                 UPDATE_COEF(0x63, 3<<14, 0),
5221                 UPDATE_COEF(0x67, 0xf000, 0x3000),
5222                 {}
5223         };
5224         static const struct coef_fw coef0255[] = {
5225                 WRITE_COEF(0x45, 0xc089),
5226                 WRITE_COEF(0x45, 0xc489),
5227                 WRITE_COEFEX(0x57, 0x03, 0x8ea6),
5228                 WRITE_COEF(0x49, 0x0049),
5229                 {}
5230         };
5231         static const struct coef_fw coef0256[] = {
5232                 WRITE_COEF(0x45, 0xc489),
5233                 WRITE_COEFEX(0x57, 0x03, 0x0da3),
5234                 WRITE_COEF(0x49, 0x0049),
5235                 UPDATE_COEFEX(0x57, 0x05, 1<<14, 0), /* Direct Drive HP Amp control(Set to verb control)*/
5236                 WRITE_COEF(0x06, 0x6100),
5237                 {}
5238         };
5239         static const struct coef_fw coef0233[] = {
5240                 WRITE_COEF(0x06, 0x2100),
5241                 WRITE_COEF(0x32, 0x4ea3),
5242                 {}
5243         };
5244         static const struct coef_fw coef0288[] = {
5245                 UPDATE_COEF(0x4f, 0xfcc0, 0xc400), /* Set to TRS type */
5246                 UPDATE_COEF(0x50, 0x2000, 0x2000),
5247                 UPDATE_COEF(0x56, 0x0006, 0x0006),
5248                 UPDATE_COEF(0x66, 0x0008, 0),
5249                 UPDATE_COEF(0x67, 0x2000, 0),
5250                 {}
5251         };
5252         static const struct coef_fw coef0292[] = {
5253                 WRITE_COEF(0x76, 0x000e),
5254                 WRITE_COEF(0x6c, 0x2400),
5255                 WRITE_COEF(0x6b, 0xc429),
5256                 WRITE_COEF(0x18, 0x7308),
5257                 {}
5258         };
5259         static const struct coef_fw coef0293[] = {
5260                 UPDATE_COEF(0x4a, 0x000f, 0x000e), /* Combo Jack auto detect */
5261                 WRITE_COEF(0x45, 0xC429), /* Set to TRS type */
5262                 UPDATE_COEF(0x1a, 1<<3, 0), /* Combo JD gating without LINE1-VREFO */
5263                 {}
5264         };
5265         static const struct coef_fw coef0688[] = {
5266                 WRITE_COEF(0x11, 0x0041),
5267                 WRITE_COEF(0x15, 0x0d40),
5268                 WRITE_COEF(0xb7, 0x802b),
5269                 {}
5270         };
5271         static const struct coef_fw coef0274[] = {
5272                 WRITE_COEF(0x45, 0x4289),
5273                 UPDATE_COEF(0x4a, 0x0010, 0x0010),
5274                 UPDATE_COEF(0x6b, 0x0f00, 0),
5275                 UPDATE_COEF(0x49, 0x0300, 0x0300),
5276                 {}
5277         };
5278
5279         switch (codec->core.vendor_id) {
5280         case 0x10ec0215:
5281         case 0x10ec0225:
5282         case 0x10ec0285:
5283         case 0x10ec0295:
5284         case 0x10ec0289:
5285         case 0x10ec0299:
5286                 alc_process_coef_fw(codec, alc225_pre_hsmode);
5287                 alc_process_coef_fw(codec, coef0225);
5288                 break;
5289         case 0x10ec0255:
5290                 alc_process_coef_fw(codec, coef0255);
5291                 break;
5292         case 0x10ec0230:
5293         case 0x10ec0236:
5294         case 0x10ec0256:
5295         case 0x19e58326:
5296                 alc_write_coef_idx(codec, 0x1b, 0x0e4b);
5297                 alc_write_coef_idx(codec, 0x45, 0xc089);
5298                 msleep(50);
5299                 alc_process_coef_fw(codec, coef0256);
5300                 break;
5301         case 0x10ec0234:
5302         case 0x10ec0274:
5303         case 0x10ec0294:
5304                 alc_process_coef_fw(codec, coef0274);
5305                 break;
5306         case 0x10ec0233:
5307         case 0x10ec0283:
5308                 alc_process_coef_fw(codec, coef0233);
5309                 break;
5310         case 0x10ec0286:
5311         case 0x10ec0288:
5312         case 0x10ec0298:
5313                 alc_process_coef_fw(codec, coef0288);
5314                 break;
5315         case 0x10ec0292:
5316                 alc_process_coef_fw(codec, coef0292);
5317                 break;
5318         case 0x10ec0293:
5319                 alc_process_coef_fw(codec, coef0293);
5320                 break;
5321         case 0x10ec0668:
5322                 alc_process_coef_fw(codec, coef0688);
5323                 break;
5324         case 0x10ec0867:
5325                 alc_update_coefex_idx(codec, 0x57, 0x5, 1<<14, 0);
5326                 break;
5327         }
5328         codec_dbg(codec, "Headset jack set to headphone (default) mode.\n");
5329 }
5330
5331 /* Iphone type */
5332 static void alc_headset_mode_ctia(struct hda_codec *codec)
5333 {
5334         int val;
5335
5336         static const struct coef_fw coef0255[] = {
5337                 WRITE_COEF(0x45, 0xd489), /* Set to CTIA type */
5338                 WRITE_COEF(0x1b, 0x0c2b),
5339                 WRITE_COEFEX(0x57, 0x03, 0x8ea6),
5340                 {}
5341         };
5342         static const struct coef_fw coef0256[] = {
5343                 WRITE_COEF(0x45, 0xd489), /* Set to CTIA type */
5344                 WRITE_COEF(0x1b, 0x0e6b),
5345                 {}
5346         };
5347         static const struct coef_fw coef0233[] = {
5348                 WRITE_COEF(0x45, 0xd429),
5349                 WRITE_COEF(0x1b, 0x0c2b),
5350                 WRITE_COEF(0x32, 0x4ea3),
5351                 {}
5352         };
5353         static const struct coef_fw coef0288[] = {
5354                 UPDATE_COEF(0x50, 0x2000, 0x2000),
5355                 UPDATE_COEF(0x56, 0x0006, 0x0006),
5356                 UPDATE_COEF(0x66, 0x0008, 0),
5357                 UPDATE_COEF(0x67, 0x2000, 0),
5358                 {}
5359         };
5360         static const struct coef_fw coef0292[] = {
5361                 WRITE_COEF(0x6b, 0xd429),
5362                 WRITE_COEF(0x76, 0x0008),
5363                 WRITE_COEF(0x18, 0x7388),
5364                 {}
5365         };
5366         static const struct coef_fw coef0293[] = {
5367                 WRITE_COEF(0x45, 0xd429), /* Set to ctia type */
5368                 UPDATE_COEF(0x10, 7<<8, 7<<8), /* SET Line1 JD to 1 */
5369                 {}
5370         };
5371         static const struct coef_fw coef0688[] = {
5372                 WRITE_COEF(0x11, 0x0001),
5373                 WRITE_COEF(0x15, 0x0d60),
5374                 WRITE_COEF(0xc3, 0x0000),
5375                 {}
5376         };
5377         static const struct coef_fw coef0225_1[] = {
5378                 UPDATE_COEF(0x45, 0x3f<<10, 0x35<<10),
5379                 UPDATE_COEF(0x63, 3<<14, 2<<14),
5380                 {}
5381         };
5382         static const struct coef_fw coef0225_2[] = {
5383                 UPDATE_COEF(0x45, 0x3f<<10, 0x35<<10),
5384                 UPDATE_COEF(0x63, 3<<14, 1<<14),
5385                 {}
5386         };
5387
5388         switch (codec->core.vendor_id) {
5389         case 0x10ec0255:
5390                 alc_process_coef_fw(codec, coef0255);
5391                 break;
5392         case 0x10ec0230:
5393         case 0x10ec0236:
5394         case 0x10ec0256:
5395         case 0x19e58326:
5396                 alc_process_coef_fw(codec, coef0256);
5397                 break;
5398         case 0x10ec0234:
5399         case 0x10ec0274:
5400         case 0x10ec0294:
5401                 alc_write_coef_idx(codec, 0x45, 0xd689);
5402                 break;
5403         case 0x10ec0233:
5404         case 0x10ec0283:
5405                 alc_process_coef_fw(codec, coef0233);
5406                 break;
5407         case 0x10ec0298:
5408                 val = alc_read_coef_idx(codec, 0x50);
5409                 if (val & (1 << 12)) {
5410                         alc_update_coef_idx(codec, 0x8e, 0x0070, 0x0020);
5411                         alc_update_coef_idx(codec, 0x4f, 0xfcc0, 0xd400);
5412                         msleep(300);
5413                 } else {
5414                         alc_update_coef_idx(codec, 0x8e, 0x0070, 0x0010);
5415                         alc_update_coef_idx(codec, 0x4f, 0xfcc0, 0xd400);
5416                         msleep(300);
5417                 }
5418                 break;
5419         case 0x10ec0286:
5420         case 0x10ec0288:
5421                 alc_update_coef_idx(codec, 0x4f, 0xfcc0, 0xd400);
5422                 msleep(300);
5423                 alc_process_coef_fw(codec, coef0288);
5424                 break;
5425         case 0x10ec0292:
5426                 alc_process_coef_fw(codec, coef0292);
5427                 break;
5428         case 0x10ec0293:
5429                 alc_process_coef_fw(codec, coef0293);
5430                 break;
5431         case 0x10ec0668:
5432                 alc_process_coef_fw(codec, coef0688);
5433                 break;
5434         case 0x10ec0215:
5435         case 0x10ec0225:
5436         case 0x10ec0285:
5437         case 0x10ec0295:
5438         case 0x10ec0289:
5439         case 0x10ec0299:
5440                 val = alc_read_coef_idx(codec, 0x45);
5441                 if (val & (1 << 9))
5442                         alc_process_coef_fw(codec, coef0225_2);
5443                 else
5444                         alc_process_coef_fw(codec, coef0225_1);
5445                 break;
5446         case 0x10ec0867:
5447                 alc_update_coefex_idx(codec, 0x57, 0x5, 1<<14, 0);
5448                 break;
5449         }
5450         codec_dbg(codec, "Headset jack set to iPhone-style headset mode.\n");
5451 }
5452
5453 /* Nokia type */
5454 static void alc_headset_mode_omtp(struct hda_codec *codec)
5455 {
5456         static const struct coef_fw coef0255[] = {
5457                 WRITE_COEF(0x45, 0xe489), /* Set to OMTP Type */
5458                 WRITE_COEF(0x1b, 0x0c2b),
5459                 WRITE_COEFEX(0x57, 0x03, 0x8ea6),
5460                 {}
5461         };
5462         static const struct coef_fw coef0256[] = {
5463                 WRITE_COEF(0x45, 0xe489), /* Set to OMTP Type */
5464                 WRITE_COEF(0x1b, 0x0e6b),
5465                 {}
5466         };
5467         static const struct coef_fw coef0233[] = {
5468                 WRITE_COEF(0x45, 0xe429),
5469                 WRITE_COEF(0x1b, 0x0c2b),
5470                 WRITE_COEF(0x32, 0x4ea3),
5471                 {}
5472         };
5473         static const struct coef_fw coef0288[] = {
5474                 UPDATE_COEF(0x50, 0x2000, 0x2000),
5475                 UPDATE_COEF(0x56, 0x0006, 0x0006),
5476                 UPDATE_COEF(0x66, 0x0008, 0),
5477                 UPDATE_COEF(0x67, 0x2000, 0),
5478                 {}
5479         };
5480         static const struct coef_fw coef0292[] = {
5481                 WRITE_COEF(0x6b, 0xe429),
5482                 WRITE_COEF(0x76, 0x0008),
5483                 WRITE_COEF(0x18, 0x7388),
5484                 {}
5485         };
5486         static const struct coef_fw coef0293[] = {
5487                 WRITE_COEF(0x45, 0xe429), /* Set to omtp type */
5488                 UPDATE_COEF(0x10, 7<<8, 7<<8), /* SET Line1 JD to 1 */
5489                 {}
5490         };
5491         static const struct coef_fw coef0688[] = {
5492                 WRITE_COEF(0x11, 0x0001),
5493                 WRITE_COEF(0x15, 0x0d50),
5494                 WRITE_COEF(0xc3, 0x0000),
5495                 {}
5496         };
5497         static const struct coef_fw coef0225[] = {
5498                 UPDATE_COEF(0x45, 0x3f<<10, 0x39<<10),
5499                 UPDATE_COEF(0x63, 3<<14, 2<<14),
5500                 {}
5501         };
5502
5503         switch (codec->core.vendor_id) {
5504         case 0x10ec0255:
5505                 alc_process_coef_fw(codec, coef0255);
5506                 break;
5507         case 0x10ec0230:
5508         case 0x10ec0236:
5509         case 0x10ec0256:
5510         case 0x19e58326:
5511                 alc_process_coef_fw(codec, coef0256);
5512                 break;
5513         case 0x10ec0234:
5514         case 0x10ec0274:
5515         case 0x10ec0294:
5516                 alc_write_coef_idx(codec, 0x45, 0xe689);
5517                 break;
5518         case 0x10ec0233:
5519         case 0x10ec0283:
5520                 alc_process_coef_fw(codec, coef0233);
5521                 break;
5522         case 0x10ec0298:
5523                 alc_update_coef_idx(codec, 0x8e, 0x0070, 0x0010);/* Headset output enable */
5524                 alc_update_coef_idx(codec, 0x4f, 0xfcc0, 0xe400);
5525                 msleep(300);
5526                 break;
5527         case 0x10ec0286:
5528         case 0x10ec0288:
5529                 alc_update_coef_idx(codec, 0x4f, 0xfcc0, 0xe400);
5530                 msleep(300);
5531                 alc_process_coef_fw(codec, coef0288);
5532                 break;
5533         case 0x10ec0292:
5534                 alc_process_coef_fw(codec, coef0292);
5535                 break;
5536         case 0x10ec0293:
5537                 alc_process_coef_fw(codec, coef0293);
5538                 break;
5539         case 0x10ec0668:
5540                 alc_process_coef_fw(codec, coef0688);
5541                 break;
5542         case 0x10ec0215:
5543         case 0x10ec0225:
5544         case 0x10ec0285:
5545         case 0x10ec0295:
5546         case 0x10ec0289:
5547         case 0x10ec0299:
5548                 alc_process_coef_fw(codec, coef0225);
5549                 break;
5550         }
5551         codec_dbg(codec, "Headset jack set to Nokia-style headset mode.\n");
5552 }
5553
5554 static void alc_determine_headset_type(struct hda_codec *codec)
5555 {
5556         int val;
5557         bool is_ctia = false;
5558         struct alc_spec *spec = codec->spec;
5559         static const struct coef_fw coef0255[] = {
5560                 WRITE_COEF(0x45, 0xd089), /* combo jack auto switch control(Check type)*/
5561                 WRITE_COEF(0x49, 0x0149), /* combo jack auto switch control(Vref
5562  conteol) */
5563                 {}
5564         };
5565         static const struct coef_fw coef0288[] = {
5566                 UPDATE_COEF(0x4f, 0xfcc0, 0xd400), /* Check Type */
5567                 {}
5568         };
5569         static const struct coef_fw coef0298[] = {
5570                 UPDATE_COEF(0x50, 0x2000, 0x2000),
5571                 UPDATE_COEF(0x56, 0x0006, 0x0006),
5572                 UPDATE_COEF(0x66, 0x0008, 0),
5573                 UPDATE_COEF(0x67, 0x2000, 0),
5574                 UPDATE_COEF(0x19, 0x1300, 0x1300),
5575                 {}
5576         };
5577         static const struct coef_fw coef0293[] = {
5578                 UPDATE_COEF(0x4a, 0x000f, 0x0008), /* Combo Jack auto detect */
5579                 WRITE_COEF(0x45, 0xD429), /* Set to ctia type */
5580                 {}
5581         };
5582         static const struct coef_fw coef0688[] = {
5583                 WRITE_COEF(0x11, 0x0001),
5584                 WRITE_COEF(0xb7, 0x802b),
5585                 WRITE_COEF(0x15, 0x0d60),
5586                 WRITE_COEF(0xc3, 0x0c00),
5587                 {}
5588         };
5589         static const struct coef_fw coef0274[] = {
5590                 UPDATE_COEF(0x4a, 0x0010, 0),
5591                 UPDATE_COEF(0x4a, 0x8000, 0),
5592                 WRITE_COEF(0x45, 0xd289),
5593                 UPDATE_COEF(0x49, 0x0300, 0x0300),
5594                 {}
5595         };
5596
5597         if (spec->no_internal_mic_pin) {
5598                 alc_update_coef_idx(codec, 0x45, 0xf<<12 | 1<<10, 5<<12);
5599                 return;
5600         }
5601
5602         switch (codec->core.vendor_id) {
5603         case 0x10ec0255:
5604                 alc_process_coef_fw(codec, coef0255);
5605                 msleep(300);
5606                 val = alc_read_coef_idx(codec, 0x46);
5607                 is_ctia = (val & 0x0070) == 0x0070;
5608                 break;
5609         case 0x10ec0230:
5610         case 0x10ec0236:
5611         case 0x10ec0256:
5612         case 0x19e58326:
5613                 alc_write_coef_idx(codec, 0x1b, 0x0e4b);
5614                 alc_write_coef_idx(codec, 0x06, 0x6104);
5615                 alc_write_coefex_idx(codec, 0x57, 0x3, 0x09a3);
5616
5617                 snd_hda_codec_write(codec, 0x21, 0,
5618                             AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);
5619                 msleep(80);
5620                 snd_hda_codec_write(codec, 0x21, 0,
5621                             AC_VERB_SET_PIN_WIDGET_CONTROL, 0x0);
5622
5623                 alc_process_coef_fw(codec, coef0255);
5624                 msleep(300);
5625                 val = alc_read_coef_idx(codec, 0x46);
5626                 is_ctia = (val & 0x0070) == 0x0070;
5627
5628                 alc_write_coefex_idx(codec, 0x57, 0x3, 0x0da3);
5629                 alc_update_coefex_idx(codec, 0x57, 0x5, 1<<14, 0);
5630
5631                 snd_hda_codec_write(codec, 0x21, 0,
5632                             AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT);
5633                 msleep(80);
5634                 snd_hda_codec_write(codec, 0x21, 0,
5635                             AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE);
5636                 break;
5637         case 0x10ec0234:
5638         case 0x10ec0274:
5639         case 0x10ec0294:
5640                 alc_process_coef_fw(codec, coef0274);
5641                 msleep(850);
5642                 val = alc_read_coef_idx(codec, 0x46);
5643                 is_ctia = (val & 0x00f0) == 0x00f0;
5644                 break;
5645         case 0x10ec0233:
5646         case 0x10ec0283:
5647                 alc_write_coef_idx(codec, 0x45, 0xd029);
5648                 msleep(300);
5649                 val = alc_read_coef_idx(codec, 0x46);
5650                 is_ctia = (val & 0x0070) == 0x0070;
5651                 break;
5652         case 0x10ec0298:
5653                 snd_hda_codec_write(codec, 0x21, 0,
5654                             AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);
5655                 msleep(100);
5656                 snd_hda_codec_write(codec, 0x21, 0,
5657                             AC_VERB_SET_PIN_WIDGET_CONTROL, 0x0);
5658                 msleep(200);
5659
5660                 val = alc_read_coef_idx(codec, 0x50);
5661                 if (val & (1 << 12)) {
5662                         alc_update_coef_idx(codec, 0x8e, 0x0070, 0x0020);
5663                         alc_process_coef_fw(codec, coef0288);
5664                         msleep(350);
5665                         val = alc_read_coef_idx(codec, 0x50);
5666                         is_ctia = (val & 0x0070) == 0x0070;
5667                 } else {
5668                         alc_update_coef_idx(codec, 0x8e, 0x0070, 0x0010);
5669                         alc_process_coef_fw(codec, coef0288);
5670                         msleep(350);
5671                         val = alc_read_coef_idx(codec, 0x50);
5672                         is_ctia = (val & 0x0070) == 0x0070;
5673                 }
5674                 alc_process_coef_fw(codec, coef0298);
5675                 snd_hda_codec_write(codec, 0x21, 0,
5676                             AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP);
5677                 msleep(75);
5678                 snd_hda_codec_write(codec, 0x21, 0,
5679                             AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE);
5680                 break;
5681         case 0x10ec0286:
5682         case 0x10ec0288:
5683                 alc_process_coef_fw(codec, coef0288);
5684                 msleep(350);
5685                 val = alc_read_coef_idx(codec, 0x50);
5686                 is_ctia = (val & 0x0070) == 0x0070;
5687                 break;
5688         case 0x10ec0292:
5689                 alc_write_coef_idx(codec, 0x6b, 0xd429);
5690                 msleep(300);
5691                 val = alc_read_coef_idx(codec, 0x6c);
5692                 is_ctia = (val & 0x001c) == 0x001c;
5693                 break;
5694         case 0x10ec0293:
5695                 alc_process_coef_fw(codec, coef0293);
5696                 msleep(300);
5697                 val = alc_read_coef_idx(codec, 0x46);
5698                 is_ctia = (val & 0x0070) == 0x0070;
5699                 break;
5700         case 0x10ec0668:
5701                 alc_process_coef_fw(codec, coef0688);
5702                 msleep(300);
5703                 val = alc_read_coef_idx(codec, 0xbe);
5704                 is_ctia = (val & 0x1c02) == 0x1c02;
5705                 break;
5706         case 0x10ec0215:
5707         case 0x10ec0225:
5708         case 0x10ec0285:
5709         case 0x10ec0295:
5710         case 0x10ec0289:
5711         case 0x10ec0299:
5712                 snd_hda_codec_write(codec, 0x21, 0,
5713                             AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);
5714                 msleep(80);
5715                 snd_hda_codec_write(codec, 0x21, 0,
5716                             AC_VERB_SET_PIN_WIDGET_CONTROL, 0x0);
5717
5718                 alc_process_coef_fw(codec, alc225_pre_hsmode);
5719                 alc_update_coef_idx(codec, 0x67, 0xf000, 0x1000);
5720                 val = alc_read_coef_idx(codec, 0x45);
5721                 if (val & (1 << 9)) {
5722                         alc_update_coef_idx(codec, 0x45, 0x3f<<10, 0x34<<10);
5723                         alc_update_coef_idx(codec, 0x49, 3<<8, 2<<8);
5724                         msleep(800);
5725                         val = alc_read_coef_idx(codec, 0x46);
5726                         is_ctia = (val & 0x00f0) == 0x00f0;
5727                 } else {
5728                         alc_update_coef_idx(codec, 0x45, 0x3f<<10, 0x34<<10);
5729                         alc_update_coef_idx(codec, 0x49, 3<<8, 1<<8);
5730                         msleep(800);
5731                         val = alc_read_coef_idx(codec, 0x46);
5732                         is_ctia = (val & 0x00f0) == 0x00f0;
5733                 }
5734                 alc_update_coef_idx(codec, 0x4a, 7<<6, 7<<6);
5735                 alc_update_coef_idx(codec, 0x4a, 3<<4, 3<<4);
5736                 alc_update_coef_idx(codec, 0x67, 0xf000, 0x3000);
5737
5738                 snd_hda_codec_write(codec, 0x21, 0,
5739                             AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT);
5740                 msleep(80);
5741                 snd_hda_codec_write(codec, 0x21, 0,
5742                             AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE);
5743                 break;
5744         case 0x10ec0867:
5745                 is_ctia = true;
5746                 break;
5747         }
5748
5749         codec_dbg(codec, "Headset jack detected iPhone-style headset: %s\n",
5750                     is_ctia ? "yes" : "no");
5751         spec->current_headset_type = is_ctia ? ALC_HEADSET_TYPE_CTIA : ALC_HEADSET_TYPE_OMTP;
5752 }
5753
5754 static void alc_update_headset_mode(struct hda_codec *codec)
5755 {
5756         struct alc_spec *spec = codec->spec;
5757
5758         hda_nid_t mux_pin = spec->gen.imux_pins[spec->gen.cur_mux[0]];
5759         hda_nid_t hp_pin = alc_get_hp_pin(spec);
5760
5761         int new_headset_mode;
5762
5763         if (!snd_hda_jack_detect(codec, hp_pin))
5764                 new_headset_mode = ALC_HEADSET_MODE_UNPLUGGED;
5765         else if (mux_pin == spec->headset_mic_pin)
5766                 new_headset_mode = ALC_HEADSET_MODE_HEADSET;
5767         else if (mux_pin == spec->headphone_mic_pin)
5768                 new_headset_mode = ALC_HEADSET_MODE_MIC;
5769         else
5770                 new_headset_mode = ALC_HEADSET_MODE_HEADPHONE;
5771
5772         if (new_headset_mode == spec->current_headset_mode) {
5773                 snd_hda_gen_update_outputs(codec);
5774                 return;
5775         }
5776
5777         switch (new_headset_mode) {
5778         case ALC_HEADSET_MODE_UNPLUGGED:
5779                 alc_headset_mode_unplugged(codec);
5780                 spec->current_headset_mode = ALC_HEADSET_MODE_UNKNOWN;
5781                 spec->current_headset_type = ALC_HEADSET_TYPE_UNKNOWN;
5782                 spec->gen.hp_jack_present = false;
5783                 break;
5784         case ALC_HEADSET_MODE_HEADSET:
5785                 if (spec->current_headset_type == ALC_HEADSET_TYPE_UNKNOWN)
5786                         alc_determine_headset_type(codec);
5787                 if (spec->current_headset_type == ALC_HEADSET_TYPE_CTIA)
5788                         alc_headset_mode_ctia(codec);
5789                 else if (spec->current_headset_type == ALC_HEADSET_TYPE_OMTP)
5790                         alc_headset_mode_omtp(codec);
5791                 spec->gen.hp_jack_present = true;
5792                 break;
5793         case ALC_HEADSET_MODE_MIC:
5794                 alc_headset_mode_mic_in(codec, hp_pin, spec->headphone_mic_pin);
5795                 spec->gen.hp_jack_present = false;
5796                 break;
5797         case ALC_HEADSET_MODE_HEADPHONE:
5798                 alc_headset_mode_default(codec);
5799                 spec->gen.hp_jack_present = true;
5800                 break;
5801         }
5802         if (new_headset_mode != ALC_HEADSET_MODE_MIC) {
5803                 snd_hda_set_pin_ctl_cache(codec, hp_pin,
5804                                           AC_PINCTL_OUT_EN | AC_PINCTL_HP_EN);
5805                 if (spec->headphone_mic_pin && spec->headphone_mic_pin != hp_pin)
5806                         snd_hda_set_pin_ctl_cache(codec, spec->headphone_mic_pin,
5807                                                   PIN_VREFHIZ);
5808         }
5809         spec->current_headset_mode = new_headset_mode;
5810
5811         snd_hda_gen_update_outputs(codec);
5812 }
5813
5814 static void alc_update_headset_mode_hook(struct hda_codec *codec,
5815                                          struct snd_kcontrol *kcontrol,
5816                                          struct snd_ctl_elem_value *ucontrol)
5817 {
5818         alc_update_headset_mode(codec);
5819 }
5820
5821 static void alc_update_headset_jack_cb(struct hda_codec *codec,
5822                                        struct hda_jack_callback *jack)
5823 {
5824         snd_hda_gen_hp_automute(codec, jack);
5825         alc_update_headset_mode(codec);
5826 }
5827
5828 static void alc_probe_headset_mode(struct hda_codec *codec)
5829 {
5830         int i;
5831         struct alc_spec *spec = codec->spec;
5832         struct auto_pin_cfg *cfg = &spec->gen.autocfg;
5833
5834         /* Find mic pins */
5835         for (i = 0; i < cfg->num_inputs; i++) {
5836                 if (cfg->inputs[i].is_headset_mic && !spec->headset_mic_pin)
5837                         spec->headset_mic_pin = cfg->inputs[i].pin;
5838                 if (cfg->inputs[i].is_headphone_mic && !spec->headphone_mic_pin)
5839                         spec->headphone_mic_pin = cfg->inputs[i].pin;
5840         }
5841
5842         WARN_ON(spec->gen.cap_sync_hook);
5843         spec->gen.cap_sync_hook = alc_update_headset_mode_hook;
5844         spec->gen.automute_hook = alc_update_headset_mode;
5845         spec->gen.hp_automute_hook = alc_update_headset_jack_cb;
5846 }
5847
5848 static void alc_fixup_headset_mode(struct hda_codec *codec,
5849                                 const struct hda_fixup *fix, int action)
5850 {
5851         struct alc_spec *spec = codec->spec;
5852
5853         switch (action) {
5854         case HDA_FIXUP_ACT_PRE_PROBE:
5855                 spec->parse_flags |= HDA_PINCFG_HEADSET_MIC | HDA_PINCFG_HEADPHONE_MIC;
5856                 break;
5857         case HDA_FIXUP_ACT_PROBE:
5858                 alc_probe_headset_mode(codec);
5859                 break;
5860         case HDA_FIXUP_ACT_INIT:
5861                 if (is_s3_resume(codec) || is_s4_resume(codec)) {
5862                         spec->current_headset_mode = ALC_HEADSET_MODE_UNKNOWN;
5863                         spec->current_headset_type = ALC_HEADSET_TYPE_UNKNOWN;
5864                 }
5865                 alc_update_headset_mode(codec);
5866                 break;
5867         }
5868 }
5869
5870 static void alc_fixup_headset_mode_no_hp_mic(struct hda_codec *codec,
5871                                 const struct hda_fixup *fix, int action)
5872 {
5873         if (action == HDA_FIXUP_ACT_PRE_PROBE) {
5874                 struct alc_spec *spec = codec->spec;
5875                 spec->parse_flags |= HDA_PINCFG_HEADSET_MIC;
5876         }
5877         else
5878                 alc_fixup_headset_mode(codec, fix, action);
5879 }
5880
5881 static void alc255_set_default_jack_type(struct hda_codec *codec)
5882 {
5883         /* Set to iphone type */
5884         static const struct coef_fw alc255fw[] = {
5885                 WRITE_COEF(0x1b, 0x880b),
5886                 WRITE_COEF(0x45, 0xd089),
5887                 WRITE_COEF(0x1b, 0x080b),
5888                 WRITE_COEF(0x46, 0x0004),
5889                 WRITE_COEF(0x1b, 0x0c0b),
5890                 {}
5891         };
5892         static const struct coef_fw alc256fw[] = {
5893                 WRITE_COEF(0x1b, 0x884b),
5894                 WRITE_COEF(0x45, 0xd089),
5895                 WRITE_COEF(0x1b, 0x084b),
5896                 WRITE_COEF(0x46, 0x0004),
5897                 WRITE_COEF(0x1b, 0x0c4b),
5898                 {}
5899         };
5900         switch (codec->core.vendor_id) {
5901         case 0x10ec0255:
5902                 alc_process_coef_fw(codec, alc255fw);
5903                 break;
5904         case 0x10ec0230:
5905         case 0x10ec0236:
5906         case 0x10ec0256:
5907         case 0x19e58326:
5908                 alc_process_coef_fw(codec, alc256fw);
5909                 break;
5910         }
5911         msleep(30);
5912 }
5913
5914 static void alc_fixup_headset_mode_alc255(struct hda_codec *codec,
5915                                 const struct hda_fixup *fix, int action)
5916 {
5917         if (action == HDA_FIXUP_ACT_PRE_PROBE) {
5918                 alc255_set_default_jack_type(codec);
5919         }
5920         alc_fixup_headset_mode(codec, fix, action);
5921 }
5922
5923 static void alc_fixup_headset_mode_alc255_no_hp_mic(struct hda_codec *codec,
5924                                 const struct hda_fixup *fix, int action)
5925 {
5926         if (action == HDA_FIXUP_ACT_PRE_PROBE) {
5927                 struct alc_spec *spec = codec->spec;
5928                 spec->parse_flags |= HDA_PINCFG_HEADSET_MIC;
5929                 alc255_set_default_jack_type(codec);
5930         }
5931         else
5932                 alc_fixup_headset_mode(codec, fix, action);
5933 }
5934
5935 static void alc288_update_headset_jack_cb(struct hda_codec *codec,
5936                                        struct hda_jack_callback *jack)
5937 {
5938         struct alc_spec *spec = codec->spec;
5939
5940         alc_update_headset_jack_cb(codec, jack);
5941         /* Headset Mic enable or disable, only for Dell Dino */
5942         alc_update_gpio_data(codec, 0x40, spec->gen.hp_jack_present);
5943 }
5944
5945 static void alc_fixup_headset_mode_dell_alc288(struct hda_codec *codec,
5946                                 const struct hda_fixup *fix, int action)
5947 {
5948         alc_fixup_headset_mode(codec, fix, action);
5949         if (action == HDA_FIXUP_ACT_PROBE) {
5950                 struct alc_spec *spec = codec->spec;
5951                 /* toggled via hp_automute_hook */
5952                 spec->gpio_mask |= 0x40;
5953                 spec->gpio_dir |= 0x40;
5954                 spec->gen.hp_automute_hook = alc288_update_headset_jack_cb;
5955         }
5956 }
5957
5958 static void alc_fixup_auto_mute_via_amp(struct hda_codec *codec,
5959                                         const struct hda_fixup *fix, int action)
5960 {
5961         if (action == HDA_FIXUP_ACT_PRE_PROBE) {
5962                 struct alc_spec *spec = codec->spec;
5963                 spec->gen.auto_mute_via_amp = 1;
5964         }
5965 }
5966
5967 static void alc_fixup_no_shutup(struct hda_codec *codec,
5968                                 const struct hda_fixup *fix, int action)
5969 {
5970         if (action == HDA_FIXUP_ACT_PRE_PROBE) {
5971                 struct alc_spec *spec = codec->spec;
5972                 spec->no_shutup_pins = 1;
5973         }
5974 }
5975
5976 static void alc_fixup_disable_aamix(struct hda_codec *codec,
5977                                     const struct hda_fixup *fix, int action)
5978 {
5979         if (action == HDA_FIXUP_ACT_PRE_PROBE) {
5980                 struct alc_spec *spec = codec->spec;
5981                 /* Disable AA-loopback as it causes white noise */
5982                 spec->gen.mixer_nid = 0;
5983         }
5984 }
5985
5986 /* fixup for Thinkpad docks: add dock pins, avoid HP parser fixup */
5987 static void alc_fixup_tpt440_dock(struct hda_codec *codec,
5988                                   const struct hda_fixup *fix, int action)
5989 {
5990         static const struct hda_pintbl pincfgs[] = {
5991                 { 0x16, 0x21211010 }, /* dock headphone */
5992                 { 0x19, 0x21a11010 }, /* dock mic */
5993                 { }
5994         };
5995         struct alc_spec *spec = codec->spec;
5996
5997         if (action == HDA_FIXUP_ACT_PRE_PROBE) {
5998                 spec->parse_flags = HDA_PINCFG_NO_HP_FIXUP;
5999                 codec->power_save_node = 0; /* avoid click noises */
6000                 snd_hda_apply_pincfgs(codec, pincfgs);
6001         }
6002 }
6003
6004 static void alc_fixup_tpt470_dock(struct hda_codec *codec,
6005                                   const struct hda_fixup *fix, int action)
6006 {
6007         static const struct hda_pintbl pincfgs[] = {
6008                 { 0x17, 0x21211010 }, /* dock headphone */
6009                 { 0x19, 0x21a11010 }, /* dock mic */
6010                 { }
6011         };
6012         struct alc_spec *spec = codec->spec;
6013
6014         if (action == HDA_FIXUP_ACT_PRE_PROBE) {
6015                 spec->parse_flags = HDA_PINCFG_NO_HP_FIXUP;
6016                 snd_hda_apply_pincfgs(codec, pincfgs);
6017         } else if (action == HDA_FIXUP_ACT_INIT) {
6018                 /* Enable DOCK device */
6019                 snd_hda_codec_write(codec, 0x17, 0,
6020                             AC_VERB_SET_CONFIG_DEFAULT_BYTES_3, 0);
6021                 /* Enable DOCK device */
6022                 snd_hda_codec_write(codec, 0x19, 0,
6023                             AC_VERB_SET_CONFIG_DEFAULT_BYTES_3, 0);
6024         }
6025 }
6026
6027 static void alc_fixup_tpt470_dacs(struct hda_codec *codec,
6028                                   const struct hda_fixup *fix, int action)
6029 {
6030         /* Assure the speaker pin to be coupled with DAC NID 0x03; otherwise
6031          * the speaker output becomes too low by some reason on Thinkpads with
6032          * ALC298 codec
6033          */
6034         static const hda_nid_t preferred_pairs[] = {
6035                 0x14, 0x03, 0x17, 0x02, 0x21, 0x02,
6036                 0
6037         };
6038         struct alc_spec *spec = codec->spec;
6039
6040         if (action == HDA_FIXUP_ACT_PRE_PROBE)
6041                 spec->gen.preferred_dacs = preferred_pairs;
6042 }
6043
6044 static void alc295_fixup_asus_dacs(struct hda_codec *codec,
6045                                    const struct hda_fixup *fix, int action)
6046 {
6047         static const hda_nid_t preferred_pairs[] = {
6048                 0x17, 0x02, 0x21, 0x03, 0
6049         };
6050         struct alc_spec *spec = codec->spec;
6051
6052         if (action == HDA_FIXUP_ACT_PRE_PROBE)
6053                 spec->gen.preferred_dacs = preferred_pairs;
6054 }
6055
6056 static void alc_shutup_dell_xps13(struct hda_codec *codec)
6057 {
6058         struct alc_spec *spec = codec->spec;
6059         int hp_pin = alc_get_hp_pin(spec);
6060
6061         /* Prevent pop noises when headphones are plugged in */
6062         snd_hda_codec_write(codec, hp_pin, 0,
6063                             AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);
6064         msleep(20);
6065 }
6066
6067 static void alc_fixup_dell_xps13(struct hda_codec *codec,
6068                                 const struct hda_fixup *fix, int action)
6069 {
6070         struct alc_spec *spec = codec->spec;
6071         struct hda_input_mux *imux = &spec->gen.input_mux;
6072         int i;
6073
6074         switch (action) {
6075         case HDA_FIXUP_ACT_PRE_PROBE:
6076                 /* mic pin 0x19 must be initialized with Vref Hi-Z, otherwise
6077                  * it causes a click noise at start up
6078                  */
6079                 snd_hda_codec_set_pin_target(codec, 0x19, PIN_VREFHIZ);
6080                 spec->shutup = alc_shutup_dell_xps13;
6081                 break;
6082         case HDA_FIXUP_ACT_PROBE:
6083                 /* Make the internal mic the default input source. */
6084                 for (i = 0; i < imux->num_items; i++) {
6085                         if (spec->gen.imux_pins[i] == 0x12) {
6086                                 spec->gen.cur_mux[0] = i;
6087                                 break;
6088                         }
6089                 }
6090                 break;
6091         }
6092 }
6093
6094 static void alc_fixup_headset_mode_alc662(struct hda_codec *codec,
6095                                 const struct hda_fixup *fix, int action)
6096 {
6097         struct alc_spec *spec = codec->spec;
6098
6099         if (action == HDA_FIXUP_ACT_PRE_PROBE) {
6100                 spec->parse_flags |= HDA_PINCFG_HEADSET_MIC;
6101                 spec->gen.hp_mic = 1; /* Mic-in is same pin as headphone */
6102
6103                 /* Disable boost for mic-in permanently. (This code is only called
6104                    from quirks that guarantee that the headphone is at NID 0x1b.) */
6105                 snd_hda_codec_write(codec, 0x1b, 0, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000);
6106                 snd_hda_override_wcaps(codec, 0x1b, get_wcaps(codec, 0x1b) & ~AC_WCAP_IN_AMP);
6107         } else
6108                 alc_fixup_headset_mode(codec, fix, action);
6109 }
6110
6111 static void alc_fixup_headset_mode_alc668(struct hda_codec *codec,
6112                                 const struct hda_fixup *fix, int action)
6113 {
6114         if (action == HDA_FIXUP_ACT_PRE_PROBE) {
6115                 alc_write_coef_idx(codec, 0xc4, 0x8000);
6116                 alc_update_coef_idx(codec, 0xc2, ~0xfe, 0);
6117                 snd_hda_set_pin_ctl_cache(codec, 0x18, 0);
6118         }
6119         alc_fixup_headset_mode(codec, fix, action);
6120 }
6121
6122 /* Returns the nid of the external mic input pin, or 0 if it cannot be found. */
6123 static int find_ext_mic_pin(struct hda_codec *codec)
6124 {
6125         struct alc_spec *spec = codec->spec;
6126         struct auto_pin_cfg *cfg = &spec->gen.autocfg;
6127         hda_nid_t nid;
6128         unsigned int defcfg;
6129         int i;
6130
6131         for (i = 0; i < cfg->num_inputs; i++) {
6132                 if (cfg->inputs[i].type != AUTO_PIN_MIC)
6133                         continue;
6134                 nid = cfg->inputs[i].pin;
6135                 defcfg = snd_hda_codec_get_pincfg(codec, nid);
6136                 if (snd_hda_get_input_pin_attr(defcfg) == INPUT_PIN_ATTR_INT)
6137                         continue;
6138                 return nid;
6139         }
6140
6141         return 0;
6142 }
6143
6144 static void alc271_hp_gate_mic_jack(struct hda_codec *codec,
6145                                     const struct hda_fixup *fix,
6146                                     int action)
6147 {
6148         struct alc_spec *spec = codec->spec;
6149
6150         if (action == HDA_FIXUP_ACT_PROBE) {
6151                 int mic_pin = find_ext_mic_pin(codec);
6152                 int hp_pin = alc_get_hp_pin(spec);
6153
6154                 if (snd_BUG_ON(!mic_pin || !hp_pin))
6155                         return;
6156                 snd_hda_jack_set_gating_jack(codec, mic_pin, hp_pin);
6157         }
6158 }
6159
6160 static void alc269_fixup_limit_int_mic_boost(struct hda_codec *codec,
6161                                              const struct hda_fixup *fix,
6162                                              int action)
6163 {
6164         struct alc_spec *spec = codec->spec;
6165         struct auto_pin_cfg *cfg = &spec->gen.autocfg;
6166         int i;
6167
6168         /* The mic boosts on level 2 and 3 are too noisy
6169            on the internal mic input.
6170            Therefore limit the boost to 0 or 1. */
6171
6172         if (action != HDA_FIXUP_ACT_PROBE)
6173                 return;
6174
6175         for (i = 0; i < cfg->num_inputs; i++) {
6176                 hda_nid_t nid = cfg->inputs[i].pin;
6177                 unsigned int defcfg;
6178                 if (cfg->inputs[i].type != AUTO_PIN_MIC)
6179                         continue;
6180                 defcfg = snd_hda_codec_get_pincfg(codec, nid);
6181                 if (snd_hda_get_input_pin_attr(defcfg) != INPUT_PIN_ATTR_INT)
6182                         continue;
6183
6184                 snd_hda_override_amp_caps(codec, nid, HDA_INPUT,
6185                                           (0x00 << AC_AMPCAP_OFFSET_SHIFT) |
6186                                           (0x01 << AC_AMPCAP_NUM_STEPS_SHIFT) |
6187                                           (0x2f << AC_AMPCAP_STEP_SIZE_SHIFT) |
6188                                           (0 << AC_AMPCAP_MUTE_SHIFT));
6189         }
6190 }
6191
6192 static void alc283_hp_automute_hook(struct hda_codec *codec,
6193                                     struct hda_jack_callback *jack)
6194 {
6195         struct alc_spec *spec = codec->spec;
6196         int vref;
6197
6198         msleep(200);
6199         snd_hda_gen_hp_automute(codec, jack);
6200
6201         vref = spec->gen.hp_jack_present ? PIN_VREF80 : 0;
6202
6203         msleep(600);
6204         snd_hda_codec_write(codec, 0x19, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
6205                             vref);
6206 }
6207
6208 static void alc283_fixup_chromebook(struct hda_codec *codec,
6209                                     const struct hda_fixup *fix, int action)
6210 {
6211         struct alc_spec *spec = codec->spec;
6212
6213         switch (action) {
6214         case HDA_FIXUP_ACT_PRE_PROBE:
6215                 snd_hda_override_wcaps(codec, 0x03, 0);
6216                 /* Disable AA-loopback as it causes white noise */
6217                 spec->gen.mixer_nid = 0;
6218                 break;
6219         case HDA_FIXUP_ACT_INIT:
6220                 /* MIC2-VREF control */
6221                 /* Set to manual mode */
6222                 alc_update_coef_idx(codec, 0x06, 0x000c, 0);
6223                 /* Enable Line1 input control by verb */
6224                 alc_update_coef_idx(codec, 0x1a, 0, 1 << 4);
6225                 break;
6226         }
6227 }
6228
6229 static void alc283_fixup_sense_combo_jack(struct hda_codec *codec,
6230                                     const struct hda_fixup *fix, int action)
6231 {
6232         struct alc_spec *spec = codec->spec;
6233
6234         switch (action) {
6235         case HDA_FIXUP_ACT_PRE_PROBE:
6236                 spec->gen.hp_automute_hook = alc283_hp_automute_hook;
6237                 break;
6238         case HDA_FIXUP_ACT_INIT:
6239                 /* MIC2-VREF control */
6240                 /* Set to manual mode */
6241                 alc_update_coef_idx(codec, 0x06, 0x000c, 0);
6242                 break;
6243         }
6244 }
6245
6246 /* mute tablet speaker pin (0x14) via dock plugging in addition */
6247 static void asus_tx300_automute(struct hda_codec *codec)
6248 {
6249         struct alc_spec *spec = codec->spec;
6250         snd_hda_gen_update_outputs(codec);
6251         if (snd_hda_jack_detect(codec, 0x1b))
6252                 spec->gen.mute_bits |= (1ULL << 0x14);
6253 }
6254
6255 static void alc282_fixup_asus_tx300(struct hda_codec *codec,
6256                                     const struct hda_fixup *fix, int action)
6257 {
6258         struct alc_spec *spec = codec->spec;
6259         static const struct hda_pintbl dock_pins[] = {
6260                 { 0x1b, 0x21114000 }, /* dock speaker pin */
6261                 {}
6262         };
6263
6264         switch (action) {
6265         case HDA_FIXUP_ACT_PRE_PROBE:
6266                 spec->init_amp = ALC_INIT_DEFAULT;
6267                 /* TX300 needs to set up GPIO2 for the speaker amp */
6268                 alc_setup_gpio(codec, 0x04);
6269                 snd_hda_apply_pincfgs(codec, dock_pins);
6270                 spec->gen.auto_mute_via_amp = 1;
6271                 spec->gen.automute_hook = asus_tx300_automute;
6272                 snd_hda_jack_detect_enable_callback(codec, 0x1b,
6273                                                     snd_hda_gen_hp_automute);
6274                 break;
6275         case HDA_FIXUP_ACT_PROBE:
6276                 spec->init_amp = ALC_INIT_DEFAULT;
6277                 break;
6278         case HDA_FIXUP_ACT_BUILD:
6279                 /* this is a bit tricky; give more sane names for the main
6280                  * (tablet) speaker and the dock speaker, respectively
6281                  */
6282                 rename_ctl(codec, "Speaker Playback Switch",
6283                            "Dock Speaker Playback Switch");
6284                 rename_ctl(codec, "Bass Speaker Playback Switch",
6285                            "Speaker Playback Switch");
6286                 break;
6287         }
6288 }
6289
6290 static void alc290_fixup_mono_speakers(struct hda_codec *codec,
6291                                        const struct hda_fixup *fix, int action)
6292 {
6293         if (action == HDA_FIXUP_ACT_PRE_PROBE) {
6294                 /* DAC node 0x03 is giving mono output. We therefore want to
6295                    make sure 0x14 (front speaker) and 0x15 (headphones) use the
6296                    stereo DAC, while leaving 0x17 (bass speaker) for node 0x03. */
6297                 static const hda_nid_t conn1[] = { 0x0c };
6298                 snd_hda_override_conn_list(codec, 0x14, ARRAY_SIZE(conn1), conn1);
6299                 snd_hda_override_conn_list(codec, 0x15, ARRAY_SIZE(conn1), conn1);
6300         }
6301 }
6302
6303 static void alc298_fixup_speaker_volume(struct hda_codec *codec,
6304                                         const struct hda_fixup *fix, int action)
6305 {
6306         if (action == HDA_FIXUP_ACT_PRE_PROBE) {
6307                 /* The speaker is routed to the Node 0x06 by a mistake, as a result
6308                    we can't adjust the speaker's volume since this node does not has
6309                    Amp-out capability. we change the speaker's route to:
6310                    Node 0x02 (Audio Output) -> Node 0x0c (Audio Mixer) -> Node 0x17 (
6311                    Pin Complex), since Node 0x02 has Amp-out caps, we can adjust
6312                    speaker's volume now. */
6313
6314                 static const hda_nid_t conn1[] = { 0x0c };
6315                 snd_hda_override_conn_list(codec, 0x17, ARRAY_SIZE(conn1), conn1);
6316         }
6317 }
6318
6319 /* disable DAC3 (0x06) selection on NID 0x17 as it has no volume amp control */
6320 static void alc295_fixup_disable_dac3(struct hda_codec *codec,
6321                                       const struct hda_fixup *fix, int action)
6322 {
6323         if (action == HDA_FIXUP_ACT_PRE_PROBE) {
6324                 static const hda_nid_t conn[] = { 0x02, 0x03 };
6325                 snd_hda_override_conn_list(codec, 0x17, ARRAY_SIZE(conn), conn);
6326         }
6327 }
6328
6329 /* force NID 0x17 (Bass Speaker) to DAC1 to share it with the main speaker */
6330 static void alc285_fixup_speaker2_to_dac1(struct hda_codec *codec,
6331                                           const struct hda_fixup *fix, int action)
6332 {
6333         if (action == HDA_FIXUP_ACT_PRE_PROBE) {
6334                 static const hda_nid_t conn[] = { 0x02 };
6335                 snd_hda_override_conn_list(codec, 0x17, ARRAY_SIZE(conn), conn);
6336         }
6337 }
6338
6339 /* Hook to update amp GPIO4 for automute */
6340 static void alc280_hp_gpio4_automute_hook(struct hda_codec *codec,
6341                                           struct hda_jack_callback *jack)
6342 {
6343         struct alc_spec *spec = codec->spec;
6344
6345         snd_hda_gen_hp_automute(codec, jack);
6346         /* mute_led_polarity is set to 0, so we pass inverted value here */
6347         alc_update_gpio_led(codec, 0x10, spec->mute_led_polarity,
6348                             !spec->gen.hp_jack_present);
6349 }
6350
6351 /* Manage GPIOs for HP EliteBook Folio 9480m.
6352  *
6353  * GPIO4 is the headphone amplifier power control
6354  * GPIO3 is the audio output mute indicator LED
6355  */
6356
6357 static void alc280_fixup_hp_9480m(struct hda_codec *codec,
6358                                   const struct hda_fixup *fix,
6359                                   int action)
6360 {
6361         struct alc_spec *spec = codec->spec;
6362
6363         alc_fixup_hp_gpio_led(codec, action, 0x08, 0);
6364         if (action == HDA_FIXUP_ACT_PRE_PROBE) {
6365                 /* amp at GPIO4; toggled via alc280_hp_gpio4_automute_hook() */
6366                 spec->gpio_mask |= 0x10;
6367                 spec->gpio_dir |= 0x10;
6368                 spec->gen.hp_automute_hook = alc280_hp_gpio4_automute_hook;
6369         }
6370 }
6371
6372 static void alc275_fixup_gpio4_off(struct hda_codec *codec,
6373                                    const struct hda_fixup *fix,
6374                                    int action)
6375 {
6376         struct alc_spec *spec = codec->spec;
6377
6378         if (action == HDA_FIXUP_ACT_PRE_PROBE) {
6379                 spec->gpio_mask |= 0x04;
6380                 spec->gpio_dir |= 0x04;
6381                 /* set data bit low */
6382         }
6383 }
6384
6385 /* Quirk for Thinkpad X1 7th and 8th Gen
6386  * The following fixed routing needed
6387  * DAC1 (NID 0x02) -> Speaker (NID 0x14); some eq applied secretly
6388  * DAC2 (NID 0x03) -> Bass (NID 0x17) & Headphone (NID 0x21); sharing a DAC
6389  * DAC3 (NID 0x06) -> Unused, due to the lack of volume amp
6390  */
6391 static void alc285_fixup_thinkpad_x1_gen7(struct hda_codec *codec,
6392                                           const struct hda_fixup *fix, int action)
6393 {
6394         static const hda_nid_t conn[] = { 0x02, 0x03 }; /* exclude 0x06 */
6395         static const hda_nid_t preferred_pairs[] = {
6396                 0x14, 0x02, 0x17, 0x03, 0x21, 0x03, 0
6397         };
6398         struct alc_spec *spec = codec->spec;
6399
6400         switch (action) {
6401         case HDA_FIXUP_ACT_PRE_PROBE:
6402                 snd_hda_override_conn_list(codec, 0x17, ARRAY_SIZE(conn), conn);
6403                 spec->gen.preferred_dacs = preferred_pairs;
6404                 break;
6405         case HDA_FIXUP_ACT_BUILD:
6406                 /* The generic parser creates somewhat unintuitive volume ctls
6407                  * with the fixed routing above, and the shared DAC2 may be
6408                  * confusing for PA.
6409                  * Rename those to unique names so that PA doesn't touch them
6410                  * and use only Master volume.
6411                  */
6412                 rename_ctl(codec, "Front Playback Volume", "DAC1 Playback Volume");
6413                 rename_ctl(codec, "Bass Speaker Playback Volume", "DAC2 Playback Volume");
6414                 break;
6415         }
6416 }
6417
6418 static void alc233_alc662_fixup_lenovo_dual_codecs(struct hda_codec *codec,
6419                                          const struct hda_fixup *fix,
6420                                          int action)
6421 {
6422         alc_fixup_dual_codecs(codec, fix, action);
6423         switch (action) {
6424         case HDA_FIXUP_ACT_PRE_PROBE:
6425                 /* override card longname to provide a unique UCM profile */
6426                 strcpy(codec->card->longname, "HDAudio-Lenovo-DualCodecs");
6427                 break;
6428         case HDA_FIXUP_ACT_BUILD:
6429                 /* rename Capture controls depending on the codec */
6430                 rename_ctl(codec, "Capture Volume",
6431                            codec->addr == 0 ?
6432                            "Rear-Panel Capture Volume" :
6433                            "Front-Panel Capture Volume");
6434                 rename_ctl(codec, "Capture Switch",
6435                            codec->addr == 0 ?
6436                            "Rear-Panel Capture Switch" :
6437                            "Front-Panel Capture Switch");
6438                 break;
6439         }
6440 }
6441
6442 static void alc225_fixup_s3_pop_noise(struct hda_codec *codec,
6443                                       const struct hda_fixup *fix, int action)
6444 {
6445         if (action != HDA_FIXUP_ACT_PRE_PROBE)
6446                 return;
6447
6448         codec->power_save_node = 1;
6449 }
6450
6451 /* Forcibly assign NID 0x03 to HP/LO while NID 0x02 to SPK for EQ */
6452 static void alc274_fixup_bind_dacs(struct hda_codec *codec,
6453                                     const struct hda_fixup *fix, int action)
6454 {
6455         struct alc_spec *spec = codec->spec;
6456         static const hda_nid_t preferred_pairs[] = {
6457                 0x21, 0x03, 0x1b, 0x03, 0x16, 0x02,
6458                 0
6459         };
6460
6461         if (action != HDA_FIXUP_ACT_PRE_PROBE)
6462                 return;
6463
6464         spec->gen.preferred_dacs = preferred_pairs;
6465         spec->gen.auto_mute_via_amp = 1;
6466         codec->power_save_node = 0;
6467 }
6468
6469 /* avoid DAC 0x06 for bass speaker 0x17; it has no volume control */
6470 static void alc289_fixup_asus_ga401(struct hda_codec *codec,
6471                                     const struct hda_fixup *fix, int action)
6472 {
6473         static const hda_nid_t preferred_pairs[] = {
6474                 0x14, 0x02, 0x17, 0x02, 0x21, 0x03, 0
6475         };
6476         struct alc_spec *spec = codec->spec;
6477
6478         if (action == HDA_FIXUP_ACT_PRE_PROBE) {
6479                 spec->gen.preferred_dacs = preferred_pairs;
6480                 spec->gen.obey_preferred_dacs = 1;
6481         }
6482 }
6483
6484 /* The DAC of NID 0x3 will introduce click/pop noise on headphones, so invalidate it */
6485 static void alc285_fixup_invalidate_dacs(struct hda_codec *codec,
6486                               const struct hda_fixup *fix, int action)
6487 {
6488         if (action != HDA_FIXUP_ACT_PRE_PROBE)
6489                 return;
6490
6491         snd_hda_override_wcaps(codec, 0x03, 0);
6492 }
6493
6494 static void alc_combo_jack_hp_jd_restart(struct hda_codec *codec)
6495 {
6496         switch (codec->core.vendor_id) {
6497         case 0x10ec0274:
6498         case 0x10ec0294:
6499         case 0x10ec0225:
6500         case 0x10ec0295:
6501         case 0x10ec0299:
6502                 alc_update_coef_idx(codec, 0x4a, 0x8000, 1 << 15); /* Reset HP JD */
6503                 alc_update_coef_idx(codec, 0x4a, 0x8000, 0 << 15);
6504                 break;
6505         case 0x10ec0230:
6506         case 0x10ec0235:
6507         case 0x10ec0236:
6508         case 0x10ec0255:
6509         case 0x10ec0256:
6510         case 0x10ec0257:
6511         case 0x19e58326:
6512                 alc_update_coef_idx(codec, 0x1b, 0x8000, 1 << 15); /* Reset HP JD */
6513                 alc_update_coef_idx(codec, 0x1b, 0x8000, 0 << 15);
6514                 break;
6515         }
6516 }
6517
6518 static void alc295_fixup_chromebook(struct hda_codec *codec,
6519                                     const struct hda_fixup *fix, int action)
6520 {
6521         struct alc_spec *spec = codec->spec;
6522
6523         switch (action) {
6524         case HDA_FIXUP_ACT_PRE_PROBE:
6525                 spec->ultra_low_power = true;
6526                 break;
6527         case HDA_FIXUP_ACT_INIT:
6528                 alc_combo_jack_hp_jd_restart(codec);
6529                 break;
6530         }
6531 }
6532
6533 static void alc_fixup_disable_mic_vref(struct hda_codec *codec,
6534                                   const struct hda_fixup *fix, int action)
6535 {
6536         if (action == HDA_FIXUP_ACT_PRE_PROBE)
6537                 snd_hda_codec_set_pin_target(codec, 0x19, PIN_VREFHIZ);
6538 }
6539
6540
6541 static void alc294_gx502_toggle_output(struct hda_codec *codec,
6542                                         struct hda_jack_callback *cb)
6543 {
6544         /* The Windows driver sets the codec up in a very different way where
6545          * it appears to leave 0x10 = 0x8a20 set. For Linux we need to toggle it
6546          */
6547         if (snd_hda_jack_detect_state(codec, 0x21) == HDA_JACK_PRESENT)
6548                 alc_write_coef_idx(codec, 0x10, 0x8a20);
6549         else
6550                 alc_write_coef_idx(codec, 0x10, 0x0a20);
6551 }
6552
6553 static void alc294_fixup_gx502_hp(struct hda_codec *codec,
6554                                         const struct hda_fixup *fix, int action)
6555 {
6556         /* Pin 0x21: headphones/headset mic */
6557         if (!is_jack_detectable(codec, 0x21))
6558                 return;
6559
6560         switch (action) {
6561         case HDA_FIXUP_ACT_PRE_PROBE:
6562                 snd_hda_jack_detect_enable_callback(codec, 0x21,
6563                                 alc294_gx502_toggle_output);
6564                 break;
6565         case HDA_FIXUP_ACT_INIT:
6566                 /* Make sure to start in a correct state, i.e. if
6567                  * headphones have been plugged in before powering up the system
6568                  */
6569                 alc294_gx502_toggle_output(codec, NULL);
6570                 break;
6571         }
6572 }
6573
6574 static void alc294_gu502_toggle_output(struct hda_codec *codec,
6575                                        struct hda_jack_callback *cb)
6576 {
6577         /* Windows sets 0x10 to 0x8420 for Node 0x20 which is
6578          * responsible from changes between speakers and headphones
6579          */
6580         if (snd_hda_jack_detect_state(codec, 0x21) == HDA_JACK_PRESENT)
6581                 alc_write_coef_idx(codec, 0x10, 0x8420);
6582         else
6583                 alc_write_coef_idx(codec, 0x10, 0x0a20);
6584 }
6585
6586 static void alc294_fixup_gu502_hp(struct hda_codec *codec,
6587                                   const struct hda_fixup *fix, int action)
6588 {
6589         if (!is_jack_detectable(codec, 0x21))
6590                 return;
6591
6592         switch (action) {
6593         case HDA_FIXUP_ACT_PRE_PROBE:
6594                 snd_hda_jack_detect_enable_callback(codec, 0x21,
6595                                 alc294_gu502_toggle_output);
6596                 break;
6597         case HDA_FIXUP_ACT_INIT:
6598                 alc294_gu502_toggle_output(codec, NULL);
6599                 break;
6600         }
6601 }
6602
6603 static void  alc285_fixup_hp_gpio_amp_init(struct hda_codec *codec,
6604                               const struct hda_fixup *fix, int action)
6605 {
6606         if (action != HDA_FIXUP_ACT_INIT)
6607                 return;
6608
6609         msleep(100);
6610         alc_write_coef_idx(codec, 0x65, 0x0);
6611 }
6612
6613 static void alc274_fixup_hp_headset_mic(struct hda_codec *codec,
6614                                     const struct hda_fixup *fix, int action)
6615 {
6616         switch (action) {
6617         case HDA_FIXUP_ACT_INIT:
6618                 alc_combo_jack_hp_jd_restart(codec);
6619                 break;
6620         }
6621 }
6622
6623 static void alc_fixup_no_int_mic(struct hda_codec *codec,
6624                                     const struct hda_fixup *fix, int action)
6625 {
6626         struct alc_spec *spec = codec->spec;
6627
6628         switch (action) {
6629         case HDA_FIXUP_ACT_PRE_PROBE:
6630                 /* Mic RING SLEEVE swap for combo jack */
6631                 alc_update_coef_idx(codec, 0x45, 0xf<<12 | 1<<10, 5<<12);
6632                 spec->no_internal_mic_pin = true;
6633                 break;
6634         case HDA_FIXUP_ACT_INIT:
6635                 alc_combo_jack_hp_jd_restart(codec);
6636                 break;
6637         }
6638 }
6639
6640 /* GPIO1 = amplifier on/off
6641  * GPIO3 = mic mute LED
6642  */
6643 static void alc285_fixup_hp_spectre_x360_eb1(struct hda_codec *codec,
6644                                           const struct hda_fixup *fix, int action)
6645 {
6646         static const hda_nid_t conn[] = { 0x02 };
6647
6648         struct alc_spec *spec = codec->spec;
6649         static const struct hda_pintbl pincfgs[] = {
6650                 { 0x14, 0x90170110 },  /* front/high speakers */
6651                 { 0x17, 0x90170130 },  /* back/bass speakers */
6652                 { }
6653         };
6654
6655         //enable micmute led
6656         alc_fixup_hp_gpio_led(codec, action, 0x00, 0x04);
6657
6658         switch (action) {
6659         case HDA_FIXUP_ACT_PRE_PROBE:
6660                 spec->micmute_led_polarity = 1;
6661                 /* needed for amp of back speakers */
6662                 spec->gpio_mask |= 0x01;
6663                 spec->gpio_dir |= 0x01;
6664                 snd_hda_apply_pincfgs(codec, pincfgs);
6665                 /* share DAC to have unified volume control */
6666                 snd_hda_override_conn_list(codec, 0x14, ARRAY_SIZE(conn), conn);
6667                 snd_hda_override_conn_list(codec, 0x17, ARRAY_SIZE(conn), conn);
6668                 break;
6669         case HDA_FIXUP_ACT_INIT:
6670                 /* need to toggle GPIO to enable the amp of back speakers */
6671                 alc_update_gpio_data(codec, 0x01, true);
6672                 msleep(100);
6673                 alc_update_gpio_data(codec, 0x01, false);
6674                 break;
6675         }
6676 }
6677
6678 static void alc285_fixup_hp_spectre_x360(struct hda_codec *codec,
6679                                           const struct hda_fixup *fix, int action)
6680 {
6681         static const hda_nid_t conn[] = { 0x02 };
6682         static const struct hda_pintbl pincfgs[] = {
6683                 { 0x14, 0x90170110 },  /* rear speaker */
6684                 { }
6685         };
6686
6687         switch (action) {
6688         case HDA_FIXUP_ACT_PRE_PROBE:
6689                 snd_hda_apply_pincfgs(codec, pincfgs);
6690                 /* force front speaker to DAC1 */
6691                 snd_hda_override_conn_list(codec, 0x17, ARRAY_SIZE(conn), conn);
6692                 break;
6693         }
6694 }
6695
6696 /* for hda_fixup_thinkpad_acpi() */
6697 #include "thinkpad_helper.c"
6698
6699 static void alc_fixup_thinkpad_acpi(struct hda_codec *codec,
6700                                     const struct hda_fixup *fix, int action)
6701 {
6702         alc_fixup_no_shutup(codec, fix, action); /* reduce click noise */
6703         hda_fixup_thinkpad_acpi(codec, fix, action);
6704 }
6705
6706 /* Fixup for Lenovo Legion 15IMHg05 speaker output on headset removal. */
6707 static void alc287_fixup_legion_15imhg05_speakers(struct hda_codec *codec,
6708                                                   const struct hda_fixup *fix,
6709                                                   int action)
6710 {
6711         struct alc_spec *spec = codec->spec;
6712
6713         switch (action) {
6714         case HDA_FIXUP_ACT_PRE_PROBE:
6715                 spec->gen.suppress_auto_mute = 1;
6716                 break;
6717         }
6718 }
6719
6720 #ifdef CONFIG_ACPI
6721 static void comp_acpi_device_notify(acpi_handle handle, u32 event, void *data)
6722 {
6723         struct hda_codec *cdc = data;
6724         struct alc_spec *spec = cdc->spec;
6725         int i;
6726
6727         codec_info(cdc, "ACPI Notification %d\n", event);
6728
6729         for (i = 0; i < HDA_MAX_COMPONENTS; i++) {
6730                 if (spec->comps[i].dev && spec->comps[i].acpi_notify)
6731                         spec->comps[i].acpi_notify(acpi_device_handle(spec->comps[i].adev), event,
6732                                                    spec->comps[i].dev);
6733         }
6734 }
6735
6736 static int comp_bind_acpi(struct device *dev)
6737 {
6738         struct hda_codec *cdc = dev_to_hda_codec(dev);
6739         struct alc_spec *spec = cdc->spec;
6740         bool support_notifications = false;
6741         struct acpi_device *adev;
6742         int ret;
6743         int i;
6744
6745         adev = spec->comps[0].adev;
6746         if (!acpi_device_handle(adev))
6747                 return 0;
6748
6749         for (i = 0; i < HDA_MAX_COMPONENTS; i++)
6750                 support_notifications = support_notifications ||
6751                         spec->comps[i].acpi_notifications_supported;
6752
6753         if (support_notifications) {
6754                 ret = acpi_install_notify_handler(adev->handle, ACPI_DEVICE_NOTIFY,
6755                                                 comp_acpi_device_notify, cdc);
6756                 if (ret < 0) {
6757                         codec_warn(cdc, "Failed to install notify handler: %d\n", ret);
6758                         return 0;
6759                 }
6760
6761                 codec_dbg(cdc, "Notify handler installed\n");
6762         }
6763
6764         return 0;
6765 }
6766
6767 static void comp_unbind_acpi(struct device *dev)
6768 {
6769         struct hda_codec *cdc = dev_to_hda_codec(dev);
6770         struct alc_spec *spec = cdc->spec;
6771         struct acpi_device *adev;
6772         int ret;
6773
6774         adev = spec->comps[0].adev;
6775         if (!acpi_device_handle(adev))
6776                 return;
6777
6778         ret = acpi_remove_notify_handler(adev->handle, ACPI_DEVICE_NOTIFY,
6779                                          comp_acpi_device_notify);
6780         if (ret < 0)
6781                 codec_warn(cdc, "Failed to uninstall notify handler: %d\n", ret);
6782 }
6783 #else
6784 static int comp_bind_acpi(struct device *dev)
6785 {
6786         return 0;
6787 }
6788
6789 static void comp_unbind_acpi(struct device *dev)
6790 {
6791 }
6792 #endif
6793
6794 static int comp_bind(struct device *dev)
6795 {
6796         struct hda_codec *cdc = dev_to_hda_codec(dev);
6797         struct alc_spec *spec = cdc->spec;
6798         int ret;
6799
6800         ret = component_bind_all(dev, spec->comps);
6801         if (ret)
6802                 return ret;
6803
6804         return comp_bind_acpi(dev);
6805 }
6806
6807 static void comp_unbind(struct device *dev)
6808 {
6809         struct hda_codec *cdc = dev_to_hda_codec(dev);
6810         struct alc_spec *spec = cdc->spec;
6811
6812         comp_unbind_acpi(dev);
6813         component_unbind_all(dev, spec->comps);
6814 }
6815
6816 static const struct component_master_ops comp_master_ops = {
6817         .bind = comp_bind,
6818         .unbind = comp_unbind,
6819 };
6820
6821 static void comp_generic_playback_hook(struct hda_pcm_stream *hinfo, struct hda_codec *cdc,
6822                                        struct snd_pcm_substream *sub, int action)
6823 {
6824         struct alc_spec *spec = cdc->spec;
6825         int i;
6826
6827         for (i = 0; i < HDA_MAX_COMPONENTS; i++) {
6828                 if (spec->comps[i].dev && spec->comps[i].pre_playback_hook)
6829                         spec->comps[i].pre_playback_hook(spec->comps[i].dev, action);
6830         }
6831         for (i = 0; i < HDA_MAX_COMPONENTS; i++) {
6832                 if (spec->comps[i].dev && spec->comps[i].playback_hook)
6833                         spec->comps[i].playback_hook(spec->comps[i].dev, action);
6834         }
6835         for (i = 0; i < HDA_MAX_COMPONENTS; i++) {
6836                 if (spec->comps[i].dev && spec->comps[i].post_playback_hook)
6837                         spec->comps[i].post_playback_hook(spec->comps[i].dev, action);
6838         }
6839 }
6840
6841 struct scodec_dev_name {
6842         const char *bus;
6843         const char *hid;
6844         int index;
6845 };
6846
6847 /* match the device name in a slightly relaxed manner */
6848 static int comp_match_cs35l41_dev_name(struct device *dev, void *data)
6849 {
6850         struct scodec_dev_name *p = data;
6851         const char *d = dev_name(dev);
6852         int n = strlen(p->bus);
6853         char tmp[32];
6854
6855         /* check the bus name */
6856         if (strncmp(d, p->bus, n))
6857                 return 0;
6858         /* skip the bus number */
6859         if (isdigit(d[n]))
6860                 n++;
6861         /* the rest must be exact matching */
6862         snprintf(tmp, sizeof(tmp), "-%s:00-cs35l41-hda.%d", p->hid, p->index);
6863         return !strcmp(d + n, tmp);
6864 }
6865
6866 static int comp_match_tas2781_dev_name(struct device *dev,
6867         void *data)
6868 {
6869         struct scodec_dev_name *p = data;
6870         const char *d = dev_name(dev);
6871         int n = strlen(p->bus);
6872         char tmp[32];
6873
6874         /* check the bus name */
6875         if (strncmp(d, p->bus, n))
6876                 return 0;
6877         /* skip the bus number */
6878         if (isdigit(d[n]))
6879                 n++;
6880         /* the rest must be exact matching */
6881         snprintf(tmp, sizeof(tmp), "-%s:00", p->hid);
6882
6883         return !strcmp(d + n, tmp);
6884 }
6885
6886 static void cs35l41_generic_fixup(struct hda_codec *cdc, int action, const char *bus,
6887                                   const char *hid, int count)
6888 {
6889         struct device *dev = hda_codec_dev(cdc);
6890         struct alc_spec *spec = cdc->spec;
6891         struct scodec_dev_name *rec;
6892         int ret, i;
6893
6894         switch (action) {
6895         case HDA_FIXUP_ACT_PRE_PROBE:
6896                 for (i = 0; i < count; i++) {
6897                         rec = devm_kmalloc(dev, sizeof(*rec), GFP_KERNEL);
6898                         if (!rec)
6899                                 return;
6900                         rec->bus = bus;
6901                         rec->hid = hid;
6902                         rec->index = i;
6903                         spec->comps[i].codec = cdc;
6904                         component_match_add(dev, &spec->match,
6905                                             comp_match_cs35l41_dev_name, rec);
6906                 }
6907                 ret = component_master_add_with_match(dev, &comp_master_ops, spec->match);
6908                 if (ret)
6909                         codec_err(cdc, "Fail to register component aggregator %d\n", ret);
6910                 else
6911                         spec->gen.pcm_playback_hook = comp_generic_playback_hook;
6912                 break;
6913         case HDA_FIXUP_ACT_FREE:
6914                 component_master_del(dev, &comp_master_ops);
6915                 break;
6916         }
6917 }
6918
6919 static void tas2781_generic_fixup(struct hda_codec *cdc, int action,
6920         const char *bus, const char *hid)
6921 {
6922         struct device *dev = hda_codec_dev(cdc);
6923         struct alc_spec *spec = cdc->spec;
6924         struct scodec_dev_name *rec;
6925         int ret;
6926
6927         switch (action) {
6928         case HDA_FIXUP_ACT_PRE_PROBE:
6929                 rec = devm_kmalloc(dev, sizeof(*rec), GFP_KERNEL);
6930                 if (!rec)
6931                         return;
6932                 rec->bus = bus;
6933                 rec->hid = hid;
6934                 rec->index = 0;
6935                 spec->comps[0].codec = cdc;
6936                 component_match_add(dev, &spec->match,
6937                         comp_match_tas2781_dev_name, rec);
6938                 ret = component_master_add_with_match(dev, &comp_master_ops,
6939                         spec->match);
6940                 if (ret)
6941                         codec_err(cdc,
6942                                 "Fail to register component aggregator %d\n",
6943                                 ret);
6944                 else
6945                         spec->gen.pcm_playback_hook =
6946                                 comp_generic_playback_hook;
6947                 break;
6948         case HDA_FIXUP_ACT_FREE:
6949                 component_master_del(dev, &comp_master_ops);
6950                 break;
6951         }
6952 }
6953
6954 static void cs35l41_fixup_i2c_two(struct hda_codec *cdc, const struct hda_fixup *fix, int action)
6955 {
6956         cs35l41_generic_fixup(cdc, action, "i2c", "CSC3551", 2);
6957 }
6958
6959 static void cs35l41_fixup_spi_two(struct hda_codec *codec, const struct hda_fixup *fix, int action)
6960 {
6961         cs35l41_generic_fixup(codec, action, "spi", "CSC3551", 2);
6962 }
6963
6964 static void cs35l41_fixup_spi_four(struct hda_codec *codec, const struct hda_fixup *fix, int action)
6965 {
6966         cs35l41_generic_fixup(codec, action, "spi", "CSC3551", 4);
6967 }
6968
6969 static void alc287_fixup_legion_16achg6_speakers(struct hda_codec *cdc, const struct hda_fixup *fix,
6970                                                  int action)
6971 {
6972         cs35l41_generic_fixup(cdc, action, "i2c", "CLSA0100", 2);
6973 }
6974
6975 static void alc287_fixup_legion_16ithg6_speakers(struct hda_codec *cdc, const struct hda_fixup *fix,
6976                                                  int action)
6977 {
6978         cs35l41_generic_fixup(cdc, action, "i2c", "CLSA0101", 2);
6979 }
6980
6981 static void tas2781_fixup_i2c(struct hda_codec *cdc,
6982         const struct hda_fixup *fix, int action)
6983 {
6984          tas2781_generic_fixup(cdc, action, "i2c", "TIAS2781");
6985 }
6986
6987 /* for alc295_fixup_hp_top_speakers */
6988 #include "hp_x360_helper.c"
6989
6990 /* for alc285_fixup_ideapad_s740_coef() */
6991 #include "ideapad_s740_helper.c"
6992
6993 static const struct coef_fw alc256_fixup_set_coef_defaults_coefs[] = {
6994         WRITE_COEF(0x10, 0x0020), WRITE_COEF(0x24, 0x0000),
6995         WRITE_COEF(0x26, 0x0000), WRITE_COEF(0x29, 0x3000),
6996         WRITE_COEF(0x37, 0xfe05), WRITE_COEF(0x45, 0x5089),
6997         {}
6998 };
6999
7000 static void alc256_fixup_set_coef_defaults(struct hda_codec *codec,
7001                                            const struct hda_fixup *fix,
7002                                            int action)
7003 {
7004         /*
7005          * A certain other OS sets these coeffs to different values. On at least
7006          * one TongFang barebone these settings might survive even a cold
7007          * reboot. So to restore a clean slate the values are explicitly reset
7008          * to default here. Without this, the external microphone is always in a
7009          * plugged-in state, while the internal microphone is always in an
7010          * unplugged state, breaking the ability to use the internal microphone.
7011          */
7012         alc_process_coef_fw(codec, alc256_fixup_set_coef_defaults_coefs);
7013 }
7014
7015 static const struct coef_fw alc233_fixup_no_audio_jack_coefs[] = {
7016         WRITE_COEF(0x1a, 0x9003), WRITE_COEF(0x1b, 0x0e2b), WRITE_COEF(0x37, 0xfe06),
7017         WRITE_COEF(0x38, 0x4981), WRITE_COEF(0x45, 0xd489), WRITE_COEF(0x46, 0x0074),
7018         WRITE_COEF(0x49, 0x0149),
7019         {}
7020 };
7021
7022 static void alc233_fixup_no_audio_jack(struct hda_codec *codec,
7023                                        const struct hda_fixup *fix,
7024                                        int action)
7025 {
7026         /*
7027          * The audio jack input and output is not detected on the ASRock NUC Box
7028          * 1100 series when cold booting without this fix. Warm rebooting from a
7029          * certain other OS makes the audio functional, as COEF settings are
7030          * preserved in this case. This fix sets these altered COEF values as
7031          * the default.
7032          */
7033         alc_process_coef_fw(codec, alc233_fixup_no_audio_jack_coefs);
7034 }
7035
7036 static void alc256_fixup_mic_no_presence_and_resume(struct hda_codec *codec,
7037                                                     const struct hda_fixup *fix,
7038                                                     int action)
7039 {
7040         /*
7041          * The Clevo NJ51CU comes either with the ALC293 or the ALC256 codec,
7042          * but uses the 0x8686 subproduct id in both cases. The ALC256 codec
7043          * needs an additional quirk for sound working after suspend and resume.
7044          */
7045         if (codec->core.vendor_id == 0x10ec0256) {
7046                 alc_update_coef_idx(codec, 0x10, 1<<9, 0);
7047                 snd_hda_codec_set_pincfg(codec, 0x19, 0x04a11120);
7048         } else {
7049                 snd_hda_codec_set_pincfg(codec, 0x1a, 0x04a1113c);
7050         }
7051 }
7052
7053 static void alc_fixup_dell4_mic_no_presence_quiet(struct hda_codec *codec,
7054                                                   const struct hda_fixup *fix,
7055                                                   int action)
7056 {
7057         struct alc_spec *spec = codec->spec;
7058         struct hda_input_mux *imux = &spec->gen.input_mux;
7059         int i;
7060
7061         alc269_fixup_limit_int_mic_boost(codec, fix, action);
7062
7063         switch (action) {
7064         case HDA_FIXUP_ACT_PRE_PROBE:
7065                 /**
7066                  * Set the vref of pin 0x19 (Headset Mic) and pin 0x1b (Headphone Mic)
7067                  * to Hi-Z to avoid pop noises at startup and when plugging and
7068                  * unplugging headphones.
7069                  */
7070                 snd_hda_codec_set_pin_target(codec, 0x19, PIN_VREFHIZ);
7071                 snd_hda_codec_set_pin_target(codec, 0x1b, PIN_VREFHIZ);
7072                 break;
7073         case HDA_FIXUP_ACT_PROBE:
7074                 /**
7075                  * Make the internal mic (0x12) the default input source to
7076                  * prevent pop noises on cold boot.
7077                  */
7078                 for (i = 0; i < imux->num_items; i++) {
7079                         if (spec->gen.imux_pins[i] == 0x12) {
7080                                 spec->gen.cur_mux[0] = i;
7081                                 break;
7082                         }
7083                 }
7084                 break;
7085         }
7086 }
7087
7088 static void alc287_fixup_yoga9_14iap7_bass_spk_pin(struct hda_codec *codec,
7089                                           const struct hda_fixup *fix, int action)
7090 {
7091         /*
7092          * The Pin Complex 0x17 for the bass speakers is wrongly reported as
7093          * unconnected.
7094          */
7095         static const struct hda_pintbl pincfgs[] = {
7096                 { 0x17, 0x90170121 },
7097                 { }
7098         };
7099         /*
7100          * Avoid DAC 0x06 and 0x08, as they have no volume controls.
7101          * DAC 0x02 and 0x03 would be fine.
7102          */
7103         static const hda_nid_t conn[] = { 0x02, 0x03 };
7104         /*
7105          * Prefer both speakerbar (0x14) and bass speakers (0x17) connected to DAC 0x02.
7106          * Headphones (0x21) are connected to DAC 0x03.
7107          */
7108         static const hda_nid_t preferred_pairs[] = {
7109                 0x14, 0x02,
7110                 0x17, 0x02,
7111                 0x21, 0x03,
7112                 0
7113         };
7114         struct alc_spec *spec = codec->spec;
7115
7116         switch (action) {
7117         case HDA_FIXUP_ACT_PRE_PROBE:
7118                 snd_hda_apply_pincfgs(codec, pincfgs);
7119                 snd_hda_override_conn_list(codec, 0x17, ARRAY_SIZE(conn), conn);
7120                 spec->gen.preferred_dacs = preferred_pairs;
7121                 break;
7122         }
7123 }
7124
7125 static void alc295_fixup_dell_inspiron_top_speakers(struct hda_codec *codec,
7126                                           const struct hda_fixup *fix, int action)
7127 {
7128         static const struct hda_pintbl pincfgs[] = {
7129                 { 0x14, 0x90170151 },
7130                 { 0x17, 0x90170150 },
7131                 { }
7132         };
7133         static const hda_nid_t conn[] = { 0x02, 0x03 };
7134         static const hda_nid_t preferred_pairs[] = {
7135                 0x14, 0x02,
7136                 0x17, 0x03,
7137                 0x21, 0x02,
7138                 0
7139         };
7140         struct alc_spec *spec = codec->spec;
7141
7142         alc_fixup_no_shutup(codec, fix, action);
7143
7144         switch (action) {
7145         case HDA_FIXUP_ACT_PRE_PROBE:
7146                 snd_hda_apply_pincfgs(codec, pincfgs);
7147                 snd_hda_override_conn_list(codec, 0x17, ARRAY_SIZE(conn), conn);
7148                 spec->gen.preferred_dacs = preferred_pairs;
7149                 break;
7150         }
7151 }
7152
7153 /* Forcibly assign NID 0x03 to HP while NID 0x02 to SPK */
7154 static void alc287_fixup_bind_dacs(struct hda_codec *codec,
7155                                     const struct hda_fixup *fix, int action)
7156 {
7157         struct alc_spec *spec = codec->spec;
7158         static const hda_nid_t conn[] = { 0x02, 0x03 }; /* exclude 0x06 */
7159         static const hda_nid_t preferred_pairs[] = {
7160                 0x17, 0x02, 0x21, 0x03, 0
7161         };
7162
7163         if (action != HDA_FIXUP_ACT_PRE_PROBE)
7164                 return;
7165
7166         snd_hda_override_conn_list(codec, 0x17, ARRAY_SIZE(conn), conn);
7167         spec->gen.preferred_dacs = preferred_pairs;
7168         spec->gen.auto_mute_via_amp = 1;
7169         if (spec->gen.autocfg.speaker_pins[0] != 0x14) {
7170                 snd_hda_codec_write_cache(codec, 0x14, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
7171                                         0x0); /* Make sure 0x14 was disable */
7172         }
7173 }
7174 /* Fix none verb table of Headset Mic pin */
7175 static void alc_fixup_headset_mic(struct hda_codec *codec,
7176                                    const struct hda_fixup *fix, int action)
7177 {
7178         struct alc_spec *spec = codec->spec;
7179         static const struct hda_pintbl pincfgs[] = {
7180                 { 0x19, 0x03a1103c },
7181                 { }
7182         };
7183
7184         switch (action) {
7185         case HDA_FIXUP_ACT_PRE_PROBE:
7186                 snd_hda_apply_pincfgs(codec, pincfgs);
7187                 alc_update_coef_idx(codec, 0x45, 0xf<<12 | 1<<10, 5<<12);
7188                 spec->parse_flags |= HDA_PINCFG_HEADSET_MIC;
7189                 break;
7190         }
7191 }
7192
7193
7194 enum {
7195         ALC269_FIXUP_GPIO2,
7196         ALC269_FIXUP_SONY_VAIO,
7197         ALC275_FIXUP_SONY_VAIO_GPIO2,
7198         ALC269_FIXUP_DELL_M101Z,
7199         ALC269_FIXUP_SKU_IGNORE,
7200         ALC269_FIXUP_ASUS_G73JW,
7201         ALC269_FIXUP_ASUS_N7601ZM_PINS,
7202         ALC269_FIXUP_ASUS_N7601ZM,
7203         ALC269_FIXUP_LENOVO_EAPD,
7204         ALC275_FIXUP_SONY_HWEQ,
7205         ALC275_FIXUP_SONY_DISABLE_AAMIX,
7206         ALC271_FIXUP_DMIC,
7207         ALC269_FIXUP_PCM_44K,
7208         ALC269_FIXUP_STEREO_DMIC,
7209         ALC269_FIXUP_HEADSET_MIC,
7210         ALC269_FIXUP_QUANTA_MUTE,
7211         ALC269_FIXUP_LIFEBOOK,
7212         ALC269_FIXUP_LIFEBOOK_EXTMIC,
7213         ALC269_FIXUP_LIFEBOOK_HP_PIN,
7214         ALC269_FIXUP_LIFEBOOK_NO_HP_TO_LINEOUT,
7215         ALC255_FIXUP_LIFEBOOK_U7x7_HEADSET_MIC,
7216         ALC269_FIXUP_AMIC,
7217         ALC269_FIXUP_DMIC,
7218         ALC269VB_FIXUP_AMIC,
7219         ALC269VB_FIXUP_DMIC,
7220         ALC269_FIXUP_HP_MUTE_LED,
7221         ALC269_FIXUP_HP_MUTE_LED_MIC1,
7222         ALC269_FIXUP_HP_MUTE_LED_MIC2,
7223         ALC269_FIXUP_HP_MUTE_LED_MIC3,
7224         ALC269_FIXUP_HP_GPIO_LED,
7225         ALC269_FIXUP_HP_GPIO_MIC1_LED,
7226         ALC269_FIXUP_HP_LINE1_MIC1_LED,
7227         ALC269_FIXUP_INV_DMIC,
7228         ALC269_FIXUP_LENOVO_DOCK,
7229         ALC269_FIXUP_LENOVO_DOCK_LIMIT_BOOST,
7230         ALC269_FIXUP_NO_SHUTUP,
7231         ALC286_FIXUP_SONY_MIC_NO_PRESENCE,
7232         ALC269_FIXUP_PINCFG_NO_HP_TO_LINEOUT,
7233         ALC269_FIXUP_DELL1_MIC_NO_PRESENCE,
7234         ALC269_FIXUP_DELL2_MIC_NO_PRESENCE,
7235         ALC269_FIXUP_DELL3_MIC_NO_PRESENCE,
7236         ALC269_FIXUP_DELL4_MIC_NO_PRESENCE,
7237         ALC269_FIXUP_DELL4_MIC_NO_PRESENCE_QUIET,
7238         ALC269_FIXUP_HEADSET_MODE,
7239         ALC269_FIXUP_HEADSET_MODE_NO_HP_MIC,
7240         ALC269_FIXUP_ASPIRE_HEADSET_MIC,
7241         ALC269_FIXUP_ASUS_X101_FUNC,
7242         ALC269_FIXUP_ASUS_X101_VERB,
7243         ALC269_FIXUP_ASUS_X101,
7244         ALC271_FIXUP_AMIC_MIC2,
7245         ALC271_FIXUP_HP_GATE_MIC_JACK,
7246         ALC271_FIXUP_HP_GATE_MIC_JACK_E1_572,
7247         ALC269_FIXUP_ACER_AC700,
7248         ALC269_FIXUP_LIMIT_INT_MIC_BOOST,
7249         ALC269VB_FIXUP_ASUS_ZENBOOK,
7250         ALC269VB_FIXUP_ASUS_ZENBOOK_UX31A,
7251         ALC269VB_FIXUP_ASUS_MIC_NO_PRESENCE,
7252         ALC269_FIXUP_LIMIT_INT_MIC_BOOST_MUTE_LED,
7253         ALC269VB_FIXUP_ORDISSIMO_EVE2,
7254         ALC283_FIXUP_CHROME_BOOK,
7255         ALC283_FIXUP_SENSE_COMBO_JACK,
7256         ALC282_FIXUP_ASUS_TX300,
7257         ALC283_FIXUP_INT_MIC,
7258         ALC290_FIXUP_MONO_SPEAKERS,
7259         ALC290_FIXUP_MONO_SPEAKERS_HSJACK,
7260         ALC290_FIXUP_SUBWOOFER,
7261         ALC290_FIXUP_SUBWOOFER_HSJACK,
7262         ALC269_FIXUP_THINKPAD_ACPI,
7263         ALC269_FIXUP_DMIC_THINKPAD_ACPI,
7264         ALC269VB_FIXUP_CHUWI_COREBOOK_XPRO,
7265         ALC255_FIXUP_ACER_MIC_NO_PRESENCE,
7266         ALC255_FIXUP_ASUS_MIC_NO_PRESENCE,
7267         ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
7268         ALC255_FIXUP_DELL2_MIC_NO_PRESENCE,
7269         ALC255_FIXUP_HEADSET_MODE,
7270         ALC255_FIXUP_HEADSET_MODE_NO_HP_MIC,
7271         ALC293_FIXUP_DELL1_MIC_NO_PRESENCE,
7272         ALC292_FIXUP_TPT440_DOCK,
7273         ALC292_FIXUP_TPT440,
7274         ALC283_FIXUP_HEADSET_MIC,
7275         ALC255_FIXUP_MIC_MUTE_LED,
7276         ALC282_FIXUP_ASPIRE_V5_PINS,
7277         ALC269VB_FIXUP_ASPIRE_E1_COEF,
7278         ALC280_FIXUP_HP_GPIO4,
7279         ALC286_FIXUP_HP_GPIO_LED,
7280         ALC280_FIXUP_HP_GPIO2_MIC_HOTKEY,
7281         ALC280_FIXUP_HP_DOCK_PINS,
7282         ALC269_FIXUP_HP_DOCK_GPIO_MIC1_LED,
7283         ALC280_FIXUP_HP_9480M,
7284         ALC245_FIXUP_HP_X360_AMP,
7285         ALC285_FIXUP_HP_SPECTRE_X360_EB1,
7286         ALC288_FIXUP_DELL_HEADSET_MODE,
7287         ALC288_FIXUP_DELL1_MIC_NO_PRESENCE,
7288         ALC288_FIXUP_DELL_XPS_13,
7289         ALC288_FIXUP_DISABLE_AAMIX,
7290         ALC292_FIXUP_DELL_E7X_AAMIX,
7291         ALC292_FIXUP_DELL_E7X,
7292         ALC292_FIXUP_DISABLE_AAMIX,
7293         ALC293_FIXUP_DISABLE_AAMIX_MULTIJACK,
7294         ALC298_FIXUP_ALIENWARE_MIC_NO_PRESENCE,
7295         ALC298_FIXUP_DELL1_MIC_NO_PRESENCE,
7296         ALC298_FIXUP_DELL_AIO_MIC_NO_PRESENCE,
7297         ALC275_FIXUP_DELL_XPS,
7298         ALC293_FIXUP_LENOVO_SPK_NOISE,
7299         ALC233_FIXUP_LENOVO_LINE2_MIC_HOTKEY,
7300         ALC255_FIXUP_DELL_SPK_NOISE,
7301         ALC225_FIXUP_DISABLE_MIC_VREF,
7302         ALC225_FIXUP_DELL1_MIC_NO_PRESENCE,
7303         ALC295_FIXUP_DISABLE_DAC3,
7304         ALC285_FIXUP_SPEAKER2_TO_DAC1,
7305         ALC285_FIXUP_ASUS_SPEAKER2_TO_DAC1,
7306         ALC285_FIXUP_ASUS_HEADSET_MIC,
7307         ALC285_FIXUP_ASUS_SPI_REAR_SPEAKERS,
7308         ALC285_FIXUP_ASUS_I2C_SPEAKER2_TO_DAC1,
7309         ALC285_FIXUP_ASUS_I2C_HEADSET_MIC,
7310         ALC280_FIXUP_HP_HEADSET_MIC,
7311         ALC221_FIXUP_HP_FRONT_MIC,
7312         ALC292_FIXUP_TPT460,
7313         ALC298_FIXUP_SPK_VOLUME,
7314         ALC298_FIXUP_LENOVO_SPK_VOLUME,
7315         ALC256_FIXUP_DELL_INSPIRON_7559_SUBWOOFER,
7316         ALC269_FIXUP_ATIV_BOOK_8,
7317         ALC221_FIXUP_HP_288PRO_MIC_NO_PRESENCE,
7318         ALC221_FIXUP_HP_MIC_NO_PRESENCE,
7319         ALC256_FIXUP_ASUS_HEADSET_MODE,
7320         ALC256_FIXUP_ASUS_MIC,
7321         ALC256_FIXUP_ASUS_AIO_GPIO2,
7322         ALC233_FIXUP_ASUS_MIC_NO_PRESENCE,
7323         ALC233_FIXUP_EAPD_COEF_AND_MIC_NO_PRESENCE,
7324         ALC233_FIXUP_LENOVO_MULTI_CODECS,
7325         ALC233_FIXUP_ACER_HEADSET_MIC,
7326         ALC294_FIXUP_LENOVO_MIC_LOCATION,
7327         ALC225_FIXUP_DELL_WYSE_MIC_NO_PRESENCE,
7328         ALC225_FIXUP_S3_POP_NOISE,
7329         ALC700_FIXUP_INTEL_REFERENCE,
7330         ALC274_FIXUP_DELL_BIND_DACS,
7331         ALC274_FIXUP_DELL_AIO_LINEOUT_VERB,
7332         ALC298_FIXUP_TPT470_DOCK_FIX,
7333         ALC298_FIXUP_TPT470_DOCK,
7334         ALC255_FIXUP_DUMMY_LINEOUT_VERB,
7335         ALC255_FIXUP_DELL_HEADSET_MIC,
7336         ALC256_FIXUP_HUAWEI_MACH_WX9_PINS,
7337         ALC298_FIXUP_HUAWEI_MBX_STEREO,
7338         ALC295_FIXUP_HP_X360,
7339         ALC221_FIXUP_HP_HEADSET_MIC,
7340         ALC285_FIXUP_LENOVO_HEADPHONE_NOISE,
7341         ALC295_FIXUP_HP_AUTO_MUTE,
7342         ALC286_FIXUP_ACER_AIO_MIC_NO_PRESENCE,
7343         ALC294_FIXUP_ASUS_MIC,
7344         ALC294_FIXUP_ASUS_HEADSET_MIC,
7345         ALC294_FIXUP_ASUS_SPK,
7346         ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE,
7347         ALC285_FIXUP_LENOVO_PC_BEEP_IN_NOISE,
7348         ALC255_FIXUP_ACER_HEADSET_MIC,
7349         ALC295_FIXUP_CHROME_BOOK,
7350         ALC225_FIXUP_HEADSET_JACK,
7351         ALC225_FIXUP_DELL_WYSE_AIO_MIC_NO_PRESENCE,
7352         ALC225_FIXUP_WYSE_AUTO_MUTE,
7353         ALC225_FIXUP_WYSE_DISABLE_MIC_VREF,
7354         ALC286_FIXUP_ACER_AIO_HEADSET_MIC,
7355         ALC256_FIXUP_ASUS_HEADSET_MIC,
7356         ALC256_FIXUP_ASUS_MIC_NO_PRESENCE,
7357         ALC299_FIXUP_PREDATOR_SPK,
7358         ALC256_FIXUP_MEDION_HEADSET_NO_PRESENCE,
7359         ALC289_FIXUP_DELL_SPK1,
7360         ALC289_FIXUP_DELL_SPK2,
7361         ALC289_FIXUP_DUAL_SPK,
7362         ALC289_FIXUP_RTK_AMP_DUAL_SPK,
7363         ALC294_FIXUP_SPK2_TO_DAC1,
7364         ALC294_FIXUP_ASUS_DUAL_SPK,
7365         ALC285_FIXUP_THINKPAD_X1_GEN7,
7366         ALC285_FIXUP_THINKPAD_HEADSET_JACK,
7367         ALC294_FIXUP_ASUS_ALLY,
7368         ALC294_FIXUP_ASUS_ALLY_PINS,
7369         ALC294_FIXUP_ASUS_ALLY_VERBS,
7370         ALC294_FIXUP_ASUS_ALLY_SPEAKER,
7371         ALC294_FIXUP_ASUS_HPE,
7372         ALC294_FIXUP_ASUS_COEF_1B,
7373         ALC294_FIXUP_ASUS_GX502_HP,
7374         ALC294_FIXUP_ASUS_GX502_PINS,
7375         ALC294_FIXUP_ASUS_GX502_VERBS,
7376         ALC294_FIXUP_ASUS_GU502_HP,
7377         ALC294_FIXUP_ASUS_GU502_PINS,
7378         ALC294_FIXUP_ASUS_GU502_VERBS,
7379         ALC294_FIXUP_ASUS_G513_PINS,
7380         ALC285_FIXUP_ASUS_G533Z_PINS,
7381         ALC285_FIXUP_HP_GPIO_LED,
7382         ALC285_FIXUP_HP_MUTE_LED,
7383         ALC285_FIXUP_HP_SPECTRE_X360_MUTE_LED,
7384         ALC236_FIXUP_HP_MUTE_LED_COEFBIT2,
7385         ALC236_FIXUP_HP_GPIO_LED,
7386         ALC236_FIXUP_HP_MUTE_LED,
7387         ALC236_FIXUP_HP_MUTE_LED_MICMUTE_VREF,
7388         ALC298_FIXUP_SAMSUNG_AMP,
7389         ALC298_FIXUP_SAMSUNG_HEADPHONE_VERY_QUIET,
7390         ALC256_FIXUP_SAMSUNG_HEADPHONE_VERY_QUIET,
7391         ALC295_FIXUP_ASUS_MIC_NO_PRESENCE,
7392         ALC269VC_FIXUP_ACER_VCOPPERBOX_PINS,
7393         ALC269VC_FIXUP_ACER_HEADSET_MIC,
7394         ALC269VC_FIXUP_ACER_MIC_NO_PRESENCE,
7395         ALC289_FIXUP_ASUS_GA401,
7396         ALC289_FIXUP_ASUS_GA502,
7397         ALC256_FIXUP_ACER_MIC_NO_PRESENCE,
7398         ALC285_FIXUP_HP_GPIO_AMP_INIT,
7399         ALC269_FIXUP_CZC_B20,
7400         ALC269_FIXUP_CZC_TMI,
7401         ALC269_FIXUP_CZC_L101,
7402         ALC269_FIXUP_LEMOTE_A1802,
7403         ALC269_FIXUP_LEMOTE_A190X,
7404         ALC256_FIXUP_INTEL_NUC8_RUGGED,
7405         ALC233_FIXUP_INTEL_NUC8_DMIC,
7406         ALC233_FIXUP_INTEL_NUC8_BOOST,
7407         ALC256_FIXUP_INTEL_NUC10,
7408         ALC255_FIXUP_XIAOMI_HEADSET_MIC,
7409         ALC274_FIXUP_HP_MIC,
7410         ALC274_FIXUP_HP_HEADSET_MIC,
7411         ALC274_FIXUP_HP_ENVY_GPIO,
7412         ALC256_FIXUP_ASUS_HPE,
7413         ALC285_FIXUP_THINKPAD_NO_BASS_SPK_HEADSET_JACK,
7414         ALC287_FIXUP_HP_GPIO_LED,
7415         ALC256_FIXUP_HP_HEADSET_MIC,
7416         ALC245_FIXUP_HP_GPIO_LED,
7417         ALC236_FIXUP_DELL_AIO_HEADSET_MIC,
7418         ALC282_FIXUP_ACER_DISABLE_LINEOUT,
7419         ALC255_FIXUP_ACER_LIMIT_INT_MIC_BOOST,
7420         ALC256_FIXUP_ACER_HEADSET_MIC,
7421         ALC285_FIXUP_IDEAPAD_S740_COEF,
7422         ALC285_FIXUP_HP_LIMIT_INT_MIC_BOOST,
7423         ALC295_FIXUP_ASUS_DACS,
7424         ALC295_FIXUP_HP_OMEN,
7425         ALC285_FIXUP_HP_SPECTRE_X360,
7426         ALC287_FIXUP_IDEAPAD_BASS_SPK_AMP,
7427         ALC623_FIXUP_LENOVO_THINKSTATION_P340,
7428         ALC255_FIXUP_ACER_HEADPHONE_AND_MIC,
7429         ALC236_FIXUP_HP_LIMIT_INT_MIC_BOOST,
7430         ALC287_FIXUP_LEGION_15IMHG05_SPEAKERS,
7431         ALC287_FIXUP_LEGION_15IMHG05_AUTOMUTE,
7432         ALC287_FIXUP_YOGA7_14ITL_SPEAKERS,
7433         ALC298_FIXUP_LENOVO_C940_DUET7,
7434         ALC287_FIXUP_13S_GEN2_SPEAKERS,
7435         ALC256_FIXUP_SET_COEF_DEFAULTS,
7436         ALC256_FIXUP_SYSTEM76_MIC_NO_PRESENCE,
7437         ALC233_FIXUP_NO_AUDIO_JACK,
7438         ALC256_FIXUP_MIC_NO_PRESENCE_AND_RESUME,
7439         ALC285_FIXUP_LEGION_Y9000X_SPEAKERS,
7440         ALC285_FIXUP_LEGION_Y9000X_AUTOMUTE,
7441         ALC287_FIXUP_LEGION_16ACHG6,
7442         ALC287_FIXUP_CS35L41_I2C_2,
7443         ALC287_FIXUP_CS35L41_I2C_2_HP_GPIO_LED,
7444         ALC245_FIXUP_CS35L41_SPI_2,
7445         ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED,
7446         ALC245_FIXUP_CS35L41_SPI_4,
7447         ALC245_FIXUP_CS35L41_SPI_4_HP_GPIO_LED,
7448         ALC285_FIXUP_HP_SPEAKERS_MICMUTE_LED,
7449         ALC295_FIXUP_FRAMEWORK_LAPTOP_MIC_NO_PRESENCE,
7450         ALC287_FIXUP_LEGION_16ITHG6,
7451         ALC287_FIXUP_YOGA9_14IAP7_BASS_SPK,
7452         ALC287_FIXUP_YOGA9_14IAP7_BASS_SPK_PIN,
7453         ALC295_FIXUP_DELL_INSPIRON_TOP_SPEAKERS,
7454         ALC236_FIXUP_DELL_DUAL_CODECS,
7455         ALC287_FIXUP_CS35L41_I2C_2_THINKPAD_ACPI,
7456         ALC287_FIXUP_TAS2781_I2C,
7457         ALC245_FIXUP_HP_MUTE_LED_COEFBIT,
7458         ALC245_FIXUP_HP_X360_MUTE_LEDS,
7459         ALC287_FIXUP_THINKPAD_I2S_SPK,
7460         ALC287_FIXUP_MG_RTKC_CSAMP_CS35L41_I2C_THINKPAD,
7461         ALC2XX_FIXUP_HEADSET_MIC,
7462         ALC289_FIXUP_DELL_CS35L41_SPI_2,
7463         ALC294_FIXUP_CS35L41_I2C_2,
7464 };
7465
7466 /* A special fixup for Lenovo C940 and Yoga Duet 7;
7467  * both have the very same PCI SSID, and we need to apply different fixups
7468  * depending on the codec ID
7469  */
7470 static void alc298_fixup_lenovo_c940_duet7(struct hda_codec *codec,
7471                                            const struct hda_fixup *fix,
7472                                            int action)
7473 {
7474         int id;
7475
7476         if (codec->core.vendor_id == 0x10ec0298)
7477                 id = ALC298_FIXUP_LENOVO_SPK_VOLUME; /* C940 */
7478         else
7479                 id = ALC287_FIXUP_YOGA7_14ITL_SPEAKERS; /* Duet 7 */
7480         __snd_hda_apply_fixup(codec, id, action, 0);
7481 }
7482
7483 static const struct hda_fixup alc269_fixups[] = {
7484         [ALC269_FIXUP_GPIO2] = {
7485                 .type = HDA_FIXUP_FUNC,
7486                 .v.func = alc_fixup_gpio2,
7487         },
7488         [ALC269_FIXUP_SONY_VAIO] = {
7489                 .type = HDA_FIXUP_PINCTLS,
7490                 .v.pins = (const struct hda_pintbl[]) {
7491                         {0x19, PIN_VREFGRD},
7492                         {}
7493                 }
7494         },
7495         [ALC275_FIXUP_SONY_VAIO_GPIO2] = {
7496                 .type = HDA_FIXUP_FUNC,
7497                 .v.func = alc275_fixup_gpio4_off,
7498                 .chained = true,
7499                 .chain_id = ALC269_FIXUP_SONY_VAIO
7500         },
7501         [ALC269_FIXUP_DELL_M101Z] = {
7502                 .type = HDA_FIXUP_VERBS,
7503                 .v.verbs = (const struct hda_verb[]) {
7504                         /* Enables internal speaker */
7505                         {0x20, AC_VERB_SET_COEF_INDEX, 13},
7506                         {0x20, AC_VERB_SET_PROC_COEF, 0x4040},
7507                         {}
7508                 }
7509         },
7510         [ALC269_FIXUP_SKU_IGNORE] = {
7511                 .type = HDA_FIXUP_FUNC,
7512                 .v.func = alc_fixup_sku_ignore,
7513         },
7514         [ALC269_FIXUP_ASUS_G73JW] = {
7515                 .type = HDA_FIXUP_PINS,
7516                 .v.pins = (const struct hda_pintbl[]) {
7517                         { 0x17, 0x99130111 }, /* subwoofer */
7518                         { }
7519                 }
7520         },
7521         [ALC269_FIXUP_ASUS_N7601ZM_PINS] = {
7522                 .type = HDA_FIXUP_PINS,
7523                 .v.pins = (const struct hda_pintbl[]) {
7524                         { 0x19, 0x03A11050 },
7525                         { 0x1a, 0x03A11C30 },
7526                         { 0x21, 0x03211420 },
7527                         { }
7528                 }
7529         },
7530         [ALC269_FIXUP_ASUS_N7601ZM] = {
7531                 .type = HDA_FIXUP_VERBS,
7532                 .v.verbs = (const struct hda_verb[]) {
7533                         {0x20, AC_VERB_SET_COEF_INDEX, 0x62},
7534                         {0x20, AC_VERB_SET_PROC_COEF, 0xa007},
7535                         {0x20, AC_VERB_SET_COEF_INDEX, 0x10},
7536                         {0x20, AC_VERB_SET_PROC_COEF, 0x8420},
7537                         {0x20, AC_VERB_SET_COEF_INDEX, 0x0f},
7538                         {0x20, AC_VERB_SET_PROC_COEF, 0x7774},
7539                         { }
7540                 },
7541                 .chained = true,
7542                 .chain_id = ALC269_FIXUP_ASUS_N7601ZM_PINS,
7543         },
7544         [ALC269_FIXUP_LENOVO_EAPD] = {
7545                 .type = HDA_FIXUP_VERBS,
7546                 .v.verbs = (const struct hda_verb[]) {
7547                         {0x14, AC_VERB_SET_EAPD_BTLENABLE, 0},
7548                         {}
7549                 }
7550         },
7551         [ALC275_FIXUP_SONY_HWEQ] = {
7552                 .type = HDA_FIXUP_FUNC,
7553                 .v.func = alc269_fixup_hweq,
7554                 .chained = true,
7555                 .chain_id = ALC275_FIXUP_SONY_VAIO_GPIO2
7556         },
7557         [ALC275_FIXUP_SONY_DISABLE_AAMIX] = {
7558                 .type = HDA_FIXUP_FUNC,
7559                 .v.func = alc_fixup_disable_aamix,
7560                 .chained = true,
7561                 .chain_id = ALC269_FIXUP_SONY_VAIO
7562         },
7563         [ALC271_FIXUP_DMIC] = {
7564                 .type = HDA_FIXUP_FUNC,
7565                 .v.func = alc271_fixup_dmic,
7566         },
7567         [ALC269_FIXUP_PCM_44K] = {
7568                 .type = HDA_FIXUP_FUNC,
7569                 .v.func = alc269_fixup_pcm_44k,
7570                 .chained = true,
7571                 .chain_id = ALC269_FIXUP_QUANTA_MUTE
7572         },
7573         [ALC269_FIXUP_STEREO_DMIC] = {
7574                 .type = HDA_FIXUP_FUNC,
7575                 .v.func = alc269_fixup_stereo_dmic,
7576         },
7577         [ALC269_FIXUP_HEADSET_MIC] = {
7578                 .type = HDA_FIXUP_FUNC,
7579                 .v.func = alc269_fixup_headset_mic,
7580         },
7581         [ALC269_FIXUP_QUANTA_MUTE] = {
7582                 .type = HDA_FIXUP_FUNC,
7583                 .v.func = alc269_fixup_quanta_mute,
7584         },
7585         [ALC269_FIXUP_LIFEBOOK] = {
7586                 .type = HDA_FIXUP_PINS,
7587                 .v.pins = (const struct hda_pintbl[]) {
7588                         { 0x1a, 0x2101103f }, /* dock line-out */
7589                         { 0x1b, 0x23a11040 }, /* dock mic-in */
7590                         { }
7591                 },
7592                 .chained = true,
7593                 .chain_id = ALC269_FIXUP_QUANTA_MUTE
7594         },
7595         [ALC269_FIXUP_LIFEBOOK_EXTMIC] = {
7596                 .type = HDA_FIXUP_PINS,
7597                 .v.pins = (const struct hda_pintbl[]) {
7598                         { 0x19, 0x01a1903c }, /* headset mic, with jack detect */
7599                         { }
7600                 },
7601         },
7602         [ALC269_FIXUP_LIFEBOOK_HP_PIN] = {
7603                 .type = HDA_FIXUP_PINS,
7604                 .v.pins = (const struct hda_pintbl[]) {
7605                         { 0x21, 0x0221102f }, /* HP out */
7606                         { }
7607                 },
7608         },
7609         [ALC269_FIXUP_LIFEBOOK_NO_HP_TO_LINEOUT] = {
7610                 .type = HDA_FIXUP_FUNC,
7611                 .v.func = alc269_fixup_pincfg_no_hp_to_lineout,
7612         },
7613         [ALC255_FIXUP_LIFEBOOK_U7x7_HEADSET_MIC] = {
7614                 .type = HDA_FIXUP_FUNC,
7615                 .v.func = alc269_fixup_pincfg_U7x7_headset_mic,
7616         },
7617         [ALC269VB_FIXUP_CHUWI_COREBOOK_XPRO] = {
7618                 .type = HDA_FIXUP_PINS,
7619                 .v.pins = (const struct hda_pintbl[]) {
7620                         { 0x18, 0x03a19020 }, /* headset mic */
7621                         { 0x1b, 0x90170150 }, /* speaker */
7622                         { }
7623                 },
7624         },
7625         [ALC269_FIXUP_AMIC] = {
7626                 .type = HDA_FIXUP_PINS,
7627                 .v.pins = (const struct hda_pintbl[]) {
7628                         { 0x14, 0x99130110 }, /* speaker */
7629                         { 0x15, 0x0121401f }, /* HP out */
7630                         { 0x18, 0x01a19c20 }, /* mic */
7631                         { 0x19, 0x99a3092f }, /* int-mic */
7632                         { }
7633                 },
7634         },
7635         [ALC269_FIXUP_DMIC] = {
7636                 .type = HDA_FIXUP_PINS,
7637                 .v.pins = (const struct hda_pintbl[]) {
7638                         { 0x12, 0x99a3092f }, /* int-mic */
7639                         { 0x14, 0x99130110 }, /* speaker */
7640                         { 0x15, 0x0121401f }, /* HP out */
7641                         { 0x18, 0x01a19c20 }, /* mic */
7642                         { }
7643                 },
7644         },
7645         [ALC269VB_FIXUP_AMIC] = {
7646                 .type = HDA_FIXUP_PINS,
7647                 .v.pins = (const struct hda_pintbl[]) {
7648                         { 0x14, 0x99130110 }, /* speaker */
7649                         { 0x18, 0x01a19c20 }, /* mic */
7650                         { 0x19, 0x99a3092f }, /* int-mic */
7651                         { 0x21, 0x0121401f }, /* HP out */
7652                         { }
7653                 },
7654         },
7655         [ALC269VB_FIXUP_DMIC] = {
7656                 .type = HDA_FIXUP_PINS,
7657                 .v.pins = (const struct hda_pintbl[]) {
7658                         { 0x12, 0x99a3092f }, /* int-mic */
7659                         { 0x14, 0x99130110 }, /* speaker */
7660                         { 0x18, 0x01a19c20 }, /* mic */
7661                         { 0x21, 0x0121401f }, /* HP out */
7662                         { }
7663                 },
7664         },
7665         [ALC269_FIXUP_HP_MUTE_LED] = {
7666                 .type = HDA_FIXUP_FUNC,
7667                 .v.func = alc269_fixup_hp_mute_led,
7668         },
7669         [ALC269_FIXUP_HP_MUTE_LED_MIC1] = {
7670                 .type = HDA_FIXUP_FUNC,
7671                 .v.func = alc269_fixup_hp_mute_led_mic1,
7672         },
7673         [ALC269_FIXUP_HP_MUTE_LED_MIC2] = {
7674                 .type = HDA_FIXUP_FUNC,
7675                 .v.func = alc269_fixup_hp_mute_led_mic2,
7676         },
7677         [ALC269_FIXUP_HP_MUTE_LED_MIC3] = {
7678                 .type = HDA_FIXUP_FUNC,
7679                 .v.func = alc269_fixup_hp_mute_led_mic3,
7680                 .chained = true,
7681                 .chain_id = ALC295_FIXUP_HP_AUTO_MUTE
7682         },
7683         [ALC269_FIXUP_HP_GPIO_LED] = {
7684                 .type = HDA_FIXUP_FUNC,
7685                 .v.func = alc269_fixup_hp_gpio_led,
7686         },
7687         [ALC269_FIXUP_HP_GPIO_MIC1_LED] = {
7688                 .type = HDA_FIXUP_FUNC,
7689                 .v.func = alc269_fixup_hp_gpio_mic1_led,
7690         },
7691         [ALC269_FIXUP_HP_LINE1_MIC1_LED] = {
7692                 .type = HDA_FIXUP_FUNC,
7693                 .v.func = alc269_fixup_hp_line1_mic1_led,
7694         },
7695         [ALC269_FIXUP_INV_DMIC] = {
7696                 .type = HDA_FIXUP_FUNC,
7697                 .v.func = alc_fixup_inv_dmic,
7698         },
7699         [ALC269_FIXUP_NO_SHUTUP] = {
7700                 .type = HDA_FIXUP_FUNC,
7701                 .v.func = alc_fixup_no_shutup,
7702         },
7703         [ALC269_FIXUP_LENOVO_DOCK] = {
7704                 .type = HDA_FIXUP_PINS,
7705                 .v.pins = (const struct hda_pintbl[]) {
7706                         { 0x19, 0x23a11040 }, /* dock mic */
7707                         { 0x1b, 0x2121103f }, /* dock headphone */
7708                         { }
7709                 },
7710                 .chained = true,
7711                 .chain_id = ALC269_FIXUP_PINCFG_NO_HP_TO_LINEOUT
7712         },
7713         [ALC269_FIXUP_LENOVO_DOCK_LIMIT_BOOST] = {
7714                 .type = HDA_FIXUP_FUNC,
7715                 .v.func = alc269_fixup_limit_int_mic_boost,
7716                 .chained = true,
7717                 .chain_id = ALC269_FIXUP_LENOVO_DOCK,
7718         },
7719         [ALC269_FIXUP_PINCFG_NO_HP_TO_LINEOUT] = {
7720                 .type = HDA_FIXUP_FUNC,
7721                 .v.func = alc269_fixup_pincfg_no_hp_to_lineout,
7722                 .chained = true,
7723                 .chain_id = ALC269_FIXUP_THINKPAD_ACPI,
7724         },
7725         [ALC269_FIXUP_DELL1_MIC_NO_PRESENCE] = {
7726                 .type = HDA_FIXUP_PINS,
7727                 .v.pins = (const struct hda_pintbl[]) {
7728                         { 0x19, 0x01a1913c }, /* use as headset mic, without its own jack detect */
7729                         { 0x1a, 0x01a1913d }, /* use as headphone mic, without its own jack detect */
7730                         { }
7731                 },
7732                 .chained = true,
7733                 .chain_id = ALC269_FIXUP_HEADSET_MODE
7734         },
7735         [ALC269_FIXUP_DELL2_MIC_NO_PRESENCE] = {
7736                 .type = HDA_FIXUP_PINS,
7737                 .v.pins = (const struct hda_pintbl[]) {
7738                         { 0x16, 0x21014020 }, /* dock line out */
7739                         { 0x19, 0x21a19030 }, /* dock mic */
7740                         { 0x1a, 0x01a1913c }, /* use as headset mic, without its own jack detect */
7741                         { }
7742                 },
7743                 .chained = true,
7744                 .chain_id = ALC269_FIXUP_HEADSET_MODE_NO_HP_MIC
7745         },
7746         [ALC269_FIXUP_DELL3_MIC_NO_PRESENCE] = {
7747                 .type = HDA_FIXUP_PINS,
7748                 .v.pins = (const struct hda_pintbl[]) {
7749                         { 0x1a, 0x01a1913c }, /* use as headset mic, without its own jack detect */
7750                         { }
7751                 },
7752                 .chained = true,
7753                 .chain_id = ALC269_FIXUP_HEADSET_MODE_NO_HP_MIC
7754         },
7755         [ALC269_FIXUP_DELL4_MIC_NO_PRESENCE] = {
7756                 .type = HDA_FIXUP_PINS,
7757                 .v.pins = (const struct hda_pintbl[]) {
7758                         { 0x19, 0x01a1913c }, /* use as headset mic, without its own jack detect */
7759                         { 0x1b, 0x01a1913d }, /* use as headphone mic, without its own jack detect */
7760                         { }
7761                 },
7762                 .chained = true,
7763                 .chain_id = ALC269_FIXUP_HEADSET_MODE
7764         },
7765         [ALC269_FIXUP_HEADSET_MODE] = {
7766                 .type = HDA_FIXUP_FUNC,
7767                 .v.func = alc_fixup_headset_mode,
7768                 .chained = true,
7769                 .chain_id = ALC255_FIXUP_MIC_MUTE_LED
7770         },
7771         [ALC269_FIXUP_HEADSET_MODE_NO_HP_MIC] = {
7772                 .type = HDA_FIXUP_FUNC,
7773                 .v.func = alc_fixup_headset_mode_no_hp_mic,
7774         },
7775         [ALC269_FIXUP_ASPIRE_HEADSET_MIC] = {
7776                 .type = HDA_FIXUP_PINS,
7777                 .v.pins = (const struct hda_pintbl[]) {
7778                         { 0x19, 0x01a1913c }, /* headset mic w/o jack detect */
7779                         { }
7780                 },
7781                 .chained = true,
7782                 .chain_id = ALC269_FIXUP_HEADSET_MODE,
7783         },
7784         [ALC286_FIXUP_SONY_MIC_NO_PRESENCE] = {
7785                 .type = HDA_FIXUP_PINS,
7786                 .v.pins = (const struct hda_pintbl[]) {
7787                         { 0x18, 0x01a1913c }, /* use as headset mic, without its own jack detect */
7788                         { }
7789                 },
7790                 .chained = true,
7791                 .chain_id = ALC269_FIXUP_HEADSET_MIC
7792         },
7793         [ALC256_FIXUP_HUAWEI_MACH_WX9_PINS] = {
7794                 .type = HDA_FIXUP_PINS,
7795                 .v.pins = (const struct hda_pintbl[]) {
7796                         {0x12, 0x90a60130},
7797                         {0x13, 0x40000000},
7798                         {0x14, 0x90170110},
7799                         {0x18, 0x411111f0},
7800                         {0x19, 0x04a11040},
7801                         {0x1a, 0x411111f0},
7802                         {0x1b, 0x90170112},
7803                         {0x1d, 0x40759a05},
7804                         {0x1e, 0x411111f0},
7805                         {0x21, 0x04211020},
7806                         { }
7807                 },
7808                 .chained = true,
7809                 .chain_id = ALC255_FIXUP_MIC_MUTE_LED
7810         },
7811         [ALC298_FIXUP_HUAWEI_MBX_STEREO] = {
7812                 .type = HDA_FIXUP_FUNC,
7813                 .v.func = alc298_fixup_huawei_mbx_stereo,
7814                 .chained = true,
7815                 .chain_id = ALC255_FIXUP_MIC_MUTE_LED
7816         },
7817         [ALC269_FIXUP_ASUS_X101_FUNC] = {
7818                 .type = HDA_FIXUP_FUNC,
7819                 .v.func = alc269_fixup_x101_headset_mic,
7820         },
7821         [ALC269_FIXUP_ASUS_X101_VERB] = {
7822                 .type = HDA_FIXUP_VERBS,
7823                 .v.verbs = (const struct hda_verb[]) {
7824                         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
7825                         {0x20, AC_VERB_SET_COEF_INDEX, 0x08},
7826                         {0x20, AC_VERB_SET_PROC_COEF,  0x0310},
7827                         { }
7828                 },
7829                 .chained = true,
7830                 .chain_id = ALC269_FIXUP_ASUS_X101_FUNC
7831         },
7832         [ALC269_FIXUP_ASUS_X101] = {
7833                 .type = HDA_FIXUP_PINS,
7834                 .v.pins = (const struct hda_pintbl[]) {
7835                         { 0x18, 0x04a1182c }, /* Headset mic */
7836                         { }
7837                 },
7838                 .chained = true,
7839                 .chain_id = ALC269_FIXUP_ASUS_X101_VERB
7840         },
7841         [ALC271_FIXUP_AMIC_MIC2] = {
7842                 .type = HDA_FIXUP_PINS,
7843                 .v.pins = (const struct hda_pintbl[]) {
7844                         { 0x14, 0x99130110 }, /* speaker */
7845                         { 0x19, 0x01a19c20 }, /* mic */
7846                         { 0x1b, 0x99a7012f }, /* int-mic */
7847                         { 0x21, 0x0121401f }, /* HP out */
7848                         { }
7849                 },
7850         },
7851         [ALC271_FIXUP_HP_GATE_MIC_JACK] = {
7852                 .type = HDA_FIXUP_FUNC,
7853                 .v.func = alc271_hp_gate_mic_jack,
7854                 .chained = true,
7855                 .chain_id = ALC271_FIXUP_AMIC_MIC2,
7856         },
7857         [ALC271_FIXUP_HP_GATE_MIC_JACK_E1_572] = {
7858                 .type = HDA_FIXUP_FUNC,
7859                 .v.func = alc269_fixup_limit_int_mic_boost,
7860                 .chained = true,
7861                 .chain_id = ALC271_FIXUP_HP_GATE_MIC_JACK,
7862         },
7863         [ALC269_FIXUP_ACER_AC700] = {
7864                 .type = HDA_FIXUP_PINS,
7865                 .v.pins = (const struct hda_pintbl[]) {
7866                         { 0x12, 0x99a3092f }, /* int-mic */
7867                         { 0x14, 0x99130110 }, /* speaker */
7868                         { 0x18, 0x03a11c20 }, /* mic */
7869                         { 0x1e, 0x0346101e }, /* SPDIF1 */
7870                         { 0x21, 0x0321101f }, /* HP out */
7871                         { }
7872                 },
7873                 .chained = true,
7874                 .chain_id = ALC271_FIXUP_DMIC,
7875         },
7876         [ALC269_FIXUP_LIMIT_INT_MIC_BOOST] = {
7877                 .type = HDA_FIXUP_FUNC,
7878                 .v.func = alc269_fixup_limit_int_mic_boost,
7879                 .chained = true,
7880                 .chain_id = ALC269_FIXUP_THINKPAD_ACPI,
7881         },
7882         [ALC269VB_FIXUP_ASUS_ZENBOOK] = {
7883                 .type = HDA_FIXUP_FUNC,
7884                 .v.func = alc269_fixup_limit_int_mic_boost,
7885                 .chained = true,
7886                 .chain_id = ALC269VB_FIXUP_DMIC,
7887         },
7888         [ALC269VB_FIXUP_ASUS_ZENBOOK_UX31A] = {
7889                 .type = HDA_FIXUP_VERBS,
7890                 .v.verbs = (const struct hda_verb[]) {
7891                         /* class-D output amp +5dB */
7892                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x12 },
7893                         { 0x20, AC_VERB_SET_PROC_COEF, 0x2800 },
7894                         {}
7895                 },
7896                 .chained = true,
7897                 .chain_id = ALC269VB_FIXUP_ASUS_ZENBOOK,
7898         },
7899         [ALC269VB_FIXUP_ASUS_MIC_NO_PRESENCE] = {
7900                 .type = HDA_FIXUP_PINS,
7901                 .v.pins = (const struct hda_pintbl[]) {
7902                         { 0x18, 0x01a110f0 },  /* use as headset mic */
7903                         { }
7904                 },
7905                 .chained = true,
7906                 .chain_id = ALC269_FIXUP_HEADSET_MIC
7907         },
7908         [ALC269_FIXUP_LIMIT_INT_MIC_BOOST_MUTE_LED] = {
7909                 .type = HDA_FIXUP_FUNC,
7910                 .v.func = alc269_fixup_limit_int_mic_boost,
7911                 .chained = true,
7912                 .chain_id = ALC269_FIXUP_HP_MUTE_LED_MIC1,
7913         },
7914         [ALC269VB_FIXUP_ORDISSIMO_EVE2] = {
7915                 .type = HDA_FIXUP_PINS,
7916                 .v.pins = (const struct hda_pintbl[]) {
7917                         { 0x12, 0x99a3092f }, /* int-mic */
7918                         { 0x18, 0x03a11d20 }, /* mic */
7919                         { 0x19, 0x411111f0 }, /* Unused bogus pin */
7920                         { }
7921                 },
7922         },
7923         [ALC283_FIXUP_CHROME_BOOK] = {
7924                 .type = HDA_FIXUP_FUNC,
7925                 .v.func = alc283_fixup_chromebook,
7926         },
7927         [ALC283_FIXUP_SENSE_COMBO_JACK] = {
7928                 .type = HDA_FIXUP_FUNC,
7929                 .v.func = alc283_fixup_sense_combo_jack,
7930                 .chained = true,
7931                 .chain_id = ALC283_FIXUP_CHROME_BOOK,
7932         },
7933         [ALC282_FIXUP_ASUS_TX300] = {
7934                 .type = HDA_FIXUP_FUNC,
7935                 .v.func = alc282_fixup_asus_tx300,
7936         },
7937         [ALC283_FIXUP_INT_MIC] = {
7938                 .type = HDA_FIXUP_VERBS,
7939                 .v.verbs = (const struct hda_verb[]) {
7940                         {0x20, AC_VERB_SET_COEF_INDEX, 0x1a},
7941                         {0x20, AC_VERB_SET_PROC_COEF, 0x0011},
7942                         { }
7943                 },
7944                 .chained = true,
7945                 .chain_id = ALC269_FIXUP_LIMIT_INT_MIC_BOOST
7946         },
7947         [ALC290_FIXUP_SUBWOOFER_HSJACK] = {
7948                 .type = HDA_FIXUP_PINS,
7949                 .v.pins = (const struct hda_pintbl[]) {
7950                         { 0x17, 0x90170112 }, /* subwoofer */
7951                         { }
7952                 },
7953                 .chained = true,
7954                 .chain_id = ALC290_FIXUP_MONO_SPEAKERS_HSJACK,
7955         },
7956         [ALC290_FIXUP_SUBWOOFER] = {
7957                 .type = HDA_FIXUP_PINS,
7958                 .v.pins = (const struct hda_pintbl[]) {
7959                         { 0x17, 0x90170112 }, /* subwoofer */
7960                         { }
7961                 },
7962                 .chained = true,
7963                 .chain_id = ALC290_FIXUP_MONO_SPEAKERS,
7964         },
7965         [ALC290_FIXUP_MONO_SPEAKERS] = {
7966                 .type = HDA_FIXUP_FUNC,
7967                 .v.func = alc290_fixup_mono_speakers,
7968         },
7969         [ALC290_FIXUP_MONO_SPEAKERS_HSJACK] = {
7970                 .type = HDA_FIXUP_FUNC,
7971                 .v.func = alc290_fixup_mono_speakers,
7972                 .chained = true,
7973                 .chain_id = ALC269_FIXUP_DELL3_MIC_NO_PRESENCE,
7974         },
7975         [ALC269_FIXUP_THINKPAD_ACPI] = {
7976                 .type = HDA_FIXUP_FUNC,
7977                 .v.func = alc_fixup_thinkpad_acpi,
7978                 .chained = true,
7979                 .chain_id = ALC269_FIXUP_SKU_IGNORE,
7980         },
7981         [ALC269_FIXUP_DMIC_THINKPAD_ACPI] = {
7982                 .type = HDA_FIXUP_FUNC,
7983                 .v.func = alc_fixup_inv_dmic,
7984                 .chained = true,
7985                 .chain_id = ALC269_FIXUP_THINKPAD_ACPI,
7986         },
7987         [ALC255_FIXUP_ACER_MIC_NO_PRESENCE] = {
7988                 .type = HDA_FIXUP_PINS,
7989                 .v.pins = (const struct hda_pintbl[]) {
7990                         { 0x19, 0x01a1913c }, /* use as headset mic, without its own jack detect */
7991                         { }
7992                 },
7993                 .chained = true,
7994                 .chain_id = ALC255_FIXUP_HEADSET_MODE
7995         },
7996         [ALC255_FIXUP_ASUS_MIC_NO_PRESENCE] = {
7997                 .type = HDA_FIXUP_PINS,
7998                 .v.pins = (const struct hda_pintbl[]) {
7999                         { 0x19, 0x01a1913c }, /* use as headset mic, without its own jack detect */
8000                         { }
8001                 },
8002                 .chained = true,
8003                 .chain_id = ALC255_FIXUP_HEADSET_MODE
8004         },
8005         [ALC255_FIXUP_DELL1_MIC_NO_PRESENCE] = {
8006                 .type = HDA_FIXUP_PINS,
8007                 .v.pins = (const struct hda_pintbl[]) {
8008                         { 0x19, 0x01a1913c }, /* use as headset mic, without its own jack detect */
8009                         { 0x1a, 0x01a1913d }, /* use as headphone mic, without its own jack detect */
8010                         { }
8011                 },
8012                 .chained = true,
8013                 .chain_id = ALC255_FIXUP_HEADSET_MODE
8014         },
8015         [ALC255_FIXUP_DELL2_MIC_NO_PRESENCE] = {
8016                 .type = HDA_FIXUP_PINS,
8017                 .v.pins = (const struct hda_pintbl[]) {
8018                         { 0x19, 0x01a1913c }, /* use as headset mic, without its own jack detect */
8019                         { }
8020                 },
8021                 .chained = true,
8022                 .chain_id = ALC255_FIXUP_HEADSET_MODE_NO_HP_MIC
8023         },
8024         [ALC255_FIXUP_HEADSET_MODE] = {
8025                 .type = HDA_FIXUP_FUNC,
8026                 .v.func = alc_fixup_headset_mode_alc255,
8027                 .chained = true,
8028                 .chain_id = ALC255_FIXUP_MIC_MUTE_LED
8029         },
8030         [ALC255_FIXUP_HEADSET_MODE_NO_HP_MIC] = {
8031                 .type = HDA_FIXUP_FUNC,
8032                 .v.func = alc_fixup_headset_mode_alc255_no_hp_mic,
8033         },
8034         [ALC293_FIXUP_DELL1_MIC_NO_PRESENCE] = {
8035                 .type = HDA_FIXUP_PINS,
8036                 .v.pins = (const struct hda_pintbl[]) {
8037                         { 0x18, 0x01a1913d }, /* use as headphone mic, without its own jack detect */
8038                         { 0x1a, 0x01a1913c }, /* use as headset mic, without its own jack detect */
8039                         { }
8040                 },
8041                 .chained = true,
8042                 .chain_id = ALC269_FIXUP_HEADSET_MODE
8043         },
8044         [ALC292_FIXUP_TPT440_DOCK] = {
8045                 .type = HDA_FIXUP_FUNC,
8046                 .v.func = alc_fixup_tpt440_dock,
8047                 .chained = true,
8048                 .chain_id = ALC269_FIXUP_LIMIT_INT_MIC_BOOST
8049         },
8050         [ALC292_FIXUP_TPT440] = {
8051                 .type = HDA_FIXUP_FUNC,
8052                 .v.func = alc_fixup_disable_aamix,
8053                 .chained = true,
8054                 .chain_id = ALC292_FIXUP_TPT440_DOCK,
8055         },
8056         [ALC283_FIXUP_HEADSET_MIC] = {
8057                 .type = HDA_FIXUP_PINS,
8058                 .v.pins = (const struct hda_pintbl[]) {
8059                         { 0x19, 0x04a110f0 },
8060                         { },
8061                 },
8062         },
8063         [ALC255_FIXUP_MIC_MUTE_LED] = {
8064                 .type = HDA_FIXUP_FUNC,
8065                 .v.func = alc_fixup_micmute_led,
8066         },
8067         [ALC282_FIXUP_ASPIRE_V5_PINS] = {
8068                 .type = HDA_FIXUP_PINS,
8069                 .v.pins = (const struct hda_pintbl[]) {
8070                         { 0x12, 0x90a60130 },
8071                         { 0x14, 0x90170110 },
8072                         { 0x17, 0x40000008 },
8073                         { 0x18, 0x411111f0 },
8074                         { 0x19, 0x01a1913c },
8075                         { 0x1a, 0x411111f0 },
8076                         { 0x1b, 0x411111f0 },
8077                         { 0x1d, 0x40f89b2d },
8078                         { 0x1e, 0x411111f0 },
8079                         { 0x21, 0x0321101f },
8080                         { },
8081                 },
8082         },
8083         [ALC269VB_FIXUP_ASPIRE_E1_COEF] = {
8084                 .type = HDA_FIXUP_FUNC,
8085                 .v.func = alc269vb_fixup_aspire_e1_coef,
8086         },
8087         [ALC280_FIXUP_HP_GPIO4] = {
8088                 .type = HDA_FIXUP_FUNC,
8089                 .v.func = alc280_fixup_hp_gpio4,
8090         },
8091         [ALC286_FIXUP_HP_GPIO_LED] = {
8092                 .type = HDA_FIXUP_FUNC,
8093                 .v.func = alc286_fixup_hp_gpio_led,
8094         },
8095         [ALC280_FIXUP_HP_GPIO2_MIC_HOTKEY] = {
8096                 .type = HDA_FIXUP_FUNC,
8097                 .v.func = alc280_fixup_hp_gpio2_mic_hotkey,
8098         },
8099         [ALC280_FIXUP_HP_DOCK_PINS] = {
8100                 .type = HDA_FIXUP_PINS,
8101                 .v.pins = (const struct hda_pintbl[]) {
8102                         { 0x1b, 0x21011020 }, /* line-out */
8103                         { 0x1a, 0x01a1903c }, /* headset mic */
8104                         { 0x18, 0x2181103f }, /* line-in */
8105                         { },
8106                 },
8107                 .chained = true,
8108                 .chain_id = ALC280_FIXUP_HP_GPIO4
8109         },
8110         [ALC269_FIXUP_HP_DOCK_GPIO_MIC1_LED] = {
8111                 .type = HDA_FIXUP_PINS,
8112                 .v.pins = (const struct hda_pintbl[]) {
8113                         { 0x1b, 0x21011020 }, /* line-out */
8114                         { 0x18, 0x2181103f }, /* line-in */
8115                         { },
8116                 },
8117                 .chained = true,
8118                 .chain_id = ALC269_FIXUP_HP_GPIO_MIC1_LED
8119         },
8120         [ALC280_FIXUP_HP_9480M] = {
8121                 .type = HDA_FIXUP_FUNC,
8122                 .v.func = alc280_fixup_hp_9480m,
8123         },
8124         [ALC245_FIXUP_HP_X360_AMP] = {
8125                 .type = HDA_FIXUP_FUNC,
8126                 .v.func = alc245_fixup_hp_x360_amp,
8127                 .chained = true,
8128                 .chain_id = ALC245_FIXUP_HP_GPIO_LED
8129         },
8130         [ALC288_FIXUP_DELL_HEADSET_MODE] = {
8131                 .type = HDA_FIXUP_FUNC,
8132                 .v.func = alc_fixup_headset_mode_dell_alc288,
8133                 .chained = true,
8134                 .chain_id = ALC255_FIXUP_MIC_MUTE_LED
8135         },
8136         [ALC288_FIXUP_DELL1_MIC_NO_PRESENCE] = {
8137                 .type = HDA_FIXUP_PINS,
8138                 .v.pins = (const struct hda_pintbl[]) {
8139                         { 0x18, 0x01a1913c }, /* use as headset mic, without its own jack detect */
8140                         { 0x1a, 0x01a1913d }, /* use as headphone mic, without its own jack detect */
8141                         { }
8142                 },
8143                 .chained = true,
8144                 .chain_id = ALC288_FIXUP_DELL_HEADSET_MODE
8145         },
8146         [ALC288_FIXUP_DISABLE_AAMIX] = {
8147                 .type = HDA_FIXUP_FUNC,
8148                 .v.func = alc_fixup_disable_aamix,
8149                 .chained = true,
8150                 .chain_id = ALC288_FIXUP_DELL1_MIC_NO_PRESENCE
8151         },
8152         [ALC288_FIXUP_DELL_XPS_13] = {
8153                 .type = HDA_FIXUP_FUNC,
8154                 .v.func = alc_fixup_dell_xps13,
8155                 .chained = true,
8156                 .chain_id = ALC288_FIXUP_DISABLE_AAMIX
8157         },
8158         [ALC292_FIXUP_DISABLE_AAMIX] = {
8159                 .type = HDA_FIXUP_FUNC,
8160                 .v.func = alc_fixup_disable_aamix,
8161                 .chained = true,
8162                 .chain_id = ALC269_FIXUP_DELL2_MIC_NO_PRESENCE
8163         },
8164         [ALC293_FIXUP_DISABLE_AAMIX_MULTIJACK] = {
8165                 .type = HDA_FIXUP_FUNC,
8166                 .v.func = alc_fixup_disable_aamix,
8167                 .chained = true,
8168                 .chain_id = ALC293_FIXUP_DELL1_MIC_NO_PRESENCE
8169         },
8170         [ALC292_FIXUP_DELL_E7X_AAMIX] = {
8171                 .type = HDA_FIXUP_FUNC,
8172                 .v.func = alc_fixup_dell_xps13,
8173                 .chained = true,
8174                 .chain_id = ALC292_FIXUP_DISABLE_AAMIX
8175         },
8176         [ALC292_FIXUP_DELL_E7X] = {
8177                 .type = HDA_FIXUP_FUNC,
8178                 .v.func = alc_fixup_micmute_led,
8179                 /* micmute fixup must be applied at last */
8180                 .chained_before = true,
8181                 .chain_id = ALC292_FIXUP_DELL_E7X_AAMIX,
8182         },
8183         [ALC298_FIXUP_ALIENWARE_MIC_NO_PRESENCE] = {
8184                 .type = HDA_FIXUP_PINS,
8185                 .v.pins = (const struct hda_pintbl[]) {
8186                         { 0x18, 0x01a1913c }, /* headset mic w/o jack detect */
8187                         { }
8188                 },
8189                 .chained_before = true,
8190                 .chain_id = ALC269_FIXUP_HEADSET_MODE,
8191         },
8192         [ALC298_FIXUP_DELL1_MIC_NO_PRESENCE] = {
8193                 .type = HDA_FIXUP_PINS,
8194                 .v.pins = (const struct hda_pintbl[]) {
8195                         { 0x18, 0x01a1913c }, /* use as headset mic, without its own jack detect */
8196                         { 0x1a, 0x01a1913d }, /* use as headphone mic, without its own jack detect */
8197                         { }
8198                 },
8199                 .chained = true,
8200                 .chain_id = ALC269_FIXUP_HEADSET_MODE
8201         },
8202         [ALC298_FIXUP_DELL_AIO_MIC_NO_PRESENCE] = {
8203                 .type = HDA_FIXUP_PINS,
8204                 .v.pins = (const struct hda_pintbl[]) {
8205                         { 0x18, 0x01a1913c }, /* use as headset mic, without its own jack detect */
8206                         { }
8207                 },
8208                 .chained = true,
8209                 .chain_id = ALC269_FIXUP_HEADSET_MODE
8210         },
8211         [ALC275_FIXUP_DELL_XPS] = {
8212                 .type = HDA_FIXUP_VERBS,
8213                 .v.verbs = (const struct hda_verb[]) {
8214                         /* Enables internal speaker */
8215                         {0x20, AC_VERB_SET_COEF_INDEX, 0x1f},
8216                         {0x20, AC_VERB_SET_PROC_COEF, 0x00c0},
8217                         {0x20, AC_VERB_SET_COEF_INDEX, 0x30},
8218                         {0x20, AC_VERB_SET_PROC_COEF, 0x00b1},
8219                         {}
8220                 }
8221         },
8222         [ALC293_FIXUP_LENOVO_SPK_NOISE] = {
8223                 .type = HDA_FIXUP_FUNC,
8224                 .v.func = alc_fixup_disable_aamix,
8225                 .chained = true,
8226                 .chain_id = ALC269_FIXUP_THINKPAD_ACPI
8227         },
8228         [ALC233_FIXUP_LENOVO_LINE2_MIC_HOTKEY] = {
8229                 .type = HDA_FIXUP_FUNC,
8230                 .v.func = alc233_fixup_lenovo_line2_mic_hotkey,
8231         },
8232         [ALC233_FIXUP_INTEL_NUC8_DMIC] = {
8233                 .type = HDA_FIXUP_FUNC,
8234                 .v.func = alc_fixup_inv_dmic,
8235                 .chained = true,
8236                 .chain_id = ALC233_FIXUP_INTEL_NUC8_BOOST,
8237         },
8238         [ALC233_FIXUP_INTEL_NUC8_BOOST] = {
8239                 .type = HDA_FIXUP_FUNC,
8240                 .v.func = alc269_fixup_limit_int_mic_boost
8241         },
8242         [ALC255_FIXUP_DELL_SPK_NOISE] = {
8243                 .type = HDA_FIXUP_FUNC,
8244                 .v.func = alc_fixup_disable_aamix,
8245                 .chained = true,
8246                 .chain_id = ALC255_FIXUP_DELL1_MIC_NO_PRESENCE
8247         },
8248         [ALC225_FIXUP_DISABLE_MIC_VREF] = {
8249                 .type = HDA_FIXUP_FUNC,
8250                 .v.func = alc_fixup_disable_mic_vref,
8251                 .chained = true,
8252                 .chain_id = ALC269_FIXUP_DELL1_MIC_NO_PRESENCE
8253         },
8254         [ALC225_FIXUP_DELL1_MIC_NO_PRESENCE] = {
8255                 .type = HDA_FIXUP_VERBS,
8256                 .v.verbs = (const struct hda_verb[]) {
8257                         /* Disable pass-through path for FRONT 14h */
8258                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x36 },
8259                         { 0x20, AC_VERB_SET_PROC_COEF, 0x57d7 },
8260                         {}
8261                 },
8262                 .chained = true,
8263                 .chain_id = ALC225_FIXUP_DISABLE_MIC_VREF
8264         },
8265         [ALC280_FIXUP_HP_HEADSET_MIC] = {
8266                 .type = HDA_FIXUP_FUNC,
8267                 .v.func = alc_fixup_disable_aamix,
8268                 .chained = true,
8269                 .chain_id = ALC269_FIXUP_HEADSET_MIC,
8270         },
8271         [ALC221_FIXUP_HP_FRONT_MIC] = {
8272                 .type = HDA_FIXUP_PINS,
8273                 .v.pins = (const struct hda_pintbl[]) {
8274                         { 0x19, 0x02a19020 }, /* Front Mic */
8275                         { }
8276                 },
8277         },
8278         [ALC292_FIXUP_TPT460] = {
8279                 .type = HDA_FIXUP_FUNC,
8280                 .v.func = alc_fixup_tpt440_dock,
8281                 .chained = true,
8282                 .chain_id = ALC293_FIXUP_LENOVO_SPK_NOISE,
8283         },
8284         [ALC298_FIXUP_SPK_VOLUME] = {
8285                 .type = HDA_FIXUP_FUNC,
8286                 .v.func = alc298_fixup_speaker_volume,
8287                 .chained = true,
8288                 .chain_id = ALC298_FIXUP_DELL_AIO_MIC_NO_PRESENCE,
8289         },
8290         [ALC298_FIXUP_LENOVO_SPK_VOLUME] = {
8291                 .type = HDA_FIXUP_FUNC,
8292                 .v.func = alc298_fixup_speaker_volume,
8293         },
8294         [ALC295_FIXUP_DISABLE_DAC3] = {
8295                 .type = HDA_FIXUP_FUNC,
8296                 .v.func = alc295_fixup_disable_dac3,
8297         },
8298         [ALC285_FIXUP_SPEAKER2_TO_DAC1] = {
8299                 .type = HDA_FIXUP_FUNC,
8300                 .v.func = alc285_fixup_speaker2_to_dac1,
8301                 .chained = true,
8302                 .chain_id = ALC269_FIXUP_THINKPAD_ACPI
8303         },
8304         [ALC285_FIXUP_ASUS_SPEAKER2_TO_DAC1] = {
8305                 .type = HDA_FIXUP_FUNC,
8306                 .v.func = alc285_fixup_speaker2_to_dac1,
8307                 .chained = true,
8308                 .chain_id = ALC245_FIXUP_CS35L41_SPI_2
8309         },
8310         [ALC285_FIXUP_ASUS_HEADSET_MIC] = {
8311                 .type = HDA_FIXUP_PINS,
8312                 .v.pins = (const struct hda_pintbl[]) {
8313                         { 0x19, 0x03a11050 },
8314                         { 0x1b, 0x03a11c30 },
8315                         { }
8316                 },
8317                 .chained = true,
8318                 .chain_id = ALC285_FIXUP_ASUS_SPEAKER2_TO_DAC1
8319         },
8320         [ALC285_FIXUP_ASUS_SPI_REAR_SPEAKERS] = {
8321                 .type = HDA_FIXUP_PINS,
8322                 .v.pins = (const struct hda_pintbl[]) {
8323                         { 0x14, 0x90170120 },
8324                         { }
8325                 },
8326                 .chained = true,
8327                 .chain_id = ALC285_FIXUP_ASUS_HEADSET_MIC
8328         },
8329         [ALC285_FIXUP_ASUS_I2C_SPEAKER2_TO_DAC1] = {
8330                 .type = HDA_FIXUP_FUNC,
8331                 .v.func = alc285_fixup_speaker2_to_dac1,
8332                 .chained = true,
8333                 .chain_id = ALC287_FIXUP_CS35L41_I2C_2
8334         },
8335         [ALC285_FIXUP_ASUS_I2C_HEADSET_MIC] = {
8336                 .type = HDA_FIXUP_PINS,
8337                 .v.pins = (const struct hda_pintbl[]) {
8338                         { 0x19, 0x03a11050 },
8339                         { 0x1b, 0x03a11c30 },
8340                         { }
8341                 },
8342                 .chained = true,
8343                 .chain_id = ALC285_FIXUP_ASUS_I2C_SPEAKER2_TO_DAC1
8344         },
8345         [ALC256_FIXUP_DELL_INSPIRON_7559_SUBWOOFER] = {
8346                 .type = HDA_FIXUP_PINS,
8347                 .v.pins = (const struct hda_pintbl[]) {
8348                         { 0x1b, 0x90170151 },
8349                         { }
8350                 },
8351                 .chained = true,
8352                 .chain_id = ALC255_FIXUP_DELL1_MIC_NO_PRESENCE
8353         },
8354         [ALC269_FIXUP_ATIV_BOOK_8] = {
8355                 .type = HDA_FIXUP_FUNC,
8356                 .v.func = alc_fixup_auto_mute_via_amp,
8357                 .chained = true,
8358                 .chain_id = ALC269_FIXUP_NO_SHUTUP
8359         },
8360         [ALC221_FIXUP_HP_288PRO_MIC_NO_PRESENCE] = {
8361                 .type = HDA_FIXUP_PINS,
8362                 .v.pins = (const struct hda_pintbl[]) {
8363                         { 0x19, 0x01a1913c }, /* use as headset mic, without its own jack detect */
8364                         { 0x1a, 0x01813030 }, /* use as headphone mic, without its own jack detect */
8365                         { }
8366                 },
8367                 .chained = true,
8368                 .chain_id = ALC269_FIXUP_HEADSET_MODE
8369         },
8370         [ALC221_FIXUP_HP_MIC_NO_PRESENCE] = {
8371                 .type = HDA_FIXUP_PINS,
8372                 .v.pins = (const struct hda_pintbl[]) {
8373                         { 0x18, 0x01a1913c }, /* use as headset mic, without its own jack detect */
8374                         { 0x1a, 0x01a1913d }, /* use as headphone mic, without its own jack detect */
8375                         { }
8376                 },
8377                 .chained = true,
8378                 .chain_id = ALC269_FIXUP_HEADSET_MODE
8379         },
8380         [ALC256_FIXUP_ASUS_HEADSET_MODE] = {
8381                 .type = HDA_FIXUP_FUNC,
8382                 .v.func = alc_fixup_headset_mode,
8383         },
8384         [ALC256_FIXUP_ASUS_MIC] = {
8385                 .type = HDA_FIXUP_PINS,
8386                 .v.pins = (const struct hda_pintbl[]) {
8387                         { 0x13, 0x90a60160 }, /* use as internal mic */
8388                         { 0x19, 0x04a11120 }, /* use as headset mic, without its own jack detect */
8389                         { }
8390                 },
8391                 .chained = true,
8392                 .chain_id = ALC256_FIXUP_ASUS_HEADSET_MODE
8393         },
8394         [ALC256_FIXUP_ASUS_AIO_GPIO2] = {
8395                 .type = HDA_FIXUP_FUNC,
8396                 /* Set up GPIO2 for the speaker amp */
8397                 .v.func = alc_fixup_gpio4,
8398         },
8399         [ALC233_FIXUP_ASUS_MIC_NO_PRESENCE] = {
8400                 .type = HDA_FIXUP_PINS,
8401                 .v.pins = (const struct hda_pintbl[]) {
8402                         { 0x19, 0x01a1913c }, /* use as headset mic, without its own jack detect */
8403                         { }
8404                 },
8405                 .chained = true,
8406                 .chain_id = ALC269_FIXUP_HEADSET_MIC
8407         },
8408         [ALC233_FIXUP_EAPD_COEF_AND_MIC_NO_PRESENCE] = {
8409                 .type = HDA_FIXUP_VERBS,
8410                 .v.verbs = (const struct hda_verb[]) {
8411                         /* Enables internal speaker */
8412                         {0x20, AC_VERB_SET_COEF_INDEX, 0x40},
8413                         {0x20, AC_VERB_SET_PROC_COEF, 0x8800},
8414                         {}
8415                 },
8416                 .chained = true,
8417                 .chain_id = ALC233_FIXUP_ASUS_MIC_NO_PRESENCE
8418         },
8419         [ALC233_FIXUP_LENOVO_MULTI_CODECS] = {
8420                 .type = HDA_FIXUP_FUNC,
8421                 .v.func = alc233_alc662_fixup_lenovo_dual_codecs,
8422                 .chained = true,
8423                 .chain_id = ALC269_FIXUP_GPIO2
8424         },
8425         [ALC233_FIXUP_ACER_HEADSET_MIC] = {
8426                 .type = HDA_FIXUP_VERBS,
8427                 .v.verbs = (const struct hda_verb[]) {
8428                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x45 },
8429                         { 0x20, AC_VERB_SET_PROC_COEF, 0x5089 },
8430                         { }
8431                 },
8432                 .chained = true,
8433                 .chain_id = ALC233_FIXUP_ASUS_MIC_NO_PRESENCE
8434         },
8435         [ALC294_FIXUP_LENOVO_MIC_LOCATION] = {
8436                 .type = HDA_FIXUP_PINS,
8437                 .v.pins = (const struct hda_pintbl[]) {
8438                         /* Change the mic location from front to right, otherwise there are
8439                            two front mics with the same name, pulseaudio can't handle them.
8440                            This is just a temporary workaround, after applying this fixup,
8441                            there will be one "Front Mic" and one "Mic" in this machine.
8442                          */
8443                         { 0x1a, 0x04a19040 },
8444                         { }
8445                 },
8446         },
8447         [ALC225_FIXUP_DELL_WYSE_MIC_NO_PRESENCE] = {
8448                 .type = HDA_FIXUP_PINS,
8449                 .v.pins = (const struct hda_pintbl[]) {
8450                         { 0x16, 0x0101102f }, /* Rear Headset HP */
8451                         { 0x19, 0x02a1913c }, /* use as Front headset mic, without its own jack detect */
8452                         { 0x1a, 0x01a19030 }, /* Rear Headset MIC */
8453                         { 0x1b, 0x02011020 },
8454                         { }
8455                 },
8456                 .chained = true,
8457                 .chain_id = ALC225_FIXUP_S3_POP_NOISE
8458         },
8459         [ALC225_FIXUP_S3_POP_NOISE] = {
8460                 .type = HDA_FIXUP_FUNC,
8461                 .v.func = alc225_fixup_s3_pop_noise,
8462                 .chained = true,
8463                 .chain_id = ALC269_FIXUP_HEADSET_MODE_NO_HP_MIC
8464         },
8465         [ALC700_FIXUP_INTEL_REFERENCE] = {
8466                 .type = HDA_FIXUP_VERBS,
8467                 .v.verbs = (const struct hda_verb[]) {
8468                         /* Enables internal speaker */
8469                         {0x20, AC_VERB_SET_COEF_INDEX, 0x45},
8470                         {0x20, AC_VERB_SET_PROC_COEF, 0x5289},
8471                         {0x20, AC_VERB_SET_COEF_INDEX, 0x4A},
8472                         {0x20, AC_VERB_SET_PROC_COEF, 0x001b},
8473                         {0x58, AC_VERB_SET_COEF_INDEX, 0x00},
8474                         {0x58, AC_VERB_SET_PROC_COEF, 0x3888},
8475                         {0x20, AC_VERB_SET_COEF_INDEX, 0x6f},
8476                         {0x20, AC_VERB_SET_PROC_COEF, 0x2c0b},
8477                         {}
8478                 }
8479         },
8480         [ALC274_FIXUP_DELL_BIND_DACS] = {
8481                 .type = HDA_FIXUP_FUNC,
8482                 .v.func = alc274_fixup_bind_dacs,
8483                 .chained = true,
8484                 .chain_id = ALC269_FIXUP_DELL1_MIC_NO_PRESENCE
8485         },
8486         [ALC274_FIXUP_DELL_AIO_LINEOUT_VERB] = {
8487                 .type = HDA_FIXUP_PINS,
8488                 .v.pins = (const struct hda_pintbl[]) {
8489                         { 0x1b, 0x0401102f },
8490                         { }
8491                 },
8492                 .chained = true,
8493                 .chain_id = ALC274_FIXUP_DELL_BIND_DACS
8494         },
8495         [ALC298_FIXUP_TPT470_DOCK_FIX] = {
8496                 .type = HDA_FIXUP_FUNC,
8497                 .v.func = alc_fixup_tpt470_dock,
8498                 .chained = true,
8499                 .chain_id = ALC293_FIXUP_LENOVO_SPK_NOISE
8500         },
8501         [ALC298_FIXUP_TPT470_DOCK] = {
8502                 .type = HDA_FIXUP_FUNC,
8503                 .v.func = alc_fixup_tpt470_dacs,
8504                 .chained = true,
8505                 .chain_id = ALC298_FIXUP_TPT470_DOCK_FIX
8506         },
8507         [ALC255_FIXUP_DUMMY_LINEOUT_VERB] = {
8508                 .type = HDA_FIXUP_PINS,
8509                 .v.pins = (const struct hda_pintbl[]) {
8510                         { 0x14, 0x0201101f },
8511                         { }
8512                 },
8513                 .chained = true,
8514                 .chain_id = ALC255_FIXUP_DELL1_MIC_NO_PRESENCE
8515         },
8516         [ALC255_FIXUP_DELL_HEADSET_MIC] = {
8517                 .type = HDA_FIXUP_PINS,
8518                 .v.pins = (const struct hda_pintbl[]) {
8519                         { 0x19, 0x01a1913c }, /* use as headset mic, without its own jack detect */
8520                         { }
8521                 },
8522                 .chained = true,
8523                 .chain_id = ALC269_FIXUP_HEADSET_MIC
8524         },
8525         [ALC295_FIXUP_HP_X360] = {
8526                 .type = HDA_FIXUP_FUNC,
8527                 .v.func = alc295_fixup_hp_top_speakers,
8528                 .chained = true,
8529                 .chain_id = ALC269_FIXUP_HP_MUTE_LED_MIC3
8530         },
8531         [ALC221_FIXUP_HP_HEADSET_MIC] = {
8532                 .type = HDA_FIXUP_PINS,
8533                 .v.pins = (const struct hda_pintbl[]) {
8534                         { 0x19, 0x0181313f},
8535                         { }
8536                 },
8537                 .chained = true,
8538                 .chain_id = ALC269_FIXUP_HEADSET_MIC
8539         },
8540         [ALC285_FIXUP_LENOVO_HEADPHONE_NOISE] = {
8541                 .type = HDA_FIXUP_FUNC,
8542                 .v.func = alc285_fixup_invalidate_dacs,
8543                 .chained = true,
8544                 .chain_id = ALC269_FIXUP_THINKPAD_ACPI
8545         },
8546         [ALC295_FIXUP_HP_AUTO_MUTE] = {
8547                 .type = HDA_FIXUP_FUNC,
8548                 .v.func = alc_fixup_auto_mute_via_amp,
8549         },
8550         [ALC286_FIXUP_ACER_AIO_MIC_NO_PRESENCE] = {
8551                 .type = HDA_FIXUP_PINS,
8552                 .v.pins = (const struct hda_pintbl[]) {
8553                         { 0x18, 0x01a1913c }, /* use as headset mic, without its own jack detect */
8554                         { }
8555                 },
8556                 .chained = true,
8557                 .chain_id = ALC269_FIXUP_HEADSET_MIC
8558         },
8559         [ALC294_FIXUP_ASUS_MIC] = {
8560                 .type = HDA_FIXUP_PINS,
8561                 .v.pins = (const struct hda_pintbl[]) {
8562                         { 0x13, 0x90a60160 }, /* use as internal mic */
8563                         { 0x19, 0x04a11120 }, /* use as headset mic, without its own jack detect */
8564                         { }
8565                 },
8566                 .chained = true,
8567                 .chain_id = ALC269_FIXUP_HEADSET_MIC
8568         },
8569         [ALC294_FIXUP_ASUS_HEADSET_MIC] = {
8570                 .type = HDA_FIXUP_PINS,
8571                 .v.pins = (const struct hda_pintbl[]) {
8572                         { 0x19, 0x01a1103c }, /* use as headset mic */
8573                         { }
8574                 },
8575                 .chained = true,
8576                 .chain_id = ALC269_FIXUP_HEADSET_MIC
8577         },
8578         [ALC294_FIXUP_ASUS_SPK] = {
8579                 .type = HDA_FIXUP_VERBS,
8580                 .v.verbs = (const struct hda_verb[]) {
8581                         /* Set EAPD high */
8582                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x40 },
8583                         { 0x20, AC_VERB_SET_PROC_COEF, 0x8800 },
8584                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x0f },
8585                         { 0x20, AC_VERB_SET_PROC_COEF, 0x7774 },
8586                         { }
8587                 },
8588                 .chained = true,
8589                 .chain_id = ALC294_FIXUP_ASUS_HEADSET_MIC
8590         },
8591         [ALC295_FIXUP_CHROME_BOOK] = {
8592                 .type = HDA_FIXUP_FUNC,
8593                 .v.func = alc295_fixup_chromebook,
8594                 .chained = true,
8595                 .chain_id = ALC225_FIXUP_HEADSET_JACK
8596         },
8597         [ALC225_FIXUP_HEADSET_JACK] = {
8598                 .type = HDA_FIXUP_FUNC,
8599                 .v.func = alc_fixup_headset_jack,
8600         },
8601         [ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE] = {
8602                 .type = HDA_FIXUP_PINS,
8603                 .v.pins = (const struct hda_pintbl[]) {
8604                         { 0x1a, 0x01a1913c }, /* use as headset mic, without its own jack detect */
8605                         { }
8606                 },
8607                 .chained = true,
8608                 .chain_id = ALC269_FIXUP_HEADSET_MODE_NO_HP_MIC
8609         },
8610         [ALC285_FIXUP_LENOVO_PC_BEEP_IN_NOISE] = {
8611                 .type = HDA_FIXUP_VERBS,
8612                 .v.verbs = (const struct hda_verb[]) {
8613                         /* Disable PCBEEP-IN passthrough */
8614                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x36 },
8615                         { 0x20, AC_VERB_SET_PROC_COEF, 0x57d7 },
8616                         { }
8617                 },
8618                 .chained = true,
8619                 .chain_id = ALC285_FIXUP_LENOVO_HEADPHONE_NOISE
8620         },
8621         [ALC255_FIXUP_ACER_HEADSET_MIC] = {
8622                 .type = HDA_FIXUP_PINS,
8623                 .v.pins = (const struct hda_pintbl[]) {
8624                         { 0x19, 0x03a11130 },
8625                         { 0x1a, 0x90a60140 }, /* use as internal mic */
8626                         { }
8627                 },
8628                 .chained = true,
8629                 .chain_id = ALC255_FIXUP_HEADSET_MODE_NO_HP_MIC
8630         },
8631         [ALC225_FIXUP_DELL_WYSE_AIO_MIC_NO_PRESENCE] = {
8632                 .type = HDA_FIXUP_PINS,
8633                 .v.pins = (const struct hda_pintbl[]) {
8634                         { 0x16, 0x01011020 }, /* Rear Line out */
8635                         { 0x19, 0x01a1913c }, /* use as Front headset mic, without its own jack detect */
8636                         { }
8637                 },
8638                 .chained = true,
8639                 .chain_id = ALC225_FIXUP_WYSE_AUTO_MUTE
8640         },
8641         [ALC225_FIXUP_WYSE_AUTO_MUTE] = {
8642                 .type = HDA_FIXUP_FUNC,
8643                 .v.func = alc_fixup_auto_mute_via_amp,
8644                 .chained = true,
8645                 .chain_id = ALC225_FIXUP_WYSE_DISABLE_MIC_VREF
8646         },
8647         [ALC225_FIXUP_WYSE_DISABLE_MIC_VREF] = {
8648                 .type = HDA_FIXUP_FUNC,
8649                 .v.func = alc_fixup_disable_mic_vref,
8650                 .chained = true,
8651                 .chain_id = ALC269_FIXUP_HEADSET_MODE_NO_HP_MIC
8652         },
8653         [ALC286_FIXUP_ACER_AIO_HEADSET_MIC] = {
8654                 .type = HDA_FIXUP_VERBS,
8655                 .v.verbs = (const struct hda_verb[]) {
8656                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x4f },
8657                         { 0x20, AC_VERB_SET_PROC_COEF, 0x5029 },
8658                         { }
8659                 },
8660                 .chained = true,
8661                 .chain_id = ALC286_FIXUP_ACER_AIO_MIC_NO_PRESENCE
8662         },
8663         [ALC256_FIXUP_ASUS_HEADSET_MIC] = {
8664                 .type = HDA_FIXUP_PINS,
8665                 .v.pins = (const struct hda_pintbl[]) {
8666                         { 0x19, 0x03a11020 }, /* headset mic with jack detect */
8667                         { }
8668                 },
8669                 .chained = true,
8670                 .chain_id = ALC256_FIXUP_ASUS_HEADSET_MODE
8671         },
8672         [ALC256_FIXUP_ASUS_MIC_NO_PRESENCE] = {
8673                 .type = HDA_FIXUP_PINS,
8674                 .v.pins = (const struct hda_pintbl[]) {
8675                         { 0x19, 0x04a11120 }, /* use as headset mic, without its own jack detect */
8676                         { }
8677                 },
8678                 .chained = true,
8679                 .chain_id = ALC256_FIXUP_ASUS_HEADSET_MODE
8680         },
8681         [ALC299_FIXUP_PREDATOR_SPK] = {
8682                 .type = HDA_FIXUP_PINS,
8683                 .v.pins = (const struct hda_pintbl[]) {
8684                         { 0x21, 0x90170150 }, /* use as headset mic, without its own jack detect */
8685                         { }
8686                 }
8687         },
8688         [ALC256_FIXUP_MEDION_HEADSET_NO_PRESENCE] = {
8689                 .type = HDA_FIXUP_PINS,
8690                 .v.pins = (const struct hda_pintbl[]) {
8691                         { 0x19, 0x04a11040 },
8692                         { 0x21, 0x04211020 },
8693                         { }
8694                 },
8695                 .chained = true,
8696                 .chain_id = ALC256_FIXUP_ASUS_HEADSET_MODE
8697         },
8698         [ALC289_FIXUP_DELL_SPK1] = {
8699                 .type = HDA_FIXUP_PINS,
8700                 .v.pins = (const struct hda_pintbl[]) {
8701                         { 0x14, 0x90170140 },
8702                         { }
8703                 },
8704                 .chained = true,
8705                 .chain_id = ALC269_FIXUP_DELL4_MIC_NO_PRESENCE
8706         },
8707         [ALC289_FIXUP_DELL_SPK2] = {
8708                 .type = HDA_FIXUP_PINS,
8709                 .v.pins = (const struct hda_pintbl[]) {
8710                         { 0x17, 0x90170130 }, /* bass spk */
8711                         { }
8712                 },
8713                 .chained = true,
8714                 .chain_id = ALC269_FIXUP_DELL4_MIC_NO_PRESENCE
8715         },
8716         [ALC289_FIXUP_DUAL_SPK] = {
8717                 .type = HDA_FIXUP_FUNC,
8718                 .v.func = alc285_fixup_speaker2_to_dac1,
8719                 .chained = true,
8720                 .chain_id = ALC289_FIXUP_DELL_SPK2
8721         },
8722         [ALC289_FIXUP_RTK_AMP_DUAL_SPK] = {
8723                 .type = HDA_FIXUP_FUNC,
8724                 .v.func = alc285_fixup_speaker2_to_dac1,
8725                 .chained = true,
8726                 .chain_id = ALC289_FIXUP_DELL_SPK1
8727         },
8728         [ALC294_FIXUP_SPK2_TO_DAC1] = {
8729                 .type = HDA_FIXUP_FUNC,
8730                 .v.func = alc285_fixup_speaker2_to_dac1,
8731                 .chained = true,
8732                 .chain_id = ALC294_FIXUP_ASUS_HEADSET_MIC
8733         },
8734         [ALC294_FIXUP_ASUS_DUAL_SPK] = {
8735                 .type = HDA_FIXUP_FUNC,
8736                 /* The GPIO must be pulled to initialize the AMP */
8737                 .v.func = alc_fixup_gpio4,
8738                 .chained = true,
8739                 .chain_id = ALC294_FIXUP_SPK2_TO_DAC1
8740         },
8741         [ALC294_FIXUP_ASUS_ALLY] = {
8742                 .type = HDA_FIXUP_FUNC,
8743                 .v.func = cs35l41_fixup_i2c_two,
8744                 .chained = true,
8745                 .chain_id = ALC294_FIXUP_ASUS_ALLY_PINS
8746         },
8747         [ALC294_FIXUP_ASUS_ALLY_PINS] = {
8748                 .type = HDA_FIXUP_PINS,
8749                 .v.pins = (const struct hda_pintbl[]) {
8750                         { 0x19, 0x03a11050 },
8751                         { 0x1a, 0x03a11c30 },
8752                         { 0x21, 0x03211420 },
8753                         { }
8754                 },
8755                 .chained = true,
8756                 .chain_id = ALC294_FIXUP_ASUS_ALLY_VERBS
8757         },
8758         [ALC294_FIXUP_ASUS_ALLY_VERBS] = {
8759                 .type = HDA_FIXUP_VERBS,
8760                 .v.verbs = (const struct hda_verb[]) {
8761                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x45 },
8762                         { 0x20, AC_VERB_SET_PROC_COEF, 0x5089 },
8763                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x46 },
8764                         { 0x20, AC_VERB_SET_PROC_COEF, 0x0004 },
8765                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x47 },
8766                         { 0x20, AC_VERB_SET_PROC_COEF, 0xa47a },
8767                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x49 },
8768                         { 0x20, AC_VERB_SET_PROC_COEF, 0x0049},
8769                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x4a },
8770                         { 0x20, AC_VERB_SET_PROC_COEF, 0x201b },
8771                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x6b },
8772                         { 0x20, AC_VERB_SET_PROC_COEF, 0x4278},
8773                         { }
8774                 },
8775                 .chained = true,
8776                 .chain_id = ALC294_FIXUP_ASUS_ALLY_SPEAKER
8777         },
8778         [ALC294_FIXUP_ASUS_ALLY_SPEAKER] = {
8779                 .type = HDA_FIXUP_FUNC,
8780                 .v.func = alc285_fixup_speaker2_to_dac1,
8781         },
8782         [ALC285_FIXUP_THINKPAD_X1_GEN7] = {
8783                 .type = HDA_FIXUP_FUNC,
8784                 .v.func = alc285_fixup_thinkpad_x1_gen7,
8785                 .chained = true,
8786                 .chain_id = ALC269_FIXUP_THINKPAD_ACPI
8787         },
8788         [ALC285_FIXUP_THINKPAD_HEADSET_JACK] = {
8789                 .type = HDA_FIXUP_FUNC,
8790                 .v.func = alc_fixup_headset_jack,
8791                 .chained = true,
8792                 .chain_id = ALC285_FIXUP_THINKPAD_X1_GEN7
8793         },
8794         [ALC294_FIXUP_ASUS_HPE] = {
8795                 .type = HDA_FIXUP_VERBS,
8796                 .v.verbs = (const struct hda_verb[]) {
8797                         /* Set EAPD high */
8798                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x0f },
8799                         { 0x20, AC_VERB_SET_PROC_COEF, 0x7774 },
8800                         { }
8801                 },
8802                 .chained = true,
8803                 .chain_id = ALC294_FIXUP_ASUS_HEADSET_MIC
8804         },
8805         [ALC294_FIXUP_ASUS_GX502_PINS] = {
8806                 .type = HDA_FIXUP_PINS,
8807                 .v.pins = (const struct hda_pintbl[]) {
8808                         { 0x19, 0x03a11050 }, /* front HP mic */
8809                         { 0x1a, 0x01a11830 }, /* rear external mic */
8810                         { 0x21, 0x03211020 }, /* front HP out */
8811                         { }
8812                 },
8813                 .chained = true,
8814                 .chain_id = ALC294_FIXUP_ASUS_GX502_VERBS
8815         },
8816         [ALC294_FIXUP_ASUS_GX502_VERBS] = {
8817                 .type = HDA_FIXUP_VERBS,
8818                 .v.verbs = (const struct hda_verb[]) {
8819                         /* set 0x15 to HP-OUT ctrl */
8820                         { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0 },
8821                         /* unmute the 0x15 amp */
8822                         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000 },
8823                         { }
8824                 },
8825                 .chained = true,
8826                 .chain_id = ALC294_FIXUP_ASUS_GX502_HP
8827         },
8828         [ALC294_FIXUP_ASUS_GX502_HP] = {
8829                 .type = HDA_FIXUP_FUNC,
8830                 .v.func = alc294_fixup_gx502_hp,
8831         },
8832         [ALC294_FIXUP_ASUS_GU502_PINS] = {
8833                 .type = HDA_FIXUP_PINS,
8834                 .v.pins = (const struct hda_pintbl[]) {
8835                         { 0x19, 0x01a11050 }, /* rear HP mic */
8836                         { 0x1a, 0x01a11830 }, /* rear external mic */
8837                         { 0x21, 0x012110f0 }, /* rear HP out */
8838                         { }
8839                 },
8840                 .chained = true,
8841                 .chain_id = ALC294_FIXUP_ASUS_GU502_VERBS
8842         },
8843         [ALC294_FIXUP_ASUS_GU502_VERBS] = {
8844                 .type = HDA_FIXUP_VERBS,
8845                 .v.verbs = (const struct hda_verb[]) {
8846                         /* set 0x15 to HP-OUT ctrl */
8847                         { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0 },
8848                         /* unmute the 0x15 amp */
8849                         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000 },
8850                         /* set 0x1b to HP-OUT */
8851                         { 0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
8852                         { }
8853                 },
8854                 .chained = true,
8855                 .chain_id = ALC294_FIXUP_ASUS_GU502_HP
8856         },
8857         [ALC294_FIXUP_ASUS_GU502_HP] = {
8858                 .type = HDA_FIXUP_FUNC,
8859                 .v.func = alc294_fixup_gu502_hp,
8860         },
8861          [ALC294_FIXUP_ASUS_G513_PINS] = {
8862                 .type = HDA_FIXUP_PINS,
8863                 .v.pins = (const struct hda_pintbl[]) {
8864                                 { 0x19, 0x03a11050 }, /* front HP mic */
8865                                 { 0x1a, 0x03a11c30 }, /* rear external mic */
8866                                 { 0x21, 0x03211420 }, /* front HP out */
8867                                 { }
8868                 },
8869         },
8870         [ALC285_FIXUP_ASUS_G533Z_PINS] = {
8871                 .type = HDA_FIXUP_PINS,
8872                 .v.pins = (const struct hda_pintbl[]) {
8873                         { 0x14, 0x90170152 }, /* Speaker Surround Playback Switch */
8874                         { 0x19, 0x03a19020 }, /* Mic Boost Volume */
8875                         { 0x1a, 0x03a11c30 }, /* Mic Boost Volume */
8876                         { 0x1e, 0x90170151 }, /* Rear jack, IN OUT EAPD Detect */
8877                         { 0x21, 0x03211420 },
8878                         { }
8879                 },
8880         },
8881         [ALC294_FIXUP_ASUS_COEF_1B] = {
8882                 .type = HDA_FIXUP_VERBS,
8883                 .v.verbs = (const struct hda_verb[]) {
8884                         /* Set bit 10 to correct noisy output after reboot from
8885                          * Windows 10 (due to pop noise reduction?)
8886                          */
8887                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x1b },
8888                         { 0x20, AC_VERB_SET_PROC_COEF, 0x4e4b },
8889                         { }
8890                 },
8891                 .chained = true,
8892                 .chain_id = ALC289_FIXUP_ASUS_GA401,
8893         },
8894         [ALC285_FIXUP_HP_GPIO_LED] = {
8895                 .type = HDA_FIXUP_FUNC,
8896                 .v.func = alc285_fixup_hp_gpio_led,
8897         },
8898         [ALC285_FIXUP_HP_MUTE_LED] = {
8899                 .type = HDA_FIXUP_FUNC,
8900                 .v.func = alc285_fixup_hp_mute_led,
8901         },
8902         [ALC285_FIXUP_HP_SPECTRE_X360_MUTE_LED] = {
8903                 .type = HDA_FIXUP_FUNC,
8904                 .v.func = alc285_fixup_hp_spectre_x360_mute_led,
8905         },
8906         [ALC236_FIXUP_HP_MUTE_LED_COEFBIT2] = {
8907             .type = HDA_FIXUP_FUNC,
8908             .v.func = alc236_fixup_hp_mute_led_coefbit2,
8909         },
8910         [ALC236_FIXUP_HP_GPIO_LED] = {
8911                 .type = HDA_FIXUP_FUNC,
8912                 .v.func = alc236_fixup_hp_gpio_led,
8913         },
8914         [ALC236_FIXUP_HP_MUTE_LED] = {
8915                 .type = HDA_FIXUP_FUNC,
8916                 .v.func = alc236_fixup_hp_mute_led,
8917         },
8918         [ALC236_FIXUP_HP_MUTE_LED_MICMUTE_VREF] = {
8919                 .type = HDA_FIXUP_FUNC,
8920                 .v.func = alc236_fixup_hp_mute_led_micmute_vref,
8921         },
8922         [ALC298_FIXUP_SAMSUNG_AMP] = {
8923                 .type = HDA_FIXUP_FUNC,
8924                 .v.func = alc298_fixup_samsung_amp,
8925                 .chained = true,
8926                 .chain_id = ALC298_FIXUP_SAMSUNG_HEADPHONE_VERY_QUIET
8927         },
8928         [ALC298_FIXUP_SAMSUNG_HEADPHONE_VERY_QUIET] = {
8929                 .type = HDA_FIXUP_VERBS,
8930                 .v.verbs = (const struct hda_verb[]) {
8931                         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc5 },
8932                         { }
8933                 },
8934         },
8935         [ALC256_FIXUP_SAMSUNG_HEADPHONE_VERY_QUIET] = {
8936                 .type = HDA_FIXUP_VERBS,
8937                 .v.verbs = (const struct hda_verb[]) {
8938                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x08},
8939                         { 0x20, AC_VERB_SET_PROC_COEF, 0x2fcf},
8940                         { }
8941                 },
8942         },
8943         [ALC295_FIXUP_ASUS_MIC_NO_PRESENCE] = {
8944                 .type = HDA_FIXUP_PINS,
8945                 .v.pins = (const struct hda_pintbl[]) {
8946                         { 0x19, 0x01a1913c }, /* use as headset mic, without its own jack detect */
8947                         { }
8948                 },
8949                 .chained = true,
8950                 .chain_id = ALC269_FIXUP_HEADSET_MODE
8951         },
8952         [ALC269VC_FIXUP_ACER_VCOPPERBOX_PINS] = {
8953                 .type = HDA_FIXUP_PINS,
8954                 .v.pins = (const struct hda_pintbl[]) {
8955                         { 0x14, 0x90100120 }, /* use as internal speaker */
8956                         { 0x18, 0x02a111f0 }, /* use as headset mic, without its own jack detect */
8957                         { 0x1a, 0x01011020 }, /* use as line out */
8958                         { },
8959                 },
8960                 .chained = true,
8961                 .chain_id = ALC269_FIXUP_HEADSET_MIC
8962         },
8963         [ALC269VC_FIXUP_ACER_HEADSET_MIC] = {
8964                 .type = HDA_FIXUP_PINS,
8965                 .v.pins = (const struct hda_pintbl[]) {
8966                         { 0x18, 0x02a11030 }, /* use as headset mic */
8967                         { }
8968                 },
8969                 .chained = true,
8970                 .chain_id = ALC269_FIXUP_HEADSET_MIC
8971         },
8972         [ALC269VC_FIXUP_ACER_MIC_NO_PRESENCE] = {
8973                 .type = HDA_FIXUP_PINS,
8974                 .v.pins = (const struct hda_pintbl[]) {
8975                         { 0x18, 0x01a11130 }, /* use as headset mic, without its own jack detect */
8976                         { }
8977                 },
8978                 .chained = true,
8979                 .chain_id = ALC269_FIXUP_HEADSET_MIC
8980         },
8981         [ALC289_FIXUP_ASUS_GA401] = {
8982                 .type = HDA_FIXUP_FUNC,
8983                 .v.func = alc289_fixup_asus_ga401,
8984                 .chained = true,
8985                 .chain_id = ALC289_FIXUP_ASUS_GA502,
8986         },
8987         [ALC289_FIXUP_ASUS_GA502] = {
8988                 .type = HDA_FIXUP_PINS,
8989                 .v.pins = (const struct hda_pintbl[]) {
8990                         { 0x19, 0x03a11020 }, /* headset mic with jack detect */
8991                         { }
8992                 },
8993         },
8994         [ALC256_FIXUP_ACER_MIC_NO_PRESENCE] = {
8995                 .type = HDA_FIXUP_PINS,
8996                 .v.pins = (const struct hda_pintbl[]) {
8997                         { 0x19, 0x02a11120 }, /* use as headset mic, without its own jack detect */
8998                         { }
8999                 },
9000                 .chained = true,
9001                 .chain_id = ALC256_FIXUP_ASUS_HEADSET_MODE
9002         },
9003         [ALC285_FIXUP_HP_GPIO_AMP_INIT] = {
9004                 .type = HDA_FIXUP_FUNC,
9005                 .v.func = alc285_fixup_hp_gpio_amp_init,
9006                 .chained = true,
9007                 .chain_id = ALC285_FIXUP_HP_GPIO_LED
9008         },
9009         [ALC269_FIXUP_CZC_B20] = {
9010                 .type = HDA_FIXUP_PINS,
9011                 .v.pins = (const struct hda_pintbl[]) {
9012                         { 0x12, 0x411111f0 },
9013                         { 0x14, 0x90170110 }, /* speaker */
9014                         { 0x15, 0x032f1020 }, /* HP out */
9015                         { 0x17, 0x411111f0 },
9016                         { 0x18, 0x03ab1040 }, /* mic */
9017                         { 0x19, 0xb7a7013f },
9018                         { 0x1a, 0x0181305f },
9019                         { 0x1b, 0x411111f0 },
9020                         { 0x1d, 0x411111f0 },
9021                         { 0x1e, 0x411111f0 },
9022                         { }
9023                 },
9024                 .chain_id = ALC269_FIXUP_DMIC,
9025         },
9026         [ALC269_FIXUP_CZC_TMI] = {
9027                 .type = HDA_FIXUP_PINS,
9028                 .v.pins = (const struct hda_pintbl[]) {
9029                         { 0x12, 0x4000c000 },
9030                         { 0x14, 0x90170110 }, /* speaker */
9031                         { 0x15, 0x0421401f }, /* HP out */
9032                         { 0x17, 0x411111f0 },
9033                         { 0x18, 0x04a19020 }, /* mic */
9034                         { 0x19, 0x411111f0 },
9035                         { 0x1a, 0x411111f0 },
9036                         { 0x1b, 0x411111f0 },
9037                         { 0x1d, 0x40448505 },
9038                         { 0x1e, 0x411111f0 },
9039                         { 0x20, 0x8000ffff },
9040                         { }
9041                 },
9042                 .chain_id = ALC269_FIXUP_DMIC,
9043         },
9044         [ALC269_FIXUP_CZC_L101] = {
9045                 .type = HDA_FIXUP_PINS,
9046                 .v.pins = (const struct hda_pintbl[]) {
9047                         { 0x12, 0x40000000 },
9048                         { 0x14, 0x01014010 }, /* speaker */
9049                         { 0x15, 0x411111f0 }, /* HP out */
9050                         { 0x16, 0x411111f0 },
9051                         { 0x18, 0x01a19020 }, /* mic */
9052                         { 0x19, 0x02a19021 },
9053                         { 0x1a, 0x0181302f },
9054                         { 0x1b, 0x0221401f },
9055                         { 0x1c, 0x411111f0 },
9056                         { 0x1d, 0x4044c601 },
9057                         { 0x1e, 0x411111f0 },
9058                         { }
9059                 },
9060                 .chain_id = ALC269_FIXUP_DMIC,
9061         },
9062         [ALC269_FIXUP_LEMOTE_A1802] = {
9063                 .type = HDA_FIXUP_PINS,
9064                 .v.pins = (const struct hda_pintbl[]) {
9065                         { 0x12, 0x40000000 },
9066                         { 0x14, 0x90170110 }, /* speaker */
9067                         { 0x17, 0x411111f0 },
9068                         { 0x18, 0x03a19040 }, /* mic1 */
9069                         { 0x19, 0x90a70130 }, /* mic2 */
9070                         { 0x1a, 0x411111f0 },
9071                         { 0x1b, 0x411111f0 },
9072                         { 0x1d, 0x40489d2d },
9073                         { 0x1e, 0x411111f0 },
9074                         { 0x20, 0x0003ffff },
9075                         { 0x21, 0x03214020 },
9076                         { }
9077                 },
9078                 .chain_id = ALC269_FIXUP_DMIC,
9079         },
9080         [ALC269_FIXUP_LEMOTE_A190X] = {
9081                 .type = HDA_FIXUP_PINS,
9082                 .v.pins = (const struct hda_pintbl[]) {
9083                         { 0x14, 0x99130110 }, /* speaker */
9084                         { 0x15, 0x0121401f }, /* HP out */
9085                         { 0x18, 0x01a19c20 }, /* rear  mic */
9086                         { 0x19, 0x99a3092f }, /* front mic */
9087                         { 0x1b, 0x0201401f }, /* front lineout */
9088                         { }
9089                 },
9090                 .chain_id = ALC269_FIXUP_DMIC,
9091         },
9092         [ALC256_FIXUP_INTEL_NUC8_RUGGED] = {
9093                 .type = HDA_FIXUP_PINS,
9094                 .v.pins = (const struct hda_pintbl[]) {
9095                         { 0x1b, 0x01a1913c }, /* use as headset mic, without its own jack detect */
9096                         { }
9097                 },
9098                 .chained = true,
9099                 .chain_id = ALC269_FIXUP_HEADSET_MODE
9100         },
9101         [ALC256_FIXUP_INTEL_NUC10] = {
9102                 .type = HDA_FIXUP_PINS,
9103                 .v.pins = (const struct hda_pintbl[]) {
9104                         { 0x19, 0x01a1913c }, /* use as headset mic, without its own jack detect */
9105                         { }
9106                 },
9107                 .chained = true,
9108                 .chain_id = ALC269_FIXUP_HEADSET_MODE
9109         },
9110         [ALC255_FIXUP_XIAOMI_HEADSET_MIC] = {
9111                 .type = HDA_FIXUP_VERBS,
9112                 .v.verbs = (const struct hda_verb[]) {
9113                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x45 },
9114                         { 0x20, AC_VERB_SET_PROC_COEF, 0x5089 },
9115                         { }
9116                 },
9117                 .chained = true,
9118                 .chain_id = ALC289_FIXUP_ASUS_GA502
9119         },
9120         [ALC274_FIXUP_HP_MIC] = {
9121                 .type = HDA_FIXUP_VERBS,
9122                 .v.verbs = (const struct hda_verb[]) {
9123                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x45 },
9124                         { 0x20, AC_VERB_SET_PROC_COEF, 0x5089 },
9125                         { }
9126                 },
9127         },
9128         [ALC274_FIXUP_HP_HEADSET_MIC] = {
9129                 .type = HDA_FIXUP_FUNC,
9130                 .v.func = alc274_fixup_hp_headset_mic,
9131                 .chained = true,
9132                 .chain_id = ALC274_FIXUP_HP_MIC
9133         },
9134         [ALC274_FIXUP_HP_ENVY_GPIO] = {
9135                 .type = HDA_FIXUP_FUNC,
9136                 .v.func = alc274_fixup_hp_envy_gpio,
9137         },
9138         [ALC256_FIXUP_ASUS_HPE] = {
9139                 .type = HDA_FIXUP_VERBS,
9140                 .v.verbs = (const struct hda_verb[]) {
9141                         /* Set EAPD high */
9142                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x0f },
9143                         { 0x20, AC_VERB_SET_PROC_COEF, 0x7778 },
9144                         { }
9145                 },
9146                 .chained = true,
9147                 .chain_id = ALC294_FIXUP_ASUS_HEADSET_MIC
9148         },
9149         [ALC285_FIXUP_THINKPAD_NO_BASS_SPK_HEADSET_JACK] = {
9150                 .type = HDA_FIXUP_FUNC,
9151                 .v.func = alc_fixup_headset_jack,
9152                 .chained = true,
9153                 .chain_id = ALC269_FIXUP_THINKPAD_ACPI
9154         },
9155         [ALC287_FIXUP_HP_GPIO_LED] = {
9156                 .type = HDA_FIXUP_FUNC,
9157                 .v.func = alc287_fixup_hp_gpio_led,
9158         },
9159         [ALC256_FIXUP_HP_HEADSET_MIC] = {
9160                 .type = HDA_FIXUP_FUNC,
9161                 .v.func = alc274_fixup_hp_headset_mic,
9162         },
9163         [ALC236_FIXUP_DELL_AIO_HEADSET_MIC] = {
9164                 .type = HDA_FIXUP_FUNC,
9165                 .v.func = alc_fixup_no_int_mic,
9166                 .chained = true,
9167                 .chain_id = ALC255_FIXUP_DELL1_MIC_NO_PRESENCE
9168         },
9169         [ALC282_FIXUP_ACER_DISABLE_LINEOUT] = {
9170                 .type = HDA_FIXUP_PINS,
9171                 .v.pins = (const struct hda_pintbl[]) {
9172                         { 0x1b, 0x411111f0 },
9173                         { 0x18, 0x01a1913c }, /* use as headset mic, without its own jack detect */
9174                         { },
9175                 },
9176                 .chained = true,
9177                 .chain_id = ALC269_FIXUP_HEADSET_MODE
9178         },
9179         [ALC255_FIXUP_ACER_LIMIT_INT_MIC_BOOST] = {
9180                 .type = HDA_FIXUP_FUNC,
9181                 .v.func = alc269_fixup_limit_int_mic_boost,
9182                 .chained = true,
9183                 .chain_id = ALC255_FIXUP_ACER_MIC_NO_PRESENCE,
9184         },
9185         [ALC256_FIXUP_ACER_HEADSET_MIC] = {
9186                 .type = HDA_FIXUP_PINS,
9187                 .v.pins = (const struct hda_pintbl[]) {
9188                         { 0x19, 0x02a1113c }, /* use as headset mic, without its own jack detect */
9189                         { 0x1a, 0x90a1092f }, /* use as internal mic */
9190                         { }
9191                 },
9192                 .chained = true,
9193                 .chain_id = ALC269_FIXUP_HEADSET_MODE_NO_HP_MIC
9194         },
9195         [ALC285_FIXUP_IDEAPAD_S740_COEF] = {
9196                 .type = HDA_FIXUP_FUNC,
9197                 .v.func = alc285_fixup_ideapad_s740_coef,
9198                 .chained = true,
9199                 .chain_id = ALC269_FIXUP_THINKPAD_ACPI,
9200         },
9201         [ALC285_FIXUP_HP_LIMIT_INT_MIC_BOOST] = {
9202                 .type = HDA_FIXUP_FUNC,
9203                 .v.func = alc269_fixup_limit_int_mic_boost,
9204                 .chained = true,
9205                 .chain_id = ALC285_FIXUP_HP_MUTE_LED,
9206         },
9207         [ALC295_FIXUP_ASUS_DACS] = {
9208                 .type = HDA_FIXUP_FUNC,
9209                 .v.func = alc295_fixup_asus_dacs,
9210         },
9211         [ALC295_FIXUP_HP_OMEN] = {
9212                 .type = HDA_FIXUP_PINS,
9213                 .v.pins = (const struct hda_pintbl[]) {
9214                         { 0x12, 0xb7a60130 },
9215                         { 0x13, 0x40000000 },
9216                         { 0x14, 0x411111f0 },
9217                         { 0x16, 0x411111f0 },
9218                         { 0x17, 0x90170110 },
9219                         { 0x18, 0x411111f0 },
9220                         { 0x19, 0x02a11030 },
9221                         { 0x1a, 0x411111f0 },
9222                         { 0x1b, 0x04a19030 },
9223                         { 0x1d, 0x40600001 },
9224                         { 0x1e, 0x411111f0 },
9225                         { 0x21, 0x03211020 },
9226                         {}
9227                 },
9228                 .chained = true,
9229                 .chain_id = ALC269_FIXUP_HP_LINE1_MIC1_LED,
9230         },
9231         [ALC285_FIXUP_HP_SPECTRE_X360] = {
9232                 .type = HDA_FIXUP_FUNC,
9233                 .v.func = alc285_fixup_hp_spectre_x360,
9234         },
9235         [ALC285_FIXUP_HP_SPECTRE_X360_EB1] = {
9236                 .type = HDA_FIXUP_FUNC,
9237                 .v.func = alc285_fixup_hp_spectre_x360_eb1
9238         },
9239         [ALC287_FIXUP_IDEAPAD_BASS_SPK_AMP] = {
9240                 .type = HDA_FIXUP_FUNC,
9241                 .v.func = alc285_fixup_ideapad_s740_coef,
9242                 .chained = true,
9243                 .chain_id = ALC285_FIXUP_THINKPAD_HEADSET_JACK,
9244         },
9245         [ALC623_FIXUP_LENOVO_THINKSTATION_P340] = {
9246                 .type = HDA_FIXUP_FUNC,
9247                 .v.func = alc_fixup_no_shutup,
9248                 .chained = true,
9249                 .chain_id = ALC283_FIXUP_HEADSET_MIC,
9250         },
9251         [ALC255_FIXUP_ACER_HEADPHONE_AND_MIC] = {
9252                 .type = HDA_FIXUP_PINS,
9253                 .v.pins = (const struct hda_pintbl[]) {
9254                         { 0x21, 0x03211030 }, /* Change the Headphone location to Left */
9255                         { }
9256                 },
9257                 .chained = true,
9258                 .chain_id = ALC255_FIXUP_XIAOMI_HEADSET_MIC
9259         },
9260         [ALC236_FIXUP_HP_LIMIT_INT_MIC_BOOST] = {
9261                 .type = HDA_FIXUP_FUNC,
9262                 .v.func = alc269_fixup_limit_int_mic_boost,
9263                 .chained = true,
9264                 .chain_id = ALC236_FIXUP_HP_MUTE_LED_MICMUTE_VREF,
9265         },
9266         [ALC285_FIXUP_LEGION_Y9000X_SPEAKERS] = {
9267                 .type = HDA_FIXUP_FUNC,
9268                 .v.func = alc285_fixup_ideapad_s740_coef,
9269                 .chained = true,
9270                 .chain_id = ALC285_FIXUP_LEGION_Y9000X_AUTOMUTE,
9271         },
9272         [ALC285_FIXUP_LEGION_Y9000X_AUTOMUTE] = {
9273                 .type = HDA_FIXUP_FUNC,
9274                 .v.func = alc287_fixup_legion_15imhg05_speakers,
9275                 .chained = true,
9276                 .chain_id = ALC269_FIXUP_THINKPAD_ACPI,
9277         },
9278         [ALC287_FIXUP_LEGION_15IMHG05_SPEAKERS] = {
9279                 .type = HDA_FIXUP_VERBS,
9280                 //.v.verbs = legion_15imhg05_coefs,
9281                 .v.verbs = (const struct hda_verb[]) {
9282                          // set left speaker Legion 7i.
9283                          { 0x20, AC_VERB_SET_COEF_INDEX, 0x24 },
9284                          { 0x20, AC_VERB_SET_PROC_COEF, 0x41 },
9285
9286                          { 0x20, AC_VERB_SET_COEF_INDEX, 0x26 },
9287                          { 0x20, AC_VERB_SET_PROC_COEF, 0xc },
9288                          { 0x20, AC_VERB_SET_PROC_COEF, 0x0 },
9289                          { 0x20, AC_VERB_SET_PROC_COEF, 0x1a },
9290                          { 0x20, AC_VERB_SET_PROC_COEF, 0xb020 },
9291
9292                          { 0x20, AC_VERB_SET_COEF_INDEX, 0x26 },
9293                          { 0x20, AC_VERB_SET_PROC_COEF, 0x2 },
9294                          { 0x20, AC_VERB_SET_PROC_COEF, 0x0 },
9295                          { 0x20, AC_VERB_SET_PROC_COEF, 0x0 },
9296                          { 0x20, AC_VERB_SET_PROC_COEF, 0xb020 },
9297
9298                          // set right speaker Legion 7i.
9299                          { 0x20, AC_VERB_SET_COEF_INDEX, 0x24 },
9300                          { 0x20, AC_VERB_SET_PROC_COEF, 0x42 },
9301
9302                          { 0x20, AC_VERB_SET_COEF_INDEX, 0x26 },
9303                          { 0x20, AC_VERB_SET_PROC_COEF, 0xc },
9304                          { 0x20, AC_VERB_SET_PROC_COEF, 0x0 },
9305                          { 0x20, AC_VERB_SET_PROC_COEF, 0x2a },
9306                          { 0x20, AC_VERB_SET_PROC_COEF, 0xb020 },
9307
9308                          { 0x20, AC_VERB_SET_COEF_INDEX, 0x26 },
9309                          { 0x20, AC_VERB_SET_PROC_COEF, 0x2 },
9310                          { 0x20, AC_VERB_SET_PROC_COEF, 0x0 },
9311                          { 0x20, AC_VERB_SET_PROC_COEF, 0x0 },
9312                          { 0x20, AC_VERB_SET_PROC_COEF, 0xb020 },
9313                          {}
9314                 },
9315                 .chained = true,
9316                 .chain_id = ALC287_FIXUP_LEGION_15IMHG05_AUTOMUTE,
9317         },
9318         [ALC287_FIXUP_LEGION_15IMHG05_AUTOMUTE] = {
9319                 .type = HDA_FIXUP_FUNC,
9320                 .v.func = alc287_fixup_legion_15imhg05_speakers,
9321                 .chained = true,
9322                 .chain_id = ALC269_FIXUP_HEADSET_MODE,
9323         },
9324         [ALC287_FIXUP_YOGA7_14ITL_SPEAKERS] = {
9325                 .type = HDA_FIXUP_VERBS,
9326                 .v.verbs = (const struct hda_verb[]) {
9327                          // set left speaker Yoga 7i.
9328                          { 0x20, AC_VERB_SET_COEF_INDEX, 0x24 },
9329                          { 0x20, AC_VERB_SET_PROC_COEF, 0x41 },
9330
9331                          { 0x20, AC_VERB_SET_COEF_INDEX, 0x26 },
9332                          { 0x20, AC_VERB_SET_PROC_COEF, 0xc },
9333                          { 0x20, AC_VERB_SET_PROC_COEF, 0x0 },
9334                          { 0x20, AC_VERB_SET_PROC_COEF, 0x1a },
9335                          { 0x20, AC_VERB_SET_PROC_COEF, 0xb020 },
9336
9337                          { 0x20, AC_VERB_SET_COEF_INDEX, 0x26 },
9338                          { 0x20, AC_VERB_SET_PROC_COEF, 0x2 },
9339                          { 0x20, AC_VERB_SET_PROC_COEF, 0x0 },
9340                          { 0x20, AC_VERB_SET_PROC_COEF, 0x0 },
9341                          { 0x20, AC_VERB_SET_PROC_COEF, 0xb020 },
9342
9343                          // set right speaker Yoga 7i.
9344                          { 0x20, AC_VERB_SET_COEF_INDEX, 0x24 },
9345                          { 0x20, AC_VERB_SET_PROC_COEF, 0x46 },
9346
9347                          { 0x20, AC_VERB_SET_COEF_INDEX, 0x26 },
9348                          { 0x20, AC_VERB_SET_PROC_COEF, 0xc },
9349                          { 0x20, AC_VERB_SET_PROC_COEF, 0x0 },
9350                          { 0x20, AC_VERB_SET_PROC_COEF, 0x2a },
9351                          { 0x20, AC_VERB_SET_PROC_COEF, 0xb020 },
9352
9353                          { 0x20, AC_VERB_SET_COEF_INDEX, 0x26 },
9354                          { 0x20, AC_VERB_SET_PROC_COEF, 0x2 },
9355                          { 0x20, AC_VERB_SET_PROC_COEF, 0x0 },
9356                          { 0x20, AC_VERB_SET_PROC_COEF, 0x0 },
9357                          { 0x20, AC_VERB_SET_PROC_COEF, 0xb020 },
9358                          {}
9359                 },
9360                 .chained = true,
9361                 .chain_id = ALC269_FIXUP_HEADSET_MODE,
9362         },
9363         [ALC298_FIXUP_LENOVO_C940_DUET7] = {
9364                 .type = HDA_FIXUP_FUNC,
9365                 .v.func = alc298_fixup_lenovo_c940_duet7,
9366         },
9367         [ALC287_FIXUP_13S_GEN2_SPEAKERS] = {
9368                 .type = HDA_FIXUP_VERBS,
9369                 .v.verbs = (const struct hda_verb[]) {
9370                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x24 },
9371                         { 0x20, AC_VERB_SET_PROC_COEF, 0x41 },
9372                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x26 },
9373                         { 0x20, AC_VERB_SET_PROC_COEF, 0x2 },
9374                         { 0x20, AC_VERB_SET_PROC_COEF, 0x0 },
9375                         { 0x20, AC_VERB_SET_PROC_COEF, 0x0 },
9376                         { 0x20, AC_VERB_SET_PROC_COEF, 0xb020 },
9377                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x24 },
9378                         { 0x20, AC_VERB_SET_PROC_COEF, 0x42 },
9379                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x26 },
9380                         { 0x20, AC_VERB_SET_PROC_COEF, 0x2 },
9381                         { 0x20, AC_VERB_SET_PROC_COEF, 0x0 },
9382                         { 0x20, AC_VERB_SET_PROC_COEF, 0x0 },
9383                         { 0x20, AC_VERB_SET_PROC_COEF, 0xb020 },
9384                         {}
9385                 },
9386                 .chained = true,
9387                 .chain_id = ALC269_FIXUP_HEADSET_MODE,
9388         },
9389         [ALC256_FIXUP_SET_COEF_DEFAULTS] = {
9390                 .type = HDA_FIXUP_FUNC,
9391                 .v.func = alc256_fixup_set_coef_defaults,
9392         },
9393         [ALC245_FIXUP_HP_GPIO_LED] = {
9394                 .type = HDA_FIXUP_FUNC,
9395                 .v.func = alc245_fixup_hp_gpio_led,
9396         },
9397         [ALC256_FIXUP_SYSTEM76_MIC_NO_PRESENCE] = {
9398                 .type = HDA_FIXUP_PINS,
9399                 .v.pins = (const struct hda_pintbl[]) {
9400                         { 0x19, 0x03a11120 }, /* use as headset mic, without its own jack detect */
9401                         { }
9402                 },
9403                 .chained = true,
9404                 .chain_id = ALC269_FIXUP_HEADSET_MODE_NO_HP_MIC,
9405         },
9406         [ALC233_FIXUP_NO_AUDIO_JACK] = {
9407                 .type = HDA_FIXUP_FUNC,
9408                 .v.func = alc233_fixup_no_audio_jack,
9409         },
9410         [ALC256_FIXUP_MIC_NO_PRESENCE_AND_RESUME] = {
9411                 .type = HDA_FIXUP_FUNC,
9412                 .v.func = alc256_fixup_mic_no_presence_and_resume,
9413                 .chained = true,
9414                 .chain_id = ALC269_FIXUP_HEADSET_MODE_NO_HP_MIC
9415         },
9416         [ALC287_FIXUP_LEGION_16ACHG6] = {
9417                 .type = HDA_FIXUP_FUNC,
9418                 .v.func = alc287_fixup_legion_16achg6_speakers,
9419         },
9420         [ALC287_FIXUP_CS35L41_I2C_2] = {
9421                 .type = HDA_FIXUP_FUNC,
9422                 .v.func = cs35l41_fixup_i2c_two,
9423         },
9424         [ALC287_FIXUP_CS35L41_I2C_2_HP_GPIO_LED] = {
9425                 .type = HDA_FIXUP_FUNC,
9426                 .v.func = cs35l41_fixup_i2c_two,
9427                 .chained = true,
9428                 .chain_id = ALC285_FIXUP_HP_MUTE_LED,
9429         },
9430         [ALC245_FIXUP_CS35L41_SPI_2] = {
9431                 .type = HDA_FIXUP_FUNC,
9432                 .v.func = cs35l41_fixup_spi_two,
9433         },
9434         [ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED] = {
9435                 .type = HDA_FIXUP_FUNC,
9436                 .v.func = cs35l41_fixup_spi_two,
9437                 .chained = true,
9438                 .chain_id = ALC285_FIXUP_HP_GPIO_LED,
9439         },
9440         [ALC245_FIXUP_CS35L41_SPI_4] = {
9441                 .type = HDA_FIXUP_FUNC,
9442                 .v.func = cs35l41_fixup_spi_four,
9443         },
9444         [ALC245_FIXUP_CS35L41_SPI_4_HP_GPIO_LED] = {
9445                 .type = HDA_FIXUP_FUNC,
9446                 .v.func = cs35l41_fixup_spi_four,
9447                 .chained = true,
9448                 .chain_id = ALC285_FIXUP_HP_GPIO_LED,
9449         },
9450         [ALC285_FIXUP_HP_SPEAKERS_MICMUTE_LED] = {
9451                 .type = HDA_FIXUP_VERBS,
9452                 .v.verbs = (const struct hda_verb[]) {
9453                          { 0x20, AC_VERB_SET_COEF_INDEX, 0x19 },
9454                          { 0x20, AC_VERB_SET_PROC_COEF, 0x8e11 },
9455                          { }
9456                 },
9457                 .chained = true,
9458                 .chain_id = ALC285_FIXUP_HP_MUTE_LED,
9459         },
9460         [ALC269_FIXUP_DELL4_MIC_NO_PRESENCE_QUIET] = {
9461                 .type = HDA_FIXUP_FUNC,
9462                 .v.func = alc_fixup_dell4_mic_no_presence_quiet,
9463                 .chained = true,
9464                 .chain_id = ALC269_FIXUP_DELL4_MIC_NO_PRESENCE,
9465         },
9466         [ALC295_FIXUP_FRAMEWORK_LAPTOP_MIC_NO_PRESENCE] = {
9467                 .type = HDA_FIXUP_PINS,
9468                 .v.pins = (const struct hda_pintbl[]) {
9469                         { 0x19, 0x02a1112c }, /* use as headset mic, without its own jack detect */
9470                         { }
9471                 },
9472                 .chained = true,
9473                 .chain_id = ALC269_FIXUP_HEADSET_MODE_NO_HP_MIC
9474         },
9475         [ALC287_FIXUP_LEGION_16ITHG6] = {
9476                 .type = HDA_FIXUP_FUNC,
9477                 .v.func = alc287_fixup_legion_16ithg6_speakers,
9478         },
9479         [ALC287_FIXUP_YOGA9_14IAP7_BASS_SPK] = {
9480                 .type = HDA_FIXUP_VERBS,
9481                 .v.verbs = (const struct hda_verb[]) {
9482                         // enable left speaker
9483                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x24 },
9484                         { 0x20, AC_VERB_SET_PROC_COEF, 0x41 },
9485
9486                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x26 },
9487                         { 0x20, AC_VERB_SET_PROC_COEF, 0xc },
9488                         { 0x20, AC_VERB_SET_PROC_COEF, 0x0 },
9489                         { 0x20, AC_VERB_SET_PROC_COEF, 0x1a },
9490                         { 0x20, AC_VERB_SET_PROC_COEF, 0xb020 },
9491
9492                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x26 },
9493                         { 0x20, AC_VERB_SET_PROC_COEF, 0xf },
9494                         { 0x20, AC_VERB_SET_PROC_COEF, 0x0 },
9495                         { 0x20, AC_VERB_SET_PROC_COEF, 0x42 },
9496                         { 0x20, AC_VERB_SET_PROC_COEF, 0xb020 },
9497
9498                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x26 },
9499                         { 0x20, AC_VERB_SET_PROC_COEF, 0x10 },
9500                         { 0x20, AC_VERB_SET_PROC_COEF, 0x0 },
9501                         { 0x20, AC_VERB_SET_PROC_COEF, 0x40 },
9502                         { 0x20, AC_VERB_SET_PROC_COEF, 0xb020 },
9503
9504                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x26 },
9505                         { 0x20, AC_VERB_SET_PROC_COEF, 0x2 },
9506                         { 0x20, AC_VERB_SET_PROC_COEF, 0x0 },
9507                         { 0x20, AC_VERB_SET_PROC_COEF, 0x0 },
9508                         { 0x20, AC_VERB_SET_PROC_COEF, 0xb020 },
9509
9510                         // enable right speaker
9511                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x24 },
9512                         { 0x20, AC_VERB_SET_PROC_COEF, 0x46 },
9513
9514                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x26 },
9515                         { 0x20, AC_VERB_SET_PROC_COEF, 0xc },
9516                         { 0x20, AC_VERB_SET_PROC_COEF, 0x0 },
9517                         { 0x20, AC_VERB_SET_PROC_COEF, 0x2a },
9518                         { 0x20, AC_VERB_SET_PROC_COEF, 0xb020 },
9519
9520                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x26 },
9521                         { 0x20, AC_VERB_SET_PROC_COEF, 0xf },
9522                         { 0x20, AC_VERB_SET_PROC_COEF, 0x0 },
9523                         { 0x20, AC_VERB_SET_PROC_COEF, 0x46 },
9524                         { 0x20, AC_VERB_SET_PROC_COEF, 0xb020 },
9525
9526                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x26 },
9527                         { 0x20, AC_VERB_SET_PROC_COEF, 0x10 },
9528                         { 0x20, AC_VERB_SET_PROC_COEF, 0x0 },
9529                         { 0x20, AC_VERB_SET_PROC_COEF, 0x44 },
9530                         { 0x20, AC_VERB_SET_PROC_COEF, 0xb020 },
9531
9532                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x26 },
9533                         { 0x20, AC_VERB_SET_PROC_COEF, 0x2 },
9534                         { 0x20, AC_VERB_SET_PROC_COEF, 0x0 },
9535                         { 0x20, AC_VERB_SET_PROC_COEF, 0x0 },
9536                         { 0x20, AC_VERB_SET_PROC_COEF, 0xb020 },
9537
9538                         { },
9539                 },
9540         },
9541         [ALC287_FIXUP_YOGA9_14IAP7_BASS_SPK_PIN] = {
9542                 .type = HDA_FIXUP_FUNC,
9543                 .v.func = alc287_fixup_yoga9_14iap7_bass_spk_pin,
9544                 .chained = true,
9545                 .chain_id = ALC287_FIXUP_YOGA9_14IAP7_BASS_SPK,
9546         },
9547         [ALC295_FIXUP_DELL_INSPIRON_TOP_SPEAKERS] = {
9548                 .type = HDA_FIXUP_FUNC,
9549                 .v.func = alc295_fixup_dell_inspiron_top_speakers,
9550                 .chained = true,
9551                 .chain_id = ALC269_FIXUP_DELL4_MIC_NO_PRESENCE,
9552         },
9553         [ALC236_FIXUP_DELL_DUAL_CODECS] = {
9554                 .type = HDA_FIXUP_PINS,
9555                 .v.func = alc1220_fixup_gb_dual_codecs,
9556                 .chained = true,
9557                 .chain_id = ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
9558         },
9559         [ALC287_FIXUP_CS35L41_I2C_2_THINKPAD_ACPI] = {
9560                 .type = HDA_FIXUP_FUNC,
9561                 .v.func = cs35l41_fixup_i2c_two,
9562                 .chained = true,
9563                 .chain_id = ALC269_FIXUP_THINKPAD_ACPI,
9564         },
9565         [ALC287_FIXUP_TAS2781_I2C] = {
9566                 .type = HDA_FIXUP_FUNC,
9567                 .v.func = tas2781_fixup_i2c,
9568                 .chained = true,
9569                 .chain_id = ALC269_FIXUP_THINKPAD_ACPI,
9570         },
9571         [ALC245_FIXUP_HP_MUTE_LED_COEFBIT] = {
9572                 .type = HDA_FIXUP_FUNC,
9573                 .v.func = alc245_fixup_hp_mute_led_coefbit,
9574         },
9575         [ALC245_FIXUP_HP_X360_MUTE_LEDS] = {
9576                 .type = HDA_FIXUP_FUNC,
9577                 .v.func = alc245_fixup_hp_mute_led_coefbit,
9578                 .chained = true,
9579                 .chain_id = ALC245_FIXUP_HP_GPIO_LED
9580         },
9581         [ALC287_FIXUP_THINKPAD_I2S_SPK] = {
9582                 .type = HDA_FIXUP_FUNC,
9583                 .v.func = alc287_fixup_bind_dacs,
9584         },
9585         [ALC287_FIXUP_MG_RTKC_CSAMP_CS35L41_I2C_THINKPAD] = {
9586                 .type = HDA_FIXUP_FUNC,
9587                 .v.func = alc287_fixup_bind_dacs,
9588                 .chained = true,
9589                 .chain_id = ALC287_FIXUP_CS35L41_I2C_2_THINKPAD_ACPI,
9590         },
9591         [ALC2XX_FIXUP_HEADSET_MIC] = {
9592                 .type = HDA_FIXUP_FUNC,
9593                 .v.func = alc_fixup_headset_mic,
9594         },
9595         [ALC289_FIXUP_DELL_CS35L41_SPI_2] = {
9596                 .type = HDA_FIXUP_FUNC,
9597                 .v.func = cs35l41_fixup_spi_two,
9598                 .chained = true,
9599                 .chain_id = ALC289_FIXUP_DUAL_SPK
9600         },
9601         [ALC294_FIXUP_CS35L41_I2C_2] = {
9602                 .type = HDA_FIXUP_FUNC,
9603                 .v.func = cs35l41_fixup_i2c_two,
9604         },
9605 };
9606
9607 static const struct snd_pci_quirk alc269_fixup_tbl[] = {
9608         SND_PCI_QUIRK(0x1025, 0x0283, "Acer TravelMate 8371", ALC269_FIXUP_INV_DMIC),
9609         SND_PCI_QUIRK(0x1025, 0x029b, "Acer 1810TZ", ALC269_FIXUP_INV_DMIC),
9610         SND_PCI_QUIRK(0x1025, 0x0349, "Acer AOD260", ALC269_FIXUP_INV_DMIC),
9611         SND_PCI_QUIRK(0x1025, 0x047c, "Acer AC700", ALC269_FIXUP_ACER_AC700),
9612         SND_PCI_QUIRK(0x1025, 0x072d, "Acer Aspire V5-571G", ALC269_FIXUP_ASPIRE_HEADSET_MIC),
9613         SND_PCI_QUIRK(0x1025, 0x0740, "Acer AO725", ALC271_FIXUP_HP_GATE_MIC_JACK),
9614         SND_PCI_QUIRK(0x1025, 0x0742, "Acer AO756", ALC271_FIXUP_HP_GATE_MIC_JACK),
9615         SND_PCI_QUIRK(0x1025, 0x0762, "Acer Aspire E1-472", ALC271_FIXUP_HP_GATE_MIC_JACK_E1_572),
9616         SND_PCI_QUIRK(0x1025, 0x0775, "Acer Aspire E1-572", ALC271_FIXUP_HP_GATE_MIC_JACK_E1_572),
9617         SND_PCI_QUIRK(0x1025, 0x079b, "Acer Aspire V5-573G", ALC282_FIXUP_ASPIRE_V5_PINS),
9618         SND_PCI_QUIRK(0x1025, 0x080d, "Acer Aspire V5-122P", ALC269_FIXUP_ASPIRE_HEADSET_MIC),
9619         SND_PCI_QUIRK(0x1025, 0x0840, "Acer Aspire E1", ALC269VB_FIXUP_ASPIRE_E1_COEF),
9620         SND_PCI_QUIRK(0x1025, 0x101c, "Acer Veriton N2510G", ALC269_FIXUP_LIFEBOOK),
9621         SND_PCI_QUIRK(0x1025, 0x102b, "Acer Aspire C24-860", ALC286_FIXUP_ACER_AIO_MIC_NO_PRESENCE),
9622         SND_PCI_QUIRK(0x1025, 0x1065, "Acer Aspire C20-820", ALC269VC_FIXUP_ACER_HEADSET_MIC),
9623         SND_PCI_QUIRK(0x1025, 0x106d, "Acer Cloudbook 14", ALC283_FIXUP_CHROME_BOOK),
9624         SND_PCI_QUIRK(0x1025, 0x1094, "Acer Aspire E5-575T", ALC255_FIXUP_ACER_LIMIT_INT_MIC_BOOST),
9625         SND_PCI_QUIRK(0x1025, 0x1099, "Acer Aspire E5-523G", ALC255_FIXUP_ACER_MIC_NO_PRESENCE),
9626         SND_PCI_QUIRK(0x1025, 0x110e, "Acer Aspire ES1-432", ALC255_FIXUP_ACER_MIC_NO_PRESENCE),
9627         SND_PCI_QUIRK(0x1025, 0x1166, "Acer Veriton N4640G", ALC269_FIXUP_LIFEBOOK),
9628         SND_PCI_QUIRK(0x1025, 0x1167, "Acer Veriton N6640G", ALC269_FIXUP_LIFEBOOK),
9629         SND_PCI_QUIRK(0x1025, 0x1246, "Acer Predator Helios 500", ALC299_FIXUP_PREDATOR_SPK),
9630         SND_PCI_QUIRK(0x1025, 0x1247, "Acer vCopperbox", ALC269VC_FIXUP_ACER_VCOPPERBOX_PINS),
9631         SND_PCI_QUIRK(0x1025, 0x1248, "Acer Veriton N4660G", ALC269VC_FIXUP_ACER_MIC_NO_PRESENCE),
9632         SND_PCI_QUIRK(0x1025, 0x1269, "Acer SWIFT SF314-54", ALC256_FIXUP_ACER_HEADSET_MIC),
9633         SND_PCI_QUIRK(0x1025, 0x128f, "Acer Veriton Z6860G", ALC286_FIXUP_ACER_AIO_HEADSET_MIC),
9634         SND_PCI_QUIRK(0x1025, 0x1290, "Acer Veriton Z4860G", ALC286_FIXUP_ACER_AIO_HEADSET_MIC),
9635         SND_PCI_QUIRK(0x1025, 0x1291, "Acer Veriton Z4660G", ALC286_FIXUP_ACER_AIO_HEADSET_MIC),
9636         SND_PCI_QUIRK(0x1025, 0x129c, "Acer SWIFT SF314-55", ALC256_FIXUP_ACER_HEADSET_MIC),
9637         SND_PCI_QUIRK(0x1025, 0x129d, "Acer SWIFT SF313-51", ALC256_FIXUP_ACER_MIC_NO_PRESENCE),
9638         SND_PCI_QUIRK(0x1025, 0x1300, "Acer SWIFT SF314-56", ALC256_FIXUP_ACER_MIC_NO_PRESENCE),
9639         SND_PCI_QUIRK(0x1025, 0x1308, "Acer Aspire Z24-890", ALC286_FIXUP_ACER_AIO_HEADSET_MIC),
9640         SND_PCI_QUIRK(0x1025, 0x132a, "Acer TravelMate B114-21", ALC233_FIXUP_ACER_HEADSET_MIC),
9641         SND_PCI_QUIRK(0x1025, 0x1330, "Acer TravelMate X514-51T", ALC255_FIXUP_ACER_HEADSET_MIC),
9642         SND_PCI_QUIRK(0x1025, 0x141f, "Acer Spin SP513-54N", ALC255_FIXUP_ACER_MIC_NO_PRESENCE),
9643         SND_PCI_QUIRK(0x1025, 0x142b, "Acer Swift SF314-42", ALC255_FIXUP_ACER_MIC_NO_PRESENCE),
9644         SND_PCI_QUIRK(0x1025, 0x1430, "Acer TravelMate B311R-31", ALC256_FIXUP_ACER_MIC_NO_PRESENCE),
9645         SND_PCI_QUIRK(0x1025, 0x1466, "Acer Aspire A515-56", ALC255_FIXUP_ACER_HEADPHONE_AND_MIC),
9646         SND_PCI_QUIRK(0x1025, 0x1534, "Acer Predator PH315-54", ALC255_FIXUP_ACER_MIC_NO_PRESENCE),
9647         SND_PCI_QUIRK(0x1028, 0x0470, "Dell M101z", ALC269_FIXUP_DELL_M101Z),
9648         SND_PCI_QUIRK(0x1028, 0x053c, "Dell Latitude E5430", ALC292_FIXUP_DELL_E7X),
9649         SND_PCI_QUIRK(0x1028, 0x054b, "Dell XPS one 2710", ALC275_FIXUP_DELL_XPS),
9650         SND_PCI_QUIRK(0x1028, 0x05bd, "Dell Latitude E6440", ALC292_FIXUP_DELL_E7X),
9651         SND_PCI_QUIRK(0x1028, 0x05be, "Dell Latitude E6540", ALC292_FIXUP_DELL_E7X),
9652         SND_PCI_QUIRK(0x1028, 0x05ca, "Dell Latitude E7240", ALC292_FIXUP_DELL_E7X),
9653         SND_PCI_QUIRK(0x1028, 0x05cb, "Dell Latitude E7440", ALC292_FIXUP_DELL_E7X),
9654         SND_PCI_QUIRK(0x1028, 0x05da, "Dell Vostro 5460", ALC290_FIXUP_SUBWOOFER),
9655         SND_PCI_QUIRK(0x1028, 0x05f4, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE),
9656         SND_PCI_QUIRK(0x1028, 0x05f5, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE),
9657         SND_PCI_QUIRK(0x1028, 0x05f6, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE),
9658         SND_PCI_QUIRK(0x1028, 0x0615, "Dell Vostro 5470", ALC290_FIXUP_SUBWOOFER_HSJACK),
9659         SND_PCI_QUIRK(0x1028, 0x0616, "Dell Vostro 5470", ALC290_FIXUP_SUBWOOFER_HSJACK),
9660         SND_PCI_QUIRK(0x1028, 0x062c, "Dell Latitude E5550", ALC292_FIXUP_DELL_E7X),
9661         SND_PCI_QUIRK(0x1028, 0x062e, "Dell Latitude E7450", ALC292_FIXUP_DELL_E7X),
9662         SND_PCI_QUIRK(0x1028, 0x0638, "Dell Inspiron 5439", ALC290_FIXUP_MONO_SPEAKERS_HSJACK),
9663         SND_PCI_QUIRK(0x1028, 0x064a, "Dell", ALC293_FIXUP_DELL1_MIC_NO_PRESENCE),
9664         SND_PCI_QUIRK(0x1028, 0x064b, "Dell", ALC293_FIXUP_DELL1_MIC_NO_PRESENCE),
9665         SND_PCI_QUIRK(0x1028, 0x0665, "Dell XPS 13", ALC288_FIXUP_DELL_XPS_13),
9666         SND_PCI_QUIRK(0x1028, 0x0669, "Dell Optiplex 9020m", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE),
9667         SND_PCI_QUIRK(0x1028, 0x069a, "Dell Vostro 5480", ALC290_FIXUP_SUBWOOFER_HSJACK),
9668         SND_PCI_QUIRK(0x1028, 0x06c7, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE),
9669         SND_PCI_QUIRK(0x1028, 0x06d9, "Dell", ALC293_FIXUP_DELL1_MIC_NO_PRESENCE),
9670         SND_PCI_QUIRK(0x1028, 0x06da, "Dell", ALC293_FIXUP_DELL1_MIC_NO_PRESENCE),
9671         SND_PCI_QUIRK(0x1028, 0x06db, "Dell", ALC293_FIXUP_DISABLE_AAMIX_MULTIJACK),
9672         SND_PCI_QUIRK(0x1028, 0x06dd, "Dell", ALC293_FIXUP_DISABLE_AAMIX_MULTIJACK),
9673         SND_PCI_QUIRK(0x1028, 0x06de, "Dell", ALC293_FIXUP_DISABLE_AAMIX_MULTIJACK),
9674         SND_PCI_QUIRK(0x1028, 0x06df, "Dell", ALC293_FIXUP_DISABLE_AAMIX_MULTIJACK),
9675         SND_PCI_QUIRK(0x1028, 0x06e0, "Dell", ALC293_FIXUP_DISABLE_AAMIX_MULTIJACK),
9676         SND_PCI_QUIRK(0x1028, 0x0706, "Dell Inspiron 7559", ALC256_FIXUP_DELL_INSPIRON_7559_SUBWOOFER),
9677         SND_PCI_QUIRK(0x1028, 0x0725, "Dell Inspiron 3162", ALC255_FIXUP_DELL_SPK_NOISE),
9678         SND_PCI_QUIRK(0x1028, 0x0738, "Dell Precision 5820", ALC269_FIXUP_NO_SHUTUP),
9679         SND_PCI_QUIRK(0x1028, 0x075c, "Dell XPS 27 7760", ALC298_FIXUP_SPK_VOLUME),
9680         SND_PCI_QUIRK(0x1028, 0x075d, "Dell AIO", ALC298_FIXUP_SPK_VOLUME),
9681         SND_PCI_QUIRK(0x1028, 0x0798, "Dell Inspiron 17 7000 Gaming", ALC256_FIXUP_DELL_INSPIRON_7559_SUBWOOFER),
9682         SND_PCI_QUIRK(0x1028, 0x07b0, "Dell Precision 7520", ALC295_FIXUP_DISABLE_DAC3),
9683         SND_PCI_QUIRK(0x1028, 0x080c, "Dell WYSE", ALC225_FIXUP_DELL_WYSE_MIC_NO_PRESENCE),
9684         SND_PCI_QUIRK(0x1028, 0x084b, "Dell", ALC274_FIXUP_DELL_AIO_LINEOUT_VERB),
9685         SND_PCI_QUIRK(0x1028, 0x084e, "Dell", ALC274_FIXUP_DELL_AIO_LINEOUT_VERB),
9686         SND_PCI_QUIRK(0x1028, 0x0871, "Dell Precision 3630", ALC255_FIXUP_DELL_HEADSET_MIC),
9687         SND_PCI_QUIRK(0x1028, 0x0872, "Dell Precision 3630", ALC255_FIXUP_DELL_HEADSET_MIC),
9688         SND_PCI_QUIRK(0x1028, 0x0873, "Dell Precision 3930", ALC255_FIXUP_DUMMY_LINEOUT_VERB),
9689         SND_PCI_QUIRK(0x1028, 0x08ad, "Dell WYSE AIO", ALC225_FIXUP_DELL_WYSE_AIO_MIC_NO_PRESENCE),
9690         SND_PCI_QUIRK(0x1028, 0x08ae, "Dell WYSE NB", ALC225_FIXUP_DELL1_MIC_NO_PRESENCE),
9691         SND_PCI_QUIRK(0x1028, 0x0935, "Dell", ALC274_FIXUP_DELL_AIO_LINEOUT_VERB),
9692         SND_PCI_QUIRK(0x1028, 0x097d, "Dell Precision", ALC289_FIXUP_DUAL_SPK),
9693         SND_PCI_QUIRK(0x1028, 0x097e, "Dell Precision", ALC289_FIXUP_DUAL_SPK),
9694         SND_PCI_QUIRK(0x1028, 0x098d, "Dell Precision", ALC233_FIXUP_ASUS_MIC_NO_PRESENCE),
9695         SND_PCI_QUIRK(0x1028, 0x09bf, "Dell Precision", ALC233_FIXUP_ASUS_MIC_NO_PRESENCE),
9696         SND_PCI_QUIRK(0x1028, 0x0a2e, "Dell", ALC236_FIXUP_DELL_AIO_HEADSET_MIC),
9697         SND_PCI_QUIRK(0x1028, 0x0a30, "Dell", ALC236_FIXUP_DELL_AIO_HEADSET_MIC),
9698         SND_PCI_QUIRK(0x1028, 0x0a38, "Dell Latitude 7520", ALC269_FIXUP_DELL4_MIC_NO_PRESENCE_QUIET),
9699         SND_PCI_QUIRK(0x1028, 0x0a58, "Dell", ALC255_FIXUP_DELL_HEADSET_MIC),
9700         SND_PCI_QUIRK(0x1028, 0x0a61, "Dell XPS 15 9510", ALC289_FIXUP_DUAL_SPK),
9701         SND_PCI_QUIRK(0x1028, 0x0a62, "Dell Precision 5560", ALC289_FIXUP_DUAL_SPK),
9702         SND_PCI_QUIRK(0x1028, 0x0a9d, "Dell Latitude 5430", ALC269_FIXUP_DELL4_MIC_NO_PRESENCE),
9703         SND_PCI_QUIRK(0x1028, 0x0a9e, "Dell Latitude 5430", ALC269_FIXUP_DELL4_MIC_NO_PRESENCE),
9704         SND_PCI_QUIRK(0x1028, 0x0b19, "Dell XPS 15 9520", ALC289_FIXUP_DUAL_SPK),
9705         SND_PCI_QUIRK(0x1028, 0x0b1a, "Dell Precision 5570", ALC289_FIXUP_DUAL_SPK),
9706         SND_PCI_QUIRK(0x1028, 0x0b37, "Dell Inspiron 16 Plus 7620 2-in-1", ALC295_FIXUP_DELL_INSPIRON_TOP_SPEAKERS),
9707         SND_PCI_QUIRK(0x1028, 0x0b71, "Dell Inspiron 16 Plus 7620", ALC295_FIXUP_DELL_INSPIRON_TOP_SPEAKERS),
9708         SND_PCI_QUIRK(0x1028, 0x0beb, "Dell XPS 15 9530 (2023)", ALC289_FIXUP_DELL_CS35L41_SPI_2),
9709         SND_PCI_QUIRK(0x1028, 0x0c03, "Dell Precision 5340", ALC269_FIXUP_DELL4_MIC_NO_PRESENCE),
9710         SND_PCI_QUIRK(0x1028, 0x0c19, "Dell Precision 3340", ALC236_FIXUP_DELL_DUAL_CODECS),
9711         SND_PCI_QUIRK(0x1028, 0x0c1a, "Dell Precision 3340", ALC236_FIXUP_DELL_DUAL_CODECS),
9712         SND_PCI_QUIRK(0x1028, 0x0c1b, "Dell Precision 3440", ALC236_FIXUP_DELL_DUAL_CODECS),
9713         SND_PCI_QUIRK(0x1028, 0x0c1c, "Dell Precision 3540", ALC236_FIXUP_DELL_DUAL_CODECS),
9714         SND_PCI_QUIRK(0x1028, 0x0c1d, "Dell Precision 3440", ALC236_FIXUP_DELL_DUAL_CODECS),
9715         SND_PCI_QUIRK(0x1028, 0x0c1e, "Dell Precision 3540", ALC236_FIXUP_DELL_DUAL_CODECS),
9716         SND_PCI_QUIRK(0x1028, 0x0cbd, "Dell Oasis 13 CS MTL-U", ALC289_FIXUP_DELL_CS35L41_SPI_2),
9717         SND_PCI_QUIRK(0x1028, 0x0cbe, "Dell Oasis 13 2-IN-1 MTL-U", ALC289_FIXUP_DELL_CS35L41_SPI_2),
9718         SND_PCI_QUIRK(0x1028, 0x0cbf, "Dell Oasis 13 Low Weight MTU-L", ALC289_FIXUP_DELL_CS35L41_SPI_2),
9719         SND_PCI_QUIRK(0x1028, 0x0cc0, "Dell Oasis 13", ALC289_FIXUP_RTK_AMP_DUAL_SPK),
9720         SND_PCI_QUIRK(0x1028, 0x0cc1, "Dell Oasis 14 MTL-H/U", ALC289_FIXUP_DELL_CS35L41_SPI_2),
9721         SND_PCI_QUIRK(0x1028, 0x0cc2, "Dell Oasis 14 2-in-1 MTL-H/U", ALC289_FIXUP_DELL_CS35L41_SPI_2),
9722         SND_PCI_QUIRK(0x1028, 0x0cc3, "Dell Oasis 14 Low Weight MTL-U", ALC289_FIXUP_DELL_CS35L41_SPI_2),
9723         SND_PCI_QUIRK(0x1028, 0x0cc4, "Dell Oasis 16 MTL-H/U", ALC289_FIXUP_DELL_CS35L41_SPI_2),
9724         SND_PCI_QUIRK(0x1028, 0x0cc5, "Dell Oasis 14", ALC289_FIXUP_RTK_AMP_DUAL_SPK),
9725         SND_PCI_QUIRK(0x1028, 0x164a, "Dell", ALC293_FIXUP_DELL1_MIC_NO_PRESENCE),
9726         SND_PCI_QUIRK(0x1028, 0x164b, "Dell", ALC293_FIXUP_DELL1_MIC_NO_PRESENCE),
9727         SND_PCI_QUIRK(0x103c, 0x1586, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC2),
9728         SND_PCI_QUIRK(0x103c, 0x18e6, "HP", ALC269_FIXUP_HP_GPIO_LED),
9729         SND_PCI_QUIRK(0x103c, 0x218b, "HP", ALC269_FIXUP_LIMIT_INT_MIC_BOOST_MUTE_LED),
9730         SND_PCI_QUIRK(0x103c, 0x21f9, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
9731         SND_PCI_QUIRK(0x103c, 0x2210, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
9732         SND_PCI_QUIRK(0x103c, 0x2214, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
9733         SND_PCI_QUIRK(0x103c, 0x221b, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),
9734         SND_PCI_QUIRK(0x103c, 0x221c, "HP EliteBook 755 G2", ALC280_FIXUP_HP_HEADSET_MIC),
9735         SND_PCI_QUIRK(0x103c, 0x2221, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),
9736         SND_PCI_QUIRK(0x103c, 0x2225, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),
9737         SND_PCI_QUIRK(0x103c, 0x2236, "HP", ALC269_FIXUP_HP_LINE1_MIC1_LED),
9738         SND_PCI_QUIRK(0x103c, 0x2237, "HP", ALC269_FIXUP_HP_LINE1_MIC1_LED),
9739         SND_PCI_QUIRK(0x103c, 0x2238, "HP", ALC269_FIXUP_HP_LINE1_MIC1_LED),
9740         SND_PCI_QUIRK(0x103c, 0x2239, "HP", ALC269_FIXUP_HP_LINE1_MIC1_LED),
9741         SND_PCI_QUIRK(0x103c, 0x224b, "HP", ALC269_FIXUP_HP_LINE1_MIC1_LED),
9742         SND_PCI_QUIRK(0x103c, 0x2253, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),
9743         SND_PCI_QUIRK(0x103c, 0x2254, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),
9744         SND_PCI_QUIRK(0x103c, 0x2255, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),
9745         SND_PCI_QUIRK(0x103c, 0x2256, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),
9746         SND_PCI_QUIRK(0x103c, 0x2257, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),
9747         SND_PCI_QUIRK(0x103c, 0x2259, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),
9748         SND_PCI_QUIRK(0x103c, 0x225a, "HP", ALC269_FIXUP_HP_DOCK_GPIO_MIC1_LED),
9749         SND_PCI_QUIRK(0x103c, 0x225f, "HP", ALC280_FIXUP_HP_GPIO2_MIC_HOTKEY),
9750         SND_PCI_QUIRK(0x103c, 0x2260, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
9751         SND_PCI_QUIRK(0x103c, 0x2263, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
9752         SND_PCI_QUIRK(0x103c, 0x2264, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
9753         SND_PCI_QUIRK(0x103c, 0x2265, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
9754         SND_PCI_QUIRK(0x103c, 0x2268, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
9755         SND_PCI_QUIRK(0x103c, 0x226a, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
9756         SND_PCI_QUIRK(0x103c, 0x226b, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
9757         SND_PCI_QUIRK(0x103c, 0x226e, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
9758         SND_PCI_QUIRK(0x103c, 0x2271, "HP", ALC286_FIXUP_HP_GPIO_LED),
9759         SND_PCI_QUIRK(0x103c, 0x2272, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),
9760         SND_PCI_QUIRK(0x103c, 0x2272, "HP", ALC280_FIXUP_HP_DOCK_PINS),
9761         SND_PCI_QUIRK(0x103c, 0x2273, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),
9762         SND_PCI_QUIRK(0x103c, 0x2273, "HP", ALC280_FIXUP_HP_DOCK_PINS),
9763         SND_PCI_QUIRK(0x103c, 0x2278, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),
9764         SND_PCI_QUIRK(0x103c, 0x227f, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
9765         SND_PCI_QUIRK(0x103c, 0x2282, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
9766         SND_PCI_QUIRK(0x103c, 0x228b, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
9767         SND_PCI_QUIRK(0x103c, 0x228e, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
9768         SND_PCI_QUIRK(0x103c, 0x229e, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
9769         SND_PCI_QUIRK(0x103c, 0x22b2, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
9770         SND_PCI_QUIRK(0x103c, 0x22b7, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
9771         SND_PCI_QUIRK(0x103c, 0x22bf, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
9772         SND_PCI_QUIRK(0x103c, 0x22c4, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
9773         SND_PCI_QUIRK(0x103c, 0x22c5, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
9774         SND_PCI_QUIRK(0x103c, 0x22c7, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
9775         SND_PCI_QUIRK(0x103c, 0x22c8, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
9776         SND_PCI_QUIRK(0x103c, 0x22cf, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
9777         SND_PCI_QUIRK(0x103c, 0x22db, "HP", ALC280_FIXUP_HP_9480M),
9778         SND_PCI_QUIRK(0x103c, 0x22dc, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),
9779         SND_PCI_QUIRK(0x103c, 0x22fb, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),
9780         SND_PCI_QUIRK(0x103c, 0x2334, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
9781         SND_PCI_QUIRK(0x103c, 0x2335, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
9782         SND_PCI_QUIRK(0x103c, 0x2336, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
9783         SND_PCI_QUIRK(0x103c, 0x2337, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
9784         SND_PCI_QUIRK(0x103c, 0x2b5e, "HP 288 Pro G2 MT", ALC221_FIXUP_HP_288PRO_MIC_NO_PRESENCE),
9785         SND_PCI_QUIRK(0x103c, 0x802e, "HP Z240 SFF", ALC221_FIXUP_HP_MIC_NO_PRESENCE),
9786         SND_PCI_QUIRK(0x103c, 0x802f, "HP Z240", ALC221_FIXUP_HP_MIC_NO_PRESENCE),
9787         SND_PCI_QUIRK(0x103c, 0x8077, "HP", ALC256_FIXUP_HP_HEADSET_MIC),
9788         SND_PCI_QUIRK(0x103c, 0x8158, "HP", ALC256_FIXUP_HP_HEADSET_MIC),
9789         SND_PCI_QUIRK(0x103c, 0x820d, "HP Pavilion 15", ALC295_FIXUP_HP_X360),
9790         SND_PCI_QUIRK(0x103c, 0x8256, "HP", ALC221_FIXUP_HP_FRONT_MIC),
9791         SND_PCI_QUIRK(0x103c, 0x827e, "HP x360", ALC295_FIXUP_HP_X360),
9792         SND_PCI_QUIRK(0x103c, 0x827f, "HP x360", ALC269_FIXUP_HP_MUTE_LED_MIC3),
9793         SND_PCI_QUIRK(0x103c, 0x82bf, "HP G3 mini", ALC221_FIXUP_HP_MIC_NO_PRESENCE),
9794         SND_PCI_QUIRK(0x103c, 0x82c0, "HP G3 mini premium", ALC221_FIXUP_HP_MIC_NO_PRESENCE),
9795         SND_PCI_QUIRK(0x103c, 0x83b9, "HP Spectre x360", ALC269_FIXUP_HP_MUTE_LED_MIC3),
9796         SND_PCI_QUIRK(0x103c, 0x841c, "HP Pavilion 15-CK0xx", ALC269_FIXUP_HP_MUTE_LED_MIC3),
9797         SND_PCI_QUIRK(0x103c, 0x8497, "HP Envy x360", ALC269_FIXUP_HP_MUTE_LED_MIC3),
9798         SND_PCI_QUIRK(0x103c, 0x84ae, "HP 15-db0403ng", ALC236_FIXUP_HP_MUTE_LED_COEFBIT2),
9799         SND_PCI_QUIRK(0x103c, 0x84da, "HP OMEN dc0019-ur", ALC295_FIXUP_HP_OMEN),
9800         SND_PCI_QUIRK(0x103c, 0x84e7, "HP Pavilion 15", ALC269_FIXUP_HP_MUTE_LED_MIC3),
9801         SND_PCI_QUIRK(0x103c, 0x8519, "HP Spectre x360 15-df0xxx", ALC285_FIXUP_HP_SPECTRE_X360),
9802         SND_PCI_QUIRK(0x103c, 0x860f, "HP ZBook 15 G6", ALC285_FIXUP_HP_GPIO_AMP_INIT),
9803         SND_PCI_QUIRK(0x103c, 0x861f, "HP Elite Dragonfly G1", ALC285_FIXUP_HP_GPIO_AMP_INIT),
9804         SND_PCI_QUIRK(0x103c, 0x869d, "HP", ALC236_FIXUP_HP_MUTE_LED),
9805         SND_PCI_QUIRK(0x103c, 0x86c7, "HP Envy AiO 32", ALC274_FIXUP_HP_ENVY_GPIO),
9806         SND_PCI_QUIRK(0x103c, 0x86e7, "HP Spectre x360 15-eb0xxx", ALC285_FIXUP_HP_SPECTRE_X360_EB1),
9807         SND_PCI_QUIRK(0x103c, 0x86e8, "HP Spectre x360 15-eb0xxx", ALC285_FIXUP_HP_SPECTRE_X360_EB1),
9808         SND_PCI_QUIRK(0x103c, 0x86f9, "HP Spectre x360 13-aw0xxx", ALC285_FIXUP_HP_SPECTRE_X360_MUTE_LED),
9809         SND_PCI_QUIRK(0x103c, 0x8716, "HP Elite Dragonfly G2 Notebook PC", ALC285_FIXUP_HP_GPIO_AMP_INIT),
9810         SND_PCI_QUIRK(0x103c, 0x8720, "HP EliteBook x360 1040 G8 Notebook PC", ALC285_FIXUP_HP_GPIO_AMP_INIT),
9811         SND_PCI_QUIRK(0x103c, 0x8724, "HP EliteBook 850 G7", ALC285_FIXUP_HP_GPIO_LED),
9812         SND_PCI_QUIRK(0x103c, 0x8728, "HP EliteBook 840 G7", ALC285_FIXUP_HP_GPIO_LED),
9813         SND_PCI_QUIRK(0x103c, 0x8729, "HP", ALC285_FIXUP_HP_GPIO_LED),
9814         SND_PCI_QUIRK(0x103c, 0x8730, "HP ProBook 445 G7", ALC236_FIXUP_HP_MUTE_LED_MICMUTE_VREF),
9815         SND_PCI_QUIRK(0x103c, 0x8735, "HP ProBook 435 G7", ALC236_FIXUP_HP_MUTE_LED_MICMUTE_VREF),
9816         SND_PCI_QUIRK(0x103c, 0x8736, "HP", ALC285_FIXUP_HP_GPIO_AMP_INIT),
9817         SND_PCI_QUIRK(0x103c, 0x8760, "HP", ALC285_FIXUP_HP_MUTE_LED),
9818         SND_PCI_QUIRK(0x103c, 0x877a, "HP", ALC285_FIXUP_HP_MUTE_LED),
9819         SND_PCI_QUIRK(0x103c, 0x877d, "HP", ALC236_FIXUP_HP_MUTE_LED),
9820         SND_PCI_QUIRK(0x103c, 0x8780, "HP ZBook Fury 17 G7 Mobile Workstation",
9821                       ALC285_FIXUP_HP_GPIO_AMP_INIT),
9822         SND_PCI_QUIRK(0x103c, 0x8783, "HP ZBook Fury 15 G7 Mobile Workstation",
9823                       ALC285_FIXUP_HP_GPIO_AMP_INIT),
9824         SND_PCI_QUIRK(0x103c, 0x8786, "HP OMEN 15", ALC285_FIXUP_HP_MUTE_LED),
9825         SND_PCI_QUIRK(0x103c, 0x8787, "HP OMEN 15", ALC285_FIXUP_HP_MUTE_LED),
9826         SND_PCI_QUIRK(0x103c, 0x8788, "HP OMEN 15", ALC285_FIXUP_HP_MUTE_LED),
9827         SND_PCI_QUIRK(0x103c, 0x87c8, "HP", ALC287_FIXUP_HP_GPIO_LED),
9828         SND_PCI_QUIRK(0x103c, 0x87e5, "HP ProBook 440 G8 Notebook PC", ALC236_FIXUP_HP_GPIO_LED),
9829         SND_PCI_QUIRK(0x103c, 0x87e7, "HP ProBook 450 G8 Notebook PC", ALC236_FIXUP_HP_GPIO_LED),
9830         SND_PCI_QUIRK(0x103c, 0x87f1, "HP ProBook 630 G8 Notebook PC", ALC236_FIXUP_HP_GPIO_LED),
9831         SND_PCI_QUIRK(0x103c, 0x87f2, "HP ProBook 640 G8 Notebook PC", ALC236_FIXUP_HP_GPIO_LED),
9832         SND_PCI_QUIRK(0x103c, 0x87f4, "HP", ALC287_FIXUP_HP_GPIO_LED),
9833         SND_PCI_QUIRK(0x103c, 0x87f5, "HP", ALC287_FIXUP_HP_GPIO_LED),
9834         SND_PCI_QUIRK(0x103c, 0x87f6, "HP Spectre x360 14", ALC245_FIXUP_HP_X360_AMP),
9835         SND_PCI_QUIRK(0x103c, 0x87f7, "HP Spectre x360 14", ALC245_FIXUP_HP_X360_AMP),
9836         SND_PCI_QUIRK(0x103c, 0x8805, "HP ProBook 650 G8 Notebook PC", ALC236_FIXUP_HP_GPIO_LED),
9837         SND_PCI_QUIRK(0x103c, 0x880d, "HP EliteBook 830 G8 Notebook PC", ALC285_FIXUP_HP_GPIO_LED),
9838         SND_PCI_QUIRK(0x103c, 0x8811, "HP Spectre x360 15-eb1xxx", ALC285_FIXUP_HP_SPECTRE_X360_EB1),
9839         SND_PCI_QUIRK(0x103c, 0x8812, "HP Spectre x360 15-eb1xxx", ALC285_FIXUP_HP_SPECTRE_X360_EB1),
9840         SND_PCI_QUIRK(0x103c, 0x881d, "HP 250 G8 Notebook PC", ALC236_FIXUP_HP_MUTE_LED_COEFBIT2),
9841         SND_PCI_QUIRK(0x103c, 0x8846, "HP EliteBook 850 G8 Notebook PC", ALC285_FIXUP_HP_GPIO_LED),
9842         SND_PCI_QUIRK(0x103c, 0x8847, "HP EliteBook x360 830 G8 Notebook PC", ALC285_FIXUP_HP_GPIO_LED),
9843         SND_PCI_QUIRK(0x103c, 0x884b, "HP EliteBook 840 Aero G8 Notebook PC", ALC285_FIXUP_HP_GPIO_LED),
9844         SND_PCI_QUIRK(0x103c, 0x884c, "HP EliteBook 840 G8 Notebook PC", ALC285_FIXUP_HP_GPIO_LED),
9845         SND_PCI_QUIRK(0x103c, 0x8862, "HP ProBook 445 G8 Notebook PC", ALC236_FIXUP_HP_LIMIT_INT_MIC_BOOST),
9846         SND_PCI_QUIRK(0x103c, 0x8863, "HP ProBook 445 G8 Notebook PC", ALC236_FIXUP_HP_LIMIT_INT_MIC_BOOST),
9847         SND_PCI_QUIRK(0x103c, 0x886d, "HP ZBook Fury 17.3 Inch G8 Mobile Workstation PC", ALC285_FIXUP_HP_GPIO_AMP_INIT),
9848         SND_PCI_QUIRK(0x103c, 0x8870, "HP ZBook Fury 15.6 Inch G8 Mobile Workstation PC", ALC285_FIXUP_HP_GPIO_AMP_INIT),
9849         SND_PCI_QUIRK(0x103c, 0x8873, "HP ZBook Studio 15.6 Inch G8 Mobile Workstation PC", ALC285_FIXUP_HP_GPIO_AMP_INIT),
9850         SND_PCI_QUIRK(0x103c, 0x887a, "HP Laptop 15s-eq2xxx", ALC236_FIXUP_HP_MUTE_LED_COEFBIT2),
9851         SND_PCI_QUIRK(0x103c, 0x888a, "HP ENVY x360 Convertible 15-eu0xxx", ALC245_FIXUP_HP_X360_MUTE_LEDS),
9852         SND_PCI_QUIRK(0x103c, 0x888d, "HP ZBook Power 15.6 inch G8 Mobile Workstation PC", ALC236_FIXUP_HP_GPIO_LED),
9853         SND_PCI_QUIRK(0x103c, 0x8895, "HP EliteBook 855 G8 Notebook PC", ALC285_FIXUP_HP_SPEAKERS_MICMUTE_LED),
9854         SND_PCI_QUIRK(0x103c, 0x8896, "HP EliteBook 855 G8 Notebook PC", ALC285_FIXUP_HP_MUTE_LED),
9855         SND_PCI_QUIRK(0x103c, 0x8898, "HP EliteBook 845 G8 Notebook PC", ALC285_FIXUP_HP_LIMIT_INT_MIC_BOOST),
9856         SND_PCI_QUIRK(0x103c, 0x88d0, "HP Pavilion 15-eh1xxx (mainboard 88D0)", ALC287_FIXUP_HP_GPIO_LED),
9857         SND_PCI_QUIRK(0x103c, 0x8902, "HP OMEN 16", ALC285_FIXUP_HP_MUTE_LED),
9858         SND_PCI_QUIRK(0x103c, 0x890e, "HP 255 G8 Notebook PC", ALC236_FIXUP_HP_MUTE_LED_COEFBIT2),
9859         SND_PCI_QUIRK(0x103c, 0x8919, "HP Pavilion Aero Laptop 13-be0xxx", ALC287_FIXUP_HP_GPIO_LED),
9860         SND_PCI_QUIRK(0x103c, 0x896d, "HP ZBook Firefly 16 G9", ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED),
9861         SND_PCI_QUIRK(0x103c, 0x896e, "HP EliteBook x360 830 G9", ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED),
9862         SND_PCI_QUIRK(0x103c, 0x8971, "HP EliteBook 830 G9", ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED),
9863         SND_PCI_QUIRK(0x103c, 0x8972, "HP EliteBook 840 G9", ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED),
9864         SND_PCI_QUIRK(0x103c, 0x8973, "HP EliteBook 860 G9", ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED),
9865         SND_PCI_QUIRK(0x103c, 0x8974, "HP EliteBook 840 Aero G9", ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED),
9866         SND_PCI_QUIRK(0x103c, 0x8975, "HP EliteBook x360 840 Aero G9", ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED),
9867         SND_PCI_QUIRK(0x103c, 0x8981, "HP Elite Dragonfly G3", ALC245_FIXUP_CS35L41_SPI_4),
9868         SND_PCI_QUIRK(0x103c, 0x898e, "HP EliteBook 835 G9", ALC287_FIXUP_CS35L41_I2C_2),
9869         SND_PCI_QUIRK(0x103c, 0x898f, "HP EliteBook 835 G9", ALC287_FIXUP_CS35L41_I2C_2),
9870         SND_PCI_QUIRK(0x103c, 0x8991, "HP EliteBook 845 G9", ALC287_FIXUP_CS35L41_I2C_2_HP_GPIO_LED),
9871         SND_PCI_QUIRK(0x103c, 0x8992, "HP EliteBook 845 G9", ALC287_FIXUP_CS35L41_I2C_2),
9872         SND_PCI_QUIRK(0x103c, 0x8994, "HP EliteBook 855 G9", ALC287_FIXUP_CS35L41_I2C_2_HP_GPIO_LED),
9873         SND_PCI_QUIRK(0x103c, 0x8995, "HP EliteBook 855 G9", ALC287_FIXUP_CS35L41_I2C_2),
9874         SND_PCI_QUIRK(0x103c, 0x89a4, "HP ProBook 440 G9", ALC236_FIXUP_HP_GPIO_LED),
9875         SND_PCI_QUIRK(0x103c, 0x89a6, "HP ProBook 450 G9", ALC236_FIXUP_HP_GPIO_LED),
9876         SND_PCI_QUIRK(0x103c, 0x89aa, "HP EliteBook 630 G9", ALC236_FIXUP_HP_GPIO_LED),
9877         SND_PCI_QUIRK(0x103c, 0x89ac, "HP EliteBook 640 G9", ALC236_FIXUP_HP_GPIO_LED),
9878         SND_PCI_QUIRK(0x103c, 0x89ae, "HP EliteBook 650 G9", ALC236_FIXUP_HP_GPIO_LED),
9879         SND_PCI_QUIRK(0x103c, 0x89c0, "HP ZBook Power 15.6 G9", ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED),
9880         SND_PCI_QUIRK(0x103c, 0x89c3, "Zbook Studio G9", ALC245_FIXUP_CS35L41_SPI_4_HP_GPIO_LED),
9881         SND_PCI_QUIRK(0x103c, 0x89c6, "Zbook Fury 17 G9", ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED),
9882         SND_PCI_QUIRK(0x103c, 0x89ca, "HP", ALC236_FIXUP_HP_MUTE_LED_MICMUTE_VREF),
9883         SND_PCI_QUIRK(0x103c, 0x89d3, "HP EliteBook 645 G9 (MB 89D2)", ALC236_FIXUP_HP_MUTE_LED_MICMUTE_VREF),
9884         SND_PCI_QUIRK(0x103c, 0x8a20, "HP Laptop 15s-fq5xxx", ALC236_FIXUP_HP_MUTE_LED_COEFBIT2),
9885         SND_PCI_QUIRK(0x103c, 0x8a25, "HP Victus 16-d1xxx (MB 8A25)", ALC245_FIXUP_HP_MUTE_LED_COEFBIT),
9886         SND_PCI_QUIRK(0x103c, 0x8a78, "HP Dev One", ALC285_FIXUP_HP_LIMIT_INT_MIC_BOOST),
9887         SND_PCI_QUIRK(0x103c, 0x8aa0, "HP ProBook 440 G9 (MB 8A9E)", ALC236_FIXUP_HP_GPIO_LED),
9888         SND_PCI_QUIRK(0x103c, 0x8aa3, "HP ProBook 450 G9 (MB 8AA1)", ALC236_FIXUP_HP_GPIO_LED),
9889         SND_PCI_QUIRK(0x103c, 0x8aa8, "HP EliteBook 640 G9 (MB 8AA6)", ALC236_FIXUP_HP_GPIO_LED),
9890         SND_PCI_QUIRK(0x103c, 0x8aab, "HP EliteBook 650 G9 (MB 8AA9)", ALC236_FIXUP_HP_GPIO_LED),
9891         SND_PCI_QUIRK(0x103c, 0x8abb, "HP ZBook Firefly 14 G9", ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED),
9892         SND_PCI_QUIRK(0x103c, 0x8ad1, "HP EliteBook 840 14 inch G9 Notebook PC", ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED),
9893         SND_PCI_QUIRK(0x103c, 0x8ad2, "HP EliteBook 860 16 inch G9 Notebook PC", ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED),
9894         SND_PCI_QUIRK(0x103c, 0x8b2f, "HP 255 15.6 inch G10 Notebook PC", ALC236_FIXUP_HP_MUTE_LED_COEFBIT2),
9895         SND_PCI_QUIRK(0x103c, 0x8b42, "HP", ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED),
9896         SND_PCI_QUIRK(0x103c, 0x8b43, "HP", ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED),
9897         SND_PCI_QUIRK(0x103c, 0x8b44, "HP", ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED),
9898         SND_PCI_QUIRK(0x103c, 0x8b45, "HP", ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED),
9899         SND_PCI_QUIRK(0x103c, 0x8b46, "HP", ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED),
9900         SND_PCI_QUIRK(0x103c, 0x8b47, "HP", ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED),
9901         SND_PCI_QUIRK(0x103c, 0x8b5d, "HP", ALC236_FIXUP_HP_MUTE_LED_MICMUTE_VREF),
9902         SND_PCI_QUIRK(0x103c, 0x8b5e, "HP", ALC236_FIXUP_HP_MUTE_LED_MICMUTE_VREF),
9903         SND_PCI_QUIRK(0x103c, 0x8b63, "HP Elite Dragonfly 13.5 inch G4", ALC245_FIXUP_CS35L41_SPI_4_HP_GPIO_LED),
9904         SND_PCI_QUIRK(0x103c, 0x8b65, "HP ProBook 455 15.6 inch G10 Notebook PC", ALC236_FIXUP_HP_MUTE_LED_MICMUTE_VREF),
9905         SND_PCI_QUIRK(0x103c, 0x8b66, "HP", ALC236_FIXUP_HP_MUTE_LED_MICMUTE_VREF),
9906         SND_PCI_QUIRK(0x103c, 0x8b70, "HP EliteBook 835 G10", ALC287_FIXUP_CS35L41_I2C_2_HP_GPIO_LED),
9907         SND_PCI_QUIRK(0x103c, 0x8b72, "HP EliteBook 845 G10", ALC287_FIXUP_CS35L41_I2C_2_HP_GPIO_LED),
9908         SND_PCI_QUIRK(0x103c, 0x8b74, "HP EliteBook 845W G10", ALC287_FIXUP_CS35L41_I2C_2_HP_GPIO_LED),
9909         SND_PCI_QUIRK(0x103c, 0x8b77, "HP ElieBook 865 G10", ALC287_FIXUP_CS35L41_I2C_2),
9910         SND_PCI_QUIRK(0x103c, 0x8b7a, "HP", ALC236_FIXUP_HP_GPIO_LED),
9911         SND_PCI_QUIRK(0x103c, 0x8b7d, "HP", ALC236_FIXUP_HP_GPIO_LED),
9912         SND_PCI_QUIRK(0x103c, 0x8b87, "HP", ALC236_FIXUP_HP_GPIO_LED),
9913         SND_PCI_QUIRK(0x103c, 0x8b8a, "HP", ALC236_FIXUP_HP_GPIO_LED),
9914         SND_PCI_QUIRK(0x103c, 0x8b8b, "HP", ALC236_FIXUP_HP_GPIO_LED),
9915         SND_PCI_QUIRK(0x103c, 0x8b8d, "HP", ALC236_FIXUP_HP_GPIO_LED),
9916         SND_PCI_QUIRK(0x103c, 0x8b8f, "HP", ALC245_FIXUP_CS35L41_SPI_4_HP_GPIO_LED),
9917         SND_PCI_QUIRK(0x103c, 0x8b92, "HP", ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED),
9918         SND_PCI_QUIRK(0x103c, 0x8b96, "HP", ALC236_FIXUP_HP_MUTE_LED_MICMUTE_VREF),
9919         SND_PCI_QUIRK(0x103c, 0x8b97, "HP", ALC236_FIXUP_HP_MUTE_LED_MICMUTE_VREF),
9920         SND_PCI_QUIRK(0x103c, 0x8bf0, "HP", ALC236_FIXUP_HP_GPIO_LED),
9921         SND_PCI_QUIRK(0x103c, 0x8c46, "HP EliteBook 830 G11", ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED),
9922         SND_PCI_QUIRK(0x103c, 0x8c47, "HP EliteBook 840 G11", ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED),
9923         SND_PCI_QUIRK(0x103c, 0x8c48, "HP EliteBook 860 G11", ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED),
9924         SND_PCI_QUIRK(0x103c, 0x8c49, "HP Elite x360 830 2-in-1 G11", ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED),
9925         SND_PCI_QUIRK(0x103c, 0x8c70, "HP EliteBook 835 G11", ALC287_FIXUP_CS35L41_I2C_2_HP_GPIO_LED),
9926         SND_PCI_QUIRK(0x103c, 0x8c71, "HP EliteBook 845 G11", ALC287_FIXUP_CS35L41_I2C_2_HP_GPIO_LED),
9927         SND_PCI_QUIRK(0x103c, 0x8c72, "HP EliteBook 865 G11", ALC287_FIXUP_CS35L41_I2C_2_HP_GPIO_LED),
9928         SND_PCI_QUIRK(0x103c, 0x8ca4, "HP ZBook Fury", ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED),
9929         SND_PCI_QUIRK(0x103c, 0x8ca7, "HP ZBook Fury", ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED),
9930         SND_PCI_QUIRK(0x103c, 0x8cf5, "HP ZBook Studio 16", ALC245_FIXUP_CS35L41_SPI_4_HP_GPIO_LED),
9931         SND_PCI_QUIRK(0x1043, 0x103e, "ASUS X540SA", ALC256_FIXUP_ASUS_MIC),
9932         SND_PCI_QUIRK(0x1043, 0x103f, "ASUS TX300", ALC282_FIXUP_ASUS_TX300),
9933         SND_PCI_QUIRK(0x1043, 0x106d, "Asus K53BE", ALC269_FIXUP_LIMIT_INT_MIC_BOOST),
9934         SND_PCI_QUIRK(0x1043, 0x10a1, "ASUS UX391UA", ALC294_FIXUP_ASUS_SPK),
9935         SND_PCI_QUIRK(0x1043, 0x10c0, "ASUS X540SA", ALC256_FIXUP_ASUS_MIC),
9936         SND_PCI_QUIRK(0x1043, 0x10d0, "ASUS X540LA/X540LJ", ALC255_FIXUP_ASUS_MIC_NO_PRESENCE),
9937         SND_PCI_QUIRK(0x1043, 0x10d3, "ASUS K6500ZC", ALC294_FIXUP_ASUS_SPK),
9938         SND_PCI_QUIRK(0x1043, 0x115d, "Asus 1015E", ALC269_FIXUP_LIMIT_INT_MIC_BOOST),
9939         SND_PCI_QUIRK(0x1043, 0x11c0, "ASUS X556UR", ALC255_FIXUP_ASUS_MIC_NO_PRESENCE),
9940         SND_PCI_QUIRK(0x1043, 0x125e, "ASUS Q524UQK", ALC255_FIXUP_ASUS_MIC_NO_PRESENCE),
9941         SND_PCI_QUIRK(0x1043, 0x1271, "ASUS X430UN", ALC256_FIXUP_ASUS_MIC_NO_PRESENCE),
9942         SND_PCI_QUIRK(0x1043, 0x1290, "ASUS X441SA", ALC233_FIXUP_EAPD_COEF_AND_MIC_NO_PRESENCE),
9943         SND_PCI_QUIRK(0x1043, 0x12a0, "ASUS X441UV", ALC233_FIXUP_EAPD_COEF_AND_MIC_NO_PRESENCE),
9944         SND_PCI_QUIRK(0x1043, 0x12a3, "Asus N7691ZM", ALC269_FIXUP_ASUS_N7601ZM),
9945         SND_PCI_QUIRK(0x1043, 0x12af, "ASUS UX582ZS", ALC245_FIXUP_CS35L41_SPI_2),
9946         SND_PCI_QUIRK(0x1043, 0x12e0, "ASUS X541SA", ALC256_FIXUP_ASUS_MIC),
9947         SND_PCI_QUIRK(0x1043, 0x12f0, "ASUS X541UV", ALC256_FIXUP_ASUS_MIC),
9948         SND_PCI_QUIRK(0x1043, 0x1313, "Asus K42JZ", ALC269VB_FIXUP_ASUS_MIC_NO_PRESENCE),
9949         SND_PCI_QUIRK(0x1043, 0x13b0, "ASUS Z550SA", ALC256_FIXUP_ASUS_MIC),
9950         SND_PCI_QUIRK(0x1043, 0x1427, "Asus Zenbook UX31E", ALC269VB_FIXUP_ASUS_ZENBOOK),
9951         SND_PCI_QUIRK(0x1043, 0x1433, "ASUS GX650PY/PZ/PV/PU/PYV/PZV/PIV/PVV", ALC285_FIXUP_ASUS_I2C_HEADSET_MIC),
9952         SND_PCI_QUIRK(0x1043, 0x1463, "Asus GA402X/GA402N", ALC285_FIXUP_ASUS_I2C_HEADSET_MIC),
9953         SND_PCI_QUIRK(0x1043, 0x1473, "ASUS GU604VI/VC/VE/VG/VJ/VQ/VU/VV/VY/VZ", ALC285_FIXUP_ASUS_HEADSET_MIC),
9954         SND_PCI_QUIRK(0x1043, 0x1483, "ASUS GU603VQ/VU/VV/VJ/VI", ALC285_FIXUP_ASUS_HEADSET_MIC),
9955         SND_PCI_QUIRK(0x1043, 0x1493, "ASUS GV601VV/VU/VJ/VQ/VI", ALC285_FIXUP_ASUS_HEADSET_MIC),
9956         SND_PCI_QUIRK(0x1043, 0x14d3, "ASUS G614JY/JZ/JG", ALC245_FIXUP_CS35L41_SPI_2),
9957         SND_PCI_QUIRK(0x1043, 0x14e3, "ASUS G513PI/PU/PV", ALC287_FIXUP_CS35L41_I2C_2),
9958         SND_PCI_QUIRK(0x1043, 0x1503, "ASUS G733PY/PZ/PZV/PYV", ALC287_FIXUP_CS35L41_I2C_2),
9959         SND_PCI_QUIRK(0x1043, 0x1517, "Asus Zenbook UX31A", ALC269VB_FIXUP_ASUS_ZENBOOK_UX31A),
9960         SND_PCI_QUIRK(0x1043, 0x1533, "ASUS GV302XA/XJ/XQ/XU/XV/XI", ALC287_FIXUP_CS35L41_I2C_2),
9961         SND_PCI_QUIRK(0x1043, 0x1573, "ASUS GZ301VV/VQ/VU/VJ/VA/VC/VE/VVC/VQC/VUC/VJC/VEC/VCC", ALC285_FIXUP_ASUS_HEADSET_MIC),
9962         SND_PCI_QUIRK(0x1043, 0x1662, "ASUS GV301QH", ALC294_FIXUP_ASUS_DUAL_SPK),
9963         SND_PCI_QUIRK(0x1043, 0x1663, "ASUS GU603ZI/ZJ/ZQ/ZU/ZV", ALC285_FIXUP_ASUS_HEADSET_MIC),
9964         SND_PCI_QUIRK(0x1043, 0x1683, "ASUS UM3402YAR", ALC287_FIXUP_CS35L41_I2C_2),
9965         SND_PCI_QUIRK(0x1043, 0x16b2, "ASUS GU603", ALC289_FIXUP_ASUS_GA401),
9966         SND_PCI_QUIRK(0x1043, 0x16d3, "ASUS UX5304VA", ALC245_FIXUP_CS35L41_SPI_2),
9967         SND_PCI_QUIRK(0x1043, 0x16e3, "ASUS UX50", ALC269_FIXUP_STEREO_DMIC),
9968         SND_PCI_QUIRK(0x1043, 0x16f3, "ASUS UX7602VI/BZ", ALC245_FIXUP_CS35L41_SPI_2),
9969         SND_PCI_QUIRK(0x1043, 0x1740, "ASUS UX430UA", ALC295_FIXUP_ASUS_DACS),
9970         SND_PCI_QUIRK(0x1043, 0x17d1, "ASUS UX431FL", ALC294_FIXUP_ASUS_DUAL_SPK),
9971         SND_PCI_QUIRK(0x1043, 0x17f3, "ROG Ally NR2301L/X", ALC294_FIXUP_ASUS_ALLY),
9972         SND_PCI_QUIRK(0x1043, 0x1863, "ASUS UX6404VI/VV", ALC245_FIXUP_CS35L41_SPI_2),
9973         SND_PCI_QUIRK(0x1043, 0x1881, "ASUS Zephyrus S/M", ALC294_FIXUP_ASUS_GX502_PINS),
9974         SND_PCI_QUIRK(0x1043, 0x18b1, "Asus MJ401TA", ALC256_FIXUP_ASUS_HEADSET_MIC),
9975         SND_PCI_QUIRK(0x1043, 0x18d3, "ASUS UM3504DA", ALC294_FIXUP_CS35L41_I2C_2),
9976         SND_PCI_QUIRK(0x1043, 0x18f1, "Asus FX505DT", ALC256_FIXUP_ASUS_HEADSET_MIC),
9977         SND_PCI_QUIRK(0x1043, 0x194e, "ASUS UX563FD", ALC294_FIXUP_ASUS_HPE),
9978         SND_PCI_QUIRK(0x1043, 0x1970, "ASUS UX550VE", ALC289_FIXUP_ASUS_GA401),
9979         SND_PCI_QUIRK(0x1043, 0x1982, "ASUS B1400CEPE", ALC256_FIXUP_ASUS_HPE),
9980         SND_PCI_QUIRK(0x1043, 0x19ce, "ASUS B9450FA", ALC294_FIXUP_ASUS_HPE),
9981         SND_PCI_QUIRK(0x1043, 0x19e1, "ASUS UX581LV", ALC295_FIXUP_ASUS_MIC_NO_PRESENCE),
9982         SND_PCI_QUIRK(0x1043, 0x1a13, "Asus G73Jw", ALC269_FIXUP_ASUS_G73JW),
9983         SND_PCI_QUIRK(0x1043, 0x1a30, "ASUS X705UD", ALC256_FIXUP_ASUS_MIC),
9984         SND_PCI_QUIRK(0x1043, 0x1a63, "ASUS UX3405MA", ALC245_FIXUP_CS35L41_SPI_2),
9985         SND_PCI_QUIRK(0x1043, 0x1a83, "ASUS UM5302LA", ALC294_FIXUP_CS35L41_I2C_2),
9986         SND_PCI_QUIRK(0x1043, 0x1a8f, "ASUS UX582ZS", ALC245_FIXUP_CS35L41_SPI_2),
9987         SND_PCI_QUIRK(0x1043, 0x1b11, "ASUS UX431DA", ALC294_FIXUP_ASUS_COEF_1B),
9988         SND_PCI_QUIRK(0x1043, 0x1b13, "Asus U41SV", ALC269_FIXUP_INV_DMIC),
9989         SND_PCI_QUIRK(0x1043, 0x1b93, "ASUS G614JVR/JIR", ALC245_FIXUP_CS35L41_SPI_2),
9990         SND_PCI_QUIRK(0x1043, 0x1bbd, "ASUS Z550MA", ALC255_FIXUP_ASUS_MIC_NO_PRESENCE),
9991         SND_PCI_QUIRK(0x1043, 0x1c03, "ASUS UM3406HA", ALC287_FIXUP_CS35L41_I2C_2),
9992         SND_PCI_QUIRK(0x1043, 0x1c23, "Asus X55U", ALC269_FIXUP_LIMIT_INT_MIC_BOOST),
9993         SND_PCI_QUIRK(0x1043, 0x1c33, "ASUS UX5304MA", ALC245_FIXUP_CS35L41_SPI_2),
9994         SND_PCI_QUIRK(0x1043, 0x1c43, "ASUS UX8406MA", ALC245_FIXUP_CS35L41_SPI_2),
9995         SND_PCI_QUIRK(0x1043, 0x1c62, "ASUS GU603", ALC289_FIXUP_ASUS_GA401),
9996         SND_PCI_QUIRK(0x1043, 0x1c92, "ASUS ROG Strix G15", ALC285_FIXUP_ASUS_G533Z_PINS),
9997         SND_PCI_QUIRK(0x1043, 0x1c9f, "ASUS G614JU/JV/JI", ALC285_FIXUP_ASUS_HEADSET_MIC),
9998         SND_PCI_QUIRK(0x1043, 0x1caf, "ASUS G634JY/JZ/JI/JG", ALC285_FIXUP_ASUS_SPI_REAR_SPEAKERS),
9999         SND_PCI_QUIRK(0x1043, 0x1ccd, "ASUS X555UB", ALC256_FIXUP_ASUS_MIC),
10000         SND_PCI_QUIRK(0x1043, 0x1ccf, "ASUS G814JU/JV/JI", ALC245_FIXUP_CS35L41_SPI_2),
10001         SND_PCI_QUIRK(0x1043, 0x1cdf, "ASUS G814JY/JZ/JG", ALC245_FIXUP_CS35L41_SPI_2),
10002         SND_PCI_QUIRK(0x1043, 0x1cef, "ASUS G834JY/JZ/JI/JG", ALC285_FIXUP_ASUS_HEADSET_MIC),
10003         SND_PCI_QUIRK(0x1043, 0x1d1f, "ASUS G713PI/PU/PV/PVN", ALC287_FIXUP_CS35L41_I2C_2),
10004         SND_PCI_QUIRK(0x1043, 0x1d42, "ASUS Zephyrus G14 2022", ALC289_FIXUP_ASUS_GA401),
10005         SND_PCI_QUIRK(0x1043, 0x1d4e, "ASUS TM420", ALC256_FIXUP_ASUS_HPE),
10006         SND_PCI_QUIRK(0x1043, 0x1da2, "ASUS UP6502ZA/ZD", ALC245_FIXUP_CS35L41_SPI_2),
10007         SND_PCI_QUIRK(0x1043, 0x1e02, "ASUS UX3402ZA", ALC245_FIXUP_CS35L41_SPI_2),
10008         SND_PCI_QUIRK(0x1043, 0x16a3, "ASUS UX3402VA", ALC245_FIXUP_CS35L41_SPI_2),
10009         SND_PCI_QUIRK(0x1043, 0x1f62, "ASUS UX7602ZM", ALC245_FIXUP_CS35L41_SPI_2),
10010         SND_PCI_QUIRK(0x1043, 0x1e11, "ASUS Zephyrus G15", ALC289_FIXUP_ASUS_GA502),
10011         SND_PCI_QUIRK(0x1043, 0x1e12, "ASUS UM6702RA/RC", ALC287_FIXUP_CS35L41_I2C_2),
10012         SND_PCI_QUIRK(0x1043, 0x1e51, "ASUS Zephyrus M15", ALC294_FIXUP_ASUS_GU502_PINS),
10013         SND_PCI_QUIRK(0x1043, 0x1e5e, "ASUS ROG Strix G513", ALC294_FIXUP_ASUS_G513_PINS),
10014         SND_PCI_QUIRK(0x1043, 0x1e8e, "ASUS Zephyrus G15", ALC289_FIXUP_ASUS_GA401),
10015         SND_PCI_QUIRK(0x1043, 0x1ee2, "ASUS UM3402", ALC287_FIXUP_CS35L41_I2C_2),
10016         SND_PCI_QUIRK(0x1043, 0x1c52, "ASUS Zephyrus G15 2022", ALC289_FIXUP_ASUS_GA401),
10017         SND_PCI_QUIRK(0x1043, 0x1f11, "ASUS Zephyrus G14", ALC289_FIXUP_ASUS_GA401),
10018         SND_PCI_QUIRK(0x1043, 0x1f12, "ASUS UM5302", ALC287_FIXUP_CS35L41_I2C_2),
10019         SND_PCI_QUIRK(0x1043, 0x1f1f, "ASUS H7604JI/JV/J3D", ALC245_FIXUP_CS35L41_SPI_2),
10020         SND_PCI_QUIRK(0x1043, 0x1f62, "ASUS UX7602ZM", ALC245_FIXUP_CS35L41_SPI_2),
10021         SND_PCI_QUIRK(0x1043, 0x1f92, "ASUS ROG Flow X16", ALC289_FIXUP_ASUS_GA401),
10022         SND_PCI_QUIRK(0x1043, 0x3030, "ASUS ZN270IE", ALC256_FIXUP_ASUS_AIO_GPIO2),
10023         SND_PCI_QUIRK(0x1043, 0x3a20, "ASUS G614JZR", ALC245_FIXUP_CS35L41_SPI_2),
10024         SND_PCI_QUIRK(0x1043, 0x3a30, "ASUS G814JVR/JIR", ALC245_FIXUP_CS35L41_SPI_2),
10025         SND_PCI_QUIRK(0x1043, 0x3a40, "ASUS G814JZR", ALC245_FIXUP_CS35L41_SPI_2),
10026         SND_PCI_QUIRK(0x1043, 0x3a50, "ASUS G834JYR/JZR", ALC245_FIXUP_CS35L41_SPI_2),
10027         SND_PCI_QUIRK(0x1043, 0x3a60, "ASUS G634JYR/JZR", ALC245_FIXUP_CS35L41_SPI_2),
10028         SND_PCI_QUIRK(0x1043, 0x831a, "ASUS P901", ALC269_FIXUP_STEREO_DMIC),
10029         SND_PCI_QUIRK(0x1043, 0x834a, "ASUS S101", ALC269_FIXUP_STEREO_DMIC),
10030         SND_PCI_QUIRK(0x1043, 0x8398, "ASUS P1005", ALC269_FIXUP_STEREO_DMIC),
10031         SND_PCI_QUIRK(0x1043, 0x83ce, "ASUS P1005", ALC269_FIXUP_STEREO_DMIC),
10032         SND_PCI_QUIRK(0x1043, 0x8516, "ASUS X101CH", ALC269_FIXUP_ASUS_X101),
10033         SND_PCI_QUIRK(0x104d, 0x9073, "Sony VAIO", ALC275_FIXUP_SONY_VAIO_GPIO2),
10034         SND_PCI_QUIRK(0x104d, 0x907b, "Sony VAIO", ALC275_FIXUP_SONY_HWEQ),
10035         SND_PCI_QUIRK(0x104d, 0x9084, "Sony VAIO", ALC275_FIXUP_SONY_HWEQ),
10036         SND_PCI_QUIRK(0x104d, 0x9099, "Sony VAIO S13", ALC275_FIXUP_SONY_DISABLE_AAMIX),
10037         SND_PCI_QUIRK(0x104d, 0x90b5, "Sony VAIO Pro 11", ALC286_FIXUP_SONY_MIC_NO_PRESENCE),
10038         SND_PCI_QUIRK(0x104d, 0x90b6, "Sony VAIO Pro 13", ALC286_FIXUP_SONY_MIC_NO_PRESENCE),
10039         SND_PCI_QUIRK(0x10cf, 0x1475, "Lifebook", ALC269_FIXUP_LIFEBOOK),
10040         SND_PCI_QUIRK(0x10cf, 0x159f, "Lifebook E780", ALC269_FIXUP_LIFEBOOK_NO_HP_TO_LINEOUT),
10041         SND_PCI_QUIRK(0x10cf, 0x15dc, "Lifebook T731", ALC269_FIXUP_LIFEBOOK_HP_PIN),
10042         SND_PCI_QUIRK(0x10cf, 0x1629, "Lifebook U7x7", ALC255_FIXUP_LIFEBOOK_U7x7_HEADSET_MIC),
10043         SND_PCI_QUIRK(0x10cf, 0x1757, "Lifebook E752", ALC269_FIXUP_LIFEBOOK_HP_PIN),
10044         SND_PCI_QUIRK(0x10cf, 0x1845, "Lifebook U904", ALC269_FIXUP_LIFEBOOK_EXTMIC),
10045         SND_PCI_QUIRK(0x10ec, 0x10f2, "Intel Reference board", ALC700_FIXUP_INTEL_REFERENCE),
10046         SND_PCI_QUIRK(0x10ec, 0x118c, "Medion EE4254 MD62100", ALC256_FIXUP_MEDION_HEADSET_NO_PRESENCE),
10047         SND_PCI_QUIRK(0x10ec, 0x1230, "Intel Reference board", ALC295_FIXUP_CHROME_BOOK),
10048         SND_PCI_QUIRK(0x10ec, 0x124c, "Intel Reference board", ALC295_FIXUP_CHROME_BOOK),
10049         SND_PCI_QUIRK(0x10ec, 0x1252, "Intel Reference board", ALC295_FIXUP_CHROME_BOOK),
10050         SND_PCI_QUIRK(0x10ec, 0x1254, "Intel Reference board", ALC295_FIXUP_CHROME_BOOK),
10051         SND_PCI_QUIRK(0x10ec, 0x12cc, "Intel Reference board", ALC295_FIXUP_CHROME_BOOK),
10052         SND_PCI_QUIRK(0x10f7, 0x8338, "Panasonic CF-SZ6", ALC269_FIXUP_HEADSET_MODE),
10053         SND_PCI_QUIRK(0x144d, 0xc109, "Samsung Ativ book 9 (NP900X3G)", ALC269_FIXUP_INV_DMIC),
10054         SND_PCI_QUIRK(0x144d, 0xc169, "Samsung Notebook 9 Pen (NP930SBE-K01US)", ALC298_FIXUP_SAMSUNG_AMP),
10055         SND_PCI_QUIRK(0x144d, 0xc176, "Samsung Notebook 9 Pro (NP930MBE-K04US)", ALC298_FIXUP_SAMSUNG_AMP),
10056         SND_PCI_QUIRK(0x144d, 0xc189, "Samsung Galaxy Flex Book (NT950QCG-X716)", ALC298_FIXUP_SAMSUNG_AMP),
10057         SND_PCI_QUIRK(0x144d, 0xc18a, "Samsung Galaxy Book Ion (NP930XCJ-K01US)", ALC298_FIXUP_SAMSUNG_AMP),
10058         SND_PCI_QUIRK(0x144d, 0xc1a3, "Samsung Galaxy Book Pro (NP935XDB-KC1SE)", ALC298_FIXUP_SAMSUNG_AMP),
10059         SND_PCI_QUIRK(0x144d, 0xc1a6, "Samsung Galaxy Book Pro 360 (NP930QBD)", ALC298_FIXUP_SAMSUNG_AMP),
10060         SND_PCI_QUIRK(0x144d, 0xc740, "Samsung Ativ book 8 (NP870Z5G)", ALC269_FIXUP_ATIV_BOOK_8),
10061         SND_PCI_QUIRK(0x144d, 0xc812, "Samsung Notebook Pen S (NT950SBE-X58)", ALC298_FIXUP_SAMSUNG_AMP),
10062         SND_PCI_QUIRK(0x144d, 0xc830, "Samsung Galaxy Book Ion (NT950XCJ-X716A)", ALC298_FIXUP_SAMSUNG_AMP),
10063         SND_PCI_QUIRK(0x144d, 0xc832, "Samsung Galaxy Book Flex Alpha (NP730QCJ)", ALC256_FIXUP_SAMSUNG_HEADPHONE_VERY_QUIET),
10064         SND_PCI_QUIRK(0x144d, 0xca03, "Samsung Galaxy Book2 Pro 360 (NP930QED)", ALC298_FIXUP_SAMSUNG_AMP),
10065         SND_PCI_QUIRK(0x144d, 0xc868, "Samsung Galaxy Book2 Pro (NP930XED)", ALC298_FIXUP_SAMSUNG_AMP),
10066         SND_PCI_QUIRK(0x1458, 0xfa53, "Gigabyte BXBT-2807", ALC283_FIXUP_HEADSET_MIC),
10067         SND_PCI_QUIRK(0x1462, 0xb120, "MSI Cubi MS-B120", ALC283_FIXUP_HEADSET_MIC),
10068         SND_PCI_QUIRK(0x1462, 0xb171, "Cubi N 8GL (MS-B171)", ALC283_FIXUP_HEADSET_MIC),
10069         SND_PCI_QUIRK(0x152d, 0x1082, "Quanta NL3", ALC269_FIXUP_LIFEBOOK),
10070         SND_PCI_QUIRK(0x1558, 0x1323, "Clevo N130ZU", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10071         SND_PCI_QUIRK(0x1558, 0x1325, "Clevo N15[01][CW]U", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10072         SND_PCI_QUIRK(0x1558, 0x1401, "Clevo L140[CZ]U", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10073         SND_PCI_QUIRK(0x1558, 0x1403, "Clevo N140CU", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10074         SND_PCI_QUIRK(0x1558, 0x1404, "Clevo N150CU", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10075         SND_PCI_QUIRK(0x1558, 0x14a1, "Clevo L141MU", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10076         SND_PCI_QUIRK(0x1558, 0x4018, "Clevo NV40M[BE]", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10077         SND_PCI_QUIRK(0x1558, 0x4019, "Clevo NV40MZ", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10078         SND_PCI_QUIRK(0x1558, 0x4020, "Clevo NV40MB", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10079         SND_PCI_QUIRK(0x1558, 0x4041, "Clevo NV4[15]PZ", ALC256_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10080         SND_PCI_QUIRK(0x1558, 0x40a1, "Clevo NL40GU", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10081         SND_PCI_QUIRK(0x1558, 0x40c1, "Clevo NL40[CZ]U", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10082         SND_PCI_QUIRK(0x1558, 0x40d1, "Clevo NL41DU", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10083         SND_PCI_QUIRK(0x1558, 0x5015, "Clevo NH5[58]H[HJK]Q", ALC256_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10084         SND_PCI_QUIRK(0x1558, 0x5017, "Clevo NH7[79]H[HJK]Q", ALC256_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10085         SND_PCI_QUIRK(0x1558, 0x50a3, "Clevo NJ51GU", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10086         SND_PCI_QUIRK(0x1558, 0x50b3, "Clevo NK50S[BEZ]", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10087         SND_PCI_QUIRK(0x1558, 0x50b6, "Clevo NK50S5", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10088         SND_PCI_QUIRK(0x1558, 0x50b8, "Clevo NK50SZ", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10089         SND_PCI_QUIRK(0x1558, 0x50d5, "Clevo NP50D5", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10090         SND_PCI_QUIRK(0x1558, 0x50e1, "Clevo NH5[58]HPQ", ALC256_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10091         SND_PCI_QUIRK(0x1558, 0x50e2, "Clevo NH7[79]HPQ", ALC256_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10092         SND_PCI_QUIRK(0x1558, 0x50f0, "Clevo NH50A[CDF]", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10093         SND_PCI_QUIRK(0x1558, 0x50f2, "Clevo NH50E[PR]", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10094         SND_PCI_QUIRK(0x1558, 0x50f3, "Clevo NH58DPQ", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10095         SND_PCI_QUIRK(0x1558, 0x50f5, "Clevo NH55EPY", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10096         SND_PCI_QUIRK(0x1558, 0x50f6, "Clevo NH55DPQ", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10097         SND_PCI_QUIRK(0x1558, 0x5101, "Clevo S510WU", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10098         SND_PCI_QUIRK(0x1558, 0x5157, "Clevo W517GU1", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10099         SND_PCI_QUIRK(0x1558, 0x51a1, "Clevo NS50MU", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10100         SND_PCI_QUIRK(0x1558, 0x51b1, "Clevo NS50AU", ALC256_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10101         SND_PCI_QUIRK(0x1558, 0x51b3, "Clevo NS70AU", ALC256_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10102         SND_PCI_QUIRK(0x1558, 0x5630, "Clevo NP50RNJS", ALC256_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10103         SND_PCI_QUIRK(0x1558, 0x70a1, "Clevo NB70T[HJK]", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10104         SND_PCI_QUIRK(0x1558, 0x70b3, "Clevo NK70SB", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10105         SND_PCI_QUIRK(0x1558, 0x70f2, "Clevo NH79EPY", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10106         SND_PCI_QUIRK(0x1558, 0x70f3, "Clevo NH77DPQ", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10107         SND_PCI_QUIRK(0x1558, 0x70f4, "Clevo NH77EPY", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10108         SND_PCI_QUIRK(0x1558, 0x70f6, "Clevo NH77DPQ-Y", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10109         SND_PCI_QUIRK(0x1558, 0x7716, "Clevo NS50PU", ALC256_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10110         SND_PCI_QUIRK(0x1558, 0x7717, "Clevo NS70PU", ALC256_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10111         SND_PCI_QUIRK(0x1558, 0x7718, "Clevo L140PU", ALC256_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10112         SND_PCI_QUIRK(0x1558, 0x7724, "Clevo L140AU", ALC256_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10113         SND_PCI_QUIRK(0x1558, 0x8228, "Clevo NR40BU", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10114         SND_PCI_QUIRK(0x1558, 0x8520, "Clevo NH50D[CD]", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10115         SND_PCI_QUIRK(0x1558, 0x8521, "Clevo NH77D[CD]", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10116         SND_PCI_QUIRK(0x1558, 0x8535, "Clevo NH50D[BE]", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10117         SND_PCI_QUIRK(0x1558, 0x8536, "Clevo NH79D[BE]", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10118         SND_PCI_QUIRK(0x1558, 0x8550, "Clevo NH[57][0-9][ER][ACDH]Q", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10119         SND_PCI_QUIRK(0x1558, 0x8551, "Clevo NH[57][0-9][ER][ACDH]Q", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10120         SND_PCI_QUIRK(0x1558, 0x8560, "Clevo NH[57][0-9][ER][ACDH]Q", ALC269_FIXUP_HEADSET_MIC),
10121         SND_PCI_QUIRK(0x1558, 0x8561, "Clevo NH[57][0-9][ER][ACDH]Q", ALC269_FIXUP_HEADSET_MIC),
10122         SND_PCI_QUIRK(0x1558, 0x8562, "Clevo NH[57][0-9]RZ[Q]", ALC269_FIXUP_DMIC),
10123         SND_PCI_QUIRK(0x1558, 0x8668, "Clevo NP50B[BE]", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10124         SND_PCI_QUIRK(0x1558, 0x866d, "Clevo NP5[05]PN[HJK]", ALC256_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10125         SND_PCI_QUIRK(0x1558, 0x867c, "Clevo NP7[01]PNP", ALC256_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10126         SND_PCI_QUIRK(0x1558, 0x867d, "Clevo NP7[01]PN[HJK]", ALC256_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10127         SND_PCI_QUIRK(0x1558, 0x8680, "Clevo NJ50LU", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10128         SND_PCI_QUIRK(0x1558, 0x8686, "Clevo NH50[CZ]U", ALC256_FIXUP_MIC_NO_PRESENCE_AND_RESUME),
10129         SND_PCI_QUIRK(0x1558, 0x8a20, "Clevo NH55DCQ-Y", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10130         SND_PCI_QUIRK(0x1558, 0x8a51, "Clevo NH70RCQ-Y", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10131         SND_PCI_QUIRK(0x1558, 0x8d50, "Clevo NH55RCQ-M", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10132         SND_PCI_QUIRK(0x1558, 0x951d, "Clevo N950T[CDF]", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10133         SND_PCI_QUIRK(0x1558, 0x9600, "Clevo N960K[PR]", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10134         SND_PCI_QUIRK(0x1558, 0x961d, "Clevo N960S[CDF]", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10135         SND_PCI_QUIRK(0x1558, 0x971d, "Clevo N970T[CDF]", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10136         SND_PCI_QUIRK(0x1558, 0xa500, "Clevo NL5[03]RU", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10137         SND_PCI_QUIRK(0x1558, 0xa600, "Clevo NL50NU", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10138         SND_PCI_QUIRK(0x1558, 0xa650, "Clevo NP[567]0SN[CD]", ALC256_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10139         SND_PCI_QUIRK(0x1558, 0xa671, "Clevo NP70SN[CDE]", ALC256_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10140         SND_PCI_QUIRK(0x1558, 0xb018, "Clevo NP50D[BE]", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10141         SND_PCI_QUIRK(0x1558, 0xb019, "Clevo NH77D[BE]Q", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10142         SND_PCI_QUIRK(0x1558, 0xb022, "Clevo NH77D[DC][QW]", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10143         SND_PCI_QUIRK(0x1558, 0xc018, "Clevo NP50D[BE]", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10144         SND_PCI_QUIRK(0x1558, 0xc019, "Clevo NH77D[BE]Q", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10145         SND_PCI_QUIRK(0x1558, 0xc022, "Clevo NH77[DC][QW]", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10146         SND_PCI_QUIRK(0x17aa, 0x1036, "Lenovo P520", ALC233_FIXUP_LENOVO_MULTI_CODECS),
10147         SND_PCI_QUIRK(0x17aa, 0x1048, "ThinkCentre Station", ALC623_FIXUP_LENOVO_THINKSTATION_P340),
10148         SND_PCI_QUIRK(0x17aa, 0x20f2, "Thinkpad SL410/510", ALC269_FIXUP_SKU_IGNORE),
10149         SND_PCI_QUIRK(0x17aa, 0x215e, "Thinkpad L512", ALC269_FIXUP_SKU_IGNORE),
10150         SND_PCI_QUIRK(0x17aa, 0x21b8, "Thinkpad Edge 14", ALC269_FIXUP_SKU_IGNORE),
10151         SND_PCI_QUIRK(0x17aa, 0x21ca, "Thinkpad L412", ALC269_FIXUP_SKU_IGNORE),
10152         SND_PCI_QUIRK(0x17aa, 0x21e9, "Thinkpad Edge 15", ALC269_FIXUP_SKU_IGNORE),
10153         SND_PCI_QUIRK(0x17aa, 0x21f3, "Thinkpad T430", ALC269_FIXUP_LENOVO_DOCK),
10154         SND_PCI_QUIRK(0x17aa, 0x21f6, "Thinkpad T530", ALC269_FIXUP_LENOVO_DOCK_LIMIT_BOOST),
10155         SND_PCI_QUIRK(0x17aa, 0x21fa, "Thinkpad X230", ALC269_FIXUP_LENOVO_DOCK),
10156         SND_PCI_QUIRK(0x17aa, 0x21fb, "Thinkpad T430s", ALC269_FIXUP_LENOVO_DOCK),
10157         SND_PCI_QUIRK(0x17aa, 0x2203, "Thinkpad X230 Tablet", ALC269_FIXUP_LENOVO_DOCK),
10158         SND_PCI_QUIRK(0x17aa, 0x2208, "Thinkpad T431s", ALC269_FIXUP_LENOVO_DOCK),
10159         SND_PCI_QUIRK(0x17aa, 0x220c, "Thinkpad T440s", ALC292_FIXUP_TPT440),
10160         SND_PCI_QUIRK(0x17aa, 0x220e, "Thinkpad T440p", ALC292_FIXUP_TPT440_DOCK),
10161         SND_PCI_QUIRK(0x17aa, 0x2210, "Thinkpad T540p", ALC292_FIXUP_TPT440_DOCK),
10162         SND_PCI_QUIRK(0x17aa, 0x2211, "Thinkpad W541", ALC292_FIXUP_TPT440_DOCK),
10163         SND_PCI_QUIRK(0x17aa, 0x2212, "Thinkpad T440", ALC292_FIXUP_TPT440_DOCK),
10164         SND_PCI_QUIRK(0x17aa, 0x2214, "Thinkpad X240", ALC292_FIXUP_TPT440_DOCK),
10165         SND_PCI_QUIRK(0x17aa, 0x2215, "Thinkpad", ALC269_FIXUP_LIMIT_INT_MIC_BOOST),
10166         SND_PCI_QUIRK(0x17aa, 0x2218, "Thinkpad X1 Carbon 2nd", ALC292_FIXUP_TPT440_DOCK),
10167         SND_PCI_QUIRK(0x17aa, 0x2223, "ThinkPad T550", ALC292_FIXUP_TPT440_DOCK),
10168         SND_PCI_QUIRK(0x17aa, 0x2226, "ThinkPad X250", ALC292_FIXUP_TPT440_DOCK),
10169         SND_PCI_QUIRK(0x17aa, 0x222d, "Thinkpad", ALC298_FIXUP_TPT470_DOCK),
10170         SND_PCI_QUIRK(0x17aa, 0x222e, "Thinkpad", ALC298_FIXUP_TPT470_DOCK),
10171         SND_PCI_QUIRK(0x17aa, 0x2231, "Thinkpad T560", ALC292_FIXUP_TPT460),
10172         SND_PCI_QUIRK(0x17aa, 0x2233, "Thinkpad", ALC292_FIXUP_TPT460),
10173         SND_PCI_QUIRK(0x17aa, 0x2245, "Thinkpad T470", ALC298_FIXUP_TPT470_DOCK),
10174         SND_PCI_QUIRK(0x17aa, 0x2246, "Thinkpad", ALC298_FIXUP_TPT470_DOCK),
10175         SND_PCI_QUIRK(0x17aa, 0x2247, "Thinkpad", ALC298_FIXUP_TPT470_DOCK),
10176         SND_PCI_QUIRK(0x17aa, 0x2249, "Thinkpad", ALC292_FIXUP_TPT460),
10177         SND_PCI_QUIRK(0x17aa, 0x224b, "Thinkpad", ALC298_FIXUP_TPT470_DOCK),
10178         SND_PCI_QUIRK(0x17aa, 0x224c, "Thinkpad", ALC298_FIXUP_TPT470_DOCK),
10179         SND_PCI_QUIRK(0x17aa, 0x224d, "Thinkpad", ALC298_FIXUP_TPT470_DOCK),
10180         SND_PCI_QUIRK(0x17aa, 0x225d, "Thinkpad T480", ALC269_FIXUP_LIMIT_INT_MIC_BOOST),
10181         SND_PCI_QUIRK(0x17aa, 0x2292, "Thinkpad X1 Carbon 7th", ALC285_FIXUP_THINKPAD_HEADSET_JACK),
10182         SND_PCI_QUIRK(0x17aa, 0x22be, "Thinkpad X1 Carbon 8th", ALC285_FIXUP_THINKPAD_HEADSET_JACK),
10183         SND_PCI_QUIRK(0x17aa, 0x22c1, "Thinkpad P1 Gen 3", ALC285_FIXUP_THINKPAD_NO_BASS_SPK_HEADSET_JACK),
10184         SND_PCI_QUIRK(0x17aa, 0x22c2, "Thinkpad X1 Extreme Gen 3", ALC285_FIXUP_THINKPAD_NO_BASS_SPK_HEADSET_JACK),
10185         SND_PCI_QUIRK(0x17aa, 0x22f1, "Thinkpad", ALC287_FIXUP_MG_RTKC_CSAMP_CS35L41_I2C_THINKPAD),
10186         SND_PCI_QUIRK(0x17aa, 0x22f2, "Thinkpad", ALC287_FIXUP_MG_RTKC_CSAMP_CS35L41_I2C_THINKPAD),
10187         SND_PCI_QUIRK(0x17aa, 0x22f3, "Thinkpad", ALC287_FIXUP_MG_RTKC_CSAMP_CS35L41_I2C_THINKPAD),
10188         SND_PCI_QUIRK(0x17aa, 0x2316, "Thinkpad P1 Gen 6", ALC287_FIXUP_MG_RTKC_CSAMP_CS35L41_I2C_THINKPAD),
10189         SND_PCI_QUIRK(0x17aa, 0x2317, "Thinkpad P1 Gen 6", ALC287_FIXUP_MG_RTKC_CSAMP_CS35L41_I2C_THINKPAD),
10190         SND_PCI_QUIRK(0x17aa, 0x2318, "Thinkpad Z13 Gen2", ALC287_FIXUP_MG_RTKC_CSAMP_CS35L41_I2C_THINKPAD),
10191         SND_PCI_QUIRK(0x17aa, 0x2319, "Thinkpad Z16 Gen2", ALC287_FIXUP_MG_RTKC_CSAMP_CS35L41_I2C_THINKPAD),
10192         SND_PCI_QUIRK(0x17aa, 0x231a, "Thinkpad Z16 Gen2", ALC287_FIXUP_MG_RTKC_CSAMP_CS35L41_I2C_THINKPAD),
10193         SND_PCI_QUIRK(0x17aa, 0x30bb, "ThinkCentre AIO", ALC233_FIXUP_LENOVO_LINE2_MIC_HOTKEY),
10194         SND_PCI_QUIRK(0x17aa, 0x30e2, "ThinkCentre AIO", ALC233_FIXUP_LENOVO_LINE2_MIC_HOTKEY),
10195         SND_PCI_QUIRK(0x17aa, 0x310c, "ThinkCentre Station", ALC294_FIXUP_LENOVO_MIC_LOCATION),
10196         SND_PCI_QUIRK(0x17aa, 0x3111, "ThinkCentre Station", ALC294_FIXUP_LENOVO_MIC_LOCATION),
10197         SND_PCI_QUIRK(0x17aa, 0x312a, "ThinkCentre Station", ALC294_FIXUP_LENOVO_MIC_LOCATION),
10198         SND_PCI_QUIRK(0x17aa, 0x312f, "ThinkCentre Station", ALC294_FIXUP_LENOVO_MIC_LOCATION),
10199         SND_PCI_QUIRK(0x17aa, 0x313c, "ThinkCentre Station", ALC294_FIXUP_LENOVO_MIC_LOCATION),
10200         SND_PCI_QUIRK(0x17aa, 0x3151, "ThinkCentre Station", ALC283_FIXUP_HEADSET_MIC),
10201         SND_PCI_QUIRK(0x17aa, 0x3176, "ThinkCentre Station", ALC283_FIXUP_HEADSET_MIC),
10202         SND_PCI_QUIRK(0x17aa, 0x3178, "ThinkCentre Station", ALC283_FIXUP_HEADSET_MIC),
10203         SND_PCI_QUIRK(0x17aa, 0x31af, "ThinkCentre Station", ALC623_FIXUP_LENOVO_THINKSTATION_P340),
10204         SND_PCI_QUIRK(0x17aa, 0x3801, "Lenovo Yoga9 14IAP7", ALC287_FIXUP_YOGA9_14IAP7_BASS_SPK_PIN),
10205         SND_PCI_QUIRK(0x17aa, 0x3802, "Lenovo Yoga DuetITL 2021", ALC287_FIXUP_YOGA7_14ITL_SPEAKERS),
10206         SND_PCI_QUIRK(0x17aa, 0x3813, "Legion 7i 15IMHG05", ALC287_FIXUP_LEGION_15IMHG05_SPEAKERS),
10207         SND_PCI_QUIRK(0x17aa, 0x3818, "Lenovo C940 / Yoga Duet 7", ALC298_FIXUP_LENOVO_C940_DUET7),
10208         SND_PCI_QUIRK(0x17aa, 0x3819, "Lenovo 13s Gen2 ITL", ALC287_FIXUP_13S_GEN2_SPEAKERS),
10209         SND_PCI_QUIRK(0x17aa, 0x3820, "Yoga Duet 7 13ITL6", ALC287_FIXUP_YOGA7_14ITL_SPEAKERS),
10210         SND_PCI_QUIRK(0x17aa, 0x3824, "Legion Y9000X 2020", ALC285_FIXUP_LEGION_Y9000X_SPEAKERS),
10211         SND_PCI_QUIRK(0x17aa, 0x3827, "Ideapad S740", ALC285_FIXUP_IDEAPAD_S740_COEF),
10212         SND_PCI_QUIRK(0x17aa, 0x3834, "Lenovo IdeaPad Slim 9i 14ITL5", ALC287_FIXUP_YOGA7_14ITL_SPEAKERS),
10213         SND_PCI_QUIRK(0x17aa, 0x383d, "Legion Y9000X 2019", ALC285_FIXUP_LEGION_Y9000X_SPEAKERS),
10214         SND_PCI_QUIRK(0x17aa, 0x3843, "Yoga 9i", ALC287_FIXUP_IDEAPAD_BASS_SPK_AMP),
10215         SND_PCI_QUIRK(0x17aa, 0x3847, "Legion 7 16ACHG6", ALC287_FIXUP_LEGION_16ACHG6),
10216         SND_PCI_QUIRK(0x17aa, 0x384a, "Lenovo Yoga 7 15ITL5", ALC287_FIXUP_YOGA7_14ITL_SPEAKERS),
10217         SND_PCI_QUIRK(0x17aa, 0x3852, "Lenovo Yoga 7 14ITL5", ALC287_FIXUP_YOGA7_14ITL_SPEAKERS),
10218         SND_PCI_QUIRK(0x17aa, 0x3853, "Lenovo Yoga 7 15ITL5", ALC287_FIXUP_YOGA7_14ITL_SPEAKERS),
10219         SND_PCI_QUIRK(0x17aa, 0x3855, "Legion 7 16ITHG6", ALC287_FIXUP_LEGION_16ITHG6),
10220         SND_PCI_QUIRK(0x17aa, 0x3869, "Lenovo Yoga7 14IAL7", ALC287_FIXUP_YOGA9_14IAP7_BASS_SPK_PIN),
10221         SND_PCI_QUIRK(0x17aa, 0x387d, "Yoga S780-16 pro Quad AAC", ALC287_FIXUP_TAS2781_I2C),
10222         SND_PCI_QUIRK(0x17aa, 0x387e, "Yoga S780-16 pro Quad YC", ALC287_FIXUP_TAS2781_I2C),
10223         SND_PCI_QUIRK(0x17aa, 0x3881, "YB9 dual power mode2 YC", ALC287_FIXUP_TAS2781_I2C),
10224         SND_PCI_QUIRK(0x17aa, 0x3882, "Lenovo Yoga Pro 7 14APH8", ALC287_FIXUP_YOGA9_14IAP7_BASS_SPK_PIN),
10225         SND_PCI_QUIRK(0x17aa, 0x3884, "Y780 YG DUAL", ALC287_FIXUP_TAS2781_I2C),
10226         SND_PCI_QUIRK(0x17aa, 0x3886, "Y780 VECO DUAL", ALC287_FIXUP_TAS2781_I2C),
10227         SND_PCI_QUIRK(0x17aa, 0x38a7, "Y780P AMD YG dual", ALC287_FIXUP_TAS2781_I2C),
10228         SND_PCI_QUIRK(0x17aa, 0x38a8, "Y780P AMD VECO dual", ALC287_FIXUP_TAS2781_I2C),
10229         SND_PCI_QUIRK(0x17aa, 0x38ba, "Yoga S780-14.5 Air AMD quad YC", ALC287_FIXUP_TAS2781_I2C),
10230         SND_PCI_QUIRK(0x17aa, 0x38bb, "Yoga S780-14.5 Air AMD quad AAC", ALC287_FIXUP_TAS2781_I2C),
10231         SND_PCI_QUIRK(0x17aa, 0x38be, "Yoga S980-14.5 proX YC Dual", ALC287_FIXUP_TAS2781_I2C),
10232         SND_PCI_QUIRK(0x17aa, 0x38bf, "Yoga S980-14.5 proX LX Dual", ALC287_FIXUP_TAS2781_I2C),
10233         SND_PCI_QUIRK(0x17aa, 0x38c3, "Y980 DUAL", ALC287_FIXUP_TAS2781_I2C),
10234         SND_PCI_QUIRK(0x17aa, 0x38cb, "Y790 YG DUAL", ALC287_FIXUP_TAS2781_I2C),
10235         SND_PCI_QUIRK(0x17aa, 0x38cd, "Y790 VECO DUAL", ALC287_FIXUP_TAS2781_I2C),
10236         SND_PCI_QUIRK(0x17aa, 0x3902, "Lenovo E50-80", ALC269_FIXUP_DMIC_THINKPAD_ACPI),
10237         SND_PCI_QUIRK(0x17aa, 0x3977, "IdeaPad S210", ALC283_FIXUP_INT_MIC),
10238         SND_PCI_QUIRK(0x17aa, 0x3978, "Lenovo B50-70", ALC269_FIXUP_DMIC_THINKPAD_ACPI),
10239         SND_PCI_QUIRK(0x17aa, 0x3bf8, "Quanta FL1", ALC269_FIXUP_PCM_44K),
10240         SND_PCI_QUIRK(0x17aa, 0x5013, "Thinkpad", ALC269_FIXUP_LIMIT_INT_MIC_BOOST),
10241         SND_PCI_QUIRK(0x17aa, 0x501a, "Thinkpad", ALC283_FIXUP_INT_MIC),
10242         SND_PCI_QUIRK(0x17aa, 0x501e, "Thinkpad L440", ALC292_FIXUP_TPT440_DOCK),
10243         SND_PCI_QUIRK(0x17aa, 0x5026, "Thinkpad", ALC269_FIXUP_LIMIT_INT_MIC_BOOST),
10244         SND_PCI_QUIRK(0x17aa, 0x5034, "Thinkpad T450", ALC292_FIXUP_TPT440_DOCK),
10245         SND_PCI_QUIRK(0x17aa, 0x5036, "Thinkpad T450s", ALC292_FIXUP_TPT440_DOCK),
10246         SND_PCI_QUIRK(0x17aa, 0x503c, "Thinkpad L450", ALC292_FIXUP_TPT440_DOCK),
10247         SND_PCI_QUIRK(0x17aa, 0x504a, "ThinkPad X260", ALC292_FIXUP_TPT440_DOCK),
10248         SND_PCI_QUIRK(0x17aa, 0x504b, "Thinkpad", ALC293_FIXUP_LENOVO_SPK_NOISE),
10249         SND_PCI_QUIRK(0x17aa, 0x5050, "Thinkpad T560p", ALC292_FIXUP_TPT460),
10250         SND_PCI_QUIRK(0x17aa, 0x5051, "Thinkpad L460", ALC292_FIXUP_TPT460),
10251         SND_PCI_QUIRK(0x17aa, 0x5053, "Thinkpad T460", ALC292_FIXUP_TPT460),
10252         SND_PCI_QUIRK(0x17aa, 0x505d, "Thinkpad", ALC298_FIXUP_TPT470_DOCK),
10253         SND_PCI_QUIRK(0x17aa, 0x505f, "Thinkpad", ALC298_FIXUP_TPT470_DOCK),
10254         SND_PCI_QUIRK(0x17aa, 0x5062, "Thinkpad", ALC298_FIXUP_TPT470_DOCK),
10255         SND_PCI_QUIRK(0x17aa, 0x508b, "Thinkpad X12 Gen 1", ALC287_FIXUP_LEGION_15IMHG05_SPEAKERS),
10256         SND_PCI_QUIRK(0x17aa, 0x5109, "Thinkpad", ALC269_FIXUP_LIMIT_INT_MIC_BOOST),
10257         SND_PCI_QUIRK(0x17aa, 0x511e, "Thinkpad", ALC298_FIXUP_TPT470_DOCK),
10258         SND_PCI_QUIRK(0x17aa, 0x511f, "Thinkpad", ALC298_FIXUP_TPT470_DOCK),
10259         SND_PCI_QUIRK(0x17aa, 0x9e54, "LENOVO NB", ALC269_FIXUP_LENOVO_EAPD),
10260         SND_PCI_QUIRK(0x17aa, 0x9e56, "Lenovo ZhaoYang CF4620Z", ALC286_FIXUP_SONY_MIC_NO_PRESENCE),
10261         SND_PCI_QUIRK(0x1849, 0x1233, "ASRock NUC Box 1100", ALC233_FIXUP_NO_AUDIO_JACK),
10262         SND_PCI_QUIRK(0x1849, 0xa233, "Positivo Master C6300", ALC269_FIXUP_HEADSET_MIC),
10263         SND_PCI_QUIRK(0x19e5, 0x3204, "Huawei MACH-WX9", ALC256_FIXUP_HUAWEI_MACH_WX9_PINS),
10264         SND_PCI_QUIRK(0x19e5, 0x320f, "Huawei WRT-WX9 ", ALC256_FIXUP_ASUS_MIC_NO_PRESENCE),
10265         SND_PCI_QUIRK(0x1b35, 0x1235, "CZC B20", ALC269_FIXUP_CZC_B20),
10266         SND_PCI_QUIRK(0x1b35, 0x1236, "CZC TMI", ALC269_FIXUP_CZC_TMI),
10267         SND_PCI_QUIRK(0x1b35, 0x1237, "CZC L101", ALC269_FIXUP_CZC_L101),
10268         SND_PCI_QUIRK(0x1b7d, 0xa831, "Ordissimo EVE2 ", ALC269VB_FIXUP_ORDISSIMO_EVE2), /* Also known as Malata PC-B1303 */
10269         SND_PCI_QUIRK(0x1c06, 0x2013, "Lemote A1802", ALC269_FIXUP_LEMOTE_A1802),
10270         SND_PCI_QUIRK(0x1c06, 0x2015, "Lemote A190X", ALC269_FIXUP_LEMOTE_A190X),
10271         SND_PCI_QUIRK(0x1c6c, 0x1251, "Positivo N14KP6-TG", ALC288_FIXUP_DELL1_MIC_NO_PRESENCE),
10272         SND_PCI_QUIRK(0x1d05, 0x1132, "TongFang PHxTxX1", ALC256_FIXUP_SET_COEF_DEFAULTS),
10273         SND_PCI_QUIRK(0x1d05, 0x1096, "TongFang GMxMRxx", ALC269_FIXUP_NO_SHUTUP),
10274         SND_PCI_QUIRK(0x1d05, 0x1100, "TongFang GKxNRxx", ALC269_FIXUP_NO_SHUTUP),
10275         SND_PCI_QUIRK(0x1d05, 0x1111, "TongFang GMxZGxx", ALC269_FIXUP_NO_SHUTUP),
10276         SND_PCI_QUIRK(0x1d05, 0x1119, "TongFang GMxZGxx", ALC269_FIXUP_NO_SHUTUP),
10277         SND_PCI_QUIRK(0x1d05, 0x1129, "TongFang GMxZGxx", ALC269_FIXUP_NO_SHUTUP),
10278         SND_PCI_QUIRK(0x1d05, 0x1147, "TongFang GMxTGxx", ALC269_FIXUP_NO_SHUTUP),
10279         SND_PCI_QUIRK(0x1d05, 0x115c, "TongFang GMxTGxx", ALC269_FIXUP_NO_SHUTUP),
10280         SND_PCI_QUIRK(0x1d05, 0x121b, "TongFang GMxAGxx", ALC269_FIXUP_NO_SHUTUP),
10281         SND_PCI_QUIRK(0x1d72, 0x1602, "RedmiBook", ALC255_FIXUP_XIAOMI_HEADSET_MIC),
10282         SND_PCI_QUIRK(0x1d72, 0x1701, "XiaomiNotebook Pro", ALC298_FIXUP_DELL1_MIC_NO_PRESENCE),
10283         SND_PCI_QUIRK(0x1d72, 0x1901, "RedmiBook 14", ALC256_FIXUP_ASUS_HEADSET_MIC),
10284         SND_PCI_QUIRK(0x1d72, 0x1945, "Redmi G", ALC256_FIXUP_ASUS_HEADSET_MIC),
10285         SND_PCI_QUIRK(0x1d72, 0x1947, "RedmiBook Air", ALC255_FIXUP_XIAOMI_HEADSET_MIC),
10286         SND_PCI_QUIRK(0x2782, 0x0232, "CHUWI CoreBook XPro", ALC269VB_FIXUP_CHUWI_COREBOOK_XPRO),
10287         SND_PCI_QUIRK(0x8086, 0x2074, "Intel NUC 8", ALC233_FIXUP_INTEL_NUC8_DMIC),
10288         SND_PCI_QUIRK(0x8086, 0x2080, "Intel NUC 8 Rugged", ALC256_FIXUP_INTEL_NUC8_RUGGED),
10289         SND_PCI_QUIRK(0x8086, 0x2081, "Intel NUC 10", ALC256_FIXUP_INTEL_NUC10),
10290         SND_PCI_QUIRK(0x8086, 0x3038, "Intel NUC 13", ALC295_FIXUP_CHROME_BOOK),
10291         SND_PCI_QUIRK(0xf111, 0x0001, "Framework Laptop", ALC295_FIXUP_FRAMEWORK_LAPTOP_MIC_NO_PRESENCE),
10292         SND_PCI_QUIRK(0xf111, 0x0005, "Framework Laptop", ALC295_FIXUP_FRAMEWORK_LAPTOP_MIC_NO_PRESENCE),
10293         SND_PCI_QUIRK(0xf111, 0x0006, "Framework Laptop", ALC295_FIXUP_FRAMEWORK_LAPTOP_MIC_NO_PRESENCE),
10294
10295 #if 0
10296         /* Below is a quirk table taken from the old code.
10297          * Basically the device should work as is without the fixup table.
10298          * If BIOS doesn't give a proper info, enable the corresponding
10299          * fixup entry.
10300          */
10301         SND_PCI_QUIRK(0x1043, 0x8330, "ASUS Eeepc P703 P900A",
10302                       ALC269_FIXUP_AMIC),
10303         SND_PCI_QUIRK(0x1043, 0x1013, "ASUS N61Da", ALC269_FIXUP_AMIC),
10304         SND_PCI_QUIRK(0x1043, 0x1143, "ASUS B53f", ALC269_FIXUP_AMIC),
10305         SND_PCI_QUIRK(0x1043, 0x1133, "ASUS UJ20ft", ALC269_FIXUP_AMIC),
10306         SND_PCI_QUIRK(0x1043, 0x1183, "ASUS K72DR", ALC269_FIXUP_AMIC),
10307         SND_PCI_QUIRK(0x1043, 0x11b3, "ASUS K52DR", ALC269_FIXUP_AMIC),
10308         SND_PCI_QUIRK(0x1043, 0x11e3, "ASUS U33Jc", ALC269_FIXUP_AMIC),
10309         SND_PCI_QUIRK(0x1043, 0x1273, "ASUS UL80Jt", ALC269_FIXUP_AMIC),
10310         SND_PCI_QUIRK(0x1043, 0x1283, "ASUS U53Jc", ALC269_FIXUP_AMIC),
10311         SND_PCI_QUIRK(0x1043, 0x12b3, "ASUS N82JV", ALC269_FIXUP_AMIC),
10312         SND_PCI_QUIRK(0x1043, 0x12d3, "ASUS N61Jv", ALC269_FIXUP_AMIC),
10313         SND_PCI_QUIRK(0x1043, 0x13a3, "ASUS UL30Vt", ALC269_FIXUP_AMIC),
10314         SND_PCI_QUIRK(0x1043, 0x1373, "ASUS G73JX", ALC269_FIXUP_AMIC),
10315         SND_PCI_QUIRK(0x1043, 0x1383, "ASUS UJ30Jc", ALC269_FIXUP_AMIC),
10316         SND_PCI_QUIRK(0x1043, 0x13d3, "ASUS N61JA", ALC269_FIXUP_AMIC),
10317         SND_PCI_QUIRK(0x1043, 0x1413, "ASUS UL50", ALC269_FIXUP_AMIC),
10318         SND_PCI_QUIRK(0x1043, 0x1443, "ASUS UL30", ALC269_FIXUP_AMIC),
10319         SND_PCI_QUIRK(0x1043, 0x1453, "ASUS M60Jv", ALC269_FIXUP_AMIC),
10320         SND_PCI_QUIRK(0x1043, 0x1483, "ASUS UL80", ALC269_FIXUP_AMIC),
10321         SND_PCI_QUIRK(0x1043, 0x14f3, "ASUS F83Vf", ALC269_FIXUP_AMIC),
10322         SND_PCI_QUIRK(0x1043, 0x14e3, "ASUS UL20", ALC269_FIXUP_AMIC),
10323         SND_PCI_QUIRK(0x1043, 0x1513, "ASUS UX30", ALC269_FIXUP_AMIC),
10324         SND_PCI_QUIRK(0x1043, 0x1593, "ASUS N51Vn", ALC269_FIXUP_AMIC),
10325         SND_PCI_QUIRK(0x1043, 0x15a3, "ASUS N60Jv", ALC269_FIXUP_AMIC),
10326         SND_PCI_QUIRK(0x1043, 0x15b3, "ASUS N60Dp", ALC269_FIXUP_AMIC),
10327         SND_PCI_QUIRK(0x1043, 0x15c3, "ASUS N70De", ALC269_FIXUP_AMIC),
10328         SND_PCI_QUIRK(0x1043, 0x15e3, "ASUS F83T", ALC269_FIXUP_AMIC),
10329         SND_PCI_QUIRK(0x1043, 0x1643, "ASUS M60J", ALC269_FIXUP_AMIC),
10330         SND_PCI_QUIRK(0x1043, 0x1653, "ASUS U50", ALC269_FIXUP_AMIC),
10331         SND_PCI_QUIRK(0x1043, 0x1693, "ASUS F50N", ALC269_FIXUP_AMIC),
10332         SND_PCI_QUIRK(0x1043, 0x16a3, "ASUS F5Q", ALC269_FIXUP_AMIC),
10333         SND_PCI_QUIRK(0x1043, 0x1723, "ASUS P80", ALC269_FIXUP_AMIC),
10334         SND_PCI_QUIRK(0x1043, 0x1743, "ASUS U80", ALC269_FIXUP_AMIC),
10335         SND_PCI_QUIRK(0x1043, 0x1773, "ASUS U20A", ALC269_FIXUP_AMIC),
10336         SND_PCI_QUIRK(0x1043, 0x1883, "ASUS F81Se", ALC269_FIXUP_AMIC),
10337         SND_PCI_QUIRK(0x152d, 0x1778, "Quanta ON1", ALC269_FIXUP_DMIC),
10338         SND_PCI_QUIRK(0x17aa, 0x3be9, "Quanta Wistron", ALC269_FIXUP_AMIC),
10339         SND_PCI_QUIRK(0x17aa, 0x3bf8, "Quanta FL1", ALC269_FIXUP_AMIC),
10340         SND_PCI_QUIRK(0x17ff, 0x059a, "Quanta EL3", ALC269_FIXUP_DMIC),
10341         SND_PCI_QUIRK(0x17ff, 0x059b, "Quanta JR1", ALC269_FIXUP_DMIC),
10342 #endif
10343         {}
10344 };
10345
10346 static const struct snd_pci_quirk alc269_fixup_vendor_tbl[] = {
10347         SND_PCI_QUIRK_VENDOR(0x1025, "Acer Aspire", ALC271_FIXUP_DMIC),
10348         SND_PCI_QUIRK_VENDOR(0x103c, "HP", ALC269_FIXUP_HP_MUTE_LED),
10349         SND_PCI_QUIRK_VENDOR(0x104d, "Sony VAIO", ALC269_FIXUP_SONY_VAIO),
10350         SND_PCI_QUIRK_VENDOR(0x17aa, "Thinkpad", ALC269_FIXUP_THINKPAD_ACPI),
10351         SND_PCI_QUIRK_VENDOR(0x19e5, "Huawei Matebook", ALC255_FIXUP_MIC_MUTE_LED),
10352         {}
10353 };
10354
10355 static const struct hda_model_fixup alc269_fixup_models[] = {
10356         {.id = ALC269_FIXUP_AMIC, .name = "laptop-amic"},
10357         {.id = ALC269_FIXUP_DMIC, .name = "laptop-dmic"},
10358         {.id = ALC269_FIXUP_STEREO_DMIC, .name = "alc269-dmic"},
10359         {.id = ALC271_FIXUP_DMIC, .name = "alc271-dmic"},
10360         {.id = ALC269_FIXUP_INV_DMIC, .name = "inv-dmic"},
10361         {.id = ALC269_FIXUP_HEADSET_MIC, .name = "headset-mic"},
10362         {.id = ALC269_FIXUP_HEADSET_MODE, .name = "headset-mode"},
10363         {.id = ALC269_FIXUP_HEADSET_MODE_NO_HP_MIC, .name = "headset-mode-no-hp-mic"},
10364         {.id = ALC269_FIXUP_LENOVO_DOCK, .name = "lenovo-dock"},
10365         {.id = ALC269_FIXUP_LENOVO_DOCK_LIMIT_BOOST, .name = "lenovo-dock-limit-boost"},
10366         {.id = ALC269_FIXUP_HP_GPIO_LED, .name = "hp-gpio-led"},
10367         {.id = ALC269_FIXUP_HP_DOCK_GPIO_MIC1_LED, .name = "hp-dock-gpio-mic1-led"},
10368         {.id = ALC269_FIXUP_DELL1_MIC_NO_PRESENCE, .name = "dell-headset-multi"},
10369         {.id = ALC269_FIXUP_DELL2_MIC_NO_PRESENCE, .name = "dell-headset-dock"},
10370         {.id = ALC269_FIXUP_DELL3_MIC_NO_PRESENCE, .name = "dell-headset3"},
10371         {.id = ALC269_FIXUP_DELL4_MIC_NO_PRESENCE, .name = "dell-headset4"},
10372         {.id = ALC283_FIXUP_CHROME_BOOK, .name = "alc283-dac-wcaps"},
10373         {.id = ALC283_FIXUP_SENSE_COMBO_JACK, .name = "alc283-sense-combo"},
10374         {.id = ALC292_FIXUP_TPT440_DOCK, .name = "tpt440-dock"},
10375         {.id = ALC292_FIXUP_TPT440, .name = "tpt440"},
10376         {.id = ALC292_FIXUP_TPT460, .name = "tpt460"},
10377         {.id = ALC298_FIXUP_TPT470_DOCK_FIX, .name = "tpt470-dock-fix"},
10378         {.id = ALC298_FIXUP_TPT470_DOCK, .name = "tpt470-dock"},
10379         {.id = ALC233_FIXUP_LENOVO_MULTI_CODECS, .name = "dual-codecs"},
10380         {.id = ALC700_FIXUP_INTEL_REFERENCE, .name = "alc700-ref"},
10381         {.id = ALC269_FIXUP_SONY_VAIO, .name = "vaio"},
10382         {.id = ALC269_FIXUP_DELL_M101Z, .name = "dell-m101z"},
10383         {.id = ALC269_FIXUP_ASUS_G73JW, .name = "asus-g73jw"},
10384         {.id = ALC269_FIXUP_LENOVO_EAPD, .name = "lenovo-eapd"},
10385         {.id = ALC275_FIXUP_SONY_HWEQ, .name = "sony-hweq"},
10386         {.id = ALC269_FIXUP_PCM_44K, .name = "pcm44k"},
10387         {.id = ALC269_FIXUP_LIFEBOOK, .name = "lifebook"},
10388         {.id = ALC269_FIXUP_LIFEBOOK_EXTMIC, .name = "lifebook-extmic"},
10389         {.id = ALC269_FIXUP_LIFEBOOK_HP_PIN, .name = "lifebook-hp-pin"},
10390         {.id = ALC255_FIXUP_LIFEBOOK_U7x7_HEADSET_MIC, .name = "lifebook-u7x7"},
10391         {.id = ALC269VB_FIXUP_AMIC, .name = "alc269vb-amic"},
10392         {.id = ALC269VB_FIXUP_DMIC, .name = "alc269vb-dmic"},
10393         {.id = ALC269_FIXUP_HP_MUTE_LED_MIC1, .name = "hp-mute-led-mic1"},
10394         {.id = ALC269_FIXUP_HP_MUTE_LED_MIC2, .name = "hp-mute-led-mic2"},
10395         {.id = ALC269_FIXUP_HP_MUTE_LED_MIC3, .name = "hp-mute-led-mic3"},
10396         {.id = ALC269_FIXUP_HP_GPIO_MIC1_LED, .name = "hp-gpio-mic1"},
10397         {.id = ALC269_FIXUP_HP_LINE1_MIC1_LED, .name = "hp-line1-mic1"},
10398         {.id = ALC269_FIXUP_NO_SHUTUP, .name = "noshutup"},
10399         {.id = ALC286_FIXUP_SONY_MIC_NO_PRESENCE, .name = "sony-nomic"},
10400         {.id = ALC269_FIXUP_ASPIRE_HEADSET_MIC, .name = "aspire-headset-mic"},
10401         {.id = ALC269_FIXUP_ASUS_X101, .name = "asus-x101"},
10402         {.id = ALC271_FIXUP_HP_GATE_MIC_JACK, .name = "acer-ao7xx"},
10403         {.id = ALC271_FIXUP_HP_GATE_MIC_JACK_E1_572, .name = "acer-aspire-e1"},
10404         {.id = ALC269_FIXUP_ACER_AC700, .name = "acer-ac700"},
10405         {.id = ALC269_FIXUP_LIMIT_INT_MIC_BOOST, .name = "limit-mic-boost"},
10406         {.id = ALC269VB_FIXUP_ASUS_ZENBOOK, .name = "asus-zenbook"},
10407         {.id = ALC269VB_FIXUP_ASUS_ZENBOOK_UX31A, .name = "asus-zenbook-ux31a"},
10408         {.id = ALC269VB_FIXUP_ORDISSIMO_EVE2, .name = "ordissimo"},
10409         {.id = ALC282_FIXUP_ASUS_TX300, .name = "asus-tx300"},
10410         {.id = ALC283_FIXUP_INT_MIC, .name = "alc283-int-mic"},
10411         {.id = ALC290_FIXUP_MONO_SPEAKERS_HSJACK, .name = "mono-speakers"},
10412         {.id = ALC290_FIXUP_SUBWOOFER_HSJACK, .name = "alc290-subwoofer"},
10413         {.id = ALC269_FIXUP_THINKPAD_ACPI, .name = "thinkpad"},
10414         {.id = ALC269_FIXUP_DMIC_THINKPAD_ACPI, .name = "dmic-thinkpad"},
10415         {.id = ALC255_FIXUP_ACER_MIC_NO_PRESENCE, .name = "alc255-acer"},
10416         {.id = ALC255_FIXUP_ASUS_MIC_NO_PRESENCE, .name = "alc255-asus"},
10417         {.id = ALC255_FIXUP_DELL1_MIC_NO_PRESENCE, .name = "alc255-dell1"},
10418         {.id = ALC255_FIXUP_DELL2_MIC_NO_PRESENCE, .name = "alc255-dell2"},
10419         {.id = ALC293_FIXUP_DELL1_MIC_NO_PRESENCE, .name = "alc293-dell1"},
10420         {.id = ALC283_FIXUP_HEADSET_MIC, .name = "alc283-headset"},
10421         {.id = ALC255_FIXUP_MIC_MUTE_LED, .name = "alc255-dell-mute"},
10422         {.id = ALC282_FIXUP_ASPIRE_V5_PINS, .name = "aspire-v5"},
10423         {.id = ALC269VB_FIXUP_ASPIRE_E1_COEF, .name = "aspire-e1-coef"},
10424         {.id = ALC280_FIXUP_HP_GPIO4, .name = "hp-gpio4"},
10425         {.id = ALC286_FIXUP_HP_GPIO_LED, .name = "hp-gpio-led"},
10426         {.id = ALC280_FIXUP_HP_GPIO2_MIC_HOTKEY, .name = "hp-gpio2-hotkey"},
10427         {.id = ALC280_FIXUP_HP_DOCK_PINS, .name = "hp-dock-pins"},
10428         {.id = ALC269_FIXUP_HP_DOCK_GPIO_MIC1_LED, .name = "hp-dock-gpio-mic"},
10429         {.id = ALC280_FIXUP_HP_9480M, .name = "hp-9480m"},
10430         {.id = ALC288_FIXUP_DELL_HEADSET_MODE, .name = "alc288-dell-headset"},
10431         {.id = ALC288_FIXUP_DELL1_MIC_NO_PRESENCE, .name = "alc288-dell1"},
10432         {.id = ALC288_FIXUP_DELL_XPS_13, .name = "alc288-dell-xps13"},
10433         {.id = ALC292_FIXUP_DELL_E7X, .name = "dell-e7x"},
10434         {.id = ALC293_FIXUP_DISABLE_AAMIX_MULTIJACK, .name = "alc293-dell"},
10435         {.id = ALC298_FIXUP_DELL1_MIC_NO_PRESENCE, .name = "alc298-dell1"},
10436         {.id = ALC298_FIXUP_DELL_AIO_MIC_NO_PRESENCE, .name = "alc298-dell-aio"},
10437         {.id = ALC275_FIXUP_DELL_XPS, .name = "alc275-dell-xps"},
10438         {.id = ALC293_FIXUP_LENOVO_SPK_NOISE, .name = "lenovo-spk-noise"},
10439         {.id = ALC233_FIXUP_LENOVO_LINE2_MIC_HOTKEY, .name = "lenovo-hotkey"},
10440         {.id = ALC255_FIXUP_DELL_SPK_NOISE, .name = "dell-spk-noise"},
10441         {.id = ALC225_FIXUP_DELL1_MIC_NO_PRESENCE, .name = "alc225-dell1"},
10442         {.id = ALC295_FIXUP_DISABLE_DAC3, .name = "alc295-disable-dac3"},
10443         {.id = ALC285_FIXUP_SPEAKER2_TO_DAC1, .name = "alc285-speaker2-to-dac1"},
10444         {.id = ALC280_FIXUP_HP_HEADSET_MIC, .name = "alc280-hp-headset"},
10445         {.id = ALC221_FIXUP_HP_FRONT_MIC, .name = "alc221-hp-mic"},
10446         {.id = ALC298_FIXUP_SPK_VOLUME, .name = "alc298-spk-volume"},
10447         {.id = ALC256_FIXUP_DELL_INSPIRON_7559_SUBWOOFER, .name = "dell-inspiron-7559"},
10448         {.id = ALC269_FIXUP_ATIV_BOOK_8, .name = "ativ-book"},
10449         {.id = ALC221_FIXUP_HP_MIC_NO_PRESENCE, .name = "alc221-hp-mic"},
10450         {.id = ALC256_FIXUP_ASUS_HEADSET_MODE, .name = "alc256-asus-headset"},
10451         {.id = ALC256_FIXUP_ASUS_MIC, .name = "alc256-asus-mic"},
10452         {.id = ALC256_FIXUP_ASUS_AIO_GPIO2, .name = "alc256-asus-aio"},
10453         {.id = ALC233_FIXUP_ASUS_MIC_NO_PRESENCE, .name = "alc233-asus"},
10454         {.id = ALC233_FIXUP_EAPD_COEF_AND_MIC_NO_PRESENCE, .name = "alc233-eapd"},
10455         {.id = ALC294_FIXUP_LENOVO_MIC_LOCATION, .name = "alc294-lenovo-mic"},
10456         {.id = ALC225_FIXUP_DELL_WYSE_MIC_NO_PRESENCE, .name = "alc225-wyse"},
10457         {.id = ALC274_FIXUP_DELL_AIO_LINEOUT_VERB, .name = "alc274-dell-aio"},
10458         {.id = ALC255_FIXUP_DUMMY_LINEOUT_VERB, .name = "alc255-dummy-lineout"},
10459         {.id = ALC255_FIXUP_DELL_HEADSET_MIC, .name = "alc255-dell-headset"},
10460         {.id = ALC295_FIXUP_HP_X360, .name = "alc295-hp-x360"},
10461         {.id = ALC225_FIXUP_HEADSET_JACK, .name = "alc-headset-jack"},
10462         {.id = ALC295_FIXUP_CHROME_BOOK, .name = "alc-chrome-book"},
10463         {.id = ALC299_FIXUP_PREDATOR_SPK, .name = "predator-spk"},
10464         {.id = ALC298_FIXUP_HUAWEI_MBX_STEREO, .name = "huawei-mbx-stereo"},
10465         {.id = ALC256_FIXUP_MEDION_HEADSET_NO_PRESENCE, .name = "alc256-medion-headset"},
10466         {.id = ALC298_FIXUP_SAMSUNG_AMP, .name = "alc298-samsung-amp"},
10467         {.id = ALC256_FIXUP_SAMSUNG_HEADPHONE_VERY_QUIET, .name = "alc256-samsung-headphone"},
10468         {.id = ALC255_FIXUP_XIAOMI_HEADSET_MIC, .name = "alc255-xiaomi-headset"},
10469         {.id = ALC274_FIXUP_HP_MIC, .name = "alc274-hp-mic-detect"},
10470         {.id = ALC245_FIXUP_HP_X360_AMP, .name = "alc245-hp-x360-amp"},
10471         {.id = ALC295_FIXUP_HP_OMEN, .name = "alc295-hp-omen"},
10472         {.id = ALC285_FIXUP_HP_SPECTRE_X360, .name = "alc285-hp-spectre-x360"},
10473         {.id = ALC285_FIXUP_HP_SPECTRE_X360_EB1, .name = "alc285-hp-spectre-x360-eb1"},
10474         {.id = ALC287_FIXUP_IDEAPAD_BASS_SPK_AMP, .name = "alc287-ideapad-bass-spk-amp"},
10475         {.id = ALC287_FIXUP_YOGA9_14IAP7_BASS_SPK_PIN, .name = "alc287-yoga9-bass-spk-pin"},
10476         {.id = ALC623_FIXUP_LENOVO_THINKSTATION_P340, .name = "alc623-lenovo-thinkstation-p340"},
10477         {.id = ALC255_FIXUP_ACER_HEADPHONE_AND_MIC, .name = "alc255-acer-headphone-and-mic"},
10478         {.id = ALC285_FIXUP_HP_GPIO_AMP_INIT, .name = "alc285-hp-amp-init"},
10479         {}
10480 };
10481 #define ALC225_STANDARD_PINS \
10482         {0x21, 0x04211020}
10483
10484 #define ALC256_STANDARD_PINS \
10485         {0x12, 0x90a60140}, \
10486         {0x14, 0x90170110}, \
10487         {0x21, 0x02211020}
10488
10489 #define ALC282_STANDARD_PINS \
10490         {0x14, 0x90170110}
10491
10492 #define ALC290_STANDARD_PINS \
10493         {0x12, 0x99a30130}
10494
10495 #define ALC292_STANDARD_PINS \
10496         {0x14, 0x90170110}, \
10497         {0x15, 0x0221401f}
10498
10499 #define ALC295_STANDARD_PINS \
10500         {0x12, 0xb7a60130}, \
10501         {0x14, 0x90170110}, \
10502         {0x21, 0x04211020}
10503
10504 #define ALC298_STANDARD_PINS \
10505         {0x12, 0x90a60130}, \
10506         {0x21, 0x03211020}
10507
10508 static const struct snd_hda_pin_quirk alc269_pin_fixup_tbl[] = {
10509         SND_HDA_PIN_QUIRK(0x10ec0221, 0x103c, "HP Workstation", ALC221_FIXUP_HP_HEADSET_MIC,
10510                 {0x14, 0x01014020},
10511                 {0x17, 0x90170110},
10512                 {0x18, 0x02a11030},
10513                 {0x19, 0x0181303F},
10514                 {0x21, 0x0221102f}),
10515         SND_HDA_PIN_QUIRK(0x10ec0255, 0x1025, "Acer", ALC255_FIXUP_ACER_MIC_NO_PRESENCE,
10516                 {0x12, 0x90a601c0},
10517                 {0x14, 0x90171120},
10518                 {0x21, 0x02211030}),
10519         SND_HDA_PIN_QUIRK(0x10ec0255, 0x1043, "ASUS", ALC255_FIXUP_ASUS_MIC_NO_PRESENCE,
10520                 {0x14, 0x90170110},
10521                 {0x1b, 0x90a70130},
10522                 {0x21, 0x03211020}),
10523         SND_HDA_PIN_QUIRK(0x10ec0255, 0x1043, "ASUS", ALC255_FIXUP_ASUS_MIC_NO_PRESENCE,
10524                 {0x1a, 0x90a70130},
10525                 {0x1b, 0x90170110},
10526                 {0x21, 0x03211020}),
10527         SND_HDA_PIN_QUIRK(0x10ec0225, 0x1028, "Dell", ALC225_FIXUP_DELL1_MIC_NO_PRESENCE,
10528                 ALC225_STANDARD_PINS,
10529                 {0x12, 0xb7a60130},
10530                 {0x14, 0x901701a0}),
10531         SND_HDA_PIN_QUIRK(0x10ec0225, 0x1028, "Dell", ALC225_FIXUP_DELL1_MIC_NO_PRESENCE,
10532                 ALC225_STANDARD_PINS,
10533                 {0x12, 0xb7a60130},
10534                 {0x14, 0x901701b0}),
10535         SND_HDA_PIN_QUIRK(0x10ec0225, 0x1028, "Dell", ALC225_FIXUP_DELL1_MIC_NO_PRESENCE,
10536                 ALC225_STANDARD_PINS,
10537                 {0x12, 0xb7a60150},
10538                 {0x14, 0x901701a0}),
10539         SND_HDA_PIN_QUIRK(0x10ec0225, 0x1028, "Dell", ALC225_FIXUP_DELL1_MIC_NO_PRESENCE,
10540                 ALC225_STANDARD_PINS,
10541                 {0x12, 0xb7a60150},
10542                 {0x14, 0x901701b0}),
10543         SND_HDA_PIN_QUIRK(0x10ec0225, 0x1028, "Dell", ALC225_FIXUP_DELL1_MIC_NO_PRESENCE,
10544                 ALC225_STANDARD_PINS,
10545                 {0x12, 0xb7a60130},
10546                 {0x1b, 0x90170110}),
10547         SND_HDA_PIN_QUIRK(0x10ec0233, 0x8086, "Intel NUC Skull Canyon", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE,
10548                 {0x1b, 0x01111010},
10549                 {0x1e, 0x01451130},
10550                 {0x21, 0x02211020}),
10551         SND_HDA_PIN_QUIRK(0x10ec0235, 0x17aa, "Lenovo", ALC233_FIXUP_LENOVO_LINE2_MIC_HOTKEY,
10552                 {0x12, 0x90a60140},
10553                 {0x14, 0x90170110},
10554                 {0x19, 0x02a11030},
10555                 {0x21, 0x02211020}),
10556         SND_HDA_PIN_QUIRK(0x10ec0235, 0x17aa, "Lenovo", ALC294_FIXUP_LENOVO_MIC_LOCATION,
10557                 {0x14, 0x90170110},
10558                 {0x19, 0x02a11030},
10559                 {0x1a, 0x02a11040},
10560                 {0x1b, 0x01014020},
10561                 {0x21, 0x0221101f}),
10562         SND_HDA_PIN_QUIRK(0x10ec0235, 0x17aa, "Lenovo", ALC294_FIXUP_LENOVO_MIC_LOCATION,
10563                 {0x14, 0x90170110},
10564                 {0x19, 0x02a11030},
10565                 {0x1a, 0x02a11040},
10566                 {0x1b, 0x01011020},
10567                 {0x21, 0x0221101f}),
10568         SND_HDA_PIN_QUIRK(0x10ec0235, 0x17aa, "Lenovo", ALC294_FIXUP_LENOVO_MIC_LOCATION,
10569                 {0x14, 0x90170110},
10570                 {0x19, 0x02a11020},
10571                 {0x1a, 0x02a11030},
10572                 {0x21, 0x0221101f}),
10573         SND_HDA_PIN_QUIRK(0x10ec0236, 0x1028, "Dell", ALC236_FIXUP_DELL_AIO_HEADSET_MIC,
10574                 {0x21, 0x02211010}),
10575         SND_HDA_PIN_QUIRK(0x10ec0236, 0x103c, "HP", ALC256_FIXUP_HP_HEADSET_MIC,
10576                 {0x14, 0x90170110},
10577                 {0x19, 0x02a11020},
10578                 {0x21, 0x02211030}),
10579         SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL2_MIC_NO_PRESENCE,
10580                 {0x14, 0x90170110},
10581                 {0x21, 0x02211020}),
10582         SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
10583                 {0x14, 0x90170130},
10584                 {0x21, 0x02211040}),
10585         SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
10586                 {0x12, 0x90a60140},
10587                 {0x14, 0x90170110},
10588                 {0x21, 0x02211020}),
10589         SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
10590                 {0x12, 0x90a60160},
10591                 {0x14, 0x90170120},
10592                 {0x21, 0x02211030}),
10593         SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
10594                 {0x14, 0x90170110},
10595                 {0x1b, 0x02011020},
10596                 {0x21, 0x0221101f}),
10597         SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
10598                 {0x14, 0x90170110},
10599                 {0x1b, 0x01011020},
10600                 {0x21, 0x0221101f}),
10601         SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
10602                 {0x14, 0x90170130},
10603                 {0x1b, 0x01014020},
10604                 {0x21, 0x0221103f}),
10605         SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
10606                 {0x14, 0x90170130},
10607                 {0x1b, 0x01011020},
10608                 {0x21, 0x0221103f}),
10609         SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
10610                 {0x14, 0x90170130},
10611                 {0x1b, 0x02011020},
10612                 {0x21, 0x0221103f}),
10613         SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
10614                 {0x14, 0x90170150},
10615                 {0x1b, 0x02011020},
10616                 {0x21, 0x0221105f}),
10617         SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
10618                 {0x14, 0x90170110},
10619                 {0x1b, 0x01014020},
10620                 {0x21, 0x0221101f}),
10621         SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
10622                 {0x12, 0x90a60160},
10623                 {0x14, 0x90170120},
10624                 {0x17, 0x90170140},
10625                 {0x21, 0x0321102f}),
10626         SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
10627                 {0x12, 0x90a60160},
10628                 {0x14, 0x90170130},
10629                 {0x21, 0x02211040}),
10630         SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
10631                 {0x12, 0x90a60160},
10632                 {0x14, 0x90170140},
10633                 {0x21, 0x02211050}),
10634         SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
10635                 {0x12, 0x90a60170},
10636                 {0x14, 0x90170120},
10637                 {0x21, 0x02211030}),
10638         SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
10639                 {0x12, 0x90a60170},
10640                 {0x14, 0x90170130},
10641                 {0x21, 0x02211040}),
10642         SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
10643                 {0x12, 0x90a60170},
10644                 {0x14, 0x90171130},
10645                 {0x21, 0x02211040}),
10646         SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
10647                 {0x12, 0x90a60170},
10648                 {0x14, 0x90170140},
10649                 {0x21, 0x02211050}),
10650         SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell Inspiron 5548", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
10651                 {0x12, 0x90a60180},
10652                 {0x14, 0x90170130},
10653                 {0x21, 0x02211040}),
10654         SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell Inspiron 5565", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
10655                 {0x12, 0x90a60180},
10656                 {0x14, 0x90170120},
10657                 {0x21, 0x02211030}),
10658         SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
10659                 {0x1b, 0x01011020},
10660                 {0x21, 0x02211010}),
10661         SND_HDA_PIN_QUIRK(0x10ec0256, 0x1043, "ASUS", ALC256_FIXUP_ASUS_MIC,
10662                 {0x14, 0x90170110},
10663                 {0x1b, 0x90a70130},
10664                 {0x21, 0x04211020}),
10665         SND_HDA_PIN_QUIRK(0x10ec0256, 0x1043, "ASUS", ALC256_FIXUP_ASUS_MIC,
10666                 {0x14, 0x90170110},
10667                 {0x1b, 0x90a70130},
10668                 {0x21, 0x03211020}),
10669         SND_HDA_PIN_QUIRK(0x10ec0256, 0x1043, "ASUS", ALC256_FIXUP_ASUS_MIC_NO_PRESENCE,
10670                 {0x12, 0x90a60130},
10671                 {0x14, 0x90170110},
10672                 {0x21, 0x03211020}),
10673         SND_HDA_PIN_QUIRK(0x10ec0256, 0x1043, "ASUS", ALC256_FIXUP_ASUS_MIC_NO_PRESENCE,
10674                 {0x12, 0x90a60130},
10675                 {0x14, 0x90170110},
10676                 {0x21, 0x04211020}),
10677         SND_HDA_PIN_QUIRK(0x10ec0256, 0x1043, "ASUS", ALC256_FIXUP_ASUS_MIC_NO_PRESENCE,
10678                 {0x1a, 0x90a70130},
10679                 {0x1b, 0x90170110},
10680                 {0x21, 0x03211020}),
10681        SND_HDA_PIN_QUIRK(0x10ec0256, 0x103c, "HP", ALC256_FIXUP_HP_HEADSET_MIC,
10682                 {0x14, 0x90170110},
10683                 {0x19, 0x02a11020},
10684                 {0x21, 0x0221101f}),
10685        SND_HDA_PIN_QUIRK(0x10ec0274, 0x103c, "HP", ALC274_FIXUP_HP_HEADSET_MIC,
10686                 {0x17, 0x90170110},
10687                 {0x19, 0x03a11030},
10688                 {0x21, 0x03211020}),
10689         SND_HDA_PIN_QUIRK(0x10ec0280, 0x103c, "HP", ALC280_FIXUP_HP_GPIO4,
10690                 {0x12, 0x90a60130},
10691                 {0x14, 0x90170110},
10692                 {0x15, 0x0421101f},
10693                 {0x1a, 0x04a11020}),
10694         SND_HDA_PIN_QUIRK(0x10ec0280, 0x103c, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED,
10695                 {0x12, 0x90a60140},
10696                 {0x14, 0x90170110},
10697                 {0x15, 0x0421101f},
10698                 {0x18, 0x02811030},
10699                 {0x1a, 0x04a1103f},
10700                 {0x1b, 0x02011020}),
10701         SND_HDA_PIN_QUIRK(0x10ec0282, 0x103c, "HP 15 Touchsmart", ALC269_FIXUP_HP_MUTE_LED_MIC1,
10702                 ALC282_STANDARD_PINS,
10703                 {0x12, 0x99a30130},
10704                 {0x19, 0x03a11020},
10705                 {0x21, 0x0321101f}),
10706         SND_HDA_PIN_QUIRK(0x10ec0282, 0x103c, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1,
10707                 ALC282_STANDARD_PINS,
10708                 {0x12, 0x99a30130},
10709                 {0x19, 0x03a11020},
10710                 {0x21, 0x03211040}),
10711         SND_HDA_PIN_QUIRK(0x10ec0282, 0x103c, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1,
10712                 ALC282_STANDARD_PINS,
10713                 {0x12, 0x99a30130},
10714                 {0x19, 0x03a11030},
10715                 {0x21, 0x03211020}),
10716         SND_HDA_PIN_QUIRK(0x10ec0282, 0x103c, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1,
10717                 ALC282_STANDARD_PINS,
10718                 {0x12, 0x99a30130},
10719                 {0x19, 0x04a11020},
10720                 {0x21, 0x0421101f}),
10721         SND_HDA_PIN_QUIRK(0x10ec0282, 0x103c, "HP", ALC269_FIXUP_HP_LINE1_MIC1_LED,
10722                 ALC282_STANDARD_PINS,
10723                 {0x12, 0x90a60140},
10724                 {0x19, 0x04a11030},
10725                 {0x21, 0x04211020}),
10726         SND_HDA_PIN_QUIRK(0x10ec0282, 0x1025, "Acer", ALC282_FIXUP_ACER_DISABLE_LINEOUT,
10727                 ALC282_STANDARD_PINS,
10728                 {0x12, 0x90a609c0},
10729                 {0x18, 0x03a11830},
10730                 {0x19, 0x04a19831},
10731                 {0x1a, 0x0481303f},
10732                 {0x1b, 0x04211020},
10733                 {0x21, 0x0321101f}),
10734         SND_HDA_PIN_QUIRK(0x10ec0282, 0x1025, "Acer", ALC282_FIXUP_ACER_DISABLE_LINEOUT,
10735                 ALC282_STANDARD_PINS,
10736                 {0x12, 0x90a60940},
10737                 {0x18, 0x03a11830},
10738                 {0x19, 0x04a19831},
10739                 {0x1a, 0x0481303f},
10740                 {0x1b, 0x04211020},
10741                 {0x21, 0x0321101f}),
10742         SND_HDA_PIN_QUIRK(0x10ec0283, 0x1028, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE,
10743                 ALC282_STANDARD_PINS,
10744                 {0x12, 0x90a60130},
10745                 {0x21, 0x0321101f}),
10746         SND_HDA_PIN_QUIRK(0x10ec0283, 0x1028, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE,
10747                 {0x12, 0x90a60160},
10748                 {0x14, 0x90170120},
10749                 {0x21, 0x02211030}),
10750         SND_HDA_PIN_QUIRK(0x10ec0283, 0x1028, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE,
10751                 ALC282_STANDARD_PINS,
10752                 {0x12, 0x90a60130},
10753                 {0x19, 0x03a11020},
10754                 {0x21, 0x0321101f}),
10755         SND_HDA_PIN_QUIRK(0x10ec0285, 0x17aa, "Lenovo", ALC285_FIXUP_LENOVO_PC_BEEP_IN_NOISE,
10756                 {0x12, 0x90a60130},
10757                 {0x14, 0x90170110},
10758                 {0x19, 0x04a11040},
10759                 {0x21, 0x04211020}),
10760         SND_HDA_PIN_QUIRK(0x10ec0285, 0x17aa, "Lenovo", ALC285_FIXUP_LENOVO_PC_BEEP_IN_NOISE,
10761                 {0x14, 0x90170110},
10762                 {0x19, 0x04a11040},
10763                 {0x1d, 0x40600001},
10764                 {0x21, 0x04211020}),
10765         SND_HDA_PIN_QUIRK(0x10ec0285, 0x17aa, "Lenovo", ALC285_FIXUP_THINKPAD_NO_BASS_SPK_HEADSET_JACK,
10766                 {0x14, 0x90170110},
10767                 {0x19, 0x04a11040},
10768                 {0x21, 0x04211020}),
10769         SND_HDA_PIN_QUIRK(0x10ec0287, 0x17aa, "Lenovo", ALC285_FIXUP_THINKPAD_HEADSET_JACK,
10770                 {0x14, 0x90170110},
10771                 {0x17, 0x90170111},
10772                 {0x19, 0x03a11030},
10773                 {0x21, 0x03211020}),
10774         SND_HDA_PIN_QUIRK(0x10ec0287, 0x17aa, "Lenovo", ALC287_FIXUP_THINKPAD_I2S_SPK,
10775                 {0x17, 0x90170110},
10776                 {0x19, 0x03a11030},
10777                 {0x21, 0x03211020}),
10778         SND_HDA_PIN_QUIRK(0x10ec0287, 0x17aa, "Lenovo", ALC287_FIXUP_THINKPAD_I2S_SPK,
10779                 {0x17, 0x90170110}, /* 0x231f with RTK I2S AMP */
10780                 {0x19, 0x04a11040},
10781                 {0x21, 0x04211020}),
10782         SND_HDA_PIN_QUIRK(0x10ec0286, 0x1025, "Acer", ALC286_FIXUP_ACER_AIO_MIC_NO_PRESENCE,
10783                 {0x12, 0x90a60130},
10784                 {0x17, 0x90170110},
10785                 {0x21, 0x02211020}),
10786         SND_HDA_PIN_QUIRK(0x10ec0288, 0x1028, "Dell", ALC288_FIXUP_DELL1_MIC_NO_PRESENCE,
10787                 {0x12, 0x90a60120},
10788                 {0x14, 0x90170110},
10789                 {0x21, 0x0321101f}),
10790         SND_HDA_PIN_QUIRK(0x10ec0290, 0x103c, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1,
10791                 ALC290_STANDARD_PINS,
10792                 {0x15, 0x04211040},
10793                 {0x18, 0x90170112},
10794                 {0x1a, 0x04a11020}),
10795         SND_HDA_PIN_QUIRK(0x10ec0290, 0x103c, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1,
10796                 ALC290_STANDARD_PINS,
10797                 {0x15, 0x04211040},
10798                 {0x18, 0x90170110},
10799                 {0x1a, 0x04a11020}),
10800         SND_HDA_PIN_QUIRK(0x10ec0290, 0x103c, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1,
10801                 ALC290_STANDARD_PINS,
10802                 {0x15, 0x0421101f},
10803                 {0x1a, 0x04a11020}),
10804         SND_HDA_PIN_QUIRK(0x10ec0290, 0x103c, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1,
10805                 ALC290_STANDARD_PINS,
10806                 {0x15, 0x04211020},
10807                 {0x1a, 0x04a11040}),
10808         SND_HDA_PIN_QUIRK(0x10ec0290, 0x103c, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1,
10809                 ALC290_STANDARD_PINS,
10810                 {0x14, 0x90170110},
10811                 {0x15, 0x04211020},
10812                 {0x1a, 0x04a11040}),
10813         SND_HDA_PIN_QUIRK(0x10ec0290, 0x103c, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1,
10814                 ALC290_STANDARD_PINS,
10815                 {0x14, 0x90170110},
10816                 {0x15, 0x04211020},
10817                 {0x1a, 0x04a11020}),
10818         SND_HDA_PIN_QUIRK(0x10ec0290, 0x103c, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1,
10819                 ALC290_STANDARD_PINS,
10820                 {0x14, 0x90170110},
10821                 {0x15, 0x0421101f},
10822                 {0x1a, 0x04a11020}),
10823         SND_HDA_PIN_QUIRK(0x10ec0292, 0x1028, "Dell", ALC269_FIXUP_DELL2_MIC_NO_PRESENCE,
10824                 ALC292_STANDARD_PINS,
10825                 {0x12, 0x90a60140},
10826                 {0x16, 0x01014020},
10827                 {0x19, 0x01a19030}),
10828         SND_HDA_PIN_QUIRK(0x10ec0292, 0x1028, "Dell", ALC269_FIXUP_DELL2_MIC_NO_PRESENCE,
10829                 ALC292_STANDARD_PINS,
10830                 {0x12, 0x90a60140},
10831                 {0x16, 0x01014020},
10832                 {0x18, 0x02a19031},
10833                 {0x19, 0x01a1903e}),
10834         SND_HDA_PIN_QUIRK(0x10ec0292, 0x1028, "Dell", ALC269_FIXUP_DELL3_MIC_NO_PRESENCE,
10835                 ALC292_STANDARD_PINS,
10836                 {0x12, 0x90a60140}),
10837         SND_HDA_PIN_QUIRK(0x10ec0293, 0x1028, "Dell", ALC293_FIXUP_DELL1_MIC_NO_PRESENCE,
10838                 ALC292_STANDARD_PINS,
10839                 {0x13, 0x90a60140},
10840                 {0x16, 0x21014020},
10841                 {0x19, 0x21a19030}),
10842         SND_HDA_PIN_QUIRK(0x10ec0293, 0x1028, "Dell", ALC293_FIXUP_DELL1_MIC_NO_PRESENCE,
10843                 ALC292_STANDARD_PINS,
10844                 {0x13, 0x90a60140}),
10845         SND_HDA_PIN_QUIRK(0x10ec0294, 0x1043, "ASUS", ALC294_FIXUP_ASUS_HPE,
10846                 {0x17, 0x90170110},
10847                 {0x21, 0x04211020}),
10848         SND_HDA_PIN_QUIRK(0x10ec0294, 0x1043, "ASUS", ALC294_FIXUP_ASUS_MIC,
10849                 {0x14, 0x90170110},
10850                 {0x1b, 0x90a70130},
10851                 {0x21, 0x04211020}),
10852         SND_HDA_PIN_QUIRK(0x10ec0294, 0x1043, "ASUS", ALC294_FIXUP_ASUS_SPK,
10853                 {0x12, 0x90a60130},
10854                 {0x17, 0x90170110},
10855                 {0x21, 0x03211020}),
10856         SND_HDA_PIN_QUIRK(0x10ec0294, 0x1043, "ASUS", ALC294_FIXUP_ASUS_SPK,
10857                 {0x12, 0x90a60130},
10858                 {0x17, 0x90170110},
10859                 {0x21, 0x04211020}),
10860         SND_HDA_PIN_QUIRK(0x10ec0295, 0x1043, "ASUS", ALC294_FIXUP_ASUS_SPK,
10861                 {0x12, 0x90a60130},
10862                 {0x17, 0x90170110},
10863                 {0x21, 0x03211020}),
10864         SND_HDA_PIN_QUIRK(0x10ec0295, 0x1043, "ASUS", ALC295_FIXUP_ASUS_MIC_NO_PRESENCE,
10865                 {0x12, 0x90a60120},
10866                 {0x17, 0x90170110},
10867                 {0x21, 0x04211030}),
10868         SND_HDA_PIN_QUIRK(0x10ec0295, 0x1043, "ASUS", ALC295_FIXUP_ASUS_MIC_NO_PRESENCE,
10869                 {0x12, 0x90a60130},
10870                 {0x17, 0x90170110},
10871                 {0x21, 0x03211020}),
10872         SND_HDA_PIN_QUIRK(0x10ec0295, 0x1043, "ASUS", ALC295_FIXUP_ASUS_MIC_NO_PRESENCE,
10873                 {0x12, 0x90a60130},
10874                 {0x17, 0x90170110},
10875                 {0x21, 0x03211020}),
10876         SND_HDA_PIN_QUIRK(0x10ec0298, 0x1028, "Dell", ALC298_FIXUP_DELL1_MIC_NO_PRESENCE,
10877                 ALC298_STANDARD_PINS,
10878                 {0x17, 0x90170110}),
10879         SND_HDA_PIN_QUIRK(0x10ec0298, 0x1028, "Dell", ALC298_FIXUP_DELL1_MIC_NO_PRESENCE,
10880                 ALC298_STANDARD_PINS,
10881                 {0x17, 0x90170140}),
10882         SND_HDA_PIN_QUIRK(0x10ec0298, 0x1028, "Dell", ALC298_FIXUP_DELL1_MIC_NO_PRESENCE,
10883                 ALC298_STANDARD_PINS,
10884                 {0x17, 0x90170150}),
10885         SND_HDA_PIN_QUIRK(0x10ec0298, 0x1028, "Dell", ALC298_FIXUP_SPK_VOLUME,
10886                 {0x12, 0xb7a60140},
10887                 {0x13, 0xb7a60150},
10888                 {0x17, 0x90170110},
10889                 {0x1a, 0x03011020},
10890                 {0x21, 0x03211030}),
10891         SND_HDA_PIN_QUIRK(0x10ec0298, 0x1028, "Dell", ALC298_FIXUP_ALIENWARE_MIC_NO_PRESENCE,
10892                 {0x12, 0xb7a60140},
10893                 {0x17, 0x90170110},
10894                 {0x1a, 0x03a11030},
10895                 {0x21, 0x03211020}),
10896         SND_HDA_PIN_QUIRK(0x10ec0299, 0x1028, "Dell", ALC269_FIXUP_DELL4_MIC_NO_PRESENCE,
10897                 ALC225_STANDARD_PINS,
10898                 {0x12, 0xb7a60130},
10899                 {0x17, 0x90170110}),
10900         SND_HDA_PIN_QUIRK(0x10ec0623, 0x17aa, "Lenovo", ALC283_FIXUP_HEADSET_MIC,
10901                 {0x14, 0x01014010},
10902                 {0x17, 0x90170120},
10903                 {0x18, 0x02a11030},
10904                 {0x19, 0x02a1103f},
10905                 {0x21, 0x0221101f}),
10906         {}
10907 };
10908
10909 /* This is the fallback pin_fixup_tbl for alc269 family, to make the tbl match
10910  * more machines, don't need to match all valid pins, just need to match
10911  * all the pins defined in the tbl. Just because of this reason, it is possible
10912  * that a single machine matches multiple tbls, so there is one limitation:
10913  *   at most one tbl is allowed to define for the same vendor and same codec
10914  */
10915 static const struct snd_hda_pin_quirk alc269_fallback_pin_fixup_tbl[] = {
10916         SND_HDA_PIN_QUIRK(0x10ec0289, 0x1028, "Dell", ALC269_FIXUP_DELL4_MIC_NO_PRESENCE,
10917                 {0x19, 0x40000000},
10918                 {0x1b, 0x40000000}),
10919         SND_HDA_PIN_QUIRK(0x10ec0295, 0x1028, "Dell", ALC269_FIXUP_DELL4_MIC_NO_PRESENCE,
10920                 {0x19, 0x40000000},
10921                 {0x1b, 0x40000000}),
10922         SND_HDA_PIN_QUIRK(0x10ec0256, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
10923                 {0x19, 0x40000000},
10924                 {0x1a, 0x40000000}),
10925         SND_HDA_PIN_QUIRK(0x10ec0236, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
10926                 {0x19, 0x40000000},
10927                 {0x1a, 0x40000000}),
10928         SND_HDA_PIN_QUIRK(0x10ec0274, 0x1028, "Dell", ALC274_FIXUP_DELL_AIO_LINEOUT_VERB,
10929                 {0x19, 0x40000000},
10930                 {0x1a, 0x40000000}),
10931         SND_HDA_PIN_QUIRK(0x10ec0256, 0x1043, "ASUS", ALC2XX_FIXUP_HEADSET_MIC,
10932                 {0x19, 0x40000000}),
10933         {}
10934 };
10935
10936 static void alc269_fill_coef(struct hda_codec *codec)
10937 {
10938         struct alc_spec *spec = codec->spec;
10939         int val;
10940
10941         if (spec->codec_variant != ALC269_TYPE_ALC269VB)
10942                 return;
10943
10944         if ((alc_get_coef0(codec) & 0x00ff) < 0x015) {
10945                 alc_write_coef_idx(codec, 0xf, 0x960b);
10946                 alc_write_coef_idx(codec, 0xe, 0x8817);
10947         }
10948
10949         if ((alc_get_coef0(codec) & 0x00ff) == 0x016) {
10950                 alc_write_coef_idx(codec, 0xf, 0x960b);
10951                 alc_write_coef_idx(codec, 0xe, 0x8814);
10952         }
10953
10954         if ((alc_get_coef0(codec) & 0x00ff) == 0x017) {
10955                 /* Power up output pin */
10956                 alc_update_coef_idx(codec, 0x04, 0, 1<<11);
10957         }
10958
10959         if ((alc_get_coef0(codec) & 0x00ff) == 0x018) {
10960                 val = alc_read_coef_idx(codec, 0xd);
10961                 if (val != -1 && (val & 0x0c00) >> 10 != 0x1) {
10962                         /* Capless ramp up clock control */
10963                         alc_write_coef_idx(codec, 0xd, val | (1<<10));
10964                 }
10965                 val = alc_read_coef_idx(codec, 0x17);
10966                 if (val != -1 && (val & 0x01c0) >> 6 != 0x4) {
10967                         /* Class D power on reset */
10968                         alc_write_coef_idx(codec, 0x17, val | (1<<7));
10969                 }
10970         }
10971
10972         /* HP */
10973         alc_update_coef_idx(codec, 0x4, 0, 1<<11);
10974 }
10975
10976 /*
10977  */
10978 static int patch_alc269(struct hda_codec *codec)
10979 {
10980         struct alc_spec *spec;
10981         int err;
10982
10983         err = alc_alloc_spec(codec, 0x0b);
10984         if (err < 0)
10985                 return err;
10986
10987         spec = codec->spec;
10988         spec->gen.shared_mic_vref_pin = 0x18;
10989         codec->power_save_node = 0;
10990         spec->en_3kpull_low = true;
10991
10992 #ifdef CONFIG_PM
10993         codec->patch_ops.suspend = alc269_suspend;
10994         codec->patch_ops.resume = alc269_resume;
10995 #endif
10996         spec->shutup = alc_default_shutup;
10997         spec->init_hook = alc_default_init;
10998
10999         switch (codec->core.vendor_id) {
11000         case 0x10ec0269:
11001                 spec->codec_variant = ALC269_TYPE_ALC269VA;
11002                 switch (alc_get_coef0(codec) & 0x00f0) {
11003                 case 0x0010:
11004                         if (codec->bus->pci &&
11005                             codec->bus->pci->subsystem_vendor == 0x1025 &&
11006                             spec->cdefine.platform_type == 1)
11007                                 err = alc_codec_rename(codec, "ALC271X");
11008                         spec->codec_variant = ALC269_TYPE_ALC269VB;
11009                         break;
11010                 case 0x0020:
11011                         if (codec->bus->pci &&
11012                             codec->bus->pci->subsystem_vendor == 0x17aa &&
11013                             codec->bus->pci->subsystem_device == 0x21f3)
11014                                 err = alc_codec_rename(codec, "ALC3202");
11015                         spec->codec_variant = ALC269_TYPE_ALC269VC;
11016                         break;
11017                 case 0x0030:
11018                         spec->codec_variant = ALC269_TYPE_ALC269VD;
11019                         break;
11020                 default:
11021                         alc_fix_pll_init(codec, 0x20, 0x04, 15);
11022                 }
11023                 if (err < 0)
11024                         goto error;
11025                 spec->shutup = alc269_shutup;
11026                 spec->init_hook = alc269_fill_coef;
11027                 alc269_fill_coef(codec);
11028                 break;
11029
11030         case 0x10ec0280:
11031         case 0x10ec0290:
11032                 spec->codec_variant = ALC269_TYPE_ALC280;
11033                 break;
11034         case 0x10ec0282:
11035                 spec->codec_variant = ALC269_TYPE_ALC282;
11036                 spec->shutup = alc282_shutup;
11037                 spec->init_hook = alc282_init;
11038                 break;
11039         case 0x10ec0233:
11040         case 0x10ec0283:
11041                 spec->codec_variant = ALC269_TYPE_ALC283;
11042                 spec->shutup = alc283_shutup;
11043                 spec->init_hook = alc283_init;
11044                 break;
11045         case 0x10ec0284:
11046         case 0x10ec0292:
11047                 spec->codec_variant = ALC269_TYPE_ALC284;
11048                 break;
11049         case 0x10ec0293:
11050                 spec->codec_variant = ALC269_TYPE_ALC293;
11051                 break;
11052         case 0x10ec0286:
11053         case 0x10ec0288:
11054                 spec->codec_variant = ALC269_TYPE_ALC286;
11055                 break;
11056         case 0x10ec0298:
11057                 spec->codec_variant = ALC269_TYPE_ALC298;
11058                 break;
11059         case 0x10ec0235:
11060         case 0x10ec0255:
11061                 spec->codec_variant = ALC269_TYPE_ALC255;
11062                 spec->shutup = alc256_shutup;
11063                 spec->init_hook = alc256_init;
11064                 break;
11065         case 0x10ec0230:
11066         case 0x10ec0236:
11067         case 0x10ec0256:
11068         case 0x19e58326:
11069                 spec->codec_variant = ALC269_TYPE_ALC256;
11070                 spec->shutup = alc256_shutup;
11071                 spec->init_hook = alc256_init;
11072                 spec->gen.mixer_nid = 0; /* ALC256 does not have any loopback mixer path */
11073                 if (codec->core.vendor_id == 0x10ec0236 &&
11074                     codec->bus->pci->vendor != PCI_VENDOR_ID_AMD)
11075                         spec->en_3kpull_low = false;
11076                 break;
11077         case 0x10ec0257:
11078                 spec->codec_variant = ALC269_TYPE_ALC257;
11079                 spec->shutup = alc256_shutup;
11080                 spec->init_hook = alc256_init;
11081                 spec->gen.mixer_nid = 0;
11082                 spec->en_3kpull_low = false;
11083                 break;
11084         case 0x10ec0215:
11085         case 0x10ec0245:
11086         case 0x10ec0285:
11087         case 0x10ec0289:
11088                 if (alc_get_coef0(codec) & 0x0010)
11089                         spec->codec_variant = ALC269_TYPE_ALC245;
11090                 else
11091                         spec->codec_variant = ALC269_TYPE_ALC215;
11092                 spec->shutup = alc225_shutup;
11093                 spec->init_hook = alc225_init;
11094                 spec->gen.mixer_nid = 0;
11095                 break;
11096         case 0x10ec0225:
11097         case 0x10ec0295:
11098         case 0x10ec0299:
11099                 spec->codec_variant = ALC269_TYPE_ALC225;
11100                 spec->shutup = alc225_shutup;
11101                 spec->init_hook = alc225_init;
11102                 spec->gen.mixer_nid = 0; /* no loopback on ALC225, ALC295 and ALC299 */
11103                 break;
11104         case 0x10ec0287:
11105                 spec->codec_variant = ALC269_TYPE_ALC287;
11106                 spec->shutup = alc225_shutup;
11107                 spec->init_hook = alc225_init;
11108                 spec->gen.mixer_nid = 0; /* no loopback on ALC287 */
11109                 break;
11110         case 0x10ec0234:
11111         case 0x10ec0274:
11112         case 0x10ec0294:
11113                 spec->codec_variant = ALC269_TYPE_ALC294;
11114                 spec->gen.mixer_nid = 0; /* ALC2x4 does not have any loopback mixer path */
11115                 alc_update_coef_idx(codec, 0x6b, 0x0018, (1<<4) | (1<<3)); /* UAJ MIC Vref control by verb */
11116                 spec->init_hook = alc294_init;
11117                 break;
11118         case 0x10ec0300:
11119                 spec->codec_variant = ALC269_TYPE_ALC300;
11120                 spec->gen.mixer_nid = 0; /* no loopback on ALC300 */
11121                 break;
11122         case 0x10ec0623:
11123                 spec->codec_variant = ALC269_TYPE_ALC623;
11124                 break;
11125         case 0x10ec0700:
11126         case 0x10ec0701:
11127         case 0x10ec0703:
11128         case 0x10ec0711:
11129                 spec->codec_variant = ALC269_TYPE_ALC700;
11130                 spec->gen.mixer_nid = 0; /* ALC700 does not have any loopback mixer path */
11131                 alc_update_coef_idx(codec, 0x4a, 1 << 15, 0); /* Combo jack auto trigger control */
11132                 spec->init_hook = alc294_init;
11133                 break;
11134
11135         }
11136
11137         if (snd_hda_codec_read(codec, 0x51, 0, AC_VERB_PARAMETERS, 0) == 0x10ec5505) {
11138                 spec->has_alc5505_dsp = 1;
11139                 spec->init_hook = alc5505_dsp_init;
11140         }
11141
11142         alc_pre_init(codec);
11143
11144         snd_hda_pick_fixup(codec, alc269_fixup_models,
11145                        alc269_fixup_tbl, alc269_fixups);
11146         /* FIXME: both TX300 and ROG Strix G17 have the same SSID, and
11147          * the quirk breaks the latter (bko#214101).
11148          * Clear the wrong entry.
11149          */
11150         if (codec->fixup_id == ALC282_FIXUP_ASUS_TX300 &&
11151             codec->core.vendor_id == 0x10ec0294) {
11152                 codec_dbg(codec, "Clear wrong fixup for ASUS ROG Strix G17\n");
11153                 codec->fixup_id = HDA_FIXUP_ID_NOT_SET;
11154         }
11155
11156         snd_hda_pick_pin_fixup(codec, alc269_pin_fixup_tbl, alc269_fixups, true);
11157         snd_hda_pick_pin_fixup(codec, alc269_fallback_pin_fixup_tbl, alc269_fixups, false);
11158         snd_hda_pick_fixup(codec, NULL, alc269_fixup_vendor_tbl,
11159                            alc269_fixups);
11160         snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE);
11161
11162         alc_auto_parse_customize_define(codec);
11163
11164         if (has_cdefine_beep(codec))
11165                 spec->gen.beep_nid = 0x01;
11166
11167         /* automatic parse from the BIOS config */
11168         err = alc269_parse_auto_config(codec);
11169         if (err < 0)
11170                 goto error;
11171
11172         if (!spec->gen.no_analog && spec->gen.beep_nid && spec->gen.mixer_nid) {
11173                 err = set_beep_amp(spec, spec->gen.mixer_nid, 0x04, HDA_INPUT);
11174                 if (err < 0)
11175                         goto error;
11176         }
11177
11178         snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE);
11179
11180         return 0;
11181
11182  error:
11183         alc_free(codec);
11184         return err;
11185 }
11186
11187 /*
11188  * ALC861
11189  */
11190
11191 static int alc861_parse_auto_config(struct hda_codec *codec)
11192 {
11193         static const hda_nid_t alc861_ignore[] = { 0x1d, 0 };
11194         static const hda_nid_t alc861_ssids[] = { 0x0e, 0x0f, 0x0b, 0 };
11195         return alc_parse_auto_config(codec, alc861_ignore, alc861_ssids);
11196 }
11197
11198 /* Pin config fixes */
11199 enum {
11200         ALC861_FIXUP_FSC_AMILO_PI1505,
11201         ALC861_FIXUP_AMP_VREF_0F,
11202         ALC861_FIXUP_NO_JACK_DETECT,
11203         ALC861_FIXUP_ASUS_A6RP,
11204         ALC660_FIXUP_ASUS_W7J,
11205 };
11206
11207 /* On some laptops, VREF of pin 0x0f is abused for controlling the main amp */
11208 static void alc861_fixup_asus_amp_vref_0f(struct hda_codec *codec,
11209                         const struct hda_fixup *fix, int action)
11210 {
11211         struct alc_spec *spec = codec->spec;
11212         unsigned int val;
11213
11214         if (action != HDA_FIXUP_ACT_INIT)
11215                 return;
11216         val = snd_hda_codec_get_pin_target(codec, 0x0f);
11217         if (!(val & (AC_PINCTL_IN_EN | AC_PINCTL_OUT_EN)))
11218                 val |= AC_PINCTL_IN_EN;
11219         val |= AC_PINCTL_VREF_50;
11220         snd_hda_set_pin_ctl(codec, 0x0f, val);
11221         spec->gen.keep_vref_in_automute = 1;
11222 }
11223
11224 /* suppress the jack-detection */
11225 static void alc_fixup_no_jack_detect(struct hda_codec *codec,
11226                                      const struct hda_fixup *fix, int action)
11227 {
11228         if (action == HDA_FIXUP_ACT_PRE_PROBE)
11229                 codec->no_jack_detect = 1;
11230 }
11231
11232 static const struct hda_fixup alc861_fixups[] = {
11233         [ALC861_FIXUP_FSC_AMILO_PI1505] = {
11234                 .type = HDA_FIXUP_PINS,
11235                 .v.pins = (const struct hda_pintbl[]) {
11236                         { 0x0b, 0x0221101f }, /* HP */
11237                         { 0x0f, 0x90170310 }, /* speaker */
11238                         { }
11239                 }
11240         },
11241         [ALC861_FIXUP_AMP_VREF_0F] = {
11242                 .type = HDA_FIXUP_FUNC,
11243                 .v.func = alc861_fixup_asus_amp_vref_0f,
11244         },
11245         [ALC861_FIXUP_NO_JACK_DETECT] = {
11246                 .type = HDA_FIXUP_FUNC,
11247                 .v.func = alc_fixup_no_jack_detect,
11248         },
11249         [ALC861_FIXUP_ASUS_A6RP] = {
11250                 .type = HDA_FIXUP_FUNC,
11251                 .v.func = alc861_fixup_asus_amp_vref_0f,
11252                 .chained = true,
11253                 .chain_id = ALC861_FIXUP_NO_JACK_DETECT,
11254         },
11255         [ALC660_FIXUP_ASUS_W7J] = {
11256                 .type = HDA_FIXUP_VERBS,
11257                 .v.verbs = (const struct hda_verb[]) {
11258                         /* ASUS W7J needs a magic pin setup on unused NID 0x10
11259                          * for enabling outputs
11260                          */
11261                         {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
11262                         { }
11263                 },
11264         }
11265 };
11266
11267 static const struct snd_pci_quirk alc861_fixup_tbl[] = {
11268         SND_PCI_QUIRK(0x1043, 0x1253, "ASUS W7J", ALC660_FIXUP_ASUS_W7J),
11269         SND_PCI_QUIRK(0x1043, 0x1263, "ASUS Z35HL", ALC660_FIXUP_ASUS_W7J),
11270         SND_PCI_QUIRK(0x1043, 0x1393, "ASUS A6Rp", ALC861_FIXUP_ASUS_A6RP),
11271         SND_PCI_QUIRK_VENDOR(0x1043, "ASUS laptop", ALC861_FIXUP_AMP_VREF_0F),
11272         SND_PCI_QUIRK(0x1462, 0x7254, "HP DX2200", ALC861_FIXUP_NO_JACK_DETECT),
11273         SND_PCI_QUIRK_VENDOR(0x1584, "Haier/Uniwill", ALC861_FIXUP_AMP_VREF_0F),
11274         SND_PCI_QUIRK(0x1734, 0x10c7, "FSC Amilo Pi1505", ALC861_FIXUP_FSC_AMILO_PI1505),
11275         {}
11276 };
11277
11278 /*
11279  */
11280 static int patch_alc861(struct hda_codec *codec)
11281 {
11282         struct alc_spec *spec;
11283         int err;
11284
11285         err = alc_alloc_spec(codec, 0x15);
11286         if (err < 0)
11287                 return err;
11288
11289         spec = codec->spec;
11290         if (has_cdefine_beep(codec))
11291                 spec->gen.beep_nid = 0x23;
11292
11293 #ifdef CONFIG_PM
11294         spec->power_hook = alc_power_eapd;
11295 #endif
11296
11297         alc_pre_init(codec);
11298
11299         snd_hda_pick_fixup(codec, NULL, alc861_fixup_tbl, alc861_fixups);
11300         snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE);
11301
11302         /* automatic parse from the BIOS config */
11303         err = alc861_parse_auto_config(codec);
11304         if (err < 0)
11305                 goto error;
11306
11307         if (!spec->gen.no_analog) {
11308                 err = set_beep_amp(spec, 0x23, 0, HDA_OUTPUT);
11309                 if (err < 0)
11310                         goto error;
11311         }
11312
11313         snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE);
11314
11315         return 0;
11316
11317  error:
11318         alc_free(codec);
11319         return err;
11320 }
11321
11322 /*
11323  * ALC861-VD support
11324  *
11325  * Based on ALC882
11326  *
11327  * In addition, an independent DAC
11328  */
11329 static int alc861vd_parse_auto_config(struct hda_codec *codec)
11330 {
11331         static const hda_nid_t alc861vd_ignore[] = { 0x1d, 0 };
11332         static const hda_nid_t alc861vd_ssids[] = { 0x15, 0x1b, 0x14, 0 };
11333         return alc_parse_auto_config(codec, alc861vd_ignore, alc861vd_ssids);
11334 }
11335
11336 enum {
11337         ALC660VD_FIX_ASUS_GPIO1,
11338         ALC861VD_FIX_DALLAS,
11339 };
11340
11341 /* exclude VREF80 */
11342 static void alc861vd_fixup_dallas(struct hda_codec *codec,
11343                                   const struct hda_fixup *fix, int action)
11344 {
11345         if (action == HDA_FIXUP_ACT_PRE_PROBE) {
11346                 snd_hda_override_pin_caps(codec, 0x18, 0x00000734);
11347                 snd_hda_override_pin_caps(codec, 0x19, 0x0000073c);
11348         }
11349 }
11350
11351 /* reset GPIO1 */
11352 static void alc660vd_fixup_asus_gpio1(struct hda_codec *codec,
11353                                       const struct hda_fixup *fix, int action)
11354 {
11355         struct alc_spec *spec = codec->spec;
11356
11357         if (action == HDA_FIXUP_ACT_PRE_PROBE)
11358                 spec->gpio_mask |= 0x02;
11359         alc_fixup_gpio(codec, action, 0x01);
11360 }
11361
11362 static const struct hda_fixup alc861vd_fixups[] = {
11363         [ALC660VD_FIX_ASUS_GPIO1] = {
11364                 .type = HDA_FIXUP_FUNC,
11365                 .v.func = alc660vd_fixup_asus_gpio1,
11366         },
11367         [ALC861VD_FIX_DALLAS] = {
11368                 .type = HDA_FIXUP_FUNC,
11369                 .v.func = alc861vd_fixup_dallas,
11370         },
11371 };
11372
11373 static const struct snd_pci_quirk alc861vd_fixup_tbl[] = {
11374         SND_PCI_QUIRK(0x103c, 0x30bf, "HP TX1000", ALC861VD_FIX_DALLAS),
11375         SND_PCI_QUIRK(0x1043, 0x1339, "ASUS A7-K", ALC660VD_FIX_ASUS_GPIO1),
11376         SND_PCI_QUIRK(0x1179, 0xff31, "Toshiba L30-149", ALC861VD_FIX_DALLAS),
11377         {}
11378 };
11379
11380 /*
11381  */
11382 static int patch_alc861vd(struct hda_codec *codec)
11383 {
11384         struct alc_spec *spec;
11385         int err;
11386
11387         err = alc_alloc_spec(codec, 0x0b);
11388         if (err < 0)
11389                 return err;
11390
11391         spec = codec->spec;
11392         if (has_cdefine_beep(codec))
11393                 spec->gen.beep_nid = 0x23;
11394
11395         spec->shutup = alc_eapd_shutup;
11396
11397         alc_pre_init(codec);
11398
11399         snd_hda_pick_fixup(codec, NULL, alc861vd_fixup_tbl, alc861vd_fixups);
11400         snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE);
11401
11402         /* automatic parse from the BIOS config */
11403         err = alc861vd_parse_auto_config(codec);
11404         if (err < 0)
11405                 goto error;
11406
11407         if (!spec->gen.no_analog) {
11408                 err = set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
11409                 if (err < 0)
11410                         goto error;
11411         }
11412
11413         snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE);
11414
11415         return 0;
11416
11417  error:
11418         alc_free(codec);
11419         return err;
11420 }
11421
11422 /*
11423  * ALC662 support
11424  *
11425  * ALC662 is almost identical with ALC880 but has cleaner and more flexible
11426  * configuration.  Each pin widget can choose any input DACs and a mixer.
11427  * Each ADC is connected from a mixer of all inputs.  This makes possible
11428  * 6-channel independent captures.
11429  *
11430  * In addition, an independent DAC for the multi-playback (not used in this
11431  * driver yet).
11432  */
11433
11434 /*
11435  * BIOS auto configuration
11436  */
11437
11438 static int alc662_parse_auto_config(struct hda_codec *codec)
11439 {
11440         static const hda_nid_t alc662_ignore[] = { 0x1d, 0 };
11441         static const hda_nid_t alc663_ssids[] = { 0x15, 0x1b, 0x14, 0x21 };
11442         static const hda_nid_t alc662_ssids[] = { 0x15, 0x1b, 0x14, 0 };
11443         const hda_nid_t *ssids;
11444
11445         if (codec->core.vendor_id == 0x10ec0272 || codec->core.vendor_id == 0x10ec0663 ||
11446             codec->core.vendor_id == 0x10ec0665 || codec->core.vendor_id == 0x10ec0670 ||
11447             codec->core.vendor_id == 0x10ec0671)
11448                 ssids = alc663_ssids;
11449         else
11450                 ssids = alc662_ssids;
11451         return alc_parse_auto_config(codec, alc662_ignore, ssids);
11452 }
11453
11454 static void alc272_fixup_mario(struct hda_codec *codec,
11455                                const struct hda_fixup *fix, int action)
11456 {
11457         if (action != HDA_FIXUP_ACT_PRE_PROBE)
11458                 return;
11459         if (snd_hda_override_amp_caps(codec, 0x2, HDA_OUTPUT,
11460                                       (0x3b << AC_AMPCAP_OFFSET_SHIFT) |
11461                                       (0x3b << AC_AMPCAP_NUM_STEPS_SHIFT) |
11462                                       (0x03 << AC_AMPCAP_STEP_SIZE_SHIFT) |
11463                                       (0 << AC_AMPCAP_MUTE_SHIFT)))
11464                 codec_warn(codec, "failed to override amp caps for NID 0x2\n");
11465 }
11466
11467 static const struct snd_pcm_chmap_elem asus_pcm_2_1_chmaps[] = {
11468         { .channels = 2,
11469           .map = { SNDRV_CHMAP_FL, SNDRV_CHMAP_FR } },
11470         { .channels = 4,
11471           .map = { SNDRV_CHMAP_FL, SNDRV_CHMAP_FR,
11472                    SNDRV_CHMAP_NA, SNDRV_CHMAP_LFE } }, /* LFE only on right */
11473         { }
11474 };
11475
11476 /* override the 2.1 chmap */
11477 static void alc_fixup_bass_chmap(struct hda_codec *codec,
11478                                     const struct hda_fixup *fix, int action)
11479 {
11480         if (action == HDA_FIXUP_ACT_BUILD) {
11481                 struct alc_spec *spec = codec->spec;
11482                 spec->gen.pcm_rec[0]->stream[0].chmap = asus_pcm_2_1_chmaps;
11483         }
11484 }
11485
11486 /* avoid D3 for keeping GPIO up */
11487 static unsigned int gpio_led_power_filter(struct hda_codec *codec,
11488                                           hda_nid_t nid,
11489                                           unsigned int power_state)
11490 {
11491         struct alc_spec *spec = codec->spec;
11492         if (nid == codec->core.afg && power_state == AC_PWRST_D3 && spec->gpio_data)
11493                 return AC_PWRST_D0;
11494         return power_state;
11495 }
11496
11497 static void alc662_fixup_led_gpio1(struct hda_codec *codec,
11498                                    const struct hda_fixup *fix, int action)
11499 {
11500         struct alc_spec *spec = codec->spec;
11501
11502         alc_fixup_hp_gpio_led(codec, action, 0x01, 0);
11503         if (action == HDA_FIXUP_ACT_PRE_PROBE) {
11504                 spec->mute_led_polarity = 1;
11505                 codec->power_filter = gpio_led_power_filter;
11506         }
11507 }
11508
11509 static void alc662_usi_automute_hook(struct hda_codec *codec,
11510                                          struct hda_jack_callback *jack)
11511 {
11512         struct alc_spec *spec = codec->spec;
11513         int vref;
11514         msleep(200);
11515         snd_hda_gen_hp_automute(codec, jack);
11516
11517         vref = spec->gen.hp_jack_present ? PIN_VREF80 : 0;
11518         msleep(100);
11519         snd_hda_codec_write(codec, 0x19, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
11520                             vref);
11521 }
11522
11523 static void alc662_fixup_usi_headset_mic(struct hda_codec *codec,
11524                                      const struct hda_fixup *fix, int action)
11525 {
11526         struct alc_spec *spec = codec->spec;
11527         if (action == HDA_FIXUP_ACT_PRE_PROBE) {
11528                 spec->parse_flags |= HDA_PINCFG_HEADSET_MIC;
11529                 spec->gen.hp_automute_hook = alc662_usi_automute_hook;
11530         }
11531 }
11532
11533 static void alc662_aspire_ethos_mute_speakers(struct hda_codec *codec,
11534                                         struct hda_jack_callback *cb)
11535 {
11536         /* surround speakers at 0x1b already get muted automatically when
11537          * headphones are plugged in, but we have to mute/unmute the remaining
11538          * channels manually:
11539          * 0x15 - front left/front right
11540          * 0x18 - front center/ LFE
11541          */
11542         if (snd_hda_jack_detect_state(codec, 0x1b) == HDA_JACK_PRESENT) {
11543                 snd_hda_set_pin_ctl_cache(codec, 0x15, 0);
11544                 snd_hda_set_pin_ctl_cache(codec, 0x18, 0);
11545         } else {
11546                 snd_hda_set_pin_ctl_cache(codec, 0x15, PIN_OUT);
11547                 snd_hda_set_pin_ctl_cache(codec, 0x18, PIN_OUT);
11548         }
11549 }
11550
11551 static void alc662_fixup_aspire_ethos_hp(struct hda_codec *codec,
11552                                         const struct hda_fixup *fix, int action)
11553 {
11554     /* Pin 0x1b: shared headphones jack and surround speakers */
11555         if (!is_jack_detectable(codec, 0x1b))
11556                 return;
11557
11558         switch (action) {
11559         case HDA_FIXUP_ACT_PRE_PROBE:
11560                 snd_hda_jack_detect_enable_callback(codec, 0x1b,
11561                                 alc662_aspire_ethos_mute_speakers);
11562                 /* subwoofer needs an extra GPIO setting to become audible */
11563                 alc_setup_gpio(codec, 0x02);
11564                 break;
11565         case HDA_FIXUP_ACT_INIT:
11566                 /* Make sure to start in a correct state, i.e. if
11567                  * headphones have been plugged in before powering up the system
11568                  */
11569                 alc662_aspire_ethos_mute_speakers(codec, NULL);
11570                 break;
11571         }
11572 }
11573
11574 static void alc671_fixup_hp_headset_mic2(struct hda_codec *codec,
11575                                              const struct hda_fixup *fix, int action)
11576 {
11577         struct alc_spec *spec = codec->spec;
11578
11579         static const struct hda_pintbl pincfgs[] = {
11580                 { 0x19, 0x02a11040 }, /* use as headset mic, with its own jack detect */
11581                 { 0x1b, 0x0181304f },
11582                 { }
11583         };
11584
11585         switch (action) {
11586         case HDA_FIXUP_ACT_PRE_PROBE:
11587                 spec->gen.mixer_nid = 0;
11588                 spec->parse_flags |= HDA_PINCFG_HEADSET_MIC;
11589                 snd_hda_apply_pincfgs(codec, pincfgs);
11590                 break;
11591         case HDA_FIXUP_ACT_INIT:
11592                 alc_write_coef_idx(codec, 0x19, 0xa054);
11593                 break;
11594         }
11595 }
11596
11597 static void alc897_hp_automute_hook(struct hda_codec *codec,
11598                                          struct hda_jack_callback *jack)
11599 {
11600         struct alc_spec *spec = codec->spec;
11601         int vref;
11602
11603         snd_hda_gen_hp_automute(codec, jack);
11604         vref = spec->gen.hp_jack_present ? (PIN_HP | AC_PINCTL_VREF_100) : PIN_HP;
11605         snd_hda_codec_write(codec, 0x1b, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
11606                             vref);
11607 }
11608
11609 static void alc897_fixup_lenovo_headset_mic(struct hda_codec *codec,
11610                                      const struct hda_fixup *fix, int action)
11611 {
11612         struct alc_spec *spec = codec->spec;
11613         if (action == HDA_FIXUP_ACT_PRE_PROBE) {
11614                 spec->gen.hp_automute_hook = alc897_hp_automute_hook;
11615         }
11616 }
11617
11618 static void alc897_fixup_lenovo_headset_mode(struct hda_codec *codec,
11619                                      const struct hda_fixup *fix, int action)
11620 {
11621         struct alc_spec *spec = codec->spec;
11622
11623         if (action == HDA_FIXUP_ACT_PRE_PROBE) {
11624                 spec->parse_flags |= HDA_PINCFG_HEADSET_MIC;
11625                 spec->gen.hp_automute_hook = alc897_hp_automute_hook;
11626         }
11627 }
11628
11629 static const struct coef_fw alc668_coefs[] = {
11630         WRITE_COEF(0x01, 0xbebe), WRITE_COEF(0x02, 0xaaaa), WRITE_COEF(0x03,    0x0),
11631         WRITE_COEF(0x04, 0x0180), WRITE_COEF(0x06,    0x0), WRITE_COEF(0x07, 0x0f80),
11632         WRITE_COEF(0x08, 0x0031), WRITE_COEF(0x0a, 0x0060), WRITE_COEF(0x0b,    0x0),
11633         WRITE_COEF(0x0c, 0x7cf7), WRITE_COEF(0x0d, 0x1080), WRITE_COEF(0x0e, 0x7f7f),
11634         WRITE_COEF(0x0f, 0xcccc), WRITE_COEF(0x10, 0xddcc), WRITE_COEF(0x11, 0x0001),
11635         WRITE_COEF(0x13,    0x0), WRITE_COEF(0x14, 0x2aa0), WRITE_COEF(0x17, 0xa940),
11636         WRITE_COEF(0x19,    0x0), WRITE_COEF(0x1a,    0x0), WRITE_COEF(0x1b,    0x0),
11637         WRITE_COEF(0x1c,    0x0), WRITE_COEF(0x1d,    0x0), WRITE_COEF(0x1e, 0x7418),
11638         WRITE_COEF(0x1f, 0x0804), WRITE_COEF(0x20, 0x4200), WRITE_COEF(0x21, 0x0468),
11639         WRITE_COEF(0x22, 0x8ccc), WRITE_COEF(0x23, 0x0250), WRITE_COEF(0x24, 0x7418),
11640         WRITE_COEF(0x27,    0x0), WRITE_COEF(0x28, 0x8ccc), WRITE_COEF(0x2a, 0xff00),
11641         WRITE_COEF(0x2b, 0x8000), WRITE_COEF(0xa7, 0xff00), WRITE_COEF(0xa8, 0x8000),
11642         WRITE_COEF(0xaa, 0x2e17), WRITE_COEF(0xab, 0xa0c0), WRITE_COEF(0xac,    0x0),
11643         WRITE_COEF(0xad,    0x0), WRITE_COEF(0xae, 0x2ac6), WRITE_COEF(0xaf, 0xa480),
11644         WRITE_COEF(0xb0,    0x0), WRITE_COEF(0xb1,    0x0), WRITE_COEF(0xb2,    0x0),
11645         WRITE_COEF(0xb3,    0x0), WRITE_COEF(0xb4,    0x0), WRITE_COEF(0xb5, 0x1040),
11646         WRITE_COEF(0xb6, 0xd697), WRITE_COEF(0xb7, 0x902b), WRITE_COEF(0xb8, 0xd697),
11647         WRITE_COEF(0xb9, 0x902b), WRITE_COEF(0xba, 0xb8ba), WRITE_COEF(0xbb, 0xaaab),
11648         WRITE_COEF(0xbc, 0xaaaf), WRITE_COEF(0xbd, 0x6aaa), WRITE_COEF(0xbe, 0x1c02),
11649         WRITE_COEF(0xc0, 0x00ff), WRITE_COEF(0xc1, 0x0fa6),
11650         {}
11651 };
11652
11653 static void alc668_restore_default_value(struct hda_codec *codec)
11654 {
11655         alc_process_coef_fw(codec, alc668_coefs);
11656 }
11657
11658 enum {
11659         ALC662_FIXUP_ASPIRE,
11660         ALC662_FIXUP_LED_GPIO1,
11661         ALC662_FIXUP_IDEAPAD,
11662         ALC272_FIXUP_MARIO,
11663         ALC662_FIXUP_CZC_ET26,
11664         ALC662_FIXUP_CZC_P10T,
11665         ALC662_FIXUP_SKU_IGNORE,
11666         ALC662_FIXUP_HP_RP5800,
11667         ALC662_FIXUP_ASUS_MODE1,
11668         ALC662_FIXUP_ASUS_MODE2,
11669         ALC662_FIXUP_ASUS_MODE3,
11670         ALC662_FIXUP_ASUS_MODE4,
11671         ALC662_FIXUP_ASUS_MODE5,
11672         ALC662_FIXUP_ASUS_MODE6,
11673         ALC662_FIXUP_ASUS_MODE7,
11674         ALC662_FIXUP_ASUS_MODE8,
11675         ALC662_FIXUP_NO_JACK_DETECT,
11676         ALC662_FIXUP_ZOTAC_Z68,
11677         ALC662_FIXUP_INV_DMIC,
11678         ALC662_FIXUP_DELL_MIC_NO_PRESENCE,
11679         ALC668_FIXUP_DELL_MIC_NO_PRESENCE,
11680         ALC662_FIXUP_HEADSET_MODE,
11681         ALC668_FIXUP_HEADSET_MODE,
11682         ALC662_FIXUP_BASS_MODE4_CHMAP,
11683         ALC662_FIXUP_BASS_16,
11684         ALC662_FIXUP_BASS_1A,
11685         ALC662_FIXUP_BASS_CHMAP,
11686         ALC668_FIXUP_AUTO_MUTE,
11687         ALC668_FIXUP_DELL_DISABLE_AAMIX,
11688         ALC668_FIXUP_DELL_XPS13,
11689         ALC662_FIXUP_ASUS_Nx50,
11690         ALC668_FIXUP_ASUS_Nx51_HEADSET_MODE,
11691         ALC668_FIXUP_ASUS_Nx51,
11692         ALC668_FIXUP_MIC_COEF,
11693         ALC668_FIXUP_ASUS_G751,
11694         ALC891_FIXUP_HEADSET_MODE,
11695         ALC891_FIXUP_DELL_MIC_NO_PRESENCE,
11696         ALC662_FIXUP_ACER_VERITON,
11697         ALC892_FIXUP_ASROCK_MOBO,
11698         ALC662_FIXUP_USI_FUNC,
11699         ALC662_FIXUP_USI_HEADSET_MODE,
11700         ALC662_FIXUP_LENOVO_MULTI_CODECS,
11701         ALC669_FIXUP_ACER_ASPIRE_ETHOS,
11702         ALC669_FIXUP_ACER_ASPIRE_ETHOS_HEADSET,
11703         ALC671_FIXUP_HP_HEADSET_MIC2,
11704         ALC662_FIXUP_ACER_X2660G_HEADSET_MODE,
11705         ALC662_FIXUP_ACER_NITRO_HEADSET_MODE,
11706         ALC668_FIXUP_ASUS_NO_HEADSET_MIC,
11707         ALC668_FIXUP_HEADSET_MIC,
11708         ALC668_FIXUP_MIC_DET_COEF,
11709         ALC897_FIXUP_LENOVO_HEADSET_MIC,
11710         ALC897_FIXUP_HEADSET_MIC_PIN,
11711         ALC897_FIXUP_HP_HSMIC_VERB,
11712         ALC897_FIXUP_LENOVO_HEADSET_MODE,
11713         ALC897_FIXUP_HEADSET_MIC_PIN2,
11714         ALC897_FIXUP_UNIS_H3C_X500S,
11715 };
11716
11717 static const struct hda_fixup alc662_fixups[] = {
11718         [ALC662_FIXUP_ASPIRE] = {
11719                 .type = HDA_FIXUP_PINS,
11720                 .v.pins = (const struct hda_pintbl[]) {
11721                         { 0x15, 0x99130112 }, /* subwoofer */
11722                         { }
11723                 }
11724         },
11725         [ALC662_FIXUP_LED_GPIO1] = {
11726                 .type = HDA_FIXUP_FUNC,
11727                 .v.func = alc662_fixup_led_gpio1,
11728         },
11729         [ALC662_FIXUP_IDEAPAD] = {
11730                 .type = HDA_FIXUP_PINS,
11731                 .v.pins = (const struct hda_pintbl[]) {
11732                         { 0x17, 0x99130112 }, /* subwoofer */
11733                         { }
11734                 },
11735                 .chained = true,
11736                 .chain_id = ALC662_FIXUP_LED_GPIO1,
11737         },
11738         [ALC272_FIXUP_MARIO] = {
11739                 .type = HDA_FIXUP_FUNC,
11740                 .v.func = alc272_fixup_mario,
11741         },
11742         [ALC662_FIXUP_CZC_ET26] = {
11743                 .type = HDA_FIXUP_PINS,
11744                 .v.pins = (const struct hda_pintbl[]) {
11745                         {0x12, 0x403cc000},
11746                         {0x14, 0x90170110}, /* speaker */
11747                         {0x15, 0x411111f0},
11748                         {0x16, 0x411111f0},
11749                         {0x18, 0x01a19030}, /* mic */
11750                         {0x19, 0x90a7013f}, /* int-mic */
11751                         {0x1a, 0x01014020},
11752                         {0x1b, 0x0121401f},
11753                         {0x1c, 0x411111f0},
11754                         {0x1d, 0x411111f0},
11755                         {0x1e, 0x40478e35},
11756                         {}
11757                 },
11758                 .chained = true,
11759                 .chain_id = ALC662_FIXUP_SKU_IGNORE
11760         },
11761         [ALC662_FIXUP_CZC_P10T] = {
11762                 .type = HDA_FIXUP_VERBS,
11763                 .v.verbs = (const struct hda_verb[]) {
11764                         {0x14, AC_VERB_SET_EAPD_BTLENABLE, 0},
11765                         {}
11766                 }
11767         },
11768         [ALC662_FIXUP_SKU_IGNORE] = {
11769                 .type = HDA_FIXUP_FUNC,
11770                 .v.func = alc_fixup_sku_ignore,
11771         },
11772         [ALC662_FIXUP_HP_RP5800] = {
11773                 .type = HDA_FIXUP_PINS,
11774                 .v.pins = (const struct hda_pintbl[]) {
11775                         { 0x14, 0x0221201f }, /* HP out */
11776                         { }
11777                 },
11778                 .chained = true,
11779                 .chain_id = ALC662_FIXUP_SKU_IGNORE
11780         },
11781         [ALC662_FIXUP_ASUS_MODE1] = {
11782                 .type = HDA_FIXUP_PINS,
11783                 .v.pins = (const struct hda_pintbl[]) {
11784                         { 0x14, 0x99130110 }, /* speaker */
11785                         { 0x18, 0x01a19c20 }, /* mic */
11786                         { 0x19, 0x99a3092f }, /* int-mic */
11787                         { 0x21, 0x0121401f }, /* HP out */
11788                         { }
11789                 },
11790                 .chained = true,
11791                 .chain_id = ALC662_FIXUP_SKU_IGNORE
11792         },
11793         [ALC662_FIXUP_ASUS_MODE2] = {
11794                 .type = HDA_FIXUP_PINS,
11795                 .v.pins = (const struct hda_pintbl[]) {
11796                         { 0x14, 0x99130110 }, /* speaker */
11797                         { 0x18, 0x01a19820 }, /* mic */
11798                         { 0x19, 0x99a3092f }, /* int-mic */
11799                         { 0x1b, 0x0121401f }, /* HP out */
11800                         { }
11801                 },
11802                 .chained = true,
11803                 .chain_id = ALC662_FIXUP_SKU_IGNORE
11804         },
11805         [ALC662_FIXUP_ASUS_MODE3] = {
11806                 .type = HDA_FIXUP_PINS,
11807                 .v.pins = (const struct hda_pintbl[]) {
11808                         { 0x14, 0x99130110 }, /* speaker */
11809                         { 0x15, 0x0121441f }, /* HP */
11810                         { 0x18, 0x01a19840 }, /* mic */
11811                         { 0x19, 0x99a3094f }, /* int-mic */
11812                         { 0x21, 0x01211420 }, /* HP2 */
11813                         { }
11814                 },
11815                 .chained = true,
11816                 .chain_id = ALC662_FIXUP_SKU_IGNORE
11817         },
11818         [ALC662_FIXUP_ASUS_MODE4] = {
11819                 .type = HDA_FIXUP_PINS,
11820                 .v.pins = (const struct hda_pintbl[]) {
11821                         { 0x14, 0x99130110 }, /* speaker */
11822                         { 0x16, 0x99130111 }, /* speaker */
11823                         { 0x18, 0x01a19840 }, /* mic */
11824                         { 0x19, 0x99a3094f }, /* int-mic */
11825                         { 0x21, 0x0121441f }, /* HP */
11826                         { }
11827                 },
11828                 .chained = true,
11829                 .chain_id = ALC662_FIXUP_SKU_IGNORE
11830         },
11831         [ALC662_FIXUP_ASUS_MODE5] = {
11832                 .type = HDA_FIXUP_PINS,
11833                 .v.pins = (const struct hda_pintbl[]) {
11834                         { 0x14, 0x99130110 }, /* speaker */
11835                         { 0x15, 0x0121441f }, /* HP */
11836                         { 0x16, 0x99130111 }, /* speaker */
11837                         { 0x18, 0x01a19840 }, /* mic */
11838                         { 0x19, 0x99a3094f }, /* int-mic */
11839                         { }
11840                 },
11841                 .chained = true,
11842                 .chain_id = ALC662_FIXUP_SKU_IGNORE
11843         },
11844         [ALC662_FIXUP_ASUS_MODE6] = {
11845                 .type = HDA_FIXUP_PINS,
11846                 .v.pins = (const struct hda_pintbl[]) {
11847                         { 0x14, 0x99130110 }, /* speaker */
11848                         { 0x15, 0x01211420 }, /* HP2 */
11849                         { 0x18, 0x01a19840 }, /* mic */
11850                         { 0x19, 0x99a3094f }, /* int-mic */
11851                         { 0x1b, 0x0121441f }, /* HP */
11852                         { }
11853                 },
11854                 .chained = true,
11855                 .chain_id = ALC662_FIXUP_SKU_IGNORE
11856         },
11857         [ALC662_FIXUP_ASUS_MODE7] = {
11858                 .type = HDA_FIXUP_PINS,
11859                 .v.pins = (const struct hda_pintbl[]) {
11860                         { 0x14, 0x99130110 }, /* speaker */
11861                         { 0x17, 0x99130111 }, /* speaker */
11862                         { 0x18, 0x01a19840 }, /* mic */
11863                         { 0x19, 0x99a3094f }, /* int-mic */
11864                         { 0x1b, 0x01214020 }, /* HP */
11865                         { 0x21, 0x0121401f }, /* HP */
11866                         { }
11867                 },
11868                 .chained = true,
11869                 .chain_id = ALC662_FIXUP_SKU_IGNORE
11870         },
11871         [ALC662_FIXUP_ASUS_MODE8] = {
11872                 .type = HDA_FIXUP_PINS,
11873                 .v.pins = (const struct hda_pintbl[]) {
11874                         { 0x14, 0x99130110 }, /* speaker */
11875                         { 0x12, 0x99a30970 }, /* int-mic */
11876                         { 0x15, 0x01214020 }, /* HP */
11877                         { 0x17, 0x99130111 }, /* speaker */
11878                         { 0x18, 0x01a19840 }, /* mic */
11879                         { 0x21, 0x0121401f }, /* HP */
11880                         { }
11881                 },
11882                 .chained = true,
11883                 .chain_id = ALC662_FIXUP_SKU_IGNORE
11884         },
11885         [ALC662_FIXUP_NO_JACK_DETECT] = {
11886                 .type = HDA_FIXUP_FUNC,
11887                 .v.func = alc_fixup_no_jack_detect,
11888         },
11889         [ALC662_FIXUP_ZOTAC_Z68] = {
11890                 .type = HDA_FIXUP_PINS,
11891                 .v.pins = (const struct hda_pintbl[]) {
11892                         { 0x1b, 0x02214020 }, /* Front HP */
11893                         { }
11894                 }
11895         },
11896         [ALC662_FIXUP_INV_DMIC] = {
11897                 .type = HDA_FIXUP_FUNC,
11898                 .v.func = alc_fixup_inv_dmic,
11899         },
11900         [ALC668_FIXUP_DELL_XPS13] = {
11901                 .type = HDA_FIXUP_FUNC,
11902                 .v.func = alc_fixup_dell_xps13,
11903                 .chained = true,
11904                 .chain_id = ALC668_FIXUP_DELL_DISABLE_AAMIX
11905         },
11906         [ALC668_FIXUP_DELL_DISABLE_AAMIX] = {
11907                 .type = HDA_FIXUP_FUNC,
11908                 .v.func = alc_fixup_disable_aamix,
11909                 .chained = true,
11910                 .chain_id = ALC668_FIXUP_DELL_MIC_NO_PRESENCE
11911         },
11912         [ALC668_FIXUP_AUTO_MUTE] = {
11913                 .type = HDA_FIXUP_FUNC,
11914                 .v.func = alc_fixup_auto_mute_via_amp,
11915                 .chained = true,
11916                 .chain_id = ALC668_FIXUP_DELL_MIC_NO_PRESENCE
11917         },
11918         [ALC662_FIXUP_DELL_MIC_NO_PRESENCE] = {
11919                 .type = HDA_FIXUP_PINS,
11920                 .v.pins = (const struct hda_pintbl[]) {
11921                         { 0x19, 0x03a1113c }, /* use as headset mic, without its own jack detect */
11922                         /* headphone mic by setting pin control of 0x1b (headphone out) to in + vref_50 */
11923                         { }
11924                 },
11925                 .chained = true,
11926                 .chain_id = ALC662_FIXUP_HEADSET_MODE
11927         },
11928         [ALC662_FIXUP_HEADSET_MODE] = {
11929                 .type = HDA_FIXUP_FUNC,
11930                 .v.func = alc_fixup_headset_mode_alc662,
11931         },
11932         [ALC668_FIXUP_DELL_MIC_NO_PRESENCE] = {
11933                 .type = HDA_FIXUP_PINS,
11934                 .v.pins = (const struct hda_pintbl[]) {
11935                         { 0x19, 0x03a1913d }, /* use as headphone mic, without its own jack detect */
11936                         { 0x1b, 0x03a1113c }, /* use as headset mic, without its own jack detect */
11937                         { }
11938                 },
11939                 .chained = true,
11940                 .chain_id = ALC668_FIXUP_HEADSET_MODE
11941         },
11942         [ALC668_FIXUP_HEADSET_MODE] = {
11943                 .type = HDA_FIXUP_FUNC,
11944                 .v.func = alc_fixup_headset_mode_alc668,
11945         },
11946         [ALC662_FIXUP_BASS_MODE4_CHMAP] = {
11947                 .type = HDA_FIXUP_FUNC,
11948                 .v.func = alc_fixup_bass_chmap,
11949                 .chained = true,
11950                 .chain_id = ALC662_FIXUP_ASUS_MODE4
11951         },
11952         [ALC662_FIXUP_BASS_16] = {
11953                 .type = HDA_FIXUP_PINS,
11954                 .v.pins = (const struct hda_pintbl[]) {
11955                         {0x16, 0x80106111}, /* bass speaker */
11956                         {}
11957                 },
11958                 .chained = true,
11959                 .chain_id = ALC662_FIXUP_BASS_CHMAP,
11960         },
11961         [ALC662_FIXUP_BASS_1A] = {
11962                 .type = HDA_FIXUP_PINS,
11963                 .v.pins = (const struct hda_pintbl[]) {
11964                         {0x1a, 0x80106111}, /* bass speaker */
11965                         {}
11966                 },
11967                 .chained = true,
11968                 .chain_id = ALC662_FIXUP_BASS_CHMAP,
11969         },
11970         [ALC662_FIXUP_BASS_CHMAP] = {
11971                 .type = HDA_FIXUP_FUNC,
11972                 .v.func = alc_fixup_bass_chmap,
11973         },
11974         [ALC662_FIXUP_ASUS_Nx50] = {
11975                 .type = HDA_FIXUP_FUNC,
11976                 .v.func = alc_fixup_auto_mute_via_amp,
11977                 .chained = true,
11978                 .chain_id = ALC662_FIXUP_BASS_1A
11979         },
11980         [ALC668_FIXUP_ASUS_Nx51_HEADSET_MODE] = {
11981                 .type = HDA_FIXUP_FUNC,
11982                 .v.func = alc_fixup_headset_mode_alc668,
11983                 .chain_id = ALC662_FIXUP_BASS_CHMAP
11984         },
11985         [ALC668_FIXUP_ASUS_Nx51] = {
11986                 .type = HDA_FIXUP_PINS,
11987                 .v.pins = (const struct hda_pintbl[]) {
11988                         { 0x19, 0x03a1913d }, /* use as headphone mic, without its own jack detect */
11989                         { 0x1a, 0x90170151 }, /* bass speaker */
11990                         { 0x1b, 0x03a1113c }, /* use as headset mic, without its own jack detect */
11991                         {}
11992                 },
11993                 .chained = true,
11994                 .chain_id = ALC668_FIXUP_ASUS_Nx51_HEADSET_MODE,
11995         },
11996         [ALC668_FIXUP_MIC_COEF] = {
11997                 .type = HDA_FIXUP_VERBS,
11998                 .v.verbs = (const struct hda_verb[]) {
11999                         { 0x20, AC_VERB_SET_COEF_INDEX, 0xc3 },
12000                         { 0x20, AC_VERB_SET_PROC_COEF, 0x4000 },
12001                         {}
12002                 },
12003         },
12004         [ALC668_FIXUP_ASUS_G751] = {
12005                 .type = HDA_FIXUP_PINS,
12006                 .v.pins = (const struct hda_pintbl[]) {
12007                         { 0x16, 0x0421101f }, /* HP */
12008                         {}
12009                 },
12010                 .chained = true,
12011                 .chain_id = ALC668_FIXUP_MIC_COEF
12012         },
12013         [ALC891_FIXUP_HEADSET_MODE] = {
12014                 .type = HDA_FIXUP_FUNC,
12015                 .v.func = alc_fixup_headset_mode,
12016         },
12017         [ALC891_FIXUP_DELL_MIC_NO_PRESENCE] = {
12018                 .type = HDA_FIXUP_PINS,
12019                 .v.pins = (const struct hda_pintbl[]) {
12020                         { 0x19, 0x03a1913d }, /* use as headphone mic, without its own jack detect */
12021                         { 0x1b, 0x03a1113c }, /* use as headset mic, without its own jack detect */
12022                         { }
12023                 },
12024                 .chained = true,
12025                 .chain_id = ALC891_FIXUP_HEADSET_MODE
12026         },
12027         [ALC662_FIXUP_ACER_VERITON] = {
12028                 .type = HDA_FIXUP_PINS,
12029                 .v.pins = (const struct hda_pintbl[]) {
12030                         { 0x15, 0x50170120 }, /* no internal speaker */
12031                         { }
12032                 }
12033         },
12034         [ALC892_FIXUP_ASROCK_MOBO] = {
12035                 .type = HDA_FIXUP_PINS,
12036                 .v.pins = (const struct hda_pintbl[]) {
12037                         { 0x15, 0x40f000f0 }, /* disabled */
12038                         { 0x16, 0x40f000f0 }, /* disabled */
12039                         { }
12040                 }
12041         },
12042         [ALC662_FIXUP_USI_FUNC] = {
12043                 .type = HDA_FIXUP_FUNC,
12044                 .v.func = alc662_fixup_usi_headset_mic,
12045         },
12046         [ALC662_FIXUP_USI_HEADSET_MODE] = {
12047                 .type = HDA_FIXUP_PINS,
12048                 .v.pins = (const struct hda_pintbl[]) {
12049                         { 0x19, 0x02a1913c }, /* use as headset mic, without its own jack detect */
12050                         { 0x18, 0x01a1903d },
12051                         { }
12052                 },
12053                 .chained = true,
12054                 .chain_id = ALC662_FIXUP_USI_FUNC
12055         },
12056         [ALC662_FIXUP_LENOVO_MULTI_CODECS] = {
12057                 .type = HDA_FIXUP_FUNC,
12058                 .v.func = alc233_alc662_fixup_lenovo_dual_codecs,
12059         },
12060         [ALC669_FIXUP_ACER_ASPIRE_ETHOS_HEADSET] = {
12061                 .type = HDA_FIXUP_FUNC,
12062                 .v.func = alc662_fixup_aspire_ethos_hp,
12063         },
12064         [ALC669_FIXUP_ACER_ASPIRE_ETHOS] = {
12065                 .type = HDA_FIXUP_PINS,
12066                 .v.pins = (const struct hda_pintbl[]) {
12067                         { 0x15, 0x92130110 }, /* front speakers */
12068                         { 0x18, 0x99130111 }, /* center/subwoofer */
12069                         { 0x1b, 0x11130012 }, /* surround plus jack for HP */
12070                         { }
12071                 },
12072                 .chained = true,
12073                 .chain_id = ALC669_FIXUP_ACER_ASPIRE_ETHOS_HEADSET
12074         },
12075         [ALC671_FIXUP_HP_HEADSET_MIC2] = {
12076                 .type = HDA_FIXUP_FUNC,
12077                 .v.func = alc671_fixup_hp_headset_mic2,
12078         },
12079         [ALC662_FIXUP_ACER_X2660G_HEADSET_MODE] = {
12080                 .type = HDA_FIXUP_PINS,
12081                 .v.pins = (const struct hda_pintbl[]) {
12082                         { 0x1a, 0x02a1113c }, /* use as headset mic, without its own jack detect */
12083                         { }
12084                 },
12085                 .chained = true,
12086                 .chain_id = ALC662_FIXUP_USI_FUNC
12087         },
12088         [ALC662_FIXUP_ACER_NITRO_HEADSET_MODE] = {
12089                 .type = HDA_FIXUP_PINS,
12090                 .v.pins = (const struct hda_pintbl[]) {
12091                         { 0x1a, 0x01a11140 }, /* use as headset mic, without its own jack detect */
12092                         { 0x1b, 0x0221144f },
12093                         { }
12094                 },
12095                 .chained = true,
12096                 .chain_id = ALC662_FIXUP_USI_FUNC
12097         },
12098         [ALC668_FIXUP_ASUS_NO_HEADSET_MIC] = {
12099                 .type = HDA_FIXUP_PINS,
12100                 .v.pins = (const struct hda_pintbl[]) {
12101                         { 0x1b, 0x04a1112c },
12102                         { }
12103                 },
12104                 .chained = true,
12105                 .chain_id = ALC668_FIXUP_HEADSET_MIC
12106         },
12107         [ALC668_FIXUP_HEADSET_MIC] = {
12108                 .type = HDA_FIXUP_FUNC,
12109                 .v.func = alc269_fixup_headset_mic,
12110                 .chained = true,
12111                 .chain_id = ALC668_FIXUP_MIC_DET_COEF
12112         },
12113         [ALC668_FIXUP_MIC_DET_COEF] = {
12114                 .type = HDA_FIXUP_VERBS,
12115                 .v.verbs = (const struct hda_verb[]) {
12116                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x15 },
12117                         { 0x20, AC_VERB_SET_PROC_COEF, 0x0d60 },
12118                         {}
12119                 },
12120         },
12121         [ALC897_FIXUP_LENOVO_HEADSET_MIC] = {
12122                 .type = HDA_FIXUP_FUNC,
12123                 .v.func = alc897_fixup_lenovo_headset_mic,
12124         },
12125         [ALC897_FIXUP_HEADSET_MIC_PIN] = {
12126                 .type = HDA_FIXUP_PINS,
12127                 .v.pins = (const struct hda_pintbl[]) {
12128                         { 0x1a, 0x03a11050 },
12129                         { }
12130                 },
12131                 .chained = true,
12132                 .chain_id = ALC897_FIXUP_LENOVO_HEADSET_MIC
12133         },
12134         [ALC897_FIXUP_HP_HSMIC_VERB] = {
12135                 .type = HDA_FIXUP_PINS,
12136                 .v.pins = (const struct hda_pintbl[]) {
12137                         { 0x19, 0x01a1913c }, /* use as headset mic, without its own jack detect */
12138                         { }
12139                 },
12140         },
12141         [ALC897_FIXUP_LENOVO_HEADSET_MODE] = {
12142                 .type = HDA_FIXUP_FUNC,
12143                 .v.func = alc897_fixup_lenovo_headset_mode,
12144         },
12145         [ALC897_FIXUP_HEADSET_MIC_PIN2] = {
12146                 .type = HDA_FIXUP_PINS,
12147                 .v.pins = (const struct hda_pintbl[]) {
12148                         { 0x1a, 0x01a11140 }, /* use as headset mic, without its own jack detect */
12149                         { }
12150                 },
12151                 .chained = true,
12152                 .chain_id = ALC897_FIXUP_LENOVO_HEADSET_MODE
12153         },
12154         [ALC897_FIXUP_UNIS_H3C_X500S] = {
12155                 .type = HDA_FIXUP_VERBS,
12156                 .v.verbs = (const struct hda_verb[]) {
12157                         { 0x14, AC_VERB_SET_EAPD_BTLENABLE, 0 },
12158                         {}
12159                 },
12160         },
12161 };
12162
12163 static const struct snd_pci_quirk alc662_fixup_tbl[] = {
12164         SND_PCI_QUIRK(0x1019, 0x9087, "ECS", ALC662_FIXUP_ASUS_MODE2),
12165         SND_PCI_QUIRK(0x1025, 0x022f, "Acer Aspire One", ALC662_FIXUP_INV_DMIC),
12166         SND_PCI_QUIRK(0x1025, 0x0241, "Packard Bell DOTS", ALC662_FIXUP_INV_DMIC),
12167         SND_PCI_QUIRK(0x1025, 0x0308, "Acer Aspire 8942G", ALC662_FIXUP_ASPIRE),
12168         SND_PCI_QUIRK(0x1025, 0x031c, "Gateway NV79", ALC662_FIXUP_SKU_IGNORE),
12169         SND_PCI_QUIRK(0x1025, 0x0349, "eMachines eM250", ALC662_FIXUP_INV_DMIC),
12170         SND_PCI_QUIRK(0x1025, 0x034a, "Gateway LT27", ALC662_FIXUP_INV_DMIC),
12171         SND_PCI_QUIRK(0x1025, 0x038b, "Acer Aspire 8943G", ALC662_FIXUP_ASPIRE),
12172         SND_PCI_QUIRK(0x1025, 0x0566, "Acer Aspire Ethos 8951G", ALC669_FIXUP_ACER_ASPIRE_ETHOS),
12173         SND_PCI_QUIRK(0x1025, 0x123c, "Acer Nitro N50-600", ALC662_FIXUP_ACER_NITRO_HEADSET_MODE),
12174         SND_PCI_QUIRK(0x1025, 0x124e, "Acer 2660G", ALC662_FIXUP_ACER_X2660G_HEADSET_MODE),
12175         SND_PCI_QUIRK(0x1028, 0x05d8, "Dell", ALC668_FIXUP_DELL_MIC_NO_PRESENCE),
12176         SND_PCI_QUIRK(0x1028, 0x05db, "Dell", ALC668_FIXUP_DELL_MIC_NO_PRESENCE),
12177         SND_PCI_QUIRK(0x1028, 0x05fe, "Dell XPS 15", ALC668_FIXUP_DELL_XPS13),
12178         SND_PCI_QUIRK(0x1028, 0x060a, "Dell XPS 13", ALC668_FIXUP_DELL_XPS13),
12179         SND_PCI_QUIRK(0x1028, 0x060d, "Dell M3800", ALC668_FIXUP_DELL_XPS13),
12180         SND_PCI_QUIRK(0x1028, 0x0625, "Dell", ALC668_FIXUP_DELL_MIC_NO_PRESENCE),
12181         SND_PCI_QUIRK(0x1028, 0x0626, "Dell", ALC668_FIXUP_DELL_MIC_NO_PRESENCE),
12182         SND_PCI_QUIRK(0x1028, 0x0696, "Dell", ALC668_FIXUP_DELL_MIC_NO_PRESENCE),
12183         SND_PCI_QUIRK(0x1028, 0x0698, "Dell", ALC668_FIXUP_DELL_MIC_NO_PRESENCE),
12184         SND_PCI_QUIRK(0x1028, 0x069f, "Dell", ALC668_FIXUP_DELL_MIC_NO_PRESENCE),
12185         SND_PCI_QUIRK(0x103c, 0x1632, "HP RP5800", ALC662_FIXUP_HP_RP5800),
12186         SND_PCI_QUIRK(0x103c, 0x870c, "HP", ALC897_FIXUP_HP_HSMIC_VERB),
12187         SND_PCI_QUIRK(0x103c, 0x8719, "HP", ALC897_FIXUP_HP_HSMIC_VERB),
12188         SND_PCI_QUIRK(0x103c, 0x872b, "HP", ALC897_FIXUP_HP_HSMIC_VERB),
12189         SND_PCI_QUIRK(0x103c, 0x873e, "HP", ALC671_FIXUP_HP_HEADSET_MIC2),
12190         SND_PCI_QUIRK(0x103c, 0x8768, "HP Slim Desktop S01", ALC671_FIXUP_HP_HEADSET_MIC2),
12191         SND_PCI_QUIRK(0x103c, 0x877e, "HP 288 Pro G6", ALC671_FIXUP_HP_HEADSET_MIC2),
12192         SND_PCI_QUIRK(0x103c, 0x885f, "HP 288 Pro G8", ALC671_FIXUP_HP_HEADSET_MIC2),
12193         SND_PCI_QUIRK(0x1043, 0x1080, "Asus UX501VW", ALC668_FIXUP_HEADSET_MODE),
12194         SND_PCI_QUIRK(0x1043, 0x11cd, "Asus N550", ALC662_FIXUP_ASUS_Nx50),
12195         SND_PCI_QUIRK(0x1043, 0x129d, "Asus N750", ALC662_FIXUP_ASUS_Nx50),
12196         SND_PCI_QUIRK(0x1043, 0x12ff, "ASUS G751", ALC668_FIXUP_ASUS_G751),
12197         SND_PCI_QUIRK(0x1043, 0x13df, "Asus N550JX", ALC662_FIXUP_BASS_1A),
12198         SND_PCI_QUIRK(0x1043, 0x1477, "ASUS N56VZ", ALC662_FIXUP_BASS_MODE4_CHMAP),
12199         SND_PCI_QUIRK(0x1043, 0x15a7, "ASUS UX51VZH", ALC662_FIXUP_BASS_16),
12200         SND_PCI_QUIRK(0x1043, 0x177d, "ASUS N551", ALC668_FIXUP_ASUS_Nx51),
12201         SND_PCI_QUIRK(0x1043, 0x17bd, "ASUS N751", ALC668_FIXUP_ASUS_Nx51),
12202         SND_PCI_QUIRK(0x1043, 0x185d, "ASUS G551JW", ALC668_FIXUP_ASUS_NO_HEADSET_MIC),
12203         SND_PCI_QUIRK(0x1043, 0x1963, "ASUS X71SL", ALC662_FIXUP_ASUS_MODE8),
12204         SND_PCI_QUIRK(0x1043, 0x1b73, "ASUS N55SF", ALC662_FIXUP_BASS_16),
12205         SND_PCI_QUIRK(0x1043, 0x1bf3, "ASUS N76VZ", ALC662_FIXUP_BASS_MODE4_CHMAP),
12206         SND_PCI_QUIRK(0x1043, 0x8469, "ASUS mobo", ALC662_FIXUP_NO_JACK_DETECT),
12207         SND_PCI_QUIRK(0x105b, 0x0cd6, "Foxconn", ALC662_FIXUP_ASUS_MODE2),
12208         SND_PCI_QUIRK(0x144d, 0xc051, "Samsung R720", ALC662_FIXUP_IDEAPAD),
12209         SND_PCI_QUIRK(0x14cd, 0x5003, "USI", ALC662_FIXUP_USI_HEADSET_MODE),
12210         SND_PCI_QUIRK(0x17aa, 0x1036, "Lenovo P520", ALC662_FIXUP_LENOVO_MULTI_CODECS),
12211         SND_PCI_QUIRK(0x17aa, 0x1057, "Lenovo P360", ALC897_FIXUP_HEADSET_MIC_PIN),
12212         SND_PCI_QUIRK(0x17aa, 0x1064, "Lenovo P3 Tower", ALC897_FIXUP_HEADSET_MIC_PIN),
12213         SND_PCI_QUIRK(0x17aa, 0x32ca, "Lenovo ThinkCentre M80", ALC897_FIXUP_HEADSET_MIC_PIN),
12214         SND_PCI_QUIRK(0x17aa, 0x32cb, "Lenovo ThinkCentre M70", ALC897_FIXUP_HEADSET_MIC_PIN),
12215         SND_PCI_QUIRK(0x17aa, 0x32cf, "Lenovo ThinkCentre M950", ALC897_FIXUP_HEADSET_MIC_PIN),
12216         SND_PCI_QUIRK(0x17aa, 0x32f7, "Lenovo ThinkCentre M90", ALC897_FIXUP_HEADSET_MIC_PIN),
12217         SND_PCI_QUIRK(0x17aa, 0x3321, "Lenovo ThinkCentre M70 Gen4", ALC897_FIXUP_HEADSET_MIC_PIN),
12218         SND_PCI_QUIRK(0x17aa, 0x331b, "Lenovo ThinkCentre M90 Gen4", ALC897_FIXUP_HEADSET_MIC_PIN),
12219         SND_PCI_QUIRK(0x17aa, 0x3364, "Lenovo ThinkCentre M90 Gen5", ALC897_FIXUP_HEADSET_MIC_PIN),
12220         SND_PCI_QUIRK(0x17aa, 0x3742, "Lenovo TianYi510Pro-14IOB", ALC897_FIXUP_HEADSET_MIC_PIN2),
12221         SND_PCI_QUIRK(0x17aa, 0x38af, "Lenovo Ideapad Y550P", ALC662_FIXUP_IDEAPAD),
12222         SND_PCI_QUIRK(0x17aa, 0x3a0d, "Lenovo Ideapad Y550", ALC662_FIXUP_IDEAPAD),
12223         SND_PCI_QUIRK(0x1849, 0x5892, "ASRock B150M", ALC892_FIXUP_ASROCK_MOBO),
12224         SND_PCI_QUIRK(0x19da, 0xa130, "Zotac Z68", ALC662_FIXUP_ZOTAC_Z68),
12225         SND_PCI_QUIRK(0x1b0a, 0x01b8, "ACER Veriton", ALC662_FIXUP_ACER_VERITON),
12226         SND_PCI_QUIRK(0x1b35, 0x1234, "CZC ET26", ALC662_FIXUP_CZC_ET26),
12227         SND_PCI_QUIRK(0x1b35, 0x2206, "CZC P10T", ALC662_FIXUP_CZC_P10T),
12228         SND_PCI_QUIRK(0x1c6c, 0x1239, "Compaq N14JP6-V2", ALC897_FIXUP_HP_HSMIC_VERB),
12229
12230 #if 0
12231         /* Below is a quirk table taken from the old code.
12232          * Basically the device should work as is without the fixup table.
12233          * If BIOS doesn't give a proper info, enable the corresponding
12234          * fixup entry.
12235          */
12236         SND_PCI_QUIRK(0x1043, 0x1000, "ASUS N50Vm", ALC662_FIXUP_ASUS_MODE1),
12237         SND_PCI_QUIRK(0x1043, 0x1092, "ASUS NB", ALC662_FIXUP_ASUS_MODE3),
12238         SND_PCI_QUIRK(0x1043, 0x1173, "ASUS K73Jn", ALC662_FIXUP_ASUS_MODE1),
12239         SND_PCI_QUIRK(0x1043, 0x11c3, "ASUS M70V", ALC662_FIXUP_ASUS_MODE3),
12240         SND_PCI_QUIRK(0x1043, 0x11d3, "ASUS NB", ALC662_FIXUP_ASUS_MODE1),
12241         SND_PCI_QUIRK(0x1043, 0x11f3, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),
12242         SND_PCI_QUIRK(0x1043, 0x1203, "ASUS NB", ALC662_FIXUP_ASUS_MODE1),
12243         SND_PCI_QUIRK(0x1043, 0x1303, "ASUS G60J", ALC662_FIXUP_ASUS_MODE1),
12244         SND_PCI_QUIRK(0x1043, 0x1333, "ASUS G60Jx", ALC662_FIXUP_ASUS_MODE1),
12245         SND_PCI_QUIRK(0x1043, 0x1339, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),
12246         SND_PCI_QUIRK(0x1043, 0x13e3, "ASUS N71JA", ALC662_FIXUP_ASUS_MODE7),
12247         SND_PCI_QUIRK(0x1043, 0x1463, "ASUS N71", ALC662_FIXUP_ASUS_MODE7),
12248         SND_PCI_QUIRK(0x1043, 0x14d3, "ASUS G72", ALC662_FIXUP_ASUS_MODE8),
12249         SND_PCI_QUIRK(0x1043, 0x1563, "ASUS N90", ALC662_FIXUP_ASUS_MODE3),
12250         SND_PCI_QUIRK(0x1043, 0x15d3, "ASUS N50SF F50SF", ALC662_FIXUP_ASUS_MODE1),
12251         SND_PCI_QUIRK(0x1043, 0x16c3, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),
12252         SND_PCI_QUIRK(0x1043, 0x16f3, "ASUS K40C K50C", ALC662_FIXUP_ASUS_MODE2),
12253         SND_PCI_QUIRK(0x1043, 0x1733, "ASUS N81De", ALC662_FIXUP_ASUS_MODE1),
12254         SND_PCI_QUIRK(0x1043, 0x1753, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),
12255         SND_PCI_QUIRK(0x1043, 0x1763, "ASUS NB", ALC662_FIXUP_ASUS_MODE6),
12256         SND_PCI_QUIRK(0x1043, 0x1765, "ASUS NB", ALC662_FIXUP_ASUS_MODE6),
12257         SND_PCI_QUIRK(0x1043, 0x1783, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),
12258         SND_PCI_QUIRK(0x1043, 0x1793, "ASUS F50GX", ALC662_FIXUP_ASUS_MODE1),
12259         SND_PCI_QUIRK(0x1043, 0x17b3, "ASUS F70SL", ALC662_FIXUP_ASUS_MODE3),
12260         SND_PCI_QUIRK(0x1043, 0x17f3, "ASUS X58LE", ALC662_FIXUP_ASUS_MODE2),
12261         SND_PCI_QUIRK(0x1043, 0x1813, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),
12262         SND_PCI_QUIRK(0x1043, 0x1823, "ASUS NB", ALC662_FIXUP_ASUS_MODE5),
12263         SND_PCI_QUIRK(0x1043, 0x1833, "ASUS NB", ALC662_FIXUP_ASUS_MODE6),
12264         SND_PCI_QUIRK(0x1043, 0x1843, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),
12265         SND_PCI_QUIRK(0x1043, 0x1853, "ASUS F50Z", ALC662_FIXUP_ASUS_MODE1),
12266         SND_PCI_QUIRK(0x1043, 0x1864, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),
12267         SND_PCI_QUIRK(0x1043, 0x1876, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),
12268         SND_PCI_QUIRK(0x1043, 0x1893, "ASUS M50Vm", ALC662_FIXUP_ASUS_MODE3),
12269         SND_PCI_QUIRK(0x1043, 0x1894, "ASUS X55", ALC662_FIXUP_ASUS_MODE3),
12270         SND_PCI_QUIRK(0x1043, 0x18b3, "ASUS N80Vc", ALC662_FIXUP_ASUS_MODE1),
12271         SND_PCI_QUIRK(0x1043, 0x18c3, "ASUS VX5", ALC662_FIXUP_ASUS_MODE1),
12272         SND_PCI_QUIRK(0x1043, 0x18d3, "ASUS N81Te", ALC662_FIXUP_ASUS_MODE1),
12273         SND_PCI_QUIRK(0x1043, 0x18f3, "ASUS N505Tp", ALC662_FIXUP_ASUS_MODE1),
12274         SND_PCI_QUIRK(0x1043, 0x1903, "ASUS F5GL", ALC662_FIXUP_ASUS_MODE1),
12275         SND_PCI_QUIRK(0x1043, 0x1913, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),
12276         SND_PCI_QUIRK(0x1043, 0x1933, "ASUS F80Q", ALC662_FIXUP_ASUS_MODE2),
12277         SND_PCI_QUIRK(0x1043, 0x1943, "ASUS Vx3V", ALC662_FIXUP_ASUS_MODE1),
12278         SND_PCI_QUIRK(0x1043, 0x1953, "ASUS NB", ALC662_FIXUP_ASUS_MODE1),
12279         SND_PCI_QUIRK(0x1043, 0x1963, "ASUS X71C", ALC662_FIXUP_ASUS_MODE3),
12280         SND_PCI_QUIRK(0x1043, 0x1983, "ASUS N5051A", ALC662_FIXUP_ASUS_MODE1),
12281         SND_PCI_QUIRK(0x1043, 0x1993, "ASUS N20", ALC662_FIXUP_ASUS_MODE1),
12282         SND_PCI_QUIRK(0x1043, 0x19b3, "ASUS F7Z", ALC662_FIXUP_ASUS_MODE1),
12283         SND_PCI_QUIRK(0x1043, 0x19c3, "ASUS F5Z/F6x", ALC662_FIXUP_ASUS_MODE2),
12284         SND_PCI_QUIRK(0x1043, 0x19e3, "ASUS NB", ALC662_FIXUP_ASUS_MODE1),
12285         SND_PCI_QUIRK(0x1043, 0x19f3, "ASUS NB", ALC662_FIXUP_ASUS_MODE4),
12286 #endif
12287         {}
12288 };
12289
12290 static const struct hda_model_fixup alc662_fixup_models[] = {
12291         {.id = ALC662_FIXUP_ASPIRE, .name = "aspire"},
12292         {.id = ALC662_FIXUP_IDEAPAD, .name = "ideapad"},
12293         {.id = ALC272_FIXUP_MARIO, .name = "mario"},
12294         {.id = ALC662_FIXUP_HP_RP5800, .name = "hp-rp5800"},
12295         {.id = ALC662_FIXUP_ASUS_MODE1, .name = "asus-mode1"},
12296         {.id = ALC662_FIXUP_ASUS_MODE2, .name = "asus-mode2"},
12297         {.id = ALC662_FIXUP_ASUS_MODE3, .name = "asus-mode3"},
12298         {.id = ALC662_FIXUP_ASUS_MODE4, .name = "asus-mode4"},
12299         {.id = ALC662_FIXUP_ASUS_MODE5, .name = "asus-mode5"},
12300         {.id = ALC662_FIXUP_ASUS_MODE6, .name = "asus-mode6"},
12301         {.id = ALC662_FIXUP_ASUS_MODE7, .name = "asus-mode7"},
12302         {.id = ALC662_FIXUP_ASUS_MODE8, .name = "asus-mode8"},
12303         {.id = ALC662_FIXUP_ZOTAC_Z68, .name = "zotac-z68"},
12304         {.id = ALC662_FIXUP_INV_DMIC, .name = "inv-dmic"},
12305         {.id = ALC662_FIXUP_DELL_MIC_NO_PRESENCE, .name = "alc662-headset-multi"},
12306         {.id = ALC668_FIXUP_DELL_MIC_NO_PRESENCE, .name = "dell-headset-multi"},
12307         {.id = ALC662_FIXUP_HEADSET_MODE, .name = "alc662-headset"},
12308         {.id = ALC668_FIXUP_HEADSET_MODE, .name = "alc668-headset"},
12309         {.id = ALC662_FIXUP_BASS_16, .name = "bass16"},
12310         {.id = ALC662_FIXUP_BASS_1A, .name = "bass1a"},
12311         {.id = ALC668_FIXUP_AUTO_MUTE, .name = "automute"},
12312         {.id = ALC668_FIXUP_DELL_XPS13, .name = "dell-xps13"},
12313         {.id = ALC662_FIXUP_ASUS_Nx50, .name = "asus-nx50"},
12314         {.id = ALC668_FIXUP_ASUS_Nx51, .name = "asus-nx51"},
12315         {.id = ALC668_FIXUP_ASUS_G751, .name = "asus-g751"},
12316         {.id = ALC891_FIXUP_HEADSET_MODE, .name = "alc891-headset"},
12317         {.id = ALC891_FIXUP_DELL_MIC_NO_PRESENCE, .name = "alc891-headset-multi"},
12318         {.id = ALC662_FIXUP_ACER_VERITON, .name = "acer-veriton"},
12319         {.id = ALC892_FIXUP_ASROCK_MOBO, .name = "asrock-mobo"},
12320         {.id = ALC662_FIXUP_USI_HEADSET_MODE, .name = "usi-headset"},
12321         {.id = ALC662_FIXUP_LENOVO_MULTI_CODECS, .name = "dual-codecs"},
12322         {.id = ALC669_FIXUP_ACER_ASPIRE_ETHOS, .name = "aspire-ethos"},
12323         {.id = ALC897_FIXUP_UNIS_H3C_X500S, .name = "unis-h3c-x500s"},
12324         {}
12325 };
12326
12327 static const struct snd_hda_pin_quirk alc662_pin_fixup_tbl[] = {
12328         SND_HDA_PIN_QUIRK(0x10ec0867, 0x1028, "Dell", ALC891_FIXUP_DELL_MIC_NO_PRESENCE,
12329                 {0x17, 0x02211010},
12330                 {0x18, 0x01a19030},
12331                 {0x1a, 0x01813040},
12332                 {0x21, 0x01014020}),
12333         SND_HDA_PIN_QUIRK(0x10ec0867, 0x1028, "Dell", ALC891_FIXUP_DELL_MIC_NO_PRESENCE,
12334                 {0x16, 0x01813030},
12335                 {0x17, 0x02211010},
12336                 {0x18, 0x01a19040},
12337                 {0x21, 0x01014020}),
12338         SND_HDA_PIN_QUIRK(0x10ec0662, 0x1028, "Dell", ALC662_FIXUP_DELL_MIC_NO_PRESENCE,
12339                 {0x14, 0x01014010},
12340                 {0x18, 0x01a19020},
12341                 {0x1a, 0x0181302f},
12342                 {0x1b, 0x0221401f}),
12343         SND_HDA_PIN_QUIRK(0x10ec0668, 0x1028, "Dell", ALC668_FIXUP_AUTO_MUTE,
12344                 {0x12, 0x99a30130},
12345                 {0x14, 0x90170110},
12346                 {0x15, 0x0321101f},
12347                 {0x16, 0x03011020}),
12348         SND_HDA_PIN_QUIRK(0x10ec0668, 0x1028, "Dell", ALC668_FIXUP_AUTO_MUTE,
12349                 {0x12, 0x99a30140},
12350                 {0x14, 0x90170110},
12351                 {0x15, 0x0321101f},
12352                 {0x16, 0x03011020}),
12353         SND_HDA_PIN_QUIRK(0x10ec0668, 0x1028, "Dell", ALC668_FIXUP_AUTO_MUTE,
12354                 {0x12, 0x99a30150},
12355                 {0x14, 0x90170110},
12356                 {0x15, 0x0321101f},
12357                 {0x16, 0x03011020}),
12358         SND_HDA_PIN_QUIRK(0x10ec0668, 0x1028, "Dell", ALC668_FIXUP_AUTO_MUTE,
12359                 {0x14, 0x90170110},
12360                 {0x15, 0x0321101f},
12361                 {0x16, 0x03011020}),
12362         SND_HDA_PIN_QUIRK(0x10ec0668, 0x1028, "Dell XPS 15", ALC668_FIXUP_AUTO_MUTE,
12363                 {0x12, 0x90a60130},
12364                 {0x14, 0x90170110},
12365                 {0x15, 0x0321101f}),
12366         SND_HDA_PIN_QUIRK(0x10ec0671, 0x103c, "HP cPC", ALC671_FIXUP_HP_HEADSET_MIC2,
12367                 {0x14, 0x01014010},
12368                 {0x17, 0x90170150},
12369                 {0x19, 0x02a11060},
12370                 {0x1b, 0x01813030},
12371                 {0x21, 0x02211020}),
12372         SND_HDA_PIN_QUIRK(0x10ec0671, 0x103c, "HP cPC", ALC671_FIXUP_HP_HEADSET_MIC2,
12373                 {0x14, 0x01014010},
12374                 {0x18, 0x01a19040},
12375                 {0x1b, 0x01813030},
12376                 {0x21, 0x02211020}),
12377         SND_HDA_PIN_QUIRK(0x10ec0671, 0x103c, "HP cPC", ALC671_FIXUP_HP_HEADSET_MIC2,
12378                 {0x14, 0x01014020},
12379                 {0x17, 0x90170110},
12380                 {0x18, 0x01a19050},
12381                 {0x1b, 0x01813040},
12382                 {0x21, 0x02211030}),
12383         {}
12384 };
12385
12386 /*
12387  */
12388 static int patch_alc662(struct hda_codec *codec)
12389 {
12390         struct alc_spec *spec;
12391         int err;
12392
12393         err = alc_alloc_spec(codec, 0x0b);
12394         if (err < 0)
12395                 return err;
12396
12397         spec = codec->spec;
12398
12399         spec->shutup = alc_eapd_shutup;
12400
12401         /* handle multiple HPs as is */
12402         spec->parse_flags = HDA_PINCFG_NO_HP_FIXUP;
12403
12404         alc_fix_pll_init(codec, 0x20, 0x04, 15);
12405
12406         switch (codec->core.vendor_id) {
12407         case 0x10ec0668:
12408                 spec->init_hook = alc668_restore_default_value;
12409                 break;
12410         }
12411
12412         alc_pre_init(codec);
12413
12414         snd_hda_pick_fixup(codec, alc662_fixup_models,
12415                        alc662_fixup_tbl, alc662_fixups);
12416         snd_hda_pick_pin_fixup(codec, alc662_pin_fixup_tbl, alc662_fixups, true);
12417         snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE);
12418
12419         alc_auto_parse_customize_define(codec);
12420
12421         if (has_cdefine_beep(codec))
12422                 spec->gen.beep_nid = 0x01;
12423
12424         if ((alc_get_coef0(codec) & (1 << 14)) &&
12425             codec->bus->pci && codec->bus->pci->subsystem_vendor == 0x1025 &&
12426             spec->cdefine.platform_type == 1) {
12427                 err = alc_codec_rename(codec, "ALC272X");
12428                 if (err < 0)
12429                         goto error;
12430         }
12431
12432         /* automatic parse from the BIOS config */
12433         err = alc662_parse_auto_config(codec);
12434         if (err < 0)
12435                 goto error;
12436
12437         if (!spec->gen.no_analog && spec->gen.beep_nid) {
12438                 switch (codec->core.vendor_id) {
12439                 case 0x10ec0662:
12440                         err = set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
12441                         break;
12442                 case 0x10ec0272:
12443                 case 0x10ec0663:
12444                 case 0x10ec0665:
12445                 case 0x10ec0668:
12446                         err = set_beep_amp(spec, 0x0b, 0x04, HDA_INPUT);
12447                         break;
12448                 case 0x10ec0273:
12449                         err = set_beep_amp(spec, 0x0b, 0x03, HDA_INPUT);
12450                         break;
12451                 }
12452                 if (err < 0)
12453                         goto error;
12454         }
12455
12456         snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE);
12457
12458         return 0;
12459
12460  error:
12461         alc_free(codec);
12462         return err;
12463 }
12464
12465 /*
12466  * ALC680 support
12467  */
12468
12469 static int alc680_parse_auto_config(struct hda_codec *codec)
12470 {
12471         return alc_parse_auto_config(codec, NULL, NULL);
12472 }
12473
12474 /*
12475  */
12476 static int patch_alc680(struct hda_codec *codec)
12477 {
12478         int err;
12479
12480         /* ALC680 has no aa-loopback mixer */
12481         err = alc_alloc_spec(codec, 0);
12482         if (err < 0)
12483                 return err;
12484
12485         /* automatic parse from the BIOS config */
12486         err = alc680_parse_auto_config(codec);
12487         if (err < 0) {
12488                 alc_free(codec);
12489                 return err;
12490         }
12491
12492         return 0;
12493 }
12494
12495 /*
12496  * patch entries
12497  */
12498 static const struct hda_device_id snd_hda_id_realtek[] = {
12499         HDA_CODEC_ENTRY(0x10ec0215, "ALC215", patch_alc269),
12500         HDA_CODEC_ENTRY(0x10ec0221, "ALC221", patch_alc269),
12501         HDA_CODEC_ENTRY(0x10ec0222, "ALC222", patch_alc269),
12502         HDA_CODEC_ENTRY(0x10ec0225, "ALC225", patch_alc269),
12503         HDA_CODEC_ENTRY(0x10ec0230, "ALC236", patch_alc269),
12504         HDA_CODEC_ENTRY(0x10ec0231, "ALC231", patch_alc269),
12505         HDA_CODEC_ENTRY(0x10ec0233, "ALC233", patch_alc269),
12506         HDA_CODEC_ENTRY(0x10ec0234, "ALC234", patch_alc269),
12507         HDA_CODEC_ENTRY(0x10ec0235, "ALC233", patch_alc269),
12508         HDA_CODEC_ENTRY(0x10ec0236, "ALC236", patch_alc269),
12509         HDA_CODEC_ENTRY(0x10ec0245, "ALC245", patch_alc269),
12510         HDA_CODEC_ENTRY(0x10ec0255, "ALC255", patch_alc269),
12511         HDA_CODEC_ENTRY(0x10ec0256, "ALC256", patch_alc269),
12512         HDA_CODEC_ENTRY(0x10ec0257, "ALC257", patch_alc269),
12513         HDA_CODEC_ENTRY(0x10ec0260, "ALC260", patch_alc260),
12514         HDA_CODEC_ENTRY(0x10ec0262, "ALC262", patch_alc262),
12515         HDA_CODEC_ENTRY(0x10ec0267, "ALC267", patch_alc268),
12516         HDA_CODEC_ENTRY(0x10ec0268, "ALC268", patch_alc268),
12517         HDA_CODEC_ENTRY(0x10ec0269, "ALC269", patch_alc269),
12518         HDA_CODEC_ENTRY(0x10ec0270, "ALC270", patch_alc269),
12519         HDA_CODEC_ENTRY(0x10ec0272, "ALC272", patch_alc662),
12520         HDA_CODEC_ENTRY(0x10ec0274, "ALC274", patch_alc269),
12521         HDA_CODEC_ENTRY(0x10ec0275, "ALC275", patch_alc269),
12522         HDA_CODEC_ENTRY(0x10ec0276, "ALC276", patch_alc269),
12523         HDA_CODEC_ENTRY(0x10ec0280, "ALC280", patch_alc269),
12524         HDA_CODEC_ENTRY(0x10ec0282, "ALC282", patch_alc269),
12525         HDA_CODEC_ENTRY(0x10ec0283, "ALC283", patch_alc269),
12526         HDA_CODEC_ENTRY(0x10ec0284, "ALC284", patch_alc269),
12527         HDA_CODEC_ENTRY(0x10ec0285, "ALC285", patch_alc269),
12528         HDA_CODEC_ENTRY(0x10ec0286, "ALC286", patch_alc269),
12529         HDA_CODEC_ENTRY(0x10ec0287, "ALC287", patch_alc269),
12530         HDA_CODEC_ENTRY(0x10ec0288, "ALC288", patch_alc269),
12531         HDA_CODEC_ENTRY(0x10ec0289, "ALC289", patch_alc269),
12532         HDA_CODEC_ENTRY(0x10ec0290, "ALC290", patch_alc269),
12533         HDA_CODEC_ENTRY(0x10ec0292, "ALC292", patch_alc269),
12534         HDA_CODEC_ENTRY(0x10ec0293, "ALC293", patch_alc269),
12535         HDA_CODEC_ENTRY(0x10ec0294, "ALC294", patch_alc269),
12536         HDA_CODEC_ENTRY(0x10ec0295, "ALC295", patch_alc269),
12537         HDA_CODEC_ENTRY(0x10ec0298, "ALC298", patch_alc269),
12538         HDA_CODEC_ENTRY(0x10ec0299, "ALC299", patch_alc269),
12539         HDA_CODEC_ENTRY(0x10ec0300, "ALC300", patch_alc269),
12540         HDA_CODEC_ENTRY(0x10ec0623, "ALC623", patch_alc269),
12541         HDA_CODEC_REV_ENTRY(0x10ec0861, 0x100340, "ALC660", patch_alc861),
12542         HDA_CODEC_ENTRY(0x10ec0660, "ALC660-VD", patch_alc861vd),
12543         HDA_CODEC_ENTRY(0x10ec0861, "ALC861", patch_alc861),
12544         HDA_CODEC_ENTRY(0x10ec0862, "ALC861-VD", patch_alc861vd),
12545         HDA_CODEC_REV_ENTRY(0x10ec0662, 0x100002, "ALC662 rev2", patch_alc882),
12546         HDA_CODEC_REV_ENTRY(0x10ec0662, 0x100101, "ALC662 rev1", patch_alc662),
12547         HDA_CODEC_REV_ENTRY(0x10ec0662, 0x100300, "ALC662 rev3", patch_alc662),
12548         HDA_CODEC_ENTRY(0x10ec0663, "ALC663", patch_alc662),
12549         HDA_CODEC_ENTRY(0x10ec0665, "ALC665", patch_alc662),
12550         HDA_CODEC_ENTRY(0x10ec0667, "ALC667", patch_alc662),
12551         HDA_CODEC_ENTRY(0x10ec0668, "ALC668", patch_alc662),
12552         HDA_CODEC_ENTRY(0x10ec0670, "ALC670", patch_alc662),
12553         HDA_CODEC_ENTRY(0x10ec0671, "ALC671", patch_alc662),
12554         HDA_CODEC_ENTRY(0x10ec0680, "ALC680", patch_alc680),
12555         HDA_CODEC_ENTRY(0x10ec0700, "ALC700", patch_alc269),
12556         HDA_CODEC_ENTRY(0x10ec0701, "ALC701", patch_alc269),
12557         HDA_CODEC_ENTRY(0x10ec0703, "ALC703", patch_alc269),
12558         HDA_CODEC_ENTRY(0x10ec0711, "ALC711", patch_alc269),
12559         HDA_CODEC_ENTRY(0x10ec0867, "ALC891", patch_alc662),
12560         HDA_CODEC_ENTRY(0x10ec0880, "ALC880", patch_alc880),
12561         HDA_CODEC_ENTRY(0x10ec0882, "ALC882", patch_alc882),
12562         HDA_CODEC_ENTRY(0x10ec0883, "ALC883", patch_alc882),
12563         HDA_CODEC_REV_ENTRY(0x10ec0885, 0x100101, "ALC889A", patch_alc882),
12564         HDA_CODEC_REV_ENTRY(0x10ec0885, 0x100103, "ALC889A", patch_alc882),
12565         HDA_CODEC_ENTRY(0x10ec0885, "ALC885", patch_alc882),
12566         HDA_CODEC_ENTRY(0x10ec0887, "ALC887", patch_alc882),
12567         HDA_CODEC_REV_ENTRY(0x10ec0888, 0x100101, "ALC1200", patch_alc882),
12568         HDA_CODEC_ENTRY(0x10ec0888, "ALC888", patch_alc882),
12569         HDA_CODEC_ENTRY(0x10ec0889, "ALC889", patch_alc882),
12570         HDA_CODEC_ENTRY(0x10ec0892, "ALC892", patch_alc662),
12571         HDA_CODEC_ENTRY(0x10ec0897, "ALC897", patch_alc662),
12572         HDA_CODEC_ENTRY(0x10ec0899, "ALC898", patch_alc882),
12573         HDA_CODEC_ENTRY(0x10ec0900, "ALC1150", patch_alc882),
12574         HDA_CODEC_ENTRY(0x10ec0b00, "ALCS1200A", patch_alc882),
12575         HDA_CODEC_ENTRY(0x10ec1168, "ALC1220", patch_alc882),
12576         HDA_CODEC_ENTRY(0x10ec1220, "ALC1220", patch_alc882),
12577         HDA_CODEC_ENTRY(0x19e58326, "HW8326", patch_alc269),
12578         {} /* terminator */
12579 };
12580 MODULE_DEVICE_TABLE(hdaudio, snd_hda_id_realtek);
12581
12582 MODULE_LICENSE("GPL");
12583 MODULE_DESCRIPTION("Realtek HD-audio codec");
12584
12585 static struct hda_codec_driver realtek_driver = {
12586         .id = snd_hda_id_realtek,
12587 };
12588
12589 module_hda_codec_driver(realtek_driver);