sound/pci/hda/patch_realtek.c

   1 // SPDX-License-Identifier: GPL-2.0-or-later
   2 /*
   3  * Universal Interface for Intel High Definition Audio Codec
   4  *
   5  * HD audio interface patch for Realtek ALC codecs
   6  *
   7  * Copyright (c) 2004 Kailang Yang <kailang@realtek.com.tw>
   8  *                    PeiSen Hou <pshou@realtek.com.tw>
   9  *                    Takashi Iwai <tiwai@suse.de>
  10  *                    Jonathan Woithe <jwoithe@just42.net>
  11  */
  12
  13 #include <linux/acpi.h>
  14 #include <linux/init.h>
  15 #include <linux/delay.h>
  16 #include <linux/slab.h>
  17 #include <linux/pci.h>
  18 #include <linux/dmi.h>
  19 #include <linux/module.h>
  20 #include <linux/input.h>
  21 #include <linux/leds.h>
  22 #include <linux/ctype.h>
  23 #include <sound/core.h>
  24 #include <sound/jack.h>
  25 #include <sound/hda_codec.h>
  26 #include "hda_local.h"
  27 #include "hda_auto_parser.h"
  28 #include "hda_jack.h"
  29 #include "hda_generic.h"
  30 #include "hda_component.h"
  31
  32 /* keep halting ALC5505 DSP, for power saving */
  33 #define HALT_REALTEK_ALC5505
  34
  35 /* extra amp-initialization sequence types */
  36 enum {
  37         ALC_INIT_UNDEFINED,
  38         ALC_INIT_NONE,
  39         ALC_INIT_DEFAULT,
  40 };
  41
  42 enum {
  43         ALC_HEADSET_MODE_UNKNOWN,
  44         ALC_HEADSET_MODE_UNPLUGGED,
  45         ALC_HEADSET_MODE_HEADSET,
  46         ALC_HEADSET_MODE_MIC,
  47         ALC_HEADSET_MODE_HEADPHONE,
  48 };
  49
  50 enum {
  51         ALC_HEADSET_TYPE_UNKNOWN,
  52         ALC_HEADSET_TYPE_CTIA,
  53         ALC_HEADSET_TYPE_OMTP,
  54 };
  55
  56 enum {
  57         ALC_KEY_MICMUTE_INDEX,
  58 };
  59
  60 struct alc_customize_define {
  61         unsigned int  sku_cfg;
  62         unsigned char port_connectivity;
  63         unsigned char check_sum;
  64         unsigned char customization;
  65         unsigned char external_amp;
  66         unsigned int  enable_pcbeep:1;
  67         unsigned int  platform_type:1;
  68         unsigned int  swap:1;
  69         unsigned int  override:1;
  70         unsigned int  fixup:1; /* Means that this sku is set by driver, not read from hw */
  71 };
  72
  73 struct alc_coef_led {
  74         unsigned int idx;
  75         unsigned int mask;
  76         unsigned int on;
  77         unsigned int off;
  78 };
  79
  80 struct alc_spec {
  81         struct hda_gen_spec gen; /* must be at head */
  82
  83         /* codec parameterization */
  84         struct alc_customize_define cdefine;
  85         unsigned int parse_flags; /* flag for snd_hda_parse_pin_defcfg() */
  86
  87         /* GPIO bits */
  88         unsigned int gpio_mask;
  89         unsigned int gpio_dir;
  90         unsigned int gpio_data;
  91         bool gpio_write_delay;  /* add a delay before writing gpio_data */
  92
  93         /* mute LED for HP laptops, see vref_mute_led_set() */
  94         int mute_led_polarity;
  95         int micmute_led_polarity;
  96         hda_nid_t mute_led_nid;
  97         hda_nid_t cap_mute_led_nid;
  98
  99         unsigned int gpio_mute_led_mask;
 100         unsigned int gpio_mic_led_mask;
 101         struct alc_coef_led mute_led_coef;
 102         struct alc_coef_led mic_led_coef;
 103         struct mutex coef_mutex;
 104
 105         hda_nid_t headset_mic_pin;
 106         hda_nid_t headphone_mic_pin;
 107         int current_headset_mode;
 108         int current_headset_type;
 109
 110         /* hooks */
 111         void (*init_hook)(struct hda_codec *codec);
 112 #ifdef CONFIG_PM
 113         void (*power_hook)(struct hda_codec *codec);
 114 #endif
 115         void (*shutup)(struct hda_codec *codec);
 116
 117         int init_amp;
 118         int codec_variant;      /* flag for other variants */
 119         unsigned int has_alc5505_dsp:1;
 120         unsigned int no_depop_delay:1;
 121         unsigned int done_hp_init:1;
 122         unsigned int no_shutup_pins:1;
 123         unsigned int ultra_low_power:1;
 124         unsigned int has_hs_key:1;
 125         unsigned int no_internal_mic_pin:1;
 126         unsigned int en_3kpull_low:1;
 127
 128         /* for PLL fix */
 129         hda_nid_t pll_nid;
 130         unsigned int pll_coef_idx, pll_coef_bit;
 131         unsigned int coef0;
 132         struct input_dev *kb_dev;
 133         u8 alc_mute_keycode_map[1];
 134
 135         /* component binding */
 136         struct hda_component comps[HDA_MAX_COMPONENTS];
 137 };
 138
 139 /*
 140  * COEF access helper functions
 141  */
 142
 143 static void coef_mutex_lock(struct hda_codec *codec)
 144 {
 145         struct alc_spec *spec = codec->spec;
 146
 147         snd_hda_power_up_pm(codec);
 148         mutex_lock(&spec->coef_mutex);
 149 }
 150
 151 static void coef_mutex_unlock(struct hda_codec *codec)
 152 {
 153         struct alc_spec *spec = codec->spec;
 154
 155         mutex_unlock(&spec->coef_mutex);
 156         snd_hda_power_down_pm(codec);
 157 }
 158
 159 static int __alc_read_coefex_idx(struct hda_codec *codec, hda_nid_t nid,
 160                                  unsigned int coef_idx)
 161 {
 162         unsigned int val;
 163
 164         snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_COEF_INDEX, coef_idx);
 165         val = snd_hda_codec_read(codec, nid, 0, AC_VERB_GET_PROC_COEF, 0);
 166         return val;
 167 }
 168
 169 static int alc_read_coefex_idx(struct hda_codec *codec, hda_nid_t nid,
 170                                unsigned int coef_idx)
 171 {
 172         unsigned int val;
 173
 174         coef_mutex_lock(codec);
 175         val = __alc_read_coefex_idx(codec, nid, coef_idx);
 176         coef_mutex_unlock(codec);
 177         return val;
 178 }
 179
 180 #define alc_read_coef_idx(codec, coef_idx) \
 181         alc_read_coefex_idx(codec, 0x20, coef_idx)
 182
 183 static void __alc_write_coefex_idx(struct hda_codec *codec, hda_nid_t nid,
 184                                    unsigned int coef_idx, unsigned int coef_val)
 185 {
 186         snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_COEF_INDEX, coef_idx);
 187         snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_PROC_COEF, coef_val);
 188 }
 189
 190 static void alc_write_coefex_idx(struct hda_codec *codec, hda_nid_t nid,
 191                                  unsigned int coef_idx, unsigned int coef_val)
 192 {
 193         coef_mutex_lock(codec);
 194         __alc_write_coefex_idx(codec, nid, coef_idx, coef_val);
 195         coef_mutex_unlock(codec);
 196 }
 197
 198 #define alc_write_coef_idx(codec, coef_idx, coef_val) \
 199         alc_write_coefex_idx(codec, 0x20, coef_idx, coef_val)
 200
 201 static void __alc_update_coefex_idx(struct hda_codec *codec, hda_nid_t nid,
 202                                     unsigned int coef_idx, unsigned int mask,
 203                                     unsigned int bits_set)
 204 {
 205         unsigned int val = __alc_read_coefex_idx(codec, nid, coef_idx);
 206
 207         if (val != -1)
 208                 __alc_write_coefex_idx(codec, nid, coef_idx,
 209                                        (val & ~mask) | bits_set);
 210 }
 211
 212 static void alc_update_coefex_idx(struct hda_codec *codec, hda_nid_t nid,
 213                                   unsigned int coef_idx, unsigned int mask,
 214                                   unsigned int bits_set)
 215 {
 216         coef_mutex_lock(codec);
 217         __alc_update_coefex_idx(codec, nid, coef_idx, mask, bits_set);
 218         coef_mutex_unlock(codec);
 219 }
 220
 221 #define alc_update_coef_idx(codec, coef_idx, mask, bits_set)    \
 222         alc_update_coefex_idx(codec, 0x20, coef_idx, mask, bits_set)
 223
 224 /* a special bypass for COEF 0; read the cached value at the second time */
 225 static unsigned int alc_get_coef0(struct hda_codec *codec)
 226 {
 227         struct alc_spec *spec = codec->spec;
 228
 229         if (!spec->coef0)
 230                 spec->coef0 = alc_read_coef_idx(codec, 0);
 231         return spec->coef0;
 232 }
 233
 234 /* coef writes/updates batch */
 235 struct coef_fw {
 236         unsigned char nid;
 237         unsigned char idx;
 238         unsigned short mask;
 239         unsigned short val;
 240 };
 241
 242 #define UPDATE_COEFEX(_nid, _idx, _mask, _val) \
 243         { .nid = (_nid), .idx = (_idx), .mask = (_mask), .val = (_val) }
 244 #define WRITE_COEFEX(_nid, _idx, _val) UPDATE_COEFEX(_nid, _idx, -1, _val)
 245 #define WRITE_COEF(_idx, _val) WRITE_COEFEX(0x20, _idx, _val)
 246 #define UPDATE_COEF(_idx, _mask, _val) UPDATE_COEFEX(0x20, _idx, _mask, _val)
 247
 248 static void alc_process_coef_fw(struct hda_codec *codec,
 249                                 const struct coef_fw *fw)
 250 {
 251         coef_mutex_lock(codec);
 252         for (; fw->nid; fw++) {
 253                 if (fw->mask == (unsigned short)-1)
 254                         __alc_write_coefex_idx(codec, fw->nid, fw->idx, fw->val);
 255                 else
 256                         __alc_update_coefex_idx(codec, fw->nid, fw->idx,
 257                                                 fw->mask, fw->val);
 258         }
 259         coef_mutex_unlock(codec);
 260 }
 261
 262 /*
 263  * GPIO setup tables, used in initialization
 264  */
 265
 266 /* Enable GPIO mask and set output */
 267 static void alc_setup_gpio(struct hda_codec *codec, unsigned int mask)
 268 {
 269         struct alc_spec *spec = codec->spec;
 270
 271         spec->gpio_mask |= mask;
 272         spec->gpio_dir |= mask;
 273         spec->gpio_data |= mask;
 274 }
 275
 276 static void alc_write_gpio_data(struct hda_codec *codec)
 277 {
 278         struct alc_spec *spec = codec->spec;
 279
 280         snd_hda_codec_write(codec, 0x01, 0, AC_VERB_SET_GPIO_DATA,
 281                             spec->gpio_data);
 282 }
 283
 284 static void alc_update_gpio_data(struct hda_codec *codec, unsigned int mask,
 285                                  bool on)
 286 {
 287         struct alc_spec *spec = codec->spec;
 288         unsigned int oldval = spec->gpio_data;
 289
 290         if (on)
 291                 spec->gpio_data |= mask;
 292         else
 293                 spec->gpio_data &= ~mask;
 294         if (oldval != spec->gpio_data)
 295                 alc_write_gpio_data(codec);
 296 }
 297
 298 static void alc_write_gpio(struct hda_codec *codec)
 299 {
 300         struct alc_spec *spec = codec->spec;
 301
 302         if (!spec->gpio_mask)
 303                 return;
 304
 305         snd_hda_codec_write(codec, codec->core.afg, 0,
 306                             AC_VERB_SET_GPIO_MASK, spec->gpio_mask);
 307         snd_hda_codec_write(codec, codec->core.afg, 0,
 308                             AC_VERB_SET_GPIO_DIRECTION, spec->gpio_dir);
 309         if (spec->gpio_write_delay)
 310                 msleep(1);
 311         alc_write_gpio_data(codec);
 312 }
 313
 314 static void alc_fixup_gpio(struct hda_codec *codec, int action,
 315                            unsigned int mask)
 316 {
 317         if (action == HDA_FIXUP_ACT_PRE_PROBE)
 318                 alc_setup_gpio(codec, mask);
 319 }
 320
 321 static void alc_fixup_gpio1(struct hda_codec *codec,
 322                             const struct hda_fixup *fix, int action)
 323 {
 324         alc_fixup_gpio(codec, action, 0x01);
 325 }
 326
 327 static void alc_fixup_gpio2(struct hda_codec *codec,
 328                             const struct hda_fixup *fix, int action)
 329 {
 330         alc_fixup_gpio(codec, action, 0x02);
 331 }
 332
 333 static void alc_fixup_gpio3(struct hda_codec *codec,
 334                             const struct hda_fixup *fix, int action)
 335 {
 336         alc_fixup_gpio(codec, action, 0x03);
 337 }
 338
 339 static void alc_fixup_gpio4(struct hda_codec *codec,
 340                             const struct hda_fixup *fix, int action)
 341 {
 342         alc_fixup_gpio(codec, action, 0x04);
 343 }
 344
 345 static void alc_fixup_micmute_led(struct hda_codec *codec,
 346                                   const struct hda_fixup *fix, int action)
 347 {
 348         if (action == HDA_FIXUP_ACT_PRE_PROBE)
 349                 snd_hda_gen_add_micmute_led_cdev(codec, NULL);
 350 }
 351
 352 /*
 353  * Fix hardware PLL issue
 354  * On some codecs, the analog PLL gating control must be off while
 355  * the default value is 1.
 356  */
 357 static void alc_fix_pll(struct hda_codec *codec)
 358 {
 359         struct alc_spec *spec = codec->spec;
 360
 361         if (spec->pll_nid)
 362                 alc_update_coefex_idx(codec, spec->pll_nid, spec->pll_coef_idx,
 363                                       1 << spec->pll_coef_bit, 0);
 364 }
 365
 366 static void alc_fix_pll_init(struct hda_codec *codec, hda_nid_t nid,
 367                              unsigned int coef_idx, unsigned int coef_bit)
 368 {
 369         struct alc_spec *spec = codec->spec;
 370         spec->pll_nid = nid;
 371         spec->pll_coef_idx = coef_idx;
 372         spec->pll_coef_bit = coef_bit;
 373         alc_fix_pll(codec);
 374 }
 375
 376 /* update the master volume per volume-knob's unsol event */
 377 static void alc_update_knob_master(struct hda_codec *codec,
 378                                    struct hda_jack_callback *jack)
 379 {
 380         unsigned int val;
 381         struct snd_kcontrol *kctl;
 382         struct snd_ctl_elem_value *uctl;
 383
 384         kctl = snd_hda_find_mixer_ctl(codec, "Master Playback Volume");
 385         if (!kctl)
 386                 return;
 387         uctl = kzalloc(sizeof(*uctl), GFP_KERNEL);
 388         if (!uctl)
 389                 return;
 390         val = snd_hda_codec_read(codec, jack->nid, 0,
 391                                  AC_VERB_GET_VOLUME_KNOB_CONTROL, 0);
 392         val &= HDA_AMP_VOLMASK;
 393         uctl->value.integer.value[0] = val;
 394         uctl->value.integer.value[1] = val;
 395         kctl->put(kctl, uctl);
 396         kfree(uctl);
 397 }
 398
 399 static void alc880_unsol_event(struct hda_codec *codec, unsigned int res)
 400 {
 401         /* For some reason, the res given from ALC880 is broken.
 402            Here we adjust it properly. */
 403         snd_hda_jack_unsol_event(codec, res >> 2);
 404 }
 405
 406 /* Change EAPD to verb control */
 407 static void alc_fill_eapd_coef(struct hda_codec *codec)
 408 {
 409         int coef;
 410
 411         coef = alc_get_coef0(codec);
 412
 413         switch (codec->core.vendor_id) {
 414         case 0x10ec0262:
 415                 alc_update_coef_idx(codec, 0x7, 0, 1<<5);
 416                 break;
 417         case 0x10ec0267:
 418         case 0x10ec0268:
 419                 alc_update_coef_idx(codec, 0x7, 0, 1<<13);
 420                 break;
 421         case 0x10ec0269:
 422                 if ((coef & 0x00f0) == 0x0010)
 423                         alc_update_coef_idx(codec, 0xd, 0, 1<<14);
 424                 if ((coef & 0x00f0) == 0x0020)
 425                         alc_update_coef_idx(codec, 0x4, 1<<15, 0);
 426                 if ((coef & 0x00f0) == 0x0030)
 427                         alc_update_coef_idx(codec, 0x10, 1<<9, 0);
 428                 break;
 429         case 0x10ec0280:
 430         case 0x10ec0284:
 431         case 0x10ec0290:
 432         case 0x10ec0292:
 433                 alc_update_coef_idx(codec, 0x4, 1<<15, 0);
 434                 break;
 435         case 0x10ec0225:
 436         case 0x10ec0295:
 437         case 0x10ec0299:
 438                 alc_update_coef_idx(codec, 0x67, 0xf000, 0x3000);
 439                 fallthrough;
 440         case 0x10ec0215:
 441         case 0x10ec0285:
 442         case 0x10ec0289:
 443                 alc_update_coef_idx(codec, 0x36, 1<<13, 0);
 444                 fallthrough;
 445         case 0x10ec0230:
 446         case 0x10ec0233:
 447         case 0x10ec0235:
 448         case 0x10ec0236:
 449         case 0x10ec0245:
 450         case 0x10ec0255:
 451         case 0x10ec0256:
 452         case 0x19e58326:
 453         case 0x10ec0257:
 454         case 0x10ec0282:
 455         case 0x10ec0283:
 456         case 0x10ec0286:
 457         case 0x10ec0288:
 458         case 0x10ec0298:
 459         case 0x10ec0300:
 460                 alc_update_coef_idx(codec, 0x10, 1<<9, 0);
 461                 break;
 462         case 0x10ec0275:
 463                 alc_update_coef_idx(codec, 0xe, 0, 1<<0);
 464                 break;
 465         case 0x10ec0287:
 466                 alc_update_coef_idx(codec, 0x10, 1<<9, 0);
 467                 alc_write_coef_idx(codec, 0x8, 0x4ab7);
 468                 break;
 469         case 0x10ec0293:
 470                 alc_update_coef_idx(codec, 0xa, 1<<13, 0);
 471                 break;
 472         case 0x10ec0234:
 473         case 0x10ec0274:
 474         case 0x10ec0294:
 475         case 0x10ec0700:
 476         case 0x10ec0701:
 477         case 0x10ec0703:
 478         case 0x10ec0711:
 479                 alc_update_coef_idx(codec, 0x10, 1<<15, 0);
 480                 break;
 481         case 0x10ec0662:
 482                 if ((coef & 0x00f0) == 0x0030)
 483                         alc_update_coef_idx(codec, 0x4, 1<<10, 0); /* EAPD Ctrl */
 484                 break;
 485         case 0x10ec0272:
 486         case 0x10ec0273:
 487         case 0x10ec0663:
 488         case 0x10ec0665:
 489         case 0x10ec0670:
 490         case 0x10ec0671:
 491         case 0x10ec0672:
 492                 alc_update_coef_idx(codec, 0xd, 0, 1<<14); /* EAPD Ctrl */
 493                 break;
 494         case 0x10ec0222:
 495         case 0x10ec0623:
 496                 alc_update_coef_idx(codec, 0x19, 1<<13, 0);
 497                 break;
 498         case 0x10ec0668:
 499                 alc_update_coef_idx(codec, 0x7, 3<<13, 0);
 500                 break;
 501         case 0x10ec0867:
 502                 alc_update_coef_idx(codec, 0x4, 1<<10, 0);
 503                 break;
 504         case 0x10ec0888:
 505                 if ((coef & 0x00f0) == 0x0020 || (coef & 0x00f0) == 0x0030)
 506                         alc_update_coef_idx(codec, 0x7, 1<<5, 0);
 507                 break;
 508         case 0x10ec0892:
 509         case 0x10ec0897:
 510                 alc_update_coef_idx(codec, 0x7, 1<<5, 0);
 511                 break;
 512         case 0x10ec0899:
 513         case 0x10ec0900:
 514         case 0x10ec0b00:
 515         case 0x10ec1168:
 516         case 0x10ec1220:
 517                 alc_update_coef_idx(codec, 0x7, 1<<1, 0);
 518                 break;
 519         }
 520 }
 521
 522 /* additional initialization for ALC888 variants */
 523 static void alc888_coef_init(struct hda_codec *codec)
 524 {
 525         switch (alc_get_coef0(codec) & 0x00f0) {
 526         /* alc888-VA */
 527         case 0x00:
 528         /* alc888-VB */
 529         case 0x10:
 530                 alc_update_coef_idx(codec, 7, 0, 0x2030); /* Turn EAPD to High */
 531                 break;
 532         }
 533 }
 534
 535 /* turn on/off EAPD control (only if available) */
 536 static void set_eapd(struct hda_codec *codec, hda_nid_t nid, int on)
 537 {
 538         if (get_wcaps_type(get_wcaps(codec, nid)) != AC_WID_PIN)
 539                 return;
 540         if (snd_hda_query_pin_caps(codec, nid) & AC_PINCAP_EAPD)
 541                 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_EAPD_BTLENABLE,
 542                                     on ? 2 : 0);
 543 }
 544
 545 /* turn on/off EAPD controls of the codec */
 546 static void alc_auto_setup_eapd(struct hda_codec *codec, bool on)
 547 {
 548         /* We currently only handle front, HP */
 549         static const hda_nid_t pins[] = {
 550                 0x0f, 0x10, 0x14, 0x15, 0x17, 0
 551         };
 552         const hda_nid_t *p;
 553         for (p = pins; *p; p++)
 554                 set_eapd(codec, *p, on);
 555 }
 556
 557 static int find_ext_mic_pin(struct hda_codec *codec);
 558
 559 static void alc_headset_mic_no_shutup(struct hda_codec *codec)
 560 {
 561         const struct hda_pincfg *pin;
 562         int mic_pin = find_ext_mic_pin(codec);
 563         int i;
 564
 565         /* don't shut up pins when unloading the driver; otherwise it breaks
 566          * the default pin setup at the next load of the driver
 567          */
 568         if (codec->bus->shutdown)
 569                 return;
 570
 571         snd_array_for_each(&codec->init_pins, i, pin) {
 572                 /* use read here for syncing after issuing each verb */
 573                 if (pin->nid != mic_pin)
 574                         snd_hda_codec_read(codec, pin->nid, 0,
 575                                         AC_VERB_SET_PIN_WIDGET_CONTROL, 0);
 576         }
 577
 578         codec->pins_shutup = 1;
 579 }
 580
 581 static void alc_shutup_pins(struct hda_codec *codec)
 582 {
 583         struct alc_spec *spec = codec->spec;
 584
 585         switch (codec->core.vendor_id) {
 586         case 0x10ec0236:
 587         case 0x10ec0256:
 588         case 0x19e58326:
 589         case 0x10ec0283:
 590         case 0x10ec0286:
 591         case 0x10ec0288:
 592         case 0x10ec0298:
 593                 alc_headset_mic_no_shutup(codec);
 594                 break;
 595         default:
 596                 if (!spec->no_shutup_pins)
 597                         snd_hda_shutup_pins(codec);
 598                 break;
 599         }
 600 }
 601
 602 /* generic shutup callback;
 603  * just turning off EAPD and a little pause for avoiding pop-noise
 604  */
 605 static void alc_eapd_shutup(struct hda_codec *codec)
 606 {
 607         struct alc_spec *spec = codec->spec;
 608
 609         alc_auto_setup_eapd(codec, false);
 610         if (!spec->no_depop_delay)
 611                 msleep(200);
 612         alc_shutup_pins(codec);
 613 }
 614
 615 /* generic EAPD initialization */
 616 static void alc_auto_init_amp(struct hda_codec *codec, int type)
 617 {
 618         alc_auto_setup_eapd(codec, true);
 619         alc_write_gpio(codec);
 620         switch (type) {
 621         case ALC_INIT_DEFAULT:
 622                 switch (codec->core.vendor_id) {
 623                 case 0x10ec0260:
 624                         alc_update_coefex_idx(codec, 0x1a, 7, 0, 0x2010);
 625                         break;
 626                 case 0x10ec0880:
 627                 case 0x10ec0882:
 628                 case 0x10ec0883:
 629                 case 0x10ec0885:
 630                         alc_update_coef_idx(codec, 7, 0, 0x2030);
 631                         break;
 632                 case 0x10ec0888:
 633                         alc888_coef_init(codec);
 634                         break;
 635                 }
 636                 break;
 637         }
 638 }
 639
 640 /* get a primary headphone pin if available */
 641 static hda_nid_t alc_get_hp_pin(struct alc_spec *spec)
 642 {
 643         if (spec->gen.autocfg.hp_pins[0])
 644                 return spec->gen.autocfg.hp_pins[0];
 645         if (spec->gen.autocfg.line_out_type == AC_JACK_HP_OUT)
 646                 return spec->gen.autocfg.line_out_pins[0];
 647         return 0;
 648 }
 649
 650 /*
 651  * Realtek SSID verification
 652  */
 653
 654 /* Could be any non-zero and even value. When used as fixup, tells
 655  * the driver to ignore any present sku defines.
 656  */
 657 #define ALC_FIXUP_SKU_IGNORE (2)
 658
 659 static void alc_fixup_sku_ignore(struct hda_codec *codec,
 660                                  const struct hda_fixup *fix, int action)
 661 {
 662         struct alc_spec *spec = codec->spec;
 663         if (action == HDA_FIXUP_ACT_PRE_PROBE) {
 664                 spec->cdefine.fixup = 1;
 665                 spec->cdefine.sku_cfg = ALC_FIXUP_SKU_IGNORE;
 666         }
 667 }
 668
 669 static void alc_fixup_no_depop_delay(struct hda_codec *codec,
 670                                     const struct hda_fixup *fix, int action)
 671 {
 672         struct alc_spec *spec = codec->spec;
 673
 674         if (action == HDA_FIXUP_ACT_PROBE) {
 675                 spec->no_depop_delay = 1;
 676                 codec->depop_delay = 0;
 677         }
 678 }
 679
 680 static int alc_auto_parse_customize_define(struct hda_codec *codec)
 681 {
 682         unsigned int ass, tmp, i;
 683         unsigned nid = 0;
 684         struct alc_spec *spec = codec->spec;
 685
 686         spec->cdefine.enable_pcbeep = 1; /* assume always enabled */
 687
 688         if (spec->cdefine.fixup) {
 689                 ass = spec->cdefine.sku_cfg;
 690                 if (ass == ALC_FIXUP_SKU_IGNORE)
 691                         return -1;
 692                 goto do_sku;
 693         }
 694
 695         if (!codec->bus->pci)
 696                 return -1;
 697         ass = codec->core.subsystem_id & 0xffff;
 698         if (ass != codec->bus->pci->subsystem_device && (ass & 1))
 699                 goto do_sku;
 700
 701         nid = 0x1d;
 702         if (codec->core.vendor_id == 0x10ec0260)
 703                 nid = 0x17;
 704         ass = snd_hda_codec_get_pincfg(codec, nid);
 705
 706         if (!(ass & 1)) {
 707                 codec_info(codec, "%s: SKU not ready 0x%08x\n",
 708                            codec->core.chip_name, ass);
 709                 return -1;
 710         }
 711
 712         /* check sum */
 713         tmp = 0;
 714         for (i = 1; i < 16; i++) {
 715                 if ((ass >> i) & 1)
 716                         tmp++;
 717         }
 718         if (((ass >> 16) & 0xf) != tmp)
 719                 return -1;
 720
 721         spec->cdefine.port_connectivity = ass >> 30;
 722         spec->cdefine.enable_pcbeep = (ass & 0x100000) >> 20;
 723         spec->cdefine.check_sum = (ass >> 16) & 0xf;
 724         spec->cdefine.customization = ass >> 8;
 725 do_sku:
 726         spec->cdefine.sku_cfg = ass;
 727         spec->cdefine.external_amp = (ass & 0x38) >> 3;
 728         spec->cdefine.platform_type = (ass & 0x4) >> 2;
 729         spec->cdefine.swap = (ass & 0x2) >> 1;
 730         spec->cdefine.override = ass & 0x1;
 731
 732         codec_dbg(codec, "SKU: Nid=0x%x sku_cfg=0x%08x\n",
 733                    nid, spec->cdefine.sku_cfg);
 734         codec_dbg(codec, "SKU: port_connectivity=0x%x\n",
 735                    spec->cdefine.port_connectivity);
 736         codec_dbg(codec, "SKU: enable_pcbeep=0x%x\n", spec->cdefine.enable_pcbeep);
 737         codec_dbg(codec, "SKU: check_sum=0x%08x\n", spec->cdefine.check_sum);
 738         codec_dbg(codec, "SKU: customization=0x%08x\n", spec->cdefine.customization);
 739         codec_dbg(codec, "SKU: external_amp=0x%x\n", spec->cdefine.external_amp);
 740         codec_dbg(codec, "SKU: platform_type=0x%x\n", spec->cdefine.platform_type);
 741         codec_dbg(codec, "SKU: swap=0x%x\n", spec->cdefine.swap);
 742         codec_dbg(codec, "SKU: override=0x%x\n", spec->cdefine.override);
 743
 744         return 0;
 745 }
 746
 747 /* return the position of NID in the list, or -1 if not found */
 748 static int find_idx_in_nid_list(hda_nid_t nid, const hda_nid_t *list, int nums)
 749 {
 750         int i;
 751         for (i = 0; i < nums; i++)
 752                 if (list[i] == nid)
 753                         return i;
 754         return -1;
 755 }
 756 /* return true if the given NID is found in the list */
 757 static bool found_in_nid_list(hda_nid_t nid, const hda_nid_t *list, int nums)
 758 {
 759         return find_idx_in_nid_list(nid, list, nums) >= 0;
 760 }
 761
 762 /* check subsystem ID and set up device-specific initialization;
 763  * return 1 if initialized, 0 if invalid SSID
 764  */
 765 /* 32-bit subsystem ID for BIOS loading in HD Audio codec.
 766  *      31 ~ 16 :       Manufacture ID
 767  *      15 ~ 8  :       SKU ID
 768  *      7  ~ 0  :       Assembly ID
 769  *      port-A --> pin 39/41, port-E --> pin 14/15, port-D --> pin 35/36
 770  */
 771 static int alc_subsystem_id(struct hda_codec *codec, const hda_nid_t *ports)
 772 {
 773         unsigned int ass, tmp, i;
 774         unsigned nid;
 775         struct alc_spec *spec = codec->spec;
 776
 777         if (spec->cdefine.fixup) {
 778                 ass = spec->cdefine.sku_cfg;
 779                 if (ass == ALC_FIXUP_SKU_IGNORE)
 780                         return 0;
 781                 goto do_sku;
 782         }
 783
 784         ass = codec->core.subsystem_id & 0xffff;
 785         if (codec->bus->pci &&
 786             ass != codec->bus->pci->subsystem_device && (ass & 1))
 787                 goto do_sku;
 788
 789         /* invalid SSID, check the special NID pin defcfg instead */
 790         /*
 791          * 31~30        : port connectivity
 792          * 29~21        : reserve
 793          * 20           : PCBEEP input
 794          * 19~16        : Check sum (15:1)
 795          * 15~1         : Custom
 796          * 0            : override
 797         */
 798         nid = 0x1d;
 799         if (codec->core.vendor_id == 0x10ec0260)
 800                 nid = 0x17;
 801         ass = snd_hda_codec_get_pincfg(codec, nid);
 802         codec_dbg(codec,
 803                   "realtek: No valid SSID, checking pincfg 0x%08x for NID 0x%x\n",
 804                    ass, nid);
 805         if (!(ass & 1))
 806                 return 0;
 807         if ((ass >> 30) != 1)   /* no physical connection */
 808                 return 0;
 809
 810         /* check sum */
 811         tmp = 0;
 812         for (i = 1; i < 16; i++) {
 813                 if ((ass >> i) & 1)
 814                         tmp++;
 815         }
 816         if (((ass >> 16) & 0xf) != tmp)
 817                 return 0;
 818 do_sku:
 819         codec_dbg(codec, "realtek: Enabling init ASM_ID=0x%04x CODEC_ID=%08x\n",
 820                    ass & 0xffff, codec->core.vendor_id);
 821         /*
 822          * 0 : override
 823          * 1 :  Swap Jack
 824          * 2 : 0 --> Desktop, 1 --> Laptop
 825          * 3~5 : External Amplifier control
 826          * 7~6 : Reserved
 827         */
 828         tmp = (ass & 0x38) >> 3;        /* external Amp control */
 829         if (spec->init_amp == ALC_INIT_UNDEFINED) {
 830                 switch (tmp) {
 831                 case 1:
 832                         alc_setup_gpio(codec, 0x01);
 833                         break;
 834                 case 3:
 835                         alc_setup_gpio(codec, 0x02);
 836                         break;
 837                 case 7:
 838                         alc_setup_gpio(codec, 0x04);
 839                         break;
 840                 case 5:
 841                 default:
 842                         spec->init_amp = ALC_INIT_DEFAULT;
 843                         break;
 844                 }
 845         }
 846
 847         /* is laptop or Desktop and enable the function "Mute internal speaker
 848          * when the external headphone out jack is plugged"
 849          */
 850         if (!(ass & 0x8000))
 851                 return 1;
 852         /*
 853          * 10~8 : Jack location
 854          * 12~11: Headphone out -> 00: PortA, 01: PortE, 02: PortD, 03: Resvered
 855          * 14~13: Resvered
 856          * 15   : 1 --> enable the function "Mute internal speaker
 857          *              when the external headphone out jack is plugged"
 858          */
 859         if (!alc_get_hp_pin(spec)) {
 860                 hda_nid_t nid;
 861                 tmp = (ass >> 11) & 0x3;        /* HP to chassis */
 862                 nid = ports[tmp];
 863                 if (found_in_nid_list(nid, spec->gen.autocfg.line_out_pins,
 864                                       spec->gen.autocfg.line_outs))
 865                         return 1;
 866                 spec->gen.autocfg.hp_pins[0] = nid;
 867         }
 868         return 1;
 869 }
 870
 871 /* Check the validity of ALC subsystem-id
 872  * ports contains an array of 4 pin NIDs for port-A, E, D and I */
 873 static void alc_ssid_check(struct hda_codec *codec, const hda_nid_t *ports)
 874 {
 875         if (!alc_subsystem_id(codec, ports)) {
 876                 struct alc_spec *spec = codec->spec;
 877                 if (spec->init_amp == ALC_INIT_UNDEFINED) {
 878                         codec_dbg(codec,
 879                                   "realtek: Enable default setup for auto mode as fallback\n");
 880                         spec->init_amp = ALC_INIT_DEFAULT;
 881                 }
 882         }
 883 }
 884
 885 /*
 886  */
 887
 888 static void alc_fixup_inv_dmic(struct hda_codec *codec,
 889                                const struct hda_fixup *fix, int action)
 890 {
 891         struct alc_spec *spec = codec->spec;
 892
 893         spec->gen.inv_dmic_split = 1;
 894 }
 895
 896
 897 static int alc_build_controls(struct hda_codec *codec)
 898 {
 899         int err;
 900
 901         err = snd_hda_gen_build_controls(codec);
 902         if (err < 0)
 903                 return err;
 904
 905         snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_BUILD);
 906         return 0;
 907 }
 908
 909
 910 /*
 911  * Common callbacks
 912  */
 913
 914 static void alc_pre_init(struct hda_codec *codec)
 915 {
 916         alc_fill_eapd_coef(codec);
 917 }
 918
 919 #define is_s3_resume(codec) \
 920         ((codec)->core.dev.power.power_state.event == PM_EVENT_RESUME)
 921 #define is_s4_resume(codec) \
 922         ((codec)->core.dev.power.power_state.event == PM_EVENT_RESTORE)
 923
 924 static int alc_init(struct hda_codec *codec)
 925 {
 926         struct alc_spec *spec = codec->spec;
 927
 928         /* hibernation resume needs the full chip initialization */
 929         if (is_s4_resume(codec))
 930                 alc_pre_init(codec);
 931
 932         if (spec->init_hook)
 933                 spec->init_hook(codec);
 934
 935         spec->gen.skip_verbs = 1; /* applied in below */
 936         snd_hda_gen_init(codec);
 937         alc_fix_pll(codec);
 938         alc_auto_init_amp(codec, spec->init_amp);
 939         snd_hda_apply_verbs(codec); /* apply verbs here after own init */
 940
 941         snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_INIT);
 942
 943         return 0;
 944 }
 945
 946 #define alc_free        snd_hda_gen_free
 947
 948 #ifdef CONFIG_PM
 949 static inline void alc_shutup(struct hda_codec *codec)
 950 {
 951         struct alc_spec *spec = codec->spec;
 952
 953         if (!snd_hda_get_bool_hint(codec, "shutup"))
 954                 return; /* disabled explicitly by hints */
 955
 956         if (spec && spec->shutup)
 957                 spec->shutup(codec);
 958         else
 959                 alc_shutup_pins(codec);
 960 }
 961
 962 static void alc_power_eapd(struct hda_codec *codec)
 963 {
 964         alc_auto_setup_eapd(codec, false);
 965 }
 966
 967 static int alc_suspend(struct hda_codec *codec)
 968 {
 969         struct alc_spec *spec = codec->spec;
 970         alc_shutup(codec);
 971         if (spec && spec->power_hook)
 972                 spec->power_hook(codec);
 973         return 0;
 974 }
 975
 976 static int alc_resume(struct hda_codec *codec)
 977 {
 978         struct alc_spec *spec = codec->spec;
 979
 980         if (!spec->no_depop_delay)
 981                 msleep(150); /* to avoid pop noise */
 982         codec->patch_ops.init(codec);
 983         snd_hda_regmap_sync(codec);
 984         hda_call_check_power_status(codec, 0x01);
 985         return 0;
 986 }
 987 #endif
 988
 989 /*
 990  */
 991 static const struct hda_codec_ops alc_patch_ops = {
 992         .build_controls = alc_build_controls,
 993         .build_pcms = snd_hda_gen_build_pcms,
 994         .init = alc_init,
 995         .free = alc_free,
 996         .unsol_event = snd_hda_jack_unsol_event,
 997 #ifdef CONFIG_PM
 998         .resume = alc_resume,
 999         .suspend = alc_suspend,
1000         .check_power_status = snd_hda_gen_check_power_status,
1001 #endif
1002 };
1003
1004
1005 #define alc_codec_rename(codec, name) snd_hda_codec_set_name(codec, name)
1006
1007 /*
1008  * Rename codecs appropriately from COEF value or subvendor id
1009  */
1010 struct alc_codec_rename_table {
1011         unsigned int vendor_id;
1012         unsigned short coef_mask;
1013         unsigned short coef_bits;
1014         const char *name;
1015 };
1016
1017 struct alc_codec_rename_pci_table {
1018         unsigned int codec_vendor_id;
1019         unsigned short pci_subvendor;
1020         unsigned short pci_subdevice;
1021         const char *name;
1022 };
1023
1024 static const struct alc_codec_rename_table rename_tbl[] = {
1025         { 0x10ec0221, 0xf00f, 0x1003, "ALC231" },
1026         { 0x10ec0269, 0xfff0, 0x3010, "ALC277" },
1027         { 0x10ec0269, 0xf0f0, 0x2010, "ALC259" },
1028         { 0x10ec0269, 0xf0f0, 0x3010, "ALC258" },
1029         { 0x10ec0269, 0x00f0, 0x0010, "ALC269VB" },
1030         { 0x10ec0269, 0xffff, 0xa023, "ALC259" },
1031         { 0x10ec0269, 0xffff, 0x6023, "ALC281X" },
1032         { 0x10ec0269, 0x00f0, 0x0020, "ALC269VC" },
1033         { 0x10ec0269, 0x00f0, 0x0030, "ALC269VD" },
1034         { 0x10ec0662, 0xffff, 0x4020, "ALC656" },
1035         { 0x10ec0887, 0x00f0, 0x0030, "ALC887-VD" },
1036         { 0x10ec0888, 0x00f0, 0x0030, "ALC888-VD" },
1037         { 0x10ec0888, 0xf0f0, 0x3020, "ALC886" },
1038         { 0x10ec0899, 0x2000, 0x2000, "ALC899" },
1039         { 0x10ec0892, 0xffff, 0x8020, "ALC661" },
1040         { 0x10ec0892, 0xffff, 0x8011, "ALC661" },
1041         { 0x10ec0892, 0xffff, 0x4011, "ALC656" },
1042         { } /* terminator */
1043 };
1044
1045 static const struct alc_codec_rename_pci_table rename_pci_tbl[] = {
1046         { 0x10ec0280, 0x1028, 0, "ALC3220" },
1047         { 0x10ec0282, 0x1028, 0, "ALC3221" },
1048         { 0x10ec0283, 0x1028, 0, "ALC3223" },
1049         { 0x10ec0288, 0x1028, 0, "ALC3263" },
1050         { 0x10ec0292, 0x1028, 0, "ALC3226" },
1051         { 0x10ec0293, 0x1028, 0, "ALC3235" },
1052         { 0x10ec0255, 0x1028, 0, "ALC3234" },
1053         { 0x10ec0668, 0x1028, 0, "ALC3661" },
1054         { 0x10ec0275, 0x1028, 0, "ALC3260" },
1055         { 0x10ec0899, 0x1028, 0, "ALC3861" },
1056         { 0x10ec0298, 0x1028, 0, "ALC3266" },
1057         { 0x10ec0236, 0x1028, 0, "ALC3204" },
1058         { 0x10ec0256, 0x1028, 0, "ALC3246" },
1059         { 0x10ec0225, 0x1028, 0, "ALC3253" },
1060         { 0x10ec0295, 0x1028, 0, "ALC3254" },
1061         { 0x10ec0299, 0x1028, 0, "ALC3271" },
1062         { 0x10ec0670, 0x1025, 0, "ALC669X" },
1063         { 0x10ec0676, 0x1025, 0, "ALC679X" },
1064         { 0x10ec0282, 0x1043, 0, "ALC3229" },
1065         { 0x10ec0233, 0x1043, 0, "ALC3236" },
1066         { 0x10ec0280, 0x103c, 0, "ALC3228" },
1067         { 0x10ec0282, 0x103c, 0, "ALC3227" },
1068         { 0x10ec0286, 0x103c, 0, "ALC3242" },
1069         { 0x10ec0290, 0x103c, 0, "ALC3241" },
1070         { 0x10ec0668, 0x103c, 0, "ALC3662" },
1071         { 0x10ec0283, 0x17aa, 0, "ALC3239" },
1072         { 0x10ec0292, 0x17aa, 0, "ALC3232" },
1073         { } /* terminator */
1074 };
1075
1076 static int alc_codec_rename_from_preset(struct hda_codec *codec)
1077 {
1078         const struct alc_codec_rename_table *p;
1079         const struct alc_codec_rename_pci_table *q;
1080
1081         for (p = rename_tbl; p->vendor_id; p++) {
1082                 if (p->vendor_id != codec->core.vendor_id)
1083                         continue;
1084                 if ((alc_get_coef0(codec) & p->coef_mask) == p->coef_bits)
1085                         return alc_codec_rename(codec, p->name);
1086         }
1087
1088         if (!codec->bus->pci)
1089                 return 0;
1090         for (q = rename_pci_tbl; q->codec_vendor_id; q++) {
1091                 if (q->codec_vendor_id != codec->core.vendor_id)
1092                         continue;
1093                 if (q->pci_subvendor != codec->bus->pci->subsystem_vendor)
1094                         continue;
1095                 if (!q->pci_subdevice ||
1096                     q->pci_subdevice == codec->bus->pci->subsystem_device)
1097                         return alc_codec_rename(codec, q->name);
1098         }
1099
1100         return 0;
1101 }
1102
1103
1104 /*
1105  * Digital-beep handlers
1106  */
1107 #ifdef CONFIG_SND_HDA_INPUT_BEEP
1108
1109 /* additional beep mixers; private_value will be overwritten */
1110 static const struct snd_kcontrol_new alc_beep_mixer[] = {
1111         HDA_CODEC_VOLUME("Beep Playback Volume", 0, 0, HDA_INPUT),
1112         HDA_CODEC_MUTE_BEEP("Beep Playback Switch", 0, 0, HDA_INPUT),
1113 };
1114
1115 /* set up and create beep controls */
1116 static int set_beep_amp(struct alc_spec *spec, hda_nid_t nid,
1117                         int idx, int dir)
1118 {
1119         struct snd_kcontrol_new *knew;
1120         unsigned int beep_amp = HDA_COMPOSE_AMP_VAL(nid, 3, idx, dir);
1121         int i;
1122
1123         for (i = 0; i < ARRAY_SIZE(alc_beep_mixer); i++) {
1124                 knew = snd_hda_gen_add_kctl(&spec->gen, NULL,
1125                                             &alc_beep_mixer[i]);
1126                 if (!knew)
1127                         return -ENOMEM;
1128                 knew->private_value = beep_amp;
1129         }
1130         return 0;
1131 }
1132
1133 static const struct snd_pci_quirk beep_allow_list[] = {
1134         SND_PCI_QUIRK(0x1043, 0x103c, "ASUS", 1),
1135         SND_PCI_QUIRK(0x1043, 0x115d, "ASUS", 1),
1136         SND_PCI_QUIRK(0x1043, 0x829f, "ASUS", 1),
1137         SND_PCI_QUIRK(0x1043, 0x8376, "EeePC", 1),
1138         SND_PCI_QUIRK(0x1043, 0x83ce, "EeePC", 1),
1139         SND_PCI_QUIRK(0x1043, 0x831a, "EeePC", 1),
1140         SND_PCI_QUIRK(0x1043, 0x834a, "EeePC", 1),
1141         SND_PCI_QUIRK(0x1458, 0xa002, "GA-MA790X", 1),
1142         SND_PCI_QUIRK(0x8086, 0xd613, "Intel", 1),
1143         /* denylist -- no beep available */
1144         SND_PCI_QUIRK(0x17aa, 0x309e, "Lenovo ThinkCentre M73", 0),
1145         SND_PCI_QUIRK(0x17aa, 0x30a3, "Lenovo ThinkCentre M93", 0),
1146         {}
1147 };
1148
1149 static inline int has_cdefine_beep(struct hda_codec *codec)
1150 {
1151         struct alc_spec *spec = codec->spec;
1152         const struct snd_pci_quirk *q;
1153         q = snd_pci_quirk_lookup(codec->bus->pci, beep_allow_list);
1154         if (q)
1155                 return q->value;
1156         return spec->cdefine.enable_pcbeep;
1157 }
1158 #else
1159 #define set_beep_amp(spec, nid, idx, dir)       0
1160 #define has_cdefine_beep(codec)         0
1161 #endif
1162
1163 /* parse the BIOS configuration and set up the alc_spec */
1164 /* return 1 if successful, 0 if the proper config is not found,
1165  * or a negative error code
1166  */
1167 static int alc_parse_auto_config(struct hda_codec *codec,
1168                                  const hda_nid_t *ignore_nids,
1169                                  const hda_nid_t *ssid_nids)
1170 {
1171         struct alc_spec *spec = codec->spec;
1172         struct auto_pin_cfg *cfg = &spec->gen.autocfg;
1173         int err;
1174
1175         err = snd_hda_parse_pin_defcfg(codec, cfg, ignore_nids,
1176                                        spec->parse_flags);
1177         if (err < 0)
1178                 return err;
1179
1180         if (ssid_nids)
1181                 alc_ssid_check(codec, ssid_nids);
1182
1183         err = snd_hda_gen_parse_auto_config(codec, cfg);
1184         if (err < 0)
1185                 return err;
1186
1187         return 1;
1188 }
1189
1190 /* common preparation job for alc_spec */
1191 static int alc_alloc_spec(struct hda_codec *codec, hda_nid_t mixer_nid)
1192 {
1193         struct alc_spec *spec = kzalloc(sizeof(*spec), GFP_KERNEL);
1194         int err;
1195
1196         if (!spec)
1197                 return -ENOMEM;
1198         codec->spec = spec;
1199         snd_hda_gen_spec_init(&spec->gen);
1200         spec->gen.mixer_nid = mixer_nid;
1201         spec->gen.own_eapd_ctl = 1;
1202         codec->single_adc_amp = 1;
1203         /* FIXME: do we need this for all Realtek codec models? */
1204         codec->spdif_status_reset = 1;
1205         codec->forced_resume = 1;
1206         codec->patch_ops = alc_patch_ops;
1207         mutex_init(&spec->coef_mutex);
1208
1209         err = alc_codec_rename_from_preset(codec);
1210         if (err < 0) {
1211                 kfree(spec);
1212                 return err;
1213         }
1214         return 0;
1215 }
1216
1217 static int alc880_parse_auto_config(struct hda_codec *codec)
1218 {
1219         static const hda_nid_t alc880_ignore[] = { 0x1d, 0 };
1220         static const hda_nid_t alc880_ssids[] = { 0x15, 0x1b, 0x14, 0 };
1221         return alc_parse_auto_config(codec, alc880_ignore, alc880_ssids);
1222 }
1223
1224 /*
1225  * ALC880 fix-ups
1226  */
1227 enum {
1228         ALC880_FIXUP_GPIO1,
1229         ALC880_FIXUP_GPIO2,
1230         ALC880_FIXUP_MEDION_RIM,
1231         ALC880_FIXUP_LG,
1232         ALC880_FIXUP_LG_LW25,
1233         ALC880_FIXUP_W810,
1234         ALC880_FIXUP_EAPD_COEF,
1235         ALC880_FIXUP_TCL_S700,
1236         ALC880_FIXUP_VOL_KNOB,
1237         ALC880_FIXUP_FUJITSU,
1238         ALC880_FIXUP_F1734,
1239         ALC880_FIXUP_UNIWILL,
1240         ALC880_FIXUP_UNIWILL_DIG,
1241         ALC880_FIXUP_Z71V,
1242         ALC880_FIXUP_ASUS_W5A,
1243         ALC880_FIXUP_3ST_BASE,
1244         ALC880_FIXUP_3ST,
1245         ALC880_FIXUP_3ST_DIG,
1246         ALC880_FIXUP_5ST_BASE,
1247         ALC880_FIXUP_5ST,
1248         ALC880_FIXUP_5ST_DIG,
1249         ALC880_FIXUP_6ST_BASE,
1250         ALC880_FIXUP_6ST,
1251         ALC880_FIXUP_6ST_DIG,
1252         ALC880_FIXUP_6ST_AUTOMUTE,
1253 };
1254
1255 /* enable the volume-knob widget support on NID 0x21 */
1256 static void alc880_fixup_vol_knob(struct hda_codec *codec,
1257                                   const struct hda_fixup *fix, int action)
1258 {
1259         if (action == HDA_FIXUP_ACT_PROBE)
1260                 snd_hda_jack_detect_enable_callback(codec, 0x21,
1261                                                     alc_update_knob_master);
1262 }
1263
1264 static const struct hda_fixup alc880_fixups[] = {
1265         [ALC880_FIXUP_GPIO1] = {
1266                 .type = HDA_FIXUP_FUNC,
1267                 .v.func = alc_fixup_gpio1,
1268         },
1269         [ALC880_FIXUP_GPIO2] = {
1270                 .type = HDA_FIXUP_FUNC,
1271                 .v.func = alc_fixup_gpio2,
1272         },
1273         [ALC880_FIXUP_MEDION_RIM] = {
1274                 .type = HDA_FIXUP_VERBS,
1275                 .v.verbs = (const struct hda_verb[]) {
1276                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x07 },
1277                         { 0x20, AC_VERB_SET_PROC_COEF,  0x3060 },
1278                         { }
1279                 },
1280                 .chained = true,
1281                 .chain_id = ALC880_FIXUP_GPIO2,
1282         },
1283         [ALC880_FIXUP_LG] = {
1284                 .type = HDA_FIXUP_PINS,
1285                 .v.pins = (const struct hda_pintbl[]) {
1286                         /* disable bogus unused pins */
1287                         { 0x16, 0x411111f0 },
1288                         { 0x18, 0x411111f0 },
1289                         { 0x1a, 0x411111f0 },
1290                         { }
1291                 }
1292         },
1293         [ALC880_FIXUP_LG_LW25] = {
1294                 .type = HDA_FIXUP_PINS,
1295                 .v.pins = (const struct hda_pintbl[]) {
1296                         { 0x1a, 0x0181344f }, /* line-in */
1297                         { 0x1b, 0x0321403f }, /* headphone */
1298                         { }
1299                 }
1300         },
1301         [ALC880_FIXUP_W810] = {
1302                 .type = HDA_FIXUP_PINS,
1303                 .v.pins = (const struct hda_pintbl[]) {
1304                         /* disable bogus unused pins */
1305                         { 0x17, 0x411111f0 },
1306                         { }
1307                 },
1308                 .chained = true,
1309                 .chain_id = ALC880_FIXUP_GPIO2,
1310         },
1311         [ALC880_FIXUP_EAPD_COEF] = {
1312                 .type = HDA_FIXUP_VERBS,
1313                 .v.verbs = (const struct hda_verb[]) {
1314                         /* change to EAPD mode */
1315                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x07 },
1316                         { 0x20, AC_VERB_SET_PROC_COEF,  0x3060 },
1317                         {}
1318                 },
1319         },
1320         [ALC880_FIXUP_TCL_S700] = {
1321                 .type = HDA_FIXUP_VERBS,
1322                 .v.verbs = (const struct hda_verb[]) {
1323                         /* change to EAPD mode */
1324                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x07 },
1325                         { 0x20, AC_VERB_SET_PROC_COEF,  0x3070 },
1326                         {}
1327                 },
1328                 .chained = true,
1329                 .chain_id = ALC880_FIXUP_GPIO2,
1330         },
1331         [ALC880_FIXUP_VOL_KNOB] = {
1332                 .type = HDA_FIXUP_FUNC,
1333                 .v.func = alc880_fixup_vol_knob,
1334         },
1335         [ALC880_FIXUP_FUJITSU] = {
1336                 /* override all pins as BIOS on old Amilo is broken */
1337                 .type = HDA_FIXUP_PINS,
1338                 .v.pins = (const struct hda_pintbl[]) {
1339                         { 0x14, 0x0121401f }, /* HP */
1340                         { 0x15, 0x99030120 }, /* speaker */
1341                         { 0x16, 0x99030130 }, /* bass speaker */
1342                         { 0x17, 0x411111f0 }, /* N/A */
1343                         { 0x18, 0x411111f0 }, /* N/A */
1344                         { 0x19, 0x01a19950 }, /* mic-in */
1345                         { 0x1a, 0x411111f0 }, /* N/A */
1346                         { 0x1b, 0x411111f0 }, /* N/A */
1347                         { 0x1c, 0x411111f0 }, /* N/A */
1348                         { 0x1d, 0x411111f0 }, /* N/A */
1349                         { 0x1e, 0x01454140 }, /* SPDIF out */
1350                         { }
1351                 },
1352                 .chained = true,
1353                 .chain_id = ALC880_FIXUP_VOL_KNOB,
1354         },
1355         [ALC880_FIXUP_F1734] = {
1356                 /* almost compatible with FUJITSU, but no bass and SPDIF */
1357                 .type = HDA_FIXUP_PINS,
1358                 .v.pins = (const struct hda_pintbl[]) {
1359                         { 0x14, 0x0121401f }, /* HP */
1360                         { 0x15, 0x99030120 }, /* speaker */
1361                         { 0x16, 0x411111f0 }, /* N/A */
1362                         { 0x17, 0x411111f0 }, /* N/A */
1363                         { 0x18, 0x411111f0 }, /* N/A */
1364                         { 0x19, 0x01a19950 }, /* mic-in */
1365                         { 0x1a, 0x411111f0 }, /* N/A */
1366                         { 0x1b, 0x411111f0 }, /* N/A */
1367                         { 0x1c, 0x411111f0 }, /* N/A */
1368                         { 0x1d, 0x411111f0 }, /* N/A */
1369                         { 0x1e, 0x411111f0 }, /* N/A */
1370                         { }
1371                 },
1372                 .chained = true,
1373                 .chain_id = ALC880_FIXUP_VOL_KNOB,
1374         },
1375         [ALC880_FIXUP_UNIWILL] = {
1376                 /* need to fix HP and speaker pins to be parsed correctly */
1377                 .type = HDA_FIXUP_PINS,
1378                 .v.pins = (const struct hda_pintbl[]) {
1379                         { 0x14, 0x0121411f }, /* HP */
1380                         { 0x15, 0x99030120 }, /* speaker */
1381                         { 0x16, 0x99030130 }, /* bass speaker */
1382                         { }
1383                 },
1384         },
1385         [ALC880_FIXUP_UNIWILL_DIG] = {
1386                 .type = HDA_FIXUP_PINS,
1387                 .v.pins = (const struct hda_pintbl[]) {
1388                         /* disable bogus unused pins */
1389                         { 0x17, 0x411111f0 },
1390                         { 0x19, 0x411111f0 },
1391                         { 0x1b, 0x411111f0 },
1392                         { 0x1f, 0x411111f0 },
1393                         { }
1394                 }
1395         },
1396         [ALC880_FIXUP_Z71V] = {
1397                 .type = HDA_FIXUP_PINS,
1398                 .v.pins = (const struct hda_pintbl[]) {
1399                         /* set up the whole pins as BIOS is utterly broken */
1400                         { 0x14, 0x99030120 }, /* speaker */
1401                         { 0x15, 0x0121411f }, /* HP */
1402                         { 0x16, 0x411111f0 }, /* N/A */
1403                         { 0x17, 0x411111f0 }, /* N/A */
1404                         { 0x18, 0x01a19950 }, /* mic-in */
1405                         { 0x19, 0x411111f0 }, /* N/A */
1406                         { 0x1a, 0x01813031 }, /* line-in */
1407                         { 0x1b, 0x411111f0 }, /* N/A */
1408                         { 0x1c, 0x411111f0 }, /* N/A */
1409                         { 0x1d, 0x411111f0 }, /* N/A */
1410                         { 0x1e, 0x0144111e }, /* SPDIF */
1411                         { }
1412                 }
1413         },
1414         [ALC880_FIXUP_ASUS_W5A] = {
1415                 .type = HDA_FIXUP_PINS,
1416                 .v.pins = (const struct hda_pintbl[]) {
1417                         /* set up the whole pins as BIOS is utterly broken */
1418                         { 0x14, 0x0121411f }, /* HP */
1419                         { 0x15, 0x411111f0 }, /* N/A */
1420                         { 0x16, 0x411111f0 }, /* N/A */
1421                         { 0x17, 0x411111f0 }, /* N/A */
1422                         { 0x18, 0x90a60160 }, /* mic */
1423                         { 0x19, 0x411111f0 }, /* N/A */
1424                         { 0x1a, 0x411111f0 }, /* N/A */
1425                         { 0x1b, 0x411111f0 }, /* N/A */
1426                         { 0x1c, 0x411111f0 }, /* N/A */
1427                         { 0x1d, 0x411111f0 }, /* N/A */
1428                         { 0x1e, 0xb743111e }, /* SPDIF out */
1429                         { }
1430                 },
1431                 .chained = true,
1432                 .chain_id = ALC880_FIXUP_GPIO1,
1433         },
1434         [ALC880_FIXUP_3ST_BASE] = {
1435                 .type = HDA_FIXUP_PINS,
1436                 .v.pins = (const struct hda_pintbl[]) {
1437                         { 0x14, 0x01014010 }, /* line-out */
1438                         { 0x15, 0x411111f0 }, /* N/A */
1439                         { 0x16, 0x411111f0 }, /* N/A */
1440                         { 0x17, 0x411111f0 }, /* N/A */
1441                         { 0x18, 0x01a19c30 }, /* mic-in */
1442                         { 0x19, 0x0121411f }, /* HP */
1443                         { 0x1a, 0x01813031 }, /* line-in */
1444                         { 0x1b, 0x02a19c40 }, /* front-mic */
1445                         { 0x1c, 0x411111f0 }, /* N/A */
1446                         { 0x1d, 0x411111f0 }, /* N/A */
1447                         /* 0x1e is filled in below */
1448                         { 0x1f, 0x411111f0 }, /* N/A */
1449                         { }
1450                 }
1451         },
1452         [ALC880_FIXUP_3ST] = {
1453                 .type = HDA_FIXUP_PINS,
1454                 .v.pins = (const struct hda_pintbl[]) {
1455                         { 0x1e, 0x411111f0 }, /* N/A */
1456                         { }
1457                 },
1458                 .chained = true,
1459                 .chain_id = ALC880_FIXUP_3ST_BASE,
1460         },
1461         [ALC880_FIXUP_3ST_DIG] = {
1462                 .type = HDA_FIXUP_PINS,
1463                 .v.pins = (const struct hda_pintbl[]) {
1464                         { 0x1e, 0x0144111e }, /* SPDIF */
1465                         { }
1466                 },
1467                 .chained = true,
1468                 .chain_id = ALC880_FIXUP_3ST_BASE,
1469         },
1470         [ALC880_FIXUP_5ST_BASE] = {
1471                 .type = HDA_FIXUP_PINS,
1472                 .v.pins = (const struct hda_pintbl[]) {
1473                         { 0x14, 0x01014010 }, /* front */
1474                         { 0x15, 0x411111f0 }, /* N/A */
1475                         { 0x16, 0x01011411 }, /* CLFE */
1476                         { 0x17, 0x01016412 }, /* surr */
1477                         { 0x18, 0x01a19c30 }, /* mic-in */
1478                         { 0x19, 0x0121411f }, /* HP */
1479                         { 0x1a, 0x01813031 }, /* line-in */
1480                         { 0x1b, 0x02a19c40 }, /* front-mic */
1481                         { 0x1c, 0x411111f0 }, /* N/A */
1482                         { 0x1d, 0x411111f0 }, /* N/A */
1483                         /* 0x1e is filled in below */
1484                         { 0x1f, 0x411111f0 }, /* N/A */
1485                         { }
1486                 }
1487         },
1488         [ALC880_FIXUP_5ST] = {
1489                 .type = HDA_FIXUP_PINS,
1490                 .v.pins = (const struct hda_pintbl[]) {
1491                         { 0x1e, 0x411111f0 }, /* N/A */
1492                         { }
1493                 },
1494                 .chained = true,
1495                 .chain_id = ALC880_FIXUP_5ST_BASE,
1496         },
1497         [ALC880_FIXUP_5ST_DIG] = {
1498                 .type = HDA_FIXUP_PINS,
1499                 .v.pins = (const struct hda_pintbl[]) {
1500                         { 0x1e, 0x0144111e }, /* SPDIF */
1501                         { }
1502                 },
1503                 .chained = true,
1504                 .chain_id = ALC880_FIXUP_5ST_BASE,
1505         },
1506         [ALC880_FIXUP_6ST_BASE] = {
1507                 .type = HDA_FIXUP_PINS,
1508                 .v.pins = (const struct hda_pintbl[]) {
1509                         { 0x14, 0x01014010 }, /* front */
1510                         { 0x15, 0x01016412 }, /* surr */
1511                         { 0x16, 0x01011411 }, /* CLFE */
1512                         { 0x17, 0x01012414 }, /* side */
1513                         { 0x18, 0x01a19c30 }, /* mic-in */
1514                         { 0x19, 0x02a19c40 }, /* front-mic */
1515                         { 0x1a, 0x01813031 }, /* line-in */
1516                         { 0x1b, 0x0121411f }, /* HP */
1517                         { 0x1c, 0x411111f0 }, /* N/A */
1518                         { 0x1d, 0x411111f0 }, /* N/A */
1519                         /* 0x1e is filled in below */
1520                         { 0x1f, 0x411111f0 }, /* N/A */
1521                         { }
1522                 }
1523         },
1524         [ALC880_FIXUP_6ST] = {
1525                 .type = HDA_FIXUP_PINS,
1526                 .v.pins = (const struct hda_pintbl[]) {
1527                         { 0x1e, 0x411111f0 }, /* N/A */
1528                         { }
1529                 },
1530                 .chained = true,
1531                 .chain_id = ALC880_FIXUP_6ST_BASE,
1532         },
1533         [ALC880_FIXUP_6ST_DIG] = {
1534                 .type = HDA_FIXUP_PINS,
1535                 .v.pins = (const struct hda_pintbl[]) {
1536                         { 0x1e, 0x0144111e }, /* SPDIF */
1537                         { }
1538                 },
1539                 .chained = true,
1540                 .chain_id = ALC880_FIXUP_6ST_BASE,
1541         },
1542         [ALC880_FIXUP_6ST_AUTOMUTE] = {
1543                 .type = HDA_FIXUP_PINS,
1544                 .v.pins = (const struct hda_pintbl[]) {
1545                         { 0x1b, 0x0121401f }, /* HP with jack detect */
1546                         { }
1547                 },
1548                 .chained_before = true,
1549                 .chain_id = ALC880_FIXUP_6ST_BASE,
1550         },
1551 };
1552
1553 static const struct snd_pci_quirk alc880_fixup_tbl[] = {
1554         SND_PCI_QUIRK(0x1019, 0x0f69, "Coeus G610P", ALC880_FIXUP_W810),
1555         SND_PCI_QUIRK(0x1043, 0x10c3, "ASUS W5A", ALC880_FIXUP_ASUS_W5A),
1556         SND_PCI_QUIRK(0x1043, 0x1964, "ASUS Z71V", ALC880_FIXUP_Z71V),
1557         SND_PCI_QUIRK_VENDOR(0x1043, "ASUS", ALC880_FIXUP_GPIO1),
1558         SND_PCI_QUIRK(0x147b, 0x1045, "ABit AA8XE", ALC880_FIXUP_6ST_AUTOMUTE),
1559         SND_PCI_QUIRK(0x1558, 0x5401, "Clevo GPIO2", ALC880_FIXUP_GPIO2),
1560         SND_PCI_QUIRK_VENDOR(0x1558, "Clevo", ALC880_FIXUP_EAPD_COEF),
1561         SND_PCI_QUIRK(0x1584, 0x9050, "Uniwill", ALC880_FIXUP_UNIWILL_DIG),
1562         SND_PCI_QUIRK(0x1584, 0x9054, "Uniwill", ALC880_FIXUP_F1734),
1563         SND_PCI_QUIRK(0x1584, 0x9070, "Uniwill", ALC880_FIXUP_UNIWILL),
1564         SND_PCI_QUIRK(0x1584, 0x9077, "Uniwill P53", ALC880_FIXUP_VOL_KNOB),
1565         SND_PCI_QUIRK(0x161f, 0x203d, "W810", ALC880_FIXUP_W810),
1566         SND_PCI_QUIRK(0x161f, 0x205d, "Medion Rim 2150", ALC880_FIXUP_MEDION_RIM),
1567         SND_PCI_QUIRK(0x1631, 0xe011, "PB 13201056", ALC880_FIXUP_6ST_AUTOMUTE),
1568         SND_PCI_QUIRK(0x1734, 0x107c, "FSC Amilo M1437", ALC880_FIXUP_FUJITSU),
1569         SND_PCI_QUIRK(0x1734, 0x1094, "FSC Amilo M1451G", ALC880_FIXUP_FUJITSU),
1570         SND_PCI_QUIRK(0x1734, 0x10ac, "FSC AMILO Xi 1526", ALC880_FIXUP_F1734),
1571         SND_PCI_QUIRK(0x1734, 0x10b0, "FSC Amilo Pi1556", ALC880_FIXUP_FUJITSU),
1572         SND_PCI_QUIRK(0x1854, 0x003b, "LG", ALC880_FIXUP_LG),
1573         SND_PCI_QUIRK(0x1854, 0x005f, "LG P1 Express", ALC880_FIXUP_LG),
1574         SND_PCI_QUIRK(0x1854, 0x0068, "LG w1", ALC880_FIXUP_LG),
1575         SND_PCI_QUIRK(0x1854, 0x0077, "LG LW25", ALC880_FIXUP_LG_LW25),
1576         SND_PCI_QUIRK(0x19db, 0x4188, "TCL S700", ALC880_FIXUP_TCL_S700),
1577
1578         /* Below is the copied entries from alc880_quirks.c.
1579          * It's not quite sure whether BIOS sets the correct pin-config table
1580          * on these machines, thus they are kept to be compatible with
1581          * the old static quirks.  Once when it's confirmed to work without
1582          * these overrides, it'd be better to remove.
1583          */
1584         SND_PCI_QUIRK(0x1019, 0xa880, "ECS", ALC880_FIXUP_5ST_DIG),
1585         SND_PCI_QUIRK(0x1019, 0xa884, "Acer APFV", ALC880_FIXUP_6ST),
1586         SND_PCI_QUIRK(0x1025, 0x0070, "ULI", ALC880_FIXUP_3ST_DIG),
1587         SND_PCI_QUIRK(0x1025, 0x0077, "ULI", ALC880_FIXUP_6ST_DIG),
1588         SND_PCI_QUIRK(0x1025, 0x0078, "ULI", ALC880_FIXUP_6ST_DIG),
1589         SND_PCI_QUIRK(0x1025, 0x0087, "ULI", ALC880_FIXUP_6ST_DIG),
1590         SND_PCI_QUIRK(0x1025, 0xe309, "ULI", ALC880_FIXUP_3ST_DIG),
1591         SND_PCI_QUIRK(0x1025, 0xe310, "ULI", ALC880_FIXUP_3ST),
1592         SND_PCI_QUIRK(0x1039, 0x1234, NULL, ALC880_FIXUP_6ST_DIG),
1593         SND_PCI_QUIRK(0x104d, 0x81a0, "Sony", ALC880_FIXUP_3ST),
1594         SND_PCI_QUIRK(0x104d, 0x81d6, "Sony", ALC880_FIXUP_3ST),
1595         SND_PCI_QUIRK(0x107b, 0x3032, "Gateway", ALC880_FIXUP_5ST),
1596         SND_PCI_QUIRK(0x107b, 0x3033, "Gateway", ALC880_FIXUP_5ST),
1597         SND_PCI_QUIRK(0x107b, 0x4039, "Gateway", ALC880_FIXUP_5ST),
1598         SND_PCI_QUIRK(0x1297, 0xc790, "Shuttle ST20G5", ALC880_FIXUP_6ST_DIG),
1599         SND_PCI_QUIRK(0x1458, 0xa102, "Gigabyte K8", ALC880_FIXUP_6ST_DIG),
1600         SND_PCI_QUIRK(0x1462, 0x1150, "MSI", ALC880_FIXUP_6ST_DIG),
1601         SND_PCI_QUIRK(0x1509, 0x925d, "FIC P4M", ALC880_FIXUP_6ST_DIG),
1602         SND_PCI_QUIRK(0x1565, 0x8202, "Biostar", ALC880_FIXUP_5ST_DIG),
1603         SND_PCI_QUIRK(0x1695, 0x400d, "EPoX", ALC880_FIXUP_5ST_DIG),
1604         SND_PCI_QUIRK(0x1695, 0x4012, "EPox EP-5LDA", ALC880_FIXUP_5ST_DIG),
1605         SND_PCI_QUIRK(0x2668, 0x8086, NULL, ALC880_FIXUP_6ST_DIG), /* broken BIOS */
1606         SND_PCI_QUIRK(0x8086, 0x2668, NULL, ALC880_FIXUP_6ST_DIG),
1607         SND_PCI_QUIRK(0x8086, 0xa100, "Intel mobo", ALC880_FIXUP_5ST_DIG),
1608         SND_PCI_QUIRK(0x8086, 0xd400, "Intel mobo", ALC880_FIXUP_5ST_DIG),
1609         SND_PCI_QUIRK(0x8086, 0xd401, "Intel mobo", ALC880_FIXUP_5ST_DIG),
1610         SND_PCI_QUIRK(0x8086, 0xd402, "Intel mobo", ALC880_FIXUP_3ST_DIG),
1611         SND_PCI_QUIRK(0x8086, 0xe224, "Intel mobo", ALC880_FIXUP_5ST_DIG),
1612         SND_PCI_QUIRK(0x8086, 0xe305, "Intel mobo", ALC880_FIXUP_3ST_DIG),
1613         SND_PCI_QUIRK(0x8086, 0xe308, "Intel mobo", ALC880_FIXUP_3ST_DIG),
1614         SND_PCI_QUIRK(0x8086, 0xe400, "Intel mobo", ALC880_FIXUP_5ST_DIG),
1615         SND_PCI_QUIRK(0x8086, 0xe401, "Intel mobo", ALC880_FIXUP_5ST_DIG),
1616         SND_PCI_QUIRK(0x8086, 0xe402, "Intel mobo", ALC880_FIXUP_5ST_DIG),
1617         /* default Intel */
1618         SND_PCI_QUIRK_VENDOR(0x8086, "Intel mobo", ALC880_FIXUP_3ST),
1619         SND_PCI_QUIRK(0xa0a0, 0x0560, "AOpen i915GMm-HFS", ALC880_FIXUP_5ST_DIG),
1620         SND_PCI_QUIRK(0xe803, 0x1019, NULL, ALC880_FIXUP_6ST_DIG),
1621         {}
1622 };
1623
1624 static const struct hda_model_fixup alc880_fixup_models[] = {
1625         {.id = ALC880_FIXUP_3ST, .name = "3stack"},
1626         {.id = ALC880_FIXUP_3ST_DIG, .name = "3stack-digout"},
1627         {.id = ALC880_FIXUP_5ST, .name = "5stack"},
1628         {.id = ALC880_FIXUP_5ST_DIG, .name = "5stack-digout"},
1629         {.id = ALC880_FIXUP_6ST, .name = "6stack"},
1630         {.id = ALC880_FIXUP_6ST_DIG, .name = "6stack-digout"},
1631         {.id = ALC880_FIXUP_6ST_AUTOMUTE, .name = "6stack-automute"},
1632         {}
1633 };
1634
1635
1636 /*
1637  * OK, here we have finally the patch for ALC880
1638  */
1639 static int patch_alc880(struct hda_codec *codec)
1640 {
1641         struct alc_spec *spec;
1642         int err;
1643
1644         err = alc_alloc_spec(codec, 0x0b);
1645         if (err < 0)
1646                 return err;
1647
1648         spec = codec->spec;
1649         spec->gen.need_dac_fix = 1;
1650         spec->gen.beep_nid = 0x01;
1651
1652         codec->patch_ops.unsol_event = alc880_unsol_event;
1653
1654         alc_pre_init(codec);
1655
1656         snd_hda_pick_fixup(codec, alc880_fixup_models, alc880_fixup_tbl,
1657                        alc880_fixups);
1658         snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE);
1659
1660         /* automatic parse from the BIOS config */
1661         err = alc880_parse_auto_config(codec);
1662         if (err < 0)
1663                 goto error;
1664
1665         if (!spec->gen.no_analog) {
1666                 err = set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
1667                 if (err < 0)
1668                         goto error;
1669         }
1670
1671         snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE);
1672
1673         return 0;
1674
1675  error:
1676         alc_free(codec);
1677         return err;
1678 }
1679
1680
1681 /*
1682  * ALC260 support
1683  */
1684 static int alc260_parse_auto_config(struct hda_codec *codec)
1685 {
1686         static const hda_nid_t alc260_ignore[] = { 0x17, 0 };
1687         static const hda_nid_t alc260_ssids[] = { 0x10, 0x15, 0x0f, 0 };
1688         return alc_parse_auto_config(codec, alc260_ignore, alc260_ssids);
1689 }
1690
1691 /*
1692  * Pin config fixes
1693  */
1694 enum {
1695         ALC260_FIXUP_HP_DC5750,
1696         ALC260_FIXUP_HP_PIN_0F,
1697         ALC260_FIXUP_COEF,
1698         ALC260_FIXUP_GPIO1,
1699         ALC260_FIXUP_GPIO1_TOGGLE,
1700         ALC260_FIXUP_REPLACER,
1701         ALC260_FIXUP_HP_B1900,
1702         ALC260_FIXUP_KN1,
1703         ALC260_FIXUP_FSC_S7020,
1704         ALC260_FIXUP_FSC_S7020_JWSE,
1705         ALC260_FIXUP_VAIO_PINS,
1706 };
1707
1708 static void alc260_gpio1_automute(struct hda_codec *codec)
1709 {
1710         struct alc_spec *spec = codec->spec;
1711
1712         alc_update_gpio_data(codec, 0x01, spec->gen.hp_jack_present);
1713 }
1714
1715 static void alc260_fixup_gpio1_toggle(struct hda_codec *codec,
1716                                       const struct hda_fixup *fix, int action)
1717 {
1718         struct alc_spec *spec = codec->spec;
1719         if (action == HDA_FIXUP_ACT_PROBE) {
1720                 /* although the machine has only one output pin, we need to
1721                  * toggle GPIO1 according to the jack state
1722                  */
1723                 spec->gen.automute_hook = alc260_gpio1_automute;
1724                 spec->gen.detect_hp = 1;
1725                 spec->gen.automute_speaker = 1;
1726                 spec->gen.autocfg.hp_pins[0] = 0x0f; /* copy it for automute */
1727                 snd_hda_jack_detect_enable_callback(codec, 0x0f,
1728                                                     snd_hda_gen_hp_automute);
1729                 alc_setup_gpio(codec, 0x01);
1730         }
1731 }
1732
1733 static void alc260_fixup_kn1(struct hda_codec *codec,
1734                              const struct hda_fixup *fix, int action)
1735 {
1736         struct alc_spec *spec = codec->spec;
1737         static const struct hda_pintbl pincfgs[] = {
1738                 { 0x0f, 0x02214000 }, /* HP/speaker */
1739                 { 0x12, 0x90a60160 }, /* int mic */
1740                 { 0x13, 0x02a19000 }, /* ext mic */
1741                 { 0x18, 0x01446000 }, /* SPDIF out */
1742                 /* disable bogus I/O pins */
1743                 { 0x10, 0x411111f0 },
1744                 { 0x11, 0x411111f0 },
1745                 { 0x14, 0x411111f0 },
1746                 { 0x15, 0x411111f0 },
1747                 { 0x16, 0x411111f0 },
1748                 { 0x17, 0x411111f0 },
1749                 { 0x19, 0x411111f0 },
1750                 { }
1751         };
1752
1753         switch (action) {
1754         case HDA_FIXUP_ACT_PRE_PROBE:
1755                 snd_hda_apply_pincfgs(codec, pincfgs);
1756                 spec->init_amp = ALC_INIT_NONE;
1757                 break;
1758         }
1759 }
1760
1761 static void alc260_fixup_fsc_s7020(struct hda_codec *codec,
1762                                    const struct hda_fixup *fix, int action)
1763 {
1764         struct alc_spec *spec = codec->spec;
1765         if (action == HDA_FIXUP_ACT_PRE_PROBE)
1766                 spec->init_amp = ALC_INIT_NONE;
1767 }
1768
1769 static void alc260_fixup_fsc_s7020_jwse(struct hda_codec *codec,
1770                                    const struct hda_fixup *fix, int action)
1771 {
1772         struct alc_spec *spec = codec->spec;
1773         if (action == HDA_FIXUP_ACT_PRE_PROBE) {
1774                 spec->gen.add_jack_modes = 1;
1775                 spec->gen.hp_mic = 1;
1776         }
1777 }
1778
1779 static const struct hda_fixup alc260_fixups[] = {
1780         [ALC260_FIXUP_HP_DC5750] = {
1781                 .type = HDA_FIXUP_PINS,
1782                 .v.pins = (const struct hda_pintbl[]) {
1783                         { 0x11, 0x90130110 }, /* speaker */
1784                         { }
1785                 }
1786         },
1787         [ALC260_FIXUP_HP_PIN_0F] = {
1788                 .type = HDA_FIXUP_PINS,
1789                 .v.pins = (const struct hda_pintbl[]) {
1790                         { 0x0f, 0x01214000 }, /* HP */
1791                         { }
1792                 }
1793         },
1794         [ALC260_FIXUP_COEF] = {
1795                 .type = HDA_FIXUP_VERBS,
1796                 .v.verbs = (const struct hda_verb[]) {
1797                         { 0x1a, AC_VERB_SET_COEF_INDEX, 0x07 },
1798                         { 0x1a, AC_VERB_SET_PROC_COEF,  0x3040 },
1799                         { }
1800                 },
1801         },
1802         [ALC260_FIXUP_GPIO1] = {
1803                 .type = HDA_FIXUP_FUNC,
1804                 .v.func = alc_fixup_gpio1,
1805         },
1806         [ALC260_FIXUP_GPIO1_TOGGLE] = {
1807                 .type = HDA_FIXUP_FUNC,
1808                 .v.func = alc260_fixup_gpio1_toggle,
1809                 .chained = true,
1810                 .chain_id = ALC260_FIXUP_HP_PIN_0F,
1811         },
1812         [ALC260_FIXUP_REPLACER] = {
1813                 .type = HDA_FIXUP_VERBS,
1814                 .v.verbs = (const struct hda_verb[]) {
1815                         { 0x1a, AC_VERB_SET_COEF_INDEX, 0x07 },
1816                         { 0x1a, AC_VERB_SET_PROC_COEF,  0x3050 },
1817                         { }
1818                 },
1819                 .chained = true,
1820                 .chain_id = ALC260_FIXUP_GPIO1_TOGGLE,
1821         },
1822         [ALC260_FIXUP_HP_B1900] = {
1823                 .type = HDA_FIXUP_FUNC,
1824                 .v.func = alc260_fixup_gpio1_toggle,
1825                 .chained = true,
1826                 .chain_id = ALC260_FIXUP_COEF,
1827         },
1828         [ALC260_FIXUP_KN1] = {
1829                 .type = HDA_FIXUP_FUNC,
1830                 .v.func = alc260_fixup_kn1,
1831         },
1832         [ALC260_FIXUP_FSC_S7020] = {
1833                 .type = HDA_FIXUP_FUNC,
1834                 .v.func = alc260_fixup_fsc_s7020,
1835         },
1836         [ALC260_FIXUP_FSC_S7020_JWSE] = {
1837                 .type = HDA_FIXUP_FUNC,
1838                 .v.func = alc260_fixup_fsc_s7020_jwse,
1839                 .chained = true,
1840                 .chain_id = ALC260_FIXUP_FSC_S7020,
1841         },
1842         [ALC260_FIXUP_VAIO_PINS] = {
1843                 .type = HDA_FIXUP_PINS,
1844                 .v.pins = (const struct hda_pintbl[]) {
1845                         /* Pin configs are missing completely on some VAIOs */
1846                         { 0x0f, 0x01211020 },
1847                         { 0x10, 0x0001003f },
1848                         { 0x11, 0x411111f0 },
1849                         { 0x12, 0x01a15930 },
1850                         { 0x13, 0x411111f0 },
1851                         { 0x14, 0x411111f0 },
1852                         { 0x15, 0x411111f0 },
1853                         { 0x16, 0x411111f0 },
1854                         { 0x17, 0x411111f0 },
1855                         { 0x18, 0x411111f0 },
1856                         { 0x19, 0x411111f0 },
1857                         { }
1858                 }
1859         },
1860 };
1861
1862 static const struct snd_pci_quirk alc260_fixup_tbl[] = {
1863         SND_PCI_QUIRK(0x1025, 0x007b, "Acer C20x", ALC260_FIXUP_GPIO1),
1864         SND_PCI_QUIRK(0x1025, 0x007f, "Acer Aspire 9500", ALC260_FIXUP_COEF),
1865         SND_PCI_QUIRK(0x1025, 0x008f, "Acer", ALC260_FIXUP_GPIO1),
1866         SND_PCI_QUIRK(0x103c, 0x280a, "HP dc5750", ALC260_FIXUP_HP_DC5750),
1867         SND_PCI_QUIRK(0x103c, 0x30ba, "HP Presario B1900", ALC260_FIXUP_HP_B1900),
1868         SND_PCI_QUIRK(0x104d, 0x81bb, "Sony VAIO", ALC260_FIXUP_VAIO_PINS),
1869         SND_PCI_QUIRK(0x104d, 0x81e2, "Sony VAIO TX", ALC260_FIXUP_HP_PIN_0F),
1870         SND_PCI_QUIRK(0x10cf, 0x1326, "FSC LifeBook S7020", ALC260_FIXUP_FSC_S7020),
1871         SND_PCI_QUIRK(0x1509, 0x4540, "Favorit 100XS", ALC260_FIXUP_GPIO1),
1872         SND_PCI_QUIRK(0x152d, 0x0729, "Quanta KN1", ALC260_FIXUP_KN1),
1873         SND_PCI_QUIRK(0x161f, 0x2057, "Replacer 672V", ALC260_FIXUP_REPLACER),
1874         SND_PCI_QUIRK(0x1631, 0xc017, "PB V7900", ALC260_FIXUP_COEF),
1875         {}
1876 };
1877
1878 static const struct hda_model_fixup alc260_fixup_models[] = {
1879         {.id = ALC260_FIXUP_GPIO1, .name = "gpio1"},
1880         {.id = ALC260_FIXUP_COEF, .name = "coef"},
1881         {.id = ALC260_FIXUP_FSC_S7020, .name = "fujitsu"},
1882         {.id = ALC260_FIXUP_FSC_S7020_JWSE, .name = "fujitsu-jwse"},
1883         {}
1884 };
1885
1886 /*
1887  */
1888 static int patch_alc260(struct hda_codec *codec)
1889 {
1890         struct alc_spec *spec;
1891         int err;
1892
1893         err = alc_alloc_spec(codec, 0x07);
1894         if (err < 0)
1895                 return err;
1896
1897         spec = codec->spec;
1898         /* as quite a few machines require HP amp for speaker outputs,
1899          * it's easier to enable it unconditionally; even if it's unneeded,
1900          * it's almost harmless.
1901          */
1902         spec->gen.prefer_hp_amp = 1;
1903         spec->gen.beep_nid = 0x01;
1904
1905         spec->shutup = alc_eapd_shutup;
1906
1907         alc_pre_init(codec);
1908
1909         snd_hda_pick_fixup(codec, alc260_fixup_models, alc260_fixup_tbl,
1910                            alc260_fixups);
1911         snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE);
1912
1913         /* automatic parse from the BIOS config */
1914         err = alc260_parse_auto_config(codec);
1915         if (err < 0)
1916                 goto error;
1917
1918         if (!spec->gen.no_analog) {
1919                 err = set_beep_amp(spec, 0x07, 0x05, HDA_INPUT);
1920                 if (err < 0)
1921                         goto error;
1922         }
1923
1924         snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE);
1925
1926         return 0;
1927
1928  error:
1929         alc_free(codec);
1930         return err;
1931 }
1932
1933
1934 /*
1935  * ALC882/883/885/888/889 support
1936  *
1937  * ALC882 is almost identical with ALC880 but has cleaner and more flexible
1938  * configuration.  Each pin widget can choose any input DACs and a mixer.
1939  * Each ADC is connected from a mixer of all inputs.  This makes possible
1940  * 6-channel independent captures.
1941  *
1942  * In addition, an independent DAC for the multi-playback (not used in this
1943  * driver yet).
1944  */
1945
1946 /*
1947  * Pin config fixes
1948  */
1949 enum {
1950         ALC882_FIXUP_ABIT_AW9D_MAX,
1951         ALC882_FIXUP_LENOVO_Y530,
1952         ALC882_FIXUP_PB_M5210,
1953         ALC882_FIXUP_ACER_ASPIRE_7736,
1954         ALC882_FIXUP_ASUS_W90V,
1955         ALC889_FIXUP_CD,
1956         ALC889_FIXUP_FRONT_HP_NO_PRESENCE,
1957         ALC889_FIXUP_VAIO_TT,
1958         ALC888_FIXUP_EEE1601,
1959         ALC886_FIXUP_EAPD,
1960         ALC882_FIXUP_EAPD,
1961         ALC883_FIXUP_EAPD,
1962         ALC883_FIXUP_ACER_EAPD,
1963         ALC882_FIXUP_GPIO1,
1964         ALC882_FIXUP_GPIO2,
1965         ALC882_FIXUP_GPIO3,
1966         ALC889_FIXUP_COEF,
1967         ALC882_FIXUP_ASUS_W2JC,
1968         ALC882_FIXUP_ACER_ASPIRE_4930G,
1969         ALC882_FIXUP_ACER_ASPIRE_8930G,
1970         ALC882_FIXUP_ASPIRE_8930G_VERBS,
1971         ALC885_FIXUP_MACPRO_GPIO,
1972         ALC889_FIXUP_DAC_ROUTE,
1973         ALC889_FIXUP_MBP_VREF,
1974         ALC889_FIXUP_IMAC91_VREF,
1975         ALC889_FIXUP_MBA11_VREF,
1976         ALC889_FIXUP_MBA21_VREF,
1977         ALC889_FIXUP_MP11_VREF,
1978         ALC889_FIXUP_MP41_VREF,
1979         ALC882_FIXUP_INV_DMIC,
1980         ALC882_FIXUP_NO_PRIMARY_HP,
1981         ALC887_FIXUP_ASUS_BASS,
1982         ALC887_FIXUP_BASS_CHMAP,
1983         ALC1220_FIXUP_GB_DUAL_CODECS,
1984         ALC1220_FIXUP_GB_X570,
1985         ALC1220_FIXUP_CLEVO_P950,
1986         ALC1220_FIXUP_CLEVO_PB51ED,
1987         ALC1220_FIXUP_CLEVO_PB51ED_PINS,
1988         ALC887_FIXUP_ASUS_AUDIO,
1989         ALC887_FIXUP_ASUS_HMIC,
1990         ALCS1200A_FIXUP_MIC_VREF,
1991         ALC888VD_FIXUP_MIC_100VREF,
1992 };
1993
1994 static void alc889_fixup_coef(struct hda_codec *codec,
1995                               const struct hda_fixup *fix, int action)
1996 {
1997         if (action != HDA_FIXUP_ACT_INIT)
1998                 return;
1999         alc_update_coef_idx(codec, 7, 0, 0x2030);
2000 }
2001
2002 /* set up GPIO at initialization */
2003 static void alc885_fixup_macpro_gpio(struct hda_codec *codec,
2004                                      const struct hda_fixup *fix, int action)
2005 {
2006         struct alc_spec *spec = codec->spec;
2007
2008         spec->gpio_write_delay = true;
2009         alc_fixup_gpio3(codec, fix, action);
2010 }
2011
2012 /* Fix the connection of some pins for ALC889:
2013  * At least, Acer Aspire 5935 shows the connections to DAC3/4 don't
2014  * work correctly (bko#42740)
2015  */
2016 static void alc889_fixup_dac_route(struct hda_codec *codec,
2017                                    const struct hda_fixup *fix, int action)
2018 {
2019         if (action == HDA_FIXUP_ACT_PRE_PROBE) {
2020                 /* fake the connections during parsing the tree */
2021                 static const hda_nid_t conn1[] = { 0x0c, 0x0d };
2022                 static const hda_nid_t conn2[] = { 0x0e, 0x0f };
2023                 snd_hda_override_conn_list(codec, 0x14, ARRAY_SIZE(conn1), conn1);
2024                 snd_hda_override_conn_list(codec, 0x15, ARRAY_SIZE(conn1), conn1);
2025                 snd_hda_override_conn_list(codec, 0x18, ARRAY_SIZE(conn2), conn2);
2026                 snd_hda_override_conn_list(codec, 0x1a, ARRAY_SIZE(conn2), conn2);
2027         } else if (action == HDA_FIXUP_ACT_PROBE) {
2028                 /* restore the connections */
2029                 static const hda_nid_t conn[] = { 0x0c, 0x0d, 0x0e, 0x0f, 0x26 };
2030                 snd_hda_override_conn_list(codec, 0x14, ARRAY_SIZE(conn), conn);
2031                 snd_hda_override_conn_list(codec, 0x15, ARRAY_SIZE(conn), conn);
2032                 snd_hda_override_conn_list(codec, 0x18, ARRAY_SIZE(conn), conn);
2033                 snd_hda_override_conn_list(codec, 0x1a, ARRAY_SIZE(conn), conn);
2034         }
2035 }
2036
2037 /* Set VREF on HP pin */
2038 static void alc889_fixup_mbp_vref(struct hda_codec *codec,
2039                                   const struct hda_fixup *fix, int action)
2040 {
2041         static const hda_nid_t nids[] = { 0x14, 0x15, 0x19 };
2042         struct alc_spec *spec = codec->spec;
2043         int i;
2044
2045         if (action != HDA_FIXUP_ACT_INIT)
2046                 return;
2047         for (i = 0; i < ARRAY_SIZE(nids); i++) {
2048                 unsigned int val = snd_hda_codec_get_pincfg(codec, nids[i]);
2049                 if (get_defcfg_device(val) != AC_JACK_HP_OUT)
2050                         continue;
2051                 val = snd_hda_codec_get_pin_target(codec, nids[i]);
2052                 val |= AC_PINCTL_VREF_80;
2053                 snd_hda_set_pin_ctl(codec, nids[i], val);
2054                 spec->gen.keep_vref_in_automute = 1;
2055                 break;
2056         }
2057 }
2058
2059 static void alc889_fixup_mac_pins(struct hda_codec *codec,
2060                                   const hda_nid_t *nids, int num_nids)
2061 {
2062         struct alc_spec *spec = codec->spec;
2063         int i;
2064
2065         for (i = 0; i < num_nids; i++) {
2066                 unsigned int val;
2067                 val = snd_hda_codec_get_pin_target(codec, nids[i]);
2068                 val |= AC_PINCTL_VREF_50;
2069                 snd_hda_set_pin_ctl(codec, nids[i], val);
2070         }
2071         spec->gen.keep_vref_in_automute = 1;
2072 }
2073
2074 /* Set VREF on speaker pins on imac91 */
2075 static void alc889_fixup_imac91_vref(struct hda_codec *codec,
2076                                      const struct hda_fixup *fix, int action)
2077 {
2078         static const hda_nid_t nids[] = { 0x18, 0x1a };
2079
2080         if (action == HDA_FIXUP_ACT_INIT)
2081                 alc889_fixup_mac_pins(codec, nids, ARRAY_SIZE(nids));
2082 }
2083
2084 /* Set VREF on speaker pins on mba11 */
2085 static void alc889_fixup_mba11_vref(struct hda_codec *codec,
2086                                     const struct hda_fixup *fix, int action)
2087 {
2088         static const hda_nid_t nids[] = { 0x18 };
2089
2090         if (action == HDA_FIXUP_ACT_INIT)
2091                 alc889_fixup_mac_pins(codec, nids, ARRAY_SIZE(nids));
2092 }
2093
2094 /* Set VREF on speaker pins on mba21 */
2095 static void alc889_fixup_mba21_vref(struct hda_codec *codec,
2096                                     const struct hda_fixup *fix, int action)
2097 {
2098         static const hda_nid_t nids[] = { 0x18, 0x19 };
2099
2100         if (action == HDA_FIXUP_ACT_INIT)
2101                 alc889_fixup_mac_pins(codec, nids, ARRAY_SIZE(nids));
2102 }
2103
2104 /* Don't take HP output as primary
2105  * Strangely, the speaker output doesn't work on Vaio Z and some Vaio
2106  * all-in-one desktop PCs (for example VGC-LN51JGB) through DAC 0x05
2107  */
2108 static void alc882_fixup_no_primary_hp(struct hda_codec *codec,
2109                                        const struct hda_fixup *fix, int action)
2110 {
2111         struct alc_spec *spec = codec->spec;
2112         if (action == HDA_FIXUP_ACT_PRE_PROBE) {
2113                 spec->gen.no_primary_hp = 1;
2114                 spec->gen.no_multi_io = 1;
2115         }
2116 }
2117
2118 static void alc_fixup_bass_chmap(struct hda_codec *codec,
2119                                  const struct hda_fixup *fix, int action);
2120
2121 /* For dual-codec configuration, we need to disable some features to avoid
2122  * conflicts of kctls and PCM streams
2123  */
2124 static void alc_fixup_dual_codecs(struct hda_codec *codec,
2125                                   const struct hda_fixup *fix, int action)
2126 {
2127         struct alc_spec *spec = codec->spec;
2128
2129         if (action != HDA_FIXUP_ACT_PRE_PROBE)
2130                 return;
2131         /* disable vmaster */
2132         spec->gen.suppress_vmaster = 1;
2133         /* auto-mute and auto-mic switch don't work with multiple codecs */
2134         spec->gen.suppress_auto_mute = 1;
2135         spec->gen.suppress_auto_mic = 1;
2136         /* disable aamix as well */
2137         spec->gen.mixer_nid = 0;
2138         /* add location prefix to avoid conflicts */
2139         codec->force_pin_prefix = 1;
2140 }
2141
2142 static void rename_ctl(struct hda_codec *codec, const char *oldname,
2143                        const char *newname)
2144 {
2145         struct snd_kcontrol *kctl;
2146
2147         kctl = snd_hda_find_mixer_ctl(codec, oldname);
2148         if (kctl)
2149                 snd_ctl_rename(codec->card, kctl, newname);
2150 }
2151
2152 static void alc1220_fixup_gb_dual_codecs(struct hda_codec *codec,
2153                                          const struct hda_fixup *fix,
2154                                          int action)
2155 {
2156         alc_fixup_dual_codecs(codec, fix, action);
2157         switch (action) {
2158         case HDA_FIXUP_ACT_PRE_PROBE:
2159                 /* override card longname to provide a unique UCM profile */
2160                 strcpy(codec->card->longname, "HDAudio-Gigabyte-ALC1220DualCodecs");
2161                 break;
2162         case HDA_FIXUP_ACT_BUILD:
2163                 /* rename Capture controls depending on the codec */
2164                 rename_ctl(codec, "Capture Volume",
2165                            codec->addr == 0 ?
2166                            "Rear-Panel Capture Volume" :
2167                            "Front-Panel Capture Volume");
2168                 rename_ctl(codec, "Capture Switch",
2169                            codec->addr == 0 ?
2170                            "Rear-Panel Capture Switch" :
2171                            "Front-Panel Capture Switch");
2172                 break;
2173         }
2174 }
2175
2176 static void alc1220_fixup_gb_x570(struct hda_codec *codec,
2177                                      const struct hda_fixup *fix,
2178                                      int action)
2179 {
2180         static const hda_nid_t conn1[] = { 0x0c };
2181         static const struct coef_fw gb_x570_coefs[] = {
2182                 WRITE_COEF(0x07, 0x03c0),
2183                 WRITE_COEF(0x1a, 0x01c1),
2184                 WRITE_COEF(0x1b, 0x0202),
2185                 WRITE_COEF(0x43, 0x3005),
2186                 {}
2187         };
2188
2189         switch (action) {
2190         case HDA_FIXUP_ACT_PRE_PROBE:
2191                 snd_hda_override_conn_list(codec, 0x14, ARRAY_SIZE(conn1), conn1);
2192                 snd_hda_override_conn_list(codec, 0x1b, ARRAY_SIZE(conn1), conn1);
2193                 break;
2194         case HDA_FIXUP_ACT_INIT:
2195                 alc_process_coef_fw(codec, gb_x570_coefs);
2196                 break;
2197         }
2198 }
2199
2200 static void alc1220_fixup_clevo_p950(struct hda_codec *codec,
2201                                      const struct hda_fixup *fix,
2202                                      int action)
2203 {
2204         static const hda_nid_t conn1[] = { 0x0c };
2205
2206         if (action != HDA_FIXUP_ACT_PRE_PROBE)
2207                 return;
2208
2209         alc_update_coef_idx(codec, 0x7, 0, 0x3c3);
2210         /* We therefore want to make sure 0x14 (front headphone) and
2211          * 0x1b (speakers) use the stereo DAC 0x02
2212          */
2213         snd_hda_override_conn_list(codec, 0x14, ARRAY_SIZE(conn1), conn1);
2214         snd_hda_override_conn_list(codec, 0x1b, ARRAY_SIZE(conn1), conn1);
2215 }
2216
2217 static void alc_fixup_headset_mode_no_hp_mic(struct hda_codec *codec,
2218                                 const struct hda_fixup *fix, int action);
2219
2220 static void alc1220_fixup_clevo_pb51ed(struct hda_codec *codec,
2221                                      const struct hda_fixup *fix,
2222                                      int action)
2223 {
2224         alc1220_fixup_clevo_p950(codec, fix, action);
2225         alc_fixup_headset_mode_no_hp_mic(codec, fix, action);
2226 }
2227
2228 static void alc887_asus_hp_automute_hook(struct hda_codec *codec,
2229                                          struct hda_jack_callback *jack)
2230 {
2231         struct alc_spec *spec = codec->spec;
2232         unsigned int vref;
2233
2234         snd_hda_gen_hp_automute(codec, jack);
2235
2236         if (spec->gen.hp_jack_present)
2237                 vref = AC_PINCTL_VREF_80;
2238         else
2239                 vref = AC_PINCTL_VREF_HIZ;
2240         snd_hda_set_pin_ctl(codec, 0x19, PIN_HP | vref);
2241 }
2242
2243 static void alc887_fixup_asus_jack(struct hda_codec *codec,
2244                                      const struct hda_fixup *fix, int action)
2245 {
2246         struct alc_spec *spec = codec->spec;
2247         if (action != HDA_FIXUP_ACT_PROBE)
2248                 return;
2249         snd_hda_set_pin_ctl_cache(codec, 0x1b, PIN_HP);
2250         spec->gen.hp_automute_hook = alc887_asus_hp_automute_hook;
2251 }
2252
2253 static const struct hda_fixup alc882_fixups[] = {
2254         [ALC882_FIXUP_ABIT_AW9D_MAX] = {
2255                 .type = HDA_FIXUP_PINS,
2256                 .v.pins = (const struct hda_pintbl[]) {
2257                         { 0x15, 0x01080104 }, /* side */
2258                         { 0x16, 0x01011012 }, /* rear */
2259                         { 0x17, 0x01016011 }, /* clfe */
2260                         { }
2261                 }
2262         },
2263         [ALC882_FIXUP_LENOVO_Y530] = {
2264                 .type = HDA_FIXUP_PINS,
2265                 .v.pins = (const struct hda_pintbl[]) {
2266                         { 0x15, 0x99130112 }, /* rear int speakers */
2267                         { 0x16, 0x99130111 }, /* subwoofer */
2268                         { }
2269                 }
2270         },
2271         [ALC882_FIXUP_PB_M5210] = {
2272                 .type = HDA_FIXUP_PINCTLS,
2273                 .v.pins = (const struct hda_pintbl[]) {
2274                         { 0x19, PIN_VREF50 },
2275                         {}
2276                 }
2277         },
2278         [ALC882_FIXUP_ACER_ASPIRE_7736] = {
2279                 .type = HDA_FIXUP_FUNC,
2280                 .v.func = alc_fixup_sku_ignore,
2281         },
2282         [ALC882_FIXUP_ASUS_W90V] = {
2283                 .type = HDA_FIXUP_PINS,
2284                 .v.pins = (const struct hda_pintbl[]) {
2285                         { 0x16, 0x99130110 }, /* fix sequence for CLFE */
2286                         { }
2287                 }
2288         },
2289         [ALC889_FIXUP_CD] = {
2290                 .type = HDA_FIXUP_PINS,
2291                 .v.pins = (const struct hda_pintbl[]) {
2292                         { 0x1c, 0x993301f0 }, /* CD */
2293                         { }
2294                 }
2295         },
2296         [ALC889_FIXUP_FRONT_HP_NO_PRESENCE] = {
2297                 .type = HDA_FIXUP_PINS,
2298                 .v.pins = (const struct hda_pintbl[]) {
2299                         { 0x1b, 0x02214120 }, /* Front HP jack is flaky, disable jack detect */
2300                         { }
2301                 },
2302                 .chained = true,
2303                 .chain_id = ALC889_FIXUP_CD,
2304         },
2305         [ALC889_FIXUP_VAIO_TT] = {
2306                 .type = HDA_FIXUP_PINS,
2307                 .v.pins = (const struct hda_pintbl[]) {
2308                         { 0x17, 0x90170111 }, /* hidden surround speaker */
2309                         { }
2310                 }
2311         },
2312         [ALC888_FIXUP_EEE1601] = {
2313                 .type = HDA_FIXUP_VERBS,
2314                 .v.verbs = (const struct hda_verb[]) {
2315                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x0b },
2316                         { 0x20, AC_VERB_SET_PROC_COEF,  0x0838 },
2317                         { }
2318                 }
2319         },
2320         [ALC886_FIXUP_EAPD] = {
2321                 .type = HDA_FIXUP_VERBS,
2322                 .v.verbs = (const struct hda_verb[]) {
2323                         /* change to EAPD mode */
2324                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x07 },
2325                         { 0x20, AC_VERB_SET_PROC_COEF, 0x0068 },
2326                         { }
2327                 }
2328         },
2329         [ALC882_FIXUP_EAPD] = {
2330                 .type = HDA_FIXUP_VERBS,
2331                 .v.verbs = (const struct hda_verb[]) {
2332                         /* change to EAPD mode */
2333                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x07 },
2334                         { 0x20, AC_VERB_SET_PROC_COEF, 0x3060 },
2335                         { }
2336                 }
2337         },
2338         [ALC883_FIXUP_EAPD] = {
2339                 .type = HDA_FIXUP_VERBS,
2340                 .v.verbs = (const struct hda_verb[]) {
2341                         /* change to EAPD mode */
2342                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x07 },
2343                         { 0x20, AC_VERB_SET_PROC_COEF, 0x3070 },
2344                         { }
2345                 }
2346         },
2347         [ALC883_FIXUP_ACER_EAPD] = {
2348                 .type = HDA_FIXUP_VERBS,
2349                 .v.verbs = (const struct hda_verb[]) {
2350                         /* eanable EAPD on Acer laptops */
2351                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x07 },
2352                         { 0x20, AC_VERB_SET_PROC_COEF, 0x3050 },
2353                         { }
2354                 }
2355         },
2356         [ALC882_FIXUP_GPIO1] = {
2357                 .type = HDA_FIXUP_FUNC,
2358                 .v.func = alc_fixup_gpio1,
2359         },
2360         [ALC882_FIXUP_GPIO2] = {
2361                 .type = HDA_FIXUP_FUNC,
2362                 .v.func = alc_fixup_gpio2,
2363         },
2364         [ALC882_FIXUP_GPIO3] = {
2365                 .type = HDA_FIXUP_FUNC,
2366                 .v.func = alc_fixup_gpio3,
2367         },
2368         [ALC882_FIXUP_ASUS_W2JC] = {
2369                 .type = HDA_FIXUP_FUNC,
2370                 .v.func = alc_fixup_gpio1,
2371                 .chained = true,
2372                 .chain_id = ALC882_FIXUP_EAPD,
2373         },
2374         [ALC889_FIXUP_COEF] = {
2375                 .type = HDA_FIXUP_FUNC,
2376                 .v.func = alc889_fixup_coef,
2377         },
2378         [ALC882_FIXUP_ACER_ASPIRE_4930G] = {
2379                 .type = HDA_FIXUP_PINS,
2380                 .v.pins = (const struct hda_pintbl[]) {
2381                         { 0x16, 0x99130111 }, /* CLFE speaker */
2382                         { 0x17, 0x99130112 }, /* surround speaker */
2383                         { }
2384                 },
2385                 .chained = true,
2386                 .chain_id = ALC882_FIXUP_GPIO1,
2387         },
2388         [ALC882_FIXUP_ACER_ASPIRE_8930G] = {
2389                 .type = HDA_FIXUP_PINS,
2390                 .v.pins = (const struct hda_pintbl[]) {
2391                         { 0x16, 0x99130111 }, /* CLFE speaker */
2392                         { 0x1b, 0x99130112 }, /* surround speaker */
2393                         { }
2394                 },
2395                 .chained = true,
2396                 .chain_id = ALC882_FIXUP_ASPIRE_8930G_VERBS,
2397         },
2398         [ALC882_FIXUP_ASPIRE_8930G_VERBS] = {
2399                 /* additional init verbs for Acer Aspire 8930G */
2400                 .type = HDA_FIXUP_VERBS,
2401                 .v.verbs = (const struct hda_verb[]) {
2402                         /* Enable all DACs */
2403                         /* DAC DISABLE/MUTE 1? */
2404                         /*  setting bits 1-5 disables DAC nids 0x02-0x06
2405                          *  apparently. Init=0x38 */
2406                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x03 },
2407                         { 0x20, AC_VERB_SET_PROC_COEF, 0x0000 },
2408                         /* DAC DISABLE/MUTE 2? */
2409                         /*  some bit here disables the other DACs.
2410                          *  Init=0x4900 */
2411                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x08 },
2412                         { 0x20, AC_VERB_SET_PROC_COEF, 0x0000 },
2413                         /* DMIC fix
2414                          * This laptop has a stereo digital microphone.
2415                          * The mics are only 1cm apart which makes the stereo
2416                          * useless. However, either the mic or the ALC889
2417                          * makes the signal become a difference/sum signal
2418                          * instead of standard stereo, which is annoying.
2419                          * So instead we flip this bit which makes the
2420                          * codec replicate the sum signal to both channels,
2421                          * turning it into a normal mono mic.
2422                          */
2423                         /* DMIC_CONTROL? Init value = 0x0001 */
2424                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x0b },
2425                         { 0x20, AC_VERB_SET_PROC_COEF, 0x0003 },
2426                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x07 },
2427                         { 0x20, AC_VERB_SET_PROC_COEF, 0x3050 },
2428                         { }
2429                 },
2430                 .chained = true,
2431                 .chain_id = ALC882_FIXUP_GPIO1,
2432         },
2433         [ALC885_FIXUP_MACPRO_GPIO] = {
2434                 .type = HDA_FIXUP_FUNC,
2435                 .v.func = alc885_fixup_macpro_gpio,
2436         },
2437         [ALC889_FIXUP_DAC_ROUTE] = {
2438                 .type = HDA_FIXUP_FUNC,
2439                 .v.func = alc889_fixup_dac_route,
2440         },
2441         [ALC889_FIXUP_MBP_VREF] = {
2442                 .type = HDA_FIXUP_FUNC,
2443                 .v.func = alc889_fixup_mbp_vref,
2444                 .chained = true,
2445                 .chain_id = ALC882_FIXUP_GPIO1,
2446         },
2447         [ALC889_FIXUP_IMAC91_VREF] = {
2448                 .type = HDA_FIXUP_FUNC,
2449                 .v.func = alc889_fixup_imac91_vref,
2450                 .chained = true,
2451                 .chain_id = ALC882_FIXUP_GPIO1,
2452         },
2453         [ALC889_FIXUP_MBA11_VREF] = {
2454                 .type = HDA_FIXUP_FUNC,
2455                 .v.func = alc889_fixup_mba11_vref,
2456                 .chained = true,
2457                 .chain_id = ALC889_FIXUP_MBP_VREF,
2458         },
2459         [ALC889_FIXUP_MBA21_VREF] = {
2460                 .type = HDA_FIXUP_FUNC,
2461                 .v.func = alc889_fixup_mba21_vref,
2462                 .chained = true,
2463                 .chain_id = ALC889_FIXUP_MBP_VREF,
2464         },
2465         [ALC889_FIXUP_MP11_VREF] = {
2466                 .type = HDA_FIXUP_FUNC,
2467                 .v.func = alc889_fixup_mba11_vref,
2468                 .chained = true,
2469                 .chain_id = ALC885_FIXUP_MACPRO_GPIO,
2470         },
2471         [ALC889_FIXUP_MP41_VREF] = {
2472                 .type = HDA_FIXUP_FUNC,
2473                 .v.func = alc889_fixup_mbp_vref,
2474                 .chained = true,
2475                 .chain_id = ALC885_FIXUP_MACPRO_GPIO,
2476         },
2477         [ALC882_FIXUP_INV_DMIC] = {
2478                 .type = HDA_FIXUP_FUNC,
2479                 .v.func = alc_fixup_inv_dmic,
2480         },
2481         [ALC882_FIXUP_NO_PRIMARY_HP] = {
2482                 .type = HDA_FIXUP_FUNC,
2483                 .v.func = alc882_fixup_no_primary_hp,
2484         },
2485         [ALC887_FIXUP_ASUS_BASS] = {
2486                 .type = HDA_FIXUP_PINS,
2487                 .v.pins = (const struct hda_pintbl[]) {
2488                         {0x16, 0x99130130}, /* bass speaker */
2489                         {}
2490                 },
2491                 .chained = true,
2492                 .chain_id = ALC887_FIXUP_BASS_CHMAP,
2493         },
2494         [ALC887_FIXUP_BASS_CHMAP] = {
2495                 .type = HDA_FIXUP_FUNC,
2496                 .v.func = alc_fixup_bass_chmap,
2497         },
2498         [ALC1220_FIXUP_GB_DUAL_CODECS] = {
2499                 .type = HDA_FIXUP_FUNC,
2500                 .v.func = alc1220_fixup_gb_dual_codecs,
2501         },
2502         [ALC1220_FIXUP_GB_X570] = {
2503                 .type = HDA_FIXUP_FUNC,
2504                 .v.func = alc1220_fixup_gb_x570,
2505         },
2506         [ALC1220_FIXUP_CLEVO_P950] = {
2507                 .type = HDA_FIXUP_FUNC,
2508                 .v.func = alc1220_fixup_clevo_p950,
2509         },
2510         [ALC1220_FIXUP_CLEVO_PB51ED] = {
2511                 .type = HDA_FIXUP_FUNC,
2512                 .v.func = alc1220_fixup_clevo_pb51ed,
2513         },
2514         [ALC1220_FIXUP_CLEVO_PB51ED_PINS] = {
2515                 .type = HDA_FIXUP_PINS,
2516                 .v.pins = (const struct hda_pintbl[]) {
2517                         { 0x19, 0x01a1913c }, /* use as headset mic, without its own jack detect */
2518                         {}
2519                 },
2520                 .chained = true,
2521                 .chain_id = ALC1220_FIXUP_CLEVO_PB51ED,
2522         },
2523         [ALC887_FIXUP_ASUS_AUDIO] = {
2524                 .type = HDA_FIXUP_PINS,
2525                 .v.pins = (const struct hda_pintbl[]) {
2526                         { 0x15, 0x02a14150 }, /* use as headset mic, without its own jack detect */
2527                         { 0x19, 0x22219420 },
2528                         {}
2529                 },
2530         },
2531         [ALC887_FIXUP_ASUS_HMIC] = {
2532                 .type = HDA_FIXUP_FUNC,
2533                 .v.func = alc887_fixup_asus_jack,
2534                 .chained = true,
2535                 .chain_id = ALC887_FIXUP_ASUS_AUDIO,
2536         },
2537         [ALCS1200A_FIXUP_MIC_VREF] = {
2538                 .type = HDA_FIXUP_PINCTLS,
2539                 .v.pins = (const struct hda_pintbl[]) {
2540                         { 0x18, PIN_VREF50 }, /* rear mic */
2541                         { 0x19, PIN_VREF50 }, /* front mic */
2542                         {}
2543                 }
2544         },
2545         [ALC888VD_FIXUP_MIC_100VREF] = {
2546                 .type = HDA_FIXUP_PINCTLS,
2547                 .v.pins = (const struct hda_pintbl[]) {
2548                         { 0x18, PIN_VREF100 }, /* headset mic */
2549                         {}
2550                 }
2551         },
2552 };
2553
2554 static const struct snd_pci_quirk alc882_fixup_tbl[] = {
2555         SND_PCI_QUIRK(0x1025, 0x006c, "Acer Aspire 9810", ALC883_FIXUP_ACER_EAPD),
2556         SND_PCI_QUIRK(0x1025, 0x0090, "Acer Aspire", ALC883_FIXUP_ACER_EAPD),
2557         SND_PCI_QUIRK(0x1025, 0x0107, "Acer Aspire", ALC883_FIXUP_ACER_EAPD),
2558         SND_PCI_QUIRK(0x1025, 0x010a, "Acer Ferrari 5000", ALC883_FIXUP_ACER_EAPD),
2559         SND_PCI_QUIRK(0x1025, 0x0110, "Acer Aspire", ALC883_FIXUP_ACER_EAPD),
2560         SND_PCI_QUIRK(0x1025, 0x0112, "Acer Aspire 9303", ALC883_FIXUP_ACER_EAPD),
2561         SND_PCI_QUIRK(0x1025, 0x0121, "Acer Aspire 5920G", ALC883_FIXUP_ACER_EAPD),
2562         SND_PCI_QUIRK(0x1025, 0x013e, "Acer Aspire 4930G",
2563                       ALC882_FIXUP_ACER_ASPIRE_4930G),
2564         SND_PCI_QUIRK(0x1025, 0x013f, "Acer Aspire 5930G",
2565                       ALC882_FIXUP_ACER_ASPIRE_4930G),
2566         SND_PCI_QUIRK(0x1025, 0x0145, "Acer Aspire 8930G",
2567                       ALC882_FIXUP_ACER_ASPIRE_8930G),
2568         SND_PCI_QUIRK(0x1025, 0x0146, "Acer Aspire 6935G",
2569                       ALC882_FIXUP_ACER_ASPIRE_8930G),
2570         SND_PCI_QUIRK(0x1025, 0x0142, "Acer Aspire 7730G",
2571                       ALC882_FIXUP_ACER_ASPIRE_4930G),
2572         SND_PCI_QUIRK(0x1025, 0x0155, "Packard-Bell M5120", ALC882_FIXUP_PB_M5210),
2573         SND_PCI_QUIRK(0x1025, 0x015e, "Acer Aspire 6930G",
2574                       ALC882_FIXUP_ACER_ASPIRE_4930G),
2575         SND_PCI_QUIRK(0x1025, 0x0166, "Acer Aspire 6530G",
2576                       ALC882_FIXUP_ACER_ASPIRE_4930G),
2577         SND_PCI_QUIRK(0x1025, 0x021e, "Acer Aspire 5739G",
2578                       ALC882_FIXUP_ACER_ASPIRE_4930G),
2579         SND_PCI_QUIRK(0x1025, 0x0259, "Acer Aspire 5935", ALC889_FIXUP_DAC_ROUTE),
2580         SND_PCI_QUIRK(0x1025, 0x026b, "Acer Aspire 8940G", ALC882_FIXUP_ACER_ASPIRE_8930G),
2581         SND_PCI_QUIRK(0x1025, 0x0296, "Acer Aspire 7736z", ALC882_FIXUP_ACER_ASPIRE_7736),
2582         SND_PCI_QUIRK(0x1043, 0x13c2, "Asus A7M", ALC882_FIXUP_EAPD),
2583         SND_PCI_QUIRK(0x1043, 0x1873, "ASUS W90V", ALC882_FIXUP_ASUS_W90V),
2584         SND_PCI_QUIRK(0x1043, 0x1971, "Asus W2JC", ALC882_FIXUP_ASUS_W2JC),
2585         SND_PCI_QUIRK(0x1043, 0x2390, "Asus D700SA", ALC887_FIXUP_ASUS_HMIC),
2586         SND_PCI_QUIRK(0x1043, 0x835f, "Asus Eee 1601", ALC888_FIXUP_EEE1601),
2587         SND_PCI_QUIRK(0x1043, 0x84bc, "ASUS ET2700", ALC887_FIXUP_ASUS_BASS),
2588         SND_PCI_QUIRK(0x1043, 0x8691, "ASUS ROG Ranger VIII", ALC882_FIXUP_GPIO3),
2589         SND_PCI_QUIRK(0x1043, 0x8797, "ASUS TUF B550M-PLUS", ALCS1200A_FIXUP_MIC_VREF),
2590         SND_PCI_QUIRK(0x104d, 0x9043, "Sony Vaio VGC-LN51JGB", ALC882_FIXUP_NO_PRIMARY_HP),
2591         SND_PCI_QUIRK(0x104d, 0x9044, "Sony VAIO AiO", ALC882_FIXUP_NO_PRIMARY_HP),
2592         SND_PCI_QUIRK(0x104d, 0x9047, "Sony Vaio TT", ALC889_FIXUP_VAIO_TT),
2593         SND_PCI_QUIRK(0x104d, 0x905a, "Sony Vaio Z", ALC882_FIXUP_NO_PRIMARY_HP),
2594         SND_PCI_QUIRK(0x104d, 0x9060, "Sony Vaio VPCL14M1R", ALC882_FIXUP_NO_PRIMARY_HP),
2595
2596         /* All Apple entries are in codec SSIDs */
2597         SND_PCI_QUIRK(0x106b, 0x00a0, "MacBookPro 3,1", ALC889_FIXUP_MBP_VREF),
2598         SND_PCI_QUIRK(0x106b, 0x00a1, "Macbook", ALC889_FIXUP_MBP_VREF),
2599         SND_PCI_QUIRK(0x106b, 0x00a4, "MacbookPro 4,1", ALC889_FIXUP_MBP_VREF),
2600         SND_PCI_QUIRK(0x106b, 0x0c00, "Mac Pro", ALC889_FIXUP_MP11_VREF),
2601         SND_PCI_QUIRK(0x106b, 0x1000, "iMac 24", ALC885_FIXUP_MACPRO_GPIO),
2602         SND_PCI_QUIRK(0x106b, 0x2800, "AppleTV", ALC885_FIXUP_MACPRO_GPIO),
2603         SND_PCI_QUIRK(0x106b, 0x2c00, "MacbookPro rev3", ALC889_FIXUP_MBP_VREF),
2604         SND_PCI_QUIRK(0x106b, 0x3000, "iMac", ALC889_FIXUP_MBP_VREF),
2605         SND_PCI_QUIRK(0x106b, 0x3200, "iMac 7,1 Aluminum", ALC882_FIXUP_EAPD),
2606         SND_PCI_QUIRK(0x106b, 0x3400, "MacBookAir 1,1", ALC889_FIXUP_MBA11_VREF),
2607         SND_PCI_QUIRK(0x106b, 0x3500, "MacBookAir 2,1", ALC889_FIXUP_MBA21_VREF),
2608         SND_PCI_QUIRK(0x106b, 0x3600, "Macbook 3,1", ALC889_FIXUP_MBP_VREF),
2609         SND_PCI_QUIRK(0x106b, 0x3800, "MacbookPro 4,1", ALC889_FIXUP_MBP_VREF),
2610         SND_PCI_QUIRK(0x106b, 0x3e00, "iMac 24 Aluminum", ALC885_FIXUP_MACPRO_GPIO),
2611         SND_PCI_QUIRK(0x106b, 0x3f00, "Macbook 5,1", ALC889_FIXUP_IMAC91_VREF),
2612         SND_PCI_QUIRK(0x106b, 0x4000, "MacbookPro 5,1", ALC889_FIXUP_IMAC91_VREF),
2613         SND_PCI_QUIRK(0x106b, 0x4100, "Macmini 3,1", ALC889_FIXUP_IMAC91_VREF),
2614         SND_PCI_QUIRK(0x106b, 0x4200, "Mac Pro 4,1/5,1", ALC889_FIXUP_MP41_VREF),
2615         SND_PCI_QUIRK(0x106b, 0x4300, "iMac 9,1", ALC889_FIXUP_IMAC91_VREF),
2616         SND_PCI_QUIRK(0x106b, 0x4600, "MacbookPro 5,2", ALC889_FIXUP_IMAC91_VREF),
2617         SND_PCI_QUIRK(0x106b, 0x4900, "iMac 9,1 Aluminum", ALC889_FIXUP_IMAC91_VREF),
2618         SND_PCI_QUIRK(0x106b, 0x4a00, "Macbook 5,2", ALC889_FIXUP_MBA11_VREF),
2619
2620         SND_PCI_QUIRK(0x1071, 0x8258, "Evesham Voyaeger", ALC882_FIXUP_EAPD),
2621         SND_PCI_QUIRK(0x10ec, 0x12d8, "iBase Elo Touch", ALC888VD_FIXUP_MIC_100VREF),
2622         SND_PCI_QUIRK(0x13fe, 0x1009, "Advantech MIT-W101", ALC886_FIXUP_EAPD),
2623         SND_PCI_QUIRK(0x1458, 0xa002, "Gigabyte EP45-DS3/Z87X-UD3H", ALC889_FIXUP_FRONT_HP_NO_PRESENCE),
2624         SND_PCI_QUIRK(0x1458, 0xa0b8, "Gigabyte AZ370-Gaming", ALC1220_FIXUP_GB_DUAL_CODECS),
2625         SND_PCI_QUIRK(0x1458, 0xa0cd, "Gigabyte X570 Aorus Master", ALC1220_FIXUP_GB_X570),
2626         SND_PCI_QUIRK(0x1458, 0xa0ce, "Gigabyte X570 Aorus Xtreme", ALC1220_FIXUP_GB_X570),
2627         SND_PCI_QUIRK(0x1458, 0xa0d5, "Gigabyte X570S Aorus Master", ALC1220_FIXUP_GB_X570),
2628         SND_PCI_QUIRK(0x1462, 0x11f7, "MSI-GE63", ALC1220_FIXUP_CLEVO_P950),
2629         SND_PCI_QUIRK(0x1462, 0x1228, "MSI-GP63", ALC1220_FIXUP_CLEVO_P950),
2630         SND_PCI_QUIRK(0x1462, 0x1229, "MSI-GP73", ALC1220_FIXUP_CLEVO_P950),
2631         SND_PCI_QUIRK(0x1462, 0x1275, "MSI-GL63", ALC1220_FIXUP_CLEVO_P950),
2632         SND_PCI_QUIRK(0x1462, 0x1276, "MSI-GL73", ALC1220_FIXUP_CLEVO_P950),
2633         SND_PCI_QUIRK(0x1462, 0x1293, "MSI-GP65", ALC1220_FIXUP_CLEVO_P950),
2634         SND_PCI_QUIRK(0x1462, 0x7350, "MSI-7350", ALC889_FIXUP_CD),
2635         SND_PCI_QUIRK(0x1462, 0xcc34, "MSI Godlike X570", ALC1220_FIXUP_GB_DUAL_CODECS),
2636         SND_PCI_QUIRK(0x1462, 0xda57, "MSI Z270-Gaming", ALC1220_FIXUP_GB_DUAL_CODECS),
2637         SND_PCI_QUIRK_VENDOR(0x1462, "MSI", ALC882_FIXUP_GPIO3),
2638         SND_PCI_QUIRK(0x147b, 0x107a, "Abit AW9D-MAX", ALC882_FIXUP_ABIT_AW9D_MAX),
2639         SND_PCI_QUIRK(0x1558, 0x3702, "Clevo X370SN[VW]", ALC1220_FIXUP_CLEVO_PB51ED_PINS),
2640         SND_PCI_QUIRK(0x1558, 0x50d3, "Clevo PC50[ER][CDF]", ALC1220_FIXUP_CLEVO_PB51ED_PINS),
2641         SND_PCI_QUIRK(0x1558, 0x65d1, "Clevo PB51[ER][CDF]", ALC1220_FIXUP_CLEVO_PB51ED_PINS),
2642         SND_PCI_QUIRK(0x1558, 0x65d2, "Clevo PB51R[CDF]", ALC1220_FIXUP_CLEVO_PB51ED_PINS),
2643         SND_PCI_QUIRK(0x1558, 0x65e1, "Clevo PB51[ED][DF]", ALC1220_FIXUP_CLEVO_PB51ED_PINS),
2644         SND_PCI_QUIRK(0x1558, 0x65e5, "Clevo PC50D[PRS](?:-D|-G)?", ALC1220_FIXUP_CLEVO_PB51ED_PINS),
2645         SND_PCI_QUIRK(0x1558, 0x65f1, "Clevo PC50HS", ALC1220_FIXUP_CLEVO_PB51ED_PINS),
2646         SND_PCI_QUIRK(0x1558, 0x65f5, "Clevo PD50PN[NRT]", ALC1220_FIXUP_CLEVO_PB51ED_PINS),
2647         SND_PCI_QUIRK(0x1558, 0x66a2, "Clevo PE60RNE", ALC1220_FIXUP_CLEVO_PB51ED_PINS),
2648         SND_PCI_QUIRK(0x1558, 0x67d1, "Clevo PB71[ER][CDF]", ALC1220_FIXUP_CLEVO_PB51ED_PINS),
2649         SND_PCI_QUIRK(0x1558, 0x67e1, "Clevo PB71[DE][CDF]", ALC1220_FIXUP_CLEVO_PB51ED_PINS),
2650         SND_PCI_QUIRK(0x1558, 0x67e5, "Clevo PC70D[PRS](?:-D|-G)?", ALC1220_FIXUP_CLEVO_PB51ED_PINS),
2651         SND_PCI_QUIRK(0x1558, 0x67f1, "Clevo PC70H[PRS]", ALC1220_FIXUP_CLEVO_PB51ED_PINS),
2652         SND_PCI_QUIRK(0x1558, 0x67f5, "Clevo PD70PN[NRT]", ALC1220_FIXUP_CLEVO_PB51ED_PINS),
2653         SND_PCI_QUIRK(0x1558, 0x70d1, "Clevo PC70[ER][CDF]", ALC1220_FIXUP_CLEVO_PB51ED_PINS),
2654         SND_PCI_QUIRK(0x1558, 0x7714, "Clevo X170SM", ALC1220_FIXUP_CLEVO_PB51ED_PINS),
2655         SND_PCI_QUIRK(0x1558, 0x7715, "Clevo X170KM-G", ALC1220_FIXUP_CLEVO_PB51ED),
2656         SND_PCI_QUIRK(0x1558, 0x9501, "Clevo P950HR", ALC1220_FIXUP_CLEVO_P950),
2657         SND_PCI_QUIRK(0x1558, 0x9506, "Clevo P955HQ", ALC1220_FIXUP_CLEVO_P950),
2658         SND_PCI_QUIRK(0x1558, 0x950a, "Clevo P955H[PR]", ALC1220_FIXUP_CLEVO_P950),
2659         SND_PCI_QUIRK(0x1558, 0x95e1, "Clevo P95xER", ALC1220_FIXUP_CLEVO_P950),
2660         SND_PCI_QUIRK(0x1558, 0x95e2, "Clevo P950ER", ALC1220_FIXUP_CLEVO_P950),
2661         SND_PCI_QUIRK(0x1558, 0x95e3, "Clevo P955[ER]T", ALC1220_FIXUP_CLEVO_P950),
2662         SND_PCI_QUIRK(0x1558, 0x95e4, "Clevo P955ER", ALC1220_FIXUP_CLEVO_P950),
2663         SND_PCI_QUIRK(0x1558, 0x95e5, "Clevo P955EE6", ALC1220_FIXUP_CLEVO_P950),
2664         SND_PCI_QUIRK(0x1558, 0x95e6, "Clevo P950R[CDF]", ALC1220_FIXUP_CLEVO_P950),
2665         SND_PCI_QUIRK(0x1558, 0x96e1, "Clevo P960[ER][CDFN]-K", ALC1220_FIXUP_CLEVO_P950),
2666         SND_PCI_QUIRK(0x1558, 0x97e1, "Clevo P970[ER][CDFN]", ALC1220_FIXUP_CLEVO_P950),
2667         SND_PCI_QUIRK(0x1558, 0x97e2, "Clevo P970RC-M", ALC1220_FIXUP_CLEVO_P950),
2668         SND_PCI_QUIRK(0x1558, 0xd502, "Clevo PD50SNE", ALC1220_FIXUP_CLEVO_PB51ED_PINS),
2669         SND_PCI_QUIRK_VENDOR(0x1558, "Clevo laptop", ALC882_FIXUP_EAPD),
2670         SND_PCI_QUIRK(0x161f, 0x2054, "Medion laptop", ALC883_FIXUP_EAPD),
2671         SND_PCI_QUIRK(0x17aa, 0x3a0d, "Lenovo Y530", ALC882_FIXUP_LENOVO_Y530),
2672         SND_PCI_QUIRK(0x8086, 0x0022, "DX58SO", ALC889_FIXUP_COEF),
2673         {}
2674 };
2675
2676 static const struct hda_model_fixup alc882_fixup_models[] = {
2677         {.id = ALC882_FIXUP_ABIT_AW9D_MAX, .name = "abit-aw9d"},
2678         {.id = ALC882_FIXUP_LENOVO_Y530, .name = "lenovo-y530"},
2679         {.id = ALC882_FIXUP_ACER_ASPIRE_7736, .name = "acer-aspire-7736"},
2680         {.id = ALC882_FIXUP_ASUS_W90V, .name = "asus-w90v"},
2681         {.id = ALC889_FIXUP_CD, .name = "cd"},
2682         {.id = ALC889_FIXUP_FRONT_HP_NO_PRESENCE, .name = "no-front-hp"},
2683         {.id = ALC889_FIXUP_VAIO_TT, .name = "vaio-tt"},
2684         {.id = ALC888_FIXUP_EEE1601, .name = "eee1601"},
2685         {.id = ALC882_FIXUP_EAPD, .name = "alc882-eapd"},
2686         {.id = ALC883_FIXUP_EAPD, .name = "alc883-eapd"},
2687         {.id = ALC882_FIXUP_GPIO1, .name = "gpio1"},
2688         {.id = ALC882_FIXUP_GPIO2, .name = "gpio2"},
2689         {.id = ALC882_FIXUP_GPIO3, .name = "gpio3"},
2690         {.id = ALC889_FIXUP_COEF, .name = "alc889-coef"},
2691         {.id = ALC882_FIXUP_ASUS_W2JC, .name = "asus-w2jc"},
2692         {.id = ALC882_FIXUP_ACER_ASPIRE_4930G, .name = "acer-aspire-4930g"},
2693         {.id = ALC882_FIXUP_ACER_ASPIRE_8930G, .name = "acer-aspire-8930g"},
2694         {.id = ALC883_FIXUP_ACER_EAPD, .name = "acer-aspire"},
2695         {.id = ALC885_FIXUP_MACPRO_GPIO, .name = "macpro-gpio"},
2696         {.id = ALC889_FIXUP_DAC_ROUTE, .name = "dac-route"},
2697         {.id = ALC889_FIXUP_MBP_VREF, .name = "mbp-vref"},
2698         {.id = ALC889_FIXUP_IMAC91_VREF, .name = "imac91-vref"},
2699         {.id = ALC889_FIXUP_MBA11_VREF, .name = "mba11-vref"},
2700         {.id = ALC889_FIXUP_MBA21_VREF, .name = "mba21-vref"},
2701         {.id = ALC889_FIXUP_MP11_VREF, .name = "mp11-vref"},
2702         {.id = ALC889_FIXUP_MP41_VREF, .name = "mp41-vref"},
2703         {.id = ALC882_FIXUP_INV_DMIC, .name = "inv-dmic"},
2704         {.id = ALC882_FIXUP_NO_PRIMARY_HP, .name = "no-primary-hp"},
2705         {.id = ALC887_FIXUP_ASUS_BASS, .name = "asus-bass"},
2706         {.id = ALC1220_FIXUP_GB_DUAL_CODECS, .name = "dual-codecs"},
2707         {.id = ALC1220_FIXUP_GB_X570, .name = "gb-x570"},
2708         {.id = ALC1220_FIXUP_CLEVO_P950, .name = "clevo-p950"},
2709         {}
2710 };
2711
2712 static const struct snd_hda_pin_quirk alc882_pin_fixup_tbl[] = {
2713         SND_HDA_PIN_QUIRK(0x10ec1220, 0x1043, "ASUS", ALC1220_FIXUP_CLEVO_P950,
2714                 {0x14, 0x01014010},
2715                 {0x15, 0x01011012},
2716                 {0x16, 0x01016011},
2717                 {0x18, 0x01a19040},
2718                 {0x19, 0x02a19050},
2719                 {0x1a, 0x0181304f},
2720                 {0x1b, 0x0221401f},
2721                 {0x1e, 0x01456130}),
2722         SND_HDA_PIN_QUIRK(0x10ec1220, 0x1462, "MS-7C35", ALC1220_FIXUP_CLEVO_P950,
2723                 {0x14, 0x01015010},
2724                 {0x15, 0x01011012},
2725                 {0x16, 0x01011011},
2726                 {0x18, 0x01a11040},
2727                 {0x19, 0x02a19050},
2728                 {0x1a, 0x0181104f},
2729                 {0x1b, 0x0221401f},
2730                 {0x1e, 0x01451130}),
2731         {}
2732 };
2733
2734 /*
2735  * BIOS auto configuration
2736  */
2737 /* almost identical with ALC880 parser... */
2738 static int alc882_parse_auto_config(struct hda_codec *codec)
2739 {
2740         static const hda_nid_t alc882_ignore[] = { 0x1d, 0 };
2741         static const hda_nid_t alc882_ssids[] = { 0x15, 0x1b, 0x14, 0 };
2742         return alc_parse_auto_config(codec, alc882_ignore, alc882_ssids);
2743 }
2744
2745 /*
2746  */
2747 static int patch_alc882(struct hda_codec *codec)
2748 {
2749         struct alc_spec *spec;
2750         int err;
2751
2752         err = alc_alloc_spec(codec, 0x0b);
2753         if (err < 0)
2754                 return err;
2755
2756         spec = codec->spec;
2757
2758         switch (codec->core.vendor_id) {
2759         case 0x10ec0882:
2760         case 0x10ec0885:
2761         case 0x10ec0900:
2762         case 0x10ec0b00:
2763         case 0x10ec1220:
2764                 break;
2765         default:
2766                 /* ALC883 and variants */
2767                 alc_fix_pll_init(codec, 0x20, 0x0a, 10);
2768                 break;
2769         }
2770
2771         alc_pre_init(codec);
2772
2773         snd_hda_pick_fixup(codec, alc882_fixup_models, alc882_fixup_tbl,
2774                        alc882_fixups);
2775         snd_hda_pick_pin_fixup(codec, alc882_pin_fixup_tbl, alc882_fixups, true);
2776         snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE);
2777
2778         alc_auto_parse_customize_define(codec);
2779
2780         if (has_cdefine_beep(codec))
2781                 spec->gen.beep_nid = 0x01;
2782
2783         /* automatic parse from the BIOS config */
2784         err = alc882_parse_auto_config(codec);
2785         if (err < 0)
2786                 goto error;
2787
2788         if (!spec->gen.no_analog && spec->gen.beep_nid) {
2789                 err = set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
2790                 if (err < 0)
2791                         goto error;
2792         }
2793
2794         snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE);
2795
2796         return 0;
2797
2798  error:
2799         alc_free(codec);
2800         return err;
2801 }
2802
2803
2804 /*
2805  * ALC262 support
2806  */
2807 static int alc262_parse_auto_config(struct hda_codec *codec)
2808 {
2809         static const hda_nid_t alc262_ignore[] = { 0x1d, 0 };
2810         static const hda_nid_t alc262_ssids[] = { 0x15, 0x1b, 0x14, 0 };
2811         return alc_parse_auto_config(codec, alc262_ignore, alc262_ssids);
2812 }
2813
2814 /*
2815  * Pin config fixes
2816  */
2817 enum {
2818         ALC262_FIXUP_FSC_H270,
2819         ALC262_FIXUP_FSC_S7110,
2820         ALC262_FIXUP_HP_Z200,
2821         ALC262_FIXUP_TYAN,
2822         ALC262_FIXUP_LENOVO_3000,
2823         ALC262_FIXUP_BENQ,
2824         ALC262_FIXUP_BENQ_T31,
2825         ALC262_FIXUP_INV_DMIC,
2826         ALC262_FIXUP_INTEL_BAYLEYBAY,
2827 };
2828
2829 static const struct hda_fixup alc262_fixups[] = {
2830         [ALC262_FIXUP_FSC_H270] = {
2831                 .type = HDA_FIXUP_PINS,
2832                 .v.pins = (const struct hda_pintbl[]) {
2833                         { 0x14, 0x99130110 }, /* speaker */
2834                         { 0x15, 0x0221142f }, /* front HP */
2835                         { 0x1b, 0x0121141f }, /* rear HP */
2836                         { }
2837                 }
2838         },
2839         [ALC262_FIXUP_FSC_S7110] = {
2840                 .type = HDA_FIXUP_PINS,
2841                 .v.pins = (const struct hda_pintbl[]) {
2842                         { 0x15, 0x90170110 }, /* speaker */
2843                         { }
2844                 },
2845                 .chained = true,
2846                 .chain_id = ALC262_FIXUP_BENQ,
2847         },
2848         [ALC262_FIXUP_HP_Z200] = {
2849                 .type = HDA_FIXUP_PINS,
2850                 .v.pins = (const struct hda_pintbl[]) {
2851                         { 0x16, 0x99130120 }, /* internal speaker */
2852                         { }
2853                 }
2854         },
2855         [ALC262_FIXUP_TYAN] = {
2856                 .type = HDA_FIXUP_PINS,
2857                 .v.pins = (const struct hda_pintbl[]) {
2858                         { 0x14, 0x1993e1f0 }, /* int AUX */
2859                         { }
2860                 }
2861         },
2862         [ALC262_FIXUP_LENOVO_3000] = {
2863                 .type = HDA_FIXUP_PINCTLS,
2864                 .v.pins = (const struct hda_pintbl[]) {
2865                         { 0x19, PIN_VREF50 },
2866                         {}
2867                 },
2868                 .chained = true,
2869                 .chain_id = ALC262_FIXUP_BENQ,
2870         },
2871         [ALC262_FIXUP_BENQ] = {
2872                 .type = HDA_FIXUP_VERBS,
2873                 .v.verbs = (const struct hda_verb[]) {
2874                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x07 },
2875                         { 0x20, AC_VERB_SET_PROC_COEF, 0x3070 },
2876                         {}
2877                 }
2878         },
2879         [ALC262_FIXUP_BENQ_T31] = {
2880                 .type = HDA_FIXUP_VERBS,
2881                 .v.verbs = (const struct hda_verb[]) {
2882                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x07 },
2883                         { 0x20, AC_VERB_SET_PROC_COEF, 0x3050 },
2884                         {}
2885                 }
2886         },
2887         [ALC262_FIXUP_INV_DMIC] = {
2888                 .type = HDA_FIXUP_FUNC,
2889                 .v.func = alc_fixup_inv_dmic,
2890         },
2891         [ALC262_FIXUP_INTEL_BAYLEYBAY] = {
2892                 .type = HDA_FIXUP_FUNC,
2893                 .v.func = alc_fixup_no_depop_delay,
2894         },
2895 };
2896
2897 static const struct snd_pci_quirk alc262_fixup_tbl[] = {
2898         SND_PCI_QUIRK(0x103c, 0x170b, "HP Z200", ALC262_FIXUP_HP_Z200),
2899         SND_PCI_QUIRK(0x10cf, 0x1397, "Fujitsu Lifebook S7110", ALC262_FIXUP_FSC_S7110),
2900         SND_PCI_QUIRK(0x10cf, 0x142d, "Fujitsu Lifebook E8410", ALC262_FIXUP_BENQ),
2901         SND_PCI_QUIRK(0x10f1, 0x2915, "Tyan Thunder n6650W", ALC262_FIXUP_TYAN),
2902         SND_PCI_QUIRK(0x1734, 0x1141, "FSC ESPRIMO U9210", ALC262_FIXUP_FSC_H270),
2903         SND_PCI_QUIRK(0x1734, 0x1147, "FSC Celsius H270", ALC262_FIXUP_FSC_H270),
2904         SND_PCI_QUIRK(0x17aa, 0x384e, "Lenovo 3000", ALC262_FIXUP_LENOVO_3000),
2905         SND_PCI_QUIRK(0x17ff, 0x0560, "Benq ED8", ALC262_FIXUP_BENQ),
2906         SND_PCI_QUIRK(0x17ff, 0x058d, "Benq T31-16", ALC262_FIXUP_BENQ_T31),
2907         SND_PCI_QUIRK(0x8086, 0x7270, "BayleyBay", ALC262_FIXUP_INTEL_BAYLEYBAY),
2908         {}
2909 };
2910
2911 static const struct hda_model_fixup alc262_fixup_models[] = {
2912         {.id = ALC262_FIXUP_INV_DMIC, .name = "inv-dmic"},
2913         {.id = ALC262_FIXUP_FSC_H270, .name = "fsc-h270"},
2914         {.id = ALC262_FIXUP_FSC_S7110, .name = "fsc-s7110"},
2915         {.id = ALC262_FIXUP_HP_Z200, .name = "hp-z200"},
2916         {.id = ALC262_FIXUP_TYAN, .name = "tyan"},
2917         {.id = ALC262_FIXUP_LENOVO_3000, .name = "lenovo-3000"},
2918         {.id = ALC262_FIXUP_BENQ, .name = "benq"},
2919         {.id = ALC262_FIXUP_BENQ_T31, .name = "benq-t31"},
2920         {.id = ALC262_FIXUP_INTEL_BAYLEYBAY, .name = "bayleybay"},
2921         {}
2922 };
2923
2924 /*
2925  */
2926 static int patch_alc262(struct hda_codec *codec)
2927 {
2928         struct alc_spec *spec;
2929         int err;
2930
2931         err = alc_alloc_spec(codec, 0x0b);
2932         if (err < 0)
2933                 return err;
2934
2935         spec = codec->spec;
2936         spec->gen.shared_mic_vref_pin = 0x18;
2937
2938         spec->shutup = alc_eapd_shutup;
2939
2940 #if 0
2941         /* pshou 07/11/05  set a zero PCM sample to DAC when FIFO is
2942          * under-run
2943          */
2944         alc_update_coefex_idx(codec, 0x1a, 7, 0, 0x80);
2945 #endif
2946         alc_fix_pll_init(codec, 0x20, 0x0a, 10);
2947
2948         alc_pre_init(codec);
2949
2950         snd_hda_pick_fixup(codec, alc262_fixup_models, alc262_fixup_tbl,
2951                        alc262_fixups);
2952         snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE);
2953
2954         alc_auto_parse_customize_define(codec);
2955
2956         if (has_cdefine_beep(codec))
2957                 spec->gen.beep_nid = 0x01;
2958
2959         /* automatic parse from the BIOS config */
2960         err = alc262_parse_auto_config(codec);
2961         if (err < 0)
2962                 goto error;
2963
2964         if (!spec->gen.no_analog && spec->gen.beep_nid) {
2965                 err = set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
2966                 if (err < 0)
2967                         goto error;
2968         }
2969
2970         snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE);
2971
2972         return 0;
2973
2974  error:
2975         alc_free(codec);
2976         return err;
2977 }
2978
2979 /*
2980  *  ALC268
2981  */
2982 /* bind Beep switches of both NID 0x0f and 0x10 */
2983 static int alc268_beep_switch_put(struct snd_kcontrol *kcontrol,
2984                                   struct snd_ctl_elem_value *ucontrol)
2985 {
2986         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2987         unsigned long pval;
2988         int err;
2989
2990         mutex_lock(&codec->control_mutex);
2991         pval = kcontrol->private_value;
2992         kcontrol->private_value = (pval & ~0xff) | 0x0f;
2993         err = snd_hda_mixer_amp_switch_put(kcontrol, ucontrol);
2994         if (err >= 0) {
2995                 kcontrol->private_value = (pval & ~0xff) | 0x10;
2996                 err = snd_hda_mixer_amp_switch_put(kcontrol, ucontrol);
2997         }
2998         kcontrol->private_value = pval;
2999         mutex_unlock(&codec->control_mutex);
3000         return err;
3001 }
3002
3003 static const struct snd_kcontrol_new alc268_beep_mixer[] = {
3004         HDA_CODEC_VOLUME("Beep Playback Volume", 0x1d, 0x0, HDA_INPUT),
3005         {
3006                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3007                 .name = "Beep Playback Switch",
3008                 .subdevice = HDA_SUBDEV_AMP_FLAG,
3009                 .info = snd_hda_mixer_amp_switch_info,
3010                 .get = snd_hda_mixer_amp_switch_get,
3011                 .put = alc268_beep_switch_put,
3012                 .private_value = HDA_COMPOSE_AMP_VAL(0x0f, 3, 1, HDA_INPUT)
3013         },
3014 };
3015
3016 /* set PCBEEP vol = 0, mute connections */
3017 static const struct hda_verb alc268_beep_init_verbs[] = {
3018         {0x1d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
3019         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
3020         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
3021         { }
3022 };
3023
3024 enum {
3025         ALC268_FIXUP_INV_DMIC,
3026         ALC268_FIXUP_HP_EAPD,
3027         ALC268_FIXUP_SPDIF,
3028 };
3029
3030 static const struct hda_fixup alc268_fixups[] = {
3031         [ALC268_FIXUP_INV_DMIC] = {
3032                 .type = HDA_FIXUP_FUNC,
3033                 .v.func = alc_fixup_inv_dmic,
3034         },
3035         [ALC268_FIXUP_HP_EAPD] = {
3036                 .type = HDA_FIXUP_VERBS,
3037                 .v.verbs = (const struct hda_verb[]) {
3038                         {0x15, AC_VERB_SET_EAPD_BTLENABLE, 0},
3039                         {}
3040                 }
3041         },
3042         [ALC268_FIXUP_SPDIF] = {
3043                 .type = HDA_FIXUP_PINS,
3044                 .v.pins = (const struct hda_pintbl[]) {
3045                         { 0x1e, 0x014b1180 }, /* enable SPDIF out */
3046                         {}
3047                 }
3048         },
3049 };
3050
3051 static const struct hda_model_fixup alc268_fixup_models[] = {
3052         {.id = ALC268_FIXUP_INV_DMIC, .name = "inv-dmic"},
3053         {.id = ALC268_FIXUP_HP_EAPD, .name = "hp-eapd"},
3054         {.id = ALC268_FIXUP_SPDIF, .name = "spdif"},
3055         {}
3056 };
3057
3058 static const struct snd_pci_quirk alc268_fixup_tbl[] = {
3059         SND_PCI_QUIRK(0x1025, 0x0139, "Acer TravelMate 6293", ALC268_FIXUP_SPDIF),
3060         SND_PCI_QUIRK(0x1025, 0x015b, "Acer AOA 150 (ZG5)", ALC268_FIXUP_INV_DMIC),
3061         /* below is codec SSID since multiple Toshiba laptops have the
3062          * same PCI SSID 1179:ff00
3063          */
3064         SND_PCI_QUIRK(0x1179, 0xff06, "Toshiba P200", ALC268_FIXUP_HP_EAPD),
3065         {}
3066 };
3067
3068 /*
3069  * BIOS auto configuration
3070  */
3071 static int alc268_parse_auto_config(struct hda_codec *codec)
3072 {
3073         static const hda_nid_t alc268_ssids[] = { 0x15, 0x1b, 0x14, 0 };
3074         return alc_parse_auto_config(codec, NULL, alc268_ssids);
3075 }
3076
3077 /*
3078  */
3079 static int patch_alc268(struct hda_codec *codec)
3080 {
3081         struct alc_spec *spec;
3082         int i, err;
3083
3084         /* ALC268 has no aa-loopback mixer */
3085         err = alc_alloc_spec(codec, 0);
3086         if (err < 0)
3087                 return err;
3088
3089         spec = codec->spec;
3090         if (has_cdefine_beep(codec))
3091                 spec->gen.beep_nid = 0x01;
3092
3093         spec->shutup = alc_eapd_shutup;
3094
3095         alc_pre_init(codec);
3096
3097         snd_hda_pick_fixup(codec, alc268_fixup_models, alc268_fixup_tbl, alc268_fixups);
3098         snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE);
3099
3100         /* automatic parse from the BIOS config */
3101         err = alc268_parse_auto_config(codec);
3102         if (err < 0)
3103                 goto error;
3104
3105         if (err > 0 && !spec->gen.no_analog &&
3106             spec->gen.autocfg.speaker_pins[0] != 0x1d) {
3107                 for (i = 0; i < ARRAY_SIZE(alc268_beep_mixer); i++) {
3108                         if (!snd_hda_gen_add_kctl(&spec->gen, NULL,
3109                                                   &alc268_beep_mixer[i])) {
3110                                 err = -ENOMEM;
3111                                 goto error;
3112                         }
3113                 }
3114                 snd_hda_add_verbs(codec, alc268_beep_init_verbs);
3115                 if (!query_amp_caps(codec, 0x1d, HDA_INPUT))
3116                         /* override the amp caps for beep generator */
3117                         snd_hda_override_amp_caps(codec, 0x1d, HDA_INPUT,
3118                                           (0x0c << AC_AMPCAP_OFFSET_SHIFT) |
3119                                           (0x0c << AC_AMPCAP_NUM_STEPS_SHIFT) |
3120                                           (0x07 << AC_AMPCAP_STEP_SIZE_SHIFT) |
3121                                           (0 << AC_AMPCAP_MUTE_SHIFT));
3122         }
3123
3124         snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE);
3125
3126         return 0;
3127
3128  error:
3129         alc_free(codec);
3130         return err;
3131 }
3132
3133 /*
3134  * ALC269
3135  */
3136
3137 static const struct hda_pcm_stream alc269_44k_pcm_analog_playback = {
3138         .rates = SNDRV_PCM_RATE_44100, /* fixed rate */
3139 };
3140
3141 static const struct hda_pcm_stream alc269_44k_pcm_analog_capture = {
3142         .rates = SNDRV_PCM_RATE_44100, /* fixed rate */
3143 };
3144
3145 /* different alc269-variants */
3146 enum {
3147         ALC269_TYPE_ALC269VA,
3148         ALC269_TYPE_ALC269VB,
3149         ALC269_TYPE_ALC269VC,
3150         ALC269_TYPE_ALC269VD,
3151         ALC269_TYPE_ALC280,
3152         ALC269_TYPE_ALC282,
3153         ALC269_TYPE_ALC283,
3154         ALC269_TYPE_ALC284,
3155         ALC269_TYPE_ALC293,
3156         ALC269_TYPE_ALC286,
3157         ALC269_TYPE_ALC298,
3158         ALC269_TYPE_ALC255,
3159         ALC269_TYPE_ALC256,
3160         ALC269_TYPE_ALC257,
3161         ALC269_TYPE_ALC215,
3162         ALC269_TYPE_ALC225,
3163         ALC269_TYPE_ALC245,
3164         ALC269_TYPE_ALC287,
3165         ALC269_TYPE_ALC294,
3166         ALC269_TYPE_ALC300,
3167         ALC269_TYPE_ALC623,
3168         ALC269_TYPE_ALC700,
3169 };
3170
3171 /*
3172  * BIOS auto configuration
3173  */
3174 static int alc269_parse_auto_config(struct hda_codec *codec)
3175 {
3176         static const hda_nid_t alc269_ignore[] = { 0x1d, 0 };
3177         static const hda_nid_t alc269_ssids[] = { 0, 0x1b, 0x14, 0x21 };
3178         static const hda_nid_t alc269va_ssids[] = { 0x15, 0x1b, 0x14, 0 };
3179         struct alc_spec *spec = codec->spec;
3180         const hda_nid_t *ssids;
3181
3182         switch (spec->codec_variant) {
3183         case ALC269_TYPE_ALC269VA:
3184         case ALC269_TYPE_ALC269VC:
3185         case ALC269_TYPE_ALC280:
3186         case ALC269_TYPE_ALC284:
3187         case ALC269_TYPE_ALC293:
3188                 ssids = alc269va_ssids;
3189                 break;
3190         case ALC269_TYPE_ALC269VB:
3191         case ALC269_TYPE_ALC269VD:
3192         case ALC269_TYPE_ALC282:
3193         case ALC269_TYPE_ALC283:
3194         case ALC269_TYPE_ALC286:
3195         case ALC269_TYPE_ALC298:
3196         case ALC269_TYPE_ALC255:
3197         case ALC269_TYPE_ALC256:
3198         case ALC269_TYPE_ALC257:
3199         case ALC269_TYPE_ALC215:
3200         case ALC269_TYPE_ALC225:
3201         case ALC269_TYPE_ALC245:
3202         case ALC269_TYPE_ALC287:
3203         case ALC269_TYPE_ALC294:
3204         case ALC269_TYPE_ALC300:
3205         case ALC269_TYPE_ALC623:
3206         case ALC269_TYPE_ALC700:
3207                 ssids = alc269_ssids;
3208                 break;
3209         default:
3210                 ssids = alc269_ssids;
3211                 break;
3212         }
3213
3214         return alc_parse_auto_config(codec, alc269_ignore, ssids);
3215 }
3216
3217 static const struct hda_jack_keymap alc_headset_btn_keymap[] = {
3218         { SND_JACK_BTN_0, KEY_PLAYPAUSE },
3219         { SND_JACK_BTN_1, KEY_VOICECOMMAND },
3220         { SND_JACK_BTN_2, KEY_VOLUMEUP },
3221         { SND_JACK_BTN_3, KEY_VOLUMEDOWN },
3222         {}
3223 };
3224
3225 static void alc_headset_btn_callback(struct hda_codec *codec,
3226                                      struct hda_jack_callback *jack)
3227 {
3228         int report = 0;
3229
3230         if (jack->unsol_res & (7 << 13))
3231                 report |= SND_JACK_BTN_0;
3232
3233         if (jack->unsol_res  & (1 << 16 | 3 << 8))
3234                 report |= SND_JACK_BTN_1;
3235
3236         /* Volume up key */
3237         if (jack->unsol_res & (7 << 23))
3238                 report |= SND_JACK_BTN_2;
3239
3240         /* Volume down key */
3241         if (jack->unsol_res & (7 << 10))
3242                 report |= SND_JACK_BTN_3;
3243
3244         snd_hda_jack_set_button_state(codec, jack->nid, report);
3245 }
3246
3247 static void alc_disable_headset_jack_key(struct hda_codec *codec)
3248 {
3249         struct alc_spec *spec = codec->spec;
3250
3251         if (!spec->has_hs_key)
3252                 return;
3253
3254         switch (codec->core.vendor_id) {
3255         case 0x10ec0215:
3256         case 0x10ec0225:
3257         case 0x10ec0285:
3258         case 0x10ec0287:
3259         case 0x10ec0295:
3260         case 0x10ec0289:
3261         case 0x10ec0299:
3262                 alc_write_coef_idx(codec, 0x48, 0x0);
3263                 alc_update_coef_idx(codec, 0x49, 0x0045, 0x0);
3264                 alc_update_coef_idx(codec, 0x44, 0x0045 << 8, 0x0);
3265                 break;
3266         case 0x10ec0230:
3267         case 0x10ec0236:
3268         case 0x10ec0256:
3269         case 0x10ec0257:
3270         case 0x19e58326:
3271                 alc_write_coef_idx(codec, 0x48, 0x0);
3272                 alc_update_coef_idx(codec, 0x49, 0x0045, 0x0);
3273                 break;
3274         }
3275 }
3276
3277 static void alc_enable_headset_jack_key(struct hda_codec *codec)
3278 {
3279         struct alc_spec *spec = codec->spec;
3280
3281         if (!spec->has_hs_key)
3282                 return;
3283
3284         switch (codec->core.vendor_id) {
3285         case 0x10ec0215:
3286         case 0x10ec0225:
3287         case 0x10ec0285:
3288         case 0x10ec0287:
3289         case 0x10ec0295:
3290         case 0x10ec0289:
3291         case 0x10ec0299:
3292                 alc_write_coef_idx(codec, 0x48, 0xd011);
3293                 alc_update_coef_idx(codec, 0x49, 0x007f, 0x0045);
3294                 alc_update_coef_idx(codec, 0x44, 0x007f << 8, 0x0045 << 8);
3295                 break;
3296         case 0x10ec0230:
3297         case 0x10ec0236:
3298         case 0x10ec0256:
3299         case 0x10ec0257:
3300         case 0x19e58326:
3301                 alc_write_coef_idx(codec, 0x48, 0xd011);
3302                 alc_update_coef_idx(codec, 0x49, 0x007f, 0x0045);
3303                 break;
3304         }
3305 }
3306
3307 static void alc_fixup_headset_jack(struct hda_codec *codec,
3308                                     const struct hda_fixup *fix, int action)
3309 {
3310         struct alc_spec *spec = codec->spec;
3311         hda_nid_t hp_pin;
3312
3313         switch (action) {
3314         case HDA_FIXUP_ACT_PRE_PROBE:
3315                 spec->has_hs_key = 1;
3316                 snd_hda_jack_detect_enable_callback(codec, 0x55,
3317                                                     alc_headset_btn_callback);
3318                 break;
3319         case HDA_FIXUP_ACT_BUILD:
3320                 hp_pin = alc_get_hp_pin(spec);
3321                 if (!hp_pin || snd_hda_jack_bind_keymap(codec, 0x55,
3322                                                         alc_headset_btn_keymap,
3323                                                         hp_pin))
3324                         snd_hda_jack_add_kctl(codec, 0x55, "Headset Jack",
3325                                               false, SND_JACK_HEADSET,
3326                                               alc_headset_btn_keymap);
3327
3328                 alc_enable_headset_jack_key(codec);
3329                 break;
3330         }
3331 }
3332
3333 static void alc269vb_toggle_power_output(struct hda_codec *codec, int power_up)
3334 {
3335         alc_update_coef_idx(codec, 0x04, 1 << 11, power_up ? (1 << 11) : 0);
3336 }
3337
3338 static void alc269_shutup(struct hda_codec *codec)
3339 {
3340         struct alc_spec *spec = codec->spec;
3341
3342         if (spec->codec_variant == ALC269_TYPE_ALC269VB)
3343                 alc269vb_toggle_power_output(codec, 0);
3344         if (spec->codec_variant == ALC269_TYPE_ALC269VB &&
3345                         (alc_get_coef0(codec) & 0x00ff) == 0x018) {
3346                 msleep(150);
3347         }
3348         alc_shutup_pins(codec);
3349 }
3350
3351 static const struct coef_fw alc282_coefs[] = {
3352         WRITE_COEF(0x03, 0x0002), /* Power Down Control */
3353         UPDATE_COEF(0x05, 0xff3f, 0x0700), /* FIFO and filter clock */
3354         WRITE_COEF(0x07, 0x0200), /* DMIC control */
3355         UPDATE_COEF(0x06, 0x00f0, 0), /* Analog clock */
3356         UPDATE_COEF(0x08, 0xfffc, 0x0c2c), /* JD */
3357         WRITE_COEF(0x0a, 0xcccc), /* JD offset1 */
3358         WRITE_COEF(0x0b, 0xcccc), /* JD offset2 */
3359         WRITE_COEF(0x0e, 0x6e00), /* LDO1/2/3, DAC/ADC */
3360         UPDATE_COEF(0x0f, 0xf800, 0x1000), /* JD */
3361         UPDATE_COEF(0x10, 0xfc00, 0x0c00), /* Capless */
3362         WRITE_COEF(0x6f, 0x0), /* Class D test 4 */
3363         UPDATE_COEF(0x0c, 0xfe00, 0), /* IO power down directly */
3364         WRITE_COEF(0x34, 0xa0c0), /* ANC */
3365         UPDATE_COEF(0x16, 0x0008, 0), /* AGC MUX */
3366         UPDATE_COEF(0x1d, 0x00e0, 0), /* DAC simple content protection */
3367         UPDATE_COEF(0x1f, 0x00e0, 0), /* ADC simple content protection */
3368         WRITE_COEF(0x21, 0x8804), /* DAC ADC Zero Detection */
3369         WRITE_COEF(0x63, 0x2902), /* PLL */
3370         WRITE_COEF(0x68, 0xa080), /* capless control 2 */
3371         WRITE_COEF(0x69, 0x3400), /* capless control 3 */
3372         WRITE_COEF(0x6a, 0x2f3e), /* capless control 4 */
3373         WRITE_COEF(0x6b, 0x0), /* capless control 5 */
3374         UPDATE_COEF(0x6d, 0x0fff, 0x0900), /* class D test 2 */
3375         WRITE_COEF(0x6e, 0x110a), /* class D test 3 */
3376         UPDATE_COEF(0x70, 0x00f8, 0x00d8), /* class D test 5 */
3377         WRITE_COEF(0x71, 0x0014), /* class D test 6 */
3378         WRITE_COEF(0x72, 0xc2ba), /* classD OCP */
3379         UPDATE_COEF(0x77, 0x0f80, 0), /* classD pure DC test */
3380         WRITE_COEF(0x6c, 0xfc06), /* Class D amp control */
3381         {}
3382 };
3383
3384 static void alc282_restore_default_value(struct hda_codec *codec)
3385 {
3386         alc_process_coef_fw(codec, alc282_coefs);
3387 }
3388
3389 static void alc282_init(struct hda_codec *codec)
3390 {
3391         struct alc_spec *spec = codec->spec;
3392         hda_nid_t hp_pin = alc_get_hp_pin(spec);
3393         bool hp_pin_sense;
3394         int coef78;
3395
3396         alc282_restore_default_value(codec);
3397
3398         if (!hp_pin)
3399                 return;
3400         hp_pin_sense = snd_hda_jack_detect(codec, hp_pin);
3401         coef78 = alc_read_coef_idx(codec, 0x78);
3402
3403         /* Index 0x78 Direct Drive HP AMP LPM Control 1 */
3404         /* Headphone capless set to high power mode */
3405         alc_write_coef_idx(codec, 0x78, 0x9004);
3406
3407         if (hp_pin_sense)
3408                 msleep(2);
3409
3410         snd_hda_codec_write(codec, hp_pin, 0,
3411                             AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);
3412
3413         if (hp_pin_sense)
3414                 msleep(85);
3415
3416         snd_hda_codec_write(codec, hp_pin, 0,
3417                             AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT);
3418
3419         if (hp_pin_sense)
3420                 msleep(100);
3421
3422         /* Headphone capless set to normal mode */
3423         alc_write_coef_idx(codec, 0x78, coef78);
3424 }
3425
3426 static void alc282_shutup(struct hda_codec *codec)
3427 {
3428         struct alc_spec *spec = codec->spec;
3429         hda_nid_t hp_pin = alc_get_hp_pin(spec);
3430         bool hp_pin_sense;
3431         int coef78;
3432
3433         if (!hp_pin) {
3434                 alc269_shutup(codec);
3435                 return;
3436         }
3437
3438         hp_pin_sense = snd_hda_jack_detect(codec, hp_pin);
3439         coef78 = alc_read_coef_idx(codec, 0x78);
3440         alc_write_coef_idx(codec, 0x78, 0x9004);
3441
3442         if (hp_pin_sense)
3443                 msleep(2);
3444
3445         snd_hda_codec_write(codec, hp_pin, 0,
3446                             AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);
3447
3448         if (hp_pin_sense)
3449                 msleep(85);
3450
3451         if (!spec->no_shutup_pins)
3452                 snd_hda_codec_write(codec, hp_pin, 0,
3453                                     AC_VERB_SET_PIN_WIDGET_CONTROL, 0x0);
3454
3455         if (hp_pin_sense)
3456                 msleep(100);
3457
3458         alc_auto_setup_eapd(codec, false);
3459         alc_shutup_pins(codec);
3460         alc_write_coef_idx(codec, 0x78, coef78);
3461 }
3462
3463 static const struct coef_fw alc283_coefs[] = {
3464         WRITE_COEF(0x03, 0x0002), /* Power Down Control */
3465         UPDATE_COEF(0x05, 0xff3f, 0x0700), /* FIFO and filter clock */
3466         WRITE_COEF(0x07, 0x0200), /* DMIC control */
3467         UPDATE_COEF(0x06, 0x00f0, 0), /* Analog clock */
3468         UPDATE_COEF(0x08, 0xfffc, 0x0c2c), /* JD */
3469         WRITE_COEF(0x0a, 0xcccc), /* JD offset1 */
3470         WRITE_COEF(0x0b, 0xcccc), /* JD offset2 */
3471         WRITE_COEF(0x0e, 0x6fc0), /* LDO1/2/3, DAC/ADC */
3472         UPDATE_COEF(0x0f, 0xf800, 0x1000), /* JD */
3473         UPDATE_COEF(0x10, 0xfc00, 0x0c00), /* Capless */
3474         WRITE_COEF(0x3a, 0x0), /* Class D test 4 */
3475         UPDATE_COEF(0x0c, 0xfe00, 0x0), /* IO power down directly */
3476         WRITE_COEF(0x22, 0xa0c0), /* ANC */
3477         UPDATE_COEFEX(0x53, 0x01, 0x000f, 0x0008), /* AGC MUX */
3478         UPDATE_COEF(0x1d, 0x00e0, 0), /* DAC simple content protection */
3479         UPDATE_COEF(0x1f, 0x00e0, 0), /* ADC simple content protection */
3480         WRITE_COEF(0x21, 0x8804), /* DAC ADC Zero Detection */
3481         WRITE_COEF(0x2e, 0x2902), /* PLL */
3482         WRITE_COEF(0x33, 0xa080), /* capless control 2 */
3483         WRITE_COEF(0x34, 0x3400), /* capless control 3 */
3484         WRITE_COEF(0x35, 0x2f3e), /* capless control 4 */
3485         WRITE_COEF(0x36, 0x0), /* capless control 5 */
3486         UPDATE_COEF(0x38, 0x0fff, 0x0900), /* class D test 2 */
3487         WRITE_COEF(0x39, 0x110a), /* class D test 3 */
3488         UPDATE_COEF(0x3b, 0x00f8, 0x00d8), /* class D test 5 */
3489         WRITE_COEF(0x3c, 0x0014), /* class D test 6 */
3490         WRITE_COEF(0x3d, 0xc2ba), /* classD OCP */
3491         UPDATE_COEF(0x42, 0x0f80, 0x0), /* classD pure DC test */
3492         WRITE_COEF(0x49, 0x0), /* test mode */
3493         UPDATE_COEF(0x40, 0xf800, 0x9800), /* Class D DC enable */
3494         UPDATE_COEF(0x42, 0xf000, 0x2000), /* DC offset */
3495         WRITE_COEF(0x37, 0xfc06), /* Class D amp control */
3496         UPDATE_COEF(0x1b, 0x8000, 0), /* HP JD control */
3497         {}
3498 };
3499
3500 static void alc283_restore_default_value(struct hda_codec *codec)
3501 {
3502         alc_process_coef_fw(codec, alc283_coefs);
3503 }
3504
3505 static void alc283_init(struct hda_codec *codec)
3506 {
3507         struct alc_spec *spec = codec->spec;
3508         hda_nid_t hp_pin = alc_get_hp_pin(spec);
3509         bool hp_pin_sense;
3510
3511         alc283_restore_default_value(codec);
3512
3513         if (!hp_pin)
3514                 return;
3515
3516         msleep(30);
3517         hp_pin_sense = snd_hda_jack_detect(codec, hp_pin);
3518
3519         /* Index 0x43 Direct Drive HP AMP LPM Control 1 */
3520         /* Headphone capless set to high power mode */
3521         alc_write_coef_idx(codec, 0x43, 0x9004);
3522
3523         snd_hda_codec_write(codec, hp_pin, 0,
3524                             AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);
3525
3526         if (hp_pin_sense)
3527                 msleep(85);
3528
3529         snd_hda_codec_write(codec, hp_pin, 0,
3530                             AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT);
3531
3532         if (hp_pin_sense)
3533                 msleep(85);
3534         /* Index 0x46 Combo jack auto switch control 2 */
3535         /* 3k pull low control for Headset jack. */
3536         alc_update_coef_idx(codec, 0x46, 3 << 12, 0);
3537         /* Headphone capless set to normal mode */
3538         alc_write_coef_idx(codec, 0x43, 0x9614);
3539 }
3540
3541 static void alc283_shutup(struct hda_codec *codec)
3542 {
3543         struct alc_spec *spec = codec->spec;
3544         hda_nid_t hp_pin = alc_get_hp_pin(spec);
3545         bool hp_pin_sense;
3546
3547         if (!hp_pin) {
3548                 alc269_shutup(codec);
3549                 return;
3550         }
3551
3552         hp_pin_sense = snd_hda_jack_detect(codec, hp_pin);
3553
3554         alc_write_coef_idx(codec, 0x43, 0x9004);
3555
3556         /*depop hp during suspend*/
3557         alc_write_coef_idx(codec, 0x06, 0x2100);
3558
3559         snd_hda_codec_write(codec, hp_pin, 0,
3560                             AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);
3561
3562         if (hp_pin_sense)
3563                 msleep(100);
3564
3565         if (!spec->no_shutup_pins)
3566                 snd_hda_codec_write(codec, hp_pin, 0,
3567                                     AC_VERB_SET_PIN_WIDGET_CONTROL, 0x0);
3568
3569         alc_update_coef_idx(codec, 0x46, 0, 3 << 12);
3570
3571         if (hp_pin_sense)
3572                 msleep(100);
3573         alc_auto_setup_eapd(codec, false);
3574         alc_shutup_pins(codec);
3575         alc_write_coef_idx(codec, 0x43, 0x9614);
3576 }
3577
3578 static void alc256_init(struct hda_codec *codec)
3579 {
3580         struct alc_spec *spec = codec->spec;
3581         hda_nid_t hp_pin = alc_get_hp_pin(spec);
3582         bool hp_pin_sense;
3583
3584         if (spec->ultra_low_power) {
3585                 alc_update_coef_idx(codec, 0x03, 1<<1, 1<<1);
3586                 alc_update_coef_idx(codec, 0x08, 3<<2, 3<<2);
3587                 alc_update_coef_idx(codec, 0x08, 7<<4, 0);
3588                 alc_update_coef_idx(codec, 0x3b, 1<<15, 0);
3589                 alc_update_coef_idx(codec, 0x0e, 7<<6, 7<<6);
3590                 msleep(30);
3591         }
3592
3593         if (!hp_pin)
3594                 hp_pin = 0x21;
3595
3596         msleep(30);
3597
3598         hp_pin_sense = snd_hda_jack_detect(codec, hp_pin);
3599
3600         if (hp_pin_sense)
3601                 msleep(2);
3602
3603         alc_update_coefex_idx(codec, 0x57, 0x04, 0x0007, 0x1); /* Low power */
3604
3605         snd_hda_codec_write(codec, hp_pin, 0,
3606                             AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);
3607
3608         if (hp_pin_sense || spec->ultra_low_power)
3609                 msleep(85);
3610
3611         snd_hda_codec_write(codec, hp_pin, 0,
3612                             AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT);
3613
3614         if (hp_pin_sense || spec->ultra_low_power)
3615                 msleep(100);
3616
3617         alc_update_coef_idx(codec, 0x46, 3 << 12, 0);
3618         alc_update_coefex_idx(codec, 0x57, 0x04, 0x0007, 0x4); /* Hight power */
3619         alc_update_coefex_idx(codec, 0x53, 0x02, 0x8000, 1 << 15); /* Clear bit */
3620         alc_update_coefex_idx(codec, 0x53, 0x02, 0x8000, 0 << 15);
3621         /*
3622          * Expose headphone mic (or possibly Line In on some machines) instead
3623          * of PC Beep on 1Ah, and disable 1Ah loopback for all outputs. See
3624          * Documentation/sound/hd-audio/realtek-pc-beep.rst for details of
3625          * this register.
3626          */
3627         alc_write_coef_idx(codec, 0x36, 0x5757);
3628 }
3629
3630 static void alc256_shutup(struct hda_codec *codec)
3631 {
3632         struct alc_spec *spec = codec->spec;
3633         hda_nid_t hp_pin = alc_get_hp_pin(spec);
3634         bool hp_pin_sense;
3635
3636         if (!hp_pin)
3637                 hp_pin = 0x21;
3638
3639         alc_update_coefex_idx(codec, 0x57, 0x04, 0x0007, 0x1); /* Low power */
3640         hp_pin_sense = snd_hda_jack_detect(codec, hp_pin);
3641
3642         if (hp_pin_sense)
3643                 msleep(2);
3644
3645         snd_hda_codec_write(codec, hp_pin, 0,
3646                             AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);
3647
3648         if (hp_pin_sense || spec->ultra_low_power)
3649                 msleep(85);
3650
3651         /* 3k pull low control for Headset jack. */
3652         /* NOTE: call this before clearing the pin, otherwise codec stalls */
3653         /* If disable 3k pulldown control for alc257, the Mic detection will not work correctly
3654          * when booting with headset plugged. So skip setting it for the codec alc257
3655          */
3656         if (spec->en_3kpull_low)
3657                 alc_update_coef_idx(codec, 0x46, 0, 3 << 12);
3658
3659         if (!spec->no_shutup_pins)
3660                 snd_hda_codec_write(codec, hp_pin, 0,
3661                                     AC_VERB_SET_PIN_WIDGET_CONTROL, 0x0);
3662
3663         if (hp_pin_sense || spec->ultra_low_power)
3664                 msleep(100);
3665
3666         alc_auto_setup_eapd(codec, false);
3667         alc_shutup_pins(codec);
3668         if (spec->ultra_low_power) {
3669                 msleep(50);
3670                 alc_update_coef_idx(codec, 0x03, 1<<1, 0);
3671                 alc_update_coef_idx(codec, 0x08, 7<<4, 7<<4);
3672                 alc_update_coef_idx(codec, 0x08, 3<<2, 0);
3673                 alc_update_coef_idx(codec, 0x3b, 1<<15, 1<<15);
3674                 alc_update_coef_idx(codec, 0x0e, 7<<6, 0);
3675                 msleep(30);
3676         }
3677 }
3678
3679 static void alc285_hp_init(struct hda_codec *codec)
3680 {
3681         struct alc_spec *spec = codec->spec;
3682         hda_nid_t hp_pin = alc_get_hp_pin(spec);
3683         int i, val;
3684         int coef38, coef0d, coef36;
3685
3686         alc_write_coefex_idx(codec, 0x58, 0x00, 0x1888); /* write default value */
3687         alc_update_coef_idx(codec, 0x4a, 1<<15, 1<<15); /* Reset HP JD */
3688         coef38 = alc_read_coef_idx(codec, 0x38); /* Amp control */
3689         coef0d = alc_read_coef_idx(codec, 0x0d); /* Digital Misc control */
3690         coef36 = alc_read_coef_idx(codec, 0x36); /* Passthrough Control */
3691         alc_update_coef_idx(codec, 0x38, 1<<4, 0x0);
3692         alc_update_coef_idx(codec, 0x0d, 0x110, 0x0);
3693
3694         alc_update_coef_idx(codec, 0x67, 0xf000, 0x3000);
3695
3696         if (hp_pin)
3697                 snd_hda_codec_write(codec, hp_pin, 0,
3698                             AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);
3699
3700         msleep(130);
3701         alc_update_coef_idx(codec, 0x36, 1<<14, 1<<14);
3702         alc_update_coef_idx(codec, 0x36, 1<<13, 0x0);
3703
3704         if (hp_pin)
3705                 snd_hda_codec_write(codec, hp_pin, 0,
3706                             AC_VERB_SET_PIN_WIDGET_CONTROL, 0x0);
3707         msleep(10);
3708         alc_write_coef_idx(codec, 0x67, 0x0); /* Set HP depop to manual mode */
3709         alc_write_coefex_idx(codec, 0x58, 0x00, 0x7880);
3710         alc_write_coefex_idx(codec, 0x58, 0x0f, 0xf049);
3711         alc_update_coefex_idx(codec, 0x58, 0x03, 0x00f0, 0x00c0);
3712
3713         alc_write_coefex_idx(codec, 0x58, 0x00, 0xf888); /* HP depop procedure start */
3714         val = alc_read_coefex_idx(codec, 0x58, 0x00);
3715         for (i = 0; i < 20 && val & 0x8000; i++) {
3716                 msleep(50);
3717                 val = alc_read_coefex_idx(codec, 0x58, 0x00);
3718         } /* Wait for depop procedure finish  */
3719
3720         alc_write_coefex_idx(codec, 0x58, 0x00, val); /* write back the result */
3721         alc_update_coef_idx(codec, 0x38, 1<<4, coef38);
3722         alc_update_coef_idx(codec, 0x0d, 0x110, coef0d);
3723         alc_update_coef_idx(codec, 0x36, 3<<13, coef36);
3724
3725         msleep(50);
3726         alc_update_coef_idx(codec, 0x4a, 1<<15, 0);
3727 }
3728
3729 static void alc225_init(struct hda_codec *codec)
3730 {
3731         struct alc_spec *spec = codec->spec;
3732         hda_nid_t hp_pin = alc_get_hp_pin(spec);
3733         bool hp1_pin_sense, hp2_pin_sense;
3734
3735         if (spec->ultra_low_power) {
3736                 alc_update_coef_idx(codec, 0x08, 0x0f << 2, 3<<2);
3737                 alc_update_coef_idx(codec, 0x0e, 7<<6, 7<<6);
3738                 alc_update_coef_idx(codec, 0x33, 1<<11, 0);
3739                 msleep(30);
3740         }
3741
3742         if (spec->codec_variant != ALC269_TYPE_ALC287 &&
3743                 spec->codec_variant != ALC269_TYPE_ALC245)
3744                 /* required only at boot or S3 and S4 resume time */
3745                 if (!spec->done_hp_init ||
3746                         is_s3_resume(codec) ||
3747                         is_s4_resume(codec)) {
3748                         alc285_hp_init(codec);
3749                         spec->done_hp_init = true;
3750                 }
3751
3752         if (!hp_pin)
3753                 hp_pin = 0x21;
3754         msleep(30);
3755
3756         hp1_pin_sense = snd_hda_jack_detect(codec, hp_pin);
3757         hp2_pin_sense = snd_hda_jack_detect(codec, 0x16);
3758
3759         if (hp1_pin_sense || hp2_pin_sense)
3760                 msleep(2);
3761
3762         alc_update_coefex_idx(codec, 0x57, 0x04, 0x0007, 0x1); /* Low power */
3763
3764         if (hp1_pin_sense || spec->ultra_low_power)
3765                 snd_hda_codec_write(codec, hp_pin, 0,
3766                             AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);
3767         if (hp2_pin_sense)
3768                 snd_hda_codec_write(codec, 0x16, 0,
3769                             AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);
3770
3771         if (hp1_pin_sense || hp2_pin_sense || spec->ultra_low_power)
3772                 msleep(85);
3773
3774         if (hp1_pin_sense || spec->ultra_low_power)
3775                 snd_hda_codec_write(codec, hp_pin, 0,
3776                             AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT);
3777         if (hp2_pin_sense)
3778                 snd_hda_codec_write(codec, 0x16, 0,
3779                             AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT);
3780
3781         if (hp1_pin_sense || hp2_pin_sense || spec->ultra_low_power)
3782                 msleep(100);
3783
3784         alc_update_coef_idx(codec, 0x4a, 3 << 10, 0);
3785         alc_update_coefex_idx(codec, 0x57, 0x04, 0x0007, 0x4); /* Hight power */
3786 }
3787
3788 static void alc225_shutup(struct hda_codec *codec)
3789 {
3790         struct alc_spec *spec = codec->spec;
3791         hda_nid_t hp_pin = alc_get_hp_pin(spec);
3792         bool hp1_pin_sense, hp2_pin_sense;
3793
3794         if (!hp_pin)
3795                 hp_pin = 0x21;
3796
3797         alc_disable_headset_jack_key(codec);
3798         /* 3k pull low control for Headset jack. */
3799         alc_update_coef_idx(codec, 0x4a, 0, 3 << 10);
3800
3801         hp1_pin_sense = snd_hda_jack_detect(codec, hp_pin);
3802         hp2_pin_sense = snd_hda_jack_detect(codec, 0x16);
3803
3804         if (hp1_pin_sense || hp2_pin_sense)
3805                 msleep(2);
3806
3807         if (hp1_pin_sense || spec->ultra_low_power)
3808                 snd_hda_codec_write(codec, hp_pin, 0,
3809                             AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);
3810         if (hp2_pin_sense)
3811                 snd_hda_codec_write(codec, 0x16, 0,
3812                             AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);
3813
3814         if (hp1_pin_sense || hp2_pin_sense || spec->ultra_low_power)
3815                 msleep(85);
3816
3817         if (hp1_pin_sense || spec->ultra_low_power)
3818                 snd_hda_codec_write(codec, hp_pin, 0,
3819                             AC_VERB_SET_PIN_WIDGET_CONTROL, 0x0);
3820         if (hp2_pin_sense)
3821                 snd_hda_codec_write(codec, 0x16, 0,
3822                             AC_VERB_SET_PIN_WIDGET_CONTROL, 0x0);
3823
3824         if (hp1_pin_sense || hp2_pin_sense || spec->ultra_low_power)
3825                 msleep(100);
3826
3827         alc_auto_setup_eapd(codec, false);
3828         alc_shutup_pins(codec);
3829         if (spec->ultra_low_power) {
3830                 msleep(50);
3831                 alc_update_coef_idx(codec, 0x08, 0x0f << 2, 0x0c << 2);
3832                 alc_update_coef_idx(codec, 0x0e, 7<<6, 0);
3833                 alc_update_coef_idx(codec, 0x33, 1<<11, 1<<11);
3834                 alc_update_coef_idx(codec, 0x4a, 3<<4, 2<<4);
3835                 msleep(30);
3836         }
3837
3838         alc_update_coef_idx(codec, 0x4a, 3 << 10, 0);
3839         alc_enable_headset_jack_key(codec);
3840 }
3841
3842 static void alc_default_init(struct hda_codec *codec)
3843 {
3844         struct alc_spec *spec = codec->spec;
3845         hda_nid_t hp_pin = alc_get_hp_pin(spec);
3846         bool hp_pin_sense;
3847
3848         if (!hp_pin)
3849                 return;
3850
3851         msleep(30);
3852
3853         hp_pin_sense = snd_hda_jack_detect(codec, hp_pin);
3854
3855         if (hp_pin_sense)
3856                 msleep(2);
3857
3858         snd_hda_codec_write(codec, hp_pin, 0,
3859                             AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);
3860
3861         if (hp_pin_sense)
3862                 msleep(85);
3863
3864         snd_hda_codec_write(codec, hp_pin, 0,
3865                             AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT);
3866
3867         if (hp_pin_sense)
3868                 msleep(100);
3869 }
3870
3871 static void alc_default_shutup(struct hda_codec *codec)
3872 {
3873         struct alc_spec *spec = codec->spec;
3874         hda_nid_t hp_pin = alc_get_hp_pin(spec);
3875         bool hp_pin_sense;
3876
3877         if (!hp_pin) {
3878                 alc269_shutup(codec);
3879                 return;
3880         }
3881
3882         hp_pin_sense = snd_hda_jack_detect(codec, hp_pin);
3883
3884         if (hp_pin_sense)
3885                 msleep(2);
3886
3887         snd_hda_codec_write(codec, hp_pin, 0,
3888                             AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);
3889
3890         if (hp_pin_sense)
3891                 msleep(85);
3892
3893         if (!spec->no_shutup_pins)
3894                 snd_hda_codec_write(codec, hp_pin, 0,
3895                                     AC_VERB_SET_PIN_WIDGET_CONTROL, 0x0);
3896
3897         if (hp_pin_sense)
3898                 msleep(100);
3899
3900         alc_auto_setup_eapd(codec, false);
3901         alc_shutup_pins(codec);
3902 }
3903
3904 static void alc294_hp_init(struct hda_codec *codec)
3905 {
3906         struct alc_spec *spec = codec->spec;
3907         hda_nid_t hp_pin = alc_get_hp_pin(spec);
3908         int i, val;
3909
3910         if (!hp_pin)
3911                 return;
3912
3913         snd_hda_codec_write(codec, hp_pin, 0,
3914                             AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);
3915
3916         msleep(100);
3917
3918         if (!spec->no_shutup_pins)
3919                 snd_hda_codec_write(codec, hp_pin, 0,
3920                                     AC_VERB_SET_PIN_WIDGET_CONTROL, 0x0);
3921
3922         alc_update_coef_idx(codec, 0x6f, 0x000f, 0);/* Set HP depop to manual mode */
3923         alc_update_coefex_idx(codec, 0x58, 0x00, 0x8000, 0x8000); /* HP depop procedure start */
3924
3925         /* Wait for depop procedure finish  */
3926         val = alc_read_coefex_idx(codec, 0x58, 0x01);
3927         for (i = 0; i < 20 && val & 0x0080; i++) {
3928                 msleep(50);
3929                 val = alc_read_coefex_idx(codec, 0x58, 0x01);
3930         }
3931         /* Set HP depop to auto mode */
3932         alc_update_coef_idx(codec, 0x6f, 0x000f, 0x000b);
3933         msleep(50);
3934 }
3935
3936 static void alc294_init(struct hda_codec *codec)
3937 {
3938         struct alc_spec *spec = codec->spec;
3939
3940         /* required only at boot or S4 resume time */
3941         if (!spec->done_hp_init ||
3942             codec->core.dev.power.power_state.event == PM_EVENT_RESTORE) {
3943                 alc294_hp_init(codec);
3944                 spec->done_hp_init = true;
3945         }
3946         alc_default_init(codec);
3947 }
3948
3949 static void alc5505_coef_set(struct hda_codec *codec, unsigned int index_reg,
3950                              unsigned int val)
3951 {
3952         snd_hda_codec_write(codec, 0x51, 0, AC_VERB_SET_COEF_INDEX, index_reg >> 1);
3953         snd_hda_codec_write(codec, 0x51, 0, AC_VERB_SET_PROC_COEF, val & 0xffff); /* LSB */
3954         snd_hda_codec_write(codec, 0x51, 0, AC_VERB_SET_PROC_COEF, val >> 16); /* MSB */
3955 }
3956
3957 static int alc5505_coef_get(struct hda_codec *codec, unsigned int index_reg)
3958 {
3959         unsigned int val;
3960
3961         snd_hda_codec_write(codec, 0x51, 0, AC_VERB_SET_COEF_INDEX, index_reg >> 1);
3962         val = snd_hda_codec_read(codec, 0x51, 0, AC_VERB_GET_PROC_COEF, 0)
3963                 & 0xffff;
3964         val |= snd_hda_codec_read(codec, 0x51, 0, AC_VERB_GET_PROC_COEF, 0)
3965                 << 16;
3966         return val;
3967 }
3968
3969 static void alc5505_dsp_halt(struct hda_codec *codec)
3970 {
3971         unsigned int val;
3972
3973         alc5505_coef_set(codec, 0x3000, 0x000c); /* DSP CPU stop */
3974         alc5505_coef_set(codec, 0x880c, 0x0008); /* DDR enter self refresh */
3975         alc5505_coef_set(codec, 0x61c0, 0x11110080); /* Clock control for PLL and CPU */
3976         alc5505_coef_set(codec, 0x6230, 0xfc0d4011); /* Disable Input OP */
3977         alc5505_coef_set(codec, 0x61b4, 0x040a2b03); /* Stop PLL2 */
3978         alc5505_coef_set(codec, 0x61b0, 0x00005b17); /* Stop PLL1 */
3979         alc5505_coef_set(codec, 0x61b8, 0x04133303); /* Stop PLL3 */
3980         val = alc5505_coef_get(codec, 0x6220);
3981         alc5505_coef_set(codec, 0x6220, (val | 0x3000)); /* switch Ringbuffer clock to DBUS clock */
3982 }
3983
3984 static void alc5505_dsp_back_from_halt(struct hda_codec *codec)
3985 {
3986         alc5505_coef_set(codec, 0x61b8, 0x04133302);
3987         alc5505_coef_set(codec, 0x61b0, 0x00005b16);
3988         alc5505_coef_set(codec, 0x61b4, 0x040a2b02);
3989         alc5505_coef_set(codec, 0x6230, 0xf80d4011);
3990         alc5505_coef_set(codec, 0x6220, 0x2002010f);
3991         alc5505_coef_set(codec, 0x880c, 0x00000004);
3992 }
3993
3994 static void alc5505_dsp_init(struct hda_codec *codec)
3995 {
3996         unsigned int val;
3997
3998         alc5505_dsp_halt(codec);
3999         alc5505_dsp_back_from_halt(codec);
4000         alc5505_coef_set(codec, 0x61b0, 0x5b14); /* PLL1 control */
4001         alc5505_coef_set(codec, 0x61b0, 0x5b16);
4002         alc5505_coef_set(codec, 0x61b4, 0x04132b00); /* PLL2 control */
4003         alc5505_coef_set(codec, 0x61b4, 0x04132b02);
4004         alc5505_coef_set(codec, 0x61b8, 0x041f3300); /* PLL3 control*/
4005         alc5505_coef_set(codec, 0x61b8, 0x041f3302);
4006         snd_hda_codec_write(codec, 0x51, 0, AC_VERB_SET_CODEC_RESET, 0); /* Function reset */
4007         alc5505_coef_set(codec, 0x61b8, 0x041b3302);
4008         alc5505_coef_set(codec, 0x61b8, 0x04173302);
4009         alc5505_coef_set(codec, 0x61b8, 0x04163302);
4010         alc5505_coef_set(codec, 0x8800, 0x348b328b); /* DRAM control */
4011         alc5505_coef_set(codec, 0x8808, 0x00020022); /* DRAM control */
4012         alc5505_coef_set(codec, 0x8818, 0x00000400); /* DRAM control */
4013
4014         val = alc5505_coef_get(codec, 0x6200) >> 16; /* Read revision ID */
4015         if (val <= 3)
4016                 alc5505_coef_set(codec, 0x6220, 0x2002010f); /* I/O PAD Configuration */
4017         else
4018                 alc5505_coef_set(codec, 0x6220, 0x6002018f);
4019
4020         alc5505_coef_set(codec, 0x61ac, 0x055525f0); /**/
4021         alc5505_coef_set(codec, 0x61c0, 0x12230080); /* Clock control */
4022         alc5505_coef_set(codec, 0x61b4, 0x040e2b02); /* PLL2 control */
4023         alc5505_coef_set(codec, 0x61bc, 0x010234f8); /* OSC Control */
4024         alc5505_coef_set(codec, 0x880c, 0x00000004); /* DRAM Function control */
4025         alc5505_coef_set(codec, 0x880c, 0x00000003);
4026         alc5505_coef_set(codec, 0x880c, 0x00000010);
4027
4028 #ifdef HALT_REALTEK_ALC5505
4029         alc5505_dsp_halt(codec);
4030 #endif
4031 }
4032
4033 #ifdef HALT_REALTEK_ALC5505
4034 #define alc5505_dsp_suspend(codec)      do { } while (0) /* NOP */
4035 #define alc5505_dsp_resume(codec)       do { } while (0) /* NOP */
4036 #else
4037 #define alc5505_dsp_suspend(codec)      alc5505_dsp_halt(codec)
4038 #define alc5505_dsp_resume(codec)       alc5505_dsp_back_from_halt(codec)
4039 #endif
4040
4041 #ifdef CONFIG_PM
4042 static int alc269_suspend(struct hda_codec *codec)
4043 {
4044         struct alc_spec *spec = codec->spec;
4045
4046         if (spec->has_alc5505_dsp)
4047                 alc5505_dsp_suspend(codec);
4048
4049         return alc_suspend(codec);
4050 }
4051
4052 static int alc269_resume(struct hda_codec *codec)
4053 {
4054         struct alc_spec *spec = codec->spec;
4055
4056         if (spec->codec_variant == ALC269_TYPE_ALC269VB)
4057                 alc269vb_toggle_power_output(codec, 0);
4058         if (spec->codec_variant == ALC269_TYPE_ALC269VB &&
4059                         (alc_get_coef0(codec) & 0x00ff) == 0x018) {
4060                 msleep(150);
4061         }
4062
4063         codec->patch_ops.init(codec);
4064
4065         if (spec->codec_variant == ALC269_TYPE_ALC269VB)
4066                 alc269vb_toggle_power_output(codec, 1);
4067         if (spec->codec_variant == ALC269_TYPE_ALC269VB &&
4068                         (alc_get_coef0(codec) & 0x00ff) == 0x017) {
4069                 msleep(200);
4070         }
4071
4072         snd_hda_regmap_sync(codec);
4073         hda_call_check_power_status(codec, 0x01);
4074
4075         /* on some machine, the BIOS will clear the codec gpio data when enter
4076          * suspend, and won't restore the data after resume, so we restore it
4077          * in the driver.
4078          */
4079         if (spec->gpio_data)
4080                 alc_write_gpio_data(codec);
4081
4082         if (spec->has_alc5505_dsp)
4083                 alc5505_dsp_resume(codec);
4084
4085         return 0;
4086 }
4087 #endif /* CONFIG_PM */
4088
4089 static void alc269_fixup_pincfg_no_hp_to_lineout(struct hda_codec *codec,
4090                                                  const struct hda_fixup *fix, int action)
4091 {
4092         struct alc_spec *spec = codec->spec;
4093
4094         if (action == HDA_FIXUP_ACT_PRE_PROBE)
4095                 spec->parse_flags = HDA_PINCFG_NO_HP_FIXUP;
4096 }
4097
4098 static void alc269_fixup_pincfg_U7x7_headset_mic(struct hda_codec *codec,
4099                                                  const struct hda_fixup *fix,
4100                                                  int action)
4101 {
4102         unsigned int cfg_headphone = snd_hda_codec_get_pincfg(codec, 0x21);
4103         unsigned int cfg_headset_mic = snd_hda_codec_get_pincfg(codec, 0x19);
4104
4105         if (cfg_headphone && cfg_headset_mic == 0x411111f0)
4106                 snd_hda_codec_set_pincfg(codec, 0x19,
4107                         (cfg_headphone & ~AC_DEFCFG_DEVICE) |
4108                         (AC_JACK_MIC_IN << AC_DEFCFG_DEVICE_SHIFT));
4109 }
4110
4111 static void alc269_fixup_hweq(struct hda_codec *codec,
4112                                const struct hda_fixup *fix, int action)
4113 {
4114         if (action == HDA_FIXUP_ACT_INIT)
4115                 alc_update_coef_idx(codec, 0x1e, 0, 0x80);
4116 }
4117
4118 static void alc269_fixup_headset_mic(struct hda_codec *codec,
4119                                        const struct hda_fixup *fix, int action)
4120 {
4121         struct alc_spec *spec = codec->spec;
4122
4123         if (action == HDA_FIXUP_ACT_PRE_PROBE)
4124                 spec->parse_flags |= HDA_PINCFG_HEADSET_MIC;
4125 }
4126
4127 static void alc271_fixup_dmic(struct hda_codec *codec,
4128                               const struct hda_fixup *fix, int action)
4129 {
4130         static const struct hda_verb verbs[] = {
4131                 {0x20, AC_VERB_SET_COEF_INDEX, 0x0d},
4132                 {0x20, AC_VERB_SET_PROC_COEF, 0x4000},
4133                 {}
4134         };
4135         unsigned int cfg;
4136
4137         if (strcmp(codec->core.chip_name, "ALC271X") &&
4138             strcmp(codec->core.chip_name, "ALC269VB"))
4139                 return;
4140         cfg = snd_hda_codec_get_pincfg(codec, 0x12);
4141         if (get_defcfg_connect(cfg) == AC_JACK_PORT_FIXED)
4142                 snd_hda_sequence_write(codec, verbs);
4143 }
4144
4145 /* Fix the speaker amp after resume, etc */
4146 static void alc269vb_fixup_aspire_e1_coef(struct hda_codec *codec,
4147                                           const struct hda_fixup *fix,
4148                                           int action)
4149 {
4150         if (action == HDA_FIXUP_ACT_INIT)
4151                 alc_update_coef_idx(codec, 0x0d, 0x6000, 0x6000);
4152 }
4153
4154 static void alc269_fixup_pcm_44k(struct hda_codec *codec,
4155                                  const struct hda_fixup *fix, int action)
4156 {
4157         struct alc_spec *spec = codec->spec;
4158
4159         if (action != HDA_FIXUP_ACT_PROBE)
4160                 return;
4161
4162         /* Due to a hardware problem on Lenovo Ideadpad, we need to
4163          * fix the sample rate of analog I/O to 44.1kHz
4164          */
4165         spec->gen.stream_analog_playback = &alc269_44k_pcm_analog_playback;
4166         spec->gen.stream_analog_capture = &alc269_44k_pcm_analog_capture;
4167 }
4168
4169 static void alc269_fixup_stereo_dmic(struct hda_codec *codec,
4170                                      const struct hda_fixup *fix, int action)
4171 {
4172         /* The digital-mic unit sends PDM (differential signal) instead of
4173          * the standard PCM, thus you can't record a valid mono stream as is.
4174          * Below is a workaround specific to ALC269 to control the dmic
4175          * signal source as mono.
4176          */
4177         if (action == HDA_FIXUP_ACT_INIT)
4178                 alc_update_coef_idx(codec, 0x07, 0, 0x80);
4179 }
4180
4181 static void alc269_quanta_automute(struct hda_codec *codec)
4182 {
4183         snd_hda_gen_update_outputs(codec);
4184
4185         alc_write_coef_idx(codec, 0x0c, 0x680);
4186         alc_write_coef_idx(codec, 0x0c, 0x480);
4187 }
4188
4189 static void alc269_fixup_quanta_mute(struct hda_codec *codec,
4190                                      const struct hda_fixup *fix, int action)
4191 {
4192         struct alc_spec *spec = codec->spec;
4193         if (action != HDA_FIXUP_ACT_PROBE)
4194                 return;
4195         spec->gen.automute_hook = alc269_quanta_automute;
4196 }
4197
4198 static void alc269_x101_hp_automute_hook(struct hda_codec *codec,
4199                                          struct hda_jack_callback *jack)
4200 {
4201         struct alc_spec *spec = codec->spec;
4202         int vref;
4203         msleep(200);
4204         snd_hda_gen_hp_automute(codec, jack);
4205
4206         vref = spec->gen.hp_jack_present ? PIN_VREF80 : 0;
4207         msleep(100);
4208         snd_hda_codec_write(codec, 0x18, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
4209                             vref);
4210         msleep(500);
4211         snd_hda_codec_write(codec, 0x18, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
4212                             vref);
4213 }
4214
4215 /*
4216  * Magic sequence to make Huawei Matebook X right speaker working (bko#197801)
4217  */
4218 struct hda_alc298_mbxinit {
4219         unsigned char value_0x23;
4220         unsigned char value_0x25;
4221 };
4222
4223 static void alc298_huawei_mbx_stereo_seq(struct hda_codec *codec,
4224                                          const struct hda_alc298_mbxinit *initval,
4225                                          bool first)
4226 {
4227         snd_hda_codec_write(codec, 0x06, 0, AC_VERB_SET_DIGI_CONVERT_3, 0x0);
4228         alc_write_coef_idx(codec, 0x26, 0xb000);
4229
4230         if (first)
4231                 snd_hda_codec_write(codec, 0x21, 0, AC_VERB_GET_PIN_SENSE, 0x0);
4232
4233         snd_hda_codec_write(codec, 0x6, 0, AC_VERB_SET_DIGI_CONVERT_3, 0x80);
4234         alc_write_coef_idx(codec, 0x26, 0xf000);
4235         alc_write_coef_idx(codec, 0x23, initval->value_0x23);
4236
4237         if (initval->value_0x23 != 0x1e)
4238                 alc_write_coef_idx(codec, 0x25, initval->value_0x25);
4239
4240         snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_COEF_INDEX, 0x26);
4241         snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_PROC_COEF, 0xb010);
4242 }
4243
4244 static void alc298_fixup_huawei_mbx_stereo(struct hda_codec *codec,
4245                                            const struct hda_fixup *fix,
4246                                            int action)
4247 {
4248         /* Initialization magic */
4249         static const struct hda_alc298_mbxinit dac_init[] = {
4250                 {0x0c, 0x00}, {0x0d, 0x00}, {0x0e, 0x00}, {0x0f, 0x00},
4251                 {0x10, 0x00}, {0x1a, 0x40}, {0x1b, 0x82}, {0x1c, 0x00},
4252                 {0x1d, 0x00}, {0x1e, 0x00}, {0x1f, 0x00},
4253                 {0x20, 0xc2}, {0x21, 0xc8}, {0x22, 0x26}, {0x23, 0x24},
4254                 {0x27, 0xff}, {0x28, 0xff}, {0x29, 0xff}, {0x2a, 0x8f},
4255                 {0x2b, 0x02}, {0x2c, 0x48}, {0x2d, 0x34}, {0x2e, 0x00},
4256                 {0x2f, 0x00},
4257                 {0x30, 0x00}, {0x31, 0x00}, {0x32, 0x00}, {0x33, 0x00},
4258                 {0x34, 0x00}, {0x35, 0x01}, {0x36, 0x93}, {0x37, 0x0c},
4259                 {0x38, 0x00}, {0x39, 0x00}, {0x3a, 0xf8}, {0x38, 0x80},
4260                 {}
4261         };
4262         const struct hda_alc298_mbxinit *seq;
4263
4264         if (action != HDA_FIXUP_ACT_INIT)
4265                 return;
4266
4267         /* Start */
4268         snd_hda_codec_write(codec, 0x06, 0, AC_VERB_SET_DIGI_CONVERT_3, 0x00);
4269         snd_hda_codec_write(codec, 0x06, 0, AC_VERB_SET_DIGI_CONVERT_3, 0x80);
4270         alc_write_coef_idx(codec, 0x26, 0xf000);
4271         alc_write_coef_idx(codec, 0x22, 0x31);
4272         alc_write_coef_idx(codec, 0x23, 0x0b);
4273         alc_write_coef_idx(codec, 0x25, 0x00);
4274         snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_COEF_INDEX, 0x26);
4275         snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_PROC_COEF, 0xb010);
4276
4277         for (seq = dac_init; seq->value_0x23; seq++)
4278                 alc298_huawei_mbx_stereo_seq(codec, seq, seq == dac_init);
4279 }
4280
4281 static void alc269_fixup_x101_headset_mic(struct hda_codec *codec,
4282                                      const struct hda_fixup *fix, int action)
4283 {
4284         struct alc_spec *spec = codec->spec;
4285         if (action == HDA_FIXUP_ACT_PRE_PROBE) {
4286                 spec->parse_flags |= HDA_PINCFG_HEADSET_MIC;
4287                 spec->gen.hp_automute_hook = alc269_x101_hp_automute_hook;
4288         }
4289 }
4290
4291 static void alc_update_vref_led(struct hda_codec *codec, hda_nid_t pin,
4292                                 bool polarity, bool on)
4293 {
4294         unsigned int pinval;
4295
4296         if (!pin)
4297                 return;
4298         if (polarity)
4299                 on = !on;
4300         pinval = snd_hda_codec_get_pin_target(codec, pin);
4301         pinval &= ~AC_PINCTL_VREFEN;
4302         pinval |= on ? AC_PINCTL_VREF_80 : AC_PINCTL_VREF_HIZ;
4303         /* temporarily power up/down for setting VREF */
4304         snd_hda_power_up_pm(codec);
4305         snd_hda_set_pin_ctl_cache(codec, pin, pinval);
4306         snd_hda_power_down_pm(codec);
4307 }
4308
4309 /* update mute-LED according to the speaker mute state via mic VREF pin */
4310 static int vref_mute_led_set(struct led_classdev *led_cdev,
4311                              enum led_brightness brightness)
4312 {
4313         struct hda_codec *codec = dev_to_hda_codec(led_cdev->dev->parent);
4314         struct alc_spec *spec = codec->spec;
4315
4316         alc_update_vref_led(codec, spec->mute_led_nid,
4317                             spec->mute_led_polarity, brightness);
4318         return 0;
4319 }
4320
4321 /* Make sure the led works even in runtime suspend */
4322 static unsigned int led_power_filter(struct hda_codec *codec,
4323                                                   hda_nid_t nid,
4324                                                   unsigned int power_state)
4325 {
4326         struct alc_spec *spec = codec->spec;
4327
4328         if (power_state != AC_PWRST_D3 || nid == 0 ||
4329             (nid != spec->mute_led_nid && nid != spec->cap_mute_led_nid))
4330                 return power_state;
4331
4332         /* Set pin ctl again, it might have just been set to 0 */
4333         snd_hda_set_pin_ctl(codec, nid,
4334                             snd_hda_codec_get_pin_target(codec, nid));
4335
4336         return snd_hda_gen_path_power_filter(codec, nid, power_state);
4337 }
4338
4339 static void alc269_fixup_hp_mute_led(struct hda_codec *codec,
4340                                      const struct hda_fixup *fix, int action)
4341 {
4342         struct alc_spec *spec = codec->spec;
4343         const struct dmi_device *dev = NULL;
4344
4345         if (action != HDA_FIXUP_ACT_PRE_PROBE)
4346                 return;
4347
4348         while ((dev = dmi_find_device(DMI_DEV_TYPE_OEM_STRING, NULL, dev))) {
4349                 int pol, pin;
4350                 if (sscanf(dev->name, "HP_Mute_LED_%d_%x", &pol, &pin) != 2)
4351                         continue;
4352                 if (pin < 0x0a || pin >= 0x10)
4353                         break;
4354                 spec->mute_led_polarity = pol;
4355                 spec->mute_led_nid = pin - 0x0a + 0x18;
4356                 snd_hda_gen_add_mute_led_cdev(codec, vref_mute_led_set);
4357                 codec->power_filter = led_power_filter;
4358                 codec_dbg(codec,
4359                           "Detected mute LED for %x:%d\n", spec->mute_led_nid,
4360                            spec->mute_led_polarity);
4361                 break;
4362         }
4363 }
4364
4365 static void alc269_fixup_hp_mute_led_micx(struct hda_codec *codec,
4366                                           const struct hda_fixup *fix,
4367                                           int action, hda_nid_t pin)
4368 {
4369         struct alc_spec *spec = codec->spec;
4370
4371         if (action == HDA_FIXUP_ACT_PRE_PROBE) {
4372                 spec->mute_led_polarity = 0;
4373                 spec->mute_led_nid = pin;
4374                 snd_hda_gen_add_mute_led_cdev(codec, vref_mute_led_set);
4375                 codec->power_filter = led_power_filter;
4376         }
4377 }
4378
4379 static void alc269_fixup_hp_mute_led_mic1(struct hda_codec *codec,
4380                                 const struct hda_fixup *fix, int action)
4381 {
4382         alc269_fixup_hp_mute_led_micx(codec, fix, action, 0x18);
4383 }
4384
4385 static void alc269_fixup_hp_mute_led_mic2(struct hda_codec *codec,
4386                                 const struct hda_fixup *fix, int action)
4387 {
4388         alc269_fixup_hp_mute_led_micx(codec, fix, action, 0x19);
4389 }
4390
4391 static void alc269_fixup_hp_mute_led_mic3(struct hda_codec *codec,
4392                                 const struct hda_fixup *fix, int action)
4393 {
4394         alc269_fixup_hp_mute_led_micx(codec, fix, action, 0x1b);
4395 }
4396
4397 /* update LED status via GPIO */
4398 static void alc_update_gpio_led(struct hda_codec *codec, unsigned int mask,
4399                                 int polarity, bool enabled)
4400 {
4401         if (polarity)
4402                 enabled = !enabled;
4403         alc_update_gpio_data(codec, mask, !enabled); /* muted -> LED on */
4404 }
4405
4406 /* turn on/off mute LED via GPIO per vmaster hook */
4407 static int gpio_mute_led_set(struct led_classdev *led_cdev,
4408                              enum led_brightness brightness)
4409 {
4410         struct hda_codec *codec = dev_to_hda_codec(led_cdev->dev->parent);
4411         struct alc_spec *spec = codec->spec;
4412
4413         alc_update_gpio_led(codec, spec->gpio_mute_led_mask,
4414                             spec->mute_led_polarity, !brightness);
4415         return 0;
4416 }
4417
4418 /* turn on/off mic-mute LED via GPIO per capture hook */
4419 static int micmute_led_set(struct led_classdev *led_cdev,
4420                            enum led_brightness brightness)
4421 {
4422         struct hda_codec *codec = dev_to_hda_codec(led_cdev->dev->parent);
4423         struct alc_spec *spec = codec->spec;
4424
4425         alc_update_gpio_led(codec, spec->gpio_mic_led_mask,
4426                             spec->micmute_led_polarity, !brightness);
4427         return 0;
4428 }
4429
4430 /* setup mute and mic-mute GPIO bits, add hooks appropriately */
4431 static void alc_fixup_hp_gpio_led(struct hda_codec *codec,
4432                                   int action,
4433                                   unsigned int mute_mask,
4434                                   unsigned int micmute_mask)
4435 {
4436         struct alc_spec *spec = codec->spec;
4437
4438         alc_fixup_gpio(codec, action, mute_mask | micmute_mask);
4439
4440         if (action != HDA_FIXUP_ACT_PRE_PROBE)
4441                 return;
4442         if (mute_mask) {
4443                 spec->gpio_mute_led_mask = mute_mask;
4444                 snd_hda_gen_add_mute_led_cdev(codec, gpio_mute_led_set);
4445         }
4446         if (micmute_mask) {
4447                 spec->gpio_mic_led_mask = micmute_mask;
4448                 snd_hda_gen_add_micmute_led_cdev(codec, micmute_led_set);
4449         }
4450 }
4451
4452 static void alc236_fixup_hp_gpio_led(struct hda_codec *codec,
4453                                 const struct hda_fixup *fix, int action)
4454 {
4455         alc_fixup_hp_gpio_led(codec, action, 0x02, 0x01);
4456 }
4457
4458 static void alc269_fixup_hp_gpio_led(struct hda_codec *codec,
4459                                 const struct hda_fixup *fix, int action)
4460 {
4461         alc_fixup_hp_gpio_led(codec, action, 0x08, 0x10);
4462 }
4463
4464 static void alc285_fixup_hp_gpio_led(struct hda_codec *codec,
4465                                 const struct hda_fixup *fix, int action)
4466 {
4467         alc_fixup_hp_gpio_led(codec, action, 0x04, 0x01);
4468 }
4469
4470 static void alc286_fixup_hp_gpio_led(struct hda_codec *codec,
4471                                 const struct hda_fixup *fix, int action)
4472 {
4473         alc_fixup_hp_gpio_led(codec, action, 0x02, 0x20);
4474 }
4475
4476 static void alc287_fixup_hp_gpio_led(struct hda_codec *codec,
4477                                 const struct hda_fixup *fix, int action)
4478 {
4479         alc_fixup_hp_gpio_led(codec, action, 0x10, 0);
4480 }
4481
4482 static void alc245_fixup_hp_gpio_led(struct hda_codec *codec,
4483                                 const struct hda_fixup *fix, int action)
4484 {
4485         struct alc_spec *spec = codec->spec;
4486
4487         if (action == HDA_FIXUP_ACT_PRE_PROBE)
4488                 spec->micmute_led_polarity = 1;
4489         alc_fixup_hp_gpio_led(codec, action, 0, 0x04);
4490 }
4491
4492 /* turn on/off mic-mute LED per capture hook via VREF change */
4493 static int vref_micmute_led_set(struct led_classdev *led_cdev,
4494                                 enum led_brightness brightness)
4495 {
4496         struct hda_codec *codec = dev_to_hda_codec(led_cdev->dev->parent);
4497         struct alc_spec *spec = codec->spec;
4498
4499         alc_update_vref_led(codec, spec->cap_mute_led_nid,
4500                             spec->micmute_led_polarity, brightness);
4501         return 0;
4502 }
4503
4504 static void alc269_fixup_hp_gpio_mic1_led(struct hda_codec *codec,
4505                                 const struct hda_fixup *fix, int action)
4506 {
4507         struct alc_spec *spec = codec->spec;
4508
4509         alc_fixup_hp_gpio_led(codec, action, 0x08, 0);
4510         if (action == HDA_FIXUP_ACT_PRE_PROBE) {
4511                 /* Like hp_gpio_mic1_led, but also needs GPIO4 low to
4512                  * enable headphone amp
4513                  */
4514                 spec->gpio_mask |= 0x10;
4515                 spec->gpio_dir |= 0x10;
4516                 spec->cap_mute_led_nid = 0x18;
4517                 snd_hda_gen_add_micmute_led_cdev(codec, vref_micmute_led_set);
4518                 codec->power_filter = led_power_filter;
4519         }
4520 }
4521
4522 static void alc280_fixup_hp_gpio4(struct hda_codec *codec,
4523                                    const struct hda_fixup *fix, int action)
4524 {
4525         struct alc_spec *spec = codec->spec;
4526
4527         alc_fixup_hp_gpio_led(codec, action, 0x08, 0);
4528         if (action == HDA_FIXUP_ACT_PRE_PROBE) {
4529                 spec->cap_mute_led_nid = 0x18;
4530                 snd_hda_gen_add_micmute_led_cdev(codec, vref_micmute_led_set);
4531                 codec->power_filter = led_power_filter;
4532         }
4533 }
4534
4535 /* HP Spectre x360 14 model needs a unique workaround for enabling the amp;
4536  * it needs to toggle the GPIO0 once on and off at each time (bko#210633)
4537  */
4538 static void alc245_fixup_hp_x360_amp(struct hda_codec *codec,
4539                                      const struct hda_fixup *fix, int action)
4540 {
4541         struct alc_spec *spec = codec->spec;
4542
4543         switch (action) {
4544         case HDA_FIXUP_ACT_PRE_PROBE:
4545                 spec->gpio_mask |= 0x01;
4546                 spec->gpio_dir |= 0x01;
4547                 break;
4548         case HDA_FIXUP_ACT_INIT:
4549                 /* need to toggle GPIO to enable the amp */
4550                 alc_update_gpio_data(codec, 0x01, true);
4551                 msleep(100);
4552                 alc_update_gpio_data(codec, 0x01, false);
4553                 break;
4554         }
4555 }
4556
4557 /* toggle GPIO2 at each time stream is started; we use PREPARE state instead */
4558 static void alc274_hp_envy_pcm_hook(struct hda_pcm_stream *hinfo,
4559                                     struct hda_codec *codec,
4560                                     struct snd_pcm_substream *substream,
4561                                     int action)
4562 {
4563         switch (action) {
4564         case HDA_GEN_PCM_ACT_PREPARE:
4565                 alc_update_gpio_data(codec, 0x04, true);
4566                 break;
4567         case HDA_GEN_PCM_ACT_CLEANUP:
4568                 alc_update_gpio_data(codec, 0x04, false);
4569                 break;
4570         }
4571 }
4572
4573 static void alc274_fixup_hp_envy_gpio(struct hda_codec *codec,
4574                                       const struct hda_fixup *fix,
4575                                       int action)
4576 {
4577         struct alc_spec *spec = codec->spec;
4578
4579         if (action == HDA_FIXUP_ACT_PROBE) {
4580                 spec->gpio_mask |= 0x04;
4581                 spec->gpio_dir |= 0x04;
4582                 spec->gen.pcm_playback_hook = alc274_hp_envy_pcm_hook;
4583         }
4584 }
4585
4586 static void alc_update_coef_led(struct hda_codec *codec,
4587                                 struct alc_coef_led *led,
4588                                 bool polarity, bool on)
4589 {
4590         if (polarity)
4591                 on = !on;
4592         /* temporarily power up/down for setting COEF bit */
4593         alc_update_coef_idx(codec, led->idx, led->mask,
4594                             on ? led->on : led->off);
4595 }
4596
4597 /* update mute-LED according to the speaker mute state via COEF bit */
4598 static int coef_mute_led_set(struct led_classdev *led_cdev,
4599                              enum led_brightness brightness)
4600 {
4601         struct hda_codec *codec = dev_to_hda_codec(led_cdev->dev->parent);
4602         struct alc_spec *spec = codec->spec;
4603
4604         alc_update_coef_led(codec, &spec->mute_led_coef,
4605                             spec->mute_led_polarity, brightness);
4606         return 0;
4607 }
4608
4609 static void alc285_fixup_hp_mute_led_coefbit(struct hda_codec *codec,
4610                                           const struct hda_fixup *fix,
4611                                           int action)
4612 {
4613         struct alc_spec *spec = codec->spec;
4614
4615         if (action == HDA_FIXUP_ACT_PRE_PROBE) {
4616                 spec->mute_led_polarity = 0;
4617                 spec->mute_led_coef.idx = 0x0b;
4618                 spec->mute_led_coef.mask = 1 << 3;
4619                 spec->mute_led_coef.on = 1 << 3;
4620                 spec->mute_led_coef.off = 0;
4621                 snd_hda_gen_add_mute_led_cdev(codec, coef_mute_led_set);
4622         }
4623 }
4624
4625 static void alc236_fixup_hp_mute_led_coefbit(struct hda_codec *codec,
4626                                           const struct hda_fixup *fix,
4627                                           int action)
4628 {
4629         struct alc_spec *spec = codec->spec;
4630
4631         if (action == HDA_FIXUP_ACT_PRE_PROBE) {
4632                 spec->mute_led_polarity = 0;
4633                 spec->mute_led_coef.idx = 0x34;
4634                 spec->mute_led_coef.mask = 1 << 5;
4635                 spec->mute_led_coef.on = 0;
4636                 spec->mute_led_coef.off = 1 << 5;
4637                 snd_hda_gen_add_mute_led_cdev(codec, coef_mute_led_set);
4638         }
4639 }
4640
4641 static void alc236_fixup_hp_mute_led_coefbit2(struct hda_codec *codec,
4642                                           const struct hda_fixup *fix, int action)
4643 {
4644         struct alc_spec *spec = codec->spec;
4645
4646         if (action == HDA_FIXUP_ACT_PRE_PROBE) {
4647                 spec->mute_led_polarity = 0;
4648                 spec->mute_led_coef.idx = 0x07;
4649                 spec->mute_led_coef.mask = 1;
4650                 spec->mute_led_coef.on = 1;
4651                 spec->mute_led_coef.off = 0;
4652                 snd_hda_gen_add_mute_led_cdev(codec, coef_mute_led_set);
4653         }
4654 }
4655
4656 static void alc245_fixup_hp_mute_led_coefbit(struct hda_codec *codec,
4657                                           const struct hda_fixup *fix,
4658                                           int action)
4659 {
4660         struct alc_spec *spec = codec->spec;
4661
4662         if (action == HDA_FIXUP_ACT_PRE_PROBE) {
4663                 spec->mute_led_polarity = 0;
4664                 spec->mute_led_coef.idx = 0x0b;
4665                 spec->mute_led_coef.mask = 3 << 2;
4666                 spec->mute_led_coef.on = 2 << 2;
4667                 spec->mute_led_coef.off = 1 << 2;
4668                 snd_hda_gen_add_mute_led_cdev(codec, coef_mute_led_set);
4669         }
4670 }
4671
4672 /* turn on/off mic-mute LED per capture hook by coef bit */
4673 static int coef_micmute_led_set(struct led_classdev *led_cdev,
4674                                 enum led_brightness brightness)
4675 {
4676         struct hda_codec *codec = dev_to_hda_codec(led_cdev->dev->parent);
4677         struct alc_spec *spec = codec->spec;
4678
4679         alc_update_coef_led(codec, &spec->mic_led_coef,
4680                             spec->micmute_led_polarity, brightness);
4681         return 0;
4682 }
4683
4684 static void alc285_fixup_hp_coef_micmute_led(struct hda_codec *codec,
4685                                 const struct hda_fixup *fix, int action)
4686 {
4687         struct alc_spec *spec = codec->spec;
4688
4689         if (action == HDA_FIXUP_ACT_PRE_PROBE) {
4690                 spec->mic_led_coef.idx = 0x19;
4691                 spec->mic_led_coef.mask = 1 << 13;
4692                 spec->mic_led_coef.on = 1 << 13;
4693                 spec->mic_led_coef.off = 0;
4694                 snd_hda_gen_add_micmute_led_cdev(codec, coef_micmute_led_set);
4695         }
4696 }
4697
4698 static void alc285_fixup_hp_gpio_micmute_led(struct hda_codec *codec,
4699                                 const struct hda_fixup *fix, int action)
4700 {
4701         struct alc_spec *spec = codec->spec;
4702
4703         if (action == HDA_FIXUP_ACT_PRE_PROBE)
4704                 spec->micmute_led_polarity = 1;
4705         alc_fixup_hp_gpio_led(codec, action, 0, 0x04);
4706 }
4707
4708 static void alc236_fixup_hp_coef_micmute_led(struct hda_codec *codec,
4709                                 const struct hda_fixup *fix, int action)
4710 {
4711         struct alc_spec *spec = codec->spec;
4712
4713         if (action == HDA_FIXUP_ACT_PRE_PROBE) {
4714                 spec->mic_led_coef.idx = 0x35;
4715                 spec->mic_led_coef.mask = 3 << 2;
4716                 spec->mic_led_coef.on = 2 << 2;
4717                 spec->mic_led_coef.off = 1 << 2;
4718                 snd_hda_gen_add_micmute_led_cdev(codec, coef_micmute_led_set);
4719         }
4720 }
4721
4722 static void alc285_fixup_hp_mute_led(struct hda_codec *codec,
4723                                 const struct hda_fixup *fix, int action)
4724 {
4725         alc285_fixup_hp_mute_led_coefbit(codec, fix, action);
4726         alc285_fixup_hp_coef_micmute_led(codec, fix, action);
4727 }
4728
4729 static void alc285_fixup_hp_spectre_x360_mute_led(struct hda_codec *codec,
4730                                 const struct hda_fixup *fix, int action)
4731 {
4732         alc285_fixup_hp_mute_led_coefbit(codec, fix, action);
4733         alc285_fixup_hp_gpio_micmute_led(codec, fix, action);
4734 }
4735
4736 static void alc236_fixup_hp_mute_led(struct hda_codec *codec,
4737                                 const struct hda_fixup *fix, int action)
4738 {
4739         alc236_fixup_hp_mute_led_coefbit(codec, fix, action);
4740         alc236_fixup_hp_coef_micmute_led(codec, fix, action);
4741 }
4742
4743 static void alc236_fixup_hp_micmute_led_vref(struct hda_codec *codec,
4744                                 const struct hda_fixup *fix, int action)
4745 {
4746         struct alc_spec *spec = codec->spec;
4747
4748         if (action == HDA_FIXUP_ACT_PRE_PROBE) {
4749                 spec->cap_mute_led_nid = 0x1a;
4750                 snd_hda_gen_add_micmute_led_cdev(codec, vref_micmute_led_set);
4751                 codec->power_filter = led_power_filter;
4752         }
4753 }
4754
4755 static void alc236_fixup_hp_mute_led_micmute_vref(struct hda_codec *codec,
4756                                 const struct hda_fixup *fix, int action)
4757 {
4758         alc236_fixup_hp_mute_led_coefbit(codec, fix, action);
4759         alc236_fixup_hp_micmute_led_vref(codec, fix, action);
4760 }
4761
4762 static inline void alc298_samsung_write_coef_pack(struct hda_codec *codec,
4763                                                   const unsigned short coefs[2])
4764 {
4765         alc_write_coef_idx(codec, 0x23, coefs[0]);
4766         alc_write_coef_idx(codec, 0x25, coefs[1]);
4767         alc_write_coef_idx(codec, 0x26, 0xb011);
4768 }
4769
4770 struct alc298_samsung_amp_desc {
4771         unsigned char nid;
4772         unsigned short init_seq[2][2];
4773 };
4774
4775 static void alc298_fixup_samsung_amp(struct hda_codec *codec,
4776                                      const struct hda_fixup *fix, int action)
4777 {
4778         int i, j;
4779         static const unsigned short init_seq[][2] = {
4780                 { 0x19, 0x00 }, { 0x20, 0xc0 }, { 0x22, 0x44 }, { 0x23, 0x08 },
4781                 { 0x24, 0x85 }, { 0x25, 0x41 }, { 0x35, 0x40 }, { 0x36, 0x01 },
4782                 { 0x38, 0x81 }, { 0x3a, 0x03 }, { 0x3b, 0x81 }, { 0x40, 0x3e },
4783                 { 0x41, 0x07 }, { 0x400, 0x1 }
4784         };
4785         static const struct alc298_samsung_amp_desc amps[] = {
4786                 { 0x3a, { { 0x18, 0x1 }, { 0x26, 0x0 } } },
4787                 { 0x39, { { 0x18, 0x2 }, { 0x26, 0x1 } } }
4788         };
4789
4790         if (action != HDA_FIXUP_ACT_INIT)
4791                 return;
4792
4793         for (i = 0; i < ARRAY_SIZE(amps); i++) {
4794                 alc_write_coef_idx(codec, 0x22, amps[i].nid);
4795
4796                 for (j = 0; j < ARRAY_SIZE(amps[i].init_seq); j++)
4797                         alc298_samsung_write_coef_pack(codec, amps[i].init_seq[j]);
4798
4799                 for (j = 0; j < ARRAY_SIZE(init_seq); j++)
4800                         alc298_samsung_write_coef_pack(codec, init_seq[j]);
4801         }
4802 }
4803
4804 #if IS_REACHABLE(CONFIG_INPUT)
4805 static void gpio2_mic_hotkey_event(struct hda_codec *codec,
4806                                    struct hda_jack_callback *event)
4807 {
4808         struct alc_spec *spec = codec->spec;
4809
4810         /* GPIO2 just toggles on a keypress/keyrelease cycle. Therefore
4811            send both key on and key off event for every interrupt. */
4812         input_report_key(spec->kb_dev, spec->alc_mute_keycode_map[ALC_KEY_MICMUTE_INDEX], 1);
4813         input_sync(spec->kb_dev);
4814         input_report_key(spec->kb_dev, spec->alc_mute_keycode_map[ALC_KEY_MICMUTE_INDEX], 0);
4815         input_sync(spec->kb_dev);
4816 }
4817
4818 static int alc_register_micmute_input_device(struct hda_codec *codec)
4819 {
4820         struct alc_spec *spec = codec->spec;
4821         int i;
4822
4823         spec->kb_dev = input_allocate_device();
4824         if (!spec->kb_dev) {
4825                 codec_err(codec, "Out of memory (input_allocate_device)\n");
4826                 return -ENOMEM;
4827         }
4828
4829         spec->alc_mute_keycode_map[ALC_KEY_MICMUTE_INDEX] = KEY_MICMUTE;
4830
4831         spec->kb_dev->name = "Microphone Mute Button";
4832         spec->kb_dev->evbit[0] = BIT_MASK(EV_KEY);
4833         spec->kb_dev->keycodesize = sizeof(spec->alc_mute_keycode_map[0]);
4834         spec->kb_dev->keycodemax = ARRAY_SIZE(spec->alc_mute_keycode_map);
4835         spec->kb_dev->keycode = spec->alc_mute_keycode_map;
4836         for (i = 0; i < ARRAY_SIZE(spec->alc_mute_keycode_map); i++)
4837                 set_bit(spec->alc_mute_keycode_map[i], spec->kb_dev->keybit);
4838
4839         if (input_register_device(spec->kb_dev)) {
4840                 codec_err(codec, "input_register_device failed\n");
4841                 input_free_device(spec->kb_dev);
4842                 spec->kb_dev = NULL;
4843                 return -ENOMEM;
4844         }
4845
4846         return 0;
4847 }
4848
4849 /* GPIO1 = set according to SKU external amp
4850  * GPIO2 = mic mute hotkey
4851  * GPIO3 = mute LED
4852  * GPIO4 = mic mute LED
4853  */
4854 static void alc280_fixup_hp_gpio2_mic_hotkey(struct hda_codec *codec,
4855                                              const struct hda_fixup *fix, int action)
4856 {
4857         struct alc_spec *spec = codec->spec;
4858
4859         alc_fixup_hp_gpio_led(codec, action, 0x08, 0x10);
4860         if (action == HDA_FIXUP_ACT_PRE_PROBE) {
4861                 spec->init_amp = ALC_INIT_DEFAULT;
4862                 if (alc_register_micmute_input_device(codec) != 0)
4863                         return;
4864
4865                 spec->gpio_mask |= 0x06;
4866                 spec->gpio_dir |= 0x02;
4867                 spec->gpio_data |= 0x02;
4868                 snd_hda_codec_write_cache(codec, codec->core.afg, 0,
4869                                           AC_VERB_SET_GPIO_UNSOLICITED_RSP_MASK, 0x04);
4870                 snd_hda_jack_detect_enable_callback(codec, codec->core.afg,
4871                                                     gpio2_mic_hotkey_event);
4872                 return;
4873         }
4874
4875         if (!spec->kb_dev)
4876                 return;
4877
4878         switch (action) {
4879         case HDA_FIXUP_ACT_FREE:
4880                 input_unregister_device(spec->kb_dev);
4881                 spec->kb_dev = NULL;
4882         }
4883 }
4884
4885 /* Line2 = mic mute hotkey
4886  * GPIO2 = mic mute LED
4887  */
4888 static void alc233_fixup_lenovo_line2_mic_hotkey(struct hda_codec *codec,
4889                                              const struct hda_fixup *fix, int action)
4890 {
4891         struct alc_spec *spec = codec->spec;
4892
4893         alc_fixup_hp_gpio_led(codec, action, 0, 0x04);
4894         if (action == HDA_FIXUP_ACT_PRE_PROBE) {
4895                 spec->init_amp = ALC_INIT_DEFAULT;
4896                 if (alc_register_micmute_input_device(codec) != 0)
4897                         return;
4898
4899                 snd_hda_jack_detect_enable_callback(codec, 0x1b,
4900                                                     gpio2_mic_hotkey_event);
4901                 return;
4902         }
4903
4904         if (!spec->kb_dev)
4905                 return;
4906
4907         switch (action) {
4908         case HDA_FIXUP_ACT_FREE:
4909                 input_unregister_device(spec->kb_dev);
4910                 spec->kb_dev = NULL;
4911         }
4912 }
4913 #else /* INPUT */
4914 #define alc280_fixup_hp_gpio2_mic_hotkey        NULL
4915 #define alc233_fixup_lenovo_line2_mic_hotkey    NULL
4916 #endif /* INPUT */
4917
4918 static void alc269_fixup_hp_line1_mic1_led(struct hda_codec *codec,
4919                                 const struct hda_fixup *fix, int action)
4920 {
4921         struct alc_spec *spec = codec->spec;
4922
4923         alc269_fixup_hp_mute_led_micx(codec, fix, action, 0x1a);
4924         if (action == HDA_FIXUP_ACT_PRE_PROBE) {
4925                 spec->cap_mute_led_nid = 0x18;
4926                 snd_hda_gen_add_micmute_led_cdev(codec, vref_micmute_led_set);
4927         }
4928 }
4929
4930 static const struct coef_fw alc225_pre_hsmode[] = {
4931         UPDATE_COEF(0x4a, 1<<8, 0),
4932         UPDATE_COEFEX(0x57, 0x05, 1<<14, 0),
4933         UPDATE_COEF(0x63, 3<<14, 3<<14),
4934         UPDATE_COEF(0x4a, 3<<4, 2<<4),
4935         UPDATE_COEF(0x4a, 3<<10, 3<<10),
4936         UPDATE_COEF(0x45, 0x3f<<10, 0x34<<10),
4937         UPDATE_COEF(0x4a, 3<<10, 0),
4938         {}
4939 };
4940
4941 static void alc_headset_mode_unplugged(struct hda_codec *codec)
4942 {
4943         struct alc_spec *spec = codec->spec;
4944         static const struct coef_fw coef0255[] = {
4945                 WRITE_COEF(0x1b, 0x0c0b), /* LDO and MISC control */
4946                 WRITE_COEF(0x45, 0xd089), /* UAJ function set to menual mode */
4947                 UPDATE_COEFEX(0x57, 0x05, 1<<14, 0), /* Direct Drive HP Amp control(Set to verb control)*/
4948                 WRITE_COEF(0x06, 0x6104), /* Set MIC2 Vref gate with HP */
4949                 WRITE_COEFEX(0x57, 0x03, 0x8aa6), /* Direct Drive HP Amp control */
4950                 {}
4951         };
4952         static const struct coef_fw coef0256[] = {
4953                 WRITE_COEF(0x1b, 0x0c4b), /* LDO and MISC control */
4954                 WRITE_COEF(0x45, 0xd089), /* UAJ function set to menual mode */
4955                 WRITE_COEF(0x06, 0x6104), /* Set MIC2 Vref gate with HP */
4956                 WRITE_COEFEX(0x57, 0x03, 0x09a3), /* Direct Drive HP Amp control */
4957                 UPDATE_COEFEX(0x57, 0x05, 1<<14, 0), /* Direct Drive HP Amp control(Set to verb control)*/
4958                 {}
4959         };
4960         static const struct coef_fw coef0233[] = {
4961                 WRITE_COEF(0x1b, 0x0c0b),
4962                 WRITE_COEF(0x45, 0xc429),
4963                 UPDATE_COEF(0x35, 0x4000, 0),
4964                 WRITE_COEF(0x06, 0x2104),
4965                 WRITE_COEF(0x1a, 0x0001),
4966                 WRITE_COEF(0x26, 0x0004),
4967                 WRITE_COEF(0x32, 0x42a3),
4968                 {}
4969         };
4970         static const struct coef_fw coef0288[] = {
4971                 UPDATE_COEF(0x4f, 0xfcc0, 0xc400),
4972                 UPDATE_COEF(0x50, 0x2000, 0x2000),
4973                 UPDATE_COEF(0x56, 0x0006, 0x0006),
4974                 UPDATE_COEF(0x66, 0x0008, 0),
4975                 UPDATE_COEF(0x67, 0x2000, 0),
4976                 {}
4977         };
4978         static const struct coef_fw coef0298[] = {
4979                 UPDATE_COEF(0x19, 0x1300, 0x0300),
4980                 {}
4981         };
4982         static const struct coef_fw coef0292[] = {
4983                 WRITE_COEF(0x76, 0x000e),
4984                 WRITE_COEF(0x6c, 0x2400),
4985                 WRITE_COEF(0x18, 0x7308),
4986                 WRITE_COEF(0x6b, 0xc429),
4987                 {}
4988         };
4989         static const struct coef_fw coef0293[] = {
4990                 UPDATE_COEF(0x10, 7<<8, 6<<8), /* SET Line1 JD to 0 */
4991                 UPDATE_COEFEX(0x57, 0x05, 1<<15|1<<13, 0x0), /* SET charge pump by verb */
4992                 UPDATE_COEFEX(0x57, 0x03, 1<<10, 1<<10), /* SET EN_OSW to 1 */
4993                 UPDATE_COEF(0x1a, 1<<3, 1<<3), /* Combo JD gating with LINE1-VREFO */
4994                 WRITE_COEF(0x45, 0xc429), /* Set to TRS type */
4995                 UPDATE_COEF(0x4a, 0x000f, 0x000e), /* Combo Jack auto detect */
4996                 {}
4997         };
4998         static const struct coef_fw coef0668[] = {
4999                 WRITE_COEF(0x15, 0x0d40),
5000                 WRITE_COEF(0xb7, 0x802b),
5001                 {}
5002         };
5003         static const struct coef_fw coef0225[] = {
5004                 UPDATE_COEF(0x63, 3<<14, 0),
5005                 {}
5006         };
5007         static const struct coef_fw coef0274[] = {
5008                 UPDATE_COEF(0x4a, 0x0100, 0),
5009                 UPDATE_COEFEX(0x57, 0x05, 0x4000, 0),
5010                 UPDATE_COEF(0x6b, 0xf000, 0x5000),
5011                 UPDATE_COEF(0x4a, 0x0010, 0),
5012                 UPDATE_COEF(0x4a, 0x0c00, 0x0c00),
5013                 WRITE_COEF(0x45, 0x5289),
5014                 UPDATE_COEF(0x4a, 0x0c00, 0),
5015                 {}
5016         };
5017
5018         if (spec->no_internal_mic_pin) {
5019                 alc_update_coef_idx(codec, 0x45, 0xf<<12 | 1<<10, 5<<12);
5020                 return;
5021         }
5022
5023         switch (codec->core.vendor_id) {
5024         case 0x10ec0255:
5025                 alc_process_coef_fw(codec, coef0255);
5026                 break;
5027         case 0x10ec0230:
5028         case 0x10ec0236:
5029         case 0x10ec0256:
5030         case 0x19e58326:
5031                 alc_process_coef_fw(codec, coef0256);
5032                 break;
5033         case 0x10ec0234:
5034         case 0x10ec0274:
5035         case 0x10ec0294:
5036                 alc_process_coef_fw(codec, coef0274);
5037                 break;
5038         case 0x10ec0233:
5039         case 0x10ec0283:
5040                 alc_process_coef_fw(codec, coef0233);
5041                 break;
5042         case 0x10ec0286:
5043         case 0x10ec0288:
5044                 alc_process_coef_fw(codec, coef0288);
5045                 break;
5046         case 0x10ec0298:
5047                 alc_process_coef_fw(codec, coef0298);
5048                 alc_process_coef_fw(codec, coef0288);
5049                 break;
5050         case 0x10ec0292:
5051                 alc_process_coef_fw(codec, coef0292);
5052                 break;
5053         case 0x10ec0293:
5054                 alc_process_coef_fw(codec, coef0293);
5055                 break;
5056         case 0x10ec0668:
5057                 alc_process_coef_fw(codec, coef0668);
5058                 break;
5059         case 0x10ec0215:
5060         case 0x10ec0225:
5061         case 0x10ec0285:
5062         case 0x10ec0295:
5063         case 0x10ec0289:
5064         case 0x10ec0299:
5065                 alc_process_coef_fw(codec, alc225_pre_hsmode);
5066                 alc_process_coef_fw(codec, coef0225);
5067                 break;
5068         case 0x10ec0867:
5069                 alc_update_coefex_idx(codec, 0x57, 0x5, 1<<14, 0);
5070                 break;
5071         }
5072         codec_dbg(codec, "Headset jack set to unplugged mode.\n");
5073 }
5074
5075
5076 static void alc_headset_mode_mic_in(struct hda_codec *codec, hda_nid_t hp_pin,
5077                                     hda_nid_t mic_pin)
5078 {
5079         static const struct coef_fw coef0255[] = {
5080                 WRITE_COEFEX(0x57, 0x03, 0x8aa6),
5081                 WRITE_COEF(0x06, 0x6100), /* Set MIC2 Vref gate to normal */
5082                 {}
5083         };
5084         static const struct coef_fw coef0256[] = {
5085                 UPDATE_COEFEX(0x57, 0x05, 1<<14, 1<<14), /* Direct Drive HP Amp control(Set to verb control)*/
5086                 WRITE_COEFEX(0x57, 0x03, 0x09a3),
5087                 WRITE_COEF(0x06, 0x6100), /* Set MIC2 Vref gate to normal */
5088                 {}
5089         };
5090         static const struct coef_fw coef0233[] = {
5091                 UPDATE_COEF(0x35, 0, 1<<14),
5092                 WRITE_COEF(0x06, 0x2100),
5093                 WRITE_COEF(0x1a, 0x0021),
5094                 WRITE_COEF(0x26, 0x008c),
5095                 {}
5096         };
5097         static const struct coef_fw coef0288[] = {
5098                 UPDATE_COEF(0x4f, 0x00c0, 0),
5099                 UPDATE_COEF(0x50, 0x2000, 0),
5100                 UPDATE_COEF(0x56, 0x0006, 0),
5101                 UPDATE_COEF(0x4f, 0xfcc0, 0xc400),
5102                 UPDATE_COEF(0x66, 0x0008, 0x0008),
5103                 UPDATE_COEF(0x67, 0x2000, 0x2000),
5104                 {}
5105         };
5106         static const struct coef_fw coef0292[] = {
5107                 WRITE_COEF(0x19, 0xa208),
5108                 WRITE_COEF(0x2e, 0xacf0),
5109                 {}
5110         };
5111         static const struct coef_fw coef0293[] = {
5112                 UPDATE_COEFEX(0x57, 0x05, 0, 1<<15|1<<13), /* SET charge pump by verb */
5113                 UPDATE_COEFEX(0x57, 0x03, 1<<10, 0), /* SET EN_OSW to 0 */
5114                 UPDATE_COEF(0x1a, 1<<3, 0), /* Combo JD gating without LINE1-VREFO */
5115                 {}
5116         };
5117         static const struct coef_fw coef0688[] = {
5118                 WRITE_COEF(0xb7, 0x802b),
5119                 WRITE_COEF(0xb5, 0x1040),
5120                 UPDATE_COEF(0xc3, 0, 1<<12),
5121                 {}
5122         };
5123         static const struct coef_fw coef0225[] = {
5124                 UPDATE_COEFEX(0x57, 0x05, 1<<14, 1<<14),
5125                 UPDATE_COEF(0x4a, 3<<4, 2<<4),
5126                 UPDATE_COEF(0x63, 3<<14, 0),
5127                 {}
5128         };
5129         static const struct coef_fw coef0274[] = {
5130                 UPDATE_COEFEX(0x57, 0x05, 0x4000, 0x4000),
5131                 UPDATE_COEF(0x4a, 0x0010, 0),
5132                 UPDATE_COEF(0x6b, 0xf000, 0),
5133                 {}
5134         };
5135
5136         switch (codec->core.vendor_id) {
5137         case 0x10ec0255:
5138                 alc_write_coef_idx(codec, 0x45, 0xc489);
5139                 snd_hda_set_pin_ctl_cache(codec, hp_pin, 0);
5140                 alc_process_coef_fw(codec, coef0255);
5141                 snd_hda_set_pin_ctl_cache(codec, mic_pin, PIN_VREF50);
5142                 break;
5143         case 0x10ec0230:
5144         case 0x10ec0236:
5145         case 0x10ec0256:
5146         case 0x19e58326:
5147                 alc_write_coef_idx(codec, 0x45, 0xc489);
5148                 snd_hda_set_pin_ctl_cache(codec, hp_pin, 0);
5149                 alc_process_coef_fw(codec, coef0256);
5150                 snd_hda_set_pin_ctl_cache(codec, mic_pin, PIN_VREF50);
5151                 break;
5152         case 0x10ec0234:
5153         case 0x10ec0274:
5154         case 0x10ec0294:
5155                 alc_write_coef_idx(codec, 0x45, 0x4689);
5156                 snd_hda_set_pin_ctl_cache(codec, hp_pin, 0);
5157                 alc_process_coef_fw(codec, coef0274);
5158                 snd_hda_set_pin_ctl_cache(codec, mic_pin, PIN_VREF50);
5159                 break;
5160         case 0x10ec0233:
5161         case 0x10ec0283:
5162                 alc_write_coef_idx(codec, 0x45, 0xc429);
5163                 snd_hda_set_pin_ctl_cache(codec, hp_pin, 0);
5164                 alc_process_coef_fw(codec, coef0233);
5165                 snd_hda_set_pin_ctl_cache(codec, mic_pin, PIN_VREF50);
5166                 break;
5167         case 0x10ec0286:
5168         case 0x10ec0288:
5169         case 0x10ec0298:
5170                 snd_hda_set_pin_ctl_cache(codec, hp_pin, 0);
5171                 alc_process_coef_fw(codec, coef0288);
5172                 snd_hda_set_pin_ctl_cache(codec, mic_pin, PIN_VREF50);
5173                 break;
5174         case 0x10ec0292:
5175                 snd_hda_set_pin_ctl_cache(codec, hp_pin, 0);
5176                 alc_process_coef_fw(codec, coef0292);
5177                 break;
5178         case 0x10ec0293:
5179                 /* Set to TRS mode */
5180                 alc_write_coef_idx(codec, 0x45, 0xc429);
5181                 snd_hda_set_pin_ctl_cache(codec, hp_pin, 0);
5182                 alc_process_coef_fw(codec, coef0293);
5183                 snd_hda_set_pin_ctl_cache(codec, mic_pin, PIN_VREF50);
5184                 break;
5185         case 0x10ec0867:
5186                 alc_update_coefex_idx(codec, 0x57, 0x5, 0, 1<<14);
5187                 fallthrough;
5188         case 0x10ec0221:
5189         case 0x10ec0662:
5190                 snd_hda_set_pin_ctl_cache(codec, hp_pin, 0);
5191                 snd_hda_set_pin_ctl_cache(codec, mic_pin, PIN_VREF50);
5192                 break;
5193         case 0x10ec0668:
5194                 alc_write_coef_idx(codec, 0x11, 0x0001);
5195                 snd_hda_set_pin_ctl_cache(codec, hp_pin, 0);
5196                 alc_process_coef_fw(codec, coef0688);
5197                 snd_hda_set_pin_ctl_cache(codec, mic_pin, PIN_VREF50);
5198                 break;
5199         case 0x10ec0215:
5200         case 0x10ec0225:
5201         case 0x10ec0285:
5202         case 0x10ec0295:
5203         case 0x10ec0289:
5204         case 0x10ec0299:
5205                 alc_process_coef_fw(codec, alc225_pre_hsmode);
5206                 alc_update_coef_idx(codec, 0x45, 0x3f<<10, 0x31<<10);
5207                 snd_hda_set_pin_ctl_cache(codec, hp_pin, 0);
5208                 alc_process_coef_fw(codec, coef0225);
5209                 snd_hda_set_pin_ctl_cache(codec, mic_pin, PIN_VREF50);
5210                 break;
5211         }
5212         codec_dbg(codec, "Headset jack set to mic-in mode.\n");
5213 }
5214
5215 static void alc_headset_mode_default(struct hda_codec *codec)
5216 {
5217         static const struct coef_fw coef0225[] = {
5218                 UPDATE_COEF(0x45, 0x3f<<10, 0x30<<10),
5219                 UPDATE_COEF(0x45, 0x3f<<10, 0x31<<10),
5220                 UPDATE_COEF(0x49, 3<<8, 0<<8),
5221                 UPDATE_COEF(0x4a, 3<<4, 3<<4),
5222                 UPDATE_COEF(0x63, 3<<14, 0),
5223                 UPDATE_COEF(0x67, 0xf000, 0x3000),
5224                 {}
5225         };
5226         static const struct coef_fw coef0255[] = {
5227                 WRITE_COEF(0x45, 0xc089),
5228                 WRITE_COEF(0x45, 0xc489),
5229                 WRITE_COEFEX(0x57, 0x03, 0x8ea6),
5230                 WRITE_COEF(0x49, 0x0049),
5231                 {}
5232         };
5233         static const struct coef_fw coef0256[] = {
5234                 WRITE_COEF(0x45, 0xc489),
5235                 WRITE_COEFEX(0x57, 0x03, 0x0da3),
5236                 WRITE_COEF(0x49, 0x0049),
5237                 UPDATE_COEFEX(0x57, 0x05, 1<<14, 0), /* Direct Drive HP Amp control(Set to verb control)*/
5238                 WRITE_COEF(0x06, 0x6100),
5239                 {}
5240         };
5241         static const struct coef_fw coef0233[] = {
5242                 WRITE_COEF(0x06, 0x2100),
5243                 WRITE_COEF(0x32, 0x4ea3),
5244                 {}
5245         };
5246         static const struct coef_fw coef0288[] = {
5247                 UPDATE_COEF(0x4f, 0xfcc0, 0xc400), /* Set to TRS type */
5248                 UPDATE_COEF(0x50, 0x2000, 0x2000),
5249                 UPDATE_COEF(0x56, 0x0006, 0x0006),
5250                 UPDATE_COEF(0x66, 0x0008, 0),
5251                 UPDATE_COEF(0x67, 0x2000, 0),
5252                 {}
5253         };
5254         static const struct coef_fw coef0292[] = {
5255                 WRITE_COEF(0x76, 0x000e),
5256                 WRITE_COEF(0x6c, 0x2400),
5257                 WRITE_COEF(0x6b, 0xc429),
5258                 WRITE_COEF(0x18, 0x7308),
5259                 {}
5260         };
5261         static const struct coef_fw coef0293[] = {
5262                 UPDATE_COEF(0x4a, 0x000f, 0x000e), /* Combo Jack auto detect */
5263                 WRITE_COEF(0x45, 0xC429), /* Set to TRS type */
5264                 UPDATE_COEF(0x1a, 1<<3, 0), /* Combo JD gating without LINE1-VREFO */
5265                 {}
5266         };
5267         static const struct coef_fw coef0688[] = {
5268                 WRITE_COEF(0x11, 0x0041),
5269                 WRITE_COEF(0x15, 0x0d40),
5270                 WRITE_COEF(0xb7, 0x802b),
5271                 {}
5272         };
5273         static const struct coef_fw coef0274[] = {
5274                 WRITE_COEF(0x45, 0x4289),
5275                 UPDATE_COEF(0x4a, 0x0010, 0x0010),
5276                 UPDATE_COEF(0x6b, 0x0f00, 0),
5277                 UPDATE_COEF(0x49, 0x0300, 0x0300),
5278                 {}
5279         };
5280
5281         switch (codec->core.vendor_id) {
5282         case 0x10ec0215:
5283         case 0x10ec0225:
5284         case 0x10ec0285:
5285         case 0x10ec0295:
5286         case 0x10ec0289:
5287         case 0x10ec0299:
5288                 alc_process_coef_fw(codec, alc225_pre_hsmode);
5289                 alc_process_coef_fw(codec, coef0225);
5290                 break;
5291         case 0x10ec0255:
5292                 alc_process_coef_fw(codec, coef0255);
5293                 break;
5294         case 0x10ec0230:
5295         case 0x10ec0236:
5296         case 0x10ec0256:
5297         case 0x19e58326:
5298                 alc_write_coef_idx(codec, 0x1b, 0x0e4b);
5299                 alc_write_coef_idx(codec, 0x45, 0xc089);
5300                 msleep(50);
5301                 alc_process_coef_fw(codec, coef0256);
5302                 break;
5303         case 0x10ec0234:
5304         case 0x10ec0274:
5305         case 0x10ec0294:
5306                 alc_process_coef_fw(codec, coef0274);
5307                 break;
5308         case 0x10ec0233:
5309         case 0x10ec0283:
5310                 alc_process_coef_fw(codec, coef0233);
5311                 break;
5312         case 0x10ec0286:
5313         case 0x10ec0288:
5314         case 0x10ec0298:
5315                 alc_process_coef_fw(codec, coef0288);
5316                 break;
5317         case 0x10ec0292:
5318                 alc_process_coef_fw(codec, coef0292);
5319                 break;
5320         case 0x10ec0293:
5321                 alc_process_coef_fw(codec, coef0293);
5322                 break;
5323         case 0x10ec0668:
5324                 alc_process_coef_fw(codec, coef0688);
5325                 break;
5326         case 0x10ec0867:
5327                 alc_update_coefex_idx(codec, 0x57, 0x5, 1<<14, 0);
5328                 break;
5329         }
5330         codec_dbg(codec, "Headset jack set to headphone (default) mode.\n");
5331 }
5332
5333 /* Iphone type */
5334 static void alc_headset_mode_ctia(struct hda_codec *codec)
5335 {
5336         int val;
5337
5338         static const struct coef_fw coef0255[] = {
5339                 WRITE_COEF(0x45, 0xd489), /* Set to CTIA type */
5340                 WRITE_COEF(0x1b, 0x0c2b),
5341                 WRITE_COEFEX(0x57, 0x03, 0x8ea6),
5342                 {}
5343         };
5344         static const struct coef_fw coef0256[] = {
5345                 WRITE_COEF(0x45, 0xd489), /* Set to CTIA type */
5346                 WRITE_COEF(0x1b, 0x0e6b),
5347                 {}
5348         };
5349         static const struct coef_fw coef0233[] = {
5350                 WRITE_COEF(0x45, 0xd429),
5351                 WRITE_COEF(0x1b, 0x0c2b),
5352                 WRITE_COEF(0x32, 0x4ea3),
5353                 {}
5354         };
5355         static const struct coef_fw coef0288[] = {
5356                 UPDATE_COEF(0x50, 0x2000, 0x2000),
5357                 UPDATE_COEF(0x56, 0x0006, 0x0006),
5358                 UPDATE_COEF(0x66, 0x0008, 0),
5359                 UPDATE_COEF(0x67, 0x2000, 0),
5360                 {}
5361         };
5362         static const struct coef_fw coef0292[] = {
5363                 WRITE_COEF(0x6b, 0xd429),
5364                 WRITE_COEF(0x76, 0x0008),
5365                 WRITE_COEF(0x18, 0x7388),
5366                 {}
5367         };
5368         static const struct coef_fw coef0293[] = {
5369                 WRITE_COEF(0x45, 0xd429), /* Set to ctia type */
5370                 UPDATE_COEF(0x10, 7<<8, 7<<8), /* SET Line1 JD to 1 */
5371                 {}
5372         };
5373         static const struct coef_fw coef0688[] = {
5374                 WRITE_COEF(0x11, 0x0001),
5375                 WRITE_COEF(0x15, 0x0d60),
5376                 WRITE_COEF(0xc3, 0x0000),
5377                 {}
5378         };
5379         static const struct coef_fw coef0225_1[] = {
5380                 UPDATE_COEF(0x45, 0x3f<<10, 0x35<<10),
5381                 UPDATE_COEF(0x63, 3<<14, 2<<14),
5382                 {}
5383         };
5384         static const struct coef_fw coef0225_2[] = {
5385                 UPDATE_COEF(0x45, 0x3f<<10, 0x35<<10),
5386                 UPDATE_COEF(0x63, 3<<14, 1<<14),
5387                 {}
5388         };
5389
5390         switch (codec->core.vendor_id) {
5391         case 0x10ec0255:
5392                 alc_process_coef_fw(codec, coef0255);
5393                 break;
5394         case 0x10ec0230:
5395         case 0x10ec0236:
5396         case 0x10ec0256:
5397         case 0x19e58326:
5398                 alc_process_coef_fw(codec, coef0256);
5399                 break;
5400         case 0x10ec0234:
5401         case 0x10ec0274:
5402         case 0x10ec0294:
5403                 alc_write_coef_idx(codec, 0x45, 0xd689);
5404                 break;
5405         case 0x10ec0233:
5406         case 0x10ec0283:
5407                 alc_process_coef_fw(codec, coef0233);
5408                 break;
5409         case 0x10ec0298:
5410                 val = alc_read_coef_idx(codec, 0x50);
5411                 if (val & (1 << 12)) {
5412                         alc_update_coef_idx(codec, 0x8e, 0x0070, 0x0020);
5413                         alc_update_coef_idx(codec, 0x4f, 0xfcc0, 0xd400);
5414                         msleep(300);
5415                 } else {
5416                         alc_update_coef_idx(codec, 0x8e, 0x0070, 0x0010);
5417                         alc_update_coef_idx(codec, 0x4f, 0xfcc0, 0xd400);
5418                         msleep(300);
5419                 }
5420                 break;
5421         case 0x10ec0286:
5422         case 0x10ec0288:
5423                 alc_update_coef_idx(codec, 0x4f, 0xfcc0, 0xd400);
5424                 msleep(300);
5425                 alc_process_coef_fw(codec, coef0288);
5426                 break;
5427         case 0x10ec0292:
5428                 alc_process_coef_fw(codec, coef0292);
5429                 break;
5430         case 0x10ec0293:
5431                 alc_process_coef_fw(codec, coef0293);
5432                 break;
5433         case 0x10ec0668:
5434                 alc_process_coef_fw(codec, coef0688);
5435                 break;
5436         case 0x10ec0215:
5437         case 0x10ec0225:
5438         case 0x10ec0285:
5439         case 0x10ec0295:
5440         case 0x10ec0289:
5441         case 0x10ec0299:
5442                 val = alc_read_coef_idx(codec, 0x45);
5443                 if (val & (1 << 9))
5444                         alc_process_coef_fw(codec, coef0225_2);
5445                 else
5446                         alc_process_coef_fw(codec, coef0225_1);
5447                 break;
5448         case 0x10ec0867:
5449                 alc_update_coefex_idx(codec, 0x57, 0x5, 1<<14, 0);
5450                 break;
5451         }
5452         codec_dbg(codec, "Headset jack set to iPhone-style headset mode.\n");
5453 }
5454
5455 /* Nokia type */
5456 static void alc_headset_mode_omtp(struct hda_codec *codec)
5457 {
5458         static const struct coef_fw coef0255[] = {
5459                 WRITE_COEF(0x45, 0xe489), /* Set to OMTP Type */
5460                 WRITE_COEF(0x1b, 0x0c2b),
5461                 WRITE_COEFEX(0x57, 0x03, 0x8ea6),
5462                 {}
5463         };
5464         static const struct coef_fw coef0256[] = {
5465                 WRITE_COEF(0x45, 0xe489), /* Set to OMTP Type */
5466                 WRITE_COEF(0x1b, 0x0e6b),
5467                 {}
5468         };
5469         static const struct coef_fw coef0233[] = {
5470                 WRITE_COEF(0x45, 0xe429),
5471                 WRITE_COEF(0x1b, 0x0c2b),
5472                 WRITE_COEF(0x32, 0x4ea3),
5473                 {}
5474         };
5475         static const struct coef_fw coef0288[] = {
5476                 UPDATE_COEF(0x50, 0x2000, 0x2000),
5477                 UPDATE_COEF(0x56, 0x0006, 0x0006),
5478                 UPDATE_COEF(0x66, 0x0008, 0),
5479                 UPDATE_COEF(0x67, 0x2000, 0),
5480                 {}
5481         };
5482         static const struct coef_fw coef0292[] = {
5483                 WRITE_COEF(0x6b, 0xe429),
5484                 WRITE_COEF(0x76, 0x0008),
5485                 WRITE_COEF(0x18, 0x7388),
5486                 {}
5487         };
5488         static const struct coef_fw coef0293[] = {
5489                 WRITE_COEF(0x45, 0xe429), /* Set to omtp type */
5490                 UPDATE_COEF(0x10, 7<<8, 7<<8), /* SET Line1 JD to 1 */
5491                 {}
5492         };
5493         static const struct coef_fw coef0688[] = {
5494                 WRITE_COEF(0x11, 0x0001),
5495                 WRITE_COEF(0x15, 0x0d50),
5496                 WRITE_COEF(0xc3, 0x0000),
5497                 {}
5498         };
5499         static const struct coef_fw coef0225[] = {
5500                 UPDATE_COEF(0x45, 0x3f<<10, 0x39<<10),
5501                 UPDATE_COEF(0x63, 3<<14, 2<<14),
5502                 {}
5503         };
5504
5505         switch (codec->core.vendor_id) {
5506         case 0x10ec0255:
5507                 alc_process_coef_fw(codec, coef0255);
5508                 break;
5509         case 0x10ec0230:
5510         case 0x10ec0236:
5511         case 0x10ec0256:
5512         case 0x19e58326:
5513                 alc_process_coef_fw(codec, coef0256);
5514                 break;
5515         case 0x10ec0234:
5516         case 0x10ec0274:
5517         case 0x10ec0294:
5518                 alc_write_coef_idx(codec, 0x45, 0xe689);
5519                 break;
5520         case 0x10ec0233:
5521         case 0x10ec0283:
5522                 alc_process_coef_fw(codec, coef0233);
5523                 break;
5524         case 0x10ec0298:
5525                 alc_update_coef_idx(codec, 0x8e, 0x0070, 0x0010);/* Headset output enable */
5526                 alc_update_coef_idx(codec, 0x4f, 0xfcc0, 0xe400);
5527                 msleep(300);
5528                 break;
5529         case 0x10ec0286:
5530         case 0x10ec0288:
5531                 alc_update_coef_idx(codec, 0x4f, 0xfcc0, 0xe400);
5532                 msleep(300);
5533                 alc_process_coef_fw(codec, coef0288);
5534                 break;
5535         case 0x10ec0292:
5536                 alc_process_coef_fw(codec, coef0292);
5537                 break;
5538         case 0x10ec0293:
5539                 alc_process_coef_fw(codec, coef0293);
5540                 break;
5541         case 0x10ec0668:
5542                 alc_process_coef_fw(codec, coef0688);
5543                 break;
5544         case 0x10ec0215:
5545         case 0x10ec0225:
5546         case 0x10ec0285:
5547         case 0x10ec0295:
5548         case 0x10ec0289:
5549         case 0x10ec0299:
5550                 alc_process_coef_fw(codec, coef0225);
5551                 break;
5552         }
5553         codec_dbg(codec, "Headset jack set to Nokia-style headset mode.\n");
5554 }
5555
5556 static void alc_determine_headset_type(struct hda_codec *codec)
5557 {
5558         int val;
5559         bool is_ctia = false;
5560         struct alc_spec *spec = codec->spec;
5561         static const struct coef_fw coef0255[] = {
5562                 WRITE_COEF(0x45, 0xd089), /* combo jack auto switch control(Check type)*/
5563                 WRITE_COEF(0x49, 0x0149), /* combo jack auto switch control(Vref
5564  conteol) */
5565                 {}
5566         };
5567         static const struct coef_fw coef0288[] = {
5568                 UPDATE_COEF(0x4f, 0xfcc0, 0xd400), /* Check Type */
5569                 {}
5570         };
5571         static const struct coef_fw coef0298[] = {
5572                 UPDATE_COEF(0x50, 0x2000, 0x2000),
5573                 UPDATE_COEF(0x56, 0x0006, 0x0006),
5574                 UPDATE_COEF(0x66, 0x0008, 0),
5575                 UPDATE_COEF(0x67, 0x2000, 0),
5576                 UPDATE_COEF(0x19, 0x1300, 0x1300),
5577                 {}
5578         };
5579         static const struct coef_fw coef0293[] = {
5580                 UPDATE_COEF(0x4a, 0x000f, 0x0008), /* Combo Jack auto detect */
5581                 WRITE_COEF(0x45, 0xD429), /* Set to ctia type */
5582                 {}
5583         };
5584         static const struct coef_fw coef0688[] = {
5585                 WRITE_COEF(0x11, 0x0001),
5586                 WRITE_COEF(0xb7, 0x802b),
5587                 WRITE_COEF(0x15, 0x0d60),
5588                 WRITE_COEF(0xc3, 0x0c00),
5589                 {}
5590         };
5591         static const struct coef_fw coef0274[] = {
5592                 UPDATE_COEF(0x4a, 0x0010, 0),
5593                 UPDATE_COEF(0x4a, 0x8000, 0),
5594                 WRITE_COEF(0x45, 0xd289),
5595                 UPDATE_COEF(0x49, 0x0300, 0x0300),
5596                 {}
5597         };
5598
5599         if (spec->no_internal_mic_pin) {
5600                 alc_update_coef_idx(codec, 0x45, 0xf<<12 | 1<<10, 5<<12);
5601                 return;
5602         }
5603
5604         switch (codec->core.vendor_id) {
5605         case 0x10ec0255:
5606                 alc_process_coef_fw(codec, coef0255);
5607                 msleep(300);
5608                 val = alc_read_coef_idx(codec, 0x46);
5609                 is_ctia = (val & 0x0070) == 0x0070;
5610                 break;
5611         case 0x10ec0230:
5612         case 0x10ec0236:
5613         case 0x10ec0256:
5614         case 0x19e58326:
5615                 alc_write_coef_idx(codec, 0x1b, 0x0e4b);
5616                 alc_write_coef_idx(codec, 0x06, 0x6104);
5617                 alc_write_coefex_idx(codec, 0x57, 0x3, 0x09a3);
5618
5619                 snd_hda_codec_write(codec, 0x21, 0,
5620                             AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);
5621                 msleep(80);
5622                 snd_hda_codec_write(codec, 0x21, 0,
5623                             AC_VERB_SET_PIN_WIDGET_CONTROL, 0x0);
5624
5625                 alc_process_coef_fw(codec, coef0255);
5626                 msleep(300);
5627                 val = alc_read_coef_idx(codec, 0x46);
5628                 is_ctia = (val & 0x0070) == 0x0070;
5629
5630                 alc_write_coefex_idx(codec, 0x57, 0x3, 0x0da3);
5631                 alc_update_coefex_idx(codec, 0x57, 0x5, 1<<14, 0);
5632
5633                 snd_hda_codec_write(codec, 0x21, 0,
5634                             AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT);
5635                 msleep(80);
5636                 snd_hda_codec_write(codec, 0x21, 0,
5637                             AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE);
5638                 break;
5639         case 0x10ec0234:
5640         case 0x10ec0274:
5641         case 0x10ec0294:
5642                 alc_process_coef_fw(codec, coef0274);
5643                 msleep(850);
5644                 val = alc_read_coef_idx(codec, 0x46);
5645                 is_ctia = (val & 0x00f0) == 0x00f0;
5646                 break;
5647         case 0x10ec0233:
5648         case 0x10ec0283:
5649                 alc_write_coef_idx(codec, 0x45, 0xd029);
5650                 msleep(300);
5651                 val = alc_read_coef_idx(codec, 0x46);
5652                 is_ctia = (val & 0x0070) == 0x0070;
5653                 break;
5654         case 0x10ec0298:
5655                 snd_hda_codec_write(codec, 0x21, 0,
5656                             AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);
5657                 msleep(100);
5658                 snd_hda_codec_write(codec, 0x21, 0,
5659                             AC_VERB_SET_PIN_WIDGET_CONTROL, 0x0);
5660                 msleep(200);
5661
5662                 val = alc_read_coef_idx(codec, 0x50);
5663                 if (val & (1 << 12)) {
5664                         alc_update_coef_idx(codec, 0x8e, 0x0070, 0x0020);
5665                         alc_process_coef_fw(codec, coef0288);
5666                         msleep(350);
5667                         val = alc_read_coef_idx(codec, 0x50);
5668                         is_ctia = (val & 0x0070) == 0x0070;
5669                 } else {
5670                         alc_update_coef_idx(codec, 0x8e, 0x0070, 0x0010);
5671                         alc_process_coef_fw(codec, coef0288);
5672                         msleep(350);
5673                         val = alc_read_coef_idx(codec, 0x50);
5674                         is_ctia = (val & 0x0070) == 0x0070;
5675                 }
5676                 alc_process_coef_fw(codec, coef0298);
5677                 snd_hda_codec_write(codec, 0x21, 0,
5678                             AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP);
5679                 msleep(75);
5680                 snd_hda_codec_write(codec, 0x21, 0,
5681                             AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE);
5682                 break;
5683         case 0x10ec0286:
5684         case 0x10ec0288:
5685                 alc_process_coef_fw(codec, coef0288);
5686                 msleep(350);
5687                 val = alc_read_coef_idx(codec, 0x50);
5688                 is_ctia = (val & 0x0070) == 0x0070;
5689                 break;
5690         case 0x10ec0292:
5691                 alc_write_coef_idx(codec, 0x6b, 0xd429);
5692                 msleep(300);
5693                 val = alc_read_coef_idx(codec, 0x6c);
5694                 is_ctia = (val & 0x001c) == 0x001c;
5695                 break;
5696         case 0x10ec0293:
5697                 alc_process_coef_fw(codec, coef0293);
5698                 msleep(300);
5699                 val = alc_read_coef_idx(codec, 0x46);
5700                 is_ctia = (val & 0x0070) == 0x0070;
5701                 break;
5702         case 0x10ec0668:
5703                 alc_process_coef_fw(codec, coef0688);
5704                 msleep(300);
5705                 val = alc_read_coef_idx(codec, 0xbe);
5706                 is_ctia = (val & 0x1c02) == 0x1c02;
5707                 break;
5708         case 0x10ec0215:
5709         case 0x10ec0225:
5710         case 0x10ec0285:
5711         case 0x10ec0295:
5712         case 0x10ec0289:
5713         case 0x10ec0299:
5714                 snd_hda_codec_write(codec, 0x21, 0,
5715                             AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);
5716                 msleep(80);
5717                 snd_hda_codec_write(codec, 0x21, 0,
5718                             AC_VERB_SET_PIN_WIDGET_CONTROL, 0x0);
5719
5720                 alc_process_coef_fw(codec, alc225_pre_hsmode);
5721                 alc_update_coef_idx(codec, 0x67, 0xf000, 0x1000);
5722                 val = alc_read_coef_idx(codec, 0x45);
5723                 if (val & (1 << 9)) {
5724                         alc_update_coef_idx(codec, 0x45, 0x3f<<10, 0x34<<10);
5725                         alc_update_coef_idx(codec, 0x49, 3<<8, 2<<8);
5726                         msleep(800);
5727                         val = alc_read_coef_idx(codec, 0x46);
5728                         is_ctia = (val & 0x00f0) == 0x00f0;
5729                 } else {
5730                         alc_update_coef_idx(codec, 0x45, 0x3f<<10, 0x34<<10);
5731                         alc_update_coef_idx(codec, 0x49, 3<<8, 1<<8);
5732                         msleep(800);
5733                         val = alc_read_coef_idx(codec, 0x46);
5734                         is_ctia = (val & 0x00f0) == 0x00f0;
5735                 }
5736                 alc_update_coef_idx(codec, 0x4a, 7<<6, 7<<6);
5737                 alc_update_coef_idx(codec, 0x4a, 3<<4, 3<<4);
5738                 alc_update_coef_idx(codec, 0x67, 0xf000, 0x3000);
5739
5740                 snd_hda_codec_write(codec, 0x21, 0,
5741                             AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT);
5742                 msleep(80);
5743                 snd_hda_codec_write(codec, 0x21, 0,
5744                             AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE);
5745                 break;
5746         case 0x10ec0867:
5747                 is_ctia = true;
5748                 break;
5749         }
5750
5751         codec_dbg(codec, "Headset jack detected iPhone-style headset: %s\n",
5752                     is_ctia ? "yes" : "no");
5753         spec->current_headset_type = is_ctia ? ALC_HEADSET_TYPE_CTIA : ALC_HEADSET_TYPE_OMTP;
5754 }
5755
5756 static void alc_update_headset_mode(struct hda_codec *codec)
5757 {
5758         struct alc_spec *spec = codec->spec;
5759
5760         hda_nid_t mux_pin = spec->gen.imux_pins[spec->gen.cur_mux[0]];
5761         hda_nid_t hp_pin = alc_get_hp_pin(spec);
5762
5763         int new_headset_mode;
5764
5765         if (!snd_hda_jack_detect(codec, hp_pin))
5766                 new_headset_mode = ALC_HEADSET_MODE_UNPLUGGED;
5767         else if (mux_pin == spec->headset_mic_pin)
5768                 new_headset_mode = ALC_HEADSET_MODE_HEADSET;
5769         else if (mux_pin == spec->headphone_mic_pin)
5770                 new_headset_mode = ALC_HEADSET_MODE_MIC;
5771         else
5772                 new_headset_mode = ALC_HEADSET_MODE_HEADPHONE;
5773
5774         if (new_headset_mode == spec->current_headset_mode) {
5775                 snd_hda_gen_update_outputs(codec);
5776                 return;
5777         }
5778
5779         switch (new_headset_mode) {
5780         case ALC_HEADSET_MODE_UNPLUGGED:
5781                 alc_headset_mode_unplugged(codec);
5782                 spec->current_headset_mode = ALC_HEADSET_MODE_UNKNOWN;
5783                 spec->current_headset_type = ALC_HEADSET_TYPE_UNKNOWN;
5784                 spec->gen.hp_jack_present = false;
5785                 break;
5786         case ALC_HEADSET_MODE_HEADSET:
5787                 if (spec->current_headset_type == ALC_HEADSET_TYPE_UNKNOWN)
5788                         alc_determine_headset_type(codec);
5789                 if (spec->current_headset_type == ALC_HEADSET_TYPE_CTIA)
5790                         alc_headset_mode_ctia(codec);
5791                 else if (spec->current_headset_type == ALC_HEADSET_TYPE_OMTP)
5792                         alc_headset_mode_omtp(codec);
5793                 spec->gen.hp_jack_present = true;
5794                 break;
5795         case ALC_HEADSET_MODE_MIC:
5796                 alc_headset_mode_mic_in(codec, hp_pin, spec->headphone_mic_pin);
5797                 spec->gen.hp_jack_present = false;
5798                 break;
5799         case ALC_HEADSET_MODE_HEADPHONE:
5800                 alc_headset_mode_default(codec);
5801                 spec->gen.hp_jack_present = true;
5802                 break;
5803         }
5804         if (new_headset_mode != ALC_HEADSET_MODE_MIC) {
5805                 snd_hda_set_pin_ctl_cache(codec, hp_pin,
5806                                           AC_PINCTL_OUT_EN | AC_PINCTL_HP_EN);
5807                 if (spec->headphone_mic_pin && spec->headphone_mic_pin != hp_pin)
5808                         snd_hda_set_pin_ctl_cache(codec, spec->headphone_mic_pin,
5809                                                   PIN_VREFHIZ);
5810         }
5811         spec->current_headset_mode = new_headset_mode;
5812
5813         snd_hda_gen_update_outputs(codec);
5814 }
5815
5816 static void alc_update_headset_mode_hook(struct hda_codec *codec,
5817                                          struct snd_kcontrol *kcontrol,
5818                                          struct snd_ctl_elem_value *ucontrol)
5819 {
5820         alc_update_headset_mode(codec);
5821 }
5822
5823 static void alc_update_headset_jack_cb(struct hda_codec *codec,
5824                                        struct hda_jack_callback *jack)
5825 {
5826         snd_hda_gen_hp_automute(codec, jack);
5827         alc_update_headset_mode(codec);
5828 }
5829
5830 static void alc_probe_headset_mode(struct hda_codec *codec)
5831 {
5832         int i;
5833         struct alc_spec *spec = codec->spec;
5834         struct auto_pin_cfg *cfg = &spec->gen.autocfg;
5835
5836         /* Find mic pins */
5837         for (i = 0; i < cfg->num_inputs; i++) {
5838                 if (cfg->inputs[i].is_headset_mic && !spec->headset_mic_pin)
5839                         spec->headset_mic_pin = cfg->inputs[i].pin;
5840                 if (cfg->inputs[i].is_headphone_mic && !spec->headphone_mic_pin)
5841                         spec->headphone_mic_pin = cfg->inputs[i].pin;
5842         }
5843
5844         WARN_ON(spec->gen.cap_sync_hook);
5845         spec->gen.cap_sync_hook = alc_update_headset_mode_hook;
5846         spec->gen.automute_hook = alc_update_headset_mode;
5847         spec->gen.hp_automute_hook = alc_update_headset_jack_cb;
5848 }
5849
5850 static void alc_fixup_headset_mode(struct hda_codec *codec,
5851                                 const struct hda_fixup *fix, int action)
5852 {
5853         struct alc_spec *spec = codec->spec;
5854
5855         switch (action) {
5856         case HDA_FIXUP_ACT_PRE_PROBE:
5857                 spec->parse_flags |= HDA_PINCFG_HEADSET_MIC | HDA_PINCFG_HEADPHONE_MIC;
5858                 break;
5859         case HDA_FIXUP_ACT_PROBE:
5860                 alc_probe_headset_mode(codec);
5861                 break;
5862         case HDA_FIXUP_ACT_INIT:
5863                 if (is_s3_resume(codec) || is_s4_resume(codec)) {
5864                         spec->current_headset_mode = ALC_HEADSET_MODE_UNKNOWN;
5865                         spec->current_headset_type = ALC_HEADSET_TYPE_UNKNOWN;
5866                 }
5867                 alc_update_headset_mode(codec);
5868                 break;
5869         }
5870 }
5871
5872 static void alc_fixup_headset_mode_no_hp_mic(struct hda_codec *codec,
5873                                 const struct hda_fixup *fix, int action)
5874 {
5875         if (action == HDA_FIXUP_ACT_PRE_PROBE) {
5876                 struct alc_spec *spec = codec->spec;
5877                 spec->parse_flags |= HDA_PINCFG_HEADSET_MIC;
5878         }
5879         else
5880                 alc_fixup_headset_mode(codec, fix, action);
5881 }
5882
5883 static void alc255_set_default_jack_type(struct hda_codec *codec)
5884 {
5885         /* Set to iphone type */
5886         static const struct coef_fw alc255fw[] = {
5887                 WRITE_COEF(0x1b, 0x880b),
5888                 WRITE_COEF(0x45, 0xd089),
5889                 WRITE_COEF(0x1b, 0x080b),
5890                 WRITE_COEF(0x46, 0x0004),
5891                 WRITE_COEF(0x1b, 0x0c0b),
5892                 {}
5893         };
5894         static const struct coef_fw alc256fw[] = {
5895                 WRITE_COEF(0x1b, 0x884b),
5896                 WRITE_COEF(0x45, 0xd089),
5897                 WRITE_COEF(0x1b, 0x084b),
5898                 WRITE_COEF(0x46, 0x0004),
5899                 WRITE_COEF(0x1b, 0x0c4b),
5900                 {}
5901         };
5902         switch (codec->core.vendor_id) {
5903         case 0x10ec0255:
5904                 alc_process_coef_fw(codec, alc255fw);
5905                 break;
5906         case 0x10ec0230:
5907         case 0x10ec0236:
5908         case 0x10ec0256:
5909         case 0x19e58326:
5910                 alc_process_coef_fw(codec, alc256fw);
5911                 break;
5912         }
5913         msleep(30);
5914 }
5915
5916 static void alc_fixup_headset_mode_alc255(struct hda_codec *codec,
5917                                 const struct hda_fixup *fix, int action)
5918 {
5919         if (action == HDA_FIXUP_ACT_PRE_PROBE) {
5920                 alc255_set_default_jack_type(codec);
5921         }
5922         alc_fixup_headset_mode(codec, fix, action);
5923 }
5924
5925 static void alc_fixup_headset_mode_alc255_no_hp_mic(struct hda_codec *codec,
5926                                 const struct hda_fixup *fix, int action)
5927 {
5928         if (action == HDA_FIXUP_ACT_PRE_PROBE) {
5929                 struct alc_spec *spec = codec->spec;
5930                 spec->parse_flags |= HDA_PINCFG_HEADSET_MIC;
5931                 alc255_set_default_jack_type(codec);
5932         }
5933         else
5934                 alc_fixup_headset_mode(codec, fix, action);
5935 }
5936
5937 static void alc288_update_headset_jack_cb(struct hda_codec *codec,
5938                                        struct hda_jack_callback *jack)
5939 {
5940         struct alc_spec *spec = codec->spec;
5941
5942         alc_update_headset_jack_cb(codec, jack);
5943         /* Headset Mic enable or disable, only for Dell Dino */
5944         alc_update_gpio_data(codec, 0x40, spec->gen.hp_jack_present);
5945 }
5946
5947 static void alc_fixup_headset_mode_dell_alc288(struct hda_codec *codec,
5948                                 const struct hda_fixup *fix, int action)
5949 {
5950         alc_fixup_headset_mode(codec, fix, action);
5951         if (action == HDA_FIXUP_ACT_PROBE) {
5952                 struct alc_spec *spec = codec->spec;
5953                 /* toggled via hp_automute_hook */
5954                 spec->gpio_mask |= 0x40;
5955                 spec->gpio_dir |= 0x40;
5956                 spec->gen.hp_automute_hook = alc288_update_headset_jack_cb;
5957         }
5958 }
5959
5960 static void alc_fixup_auto_mute_via_amp(struct hda_codec *codec,
5961                                         const struct hda_fixup *fix, int action)
5962 {
5963         if (action == HDA_FIXUP_ACT_PRE_PROBE) {
5964                 struct alc_spec *spec = codec->spec;
5965                 spec->gen.auto_mute_via_amp = 1;
5966         }
5967 }
5968
5969 static void alc_fixup_no_shutup(struct hda_codec *codec,
5970                                 const struct hda_fixup *fix, int action)
5971 {
5972         if (action == HDA_FIXUP_ACT_PRE_PROBE) {
5973                 struct alc_spec *spec = codec->spec;
5974                 spec->no_shutup_pins = 1;
5975         }
5976 }
5977
5978 static void alc_fixup_disable_aamix(struct hda_codec *codec,
5979                                     const struct hda_fixup *fix, int action)
5980 {
5981         if (action == HDA_FIXUP_ACT_PRE_PROBE) {
5982                 struct alc_spec *spec = codec->spec;
5983                 /* Disable AA-loopback as it causes white noise */
5984                 spec->gen.mixer_nid = 0;
5985         }
5986 }
5987
5988 /* fixup for Thinkpad docks: add dock pins, avoid HP parser fixup */
5989 static void alc_fixup_tpt440_dock(struct hda_codec *codec,
5990                                   const struct hda_fixup *fix, int action)
5991 {
5992         static const struct hda_pintbl pincfgs[] = {
5993                 { 0x16, 0x21211010 }, /* dock headphone */
5994                 { 0x19, 0x21a11010 }, /* dock mic */
5995                 { }
5996         };
5997         struct alc_spec *spec = codec->spec;
5998
5999         if (action == HDA_FIXUP_ACT_PRE_PROBE) {
6000                 spec->parse_flags = HDA_PINCFG_NO_HP_FIXUP;
6001                 codec->power_save_node = 0; /* avoid click noises */
6002                 snd_hda_apply_pincfgs(codec, pincfgs);
6003         }
6004 }
6005
6006 static void alc_fixup_tpt470_dock(struct hda_codec *codec,
6007                                   const struct hda_fixup *fix, int action)
6008 {
6009         static const struct hda_pintbl pincfgs[] = {
6010                 { 0x17, 0x21211010 }, /* dock headphone */
6011                 { 0x19, 0x21a11010 }, /* dock mic */
6012                 { }
6013         };
6014         struct alc_spec *spec = codec->spec;
6015
6016         if (action == HDA_FIXUP_ACT_PRE_PROBE) {
6017                 spec->parse_flags = HDA_PINCFG_NO_HP_FIXUP;
6018                 snd_hda_apply_pincfgs(codec, pincfgs);
6019         } else if (action == HDA_FIXUP_ACT_INIT) {
6020                 /* Enable DOCK device */
6021                 snd_hda_codec_write(codec, 0x17, 0,
6022                             AC_VERB_SET_CONFIG_DEFAULT_BYTES_3, 0);
6023                 /* Enable DOCK device */
6024                 snd_hda_codec_write(codec, 0x19, 0,
6025                             AC_VERB_SET_CONFIG_DEFAULT_BYTES_3, 0);
6026         }
6027 }
6028
6029 static void alc_fixup_tpt470_dacs(struct hda_codec *codec,
6030                                   const struct hda_fixup *fix, int action)
6031 {
6032         /* Assure the speaker pin to be coupled with DAC NID 0x03; otherwise
6033          * the speaker output becomes too low by some reason on Thinkpads with
6034          * ALC298 codec
6035          */
6036         static const hda_nid_t preferred_pairs[] = {
6037                 0x14, 0x03, 0x17, 0x02, 0x21, 0x02,
6038                 0
6039         };
6040         struct alc_spec *spec = codec->spec;
6041
6042         if (action == HDA_FIXUP_ACT_PRE_PROBE)
6043                 spec->gen.preferred_dacs = preferred_pairs;
6044 }
6045
6046 static void alc295_fixup_asus_dacs(struct hda_codec *codec,
6047                                    const struct hda_fixup *fix, int action)
6048 {
6049         static const hda_nid_t preferred_pairs[] = {
6050                 0x17, 0x02, 0x21, 0x03, 0
6051         };
6052         struct alc_spec *spec = codec->spec;
6053
6054         if (action == HDA_FIXUP_ACT_PRE_PROBE)
6055                 spec->gen.preferred_dacs = preferred_pairs;
6056 }
6057
6058 static void alc_shutup_dell_xps13(struct hda_codec *codec)
6059 {
6060         struct alc_spec *spec = codec->spec;
6061         int hp_pin = alc_get_hp_pin(spec);
6062
6063         /* Prevent pop noises when headphones are plugged in */
6064         snd_hda_codec_write(codec, hp_pin, 0,
6065                             AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);
6066         msleep(20);
6067 }
6068
6069 static void alc_fixup_dell_xps13(struct hda_codec *codec,
6070                                 const struct hda_fixup *fix, int action)
6071 {
6072         struct alc_spec *spec = codec->spec;
6073         struct hda_input_mux *imux = &spec->gen.input_mux;
6074         int i;
6075
6076         switch (action) {
6077         case HDA_FIXUP_ACT_PRE_PROBE:
6078                 /* mic pin 0x19 must be initialized with Vref Hi-Z, otherwise
6079                  * it causes a click noise at start up
6080                  */
6081                 snd_hda_codec_set_pin_target(codec, 0x19, PIN_VREFHIZ);
6082                 spec->shutup = alc_shutup_dell_xps13;
6083                 break;
6084         case HDA_FIXUP_ACT_PROBE:
6085                 /* Make the internal mic the default input source. */
6086                 for (i = 0; i < imux->num_items; i++) {
6087                         if (spec->gen.imux_pins[i] == 0x12) {
6088                                 spec->gen.cur_mux[0] = i;
6089                                 break;
6090                         }
6091                 }
6092                 break;
6093         }
6094 }
6095
6096 static void alc_fixup_headset_mode_alc662(struct hda_codec *codec,
6097                                 const struct hda_fixup *fix, int action)
6098 {
6099         struct alc_spec *spec = codec->spec;
6100
6101         if (action == HDA_FIXUP_ACT_PRE_PROBE) {
6102                 spec->parse_flags |= HDA_PINCFG_HEADSET_MIC;
6103                 spec->gen.hp_mic = 1; /* Mic-in is same pin as headphone */
6104
6105                 /* Disable boost for mic-in permanently. (This code is only called
6106                    from quirks that guarantee that the headphone is at NID 0x1b.) */
6107                 snd_hda_codec_write(codec, 0x1b, 0, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000);
6108                 snd_hda_override_wcaps(codec, 0x1b, get_wcaps(codec, 0x1b) & ~AC_WCAP_IN_AMP);
6109         } else
6110                 alc_fixup_headset_mode(codec, fix, action);
6111 }
6112
6113 static void alc_fixup_headset_mode_alc668(struct hda_codec *codec,
6114                                 const struct hda_fixup *fix, int action)
6115 {
6116         if (action == HDA_FIXUP_ACT_PRE_PROBE) {
6117                 alc_write_coef_idx(codec, 0xc4, 0x8000);
6118                 alc_update_coef_idx(codec, 0xc2, ~0xfe, 0);
6119                 snd_hda_set_pin_ctl_cache(codec, 0x18, 0);
6120         }
6121         alc_fixup_headset_mode(codec, fix, action);
6122 }
6123
6124 /* Returns the nid of the external mic input pin, or 0 if it cannot be found. */
6125 static int find_ext_mic_pin(struct hda_codec *codec)
6126 {
6127         struct alc_spec *spec = codec->spec;
6128         struct auto_pin_cfg *cfg = &spec->gen.autocfg;
6129         hda_nid_t nid;
6130         unsigned int defcfg;
6131         int i;
6132
6133         for (i = 0; i < cfg->num_inputs; i++) {
6134                 if (cfg->inputs[i].type != AUTO_PIN_MIC)
6135                         continue;
6136                 nid = cfg->inputs[i].pin;
6137                 defcfg = snd_hda_codec_get_pincfg(codec, nid);
6138                 if (snd_hda_get_input_pin_attr(defcfg) == INPUT_PIN_ATTR_INT)
6139                         continue;
6140                 return nid;
6141         }
6142
6143         return 0;
6144 }
6145
6146 static void alc271_hp_gate_mic_jack(struct hda_codec *codec,
6147                                     const struct hda_fixup *fix,
6148                                     int action)
6149 {
6150         struct alc_spec *spec = codec->spec;
6151
6152         if (action == HDA_FIXUP_ACT_PROBE) {
6153                 int mic_pin = find_ext_mic_pin(codec);
6154                 int hp_pin = alc_get_hp_pin(spec);
6155
6156                 if (snd_BUG_ON(!mic_pin || !hp_pin))
6157                         return;
6158                 snd_hda_jack_set_gating_jack(codec, mic_pin, hp_pin);
6159         }
6160 }
6161
6162 static void alc269_fixup_limit_int_mic_boost(struct hda_codec *codec,
6163                                              const struct hda_fixup *fix,
6164                                              int action)
6165 {
6166         struct alc_spec *spec = codec->spec;
6167         struct auto_pin_cfg *cfg = &spec->gen.autocfg;
6168         int i;
6169
6170         /* The mic boosts on level 2 and 3 are too noisy
6171            on the internal mic input.
6172            Therefore limit the boost to 0 or 1. */
6173
6174         if (action != HDA_FIXUP_ACT_PROBE)
6175                 return;
6176
6177         for (i = 0; i < cfg->num_inputs; i++) {
6178                 hda_nid_t nid = cfg->inputs[i].pin;
6179                 unsigned int defcfg;
6180                 if (cfg->inputs[i].type != AUTO_PIN_MIC)
6181                         continue;
6182                 defcfg = snd_hda_codec_get_pincfg(codec, nid);
6183                 if (snd_hda_get_input_pin_attr(defcfg) != INPUT_PIN_ATTR_INT)
6184                         continue;
6185
6186                 snd_hda_override_amp_caps(codec, nid, HDA_INPUT,
6187                                           (0x00 << AC_AMPCAP_OFFSET_SHIFT) |
6188                                           (0x01 << AC_AMPCAP_NUM_STEPS_SHIFT) |
6189                                           (0x2f << AC_AMPCAP_STEP_SIZE_SHIFT) |
6190                                           (0 << AC_AMPCAP_MUTE_SHIFT));
6191         }
6192 }
6193
6194 static void alc283_hp_automute_hook(struct hda_codec *codec,
6195                                     struct hda_jack_callback *jack)
6196 {
6197         struct alc_spec *spec = codec->spec;
6198         int vref;
6199
6200         msleep(200);
6201         snd_hda_gen_hp_automute(codec, jack);
6202
6203         vref = spec->gen.hp_jack_present ? PIN_VREF80 : 0;
6204
6205         msleep(600);
6206         snd_hda_codec_write(codec, 0x19, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
6207                             vref);
6208 }
6209
6210 static void alc283_fixup_chromebook(struct hda_codec *codec,
6211                                     const struct hda_fixup *fix, int action)
6212 {
6213         struct alc_spec *spec = codec->spec;
6214
6215         switch (action) {
6216         case HDA_FIXUP_ACT_PRE_PROBE:
6217                 snd_hda_override_wcaps(codec, 0x03, 0);
6218                 /* Disable AA-loopback as it causes white noise */
6219                 spec->gen.mixer_nid = 0;
6220                 break;
6221         case HDA_FIXUP_ACT_INIT:
6222                 /* MIC2-VREF control */
6223                 /* Set to manual mode */
6224                 alc_update_coef_idx(codec, 0x06, 0x000c, 0);
6225                 /* Enable Line1 input control by verb */
6226                 alc_update_coef_idx(codec, 0x1a, 0, 1 << 4);
6227                 break;
6228         }
6229 }
6230
6231 static void alc283_fixup_sense_combo_jack(struct hda_codec *codec,
6232                                     const struct hda_fixup *fix, int action)
6233 {
6234         struct alc_spec *spec = codec->spec;
6235
6236         switch (action) {
6237         case HDA_FIXUP_ACT_PRE_PROBE:
6238                 spec->gen.hp_automute_hook = alc283_hp_automute_hook;
6239                 break;
6240         case HDA_FIXUP_ACT_INIT:
6241                 /* MIC2-VREF control */
6242                 /* Set to manual mode */
6243                 alc_update_coef_idx(codec, 0x06, 0x000c, 0);
6244                 break;
6245         }
6246 }
6247
6248 /* mute tablet speaker pin (0x14) via dock plugging in addition */
6249 static void asus_tx300_automute(struct hda_codec *codec)
6250 {
6251         struct alc_spec *spec = codec->spec;
6252         snd_hda_gen_update_outputs(codec);
6253         if (snd_hda_jack_detect(codec, 0x1b))
6254                 spec->gen.mute_bits |= (1ULL << 0x14);
6255 }
6256
6257 static void alc282_fixup_asus_tx300(struct hda_codec *codec,
6258                                     const struct hda_fixup *fix, int action)
6259 {
6260         struct alc_spec *spec = codec->spec;
6261         static const struct hda_pintbl dock_pins[] = {
6262                 { 0x1b, 0x21114000 }, /* dock speaker pin */
6263                 {}
6264         };
6265
6266         switch (action) {
6267         case HDA_FIXUP_ACT_PRE_PROBE:
6268                 spec->init_amp = ALC_INIT_DEFAULT;
6269                 /* TX300 needs to set up GPIO2 for the speaker amp */
6270                 alc_setup_gpio(codec, 0x04);
6271                 snd_hda_apply_pincfgs(codec, dock_pins);
6272                 spec->gen.auto_mute_via_amp = 1;
6273                 spec->gen.automute_hook = asus_tx300_automute;
6274                 snd_hda_jack_detect_enable_callback(codec, 0x1b,
6275                                                     snd_hda_gen_hp_automute);
6276                 break;
6277         case HDA_FIXUP_ACT_PROBE:
6278                 spec->init_amp = ALC_INIT_DEFAULT;
6279                 break;
6280         case HDA_FIXUP_ACT_BUILD:
6281                 /* this is a bit tricky; give more sane names for the main
6282                  * (tablet) speaker and the dock speaker, respectively
6283                  */
6284                 rename_ctl(codec, "Speaker Playback Switch",
6285                            "Dock Speaker Playback Switch");
6286                 rename_ctl(codec, "Bass Speaker Playback Switch",
6287                            "Speaker Playback Switch");
6288                 break;
6289         }
6290 }
6291
6292 static void alc290_fixup_mono_speakers(struct hda_codec *codec,
6293                                        const struct hda_fixup *fix, int action)
6294 {
6295         if (action == HDA_FIXUP_ACT_PRE_PROBE) {
6296                 /* DAC node 0x03 is giving mono output. We therefore want to
6297                    make sure 0x14 (front speaker) and 0x15 (headphones) use the
6298                    stereo DAC, while leaving 0x17 (bass speaker) for node 0x03. */
6299                 static const hda_nid_t conn1[] = { 0x0c };
6300                 snd_hda_override_conn_list(codec, 0x14, ARRAY_SIZE(conn1), conn1);
6301                 snd_hda_override_conn_list(codec, 0x15, ARRAY_SIZE(conn1), conn1);
6302         }
6303 }
6304
6305 static void alc298_fixup_speaker_volume(struct hda_codec *codec,
6306                                         const struct hda_fixup *fix, int action)
6307 {
6308         if (action == HDA_FIXUP_ACT_PRE_PROBE) {
6309                 /* The speaker is routed to the Node 0x06 by a mistake, as a result
6310                    we can't adjust the speaker's volume since this node does not has
6311                    Amp-out capability. we change the speaker's route to:
6312                    Node 0x02 (Audio Output) -> Node 0x0c (Audio Mixer) -> Node 0x17 (
6313                    Pin Complex), since Node 0x02 has Amp-out caps, we can adjust
6314                    speaker's volume now. */
6315
6316                 static const hda_nid_t conn1[] = { 0x0c };
6317                 snd_hda_override_conn_list(codec, 0x17, ARRAY_SIZE(conn1), conn1);
6318         }
6319 }
6320
6321 /* disable DAC3 (0x06) selection on NID 0x17 as it has no volume amp control */
6322 static void alc295_fixup_disable_dac3(struct hda_codec *codec,
6323                                       const struct hda_fixup *fix, int action)
6324 {
6325         if (action == HDA_FIXUP_ACT_PRE_PROBE) {
6326                 static const hda_nid_t conn[] = { 0x02, 0x03 };
6327                 snd_hda_override_conn_list(codec, 0x17, ARRAY_SIZE(conn), conn);
6328         }
6329 }
6330
6331 /* force NID 0x17 (Bass Speaker) to DAC1 to share it with the main speaker */
6332 static void alc285_fixup_speaker2_to_dac1(struct hda_codec *codec,
6333                                           const struct hda_fixup *fix, int action)
6334 {
6335         if (action == HDA_FIXUP_ACT_PRE_PROBE) {
6336                 static const hda_nid_t conn[] = { 0x02 };
6337                 snd_hda_override_conn_list(codec, 0x17, ARRAY_SIZE(conn), conn);
6338         }
6339 }
6340
6341 /* Hook to update amp GPIO4 for automute */
6342 static void alc280_hp_gpio4_automute_hook(struct hda_codec *codec,
6343                                           struct hda_jack_callback *jack)
6344 {
6345         struct alc_spec *spec = codec->spec;
6346
6347         snd_hda_gen_hp_automute(codec, jack);
6348         /* mute_led_polarity is set to 0, so we pass inverted value here */
6349         alc_update_gpio_led(codec, 0x10, spec->mute_led_polarity,
6350                             !spec->gen.hp_jack_present);
6351 }
6352
6353 /* Manage GPIOs for HP EliteBook Folio 9480m.
6354  *
6355  * GPIO4 is the headphone amplifier power control
6356  * GPIO3 is the audio output mute indicator LED
6357  */
6358
6359 static void alc280_fixup_hp_9480m(struct hda_codec *codec,
6360                                   const struct hda_fixup *fix,
6361                                   int action)
6362 {
6363         struct alc_spec *spec = codec->spec;
6364
6365         alc_fixup_hp_gpio_led(codec, action, 0x08, 0);
6366         if (action == HDA_FIXUP_ACT_PRE_PROBE) {
6367                 /* amp at GPIO4; toggled via alc280_hp_gpio4_automute_hook() */
6368                 spec->gpio_mask |= 0x10;
6369                 spec->gpio_dir |= 0x10;
6370                 spec->gen.hp_automute_hook = alc280_hp_gpio4_automute_hook;
6371         }
6372 }
6373
6374 static void alc275_fixup_gpio4_off(struct hda_codec *codec,
6375                                    const struct hda_fixup *fix,
6376                                    int action)
6377 {
6378         struct alc_spec *spec = codec->spec;
6379
6380         if (action == HDA_FIXUP_ACT_PRE_PROBE) {
6381                 spec->gpio_mask |= 0x04;
6382                 spec->gpio_dir |= 0x04;
6383                 /* set data bit low */
6384         }
6385 }
6386
6387 /* Quirk for Thinkpad X1 7th and 8th Gen
6388  * The following fixed routing needed
6389  * DAC1 (NID 0x02) -> Speaker (NID 0x14); some eq applied secretly
6390  * DAC2 (NID 0x03) -> Bass (NID 0x17) & Headphone (NID 0x21); sharing a DAC
6391  * DAC3 (NID 0x06) -> Unused, due to the lack of volume amp
6392  */
6393 static void alc285_fixup_thinkpad_x1_gen7(struct hda_codec *codec,
6394                                           const struct hda_fixup *fix, int action)
6395 {
6396         static const hda_nid_t conn[] = { 0x02, 0x03 }; /* exclude 0x06 */
6397         static const hda_nid_t preferred_pairs[] = {
6398                 0x14, 0x02, 0x17, 0x03, 0x21, 0x03, 0
6399         };
6400         struct alc_spec *spec = codec->spec;
6401
6402         switch (action) {
6403         case HDA_FIXUP_ACT_PRE_PROBE:
6404                 snd_hda_override_conn_list(codec, 0x17, ARRAY_SIZE(conn), conn);
6405                 spec->gen.preferred_dacs = preferred_pairs;
6406                 break;
6407         case HDA_FIXUP_ACT_BUILD:
6408                 /* The generic parser creates somewhat unintuitive volume ctls
6409                  * with the fixed routing above, and the shared DAC2 may be
6410                  * confusing for PA.
6411                  * Rename those to unique names so that PA doesn't touch them
6412                  * and use only Master volume.
6413                  */
6414                 rename_ctl(codec, "Front Playback Volume", "DAC1 Playback Volume");
6415                 rename_ctl(codec, "Bass Speaker Playback Volume", "DAC2 Playback Volume");
6416                 break;
6417         }
6418 }
6419
6420 static void alc233_alc662_fixup_lenovo_dual_codecs(struct hda_codec *codec,
6421                                          const struct hda_fixup *fix,
6422                                          int action)
6423 {
6424         alc_fixup_dual_codecs(codec, fix, action);
6425         switch (action) {
6426         case HDA_FIXUP_ACT_PRE_PROBE:
6427                 /* override card longname to provide a unique UCM profile */
6428                 strcpy(codec->card->longname, "HDAudio-Lenovo-DualCodecs");
6429                 break;
6430         case HDA_FIXUP_ACT_BUILD:
6431                 /* rename Capture controls depending on the codec */
6432                 rename_ctl(codec, "Capture Volume",
6433                            codec->addr == 0 ?
6434                            "Rear-Panel Capture Volume" :
6435                            "Front-Panel Capture Volume");
6436                 rename_ctl(codec, "Capture Switch",
6437                            codec->addr == 0 ?
6438                            "Rear-Panel Capture Switch" :
6439                            "Front-Panel Capture Switch");
6440                 break;
6441         }
6442 }
6443
6444 static void alc225_fixup_s3_pop_noise(struct hda_codec *codec,
6445                                       const struct hda_fixup *fix, int action)
6446 {
6447         if (action != HDA_FIXUP_ACT_PRE_PROBE)
6448                 return;
6449
6450         codec->power_save_node = 1;
6451 }
6452
6453 /* Forcibly assign NID 0x03 to HP/LO while NID 0x02 to SPK for EQ */
6454 static void alc274_fixup_bind_dacs(struct hda_codec *codec,
6455                                     const struct hda_fixup *fix, int action)
6456 {
6457         struct alc_spec *spec = codec->spec;
6458         static const hda_nid_t preferred_pairs[] = {
6459                 0x21, 0x03, 0x1b, 0x03, 0x16, 0x02,
6460                 0
6461         };
6462
6463         if (action != HDA_FIXUP_ACT_PRE_PROBE)
6464                 return;
6465
6466         spec->gen.preferred_dacs = preferred_pairs;
6467         spec->gen.auto_mute_via_amp = 1;
6468         codec->power_save_node = 0;
6469 }
6470
6471 /* avoid DAC 0x06 for bass speaker 0x17; it has no volume control */
6472 static void alc289_fixup_asus_ga401(struct hda_codec *codec,
6473                                     const struct hda_fixup *fix, int action)
6474 {
6475         static const hda_nid_t preferred_pairs[] = {
6476                 0x14, 0x02, 0x17, 0x02, 0x21, 0x03, 0
6477         };
6478         struct alc_spec *spec = codec->spec;
6479
6480         if (action == HDA_FIXUP_ACT_PRE_PROBE) {
6481                 spec->gen.preferred_dacs = preferred_pairs;
6482                 spec->gen.obey_preferred_dacs = 1;
6483         }
6484 }
6485
6486 /* The DAC of NID 0x3 will introduce click/pop noise on headphones, so invalidate it */
6487 static void alc285_fixup_invalidate_dacs(struct hda_codec *codec,
6488                               const struct hda_fixup *fix, int action)
6489 {
6490         if (action != HDA_FIXUP_ACT_PRE_PROBE)
6491                 return;
6492
6493         snd_hda_override_wcaps(codec, 0x03, 0);
6494 }
6495
6496 static void alc_combo_jack_hp_jd_restart(struct hda_codec *codec)
6497 {
6498         switch (codec->core.vendor_id) {
6499         case 0x10ec0274:
6500         case 0x10ec0294:
6501         case 0x10ec0225:
6502         case 0x10ec0295:
6503         case 0x10ec0299:
6504                 alc_update_coef_idx(codec, 0x4a, 0x8000, 1 << 15); /* Reset HP JD */
6505                 alc_update_coef_idx(codec, 0x4a, 0x8000, 0 << 15);
6506                 break;
6507         case 0x10ec0230:
6508         case 0x10ec0235:
6509         case 0x10ec0236:
6510         case 0x10ec0255:
6511         case 0x10ec0256:
6512         case 0x10ec0257:
6513         case 0x19e58326:
6514                 alc_update_coef_idx(codec, 0x1b, 0x8000, 1 << 15); /* Reset HP JD */
6515                 alc_update_coef_idx(codec, 0x1b, 0x8000, 0 << 15);
6516                 break;
6517         }
6518 }
6519
6520 static void alc295_fixup_chromebook(struct hda_codec *codec,
6521                                     const struct hda_fixup *fix, int action)
6522 {
6523         struct alc_spec *spec = codec->spec;
6524
6525         switch (action) {
6526         case HDA_FIXUP_ACT_PRE_PROBE:
6527                 spec->ultra_low_power = true;
6528                 break;
6529         case HDA_FIXUP_ACT_INIT:
6530                 alc_combo_jack_hp_jd_restart(codec);
6531                 break;
6532         }
6533 }
6534
6535 static void alc_fixup_disable_mic_vref(struct hda_codec *codec,
6536                                   const struct hda_fixup *fix, int action)
6537 {
6538         if (action == HDA_FIXUP_ACT_PRE_PROBE)
6539                 snd_hda_codec_set_pin_target(codec, 0x19, PIN_VREFHIZ);
6540 }
6541
6542
6543 static void alc294_gx502_toggle_output(struct hda_codec *codec,
6544                                         struct hda_jack_callback *cb)
6545 {
6546         /* The Windows driver sets the codec up in a very different way where
6547          * it appears to leave 0x10 = 0x8a20 set. For Linux we need to toggle it
6548          */
6549         if (snd_hda_jack_detect_state(codec, 0x21) == HDA_JACK_PRESENT)
6550                 alc_write_coef_idx(codec, 0x10, 0x8a20);
6551         else
6552                 alc_write_coef_idx(codec, 0x10, 0x0a20);
6553 }
6554
6555 static void alc294_fixup_gx502_hp(struct hda_codec *codec,
6556                                         const struct hda_fixup *fix, int action)
6557 {
6558         /* Pin 0x21: headphones/headset mic */
6559         if (!is_jack_detectable(codec, 0x21))
6560                 return;
6561
6562         switch (action) {
6563         case HDA_FIXUP_ACT_PRE_PROBE:
6564                 snd_hda_jack_detect_enable_callback(codec, 0x21,
6565                                 alc294_gx502_toggle_output);
6566                 break;
6567         case HDA_FIXUP_ACT_INIT:
6568                 /* Make sure to start in a correct state, i.e. if
6569                  * headphones have been plugged in before powering up the system
6570                  */
6571                 alc294_gx502_toggle_output(codec, NULL);
6572                 break;
6573         }
6574 }
6575
6576 static void alc294_gu502_toggle_output(struct hda_codec *codec,
6577                                        struct hda_jack_callback *cb)
6578 {
6579         /* Windows sets 0x10 to 0x8420 for Node 0x20 which is
6580          * responsible from changes between speakers and headphones
6581          */
6582         if (snd_hda_jack_detect_state(codec, 0x21) == HDA_JACK_PRESENT)
6583                 alc_write_coef_idx(codec, 0x10, 0x8420);
6584         else
6585                 alc_write_coef_idx(codec, 0x10, 0x0a20);
6586 }
6587
6588 static void alc294_fixup_gu502_hp(struct hda_codec *codec,
6589                                   const struct hda_fixup *fix, int action)
6590 {
6591         if (!is_jack_detectable(codec, 0x21))
6592                 return;
6593
6594         switch (action) {
6595         case HDA_FIXUP_ACT_PRE_PROBE:
6596                 snd_hda_jack_detect_enable_callback(codec, 0x21,
6597                                 alc294_gu502_toggle_output);
6598                 break;
6599         case HDA_FIXUP_ACT_INIT:
6600                 alc294_gu502_toggle_output(codec, NULL);
6601                 break;
6602         }
6603 }
6604
6605 static void  alc285_fixup_hp_gpio_amp_init(struct hda_codec *codec,
6606                               const struct hda_fixup *fix, int action)
6607 {
6608         if (action != HDA_FIXUP_ACT_INIT)
6609                 return;
6610
6611         msleep(100);
6612         alc_write_coef_idx(codec, 0x65, 0x0);
6613 }
6614
6615 static void alc274_fixup_hp_headset_mic(struct hda_codec *codec,
6616                                     const struct hda_fixup *fix, int action)
6617 {
6618         switch (action) {
6619         case HDA_FIXUP_ACT_INIT:
6620                 alc_combo_jack_hp_jd_restart(codec);
6621                 break;
6622         }
6623 }
6624
6625 static void alc_fixup_no_int_mic(struct hda_codec *codec,
6626                                     const struct hda_fixup *fix, int action)
6627 {
6628         struct alc_spec *spec = codec->spec;
6629
6630         switch (action) {
6631         case HDA_FIXUP_ACT_PRE_PROBE:
6632                 /* Mic RING SLEEVE swap for combo jack */
6633                 alc_update_coef_idx(codec, 0x45, 0xf<<12 | 1<<10, 5<<12);
6634                 spec->no_internal_mic_pin = true;
6635                 break;
6636         case HDA_FIXUP_ACT_INIT:
6637                 alc_combo_jack_hp_jd_restart(codec);
6638                 break;
6639         }
6640 }
6641
6642 /* GPIO1 = amplifier on/off
6643  * GPIO3 = mic mute LED
6644  */
6645 static void alc285_fixup_hp_spectre_x360_eb1(struct hda_codec *codec,
6646                                           const struct hda_fixup *fix, int action)
6647 {
6648         static const hda_nid_t conn[] = { 0x02 };
6649
6650         struct alc_spec *spec = codec->spec;
6651         static const struct hda_pintbl pincfgs[] = {
6652                 { 0x14, 0x90170110 },  /* front/high speakers */
6653                 { 0x17, 0x90170130 },  /* back/bass speakers */
6654                 { }
6655         };
6656
6657         //enable micmute led
6658         alc_fixup_hp_gpio_led(codec, action, 0x00, 0x04);
6659
6660         switch (action) {
6661         case HDA_FIXUP_ACT_PRE_PROBE:
6662                 spec->micmute_led_polarity = 1;
6663                 /* needed for amp of back speakers */
6664                 spec->gpio_mask |= 0x01;
6665                 spec->gpio_dir |= 0x01;
6666                 snd_hda_apply_pincfgs(codec, pincfgs);
6667                 /* share DAC to have unified volume control */
6668                 snd_hda_override_conn_list(codec, 0x14, ARRAY_SIZE(conn), conn);
6669                 snd_hda_override_conn_list(codec, 0x17, ARRAY_SIZE(conn), conn);
6670                 break;
6671         case HDA_FIXUP_ACT_INIT:
6672                 /* need to toggle GPIO to enable the amp of back speakers */
6673                 alc_update_gpio_data(codec, 0x01, true);
6674                 msleep(100);
6675                 alc_update_gpio_data(codec, 0x01, false);
6676                 break;
6677         }
6678 }
6679
6680 static void alc285_fixup_hp_spectre_x360(struct hda_codec *codec,
6681                                           const struct hda_fixup *fix, int action)
6682 {
6683         static const hda_nid_t conn[] = { 0x02 };
6684         static const struct hda_pintbl pincfgs[] = {
6685                 { 0x14, 0x90170110 },  /* rear speaker */
6686                 { }
6687         };
6688
6689         switch (action) {
6690         case HDA_FIXUP_ACT_PRE_PROBE:
6691                 snd_hda_apply_pincfgs(codec, pincfgs);
6692                 /* force front speaker to DAC1 */
6693                 snd_hda_override_conn_list(codec, 0x17, ARRAY_SIZE(conn), conn);
6694                 break;
6695         }
6696 }
6697
6698 static void alc285_fixup_hp_envy_x360(struct hda_codec *codec,
6699                                       const struct hda_fixup *fix,
6700                                       int action)
6701 {
6702         static const struct coef_fw coefs[] = {
6703                 WRITE_COEF(0x08, 0x6a0c), WRITE_COEF(0x0d, 0xa023),
6704                 WRITE_COEF(0x10, 0x0320), WRITE_COEF(0x1a, 0x8c03),
6705                 WRITE_COEF(0x25, 0x1800), WRITE_COEF(0x26, 0x003a),
6706                 WRITE_COEF(0x28, 0x1dfe), WRITE_COEF(0x29, 0xb014),
6707                 WRITE_COEF(0x2b, 0x1dfe), WRITE_COEF(0x37, 0xfe15),
6708                 WRITE_COEF(0x38, 0x7909), WRITE_COEF(0x45, 0xd489),
6709                 WRITE_COEF(0x46, 0x00f4), WRITE_COEF(0x4a, 0x21e0),
6710                 WRITE_COEF(0x66, 0x03f0), WRITE_COEF(0x67, 0x1000),
6711                 WRITE_COEF(0x6e, 0x1005), { }
6712         };
6713
6714         static const struct hda_pintbl pincfgs[] = {
6715                 { 0x12, 0xb7a60130 },  /* Internal microphone*/
6716                 { 0x14, 0x90170150 },  /* B&O soundbar speakers */
6717                 { 0x17, 0x90170153 },  /* Side speakers */
6718                 { 0x19, 0x03a11040 },  /* Headset microphone */
6719                 { }
6720         };
6721
6722         switch (action) {
6723         case HDA_FIXUP_ACT_PRE_PROBE:
6724                 snd_hda_apply_pincfgs(codec, pincfgs);
6725
6726                 /* Fixes volume control problem for side speakers */
6727                 alc295_fixup_disable_dac3(codec, fix, action);
6728
6729                 /* Fixes no sound from headset speaker */
6730                 snd_hda_codec_amp_stereo(codec, 0x21, HDA_OUTPUT, 0, -1, 0);
6731
6732                 /* Auto-enable headset mic when plugged */
6733                 snd_hda_jack_set_gating_jack(codec, 0x19, 0x21);
6734
6735                 /* Headset mic volume enhancement */
6736                 snd_hda_codec_set_pin_target(codec, 0x19, PIN_VREF50);
6737                 break;
6738         case HDA_FIXUP_ACT_INIT:
6739                 alc_process_coef_fw(codec, coefs);
6740                 break;
6741         case HDA_FIXUP_ACT_BUILD:
6742                 rename_ctl(codec, "Bass Speaker Playback Volume",
6743                            "B&O-Tuned Playback Volume");
6744                 rename_ctl(codec, "Front Playback Switch",
6745                            "B&O Soundbar Playback Switch");
6746                 rename_ctl(codec, "Bass Speaker Playback Switch",
6747                            "Side Speaker Playback Switch");
6748                 break;
6749         }
6750 }
6751
6752 /* for hda_fixup_thinkpad_acpi() */
6753 #include "thinkpad_helper.c"
6754
6755 static void alc_fixup_thinkpad_acpi(struct hda_codec *codec,
6756                                     const struct hda_fixup *fix, int action)
6757 {
6758         alc_fixup_no_shutup(codec, fix, action); /* reduce click noise */
6759         hda_fixup_thinkpad_acpi(codec, fix, action);
6760 }
6761
6762 /* Fixup for Lenovo Legion 15IMHg05 speaker output on headset removal. */
6763 static void alc287_fixup_legion_15imhg05_speakers(struct hda_codec *codec,
6764                                                   const struct hda_fixup *fix,
6765                                                   int action)
6766 {
6767         struct alc_spec *spec = codec->spec;
6768
6769         switch (action) {
6770         case HDA_FIXUP_ACT_PRE_PROBE:
6771                 spec->gen.suppress_auto_mute = 1;
6772                 break;
6773         }
6774 }
6775
6776 static void comp_acpi_device_notify(acpi_handle handle, u32 event, void *data)
6777 {
6778         struct hda_codec *cdc = data;
6779         struct alc_spec *spec = cdc->spec;
6780
6781         codec_info(cdc, "ACPI Notification %d\n", event);
6782
6783         hda_component_acpi_device_notify(spec->comps, ARRAY_SIZE(spec->comps),
6784                                          handle, event, data);
6785 }
6786
6787 static int comp_bind(struct device *dev)
6788 {
6789         struct hda_codec *cdc = dev_to_hda_codec(dev);
6790         struct alc_spec *spec = cdc->spec;
6791         int ret;
6792
6793         ret = hda_component_manager_bind(cdc, spec->comps);
6794         if (ret)
6795                 return ret;
6796
6797         return hda_component_manager_bind_acpi_notifications(cdc,
6798                                                              spec->comps, ARRAY_SIZE(spec->comps),
6799                                                              comp_acpi_device_notify, cdc);
6800 }
6801
6802 static void comp_unbind(struct device *dev)
6803 {
6804         struct hda_codec *cdc = dev_to_hda_codec(dev);
6805         struct alc_spec *spec = cdc->spec;
6806
6807         hda_component_manager_unbind_acpi_notifications(cdc, spec->comps, comp_acpi_device_notify);
6808         hda_component_manager_unbind(cdc, spec->comps);
6809 }
6810
6811 static const struct component_master_ops comp_master_ops = {
6812         .bind = comp_bind,
6813         .unbind = comp_unbind,
6814 };
6815
6816 static void comp_generic_playback_hook(struct hda_pcm_stream *hinfo, struct hda_codec *cdc,
6817                                        struct snd_pcm_substream *sub, int action)
6818 {
6819         struct alc_spec *spec = cdc->spec;
6820
6821         hda_component_manager_playback_hook(spec->comps, ARRAY_SIZE(spec->comps), action);
6822 }
6823
6824 static void comp_generic_fixup(struct hda_codec *cdc, int action, const char *bus,
6825                                const char *hid, const char *match_str, int count)
6826 {
6827         struct alc_spec *spec = cdc->spec;
6828         int ret;
6829
6830         switch (action) {
6831         case HDA_FIXUP_ACT_PRE_PROBE:
6832                 ret = hda_component_manager_init(cdc, spec->comps, count, bus, hid,
6833                                                  match_str, &comp_master_ops);
6834                 if (ret)
6835                         return;
6836
6837                 spec->gen.pcm_playback_hook = comp_generic_playback_hook;
6838                 break;
6839         case HDA_FIXUP_ACT_FREE:
6840                 hda_component_manager_free(cdc, &comp_master_ops);
6841                 break;
6842         }
6843 }
6844
6845 static void cs35l41_fixup_i2c_two(struct hda_codec *cdc, const struct hda_fixup *fix, int action)
6846 {
6847         comp_generic_fixup(cdc, action, "i2c", "CSC3551", "-%s:00-cs35l41-hda.%d", 2);
6848 }
6849
6850 static void cs35l41_fixup_i2c_four(struct hda_codec *cdc, const struct hda_fixup *fix, int action)
6851 {
6852         comp_generic_fixup(cdc, action, "i2c", "CSC3551", "-%s:00-cs35l41-hda.%d", 4);
6853 }
6854
6855 static void cs35l41_fixup_spi_two(struct hda_codec *codec, const struct hda_fixup *fix, int action)
6856 {
6857         comp_generic_fixup(codec, action, "spi", "CSC3551", "-%s:00-cs35l41-hda.%d", 2);
6858 }
6859
6860 static void cs35l41_fixup_spi_four(struct hda_codec *codec, const struct hda_fixup *fix, int action)
6861 {
6862         comp_generic_fixup(codec, action, "spi", "CSC3551", "-%s:00-cs35l41-hda.%d", 4);
6863 }
6864
6865 static void alc287_fixup_legion_16achg6_speakers(struct hda_codec *cdc, const struct hda_fixup *fix,
6866                                                  int action)
6867 {
6868         comp_generic_fixup(cdc, action, "i2c", "CLSA0100", "-%s:00-cs35l41-hda.%d", 2);
6869 }
6870
6871 static void alc287_fixup_legion_16ithg6_speakers(struct hda_codec *cdc, const struct hda_fixup *fix,
6872                                                  int action)
6873 {
6874         comp_generic_fixup(cdc, action, "i2c", "CLSA0101", "-%s:00-cs35l41-hda.%d", 2);
6875 }
6876
6877 static void cs35l56_fixup_spi_four(struct hda_codec *cdc, const struct hda_fixup *fix, int action)
6878 {
6879         comp_generic_fixup(cdc, action, "spi", "CSC3556", "-%s:00-cs35l56-hda.%d", 4);
6880 }
6881
6882 static void tas2781_fixup_i2c(struct hda_codec *cdc,
6883         const struct hda_fixup *fix, int action)
6884 {
6885         comp_generic_fixup(cdc, action, "i2c", "TIAS2781", "-%s:00", 1);
6886 }
6887
6888 static void yoga7_14arb7_fixup_i2c(struct hda_codec *cdc,
6889         const struct hda_fixup *fix, int action)
6890 {
6891         comp_generic_fixup(cdc, action, "i2c", "INT8866", "-%s:00", 1);
6892 }
6893
6894 /* for alc295_fixup_hp_top_speakers */
6895 #include "hp_x360_helper.c"
6896
6897 /* for alc285_fixup_ideapad_s740_coef() */
6898 #include "ideapad_s740_helper.c"
6899
6900 static const struct coef_fw alc256_fixup_set_coef_defaults_coefs[] = {
6901         WRITE_COEF(0x10, 0x0020), WRITE_COEF(0x24, 0x0000),
6902         WRITE_COEF(0x26, 0x0000), WRITE_COEF(0x29, 0x3000),
6903         WRITE_COEF(0x37, 0xfe05), WRITE_COEF(0x45, 0x5089),
6904         {}
6905 };
6906
6907 static void alc256_fixup_set_coef_defaults(struct hda_codec *codec,
6908                                            const struct hda_fixup *fix,
6909                                            int action)
6910 {
6911         /*
6912          * A certain other OS sets these coeffs to different values. On at least
6913          * one TongFang barebone these settings might survive even a cold
6914          * reboot. So to restore a clean slate the values are explicitly reset
6915          * to default here. Without this, the external microphone is always in a
6916          * plugged-in state, while the internal microphone is always in an
6917          * unplugged state, breaking the ability to use the internal microphone.
6918          */
6919         alc_process_coef_fw(codec, alc256_fixup_set_coef_defaults_coefs);
6920 }
6921
6922 static const struct coef_fw alc233_fixup_no_audio_jack_coefs[] = {
6923         WRITE_COEF(0x1a, 0x9003), WRITE_COEF(0x1b, 0x0e2b), WRITE_COEF(0x37, 0xfe06),
6924         WRITE_COEF(0x38, 0x4981), WRITE_COEF(0x45, 0xd489), WRITE_COEF(0x46, 0x0074),
6925         WRITE_COEF(0x49, 0x0149),
6926         {}
6927 };
6928
6929 static void alc233_fixup_no_audio_jack(struct hda_codec *codec,
6930                                        const struct hda_fixup *fix,
6931                                        int action)
6932 {
6933         /*
6934          * The audio jack input and output is not detected on the ASRock NUC Box
6935          * 1100 series when cold booting without this fix. Warm rebooting from a
6936          * certain other OS makes the audio functional, as COEF settings are
6937          * preserved in this case. This fix sets these altered COEF values as
6938          * the default.
6939          */
6940         alc_process_coef_fw(codec, alc233_fixup_no_audio_jack_coefs);
6941 }
6942
6943 static void alc256_fixup_mic_no_presence_and_resume(struct hda_codec *codec,
6944                                                     const struct hda_fixup *fix,
6945                                                     int action)
6946 {
6947         /*
6948          * The Clevo NJ51CU comes either with the ALC293 or the ALC256 codec,
6949          * but uses the 0x8686 subproduct id in both cases. The ALC256 codec
6950          * needs an additional quirk for sound working after suspend and resume.
6951          */
6952         if (codec->core.vendor_id == 0x10ec0256) {
6953                 alc_update_coef_idx(codec, 0x10, 1<<9, 0);
6954                 snd_hda_codec_set_pincfg(codec, 0x19, 0x04a11120);
6955         } else {
6956                 snd_hda_codec_set_pincfg(codec, 0x1a, 0x04a1113c);
6957         }
6958 }
6959
6960 static void alc_fixup_dell4_mic_no_presence_quiet(struct hda_codec *codec,
6961                                                   const struct hda_fixup *fix,
6962                                                   int action)
6963 {
6964         struct alc_spec *spec = codec->spec;
6965         struct hda_input_mux *imux = &spec->gen.input_mux;
6966         int i;
6967
6968         alc269_fixup_limit_int_mic_boost(codec, fix, action);
6969
6970         switch (action) {
6971         case HDA_FIXUP_ACT_PRE_PROBE:
6972                 /**
6973                  * Set the vref of pin 0x19 (Headset Mic) and pin 0x1b (Headphone Mic)
6974                  * to Hi-Z to avoid pop noises at startup and when plugging and
6975                  * unplugging headphones.
6976                  */
6977                 snd_hda_codec_set_pin_target(codec, 0x19, PIN_VREFHIZ);
6978                 snd_hda_codec_set_pin_target(codec, 0x1b, PIN_VREFHIZ);
6979                 break;
6980         case HDA_FIXUP_ACT_PROBE:
6981                 /**
6982                  * Make the internal mic (0x12) the default input source to
6983                  * prevent pop noises on cold boot.
6984                  */
6985                 for (i = 0; i < imux->num_items; i++) {
6986                         if (spec->gen.imux_pins[i] == 0x12) {
6987                                 spec->gen.cur_mux[0] = i;
6988                                 break;
6989                         }
6990                 }
6991                 break;
6992         }
6993 }
6994
6995 static void alc287_fixup_yoga9_14iap7_bass_spk_pin(struct hda_codec *codec,
6996                                           const struct hda_fixup *fix, int action)
6997 {
6998         /*
6999          * The Pin Complex 0x17 for the bass speakers is wrongly reported as
7000          * unconnected.
7001          */
7002         static const struct hda_pintbl pincfgs[] = {
7003                 { 0x17, 0x90170121 },
7004                 { }
7005         };
7006         /*
7007          * Avoid DAC 0x06 and 0x08, as they have no volume controls.
7008          * DAC 0x02 and 0x03 would be fine.
7009          */
7010         static const hda_nid_t conn[] = { 0x02, 0x03 };
7011         /*
7012          * Prefer both speakerbar (0x14) and bass speakers (0x17) connected to DAC 0x02.
7013          * Headphones (0x21) are connected to DAC 0x03.
7014          */
7015         static const hda_nid_t preferred_pairs[] = {
7016                 0x14, 0x02,
7017                 0x17, 0x02,
7018                 0x21, 0x03,
7019                 0
7020         };
7021         struct alc_spec *spec = codec->spec;
7022
7023         switch (action) {
7024         case HDA_FIXUP_ACT_PRE_PROBE:
7025                 snd_hda_apply_pincfgs(codec, pincfgs);
7026                 snd_hda_override_conn_list(codec, 0x17, ARRAY_SIZE(conn), conn);
7027                 spec->gen.preferred_dacs = preferred_pairs;
7028                 break;
7029         }
7030 }
7031
7032 static void alc295_fixup_dell_inspiron_top_speakers(struct hda_codec *codec,
7033                                           const struct hda_fixup *fix, int action)
7034 {
7035         static const struct hda_pintbl pincfgs[] = {
7036                 { 0x14, 0x90170151 },
7037                 { 0x17, 0x90170150 },
7038                 { }
7039         };
7040         static const hda_nid_t conn[] = { 0x02, 0x03 };
7041         static const hda_nid_t preferred_pairs[] = {
7042                 0x14, 0x02,
7043                 0x17, 0x03,
7044                 0x21, 0x02,
7045                 0
7046         };
7047         struct alc_spec *spec = codec->spec;
7048
7049         alc_fixup_no_shutup(codec, fix, action);
7050
7051         switch (action) {
7052         case HDA_FIXUP_ACT_PRE_PROBE:
7053                 snd_hda_apply_pincfgs(codec, pincfgs);
7054                 snd_hda_override_conn_list(codec, 0x17, ARRAY_SIZE(conn), conn);
7055                 spec->gen.preferred_dacs = preferred_pairs;
7056                 break;
7057         }
7058 }
7059
7060 /* Forcibly assign NID 0x03 to HP while NID 0x02 to SPK */
7061 static void alc287_fixup_bind_dacs(struct hda_codec *codec,
7062                                     const struct hda_fixup *fix, int action)
7063 {
7064         struct alc_spec *spec = codec->spec;
7065         static const hda_nid_t conn[] = { 0x02, 0x03 }; /* exclude 0x06 */
7066         static const hda_nid_t preferred_pairs[] = {
7067                 0x17, 0x02, 0x21, 0x03, 0
7068         };
7069
7070         if (action != HDA_FIXUP_ACT_PRE_PROBE)
7071                 return;
7072
7073         snd_hda_override_conn_list(codec, 0x17, ARRAY_SIZE(conn), conn);
7074         spec->gen.preferred_dacs = preferred_pairs;
7075         spec->gen.auto_mute_via_amp = 1;
7076         if (spec->gen.autocfg.speaker_pins[0] != 0x14) {
7077                 snd_hda_codec_write_cache(codec, 0x14, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
7078                                         0x0); /* Make sure 0x14 was disable */
7079         }
7080 }
7081 /* Fix none verb table of Headset Mic pin */
7082 static void alc_fixup_headset_mic(struct hda_codec *codec,
7083                                    const struct hda_fixup *fix, int action)
7084 {
7085         struct alc_spec *spec = codec->spec;
7086         static const struct hda_pintbl pincfgs[] = {
7087                 { 0x19, 0x03a1103c },
7088                 { }
7089         };
7090
7091         switch (action) {
7092         case HDA_FIXUP_ACT_PRE_PROBE:
7093                 snd_hda_apply_pincfgs(codec, pincfgs);
7094                 alc_update_coef_idx(codec, 0x45, 0xf<<12 | 1<<10, 5<<12);
7095                 spec->parse_flags |= HDA_PINCFG_HEADSET_MIC;
7096                 break;
7097         }
7098 }
7099
7100
7101 enum {
7102         ALC269_FIXUP_GPIO2,
7103         ALC269_FIXUP_SONY_VAIO,
7104         ALC275_FIXUP_SONY_VAIO_GPIO2,
7105         ALC269_FIXUP_DELL_M101Z,
7106         ALC269_FIXUP_SKU_IGNORE,
7107         ALC269_FIXUP_ASUS_G73JW,
7108         ALC269_FIXUP_ASUS_N7601ZM_PINS,
7109         ALC269_FIXUP_ASUS_N7601ZM,
7110         ALC269_FIXUP_LENOVO_EAPD,
7111         ALC275_FIXUP_SONY_HWEQ,
7112         ALC275_FIXUP_SONY_DISABLE_AAMIX,
7113         ALC271_FIXUP_DMIC,
7114         ALC269_FIXUP_PCM_44K,
7115         ALC269_FIXUP_STEREO_DMIC,
7116         ALC269_FIXUP_HEADSET_MIC,
7117         ALC269_FIXUP_QUANTA_MUTE,
7118         ALC269_FIXUP_LIFEBOOK,
7119         ALC269_FIXUP_LIFEBOOK_EXTMIC,
7120         ALC269_FIXUP_LIFEBOOK_HP_PIN,
7121         ALC269_FIXUP_LIFEBOOK_NO_HP_TO_LINEOUT,
7122         ALC255_FIXUP_LIFEBOOK_U7x7_HEADSET_MIC,
7123         ALC269_FIXUP_AMIC,
7124         ALC269_FIXUP_DMIC,
7125         ALC269VB_FIXUP_AMIC,
7126         ALC269VB_FIXUP_DMIC,
7127         ALC269_FIXUP_HP_MUTE_LED,
7128         ALC269_FIXUP_HP_MUTE_LED_MIC1,
7129         ALC269_FIXUP_HP_MUTE_LED_MIC2,
7130         ALC269_FIXUP_HP_MUTE_LED_MIC3,
7131         ALC269_FIXUP_HP_GPIO_LED,
7132         ALC269_FIXUP_HP_GPIO_MIC1_LED,
7133         ALC269_FIXUP_HP_LINE1_MIC1_LED,
7134         ALC269_FIXUP_INV_DMIC,
7135         ALC269_FIXUP_LENOVO_DOCK,
7136         ALC269_FIXUP_LENOVO_DOCK_LIMIT_BOOST,
7137         ALC269_FIXUP_NO_SHUTUP,
7138         ALC286_FIXUP_SONY_MIC_NO_PRESENCE,
7139         ALC269_FIXUP_PINCFG_NO_HP_TO_LINEOUT,
7140         ALC269_FIXUP_DELL1_MIC_NO_PRESENCE,
7141         ALC269_FIXUP_DELL2_MIC_NO_PRESENCE,
7142         ALC269_FIXUP_DELL3_MIC_NO_PRESENCE,
7143         ALC269_FIXUP_DELL4_MIC_NO_PRESENCE,
7144         ALC269_FIXUP_DELL4_MIC_NO_PRESENCE_QUIET,
7145         ALC269_FIXUP_HEADSET_MODE,
7146         ALC269_FIXUP_HEADSET_MODE_NO_HP_MIC,
7147         ALC269_FIXUP_ASPIRE_HEADSET_MIC,
7148         ALC269_FIXUP_ASUS_X101_FUNC,
7149         ALC269_FIXUP_ASUS_X101_VERB,
7150         ALC269_FIXUP_ASUS_X101,
7151         ALC271_FIXUP_AMIC_MIC2,
7152         ALC271_FIXUP_HP_GATE_MIC_JACK,
7153         ALC271_FIXUP_HP_GATE_MIC_JACK_E1_572,
7154         ALC269_FIXUP_ACER_AC700,
7155         ALC269_FIXUP_LIMIT_INT_MIC_BOOST,
7156         ALC269VB_FIXUP_ASUS_ZENBOOK,
7157         ALC269VB_FIXUP_ASUS_ZENBOOK_UX31A,
7158         ALC269VB_FIXUP_ASUS_MIC_NO_PRESENCE,
7159         ALC269_FIXUP_LIMIT_INT_MIC_BOOST_MUTE_LED,
7160         ALC269VB_FIXUP_ORDISSIMO_EVE2,
7161         ALC283_FIXUP_CHROME_BOOK,
7162         ALC283_FIXUP_SENSE_COMBO_JACK,
7163         ALC282_FIXUP_ASUS_TX300,
7164         ALC283_FIXUP_INT_MIC,
7165         ALC290_FIXUP_MONO_SPEAKERS,
7166         ALC290_FIXUP_MONO_SPEAKERS_HSJACK,
7167         ALC290_FIXUP_SUBWOOFER,
7168         ALC290_FIXUP_SUBWOOFER_HSJACK,
7169         ALC269_FIXUP_THINKPAD_ACPI,
7170         ALC269_FIXUP_DMIC_THINKPAD_ACPI,
7171         ALC269VB_FIXUP_CHUWI_COREBOOK_XPRO,
7172         ALC255_FIXUP_ACER_MIC_NO_PRESENCE,
7173         ALC255_FIXUP_ASUS_MIC_NO_PRESENCE,
7174         ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
7175         ALC255_FIXUP_DELL2_MIC_NO_PRESENCE,
7176         ALC255_FIXUP_HEADSET_MODE,
7177         ALC255_FIXUP_HEADSET_MODE_NO_HP_MIC,
7178         ALC293_FIXUP_DELL1_MIC_NO_PRESENCE,
7179         ALC292_FIXUP_TPT440_DOCK,
7180         ALC292_FIXUP_TPT440,
7181         ALC283_FIXUP_HEADSET_MIC,
7182         ALC255_FIXUP_MIC_MUTE_LED,
7183         ALC282_FIXUP_ASPIRE_V5_PINS,
7184         ALC269VB_FIXUP_ASPIRE_E1_COEF,
7185         ALC280_FIXUP_HP_GPIO4,
7186         ALC286_FIXUP_HP_GPIO_LED,
7187         ALC280_FIXUP_HP_GPIO2_MIC_HOTKEY,
7188         ALC280_FIXUP_HP_DOCK_PINS,
7189         ALC269_FIXUP_HP_DOCK_GPIO_MIC1_LED,
7190         ALC280_FIXUP_HP_9480M,
7191         ALC245_FIXUP_HP_X360_AMP,
7192         ALC285_FIXUP_HP_SPECTRE_X360_EB1,
7193         ALC285_FIXUP_HP_ENVY_X360,
7194         ALC288_FIXUP_DELL_HEADSET_MODE,
7195         ALC288_FIXUP_DELL1_MIC_NO_PRESENCE,
7196         ALC288_FIXUP_DELL_XPS_13,
7197         ALC288_FIXUP_DISABLE_AAMIX,
7198         ALC292_FIXUP_DELL_E7X_AAMIX,
7199         ALC292_FIXUP_DELL_E7X,
7200         ALC292_FIXUP_DISABLE_AAMIX,
7201         ALC293_FIXUP_DISABLE_AAMIX_MULTIJACK,
7202         ALC298_FIXUP_ALIENWARE_MIC_NO_PRESENCE,
7203         ALC298_FIXUP_DELL1_MIC_NO_PRESENCE,
7204         ALC298_FIXUP_DELL_AIO_MIC_NO_PRESENCE,
7205         ALC275_FIXUP_DELL_XPS,
7206         ALC293_FIXUP_LENOVO_SPK_NOISE,
7207         ALC233_FIXUP_LENOVO_LINE2_MIC_HOTKEY,
7208         ALC255_FIXUP_DELL_SPK_NOISE,
7209         ALC225_FIXUP_DISABLE_MIC_VREF,
7210         ALC225_FIXUP_DELL1_MIC_NO_PRESENCE,
7211         ALC295_FIXUP_DISABLE_DAC3,
7212         ALC285_FIXUP_SPEAKER2_TO_DAC1,
7213         ALC285_FIXUP_ASUS_SPEAKER2_TO_DAC1,
7214         ALC285_FIXUP_ASUS_HEADSET_MIC,
7215         ALC285_FIXUP_ASUS_SPI_REAR_SPEAKERS,
7216         ALC285_FIXUP_ASUS_I2C_SPEAKER2_TO_DAC1,
7217         ALC285_FIXUP_ASUS_I2C_HEADSET_MIC,
7218         ALC280_FIXUP_HP_HEADSET_MIC,
7219         ALC221_FIXUP_HP_FRONT_MIC,
7220         ALC292_FIXUP_TPT460,
7221         ALC298_FIXUP_SPK_VOLUME,
7222         ALC298_FIXUP_LENOVO_SPK_VOLUME,
7223         ALC256_FIXUP_DELL_INSPIRON_7559_SUBWOOFER,
7224         ALC269_FIXUP_ATIV_BOOK_8,
7225         ALC221_FIXUP_HP_288PRO_MIC_NO_PRESENCE,
7226         ALC221_FIXUP_HP_MIC_NO_PRESENCE,
7227         ALC256_FIXUP_ASUS_HEADSET_MODE,
7228         ALC256_FIXUP_ASUS_MIC,
7229         ALC256_FIXUP_ASUS_AIO_GPIO2,
7230         ALC233_FIXUP_ASUS_MIC_NO_PRESENCE,
7231         ALC233_FIXUP_EAPD_COEF_AND_MIC_NO_PRESENCE,
7232         ALC233_FIXUP_LENOVO_MULTI_CODECS,
7233         ALC233_FIXUP_ACER_HEADSET_MIC,
7234         ALC294_FIXUP_LENOVO_MIC_LOCATION,
7235         ALC225_FIXUP_DELL_WYSE_MIC_NO_PRESENCE,
7236         ALC225_FIXUP_S3_POP_NOISE,
7237         ALC700_FIXUP_INTEL_REFERENCE,
7238         ALC274_FIXUP_DELL_BIND_DACS,
7239         ALC274_FIXUP_DELL_AIO_LINEOUT_VERB,
7240         ALC298_FIXUP_TPT470_DOCK_FIX,
7241         ALC298_FIXUP_TPT470_DOCK,
7242         ALC255_FIXUP_DUMMY_LINEOUT_VERB,
7243         ALC255_FIXUP_DELL_HEADSET_MIC,
7244         ALC256_FIXUP_HUAWEI_MACH_WX9_PINS,
7245         ALC298_FIXUP_HUAWEI_MBX_STEREO,
7246         ALC295_FIXUP_HP_X360,
7247         ALC221_FIXUP_HP_HEADSET_MIC,
7248         ALC285_FIXUP_LENOVO_HEADPHONE_NOISE,
7249         ALC295_FIXUP_HP_AUTO_MUTE,
7250         ALC286_FIXUP_ACER_AIO_MIC_NO_PRESENCE,
7251         ALC294_FIXUP_ASUS_MIC,
7252         ALC294_FIXUP_ASUS_HEADSET_MIC,
7253         ALC294_FIXUP_ASUS_SPK,
7254         ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE,
7255         ALC285_FIXUP_LENOVO_PC_BEEP_IN_NOISE,
7256         ALC255_FIXUP_ACER_HEADSET_MIC,
7257         ALC295_FIXUP_CHROME_BOOK,
7258         ALC225_FIXUP_HEADSET_JACK,
7259         ALC225_FIXUP_DELL_WYSE_AIO_MIC_NO_PRESENCE,
7260         ALC225_FIXUP_WYSE_AUTO_MUTE,
7261         ALC225_FIXUP_WYSE_DISABLE_MIC_VREF,
7262         ALC286_FIXUP_ACER_AIO_HEADSET_MIC,
7263         ALC256_FIXUP_ASUS_HEADSET_MIC,
7264         ALC256_FIXUP_ASUS_MIC_NO_PRESENCE,
7265         ALC299_FIXUP_PREDATOR_SPK,
7266         ALC256_FIXUP_MEDION_HEADSET_NO_PRESENCE,
7267         ALC289_FIXUP_DELL_SPK1,
7268         ALC289_FIXUP_DELL_SPK2,
7269         ALC289_FIXUP_DUAL_SPK,
7270         ALC289_FIXUP_RTK_AMP_DUAL_SPK,
7271         ALC294_FIXUP_SPK2_TO_DAC1,
7272         ALC294_FIXUP_ASUS_DUAL_SPK,
7273         ALC285_FIXUP_THINKPAD_X1_GEN7,
7274         ALC285_FIXUP_THINKPAD_HEADSET_JACK,
7275         ALC294_FIXUP_ASUS_ALLY,
7276         ALC294_FIXUP_ASUS_ALLY_PINS,
7277         ALC294_FIXUP_ASUS_ALLY_VERBS,
7278         ALC294_FIXUP_ASUS_ALLY_SPEAKER,
7279         ALC294_FIXUP_ASUS_HPE,
7280         ALC294_FIXUP_ASUS_COEF_1B,
7281         ALC294_FIXUP_ASUS_GX502_HP,
7282         ALC294_FIXUP_ASUS_GX502_PINS,
7283         ALC294_FIXUP_ASUS_GX502_VERBS,
7284         ALC294_FIXUP_ASUS_GU502_HP,
7285         ALC294_FIXUP_ASUS_GU502_PINS,
7286         ALC294_FIXUP_ASUS_GU502_VERBS,
7287         ALC294_FIXUP_ASUS_G513_PINS,
7288         ALC285_FIXUP_ASUS_G533Z_PINS,
7289         ALC285_FIXUP_HP_GPIO_LED,
7290         ALC285_FIXUP_HP_MUTE_LED,
7291         ALC285_FIXUP_HP_SPECTRE_X360_MUTE_LED,
7292         ALC236_FIXUP_HP_MUTE_LED_COEFBIT2,
7293         ALC236_FIXUP_HP_GPIO_LED,
7294         ALC236_FIXUP_HP_MUTE_LED,
7295         ALC236_FIXUP_HP_MUTE_LED_MICMUTE_VREF,
7296         ALC298_FIXUP_SAMSUNG_AMP,
7297         ALC298_FIXUP_SAMSUNG_HEADPHONE_VERY_QUIET,
7298         ALC256_FIXUP_SAMSUNG_HEADPHONE_VERY_QUIET,
7299         ALC295_FIXUP_ASUS_MIC_NO_PRESENCE,
7300         ALC269VC_FIXUP_ACER_VCOPPERBOX_PINS,
7301         ALC269VC_FIXUP_ACER_HEADSET_MIC,
7302         ALC269VC_FIXUP_ACER_MIC_NO_PRESENCE,
7303         ALC289_FIXUP_ASUS_GA401,
7304         ALC289_FIXUP_ASUS_GA502,
7305         ALC256_FIXUP_ACER_MIC_NO_PRESENCE,
7306         ALC285_FIXUP_HP_GPIO_AMP_INIT,
7307         ALC269_FIXUP_CZC_B20,
7308         ALC269_FIXUP_CZC_TMI,
7309         ALC269_FIXUP_CZC_L101,
7310         ALC269_FIXUP_LEMOTE_A1802,
7311         ALC269_FIXUP_LEMOTE_A190X,
7312         ALC256_FIXUP_INTEL_NUC8_RUGGED,
7313         ALC233_FIXUP_INTEL_NUC8_DMIC,
7314         ALC233_FIXUP_INTEL_NUC8_BOOST,
7315         ALC256_FIXUP_INTEL_NUC10,
7316         ALC255_FIXUP_XIAOMI_HEADSET_MIC,
7317         ALC274_FIXUP_HP_MIC,
7318         ALC274_FIXUP_HP_HEADSET_MIC,
7319         ALC274_FIXUP_HP_ENVY_GPIO,
7320         ALC256_FIXUP_ASUS_HPE,
7321         ALC285_FIXUP_THINKPAD_NO_BASS_SPK_HEADSET_JACK,
7322         ALC287_FIXUP_HP_GPIO_LED,
7323         ALC256_FIXUP_HP_HEADSET_MIC,
7324         ALC245_FIXUP_HP_GPIO_LED,
7325         ALC236_FIXUP_DELL_AIO_HEADSET_MIC,
7326         ALC282_FIXUP_ACER_DISABLE_LINEOUT,
7327         ALC255_FIXUP_ACER_LIMIT_INT_MIC_BOOST,
7328         ALC256_FIXUP_ACER_HEADSET_MIC,
7329         ALC285_FIXUP_IDEAPAD_S740_COEF,
7330         ALC285_FIXUP_HP_LIMIT_INT_MIC_BOOST,
7331         ALC295_FIXUP_ASUS_DACS,
7332         ALC295_FIXUP_HP_OMEN,
7333         ALC285_FIXUP_HP_SPECTRE_X360,
7334         ALC287_FIXUP_IDEAPAD_BASS_SPK_AMP,
7335         ALC623_FIXUP_LENOVO_THINKSTATION_P340,
7336         ALC255_FIXUP_ACER_HEADPHONE_AND_MIC,
7337         ALC236_FIXUP_HP_LIMIT_INT_MIC_BOOST,
7338         ALC287_FIXUP_LEGION_15IMHG05_SPEAKERS,
7339         ALC287_FIXUP_LEGION_15IMHG05_AUTOMUTE,
7340         ALC287_FIXUP_YOGA7_14ITL_SPEAKERS,
7341         ALC298_FIXUP_LENOVO_C940_DUET7,
7342         ALC287_FIXUP_LENOVO_14IRP8_DUETITL,
7343         ALC287_FIXUP_13S_GEN2_SPEAKERS,
7344         ALC256_FIXUP_SET_COEF_DEFAULTS,
7345         ALC256_FIXUP_SYSTEM76_MIC_NO_PRESENCE,
7346         ALC233_FIXUP_NO_AUDIO_JACK,
7347         ALC256_FIXUP_MIC_NO_PRESENCE_AND_RESUME,
7348         ALC285_FIXUP_LEGION_Y9000X_SPEAKERS,
7349         ALC285_FIXUP_LEGION_Y9000X_AUTOMUTE,
7350         ALC287_FIXUP_LEGION_16ACHG6,
7351         ALC287_FIXUP_CS35L41_I2C_2,
7352         ALC287_FIXUP_CS35L41_I2C_2_HP_GPIO_LED,
7353         ALC287_FIXUP_CS35L41_I2C_4,
7354         ALC245_FIXUP_CS35L41_SPI_2,
7355         ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED,
7356         ALC245_FIXUP_CS35L41_SPI_4,
7357         ALC245_FIXUP_CS35L41_SPI_4_HP_GPIO_LED,
7358         ALC285_FIXUP_HP_SPEAKERS_MICMUTE_LED,
7359         ALC295_FIXUP_FRAMEWORK_LAPTOP_MIC_NO_PRESENCE,
7360         ALC287_FIXUP_LEGION_16ITHG6,
7361         ALC287_FIXUP_YOGA9_14IAP7_BASS_SPK,
7362         ALC287_FIXUP_YOGA9_14IAP7_BASS_SPK_PIN,
7363         ALC295_FIXUP_DELL_INSPIRON_TOP_SPEAKERS,
7364         ALC236_FIXUP_DELL_DUAL_CODECS,
7365         ALC287_FIXUP_CS35L41_I2C_2_THINKPAD_ACPI,
7366         ALC287_FIXUP_TAS2781_I2C,
7367         ALC287_FIXUP_YOGA7_14ARB7_I2C,
7368         ALC245_FIXUP_HP_MUTE_LED_COEFBIT,
7369         ALC245_FIXUP_HP_X360_MUTE_LEDS,
7370         ALC287_FIXUP_THINKPAD_I2S_SPK,
7371         ALC287_FIXUP_MG_RTKC_CSAMP_CS35L41_I2C_THINKPAD,
7372         ALC2XX_FIXUP_HEADSET_MIC,
7373         ALC289_FIXUP_DELL_CS35L41_SPI_2,
7374         ALC294_FIXUP_CS35L41_I2C_2,
7375         ALC245_FIXUP_CS35L56_SPI_4_HP_GPIO_LED,
7376 };
7377
7378 /* A special fixup for Lenovo C940 and Yoga Duet 7;
7379  * both have the very same PCI SSID, and we need to apply different fixups
7380  * depending on the codec ID
7381  */
7382 static void alc298_fixup_lenovo_c940_duet7(struct hda_codec *codec,
7383                                            const struct hda_fixup *fix,
7384                                            int action)
7385 {
7386         int id;
7387
7388         if (codec->core.vendor_id == 0x10ec0298)
7389                 id = ALC298_FIXUP_LENOVO_SPK_VOLUME; /* C940 */
7390         else
7391                 id = ALC287_FIXUP_YOGA7_14ITL_SPEAKERS; /* Duet 7 */
7392         __snd_hda_apply_fixup(codec, id, action, 0);
7393 }
7394
7395 /* A special fixup for Lenovo Slim/Yoga Pro 9 14IRP8 and Yoga DuetITL 2021;
7396  * 14IRP8 PCI SSID will mistakenly be matched with the DuetITL codec SSID,
7397  * so we need to apply a different fixup in this case. The only DuetITL codec
7398  * SSID reported so far is the 17aa:3802 while the 14IRP8 has the 17aa:38be
7399  * and 17aa:38bf. If it weren't for the PCI SSID, the 14IRP8 models would
7400  * have matched correctly by their codecs.
7401  */
7402 static void alc287_fixup_lenovo_14irp8_duetitl(struct hda_codec *codec,
7403                                               const struct hda_fixup *fix,
7404                                               int action)
7405 {
7406         int id;
7407
7408         if (codec->core.subsystem_id == 0x17aa3802)
7409                 id = ALC287_FIXUP_YOGA7_14ITL_SPEAKERS; /* DuetITL */
7410         else
7411                 id = ALC287_FIXUP_TAS2781_I2C; /* 14IRP8 */
7412         __snd_hda_apply_fixup(codec, id, action, 0);
7413 }
7414
7415 static const struct hda_fixup alc269_fixups[] = {
7416         [ALC269_FIXUP_GPIO2] = {
7417                 .type = HDA_FIXUP_FUNC,
7418                 .v.func = alc_fixup_gpio2,
7419         },
7420         [ALC269_FIXUP_SONY_VAIO] = {
7421                 .type = HDA_FIXUP_PINCTLS,
7422                 .v.pins = (const struct hda_pintbl[]) {
7423                         {0x19, PIN_VREFGRD},
7424                         {}
7425                 }
7426         },
7427         [ALC275_FIXUP_SONY_VAIO_GPIO2] = {
7428                 .type = HDA_FIXUP_FUNC,
7429                 .v.func = alc275_fixup_gpio4_off,
7430                 .chained = true,
7431                 .chain_id = ALC269_FIXUP_SONY_VAIO
7432         },
7433         [ALC269_FIXUP_DELL_M101Z] = {
7434                 .type = HDA_FIXUP_VERBS,
7435                 .v.verbs = (const struct hda_verb[]) {
7436                         /* Enables internal speaker */
7437                         {0x20, AC_VERB_SET_COEF_INDEX, 13},
7438                         {0x20, AC_VERB_SET_PROC_COEF, 0x4040},
7439                         {}
7440                 }
7441         },
7442         [ALC269_FIXUP_SKU_IGNORE] = {
7443                 .type = HDA_FIXUP_FUNC,
7444                 .v.func = alc_fixup_sku_ignore,
7445         },
7446         [ALC269_FIXUP_ASUS_G73JW] = {
7447                 .type = HDA_FIXUP_PINS,
7448                 .v.pins = (const struct hda_pintbl[]) {
7449                         { 0x17, 0x99130111 }, /* subwoofer */
7450                         { }
7451                 }
7452         },
7453         [ALC269_FIXUP_ASUS_N7601ZM_PINS] = {
7454                 .type = HDA_FIXUP_PINS,
7455                 .v.pins = (const struct hda_pintbl[]) {
7456                         { 0x19, 0x03A11050 },
7457                         { 0x1a, 0x03A11C30 },
7458                         { 0x21, 0x03211420 },
7459                         { }
7460                 }
7461         },
7462         [ALC269_FIXUP_ASUS_N7601ZM] = {
7463                 .type = HDA_FIXUP_VERBS,
7464                 .v.verbs = (const struct hda_verb[]) {
7465                         {0x20, AC_VERB_SET_COEF_INDEX, 0x62},
7466                         {0x20, AC_VERB_SET_PROC_COEF, 0xa007},
7467                         {0x20, AC_VERB_SET_COEF_INDEX, 0x10},
7468                         {0x20, AC_VERB_SET_PROC_COEF, 0x8420},
7469                         {0x20, AC_VERB_SET_COEF_INDEX, 0x0f},
7470                         {0x20, AC_VERB_SET_PROC_COEF, 0x7774},
7471                         { }
7472                 },
7473                 .chained = true,
7474                 .chain_id = ALC269_FIXUP_ASUS_N7601ZM_PINS,
7475         },
7476         [ALC269_FIXUP_LENOVO_EAPD] = {
7477                 .type = HDA_FIXUP_VERBS,
7478                 .v.verbs = (const struct hda_verb[]) {
7479                         {0x14, AC_VERB_SET_EAPD_BTLENABLE, 0},
7480                         {}
7481                 }
7482         },
7483         [ALC275_FIXUP_SONY_HWEQ] = {
7484                 .type = HDA_FIXUP_FUNC,
7485                 .v.func = alc269_fixup_hweq,
7486                 .chained = true,
7487                 .chain_id = ALC275_FIXUP_SONY_VAIO_GPIO2
7488         },
7489         [ALC275_FIXUP_SONY_DISABLE_AAMIX] = {
7490                 .type = HDA_FIXUP_FUNC,
7491                 .v.func = alc_fixup_disable_aamix,
7492                 .chained = true,
7493                 .chain_id = ALC269_FIXUP_SONY_VAIO
7494         },
7495         [ALC271_FIXUP_DMIC] = {
7496                 .type = HDA_FIXUP_FUNC,
7497                 .v.func = alc271_fixup_dmic,
7498         },
7499         [ALC269_FIXUP_PCM_44K] = {
7500                 .type = HDA_FIXUP_FUNC,
7501                 .v.func = alc269_fixup_pcm_44k,
7502                 .chained = true,
7503                 .chain_id = ALC269_FIXUP_QUANTA_MUTE
7504         },
7505         [ALC269_FIXUP_STEREO_DMIC] = {
7506                 .type = HDA_FIXUP_FUNC,
7507                 .v.func = alc269_fixup_stereo_dmic,
7508         },
7509         [ALC269_FIXUP_HEADSET_MIC] = {
7510                 .type = HDA_FIXUP_FUNC,
7511                 .v.func = alc269_fixup_headset_mic,
7512         },
7513         [ALC269_FIXUP_QUANTA_MUTE] = {
7514                 .type = HDA_FIXUP_FUNC,
7515                 .v.func = alc269_fixup_quanta_mute,
7516         },
7517         [ALC269_FIXUP_LIFEBOOK] = {
7518                 .type = HDA_FIXUP_PINS,
7519                 .v.pins = (const struct hda_pintbl[]) {
7520                         { 0x1a, 0x2101103f }, /* dock line-out */
7521                         { 0x1b, 0x23a11040 }, /* dock mic-in */
7522                         { }
7523                 },
7524                 .chained = true,
7525                 .chain_id = ALC269_FIXUP_QUANTA_MUTE
7526         },
7527         [ALC269_FIXUP_LIFEBOOK_EXTMIC] = {
7528                 .type = HDA_FIXUP_PINS,
7529                 .v.pins = (const struct hda_pintbl[]) {
7530                         { 0x19, 0x01a1903c }, /* headset mic, with jack detect */
7531                         { }
7532                 },
7533         },
7534         [ALC269_FIXUP_LIFEBOOK_HP_PIN] = {
7535                 .type = HDA_FIXUP_PINS,
7536                 .v.pins = (const struct hda_pintbl[]) {
7537                         { 0x21, 0x0221102f }, /* HP out */
7538                         { }
7539                 },
7540         },
7541         [ALC269_FIXUP_LIFEBOOK_NO_HP_TO_LINEOUT] = {
7542                 .type = HDA_FIXUP_FUNC,
7543                 .v.func = alc269_fixup_pincfg_no_hp_to_lineout,
7544         },
7545         [ALC255_FIXUP_LIFEBOOK_U7x7_HEADSET_MIC] = {
7546                 .type = HDA_FIXUP_FUNC,
7547                 .v.func = alc269_fixup_pincfg_U7x7_headset_mic,
7548         },
7549         [ALC269VB_FIXUP_CHUWI_COREBOOK_XPRO] = {
7550                 .type = HDA_FIXUP_PINS,
7551                 .v.pins = (const struct hda_pintbl[]) {
7552                         { 0x18, 0x03a19020 }, /* headset mic */
7553                         { 0x1b, 0x90170150 }, /* speaker */
7554                         { }
7555                 },
7556         },
7557         [ALC269_FIXUP_AMIC] = {
7558                 .type = HDA_FIXUP_PINS,
7559                 .v.pins = (const struct hda_pintbl[]) {
7560                         { 0x14, 0x99130110 }, /* speaker */
7561                         { 0x15, 0x0121401f }, /* HP out */
7562                         { 0x18, 0x01a19c20 }, /* mic */
7563                         { 0x19, 0x99a3092f }, /* int-mic */
7564                         { }
7565                 },
7566         },
7567         [ALC269_FIXUP_DMIC] = {
7568                 .type = HDA_FIXUP_PINS,
7569                 .v.pins = (const struct hda_pintbl[]) {
7570                         { 0x12, 0x99a3092f }, /* int-mic */
7571                         { 0x14, 0x99130110 }, /* speaker */
7572                         { 0x15, 0x0121401f }, /* HP out */
7573                         { 0x18, 0x01a19c20 }, /* mic */
7574                         { }
7575                 },
7576         },
7577         [ALC269VB_FIXUP_AMIC] = {
7578                 .type = HDA_FIXUP_PINS,
7579                 .v.pins = (const struct hda_pintbl[]) {
7580                         { 0x14, 0x99130110 }, /* speaker */
7581                         { 0x18, 0x01a19c20 }, /* mic */
7582                         { 0x19, 0x99a3092f }, /* int-mic */
7583                         { 0x21, 0x0121401f }, /* HP out */
7584                         { }
7585                 },
7586         },
7587         [ALC269VB_FIXUP_DMIC] = {
7588                 .type = HDA_FIXUP_PINS,
7589                 .v.pins = (const struct hda_pintbl[]) {
7590                         { 0x12, 0x99a3092f }, /* int-mic */
7591                         { 0x14, 0x99130110 }, /* speaker */
7592                         { 0x18, 0x01a19c20 }, /* mic */
7593                         { 0x21, 0x0121401f }, /* HP out */
7594                         { }
7595                 },
7596         },
7597         [ALC269_FIXUP_HP_MUTE_LED] = {
7598                 .type = HDA_FIXUP_FUNC,
7599                 .v.func = alc269_fixup_hp_mute_led,
7600         },
7601         [ALC269_FIXUP_HP_MUTE_LED_MIC1] = {
7602                 .type = HDA_FIXUP_FUNC,
7603                 .v.func = alc269_fixup_hp_mute_led_mic1,
7604         },
7605         [ALC269_FIXUP_HP_MUTE_LED_MIC2] = {
7606                 .type = HDA_FIXUP_FUNC,
7607                 .v.func = alc269_fixup_hp_mute_led_mic2,
7608         },
7609         [ALC269_FIXUP_HP_MUTE_LED_MIC3] = {
7610                 .type = HDA_FIXUP_FUNC,
7611                 .v.func = alc269_fixup_hp_mute_led_mic3,
7612                 .chained = true,
7613                 .chain_id = ALC295_FIXUP_HP_AUTO_MUTE
7614         },
7615         [ALC269_FIXUP_HP_GPIO_LED] = {
7616                 .type = HDA_FIXUP_FUNC,
7617                 .v.func = alc269_fixup_hp_gpio_led,
7618         },
7619         [ALC269_FIXUP_HP_GPIO_MIC1_LED] = {
7620                 .type = HDA_FIXUP_FUNC,
7621                 .v.func = alc269_fixup_hp_gpio_mic1_led,
7622         },
7623         [ALC269_FIXUP_HP_LINE1_MIC1_LED] = {
7624                 .type = HDA_FIXUP_FUNC,
7625                 .v.func = alc269_fixup_hp_line1_mic1_led,
7626         },
7627         [ALC269_FIXUP_INV_DMIC] = {
7628                 .type = HDA_FIXUP_FUNC,
7629                 .v.func = alc_fixup_inv_dmic,
7630         },
7631         [ALC269_FIXUP_NO_SHUTUP] = {
7632                 .type = HDA_FIXUP_FUNC,
7633                 .v.func = alc_fixup_no_shutup,
7634         },
7635         [ALC269_FIXUP_LENOVO_DOCK] = {
7636                 .type = HDA_FIXUP_PINS,
7637                 .v.pins = (const struct hda_pintbl[]) {
7638                         { 0x19, 0x23a11040 }, /* dock mic */
7639                         { 0x1b, 0x2121103f }, /* dock headphone */
7640                         { }
7641                 },
7642                 .chained = true,
7643                 .chain_id = ALC269_FIXUP_PINCFG_NO_HP_TO_LINEOUT
7644         },
7645         [ALC269_FIXUP_LENOVO_DOCK_LIMIT_BOOST] = {
7646                 .type = HDA_FIXUP_FUNC,
7647                 .v.func = alc269_fixup_limit_int_mic_boost,
7648                 .chained = true,
7649                 .chain_id = ALC269_FIXUP_LENOVO_DOCK,
7650         },
7651         [ALC269_FIXUP_PINCFG_NO_HP_TO_LINEOUT] = {
7652                 .type = HDA_FIXUP_FUNC,
7653                 .v.func = alc269_fixup_pincfg_no_hp_to_lineout,
7654                 .chained = true,
7655                 .chain_id = ALC269_FIXUP_THINKPAD_ACPI,
7656         },
7657         [ALC269_FIXUP_DELL1_MIC_NO_PRESENCE] = {
7658                 .type = HDA_FIXUP_PINS,
7659                 .v.pins = (const struct hda_pintbl[]) {
7660                         { 0x19, 0x01a1913c }, /* use as headset mic, without its own jack detect */
7661                         { 0x1a, 0x01a1913d }, /* use as headphone mic, without its own jack detect */
7662                         { }
7663                 },
7664                 .chained = true,
7665                 .chain_id = ALC269_FIXUP_HEADSET_MODE
7666         },
7667         [ALC269_FIXUP_DELL2_MIC_NO_PRESENCE] = {
7668                 .type = HDA_FIXUP_PINS,
7669                 .v.pins = (const struct hda_pintbl[]) {
7670                         { 0x16, 0x21014020 }, /* dock line out */
7671                         { 0x19, 0x21a19030 }, /* dock mic */
7672                         { 0x1a, 0x01a1913c }, /* use as headset mic, without its own jack detect */
7673                         { }
7674                 },
7675                 .chained = true,
7676                 .chain_id = ALC269_FIXUP_HEADSET_MODE_NO_HP_MIC
7677         },
7678         [ALC269_FIXUP_DELL3_MIC_NO_PRESENCE] = {
7679                 .type = HDA_FIXUP_PINS,
7680                 .v.pins = (const struct hda_pintbl[]) {
7681                         { 0x1a, 0x01a1913c }, /* use as headset mic, without its own jack detect */
7682                         { }
7683                 },
7684                 .chained = true,
7685                 .chain_id = ALC269_FIXUP_HEADSET_MODE_NO_HP_MIC
7686         },
7687         [ALC269_FIXUP_DELL4_MIC_NO_PRESENCE] = {
7688                 .type = HDA_FIXUP_PINS,
7689                 .v.pins = (const struct hda_pintbl[]) {
7690                         { 0x19, 0x01a1913c }, /* use as headset mic, without its own jack detect */
7691                         { 0x1b, 0x01a1913d }, /* use as headphone mic, without its own jack detect */
7692                         { }
7693                 },
7694                 .chained = true,
7695                 .chain_id = ALC269_FIXUP_HEADSET_MODE
7696         },
7697         [ALC269_FIXUP_HEADSET_MODE] = {
7698                 .type = HDA_FIXUP_FUNC,
7699                 .v.func = alc_fixup_headset_mode,
7700                 .chained = true,
7701                 .chain_id = ALC255_FIXUP_MIC_MUTE_LED
7702         },
7703         [ALC269_FIXUP_HEADSET_MODE_NO_HP_MIC] = {
7704                 .type = HDA_FIXUP_FUNC,
7705                 .v.func = alc_fixup_headset_mode_no_hp_mic,
7706         },
7707         [ALC269_FIXUP_ASPIRE_HEADSET_MIC] = {
7708                 .type = HDA_FIXUP_PINS,
7709                 .v.pins = (const struct hda_pintbl[]) {
7710                         { 0x19, 0x01a1913c }, /* headset mic w/o jack detect */
7711                         { }
7712                 },
7713                 .chained = true,
7714                 .chain_id = ALC269_FIXUP_HEADSET_MODE,
7715         },
7716         [ALC286_FIXUP_SONY_MIC_NO_PRESENCE] = {
7717                 .type = HDA_FIXUP_PINS,
7718                 .v.pins = (const struct hda_pintbl[]) {
7719                         { 0x18, 0x01a1913c }, /* use as headset mic, without its own jack detect */
7720                         { }
7721                 },
7722                 .chained = true,
7723                 .chain_id = ALC269_FIXUP_HEADSET_MIC
7724         },
7725         [ALC256_FIXUP_HUAWEI_MACH_WX9_PINS] = {
7726                 .type = HDA_FIXUP_PINS,
7727                 .v.pins = (const struct hda_pintbl[]) {
7728                         {0x12, 0x90a60130},
7729                         {0x13, 0x40000000},
7730                         {0x14, 0x90170110},
7731                         {0x18, 0x411111f0},
7732                         {0x19, 0x04a11040},
7733                         {0x1a, 0x411111f0},
7734                         {0x1b, 0x90170112},
7735                         {0x1d, 0x40759a05},
7736                         {0x1e, 0x411111f0},
7737                         {0x21, 0x04211020},
7738                         { }
7739                 },
7740                 .chained = true,
7741                 .chain_id = ALC255_FIXUP_MIC_MUTE_LED
7742         },
7743         [ALC298_FIXUP_HUAWEI_MBX_STEREO] = {
7744                 .type = HDA_FIXUP_FUNC,
7745                 .v.func = alc298_fixup_huawei_mbx_stereo,
7746                 .chained = true,
7747                 .chain_id = ALC255_FIXUP_MIC_MUTE_LED
7748         },
7749         [ALC269_FIXUP_ASUS_X101_FUNC] = {
7750                 .type = HDA_FIXUP_FUNC,
7751                 .v.func = alc269_fixup_x101_headset_mic,
7752         },
7753         [ALC269_FIXUP_ASUS_X101_VERB] = {
7754                 .type = HDA_FIXUP_VERBS,
7755                 .v.verbs = (const struct hda_verb[]) {
7756                         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
7757                         {0x20, AC_VERB_SET_COEF_INDEX, 0x08},
7758                         {0x20, AC_VERB_SET_PROC_COEF,  0x0310},
7759                         { }
7760                 },
7761                 .chained = true,
7762                 .chain_id = ALC269_FIXUP_ASUS_X101_FUNC
7763         },
7764         [ALC269_FIXUP_ASUS_X101] = {
7765                 .type = HDA_FIXUP_PINS,
7766                 .v.pins = (const struct hda_pintbl[]) {
7767                         { 0x18, 0x04a1182c }, /* Headset mic */
7768                         { }
7769                 },
7770                 .chained = true,
7771                 .chain_id = ALC269_FIXUP_ASUS_X101_VERB
7772         },
7773         [ALC271_FIXUP_AMIC_MIC2] = {
7774                 .type = HDA_FIXUP_PINS,
7775                 .v.pins = (const struct hda_pintbl[]) {
7776                         { 0x14, 0x99130110 }, /* speaker */
7777                         { 0x19, 0x01a19c20 }, /* mic */
7778                         { 0x1b, 0x99a7012f }, /* int-mic */
7779                         { 0x21, 0x0121401f }, /* HP out */
7780                         { }
7781                 },
7782         },
7783         [ALC271_FIXUP_HP_GATE_MIC_JACK] = {
7784                 .type = HDA_FIXUP_FUNC,
7785                 .v.func = alc271_hp_gate_mic_jack,
7786                 .chained = true,
7787                 .chain_id = ALC271_FIXUP_AMIC_MIC2,
7788         },
7789         [ALC271_FIXUP_HP_GATE_MIC_JACK_E1_572] = {
7790                 .type = HDA_FIXUP_FUNC,
7791                 .v.func = alc269_fixup_limit_int_mic_boost,
7792                 .chained = true,
7793                 .chain_id = ALC271_FIXUP_HP_GATE_MIC_JACK,
7794         },
7795         [ALC269_FIXUP_ACER_AC700] = {
7796                 .type = HDA_FIXUP_PINS,
7797                 .v.pins = (const struct hda_pintbl[]) {
7798                         { 0x12, 0x99a3092f }, /* int-mic */
7799                         { 0x14, 0x99130110 }, /* speaker */
7800                         { 0x18, 0x03a11c20 }, /* mic */
7801                         { 0x1e, 0x0346101e }, /* SPDIF1 */
7802                         { 0x21, 0x0321101f }, /* HP out */
7803                         { }
7804                 },
7805                 .chained = true,
7806                 .chain_id = ALC271_FIXUP_DMIC,
7807         },
7808         [ALC269_FIXUP_LIMIT_INT_MIC_BOOST] = {
7809                 .type = HDA_FIXUP_FUNC,
7810                 .v.func = alc269_fixup_limit_int_mic_boost,
7811                 .chained = true,
7812                 .chain_id = ALC269_FIXUP_THINKPAD_ACPI,
7813         },
7814         [ALC269VB_FIXUP_ASUS_ZENBOOK] = {
7815                 .type = HDA_FIXUP_FUNC,
7816                 .v.func = alc269_fixup_limit_int_mic_boost,
7817                 .chained = true,
7818                 .chain_id = ALC269VB_FIXUP_DMIC,
7819         },
7820         [ALC269VB_FIXUP_ASUS_ZENBOOK_UX31A] = {
7821                 .type = HDA_FIXUP_VERBS,
7822                 .v.verbs = (const struct hda_verb[]) {
7823                         /* class-D output amp +5dB */
7824                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x12 },
7825                         { 0x20, AC_VERB_SET_PROC_COEF, 0x2800 },
7826                         {}
7827                 },
7828                 .chained = true,
7829                 .chain_id = ALC269VB_FIXUP_ASUS_ZENBOOK,
7830         },
7831         [ALC269VB_FIXUP_ASUS_MIC_NO_PRESENCE] = {
7832                 .type = HDA_FIXUP_PINS,
7833                 .v.pins = (const struct hda_pintbl[]) {
7834                         { 0x18, 0x01a110f0 },  /* use as headset mic */
7835                         { }
7836                 },
7837                 .chained = true,
7838                 .chain_id = ALC269_FIXUP_HEADSET_MIC
7839         },
7840         [ALC269_FIXUP_LIMIT_INT_MIC_BOOST_MUTE_LED] = {
7841                 .type = HDA_FIXUP_FUNC,
7842                 .v.func = alc269_fixup_limit_int_mic_boost,
7843                 .chained = true,
7844                 .chain_id = ALC269_FIXUP_HP_MUTE_LED_MIC1,
7845         },
7846         [ALC269VB_FIXUP_ORDISSIMO_EVE2] = {
7847                 .type = HDA_FIXUP_PINS,
7848                 .v.pins = (const struct hda_pintbl[]) {
7849                         { 0x12, 0x99a3092f }, /* int-mic */
7850                         { 0x18, 0x03a11d20 }, /* mic */
7851                         { 0x19, 0x411111f0 }, /* Unused bogus pin */
7852                         { }
7853                 },
7854         },
7855         [ALC283_FIXUP_CHROME_BOOK] = {
7856                 .type = HDA_FIXUP_FUNC,
7857                 .v.func = alc283_fixup_chromebook,
7858         },
7859         [ALC283_FIXUP_SENSE_COMBO_JACK] = {
7860                 .type = HDA_FIXUP_FUNC,
7861                 .v.func = alc283_fixup_sense_combo_jack,
7862                 .chained = true,
7863                 .chain_id = ALC283_FIXUP_CHROME_BOOK,
7864         },
7865         [ALC282_FIXUP_ASUS_TX300] = {
7866                 .type = HDA_FIXUP_FUNC,
7867                 .v.func = alc282_fixup_asus_tx300,
7868         },
7869         [ALC283_FIXUP_INT_MIC] = {
7870                 .type = HDA_FIXUP_VERBS,
7871                 .v.verbs = (const struct hda_verb[]) {
7872                         {0x20, AC_VERB_SET_COEF_INDEX, 0x1a},
7873                         {0x20, AC_VERB_SET_PROC_COEF, 0x0011},
7874                         { }
7875                 },
7876                 .chained = true,
7877                 .chain_id = ALC269_FIXUP_LIMIT_INT_MIC_BOOST
7878         },
7879         [ALC290_FIXUP_SUBWOOFER_HSJACK] = {
7880                 .type = HDA_FIXUP_PINS,
7881                 .v.pins = (const struct hda_pintbl[]) {
7882                         { 0x17, 0x90170112 }, /* subwoofer */
7883                         { }
7884                 },
7885                 .chained = true,
7886                 .chain_id = ALC290_FIXUP_MONO_SPEAKERS_HSJACK,
7887         },
7888         [ALC290_FIXUP_SUBWOOFER] = {
7889                 .type = HDA_FIXUP_PINS,
7890                 .v.pins = (const struct hda_pintbl[]) {
7891                         { 0x17, 0x90170112 }, /* subwoofer */
7892                         { }
7893                 },
7894                 .chained = true,
7895                 .chain_id = ALC290_FIXUP_MONO_SPEAKERS,
7896         },
7897         [ALC290_FIXUP_MONO_SPEAKERS] = {
7898                 .type = HDA_FIXUP_FUNC,
7899                 .v.func = alc290_fixup_mono_speakers,
7900         },
7901         [ALC290_FIXUP_MONO_SPEAKERS_HSJACK] = {
7902                 .type = HDA_FIXUP_FUNC,
7903                 .v.func = alc290_fixup_mono_speakers,
7904                 .chained = true,
7905                 .chain_id = ALC269_FIXUP_DELL3_MIC_NO_PRESENCE,
7906         },
7907         [ALC269_FIXUP_THINKPAD_ACPI] = {
7908                 .type = HDA_FIXUP_FUNC,
7909                 .v.func = alc_fixup_thinkpad_acpi,
7910                 .chained = true,
7911                 .chain_id = ALC269_FIXUP_SKU_IGNORE,
7912         },
7913         [ALC269_FIXUP_DMIC_THINKPAD_ACPI] = {
7914                 .type = HDA_FIXUP_FUNC,
7915                 .v.func = alc_fixup_inv_dmic,
7916                 .chained = true,
7917                 .chain_id = ALC269_FIXUP_THINKPAD_ACPI,
7918         },
7919         [ALC255_FIXUP_ACER_MIC_NO_PRESENCE] = {
7920                 .type = HDA_FIXUP_PINS,
7921                 .v.pins = (const struct hda_pintbl[]) {
7922                         { 0x19, 0x01a1913c }, /* use as headset mic, without its own jack detect */
7923                         { }
7924                 },
7925                 .chained = true,
7926                 .chain_id = ALC255_FIXUP_HEADSET_MODE
7927         },
7928         [ALC255_FIXUP_ASUS_MIC_NO_PRESENCE] = {
7929                 .type = HDA_FIXUP_PINS,
7930                 .v.pins = (const struct hda_pintbl[]) {
7931                         { 0x19, 0x01a1913c }, /* use as headset mic, without its own jack detect */
7932                         { }
7933                 },
7934                 .chained = true,
7935                 .chain_id = ALC255_FIXUP_HEADSET_MODE
7936         },
7937         [ALC255_FIXUP_DELL1_MIC_NO_PRESENCE] = {
7938                 .type = HDA_FIXUP_PINS,
7939                 .v.pins = (const struct hda_pintbl[]) {
7940                         { 0x19, 0x01a1913c }, /* use as headset mic, without its own jack detect */
7941                         { 0x1a, 0x01a1913d }, /* use as headphone mic, without its own jack detect */
7942                         { }
7943                 },
7944                 .chained = true,
7945                 .chain_id = ALC255_FIXUP_HEADSET_MODE
7946         },
7947         [ALC255_FIXUP_DELL2_MIC_NO_PRESENCE] = {
7948                 .type = HDA_FIXUP_PINS,
7949                 .v.pins = (const struct hda_pintbl[]) {
7950                         { 0x19, 0x01a1913c }, /* use as headset mic, without its own jack detect */
7951                         { }
7952                 },
7953                 .chained = true,
7954                 .chain_id = ALC255_FIXUP_HEADSET_MODE_NO_HP_MIC
7955         },
7956         [ALC255_FIXUP_HEADSET_MODE] = {
7957                 .type = HDA_FIXUP_FUNC,
7958                 .v.func = alc_fixup_headset_mode_alc255,
7959                 .chained = true,
7960                 .chain_id = ALC255_FIXUP_MIC_MUTE_LED
7961         },
7962         [ALC255_FIXUP_HEADSET_MODE_NO_HP_MIC] = {
7963                 .type = HDA_FIXUP_FUNC,
7964                 .v.func = alc_fixup_headset_mode_alc255_no_hp_mic,
7965         },
7966         [ALC293_FIXUP_DELL1_MIC_NO_PRESENCE] = {
7967                 .type = HDA_FIXUP_PINS,
7968                 .v.pins = (const struct hda_pintbl[]) {
7969                         { 0x18, 0x01a1913d }, /* use as headphone mic, without its own jack detect */
7970                         { 0x1a, 0x01a1913c }, /* use as headset mic, without its own jack detect */
7971                         { }
7972                 },
7973                 .chained = true,
7974                 .chain_id = ALC269_FIXUP_HEADSET_MODE
7975         },
7976         [ALC292_FIXUP_TPT440_DOCK] = {
7977                 .type = HDA_FIXUP_FUNC,
7978                 .v.func = alc_fixup_tpt440_dock,
7979                 .chained = true,
7980                 .chain_id = ALC269_FIXUP_LIMIT_INT_MIC_BOOST
7981         },
7982         [ALC292_FIXUP_TPT440] = {
7983                 .type = HDA_FIXUP_FUNC,
7984                 .v.func = alc_fixup_disable_aamix,
7985                 .chained = true,
7986                 .chain_id = ALC292_FIXUP_TPT440_DOCK,
7987         },
7988         [ALC283_FIXUP_HEADSET_MIC] = {
7989                 .type = HDA_FIXUP_PINS,
7990                 .v.pins = (const struct hda_pintbl[]) {
7991                         { 0x19, 0x04a110f0 },
7992                         { },
7993                 },
7994         },
7995         [ALC255_FIXUP_MIC_MUTE_LED] = {
7996                 .type = HDA_FIXUP_FUNC,
7997                 .v.func = alc_fixup_micmute_led,
7998         },
7999         [ALC282_FIXUP_ASPIRE_V5_PINS] = {
8000                 .type = HDA_FIXUP_PINS,
8001                 .v.pins = (const struct hda_pintbl[]) {
8002                         { 0x12, 0x90a60130 },
8003                         { 0x14, 0x90170110 },
8004                         { 0x17, 0x40000008 },
8005                         { 0x18, 0x411111f0 },
8006                         { 0x19, 0x01a1913c },
8007                         { 0x1a, 0x411111f0 },
8008                         { 0x1b, 0x411111f0 },
8009                         { 0x1d, 0x40f89b2d },
8010                         { 0x1e, 0x411111f0 },
8011                         { 0x21, 0x0321101f },
8012                         { },
8013                 },
8014         },
8015         [ALC269VB_FIXUP_ASPIRE_E1_COEF] = {
8016                 .type = HDA_FIXUP_FUNC,
8017                 .v.func = alc269vb_fixup_aspire_e1_coef,
8018         },
8019         [ALC280_FIXUP_HP_GPIO4] = {
8020                 .type = HDA_FIXUP_FUNC,
8021                 .v.func = alc280_fixup_hp_gpio4,
8022         },
8023         [ALC286_FIXUP_HP_GPIO_LED] = {
8024                 .type = HDA_FIXUP_FUNC,
8025                 .v.func = alc286_fixup_hp_gpio_led,
8026         },
8027         [ALC280_FIXUP_HP_GPIO2_MIC_HOTKEY] = {
8028                 .type = HDA_FIXUP_FUNC,
8029                 .v.func = alc280_fixup_hp_gpio2_mic_hotkey,
8030         },
8031         [ALC280_FIXUP_HP_DOCK_PINS] = {
8032                 .type = HDA_FIXUP_PINS,
8033                 .v.pins = (const struct hda_pintbl[]) {
8034                         { 0x1b, 0x21011020 }, /* line-out */
8035                         { 0x1a, 0x01a1903c }, /* headset mic */
8036                         { 0x18, 0x2181103f }, /* line-in */
8037                         { },
8038                 },
8039                 .chained = true,
8040                 .chain_id = ALC280_FIXUP_HP_GPIO4
8041         },
8042         [ALC269_FIXUP_HP_DOCK_GPIO_MIC1_LED] = {
8043                 .type = HDA_FIXUP_PINS,
8044                 .v.pins = (const struct hda_pintbl[]) {
8045                         { 0x1b, 0x21011020 }, /* line-out */
8046                         { 0x18, 0x2181103f }, /* line-in */
8047                         { },
8048                 },
8049                 .chained = true,
8050                 .chain_id = ALC269_FIXUP_HP_GPIO_MIC1_LED
8051         },
8052         [ALC280_FIXUP_HP_9480M] = {
8053                 .type = HDA_FIXUP_FUNC,
8054                 .v.func = alc280_fixup_hp_9480m,
8055         },
8056         [ALC245_FIXUP_HP_X360_AMP] = {
8057                 .type = HDA_FIXUP_FUNC,
8058                 .v.func = alc245_fixup_hp_x360_amp,
8059                 .chained = true,
8060                 .chain_id = ALC245_FIXUP_HP_GPIO_LED
8061         },
8062         [ALC288_FIXUP_DELL_HEADSET_MODE] = {
8063                 .type = HDA_FIXUP_FUNC,
8064                 .v.func = alc_fixup_headset_mode_dell_alc288,
8065                 .chained = true,
8066                 .chain_id = ALC255_FIXUP_MIC_MUTE_LED
8067         },
8068         [ALC288_FIXUP_DELL1_MIC_NO_PRESENCE] = {
8069                 .type = HDA_FIXUP_PINS,
8070                 .v.pins = (const struct hda_pintbl[]) {
8071                         { 0x18, 0x01a1913c }, /* use as headset mic, without its own jack detect */
8072                         { 0x1a, 0x01a1913d }, /* use as headphone mic, without its own jack detect */
8073                         { }
8074                 },
8075                 .chained = true,
8076                 .chain_id = ALC288_FIXUP_DELL_HEADSET_MODE
8077         },
8078         [ALC288_FIXUP_DISABLE_AAMIX] = {
8079                 .type = HDA_FIXUP_FUNC,
8080                 .v.func = alc_fixup_disable_aamix,
8081                 .chained = true,
8082                 .chain_id = ALC288_FIXUP_DELL1_MIC_NO_PRESENCE
8083         },
8084         [ALC288_FIXUP_DELL_XPS_13] = {
8085                 .type = HDA_FIXUP_FUNC,
8086                 .v.func = alc_fixup_dell_xps13,
8087                 .chained = true,
8088                 .chain_id = ALC288_FIXUP_DISABLE_AAMIX
8089         },
8090         [ALC292_FIXUP_DISABLE_AAMIX] = {
8091                 .type = HDA_FIXUP_FUNC,
8092                 .v.func = alc_fixup_disable_aamix,
8093                 .chained = true,
8094                 .chain_id = ALC269_FIXUP_DELL2_MIC_NO_PRESENCE
8095         },
8096         [ALC293_FIXUP_DISABLE_AAMIX_MULTIJACK] = {
8097                 .type = HDA_FIXUP_FUNC,
8098                 .v.func = alc_fixup_disable_aamix,
8099                 .chained = true,
8100                 .chain_id = ALC293_FIXUP_DELL1_MIC_NO_PRESENCE
8101         },
8102         [ALC292_FIXUP_DELL_E7X_AAMIX] = {
8103                 .type = HDA_FIXUP_FUNC,
8104                 .v.func = alc_fixup_dell_xps13,
8105                 .chained = true,
8106                 .chain_id = ALC292_FIXUP_DISABLE_AAMIX
8107         },
8108         [ALC292_FIXUP_DELL_E7X] = {
8109                 .type = HDA_FIXUP_FUNC,
8110                 .v.func = alc_fixup_micmute_led,
8111                 /* micmute fixup must be applied at last */
8112                 .chained_before = true,
8113                 .chain_id = ALC292_FIXUP_DELL_E7X_AAMIX,
8114         },
8115         [ALC298_FIXUP_ALIENWARE_MIC_NO_PRESENCE] = {
8116                 .type = HDA_FIXUP_PINS,
8117                 .v.pins = (const struct hda_pintbl[]) {
8118                         { 0x18, 0x01a1913c }, /* headset mic w/o jack detect */
8119                         { }
8120                 },
8121                 .chained_before = true,
8122                 .chain_id = ALC269_FIXUP_HEADSET_MODE,
8123         },
8124         [ALC298_FIXUP_DELL1_MIC_NO_PRESENCE] = {
8125                 .type = HDA_FIXUP_PINS,
8126                 .v.pins = (const struct hda_pintbl[]) {
8127                         { 0x18, 0x01a1913c }, /* use as headset mic, without its own jack detect */
8128                         { 0x1a, 0x01a1913d }, /* use as headphone mic, without its own jack detect */
8129                         { }
8130                 },
8131                 .chained = true,
8132                 .chain_id = ALC269_FIXUP_HEADSET_MODE
8133         },
8134         [ALC298_FIXUP_DELL_AIO_MIC_NO_PRESENCE] = {
8135                 .type = HDA_FIXUP_PINS,
8136                 .v.pins = (const struct hda_pintbl[]) {
8137                         { 0x18, 0x01a1913c }, /* use as headset mic, without its own jack detect */
8138                         { }
8139                 },
8140                 .chained = true,
8141                 .chain_id = ALC269_FIXUP_HEADSET_MODE
8142         },
8143         [ALC275_FIXUP_DELL_XPS] = {
8144                 .type = HDA_FIXUP_VERBS,
8145                 .v.verbs = (const struct hda_verb[]) {
8146                         /* Enables internal speaker */
8147                         {0x20, AC_VERB_SET_COEF_INDEX, 0x1f},
8148                         {0x20, AC_VERB_SET_PROC_COEF, 0x00c0},
8149                         {0x20, AC_VERB_SET_COEF_INDEX, 0x30},
8150                         {0x20, AC_VERB_SET_PROC_COEF, 0x00b1},
8151                         {}
8152                 }
8153         },
8154         [ALC293_FIXUP_LENOVO_SPK_NOISE] = {
8155                 .type = HDA_FIXUP_FUNC,
8156                 .v.func = alc_fixup_disable_aamix,
8157                 .chained = true,
8158                 .chain_id = ALC269_FIXUP_THINKPAD_ACPI
8159         },
8160         [ALC233_FIXUP_LENOVO_LINE2_MIC_HOTKEY] = {
8161                 .type = HDA_FIXUP_FUNC,
8162                 .v.func = alc233_fixup_lenovo_line2_mic_hotkey,
8163         },
8164         [ALC233_FIXUP_INTEL_NUC8_DMIC] = {
8165                 .type = HDA_FIXUP_FUNC,
8166                 .v.func = alc_fixup_inv_dmic,
8167                 .chained = true,
8168                 .chain_id = ALC233_FIXUP_INTEL_NUC8_BOOST,
8169         },
8170         [ALC233_FIXUP_INTEL_NUC8_BOOST] = {
8171                 .type = HDA_FIXUP_FUNC,
8172                 .v.func = alc269_fixup_limit_int_mic_boost
8173         },
8174         [ALC255_FIXUP_DELL_SPK_NOISE] = {
8175                 .type = HDA_FIXUP_FUNC,
8176                 .v.func = alc_fixup_disable_aamix,
8177                 .chained = true,
8178                 .chain_id = ALC255_FIXUP_DELL1_MIC_NO_PRESENCE
8179         },
8180         [ALC225_FIXUP_DISABLE_MIC_VREF] = {
8181                 .type = HDA_FIXUP_FUNC,
8182                 .v.func = alc_fixup_disable_mic_vref,
8183                 .chained = true,
8184                 .chain_id = ALC269_FIXUP_DELL1_MIC_NO_PRESENCE
8185         },
8186         [ALC225_FIXUP_DELL1_MIC_NO_PRESENCE] = {
8187                 .type = HDA_FIXUP_VERBS,
8188                 .v.verbs = (const struct hda_verb[]) {
8189                         /* Disable pass-through path for FRONT 14h */
8190                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x36 },
8191                         { 0x20, AC_VERB_SET_PROC_COEF, 0x57d7 },
8192                         {}
8193                 },
8194                 .chained = true,
8195                 .chain_id = ALC225_FIXUP_DISABLE_MIC_VREF
8196         },
8197         [ALC280_FIXUP_HP_HEADSET_MIC] = {
8198                 .type = HDA_FIXUP_FUNC,
8199                 .v.func = alc_fixup_disable_aamix,
8200                 .chained = true,
8201                 .chain_id = ALC269_FIXUP_HEADSET_MIC,
8202         },
8203         [ALC221_FIXUP_HP_FRONT_MIC] = {
8204                 .type = HDA_FIXUP_PINS,
8205                 .v.pins = (const struct hda_pintbl[]) {
8206                         { 0x19, 0x02a19020 }, /* Front Mic */
8207                         { }
8208                 },
8209         },
8210         [ALC292_FIXUP_TPT460] = {
8211                 .type = HDA_FIXUP_FUNC,
8212                 .v.func = alc_fixup_tpt440_dock,
8213                 .chained = true,
8214                 .chain_id = ALC293_FIXUP_LENOVO_SPK_NOISE,
8215         },
8216         [ALC298_FIXUP_SPK_VOLUME] = {
8217                 .type = HDA_FIXUP_FUNC,
8218                 .v.func = alc298_fixup_speaker_volume,
8219                 .chained = true,
8220                 .chain_id = ALC298_FIXUP_DELL_AIO_MIC_NO_PRESENCE,
8221         },
8222         [ALC298_FIXUP_LENOVO_SPK_VOLUME] = {
8223                 .type = HDA_FIXUP_FUNC,
8224                 .v.func = alc298_fixup_speaker_volume,
8225         },
8226         [ALC295_FIXUP_DISABLE_DAC3] = {
8227                 .type = HDA_FIXUP_FUNC,
8228                 .v.func = alc295_fixup_disable_dac3,
8229         },
8230         [ALC285_FIXUP_SPEAKER2_TO_DAC1] = {
8231                 .type = HDA_FIXUP_FUNC,
8232                 .v.func = alc285_fixup_speaker2_to_dac1,
8233                 .chained = true,
8234                 .chain_id = ALC269_FIXUP_THINKPAD_ACPI
8235         },
8236         [ALC285_FIXUP_ASUS_SPEAKER2_TO_DAC1] = {
8237                 .type = HDA_FIXUP_FUNC,
8238                 .v.func = alc285_fixup_speaker2_to_dac1,
8239                 .chained = true,
8240                 .chain_id = ALC245_FIXUP_CS35L41_SPI_2
8241         },
8242         [ALC285_FIXUP_ASUS_HEADSET_MIC] = {
8243                 .type = HDA_FIXUP_PINS,
8244                 .v.pins = (const struct hda_pintbl[]) {
8245                         { 0x19, 0x03a11050 },
8246                         { 0x1b, 0x03a11c30 },
8247                         { }
8248                 },
8249                 .chained = true,
8250                 .chain_id = ALC285_FIXUP_ASUS_SPEAKER2_TO_DAC1
8251         },
8252         [ALC285_FIXUP_ASUS_SPI_REAR_SPEAKERS] = {
8253                 .type = HDA_FIXUP_PINS,
8254                 .v.pins = (const struct hda_pintbl[]) {
8255                         { 0x14, 0x90170120 },
8256                         { }
8257                 },
8258                 .chained = true,
8259                 .chain_id = ALC285_FIXUP_ASUS_HEADSET_MIC
8260         },
8261         [ALC285_FIXUP_ASUS_I2C_SPEAKER2_TO_DAC1] = {
8262                 .type = HDA_FIXUP_FUNC,
8263                 .v.func = alc285_fixup_speaker2_to_dac1,
8264                 .chained = true,
8265                 .chain_id = ALC287_FIXUP_CS35L41_I2C_2
8266         },
8267         [ALC285_FIXUP_ASUS_I2C_HEADSET_MIC] = {
8268                 .type = HDA_FIXUP_PINS,
8269                 .v.pins = (const struct hda_pintbl[]) {
8270                         { 0x19, 0x03a11050 },
8271                         { 0x1b, 0x03a11c30 },
8272                         { }
8273                 },
8274                 .chained = true,
8275                 .chain_id = ALC285_FIXUP_ASUS_I2C_SPEAKER2_TO_DAC1
8276         },
8277         [ALC256_FIXUP_DELL_INSPIRON_7559_SUBWOOFER] = {
8278                 .type = HDA_FIXUP_PINS,
8279                 .v.pins = (const struct hda_pintbl[]) {
8280                         { 0x1b, 0x90170151 },
8281                         { }
8282                 },
8283                 .chained = true,
8284                 .chain_id = ALC255_FIXUP_DELL1_MIC_NO_PRESENCE
8285         },
8286         [ALC269_FIXUP_ATIV_BOOK_8] = {
8287                 .type = HDA_FIXUP_FUNC,
8288                 .v.func = alc_fixup_auto_mute_via_amp,
8289                 .chained = true,
8290                 .chain_id = ALC269_FIXUP_NO_SHUTUP
8291         },
8292         [ALC221_FIXUP_HP_288PRO_MIC_NO_PRESENCE] = {
8293                 .type = HDA_FIXUP_PINS,
8294                 .v.pins = (const struct hda_pintbl[]) {
8295                         { 0x19, 0x01a1913c }, /* use as headset mic, without its own jack detect */
8296                         { 0x1a, 0x01813030 }, /* use as headphone mic, without its own jack detect */
8297                         { }
8298                 },
8299                 .chained = true,
8300                 .chain_id = ALC269_FIXUP_HEADSET_MODE
8301         },
8302         [ALC221_FIXUP_HP_MIC_NO_PRESENCE] = {
8303                 .type = HDA_FIXUP_PINS,
8304                 .v.pins = (const struct hda_pintbl[]) {
8305                         { 0x18, 0x01a1913c }, /* use as headset mic, without its own jack detect */
8306                         { 0x1a, 0x01a1913d }, /* use as headphone mic, without its own jack detect */
8307                         { }
8308                 },
8309                 .chained = true,
8310                 .chain_id = ALC269_FIXUP_HEADSET_MODE
8311         },
8312         [ALC256_FIXUP_ASUS_HEADSET_MODE] = {
8313                 .type = HDA_FIXUP_FUNC,
8314                 .v.func = alc_fixup_headset_mode,
8315         },
8316         [ALC256_FIXUP_ASUS_MIC] = {
8317                 .type = HDA_FIXUP_PINS,
8318                 .v.pins = (const struct hda_pintbl[]) {
8319                         { 0x13, 0x90a60160 }, /* use as internal mic */
8320                         { 0x19, 0x04a11120 }, /* use as headset mic, without its own jack detect */
8321                         { }
8322                 },
8323                 .chained = true,
8324                 .chain_id = ALC256_FIXUP_ASUS_HEADSET_MODE
8325         },
8326         [ALC256_FIXUP_ASUS_AIO_GPIO2] = {
8327                 .type = HDA_FIXUP_FUNC,
8328                 /* Set up GPIO2 for the speaker amp */
8329                 .v.func = alc_fixup_gpio4,
8330         },
8331         [ALC233_FIXUP_ASUS_MIC_NO_PRESENCE] = {
8332                 .type = HDA_FIXUP_PINS,
8333                 .v.pins = (const struct hda_pintbl[]) {
8334                         { 0x19, 0x01a1913c }, /* use as headset mic, without its own jack detect */
8335                         { }
8336                 },
8337                 .chained = true,
8338                 .chain_id = ALC269_FIXUP_HEADSET_MIC
8339         },
8340         [ALC233_FIXUP_EAPD_COEF_AND_MIC_NO_PRESENCE] = {
8341                 .type = HDA_FIXUP_VERBS,
8342                 .v.verbs = (const struct hda_verb[]) {
8343                         /* Enables internal speaker */
8344                         {0x20, AC_VERB_SET_COEF_INDEX, 0x40},
8345                         {0x20, AC_VERB_SET_PROC_COEF, 0x8800},
8346                         {}
8347                 },
8348                 .chained = true,
8349                 .chain_id = ALC233_FIXUP_ASUS_MIC_NO_PRESENCE
8350         },
8351         [ALC233_FIXUP_LENOVO_MULTI_CODECS] = {
8352                 .type = HDA_FIXUP_FUNC,
8353                 .v.func = alc233_alc662_fixup_lenovo_dual_codecs,
8354                 .chained = true,
8355                 .chain_id = ALC269_FIXUP_GPIO2
8356         },
8357         [ALC233_FIXUP_ACER_HEADSET_MIC] = {
8358                 .type = HDA_FIXUP_VERBS,
8359                 .v.verbs = (const struct hda_verb[]) {
8360                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x45 },
8361                         { 0x20, AC_VERB_SET_PROC_COEF, 0x5089 },
8362                         { }
8363                 },
8364                 .chained = true,
8365                 .chain_id = ALC233_FIXUP_ASUS_MIC_NO_PRESENCE
8366         },
8367         [ALC294_FIXUP_LENOVO_MIC_LOCATION] = {
8368                 .type = HDA_FIXUP_PINS,
8369                 .v.pins = (const struct hda_pintbl[]) {
8370                         /* Change the mic location from front to right, otherwise there are
8371                            two front mics with the same name, pulseaudio can't handle them.
8372                            This is just a temporary workaround, after applying this fixup,
8373                            there will be one "Front Mic" and one "Mic" in this machine.
8374                          */
8375                         { 0x1a, 0x04a19040 },
8376                         { }
8377                 },
8378         },
8379         [ALC225_FIXUP_DELL_WYSE_MIC_NO_PRESENCE] = {
8380                 .type = HDA_FIXUP_PINS,
8381                 .v.pins = (const struct hda_pintbl[]) {
8382                         { 0x16, 0x0101102f }, /* Rear Headset HP */
8383                         { 0x19, 0x02a1913c }, /* use as Front headset mic, without its own jack detect */
8384                         { 0x1a, 0x01a19030 }, /* Rear Headset MIC */
8385                         { 0x1b, 0x02011020 },
8386                         { }
8387                 },
8388                 .chained = true,
8389                 .chain_id = ALC225_FIXUP_S3_POP_NOISE
8390         },
8391         [ALC225_FIXUP_S3_POP_NOISE] = {
8392                 .type = HDA_FIXUP_FUNC,
8393                 .v.func = alc225_fixup_s3_pop_noise,
8394                 .chained = true,
8395                 .chain_id = ALC269_FIXUP_HEADSET_MODE_NO_HP_MIC
8396         },
8397         [ALC700_FIXUP_INTEL_REFERENCE] = {
8398                 .type = HDA_FIXUP_VERBS,
8399                 .v.verbs = (const struct hda_verb[]) {
8400                         /* Enables internal speaker */
8401                         {0x20, AC_VERB_SET_COEF_INDEX, 0x45},
8402                         {0x20, AC_VERB_SET_PROC_COEF, 0x5289},
8403                         {0x20, AC_VERB_SET_COEF_INDEX, 0x4A},
8404                         {0x20, AC_VERB_SET_PROC_COEF, 0x001b},
8405                         {0x58, AC_VERB_SET_COEF_INDEX, 0x00},
8406                         {0x58, AC_VERB_SET_PROC_COEF, 0x3888},
8407                         {0x20, AC_VERB_SET_COEF_INDEX, 0x6f},
8408                         {0x20, AC_VERB_SET_PROC_COEF, 0x2c0b},
8409                         {}
8410                 }
8411         },
8412         [ALC274_FIXUP_DELL_BIND_DACS] = {
8413                 .type = HDA_FIXUP_FUNC,
8414                 .v.func = alc274_fixup_bind_dacs,
8415                 .chained = true,
8416                 .chain_id = ALC269_FIXUP_DELL1_MIC_NO_PRESENCE
8417         },
8418         [ALC274_FIXUP_DELL_AIO_LINEOUT_VERB] = {
8419                 .type = HDA_FIXUP_PINS,
8420                 .v.pins = (const struct hda_pintbl[]) {
8421                         { 0x1b, 0x0401102f },
8422                         { }
8423                 },
8424                 .chained = true,
8425                 .chain_id = ALC274_FIXUP_DELL_BIND_DACS
8426         },
8427         [ALC298_FIXUP_TPT470_DOCK_FIX] = {
8428                 .type = HDA_FIXUP_FUNC,
8429                 .v.func = alc_fixup_tpt470_dock,
8430                 .chained = true,
8431                 .chain_id = ALC293_FIXUP_LENOVO_SPK_NOISE
8432         },
8433         [ALC298_FIXUP_TPT470_DOCK] = {
8434                 .type = HDA_FIXUP_FUNC,
8435                 .v.func = alc_fixup_tpt470_dacs,
8436                 .chained = true,
8437                 .chain_id = ALC298_FIXUP_TPT470_DOCK_FIX
8438         },
8439         [ALC255_FIXUP_DUMMY_LINEOUT_VERB] = {
8440                 .type = HDA_FIXUP_PINS,
8441                 .v.pins = (const struct hda_pintbl[]) {
8442                         { 0x14, 0x0201101f },
8443                         { }
8444                 },
8445                 .chained = true,
8446                 .chain_id = ALC255_FIXUP_DELL1_MIC_NO_PRESENCE
8447         },
8448         [ALC255_FIXUP_DELL_HEADSET_MIC] = {
8449                 .type = HDA_FIXUP_PINS,
8450                 .v.pins = (const struct hda_pintbl[]) {
8451                         { 0x19, 0x01a1913c }, /* use as headset mic, without its own jack detect */
8452                         { }
8453                 },
8454                 .chained = true,
8455                 .chain_id = ALC269_FIXUP_HEADSET_MIC
8456         },
8457         [ALC295_FIXUP_HP_X360] = {
8458                 .type = HDA_FIXUP_FUNC,
8459                 .v.func = alc295_fixup_hp_top_speakers,
8460                 .chained = true,
8461                 .chain_id = ALC269_FIXUP_HP_MUTE_LED_MIC3
8462         },
8463         [ALC221_FIXUP_HP_HEADSET_MIC] = {
8464                 .type = HDA_FIXUP_PINS,
8465                 .v.pins = (const struct hda_pintbl[]) {
8466                         { 0x19, 0x0181313f},
8467                         { }
8468                 },
8469                 .chained = true,
8470                 .chain_id = ALC269_FIXUP_HEADSET_MIC
8471         },
8472         [ALC285_FIXUP_LENOVO_HEADPHONE_NOISE] = {
8473                 .type = HDA_FIXUP_FUNC,
8474                 .v.func = alc285_fixup_invalidate_dacs,
8475                 .chained = true,
8476                 .chain_id = ALC269_FIXUP_THINKPAD_ACPI
8477         },
8478         [ALC295_FIXUP_HP_AUTO_MUTE] = {
8479                 .type = HDA_FIXUP_FUNC,
8480                 .v.func = alc_fixup_auto_mute_via_amp,
8481         },
8482         [ALC286_FIXUP_ACER_AIO_MIC_NO_PRESENCE] = {
8483                 .type = HDA_FIXUP_PINS,
8484                 .v.pins = (const struct hda_pintbl[]) {
8485                         { 0x18, 0x01a1913c }, /* use as headset mic, without its own jack detect */
8486                         { }
8487                 },
8488                 .chained = true,
8489                 .chain_id = ALC269_FIXUP_HEADSET_MIC
8490         },
8491         [ALC294_FIXUP_ASUS_MIC] = {
8492                 .type = HDA_FIXUP_PINS,
8493                 .v.pins = (const struct hda_pintbl[]) {
8494                         { 0x13, 0x90a60160 }, /* use as internal mic */
8495                         { 0x19, 0x04a11120 }, /* use as headset mic, without its own jack detect */
8496                         { }
8497                 },
8498                 .chained = true,
8499                 .chain_id = ALC269_FIXUP_HEADSET_MIC
8500         },
8501         [ALC294_FIXUP_ASUS_HEADSET_MIC] = {
8502                 .type = HDA_FIXUP_PINS,
8503                 .v.pins = (const struct hda_pintbl[]) {
8504                         { 0x19, 0x01a1103c }, /* use as headset mic */
8505                         { }
8506                 },
8507                 .chained = true,
8508                 .chain_id = ALC269_FIXUP_HEADSET_MIC
8509         },
8510         [ALC294_FIXUP_ASUS_SPK] = {
8511                 .type = HDA_FIXUP_VERBS,
8512                 .v.verbs = (const struct hda_verb[]) {
8513                         /* Set EAPD high */
8514                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x40 },
8515                         { 0x20, AC_VERB_SET_PROC_COEF, 0x8800 },
8516                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x0f },
8517                         { 0x20, AC_VERB_SET_PROC_COEF, 0x7774 },
8518                         { }
8519                 },
8520                 .chained = true,
8521                 .chain_id = ALC294_FIXUP_ASUS_HEADSET_MIC
8522         },
8523         [ALC295_FIXUP_CHROME_BOOK] = {
8524                 .type = HDA_FIXUP_FUNC,
8525                 .v.func = alc295_fixup_chromebook,
8526                 .chained = true,
8527                 .chain_id = ALC225_FIXUP_HEADSET_JACK
8528         },
8529         [ALC225_FIXUP_HEADSET_JACK] = {
8530                 .type = HDA_FIXUP_FUNC,
8531                 .v.func = alc_fixup_headset_jack,
8532         },
8533         [ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE] = {
8534                 .type = HDA_FIXUP_PINS,
8535                 .v.pins = (const struct hda_pintbl[]) {
8536                         { 0x1a, 0x01a1913c }, /* use as headset mic, without its own jack detect */
8537                         { }
8538                 },
8539                 .chained = true,
8540                 .chain_id = ALC269_FIXUP_HEADSET_MODE_NO_HP_MIC
8541         },
8542         [ALC285_FIXUP_LENOVO_PC_BEEP_IN_NOISE] = {
8543                 .type = HDA_FIXUP_VERBS,
8544                 .v.verbs = (const struct hda_verb[]) {
8545                         /* Disable PCBEEP-IN passthrough */
8546                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x36 },
8547                         { 0x20, AC_VERB_SET_PROC_COEF, 0x57d7 },
8548                         { }
8549                 },
8550                 .chained = true,
8551                 .chain_id = ALC285_FIXUP_LENOVO_HEADPHONE_NOISE
8552         },
8553         [ALC255_FIXUP_ACER_HEADSET_MIC] = {
8554                 .type = HDA_FIXUP_PINS,
8555                 .v.pins = (const struct hda_pintbl[]) {
8556                         { 0x19, 0x03a11130 },
8557                         { 0x1a, 0x90a60140 }, /* use as internal mic */
8558                         { }
8559                 },
8560                 .chained = true,
8561                 .chain_id = ALC255_FIXUP_HEADSET_MODE_NO_HP_MIC
8562         },
8563         [ALC225_FIXUP_DELL_WYSE_AIO_MIC_NO_PRESENCE] = {
8564                 .type = HDA_FIXUP_PINS,
8565                 .v.pins = (const struct hda_pintbl[]) {
8566                         { 0x16, 0x01011020 }, /* Rear Line out */
8567                         { 0x19, 0x01a1913c }, /* use as Front headset mic, without its own jack detect */
8568                         { }
8569                 },
8570                 .chained = true,
8571                 .chain_id = ALC225_FIXUP_WYSE_AUTO_MUTE
8572         },
8573         [ALC225_FIXUP_WYSE_AUTO_MUTE] = {
8574                 .type = HDA_FIXUP_FUNC,
8575                 .v.func = alc_fixup_auto_mute_via_amp,
8576                 .chained = true,
8577                 .chain_id = ALC225_FIXUP_WYSE_DISABLE_MIC_VREF
8578         },
8579         [ALC225_FIXUP_WYSE_DISABLE_MIC_VREF] = {
8580                 .type = HDA_FIXUP_FUNC,
8581                 .v.func = alc_fixup_disable_mic_vref,
8582                 .chained = true,
8583                 .chain_id = ALC269_FIXUP_HEADSET_MODE_NO_HP_MIC
8584         },
8585         [ALC286_FIXUP_ACER_AIO_HEADSET_MIC] = {
8586                 .type = HDA_FIXUP_VERBS,
8587                 .v.verbs = (const struct hda_verb[]) {
8588                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x4f },
8589                         { 0x20, AC_VERB_SET_PROC_COEF, 0x5029 },
8590                         { }
8591                 },
8592                 .chained = true,
8593                 .chain_id = ALC286_FIXUP_ACER_AIO_MIC_NO_PRESENCE
8594         },
8595         [ALC256_FIXUP_ASUS_HEADSET_MIC] = {
8596                 .type = HDA_FIXUP_PINS,
8597                 .v.pins = (const struct hda_pintbl[]) {
8598                         { 0x19, 0x03a11020 }, /* headset mic with jack detect */
8599                         { }
8600                 },
8601                 .chained = true,
8602                 .chain_id = ALC256_FIXUP_ASUS_HEADSET_MODE
8603         },
8604         [ALC256_FIXUP_ASUS_MIC_NO_PRESENCE] = {
8605                 .type = HDA_FIXUP_PINS,
8606                 .v.pins = (const struct hda_pintbl[]) {
8607                         { 0x19, 0x04a11120 }, /* use as headset mic, without its own jack detect */
8608                         { }
8609                 },
8610                 .chained = true,
8611                 .chain_id = ALC256_FIXUP_ASUS_HEADSET_MODE
8612         },
8613         [ALC299_FIXUP_PREDATOR_SPK] = {
8614                 .type = HDA_FIXUP_PINS,
8615                 .v.pins = (const struct hda_pintbl[]) {
8616                         { 0x21, 0x90170150 }, /* use as headset mic, without its own jack detect */
8617                         { }
8618                 }
8619         },
8620         [ALC256_FIXUP_MEDION_HEADSET_NO_PRESENCE] = {
8621                 .type = HDA_FIXUP_PINS,
8622                 .v.pins = (const struct hda_pintbl[]) {
8623                         { 0x19, 0x04a11040 },
8624                         { 0x21, 0x04211020 },
8625                         { }
8626                 },
8627                 .chained = true,
8628                 .chain_id = ALC256_FIXUP_ASUS_HEADSET_MODE
8629         },
8630         [ALC289_FIXUP_DELL_SPK1] = {
8631                 .type = HDA_FIXUP_PINS,
8632                 .v.pins = (const struct hda_pintbl[]) {
8633                         { 0x14, 0x90170140 },
8634                         { }
8635                 },
8636                 .chained = true,
8637                 .chain_id = ALC269_FIXUP_DELL4_MIC_NO_PRESENCE
8638         },
8639         [ALC289_FIXUP_DELL_SPK2] = {
8640                 .type = HDA_FIXUP_PINS,
8641                 .v.pins = (const struct hda_pintbl[]) {
8642                         { 0x17, 0x90170130 }, /* bass spk */
8643                         { }
8644                 },
8645                 .chained = true,
8646                 .chain_id = ALC269_FIXUP_DELL4_MIC_NO_PRESENCE
8647         },
8648         [ALC289_FIXUP_DUAL_SPK] = {
8649                 .type = HDA_FIXUP_FUNC,
8650                 .v.func = alc285_fixup_speaker2_to_dac1,
8651                 .chained = true,
8652                 .chain_id = ALC289_FIXUP_DELL_SPK2
8653         },
8654         [ALC289_FIXUP_RTK_AMP_DUAL_SPK] = {
8655                 .type = HDA_FIXUP_FUNC,
8656                 .v.func = alc285_fixup_speaker2_to_dac1,
8657                 .chained = true,
8658                 .chain_id = ALC289_FIXUP_DELL_SPK1
8659         },
8660         [ALC294_FIXUP_SPK2_TO_DAC1] = {
8661                 .type = HDA_FIXUP_FUNC,
8662                 .v.func = alc285_fixup_speaker2_to_dac1,
8663                 .chained = true,
8664                 .chain_id = ALC294_FIXUP_ASUS_HEADSET_MIC
8665         },
8666         [ALC294_FIXUP_ASUS_DUAL_SPK] = {
8667                 .type = HDA_FIXUP_FUNC,
8668                 /* The GPIO must be pulled to initialize the AMP */
8669                 .v.func = alc_fixup_gpio4,
8670                 .chained = true,
8671                 .chain_id = ALC294_FIXUP_SPK2_TO_DAC1
8672         },
8673         [ALC294_FIXUP_ASUS_ALLY] = {
8674                 .type = HDA_FIXUP_FUNC,
8675                 .v.func = cs35l41_fixup_i2c_two,
8676                 .chained = true,
8677                 .chain_id = ALC294_FIXUP_ASUS_ALLY_PINS
8678         },
8679         [ALC294_FIXUP_ASUS_ALLY_PINS] = {
8680                 .type = HDA_FIXUP_PINS,
8681                 .v.pins = (const struct hda_pintbl[]) {
8682                         { 0x19, 0x03a11050 },
8683                         { 0x1a, 0x03a11c30 },
8684                         { 0x21, 0x03211420 },
8685                         { }
8686                 },
8687                 .chained = true,
8688                 .chain_id = ALC294_FIXUP_ASUS_ALLY_VERBS
8689         },
8690         [ALC294_FIXUP_ASUS_ALLY_VERBS] = {
8691                 .type = HDA_FIXUP_VERBS,
8692                 .v.verbs = (const struct hda_verb[]) {
8693                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x45 },
8694                         { 0x20, AC_VERB_SET_PROC_COEF, 0x5089 },
8695                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x46 },
8696                         { 0x20, AC_VERB_SET_PROC_COEF, 0x0004 },
8697                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x47 },
8698                         { 0x20, AC_VERB_SET_PROC_COEF, 0xa47a },
8699                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x49 },
8700                         { 0x20, AC_VERB_SET_PROC_COEF, 0x0049},
8701                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x4a },
8702                         { 0x20, AC_VERB_SET_PROC_COEF, 0x201b },
8703                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x6b },
8704                         { 0x20, AC_VERB_SET_PROC_COEF, 0x4278},
8705                         { }
8706                 },
8707                 .chained = true,
8708                 .chain_id = ALC294_FIXUP_ASUS_ALLY_SPEAKER
8709         },
8710         [ALC294_FIXUP_ASUS_ALLY_SPEAKER] = {
8711                 .type = HDA_FIXUP_FUNC,
8712                 .v.func = alc285_fixup_speaker2_to_dac1,
8713         },
8714         [ALC285_FIXUP_THINKPAD_X1_GEN7] = {
8715                 .type = HDA_FIXUP_FUNC,
8716                 .v.func = alc285_fixup_thinkpad_x1_gen7,
8717                 .chained = true,
8718                 .chain_id = ALC269_FIXUP_THINKPAD_ACPI
8719         },
8720         [ALC285_FIXUP_THINKPAD_HEADSET_JACK] = {
8721                 .type = HDA_FIXUP_FUNC,
8722                 .v.func = alc_fixup_headset_jack,
8723                 .chained = true,
8724                 .chain_id = ALC285_FIXUP_THINKPAD_X1_GEN7
8725         },
8726         [ALC294_FIXUP_ASUS_HPE] = {
8727                 .type = HDA_FIXUP_VERBS,
8728                 .v.verbs = (const struct hda_verb[]) {
8729                         /* Set EAPD high */
8730                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x0f },
8731                         { 0x20, AC_VERB_SET_PROC_COEF, 0x7774 },
8732                         { }
8733                 },
8734                 .chained = true,
8735                 .chain_id = ALC294_FIXUP_ASUS_HEADSET_MIC
8736         },
8737         [ALC294_FIXUP_ASUS_GX502_PINS] = {
8738                 .type = HDA_FIXUP_PINS,
8739                 .v.pins = (const struct hda_pintbl[]) {
8740                         { 0x19, 0x03a11050 }, /* front HP mic */
8741                         { 0x1a, 0x01a11830 }, /* rear external mic */
8742                         { 0x21, 0x03211020 }, /* front HP out */
8743                         { }
8744                 },
8745                 .chained = true,
8746                 .chain_id = ALC294_FIXUP_ASUS_GX502_VERBS
8747         },
8748         [ALC294_FIXUP_ASUS_GX502_VERBS] = {
8749                 .type = HDA_FIXUP_VERBS,
8750                 .v.verbs = (const struct hda_verb[]) {
8751                         /* set 0x15 to HP-OUT ctrl */
8752                         { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0 },
8753                         /* unmute the 0x15 amp */
8754                         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000 },
8755                         { }
8756                 },
8757                 .chained = true,
8758                 .chain_id = ALC294_FIXUP_ASUS_GX502_HP
8759         },
8760         [ALC294_FIXUP_ASUS_GX502_HP] = {
8761                 .type = HDA_FIXUP_FUNC,
8762                 .v.func = alc294_fixup_gx502_hp,
8763         },
8764         [ALC294_FIXUP_ASUS_GU502_PINS] = {
8765                 .type = HDA_FIXUP_PINS,
8766                 .v.pins = (const struct hda_pintbl[]) {
8767                         { 0x19, 0x01a11050 }, /* rear HP mic */
8768                         { 0x1a, 0x01a11830 }, /* rear external mic */
8769                         { 0x21, 0x012110f0 }, /* rear HP out */
8770                         { }
8771                 },
8772                 .chained = true,
8773                 .chain_id = ALC294_FIXUP_ASUS_GU502_VERBS
8774         },
8775         [ALC294_FIXUP_ASUS_GU502_VERBS] = {
8776                 .type = HDA_FIXUP_VERBS,
8777                 .v.verbs = (const struct hda_verb[]) {
8778                         /* set 0x15 to HP-OUT ctrl */
8779                         { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0 },
8780                         /* unmute the 0x15 amp */
8781                         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000 },
8782                         /* set 0x1b to HP-OUT */
8783                         { 0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
8784                         { }
8785                 },
8786                 .chained = true,
8787                 .chain_id = ALC294_FIXUP_ASUS_GU502_HP
8788         },
8789         [ALC294_FIXUP_ASUS_GU502_HP] = {
8790                 .type = HDA_FIXUP_FUNC,
8791                 .v.func = alc294_fixup_gu502_hp,
8792         },
8793          [ALC294_FIXUP_ASUS_G513_PINS] = {
8794                 .type = HDA_FIXUP_PINS,
8795                 .v.pins = (const struct hda_pintbl[]) {
8796                                 { 0x19, 0x03a11050 }, /* front HP mic */
8797                                 { 0x1a, 0x03a11c30 }, /* rear external mic */
8798                                 { 0x21, 0x03211420 }, /* front HP out */
8799                                 { }
8800                 },
8801         },
8802         [ALC285_FIXUP_ASUS_G533Z_PINS] = {
8803                 .type = HDA_FIXUP_PINS,
8804                 .v.pins = (const struct hda_pintbl[]) {
8805                         { 0x14, 0x90170152 }, /* Speaker Surround Playback Switch */
8806                         { 0x19, 0x03a19020 }, /* Mic Boost Volume */
8807                         { 0x1a, 0x03a11c30 }, /* Mic Boost Volume */
8808                         { 0x1e, 0x90170151 }, /* Rear jack, IN OUT EAPD Detect */
8809                         { 0x21, 0x03211420 },
8810                         { }
8811                 },
8812         },
8813         [ALC294_FIXUP_ASUS_COEF_1B] = {
8814                 .type = HDA_FIXUP_VERBS,
8815                 .v.verbs = (const struct hda_verb[]) {
8816                         /* Set bit 10 to correct noisy output after reboot from
8817                          * Windows 10 (due to pop noise reduction?)
8818                          */
8819                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x1b },
8820                         { 0x20, AC_VERB_SET_PROC_COEF, 0x4e4b },
8821                         { }
8822                 },
8823                 .chained = true,
8824                 .chain_id = ALC289_FIXUP_ASUS_GA401,
8825         },
8826         [ALC285_FIXUP_HP_GPIO_LED] = {
8827                 .type = HDA_FIXUP_FUNC,
8828                 .v.func = alc285_fixup_hp_gpio_led,
8829         },
8830         [ALC285_FIXUP_HP_MUTE_LED] = {
8831                 .type = HDA_FIXUP_FUNC,
8832                 .v.func = alc285_fixup_hp_mute_led,
8833         },
8834         [ALC285_FIXUP_HP_SPECTRE_X360_MUTE_LED] = {
8835                 .type = HDA_FIXUP_FUNC,
8836                 .v.func = alc285_fixup_hp_spectre_x360_mute_led,
8837         },
8838         [ALC236_FIXUP_HP_MUTE_LED_COEFBIT2] = {
8839             .type = HDA_FIXUP_FUNC,
8840             .v.func = alc236_fixup_hp_mute_led_coefbit2,
8841         },
8842         [ALC236_FIXUP_HP_GPIO_LED] = {
8843                 .type = HDA_FIXUP_FUNC,
8844                 .v.func = alc236_fixup_hp_gpio_led,
8845         },
8846         [ALC236_FIXUP_HP_MUTE_LED] = {
8847                 .type = HDA_FIXUP_FUNC,
8848                 .v.func = alc236_fixup_hp_mute_led,
8849         },
8850         [ALC236_FIXUP_HP_MUTE_LED_MICMUTE_VREF] = {
8851                 .type = HDA_FIXUP_FUNC,
8852                 .v.func = alc236_fixup_hp_mute_led_micmute_vref,
8853         },
8854         [ALC298_FIXUP_SAMSUNG_AMP] = {
8855                 .type = HDA_FIXUP_FUNC,
8856                 .v.func = alc298_fixup_samsung_amp,
8857                 .chained = true,
8858                 .chain_id = ALC298_FIXUP_SAMSUNG_HEADPHONE_VERY_QUIET
8859         },
8860         [ALC298_FIXUP_SAMSUNG_HEADPHONE_VERY_QUIET] = {
8861                 .type = HDA_FIXUP_VERBS,
8862                 .v.verbs = (const struct hda_verb[]) {
8863                         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc5 },
8864                         { }
8865                 },
8866         },
8867         [ALC256_FIXUP_SAMSUNG_HEADPHONE_VERY_QUIET] = {
8868                 .type = HDA_FIXUP_VERBS,
8869                 .v.verbs = (const struct hda_verb[]) {
8870                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x08},
8871                         { 0x20, AC_VERB_SET_PROC_COEF, 0x2fcf},
8872                         { }
8873                 },
8874         },
8875         [ALC295_FIXUP_ASUS_MIC_NO_PRESENCE] = {
8876                 .type = HDA_FIXUP_PINS,
8877                 .v.pins = (const struct hda_pintbl[]) {
8878                         { 0x19, 0x01a1913c }, /* use as headset mic, without its own jack detect */
8879                         { }
8880                 },
8881                 .chained = true,
8882                 .chain_id = ALC269_FIXUP_HEADSET_MODE
8883         },
8884         [ALC269VC_FIXUP_ACER_VCOPPERBOX_PINS] = {
8885                 .type = HDA_FIXUP_PINS,
8886                 .v.pins = (const struct hda_pintbl[]) {
8887                         { 0x14, 0x90100120 }, /* use as internal speaker */
8888                         { 0x18, 0x02a111f0 }, /* use as headset mic, without its own jack detect */
8889                         { 0x1a, 0x01011020 }, /* use as line out */
8890                         { },
8891                 },
8892                 .chained = true,
8893                 .chain_id = ALC269_FIXUP_HEADSET_MIC
8894         },
8895         [ALC269VC_FIXUP_ACER_HEADSET_MIC] = {
8896                 .type = HDA_FIXUP_PINS,
8897                 .v.pins = (const struct hda_pintbl[]) {
8898                         { 0x18, 0x02a11030 }, /* use as headset mic */
8899                         { }
8900                 },
8901                 .chained = true,
8902                 .chain_id = ALC269_FIXUP_HEADSET_MIC
8903         },
8904         [ALC269VC_FIXUP_ACER_MIC_NO_PRESENCE] = {
8905                 .type = HDA_FIXUP_PINS,
8906                 .v.pins = (const struct hda_pintbl[]) {
8907                         { 0x18, 0x01a11130 }, /* use as headset mic, without its own jack detect */
8908                         { }
8909                 },
8910                 .chained = true,
8911                 .chain_id = ALC269_FIXUP_HEADSET_MIC
8912         },
8913         [ALC289_FIXUP_ASUS_GA401] = {
8914                 .type = HDA_FIXUP_FUNC,
8915                 .v.func = alc289_fixup_asus_ga401,
8916                 .chained = true,
8917                 .chain_id = ALC289_FIXUP_ASUS_GA502,
8918         },
8919         [ALC289_FIXUP_ASUS_GA502] = {
8920                 .type = HDA_FIXUP_PINS,
8921                 .v.pins = (const struct hda_pintbl[]) {
8922                         { 0x19, 0x03a11020 }, /* headset mic with jack detect */
8923                         { }
8924                 },
8925         },
8926         [ALC256_FIXUP_ACER_MIC_NO_PRESENCE] = {
8927                 .type = HDA_FIXUP_PINS,
8928                 .v.pins = (const struct hda_pintbl[]) {
8929                         { 0x19, 0x02a11120 }, /* use as headset mic, without its own jack detect */
8930                         { }
8931                 },
8932                 .chained = true,
8933                 .chain_id = ALC256_FIXUP_ASUS_HEADSET_MODE
8934         },
8935         [ALC285_FIXUP_HP_GPIO_AMP_INIT] = {
8936                 .type = HDA_FIXUP_FUNC,
8937                 .v.func = alc285_fixup_hp_gpio_amp_init,
8938                 .chained = true,
8939                 .chain_id = ALC285_FIXUP_HP_GPIO_LED
8940         },
8941         [ALC269_FIXUP_CZC_B20] = {
8942                 .type = HDA_FIXUP_PINS,
8943                 .v.pins = (const struct hda_pintbl[]) {
8944                         { 0x12, 0x411111f0 },
8945                         { 0x14, 0x90170110 }, /* speaker */
8946                         { 0x15, 0x032f1020 }, /* HP out */
8947                         { 0x17, 0x411111f0 },
8948                         { 0x18, 0x03ab1040 }, /* mic */
8949                         { 0x19, 0xb7a7013f },
8950                         { 0x1a, 0x0181305f },
8951                         { 0x1b, 0x411111f0 },
8952                         { 0x1d, 0x411111f0 },
8953                         { 0x1e, 0x411111f0 },
8954                         { }
8955                 },
8956                 .chain_id = ALC269_FIXUP_DMIC,
8957         },
8958         [ALC269_FIXUP_CZC_TMI] = {
8959                 .type = HDA_FIXUP_PINS,
8960                 .v.pins = (const struct hda_pintbl[]) {
8961                         { 0x12, 0x4000c000 },
8962                         { 0x14, 0x90170110 }, /* speaker */
8963                         { 0x15, 0x0421401f }, /* HP out */
8964                         { 0x17, 0x411111f0 },
8965                         { 0x18, 0x04a19020 }, /* mic */
8966                         { 0x19, 0x411111f0 },
8967                         { 0x1a, 0x411111f0 },
8968                         { 0x1b, 0x411111f0 },
8969                         { 0x1d, 0x40448505 },
8970                         { 0x1e, 0x411111f0 },
8971                         { 0x20, 0x8000ffff },
8972                         { }
8973                 },
8974                 .chain_id = ALC269_FIXUP_DMIC,
8975         },
8976         [ALC269_FIXUP_CZC_L101] = {
8977                 .type = HDA_FIXUP_PINS,
8978                 .v.pins = (const struct hda_pintbl[]) {
8979                         { 0x12, 0x40000000 },
8980                         { 0x14, 0x01014010 }, /* speaker */
8981                         { 0x15, 0x411111f0 }, /* HP out */
8982                         { 0x16, 0x411111f0 },
8983                         { 0x18, 0x01a19020 }, /* mic */
8984                         { 0x19, 0x02a19021 },
8985                         { 0x1a, 0x0181302f },
8986                         { 0x1b, 0x0221401f },
8987                         { 0x1c, 0x411111f0 },
8988                         { 0x1d, 0x4044c601 },
8989                         { 0x1e, 0x411111f0 },
8990                         { }
8991                 },
8992                 .chain_id = ALC269_FIXUP_DMIC,
8993         },
8994         [ALC269_FIXUP_LEMOTE_A1802] = {
8995                 .type = HDA_FIXUP_PINS,
8996                 .v.pins = (const struct hda_pintbl[]) {
8997                         { 0x12, 0x40000000 },
8998                         { 0x14, 0x90170110 }, /* speaker */
8999                         { 0x17, 0x411111f0 },
9000                         { 0x18, 0x03a19040 }, /* mic1 */
9001                         { 0x19, 0x90a70130 }, /* mic2 */
9002                         { 0x1a, 0x411111f0 },
9003                         { 0x1b, 0x411111f0 },
9004                         { 0x1d, 0x40489d2d },
9005                         { 0x1e, 0x411111f0 },
9006                         { 0x20, 0x0003ffff },
9007                         { 0x21, 0x03214020 },
9008                         { }
9009                 },
9010                 .chain_id = ALC269_FIXUP_DMIC,
9011         },
9012         [ALC269_FIXUP_LEMOTE_A190X] = {
9013                 .type = HDA_FIXUP_PINS,
9014                 .v.pins = (const struct hda_pintbl[]) {
9015                         { 0x14, 0x99130110 }, /* speaker */
9016                         { 0x15, 0x0121401f }, /* HP out */
9017                         { 0x18, 0x01a19c20 }, /* rear  mic */
9018                         { 0x19, 0x99a3092f }, /* front mic */
9019                         { 0x1b, 0x0201401f }, /* front lineout */
9020                         { }
9021                 },
9022                 .chain_id = ALC269_FIXUP_DMIC,
9023         },
9024         [ALC256_FIXUP_INTEL_NUC8_RUGGED] = {
9025                 .type = HDA_FIXUP_PINS,
9026                 .v.pins = (const struct hda_pintbl[]) {
9027                         { 0x1b, 0x01a1913c }, /* use as headset mic, without its own jack detect */
9028                         { }
9029                 },
9030                 .chained = true,
9031                 .chain_id = ALC269_FIXUP_HEADSET_MODE
9032         },
9033         [ALC256_FIXUP_INTEL_NUC10] = {
9034                 .type = HDA_FIXUP_PINS,
9035                 .v.pins = (const struct hda_pintbl[]) {
9036                         { 0x19, 0x01a1913c }, /* use as headset mic, without its own jack detect */
9037                         { }
9038                 },
9039                 .chained = true,
9040                 .chain_id = ALC269_FIXUP_HEADSET_MODE
9041         },
9042         [ALC255_FIXUP_XIAOMI_HEADSET_MIC] = {
9043                 .type = HDA_FIXUP_VERBS,
9044                 .v.verbs = (const struct hda_verb[]) {
9045                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x45 },
9046                         { 0x20, AC_VERB_SET_PROC_COEF, 0x5089 },
9047                         { }
9048                 },
9049                 .chained = true,
9050                 .chain_id = ALC289_FIXUP_ASUS_GA502
9051         },
9052         [ALC274_FIXUP_HP_MIC] = {
9053                 .type = HDA_FIXUP_VERBS,
9054                 .v.verbs = (const struct hda_verb[]) {
9055                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x45 },
9056                         { 0x20, AC_VERB_SET_PROC_COEF, 0x5089 },
9057                         { }
9058                 },
9059         },
9060         [ALC274_FIXUP_HP_HEADSET_MIC] = {
9061                 .type = HDA_FIXUP_FUNC,
9062                 .v.func = alc274_fixup_hp_headset_mic,
9063                 .chained = true,
9064                 .chain_id = ALC274_FIXUP_HP_MIC
9065         },
9066         [ALC274_FIXUP_HP_ENVY_GPIO] = {
9067                 .type = HDA_FIXUP_FUNC,
9068                 .v.func = alc274_fixup_hp_envy_gpio,
9069         },
9070         [ALC256_FIXUP_ASUS_HPE] = {
9071                 .type = HDA_FIXUP_VERBS,
9072                 .v.verbs = (const struct hda_verb[]) {
9073                         /* Set EAPD high */
9074                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x0f },
9075                         { 0x20, AC_VERB_SET_PROC_COEF, 0x7778 },
9076                         { }
9077                 },
9078                 .chained = true,
9079                 .chain_id = ALC294_FIXUP_ASUS_HEADSET_MIC
9080         },
9081         [ALC285_FIXUP_THINKPAD_NO_BASS_SPK_HEADSET_JACK] = {
9082                 .type = HDA_FIXUP_FUNC,
9083                 .v.func = alc_fixup_headset_jack,
9084                 .chained = true,
9085                 .chain_id = ALC269_FIXUP_THINKPAD_ACPI
9086         },
9087         [ALC287_FIXUP_HP_GPIO_LED] = {
9088                 .type = HDA_FIXUP_FUNC,
9089                 .v.func = alc287_fixup_hp_gpio_led,
9090         },
9091         [ALC256_FIXUP_HP_HEADSET_MIC] = {
9092                 .type = HDA_FIXUP_FUNC,
9093                 .v.func = alc274_fixup_hp_headset_mic,
9094         },
9095         [ALC236_FIXUP_DELL_AIO_HEADSET_MIC] = {
9096                 .type = HDA_FIXUP_FUNC,
9097                 .v.func = alc_fixup_no_int_mic,
9098                 .chained = true,
9099                 .chain_id = ALC255_FIXUP_DELL1_MIC_NO_PRESENCE
9100         },
9101         [ALC282_FIXUP_ACER_DISABLE_LINEOUT] = {
9102                 .type = HDA_FIXUP_PINS,
9103                 .v.pins = (const struct hda_pintbl[]) {
9104                         { 0x1b, 0x411111f0 },
9105                         { 0x18, 0x01a1913c }, /* use as headset mic, without its own jack detect */
9106                         { },
9107                 },
9108                 .chained = true,
9109                 .chain_id = ALC269_FIXUP_HEADSET_MODE
9110         },
9111         [ALC255_FIXUP_ACER_LIMIT_INT_MIC_BOOST] = {
9112                 .type = HDA_FIXUP_FUNC,
9113                 .v.func = alc269_fixup_limit_int_mic_boost,
9114                 .chained = true,
9115                 .chain_id = ALC255_FIXUP_ACER_MIC_NO_PRESENCE,
9116         },
9117         [ALC256_FIXUP_ACER_HEADSET_MIC] = {
9118                 .type = HDA_FIXUP_PINS,
9119                 .v.pins = (const struct hda_pintbl[]) {
9120                         { 0x19, 0x02a1113c }, /* use as headset mic, without its own jack detect */
9121                         { 0x1a, 0x90a1092f }, /* use as internal mic */
9122                         { }
9123                 },
9124                 .chained = true,
9125                 .chain_id = ALC269_FIXUP_HEADSET_MODE_NO_HP_MIC
9126         },
9127         [ALC285_FIXUP_IDEAPAD_S740_COEF] = {
9128                 .type = HDA_FIXUP_FUNC,
9129                 .v.func = alc285_fixup_ideapad_s740_coef,
9130                 .chained = true,
9131                 .chain_id = ALC269_FIXUP_THINKPAD_ACPI,
9132         },
9133         [ALC285_FIXUP_HP_LIMIT_INT_MIC_BOOST] = {
9134                 .type = HDA_FIXUP_FUNC,
9135                 .v.func = alc269_fixup_limit_int_mic_boost,
9136                 .chained = true,
9137                 .chain_id = ALC285_FIXUP_HP_MUTE_LED,
9138         },
9139         [ALC295_FIXUP_ASUS_DACS] = {
9140                 .type = HDA_FIXUP_FUNC,
9141                 .v.func = alc295_fixup_asus_dacs,
9142         },
9143         [ALC295_FIXUP_HP_OMEN] = {
9144                 .type = HDA_FIXUP_PINS,
9145                 .v.pins = (const struct hda_pintbl[]) {
9146                         { 0x12, 0xb7a60130 },
9147                         { 0x13, 0x40000000 },
9148                         { 0x14, 0x411111f0 },
9149                         { 0x16, 0x411111f0 },
9150                         { 0x17, 0x90170110 },
9151                         { 0x18, 0x411111f0 },
9152                         { 0x19, 0x02a11030 },
9153                         { 0x1a, 0x411111f0 },
9154                         { 0x1b, 0x04a19030 },
9155                         { 0x1d, 0x40600001 },
9156                         { 0x1e, 0x411111f0 },
9157                         { 0x21, 0x03211020 },
9158                         {}
9159                 },
9160                 .chained = true,
9161                 .chain_id = ALC269_FIXUP_HP_LINE1_MIC1_LED,
9162         },
9163         [ALC285_FIXUP_HP_SPECTRE_X360] = {
9164                 .type = HDA_FIXUP_FUNC,
9165                 .v.func = alc285_fixup_hp_spectre_x360,
9166         },
9167         [ALC285_FIXUP_HP_SPECTRE_X360_EB1] = {
9168                 .type = HDA_FIXUP_FUNC,
9169                 .v.func = alc285_fixup_hp_spectre_x360_eb1
9170         },
9171         [ALC285_FIXUP_HP_ENVY_X360] = {
9172                 .type = HDA_FIXUP_FUNC,
9173                 .v.func = alc285_fixup_hp_envy_x360,
9174                 .chained = true,
9175                 .chain_id = ALC285_FIXUP_HP_GPIO_AMP_INIT,
9176         },
9177         [ALC287_FIXUP_IDEAPAD_BASS_SPK_AMP] = {
9178                 .type = HDA_FIXUP_FUNC,
9179                 .v.func = alc285_fixup_ideapad_s740_coef,
9180                 .chained = true,
9181                 .chain_id = ALC285_FIXUP_THINKPAD_HEADSET_JACK,
9182         },
9183         [ALC623_FIXUP_LENOVO_THINKSTATION_P340] = {
9184                 .type = HDA_FIXUP_FUNC,
9185                 .v.func = alc_fixup_no_shutup,
9186                 .chained = true,
9187                 .chain_id = ALC283_FIXUP_HEADSET_MIC,
9188         },
9189         [ALC255_FIXUP_ACER_HEADPHONE_AND_MIC] = {
9190                 .type = HDA_FIXUP_PINS,
9191                 .v.pins = (const struct hda_pintbl[]) {
9192                         { 0x21, 0x03211030 }, /* Change the Headphone location to Left */
9193                         { }
9194                 },
9195                 .chained = true,
9196                 .chain_id = ALC255_FIXUP_XIAOMI_HEADSET_MIC
9197         },
9198         [ALC236_FIXUP_HP_LIMIT_INT_MIC_BOOST] = {
9199                 .type = HDA_FIXUP_FUNC,
9200                 .v.func = alc269_fixup_limit_int_mic_boost,
9201                 .chained = true,
9202                 .chain_id = ALC236_FIXUP_HP_MUTE_LED_MICMUTE_VREF,
9203         },
9204         [ALC285_FIXUP_LEGION_Y9000X_SPEAKERS] = {
9205                 .type = HDA_FIXUP_FUNC,
9206                 .v.func = alc285_fixup_ideapad_s740_coef,
9207                 .chained = true,
9208                 .chain_id = ALC285_FIXUP_LEGION_Y9000X_AUTOMUTE,
9209         },
9210         [ALC285_FIXUP_LEGION_Y9000X_AUTOMUTE] = {
9211                 .type = HDA_FIXUP_FUNC,
9212                 .v.func = alc287_fixup_legion_15imhg05_speakers,
9213                 .chained = true,
9214                 .chain_id = ALC269_FIXUP_THINKPAD_ACPI,
9215         },
9216         [ALC287_FIXUP_LEGION_15IMHG05_SPEAKERS] = {
9217                 .type = HDA_FIXUP_VERBS,
9218                 //.v.verbs = legion_15imhg05_coefs,
9219                 .v.verbs = (const struct hda_verb[]) {
9220                          // set left speaker Legion 7i.
9221                          { 0x20, AC_VERB_SET_COEF_INDEX, 0x24 },
9222                          { 0x20, AC_VERB_SET_PROC_COEF, 0x41 },
9223
9224                          { 0x20, AC_VERB_SET_COEF_INDEX, 0x26 },
9225                          { 0x20, AC_VERB_SET_PROC_COEF, 0xc },
9226                          { 0x20, AC_VERB_SET_PROC_COEF, 0x0 },
9227                          { 0x20, AC_VERB_SET_PROC_COEF, 0x1a },
9228                          { 0x20, AC_VERB_SET_PROC_COEF, 0xb020 },
9229
9230                          { 0x20, AC_VERB_SET_COEF_INDEX, 0x26 },
9231                          { 0x20, AC_VERB_SET_PROC_COEF, 0x2 },
9232                          { 0x20, AC_VERB_SET_PROC_COEF, 0x0 },
9233                          { 0x20, AC_VERB_SET_PROC_COEF, 0x0 },
9234                          { 0x20, AC_VERB_SET_PROC_COEF, 0xb020 },
9235
9236                          // set right speaker Legion 7i.
9237                          { 0x20, AC_VERB_SET_COEF_INDEX, 0x24 },
9238                          { 0x20, AC_VERB_SET_PROC_COEF, 0x42 },
9239
9240                          { 0x20, AC_VERB_SET_COEF_INDEX, 0x26 },
9241                          { 0x20, AC_VERB_SET_PROC_COEF, 0xc },
9242                          { 0x20, AC_VERB_SET_PROC_COEF, 0x0 },
9243                          { 0x20, AC_VERB_SET_PROC_COEF, 0x2a },
9244                          { 0x20, AC_VERB_SET_PROC_COEF, 0xb020 },
9245
9246                          { 0x20, AC_VERB_SET_COEF_INDEX, 0x26 },
9247                          { 0x20, AC_VERB_SET_PROC_COEF, 0x2 },
9248                          { 0x20, AC_VERB_SET_PROC_COEF, 0x0 },
9249                          { 0x20, AC_VERB_SET_PROC_COEF, 0x0 },
9250                          { 0x20, AC_VERB_SET_PROC_COEF, 0xb020 },
9251                          {}
9252                 },
9253                 .chained = true,
9254                 .chain_id = ALC287_FIXUP_LEGION_15IMHG05_AUTOMUTE,
9255         },
9256         [ALC287_FIXUP_LEGION_15IMHG05_AUTOMUTE] = {
9257                 .type = HDA_FIXUP_FUNC,
9258                 .v.func = alc287_fixup_legion_15imhg05_speakers,
9259                 .chained = true,
9260                 .chain_id = ALC269_FIXUP_HEADSET_MODE,
9261         },
9262         [ALC287_FIXUP_YOGA7_14ITL_SPEAKERS] = {
9263                 .type = HDA_FIXUP_VERBS,
9264                 .v.verbs = (const struct hda_verb[]) {
9265                          // set left speaker Yoga 7i.
9266                          { 0x20, AC_VERB_SET_COEF_INDEX, 0x24 },
9267                          { 0x20, AC_VERB_SET_PROC_COEF, 0x41 },
9268
9269                          { 0x20, AC_VERB_SET_COEF_INDEX, 0x26 },
9270                          { 0x20, AC_VERB_SET_PROC_COEF, 0xc },
9271                          { 0x20, AC_VERB_SET_PROC_COEF, 0x0 },
9272                          { 0x20, AC_VERB_SET_PROC_COEF, 0x1a },
9273                          { 0x20, AC_VERB_SET_PROC_COEF, 0xb020 },
9274
9275                          { 0x20, AC_VERB_SET_COEF_INDEX, 0x26 },
9276                          { 0x20, AC_VERB_SET_PROC_COEF, 0x2 },
9277                          { 0x20, AC_VERB_SET_PROC_COEF, 0x0 },
9278                          { 0x20, AC_VERB_SET_PROC_COEF, 0x0 },
9279                          { 0x20, AC_VERB_SET_PROC_COEF, 0xb020 },
9280
9281                          // set right speaker Yoga 7i.
9282                          { 0x20, AC_VERB_SET_COEF_INDEX, 0x24 },
9283                          { 0x20, AC_VERB_SET_PROC_COEF, 0x46 },
9284
9285                          { 0x20, AC_VERB_SET_COEF_INDEX, 0x26 },
9286                          { 0x20, AC_VERB_SET_PROC_COEF, 0xc },
9287                          { 0x20, AC_VERB_SET_PROC_COEF, 0x0 },
9288                          { 0x20, AC_VERB_SET_PROC_COEF, 0x2a },
9289                          { 0x20, AC_VERB_SET_PROC_COEF, 0xb020 },
9290
9291                          { 0x20, AC_VERB_SET_COEF_INDEX, 0x26 },
9292                          { 0x20, AC_VERB_SET_PROC_COEF, 0x2 },
9293                          { 0x20, AC_VERB_SET_PROC_COEF, 0x0 },
9294                          { 0x20, AC_VERB_SET_PROC_COEF, 0x0 },
9295                          { 0x20, AC_VERB_SET_PROC_COEF, 0xb020 },
9296                          {}
9297                 },
9298                 .chained = true,
9299                 .chain_id = ALC269_FIXUP_HEADSET_MODE,
9300         },
9301         [ALC298_FIXUP_LENOVO_C940_DUET7] = {
9302                 .type = HDA_FIXUP_FUNC,
9303                 .v.func = alc298_fixup_lenovo_c940_duet7,
9304         },
9305         [ALC287_FIXUP_LENOVO_14IRP8_DUETITL] = {
9306                 .type = HDA_FIXUP_FUNC,
9307                 .v.func = alc287_fixup_lenovo_14irp8_duetitl,
9308         },
9309         [ALC287_FIXUP_13S_GEN2_SPEAKERS] = {
9310                 .type = HDA_FIXUP_VERBS,
9311                 .v.verbs = (const struct hda_verb[]) {
9312                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x24 },
9313                         { 0x20, AC_VERB_SET_PROC_COEF, 0x41 },
9314                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x26 },
9315                         { 0x20, AC_VERB_SET_PROC_COEF, 0x2 },
9316                         { 0x20, AC_VERB_SET_PROC_COEF, 0x0 },
9317                         { 0x20, AC_VERB_SET_PROC_COEF, 0x0 },
9318                         { 0x20, AC_VERB_SET_PROC_COEF, 0xb020 },
9319                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x24 },
9320                         { 0x20, AC_VERB_SET_PROC_COEF, 0x42 },
9321                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x26 },
9322                         { 0x20, AC_VERB_SET_PROC_COEF, 0x2 },
9323                         { 0x20, AC_VERB_SET_PROC_COEF, 0x0 },
9324                         { 0x20, AC_VERB_SET_PROC_COEF, 0x0 },
9325                         { 0x20, AC_VERB_SET_PROC_COEF, 0xb020 },
9326                         {}
9327                 },
9328                 .chained = true,
9329                 .chain_id = ALC269_FIXUP_HEADSET_MODE,
9330         },
9331         [ALC256_FIXUP_SET_COEF_DEFAULTS] = {
9332                 .type = HDA_FIXUP_FUNC,
9333                 .v.func = alc256_fixup_set_coef_defaults,
9334         },
9335         [ALC245_FIXUP_HP_GPIO_LED] = {
9336                 .type = HDA_FIXUP_FUNC,
9337                 .v.func = alc245_fixup_hp_gpio_led,
9338         },
9339         [ALC256_FIXUP_SYSTEM76_MIC_NO_PRESENCE] = {
9340                 .type = HDA_FIXUP_PINS,
9341                 .v.pins = (const struct hda_pintbl[]) {
9342                         { 0x19, 0x03a11120 }, /* use as headset mic, without its own jack detect */
9343                         { }
9344                 },
9345                 .chained = true,
9346                 .chain_id = ALC269_FIXUP_HEADSET_MODE_NO_HP_MIC,
9347         },
9348         [ALC233_FIXUP_NO_AUDIO_JACK] = {
9349                 .type = HDA_FIXUP_FUNC,
9350                 .v.func = alc233_fixup_no_audio_jack,
9351         },
9352         [ALC256_FIXUP_MIC_NO_PRESENCE_AND_RESUME] = {
9353                 .type = HDA_FIXUP_FUNC,
9354                 .v.func = alc256_fixup_mic_no_presence_and_resume,
9355                 .chained = true,
9356                 .chain_id = ALC269_FIXUP_HEADSET_MODE_NO_HP_MIC
9357         },
9358         [ALC287_FIXUP_LEGION_16ACHG6] = {
9359                 .type = HDA_FIXUP_FUNC,
9360                 .v.func = alc287_fixup_legion_16achg6_speakers,
9361         },
9362         [ALC287_FIXUP_CS35L41_I2C_2] = {
9363                 .type = HDA_FIXUP_FUNC,
9364                 .v.func = cs35l41_fixup_i2c_two,
9365         },
9366         [ALC287_FIXUP_CS35L41_I2C_2_HP_GPIO_LED] = {
9367                 .type = HDA_FIXUP_FUNC,
9368                 .v.func = cs35l41_fixup_i2c_two,
9369                 .chained = true,
9370                 .chain_id = ALC285_FIXUP_HP_MUTE_LED,
9371         },
9372         [ALC287_FIXUP_CS35L41_I2C_4] = {
9373                 .type = HDA_FIXUP_FUNC,
9374                 .v.func = cs35l41_fixup_i2c_four,
9375         },
9376         [ALC245_FIXUP_CS35L41_SPI_2] = {
9377                 .type = HDA_FIXUP_FUNC,
9378                 .v.func = cs35l41_fixup_spi_two,
9379         },
9380         [ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED] = {
9381                 .type = HDA_FIXUP_FUNC,
9382                 .v.func = cs35l41_fixup_spi_two,
9383                 .chained = true,
9384                 .chain_id = ALC285_FIXUP_HP_GPIO_LED,
9385         },
9386         [ALC245_FIXUP_CS35L41_SPI_4] = {
9387                 .type = HDA_FIXUP_FUNC,
9388                 .v.func = cs35l41_fixup_spi_four,
9389         },
9390         [ALC245_FIXUP_CS35L41_SPI_4_HP_GPIO_LED] = {
9391                 .type = HDA_FIXUP_FUNC,
9392                 .v.func = cs35l41_fixup_spi_four,
9393                 .chained = true,
9394                 .chain_id = ALC285_FIXUP_HP_GPIO_LED,
9395         },
9396         [ALC285_FIXUP_HP_SPEAKERS_MICMUTE_LED] = {
9397                 .type = HDA_FIXUP_VERBS,
9398                 .v.verbs = (const struct hda_verb[]) {
9399                          { 0x20, AC_VERB_SET_COEF_INDEX, 0x19 },
9400                          { 0x20, AC_VERB_SET_PROC_COEF, 0x8e11 },
9401                          { }
9402                 },
9403                 .chained = true,
9404                 .chain_id = ALC285_FIXUP_HP_MUTE_LED,
9405         },
9406         [ALC269_FIXUP_DELL4_MIC_NO_PRESENCE_QUIET] = {
9407                 .type = HDA_FIXUP_FUNC,
9408                 .v.func = alc_fixup_dell4_mic_no_presence_quiet,
9409                 .chained = true,
9410                 .chain_id = ALC269_FIXUP_DELL4_MIC_NO_PRESENCE,
9411         },
9412         [ALC295_FIXUP_FRAMEWORK_LAPTOP_MIC_NO_PRESENCE] = {
9413                 .type = HDA_FIXUP_PINS,
9414                 .v.pins = (const struct hda_pintbl[]) {
9415                         { 0x19, 0x02a1112c }, /* use as headset mic, without its own jack detect */
9416                         { }
9417                 },
9418                 .chained = true,
9419                 .chain_id = ALC269_FIXUP_HEADSET_MODE_NO_HP_MIC
9420         },
9421         [ALC287_FIXUP_LEGION_16ITHG6] = {
9422                 .type = HDA_FIXUP_FUNC,
9423                 .v.func = alc287_fixup_legion_16ithg6_speakers,
9424         },
9425         [ALC287_FIXUP_YOGA9_14IAP7_BASS_SPK] = {
9426                 .type = HDA_FIXUP_VERBS,
9427                 .v.verbs = (const struct hda_verb[]) {
9428                         // enable left speaker
9429                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x24 },
9430                         { 0x20, AC_VERB_SET_PROC_COEF, 0x41 },
9431
9432                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x26 },
9433                         { 0x20, AC_VERB_SET_PROC_COEF, 0xc },
9434                         { 0x20, AC_VERB_SET_PROC_COEF, 0x0 },
9435                         { 0x20, AC_VERB_SET_PROC_COEF, 0x1a },
9436                         { 0x20, AC_VERB_SET_PROC_COEF, 0xb020 },
9437
9438                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x26 },
9439                         { 0x20, AC_VERB_SET_PROC_COEF, 0xf },
9440                         { 0x20, AC_VERB_SET_PROC_COEF, 0x0 },
9441                         { 0x20, AC_VERB_SET_PROC_COEF, 0x42 },
9442                         { 0x20, AC_VERB_SET_PROC_COEF, 0xb020 },
9443
9444                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x26 },
9445                         { 0x20, AC_VERB_SET_PROC_COEF, 0x10 },
9446                         { 0x20, AC_VERB_SET_PROC_COEF, 0x0 },
9447                         { 0x20, AC_VERB_SET_PROC_COEF, 0x40 },
9448                         { 0x20, AC_VERB_SET_PROC_COEF, 0xb020 },
9449
9450                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x26 },
9451                         { 0x20, AC_VERB_SET_PROC_COEF, 0x2 },
9452                         { 0x20, AC_VERB_SET_PROC_COEF, 0x0 },
9453                         { 0x20, AC_VERB_SET_PROC_COEF, 0x0 },
9454                         { 0x20, AC_VERB_SET_PROC_COEF, 0xb020 },
9455
9456                         // enable right speaker
9457                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x24 },
9458                         { 0x20, AC_VERB_SET_PROC_COEF, 0x46 },
9459
9460                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x26 },
9461                         { 0x20, AC_VERB_SET_PROC_COEF, 0xc },
9462                         { 0x20, AC_VERB_SET_PROC_COEF, 0x0 },
9463                         { 0x20, AC_VERB_SET_PROC_COEF, 0x2a },
9464                         { 0x20, AC_VERB_SET_PROC_COEF, 0xb020 },
9465
9466                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x26 },
9467                         { 0x20, AC_VERB_SET_PROC_COEF, 0xf },
9468                         { 0x20, AC_VERB_SET_PROC_COEF, 0x0 },
9469                         { 0x20, AC_VERB_SET_PROC_COEF, 0x46 },
9470                         { 0x20, AC_VERB_SET_PROC_COEF, 0xb020 },
9471
9472                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x26 },
9473                         { 0x20, AC_VERB_SET_PROC_COEF, 0x10 },
9474                         { 0x20, AC_VERB_SET_PROC_COEF, 0x0 },
9475                         { 0x20, AC_VERB_SET_PROC_COEF, 0x44 },
9476                         { 0x20, AC_VERB_SET_PROC_COEF, 0xb020 },
9477
9478                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x26 },
9479                         { 0x20, AC_VERB_SET_PROC_COEF, 0x2 },
9480                         { 0x20, AC_VERB_SET_PROC_COEF, 0x0 },
9481                         { 0x20, AC_VERB_SET_PROC_COEF, 0x0 },
9482                         { 0x20, AC_VERB_SET_PROC_COEF, 0xb020 },
9483
9484                         { },
9485                 },
9486         },
9487         [ALC287_FIXUP_YOGA9_14IAP7_BASS_SPK_PIN] = {
9488                 .type = HDA_FIXUP_FUNC,
9489                 .v.func = alc287_fixup_yoga9_14iap7_bass_spk_pin,
9490                 .chained = true,
9491                 .chain_id = ALC287_FIXUP_YOGA9_14IAP7_BASS_SPK,
9492         },
9493         [ALC295_FIXUP_DELL_INSPIRON_TOP_SPEAKERS] = {
9494                 .type = HDA_FIXUP_FUNC,
9495                 .v.func = alc295_fixup_dell_inspiron_top_speakers,
9496                 .chained = true,
9497                 .chain_id = ALC269_FIXUP_DELL4_MIC_NO_PRESENCE,
9498         },
9499         [ALC236_FIXUP_DELL_DUAL_CODECS] = {
9500                 .type = HDA_FIXUP_PINS,
9501                 .v.func = alc1220_fixup_gb_dual_codecs,
9502                 .chained = true,
9503                 .chain_id = ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
9504         },
9505         [ALC287_FIXUP_CS35L41_I2C_2_THINKPAD_ACPI] = {
9506                 .type = HDA_FIXUP_FUNC,
9507                 .v.func = cs35l41_fixup_i2c_two,
9508                 .chained = true,
9509                 .chain_id = ALC285_FIXUP_THINKPAD_NO_BASS_SPK_HEADSET_JACK,
9510         },
9511         [ALC287_FIXUP_TAS2781_I2C] = {
9512                 .type = HDA_FIXUP_FUNC,
9513                 .v.func = tas2781_fixup_i2c,
9514                 .chained = true,
9515                 .chain_id = ALC285_FIXUP_THINKPAD_HEADSET_JACK,
9516         },
9517         [ALC287_FIXUP_YOGA7_14ARB7_I2C] = {
9518                 .type = HDA_FIXUP_FUNC,
9519                 .v.func = yoga7_14arb7_fixup_i2c,
9520                 .chained = true,
9521                 .chain_id = ALC285_FIXUP_THINKPAD_HEADSET_JACK,
9522         },
9523         [ALC245_FIXUP_HP_MUTE_LED_COEFBIT] = {
9524                 .type = HDA_FIXUP_FUNC,
9525                 .v.func = alc245_fixup_hp_mute_led_coefbit,
9526         },
9527         [ALC245_FIXUP_HP_X360_MUTE_LEDS] = {
9528                 .type = HDA_FIXUP_FUNC,
9529                 .v.func = alc245_fixup_hp_mute_led_coefbit,
9530                 .chained = true,
9531                 .chain_id = ALC245_FIXUP_HP_GPIO_LED
9532         },
9533         [ALC287_FIXUP_THINKPAD_I2S_SPK] = {
9534                 .type = HDA_FIXUP_FUNC,
9535                 .v.func = alc287_fixup_bind_dacs,
9536                 .chained = true,
9537                 .chain_id = ALC285_FIXUP_THINKPAD_NO_BASS_SPK_HEADSET_JACK,
9538         },
9539         [ALC287_FIXUP_MG_RTKC_CSAMP_CS35L41_I2C_THINKPAD] = {
9540                 .type = HDA_FIXUP_FUNC,
9541                 .v.func = alc287_fixup_bind_dacs,
9542                 .chained = true,
9543                 .chain_id = ALC287_FIXUP_CS35L41_I2C_2_THINKPAD_ACPI,
9544         },
9545         [ALC2XX_FIXUP_HEADSET_MIC] = {
9546                 .type = HDA_FIXUP_FUNC,
9547                 .v.func = alc_fixup_headset_mic,
9548         },
9549         [ALC289_FIXUP_DELL_CS35L41_SPI_2] = {
9550                 .type = HDA_FIXUP_FUNC,
9551                 .v.func = cs35l41_fixup_spi_two,
9552                 .chained = true,
9553                 .chain_id = ALC289_FIXUP_DUAL_SPK
9554         },
9555         [ALC294_FIXUP_CS35L41_I2C_2] = {
9556                 .type = HDA_FIXUP_FUNC,
9557                 .v.func = cs35l41_fixup_i2c_two,
9558         },
9559         [ALC245_FIXUP_CS35L56_SPI_4_HP_GPIO_LED] = {
9560                 .type = HDA_FIXUP_FUNC,
9561                 .v.func = cs35l56_fixup_spi_four,
9562                 .chained = true,
9563                 .chain_id = ALC285_FIXUP_HP_GPIO_LED,
9564         },
9565 };
9566
9567 static const struct snd_pci_quirk alc269_fixup_tbl[] = {
9568         SND_PCI_QUIRK(0x1025, 0x0283, "Acer TravelMate 8371", ALC269_FIXUP_INV_DMIC),
9569         SND_PCI_QUIRK(0x1025, 0x029b, "Acer 1810TZ", ALC269_FIXUP_INV_DMIC),
9570         SND_PCI_QUIRK(0x1025, 0x0349, "Acer AOD260", ALC269_FIXUP_INV_DMIC),
9571         SND_PCI_QUIRK(0x1025, 0x047c, "Acer AC700", ALC269_FIXUP_ACER_AC700),
9572         SND_PCI_QUIRK(0x1025, 0x072d, "Acer Aspire V5-571G", ALC269_FIXUP_ASPIRE_HEADSET_MIC),
9573         SND_PCI_QUIRK(0x1025, 0x0740, "Acer AO725", ALC271_FIXUP_HP_GATE_MIC_JACK),
9574         SND_PCI_QUIRK(0x1025, 0x0742, "Acer AO756", ALC271_FIXUP_HP_GATE_MIC_JACK),
9575         SND_PCI_QUIRK(0x1025, 0x0762, "Acer Aspire E1-472", ALC271_FIXUP_HP_GATE_MIC_JACK_E1_572),
9576         SND_PCI_QUIRK(0x1025, 0x0775, "Acer Aspire E1-572", ALC271_FIXUP_HP_GATE_MIC_JACK_E1_572),
9577         SND_PCI_QUIRK(0x1025, 0x079b, "Acer Aspire V5-573G", ALC282_FIXUP_ASPIRE_V5_PINS),
9578         SND_PCI_QUIRK(0x1025, 0x080d, "Acer Aspire V5-122P", ALC269_FIXUP_ASPIRE_HEADSET_MIC),
9579         SND_PCI_QUIRK(0x1025, 0x0840, "Acer Aspire E1", ALC269VB_FIXUP_ASPIRE_E1_COEF),
9580         SND_PCI_QUIRK(0x1025, 0x101c, "Acer Veriton N2510G", ALC269_FIXUP_LIFEBOOK),
9581         SND_PCI_QUIRK(0x1025, 0x102b, "Acer Aspire C24-860", ALC286_FIXUP_ACER_AIO_MIC_NO_PRESENCE),
9582         SND_PCI_QUIRK(0x1025, 0x1065, "Acer Aspire C20-820", ALC269VC_FIXUP_ACER_HEADSET_MIC),
9583         SND_PCI_QUIRK(0x1025, 0x106d, "Acer Cloudbook 14", ALC283_FIXUP_CHROME_BOOK),
9584         SND_PCI_QUIRK(0x1025, 0x1094, "Acer Aspire E5-575T", ALC255_FIXUP_ACER_LIMIT_INT_MIC_BOOST),
9585         SND_PCI_QUIRK(0x1025, 0x1099, "Acer Aspire E5-523G", ALC255_FIXUP_ACER_MIC_NO_PRESENCE),
9586         SND_PCI_QUIRK(0x1025, 0x110e, "Acer Aspire ES1-432", ALC255_FIXUP_ACER_MIC_NO_PRESENCE),
9587         SND_PCI_QUIRK(0x1025, 0x1166, "Acer Veriton N4640G", ALC269_FIXUP_LIFEBOOK),
9588         SND_PCI_QUIRK(0x1025, 0x1167, "Acer Veriton N6640G", ALC269_FIXUP_LIFEBOOK),
9589         SND_PCI_QUIRK(0x1025, 0x1246, "Acer Predator Helios 500", ALC299_FIXUP_PREDATOR_SPK),
9590         SND_PCI_QUIRK(0x1025, 0x1247, "Acer vCopperbox", ALC269VC_FIXUP_ACER_VCOPPERBOX_PINS),
9591         SND_PCI_QUIRK(0x1025, 0x1248, "Acer Veriton N4660G", ALC269VC_FIXUP_ACER_MIC_NO_PRESENCE),
9592         SND_PCI_QUIRK(0x1025, 0x1269, "Acer SWIFT SF314-54", ALC256_FIXUP_ACER_HEADSET_MIC),
9593         SND_PCI_QUIRK(0x1025, 0x126a, "Acer Swift SF114-32", ALC256_FIXUP_ACER_MIC_NO_PRESENCE),
9594         SND_PCI_QUIRK(0x1025, 0x128f, "Acer Veriton Z6860G", ALC286_FIXUP_ACER_AIO_HEADSET_MIC),
9595         SND_PCI_QUIRK(0x1025, 0x1290, "Acer Veriton Z4860G", ALC286_FIXUP_ACER_AIO_HEADSET_MIC),
9596         SND_PCI_QUIRK(0x1025, 0x1291, "Acer Veriton Z4660G", ALC286_FIXUP_ACER_AIO_HEADSET_MIC),
9597         SND_PCI_QUIRK(0x1025, 0x129c, "Acer SWIFT SF314-55", ALC256_FIXUP_ACER_HEADSET_MIC),
9598         SND_PCI_QUIRK(0x1025, 0x129d, "Acer SWIFT SF313-51", ALC256_FIXUP_ACER_MIC_NO_PRESENCE),
9599         SND_PCI_QUIRK(0x1025, 0x1300, "Acer SWIFT SF314-56", ALC256_FIXUP_ACER_MIC_NO_PRESENCE),
9600         SND_PCI_QUIRK(0x1025, 0x1308, "Acer Aspire Z24-890", ALC286_FIXUP_ACER_AIO_HEADSET_MIC),
9601         SND_PCI_QUIRK(0x1025, 0x132a, "Acer TravelMate B114-21", ALC233_FIXUP_ACER_HEADSET_MIC),
9602         SND_PCI_QUIRK(0x1025, 0x1330, "Acer TravelMate X514-51T", ALC255_FIXUP_ACER_HEADSET_MIC),
9603         SND_PCI_QUIRK(0x1025, 0x141f, "Acer Spin SP513-54N", ALC255_FIXUP_ACER_MIC_NO_PRESENCE),
9604         SND_PCI_QUIRK(0x1025, 0x142b, "Acer Swift SF314-42", ALC255_FIXUP_ACER_MIC_NO_PRESENCE),
9605         SND_PCI_QUIRK(0x1025, 0x1430, "Acer TravelMate B311R-31", ALC256_FIXUP_ACER_MIC_NO_PRESENCE),
9606         SND_PCI_QUIRK(0x1025, 0x1466, "Acer Aspire A515-56", ALC255_FIXUP_ACER_HEADPHONE_AND_MIC),
9607         SND_PCI_QUIRK(0x1025, 0x1534, "Acer Predator PH315-54", ALC255_FIXUP_ACER_MIC_NO_PRESENCE),
9608         SND_PCI_QUIRK(0x1028, 0x0470, "Dell M101z", ALC269_FIXUP_DELL_M101Z),
9609         SND_PCI_QUIRK(0x1028, 0x053c, "Dell Latitude E5430", ALC292_FIXUP_DELL_E7X),
9610         SND_PCI_QUIRK(0x1028, 0x054b, "Dell XPS one 2710", ALC275_FIXUP_DELL_XPS),
9611         SND_PCI_QUIRK(0x1028, 0x05bd, "Dell Latitude E6440", ALC292_FIXUP_DELL_E7X),
9612         SND_PCI_QUIRK(0x1028, 0x05be, "Dell Latitude E6540", ALC292_FIXUP_DELL_E7X),
9613         SND_PCI_QUIRK(0x1028, 0x05ca, "Dell Latitude E7240", ALC292_FIXUP_DELL_E7X),
9614         SND_PCI_QUIRK(0x1028, 0x05cb, "Dell Latitude E7440", ALC292_FIXUP_DELL_E7X),
9615         SND_PCI_QUIRK(0x1028, 0x05da, "Dell Vostro 5460", ALC290_FIXUP_SUBWOOFER),
9616         SND_PCI_QUIRK(0x1028, 0x05f4, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE),
9617         SND_PCI_QUIRK(0x1028, 0x05f5, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE),
9618         SND_PCI_QUIRK(0x1028, 0x05f6, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE),
9619         SND_PCI_QUIRK(0x1028, 0x0615, "Dell Vostro 5470", ALC290_FIXUP_SUBWOOFER_HSJACK),
9620         SND_PCI_QUIRK(0x1028, 0x0616, "Dell Vostro 5470", ALC290_FIXUP_SUBWOOFER_HSJACK),
9621         SND_PCI_QUIRK(0x1028, 0x062c, "Dell Latitude E5550", ALC292_FIXUP_DELL_E7X),
9622         SND_PCI_QUIRK(0x1028, 0x062e, "Dell Latitude E7450", ALC292_FIXUP_DELL_E7X),
9623         SND_PCI_QUIRK(0x1028, 0x0638, "Dell Inspiron 5439", ALC290_FIXUP_MONO_SPEAKERS_HSJACK),
9624         SND_PCI_QUIRK(0x1028, 0x064a, "Dell", ALC293_FIXUP_DELL1_MIC_NO_PRESENCE),
9625         SND_PCI_QUIRK(0x1028, 0x064b, "Dell", ALC293_FIXUP_DELL1_MIC_NO_PRESENCE),
9626         SND_PCI_QUIRK(0x1028, 0x0665, "Dell XPS 13", ALC288_FIXUP_DELL_XPS_13),
9627         SND_PCI_QUIRK(0x1028, 0x0669, "Dell Optiplex 9020m", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE),
9628         SND_PCI_QUIRK(0x1028, 0x069a, "Dell Vostro 5480", ALC290_FIXUP_SUBWOOFER_HSJACK),
9629         SND_PCI_QUIRK(0x1028, 0x06c7, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE),
9630         SND_PCI_QUIRK(0x1028, 0x06d9, "Dell", ALC293_FIXUP_DELL1_MIC_NO_PRESENCE),
9631         SND_PCI_QUIRK(0x1028, 0x06da, "Dell", ALC293_FIXUP_DELL1_MIC_NO_PRESENCE),
9632         SND_PCI_QUIRK(0x1028, 0x06db, "Dell", ALC293_FIXUP_DISABLE_AAMIX_MULTIJACK),
9633         SND_PCI_QUIRK(0x1028, 0x06dd, "Dell", ALC293_FIXUP_DISABLE_AAMIX_MULTIJACK),
9634         SND_PCI_QUIRK(0x1028, 0x06de, "Dell", ALC293_FIXUP_DISABLE_AAMIX_MULTIJACK),
9635         SND_PCI_QUIRK(0x1028, 0x06df, "Dell", ALC293_FIXUP_DISABLE_AAMIX_MULTIJACK),
9636         SND_PCI_QUIRK(0x1028, 0x06e0, "Dell", ALC293_FIXUP_DISABLE_AAMIX_MULTIJACK),
9637         SND_PCI_QUIRK(0x1028, 0x0706, "Dell Inspiron 7559", ALC256_FIXUP_DELL_INSPIRON_7559_SUBWOOFER),
9638         SND_PCI_QUIRK(0x1028, 0x0725, "Dell Inspiron 3162", ALC255_FIXUP_DELL_SPK_NOISE),
9639         SND_PCI_QUIRK(0x1028, 0x0738, "Dell Precision 5820", ALC269_FIXUP_NO_SHUTUP),
9640         SND_PCI_QUIRK(0x1028, 0x075c, "Dell XPS 27 7760", ALC298_FIXUP_SPK_VOLUME),
9641         SND_PCI_QUIRK(0x1028, 0x075d, "Dell AIO", ALC298_FIXUP_SPK_VOLUME),
9642         SND_PCI_QUIRK(0x1028, 0x0798, "Dell Inspiron 17 7000 Gaming", ALC256_FIXUP_DELL_INSPIRON_7559_SUBWOOFER),
9643         SND_PCI_QUIRK(0x1028, 0x07b0, "Dell Precision 7520", ALC295_FIXUP_DISABLE_DAC3),
9644         SND_PCI_QUIRK(0x1028, 0x080c, "Dell WYSE", ALC225_FIXUP_DELL_WYSE_MIC_NO_PRESENCE),
9645         SND_PCI_QUIRK(0x1028, 0x084b, "Dell", ALC274_FIXUP_DELL_AIO_LINEOUT_VERB),
9646         SND_PCI_QUIRK(0x1028, 0x084e, "Dell", ALC274_FIXUP_DELL_AIO_LINEOUT_VERB),
9647         SND_PCI_QUIRK(0x1028, 0x0871, "Dell Precision 3630", ALC255_FIXUP_DELL_HEADSET_MIC),
9648         SND_PCI_QUIRK(0x1028, 0x0872, "Dell Precision 3630", ALC255_FIXUP_DELL_HEADSET_MIC),
9649         SND_PCI_QUIRK(0x1028, 0x0873, "Dell Precision 3930", ALC255_FIXUP_DUMMY_LINEOUT_VERB),
9650         SND_PCI_QUIRK(0x1028, 0x08ad, "Dell WYSE AIO", ALC225_FIXUP_DELL_WYSE_AIO_MIC_NO_PRESENCE),
9651         SND_PCI_QUIRK(0x1028, 0x08ae, "Dell WYSE NB", ALC225_FIXUP_DELL1_MIC_NO_PRESENCE),
9652         SND_PCI_QUIRK(0x1028, 0x0935, "Dell", ALC274_FIXUP_DELL_AIO_LINEOUT_VERB),
9653         SND_PCI_QUIRK(0x1028, 0x097d, "Dell Precision", ALC289_FIXUP_DUAL_SPK),
9654         SND_PCI_QUIRK(0x1028, 0x097e, "Dell Precision", ALC289_FIXUP_DUAL_SPK),
9655         SND_PCI_QUIRK(0x1028, 0x098d, "Dell Precision", ALC233_FIXUP_ASUS_MIC_NO_PRESENCE),
9656         SND_PCI_QUIRK(0x1028, 0x09bf, "Dell Precision", ALC233_FIXUP_ASUS_MIC_NO_PRESENCE),
9657         SND_PCI_QUIRK(0x1028, 0x0a2e, "Dell", ALC236_FIXUP_DELL_AIO_HEADSET_MIC),
9658         SND_PCI_QUIRK(0x1028, 0x0a30, "Dell", ALC236_FIXUP_DELL_AIO_HEADSET_MIC),
9659         SND_PCI_QUIRK(0x1028, 0x0a38, "Dell Latitude 7520", ALC269_FIXUP_DELL4_MIC_NO_PRESENCE_QUIET),
9660         SND_PCI_QUIRK(0x1028, 0x0a58, "Dell", ALC255_FIXUP_DELL_HEADSET_MIC),
9661         SND_PCI_QUIRK(0x1028, 0x0a61, "Dell XPS 15 9510", ALC289_FIXUP_DUAL_SPK),
9662         SND_PCI_QUIRK(0x1028, 0x0a62, "Dell Precision 5560", ALC289_FIXUP_DUAL_SPK),
9663         SND_PCI_QUIRK(0x1028, 0x0a9d, "Dell Latitude 5430", ALC269_FIXUP_DELL4_MIC_NO_PRESENCE),
9664         SND_PCI_QUIRK(0x1028, 0x0a9e, "Dell Latitude 5430", ALC269_FIXUP_DELL4_MIC_NO_PRESENCE),
9665         SND_PCI_QUIRK(0x1028, 0x0b19, "Dell XPS 15 9520", ALC289_FIXUP_DUAL_SPK),
9666         SND_PCI_QUIRK(0x1028, 0x0b1a, "Dell Precision 5570", ALC289_FIXUP_DUAL_SPK),
9667         SND_PCI_QUIRK(0x1028, 0x0b27, "Dell", ALC245_FIXUP_CS35L41_SPI_2),
9668         SND_PCI_QUIRK(0x1028, 0x0b28, "Dell", ALC245_FIXUP_CS35L41_SPI_2),
9669         SND_PCI_QUIRK(0x1028, 0x0b37, "Dell Inspiron 16 Plus 7620 2-in-1", ALC295_FIXUP_DELL_INSPIRON_TOP_SPEAKERS),
9670         SND_PCI_QUIRK(0x1028, 0x0b71, "Dell Inspiron 16 Plus 7620", ALC295_FIXUP_DELL_INSPIRON_TOP_SPEAKERS),
9671         SND_PCI_QUIRK(0x1028, 0x0beb, "Dell XPS 15 9530 (2023)", ALC289_FIXUP_DELL_CS35L41_SPI_2),
9672         SND_PCI_QUIRK(0x1028, 0x0c03, "Dell Precision 5340", ALC269_FIXUP_DELL4_MIC_NO_PRESENCE),
9673         SND_PCI_QUIRK(0x1028, 0x0c0b, "Dell Oasis 14 RPL-P", ALC289_FIXUP_RTK_AMP_DUAL_SPK),
9674         SND_PCI_QUIRK(0x1028, 0x0c0d, "Dell Oasis", ALC289_FIXUP_RTK_AMP_DUAL_SPK),
9675         SND_PCI_QUIRK(0x1028, 0x0c0e, "Dell Oasis 16", ALC289_FIXUP_RTK_AMP_DUAL_SPK),
9676         SND_PCI_QUIRK(0x1028, 0x0c19, "Dell Precision 3340", ALC236_FIXUP_DELL_DUAL_CODECS),
9677         SND_PCI_QUIRK(0x1028, 0x0c1a, "Dell Precision 3340", ALC236_FIXUP_DELL_DUAL_CODECS),
9678         SND_PCI_QUIRK(0x1028, 0x0c1b, "Dell Precision 3440", ALC236_FIXUP_DELL_DUAL_CODECS),
9679         SND_PCI_QUIRK(0x1028, 0x0c1c, "Dell Precision 3540", ALC236_FIXUP_DELL_DUAL_CODECS),
9680         SND_PCI_QUIRK(0x1028, 0x0c1d, "Dell Precision 3440", ALC236_FIXUP_DELL_DUAL_CODECS),
9681         SND_PCI_QUIRK(0x1028, 0x0c1e, "Dell Precision 3540", ALC236_FIXUP_DELL_DUAL_CODECS),
9682         SND_PCI_QUIRK(0x1028, 0x0c28, "Dell Inspiron 16 Plus 7630", ALC295_FIXUP_DELL_INSPIRON_TOP_SPEAKERS),
9683         SND_PCI_QUIRK(0x1028, 0x0c4d, "Dell", ALC287_FIXUP_CS35L41_I2C_4),
9684         SND_PCI_QUIRK(0x1028, 0x0cbd, "Dell Oasis 13 CS MTL-U", ALC289_FIXUP_DELL_CS35L41_SPI_2),
9685         SND_PCI_QUIRK(0x1028, 0x0cbe, "Dell Oasis 13 2-IN-1 MTL-U", ALC289_FIXUP_DELL_CS35L41_SPI_2),
9686         SND_PCI_QUIRK(0x1028, 0x0cbf, "Dell Oasis 13 Low Weight MTU-L", ALC289_FIXUP_DELL_CS35L41_SPI_2),
9687         SND_PCI_QUIRK(0x1028, 0x0cc0, "Dell Oasis 13", ALC289_FIXUP_RTK_AMP_DUAL_SPK),
9688         SND_PCI_QUIRK(0x1028, 0x0cc1, "Dell Oasis 14 MTL-H/U", ALC289_FIXUP_DELL_CS35L41_SPI_2),
9689         SND_PCI_QUIRK(0x1028, 0x0cc2, "Dell Oasis 14 2-in-1 MTL-H/U", ALC289_FIXUP_DELL_CS35L41_SPI_2),
9690         SND_PCI_QUIRK(0x1028, 0x0cc3, "Dell Oasis 14 Low Weight MTL-U", ALC289_FIXUP_DELL_CS35L41_SPI_2),
9691         SND_PCI_QUIRK(0x1028, 0x0cc4, "Dell Oasis 16 MTL-H/U", ALC289_FIXUP_DELL_CS35L41_SPI_2),
9692         SND_PCI_QUIRK(0x1028, 0x0cc5, "Dell Oasis 14", ALC289_FIXUP_RTK_AMP_DUAL_SPK),
9693         SND_PCI_QUIRK(0x1028, 0x164a, "Dell", ALC293_FIXUP_DELL1_MIC_NO_PRESENCE),
9694         SND_PCI_QUIRK(0x1028, 0x164b, "Dell", ALC293_FIXUP_DELL1_MIC_NO_PRESENCE),
9695         SND_PCI_QUIRK(0x103c, 0x1586, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC2),
9696         SND_PCI_QUIRK(0x103c, 0x18e6, "HP", ALC269_FIXUP_HP_GPIO_LED),
9697         SND_PCI_QUIRK(0x103c, 0x218b, "HP", ALC269_FIXUP_LIMIT_INT_MIC_BOOST_MUTE_LED),
9698         SND_PCI_QUIRK(0x103c, 0x21f9, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
9699         SND_PCI_QUIRK(0x103c, 0x2210, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
9700         SND_PCI_QUIRK(0x103c, 0x2214, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
9701         SND_PCI_QUIRK(0x103c, 0x221b, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),
9702         SND_PCI_QUIRK(0x103c, 0x221c, "HP EliteBook 755 G2", ALC280_FIXUP_HP_HEADSET_MIC),
9703         SND_PCI_QUIRK(0x103c, 0x2221, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),
9704         SND_PCI_QUIRK(0x103c, 0x2225, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),
9705         SND_PCI_QUIRK(0x103c, 0x2236, "HP", ALC269_FIXUP_HP_LINE1_MIC1_LED),
9706         SND_PCI_QUIRK(0x103c, 0x2237, "HP", ALC269_FIXUP_HP_LINE1_MIC1_LED),
9707         SND_PCI_QUIRK(0x103c, 0x2238, "HP", ALC269_FIXUP_HP_LINE1_MIC1_LED),
9708         SND_PCI_QUIRK(0x103c, 0x2239, "HP", ALC269_FIXUP_HP_LINE1_MIC1_LED),
9709         SND_PCI_QUIRK(0x103c, 0x224b, "HP", ALC269_FIXUP_HP_LINE1_MIC1_LED),
9710         SND_PCI_QUIRK(0x103c, 0x2253, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),
9711         SND_PCI_QUIRK(0x103c, 0x2254, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),
9712         SND_PCI_QUIRK(0x103c, 0x2255, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),
9713         SND_PCI_QUIRK(0x103c, 0x2256, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),
9714         SND_PCI_QUIRK(0x103c, 0x2257, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),
9715         SND_PCI_QUIRK(0x103c, 0x2259, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),
9716         SND_PCI_QUIRK(0x103c, 0x225a, "HP", ALC269_FIXUP_HP_DOCK_GPIO_MIC1_LED),
9717         SND_PCI_QUIRK(0x103c, 0x225f, "HP", ALC280_FIXUP_HP_GPIO2_MIC_HOTKEY),
9718         SND_PCI_QUIRK(0x103c, 0x2260, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
9719         SND_PCI_QUIRK(0x103c, 0x2263, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
9720         SND_PCI_QUIRK(0x103c, 0x2264, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
9721         SND_PCI_QUIRK(0x103c, 0x2265, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
9722         SND_PCI_QUIRK(0x103c, 0x2268, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
9723         SND_PCI_QUIRK(0x103c, 0x226a, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
9724         SND_PCI_QUIRK(0x103c, 0x226b, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
9725         SND_PCI_QUIRK(0x103c, 0x226e, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
9726         SND_PCI_QUIRK(0x103c, 0x2271, "HP", ALC286_FIXUP_HP_GPIO_LED),
9727         SND_PCI_QUIRK(0x103c, 0x2272, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),
9728         SND_PCI_QUIRK(0x103c, 0x2272, "HP", ALC280_FIXUP_HP_DOCK_PINS),
9729         SND_PCI_QUIRK(0x103c, 0x2273, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),
9730         SND_PCI_QUIRK(0x103c, 0x2273, "HP", ALC280_FIXUP_HP_DOCK_PINS),
9731         SND_PCI_QUIRK(0x103c, 0x2278, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),
9732         SND_PCI_QUIRK(0x103c, 0x227f, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
9733         SND_PCI_QUIRK(0x103c, 0x2282, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
9734         SND_PCI_QUIRK(0x103c, 0x228b, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
9735         SND_PCI_QUIRK(0x103c, 0x228e, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
9736         SND_PCI_QUIRK(0x103c, 0x229e, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
9737         SND_PCI_QUIRK(0x103c, 0x22b2, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
9738         SND_PCI_QUIRK(0x103c, 0x22b7, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
9739         SND_PCI_QUIRK(0x103c, 0x22bf, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
9740         SND_PCI_QUIRK(0x103c, 0x22c4, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
9741         SND_PCI_QUIRK(0x103c, 0x22c5, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
9742         SND_PCI_QUIRK(0x103c, 0x22c7, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
9743         SND_PCI_QUIRK(0x103c, 0x22c8, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
9744         SND_PCI_QUIRK(0x103c, 0x22cf, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
9745         SND_PCI_QUIRK(0x103c, 0x22db, "HP", ALC280_FIXUP_HP_9480M),
9746         SND_PCI_QUIRK(0x103c, 0x22dc, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),
9747         SND_PCI_QUIRK(0x103c, 0x22fb, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),
9748         SND_PCI_QUIRK(0x103c, 0x2334, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
9749         SND_PCI_QUIRK(0x103c, 0x2335, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
9750         SND_PCI_QUIRK(0x103c, 0x2336, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
9751         SND_PCI_QUIRK(0x103c, 0x2337, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
9752         SND_PCI_QUIRK(0x103c, 0x2b5e, "HP 288 Pro G2 MT", ALC221_FIXUP_HP_288PRO_MIC_NO_PRESENCE),
9753         SND_PCI_QUIRK(0x103c, 0x802e, "HP Z240 SFF", ALC221_FIXUP_HP_MIC_NO_PRESENCE),
9754         SND_PCI_QUIRK(0x103c, 0x802f, "HP Z240", ALC221_FIXUP_HP_MIC_NO_PRESENCE),
9755         SND_PCI_QUIRK(0x103c, 0x8077, "HP", ALC256_FIXUP_HP_HEADSET_MIC),
9756         SND_PCI_QUIRK(0x103c, 0x8158, "HP", ALC256_FIXUP_HP_HEADSET_MIC),
9757         SND_PCI_QUIRK(0x103c, 0x820d, "HP Pavilion 15", ALC295_FIXUP_HP_X360),
9758         SND_PCI_QUIRK(0x103c, 0x8256, "HP", ALC221_FIXUP_HP_FRONT_MIC),
9759         SND_PCI_QUIRK(0x103c, 0x827e, "HP x360", ALC295_FIXUP_HP_X360),
9760         SND_PCI_QUIRK(0x103c, 0x827f, "HP x360", ALC269_FIXUP_HP_MUTE_LED_MIC3),
9761         SND_PCI_QUIRK(0x103c, 0x82bf, "HP G3 mini", ALC221_FIXUP_HP_MIC_NO_PRESENCE),
9762         SND_PCI_QUIRK(0x103c, 0x82c0, "HP G3 mini premium", ALC221_FIXUP_HP_MIC_NO_PRESENCE),
9763         SND_PCI_QUIRK(0x103c, 0x83b9, "HP Spectre x360", ALC269_FIXUP_HP_MUTE_LED_MIC3),
9764         SND_PCI_QUIRK(0x103c, 0x841c, "HP Pavilion 15-CK0xx", ALC269_FIXUP_HP_MUTE_LED_MIC3),
9765         SND_PCI_QUIRK(0x103c, 0x8497, "HP Envy x360", ALC269_FIXUP_HP_MUTE_LED_MIC3),
9766         SND_PCI_QUIRK(0x103c, 0x84ae, "HP 15-db0403ng", ALC236_FIXUP_HP_MUTE_LED_COEFBIT2),
9767         SND_PCI_QUIRK(0x103c, 0x84da, "HP OMEN dc0019-ur", ALC295_FIXUP_HP_OMEN),
9768         SND_PCI_QUIRK(0x103c, 0x84e7, "HP Pavilion 15", ALC269_FIXUP_HP_MUTE_LED_MIC3),
9769         SND_PCI_QUIRK(0x103c, 0x8519, "HP Spectre x360 15-df0xxx", ALC285_FIXUP_HP_SPECTRE_X360),
9770         SND_PCI_QUIRK(0x103c, 0x8537, "HP ProBook 440 G6", ALC236_FIXUP_HP_MUTE_LED_MICMUTE_VREF),
9771         SND_PCI_QUIRK(0x103c, 0x85de, "HP Envy x360 13-ar0xxx", ALC285_FIXUP_HP_ENVY_X360),
9772         SND_PCI_QUIRK(0x103c, 0x860f, "HP ZBook 15 G6", ALC285_FIXUP_HP_GPIO_AMP_INIT),
9773         SND_PCI_QUIRK(0x103c, 0x861f, "HP Elite Dragonfly G1", ALC285_FIXUP_HP_GPIO_AMP_INIT),
9774         SND_PCI_QUIRK(0x103c, 0x869d, "HP", ALC236_FIXUP_HP_MUTE_LED),
9775         SND_PCI_QUIRK(0x103c, 0x86c7, "HP Envy AiO 32", ALC274_FIXUP_HP_ENVY_GPIO),
9776         SND_PCI_QUIRK(0x103c, 0x86e7, "HP Spectre x360 15-eb0xxx", ALC285_FIXUP_HP_SPECTRE_X360_EB1),
9777         SND_PCI_QUIRK(0x103c, 0x86e8, "HP Spectre x360 15-eb0xxx", ALC285_FIXUP_HP_SPECTRE_X360_EB1),
9778         SND_PCI_QUIRK(0x103c, 0x86f9, "HP Spectre x360 13-aw0xxx", ALC285_FIXUP_HP_SPECTRE_X360_MUTE_LED),
9779         SND_PCI_QUIRK(0x103c, 0x8716, "HP Elite Dragonfly G2 Notebook PC", ALC285_FIXUP_HP_GPIO_AMP_INIT),
9780         SND_PCI_QUIRK(0x103c, 0x8720, "HP EliteBook x360 1040 G8 Notebook PC", ALC285_FIXUP_HP_GPIO_AMP_INIT),
9781         SND_PCI_QUIRK(0x103c, 0x8724, "HP EliteBook 850 G7", ALC285_FIXUP_HP_GPIO_LED),
9782         SND_PCI_QUIRK(0x103c, 0x8728, "HP EliteBook 840 G7", ALC285_FIXUP_HP_GPIO_LED),
9783         SND_PCI_QUIRK(0x103c, 0x8729, "HP", ALC285_FIXUP_HP_GPIO_LED),
9784         SND_PCI_QUIRK(0x103c, 0x8730, "HP ProBook 445 G7", ALC236_FIXUP_HP_MUTE_LED_MICMUTE_VREF),
9785         SND_PCI_QUIRK(0x103c, 0x8735, "HP ProBook 435 G7", ALC236_FIXUP_HP_MUTE_LED_MICMUTE_VREF),
9786         SND_PCI_QUIRK(0x103c, 0x8736, "HP", ALC285_FIXUP_HP_GPIO_AMP_INIT),
9787         SND_PCI_QUIRK(0x103c, 0x8760, "HP", ALC285_FIXUP_HP_MUTE_LED),
9788         SND_PCI_QUIRK(0x103c, 0x876e, "HP ENVY x360 Convertible 13-ay0xxx", ALC245_FIXUP_HP_X360_MUTE_LEDS),
9789         SND_PCI_QUIRK(0x103c, 0x877a, "HP", ALC285_FIXUP_HP_MUTE_LED),
9790         SND_PCI_QUIRK(0x103c, 0x877d, "HP", ALC236_FIXUP_HP_MUTE_LED),
9791         SND_PCI_QUIRK(0x103c, 0x8780, "HP ZBook Fury 17 G7 Mobile Workstation",
9792                       ALC285_FIXUP_HP_GPIO_AMP_INIT),
9793         SND_PCI_QUIRK(0x103c, 0x8783, "HP ZBook Fury 15 G7 Mobile Workstation",
9794                       ALC285_FIXUP_HP_GPIO_AMP_INIT),
9795         SND_PCI_QUIRK(0x103c, 0x8786, "HP OMEN 15", ALC285_FIXUP_HP_MUTE_LED),
9796         SND_PCI_QUIRK(0x103c, 0x8787, "HP OMEN 15", ALC285_FIXUP_HP_MUTE_LED),
9797         SND_PCI_QUIRK(0x103c, 0x8788, "HP OMEN 15", ALC285_FIXUP_HP_MUTE_LED),
9798         SND_PCI_QUIRK(0x103c, 0x87b7, "HP Laptop 14-fq0xxx", ALC236_FIXUP_HP_MUTE_LED_COEFBIT2),
9799         SND_PCI_QUIRK(0x103c, 0x87c8, "HP", ALC287_FIXUP_HP_GPIO_LED),
9800         SND_PCI_QUIRK(0x103c, 0x87e5, "HP ProBook 440 G8 Notebook PC", ALC236_FIXUP_HP_GPIO_LED),
9801         SND_PCI_QUIRK(0x103c, 0x87e7, "HP ProBook 450 G8 Notebook PC", ALC236_FIXUP_HP_GPIO_LED),
9802         SND_PCI_QUIRK(0x103c, 0x87f1, "HP ProBook 630 G8 Notebook PC", ALC236_FIXUP_HP_GPIO_LED),
9803         SND_PCI_QUIRK(0x103c, 0x87f2, "HP ProBook 640 G8 Notebook PC", ALC236_FIXUP_HP_GPIO_LED),
9804         SND_PCI_QUIRK(0x103c, 0x87f4, "HP", ALC287_FIXUP_HP_GPIO_LED),
9805         SND_PCI_QUIRK(0x103c, 0x87f5, "HP", ALC287_FIXUP_HP_GPIO_LED),
9806         SND_PCI_QUIRK(0x103c, 0x87f6, "HP Spectre x360 14", ALC245_FIXUP_HP_X360_AMP),
9807         SND_PCI_QUIRK(0x103c, 0x87f7, "HP Spectre x360 14", ALC245_FIXUP_HP_X360_AMP),
9808         SND_PCI_QUIRK(0x103c, 0x87fe, "HP Laptop 15s-fq2xxx", ALC236_FIXUP_HP_MUTE_LED_COEFBIT2),
9809         SND_PCI_QUIRK(0x103c, 0x8805, "HP ProBook 650 G8 Notebook PC", ALC236_FIXUP_HP_GPIO_LED),
9810         SND_PCI_QUIRK(0x103c, 0x880d, "HP EliteBook 830 G8 Notebook PC", ALC285_FIXUP_HP_GPIO_LED),
9811         SND_PCI_QUIRK(0x103c, 0x8811, "HP Spectre x360 15-eb1xxx", ALC285_FIXUP_HP_SPECTRE_X360_EB1),
9812         SND_PCI_QUIRK(0x103c, 0x8812, "HP Spectre x360 15-eb1xxx", ALC285_FIXUP_HP_SPECTRE_X360_EB1),
9813         SND_PCI_QUIRK(0x103c, 0x881d, "HP 250 G8 Notebook PC", ALC236_FIXUP_HP_MUTE_LED_COEFBIT2),
9814         SND_PCI_QUIRK(0x103c, 0x8846, "HP EliteBook 850 G8 Notebook PC", ALC285_FIXUP_HP_GPIO_LED),
9815         SND_PCI_QUIRK(0x103c, 0x8847, "HP EliteBook x360 830 G8 Notebook PC", ALC285_FIXUP_HP_GPIO_LED),
9816         SND_PCI_QUIRK(0x103c, 0x884b, "HP EliteBook 840 Aero G8 Notebook PC", ALC285_FIXUP_HP_GPIO_LED),
9817         SND_PCI_QUIRK(0x103c, 0x884c, "HP EliteBook 840 G8 Notebook PC", ALC285_FIXUP_HP_GPIO_LED),
9818         SND_PCI_QUIRK(0x103c, 0x8862, "HP ProBook 445 G8 Notebook PC", ALC236_FIXUP_HP_LIMIT_INT_MIC_BOOST),
9819         SND_PCI_QUIRK(0x103c, 0x8863, "HP ProBook 445 G8 Notebook PC", ALC236_FIXUP_HP_LIMIT_INT_MIC_BOOST),
9820         SND_PCI_QUIRK(0x103c, 0x886d, "HP ZBook Fury 17.3 Inch G8 Mobile Workstation PC", ALC285_FIXUP_HP_GPIO_AMP_INIT),
9821         SND_PCI_QUIRK(0x103c, 0x8870, "HP ZBook Fury 15.6 Inch G8 Mobile Workstation PC", ALC285_FIXUP_HP_GPIO_AMP_INIT),
9822         SND_PCI_QUIRK(0x103c, 0x8873, "HP ZBook Studio 15.6 Inch G8 Mobile Workstation PC", ALC285_FIXUP_HP_GPIO_AMP_INIT),
9823         SND_PCI_QUIRK(0x103c, 0x887a, "HP Laptop 15s-eq2xxx", ALC236_FIXUP_HP_MUTE_LED_COEFBIT2),
9824         SND_PCI_QUIRK(0x103c, 0x888a, "HP ENVY x360 Convertible 15-eu0xxx", ALC245_FIXUP_HP_X360_MUTE_LEDS),
9825         SND_PCI_QUIRK(0x103c, 0x888d, "HP ZBook Power 15.6 inch G8 Mobile Workstation PC", ALC236_FIXUP_HP_GPIO_LED),
9826         SND_PCI_QUIRK(0x103c, 0x8895, "HP EliteBook 855 G8 Notebook PC", ALC285_FIXUP_HP_SPEAKERS_MICMUTE_LED),
9827         SND_PCI_QUIRK(0x103c, 0x8896, "HP EliteBook 855 G8 Notebook PC", ALC285_FIXUP_HP_MUTE_LED),
9828         SND_PCI_QUIRK(0x103c, 0x8898, "HP EliteBook 845 G8 Notebook PC", ALC285_FIXUP_HP_LIMIT_INT_MIC_BOOST),
9829         SND_PCI_QUIRK(0x103c, 0x88d0, "HP Pavilion 15-eh1xxx (mainboard 88D0)", ALC287_FIXUP_HP_GPIO_LED),
9830         SND_PCI_QUIRK(0x103c, 0x8902, "HP OMEN 16", ALC285_FIXUP_HP_MUTE_LED),
9831         SND_PCI_QUIRK(0x103c, 0x890e, "HP 255 G8 Notebook PC", ALC236_FIXUP_HP_MUTE_LED_COEFBIT2),
9832         SND_PCI_QUIRK(0x103c, 0x8919, "HP Pavilion Aero Laptop 13-be0xxx", ALC287_FIXUP_HP_GPIO_LED),
9833         SND_PCI_QUIRK(0x103c, 0x896d, "HP ZBook Firefly 16 G9", ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED),
9834         SND_PCI_QUIRK(0x103c, 0x896e, "HP EliteBook x360 830 G9", ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED),
9835         SND_PCI_QUIRK(0x103c, 0x8971, "HP EliteBook 830 G9", ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED),
9836         SND_PCI_QUIRK(0x103c, 0x8972, "HP EliteBook 840 G9", ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED),
9837         SND_PCI_QUIRK(0x103c, 0x8973, "HP EliteBook 860 G9", ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED),
9838         SND_PCI_QUIRK(0x103c, 0x8974, "HP EliteBook 840 Aero G9", ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED),
9839         SND_PCI_QUIRK(0x103c, 0x8975, "HP EliteBook x360 840 Aero G9", ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED),
9840         SND_PCI_QUIRK(0x103c, 0x897d, "HP mt440 Mobile Thin Client U74", ALC236_FIXUP_HP_GPIO_LED),
9841         SND_PCI_QUIRK(0x103c, 0x8981, "HP Elite Dragonfly G3", ALC245_FIXUP_CS35L41_SPI_4),
9842         SND_PCI_QUIRK(0x103c, 0x898e, "HP EliteBook 835 G9", ALC287_FIXUP_CS35L41_I2C_2),
9843         SND_PCI_QUIRK(0x103c, 0x898f, "HP EliteBook 835 G9", ALC287_FIXUP_CS35L41_I2C_2),
9844         SND_PCI_QUIRK(0x103c, 0x8991, "HP EliteBook 845 G9", ALC287_FIXUP_CS35L41_I2C_2_HP_GPIO_LED),
9845         SND_PCI_QUIRK(0x103c, 0x8992, "HP EliteBook 845 G9", ALC287_FIXUP_CS35L41_I2C_2),
9846         SND_PCI_QUIRK(0x103c, 0x8994, "HP EliteBook 855 G9", ALC287_FIXUP_CS35L41_I2C_2_HP_GPIO_LED),
9847         SND_PCI_QUIRK(0x103c, 0x8995, "HP EliteBook 855 G9", ALC287_FIXUP_CS35L41_I2C_2),
9848         SND_PCI_QUIRK(0x103c, 0x89a4, "HP ProBook 440 G9", ALC236_FIXUP_HP_GPIO_LED),
9849         SND_PCI_QUIRK(0x103c, 0x89a6, "HP ProBook 450 G9", ALC236_FIXUP_HP_GPIO_LED),
9850         SND_PCI_QUIRK(0x103c, 0x89aa, "HP EliteBook 630 G9", ALC236_FIXUP_HP_GPIO_LED),
9851         SND_PCI_QUIRK(0x103c, 0x89ac, "HP EliteBook 640 G9", ALC236_FIXUP_HP_GPIO_LED),
9852         SND_PCI_QUIRK(0x103c, 0x89ae, "HP EliteBook 650 G9", ALC236_FIXUP_HP_GPIO_LED),
9853         SND_PCI_QUIRK(0x103c, 0x89c0, "HP ZBook Power 15.6 G9", ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED),
9854         SND_PCI_QUIRK(0x103c, 0x89c3, "Zbook Studio G9", ALC245_FIXUP_CS35L41_SPI_4_HP_GPIO_LED),
9855         SND_PCI_QUIRK(0x103c, 0x89c6, "Zbook Fury 17 G9", ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED),
9856         SND_PCI_QUIRK(0x103c, 0x89ca, "HP", ALC236_FIXUP_HP_MUTE_LED_MICMUTE_VREF),
9857         SND_PCI_QUIRK(0x103c, 0x89d3, "HP EliteBook 645 G9 (MB 89D2)", ALC236_FIXUP_HP_MUTE_LED_MICMUTE_VREF),
9858         SND_PCI_QUIRK(0x103c, 0x89e7, "HP Elite x2 G9", ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED),
9859         SND_PCI_QUIRK(0x103c, 0x8a0f, "HP Pavilion 14-ec1xxx", ALC287_FIXUP_HP_GPIO_LED),
9860         SND_PCI_QUIRK(0x103c, 0x8a20, "HP Laptop 15s-fq5xxx", ALC236_FIXUP_HP_MUTE_LED_COEFBIT2),
9861         SND_PCI_QUIRK(0x103c, 0x8a25, "HP Victus 16-d1xxx (MB 8A25)", ALC245_FIXUP_HP_MUTE_LED_COEFBIT),
9862         SND_PCI_QUIRK(0x103c, 0x8a28, "HP Envy 13", ALC287_FIXUP_CS35L41_I2C_2),
9863         SND_PCI_QUIRK(0x103c, 0x8a29, "HP Envy 15", ALC287_FIXUP_CS35L41_I2C_2),
9864         SND_PCI_QUIRK(0x103c, 0x8a2a, "HP Envy 15", ALC287_FIXUP_CS35L41_I2C_2),
9865         SND_PCI_QUIRK(0x103c, 0x8a2b, "HP Envy 15", ALC287_FIXUP_CS35L41_I2C_2),
9866         SND_PCI_QUIRK(0x103c, 0x8a2c, "HP Envy 16", ALC287_FIXUP_CS35L41_I2C_2),
9867         SND_PCI_QUIRK(0x103c, 0x8a2d, "HP Envy 16", ALC287_FIXUP_CS35L41_I2C_2),
9868         SND_PCI_QUIRK(0x103c, 0x8a2e, "HP Envy 16", ALC287_FIXUP_CS35L41_I2C_2),
9869         SND_PCI_QUIRK(0x103c, 0x8a2e, "HP Envy 17", ALC287_FIXUP_CS35L41_I2C_2),
9870         SND_PCI_QUIRK(0x103c, 0x8a30, "HP Envy 17", ALC287_FIXUP_CS35L41_I2C_2),
9871         SND_PCI_QUIRK(0x103c, 0x8a31, "HP Envy 15", ALC287_FIXUP_CS35L41_I2C_2),
9872         SND_PCI_QUIRK(0x103c, 0x8a6e, "HP EDNA 360", ALC287_FIXUP_CS35L41_I2C_4),
9873         SND_PCI_QUIRK(0x103c, 0x8a74, "HP ProBook 440 G8 Notebook PC", ALC236_FIXUP_HP_GPIO_LED),
9874         SND_PCI_QUIRK(0x103c, 0x8a78, "HP Dev One", ALC285_FIXUP_HP_LIMIT_INT_MIC_BOOST),
9875         SND_PCI_QUIRK(0x103c, 0x8aa0, "HP ProBook 440 G9 (MB 8A9E)", ALC236_FIXUP_HP_GPIO_LED),
9876         SND_PCI_QUIRK(0x103c, 0x8aa3, "HP ProBook 450 G9 (MB 8AA1)", ALC236_FIXUP_HP_GPIO_LED),
9877         SND_PCI_QUIRK(0x103c, 0x8aa8, "HP EliteBook 640 G9 (MB 8AA6)", ALC236_FIXUP_HP_GPIO_LED),
9878         SND_PCI_QUIRK(0x103c, 0x8aab, "HP EliteBook 650 G9 (MB 8AA9)", ALC236_FIXUP_HP_GPIO_LED),
9879         SND_PCI_QUIRK(0x103c, 0x8ab9, "HP EliteBook 840 G8 (MB 8AB8)", ALC285_FIXUP_HP_GPIO_LED),
9880         SND_PCI_QUIRK(0x103c, 0x8abb, "HP ZBook Firefly 14 G9", ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED),
9881         SND_PCI_QUIRK(0x103c, 0x8ad1, "HP EliteBook 840 14 inch G9 Notebook PC", ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED),
9882         SND_PCI_QUIRK(0x103c, 0x8ad2, "HP EliteBook 860 16 inch G9 Notebook PC", ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED),
9883         SND_PCI_QUIRK(0x103c, 0x8ad8, "HP 800 G9", ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED),
9884         SND_PCI_QUIRK(0x103c, 0x8b0f, "HP Elite mt645 G7 Mobile Thin Client U81", ALC236_FIXUP_HP_MUTE_LED_MICMUTE_VREF),
9885         SND_PCI_QUIRK(0x103c, 0x8b2f, "HP 255 15.6 inch G10 Notebook PC", ALC236_FIXUP_HP_MUTE_LED_COEFBIT2),
9886         SND_PCI_QUIRK(0x103c, 0x8b3a, "HP Envy 15", ALC287_FIXUP_CS35L41_I2C_2),
9887         SND_PCI_QUIRK(0x103c, 0x8b3f, "HP mt440 Mobile Thin Client U91", ALC236_FIXUP_HP_GPIO_LED),
9888         SND_PCI_QUIRK(0x103c, 0x8b42, "HP", ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED),
9889         SND_PCI_QUIRK(0x103c, 0x8b43, "HP", ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED),
9890         SND_PCI_QUIRK(0x103c, 0x8b44, "HP", ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED),
9891         SND_PCI_QUIRK(0x103c, 0x8b45, "HP", ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED),
9892         SND_PCI_QUIRK(0x103c, 0x8b46, "HP", ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED),
9893         SND_PCI_QUIRK(0x103c, 0x8b47, "HP", ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED),
9894         SND_PCI_QUIRK(0x103c, 0x8b59, "HP Elite mt645 G7 Mobile Thin Client U89", ALC236_FIXUP_HP_MUTE_LED_MICMUTE_VREF),
9895         SND_PCI_QUIRK(0x103c, 0x8b5d, "HP", ALC236_FIXUP_HP_MUTE_LED_MICMUTE_VREF),
9896         SND_PCI_QUIRK(0x103c, 0x8b5e, "HP", ALC236_FIXUP_HP_MUTE_LED_MICMUTE_VREF),
9897         SND_PCI_QUIRK(0x103c, 0x8b63, "HP Elite Dragonfly 13.5 inch G4", ALC245_FIXUP_CS35L41_SPI_4_HP_GPIO_LED),
9898         SND_PCI_QUIRK(0x103c, 0x8b65, "HP ProBook 455 15.6 inch G10 Notebook PC", ALC236_FIXUP_HP_MUTE_LED_MICMUTE_VREF),
9899         SND_PCI_QUIRK(0x103c, 0x8b66, "HP", ALC236_FIXUP_HP_MUTE_LED_MICMUTE_VREF),
9900         SND_PCI_QUIRK(0x103c, 0x8b70, "HP EliteBook 835 G10", ALC287_FIXUP_CS35L41_I2C_2_HP_GPIO_LED),
9901         SND_PCI_QUIRK(0x103c, 0x8b72, "HP EliteBook 845 G10", ALC287_FIXUP_CS35L41_I2C_2_HP_GPIO_LED),
9902         SND_PCI_QUIRK(0x103c, 0x8b74, "HP EliteBook 845W G10", ALC287_FIXUP_CS35L41_I2C_2_HP_GPIO_LED),
9903         SND_PCI_QUIRK(0x103c, 0x8b77, "HP ElieBook 865 G10", ALC287_FIXUP_CS35L41_I2C_2),
9904         SND_PCI_QUIRK(0x103c, 0x8b7a, "HP", ALC236_FIXUP_HP_GPIO_LED),
9905         SND_PCI_QUIRK(0x103c, 0x8b7d, "HP", ALC236_FIXUP_HP_GPIO_LED),
9906         SND_PCI_QUIRK(0x103c, 0x8b87, "HP", ALC236_FIXUP_HP_GPIO_LED),
9907         SND_PCI_QUIRK(0x103c, 0x8b8a, "HP", ALC236_FIXUP_HP_GPIO_LED),
9908         SND_PCI_QUIRK(0x103c, 0x8b8b, "HP", ALC236_FIXUP_HP_GPIO_LED),
9909         SND_PCI_QUIRK(0x103c, 0x8b8d, "HP", ALC236_FIXUP_HP_GPIO_LED),
9910         SND_PCI_QUIRK(0x103c, 0x8b8f, "HP", ALC245_FIXUP_CS35L41_SPI_4_HP_GPIO_LED),
9911         SND_PCI_QUIRK(0x103c, 0x8b92, "HP", ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED),
9912         SND_PCI_QUIRK(0x103c, 0x8b96, "HP", ALC236_FIXUP_HP_MUTE_LED_MICMUTE_VREF),
9913         SND_PCI_QUIRK(0x103c, 0x8b97, "HP", ALC236_FIXUP_HP_MUTE_LED_MICMUTE_VREF),
9914         SND_PCI_QUIRK(0x103c, 0x8bdd, "HP Envy 17", ALC287_FIXUP_CS35L41_I2C_2),
9915         SND_PCI_QUIRK(0x103c, 0x8bde, "HP Envy 17", ALC287_FIXUP_CS35L41_I2C_2),
9916         SND_PCI_QUIRK(0x103c, 0x8bdf, "HP Envy 15", ALC287_FIXUP_CS35L41_I2C_2),
9917         SND_PCI_QUIRK(0x103c, 0x8be0, "HP Envy 15", ALC287_FIXUP_CS35L41_I2C_2),
9918         SND_PCI_QUIRK(0x103c, 0x8be1, "HP Envy 15", ALC287_FIXUP_CS35L41_I2C_2),
9919         SND_PCI_QUIRK(0x103c, 0x8be2, "HP Envy 15", ALC287_FIXUP_CS35L41_I2C_2),
9920         SND_PCI_QUIRK(0x103c, 0x8be3, "HP Envy 15", ALC287_FIXUP_CS35L41_I2C_2),
9921         SND_PCI_QUIRK(0x103c, 0x8be5, "HP Envy 16", ALC287_FIXUP_CS35L41_I2C_2),
9922         SND_PCI_QUIRK(0x103c, 0x8be6, "HP Envy 16", ALC287_FIXUP_CS35L41_I2C_2),
9923         SND_PCI_QUIRK(0x103c, 0x8be7, "HP Envy 17", ALC287_FIXUP_CS35L41_I2C_2),
9924         SND_PCI_QUIRK(0x103c, 0x8be8, "HP Envy 17", ALC287_FIXUP_CS35L41_I2C_2),
9925         SND_PCI_QUIRK(0x103c, 0x8be9, "HP Envy 15", ALC287_FIXUP_CS35L41_I2C_2),
9926         SND_PCI_QUIRK(0x103c, 0x8bf0, "HP", ALC236_FIXUP_HP_GPIO_LED),
9927         SND_PCI_QUIRK(0x103c, 0x8c15, "HP Spectre 14", ALC287_FIXUP_CS35L41_I2C_2),
9928         SND_PCI_QUIRK(0x103c, 0x8c16, "HP Spectre 16", ALC287_FIXUP_CS35L41_I2C_2),
9929         SND_PCI_QUIRK(0x103c, 0x8c17, "HP Spectre 16", ALC287_FIXUP_CS35L41_I2C_2),
9930         SND_PCI_QUIRK(0x103c, 0x8c46, "HP EliteBook 830 G11", ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED),
9931         SND_PCI_QUIRK(0x103c, 0x8c47, "HP EliteBook 840 G11", ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED),
9932         SND_PCI_QUIRK(0x103c, 0x8c48, "HP EliteBook 860 G11", ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED),
9933         SND_PCI_QUIRK(0x103c, 0x8c49, "HP Elite x360 830 2-in-1 G11", ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED),
9934         SND_PCI_QUIRK(0x103c, 0x8c4f, "HP Envy 15", ALC287_FIXUP_CS35L41_I2C_2),
9935         SND_PCI_QUIRK(0x103c, 0x8c50, "HP Envy 17", ALC287_FIXUP_CS35L41_I2C_2),
9936         SND_PCI_QUIRK(0x103c, 0x8c51, "HP Envy 17", ALC287_FIXUP_CS35L41_I2C_2),
9937         SND_PCI_QUIRK(0x103c, 0x8c52, "HP EliteBook 1040 G11", ALC245_FIXUP_CS35L56_SPI_4_HP_GPIO_LED),
9938         SND_PCI_QUIRK(0x103c, 0x8c53, "HP Elite x360 1040 2-in-1 G11", ALC245_FIXUP_CS35L56_SPI_4_HP_GPIO_LED),
9939         SND_PCI_QUIRK(0x103c, 0x8c66, "HP Envy 16", ALC287_FIXUP_CS35L41_I2C_2),
9940         SND_PCI_QUIRK(0x103c, 0x8c67, "HP Envy 17", ALC287_FIXUP_CS35L41_I2C_2),
9941         SND_PCI_QUIRK(0x103c, 0x8c68, "HP Envy 17", ALC287_FIXUP_CS35L41_I2C_2),
9942         SND_PCI_QUIRK(0x103c, 0x8c6a, "HP Envy 16", ALC287_FIXUP_CS35L41_I2C_2),
9943         SND_PCI_QUIRK(0x103c, 0x8c70, "HP EliteBook 835 G11", ALC287_FIXUP_CS35L41_I2C_2_HP_GPIO_LED),
9944         SND_PCI_QUIRK(0x103c, 0x8c71, "HP EliteBook 845 G11", ALC287_FIXUP_CS35L41_I2C_2_HP_GPIO_LED),
9945         SND_PCI_QUIRK(0x103c, 0x8c72, "HP EliteBook 865 G11", ALC287_FIXUP_CS35L41_I2C_2_HP_GPIO_LED),
9946         SND_PCI_QUIRK(0x103c, 0x8c8a, "HP EliteBook 630", ALC236_FIXUP_HP_GPIO_LED),
9947         SND_PCI_QUIRK(0x103c, 0x8c8c, "HP EliteBook 660", ALC236_FIXUP_HP_GPIO_LED),
9948         SND_PCI_QUIRK(0x103c, 0x8c90, "HP EliteBook 640", ALC236_FIXUP_HP_GPIO_LED),
9949         SND_PCI_QUIRK(0x103c, 0x8c91, "HP EliteBook 660", ALC236_FIXUP_HP_GPIO_LED),
9950         SND_PCI_QUIRK(0x103c, 0x8c96, "HP", ALC236_FIXUP_HP_MUTE_LED_MICMUTE_VREF),
9951         SND_PCI_QUIRK(0x103c, 0x8c97, "HP ZBook", ALC236_FIXUP_HP_MUTE_LED_MICMUTE_VREF),
9952         SND_PCI_QUIRK(0x103c, 0x8ca1, "HP ZBook Power", ALC236_FIXUP_HP_GPIO_LED),
9953         SND_PCI_QUIRK(0x103c, 0x8ca2, "HP ZBook Power", ALC236_FIXUP_HP_GPIO_LED),
9954         SND_PCI_QUIRK(0x103c, 0x8ca4, "HP ZBook Fury", ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED),
9955         SND_PCI_QUIRK(0x103c, 0x8ca7, "HP ZBook Fury", ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED),
9956         SND_PCI_QUIRK(0x103c, 0x8cdd, "HP Spectre", ALC287_FIXUP_CS35L41_I2C_2),
9957         SND_PCI_QUIRK(0x103c, 0x8cde, "HP Spectre", ALC287_FIXUP_CS35L41_I2C_2),
9958         SND_PCI_QUIRK(0x103c, 0x8cf5, "HP ZBook Studio 16", ALC245_FIXUP_CS35L41_SPI_4_HP_GPIO_LED),
9959         SND_PCI_QUIRK(0x1043, 0x103e, "ASUS X540SA", ALC256_FIXUP_ASUS_MIC),
9960         SND_PCI_QUIRK(0x1043, 0x103f, "ASUS TX300", ALC282_FIXUP_ASUS_TX300),
9961         SND_PCI_QUIRK(0x1043, 0x106d, "Asus K53BE", ALC269_FIXUP_LIMIT_INT_MIC_BOOST),
9962         SND_PCI_QUIRK(0x1043, 0x10a1, "ASUS UX391UA", ALC294_FIXUP_ASUS_SPK),
9963         SND_PCI_QUIRK(0x1043, 0x10c0, "ASUS X540SA", ALC256_FIXUP_ASUS_MIC),
9964         SND_PCI_QUIRK(0x1043, 0x10d0, "ASUS X540LA/X540LJ", ALC255_FIXUP_ASUS_MIC_NO_PRESENCE),
9965         SND_PCI_QUIRK(0x1043, 0x10d3, "ASUS K6500ZC", ALC294_FIXUP_ASUS_SPK),
9966         SND_PCI_QUIRK(0x1043, 0x115d, "Asus 1015E", ALC269_FIXUP_LIMIT_INT_MIC_BOOST),
9967         SND_PCI_QUIRK(0x1043, 0x11c0, "ASUS X556UR", ALC255_FIXUP_ASUS_MIC_NO_PRESENCE),
9968         SND_PCI_QUIRK(0x1043, 0x125e, "ASUS Q524UQK", ALC255_FIXUP_ASUS_MIC_NO_PRESENCE),
9969         SND_PCI_QUIRK(0x1043, 0x1271, "ASUS X430UN", ALC256_FIXUP_ASUS_MIC_NO_PRESENCE),
9970         SND_PCI_QUIRK(0x1043, 0x1290, "ASUS X441SA", ALC233_FIXUP_EAPD_COEF_AND_MIC_NO_PRESENCE),
9971         SND_PCI_QUIRK(0x1043, 0x12a0, "ASUS X441UV", ALC233_FIXUP_EAPD_COEF_AND_MIC_NO_PRESENCE),
9972         SND_PCI_QUIRK(0x1043, 0x12a3, "Asus N7691ZM", ALC269_FIXUP_ASUS_N7601ZM),
9973         SND_PCI_QUIRK(0x1043, 0x12af, "ASUS UX582ZS", ALC245_FIXUP_CS35L41_SPI_2),
9974         SND_PCI_QUIRK(0x1043, 0x12e0, "ASUS X541SA", ALC256_FIXUP_ASUS_MIC),
9975         SND_PCI_QUIRK(0x1043, 0x12f0, "ASUS X541UV", ALC256_FIXUP_ASUS_MIC),
9976         SND_PCI_QUIRK(0x1043, 0x1313, "Asus K42JZ", ALC269VB_FIXUP_ASUS_MIC_NO_PRESENCE),
9977         SND_PCI_QUIRK(0x1043, 0x13b0, "ASUS Z550SA", ALC256_FIXUP_ASUS_MIC),
9978         SND_PCI_QUIRK(0x1043, 0x1427, "Asus Zenbook UX31E", ALC269VB_FIXUP_ASUS_ZENBOOK),
9979         SND_PCI_QUIRK(0x1043, 0x1433, "ASUS GX650PY/PZ/PV/PU/PYV/PZV/PIV/PVV", ALC285_FIXUP_ASUS_I2C_HEADSET_MIC),
9980         SND_PCI_QUIRK(0x1043, 0x1463, "Asus GA402X/GA402N", ALC285_FIXUP_ASUS_I2C_HEADSET_MIC),
9981         SND_PCI_QUIRK(0x1043, 0x1473, "ASUS GU604VI/VC/VE/VG/VJ/VQ/VU/VV/VY/VZ", ALC285_FIXUP_ASUS_HEADSET_MIC),
9982         SND_PCI_QUIRK(0x1043, 0x1483, "ASUS GU603VQ/VU/VV/VJ/VI", ALC285_FIXUP_ASUS_HEADSET_MIC),
9983         SND_PCI_QUIRK(0x1043, 0x1493, "ASUS GV601VV/VU/VJ/VQ/VI", ALC285_FIXUP_ASUS_HEADSET_MIC),
9984         SND_PCI_QUIRK(0x1043, 0x14d3, "ASUS G614JY/JZ/JG", ALC245_FIXUP_CS35L41_SPI_2),
9985         SND_PCI_QUIRK(0x1043, 0x14e3, "ASUS G513PI/PU/PV", ALC287_FIXUP_CS35L41_I2C_2),
9986         SND_PCI_QUIRK(0x1043, 0x1503, "ASUS G733PY/PZ/PZV/PYV", ALC287_FIXUP_CS35L41_I2C_2),
9987         SND_PCI_QUIRK(0x1043, 0x1517, "Asus Zenbook UX31A", ALC269VB_FIXUP_ASUS_ZENBOOK_UX31A),
9988         SND_PCI_QUIRK(0x1043, 0x1533, "ASUS GV302XA/XJ/XQ/XU/XV/XI", ALC287_FIXUP_CS35L41_I2C_2),
9989         SND_PCI_QUIRK(0x1043, 0x1573, "ASUS GZ301VV/VQ/VU/VJ/VA/VC/VE/VVC/VQC/VUC/VJC/VEC/VCC", ALC285_FIXUP_ASUS_HEADSET_MIC),
9990         SND_PCI_QUIRK(0x1043, 0x1662, "ASUS GV301QH", ALC294_FIXUP_ASUS_DUAL_SPK),
9991         SND_PCI_QUIRK(0x1043, 0x1663, "ASUS GU603ZI/ZJ/ZQ/ZU/ZV", ALC285_FIXUP_ASUS_HEADSET_MIC),
9992         SND_PCI_QUIRK(0x1043, 0x1683, "ASUS UM3402YAR", ALC287_FIXUP_CS35L41_I2C_2),
9993         SND_PCI_QUIRK(0x1043, 0x16a3, "ASUS UX3402VA", ALC245_FIXUP_CS35L41_SPI_2),
9994         SND_PCI_QUIRK(0x1043, 0x16b2, "ASUS GU603", ALC289_FIXUP_ASUS_GA401),
9995         SND_PCI_QUIRK(0x1043, 0x16d3, "ASUS UX5304VA", ALC245_FIXUP_CS35L41_SPI_2),
9996         SND_PCI_QUIRK(0x1043, 0x16e3, "ASUS UX50", ALC269_FIXUP_STEREO_DMIC),
9997         SND_PCI_QUIRK(0x1043, 0x16f3, "ASUS UX7602VI/BZ", ALC245_FIXUP_CS35L41_SPI_2),
9998         SND_PCI_QUIRK(0x1043, 0x1740, "ASUS UX430UA", ALC295_FIXUP_ASUS_DACS),
9999         SND_PCI_QUIRK(0x1043, 0x17d1, "ASUS UX431FL", ALC294_FIXUP_ASUS_DUAL_SPK),
10000         SND_PCI_QUIRK(0x1043, 0x17f3, "ROG Ally NR2301L/X", ALC294_FIXUP_ASUS_ALLY),
10001         SND_PCI_QUIRK(0x1043, 0x1863, "ASUS UX6404VI/VV", ALC245_FIXUP_CS35L41_SPI_2),
10002         SND_PCI_QUIRK(0x1043, 0x1881, "ASUS Zephyrus S/M", ALC294_FIXUP_ASUS_GX502_PINS),
10003         SND_PCI_QUIRK(0x1043, 0x18b1, "Asus MJ401TA", ALC256_FIXUP_ASUS_HEADSET_MIC),
10004         SND_PCI_QUIRK(0x1043, 0x18d3, "ASUS UM3504DA", ALC294_FIXUP_CS35L41_I2C_2),
10005         SND_PCI_QUIRK(0x1043, 0x18f1, "Asus FX505DT", ALC256_FIXUP_ASUS_HEADSET_MIC),
10006         SND_PCI_QUIRK(0x1043, 0x194e, "ASUS UX563FD", ALC294_FIXUP_ASUS_HPE),
10007         SND_PCI_QUIRK(0x1043, 0x1970, "ASUS UX550VE", ALC289_FIXUP_ASUS_GA401),
10008         SND_PCI_QUIRK(0x1043, 0x1982, "ASUS B1400CEPE", ALC256_FIXUP_ASUS_HPE),
10009         SND_PCI_QUIRK(0x1043, 0x19ce, "ASUS B9450FA", ALC294_FIXUP_ASUS_HPE),
10010         SND_PCI_QUIRK(0x1043, 0x19e1, "ASUS UX581LV", ALC295_FIXUP_ASUS_MIC_NO_PRESENCE),
10011         SND_PCI_QUIRK(0x1043, 0x1a13, "Asus G73Jw", ALC269_FIXUP_ASUS_G73JW),
10012         SND_PCI_QUIRK(0x1043, 0x1a30, "ASUS X705UD", ALC256_FIXUP_ASUS_MIC),
10013         SND_PCI_QUIRK(0x1043, 0x1a63, "ASUS UX3405MA", ALC245_FIXUP_CS35L41_SPI_2),
10014         SND_PCI_QUIRK(0x1043, 0x1a83, "ASUS UM5302LA", ALC294_FIXUP_CS35L41_I2C_2),
10015         SND_PCI_QUIRK(0x1043, 0x1a8f, "ASUS UX582ZS", ALC245_FIXUP_CS35L41_SPI_2),
10016         SND_PCI_QUIRK(0x1043, 0x1b11, "ASUS UX431DA", ALC294_FIXUP_ASUS_COEF_1B),
10017         SND_PCI_QUIRK(0x1043, 0x1b13, "Asus U41SV", ALC269_FIXUP_INV_DMIC),
10018         SND_PCI_QUIRK(0x1043, 0x1b93, "ASUS G614JVR/JIR", ALC245_FIXUP_CS35L41_SPI_2),
10019         SND_PCI_QUIRK(0x1043, 0x1bbd, "ASUS Z550MA", ALC255_FIXUP_ASUS_MIC_NO_PRESENCE),
10020         SND_PCI_QUIRK(0x1043, 0x1c03, "ASUS UM3406HA", ALC287_FIXUP_CS35L41_I2C_2),
10021         SND_PCI_QUIRK(0x1043, 0x1c23, "Asus X55U", ALC269_FIXUP_LIMIT_INT_MIC_BOOST),
10022         SND_PCI_QUIRK(0x1043, 0x1c33, "ASUS UX5304MA", ALC245_FIXUP_CS35L41_SPI_2),
10023         SND_PCI_QUIRK(0x1043, 0x1c43, "ASUS UX8406MA", ALC245_FIXUP_CS35L41_SPI_2),
10024         SND_PCI_QUIRK(0x1043, 0x1c62, "ASUS GU603", ALC289_FIXUP_ASUS_GA401),
10025         SND_PCI_QUIRK(0x1043, 0x1c92, "ASUS ROG Strix G15", ALC285_FIXUP_ASUS_G533Z_PINS),
10026         SND_PCI_QUIRK(0x1043, 0x1c9f, "ASUS G614JU/JV/JI", ALC285_FIXUP_ASUS_HEADSET_MIC),
10027         SND_PCI_QUIRK(0x1043, 0x1caf, "ASUS G634JY/JZ/JI/JG", ALC285_FIXUP_ASUS_SPI_REAR_SPEAKERS),
10028         SND_PCI_QUIRK(0x1043, 0x1ccd, "ASUS X555UB", ALC256_FIXUP_ASUS_MIC),
10029         SND_PCI_QUIRK(0x1043, 0x1ccf, "ASUS G814JU/JV/JI", ALC245_FIXUP_CS35L41_SPI_2),
10030         SND_PCI_QUIRK(0x1043, 0x1cdf, "ASUS G814JY/JZ/JG", ALC245_FIXUP_CS35L41_SPI_2),
10031         SND_PCI_QUIRK(0x1043, 0x1cef, "ASUS G834JY/JZ/JI/JG", ALC285_FIXUP_ASUS_HEADSET_MIC),
10032         SND_PCI_QUIRK(0x1043, 0x1d1f, "ASUS G713PI/PU/PV/PVN", ALC287_FIXUP_CS35L41_I2C_2),
10033         SND_PCI_QUIRK(0x1043, 0x1d42, "ASUS Zephyrus G14 2022", ALC289_FIXUP_ASUS_GA401),
10034         SND_PCI_QUIRK(0x1043, 0x1d4e, "ASUS TM420", ALC256_FIXUP_ASUS_HPE),
10035         SND_PCI_QUIRK(0x1043, 0x1da2, "ASUS UP6502ZA/ZD", ALC245_FIXUP_CS35L41_SPI_2),
10036         SND_PCI_QUIRK(0x1043, 0x1e02, "ASUS UX3402ZA", ALC245_FIXUP_CS35L41_SPI_2),
10037         SND_PCI_QUIRK(0x1043, 0x1e11, "ASUS Zephyrus G15", ALC289_FIXUP_ASUS_GA502),
10038         SND_PCI_QUIRK(0x1043, 0x1e12, "ASUS UM3402", ALC287_FIXUP_CS35L41_I2C_2),
10039         SND_PCI_QUIRK(0x1043, 0x1e51, "ASUS Zephyrus M15", ALC294_FIXUP_ASUS_GU502_PINS),
10040         SND_PCI_QUIRK(0x1043, 0x1e5e, "ASUS ROG Strix G513", ALC294_FIXUP_ASUS_G513_PINS),
10041         SND_PCI_QUIRK(0x1043, 0x1e8e, "ASUS Zephyrus G15", ALC289_FIXUP_ASUS_GA401),
10042         SND_PCI_QUIRK(0x1043, 0x1ee2, "ASUS UM6702RA/RC", ALC287_FIXUP_CS35L41_I2C_2),
10043         SND_PCI_QUIRK(0x1043, 0x1c52, "ASUS Zephyrus G15 2022", ALC289_FIXUP_ASUS_GA401),
10044         SND_PCI_QUIRK(0x1043, 0x1f11, "ASUS Zephyrus G14", ALC289_FIXUP_ASUS_GA401),
10045         SND_PCI_QUIRK(0x1043, 0x1f12, "ASUS UM5302", ALC287_FIXUP_CS35L41_I2C_2),
10046         SND_PCI_QUIRK(0x1043, 0x1f1f, "ASUS H7604JI/JV/J3D", ALC245_FIXUP_CS35L41_SPI_2),
10047         SND_PCI_QUIRK(0x1043, 0x1f62, "ASUS UX7602ZM", ALC245_FIXUP_CS35L41_SPI_2),
10048         SND_PCI_QUIRK(0x1043, 0x1f92, "ASUS ROG Flow X16", ALC289_FIXUP_ASUS_GA401),
10049         SND_PCI_QUIRK(0x1043, 0x3030, "ASUS ZN270IE", ALC256_FIXUP_ASUS_AIO_GPIO2),
10050         SND_PCI_QUIRK(0x1043, 0x3a20, "ASUS G614JZR", ALC245_FIXUP_CS35L41_SPI_2),
10051         SND_PCI_QUIRK(0x1043, 0x3a30, "ASUS G814JVR/JIR", ALC245_FIXUP_CS35L41_SPI_2),
10052         SND_PCI_QUIRK(0x1043, 0x3a40, "ASUS G814JZR", ALC245_FIXUP_CS35L41_SPI_2),
10053         SND_PCI_QUIRK(0x1043, 0x3a50, "ASUS G834JYR/JZR", ALC245_FIXUP_CS35L41_SPI_2),
10054         SND_PCI_QUIRK(0x1043, 0x3a60, "ASUS G634JYR/JZR", ALC245_FIXUP_CS35L41_SPI_2),
10055         SND_PCI_QUIRK(0x1043, 0x831a, "ASUS P901", ALC269_FIXUP_STEREO_DMIC),
10056         SND_PCI_QUIRK(0x1043, 0x834a, "ASUS S101", ALC269_FIXUP_STEREO_DMIC),
10057         SND_PCI_QUIRK(0x1043, 0x8398, "ASUS P1005", ALC269_FIXUP_STEREO_DMIC),
10058         SND_PCI_QUIRK(0x1043, 0x83ce, "ASUS P1005", ALC269_FIXUP_STEREO_DMIC),
10059         SND_PCI_QUIRK(0x1043, 0x8516, "ASUS X101CH", ALC269_FIXUP_ASUS_X101),
10060         SND_PCI_QUIRK(0x104d, 0x9073, "Sony VAIO", ALC275_FIXUP_SONY_VAIO_GPIO2),
10061         SND_PCI_QUIRK(0x104d, 0x907b, "Sony VAIO", ALC275_FIXUP_SONY_HWEQ),
10062         SND_PCI_QUIRK(0x104d, 0x9084, "Sony VAIO", ALC275_FIXUP_SONY_HWEQ),
10063         SND_PCI_QUIRK(0x104d, 0x9099, "Sony VAIO S13", ALC275_FIXUP_SONY_DISABLE_AAMIX),
10064         SND_PCI_QUIRK(0x104d, 0x90b5, "Sony VAIO Pro 11", ALC286_FIXUP_SONY_MIC_NO_PRESENCE),
10065         SND_PCI_QUIRK(0x104d, 0x90b6, "Sony VAIO Pro 13", ALC286_FIXUP_SONY_MIC_NO_PRESENCE),
10066         SND_PCI_QUIRK(0x10cf, 0x1475, "Lifebook", ALC269_FIXUP_LIFEBOOK),
10067         SND_PCI_QUIRK(0x10cf, 0x159f, "Lifebook E780", ALC269_FIXUP_LIFEBOOK_NO_HP_TO_LINEOUT),
10068         SND_PCI_QUIRK(0x10cf, 0x15dc, "Lifebook T731", ALC269_FIXUP_LIFEBOOK_HP_PIN),
10069         SND_PCI_QUIRK(0x10cf, 0x1629, "Lifebook U7x7", ALC255_FIXUP_LIFEBOOK_U7x7_HEADSET_MIC),
10070         SND_PCI_QUIRK(0x10cf, 0x1757, "Lifebook E752", ALC269_FIXUP_LIFEBOOK_HP_PIN),
10071         SND_PCI_QUIRK(0x10cf, 0x1845, "Lifebook U904", ALC269_FIXUP_LIFEBOOK_EXTMIC),
10072         SND_PCI_QUIRK(0x10ec, 0x10f2, "Intel Reference board", ALC700_FIXUP_INTEL_REFERENCE),
10073         SND_PCI_QUIRK(0x10ec, 0x118c, "Medion EE4254 MD62100", ALC256_FIXUP_MEDION_HEADSET_NO_PRESENCE),
10074         SND_PCI_QUIRK(0x10ec, 0x1230, "Intel Reference board", ALC295_FIXUP_CHROME_BOOK),
10075         SND_PCI_QUIRK(0x10ec, 0x124c, "Intel Reference board", ALC295_FIXUP_CHROME_BOOK),
10076         SND_PCI_QUIRK(0x10ec, 0x1252, "Intel Reference board", ALC295_FIXUP_CHROME_BOOK),
10077         SND_PCI_QUIRK(0x10ec, 0x1254, "Intel Reference board", ALC295_FIXUP_CHROME_BOOK),
10078         SND_PCI_QUIRK(0x10ec, 0x12cc, "Intel Reference board", ALC295_FIXUP_CHROME_BOOK),
10079         SND_PCI_QUIRK(0x10ec, 0x12f6, "Intel Reference board", ALC295_FIXUP_CHROME_BOOK),
10080         SND_PCI_QUIRK(0x10f7, 0x8338, "Panasonic CF-SZ6", ALC269_FIXUP_HEADSET_MODE),
10081         SND_PCI_QUIRK(0x144d, 0xc109, "Samsung Ativ book 9 (NP900X3G)", ALC269_FIXUP_INV_DMIC),
10082         SND_PCI_QUIRK(0x144d, 0xc169, "Samsung Notebook 9 Pen (NP930SBE-K01US)", ALC298_FIXUP_SAMSUNG_AMP),
10083         SND_PCI_QUIRK(0x144d, 0xc176, "Samsung Notebook 9 Pro (NP930MBE-K04US)", ALC298_FIXUP_SAMSUNG_AMP),
10084         SND_PCI_QUIRK(0x144d, 0xc189, "Samsung Galaxy Flex Book (NT950QCG-X716)", ALC298_FIXUP_SAMSUNG_AMP),
10085         SND_PCI_QUIRK(0x144d, 0xc18a, "Samsung Galaxy Book Ion (NP930XCJ-K01US)", ALC298_FIXUP_SAMSUNG_AMP),
10086         SND_PCI_QUIRK(0x144d, 0xc1a3, "Samsung Galaxy Book Pro (NP935XDB-KC1SE)", ALC298_FIXUP_SAMSUNG_AMP),
10087         SND_PCI_QUIRK(0x144d, 0xc1a6, "Samsung Galaxy Book Pro 360 (NP930QBD)", ALC298_FIXUP_SAMSUNG_AMP),
10088         SND_PCI_QUIRK(0x144d, 0xc740, "Samsung Ativ book 8 (NP870Z5G)", ALC269_FIXUP_ATIV_BOOK_8),
10089         SND_PCI_QUIRK(0x144d, 0xc812, "Samsung Notebook Pen S (NT950SBE-X58)", ALC298_FIXUP_SAMSUNG_AMP),
10090         SND_PCI_QUIRK(0x144d, 0xc830, "Samsung Galaxy Book Ion (NT950XCJ-X716A)", ALC298_FIXUP_SAMSUNG_AMP),
10091         SND_PCI_QUIRK(0x144d, 0xc832, "Samsung Galaxy Book Flex Alpha (NP730QCJ)", ALC256_FIXUP_SAMSUNG_HEADPHONE_VERY_QUIET),
10092         SND_PCI_QUIRK(0x144d, 0xca03, "Samsung Galaxy Book2 Pro 360 (NP930QED)", ALC298_FIXUP_SAMSUNG_AMP),
10093         SND_PCI_QUIRK(0x144d, 0xc868, "Samsung Galaxy Book2 Pro (NP930XED)", ALC298_FIXUP_SAMSUNG_AMP),
10094         SND_PCI_QUIRK(0x1458, 0xfa53, "Gigabyte BXBT-2807", ALC283_FIXUP_HEADSET_MIC),
10095         SND_PCI_QUIRK(0x1462, 0xb120, "MSI Cubi MS-B120", ALC283_FIXUP_HEADSET_MIC),
10096         SND_PCI_QUIRK(0x1462, 0xb171, "Cubi N 8GL (MS-B171)", ALC283_FIXUP_HEADSET_MIC),
10097         SND_PCI_QUIRK(0x152d, 0x1082, "Quanta NL3", ALC269_FIXUP_LIFEBOOK),
10098         SND_PCI_QUIRK(0x1558, 0x1323, "Clevo N130ZU", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10099         SND_PCI_QUIRK(0x1558, 0x1325, "Clevo N15[01][CW]U", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10100         SND_PCI_QUIRK(0x1558, 0x1401, "Clevo L140[CZ]U", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10101         SND_PCI_QUIRK(0x1558, 0x1403, "Clevo N140CU", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10102         SND_PCI_QUIRK(0x1558, 0x1404, "Clevo N150CU", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10103         SND_PCI_QUIRK(0x1558, 0x14a1, "Clevo L141MU", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10104         SND_PCI_QUIRK(0x1558, 0x4018, "Clevo NV40M[BE]", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10105         SND_PCI_QUIRK(0x1558, 0x4019, "Clevo NV40MZ", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10106         SND_PCI_QUIRK(0x1558, 0x4020, "Clevo NV40MB", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10107         SND_PCI_QUIRK(0x1558, 0x4041, "Clevo NV4[15]PZ", ALC256_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10108         SND_PCI_QUIRK(0x1558, 0x40a1, "Clevo NL40GU", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10109         SND_PCI_QUIRK(0x1558, 0x40c1, "Clevo NL40[CZ]U", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10110         SND_PCI_QUIRK(0x1558, 0x40d1, "Clevo NL41DU", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10111         SND_PCI_QUIRK(0x1558, 0x5015, "Clevo NH5[58]H[HJK]Q", ALC256_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10112         SND_PCI_QUIRK(0x1558, 0x5017, "Clevo NH7[79]H[HJK]Q", ALC256_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10113         SND_PCI_QUIRK(0x1558, 0x50a3, "Clevo NJ51GU", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10114         SND_PCI_QUIRK(0x1558, 0x50b3, "Clevo NK50S[BEZ]", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10115         SND_PCI_QUIRK(0x1558, 0x50b6, "Clevo NK50S5", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10116         SND_PCI_QUIRK(0x1558, 0x50b8, "Clevo NK50SZ", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10117         SND_PCI_QUIRK(0x1558, 0x50d5, "Clevo NP50D5", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10118         SND_PCI_QUIRK(0x1558, 0x50e1, "Clevo NH5[58]HPQ", ALC256_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10119         SND_PCI_QUIRK(0x1558, 0x50e2, "Clevo NH7[79]HPQ", ALC256_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10120         SND_PCI_QUIRK(0x1558, 0x50f0, "Clevo NH50A[CDF]", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10121         SND_PCI_QUIRK(0x1558, 0x50f2, "Clevo NH50E[PR]", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10122         SND_PCI_QUIRK(0x1558, 0x50f3, "Clevo NH58DPQ", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10123         SND_PCI_QUIRK(0x1558, 0x50f5, "Clevo NH55EPY", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10124         SND_PCI_QUIRK(0x1558, 0x50f6, "Clevo NH55DPQ", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10125         SND_PCI_QUIRK(0x1558, 0x5101, "Clevo S510WU", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10126         SND_PCI_QUIRK(0x1558, 0x5157, "Clevo W517GU1", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10127         SND_PCI_QUIRK(0x1558, 0x51a1, "Clevo NS50MU", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10128         SND_PCI_QUIRK(0x1558, 0x51b1, "Clevo NS50AU", ALC256_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10129         SND_PCI_QUIRK(0x1558, 0x51b3, "Clevo NS70AU", ALC256_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10130         SND_PCI_QUIRK(0x1558, 0x5630, "Clevo NP50RNJS", ALC256_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10131         SND_PCI_QUIRK(0x1558, 0x70a1, "Clevo NB70T[HJK]", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10132         SND_PCI_QUIRK(0x1558, 0x70b3, "Clevo NK70SB", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10133         SND_PCI_QUIRK(0x1558, 0x70f2, "Clevo NH79EPY", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10134         SND_PCI_QUIRK(0x1558, 0x70f3, "Clevo NH77DPQ", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10135         SND_PCI_QUIRK(0x1558, 0x70f4, "Clevo NH77EPY", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10136         SND_PCI_QUIRK(0x1558, 0x70f6, "Clevo NH77DPQ-Y", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10137         SND_PCI_QUIRK(0x1558, 0x7716, "Clevo NS50PU", ALC256_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10138         SND_PCI_QUIRK(0x1558, 0x7717, "Clevo NS70PU", ALC256_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10139         SND_PCI_QUIRK(0x1558, 0x7718, "Clevo L140PU", ALC256_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10140         SND_PCI_QUIRK(0x1558, 0x7724, "Clevo L140AU", ALC256_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10141         SND_PCI_QUIRK(0x1558, 0x8228, "Clevo NR40BU", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10142         SND_PCI_QUIRK(0x1558, 0x8520, "Clevo NH50D[CD]", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10143         SND_PCI_QUIRK(0x1558, 0x8521, "Clevo NH77D[CD]", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10144         SND_PCI_QUIRK(0x1558, 0x8535, "Clevo NH50D[BE]", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10145         SND_PCI_QUIRK(0x1558, 0x8536, "Clevo NH79D[BE]", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10146         SND_PCI_QUIRK(0x1558, 0x8550, "Clevo NH[57][0-9][ER][ACDH]Q", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10147         SND_PCI_QUIRK(0x1558, 0x8551, "Clevo NH[57][0-9][ER][ACDH]Q", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10148         SND_PCI_QUIRK(0x1558, 0x8560, "Clevo NH[57][0-9][ER][ACDH]Q", ALC269_FIXUP_HEADSET_MIC),
10149         SND_PCI_QUIRK(0x1558, 0x8561, "Clevo NH[57][0-9][ER][ACDH]Q", ALC269_FIXUP_HEADSET_MIC),
10150         SND_PCI_QUIRK(0x1558, 0x8562, "Clevo NH[57][0-9]RZ[Q]", ALC269_FIXUP_DMIC),
10151         SND_PCI_QUIRK(0x1558, 0x8668, "Clevo NP50B[BE]", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10152         SND_PCI_QUIRK(0x1558, 0x866d, "Clevo NP5[05]PN[HJK]", ALC256_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10153         SND_PCI_QUIRK(0x1558, 0x867c, "Clevo NP7[01]PNP", ALC256_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10154         SND_PCI_QUIRK(0x1558, 0x867d, "Clevo NP7[01]PN[HJK]", ALC256_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10155         SND_PCI_QUIRK(0x1558, 0x8680, "Clevo NJ50LU", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10156         SND_PCI_QUIRK(0x1558, 0x8686, "Clevo NH50[CZ]U", ALC256_FIXUP_MIC_NO_PRESENCE_AND_RESUME),
10157         SND_PCI_QUIRK(0x1558, 0x8a20, "Clevo NH55DCQ-Y", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10158         SND_PCI_QUIRK(0x1558, 0x8a51, "Clevo NH70RCQ-Y", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10159         SND_PCI_QUIRK(0x1558, 0x8d50, "Clevo NH55RCQ-M", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10160         SND_PCI_QUIRK(0x1558, 0x951d, "Clevo N950T[CDF]", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10161         SND_PCI_QUIRK(0x1558, 0x9600, "Clevo N960K[PR]", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10162         SND_PCI_QUIRK(0x1558, 0x961d, "Clevo N960S[CDF]", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10163         SND_PCI_QUIRK(0x1558, 0x971d, "Clevo N970T[CDF]", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10164         SND_PCI_QUIRK(0x1558, 0xa500, "Clevo NL5[03]RU", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10165         SND_PCI_QUIRK(0x1558, 0xa600, "Clevo NL50NU", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10166         SND_PCI_QUIRK(0x1558, 0xa650, "Clevo NP[567]0SN[CD]", ALC256_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10167         SND_PCI_QUIRK(0x1558, 0xa671, "Clevo NP70SN[CDE]", ALC256_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10168         SND_PCI_QUIRK(0x1558, 0xb018, "Clevo NP50D[BE]", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10169         SND_PCI_QUIRK(0x1558, 0xb019, "Clevo NH77D[BE]Q", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10170         SND_PCI_QUIRK(0x1558, 0xb022, "Clevo NH77D[DC][QW]", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10171         SND_PCI_QUIRK(0x1558, 0xc018, "Clevo NP50D[BE]", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10172         SND_PCI_QUIRK(0x1558, 0xc019, "Clevo NH77D[BE]Q", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10173         SND_PCI_QUIRK(0x1558, 0xc022, "Clevo NH77[DC][QW]", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10174         SND_PCI_QUIRK(0x17aa, 0x1036, "Lenovo P520", ALC233_FIXUP_LENOVO_MULTI_CODECS),
10175         SND_PCI_QUIRK(0x17aa, 0x1048, "ThinkCentre Station", ALC623_FIXUP_LENOVO_THINKSTATION_P340),
10176         SND_PCI_QUIRK(0x17aa, 0x20f2, "Thinkpad SL410/510", ALC269_FIXUP_SKU_IGNORE),
10177         SND_PCI_QUIRK(0x17aa, 0x215e, "Thinkpad L512", ALC269_FIXUP_SKU_IGNORE),
10178         SND_PCI_QUIRK(0x17aa, 0x21b8, "Thinkpad Edge 14", ALC269_FIXUP_SKU_IGNORE),
10179         SND_PCI_QUIRK(0x17aa, 0x21ca, "Thinkpad L412", ALC269_FIXUP_SKU_IGNORE),
10180         SND_PCI_QUIRK(0x17aa, 0x21e9, "Thinkpad Edge 15", ALC269_FIXUP_SKU_IGNORE),
10181         SND_PCI_QUIRK(0x17aa, 0x21f3, "Thinkpad T430", ALC269_FIXUP_LENOVO_DOCK),
10182         SND_PCI_QUIRK(0x17aa, 0x21f6, "Thinkpad T530", ALC269_FIXUP_LENOVO_DOCK_LIMIT_BOOST),
10183         SND_PCI_QUIRK(0x17aa, 0x21fa, "Thinkpad X230", ALC269_FIXUP_LENOVO_DOCK),
10184         SND_PCI_QUIRK(0x17aa, 0x21fb, "Thinkpad T430s", ALC269_FIXUP_LENOVO_DOCK),
10185         SND_PCI_QUIRK(0x17aa, 0x2203, "Thinkpad X230 Tablet", ALC269_FIXUP_LENOVO_DOCK),
10186         SND_PCI_QUIRK(0x17aa, 0x2208, "Thinkpad T431s", ALC269_FIXUP_LENOVO_DOCK),
10187         SND_PCI_QUIRK(0x17aa, 0x220c, "Thinkpad T440s", ALC292_FIXUP_TPT440),
10188         SND_PCI_QUIRK(0x17aa, 0x220e, "Thinkpad T440p", ALC292_FIXUP_TPT440_DOCK),
10189         SND_PCI_QUIRK(0x17aa, 0x2210, "Thinkpad T540p", ALC292_FIXUP_TPT440_DOCK),
10190         SND_PCI_QUIRK(0x17aa, 0x2211, "Thinkpad W541", ALC292_FIXUP_TPT440_DOCK),
10191         SND_PCI_QUIRK(0x17aa, 0x2212, "Thinkpad T440", ALC292_FIXUP_TPT440_DOCK),
10192         SND_PCI_QUIRK(0x17aa, 0x2214, "Thinkpad X240", ALC292_FIXUP_TPT440_DOCK),
10193         SND_PCI_QUIRK(0x17aa, 0x2215, "Thinkpad", ALC269_FIXUP_LIMIT_INT_MIC_BOOST),
10194         SND_PCI_QUIRK(0x17aa, 0x2218, "Thinkpad X1 Carbon 2nd", ALC292_FIXUP_TPT440_DOCK),
10195         SND_PCI_QUIRK(0x17aa, 0x2223, "ThinkPad T550", ALC292_FIXUP_TPT440_DOCK),
10196         SND_PCI_QUIRK(0x17aa, 0x2226, "ThinkPad X250", ALC292_FIXUP_TPT440_DOCK),
10197         SND_PCI_QUIRK(0x17aa, 0x222d, "Thinkpad", ALC298_FIXUP_TPT470_DOCK),
10198         SND_PCI_QUIRK(0x17aa, 0x222e, "Thinkpad", ALC298_FIXUP_TPT470_DOCK),
10199         SND_PCI_QUIRK(0x17aa, 0x2231, "Thinkpad T560", ALC292_FIXUP_TPT460),
10200         SND_PCI_QUIRK(0x17aa, 0x2233, "Thinkpad", ALC292_FIXUP_TPT460),
10201         SND_PCI_QUIRK(0x17aa, 0x2245, "Thinkpad T470", ALC298_FIXUP_TPT470_DOCK),
10202         SND_PCI_QUIRK(0x17aa, 0x2246, "Thinkpad", ALC298_FIXUP_TPT470_DOCK),
10203         SND_PCI_QUIRK(0x17aa, 0x2247, "Thinkpad", ALC298_FIXUP_TPT470_DOCK),
10204         SND_PCI_QUIRK(0x17aa, 0x2249, "Thinkpad", ALC292_FIXUP_TPT460),
10205         SND_PCI_QUIRK(0x17aa, 0x224b, "Thinkpad", ALC298_FIXUP_TPT470_DOCK),
10206         SND_PCI_QUIRK(0x17aa, 0x224c, "Thinkpad", ALC298_FIXUP_TPT470_DOCK),
10207         SND_PCI_QUIRK(0x17aa, 0x224d, "Thinkpad", ALC298_FIXUP_TPT470_DOCK),
10208         SND_PCI_QUIRK(0x17aa, 0x225d, "Thinkpad T480", ALC269_FIXUP_LIMIT_INT_MIC_BOOST),
10209         SND_PCI_QUIRK(0x17aa, 0x2292, "Thinkpad X1 Carbon 7th", ALC285_FIXUP_THINKPAD_HEADSET_JACK),
10210         SND_PCI_QUIRK(0x17aa, 0x22be, "Thinkpad X1 Carbon 8th", ALC285_FIXUP_THINKPAD_HEADSET_JACK),
10211         SND_PCI_QUIRK(0x17aa, 0x22c1, "Thinkpad P1 Gen 3", ALC285_FIXUP_THINKPAD_NO_BASS_SPK_HEADSET_JACK),
10212         SND_PCI_QUIRK(0x17aa, 0x22c2, "Thinkpad X1 Extreme Gen 3", ALC285_FIXUP_THINKPAD_NO_BASS_SPK_HEADSET_JACK),
10213         SND_PCI_QUIRK(0x17aa, 0x22f1, "Thinkpad", ALC287_FIXUP_MG_RTKC_CSAMP_CS35L41_I2C_THINKPAD),
10214         SND_PCI_QUIRK(0x17aa, 0x22f2, "Thinkpad", ALC287_FIXUP_MG_RTKC_CSAMP_CS35L41_I2C_THINKPAD),
10215         SND_PCI_QUIRK(0x17aa, 0x22f3, "Thinkpad", ALC287_FIXUP_MG_RTKC_CSAMP_CS35L41_I2C_THINKPAD),
10216         SND_PCI_QUIRK(0x17aa, 0x2316, "Thinkpad P1 Gen 6", ALC287_FIXUP_MG_RTKC_CSAMP_CS35L41_I2C_THINKPAD),
10217         SND_PCI_QUIRK(0x17aa, 0x2317, "Thinkpad P1 Gen 6", ALC287_FIXUP_MG_RTKC_CSAMP_CS35L41_I2C_THINKPAD),
10218         SND_PCI_QUIRK(0x17aa, 0x2318, "Thinkpad Z13 Gen2", ALC287_FIXUP_MG_RTKC_CSAMP_CS35L41_I2C_THINKPAD),
10219         SND_PCI_QUIRK(0x17aa, 0x2319, "Thinkpad Z16 Gen2", ALC287_FIXUP_MG_RTKC_CSAMP_CS35L41_I2C_THINKPAD),
10220         SND_PCI_QUIRK(0x17aa, 0x231a, "Thinkpad Z16 Gen2", ALC287_FIXUP_MG_RTKC_CSAMP_CS35L41_I2C_THINKPAD),
10221         SND_PCI_QUIRK(0x17aa, 0x30bb, "ThinkCentre AIO", ALC233_FIXUP_LENOVO_LINE2_MIC_HOTKEY),
10222         SND_PCI_QUIRK(0x17aa, 0x30e2, "ThinkCentre AIO", ALC233_FIXUP_LENOVO_LINE2_MIC_HOTKEY),
10223         SND_PCI_QUIRK(0x17aa, 0x310c, "ThinkCentre Station", ALC294_FIXUP_LENOVO_MIC_LOCATION),
10224         SND_PCI_QUIRK(0x17aa, 0x3111, "ThinkCentre Station", ALC294_FIXUP_LENOVO_MIC_LOCATION),
10225         SND_PCI_QUIRK(0x17aa, 0x312a, "ThinkCentre Station", ALC294_FIXUP_LENOVO_MIC_LOCATION),
10226         SND_PCI_QUIRK(0x17aa, 0x312f, "ThinkCentre Station", ALC294_FIXUP_LENOVO_MIC_LOCATION),
10227         SND_PCI_QUIRK(0x17aa, 0x313c, "ThinkCentre Station", ALC294_FIXUP_LENOVO_MIC_LOCATION),
10228         SND_PCI_QUIRK(0x17aa, 0x3151, "ThinkCentre Station", ALC283_FIXUP_HEADSET_MIC),
10229         SND_PCI_QUIRK(0x17aa, 0x3176, "ThinkCentre Station", ALC283_FIXUP_HEADSET_MIC),
10230         SND_PCI_QUIRK(0x17aa, 0x3178, "ThinkCentre Station", ALC283_FIXUP_HEADSET_MIC),
10231         SND_PCI_QUIRK(0x17aa, 0x31af, "ThinkCentre Station", ALC623_FIXUP_LENOVO_THINKSTATION_P340),
10232         SND_PCI_QUIRK(0x17aa, 0x334b, "Lenovo ThinkCentre M70 Gen5", ALC283_FIXUP_HEADSET_MIC),
10233         SND_PCI_QUIRK(0x17aa, 0x3801, "Lenovo Yoga9 14IAP7", ALC287_FIXUP_YOGA9_14IAP7_BASS_SPK_PIN),
10234         SND_PCI_QUIRK(0x17aa, 0x3802, "Lenovo Yoga Pro 9 14IRP8 / DuetITL 2021", ALC287_FIXUP_LENOVO_14IRP8_DUETITL),
10235         SND_PCI_QUIRK(0x17aa, 0x3813, "Legion 7i 15IMHG05", ALC287_FIXUP_LEGION_15IMHG05_SPEAKERS),
10236         SND_PCI_QUIRK(0x17aa, 0x3818, "Lenovo C940 / Yoga Duet 7", ALC298_FIXUP_LENOVO_C940_DUET7),
10237         SND_PCI_QUIRK(0x17aa, 0x3819, "Lenovo 13s Gen2 ITL", ALC287_FIXUP_13S_GEN2_SPEAKERS),
10238         SND_PCI_QUIRK(0x17aa, 0x3820, "Yoga Duet 7 13ITL6", ALC287_FIXUP_YOGA7_14ITL_SPEAKERS),
10239         SND_PCI_QUIRK(0x17aa, 0x3824, "Legion Y9000X 2020", ALC285_FIXUP_LEGION_Y9000X_SPEAKERS),
10240         SND_PCI_QUIRK(0x17aa, 0x3827, "Ideapad S740", ALC285_FIXUP_IDEAPAD_S740_COEF),
10241         SND_PCI_QUIRK(0x17aa, 0x3834, "Lenovo IdeaPad Slim 9i 14ITL5", ALC287_FIXUP_YOGA7_14ITL_SPEAKERS),
10242         SND_PCI_QUIRK(0x17aa, 0x383d, "Legion Y9000X 2019", ALC285_FIXUP_LEGION_Y9000X_SPEAKERS),
10243         SND_PCI_QUIRK(0x17aa, 0x3843, "Yoga 9i", ALC287_FIXUP_IDEAPAD_BASS_SPK_AMP),
10244         SND_PCI_QUIRK(0x17aa, 0x3847, "Legion 7 16ACHG6", ALC287_FIXUP_LEGION_16ACHG6),
10245         SND_PCI_QUIRK(0x17aa, 0x384a, "Lenovo Yoga 7 15ITL5", ALC287_FIXUP_YOGA7_14ITL_SPEAKERS),
10246         SND_PCI_QUIRK(0x17aa, 0x3852, "Lenovo Yoga 7 14ITL5", ALC287_FIXUP_YOGA7_14ITL_SPEAKERS),
10247         SND_PCI_QUIRK(0x17aa, 0x3853, "Lenovo Yoga 7 15ITL5", ALC287_FIXUP_YOGA7_14ITL_SPEAKERS),
10248         SND_PCI_QUIRK(0x17aa, 0x3855, "Legion 7 16ITHG6", ALC287_FIXUP_LEGION_16ITHG6),
10249         SND_PCI_QUIRK(0x17aa, 0x3869, "Lenovo Yoga7 14IAL7", ALC287_FIXUP_YOGA9_14IAP7_BASS_SPK_PIN),
10250         SND_PCI_QUIRK(0x17aa, 0x386f, "Legion 7i 16IAX7", ALC287_FIXUP_CS35L41_I2C_2),
10251         SND_PCI_QUIRK(0x17aa, 0x3870, "Lenovo Yoga 7 14ARB7", ALC287_FIXUP_YOGA7_14ARB7_I2C),
10252         SND_PCI_QUIRK(0x17aa, 0x387d, "Yoga S780-16 pro Quad AAC", ALC287_FIXUP_TAS2781_I2C),
10253         SND_PCI_QUIRK(0x17aa, 0x387e, "Yoga S780-16 pro Quad YC", ALC287_FIXUP_TAS2781_I2C),
10254         SND_PCI_QUIRK(0x17aa, 0x3881, "YB9 dual power mode2 YC", ALC287_FIXUP_TAS2781_I2C),
10255         SND_PCI_QUIRK(0x17aa, 0x3882, "Lenovo Yoga Pro 7 14APH8", ALC287_FIXUP_YOGA9_14IAP7_BASS_SPK_PIN),
10256         SND_PCI_QUIRK(0x17aa, 0x3884, "Y780 YG DUAL", ALC287_FIXUP_TAS2781_I2C),
10257         SND_PCI_QUIRK(0x17aa, 0x3886, "Y780 VECO DUAL", ALC287_FIXUP_TAS2781_I2C),
10258         SND_PCI_QUIRK(0x17aa, 0x38a7, "Y780P AMD YG dual", ALC287_FIXUP_TAS2781_I2C),
10259         SND_PCI_QUIRK(0x17aa, 0x38a8, "Y780P AMD VECO dual", ALC287_FIXUP_TAS2781_I2C),
10260         SND_PCI_QUIRK(0x17aa, 0x38a9, "Thinkbook 16P", ALC287_FIXUP_CS35L41_I2C_2),
10261         SND_PCI_QUIRK(0x17aa, 0x38ab, "Thinkbook 16P", ALC287_FIXUP_CS35L41_I2C_2),
10262         SND_PCI_QUIRK(0x17aa, 0x38b4, "Legion Slim 7 16IRH8", ALC287_FIXUP_CS35L41_I2C_2),
10263         SND_PCI_QUIRK(0x17aa, 0x38b5, "Legion Slim 7 16IRH8", ALC287_FIXUP_CS35L41_I2C_2),
10264         SND_PCI_QUIRK(0x17aa, 0x38b6, "Legion Slim 7 16APH8", ALC287_FIXUP_CS35L41_I2C_2),
10265         SND_PCI_QUIRK(0x17aa, 0x38b7, "Legion Slim 7 16APH8", ALC287_FIXUP_CS35L41_I2C_2),
10266         SND_PCI_QUIRK(0x17aa, 0x38ba, "Yoga S780-14.5 Air AMD quad YC", ALC287_FIXUP_TAS2781_I2C),
10267         SND_PCI_QUIRK(0x17aa, 0x38bb, "Yoga S780-14.5 Air AMD quad AAC", ALC287_FIXUP_TAS2781_I2C),
10268         SND_PCI_QUIRK(0x17aa, 0x38be, "Yoga S980-14.5 proX YC Dual", ALC287_FIXUP_TAS2781_I2C),
10269         SND_PCI_QUIRK(0x17aa, 0x38bf, "Yoga S980-14.5 proX LX Dual", ALC287_FIXUP_TAS2781_I2C),
10270         SND_PCI_QUIRK(0x17aa, 0x38c3, "Y980 DUAL", ALC287_FIXUP_TAS2781_I2C),
10271         SND_PCI_QUIRK(0x17aa, 0x38cb, "Y790 YG DUAL", ALC287_FIXUP_TAS2781_I2C),
10272         SND_PCI_QUIRK(0x17aa, 0x38cd, "Y790 VECO DUAL", ALC287_FIXUP_TAS2781_I2C),
10273         SND_PCI_QUIRK(0x17aa, 0x3902, "Lenovo E50-80", ALC269_FIXUP_DMIC_THINKPAD_ACPI),
10274         SND_PCI_QUIRK(0x17aa, 0x3977, "IdeaPad S210", ALC283_FIXUP_INT_MIC),
10275         SND_PCI_QUIRK(0x17aa, 0x3978, "Lenovo B50-70", ALC269_FIXUP_DMIC_THINKPAD_ACPI),
10276         SND_PCI_QUIRK(0x17aa, 0x3bf8, "Quanta FL1", ALC269_FIXUP_PCM_44K),
10277         SND_PCI_QUIRK(0x17aa, 0x5013, "Thinkpad", ALC269_FIXUP_LIMIT_INT_MIC_BOOST),
10278         SND_PCI_QUIRK(0x17aa, 0x501a, "Thinkpad", ALC283_FIXUP_INT_MIC),
10279         SND_PCI_QUIRK(0x17aa, 0x501e, "Thinkpad L440", ALC292_FIXUP_TPT440_DOCK),
10280         SND_PCI_QUIRK(0x17aa, 0x5026, "Thinkpad", ALC269_FIXUP_LIMIT_INT_MIC_BOOST),
10281         SND_PCI_QUIRK(0x17aa, 0x5034, "Thinkpad T450", ALC292_FIXUP_TPT440_DOCK),
10282         SND_PCI_QUIRK(0x17aa, 0x5036, "Thinkpad T450s", ALC292_FIXUP_TPT440_DOCK),
10283         SND_PCI_QUIRK(0x17aa, 0x503c, "Thinkpad L450", ALC292_FIXUP_TPT440_DOCK),
10284         SND_PCI_QUIRK(0x17aa, 0x504a, "ThinkPad X260", ALC292_FIXUP_TPT440_DOCK),
10285         SND_PCI_QUIRK(0x17aa, 0x504b, "Thinkpad", ALC293_FIXUP_LENOVO_SPK_NOISE),
10286         SND_PCI_QUIRK(0x17aa, 0x5050, "Thinkpad T560p", ALC292_FIXUP_TPT460),
10287         SND_PCI_QUIRK(0x17aa, 0x5051, "Thinkpad L460", ALC292_FIXUP_TPT460),
10288         SND_PCI_QUIRK(0x17aa, 0x5053, "Thinkpad T460", ALC292_FIXUP_TPT460),
10289         SND_PCI_QUIRK(0x17aa, 0x505d, "Thinkpad", ALC298_FIXUP_TPT470_DOCK),
10290         SND_PCI_QUIRK(0x17aa, 0x505f, "Thinkpad", ALC298_FIXUP_TPT470_DOCK),
10291         SND_PCI_QUIRK(0x17aa, 0x5062, "Thinkpad", ALC298_FIXUP_TPT470_DOCK),
10292         SND_PCI_QUIRK(0x17aa, 0x508b, "Thinkpad X12 Gen 1", ALC287_FIXUP_LEGION_15IMHG05_SPEAKERS),
10293         SND_PCI_QUIRK(0x17aa, 0x5109, "Thinkpad", ALC269_FIXUP_LIMIT_INT_MIC_BOOST),
10294         SND_PCI_QUIRK(0x17aa, 0x511e, "Thinkpad", ALC298_FIXUP_TPT470_DOCK),
10295         SND_PCI_QUIRK(0x17aa, 0x511f, "Thinkpad", ALC298_FIXUP_TPT470_DOCK),
10296         SND_PCI_QUIRK(0x17aa, 0x9e54, "LENOVO NB", ALC269_FIXUP_LENOVO_EAPD),
10297         SND_PCI_QUIRK(0x17aa, 0x9e56, "Lenovo ZhaoYang CF4620Z", ALC286_FIXUP_SONY_MIC_NO_PRESENCE),
10298         SND_PCI_QUIRK(0x1849, 0x1233, "ASRock NUC Box 1100", ALC233_FIXUP_NO_AUDIO_JACK),
10299         SND_PCI_QUIRK(0x1849, 0xa233, "Positivo Master C6300", ALC269_FIXUP_HEADSET_MIC),
10300         SND_PCI_QUIRK(0x19e5, 0x3204, "Huawei MACH-WX9", ALC256_FIXUP_HUAWEI_MACH_WX9_PINS),
10301         SND_PCI_QUIRK(0x19e5, 0x320f, "Huawei WRT-WX9 ", ALC256_FIXUP_ASUS_MIC_NO_PRESENCE),
10302         SND_PCI_QUIRK(0x1b35, 0x1235, "CZC B20", ALC269_FIXUP_CZC_B20),
10303         SND_PCI_QUIRK(0x1b35, 0x1236, "CZC TMI", ALC269_FIXUP_CZC_TMI),
10304         SND_PCI_QUIRK(0x1b35, 0x1237, "CZC L101", ALC269_FIXUP_CZC_L101),
10305         SND_PCI_QUIRK(0x1b7d, 0xa831, "Ordissimo EVE2 ", ALC269VB_FIXUP_ORDISSIMO_EVE2), /* Also known as Malata PC-B1303 */
10306         SND_PCI_QUIRK(0x1c06, 0x2013, "Lemote A1802", ALC269_FIXUP_LEMOTE_A1802),
10307         SND_PCI_QUIRK(0x1c06, 0x2015, "Lemote A190X", ALC269_FIXUP_LEMOTE_A190X),
10308         SND_PCI_QUIRK(0x1c6c, 0x1251, "Positivo N14KP6-TG", ALC288_FIXUP_DELL1_MIC_NO_PRESENCE),
10309         SND_PCI_QUIRK(0x1d05, 0x1132, "TongFang PHxTxX1", ALC256_FIXUP_SET_COEF_DEFAULTS),
10310         SND_PCI_QUIRK(0x1d05, 0x1096, "TongFang GMxMRxx", ALC269_FIXUP_NO_SHUTUP),
10311         SND_PCI_QUIRK(0x1d05, 0x1100, "TongFang GKxNRxx", ALC269_FIXUP_NO_SHUTUP),
10312         SND_PCI_QUIRK(0x1d05, 0x1111, "TongFang GMxZGxx", ALC269_FIXUP_NO_SHUTUP),
10313         SND_PCI_QUIRK(0x1d05, 0x1119, "TongFang GMxZGxx", ALC269_FIXUP_NO_SHUTUP),
10314         SND_PCI_QUIRK(0x1d05, 0x1129, "TongFang GMxZGxx", ALC269_FIXUP_NO_SHUTUP),
10315         SND_PCI_QUIRK(0x1d05, 0x1147, "TongFang GMxTGxx", ALC269_FIXUP_NO_SHUTUP),
10316         SND_PCI_QUIRK(0x1d05, 0x115c, "TongFang GMxTGxx", ALC269_FIXUP_NO_SHUTUP),
10317         SND_PCI_QUIRK(0x1d05, 0x121b, "TongFang GMxAGxx", ALC269_FIXUP_NO_SHUTUP),
10318         SND_PCI_QUIRK(0x1d72, 0x1602, "RedmiBook", ALC255_FIXUP_XIAOMI_HEADSET_MIC),
10319         SND_PCI_QUIRK(0x1d72, 0x1701, "XiaomiNotebook Pro", ALC298_FIXUP_DELL1_MIC_NO_PRESENCE),
10320         SND_PCI_QUIRK(0x1d72, 0x1901, "RedmiBook 14", ALC256_FIXUP_ASUS_HEADSET_MIC),
10321         SND_PCI_QUIRK(0x1d72, 0x1945, "Redmi G", ALC256_FIXUP_ASUS_HEADSET_MIC),
10322         SND_PCI_QUIRK(0x1d72, 0x1947, "RedmiBook Air", ALC255_FIXUP_XIAOMI_HEADSET_MIC),
10323         SND_PCI_QUIRK(0x2782, 0x0232, "CHUWI CoreBook XPro", ALC269VB_FIXUP_CHUWI_COREBOOK_XPRO),
10324         SND_PCI_QUIRK(0x2782, 0x1707, "Vaio VJFE-ADL", ALC298_FIXUP_SPK_VOLUME),
10325         SND_PCI_QUIRK(0x8086, 0x2074, "Intel NUC 8", ALC233_FIXUP_INTEL_NUC8_DMIC),
10326         SND_PCI_QUIRK(0x8086, 0x2080, "Intel NUC 8 Rugged", ALC256_FIXUP_INTEL_NUC8_RUGGED),
10327         SND_PCI_QUIRK(0x8086, 0x2081, "Intel NUC 10", ALC256_FIXUP_INTEL_NUC10),
10328         SND_PCI_QUIRK(0x8086, 0x3038, "Intel NUC 13", ALC295_FIXUP_CHROME_BOOK),
10329         SND_PCI_QUIRK(0xf111, 0x0001, "Framework Laptop", ALC295_FIXUP_FRAMEWORK_LAPTOP_MIC_NO_PRESENCE),
10330         SND_PCI_QUIRK(0xf111, 0x0005, "Framework Laptop", ALC295_FIXUP_FRAMEWORK_LAPTOP_MIC_NO_PRESENCE),
10331         SND_PCI_QUIRK(0xf111, 0x0006, "Framework Laptop", ALC295_FIXUP_FRAMEWORK_LAPTOP_MIC_NO_PRESENCE),
10332
10333 #if 0
10334         /* Below is a quirk table taken from the old code.
10335          * Basically the device should work as is without the fixup table.
10336          * If BIOS doesn't give a proper info, enable the corresponding
10337          * fixup entry.
10338          */
10339         SND_PCI_QUIRK(0x1043, 0x8330, "ASUS Eeepc P703 P900A",
10340                       ALC269_FIXUP_AMIC),
10341         SND_PCI_QUIRK(0x1043, 0x1013, "ASUS N61Da", ALC269_FIXUP_AMIC),
10342         SND_PCI_QUIRK(0x1043, 0x1143, "ASUS B53f", ALC269_FIXUP_AMIC),
10343         SND_PCI_QUIRK(0x1043, 0x1133, "ASUS UJ20ft", ALC269_FIXUP_AMIC),
10344         SND_PCI_QUIRK(0x1043, 0x1183, "ASUS K72DR", ALC269_FIXUP_AMIC),
10345         SND_PCI_QUIRK(0x1043, 0x11b3, "ASUS K52DR", ALC269_FIXUP_AMIC),
10346         SND_PCI_QUIRK(0x1043, 0x11e3, "ASUS U33Jc", ALC269_FIXUP_AMIC),
10347         SND_PCI_QUIRK(0x1043, 0x1273, "ASUS UL80Jt", ALC269_FIXUP_AMIC),
10348         SND_PCI_QUIRK(0x1043, 0x1283, "ASUS U53Jc", ALC269_FIXUP_AMIC),
10349         SND_PCI_QUIRK(0x1043, 0x12b3, "ASUS N82JV", ALC269_FIXUP_AMIC),
10350         SND_PCI_QUIRK(0x1043, 0x12d3, "ASUS N61Jv", ALC269_FIXUP_AMIC),
10351         SND_PCI_QUIRK(0x1043, 0x13a3, "ASUS UL30Vt", ALC269_FIXUP_AMIC),
10352         SND_PCI_QUIRK(0x1043, 0x1373, "ASUS G73JX", ALC269_FIXUP_AMIC),
10353         SND_PCI_QUIRK(0x1043, 0x1383, "ASUS UJ30Jc", ALC269_FIXUP_AMIC),
10354         SND_PCI_QUIRK(0x1043, 0x13d3, "ASUS N61JA", ALC269_FIXUP_AMIC),
10355         SND_PCI_QUIRK(0x1043, 0x1413, "ASUS UL50", ALC269_FIXUP_AMIC),
10356         SND_PCI_QUIRK(0x1043, 0x1443, "ASUS UL30", ALC269_FIXUP_AMIC),
10357         SND_PCI_QUIRK(0x1043, 0x1453, "ASUS M60Jv", ALC269_FIXUP_AMIC),
10358         SND_PCI_QUIRK(0x1043, 0x1483, "ASUS UL80", ALC269_FIXUP_AMIC),
10359         SND_PCI_QUIRK(0x1043, 0x14f3, "ASUS F83Vf", ALC269_FIXUP_AMIC),
10360         SND_PCI_QUIRK(0x1043, 0x14e3, "ASUS UL20", ALC269_FIXUP_AMIC),
10361         SND_PCI_QUIRK(0x1043, 0x1513, "ASUS UX30", ALC269_FIXUP_AMIC),
10362         SND_PCI_QUIRK(0x1043, 0x1593, "ASUS N51Vn", ALC269_FIXUP_AMIC),
10363         SND_PCI_QUIRK(0x1043, 0x15a3, "ASUS N60Jv", ALC269_FIXUP_AMIC),
10364         SND_PCI_QUIRK(0x1043, 0x15b3, "ASUS N60Dp", ALC269_FIXUP_AMIC),
10365         SND_PCI_QUIRK(0x1043, 0x15c3, "ASUS N70De", ALC269_FIXUP_AMIC),
10366         SND_PCI_QUIRK(0x1043, 0x15e3, "ASUS F83T", ALC269_FIXUP_AMIC),
10367         SND_PCI_QUIRK(0x1043, 0x1643, "ASUS M60J", ALC269_FIXUP_AMIC),
10368         SND_PCI_QUIRK(0x1043, 0x1653, "ASUS U50", ALC269_FIXUP_AMIC),
10369         SND_PCI_QUIRK(0x1043, 0x1693, "ASUS F50N", ALC269_FIXUP_AMIC),
10370         SND_PCI_QUIRK(0x1043, 0x16a3, "ASUS F5Q", ALC269_FIXUP_AMIC),
10371         SND_PCI_QUIRK(0x1043, 0x1723, "ASUS P80", ALC269_FIXUP_AMIC),
10372         SND_PCI_QUIRK(0x1043, 0x1743, "ASUS U80", ALC269_FIXUP_AMIC),
10373         SND_PCI_QUIRK(0x1043, 0x1773, "ASUS U20A", ALC269_FIXUP_AMIC),
10374         SND_PCI_QUIRK(0x1043, 0x1883, "ASUS F81Se", ALC269_FIXUP_AMIC),
10375         SND_PCI_QUIRK(0x152d, 0x1778, "Quanta ON1", ALC269_FIXUP_DMIC),
10376         SND_PCI_QUIRK(0x17aa, 0x3be9, "Quanta Wistron", ALC269_FIXUP_AMIC),
10377         SND_PCI_QUIRK(0x17aa, 0x3bf8, "Quanta FL1", ALC269_FIXUP_AMIC),
10378         SND_PCI_QUIRK(0x17ff, 0x059a, "Quanta EL3", ALC269_FIXUP_DMIC),
10379         SND_PCI_QUIRK(0x17ff, 0x059b, "Quanta JR1", ALC269_FIXUP_DMIC),
10380 #endif
10381         {}
10382 };
10383
10384 static const struct snd_pci_quirk alc269_fixup_vendor_tbl[] = {
10385         SND_PCI_QUIRK_VENDOR(0x1025, "Acer Aspire", ALC271_FIXUP_DMIC),
10386         SND_PCI_QUIRK_VENDOR(0x103c, "HP", ALC269_FIXUP_HP_MUTE_LED),
10387         SND_PCI_QUIRK_VENDOR(0x104d, "Sony VAIO", ALC269_FIXUP_SONY_VAIO),
10388         SND_PCI_QUIRK_VENDOR(0x17aa, "Thinkpad", ALC269_FIXUP_THINKPAD_ACPI),
10389         SND_PCI_QUIRK_VENDOR(0x19e5, "Huawei Matebook", ALC255_FIXUP_MIC_MUTE_LED),
10390         {}
10391 };
10392
10393 static const struct hda_model_fixup alc269_fixup_models[] = {
10394         {.id = ALC269_FIXUP_AMIC, .name = "laptop-amic"},
10395         {.id = ALC269_FIXUP_DMIC, .name = "laptop-dmic"},
10396         {.id = ALC269_FIXUP_STEREO_DMIC, .name = "alc269-dmic"},
10397         {.id = ALC271_FIXUP_DMIC, .name = "alc271-dmic"},
10398         {.id = ALC269_FIXUP_INV_DMIC, .name = "inv-dmic"},
10399         {.id = ALC269_FIXUP_HEADSET_MIC, .name = "headset-mic"},
10400         {.id = ALC269_FIXUP_HEADSET_MODE, .name = "headset-mode"},
10401         {.id = ALC269_FIXUP_HEADSET_MODE_NO_HP_MIC, .name = "headset-mode-no-hp-mic"},
10402         {.id = ALC269_FIXUP_LENOVO_DOCK, .name = "lenovo-dock"},
10403         {.id = ALC269_FIXUP_LENOVO_DOCK_LIMIT_BOOST, .name = "lenovo-dock-limit-boost"},
10404         {.id = ALC269_FIXUP_HP_GPIO_LED, .name = "hp-gpio-led"},
10405         {.id = ALC269_FIXUP_HP_DOCK_GPIO_MIC1_LED, .name = "hp-dock-gpio-mic1-led"},
10406         {.id = ALC269_FIXUP_DELL1_MIC_NO_PRESENCE, .name = "dell-headset-multi"},
10407         {.id = ALC269_FIXUP_DELL2_MIC_NO_PRESENCE, .name = "dell-headset-dock"},
10408         {.id = ALC269_FIXUP_DELL3_MIC_NO_PRESENCE, .name = "dell-headset3"},
10409         {.id = ALC269_FIXUP_DELL4_MIC_NO_PRESENCE, .name = "dell-headset4"},
10410         {.id = ALC283_FIXUP_CHROME_BOOK, .name = "alc283-dac-wcaps"},
10411         {.id = ALC283_FIXUP_SENSE_COMBO_JACK, .name = "alc283-sense-combo"},
10412         {.id = ALC292_FIXUP_TPT440_DOCK, .name = "tpt440-dock"},
10413         {.id = ALC292_FIXUP_TPT440, .name = "tpt440"},
10414         {.id = ALC292_FIXUP_TPT460, .name = "tpt460"},
10415         {.id = ALC298_FIXUP_TPT470_DOCK_FIX, .name = "tpt470-dock-fix"},
10416         {.id = ALC298_FIXUP_TPT470_DOCK, .name = "tpt470-dock"},
10417         {.id = ALC233_FIXUP_LENOVO_MULTI_CODECS, .name = "dual-codecs"},
10418         {.id = ALC700_FIXUP_INTEL_REFERENCE, .name = "alc700-ref"},
10419         {.id = ALC269_FIXUP_SONY_VAIO, .name = "vaio"},
10420         {.id = ALC269_FIXUP_DELL_M101Z, .name = "dell-m101z"},
10421         {.id = ALC269_FIXUP_ASUS_G73JW, .name = "asus-g73jw"},
10422         {.id = ALC269_FIXUP_LENOVO_EAPD, .name = "lenovo-eapd"},
10423         {.id = ALC275_FIXUP_SONY_HWEQ, .name = "sony-hweq"},
10424         {.id = ALC269_FIXUP_PCM_44K, .name = "pcm44k"},
10425         {.id = ALC269_FIXUP_LIFEBOOK, .name = "lifebook"},
10426         {.id = ALC269_FIXUP_LIFEBOOK_EXTMIC, .name = "lifebook-extmic"},
10427         {.id = ALC269_FIXUP_LIFEBOOK_HP_PIN, .name = "lifebook-hp-pin"},
10428         {.id = ALC255_FIXUP_LIFEBOOK_U7x7_HEADSET_MIC, .name = "lifebook-u7x7"},
10429         {.id = ALC269VB_FIXUP_AMIC, .name = "alc269vb-amic"},
10430         {.id = ALC269VB_FIXUP_DMIC, .name = "alc269vb-dmic"},
10431         {.id = ALC269_FIXUP_HP_MUTE_LED_MIC1, .name = "hp-mute-led-mic1"},
10432         {.id = ALC269_FIXUP_HP_MUTE_LED_MIC2, .name = "hp-mute-led-mic2"},
10433         {.id = ALC269_FIXUP_HP_MUTE_LED_MIC3, .name = "hp-mute-led-mic3"},
10434         {.id = ALC269_FIXUP_HP_GPIO_MIC1_LED, .name = "hp-gpio-mic1"},
10435         {.id = ALC269_FIXUP_HP_LINE1_MIC1_LED, .name = "hp-line1-mic1"},
10436         {.id = ALC269_FIXUP_NO_SHUTUP, .name = "noshutup"},
10437         {.id = ALC286_FIXUP_SONY_MIC_NO_PRESENCE, .name = "sony-nomic"},
10438         {.id = ALC269_FIXUP_ASPIRE_HEADSET_MIC, .name = "aspire-headset-mic"},
10439         {.id = ALC269_FIXUP_ASUS_X101, .name = "asus-x101"},
10440         {.id = ALC271_FIXUP_HP_GATE_MIC_JACK, .name = "acer-ao7xx"},
10441         {.id = ALC271_FIXUP_HP_GATE_MIC_JACK_E1_572, .name = "acer-aspire-e1"},
10442         {.id = ALC269_FIXUP_ACER_AC700, .name = "acer-ac700"},
10443         {.id = ALC269_FIXUP_LIMIT_INT_MIC_BOOST, .name = "limit-mic-boost"},
10444         {.id = ALC269VB_FIXUP_ASUS_ZENBOOK, .name = "asus-zenbook"},
10445         {.id = ALC269VB_FIXUP_ASUS_ZENBOOK_UX31A, .name = "asus-zenbook-ux31a"},
10446         {.id = ALC269VB_FIXUP_ORDISSIMO_EVE2, .name = "ordissimo"},
10447         {.id = ALC282_FIXUP_ASUS_TX300, .name = "asus-tx300"},
10448         {.id = ALC283_FIXUP_INT_MIC, .name = "alc283-int-mic"},
10449         {.id = ALC290_FIXUP_MONO_SPEAKERS_HSJACK, .name = "mono-speakers"},
10450         {.id = ALC290_FIXUP_SUBWOOFER_HSJACK, .name = "alc290-subwoofer"},
10451         {.id = ALC269_FIXUP_THINKPAD_ACPI, .name = "thinkpad"},
10452         {.id = ALC269_FIXUP_DMIC_THINKPAD_ACPI, .name = "dmic-thinkpad"},
10453         {.id = ALC255_FIXUP_ACER_MIC_NO_PRESENCE, .name = "alc255-acer"},
10454         {.id = ALC255_FIXUP_ASUS_MIC_NO_PRESENCE, .name = "alc255-asus"},
10455         {.id = ALC255_FIXUP_DELL1_MIC_NO_PRESENCE, .name = "alc255-dell1"},
10456         {.id = ALC255_FIXUP_DELL2_MIC_NO_PRESENCE, .name = "alc255-dell2"},
10457         {.id = ALC293_FIXUP_DELL1_MIC_NO_PRESENCE, .name = "alc293-dell1"},
10458         {.id = ALC283_FIXUP_HEADSET_MIC, .name = "alc283-headset"},
10459         {.id = ALC255_FIXUP_MIC_MUTE_LED, .name = "alc255-dell-mute"},
10460         {.id = ALC282_FIXUP_ASPIRE_V5_PINS, .name = "aspire-v5"},
10461         {.id = ALC269VB_FIXUP_ASPIRE_E1_COEF, .name = "aspire-e1-coef"},
10462         {.id = ALC280_FIXUP_HP_GPIO4, .name = "hp-gpio4"},
10463         {.id = ALC286_FIXUP_HP_GPIO_LED, .name = "hp-gpio-led"},
10464         {.id = ALC280_FIXUP_HP_GPIO2_MIC_HOTKEY, .name = "hp-gpio2-hotkey"},
10465         {.id = ALC280_FIXUP_HP_DOCK_PINS, .name = "hp-dock-pins"},
10466         {.id = ALC269_FIXUP_HP_DOCK_GPIO_MIC1_LED, .name = "hp-dock-gpio-mic"},
10467         {.id = ALC280_FIXUP_HP_9480M, .name = "hp-9480m"},
10468         {.id = ALC288_FIXUP_DELL_HEADSET_MODE, .name = "alc288-dell-headset"},
10469         {.id = ALC288_FIXUP_DELL1_MIC_NO_PRESENCE, .name = "alc288-dell1"},
10470         {.id = ALC288_FIXUP_DELL_XPS_13, .name = "alc288-dell-xps13"},
10471         {.id = ALC292_FIXUP_DELL_E7X, .name = "dell-e7x"},
10472         {.id = ALC293_FIXUP_DISABLE_AAMIX_MULTIJACK, .name = "alc293-dell"},
10473         {.id = ALC298_FIXUP_DELL1_MIC_NO_PRESENCE, .name = "alc298-dell1"},
10474         {.id = ALC298_FIXUP_DELL_AIO_MIC_NO_PRESENCE, .name = "alc298-dell-aio"},
10475         {.id = ALC275_FIXUP_DELL_XPS, .name = "alc275-dell-xps"},
10476         {.id = ALC293_FIXUP_LENOVO_SPK_NOISE, .name = "lenovo-spk-noise"},
10477         {.id = ALC233_FIXUP_LENOVO_LINE2_MIC_HOTKEY, .name = "lenovo-hotkey"},
10478         {.id = ALC255_FIXUP_DELL_SPK_NOISE, .name = "dell-spk-noise"},
10479         {.id = ALC225_FIXUP_DELL1_MIC_NO_PRESENCE, .name = "alc225-dell1"},
10480         {.id = ALC295_FIXUP_DISABLE_DAC3, .name = "alc295-disable-dac3"},
10481         {.id = ALC285_FIXUP_SPEAKER2_TO_DAC1, .name = "alc285-speaker2-to-dac1"},
10482         {.id = ALC280_FIXUP_HP_HEADSET_MIC, .name = "alc280-hp-headset"},
10483         {.id = ALC221_FIXUP_HP_FRONT_MIC, .name = "alc221-hp-mic"},
10484         {.id = ALC298_FIXUP_SPK_VOLUME, .name = "alc298-spk-volume"},
10485         {.id = ALC256_FIXUP_DELL_INSPIRON_7559_SUBWOOFER, .name = "dell-inspiron-7559"},
10486         {.id = ALC269_FIXUP_ATIV_BOOK_8, .name = "ativ-book"},
10487         {.id = ALC221_FIXUP_HP_MIC_NO_PRESENCE, .name = "alc221-hp-mic"},
10488         {.id = ALC256_FIXUP_ASUS_HEADSET_MODE, .name = "alc256-asus-headset"},
10489         {.id = ALC256_FIXUP_ASUS_MIC, .name = "alc256-asus-mic"},
10490         {.id = ALC256_FIXUP_ASUS_AIO_GPIO2, .name = "alc256-asus-aio"},
10491         {.id = ALC233_FIXUP_ASUS_MIC_NO_PRESENCE, .name = "alc233-asus"},
10492         {.id = ALC233_FIXUP_EAPD_COEF_AND_MIC_NO_PRESENCE, .name = "alc233-eapd"},
10493         {.id = ALC294_FIXUP_LENOVO_MIC_LOCATION, .name = "alc294-lenovo-mic"},
10494         {.id = ALC225_FIXUP_DELL_WYSE_MIC_NO_PRESENCE, .name = "alc225-wyse"},
10495         {.id = ALC274_FIXUP_DELL_AIO_LINEOUT_VERB, .name = "alc274-dell-aio"},
10496         {.id = ALC255_FIXUP_DUMMY_LINEOUT_VERB, .name = "alc255-dummy-lineout"},
10497         {.id = ALC255_FIXUP_DELL_HEADSET_MIC, .name = "alc255-dell-headset"},
10498         {.id = ALC295_FIXUP_HP_X360, .name = "alc295-hp-x360"},
10499         {.id = ALC225_FIXUP_HEADSET_JACK, .name = "alc-headset-jack"},
10500         {.id = ALC295_FIXUP_CHROME_BOOK, .name = "alc-chrome-book"},
10501         {.id = ALC299_FIXUP_PREDATOR_SPK, .name = "predator-spk"},
10502         {.id = ALC298_FIXUP_HUAWEI_MBX_STEREO, .name = "huawei-mbx-stereo"},
10503         {.id = ALC256_FIXUP_MEDION_HEADSET_NO_PRESENCE, .name = "alc256-medion-headset"},
10504         {.id = ALC298_FIXUP_SAMSUNG_AMP, .name = "alc298-samsung-amp"},
10505         {.id = ALC256_FIXUP_SAMSUNG_HEADPHONE_VERY_QUIET, .name = "alc256-samsung-headphone"},
10506         {.id = ALC255_FIXUP_XIAOMI_HEADSET_MIC, .name = "alc255-xiaomi-headset"},
10507         {.id = ALC274_FIXUP_HP_MIC, .name = "alc274-hp-mic-detect"},
10508         {.id = ALC245_FIXUP_HP_X360_AMP, .name = "alc245-hp-x360-amp"},
10509         {.id = ALC295_FIXUP_HP_OMEN, .name = "alc295-hp-omen"},
10510         {.id = ALC285_FIXUP_HP_SPECTRE_X360, .name = "alc285-hp-spectre-x360"},
10511         {.id = ALC285_FIXUP_HP_SPECTRE_X360_EB1, .name = "alc285-hp-spectre-x360-eb1"},
10512         {.id = ALC285_FIXUP_HP_ENVY_X360, .name = "alc285-hp-envy-x360"},
10513         {.id = ALC287_FIXUP_IDEAPAD_BASS_SPK_AMP, .name = "alc287-ideapad-bass-spk-amp"},
10514         {.id = ALC287_FIXUP_YOGA9_14IAP7_BASS_SPK_PIN, .name = "alc287-yoga9-bass-spk-pin"},
10515         {.id = ALC623_FIXUP_LENOVO_THINKSTATION_P340, .name = "alc623-lenovo-thinkstation-p340"},
10516         {.id = ALC255_FIXUP_ACER_HEADPHONE_AND_MIC, .name = "alc255-acer-headphone-and-mic"},
10517         {.id = ALC285_FIXUP_HP_GPIO_AMP_INIT, .name = "alc285-hp-amp-init"},
10518         {}
10519 };
10520 #define ALC225_STANDARD_PINS \
10521         {0x21, 0x04211020}
10522
10523 #define ALC256_STANDARD_PINS \
10524         {0x12, 0x90a60140}, \
10525         {0x14, 0x90170110}, \
10526         {0x21, 0x02211020}
10527
10528 #define ALC282_STANDARD_PINS \
10529         {0x14, 0x90170110}
10530
10531 #define ALC290_STANDARD_PINS \
10532         {0x12, 0x99a30130}
10533
10534 #define ALC292_STANDARD_PINS \
10535         {0x14, 0x90170110}, \
10536         {0x15, 0x0221401f}
10537
10538 #define ALC295_STANDARD_PINS \
10539         {0x12, 0xb7a60130}, \
10540         {0x14, 0x90170110}, \
10541         {0x21, 0x04211020}
10542
10543 #define ALC298_STANDARD_PINS \
10544         {0x12, 0x90a60130}, \
10545         {0x21, 0x03211020}
10546
10547 static const struct snd_hda_pin_quirk alc269_pin_fixup_tbl[] = {
10548         SND_HDA_PIN_QUIRK(0x10ec0221, 0x103c, "HP Workstation", ALC221_FIXUP_HP_HEADSET_MIC,
10549                 {0x14, 0x01014020},
10550                 {0x17, 0x90170110},
10551                 {0x18, 0x02a11030},
10552                 {0x19, 0x0181303F},
10553                 {0x21, 0x0221102f}),
10554         SND_HDA_PIN_QUIRK(0x10ec0255, 0x1025, "Acer", ALC255_FIXUP_ACER_MIC_NO_PRESENCE,
10555                 {0x12, 0x90a601c0},
10556                 {0x14, 0x90171120},
10557                 {0x21, 0x02211030}),
10558         SND_HDA_PIN_QUIRK(0x10ec0255, 0x1043, "ASUS", ALC255_FIXUP_ASUS_MIC_NO_PRESENCE,
10559                 {0x14, 0x90170110},
10560                 {0x1b, 0x90a70130},
10561                 {0x21, 0x03211020}),
10562         SND_HDA_PIN_QUIRK(0x10ec0255, 0x1043, "ASUS", ALC255_FIXUP_ASUS_MIC_NO_PRESENCE,
10563                 {0x1a, 0x90a70130},
10564                 {0x1b, 0x90170110},
10565                 {0x21, 0x03211020}),
10566         SND_HDA_PIN_QUIRK(0x10ec0225, 0x1028, "Dell", ALC225_FIXUP_DELL1_MIC_NO_PRESENCE,
10567                 ALC225_STANDARD_PINS,
10568                 {0x12, 0xb7a60130},
10569                 {0x14, 0x901701a0}),
10570         SND_HDA_PIN_QUIRK(0x10ec0225, 0x1028, "Dell", ALC225_FIXUP_DELL1_MIC_NO_PRESENCE,
10571                 ALC225_STANDARD_PINS,
10572                 {0x12, 0xb7a60130},
10573                 {0x14, 0x901701b0}),
10574         SND_HDA_PIN_QUIRK(0x10ec0225, 0x1028, "Dell", ALC225_FIXUP_DELL1_MIC_NO_PRESENCE,
10575                 ALC225_STANDARD_PINS,
10576                 {0x12, 0xb7a60150},
10577                 {0x14, 0x901701a0}),
10578         SND_HDA_PIN_QUIRK(0x10ec0225, 0x1028, "Dell", ALC225_FIXUP_DELL1_MIC_NO_PRESENCE,
10579                 ALC225_STANDARD_PINS,
10580                 {0x12, 0xb7a60150},
10581                 {0x14, 0x901701b0}),
10582         SND_HDA_PIN_QUIRK(0x10ec0225, 0x1028, "Dell", ALC225_FIXUP_DELL1_MIC_NO_PRESENCE,
10583                 ALC225_STANDARD_PINS,
10584                 {0x12, 0xb7a60130},
10585                 {0x1b, 0x90170110}),
10586         SND_HDA_PIN_QUIRK(0x10ec0233, 0x8086, "Intel NUC Skull Canyon", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE,
10587                 {0x1b, 0x01111010},
10588                 {0x1e, 0x01451130},
10589                 {0x21, 0x02211020}),
10590         SND_HDA_PIN_QUIRK(0x10ec0235, 0x17aa, "Lenovo", ALC233_FIXUP_LENOVO_LINE2_MIC_HOTKEY,
10591                 {0x12, 0x90a60140},
10592                 {0x14, 0x90170110},
10593                 {0x19, 0x02a11030},
10594                 {0x21, 0x02211020}),
10595         SND_HDA_PIN_QUIRK(0x10ec0235, 0x17aa, "Lenovo", ALC294_FIXUP_LENOVO_MIC_LOCATION,
10596                 {0x14, 0x90170110},
10597                 {0x19, 0x02a11030},
10598                 {0x1a, 0x02a11040},
10599                 {0x1b, 0x01014020},
10600                 {0x21, 0x0221101f}),
10601         SND_HDA_PIN_QUIRK(0x10ec0235, 0x17aa, "Lenovo", ALC294_FIXUP_LENOVO_MIC_LOCATION,
10602                 {0x14, 0x90170110},
10603                 {0x19, 0x02a11030},
10604                 {0x1a, 0x02a11040},
10605                 {0x1b, 0x01011020},
10606                 {0x21, 0x0221101f}),
10607         SND_HDA_PIN_QUIRK(0x10ec0235, 0x17aa, "Lenovo", ALC294_FIXUP_LENOVO_MIC_LOCATION,
10608                 {0x14, 0x90170110},
10609                 {0x19, 0x02a11020},
10610                 {0x1a, 0x02a11030},
10611                 {0x21, 0x0221101f}),
10612         SND_HDA_PIN_QUIRK(0x10ec0236, 0x1028, "Dell", ALC236_FIXUP_DELL_AIO_HEADSET_MIC,
10613                 {0x21, 0x02211010}),
10614         SND_HDA_PIN_QUIRK(0x10ec0236, 0x103c, "HP", ALC256_FIXUP_HP_HEADSET_MIC,
10615                 {0x14, 0x90170110},
10616                 {0x19, 0x02a11020},
10617                 {0x21, 0x02211030}),
10618         SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL2_MIC_NO_PRESENCE,
10619                 {0x14, 0x90170110},
10620                 {0x21, 0x02211020}),
10621         SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
10622                 {0x14, 0x90170130},
10623                 {0x21, 0x02211040}),
10624         SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
10625                 {0x12, 0x90a60140},
10626                 {0x14, 0x90170110},
10627                 {0x21, 0x02211020}),
10628         SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
10629                 {0x12, 0x90a60160},
10630                 {0x14, 0x90170120},
10631                 {0x21, 0x02211030}),
10632         SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
10633                 {0x14, 0x90170110},
10634                 {0x1b, 0x02011020},
10635                 {0x21, 0x0221101f}),
10636         SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
10637                 {0x14, 0x90170110},
10638                 {0x1b, 0x01011020},
10639                 {0x21, 0x0221101f}),
10640         SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
10641                 {0x14, 0x90170130},
10642                 {0x1b, 0x01014020},
10643                 {0x21, 0x0221103f}),
10644         SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
10645                 {0x14, 0x90170130},
10646                 {0x1b, 0x01011020},
10647                 {0x21, 0x0221103f}),
10648         SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
10649                 {0x14, 0x90170130},
10650                 {0x1b, 0x02011020},
10651                 {0x21, 0x0221103f}),
10652         SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
10653                 {0x14, 0x90170150},
10654                 {0x1b, 0x02011020},
10655                 {0x21, 0x0221105f}),
10656         SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
10657                 {0x14, 0x90170110},
10658                 {0x1b, 0x01014020},
10659                 {0x21, 0x0221101f}),
10660         SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
10661                 {0x12, 0x90a60160},
10662                 {0x14, 0x90170120},
10663                 {0x17, 0x90170140},
10664                 {0x21, 0x0321102f}),
10665         SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
10666                 {0x12, 0x90a60160},
10667                 {0x14, 0x90170130},
10668                 {0x21, 0x02211040}),
10669         SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
10670                 {0x12, 0x90a60160},
10671                 {0x14, 0x90170140},
10672                 {0x21, 0x02211050}),
10673         SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
10674                 {0x12, 0x90a60170},
10675                 {0x14, 0x90170120},
10676                 {0x21, 0x02211030}),
10677         SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
10678                 {0x12, 0x90a60170},
10679                 {0x14, 0x90170130},
10680                 {0x21, 0x02211040}),
10681         SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
10682                 {0x12, 0x90a60170},
10683                 {0x14, 0x90171130},
10684                 {0x21, 0x02211040}),
10685         SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
10686                 {0x12, 0x90a60170},
10687                 {0x14, 0x90170140},
10688                 {0x21, 0x02211050}),
10689         SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell Inspiron 5548", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
10690                 {0x12, 0x90a60180},
10691                 {0x14, 0x90170130},
10692                 {0x21, 0x02211040}),
10693         SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell Inspiron 5565", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
10694                 {0x12, 0x90a60180},
10695                 {0x14, 0x90170120},
10696                 {0x21, 0x02211030}),
10697         SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
10698                 {0x1b, 0x01011020},
10699                 {0x21, 0x02211010}),
10700         SND_HDA_PIN_QUIRK(0x10ec0256, 0x1043, "ASUS", ALC256_FIXUP_ASUS_MIC,
10701                 {0x14, 0x90170110},
10702                 {0x1b, 0x90a70130},
10703                 {0x21, 0x04211020}),
10704         SND_HDA_PIN_QUIRK(0x10ec0256, 0x1043, "ASUS", ALC256_FIXUP_ASUS_MIC,
10705                 {0x14, 0x90170110},
10706                 {0x1b, 0x90a70130},
10707                 {0x21, 0x03211020}),
10708         SND_HDA_PIN_QUIRK(0x10ec0256, 0x1043, "ASUS", ALC256_FIXUP_ASUS_MIC_NO_PRESENCE,
10709                 {0x12, 0x90a60130},
10710                 {0x14, 0x90170110},
10711                 {0x21, 0x03211020}),
10712         SND_HDA_PIN_QUIRK(0x10ec0256, 0x1043, "ASUS", ALC256_FIXUP_ASUS_MIC_NO_PRESENCE,
10713                 {0x12, 0x90a60130},
10714                 {0x14, 0x90170110},
10715                 {0x21, 0x04211020}),
10716         SND_HDA_PIN_QUIRK(0x10ec0256, 0x1043, "ASUS", ALC256_FIXUP_ASUS_MIC_NO_PRESENCE,
10717                 {0x1a, 0x90a70130},
10718                 {0x1b, 0x90170110},
10719                 {0x21, 0x03211020}),
10720        SND_HDA_PIN_QUIRK(0x10ec0256, 0x103c, "HP", ALC256_FIXUP_HP_HEADSET_MIC,
10721                 {0x14, 0x90170110},
10722                 {0x19, 0x02a11020},
10723                 {0x21, 0x0221101f}),
10724        SND_HDA_PIN_QUIRK(0x10ec0274, 0x103c, "HP", ALC274_FIXUP_HP_HEADSET_MIC,
10725                 {0x17, 0x90170110},
10726                 {0x19, 0x03a11030},
10727                 {0x21, 0x03211020}),
10728         SND_HDA_PIN_QUIRK(0x10ec0280, 0x103c, "HP", ALC280_FIXUP_HP_GPIO4,
10729                 {0x12, 0x90a60130},
10730                 {0x14, 0x90170110},
10731                 {0x15, 0x0421101f},
10732                 {0x1a, 0x04a11020}),
10733         SND_HDA_PIN_QUIRK(0x10ec0280, 0x103c, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED,
10734                 {0x12, 0x90a60140},
10735                 {0x14, 0x90170110},
10736                 {0x15, 0x0421101f},
10737                 {0x18, 0x02811030},
10738                 {0x1a, 0x04a1103f},
10739                 {0x1b, 0x02011020}),
10740         SND_HDA_PIN_QUIRK(0x10ec0282, 0x103c, "HP 15 Touchsmart", ALC269_FIXUP_HP_MUTE_LED_MIC1,
10741                 ALC282_STANDARD_PINS,
10742                 {0x12, 0x99a30130},
10743                 {0x19, 0x03a11020},
10744                 {0x21, 0x0321101f}),
10745         SND_HDA_PIN_QUIRK(0x10ec0282, 0x103c, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1,
10746                 ALC282_STANDARD_PINS,
10747                 {0x12, 0x99a30130},
10748                 {0x19, 0x03a11020},
10749                 {0x21, 0x03211040}),
10750         SND_HDA_PIN_QUIRK(0x10ec0282, 0x103c, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1,
10751                 ALC282_STANDARD_PINS,
10752                 {0x12, 0x99a30130},
10753                 {0x19, 0x03a11030},
10754                 {0x21, 0x03211020}),
10755         SND_HDA_PIN_QUIRK(0x10ec0282, 0x103c, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1,
10756                 ALC282_STANDARD_PINS,
10757                 {0x12, 0x99a30130},
10758                 {0x19, 0x04a11020},
10759                 {0x21, 0x0421101f}),
10760         SND_HDA_PIN_QUIRK(0x10ec0282, 0x103c, "HP", ALC269_FIXUP_HP_LINE1_MIC1_LED,
10761                 ALC282_STANDARD_PINS,
10762                 {0x12, 0x90a60140},
10763                 {0x19, 0x04a11030},
10764                 {0x21, 0x04211020}),
10765         SND_HDA_PIN_QUIRK(0x10ec0282, 0x1025, "Acer", ALC282_FIXUP_ACER_DISABLE_LINEOUT,
10766                 ALC282_STANDARD_PINS,
10767                 {0x12, 0x90a609c0},
10768                 {0x18, 0x03a11830},
10769                 {0x19, 0x04a19831},
10770                 {0x1a, 0x0481303f},
10771                 {0x1b, 0x04211020},
10772                 {0x21, 0x0321101f}),
10773         SND_HDA_PIN_QUIRK(0x10ec0282, 0x1025, "Acer", ALC282_FIXUP_ACER_DISABLE_LINEOUT,
10774                 ALC282_STANDARD_PINS,
10775                 {0x12, 0x90a60940},
10776                 {0x18, 0x03a11830},
10777                 {0x19, 0x04a19831},
10778                 {0x1a, 0x0481303f},
10779                 {0x1b, 0x04211020},
10780                 {0x21, 0x0321101f}),
10781         SND_HDA_PIN_QUIRK(0x10ec0283, 0x1028, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE,
10782                 ALC282_STANDARD_PINS,
10783                 {0x12, 0x90a60130},
10784                 {0x21, 0x0321101f}),
10785         SND_HDA_PIN_QUIRK(0x10ec0283, 0x1028, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE,
10786                 {0x12, 0x90a60160},
10787                 {0x14, 0x90170120},
10788                 {0x21, 0x02211030}),
10789         SND_HDA_PIN_QUIRK(0x10ec0283, 0x1028, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE,
10790                 ALC282_STANDARD_PINS,
10791                 {0x12, 0x90a60130},
10792                 {0x19, 0x03a11020},
10793                 {0x21, 0x0321101f}),
10794         SND_HDA_PIN_QUIRK(0x10ec0285, 0x17aa, "Lenovo", ALC285_FIXUP_LENOVO_PC_BEEP_IN_NOISE,
10795                 {0x12, 0x90a60130},
10796                 {0x14, 0x90170110},
10797                 {0x19, 0x04a11040},
10798                 {0x21, 0x04211020}),
10799         SND_HDA_PIN_QUIRK(0x10ec0285, 0x17aa, "Lenovo", ALC285_FIXUP_LENOVO_PC_BEEP_IN_NOISE,
10800                 {0x14, 0x90170110},
10801                 {0x19, 0x04a11040},
10802                 {0x1d, 0x40600001},
10803                 {0x21, 0x04211020}),
10804         SND_HDA_PIN_QUIRK(0x10ec0285, 0x17aa, "Lenovo", ALC285_FIXUP_THINKPAD_NO_BASS_SPK_HEADSET_JACK,
10805                 {0x14, 0x90170110},
10806                 {0x19, 0x04a11040},
10807                 {0x21, 0x04211020}),
10808         SND_HDA_PIN_QUIRK(0x10ec0287, 0x17aa, "Lenovo", ALC285_FIXUP_THINKPAD_HEADSET_JACK,
10809                 {0x14, 0x90170110},
10810                 {0x17, 0x90170111},
10811                 {0x19, 0x03a11030},
10812                 {0x21, 0x03211020}),
10813         SND_HDA_PIN_QUIRK(0x10ec0287, 0x17aa, "Lenovo", ALC287_FIXUP_THINKPAD_I2S_SPK,
10814                 {0x17, 0x90170110},
10815                 {0x19, 0x03a11030},
10816                 {0x21, 0x03211020}),
10817         SND_HDA_PIN_QUIRK(0x10ec0287, 0x17aa, "Lenovo", ALC287_FIXUP_THINKPAD_I2S_SPK,
10818                 {0x17, 0x90170110}, /* 0x231f with RTK I2S AMP */
10819                 {0x19, 0x04a11040},
10820                 {0x21, 0x04211020}),
10821         SND_HDA_PIN_QUIRK(0x10ec0286, 0x1025, "Acer", ALC286_FIXUP_ACER_AIO_MIC_NO_PRESENCE,
10822                 {0x12, 0x90a60130},
10823                 {0x17, 0x90170110},
10824                 {0x21, 0x02211020}),
10825         SND_HDA_PIN_QUIRK(0x10ec0288, 0x1028, "Dell", ALC288_FIXUP_DELL1_MIC_NO_PRESENCE,
10826                 {0x12, 0x90a60120},
10827                 {0x14, 0x90170110},
10828                 {0x21, 0x0321101f}),
10829         SND_HDA_PIN_QUIRK(0x10ec0290, 0x103c, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1,
10830                 ALC290_STANDARD_PINS,
10831                 {0x15, 0x04211040},
10832                 {0x18, 0x90170112},
10833                 {0x1a, 0x04a11020}),
10834         SND_HDA_PIN_QUIRK(0x10ec0290, 0x103c, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1,
10835                 ALC290_STANDARD_PINS,
10836                 {0x15, 0x04211040},
10837                 {0x18, 0x90170110},
10838                 {0x1a, 0x04a11020}),
10839         SND_HDA_PIN_QUIRK(0x10ec0290, 0x103c, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1,
10840                 ALC290_STANDARD_PINS,
10841                 {0x15, 0x0421101f},
10842                 {0x1a, 0x04a11020}),
10843         SND_HDA_PIN_QUIRK(0x10ec0290, 0x103c, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1,
10844                 ALC290_STANDARD_PINS,
10845                 {0x15, 0x04211020},
10846                 {0x1a, 0x04a11040}),
10847         SND_HDA_PIN_QUIRK(0x10ec0290, 0x103c, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1,
10848                 ALC290_STANDARD_PINS,
10849                 {0x14, 0x90170110},
10850                 {0x15, 0x04211020},
10851                 {0x1a, 0x04a11040}),
10852         SND_HDA_PIN_QUIRK(0x10ec0290, 0x103c, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1,
10853                 ALC290_STANDARD_PINS,
10854                 {0x14, 0x90170110},
10855                 {0x15, 0x04211020},
10856                 {0x1a, 0x04a11020}),
10857         SND_HDA_PIN_QUIRK(0x10ec0290, 0x103c, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1,
10858                 ALC290_STANDARD_PINS,
10859                 {0x14, 0x90170110},
10860                 {0x15, 0x0421101f},
10861                 {0x1a, 0x04a11020}),
10862         SND_HDA_PIN_QUIRK(0x10ec0292, 0x1028, "Dell", ALC269_FIXUP_DELL2_MIC_NO_PRESENCE,
10863                 ALC292_STANDARD_PINS,
10864                 {0x12, 0x90a60140},
10865                 {0x16, 0x01014020},
10866                 {0x19, 0x01a19030}),
10867         SND_HDA_PIN_QUIRK(0x10ec0292, 0x1028, "Dell", ALC269_FIXUP_DELL2_MIC_NO_PRESENCE,
10868                 ALC292_STANDARD_PINS,
10869                 {0x12, 0x90a60140},
10870                 {0x16, 0x01014020},
10871                 {0x18, 0x02a19031},
10872                 {0x19, 0x01a1903e}),
10873         SND_HDA_PIN_QUIRK(0x10ec0292, 0x1028, "Dell", ALC269_FIXUP_DELL3_MIC_NO_PRESENCE,
10874                 ALC292_STANDARD_PINS,
10875                 {0x12, 0x90a60140}),
10876         SND_HDA_PIN_QUIRK(0x10ec0293, 0x1028, "Dell", ALC293_FIXUP_DELL1_MIC_NO_PRESENCE,
10877                 ALC292_STANDARD_PINS,
10878                 {0x13, 0x90a60140},
10879                 {0x16, 0x21014020},
10880                 {0x19, 0x21a19030}),
10881         SND_HDA_PIN_QUIRK(0x10ec0293, 0x1028, "Dell", ALC293_FIXUP_DELL1_MIC_NO_PRESENCE,
10882                 ALC292_STANDARD_PINS,
10883                 {0x13, 0x90a60140}),
10884         SND_HDA_PIN_QUIRK(0x10ec0294, 0x1043, "ASUS", ALC294_FIXUP_ASUS_HPE,
10885                 {0x17, 0x90170110},
10886                 {0x21, 0x04211020}),
10887         SND_HDA_PIN_QUIRK(0x10ec0294, 0x1043, "ASUS", ALC294_FIXUP_ASUS_MIC,
10888                 {0x14, 0x90170110},
10889                 {0x1b, 0x90a70130},
10890                 {0x21, 0x04211020}),
10891         SND_HDA_PIN_QUIRK(0x10ec0294, 0x1043, "ASUS", ALC294_FIXUP_ASUS_SPK,
10892                 {0x12, 0x90a60130},
10893                 {0x17, 0x90170110},
10894                 {0x21, 0x03211020}),
10895         SND_HDA_PIN_QUIRK(0x10ec0294, 0x1043, "ASUS", ALC294_FIXUP_ASUS_SPK,
10896                 {0x12, 0x90a60130},
10897                 {0x17, 0x90170110},
10898                 {0x21, 0x04211020}),
10899         SND_HDA_PIN_QUIRK(0x10ec0295, 0x1043, "ASUS", ALC294_FIXUP_ASUS_SPK,
10900                 {0x12, 0x90a60130},
10901                 {0x17, 0x90170110},
10902                 {0x21, 0x03211020}),
10903         SND_HDA_PIN_QUIRK(0x10ec0295, 0x1043, "ASUS", ALC295_FIXUP_ASUS_MIC_NO_PRESENCE,
10904                 {0x12, 0x90a60120},
10905                 {0x17, 0x90170110},
10906                 {0x21, 0x04211030}),
10907         SND_HDA_PIN_QUIRK(0x10ec0295, 0x1043, "ASUS", ALC295_FIXUP_ASUS_MIC_NO_PRESENCE,
10908                 {0x12, 0x90a60130},
10909                 {0x17, 0x90170110},
10910                 {0x21, 0x03211020}),
10911         SND_HDA_PIN_QUIRK(0x10ec0295, 0x1043, "ASUS", ALC295_FIXUP_ASUS_MIC_NO_PRESENCE,
10912                 {0x12, 0x90a60130},
10913                 {0x17, 0x90170110},
10914                 {0x21, 0x03211020}),
10915         SND_HDA_PIN_QUIRK(0x10ec0298, 0x1028, "Dell", ALC298_FIXUP_DELL1_MIC_NO_PRESENCE,
10916                 ALC298_STANDARD_PINS,
10917                 {0x17, 0x90170110}),
10918         SND_HDA_PIN_QUIRK(0x10ec0298, 0x1028, "Dell", ALC298_FIXUP_DELL1_MIC_NO_PRESENCE,
10919                 ALC298_STANDARD_PINS,
10920                 {0x17, 0x90170140}),
10921         SND_HDA_PIN_QUIRK(0x10ec0298, 0x1028, "Dell", ALC298_FIXUP_DELL1_MIC_NO_PRESENCE,
10922                 ALC298_STANDARD_PINS,
10923                 {0x17, 0x90170150}),
10924         SND_HDA_PIN_QUIRK(0x10ec0298, 0x1028, "Dell", ALC298_FIXUP_SPK_VOLUME,
10925                 {0x12, 0xb7a60140},
10926                 {0x13, 0xb7a60150},
10927                 {0x17, 0x90170110},
10928                 {0x1a, 0x03011020},
10929                 {0x21, 0x03211030}),
10930         SND_HDA_PIN_QUIRK(0x10ec0298, 0x1028, "Dell", ALC298_FIXUP_ALIENWARE_MIC_NO_PRESENCE,
10931                 {0x12, 0xb7a60140},
10932                 {0x17, 0x90170110},
10933                 {0x1a, 0x03a11030},
10934                 {0x21, 0x03211020}),
10935         SND_HDA_PIN_QUIRK(0x10ec0299, 0x1028, "Dell", ALC269_FIXUP_DELL4_MIC_NO_PRESENCE,
10936                 ALC225_STANDARD_PINS,
10937                 {0x12, 0xb7a60130},
10938                 {0x17, 0x90170110}),
10939         SND_HDA_PIN_QUIRK(0x10ec0623, 0x17aa, "Lenovo", ALC283_FIXUP_HEADSET_MIC,
10940                 {0x14, 0x01014010},
10941                 {0x17, 0x90170120},
10942                 {0x18, 0x02a11030},
10943                 {0x19, 0x02a1103f},
10944                 {0x21, 0x0221101f}),
10945         {}
10946 };
10947
10948 /* This is the fallback pin_fixup_tbl for alc269 family, to make the tbl match
10949  * more machines, don't need to match all valid pins, just need to match
10950  * all the pins defined in the tbl. Just because of this reason, it is possible
10951  * that a single machine matches multiple tbls, so there is one limitation:
10952  *   at most one tbl is allowed to define for the same vendor and same codec
10953  */
10954 static const struct snd_hda_pin_quirk alc269_fallback_pin_fixup_tbl[] = {
10955         SND_HDA_PIN_QUIRK(0x10ec0256, 0x1025, "Acer", ALC2XX_FIXUP_HEADSET_MIC,
10956                 {0x19, 0x40000000}),
10957         SND_HDA_PIN_QUIRK(0x10ec0289, 0x1028, "Dell", ALC269_FIXUP_DELL4_MIC_NO_PRESENCE,
10958                 {0x19, 0x40000000},
10959                 {0x1b, 0x40000000}),
10960         SND_HDA_PIN_QUIRK(0x10ec0295, 0x1028, "Dell", ALC269_FIXUP_DELL4_MIC_NO_PRESENCE,
10961                 {0x19, 0x40000000},
10962                 {0x1b, 0x40000000}),
10963         SND_HDA_PIN_QUIRK(0x10ec0256, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
10964                 {0x19, 0x40000000},
10965                 {0x1a, 0x40000000}),
10966         SND_HDA_PIN_QUIRK(0x10ec0236, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
10967                 {0x19, 0x40000000},
10968                 {0x1a, 0x40000000}),
10969         SND_HDA_PIN_QUIRK(0x10ec0274, 0x1028, "Dell", ALC274_FIXUP_DELL_AIO_LINEOUT_VERB,
10970                 {0x19, 0x40000000},
10971                 {0x1a, 0x40000000}),
10972         SND_HDA_PIN_QUIRK(0x10ec0256, 0x1043, "ASUS", ALC2XX_FIXUP_HEADSET_MIC,
10973                 {0x19, 0x40000000}),
10974         {}
10975 };
10976
10977 static void alc269_fill_coef(struct hda_codec *codec)
10978 {
10979         struct alc_spec *spec = codec->spec;
10980         int val;
10981
10982         if (spec->codec_variant != ALC269_TYPE_ALC269VB)
10983                 return;
10984
10985         if ((alc_get_coef0(codec) & 0x00ff) < 0x015) {
10986                 alc_write_coef_idx(codec, 0xf, 0x960b);
10987                 alc_write_coef_idx(codec, 0xe, 0x8817);
10988         }
10989
10990         if ((alc_get_coef0(codec) & 0x00ff) == 0x016) {
10991                 alc_write_coef_idx(codec, 0xf, 0x960b);
10992                 alc_write_coef_idx(codec, 0xe, 0x8814);
10993         }
10994
10995         if ((alc_get_coef0(codec) & 0x00ff) == 0x017) {
10996                 /* Power up output pin */
10997                 alc_update_coef_idx(codec, 0x04, 0, 1<<11);
10998         }
10999
11000         if ((alc_get_coef0(codec) & 0x00ff) == 0x018) {
11001                 val = alc_read_coef_idx(codec, 0xd);
11002                 if (val != -1 && (val & 0x0c00) >> 10 != 0x1) {
11003                         /* Capless ramp up clock control */
11004                         alc_write_coef_idx(codec, 0xd, val | (1<<10));
11005                 }
11006                 val = alc_read_coef_idx(codec, 0x17);
11007                 if (val != -1 && (val & 0x01c0) >> 6 != 0x4) {
11008                         /* Class D power on reset */
11009                         alc_write_coef_idx(codec, 0x17, val | (1<<7));
11010                 }
11011         }
11012
11013         /* HP */
11014         alc_update_coef_idx(codec, 0x4, 0, 1<<11);
11015 }
11016
11017 /*
11018  */
11019 static int patch_alc269(struct hda_codec *codec)
11020 {
11021         struct alc_spec *spec;
11022         int err;
11023
11024         err = alc_alloc_spec(codec, 0x0b);
11025         if (err < 0)
11026                 return err;
11027
11028         spec = codec->spec;
11029         spec->gen.shared_mic_vref_pin = 0x18;
11030         codec->power_save_node = 0;
11031         spec->en_3kpull_low = true;
11032
11033 #ifdef CONFIG_PM
11034         codec->patch_ops.suspend = alc269_suspend;
11035         codec->patch_ops.resume = alc269_resume;
11036 #endif
11037         spec->shutup = alc_default_shutup;
11038         spec->init_hook = alc_default_init;
11039
11040         switch (codec->core.vendor_id) {
11041         case 0x10ec0269:
11042                 spec->codec_variant = ALC269_TYPE_ALC269VA;
11043                 switch (alc_get_coef0(codec) & 0x00f0) {
11044                 case 0x0010:
11045                         if (codec->bus->pci &&
11046                             codec->bus->pci->subsystem_vendor == 0x1025 &&
11047                             spec->cdefine.platform_type == 1)
11048                                 err = alc_codec_rename(codec, "ALC271X");
11049                         spec->codec_variant = ALC269_TYPE_ALC269VB;
11050                         break;
11051                 case 0x0020:
11052                         if (codec->bus->pci &&
11053                             codec->bus->pci->subsystem_vendor == 0x17aa &&
11054                             codec->bus->pci->subsystem_device == 0x21f3)
11055                                 err = alc_codec_rename(codec, "ALC3202");
11056                         spec->codec_variant = ALC269_TYPE_ALC269VC;
11057                         break;
11058                 case 0x0030:
11059                         spec->codec_variant = ALC269_TYPE_ALC269VD;
11060                         break;
11061                 default:
11062                         alc_fix_pll_init(codec, 0x20, 0x04, 15);
11063                 }
11064                 if (err < 0)
11065                         goto error;
11066                 spec->shutup = alc269_shutup;
11067                 spec->init_hook = alc269_fill_coef;
11068                 alc269_fill_coef(codec);
11069                 break;
11070
11071         case 0x10ec0280:
11072         case 0x10ec0290:
11073                 spec->codec_variant = ALC269_TYPE_ALC280;
11074                 break;
11075         case 0x10ec0282:
11076                 spec->codec_variant = ALC269_TYPE_ALC282;
11077                 spec->shutup = alc282_shutup;
11078                 spec->init_hook = alc282_init;
11079                 break;
11080         case 0x10ec0233:
11081         case 0x10ec0283:
11082                 spec->codec_variant = ALC269_TYPE_ALC283;
11083                 spec->shutup = alc283_shutup;
11084                 spec->init_hook = alc283_init;
11085                 break;
11086         case 0x10ec0284:
11087         case 0x10ec0292:
11088                 spec->codec_variant = ALC269_TYPE_ALC284;
11089                 break;
11090         case 0x10ec0293:
11091                 spec->codec_variant = ALC269_TYPE_ALC293;
11092                 break;
11093         case 0x10ec0286:
11094         case 0x10ec0288:
11095                 spec->codec_variant = ALC269_TYPE_ALC286;
11096                 break;
11097         case 0x10ec0298:
11098                 spec->codec_variant = ALC269_TYPE_ALC298;
11099                 break;
11100         case 0x10ec0235:
11101         case 0x10ec0255:
11102                 spec->codec_variant = ALC269_TYPE_ALC255;
11103                 spec->shutup = alc256_shutup;
11104                 spec->init_hook = alc256_init;
11105                 break;
11106         case 0x10ec0230:
11107         case 0x10ec0236:
11108         case 0x10ec0256:
11109         case 0x19e58326:
11110                 spec->codec_variant = ALC269_TYPE_ALC256;
11111                 spec->shutup = alc256_shutup;
11112                 spec->init_hook = alc256_init;
11113                 spec->gen.mixer_nid = 0; /* ALC256 does not have any loopback mixer path */
11114                 if (codec->core.vendor_id == 0x10ec0236 &&
11115                     codec->bus->pci->vendor != PCI_VENDOR_ID_AMD)
11116                         spec->en_3kpull_low = false;
11117                 break;
11118         case 0x10ec0257:
11119                 spec->codec_variant = ALC269_TYPE_ALC257;
11120                 spec->shutup = alc256_shutup;
11121                 spec->init_hook = alc256_init;
11122                 spec->gen.mixer_nid = 0;
11123                 spec->en_3kpull_low = false;
11124                 break;
11125         case 0x10ec0215:
11126         case 0x10ec0245:
11127         case 0x10ec0285:
11128         case 0x10ec0289:
11129                 if (alc_get_coef0(codec) & 0x0010)
11130                         spec->codec_variant = ALC269_TYPE_ALC245;
11131                 else
11132                         spec->codec_variant = ALC269_TYPE_ALC215;
11133                 spec->shutup = alc225_shutup;
11134                 spec->init_hook = alc225_init;
11135                 spec->gen.mixer_nid = 0;
11136                 break;
11137         case 0x10ec0225:
11138         case 0x10ec0295:
11139         case 0x10ec0299:
11140                 spec->codec_variant = ALC269_TYPE_ALC225;
11141                 spec->shutup = alc225_shutup;
11142                 spec->init_hook = alc225_init;
11143                 spec->gen.mixer_nid = 0; /* no loopback on ALC225, ALC295 and ALC299 */
11144                 break;
11145         case 0x10ec0287:
11146                 spec->codec_variant = ALC269_TYPE_ALC287;
11147                 spec->shutup = alc225_shutup;
11148                 spec->init_hook = alc225_init;
11149                 spec->gen.mixer_nid = 0; /* no loopback on ALC287 */
11150                 break;
11151         case 0x10ec0234:
11152         case 0x10ec0274:
11153         case 0x10ec0294:
11154                 spec->codec_variant = ALC269_TYPE_ALC294;
11155                 spec->gen.mixer_nid = 0; /* ALC2x4 does not have any loopback mixer path */
11156                 alc_update_coef_idx(codec, 0x6b, 0x0018, (1<<4) | (1<<3)); /* UAJ MIC Vref control by verb */
11157                 spec->init_hook = alc294_init;
11158                 break;
11159         case 0x10ec0300:
11160                 spec->codec_variant = ALC269_TYPE_ALC300;
11161                 spec->gen.mixer_nid = 0; /* no loopback on ALC300 */
11162                 break;
11163         case 0x10ec0623:
11164                 spec->codec_variant = ALC269_TYPE_ALC623;
11165                 break;
11166         case 0x10ec0700:
11167         case 0x10ec0701:
11168         case 0x10ec0703:
11169         case 0x10ec0711:
11170                 spec->codec_variant = ALC269_TYPE_ALC700;
11171                 spec->gen.mixer_nid = 0; /* ALC700 does not have any loopback mixer path */
11172                 alc_update_coef_idx(codec, 0x4a, 1 << 15, 0); /* Combo jack auto trigger control */
11173                 spec->init_hook = alc294_init;
11174                 break;
11175
11176         }
11177
11178         if (snd_hda_codec_read(codec, 0x51, 0, AC_VERB_PARAMETERS, 0) == 0x10ec5505) {
11179                 spec->has_alc5505_dsp = 1;
11180                 spec->init_hook = alc5505_dsp_init;
11181         }
11182
11183         alc_pre_init(codec);
11184
11185         snd_hda_pick_fixup(codec, alc269_fixup_models,
11186                        alc269_fixup_tbl, alc269_fixups);
11187         /* FIXME: both TX300 and ROG Strix G17 have the same SSID, and
11188          * the quirk breaks the latter (bko#214101).
11189          * Clear the wrong entry.
11190          */
11191         if (codec->fixup_id == ALC282_FIXUP_ASUS_TX300 &&
11192             codec->core.vendor_id == 0x10ec0294) {
11193                 codec_dbg(codec, "Clear wrong fixup for ASUS ROG Strix G17\n");
11194                 codec->fixup_id = HDA_FIXUP_ID_NOT_SET;
11195         }
11196
11197         snd_hda_pick_pin_fixup(codec, alc269_pin_fixup_tbl, alc269_fixups, true);
11198         snd_hda_pick_pin_fixup(codec, alc269_fallback_pin_fixup_tbl, alc269_fixups, false);
11199         snd_hda_pick_fixup(codec, NULL, alc269_fixup_vendor_tbl,
11200                            alc269_fixups);
11201         snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE);
11202
11203         alc_auto_parse_customize_define(codec);
11204
11205         if (has_cdefine_beep(codec))
11206                 spec->gen.beep_nid = 0x01;
11207
11208         /* automatic parse from the BIOS config */
11209         err = alc269_parse_auto_config(codec);
11210         if (err < 0)
11211                 goto error;
11212
11213         if (!spec->gen.no_analog && spec->gen.beep_nid && spec->gen.mixer_nid) {
11214                 err = set_beep_amp(spec, spec->gen.mixer_nid, 0x04, HDA_INPUT);
11215                 if (err < 0)
11216                         goto error;
11217         }
11218
11219         snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE);
11220
11221         return 0;
11222
11223  error:
11224         alc_free(codec);
11225         return err;
11226 }
11227
11228 /*
11229  * ALC861
11230  */
11231
11232 static int alc861_parse_auto_config(struct hda_codec *codec)
11233 {
11234         static const hda_nid_t alc861_ignore[] = { 0x1d, 0 };
11235         static const hda_nid_t alc861_ssids[] = { 0x0e, 0x0f, 0x0b, 0 };
11236         return alc_parse_auto_config(codec, alc861_ignore, alc861_ssids);
11237 }
11238
11239 /* Pin config fixes */
11240 enum {
11241         ALC861_FIXUP_FSC_AMILO_PI1505,
11242         ALC861_FIXUP_AMP_VREF_0F,
11243         ALC861_FIXUP_NO_JACK_DETECT,
11244         ALC861_FIXUP_ASUS_A6RP,
11245         ALC660_FIXUP_ASUS_W7J,
11246 };
11247
11248 /* On some laptops, VREF of pin 0x0f is abused for controlling the main amp */
11249 static void alc861_fixup_asus_amp_vref_0f(struct hda_codec *codec,
11250                         const struct hda_fixup *fix, int action)
11251 {
11252         struct alc_spec *spec = codec->spec;
11253         unsigned int val;
11254
11255         if (action != HDA_FIXUP_ACT_INIT)
11256                 return;
11257         val = snd_hda_codec_get_pin_target(codec, 0x0f);
11258         if (!(val & (AC_PINCTL_IN_EN | AC_PINCTL_OUT_EN)))
11259                 val |= AC_PINCTL_IN_EN;
11260         val |= AC_PINCTL_VREF_50;
11261         snd_hda_set_pin_ctl(codec, 0x0f, val);
11262         spec->gen.keep_vref_in_automute = 1;
11263 }
11264
11265 /* suppress the jack-detection */
11266 static void alc_fixup_no_jack_detect(struct hda_codec *codec,
11267                                      const struct hda_fixup *fix, int action)
11268 {
11269         if (action == HDA_FIXUP_ACT_PRE_PROBE)
11270                 codec->no_jack_detect = 1;
11271 }
11272
11273 static const struct hda_fixup alc861_fixups[] = {
11274         [ALC861_FIXUP_FSC_AMILO_PI1505] = {
11275                 .type = HDA_FIXUP_PINS,
11276                 .v.pins = (const struct hda_pintbl[]) {
11277                         { 0x0b, 0x0221101f }, /* HP */
11278                         { 0x0f, 0x90170310 }, /* speaker */
11279                         { }
11280                 }
11281         },
11282         [ALC861_FIXUP_AMP_VREF_0F] = {
11283                 .type = HDA_FIXUP_FUNC,
11284                 .v.func = alc861_fixup_asus_amp_vref_0f,
11285         },
11286         [ALC861_FIXUP_NO_JACK_DETECT] = {
11287                 .type = HDA_FIXUP_FUNC,
11288                 .v.func = alc_fixup_no_jack_detect,
11289         },
11290         [ALC861_FIXUP_ASUS_A6RP] = {
11291                 .type = HDA_FIXUP_FUNC,
11292                 .v.func = alc861_fixup_asus_amp_vref_0f,
11293                 .chained = true,
11294                 .chain_id = ALC861_FIXUP_NO_JACK_DETECT,
11295         },
11296         [ALC660_FIXUP_ASUS_W7J] = {
11297                 .type = HDA_FIXUP_VERBS,
11298                 .v.verbs = (const struct hda_verb[]) {
11299                         /* ASUS W7J needs a magic pin setup on unused NID 0x10
11300                          * for enabling outputs
11301                          */
11302                         {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
11303                         { }
11304                 },
11305         }
11306 };
11307
11308 static const struct snd_pci_quirk alc861_fixup_tbl[] = {
11309         SND_PCI_QUIRK(0x1043, 0x1253, "ASUS W7J", ALC660_FIXUP_ASUS_W7J),
11310         SND_PCI_QUIRK(0x1043, 0x1263, "ASUS Z35HL", ALC660_FIXUP_ASUS_W7J),
11311         SND_PCI_QUIRK(0x1043, 0x1393, "ASUS A6Rp", ALC861_FIXUP_ASUS_A6RP),
11312         SND_PCI_QUIRK_VENDOR(0x1043, "ASUS laptop", ALC861_FIXUP_AMP_VREF_0F),
11313         SND_PCI_QUIRK(0x1462, 0x7254, "HP DX2200", ALC861_FIXUP_NO_JACK_DETECT),
11314         SND_PCI_QUIRK_VENDOR(0x1584, "Haier/Uniwill", ALC861_FIXUP_AMP_VREF_0F),
11315         SND_PCI_QUIRK(0x1734, 0x10c7, "FSC Amilo Pi1505", ALC861_FIXUP_FSC_AMILO_PI1505),
11316         {}
11317 };
11318
11319 /*
11320  */
11321 static int patch_alc861(struct hda_codec *codec)
11322 {
11323         struct alc_spec *spec;
11324         int err;
11325
11326         err = alc_alloc_spec(codec, 0x15);
11327         if (err < 0)
11328                 return err;
11329
11330         spec = codec->spec;
11331         if (has_cdefine_beep(codec))
11332                 spec->gen.beep_nid = 0x23;
11333
11334 #ifdef CONFIG_PM
11335         spec->power_hook = alc_power_eapd;
11336 #endif
11337
11338         alc_pre_init(codec);
11339
11340         snd_hda_pick_fixup(codec, NULL, alc861_fixup_tbl, alc861_fixups);
11341         snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE);
11342
11343         /* automatic parse from the BIOS config */
11344         err = alc861_parse_auto_config(codec);
11345         if (err < 0)
11346                 goto error;
11347
11348         if (!spec->gen.no_analog) {
11349                 err = set_beep_amp(spec, 0x23, 0, HDA_OUTPUT);
11350                 if (err < 0)
11351                         goto error;
11352         }
11353
11354         snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE);
11355
11356         return 0;
11357
11358  error:
11359         alc_free(codec);
11360         return err;
11361 }
11362
11363 /*
11364  * ALC861-VD support
11365  *
11366  * Based on ALC882
11367  *
11368  * In addition, an independent DAC
11369  */
11370 static int alc861vd_parse_auto_config(struct hda_codec *codec)
11371 {
11372         static const hda_nid_t alc861vd_ignore[] = { 0x1d, 0 };
11373         static const hda_nid_t alc861vd_ssids[] = { 0x15, 0x1b, 0x14, 0 };
11374         return alc_parse_auto_config(codec, alc861vd_ignore, alc861vd_ssids);
11375 }
11376
11377 enum {
11378         ALC660VD_FIX_ASUS_GPIO1,
11379         ALC861VD_FIX_DALLAS,
11380 };
11381
11382 /* exclude VREF80 */
11383 static void alc861vd_fixup_dallas(struct hda_codec *codec,
11384                                   const struct hda_fixup *fix, int action)
11385 {
11386         if (action == HDA_FIXUP_ACT_PRE_PROBE) {
11387                 snd_hda_override_pin_caps(codec, 0x18, 0x00000734);
11388                 snd_hda_override_pin_caps(codec, 0x19, 0x0000073c);
11389         }
11390 }
11391
11392 /* reset GPIO1 */
11393 static void alc660vd_fixup_asus_gpio1(struct hda_codec *codec,
11394                                       const struct hda_fixup *fix, int action)
11395 {
11396         struct alc_spec *spec = codec->spec;
11397
11398         if (action == HDA_FIXUP_ACT_PRE_PROBE)
11399                 spec->gpio_mask |= 0x02;
11400         alc_fixup_gpio(codec, action, 0x01);
11401 }
11402
11403 static const struct hda_fixup alc861vd_fixups[] = {
11404         [ALC660VD_FIX_ASUS_GPIO1] = {
11405                 .type = HDA_FIXUP_FUNC,
11406                 .v.func = alc660vd_fixup_asus_gpio1,
11407         },
11408         [ALC861VD_FIX_DALLAS] = {
11409                 .type = HDA_FIXUP_FUNC,
11410                 .v.func = alc861vd_fixup_dallas,
11411         },
11412 };
11413
11414 static const struct snd_pci_quirk alc861vd_fixup_tbl[] = {
11415         SND_PCI_QUIRK(0x103c, 0x30bf, "HP TX1000", ALC861VD_FIX_DALLAS),
11416         SND_PCI_QUIRK(0x1043, 0x1339, "ASUS A7-K", ALC660VD_FIX_ASUS_GPIO1),
11417         SND_PCI_QUIRK(0x1179, 0xff31, "Toshiba L30-149", ALC861VD_FIX_DALLAS),
11418         {}
11419 };
11420
11421 /*
11422  */
11423 static int patch_alc861vd(struct hda_codec *codec)
11424 {
11425         struct alc_spec *spec;
11426         int err;
11427
11428         err = alc_alloc_spec(codec, 0x0b);
11429         if (err < 0)
11430                 return err;
11431
11432         spec = codec->spec;
11433         if (has_cdefine_beep(codec))
11434                 spec->gen.beep_nid = 0x23;
11435
11436         spec->shutup = alc_eapd_shutup;
11437
11438         alc_pre_init(codec);
11439
11440         snd_hda_pick_fixup(codec, NULL, alc861vd_fixup_tbl, alc861vd_fixups);
11441         snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE);
11442
11443         /* automatic parse from the BIOS config */
11444         err = alc861vd_parse_auto_config(codec);
11445         if (err < 0)
11446                 goto error;
11447
11448         if (!spec->gen.no_analog) {
11449                 err = set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
11450                 if (err < 0)
11451                         goto error;
11452         }
11453
11454         snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE);
11455
11456         return 0;
11457
11458  error:
11459         alc_free(codec);
11460         return err;
11461 }
11462
11463 /*
11464  * ALC662 support
11465  *
11466  * ALC662 is almost identical with ALC880 but has cleaner and more flexible
11467  * configuration.  Each pin widget can choose any input DACs and a mixer.
11468  * Each ADC is connected from a mixer of all inputs.  This makes possible
11469  * 6-channel independent captures.
11470  *
11471  * In addition, an independent DAC for the multi-playback (not used in this
11472  * driver yet).
11473  */
11474
11475 /*
11476  * BIOS auto configuration
11477  */
11478
11479 static int alc662_parse_auto_config(struct hda_codec *codec)
11480 {
11481         static const hda_nid_t alc662_ignore[] = { 0x1d, 0 };
11482         static const hda_nid_t alc663_ssids[] = { 0x15, 0x1b, 0x14, 0x21 };
11483         static const hda_nid_t alc662_ssids[] = { 0x15, 0x1b, 0x14, 0 };
11484         const hda_nid_t *ssids;
11485
11486         if (codec->core.vendor_id == 0x10ec0272 || codec->core.vendor_id == 0x10ec0663 ||
11487             codec->core.vendor_id == 0x10ec0665 || codec->core.vendor_id == 0x10ec0670 ||
11488             codec->core.vendor_id == 0x10ec0671)
11489                 ssids = alc663_ssids;
11490         else
11491                 ssids = alc662_ssids;
11492         return alc_parse_auto_config(codec, alc662_ignore, ssids);
11493 }
11494
11495 static void alc272_fixup_mario(struct hda_codec *codec,
11496                                const struct hda_fixup *fix, int action)
11497 {
11498         if (action != HDA_FIXUP_ACT_PRE_PROBE)
11499                 return;
11500         if (snd_hda_override_amp_caps(codec, 0x2, HDA_OUTPUT,
11501                                       (0x3b << AC_AMPCAP_OFFSET_SHIFT) |
11502                                       (0x3b << AC_AMPCAP_NUM_STEPS_SHIFT) |
11503                                       (0x03 << AC_AMPCAP_STEP_SIZE_SHIFT) |
11504                                       (0 << AC_AMPCAP_MUTE_SHIFT)))
11505                 codec_warn(codec, "failed to override amp caps for NID 0x2\n");
11506 }
11507
11508 static const struct snd_pcm_chmap_elem asus_pcm_2_1_chmaps[] = {
11509         { .channels = 2,
11510           .map = { SNDRV_CHMAP_FL, SNDRV_CHMAP_FR } },
11511         { .channels = 4,
11512           .map = { SNDRV_CHMAP_FL, SNDRV_CHMAP_FR,
11513                    SNDRV_CHMAP_NA, SNDRV_CHMAP_LFE } }, /* LFE only on right */
11514         { }
11515 };
11516
11517 /* override the 2.1 chmap */
11518 static void alc_fixup_bass_chmap(struct hda_codec *codec,
11519                                     const struct hda_fixup *fix, int action)
11520 {
11521         if (action == HDA_FIXUP_ACT_BUILD) {
11522                 struct alc_spec *spec = codec->spec;
11523                 spec->gen.pcm_rec[0]->stream[0].chmap = asus_pcm_2_1_chmaps;
11524         }
11525 }
11526
11527 /* avoid D3 for keeping GPIO up */
11528 static unsigned int gpio_led_power_filter(struct hda_codec *codec,
11529                                           hda_nid_t nid,
11530                                           unsigned int power_state)
11531 {
11532         struct alc_spec *spec = codec->spec;
11533         if (nid == codec->core.afg && power_state == AC_PWRST_D3 && spec->gpio_data)
11534                 return AC_PWRST_D0;
11535         return power_state;
11536 }
11537
11538 static void alc662_fixup_led_gpio1(struct hda_codec *codec,
11539                                    const struct hda_fixup *fix, int action)
11540 {
11541         struct alc_spec *spec = codec->spec;
11542
11543         alc_fixup_hp_gpio_led(codec, action, 0x01, 0);
11544         if (action == HDA_FIXUP_ACT_PRE_PROBE) {
11545                 spec->mute_led_polarity = 1;
11546                 codec->power_filter = gpio_led_power_filter;
11547         }
11548 }
11549
11550 static void alc662_usi_automute_hook(struct hda_codec *codec,
11551                                          struct hda_jack_callback *jack)
11552 {
11553         struct alc_spec *spec = codec->spec;
11554         int vref;
11555         msleep(200);
11556         snd_hda_gen_hp_automute(codec, jack);
11557
11558         vref = spec->gen.hp_jack_present ? PIN_VREF80 : 0;
11559         msleep(100);
11560         snd_hda_codec_write(codec, 0x19, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
11561                             vref);
11562 }
11563
11564 static void alc662_fixup_usi_headset_mic(struct hda_codec *codec,
11565                                      const struct hda_fixup *fix, int action)
11566 {
11567         struct alc_spec *spec = codec->spec;
11568         if (action == HDA_FIXUP_ACT_PRE_PROBE) {
11569                 spec->parse_flags |= HDA_PINCFG_HEADSET_MIC;
11570                 spec->gen.hp_automute_hook = alc662_usi_automute_hook;
11571         }
11572 }
11573
11574 static void alc662_aspire_ethos_mute_speakers(struct hda_codec *codec,
11575                                         struct hda_jack_callback *cb)
11576 {
11577         /* surround speakers at 0x1b already get muted automatically when
11578          * headphones are plugged in, but we have to mute/unmute the remaining
11579          * channels manually:
11580          * 0x15 - front left/front right
11581          * 0x18 - front center/ LFE
11582          */
11583         if (snd_hda_jack_detect_state(codec, 0x1b) == HDA_JACK_PRESENT) {
11584                 snd_hda_set_pin_ctl_cache(codec, 0x15, 0);
11585                 snd_hda_set_pin_ctl_cache(codec, 0x18, 0);
11586         } else {
11587                 snd_hda_set_pin_ctl_cache(codec, 0x15, PIN_OUT);
11588                 snd_hda_set_pin_ctl_cache(codec, 0x18, PIN_OUT);
11589         }
11590 }
11591
11592 static void alc662_fixup_aspire_ethos_hp(struct hda_codec *codec,
11593                                         const struct hda_fixup *fix, int action)
11594 {
11595     /* Pin 0x1b: shared headphones jack and surround speakers */
11596         if (!is_jack_detectable(codec, 0x1b))
11597                 return;
11598
11599         switch (action) {
11600         case HDA_FIXUP_ACT_PRE_PROBE:
11601                 snd_hda_jack_detect_enable_callback(codec, 0x1b,
11602                                 alc662_aspire_ethos_mute_speakers);
11603                 /* subwoofer needs an extra GPIO setting to become audible */
11604                 alc_setup_gpio(codec, 0x02);
11605                 break;
11606         case HDA_FIXUP_ACT_INIT:
11607                 /* Make sure to start in a correct state, i.e. if
11608                  * headphones have been plugged in before powering up the system
11609                  */
11610                 alc662_aspire_ethos_mute_speakers(codec, NULL);
11611                 break;
11612         }
11613 }
11614
11615 static void alc671_fixup_hp_headset_mic2(struct hda_codec *codec,
11616                                              const struct hda_fixup *fix, int action)
11617 {
11618         struct alc_spec *spec = codec->spec;
11619
11620         static const struct hda_pintbl pincfgs[] = {
11621                 { 0x19, 0x02a11040 }, /* use as headset mic, with its own jack detect */
11622                 { 0x1b, 0x0181304f },
11623                 { }
11624         };
11625
11626         switch (action) {
11627         case HDA_FIXUP_ACT_PRE_PROBE:
11628                 spec->gen.mixer_nid = 0;
11629                 spec->parse_flags |= HDA_PINCFG_HEADSET_MIC;
11630                 snd_hda_apply_pincfgs(codec, pincfgs);
11631                 break;
11632         case HDA_FIXUP_ACT_INIT:
11633                 alc_write_coef_idx(codec, 0x19, 0xa054);
11634                 break;
11635         }
11636 }
11637
11638 static void alc897_hp_automute_hook(struct hda_codec *codec,
11639                                          struct hda_jack_callback *jack)
11640 {
11641         struct alc_spec *spec = codec->spec;
11642         int vref;
11643
11644         snd_hda_gen_hp_automute(codec, jack);
11645         vref = spec->gen.hp_jack_present ? (PIN_HP | AC_PINCTL_VREF_100) : PIN_HP;
11646         snd_hda_set_pin_ctl(codec, 0x1b, vref);
11647 }
11648
11649 static void alc897_fixup_lenovo_headset_mic(struct hda_codec *codec,
11650                                      const struct hda_fixup *fix, int action)
11651 {
11652         struct alc_spec *spec = codec->spec;
11653         if (action == HDA_FIXUP_ACT_PRE_PROBE) {
11654                 spec->gen.hp_automute_hook = alc897_hp_automute_hook;
11655                 spec->no_shutup_pins = 1;
11656         }
11657         if (action == HDA_FIXUP_ACT_PROBE) {
11658                 snd_hda_set_pin_ctl_cache(codec, 0x1a, PIN_IN | AC_PINCTL_VREF_100);
11659         }
11660 }
11661
11662 static void alc897_fixup_lenovo_headset_mode(struct hda_codec *codec,
11663                                      const struct hda_fixup *fix, int action)
11664 {
11665         struct alc_spec *spec = codec->spec;
11666
11667         if (action == HDA_FIXUP_ACT_PRE_PROBE) {
11668                 spec->parse_flags |= HDA_PINCFG_HEADSET_MIC;
11669                 spec->gen.hp_automute_hook = alc897_hp_automute_hook;
11670         }
11671 }
11672
11673 static const struct coef_fw alc668_coefs[] = {
11674         WRITE_COEF(0x01, 0xbebe), WRITE_COEF(0x02, 0xaaaa), WRITE_COEF(0x03,    0x0),
11675         WRITE_COEF(0x04, 0x0180), WRITE_COEF(0x06,    0x0), WRITE_COEF(0x07, 0x0f80),
11676         WRITE_COEF(0x08, 0x0031), WRITE_COEF(0x0a, 0x0060), WRITE_COEF(0x0b,    0x0),
11677         WRITE_COEF(0x0c, 0x7cf7), WRITE_COEF(0x0d, 0x1080), WRITE_COEF(0x0e, 0x7f7f),
11678         WRITE_COEF(0x0f, 0xcccc), WRITE_COEF(0x10, 0xddcc), WRITE_COEF(0x11, 0x0001),
11679         WRITE_COEF(0x13,    0x0), WRITE_COEF(0x14, 0x2aa0), WRITE_COEF(0x17, 0xa940),
11680         WRITE_COEF(0x19,    0x0), WRITE_COEF(0x1a,    0x0), WRITE_COEF(0x1b,    0x0),
11681         WRITE_COEF(0x1c,    0x0), WRITE_COEF(0x1d,    0x0), WRITE_COEF(0x1e, 0x7418),
11682         WRITE_COEF(0x1f, 0x0804), WRITE_COEF(0x20, 0x4200), WRITE_COEF(0x21, 0x0468),
11683         WRITE_COEF(0x22, 0x8ccc), WRITE_COEF(0x23, 0x0250), WRITE_COEF(0x24, 0x7418),
11684         WRITE_COEF(0x27,    0x0), WRITE_COEF(0x28, 0x8ccc), WRITE_COEF(0x2a, 0xff00),
11685         WRITE_COEF(0x2b, 0x8000), WRITE_COEF(0xa7, 0xff00), WRITE_COEF(0xa8, 0x8000),
11686         WRITE_COEF(0xaa, 0x2e17), WRITE_COEF(0xab, 0xa0c0), WRITE_COEF(0xac,    0x0),
11687         WRITE_COEF(0xad,    0x0), WRITE_COEF(0xae, 0x2ac6), WRITE_COEF(0xaf, 0xa480),
11688         WRITE_COEF(0xb0,    0x0), WRITE_COEF(0xb1,    0x0), WRITE_COEF(0xb2,    0x0),
11689         WRITE_COEF(0xb3,    0x0), WRITE_COEF(0xb4,    0x0), WRITE_COEF(0xb5, 0x1040),
11690         WRITE_COEF(0xb6, 0xd697), WRITE_COEF(0xb7, 0x902b), WRITE_COEF(0xb8, 0xd697),
11691         WRITE_COEF(0xb9, 0x902b), WRITE_COEF(0xba, 0xb8ba), WRITE_COEF(0xbb, 0xaaab),
11692         WRITE_COEF(0xbc, 0xaaaf), WRITE_COEF(0xbd, 0x6aaa), WRITE_COEF(0xbe, 0x1c02),
11693         WRITE_COEF(0xc0, 0x00ff), WRITE_COEF(0xc1, 0x0fa6),
11694         {}
11695 };
11696
11697 static void alc668_restore_default_value(struct hda_codec *codec)
11698 {
11699         alc_process_coef_fw(codec, alc668_coefs);
11700 }
11701
11702 enum {
11703         ALC662_FIXUP_ASPIRE,
11704         ALC662_FIXUP_LED_GPIO1,
11705         ALC662_FIXUP_IDEAPAD,
11706         ALC272_FIXUP_MARIO,
11707         ALC662_FIXUP_CZC_ET26,
11708         ALC662_FIXUP_CZC_P10T,
11709         ALC662_FIXUP_SKU_IGNORE,
11710         ALC662_FIXUP_HP_RP5800,
11711         ALC662_FIXUP_ASUS_MODE1,
11712         ALC662_FIXUP_ASUS_MODE2,
11713         ALC662_FIXUP_ASUS_MODE3,
11714         ALC662_FIXUP_ASUS_MODE4,
11715         ALC662_FIXUP_ASUS_MODE5,
11716         ALC662_FIXUP_ASUS_MODE6,
11717         ALC662_FIXUP_ASUS_MODE7,
11718         ALC662_FIXUP_ASUS_MODE8,
11719         ALC662_FIXUP_NO_JACK_DETECT,
11720         ALC662_FIXUP_ZOTAC_Z68,
11721         ALC662_FIXUP_INV_DMIC,
11722         ALC662_FIXUP_DELL_MIC_NO_PRESENCE,
11723         ALC668_FIXUP_DELL_MIC_NO_PRESENCE,
11724         ALC662_FIXUP_HEADSET_MODE,
11725         ALC668_FIXUP_HEADSET_MODE,
11726         ALC662_FIXUP_BASS_MODE4_CHMAP,
11727         ALC662_FIXUP_BASS_16,
11728         ALC662_FIXUP_BASS_1A,
11729         ALC662_FIXUP_BASS_CHMAP,
11730         ALC668_FIXUP_AUTO_MUTE,
11731         ALC668_FIXUP_DELL_DISABLE_AAMIX,
11732         ALC668_FIXUP_DELL_XPS13,
11733         ALC662_FIXUP_ASUS_Nx50,
11734         ALC668_FIXUP_ASUS_Nx51_HEADSET_MODE,
11735         ALC668_FIXUP_ASUS_Nx51,
11736         ALC668_FIXUP_MIC_COEF,
11737         ALC668_FIXUP_ASUS_G751,
11738         ALC891_FIXUP_HEADSET_MODE,
11739         ALC891_FIXUP_DELL_MIC_NO_PRESENCE,
11740         ALC662_FIXUP_ACER_VERITON,
11741         ALC892_FIXUP_ASROCK_MOBO,
11742         ALC662_FIXUP_USI_FUNC,
11743         ALC662_FIXUP_USI_HEADSET_MODE,
11744         ALC662_FIXUP_LENOVO_MULTI_CODECS,
11745         ALC669_FIXUP_ACER_ASPIRE_ETHOS,
11746         ALC669_FIXUP_ACER_ASPIRE_ETHOS_HEADSET,
11747         ALC671_FIXUP_HP_HEADSET_MIC2,
11748         ALC662_FIXUP_ACER_X2660G_HEADSET_MODE,
11749         ALC662_FIXUP_ACER_NITRO_HEADSET_MODE,
11750         ALC668_FIXUP_ASUS_NO_HEADSET_MIC,
11751         ALC668_FIXUP_HEADSET_MIC,
11752         ALC668_FIXUP_MIC_DET_COEF,
11753         ALC897_FIXUP_LENOVO_HEADSET_MIC,
11754         ALC897_FIXUP_HEADSET_MIC_PIN,
11755         ALC897_FIXUP_HP_HSMIC_VERB,
11756         ALC897_FIXUP_LENOVO_HEADSET_MODE,
11757         ALC897_FIXUP_HEADSET_MIC_PIN2,
11758         ALC897_FIXUP_UNIS_H3C_X500S,
11759 };
11760
11761 static const struct hda_fixup alc662_fixups[] = {
11762         [ALC662_FIXUP_ASPIRE] = {
11763                 .type = HDA_FIXUP_PINS,
11764                 .v.pins = (const struct hda_pintbl[]) {
11765                         { 0x15, 0x99130112 }, /* subwoofer */
11766                         { }
11767                 }
11768         },
11769         [ALC662_FIXUP_LED_GPIO1] = {
11770                 .type = HDA_FIXUP_FUNC,
11771                 .v.func = alc662_fixup_led_gpio1,
11772         },
11773         [ALC662_FIXUP_IDEAPAD] = {
11774                 .type = HDA_FIXUP_PINS,
11775                 .v.pins = (const struct hda_pintbl[]) {
11776                         { 0x17, 0x99130112 }, /* subwoofer */
11777                         { }
11778                 },
11779                 .chained = true,
11780                 .chain_id = ALC662_FIXUP_LED_GPIO1,
11781         },
11782         [ALC272_FIXUP_MARIO] = {
11783                 .type = HDA_FIXUP_FUNC,
11784                 .v.func = alc272_fixup_mario,
11785         },
11786         [ALC662_FIXUP_CZC_ET26] = {
11787                 .type = HDA_FIXUP_PINS,
11788                 .v.pins = (const struct hda_pintbl[]) {
11789                         {0x12, 0x403cc000},
11790                         {0x14, 0x90170110}, /* speaker */
11791                         {0x15, 0x411111f0},
11792                         {0x16, 0x411111f0},
11793                         {0x18, 0x01a19030}, /* mic */
11794                         {0x19, 0x90a7013f}, /* int-mic */
11795                         {0x1a, 0x01014020},
11796                         {0x1b, 0x0121401f},
11797                         {0x1c, 0x411111f0},
11798                         {0x1d, 0x411111f0},
11799                         {0x1e, 0x40478e35},
11800                         {}
11801                 },
11802                 .chained = true,
11803                 .chain_id = ALC662_FIXUP_SKU_IGNORE
11804         },
11805         [ALC662_FIXUP_CZC_P10T] = {
11806                 .type = HDA_FIXUP_VERBS,
11807                 .v.verbs = (const struct hda_verb[]) {
11808                         {0x14, AC_VERB_SET_EAPD_BTLENABLE, 0},
11809                         {}
11810                 }
11811         },
11812         [ALC662_FIXUP_SKU_IGNORE] = {
11813                 .type = HDA_FIXUP_FUNC,
11814                 .v.func = alc_fixup_sku_ignore,
11815         },
11816         [ALC662_FIXUP_HP_RP5800] = {
11817                 .type = HDA_FIXUP_PINS,
11818                 .v.pins = (const struct hda_pintbl[]) {
11819                         { 0x14, 0x0221201f }, /* HP out */
11820                         { }
11821                 },
11822                 .chained = true,
11823                 .chain_id = ALC662_FIXUP_SKU_IGNORE
11824         },
11825         [ALC662_FIXUP_ASUS_MODE1] = {
11826                 .type = HDA_FIXUP_PINS,
11827                 .v.pins = (const struct hda_pintbl[]) {
11828                         { 0x14, 0x99130110 }, /* speaker */
11829                         { 0x18, 0x01a19c20 }, /* mic */
11830                         { 0x19, 0x99a3092f }, /* int-mic */
11831                         { 0x21, 0x0121401f }, /* HP out */
11832                         { }
11833                 },
11834                 .chained = true,
11835                 .chain_id = ALC662_FIXUP_SKU_IGNORE
11836         },
11837         [ALC662_FIXUP_ASUS_MODE2] = {
11838                 .type = HDA_FIXUP_PINS,
11839                 .v.pins = (const struct hda_pintbl[]) {
11840                         { 0x14, 0x99130110 }, /* speaker */
11841                         { 0x18, 0x01a19820 }, /* mic */
11842                         { 0x19, 0x99a3092f }, /* int-mic */
11843                         { 0x1b, 0x0121401f }, /* HP out */
11844                         { }
11845                 },
11846                 .chained = true,
11847                 .chain_id = ALC662_FIXUP_SKU_IGNORE
11848         },
11849         [ALC662_FIXUP_ASUS_MODE3] = {
11850                 .type = HDA_FIXUP_PINS,
11851                 .v.pins = (const struct hda_pintbl[]) {
11852                         { 0x14, 0x99130110 }, /* speaker */
11853                         { 0x15, 0x0121441f }, /* HP */
11854                         { 0x18, 0x01a19840 }, /* mic */
11855                         { 0x19, 0x99a3094f }, /* int-mic */
11856                         { 0x21, 0x01211420 }, /* HP2 */
11857                         { }
11858                 },
11859                 .chained = true,
11860                 .chain_id = ALC662_FIXUP_SKU_IGNORE
11861         },
11862         [ALC662_FIXUP_ASUS_MODE4] = {
11863                 .type = HDA_FIXUP_PINS,
11864                 .v.pins = (const struct hda_pintbl[]) {
11865                         { 0x14, 0x99130110 }, /* speaker */
11866                         { 0x16, 0x99130111 }, /* speaker */
11867                         { 0x18, 0x01a19840 }, /* mic */
11868                         { 0x19, 0x99a3094f }, /* int-mic */
11869                         { 0x21, 0x0121441f }, /* HP */
11870                         { }
11871                 },
11872                 .chained = true,
11873                 .chain_id = ALC662_FIXUP_SKU_IGNORE
11874         },
11875         [ALC662_FIXUP_ASUS_MODE5] = {
11876                 .type = HDA_FIXUP_PINS,
11877                 .v.pins = (const struct hda_pintbl[]) {
11878                         { 0x14, 0x99130110 }, /* speaker */
11879                         { 0x15, 0x0121441f }, /* HP */
11880                         { 0x16, 0x99130111 }, /* speaker */
11881                         { 0x18, 0x01a19840 }, /* mic */
11882                         { 0x19, 0x99a3094f }, /* int-mic */
11883                         { }
11884                 },
11885                 .chained = true,
11886                 .chain_id = ALC662_FIXUP_SKU_IGNORE
11887         },
11888         [ALC662_FIXUP_ASUS_MODE6] = {
11889                 .type = HDA_FIXUP_PINS,
11890                 .v.pins = (const struct hda_pintbl[]) {
11891                         { 0x14, 0x99130110 }, /* speaker */
11892                         { 0x15, 0x01211420 }, /* HP2 */
11893                         { 0x18, 0x01a19840 }, /* mic */
11894                         { 0x19, 0x99a3094f }, /* int-mic */
11895                         { 0x1b, 0x0121441f }, /* HP */
11896                         { }
11897                 },
11898                 .chained = true,
11899                 .chain_id = ALC662_FIXUP_SKU_IGNORE
11900         },
11901         [ALC662_FIXUP_ASUS_MODE7] = {
11902                 .type = HDA_FIXUP_PINS,
11903                 .v.pins = (const struct hda_pintbl[]) {
11904                         { 0x14, 0x99130110 }, /* speaker */
11905                         { 0x17, 0x99130111 }, /* speaker */
11906                         { 0x18, 0x01a19840 }, /* mic */
11907                         { 0x19, 0x99a3094f }, /* int-mic */
11908                         { 0x1b, 0x01214020 }, /* HP */
11909                         { 0x21, 0x0121401f }, /* HP */
11910                         { }
11911                 },
11912                 .chained = true,
11913                 .chain_id = ALC662_FIXUP_SKU_IGNORE
11914         },
11915         [ALC662_FIXUP_ASUS_MODE8] = {
11916                 .type = HDA_FIXUP_PINS,
11917                 .v.pins = (const struct hda_pintbl[]) {
11918                         { 0x14, 0x99130110 }, /* speaker */
11919                         { 0x12, 0x99a30970 }, /* int-mic */
11920                         { 0x15, 0x01214020 }, /* HP */
11921                         { 0x17, 0x99130111 }, /* speaker */
11922                         { 0x18, 0x01a19840 }, /* mic */
11923                         { 0x21, 0x0121401f }, /* HP */
11924                         { }
11925                 },
11926                 .chained = true,
11927                 .chain_id = ALC662_FIXUP_SKU_IGNORE
11928         },
11929         [ALC662_FIXUP_NO_JACK_DETECT] = {
11930                 .type = HDA_FIXUP_FUNC,
11931                 .v.func = alc_fixup_no_jack_detect,
11932         },
11933         [ALC662_FIXUP_ZOTAC_Z68] = {
11934                 .type = HDA_FIXUP_PINS,
11935                 .v.pins = (const struct hda_pintbl[]) {
11936                         { 0x1b, 0x02214020 }, /* Front HP */
11937                         { }
11938                 }
11939         },
11940         [ALC662_FIXUP_INV_DMIC] = {
11941                 .type = HDA_FIXUP_FUNC,
11942                 .v.func = alc_fixup_inv_dmic,
11943         },
11944         [ALC668_FIXUP_DELL_XPS13] = {
11945                 .type = HDA_FIXUP_FUNC,
11946                 .v.func = alc_fixup_dell_xps13,
11947                 .chained = true,
11948                 .chain_id = ALC668_FIXUP_DELL_DISABLE_AAMIX
11949         },
11950         [ALC668_FIXUP_DELL_DISABLE_AAMIX] = {
11951                 .type = HDA_FIXUP_FUNC,
11952                 .v.func = alc_fixup_disable_aamix,
11953                 .chained = true,
11954                 .chain_id = ALC668_FIXUP_DELL_MIC_NO_PRESENCE
11955         },
11956         [ALC668_FIXUP_AUTO_MUTE] = {
11957                 .type = HDA_FIXUP_FUNC,
11958                 .v.func = alc_fixup_auto_mute_via_amp,
11959                 .chained = true,
11960                 .chain_id = ALC668_FIXUP_DELL_MIC_NO_PRESENCE
11961         },
11962         [ALC662_FIXUP_DELL_MIC_NO_PRESENCE] = {
11963                 .type = HDA_FIXUP_PINS,
11964                 .v.pins = (const struct hda_pintbl[]) {
11965                         { 0x19, 0x03a1113c }, /* use as headset mic, without its own jack detect */
11966                         /* headphone mic by setting pin control of 0x1b (headphone out) to in + vref_50 */
11967                         { }
11968                 },
11969                 .chained = true,
11970                 .chain_id = ALC662_FIXUP_HEADSET_MODE
11971         },
11972         [ALC662_FIXUP_HEADSET_MODE] = {
11973                 .type = HDA_FIXUP_FUNC,
11974                 .v.func = alc_fixup_headset_mode_alc662,
11975         },
11976         [ALC668_FIXUP_DELL_MIC_NO_PRESENCE] = {
11977                 .type = HDA_FIXUP_PINS,
11978                 .v.pins = (const struct hda_pintbl[]) {
11979                         { 0x19, 0x03a1913d }, /* use as headphone mic, without its own jack detect */
11980                         { 0x1b, 0x03a1113c }, /* use as headset mic, without its own jack detect */
11981                         { }
11982                 },
11983                 .chained = true,
11984                 .chain_id = ALC668_FIXUP_HEADSET_MODE
11985         },
11986         [ALC668_FIXUP_HEADSET_MODE] = {
11987                 .type = HDA_FIXUP_FUNC,
11988                 .v.func = alc_fixup_headset_mode_alc668,
11989         },
11990         [ALC662_FIXUP_BASS_MODE4_CHMAP] = {
11991                 .type = HDA_FIXUP_FUNC,
11992                 .v.func = alc_fixup_bass_chmap,
11993                 .chained = true,
11994                 .chain_id = ALC662_FIXUP_ASUS_MODE4
11995         },
11996         [ALC662_FIXUP_BASS_16] = {
11997                 .type = HDA_FIXUP_PINS,
11998                 .v.pins = (const struct hda_pintbl[]) {
11999                         {0x16, 0x80106111}, /* bass speaker */
12000                         {}
12001                 },
12002                 .chained = true,
12003                 .chain_id = ALC662_FIXUP_BASS_CHMAP,
12004         },
12005         [ALC662_FIXUP_BASS_1A] = {
12006                 .type = HDA_FIXUP_PINS,
12007                 .v.pins = (const struct hda_pintbl[]) {
12008                         {0x1a, 0x80106111}, /* bass speaker */
12009                         {}
12010                 },
12011                 .chained = true,
12012                 .chain_id = ALC662_FIXUP_BASS_CHMAP,
12013         },
12014         [ALC662_FIXUP_BASS_CHMAP] = {
12015                 .type = HDA_FIXUP_FUNC,
12016                 .v.func = alc_fixup_bass_chmap,
12017         },
12018         [ALC662_FIXUP_ASUS_Nx50] = {
12019                 .type = HDA_FIXUP_FUNC,
12020                 .v.func = alc_fixup_auto_mute_via_amp,
12021                 .chained = true,
12022                 .chain_id = ALC662_FIXUP_BASS_1A
12023         },
12024         [ALC668_FIXUP_ASUS_Nx51_HEADSET_MODE] = {
12025                 .type = HDA_FIXUP_FUNC,
12026                 .v.func = alc_fixup_headset_mode_alc668,
12027                 .chain_id = ALC662_FIXUP_BASS_CHMAP
12028         },
12029         [ALC668_FIXUP_ASUS_Nx51] = {
12030                 .type = HDA_FIXUP_PINS,
12031                 .v.pins = (const struct hda_pintbl[]) {
12032                         { 0x19, 0x03a1913d }, /* use as headphone mic, without its own jack detect */
12033                         { 0x1a, 0x90170151 }, /* bass speaker */
12034                         { 0x1b, 0x03a1113c }, /* use as headset mic, without its own jack detect */
12035                         {}
12036                 },
12037                 .chained = true,
12038                 .chain_id = ALC668_FIXUP_ASUS_Nx51_HEADSET_MODE,
12039         },
12040         [ALC668_FIXUP_MIC_COEF] = {
12041                 .type = HDA_FIXUP_VERBS,
12042                 .v.verbs = (const struct hda_verb[]) {
12043                         { 0x20, AC_VERB_SET_COEF_INDEX, 0xc3 },
12044                         { 0x20, AC_VERB_SET_PROC_COEF, 0x4000 },
12045                         {}
12046                 },
12047         },
12048         [ALC668_FIXUP_ASUS_G751] = {
12049                 .type = HDA_FIXUP_PINS,
12050                 .v.pins = (const struct hda_pintbl[]) {
12051                         { 0x16, 0x0421101f }, /* HP */
12052                         {}
12053                 },
12054                 .chained = true,
12055                 .chain_id = ALC668_FIXUP_MIC_COEF
12056         },
12057         [ALC891_FIXUP_HEADSET_MODE] = {
12058                 .type = HDA_FIXUP_FUNC,
12059                 .v.func = alc_fixup_headset_mode,
12060         },
12061         [ALC891_FIXUP_DELL_MIC_NO_PRESENCE] = {
12062                 .type = HDA_FIXUP_PINS,
12063                 .v.pins = (const struct hda_pintbl[]) {
12064                         { 0x19, 0x03a1913d }, /* use as headphone mic, without its own jack detect */
12065                         { 0x1b, 0x03a1113c }, /* use as headset mic, without its own jack detect */
12066                         { }
12067                 },
12068                 .chained = true,
12069                 .chain_id = ALC891_FIXUP_HEADSET_MODE
12070         },
12071         [ALC662_FIXUP_ACER_VERITON] = {
12072                 .type = HDA_FIXUP_PINS,
12073                 .v.pins = (const struct hda_pintbl[]) {
12074                         { 0x15, 0x50170120 }, /* no internal speaker */
12075                         { }
12076                 }
12077         },
12078         [ALC892_FIXUP_ASROCK_MOBO] = {
12079                 .type = HDA_FIXUP_PINS,
12080                 .v.pins = (const struct hda_pintbl[]) {
12081                         { 0x15, 0x40f000f0 }, /* disabled */
12082                         { 0x16, 0x40f000f0 }, /* disabled */
12083                         { }
12084                 }
12085         },
12086         [ALC662_FIXUP_USI_FUNC] = {
12087                 .type = HDA_FIXUP_FUNC,
12088                 .v.func = alc662_fixup_usi_headset_mic,
12089         },
12090         [ALC662_FIXUP_USI_HEADSET_MODE] = {
12091                 .type = HDA_FIXUP_PINS,
12092                 .v.pins = (const struct hda_pintbl[]) {
12093                         { 0x19, 0x02a1913c }, /* use as headset mic, without its own jack detect */
12094                         { 0x18, 0x01a1903d },
12095                         { }
12096                 },
12097                 .chained = true,
12098                 .chain_id = ALC662_FIXUP_USI_FUNC
12099         },
12100         [ALC662_FIXUP_LENOVO_MULTI_CODECS] = {
12101                 .type = HDA_FIXUP_FUNC,
12102                 .v.func = alc233_alc662_fixup_lenovo_dual_codecs,
12103         },
12104         [ALC669_FIXUP_ACER_ASPIRE_ETHOS_HEADSET] = {
12105                 .type = HDA_FIXUP_FUNC,
12106                 .v.func = alc662_fixup_aspire_ethos_hp,
12107         },
12108         [ALC669_FIXUP_ACER_ASPIRE_ETHOS] = {
12109                 .type = HDA_FIXUP_PINS,
12110                 .v.pins = (const struct hda_pintbl[]) {
12111                         { 0x15, 0x92130110 }, /* front speakers */
12112                         { 0x18, 0x99130111 }, /* center/subwoofer */
12113                         { 0x1b, 0x11130012 }, /* surround plus jack for HP */
12114                         { }
12115                 },
12116                 .chained = true,
12117                 .chain_id = ALC669_FIXUP_ACER_ASPIRE_ETHOS_HEADSET
12118         },
12119         [ALC671_FIXUP_HP_HEADSET_MIC2] = {
12120                 .type = HDA_FIXUP_FUNC,
12121                 .v.func = alc671_fixup_hp_headset_mic2,
12122         },
12123         [ALC662_FIXUP_ACER_X2660G_HEADSET_MODE] = {
12124                 .type = HDA_FIXUP_PINS,
12125                 .v.pins = (const struct hda_pintbl[]) {
12126                         { 0x1a, 0x02a1113c }, /* use as headset mic, without its own jack detect */
12127                         { }
12128                 },
12129                 .chained = true,
12130                 .chain_id = ALC662_FIXUP_USI_FUNC
12131         },
12132         [ALC662_FIXUP_ACER_NITRO_HEADSET_MODE] = {
12133                 .type = HDA_FIXUP_PINS,
12134                 .v.pins = (const struct hda_pintbl[]) {
12135                         { 0x1a, 0x01a11140 }, /* use as headset mic, without its own jack detect */
12136                         { 0x1b, 0x0221144f },
12137                         { }
12138                 },
12139                 .chained = true,
12140                 .chain_id = ALC662_FIXUP_USI_FUNC
12141         },
12142         [ALC668_FIXUP_ASUS_NO_HEADSET_MIC] = {
12143                 .type = HDA_FIXUP_PINS,
12144                 .v.pins = (const struct hda_pintbl[]) {
12145                         { 0x1b, 0x04a1112c },
12146                         { }
12147                 },
12148                 .chained = true,
12149                 .chain_id = ALC668_FIXUP_HEADSET_MIC
12150         },
12151         [ALC668_FIXUP_HEADSET_MIC] = {
12152                 .type = HDA_FIXUP_FUNC,
12153                 .v.func = alc269_fixup_headset_mic,
12154                 .chained = true,
12155                 .chain_id = ALC668_FIXUP_MIC_DET_COEF
12156         },
12157         [ALC668_FIXUP_MIC_DET_COEF] = {
12158                 .type = HDA_FIXUP_VERBS,
12159                 .v.verbs = (const struct hda_verb[]) {
12160                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x15 },
12161                         { 0x20, AC_VERB_SET_PROC_COEF, 0x0d60 },
12162                         {}
12163                 },
12164         },
12165         [ALC897_FIXUP_LENOVO_HEADSET_MIC] = {
12166                 .type = HDA_FIXUP_FUNC,
12167                 .v.func = alc897_fixup_lenovo_headset_mic,
12168         },
12169         [ALC897_FIXUP_HEADSET_MIC_PIN] = {
12170                 .type = HDA_FIXUP_PINS,
12171                 .v.pins = (const struct hda_pintbl[]) {
12172                         { 0x1a, 0x03a11050 },
12173                         { }
12174                 },
12175                 .chained = true,
12176                 .chain_id = ALC897_FIXUP_LENOVO_HEADSET_MIC
12177         },
12178         [ALC897_FIXUP_HP_HSMIC_VERB] = {
12179                 .type = HDA_FIXUP_PINS,
12180                 .v.pins = (const struct hda_pintbl[]) {
12181                         { 0x19, 0x01a1913c }, /* use as headset mic, without its own jack detect */
12182                         { }
12183                 },
12184         },
12185         [ALC897_FIXUP_LENOVO_HEADSET_MODE] = {
12186                 .type = HDA_FIXUP_FUNC,
12187                 .v.func = alc897_fixup_lenovo_headset_mode,
12188         },
12189         [ALC897_FIXUP_HEADSET_MIC_PIN2] = {
12190                 .type = HDA_FIXUP_PINS,
12191                 .v.pins = (const struct hda_pintbl[]) {
12192                         { 0x1a, 0x01a11140 }, /* use as headset mic, without its own jack detect */
12193                         { }
12194                 },
12195                 .chained = true,
12196                 .chain_id = ALC897_FIXUP_LENOVO_HEADSET_MODE
12197         },
12198         [ALC897_FIXUP_UNIS_H3C_X500S] = {
12199                 .type = HDA_FIXUP_VERBS,
12200                 .v.verbs = (const struct hda_verb[]) {
12201                         { 0x14, AC_VERB_SET_EAPD_BTLENABLE, 0 },
12202                         {}
12203                 },
12204         },
12205 };
12206
12207 static const struct snd_pci_quirk alc662_fixup_tbl[] = {
12208         SND_PCI_QUIRK(0x1019, 0x9087, "ECS", ALC662_FIXUP_ASUS_MODE2),
12209         SND_PCI_QUIRK(0x1025, 0x022f, "Acer Aspire One", ALC662_FIXUP_INV_DMIC),
12210         SND_PCI_QUIRK(0x1025, 0x0241, "Packard Bell DOTS", ALC662_FIXUP_INV_DMIC),
12211         SND_PCI_QUIRK(0x1025, 0x0308, "Acer Aspire 8942G", ALC662_FIXUP_ASPIRE),
12212         SND_PCI_QUIRK(0x1025, 0x031c, "Gateway NV79", ALC662_FIXUP_SKU_IGNORE),
12213         SND_PCI_QUIRK(0x1025, 0x0349, "eMachines eM250", ALC662_FIXUP_INV_DMIC),
12214         SND_PCI_QUIRK(0x1025, 0x034a, "Gateway LT27", ALC662_FIXUP_INV_DMIC),
12215         SND_PCI_QUIRK(0x1025, 0x038b, "Acer Aspire 8943G", ALC662_FIXUP_ASPIRE),
12216         SND_PCI_QUIRK(0x1025, 0x0566, "Acer Aspire Ethos 8951G", ALC669_FIXUP_ACER_ASPIRE_ETHOS),
12217         SND_PCI_QUIRK(0x1025, 0x123c, "Acer Nitro N50-600", ALC662_FIXUP_ACER_NITRO_HEADSET_MODE),
12218         SND_PCI_QUIRK(0x1025, 0x124e, "Acer 2660G", ALC662_FIXUP_ACER_X2660G_HEADSET_MODE),
12219         SND_PCI_QUIRK(0x1028, 0x05d8, "Dell", ALC668_FIXUP_DELL_MIC_NO_PRESENCE),
12220         SND_PCI_QUIRK(0x1028, 0x05db, "Dell", ALC668_FIXUP_DELL_MIC_NO_PRESENCE),
12221         SND_PCI_QUIRK(0x1028, 0x05fe, "Dell XPS 15", ALC668_FIXUP_DELL_XPS13),
12222         SND_PCI_QUIRK(0x1028, 0x060a, "Dell XPS 13", ALC668_FIXUP_DELL_XPS13),
12223         SND_PCI_QUIRK(0x1028, 0x060d, "Dell M3800", ALC668_FIXUP_DELL_XPS13),
12224         SND_PCI_QUIRK(0x1028, 0x0625, "Dell", ALC668_FIXUP_DELL_MIC_NO_PRESENCE),
12225         SND_PCI_QUIRK(0x1028, 0x0626, "Dell", ALC668_FIXUP_DELL_MIC_NO_PRESENCE),
12226         SND_PCI_QUIRK(0x1028, 0x0696, "Dell", ALC668_FIXUP_DELL_MIC_NO_PRESENCE),
12227         SND_PCI_QUIRK(0x1028, 0x0698, "Dell", ALC668_FIXUP_DELL_MIC_NO_PRESENCE),
12228         SND_PCI_QUIRK(0x1028, 0x069f, "Dell", ALC668_FIXUP_DELL_MIC_NO_PRESENCE),
12229         SND_PCI_QUIRK(0x103c, 0x1632, "HP RP5800", ALC662_FIXUP_HP_RP5800),
12230         SND_PCI_QUIRK(0x103c, 0x870c, "HP", ALC897_FIXUP_HP_HSMIC_VERB),
12231         SND_PCI_QUIRK(0x103c, 0x8719, "HP", ALC897_FIXUP_HP_HSMIC_VERB),
12232         SND_PCI_QUIRK(0x103c, 0x872b, "HP", ALC897_FIXUP_HP_HSMIC_VERB),
12233         SND_PCI_QUIRK(0x103c, 0x873e, "HP", ALC671_FIXUP_HP_HEADSET_MIC2),
12234         SND_PCI_QUIRK(0x103c, 0x8768, "HP Slim Desktop S01", ALC671_FIXUP_HP_HEADSET_MIC2),
12235         SND_PCI_QUIRK(0x103c, 0x877e, "HP 288 Pro G6", ALC671_FIXUP_HP_HEADSET_MIC2),
12236         SND_PCI_QUIRK(0x103c, 0x885f, "HP 288 Pro G8", ALC671_FIXUP_HP_HEADSET_MIC2),
12237         SND_PCI_QUIRK(0x1043, 0x1080, "Asus UX501VW", ALC668_FIXUP_HEADSET_MODE),
12238         SND_PCI_QUIRK(0x1043, 0x11cd, "Asus N550", ALC662_FIXUP_ASUS_Nx50),
12239         SND_PCI_QUIRK(0x1043, 0x129d, "Asus N750", ALC662_FIXUP_ASUS_Nx50),
12240         SND_PCI_QUIRK(0x1043, 0x12ff, "ASUS G751", ALC668_FIXUP_ASUS_G751),
12241         SND_PCI_QUIRK(0x1043, 0x13df, "Asus N550JX", ALC662_FIXUP_BASS_1A),
12242         SND_PCI_QUIRK(0x1043, 0x1477, "ASUS N56VZ", ALC662_FIXUP_BASS_MODE4_CHMAP),
12243         SND_PCI_QUIRK(0x1043, 0x15a7, "ASUS UX51VZH", ALC662_FIXUP_BASS_16),
12244         SND_PCI_QUIRK(0x1043, 0x177d, "ASUS N551", ALC668_FIXUP_ASUS_Nx51),
12245         SND_PCI_QUIRK(0x1043, 0x17bd, "ASUS N751", ALC668_FIXUP_ASUS_Nx51),
12246         SND_PCI_QUIRK(0x1043, 0x185d, "ASUS G551JW", ALC668_FIXUP_ASUS_NO_HEADSET_MIC),
12247         SND_PCI_QUIRK(0x1043, 0x1963, "ASUS X71SL", ALC662_FIXUP_ASUS_MODE8),
12248         SND_PCI_QUIRK(0x1043, 0x1b73, "ASUS N55SF", ALC662_FIXUP_BASS_16),
12249         SND_PCI_QUIRK(0x1043, 0x1bf3, "ASUS N76VZ", ALC662_FIXUP_BASS_MODE4_CHMAP),
12250         SND_PCI_QUIRK(0x1043, 0x8469, "ASUS mobo", ALC662_FIXUP_NO_JACK_DETECT),
12251         SND_PCI_QUIRK(0x105b, 0x0cd6, "Foxconn", ALC662_FIXUP_ASUS_MODE2),
12252         SND_PCI_QUIRK(0x144d, 0xc051, "Samsung R720", ALC662_FIXUP_IDEAPAD),
12253         SND_PCI_QUIRK(0x14cd, 0x5003, "USI", ALC662_FIXUP_USI_HEADSET_MODE),
12254         SND_PCI_QUIRK(0x17aa, 0x1036, "Lenovo P520", ALC662_FIXUP_LENOVO_MULTI_CODECS),
12255         SND_PCI_QUIRK(0x17aa, 0x1057, "Lenovo P360", ALC897_FIXUP_HEADSET_MIC_PIN),
12256         SND_PCI_QUIRK(0x17aa, 0x1064, "Lenovo P3 Tower", ALC897_FIXUP_HEADSET_MIC_PIN),
12257         SND_PCI_QUIRK(0x17aa, 0x32ca, "Lenovo ThinkCentre M80", ALC897_FIXUP_HEADSET_MIC_PIN),
12258         SND_PCI_QUIRK(0x17aa, 0x32cb, "Lenovo ThinkCentre M70", ALC897_FIXUP_HEADSET_MIC_PIN),
12259         SND_PCI_QUIRK(0x17aa, 0x32cf, "Lenovo ThinkCentre M950", ALC897_FIXUP_HEADSET_MIC_PIN),
12260         SND_PCI_QUIRK(0x17aa, 0x32f7, "Lenovo ThinkCentre M90", ALC897_FIXUP_HEADSET_MIC_PIN),
12261         SND_PCI_QUIRK(0x17aa, 0x3321, "Lenovo ThinkCentre M70 Gen4", ALC897_FIXUP_HEADSET_MIC_PIN),
12262         SND_PCI_QUIRK(0x17aa, 0x331b, "Lenovo ThinkCentre M90 Gen4", ALC897_FIXUP_HEADSET_MIC_PIN),
12263         SND_PCI_QUIRK(0x17aa, 0x3364, "Lenovo ThinkCentre M90 Gen5", ALC897_FIXUP_HEADSET_MIC_PIN),
12264         SND_PCI_QUIRK(0x17aa, 0x3742, "Lenovo TianYi510Pro-14IOB", ALC897_FIXUP_HEADSET_MIC_PIN2),
12265         SND_PCI_QUIRK(0x17aa, 0x38af, "Lenovo Ideapad Y550P", ALC662_FIXUP_IDEAPAD),
12266         SND_PCI_QUIRK(0x17aa, 0x3a0d, "Lenovo Ideapad Y550", ALC662_FIXUP_IDEAPAD),
12267         SND_PCI_QUIRK(0x1849, 0x5892, "ASRock B150M", ALC892_FIXUP_ASROCK_MOBO),
12268         SND_PCI_QUIRK(0x19da, 0xa130, "Zotac Z68", ALC662_FIXUP_ZOTAC_Z68),
12269         SND_PCI_QUIRK(0x1b0a, 0x01b8, "ACER Veriton", ALC662_FIXUP_ACER_VERITON),
12270         SND_PCI_QUIRK(0x1b35, 0x1234, "CZC ET26", ALC662_FIXUP_CZC_ET26),
12271         SND_PCI_QUIRK(0x1b35, 0x2206, "CZC P10T", ALC662_FIXUP_CZC_P10T),
12272         SND_PCI_QUIRK(0x1c6c, 0x1239, "Compaq N14JP6-V2", ALC897_FIXUP_HP_HSMIC_VERB),
12273
12274 #if 0
12275         /* Below is a quirk table taken from the old code.
12276          * Basically the device should work as is without the fixup table.
12277          * If BIOS doesn't give a proper info, enable the corresponding
12278          * fixup entry.
12279          */
12280         SND_PCI_QUIRK(0x1043, 0x1000, "ASUS N50Vm", ALC662_FIXUP_ASUS_MODE1),
12281         SND_PCI_QUIRK(0x1043, 0x1092, "ASUS NB", ALC662_FIXUP_ASUS_MODE3),
12282         SND_PCI_QUIRK(0x1043, 0x1173, "ASUS K73Jn", ALC662_FIXUP_ASUS_MODE1),
12283         SND_PCI_QUIRK(0x1043, 0x11c3, "ASUS M70V", ALC662_FIXUP_ASUS_MODE3),
12284         SND_PCI_QUIRK(0x1043, 0x11d3, "ASUS NB", ALC662_FIXUP_ASUS_MODE1),
12285         SND_PCI_QUIRK(0x1043, 0x11f3, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),
12286         SND_PCI_QUIRK(0x1043, 0x1203, "ASUS NB", ALC662_FIXUP_ASUS_MODE1),
12287         SND_PCI_QUIRK(0x1043, 0x1303, "ASUS G60J", ALC662_FIXUP_ASUS_MODE1),
12288         SND_PCI_QUIRK(0x1043, 0x1333, "ASUS G60Jx", ALC662_FIXUP_ASUS_MODE1),
12289         SND_PCI_QUIRK(0x1043, 0x1339, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),
12290         SND_PCI_QUIRK(0x1043, 0x13e3, "ASUS N71JA", ALC662_FIXUP_ASUS_MODE7),
12291         SND_PCI_QUIRK(0x1043, 0x1463, "ASUS N71", ALC662_FIXUP_ASUS_MODE7),
12292         SND_PCI_QUIRK(0x1043, 0x14d3, "ASUS G72", ALC662_FIXUP_ASUS_MODE8),
12293         SND_PCI_QUIRK(0x1043, 0x1563, "ASUS N90", ALC662_FIXUP_ASUS_MODE3),
12294         SND_PCI_QUIRK(0x1043, 0x15d3, "ASUS N50SF F50SF", ALC662_FIXUP_ASUS_MODE1),
12295         SND_PCI_QUIRK(0x1043, 0x16c3, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),
12296         SND_PCI_QUIRK(0x1043, 0x16f3, "ASUS K40C K50C", ALC662_FIXUP_ASUS_MODE2),
12297         SND_PCI_QUIRK(0x1043, 0x1733, "ASUS N81De", ALC662_FIXUP_ASUS_MODE1),
12298         SND_PCI_QUIRK(0x1043, 0x1753, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),
12299         SND_PCI_QUIRK(0x1043, 0x1763, "ASUS NB", ALC662_FIXUP_ASUS_MODE6),
12300         SND_PCI_QUIRK(0x1043, 0x1765, "ASUS NB", ALC662_FIXUP_ASUS_MODE6),
12301         SND_PCI_QUIRK(0x1043, 0x1783, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),
12302         SND_PCI_QUIRK(0x1043, 0x1793, "ASUS F50GX", ALC662_FIXUP_ASUS_MODE1),
12303         SND_PCI_QUIRK(0x1043, 0x17b3, "ASUS F70SL", ALC662_FIXUP_ASUS_MODE3),
12304         SND_PCI_QUIRK(0x1043, 0x17f3, "ASUS X58LE", ALC662_FIXUP_ASUS_MODE2),
12305         SND_PCI_QUIRK(0x1043, 0x1813, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),
12306         SND_PCI_QUIRK(0x1043, 0x1823, "ASUS NB", ALC662_FIXUP_ASUS_MODE5),
12307         SND_PCI_QUIRK(0x1043, 0x1833, "ASUS NB", ALC662_FIXUP_ASUS_MODE6),
12308         SND_PCI_QUIRK(0x1043, 0x1843, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),
12309         SND_PCI_QUIRK(0x1043, 0x1853, "ASUS F50Z", ALC662_FIXUP_ASUS_MODE1),
12310         SND_PCI_QUIRK(0x1043, 0x1864, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),
12311         SND_PCI_QUIRK(0x1043, 0x1876, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),
12312         SND_PCI_QUIRK(0x1043, 0x1893, "ASUS M50Vm", ALC662_FIXUP_ASUS_MODE3),
12313         SND_PCI_QUIRK(0x1043, 0x1894, "ASUS X55", ALC662_FIXUP_ASUS_MODE3),
12314         SND_PCI_QUIRK(0x1043, 0x18b3, "ASUS N80Vc", ALC662_FIXUP_ASUS_MODE1),
12315         SND_PCI_QUIRK(0x1043, 0x18c3, "ASUS VX5", ALC662_FIXUP_ASUS_MODE1),
12316         SND_PCI_QUIRK(0x1043, 0x18d3, "ASUS N81Te", ALC662_FIXUP_ASUS_MODE1),
12317         SND_PCI_QUIRK(0x1043, 0x18f3, "ASUS N505Tp", ALC662_FIXUP_ASUS_MODE1),
12318         SND_PCI_QUIRK(0x1043, 0x1903, "ASUS F5GL", ALC662_FIXUP_ASUS_MODE1),
12319         SND_PCI_QUIRK(0x1043, 0x1913, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),
12320         SND_PCI_QUIRK(0x1043, 0x1933, "ASUS F80Q", ALC662_FIXUP_ASUS_MODE2),
12321         SND_PCI_QUIRK(0x1043, 0x1943, "ASUS Vx3V", ALC662_FIXUP_ASUS_MODE1),
12322         SND_PCI_QUIRK(0x1043, 0x1953, "ASUS NB", ALC662_FIXUP_ASUS_MODE1),
12323         SND_PCI_QUIRK(0x1043, 0x1963, "ASUS X71C", ALC662_FIXUP_ASUS_MODE3),
12324         SND_PCI_QUIRK(0x1043, 0x1983, "ASUS N5051A", ALC662_FIXUP_ASUS_MODE1),
12325         SND_PCI_QUIRK(0x1043, 0x1993, "ASUS N20", ALC662_FIXUP_ASUS_MODE1),
12326         SND_PCI_QUIRK(0x1043, 0x19b3, "ASUS F7Z", ALC662_FIXUP_ASUS_MODE1),
12327         SND_PCI_QUIRK(0x1043, 0x19c3, "ASUS F5Z/F6x", ALC662_FIXUP_ASUS_MODE2),
12328         SND_PCI_QUIRK(0x1043, 0x19e3, "ASUS NB", ALC662_FIXUP_ASUS_MODE1),
12329         SND_PCI_QUIRK(0x1043, 0x19f3, "ASUS NB", ALC662_FIXUP_ASUS_MODE4),
12330 #endif
12331         {}
12332 };
12333
12334 static const struct hda_model_fixup alc662_fixup_models[] = {
12335         {.id = ALC662_FIXUP_ASPIRE, .name = "aspire"},
12336         {.id = ALC662_FIXUP_IDEAPAD, .name = "ideapad"},
12337         {.id = ALC272_FIXUP_MARIO, .name = "mario"},
12338         {.id = ALC662_FIXUP_HP_RP5800, .name = "hp-rp5800"},
12339         {.id = ALC662_FIXUP_ASUS_MODE1, .name = "asus-mode1"},
12340         {.id = ALC662_FIXUP_ASUS_MODE2, .name = "asus-mode2"},
12341         {.id = ALC662_FIXUP_ASUS_MODE3, .name = "asus-mode3"},
12342         {.id = ALC662_FIXUP_ASUS_MODE4, .name = "asus-mode4"},
12343         {.id = ALC662_FIXUP_ASUS_MODE5, .name = "asus-mode5"},
12344         {.id = ALC662_FIXUP_ASUS_MODE6, .name = "asus-mode6"},
12345         {.id = ALC662_FIXUP_ASUS_MODE7, .name = "asus-mode7"},
12346         {.id = ALC662_FIXUP_ASUS_MODE8, .name = "asus-mode8"},
12347         {.id = ALC662_FIXUP_ZOTAC_Z68, .name = "zotac-z68"},
12348         {.id = ALC662_FIXUP_INV_DMIC, .name = "inv-dmic"},
12349         {.id = ALC662_FIXUP_DELL_MIC_NO_PRESENCE, .name = "alc662-headset-multi"},
12350         {.id = ALC668_FIXUP_DELL_MIC_NO_PRESENCE, .name = "dell-headset-multi"},
12351         {.id = ALC662_FIXUP_HEADSET_MODE, .name = "alc662-headset"},
12352         {.id = ALC668_FIXUP_HEADSET_MODE, .name = "alc668-headset"},
12353         {.id = ALC662_FIXUP_BASS_16, .name = "bass16"},
12354         {.id = ALC662_FIXUP_BASS_1A, .name = "bass1a"},
12355         {.id = ALC668_FIXUP_AUTO_MUTE, .name = "automute"},
12356         {.id = ALC668_FIXUP_DELL_XPS13, .name = "dell-xps13"},
12357         {.id = ALC662_FIXUP_ASUS_Nx50, .name = "asus-nx50"},
12358         {.id = ALC668_FIXUP_ASUS_Nx51, .name = "asus-nx51"},
12359         {.id = ALC668_FIXUP_ASUS_G751, .name = "asus-g751"},
12360         {.id = ALC891_FIXUP_HEADSET_MODE, .name = "alc891-headset"},
12361         {.id = ALC891_FIXUP_DELL_MIC_NO_PRESENCE, .name = "alc891-headset-multi"},
12362         {.id = ALC662_FIXUP_ACER_VERITON, .name = "acer-veriton"},
12363         {.id = ALC892_FIXUP_ASROCK_MOBO, .name = "asrock-mobo"},
12364         {.id = ALC662_FIXUP_USI_HEADSET_MODE, .name = "usi-headset"},
12365         {.id = ALC662_FIXUP_LENOVO_MULTI_CODECS, .name = "dual-codecs"},
12366         {.id = ALC669_FIXUP_ACER_ASPIRE_ETHOS, .name = "aspire-ethos"},
12367         {.id = ALC897_FIXUP_UNIS_H3C_X500S, .name = "unis-h3c-x500s"},
12368         {}
12369 };
12370
12371 static const struct snd_hda_pin_quirk alc662_pin_fixup_tbl[] = {
12372         SND_HDA_PIN_QUIRK(0x10ec0867, 0x1028, "Dell", ALC891_FIXUP_DELL_MIC_NO_PRESENCE,
12373                 {0x17, 0x02211010},
12374                 {0x18, 0x01a19030},
12375                 {0x1a, 0x01813040},
12376                 {0x21, 0x01014020}),
12377         SND_HDA_PIN_QUIRK(0x10ec0867, 0x1028, "Dell", ALC891_FIXUP_DELL_MIC_NO_PRESENCE,
12378                 {0x16, 0x01813030},
12379                 {0x17, 0x02211010},
12380                 {0x18, 0x01a19040},
12381                 {0x21, 0x01014020}),
12382         SND_HDA_PIN_QUIRK(0x10ec0662, 0x1028, "Dell", ALC662_FIXUP_DELL_MIC_NO_PRESENCE,
12383                 {0x14, 0x01014010},
12384                 {0x18, 0x01a19020},
12385                 {0x1a, 0x0181302f},
12386                 {0x1b, 0x0221401f}),
12387         SND_HDA_PIN_QUIRK(0x10ec0668, 0x1028, "Dell", ALC668_FIXUP_AUTO_MUTE,
12388                 {0x12, 0x99a30130},
12389                 {0x14, 0x90170110},
12390                 {0x15, 0x0321101f},
12391                 {0x16, 0x03011020}),
12392         SND_HDA_PIN_QUIRK(0x10ec0668, 0x1028, "Dell", ALC668_FIXUP_AUTO_MUTE,
12393                 {0x12, 0x99a30140},
12394                 {0x14, 0x90170110},
12395                 {0x15, 0x0321101f},
12396                 {0x16, 0x03011020}),
12397         SND_HDA_PIN_QUIRK(0x10ec0668, 0x1028, "Dell", ALC668_FIXUP_AUTO_MUTE,
12398                 {0x12, 0x99a30150},
12399                 {0x14, 0x90170110},
12400                 {0x15, 0x0321101f},
12401                 {0x16, 0x03011020}),
12402         SND_HDA_PIN_QUIRK(0x10ec0668, 0x1028, "Dell", ALC668_FIXUP_AUTO_MUTE,
12403                 {0x14, 0x90170110},
12404                 {0x15, 0x0321101f},
12405                 {0x16, 0x03011020}),
12406         SND_HDA_PIN_QUIRK(0x10ec0668, 0x1028, "Dell XPS 15", ALC668_FIXUP_AUTO_MUTE,
12407                 {0x12, 0x90a60130},
12408                 {0x14, 0x90170110},
12409                 {0x15, 0x0321101f}),
12410         SND_HDA_PIN_QUIRK(0x10ec0671, 0x103c, "HP cPC", ALC671_FIXUP_HP_HEADSET_MIC2,
12411                 {0x14, 0x01014010},
12412                 {0x17, 0x90170150},
12413                 {0x19, 0x02a11060},
12414                 {0x1b, 0x01813030},
12415                 {0x21, 0x02211020}),
12416         SND_HDA_PIN_QUIRK(0x10ec0671, 0x103c, "HP cPC", ALC671_FIXUP_HP_HEADSET_MIC2,
12417                 {0x14, 0x01014010},
12418                 {0x18, 0x01a19040},
12419                 {0x1b, 0x01813030},
12420                 {0x21, 0x02211020}),
12421         SND_HDA_PIN_QUIRK(0x10ec0671, 0x103c, "HP cPC", ALC671_FIXUP_HP_HEADSET_MIC2,
12422                 {0x14, 0x01014020},
12423                 {0x17, 0x90170110},
12424                 {0x18, 0x01a19050},
12425                 {0x1b, 0x01813040},
12426                 {0x21, 0x02211030}),
12427         {}
12428 };
12429
12430 /*
12431  */
12432 static int patch_alc662(struct hda_codec *codec)
12433 {
12434         struct alc_spec *spec;
12435         int err;
12436
12437         err = alc_alloc_spec(codec, 0x0b);
12438         if (err < 0)
12439                 return err;
12440
12441         spec = codec->spec;
12442
12443         spec->shutup = alc_eapd_shutup;
12444
12445         /* handle multiple HPs as is */
12446         spec->parse_flags = HDA_PINCFG_NO_HP_FIXUP;
12447
12448         alc_fix_pll_init(codec, 0x20, 0x04, 15);
12449
12450         switch (codec->core.vendor_id) {
12451         case 0x10ec0668:
12452                 spec->init_hook = alc668_restore_default_value;
12453                 break;
12454         }
12455
12456         alc_pre_init(codec);
12457
12458         snd_hda_pick_fixup(codec, alc662_fixup_models,
12459                        alc662_fixup_tbl, alc662_fixups);
12460         snd_hda_pick_pin_fixup(codec, alc662_pin_fixup_tbl, alc662_fixups, true);
12461         snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE);
12462
12463         alc_auto_parse_customize_define(codec);
12464
12465         if (has_cdefine_beep(codec))
12466                 spec->gen.beep_nid = 0x01;
12467
12468         if ((alc_get_coef0(codec) & (1 << 14)) &&
12469             codec->bus->pci && codec->bus->pci->subsystem_vendor == 0x1025 &&
12470             spec->cdefine.platform_type == 1) {
12471                 err = alc_codec_rename(codec, "ALC272X");
12472                 if (err < 0)
12473                         goto error;
12474         }
12475
12476         /* automatic parse from the BIOS config */
12477         err = alc662_parse_auto_config(codec);
12478         if (err < 0)
12479                 goto error;
12480
12481         if (!spec->gen.no_analog && spec->gen.beep_nid) {
12482                 switch (codec->core.vendor_id) {
12483                 case 0x10ec0662:
12484                         err = set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
12485                         break;
12486                 case 0x10ec0272:
12487                 case 0x10ec0663:
12488                 case 0x10ec0665:
12489                 case 0x10ec0668:
12490                         err = set_beep_amp(spec, 0x0b, 0x04, HDA_INPUT);
12491                         break;
12492                 case 0x10ec0273:
12493                         err = set_beep_amp(spec, 0x0b, 0x03, HDA_INPUT);
12494                         break;
12495                 }
12496                 if (err < 0)
12497                         goto error;
12498         }
12499
12500         snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE);
12501
12502         return 0;
12503
12504  error:
12505         alc_free(codec);
12506         return err;
12507 }
12508
12509 /*
12510  * ALC680 support
12511  */
12512
12513 static int alc680_parse_auto_config(struct hda_codec *codec)
12514 {
12515         return alc_parse_auto_config(codec, NULL, NULL);
12516 }
12517
12518 /*
12519  */
12520 static int patch_alc680(struct hda_codec *codec)
12521 {
12522         int err;
12523
12524         /* ALC680 has no aa-loopback mixer */
12525         err = alc_alloc_spec(codec, 0);
12526         if (err < 0)
12527                 return err;
12528
12529         /* automatic parse from the BIOS config */
12530         err = alc680_parse_auto_config(codec);
12531         if (err < 0) {
12532                 alc_free(codec);
12533                 return err;
12534         }
12535
12536         return 0;
12537 }
12538
12539 /*
12540  * patch entries
12541  */
12542 static const struct hda_device_id snd_hda_id_realtek[] = {
12543         HDA_CODEC_ENTRY(0x10ec0215, "ALC215", patch_alc269),
12544         HDA_CODEC_ENTRY(0x10ec0221, "ALC221", patch_alc269),
12545         HDA_CODEC_ENTRY(0x10ec0222, "ALC222", patch_alc269),
12546         HDA_CODEC_ENTRY(0x10ec0225, "ALC225", patch_alc269),
12547         HDA_CODEC_ENTRY(0x10ec0230, "ALC236", patch_alc269),
12548         HDA_CODEC_ENTRY(0x10ec0231, "ALC231", patch_alc269),
12549         HDA_CODEC_ENTRY(0x10ec0233, "ALC233", patch_alc269),
12550         HDA_CODEC_ENTRY(0x10ec0234, "ALC234", patch_alc269),
12551         HDA_CODEC_ENTRY(0x10ec0235, "ALC233", patch_alc269),
12552         HDA_CODEC_ENTRY(0x10ec0236, "ALC236", patch_alc269),
12553         HDA_CODEC_ENTRY(0x10ec0245, "ALC245", patch_alc269),
12554         HDA_CODEC_ENTRY(0x10ec0255, "ALC255", patch_alc269),
12555         HDA_CODEC_ENTRY(0x10ec0256, "ALC256", patch_alc269),
12556         HDA_CODEC_ENTRY(0x10ec0257, "ALC257", patch_alc269),
12557         HDA_CODEC_ENTRY(0x10ec0260, "ALC260", patch_alc260),
12558         HDA_CODEC_ENTRY(0x10ec0262, "ALC262", patch_alc262),
12559         HDA_CODEC_ENTRY(0x10ec0267, "ALC267", patch_alc268),
12560         HDA_CODEC_ENTRY(0x10ec0268, "ALC268", patch_alc268),
12561         HDA_CODEC_ENTRY(0x10ec0269, "ALC269", patch_alc269),
12562         HDA_CODEC_ENTRY(0x10ec0270, "ALC270", patch_alc269),
12563         HDA_CODEC_ENTRY(0x10ec0272, "ALC272", patch_alc662),
12564         HDA_CODEC_ENTRY(0x10ec0274, "ALC274", patch_alc269),
12565         HDA_CODEC_ENTRY(0x10ec0275, "ALC275", patch_alc269),
12566         HDA_CODEC_ENTRY(0x10ec0276, "ALC276", patch_alc269),
12567         HDA_CODEC_ENTRY(0x10ec0280, "ALC280", patch_alc269),
12568         HDA_CODEC_ENTRY(0x10ec0282, "ALC282", patch_alc269),
12569         HDA_CODEC_ENTRY(0x10ec0283, "ALC283", patch_alc269),
12570         HDA_CODEC_ENTRY(0x10ec0284, "ALC284", patch_alc269),
12571         HDA_CODEC_ENTRY(0x10ec0285, "ALC285", patch_alc269),
12572         HDA_CODEC_ENTRY(0x10ec0286, "ALC286", patch_alc269),
12573         HDA_CODEC_ENTRY(0x10ec0287, "ALC287", patch_alc269),
12574         HDA_CODEC_ENTRY(0x10ec0288, "ALC288", patch_alc269),
12575         HDA_CODEC_ENTRY(0x10ec0289, "ALC289", patch_alc269),
12576         HDA_CODEC_ENTRY(0x10ec0290, "ALC290", patch_alc269),
12577         HDA_CODEC_ENTRY(0x10ec0292, "ALC292", patch_alc269),
12578         HDA_CODEC_ENTRY(0x10ec0293, "ALC293", patch_alc269),
12579         HDA_CODEC_ENTRY(0x10ec0294, "ALC294", patch_alc269),
12580         HDA_CODEC_ENTRY(0x10ec0295, "ALC295", patch_alc269),
12581         HDA_CODEC_ENTRY(0x10ec0298, "ALC298", patch_alc269),
12582         HDA_CODEC_ENTRY(0x10ec0299, "ALC299", patch_alc269),
12583         HDA_CODEC_ENTRY(0x10ec0300, "ALC300", patch_alc269),
12584         HDA_CODEC_ENTRY(0x10ec0623, "ALC623", patch_alc269),
12585         HDA_CODEC_REV_ENTRY(0x10ec0861, 0x100340, "ALC660", patch_alc861),
12586         HDA_CODEC_ENTRY(0x10ec0660, "ALC660-VD", patch_alc861vd),
12587         HDA_CODEC_ENTRY(0x10ec0861, "ALC861", patch_alc861),
12588         HDA_CODEC_ENTRY(0x10ec0862, "ALC861-VD", patch_alc861vd),
12589         HDA_CODEC_REV_ENTRY(0x10ec0662, 0x100002, "ALC662 rev2", patch_alc882),
12590         HDA_CODEC_REV_ENTRY(0x10ec0662, 0x100101, "ALC662 rev1", patch_alc662),
12591         HDA_CODEC_REV_ENTRY(0x10ec0662, 0x100300, "ALC662 rev3", patch_alc662),
12592         HDA_CODEC_ENTRY(0x10ec0663, "ALC663", patch_alc662),
12593         HDA_CODEC_ENTRY(0x10ec0665, "ALC665", patch_alc662),
12594         HDA_CODEC_ENTRY(0x10ec0667, "ALC667", patch_alc662),
12595         HDA_CODEC_ENTRY(0x10ec0668, "ALC668", patch_alc662),
12596         HDA_CODEC_ENTRY(0x10ec0670, "ALC670", patch_alc662),
12597         HDA_CODEC_ENTRY(0x10ec0671, "ALC671", patch_alc662),
12598         HDA_CODEC_ENTRY(0x10ec0680, "ALC680", patch_alc680),
12599         HDA_CODEC_ENTRY(0x10ec0700, "ALC700", patch_alc269),
12600         HDA_CODEC_ENTRY(0x10ec0701, "ALC701", patch_alc269),
12601         HDA_CODEC_ENTRY(0x10ec0703, "ALC703", patch_alc269),
12602         HDA_CODEC_ENTRY(0x10ec0711, "ALC711", patch_alc269),
12603         HDA_CODEC_ENTRY(0x10ec0867, "ALC891", patch_alc662),
12604         HDA_CODEC_ENTRY(0x10ec0880, "ALC880", patch_alc880),
12605         HDA_CODEC_ENTRY(0x10ec0882, "ALC882", patch_alc882),
12606         HDA_CODEC_ENTRY(0x10ec0883, "ALC883", patch_alc882),
12607         HDA_CODEC_REV_ENTRY(0x10ec0885, 0x100101, "ALC889A", patch_alc882),
12608         HDA_CODEC_REV_ENTRY(0x10ec0885, 0x100103, "ALC889A", patch_alc882),
12609         HDA_CODEC_ENTRY(0x10ec0885, "ALC885", patch_alc882),
12610         HDA_CODEC_ENTRY(0x10ec0887, "ALC887", patch_alc882),
12611         HDA_CODEC_REV_ENTRY(0x10ec0888, 0x100101, "ALC1200", patch_alc882),
12612         HDA_CODEC_ENTRY(0x10ec0888, "ALC888", patch_alc882),
12613         HDA_CODEC_ENTRY(0x10ec0889, "ALC889", patch_alc882),
12614         HDA_CODEC_ENTRY(0x10ec0892, "ALC892", patch_alc662),
12615         HDA_CODEC_ENTRY(0x10ec0897, "ALC897", patch_alc662),
12616         HDA_CODEC_ENTRY(0x10ec0899, "ALC898", patch_alc882),
12617         HDA_CODEC_ENTRY(0x10ec0900, "ALC1150", patch_alc882),
12618         HDA_CODEC_ENTRY(0x10ec0b00, "ALCS1200A", patch_alc882),
12619         HDA_CODEC_ENTRY(0x10ec1168, "ALC1220", patch_alc882),
12620         HDA_CODEC_ENTRY(0x10ec1220, "ALC1220", patch_alc882),
12621         HDA_CODEC_ENTRY(0x19e58326, "HW8326", patch_alc269),
12622         {} /* terminator */
12623 };
12624 MODULE_DEVICE_TABLE(hdaudio, snd_hda_id_realtek);
12625
12626 MODULE_LICENSE("GPL");
12627 MODULE_DESCRIPTION("Realtek HD-audio codec");
12628 MODULE_IMPORT_NS(SND_HDA_SCODEC_COMPONENT);
12629
12630 static struct hda_codec_driver realtek_driver = {
12631         .id = snd_hda_id_realtek,
12632 };
12633
12634 module_hda_codec_driver(realtek_driver);