sound/pci/hda/patch_realtek.c

   1 // SPDX-License-Identifier: GPL-2.0-or-later
   2 /*
   3  * Universal Interface for Intel High Definition Audio Codec
   4  *
   5  * HD audio interface patch for Realtek ALC codecs
   6  *
   7  * Copyright (c) 2004 Kailang Yang <kailang@realtek.com.tw>
   8  *                    PeiSen Hou <pshou@realtek.com.tw>
   9  *                    Takashi Iwai <tiwai@suse.de>
  10  *                    Jonathan Woithe <jwoithe@just42.net>
  11  */
  12
  13 #include <linux/acpi.h>
  14 #include <linux/init.h>
  15 #include <linux/delay.h>
  16 #include <linux/slab.h>
  17 #include <linux/pci.h>
  18 #include <linux/dmi.h>
  19 #include <linux/module.h>
  20 #include <linux/input.h>
  21 #include <linux/leds.h>
  22 #include <linux/ctype.h>
  23 #include <sound/core.h>
  24 #include <sound/jack.h>
  25 #include <sound/hda_codec.h>
  26 #include "hda_local.h"
  27 #include "hda_auto_parser.h"
  28 #include "hda_jack.h"
  29 #include "hda_generic.h"
  30 #include "hda_component.h"
  31
  32 /* keep halting ALC5505 DSP, for power saving */
  33 #define HALT_REALTEK_ALC5505
  34
  35 /* extra amp-initialization sequence types */
  36 enum {
  37         ALC_INIT_UNDEFINED,
  38         ALC_INIT_NONE,
  39         ALC_INIT_DEFAULT,
  40 };
  41
  42 enum {
  43         ALC_HEADSET_MODE_UNKNOWN,
  44         ALC_HEADSET_MODE_UNPLUGGED,
  45         ALC_HEADSET_MODE_HEADSET,
  46         ALC_HEADSET_MODE_MIC,
  47         ALC_HEADSET_MODE_HEADPHONE,
  48 };
  49
  50 enum {
  51         ALC_HEADSET_TYPE_UNKNOWN,
  52         ALC_HEADSET_TYPE_CTIA,
  53         ALC_HEADSET_TYPE_OMTP,
  54 };
  55
  56 enum {
  57         ALC_KEY_MICMUTE_INDEX,
  58 };
  59
  60 struct alc_customize_define {
  61         unsigned int  sku_cfg;
  62         unsigned char port_connectivity;
  63         unsigned char check_sum;
  64         unsigned char customization;
  65         unsigned char external_amp;
  66         unsigned int  enable_pcbeep:1;
  67         unsigned int  platform_type:1;
  68         unsigned int  swap:1;
  69         unsigned int  override:1;
  70         unsigned int  fixup:1; /* Means that this sku is set by driver, not read from hw */
  71 };
  72
  73 struct alc_coef_led {
  74         unsigned int idx;
  75         unsigned int mask;
  76         unsigned int on;
  77         unsigned int off;
  78 };
  79
  80 struct alc_spec {
  81         struct hda_gen_spec gen; /* must be at head */
  82
  83         /* codec parameterization */
  84         struct alc_customize_define cdefine;
  85         unsigned int parse_flags; /* flag for snd_hda_parse_pin_defcfg() */
  86
  87         /* GPIO bits */
  88         unsigned int gpio_mask;
  89         unsigned int gpio_dir;
  90         unsigned int gpio_data;
  91         bool gpio_write_delay;  /* add a delay before writing gpio_data */
  92
  93         /* mute LED for HP laptops, see vref_mute_led_set() */
  94         int mute_led_polarity;
  95         int micmute_led_polarity;
  96         hda_nid_t mute_led_nid;
  97         hda_nid_t cap_mute_led_nid;
  98
  99         unsigned int gpio_mute_led_mask;
 100         unsigned int gpio_mic_led_mask;
 101         struct alc_coef_led mute_led_coef;
 102         struct alc_coef_led mic_led_coef;
 103         struct mutex coef_mutex;
 104
 105         hda_nid_t headset_mic_pin;
 106         hda_nid_t headphone_mic_pin;
 107         int current_headset_mode;
 108         int current_headset_type;
 109
 110         /* hooks */
 111         void (*init_hook)(struct hda_codec *codec);
 112 #ifdef CONFIG_PM
 113         void (*power_hook)(struct hda_codec *codec);
 114 #endif
 115         void (*shutup)(struct hda_codec *codec);
 116
 117         int init_amp;
 118         int codec_variant;      /* flag for other variants */
 119         unsigned int has_alc5505_dsp:1;
 120         unsigned int no_depop_delay:1;
 121         unsigned int done_hp_init:1;
 122         unsigned int no_shutup_pins:1;
 123         unsigned int ultra_low_power:1;
 124         unsigned int has_hs_key:1;
 125         unsigned int no_internal_mic_pin:1;
 126         unsigned int en_3kpull_low:1;
 127
 128         /* for PLL fix */
 129         hda_nid_t pll_nid;
 130         unsigned int pll_coef_idx, pll_coef_bit;
 131         unsigned int coef0;
 132         struct input_dev *kb_dev;
 133         u8 alc_mute_keycode_map[1];
 134
 135         /* component binding */
 136         struct hda_component comps[HDA_MAX_COMPONENTS];
 137 };
 138
 139 /*
 140  * COEF access helper functions
 141  */
 142
 143 static void coef_mutex_lock(struct hda_codec *codec)
 144 {
 145         struct alc_spec *spec = codec->spec;
 146
 147         snd_hda_power_up_pm(codec);
 148         mutex_lock(&spec->coef_mutex);
 149 }
 150
 151 static void coef_mutex_unlock(struct hda_codec *codec)
 152 {
 153         struct alc_spec *spec = codec->spec;
 154
 155         mutex_unlock(&spec->coef_mutex);
 156         snd_hda_power_down_pm(codec);
 157 }
 158
 159 static int __alc_read_coefex_idx(struct hda_codec *codec, hda_nid_t nid,
 160                                  unsigned int coef_idx)
 161 {
 162         unsigned int val;
 163
 164         snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_COEF_INDEX, coef_idx);
 165         val = snd_hda_codec_read(codec, nid, 0, AC_VERB_GET_PROC_COEF, 0);
 166         return val;
 167 }
 168
 169 static int alc_read_coefex_idx(struct hda_codec *codec, hda_nid_t nid,
 170                                unsigned int coef_idx)
 171 {
 172         unsigned int val;
 173
 174         coef_mutex_lock(codec);
 175         val = __alc_read_coefex_idx(codec, nid, coef_idx);
 176         coef_mutex_unlock(codec);
 177         return val;
 178 }
 179
 180 #define alc_read_coef_idx(codec, coef_idx) \
 181         alc_read_coefex_idx(codec, 0x20, coef_idx)
 182
 183 static void __alc_write_coefex_idx(struct hda_codec *codec, hda_nid_t nid,
 184                                    unsigned int coef_idx, unsigned int coef_val)
 185 {
 186         snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_COEF_INDEX, coef_idx);
 187         snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_PROC_COEF, coef_val);
 188 }
 189
 190 static void alc_write_coefex_idx(struct hda_codec *codec, hda_nid_t nid,
 191                                  unsigned int coef_idx, unsigned int coef_val)
 192 {
 193         coef_mutex_lock(codec);
 194         __alc_write_coefex_idx(codec, nid, coef_idx, coef_val);
 195         coef_mutex_unlock(codec);
 196 }
 197
 198 #define alc_write_coef_idx(codec, coef_idx, coef_val) \
 199         alc_write_coefex_idx(codec, 0x20, coef_idx, coef_val)
 200
 201 static void __alc_update_coefex_idx(struct hda_codec *codec, hda_nid_t nid,
 202                                     unsigned int coef_idx, unsigned int mask,
 203                                     unsigned int bits_set)
 204 {
 205         unsigned int val = __alc_read_coefex_idx(codec, nid, coef_idx);
 206
 207         if (val != -1)
 208                 __alc_write_coefex_idx(codec, nid, coef_idx,
 209                                        (val & ~mask) | bits_set);
 210 }
 211
 212 static void alc_update_coefex_idx(struct hda_codec *codec, hda_nid_t nid,
 213                                   unsigned int coef_idx, unsigned int mask,
 214                                   unsigned int bits_set)
 215 {
 216         coef_mutex_lock(codec);
 217         __alc_update_coefex_idx(codec, nid, coef_idx, mask, bits_set);
 218         coef_mutex_unlock(codec);
 219 }
 220
 221 #define alc_update_coef_idx(codec, coef_idx, mask, bits_set)    \
 222         alc_update_coefex_idx(codec, 0x20, coef_idx, mask, bits_set)
 223
 224 /* a special bypass for COEF 0; read the cached value at the second time */
 225 static unsigned int alc_get_coef0(struct hda_codec *codec)
 226 {
 227         struct alc_spec *spec = codec->spec;
 228
 229         if (!spec->coef0)
 230                 spec->coef0 = alc_read_coef_idx(codec, 0);
 231         return spec->coef0;
 232 }
 233
 234 /* coef writes/updates batch */
 235 struct coef_fw {
 236         unsigned char nid;
 237         unsigned char idx;
 238         unsigned short mask;
 239         unsigned short val;
 240 };
 241
 242 #define UPDATE_COEFEX(_nid, _idx, _mask, _val) \
 243         { .nid = (_nid), .idx = (_idx), .mask = (_mask), .val = (_val) }
 244 #define WRITE_COEFEX(_nid, _idx, _val) UPDATE_COEFEX(_nid, _idx, -1, _val)
 245 #define WRITE_COEF(_idx, _val) WRITE_COEFEX(0x20, _idx, _val)
 246 #define UPDATE_COEF(_idx, _mask, _val) UPDATE_COEFEX(0x20, _idx, _mask, _val)
 247
 248 static void alc_process_coef_fw(struct hda_codec *codec,
 249                                 const struct coef_fw *fw)
 250 {
 251         coef_mutex_lock(codec);
 252         for (; fw->nid; fw++) {
 253                 if (fw->mask == (unsigned short)-1)
 254                         __alc_write_coefex_idx(codec, fw->nid, fw->idx, fw->val);
 255                 else
 256                         __alc_update_coefex_idx(codec, fw->nid, fw->idx,
 257                                                 fw->mask, fw->val);
 258         }
 259         coef_mutex_unlock(codec);
 260 }
 261
 262 /*
 263  * GPIO setup tables, used in initialization
 264  */
 265
 266 /* Enable GPIO mask and set output */
 267 static void alc_setup_gpio(struct hda_codec *codec, unsigned int mask)
 268 {
 269         struct alc_spec *spec = codec->spec;
 270
 271         spec->gpio_mask |= mask;
 272         spec->gpio_dir |= mask;
 273         spec->gpio_data |= mask;
 274 }
 275
 276 static void alc_write_gpio_data(struct hda_codec *codec)
 277 {
 278         struct alc_spec *spec = codec->spec;
 279
 280         snd_hda_codec_write(codec, 0x01, 0, AC_VERB_SET_GPIO_DATA,
 281                             spec->gpio_data);
 282 }
 283
 284 static void alc_update_gpio_data(struct hda_codec *codec, unsigned int mask,
 285                                  bool on)
 286 {
 287         struct alc_spec *spec = codec->spec;
 288         unsigned int oldval = spec->gpio_data;
 289
 290         if (on)
 291                 spec->gpio_data |= mask;
 292         else
 293                 spec->gpio_data &= ~mask;
 294         if (oldval != spec->gpio_data)
 295                 alc_write_gpio_data(codec);
 296 }
 297
 298 static void alc_write_gpio(struct hda_codec *codec)
 299 {
 300         struct alc_spec *spec = codec->spec;
 301
 302         if (!spec->gpio_mask)
 303                 return;
 304
 305         snd_hda_codec_write(codec, codec->core.afg, 0,
 306                             AC_VERB_SET_GPIO_MASK, spec->gpio_mask);
 307         snd_hda_codec_write(codec, codec->core.afg, 0,
 308                             AC_VERB_SET_GPIO_DIRECTION, spec->gpio_dir);
 309         if (spec->gpio_write_delay)
 310                 msleep(1);
 311         alc_write_gpio_data(codec);
 312 }
 313
 314 static void alc_fixup_gpio(struct hda_codec *codec, int action,
 315                            unsigned int mask)
 316 {
 317         if (action == HDA_FIXUP_ACT_PRE_PROBE)
 318                 alc_setup_gpio(codec, mask);
 319 }
 320
 321 static void alc_fixup_gpio1(struct hda_codec *codec,
 322                             const struct hda_fixup *fix, int action)
 323 {
 324         alc_fixup_gpio(codec, action, 0x01);
 325 }
 326
 327 static void alc_fixup_gpio2(struct hda_codec *codec,
 328                             const struct hda_fixup *fix, int action)
 329 {
 330         alc_fixup_gpio(codec, action, 0x02);
 331 }
 332
 333 static void alc_fixup_gpio3(struct hda_codec *codec,
 334                             const struct hda_fixup *fix, int action)
 335 {
 336         alc_fixup_gpio(codec, action, 0x03);
 337 }
 338
 339 static void alc_fixup_gpio4(struct hda_codec *codec,
 340                             const struct hda_fixup *fix, int action)
 341 {
 342         alc_fixup_gpio(codec, action, 0x04);
 343 }
 344
 345 static void alc_fixup_micmute_led(struct hda_codec *codec,
 346                                   const struct hda_fixup *fix, int action)
 347 {
 348         if (action == HDA_FIXUP_ACT_PRE_PROBE)
 349                 snd_hda_gen_add_micmute_led_cdev(codec, NULL);
 350 }
 351
 352 /*
 353  * Fix hardware PLL issue
 354  * On some codecs, the analog PLL gating control must be off while
 355  * the default value is 1.
 356  */
 357 static void alc_fix_pll(struct hda_codec *codec)
 358 {
 359         struct alc_spec *spec = codec->spec;
 360
 361         if (spec->pll_nid)
 362                 alc_update_coefex_idx(codec, spec->pll_nid, spec->pll_coef_idx,
 363                                       1 << spec->pll_coef_bit, 0);
 364 }
 365
 366 static void alc_fix_pll_init(struct hda_codec *codec, hda_nid_t nid,
 367                              unsigned int coef_idx, unsigned int coef_bit)
 368 {
 369         struct alc_spec *spec = codec->spec;
 370         spec->pll_nid = nid;
 371         spec->pll_coef_idx = coef_idx;
 372         spec->pll_coef_bit = coef_bit;
 373         alc_fix_pll(codec);
 374 }
 375
 376 /* update the master volume per volume-knob's unsol event */
 377 static void alc_update_knob_master(struct hda_codec *codec,
 378                                    struct hda_jack_callback *jack)
 379 {
 380         unsigned int val;
 381         struct snd_kcontrol *kctl;
 382         struct snd_ctl_elem_value *uctl;
 383
 384         kctl = snd_hda_find_mixer_ctl(codec, "Master Playback Volume");
 385         if (!kctl)
 386                 return;
 387         uctl = kzalloc(sizeof(*uctl), GFP_KERNEL);
 388         if (!uctl)
 389                 return;
 390         val = snd_hda_codec_read(codec, jack->nid, 0,
 391                                  AC_VERB_GET_VOLUME_KNOB_CONTROL, 0);
 392         val &= HDA_AMP_VOLMASK;
 393         uctl->value.integer.value[0] = val;
 394         uctl->value.integer.value[1] = val;
 395         kctl->put(kctl, uctl);
 396         kfree(uctl);
 397 }
 398
 399 static void alc880_unsol_event(struct hda_codec *codec, unsigned int res)
 400 {
 401         /* For some reason, the res given from ALC880 is broken.
 402            Here we adjust it properly. */
 403         snd_hda_jack_unsol_event(codec, res >> 2);
 404 }
 405
 406 /* Change EAPD to verb control */
 407 static void alc_fill_eapd_coef(struct hda_codec *codec)
 408 {
 409         int coef;
 410
 411         coef = alc_get_coef0(codec);
 412
 413         switch (codec->core.vendor_id) {
 414         case 0x10ec0262:
 415                 alc_update_coef_idx(codec, 0x7, 0, 1<<5);
 416                 break;
 417         case 0x10ec0267:
 418         case 0x10ec0268:
 419                 alc_update_coef_idx(codec, 0x7, 0, 1<<13);
 420                 break;
 421         case 0x10ec0269:
 422                 if ((coef & 0x00f0) == 0x0010)
 423                         alc_update_coef_idx(codec, 0xd, 0, 1<<14);
 424                 if ((coef & 0x00f0) == 0x0020)
 425                         alc_update_coef_idx(codec, 0x4, 1<<15, 0);
 426                 if ((coef & 0x00f0) == 0x0030)
 427                         alc_update_coef_idx(codec, 0x10, 1<<9, 0);
 428                 break;
 429         case 0x10ec0280:
 430         case 0x10ec0284:
 431         case 0x10ec0290:
 432         case 0x10ec0292:
 433                 alc_update_coef_idx(codec, 0x4, 1<<15, 0);
 434                 break;
 435         case 0x10ec0225:
 436         case 0x10ec0295:
 437         case 0x10ec0299:
 438                 alc_update_coef_idx(codec, 0x67, 0xf000, 0x3000);
 439                 fallthrough;
 440         case 0x10ec0215:
 441         case 0x10ec0285:
 442         case 0x10ec0289:
 443                 alc_update_coef_idx(codec, 0x36, 1<<13, 0);
 444                 fallthrough;
 445         case 0x10ec0230:
 446         case 0x10ec0233:
 447         case 0x10ec0235:
 448         case 0x10ec0236:
 449         case 0x10ec0245:
 450         case 0x10ec0255:
 451         case 0x10ec0256:
 452         case 0x19e58326:
 453         case 0x10ec0257:
 454         case 0x10ec0282:
 455         case 0x10ec0283:
 456         case 0x10ec0286:
 457         case 0x10ec0288:
 458         case 0x10ec0298:
 459         case 0x10ec0300:
 460                 alc_update_coef_idx(codec, 0x10, 1<<9, 0);
 461                 break;
 462         case 0x10ec0275:
 463                 alc_update_coef_idx(codec, 0xe, 0, 1<<0);
 464                 break;
 465         case 0x10ec0287:
 466                 alc_update_coef_idx(codec, 0x10, 1<<9, 0);
 467                 alc_write_coef_idx(codec, 0x8, 0x4ab7);
 468                 break;
 469         case 0x10ec0293:
 470                 alc_update_coef_idx(codec, 0xa, 1<<13, 0);
 471                 break;
 472         case 0x10ec0234:
 473         case 0x10ec0274:
 474         case 0x10ec0294:
 475         case 0x10ec0700:
 476         case 0x10ec0701:
 477         case 0x10ec0703:
 478         case 0x10ec0711:
 479                 alc_update_coef_idx(codec, 0x10, 1<<15, 0);
 480                 break;
 481         case 0x10ec0662:
 482                 if ((coef & 0x00f0) == 0x0030)
 483                         alc_update_coef_idx(codec, 0x4, 1<<10, 0); /* EAPD Ctrl */
 484                 break;
 485         case 0x10ec0272:
 486         case 0x10ec0273:
 487         case 0x10ec0663:
 488         case 0x10ec0665:
 489         case 0x10ec0670:
 490         case 0x10ec0671:
 491         case 0x10ec0672:
 492                 alc_update_coef_idx(codec, 0xd, 0, 1<<14); /* EAPD Ctrl */
 493                 break;
 494         case 0x10ec0222:
 495         case 0x10ec0623:
 496                 alc_update_coef_idx(codec, 0x19, 1<<13, 0);
 497                 break;
 498         case 0x10ec0668:
 499                 alc_update_coef_idx(codec, 0x7, 3<<13, 0);
 500                 break;
 501         case 0x10ec0867:
 502                 alc_update_coef_idx(codec, 0x4, 1<<10, 0);
 503                 break;
 504         case 0x10ec0888:
 505                 if ((coef & 0x00f0) == 0x0020 || (coef & 0x00f0) == 0x0030)
 506                         alc_update_coef_idx(codec, 0x7, 1<<5, 0);
 507                 break;
 508         case 0x10ec0892:
 509         case 0x10ec0897:
 510                 alc_update_coef_idx(codec, 0x7, 1<<5, 0);
 511                 break;
 512         case 0x10ec0899:
 513         case 0x10ec0900:
 514         case 0x10ec0b00:
 515         case 0x10ec1168:
 516         case 0x10ec1220:
 517                 alc_update_coef_idx(codec, 0x7, 1<<1, 0);
 518                 break;
 519         }
 520 }
 521
 522 /* additional initialization for ALC888 variants */
 523 static void alc888_coef_init(struct hda_codec *codec)
 524 {
 525         switch (alc_get_coef0(codec) & 0x00f0) {
 526         /* alc888-VA */
 527         case 0x00:
 528         /* alc888-VB */
 529         case 0x10:
 530                 alc_update_coef_idx(codec, 7, 0, 0x2030); /* Turn EAPD to High */
 531                 break;
 532         }
 533 }
 534
 535 /* turn on/off EAPD control (only if available) */
 536 static void set_eapd(struct hda_codec *codec, hda_nid_t nid, int on)
 537 {
 538         if (get_wcaps_type(get_wcaps(codec, nid)) != AC_WID_PIN)
 539                 return;
 540         if (snd_hda_query_pin_caps(codec, nid) & AC_PINCAP_EAPD)
 541                 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_EAPD_BTLENABLE,
 542                                     on ? 2 : 0);
 543 }
 544
 545 /* turn on/off EAPD controls of the codec */
 546 static void alc_auto_setup_eapd(struct hda_codec *codec, bool on)
 547 {
 548         /* We currently only handle front, HP */
 549         static const hda_nid_t pins[] = {
 550                 0x0f, 0x10, 0x14, 0x15, 0x17, 0
 551         };
 552         const hda_nid_t *p;
 553         for (p = pins; *p; p++)
 554                 set_eapd(codec, *p, on);
 555 }
 556
 557 static int find_ext_mic_pin(struct hda_codec *codec);
 558
 559 static void alc_headset_mic_no_shutup(struct hda_codec *codec)
 560 {
 561         const struct hda_pincfg *pin;
 562         int mic_pin = find_ext_mic_pin(codec);
 563         int i;
 564
 565         /* don't shut up pins when unloading the driver; otherwise it breaks
 566          * the default pin setup at the next load of the driver
 567          */
 568         if (codec->bus->shutdown)
 569                 return;
 570
 571         snd_array_for_each(&codec->init_pins, i, pin) {
 572                 /* use read here for syncing after issuing each verb */
 573                 if (pin->nid != mic_pin)
 574                         snd_hda_codec_read(codec, pin->nid, 0,
 575                                         AC_VERB_SET_PIN_WIDGET_CONTROL, 0);
 576         }
 577
 578         codec->pins_shutup = 1;
 579 }
 580
 581 static void alc_shutup_pins(struct hda_codec *codec)
 582 {
 583         struct alc_spec *spec = codec->spec;
 584
 585         switch (codec->core.vendor_id) {
 586         case 0x10ec0236:
 587         case 0x10ec0256:
 588         case 0x19e58326:
 589         case 0x10ec0283:
 590         case 0x10ec0286:
 591         case 0x10ec0288:
 592         case 0x10ec0298:
 593                 alc_headset_mic_no_shutup(codec);
 594                 break;
 595         default:
 596                 if (!spec->no_shutup_pins)
 597                         snd_hda_shutup_pins(codec);
 598                 break;
 599         }
 600 }
 601
 602 /* generic shutup callback;
 603  * just turning off EAPD and a little pause for avoiding pop-noise
 604  */
 605 static void alc_eapd_shutup(struct hda_codec *codec)
 606 {
 607         struct alc_spec *spec = codec->spec;
 608
 609         alc_auto_setup_eapd(codec, false);
 610         if (!spec->no_depop_delay)
 611                 msleep(200);
 612         alc_shutup_pins(codec);
 613 }
 614
 615 /* generic EAPD initialization */
 616 static void alc_auto_init_amp(struct hda_codec *codec, int type)
 617 {
 618         alc_auto_setup_eapd(codec, true);
 619         alc_write_gpio(codec);
 620         switch (type) {
 621         case ALC_INIT_DEFAULT:
 622                 switch (codec->core.vendor_id) {
 623                 case 0x10ec0260:
 624                         alc_update_coefex_idx(codec, 0x1a, 7, 0, 0x2010);
 625                         break;
 626                 case 0x10ec0880:
 627                 case 0x10ec0882:
 628                 case 0x10ec0883:
 629                 case 0x10ec0885:
 630                         alc_update_coef_idx(codec, 7, 0, 0x2030);
 631                         break;
 632                 case 0x10ec0888:
 633                         alc888_coef_init(codec);
 634                         break;
 635                 }
 636                 break;
 637         }
 638 }
 639
 640 /* get a primary headphone pin if available */
 641 static hda_nid_t alc_get_hp_pin(struct alc_spec *spec)
 642 {
 643         if (spec->gen.autocfg.hp_pins[0])
 644                 return spec->gen.autocfg.hp_pins[0];
 645         if (spec->gen.autocfg.line_out_type == AC_JACK_HP_OUT)
 646                 return spec->gen.autocfg.line_out_pins[0];
 647         return 0;
 648 }
 649
 650 /*
 651  * Realtek SSID verification
 652  */
 653
 654 /* Could be any non-zero and even value. When used as fixup, tells
 655  * the driver to ignore any present sku defines.
 656  */
 657 #define ALC_FIXUP_SKU_IGNORE (2)
 658
 659 static void alc_fixup_sku_ignore(struct hda_codec *codec,
 660                                  const struct hda_fixup *fix, int action)
 661 {
 662         struct alc_spec *spec = codec->spec;
 663         if (action == HDA_FIXUP_ACT_PRE_PROBE) {
 664                 spec->cdefine.fixup = 1;
 665                 spec->cdefine.sku_cfg = ALC_FIXUP_SKU_IGNORE;
 666         }
 667 }
 668
 669 static void alc_fixup_no_depop_delay(struct hda_codec *codec,
 670                                     const struct hda_fixup *fix, int action)
 671 {
 672         struct alc_spec *spec = codec->spec;
 673
 674         if (action == HDA_FIXUP_ACT_PROBE) {
 675                 spec->no_depop_delay = 1;
 676                 codec->depop_delay = 0;
 677         }
 678 }
 679
 680 static int alc_auto_parse_customize_define(struct hda_codec *codec)
 681 {
 682         unsigned int ass, tmp, i;
 683         unsigned nid = 0;
 684         struct alc_spec *spec = codec->spec;
 685
 686         spec->cdefine.enable_pcbeep = 1; /* assume always enabled */
 687
 688         if (spec->cdefine.fixup) {
 689                 ass = spec->cdefine.sku_cfg;
 690                 if (ass == ALC_FIXUP_SKU_IGNORE)
 691                         return -1;
 692                 goto do_sku;
 693         }
 694
 695         if (!codec->bus->pci)
 696                 return -1;
 697         ass = codec->core.subsystem_id & 0xffff;
 698         if (ass != codec->bus->pci->subsystem_device && (ass & 1))
 699                 goto do_sku;
 700
 701         nid = 0x1d;
 702         if (codec->core.vendor_id == 0x10ec0260)
 703                 nid = 0x17;
 704         ass = snd_hda_codec_get_pincfg(codec, nid);
 705
 706         if (!(ass & 1)) {
 707                 codec_info(codec, "%s: SKU not ready 0x%08x\n",
 708                            codec->core.chip_name, ass);
 709                 return -1;
 710         }
 711
 712         /* check sum */
 713         tmp = 0;
 714         for (i = 1; i < 16; i++) {
 715                 if ((ass >> i) & 1)
 716                         tmp++;
 717         }
 718         if (((ass >> 16) & 0xf) != tmp)
 719                 return -1;
 720
 721         spec->cdefine.port_connectivity = ass >> 30;
 722         spec->cdefine.enable_pcbeep = (ass & 0x100000) >> 20;
 723         spec->cdefine.check_sum = (ass >> 16) & 0xf;
 724         spec->cdefine.customization = ass >> 8;
 725 do_sku:
 726         spec->cdefine.sku_cfg = ass;
 727         spec->cdefine.external_amp = (ass & 0x38) >> 3;
 728         spec->cdefine.platform_type = (ass & 0x4) >> 2;
 729         spec->cdefine.swap = (ass & 0x2) >> 1;
 730         spec->cdefine.override = ass & 0x1;
 731
 732         codec_dbg(codec, "SKU: Nid=0x%x sku_cfg=0x%08x\n",
 733                    nid, spec->cdefine.sku_cfg);
 734         codec_dbg(codec, "SKU: port_connectivity=0x%x\n",
 735                    spec->cdefine.port_connectivity);
 736         codec_dbg(codec, "SKU: enable_pcbeep=0x%x\n", spec->cdefine.enable_pcbeep);
 737         codec_dbg(codec, "SKU: check_sum=0x%08x\n", spec->cdefine.check_sum);
 738         codec_dbg(codec, "SKU: customization=0x%08x\n", spec->cdefine.customization);
 739         codec_dbg(codec, "SKU: external_amp=0x%x\n", spec->cdefine.external_amp);
 740         codec_dbg(codec, "SKU: platform_type=0x%x\n", spec->cdefine.platform_type);
 741         codec_dbg(codec, "SKU: swap=0x%x\n", spec->cdefine.swap);
 742         codec_dbg(codec, "SKU: override=0x%x\n", spec->cdefine.override);
 743
 744         return 0;
 745 }
 746
 747 /* return the position of NID in the list, or -1 if not found */
 748 static int find_idx_in_nid_list(hda_nid_t nid, const hda_nid_t *list, int nums)
 749 {
 750         int i;
 751         for (i = 0; i < nums; i++)
 752                 if (list[i] == nid)
 753                         return i;
 754         return -1;
 755 }
 756 /* return true if the given NID is found in the list */
 757 static bool found_in_nid_list(hda_nid_t nid, const hda_nid_t *list, int nums)
 758 {
 759         return find_idx_in_nid_list(nid, list, nums) >= 0;
 760 }
 761
 762 /* check subsystem ID and set up device-specific initialization;
 763  * return 1 if initialized, 0 if invalid SSID
 764  */
 765 /* 32-bit subsystem ID for BIOS loading in HD Audio codec.
 766  *      31 ~ 16 :       Manufacture ID
 767  *      15 ~ 8  :       SKU ID
 768  *      7  ~ 0  :       Assembly ID
 769  *      port-A --> pin 39/41, port-E --> pin 14/15, port-D --> pin 35/36
 770  */
 771 static int alc_subsystem_id(struct hda_codec *codec, const hda_nid_t *ports)
 772 {
 773         unsigned int ass, tmp, i;
 774         unsigned nid;
 775         struct alc_spec *spec = codec->spec;
 776
 777         if (spec->cdefine.fixup) {
 778                 ass = spec->cdefine.sku_cfg;
 779                 if (ass == ALC_FIXUP_SKU_IGNORE)
 780                         return 0;
 781                 goto do_sku;
 782         }
 783
 784         ass = codec->core.subsystem_id & 0xffff;
 785         if (codec->bus->pci &&
 786             ass != codec->bus->pci->subsystem_device && (ass & 1))
 787                 goto do_sku;
 788
 789         /* invalid SSID, check the special NID pin defcfg instead */
 790         /*
 791          * 31~30        : port connectivity
 792          * 29~21        : reserve
 793          * 20           : PCBEEP input
 794          * 19~16        : Check sum (15:1)
 795          * 15~1         : Custom
 796          * 0            : override
 797         */
 798         nid = 0x1d;
 799         if (codec->core.vendor_id == 0x10ec0260)
 800                 nid = 0x17;
 801         ass = snd_hda_codec_get_pincfg(codec, nid);
 802         codec_dbg(codec,
 803                   "realtek: No valid SSID, checking pincfg 0x%08x for NID 0x%x\n",
 804                    ass, nid);
 805         if (!(ass & 1))
 806                 return 0;
 807         if ((ass >> 30) != 1)   /* no physical connection */
 808                 return 0;
 809
 810         /* check sum */
 811         tmp = 0;
 812         for (i = 1; i < 16; i++) {
 813                 if ((ass >> i) & 1)
 814                         tmp++;
 815         }
 816         if (((ass >> 16) & 0xf) != tmp)
 817                 return 0;
 818 do_sku:
 819         codec_dbg(codec, "realtek: Enabling init ASM_ID=0x%04x CODEC_ID=%08x\n",
 820                    ass & 0xffff, codec->core.vendor_id);
 821         /*
 822          * 0 : override
 823          * 1 :  Swap Jack
 824          * 2 : 0 --> Desktop, 1 --> Laptop
 825          * 3~5 : External Amplifier control
 826          * 7~6 : Reserved
 827         */
 828         tmp = (ass & 0x38) >> 3;        /* external Amp control */
 829         if (spec->init_amp == ALC_INIT_UNDEFINED) {
 830                 switch (tmp) {
 831                 case 1:
 832                         alc_setup_gpio(codec, 0x01);
 833                         break;
 834                 case 3:
 835                         alc_setup_gpio(codec, 0x02);
 836                         break;
 837                 case 7:
 838                         alc_setup_gpio(codec, 0x04);
 839                         break;
 840                 case 5:
 841                 default:
 842                         spec->init_amp = ALC_INIT_DEFAULT;
 843                         break;
 844                 }
 845         }
 846
 847         /* is laptop or Desktop and enable the function "Mute internal speaker
 848          * when the external headphone out jack is plugged"
 849          */
 850         if (!(ass & 0x8000))
 851                 return 1;
 852         /*
 853          * 10~8 : Jack location
 854          * 12~11: Headphone out -> 00: PortA, 01: PortE, 02: PortD, 03: Resvered
 855          * 14~13: Resvered
 856          * 15   : 1 --> enable the function "Mute internal speaker
 857          *              when the external headphone out jack is plugged"
 858          */
 859         if (!alc_get_hp_pin(spec)) {
 860                 hda_nid_t nid;
 861                 tmp = (ass >> 11) & 0x3;        /* HP to chassis */
 862                 nid = ports[tmp];
 863                 if (found_in_nid_list(nid, spec->gen.autocfg.line_out_pins,
 864                                       spec->gen.autocfg.line_outs))
 865                         return 1;
 866                 spec->gen.autocfg.hp_pins[0] = nid;
 867         }
 868         return 1;
 869 }
 870
 871 /* Check the validity of ALC subsystem-id
 872  * ports contains an array of 4 pin NIDs for port-A, E, D and I */
 873 static void alc_ssid_check(struct hda_codec *codec, const hda_nid_t *ports)
 874 {
 875         if (!alc_subsystem_id(codec, ports)) {
 876                 struct alc_spec *spec = codec->spec;
 877                 if (spec->init_amp == ALC_INIT_UNDEFINED) {
 878                         codec_dbg(codec,
 879                                   "realtek: Enable default setup for auto mode as fallback\n");
 880                         spec->init_amp = ALC_INIT_DEFAULT;
 881                 }
 882         }
 883 }
 884
 885 /*
 886  */
 887
 888 static void alc_fixup_inv_dmic(struct hda_codec *codec,
 889                                const struct hda_fixup *fix, int action)
 890 {
 891         struct alc_spec *spec = codec->spec;
 892
 893         spec->gen.inv_dmic_split = 1;
 894 }
 895
 896
 897 static int alc_build_controls(struct hda_codec *codec)
 898 {
 899         int err;
 900
 901         err = snd_hda_gen_build_controls(codec);
 902         if (err < 0)
 903                 return err;
 904
 905         snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_BUILD);
 906         return 0;
 907 }
 908
 909
 910 /*
 911  * Common callbacks
 912  */
 913
 914 static void alc_pre_init(struct hda_codec *codec)
 915 {
 916         alc_fill_eapd_coef(codec);
 917 }
 918
 919 #define is_s3_resume(codec) \
 920         ((codec)->core.dev.power.power_state.event == PM_EVENT_RESUME)
 921 #define is_s4_resume(codec) \
 922         ((codec)->core.dev.power.power_state.event == PM_EVENT_RESTORE)
 923
 924 static int alc_init(struct hda_codec *codec)
 925 {
 926         struct alc_spec *spec = codec->spec;
 927
 928         /* hibernation resume needs the full chip initialization */
 929         if (is_s4_resume(codec))
 930                 alc_pre_init(codec);
 931
 932         if (spec->init_hook)
 933                 spec->init_hook(codec);
 934
 935         spec->gen.skip_verbs = 1; /* applied in below */
 936         snd_hda_gen_init(codec);
 937         alc_fix_pll(codec);
 938         alc_auto_init_amp(codec, spec->init_amp);
 939         snd_hda_apply_verbs(codec); /* apply verbs here after own init */
 940
 941         snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_INIT);
 942
 943         return 0;
 944 }
 945
 946 #define alc_free        snd_hda_gen_free
 947
 948 #ifdef CONFIG_PM
 949 static inline void alc_shutup(struct hda_codec *codec)
 950 {
 951         struct alc_spec *spec = codec->spec;
 952
 953         if (!snd_hda_get_bool_hint(codec, "shutup"))
 954                 return; /* disabled explicitly by hints */
 955
 956         if (spec && spec->shutup)
 957                 spec->shutup(codec);
 958         else
 959                 alc_shutup_pins(codec);
 960 }
 961
 962 static void alc_power_eapd(struct hda_codec *codec)
 963 {
 964         alc_auto_setup_eapd(codec, false);
 965 }
 966
 967 static int alc_suspend(struct hda_codec *codec)
 968 {
 969         struct alc_spec *spec = codec->spec;
 970         alc_shutup(codec);
 971         if (spec && spec->power_hook)
 972                 spec->power_hook(codec);
 973         return 0;
 974 }
 975
 976 static int alc_resume(struct hda_codec *codec)
 977 {
 978         struct alc_spec *spec = codec->spec;
 979
 980         if (!spec->no_depop_delay)
 981                 msleep(150); /* to avoid pop noise */
 982         codec->patch_ops.init(codec);
 983         snd_hda_regmap_sync(codec);
 984         hda_call_check_power_status(codec, 0x01);
 985         return 0;
 986 }
 987 #endif
 988
 989 /*
 990  */
 991 static const struct hda_codec_ops alc_patch_ops = {
 992         .build_controls = alc_build_controls,
 993         .build_pcms = snd_hda_gen_build_pcms,
 994         .init = alc_init,
 995         .free = alc_free,
 996         .unsol_event = snd_hda_jack_unsol_event,
 997 #ifdef CONFIG_PM
 998         .resume = alc_resume,
 999         .suspend = alc_suspend,
1000         .check_power_status = snd_hda_gen_check_power_status,
1001 #endif
1002 };
1003
1004
1005 #define alc_codec_rename(codec, name) snd_hda_codec_set_name(codec, name)
1006
1007 /*
1008  * Rename codecs appropriately from COEF value or subvendor id
1009  */
1010 struct alc_codec_rename_table {
1011         unsigned int vendor_id;
1012         unsigned short coef_mask;
1013         unsigned short coef_bits;
1014         const char *name;
1015 };
1016
1017 struct alc_codec_rename_pci_table {
1018         unsigned int codec_vendor_id;
1019         unsigned short pci_subvendor;
1020         unsigned short pci_subdevice;
1021         const char *name;
1022 };
1023
1024 static const struct alc_codec_rename_table rename_tbl[] = {
1025         { 0x10ec0221, 0xf00f, 0x1003, "ALC231" },
1026         { 0x10ec0269, 0xfff0, 0x3010, "ALC277" },
1027         { 0x10ec0269, 0xf0f0, 0x2010, "ALC259" },
1028         { 0x10ec0269, 0xf0f0, 0x3010, "ALC258" },
1029         { 0x10ec0269, 0x00f0, 0x0010, "ALC269VB" },
1030         { 0x10ec0269, 0xffff, 0xa023, "ALC259" },
1031         { 0x10ec0269, 0xffff, 0x6023, "ALC281X" },
1032         { 0x10ec0269, 0x00f0, 0x0020, "ALC269VC" },
1033         { 0x10ec0269, 0x00f0, 0x0030, "ALC269VD" },
1034         { 0x10ec0662, 0xffff, 0x4020, "ALC656" },
1035         { 0x10ec0887, 0x00f0, 0x0030, "ALC887-VD" },
1036         { 0x10ec0888, 0x00f0, 0x0030, "ALC888-VD" },
1037         { 0x10ec0888, 0xf0f0, 0x3020, "ALC886" },
1038         { 0x10ec0899, 0x2000, 0x2000, "ALC899" },
1039         { 0x10ec0892, 0xffff, 0x8020, "ALC661" },
1040         { 0x10ec0892, 0xffff, 0x8011, "ALC661" },
1041         { 0x10ec0892, 0xffff, 0x4011, "ALC656" },
1042         { } /* terminator */
1043 };
1044
1045 static const struct alc_codec_rename_pci_table rename_pci_tbl[] = {
1046         { 0x10ec0280, 0x1028, 0, "ALC3220" },
1047         { 0x10ec0282, 0x1028, 0, "ALC3221" },
1048         { 0x10ec0283, 0x1028, 0, "ALC3223" },
1049         { 0x10ec0288, 0x1028, 0, "ALC3263" },
1050         { 0x10ec0292, 0x1028, 0, "ALC3226" },
1051         { 0x10ec0293, 0x1028, 0, "ALC3235" },
1052         { 0x10ec0255, 0x1028, 0, "ALC3234" },
1053         { 0x10ec0668, 0x1028, 0, "ALC3661" },
1054         { 0x10ec0275, 0x1028, 0, "ALC3260" },
1055         { 0x10ec0899, 0x1028, 0, "ALC3861" },
1056         { 0x10ec0298, 0x1028, 0, "ALC3266" },
1057         { 0x10ec0236, 0x1028, 0, "ALC3204" },
1058         { 0x10ec0256, 0x1028, 0, "ALC3246" },
1059         { 0x10ec0225, 0x1028, 0, "ALC3253" },
1060         { 0x10ec0295, 0x1028, 0, "ALC3254" },
1061         { 0x10ec0299, 0x1028, 0, "ALC3271" },
1062         { 0x10ec0670, 0x1025, 0, "ALC669X" },
1063         { 0x10ec0676, 0x1025, 0, "ALC679X" },
1064         { 0x10ec0282, 0x1043, 0, "ALC3229" },
1065         { 0x10ec0233, 0x1043, 0, "ALC3236" },
1066         { 0x10ec0280, 0x103c, 0, "ALC3228" },
1067         { 0x10ec0282, 0x103c, 0, "ALC3227" },
1068         { 0x10ec0286, 0x103c, 0, "ALC3242" },
1069         { 0x10ec0290, 0x103c, 0, "ALC3241" },
1070         { 0x10ec0668, 0x103c, 0, "ALC3662" },
1071         { 0x10ec0283, 0x17aa, 0, "ALC3239" },
1072         { 0x10ec0292, 0x17aa, 0, "ALC3232" },
1073         { } /* terminator */
1074 };
1075
1076 static int alc_codec_rename_from_preset(struct hda_codec *codec)
1077 {
1078         const struct alc_codec_rename_table *p;
1079         const struct alc_codec_rename_pci_table *q;
1080
1081         for (p = rename_tbl; p->vendor_id; p++) {
1082                 if (p->vendor_id != codec->core.vendor_id)
1083                         continue;
1084                 if ((alc_get_coef0(codec) & p->coef_mask) == p->coef_bits)
1085                         return alc_codec_rename(codec, p->name);
1086         }
1087
1088         if (!codec->bus->pci)
1089                 return 0;
1090         for (q = rename_pci_tbl; q->codec_vendor_id; q++) {
1091                 if (q->codec_vendor_id != codec->core.vendor_id)
1092                         continue;
1093                 if (q->pci_subvendor != codec->bus->pci->subsystem_vendor)
1094                         continue;
1095                 if (!q->pci_subdevice ||
1096                     q->pci_subdevice == codec->bus->pci->subsystem_device)
1097                         return alc_codec_rename(codec, q->name);
1098         }
1099
1100         return 0;
1101 }
1102
1103
1104 /*
1105  * Digital-beep handlers
1106  */
1107 #ifdef CONFIG_SND_HDA_INPUT_BEEP
1108
1109 /* additional beep mixers; private_value will be overwritten */
1110 static const struct snd_kcontrol_new alc_beep_mixer[] = {
1111         HDA_CODEC_VOLUME("Beep Playback Volume", 0, 0, HDA_INPUT),
1112         HDA_CODEC_MUTE_BEEP("Beep Playback Switch", 0, 0, HDA_INPUT),
1113 };
1114
1115 /* set up and create beep controls */
1116 static int set_beep_amp(struct alc_spec *spec, hda_nid_t nid,
1117                         int idx, int dir)
1118 {
1119         struct snd_kcontrol_new *knew;
1120         unsigned int beep_amp = HDA_COMPOSE_AMP_VAL(nid, 3, idx, dir);
1121         int i;
1122
1123         for (i = 0; i < ARRAY_SIZE(alc_beep_mixer); i++) {
1124                 knew = snd_hda_gen_add_kctl(&spec->gen, NULL,
1125                                             &alc_beep_mixer[i]);
1126                 if (!knew)
1127                         return -ENOMEM;
1128                 knew->private_value = beep_amp;
1129         }
1130         return 0;
1131 }
1132
1133 static const struct snd_pci_quirk beep_allow_list[] = {
1134         SND_PCI_QUIRK(0x1043, 0x103c, "ASUS", 1),
1135         SND_PCI_QUIRK(0x1043, 0x115d, "ASUS", 1),
1136         SND_PCI_QUIRK(0x1043, 0x829f, "ASUS", 1),
1137         SND_PCI_QUIRK(0x1043, 0x8376, "EeePC", 1),
1138         SND_PCI_QUIRK(0x1043, 0x83ce, "EeePC", 1),
1139         SND_PCI_QUIRK(0x1043, 0x831a, "EeePC", 1),
1140         SND_PCI_QUIRK(0x1043, 0x834a, "EeePC", 1),
1141         SND_PCI_QUIRK(0x1458, 0xa002, "GA-MA790X", 1),
1142         SND_PCI_QUIRK(0x8086, 0xd613, "Intel", 1),
1143         /* denylist -- no beep available */
1144         SND_PCI_QUIRK(0x17aa, 0x309e, "Lenovo ThinkCentre M73", 0),
1145         SND_PCI_QUIRK(0x17aa, 0x30a3, "Lenovo ThinkCentre M93", 0),
1146         {}
1147 };
1148
1149 static inline int has_cdefine_beep(struct hda_codec *codec)
1150 {
1151         struct alc_spec *spec = codec->spec;
1152         const struct snd_pci_quirk *q;
1153         q = snd_pci_quirk_lookup(codec->bus->pci, beep_allow_list);
1154         if (q)
1155                 return q->value;
1156         return spec->cdefine.enable_pcbeep;
1157 }
1158 #else
1159 #define set_beep_amp(spec, nid, idx, dir)       0
1160 #define has_cdefine_beep(codec)         0
1161 #endif
1162
1163 /* parse the BIOS configuration and set up the alc_spec */
1164 /* return 1 if successful, 0 if the proper config is not found,
1165  * or a negative error code
1166  */
1167 static int alc_parse_auto_config(struct hda_codec *codec,
1168                                  const hda_nid_t *ignore_nids,
1169                                  const hda_nid_t *ssid_nids)
1170 {
1171         struct alc_spec *spec = codec->spec;
1172         struct auto_pin_cfg *cfg = &spec->gen.autocfg;
1173         int err;
1174
1175         err = snd_hda_parse_pin_defcfg(codec, cfg, ignore_nids,
1176                                        spec->parse_flags);
1177         if (err < 0)
1178                 return err;
1179
1180         if (ssid_nids)
1181                 alc_ssid_check(codec, ssid_nids);
1182
1183         err = snd_hda_gen_parse_auto_config(codec, cfg);
1184         if (err < 0)
1185                 return err;
1186
1187         return 1;
1188 }
1189
1190 /* common preparation job for alc_spec */
1191 static int alc_alloc_spec(struct hda_codec *codec, hda_nid_t mixer_nid)
1192 {
1193         struct alc_spec *spec = kzalloc(sizeof(*spec), GFP_KERNEL);
1194         int err;
1195
1196         if (!spec)
1197                 return -ENOMEM;
1198         codec->spec = spec;
1199         snd_hda_gen_spec_init(&spec->gen);
1200         spec->gen.mixer_nid = mixer_nid;
1201         spec->gen.own_eapd_ctl = 1;
1202         codec->single_adc_amp = 1;
1203         /* FIXME: do we need this for all Realtek codec models? */
1204         codec->spdif_status_reset = 1;
1205         codec->forced_resume = 1;
1206         codec->patch_ops = alc_patch_ops;
1207         mutex_init(&spec->coef_mutex);
1208
1209         err = alc_codec_rename_from_preset(codec);
1210         if (err < 0) {
1211                 kfree(spec);
1212                 return err;
1213         }
1214         return 0;
1215 }
1216
1217 static int alc880_parse_auto_config(struct hda_codec *codec)
1218 {
1219         static const hda_nid_t alc880_ignore[] = { 0x1d, 0 };
1220         static const hda_nid_t alc880_ssids[] = { 0x15, 0x1b, 0x14, 0 };
1221         return alc_parse_auto_config(codec, alc880_ignore, alc880_ssids);
1222 }
1223
1224 /*
1225  * ALC880 fix-ups
1226  */
1227 enum {
1228         ALC880_FIXUP_GPIO1,
1229         ALC880_FIXUP_GPIO2,
1230         ALC880_FIXUP_MEDION_RIM,
1231         ALC880_FIXUP_LG,
1232         ALC880_FIXUP_LG_LW25,
1233         ALC880_FIXUP_W810,
1234         ALC880_FIXUP_EAPD_COEF,
1235         ALC880_FIXUP_TCL_S700,
1236         ALC880_FIXUP_VOL_KNOB,
1237         ALC880_FIXUP_FUJITSU,
1238         ALC880_FIXUP_F1734,
1239         ALC880_FIXUP_UNIWILL,
1240         ALC880_FIXUP_UNIWILL_DIG,
1241         ALC880_FIXUP_Z71V,
1242         ALC880_FIXUP_ASUS_W5A,
1243         ALC880_FIXUP_3ST_BASE,
1244         ALC880_FIXUP_3ST,
1245         ALC880_FIXUP_3ST_DIG,
1246         ALC880_FIXUP_5ST_BASE,
1247         ALC880_FIXUP_5ST,
1248         ALC880_FIXUP_5ST_DIG,
1249         ALC880_FIXUP_6ST_BASE,
1250         ALC880_FIXUP_6ST,
1251         ALC880_FIXUP_6ST_DIG,
1252         ALC880_FIXUP_6ST_AUTOMUTE,
1253 };
1254
1255 /* enable the volume-knob widget support on NID 0x21 */
1256 static void alc880_fixup_vol_knob(struct hda_codec *codec,
1257                                   const struct hda_fixup *fix, int action)
1258 {
1259         if (action == HDA_FIXUP_ACT_PROBE)
1260                 snd_hda_jack_detect_enable_callback(codec, 0x21,
1261                                                     alc_update_knob_master);
1262 }
1263
1264 static const struct hda_fixup alc880_fixups[] = {
1265         [ALC880_FIXUP_GPIO1] = {
1266                 .type = HDA_FIXUP_FUNC,
1267                 .v.func = alc_fixup_gpio1,
1268         },
1269         [ALC880_FIXUP_GPIO2] = {
1270                 .type = HDA_FIXUP_FUNC,
1271                 .v.func = alc_fixup_gpio2,
1272         },
1273         [ALC880_FIXUP_MEDION_RIM] = {
1274                 .type = HDA_FIXUP_VERBS,
1275                 .v.verbs = (const struct hda_verb[]) {
1276                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x07 },
1277                         { 0x20, AC_VERB_SET_PROC_COEF,  0x3060 },
1278                         { }
1279                 },
1280                 .chained = true,
1281                 .chain_id = ALC880_FIXUP_GPIO2,
1282         },
1283         [ALC880_FIXUP_LG] = {
1284                 .type = HDA_FIXUP_PINS,
1285                 .v.pins = (const struct hda_pintbl[]) {
1286                         /* disable bogus unused pins */
1287                         { 0x16, 0x411111f0 },
1288                         { 0x18, 0x411111f0 },
1289                         { 0x1a, 0x411111f0 },
1290                         { }
1291                 }
1292         },
1293         [ALC880_FIXUP_LG_LW25] = {
1294                 .type = HDA_FIXUP_PINS,
1295                 .v.pins = (const struct hda_pintbl[]) {
1296                         { 0x1a, 0x0181344f }, /* line-in */
1297                         { 0x1b, 0x0321403f }, /* headphone */
1298                         { }
1299                 }
1300         },
1301         [ALC880_FIXUP_W810] = {
1302                 .type = HDA_FIXUP_PINS,
1303                 .v.pins = (const struct hda_pintbl[]) {
1304                         /* disable bogus unused pins */
1305                         { 0x17, 0x411111f0 },
1306                         { }
1307                 },
1308                 .chained = true,
1309                 .chain_id = ALC880_FIXUP_GPIO2,
1310         },
1311         [ALC880_FIXUP_EAPD_COEF] = {
1312                 .type = HDA_FIXUP_VERBS,
1313                 .v.verbs = (const struct hda_verb[]) {
1314                         /* change to EAPD mode */
1315                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x07 },
1316                         { 0x20, AC_VERB_SET_PROC_COEF,  0x3060 },
1317                         {}
1318                 },
1319         },
1320         [ALC880_FIXUP_TCL_S700] = {
1321                 .type = HDA_FIXUP_VERBS,
1322                 .v.verbs = (const struct hda_verb[]) {
1323                         /* change to EAPD mode */
1324                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x07 },
1325                         { 0x20, AC_VERB_SET_PROC_COEF,  0x3070 },
1326                         {}
1327                 },
1328                 .chained = true,
1329                 .chain_id = ALC880_FIXUP_GPIO2,
1330         },
1331         [ALC880_FIXUP_VOL_KNOB] = {
1332                 .type = HDA_FIXUP_FUNC,
1333                 .v.func = alc880_fixup_vol_knob,
1334         },
1335         [ALC880_FIXUP_FUJITSU] = {
1336                 /* override all pins as BIOS on old Amilo is broken */
1337                 .type = HDA_FIXUP_PINS,
1338                 .v.pins = (const struct hda_pintbl[]) {
1339                         { 0x14, 0x0121401f }, /* HP */
1340                         { 0x15, 0x99030120 }, /* speaker */
1341                         { 0x16, 0x99030130 }, /* bass speaker */
1342                         { 0x17, 0x411111f0 }, /* N/A */
1343                         { 0x18, 0x411111f0 }, /* N/A */
1344                         { 0x19, 0x01a19950 }, /* mic-in */
1345                         { 0x1a, 0x411111f0 }, /* N/A */
1346                         { 0x1b, 0x411111f0 }, /* N/A */
1347                         { 0x1c, 0x411111f0 }, /* N/A */
1348                         { 0x1d, 0x411111f0 }, /* N/A */
1349                         { 0x1e, 0x01454140 }, /* SPDIF out */
1350                         { }
1351                 },
1352                 .chained = true,
1353                 .chain_id = ALC880_FIXUP_VOL_KNOB,
1354         },
1355         [ALC880_FIXUP_F1734] = {
1356                 /* almost compatible with FUJITSU, but no bass and SPDIF */
1357                 .type = HDA_FIXUP_PINS,
1358                 .v.pins = (const struct hda_pintbl[]) {
1359                         { 0x14, 0x0121401f }, /* HP */
1360                         { 0x15, 0x99030120 }, /* speaker */
1361                         { 0x16, 0x411111f0 }, /* N/A */
1362                         { 0x17, 0x411111f0 }, /* N/A */
1363                         { 0x18, 0x411111f0 }, /* N/A */
1364                         { 0x19, 0x01a19950 }, /* mic-in */
1365                         { 0x1a, 0x411111f0 }, /* N/A */
1366                         { 0x1b, 0x411111f0 }, /* N/A */
1367                         { 0x1c, 0x411111f0 }, /* N/A */
1368                         { 0x1d, 0x411111f0 }, /* N/A */
1369                         { 0x1e, 0x411111f0 }, /* N/A */
1370                         { }
1371                 },
1372                 .chained = true,
1373                 .chain_id = ALC880_FIXUP_VOL_KNOB,
1374         },
1375         [ALC880_FIXUP_UNIWILL] = {
1376                 /* need to fix HP and speaker pins to be parsed correctly */
1377                 .type = HDA_FIXUP_PINS,
1378                 .v.pins = (const struct hda_pintbl[]) {
1379                         { 0x14, 0x0121411f }, /* HP */
1380                         { 0x15, 0x99030120 }, /* speaker */
1381                         { 0x16, 0x99030130 }, /* bass speaker */
1382                         { }
1383                 },
1384         },
1385         [ALC880_FIXUP_UNIWILL_DIG] = {
1386                 .type = HDA_FIXUP_PINS,
1387                 .v.pins = (const struct hda_pintbl[]) {
1388                         /* disable bogus unused pins */
1389                         { 0x17, 0x411111f0 },
1390                         { 0x19, 0x411111f0 },
1391                         { 0x1b, 0x411111f0 },
1392                         { 0x1f, 0x411111f0 },
1393                         { }
1394                 }
1395         },
1396         [ALC880_FIXUP_Z71V] = {
1397                 .type = HDA_FIXUP_PINS,
1398                 .v.pins = (const struct hda_pintbl[]) {
1399                         /* set up the whole pins as BIOS is utterly broken */
1400                         { 0x14, 0x99030120 }, /* speaker */
1401                         { 0x15, 0x0121411f }, /* HP */
1402                         { 0x16, 0x411111f0 }, /* N/A */
1403                         { 0x17, 0x411111f0 }, /* N/A */
1404                         { 0x18, 0x01a19950 }, /* mic-in */
1405                         { 0x19, 0x411111f0 }, /* N/A */
1406                         { 0x1a, 0x01813031 }, /* line-in */
1407                         { 0x1b, 0x411111f0 }, /* N/A */
1408                         { 0x1c, 0x411111f0 }, /* N/A */
1409                         { 0x1d, 0x411111f0 }, /* N/A */
1410                         { 0x1e, 0x0144111e }, /* SPDIF */
1411                         { }
1412                 }
1413         },
1414         [ALC880_FIXUP_ASUS_W5A] = {
1415                 .type = HDA_FIXUP_PINS,
1416                 .v.pins = (const struct hda_pintbl[]) {
1417                         /* set up the whole pins as BIOS is utterly broken */
1418                         { 0x14, 0x0121411f }, /* HP */
1419                         { 0x15, 0x411111f0 }, /* N/A */
1420                         { 0x16, 0x411111f0 }, /* N/A */
1421                         { 0x17, 0x411111f0 }, /* N/A */
1422                         { 0x18, 0x90a60160 }, /* mic */
1423                         { 0x19, 0x411111f0 }, /* N/A */
1424                         { 0x1a, 0x411111f0 }, /* N/A */
1425                         { 0x1b, 0x411111f0 }, /* N/A */
1426                         { 0x1c, 0x411111f0 }, /* N/A */
1427                         { 0x1d, 0x411111f0 }, /* N/A */
1428                         { 0x1e, 0xb743111e }, /* SPDIF out */
1429                         { }
1430                 },
1431                 .chained = true,
1432                 .chain_id = ALC880_FIXUP_GPIO1,
1433         },
1434         [ALC880_FIXUP_3ST_BASE] = {
1435                 .type = HDA_FIXUP_PINS,
1436                 .v.pins = (const struct hda_pintbl[]) {
1437                         { 0x14, 0x01014010 }, /* line-out */
1438                         { 0x15, 0x411111f0 }, /* N/A */
1439                         { 0x16, 0x411111f0 }, /* N/A */
1440                         { 0x17, 0x411111f0 }, /* N/A */
1441                         { 0x18, 0x01a19c30 }, /* mic-in */
1442                         { 0x19, 0x0121411f }, /* HP */
1443                         { 0x1a, 0x01813031 }, /* line-in */
1444                         { 0x1b, 0x02a19c40 }, /* front-mic */
1445                         { 0x1c, 0x411111f0 }, /* N/A */
1446                         { 0x1d, 0x411111f0 }, /* N/A */
1447                         /* 0x1e is filled in below */
1448                         { 0x1f, 0x411111f0 }, /* N/A */
1449                         { }
1450                 }
1451         },
1452         [ALC880_FIXUP_3ST] = {
1453                 .type = HDA_FIXUP_PINS,
1454                 .v.pins = (const struct hda_pintbl[]) {
1455                         { 0x1e, 0x411111f0 }, /* N/A */
1456                         { }
1457                 },
1458                 .chained = true,
1459                 .chain_id = ALC880_FIXUP_3ST_BASE,
1460         },
1461         [ALC880_FIXUP_3ST_DIG] = {
1462                 .type = HDA_FIXUP_PINS,
1463                 .v.pins = (const struct hda_pintbl[]) {
1464                         { 0x1e, 0x0144111e }, /* SPDIF */
1465                         { }
1466                 },
1467                 .chained = true,
1468                 .chain_id = ALC880_FIXUP_3ST_BASE,
1469         },
1470         [ALC880_FIXUP_5ST_BASE] = {
1471                 .type = HDA_FIXUP_PINS,
1472                 .v.pins = (const struct hda_pintbl[]) {
1473                         { 0x14, 0x01014010 }, /* front */
1474                         { 0x15, 0x411111f0 }, /* N/A */
1475                         { 0x16, 0x01011411 }, /* CLFE */
1476                         { 0x17, 0x01016412 }, /* surr */
1477                         { 0x18, 0x01a19c30 }, /* mic-in */
1478                         { 0x19, 0x0121411f }, /* HP */
1479                         { 0x1a, 0x01813031 }, /* line-in */
1480                         { 0x1b, 0x02a19c40 }, /* front-mic */
1481                         { 0x1c, 0x411111f0 }, /* N/A */
1482                         { 0x1d, 0x411111f0 }, /* N/A */
1483                         /* 0x1e is filled in below */
1484                         { 0x1f, 0x411111f0 }, /* N/A */
1485                         { }
1486                 }
1487         },
1488         [ALC880_FIXUP_5ST] = {
1489                 .type = HDA_FIXUP_PINS,
1490                 .v.pins = (const struct hda_pintbl[]) {
1491                         { 0x1e, 0x411111f0 }, /* N/A */
1492                         { }
1493                 },
1494                 .chained = true,
1495                 .chain_id = ALC880_FIXUP_5ST_BASE,
1496         },
1497         [ALC880_FIXUP_5ST_DIG] = {
1498                 .type = HDA_FIXUP_PINS,
1499                 .v.pins = (const struct hda_pintbl[]) {
1500                         { 0x1e, 0x0144111e }, /* SPDIF */
1501                         { }
1502                 },
1503                 .chained = true,
1504                 .chain_id = ALC880_FIXUP_5ST_BASE,
1505         },
1506         [ALC880_FIXUP_6ST_BASE] = {
1507                 .type = HDA_FIXUP_PINS,
1508                 .v.pins = (const struct hda_pintbl[]) {
1509                         { 0x14, 0x01014010 }, /* front */
1510                         { 0x15, 0x01016412 }, /* surr */
1511                         { 0x16, 0x01011411 }, /* CLFE */
1512                         { 0x17, 0x01012414 }, /* side */
1513                         { 0x18, 0x01a19c30 }, /* mic-in */
1514                         { 0x19, 0x02a19c40 }, /* front-mic */
1515                         { 0x1a, 0x01813031 }, /* line-in */
1516                         { 0x1b, 0x0121411f }, /* HP */
1517                         { 0x1c, 0x411111f0 }, /* N/A */
1518                         { 0x1d, 0x411111f0 }, /* N/A */
1519                         /* 0x1e is filled in below */
1520                         { 0x1f, 0x411111f0 }, /* N/A */
1521                         { }
1522                 }
1523         },
1524         [ALC880_FIXUP_6ST] = {
1525                 .type = HDA_FIXUP_PINS,
1526                 .v.pins = (const struct hda_pintbl[]) {
1527                         { 0x1e, 0x411111f0 }, /* N/A */
1528                         { }
1529                 },
1530                 .chained = true,
1531                 .chain_id = ALC880_FIXUP_6ST_BASE,
1532         },
1533         [ALC880_FIXUP_6ST_DIG] = {
1534                 .type = HDA_FIXUP_PINS,
1535                 .v.pins = (const struct hda_pintbl[]) {
1536                         { 0x1e, 0x0144111e }, /* SPDIF */
1537                         { }
1538                 },
1539                 .chained = true,
1540                 .chain_id = ALC880_FIXUP_6ST_BASE,
1541         },
1542         [ALC880_FIXUP_6ST_AUTOMUTE] = {
1543                 .type = HDA_FIXUP_PINS,
1544                 .v.pins = (const struct hda_pintbl[]) {
1545                         { 0x1b, 0x0121401f }, /* HP with jack detect */
1546                         { }
1547                 },
1548                 .chained_before = true,
1549                 .chain_id = ALC880_FIXUP_6ST_BASE,
1550         },
1551 };
1552
1553 static const struct snd_pci_quirk alc880_fixup_tbl[] = {
1554         SND_PCI_QUIRK(0x1019, 0x0f69, "Coeus G610P", ALC880_FIXUP_W810),
1555         SND_PCI_QUIRK(0x1043, 0x10c3, "ASUS W5A", ALC880_FIXUP_ASUS_W5A),
1556         SND_PCI_QUIRK(0x1043, 0x1964, "ASUS Z71V", ALC880_FIXUP_Z71V),
1557         SND_PCI_QUIRK_VENDOR(0x1043, "ASUS", ALC880_FIXUP_GPIO1),
1558         SND_PCI_QUIRK(0x147b, 0x1045, "ABit AA8XE", ALC880_FIXUP_6ST_AUTOMUTE),
1559         SND_PCI_QUIRK(0x1558, 0x5401, "Clevo GPIO2", ALC880_FIXUP_GPIO2),
1560         SND_PCI_QUIRK_VENDOR(0x1558, "Clevo", ALC880_FIXUP_EAPD_COEF),
1561         SND_PCI_QUIRK(0x1584, 0x9050, "Uniwill", ALC880_FIXUP_UNIWILL_DIG),
1562         SND_PCI_QUIRK(0x1584, 0x9054, "Uniwill", ALC880_FIXUP_F1734),
1563         SND_PCI_QUIRK(0x1584, 0x9070, "Uniwill", ALC880_FIXUP_UNIWILL),
1564         SND_PCI_QUIRK(0x1584, 0x9077, "Uniwill P53", ALC880_FIXUP_VOL_KNOB),
1565         SND_PCI_QUIRK(0x161f, 0x203d, "W810", ALC880_FIXUP_W810),
1566         SND_PCI_QUIRK(0x161f, 0x205d, "Medion Rim 2150", ALC880_FIXUP_MEDION_RIM),
1567         SND_PCI_QUIRK(0x1631, 0xe011, "PB 13201056", ALC880_FIXUP_6ST_AUTOMUTE),
1568         SND_PCI_QUIRK(0x1734, 0x107c, "FSC Amilo M1437", ALC880_FIXUP_FUJITSU),
1569         SND_PCI_QUIRK(0x1734, 0x1094, "FSC Amilo M1451G", ALC880_FIXUP_FUJITSU),
1570         SND_PCI_QUIRK(0x1734, 0x10ac, "FSC AMILO Xi 1526", ALC880_FIXUP_F1734),
1571         SND_PCI_QUIRK(0x1734, 0x10b0, "FSC Amilo Pi1556", ALC880_FIXUP_FUJITSU),
1572         SND_PCI_QUIRK(0x1854, 0x003b, "LG", ALC880_FIXUP_LG),
1573         SND_PCI_QUIRK(0x1854, 0x005f, "LG P1 Express", ALC880_FIXUP_LG),
1574         SND_PCI_QUIRK(0x1854, 0x0068, "LG w1", ALC880_FIXUP_LG),
1575         SND_PCI_QUIRK(0x1854, 0x0077, "LG LW25", ALC880_FIXUP_LG_LW25),
1576         SND_PCI_QUIRK(0x19db, 0x4188, "TCL S700", ALC880_FIXUP_TCL_S700),
1577
1578         /* Below is the copied entries from alc880_quirks.c.
1579          * It's not quite sure whether BIOS sets the correct pin-config table
1580          * on these machines, thus they are kept to be compatible with
1581          * the old static quirks.  Once when it's confirmed to work without
1582          * these overrides, it'd be better to remove.
1583          */
1584         SND_PCI_QUIRK(0x1019, 0xa880, "ECS", ALC880_FIXUP_5ST_DIG),
1585         SND_PCI_QUIRK(0x1019, 0xa884, "Acer APFV", ALC880_FIXUP_6ST),
1586         SND_PCI_QUIRK(0x1025, 0x0070, "ULI", ALC880_FIXUP_3ST_DIG),
1587         SND_PCI_QUIRK(0x1025, 0x0077, "ULI", ALC880_FIXUP_6ST_DIG),
1588         SND_PCI_QUIRK(0x1025, 0x0078, "ULI", ALC880_FIXUP_6ST_DIG),
1589         SND_PCI_QUIRK(0x1025, 0x0087, "ULI", ALC880_FIXUP_6ST_DIG),
1590         SND_PCI_QUIRK(0x1025, 0xe309, "ULI", ALC880_FIXUP_3ST_DIG),
1591         SND_PCI_QUIRK(0x1025, 0xe310, "ULI", ALC880_FIXUP_3ST),
1592         SND_PCI_QUIRK(0x1039, 0x1234, NULL, ALC880_FIXUP_6ST_DIG),
1593         SND_PCI_QUIRK(0x104d, 0x81a0, "Sony", ALC880_FIXUP_3ST),
1594         SND_PCI_QUIRK(0x104d, 0x81d6, "Sony", ALC880_FIXUP_3ST),
1595         SND_PCI_QUIRK(0x107b, 0x3032, "Gateway", ALC880_FIXUP_5ST),
1596         SND_PCI_QUIRK(0x107b, 0x3033, "Gateway", ALC880_FIXUP_5ST),
1597         SND_PCI_QUIRK(0x107b, 0x4039, "Gateway", ALC880_FIXUP_5ST),
1598         SND_PCI_QUIRK(0x1297, 0xc790, "Shuttle ST20G5", ALC880_FIXUP_6ST_DIG),
1599         SND_PCI_QUIRK(0x1458, 0xa102, "Gigabyte K8", ALC880_FIXUP_6ST_DIG),
1600         SND_PCI_QUIRK(0x1462, 0x1150, "MSI", ALC880_FIXUP_6ST_DIG),
1601         SND_PCI_QUIRK(0x1509, 0x925d, "FIC P4M", ALC880_FIXUP_6ST_DIG),
1602         SND_PCI_QUIRK(0x1565, 0x8202, "Biostar", ALC880_FIXUP_5ST_DIG),
1603         SND_PCI_QUIRK(0x1695, 0x400d, "EPoX", ALC880_FIXUP_5ST_DIG),
1604         SND_PCI_QUIRK(0x1695, 0x4012, "EPox EP-5LDA", ALC880_FIXUP_5ST_DIG),
1605         SND_PCI_QUIRK(0x2668, 0x8086, NULL, ALC880_FIXUP_6ST_DIG), /* broken BIOS */
1606         SND_PCI_QUIRK(0x8086, 0x2668, NULL, ALC880_FIXUP_6ST_DIG),
1607         SND_PCI_QUIRK(0x8086, 0xa100, "Intel mobo", ALC880_FIXUP_5ST_DIG),
1608         SND_PCI_QUIRK(0x8086, 0xd400, "Intel mobo", ALC880_FIXUP_5ST_DIG),
1609         SND_PCI_QUIRK(0x8086, 0xd401, "Intel mobo", ALC880_FIXUP_5ST_DIG),
1610         SND_PCI_QUIRK(0x8086, 0xd402, "Intel mobo", ALC880_FIXUP_3ST_DIG),
1611         SND_PCI_QUIRK(0x8086, 0xe224, "Intel mobo", ALC880_FIXUP_5ST_DIG),
1612         SND_PCI_QUIRK(0x8086, 0xe305, "Intel mobo", ALC880_FIXUP_3ST_DIG),
1613         SND_PCI_QUIRK(0x8086, 0xe308, "Intel mobo", ALC880_FIXUP_3ST_DIG),
1614         SND_PCI_QUIRK(0x8086, 0xe400, "Intel mobo", ALC880_FIXUP_5ST_DIG),
1615         SND_PCI_QUIRK(0x8086, 0xe401, "Intel mobo", ALC880_FIXUP_5ST_DIG),
1616         SND_PCI_QUIRK(0x8086, 0xe402, "Intel mobo", ALC880_FIXUP_5ST_DIG),
1617         /* default Intel */
1618         SND_PCI_QUIRK_VENDOR(0x8086, "Intel mobo", ALC880_FIXUP_3ST),
1619         SND_PCI_QUIRK(0xa0a0, 0x0560, "AOpen i915GMm-HFS", ALC880_FIXUP_5ST_DIG),
1620         SND_PCI_QUIRK(0xe803, 0x1019, NULL, ALC880_FIXUP_6ST_DIG),
1621         {}
1622 };
1623
1624 static const struct hda_model_fixup alc880_fixup_models[] = {
1625         {.id = ALC880_FIXUP_3ST, .name = "3stack"},
1626         {.id = ALC880_FIXUP_3ST_DIG, .name = "3stack-digout"},
1627         {.id = ALC880_FIXUP_5ST, .name = "5stack"},
1628         {.id = ALC880_FIXUP_5ST_DIG, .name = "5stack-digout"},
1629         {.id = ALC880_FIXUP_6ST, .name = "6stack"},
1630         {.id = ALC880_FIXUP_6ST_DIG, .name = "6stack-digout"},
1631         {.id = ALC880_FIXUP_6ST_AUTOMUTE, .name = "6stack-automute"},
1632         {}
1633 };
1634
1635
1636 /*
1637  * OK, here we have finally the patch for ALC880
1638  */
1639 static int patch_alc880(struct hda_codec *codec)
1640 {
1641         struct alc_spec *spec;
1642         int err;
1643
1644         err = alc_alloc_spec(codec, 0x0b);
1645         if (err < 0)
1646                 return err;
1647
1648         spec = codec->spec;
1649         spec->gen.need_dac_fix = 1;
1650         spec->gen.beep_nid = 0x01;
1651
1652         codec->patch_ops.unsol_event = alc880_unsol_event;
1653
1654         alc_pre_init(codec);
1655
1656         snd_hda_pick_fixup(codec, alc880_fixup_models, alc880_fixup_tbl,
1657                        alc880_fixups);
1658         snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE);
1659
1660         /* automatic parse from the BIOS config */
1661         err = alc880_parse_auto_config(codec);
1662         if (err < 0)
1663                 goto error;
1664
1665         if (!spec->gen.no_analog) {
1666                 err = set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
1667                 if (err < 0)
1668                         goto error;
1669         }
1670
1671         snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE);
1672
1673         return 0;
1674
1675  error:
1676         alc_free(codec);
1677         return err;
1678 }
1679
1680
1681 /*
1682  * ALC260 support
1683  */
1684 static int alc260_parse_auto_config(struct hda_codec *codec)
1685 {
1686         static const hda_nid_t alc260_ignore[] = { 0x17, 0 };
1687         static const hda_nid_t alc260_ssids[] = { 0x10, 0x15, 0x0f, 0 };
1688         return alc_parse_auto_config(codec, alc260_ignore, alc260_ssids);
1689 }
1690
1691 /*
1692  * Pin config fixes
1693  */
1694 enum {
1695         ALC260_FIXUP_HP_DC5750,
1696         ALC260_FIXUP_HP_PIN_0F,
1697         ALC260_FIXUP_COEF,
1698         ALC260_FIXUP_GPIO1,
1699         ALC260_FIXUP_GPIO1_TOGGLE,
1700         ALC260_FIXUP_REPLACER,
1701         ALC260_FIXUP_HP_B1900,
1702         ALC260_FIXUP_KN1,
1703         ALC260_FIXUP_FSC_S7020,
1704         ALC260_FIXUP_FSC_S7020_JWSE,
1705         ALC260_FIXUP_VAIO_PINS,
1706 };
1707
1708 static void alc260_gpio1_automute(struct hda_codec *codec)
1709 {
1710         struct alc_spec *spec = codec->spec;
1711
1712         alc_update_gpio_data(codec, 0x01, spec->gen.hp_jack_present);
1713 }
1714
1715 static void alc260_fixup_gpio1_toggle(struct hda_codec *codec,
1716                                       const struct hda_fixup *fix, int action)
1717 {
1718         struct alc_spec *spec = codec->spec;
1719         if (action == HDA_FIXUP_ACT_PROBE) {
1720                 /* although the machine has only one output pin, we need to
1721                  * toggle GPIO1 according to the jack state
1722                  */
1723                 spec->gen.automute_hook = alc260_gpio1_automute;
1724                 spec->gen.detect_hp = 1;
1725                 spec->gen.automute_speaker = 1;
1726                 spec->gen.autocfg.hp_pins[0] = 0x0f; /* copy it for automute */
1727                 snd_hda_jack_detect_enable_callback(codec, 0x0f,
1728                                                     snd_hda_gen_hp_automute);
1729                 alc_setup_gpio(codec, 0x01);
1730         }
1731 }
1732
1733 static void alc260_fixup_kn1(struct hda_codec *codec,
1734                              const struct hda_fixup *fix, int action)
1735 {
1736         struct alc_spec *spec = codec->spec;
1737         static const struct hda_pintbl pincfgs[] = {
1738                 { 0x0f, 0x02214000 }, /* HP/speaker */
1739                 { 0x12, 0x90a60160 }, /* int mic */
1740                 { 0x13, 0x02a19000 }, /* ext mic */
1741                 { 0x18, 0x01446000 }, /* SPDIF out */
1742                 /* disable bogus I/O pins */
1743                 { 0x10, 0x411111f0 },
1744                 { 0x11, 0x411111f0 },
1745                 { 0x14, 0x411111f0 },
1746                 { 0x15, 0x411111f0 },
1747                 { 0x16, 0x411111f0 },
1748                 { 0x17, 0x411111f0 },
1749                 { 0x19, 0x411111f0 },
1750                 { }
1751         };
1752
1753         switch (action) {
1754         case HDA_FIXUP_ACT_PRE_PROBE:
1755                 snd_hda_apply_pincfgs(codec, pincfgs);
1756                 spec->init_amp = ALC_INIT_NONE;
1757                 break;
1758         }
1759 }
1760
1761 static void alc260_fixup_fsc_s7020(struct hda_codec *codec,
1762                                    const struct hda_fixup *fix, int action)
1763 {
1764         struct alc_spec *spec = codec->spec;
1765         if (action == HDA_FIXUP_ACT_PRE_PROBE)
1766                 spec->init_amp = ALC_INIT_NONE;
1767 }
1768
1769 static void alc260_fixup_fsc_s7020_jwse(struct hda_codec *codec,
1770                                    const struct hda_fixup *fix, int action)
1771 {
1772         struct alc_spec *spec = codec->spec;
1773         if (action == HDA_FIXUP_ACT_PRE_PROBE) {
1774                 spec->gen.add_jack_modes = 1;
1775                 spec->gen.hp_mic = 1;
1776         }
1777 }
1778
1779 static const struct hda_fixup alc260_fixups[] = {
1780         [ALC260_FIXUP_HP_DC5750] = {
1781                 .type = HDA_FIXUP_PINS,
1782                 .v.pins = (const struct hda_pintbl[]) {
1783                         { 0x11, 0x90130110 }, /* speaker */
1784                         { }
1785                 }
1786         },
1787         [ALC260_FIXUP_HP_PIN_0F] = {
1788                 .type = HDA_FIXUP_PINS,
1789                 .v.pins = (const struct hda_pintbl[]) {
1790                         { 0x0f, 0x01214000 }, /* HP */
1791                         { }
1792                 }
1793         },
1794         [ALC260_FIXUP_COEF] = {
1795                 .type = HDA_FIXUP_VERBS,
1796                 .v.verbs = (const struct hda_verb[]) {
1797                         { 0x1a, AC_VERB_SET_COEF_INDEX, 0x07 },
1798                         { 0x1a, AC_VERB_SET_PROC_COEF,  0x3040 },
1799                         { }
1800                 },
1801         },
1802         [ALC260_FIXUP_GPIO1] = {
1803                 .type = HDA_FIXUP_FUNC,
1804                 .v.func = alc_fixup_gpio1,
1805         },
1806         [ALC260_FIXUP_GPIO1_TOGGLE] = {
1807                 .type = HDA_FIXUP_FUNC,
1808                 .v.func = alc260_fixup_gpio1_toggle,
1809                 .chained = true,
1810                 .chain_id = ALC260_FIXUP_HP_PIN_0F,
1811         },
1812         [ALC260_FIXUP_REPLACER] = {
1813                 .type = HDA_FIXUP_VERBS,
1814                 .v.verbs = (const struct hda_verb[]) {
1815                         { 0x1a, AC_VERB_SET_COEF_INDEX, 0x07 },
1816                         { 0x1a, AC_VERB_SET_PROC_COEF,  0x3050 },
1817                         { }
1818                 },
1819                 .chained = true,
1820                 .chain_id = ALC260_FIXUP_GPIO1_TOGGLE,
1821         },
1822         [ALC260_FIXUP_HP_B1900] = {
1823                 .type = HDA_FIXUP_FUNC,
1824                 .v.func = alc260_fixup_gpio1_toggle,
1825                 .chained = true,
1826                 .chain_id = ALC260_FIXUP_COEF,
1827         },
1828         [ALC260_FIXUP_KN1] = {
1829                 .type = HDA_FIXUP_FUNC,
1830                 .v.func = alc260_fixup_kn1,
1831         },
1832         [ALC260_FIXUP_FSC_S7020] = {
1833                 .type = HDA_FIXUP_FUNC,
1834                 .v.func = alc260_fixup_fsc_s7020,
1835         },
1836         [ALC260_FIXUP_FSC_S7020_JWSE] = {
1837                 .type = HDA_FIXUP_FUNC,
1838                 .v.func = alc260_fixup_fsc_s7020_jwse,
1839                 .chained = true,
1840                 .chain_id = ALC260_FIXUP_FSC_S7020,
1841         },
1842         [ALC260_FIXUP_VAIO_PINS] = {
1843                 .type = HDA_FIXUP_PINS,
1844                 .v.pins = (const struct hda_pintbl[]) {
1845                         /* Pin configs are missing completely on some VAIOs */
1846                         { 0x0f, 0x01211020 },
1847                         { 0x10, 0x0001003f },
1848                         { 0x11, 0x411111f0 },
1849                         { 0x12, 0x01a15930 },
1850                         { 0x13, 0x411111f0 },
1851                         { 0x14, 0x411111f0 },
1852                         { 0x15, 0x411111f0 },
1853                         { 0x16, 0x411111f0 },
1854                         { 0x17, 0x411111f0 },
1855                         { 0x18, 0x411111f0 },
1856                         { 0x19, 0x411111f0 },
1857                         { }
1858                 }
1859         },
1860 };
1861
1862 static const struct snd_pci_quirk alc260_fixup_tbl[] = {
1863         SND_PCI_QUIRK(0x1025, 0x007b, "Acer C20x", ALC260_FIXUP_GPIO1),
1864         SND_PCI_QUIRK(0x1025, 0x007f, "Acer Aspire 9500", ALC260_FIXUP_COEF),
1865         SND_PCI_QUIRK(0x1025, 0x008f, "Acer", ALC260_FIXUP_GPIO1),
1866         SND_PCI_QUIRK(0x103c, 0x280a, "HP dc5750", ALC260_FIXUP_HP_DC5750),
1867         SND_PCI_QUIRK(0x103c, 0x30ba, "HP Presario B1900", ALC260_FIXUP_HP_B1900),
1868         SND_PCI_QUIRK(0x104d, 0x81bb, "Sony VAIO", ALC260_FIXUP_VAIO_PINS),
1869         SND_PCI_QUIRK(0x104d, 0x81e2, "Sony VAIO TX", ALC260_FIXUP_HP_PIN_0F),
1870         SND_PCI_QUIRK(0x10cf, 0x1326, "FSC LifeBook S7020", ALC260_FIXUP_FSC_S7020),
1871         SND_PCI_QUIRK(0x1509, 0x4540, "Favorit 100XS", ALC260_FIXUP_GPIO1),
1872         SND_PCI_QUIRK(0x152d, 0x0729, "Quanta KN1", ALC260_FIXUP_KN1),
1873         SND_PCI_QUIRK(0x161f, 0x2057, "Replacer 672V", ALC260_FIXUP_REPLACER),
1874         SND_PCI_QUIRK(0x1631, 0xc017, "PB V7900", ALC260_FIXUP_COEF),
1875         {}
1876 };
1877
1878 static const struct hda_model_fixup alc260_fixup_models[] = {
1879         {.id = ALC260_FIXUP_GPIO1, .name = "gpio1"},
1880         {.id = ALC260_FIXUP_COEF, .name = "coef"},
1881         {.id = ALC260_FIXUP_FSC_S7020, .name = "fujitsu"},
1882         {.id = ALC260_FIXUP_FSC_S7020_JWSE, .name = "fujitsu-jwse"},
1883         {}
1884 };
1885
1886 /*
1887  */
1888 static int patch_alc260(struct hda_codec *codec)
1889 {
1890         struct alc_spec *spec;
1891         int err;
1892
1893         err = alc_alloc_spec(codec, 0x07);
1894         if (err < 0)
1895                 return err;
1896
1897         spec = codec->spec;
1898         /* as quite a few machines require HP amp for speaker outputs,
1899          * it's easier to enable it unconditionally; even if it's unneeded,
1900          * it's almost harmless.
1901          */
1902         spec->gen.prefer_hp_amp = 1;
1903         spec->gen.beep_nid = 0x01;
1904
1905         spec->shutup = alc_eapd_shutup;
1906
1907         alc_pre_init(codec);
1908
1909         snd_hda_pick_fixup(codec, alc260_fixup_models, alc260_fixup_tbl,
1910                            alc260_fixups);
1911         snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE);
1912
1913         /* automatic parse from the BIOS config */
1914         err = alc260_parse_auto_config(codec);
1915         if (err < 0)
1916                 goto error;
1917
1918         if (!spec->gen.no_analog) {
1919                 err = set_beep_amp(spec, 0x07, 0x05, HDA_INPUT);
1920                 if (err < 0)
1921                         goto error;
1922         }
1923
1924         snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE);
1925
1926         return 0;
1927
1928  error:
1929         alc_free(codec);
1930         return err;
1931 }
1932
1933
1934 /*
1935  * ALC882/883/885/888/889 support
1936  *
1937  * ALC882 is almost identical with ALC880 but has cleaner and more flexible
1938  * configuration.  Each pin widget can choose any input DACs and a mixer.
1939  * Each ADC is connected from a mixer of all inputs.  This makes possible
1940  * 6-channel independent captures.
1941  *
1942  * In addition, an independent DAC for the multi-playback (not used in this
1943  * driver yet).
1944  */
1945
1946 /*
1947  * Pin config fixes
1948  */
1949 enum {
1950         ALC882_FIXUP_ABIT_AW9D_MAX,
1951         ALC882_FIXUP_LENOVO_Y530,
1952         ALC882_FIXUP_PB_M5210,
1953         ALC882_FIXUP_ACER_ASPIRE_7736,
1954         ALC882_FIXUP_ASUS_W90V,
1955         ALC889_FIXUP_CD,
1956         ALC889_FIXUP_FRONT_HP_NO_PRESENCE,
1957         ALC889_FIXUP_VAIO_TT,
1958         ALC888_FIXUP_EEE1601,
1959         ALC886_FIXUP_EAPD,
1960         ALC882_FIXUP_EAPD,
1961         ALC883_FIXUP_EAPD,
1962         ALC883_FIXUP_ACER_EAPD,
1963         ALC882_FIXUP_GPIO1,
1964         ALC882_FIXUP_GPIO2,
1965         ALC882_FIXUP_GPIO3,
1966         ALC889_FIXUP_COEF,
1967         ALC882_FIXUP_ASUS_W2JC,
1968         ALC882_FIXUP_ACER_ASPIRE_4930G,
1969         ALC882_FIXUP_ACER_ASPIRE_8930G,
1970         ALC882_FIXUP_ASPIRE_8930G_VERBS,
1971         ALC885_FIXUP_MACPRO_GPIO,
1972         ALC889_FIXUP_DAC_ROUTE,
1973         ALC889_FIXUP_MBP_VREF,
1974         ALC889_FIXUP_IMAC91_VREF,
1975         ALC889_FIXUP_MBA11_VREF,
1976         ALC889_FIXUP_MBA21_VREF,
1977         ALC889_FIXUP_MP11_VREF,
1978         ALC889_FIXUP_MP41_VREF,
1979         ALC882_FIXUP_INV_DMIC,
1980         ALC882_FIXUP_NO_PRIMARY_HP,
1981         ALC887_FIXUP_ASUS_BASS,
1982         ALC887_FIXUP_BASS_CHMAP,
1983         ALC1220_FIXUP_GB_DUAL_CODECS,
1984         ALC1220_FIXUP_GB_X570,
1985         ALC1220_FIXUP_CLEVO_P950,
1986         ALC1220_FIXUP_CLEVO_PB51ED,
1987         ALC1220_FIXUP_CLEVO_PB51ED_PINS,
1988         ALC887_FIXUP_ASUS_AUDIO,
1989         ALC887_FIXUP_ASUS_HMIC,
1990         ALCS1200A_FIXUP_MIC_VREF,
1991         ALC888VD_FIXUP_MIC_100VREF,
1992 };
1993
1994 static void alc889_fixup_coef(struct hda_codec *codec,
1995                               const struct hda_fixup *fix, int action)
1996 {
1997         if (action != HDA_FIXUP_ACT_INIT)
1998                 return;
1999         alc_update_coef_idx(codec, 7, 0, 0x2030);
2000 }
2001
2002 /* set up GPIO at initialization */
2003 static void alc885_fixup_macpro_gpio(struct hda_codec *codec,
2004                                      const struct hda_fixup *fix, int action)
2005 {
2006         struct alc_spec *spec = codec->spec;
2007
2008         spec->gpio_write_delay = true;
2009         alc_fixup_gpio3(codec, fix, action);
2010 }
2011
2012 /* Fix the connection of some pins for ALC889:
2013  * At least, Acer Aspire 5935 shows the connections to DAC3/4 don't
2014  * work correctly (bko#42740)
2015  */
2016 static void alc889_fixup_dac_route(struct hda_codec *codec,
2017                                    const struct hda_fixup *fix, int action)
2018 {
2019         if (action == HDA_FIXUP_ACT_PRE_PROBE) {
2020                 /* fake the connections during parsing the tree */
2021                 static const hda_nid_t conn1[] = { 0x0c, 0x0d };
2022                 static const hda_nid_t conn2[] = { 0x0e, 0x0f };
2023                 snd_hda_override_conn_list(codec, 0x14, ARRAY_SIZE(conn1), conn1);
2024                 snd_hda_override_conn_list(codec, 0x15, ARRAY_SIZE(conn1), conn1);
2025                 snd_hda_override_conn_list(codec, 0x18, ARRAY_SIZE(conn2), conn2);
2026                 snd_hda_override_conn_list(codec, 0x1a, ARRAY_SIZE(conn2), conn2);
2027         } else if (action == HDA_FIXUP_ACT_PROBE) {
2028                 /* restore the connections */
2029                 static const hda_nid_t conn[] = { 0x0c, 0x0d, 0x0e, 0x0f, 0x26 };
2030                 snd_hda_override_conn_list(codec, 0x14, ARRAY_SIZE(conn), conn);
2031                 snd_hda_override_conn_list(codec, 0x15, ARRAY_SIZE(conn), conn);
2032                 snd_hda_override_conn_list(codec, 0x18, ARRAY_SIZE(conn), conn);
2033                 snd_hda_override_conn_list(codec, 0x1a, ARRAY_SIZE(conn), conn);
2034         }
2035 }
2036
2037 /* Set VREF on HP pin */
2038 static void alc889_fixup_mbp_vref(struct hda_codec *codec,
2039                                   const struct hda_fixup *fix, int action)
2040 {
2041         static const hda_nid_t nids[] = { 0x14, 0x15, 0x19 };
2042         struct alc_spec *spec = codec->spec;
2043         int i;
2044
2045         if (action != HDA_FIXUP_ACT_INIT)
2046                 return;
2047         for (i = 0; i < ARRAY_SIZE(nids); i++) {
2048                 unsigned int val = snd_hda_codec_get_pincfg(codec, nids[i]);
2049                 if (get_defcfg_device(val) != AC_JACK_HP_OUT)
2050                         continue;
2051                 val = snd_hda_codec_get_pin_target(codec, nids[i]);
2052                 val |= AC_PINCTL_VREF_80;
2053                 snd_hda_set_pin_ctl(codec, nids[i], val);
2054                 spec->gen.keep_vref_in_automute = 1;
2055                 break;
2056         }
2057 }
2058
2059 static void alc889_fixup_mac_pins(struct hda_codec *codec,
2060                                   const hda_nid_t *nids, int num_nids)
2061 {
2062         struct alc_spec *spec = codec->spec;
2063         int i;
2064
2065         for (i = 0; i < num_nids; i++) {
2066                 unsigned int val;
2067                 val = snd_hda_codec_get_pin_target(codec, nids[i]);
2068                 val |= AC_PINCTL_VREF_50;
2069                 snd_hda_set_pin_ctl(codec, nids[i], val);
2070         }
2071         spec->gen.keep_vref_in_automute = 1;
2072 }
2073
2074 /* Set VREF on speaker pins on imac91 */
2075 static void alc889_fixup_imac91_vref(struct hda_codec *codec,
2076                                      const struct hda_fixup *fix, int action)
2077 {
2078         static const hda_nid_t nids[] = { 0x18, 0x1a };
2079
2080         if (action == HDA_FIXUP_ACT_INIT)
2081                 alc889_fixup_mac_pins(codec, nids, ARRAY_SIZE(nids));
2082 }
2083
2084 /* Set VREF on speaker pins on mba11 */
2085 static void alc889_fixup_mba11_vref(struct hda_codec *codec,
2086                                     const struct hda_fixup *fix, int action)
2087 {
2088         static const hda_nid_t nids[] = { 0x18 };
2089
2090         if (action == HDA_FIXUP_ACT_INIT)
2091                 alc889_fixup_mac_pins(codec, nids, ARRAY_SIZE(nids));
2092 }
2093
2094 /* Set VREF on speaker pins on mba21 */
2095 static void alc889_fixup_mba21_vref(struct hda_codec *codec,
2096                                     const struct hda_fixup *fix, int action)
2097 {
2098         static const hda_nid_t nids[] = { 0x18, 0x19 };
2099
2100         if (action == HDA_FIXUP_ACT_INIT)
2101                 alc889_fixup_mac_pins(codec, nids, ARRAY_SIZE(nids));
2102 }
2103
2104 /* Don't take HP output as primary
2105  * Strangely, the speaker output doesn't work on Vaio Z and some Vaio
2106  * all-in-one desktop PCs (for example VGC-LN51JGB) through DAC 0x05
2107  */
2108 static void alc882_fixup_no_primary_hp(struct hda_codec *codec,
2109                                        const struct hda_fixup *fix, int action)
2110 {
2111         struct alc_spec *spec = codec->spec;
2112         if (action == HDA_FIXUP_ACT_PRE_PROBE) {
2113                 spec->gen.no_primary_hp = 1;
2114                 spec->gen.no_multi_io = 1;
2115         }
2116 }
2117
2118 static void alc_fixup_bass_chmap(struct hda_codec *codec,
2119                                  const struct hda_fixup *fix, int action);
2120
2121 /* For dual-codec configuration, we need to disable some features to avoid
2122  * conflicts of kctls and PCM streams
2123  */
2124 static void alc_fixup_dual_codecs(struct hda_codec *codec,
2125                                   const struct hda_fixup *fix, int action)
2126 {
2127         struct alc_spec *spec = codec->spec;
2128
2129         if (action != HDA_FIXUP_ACT_PRE_PROBE)
2130                 return;
2131         /* disable vmaster */
2132         spec->gen.suppress_vmaster = 1;
2133         /* auto-mute and auto-mic switch don't work with multiple codecs */
2134         spec->gen.suppress_auto_mute = 1;
2135         spec->gen.suppress_auto_mic = 1;
2136         /* disable aamix as well */
2137         spec->gen.mixer_nid = 0;
2138         /* add location prefix to avoid conflicts */
2139         codec->force_pin_prefix = 1;
2140 }
2141
2142 static void rename_ctl(struct hda_codec *codec, const char *oldname,
2143                        const char *newname)
2144 {
2145         struct snd_kcontrol *kctl;
2146
2147         kctl = snd_hda_find_mixer_ctl(codec, oldname);
2148         if (kctl)
2149                 snd_ctl_rename(codec->card, kctl, newname);
2150 }
2151
2152 static void alc1220_fixup_gb_dual_codecs(struct hda_codec *codec,
2153                                          const struct hda_fixup *fix,
2154                                          int action)
2155 {
2156         alc_fixup_dual_codecs(codec, fix, action);
2157         switch (action) {
2158         case HDA_FIXUP_ACT_PRE_PROBE:
2159                 /* override card longname to provide a unique UCM profile */
2160                 strcpy(codec->card->longname, "HDAudio-Gigabyte-ALC1220DualCodecs");
2161                 break;
2162         case HDA_FIXUP_ACT_BUILD:
2163                 /* rename Capture controls depending on the codec */
2164                 rename_ctl(codec, "Capture Volume",
2165                            codec->addr == 0 ?
2166                            "Rear-Panel Capture Volume" :
2167                            "Front-Panel Capture Volume");
2168                 rename_ctl(codec, "Capture Switch",
2169                            codec->addr == 0 ?
2170                            "Rear-Panel Capture Switch" :
2171                            "Front-Panel Capture Switch");
2172                 break;
2173         }
2174 }
2175
2176 static void alc1220_fixup_gb_x570(struct hda_codec *codec,
2177                                      const struct hda_fixup *fix,
2178                                      int action)
2179 {
2180         static const hda_nid_t conn1[] = { 0x0c };
2181         static const struct coef_fw gb_x570_coefs[] = {
2182                 WRITE_COEF(0x07, 0x03c0),
2183                 WRITE_COEF(0x1a, 0x01c1),
2184                 WRITE_COEF(0x1b, 0x0202),
2185                 WRITE_COEF(0x43, 0x3005),
2186                 {}
2187         };
2188
2189         switch (action) {
2190         case HDA_FIXUP_ACT_PRE_PROBE:
2191                 snd_hda_override_conn_list(codec, 0x14, ARRAY_SIZE(conn1), conn1);
2192                 snd_hda_override_conn_list(codec, 0x1b, ARRAY_SIZE(conn1), conn1);
2193                 break;
2194         case HDA_FIXUP_ACT_INIT:
2195                 alc_process_coef_fw(codec, gb_x570_coefs);
2196                 break;
2197         }
2198 }
2199
2200 static void alc1220_fixup_clevo_p950(struct hda_codec *codec,
2201                                      const struct hda_fixup *fix,
2202                                      int action)
2203 {
2204         static const hda_nid_t conn1[] = { 0x0c };
2205
2206         if (action != HDA_FIXUP_ACT_PRE_PROBE)
2207                 return;
2208
2209         alc_update_coef_idx(codec, 0x7, 0, 0x3c3);
2210         /* We therefore want to make sure 0x14 (front headphone) and
2211          * 0x1b (speakers) use the stereo DAC 0x02
2212          */
2213         snd_hda_override_conn_list(codec, 0x14, ARRAY_SIZE(conn1), conn1);
2214         snd_hda_override_conn_list(codec, 0x1b, ARRAY_SIZE(conn1), conn1);
2215 }
2216
2217 static void alc_fixup_headset_mode_no_hp_mic(struct hda_codec *codec,
2218                                 const struct hda_fixup *fix, int action);
2219
2220 static void alc1220_fixup_clevo_pb51ed(struct hda_codec *codec,
2221                                      const struct hda_fixup *fix,
2222                                      int action)
2223 {
2224         alc1220_fixup_clevo_p950(codec, fix, action);
2225         alc_fixup_headset_mode_no_hp_mic(codec, fix, action);
2226 }
2227
2228 static void alc887_asus_hp_automute_hook(struct hda_codec *codec,
2229                                          struct hda_jack_callback *jack)
2230 {
2231         struct alc_spec *spec = codec->spec;
2232         unsigned int vref;
2233
2234         snd_hda_gen_hp_automute(codec, jack);
2235
2236         if (spec->gen.hp_jack_present)
2237                 vref = AC_PINCTL_VREF_80;
2238         else
2239                 vref = AC_PINCTL_VREF_HIZ;
2240         snd_hda_set_pin_ctl(codec, 0x19, PIN_HP | vref);
2241 }
2242
2243 static void alc887_fixup_asus_jack(struct hda_codec *codec,
2244                                      const struct hda_fixup *fix, int action)
2245 {
2246         struct alc_spec *spec = codec->spec;
2247         if (action != HDA_FIXUP_ACT_PROBE)
2248                 return;
2249         snd_hda_set_pin_ctl_cache(codec, 0x1b, PIN_HP);
2250         spec->gen.hp_automute_hook = alc887_asus_hp_automute_hook;
2251 }
2252
2253 static const struct hda_fixup alc882_fixups[] = {
2254         [ALC882_FIXUP_ABIT_AW9D_MAX] = {
2255                 .type = HDA_FIXUP_PINS,
2256                 .v.pins = (const struct hda_pintbl[]) {
2257                         { 0x15, 0x01080104 }, /* side */
2258                         { 0x16, 0x01011012 }, /* rear */
2259                         { 0x17, 0x01016011 }, /* clfe */
2260                         { }
2261                 }
2262         },
2263         [ALC882_FIXUP_LENOVO_Y530] = {
2264                 .type = HDA_FIXUP_PINS,
2265                 .v.pins = (const struct hda_pintbl[]) {
2266                         { 0x15, 0x99130112 }, /* rear int speakers */
2267                         { 0x16, 0x99130111 }, /* subwoofer */
2268                         { }
2269                 }
2270         },
2271         [ALC882_FIXUP_PB_M5210] = {
2272                 .type = HDA_FIXUP_PINCTLS,
2273                 .v.pins = (const struct hda_pintbl[]) {
2274                         { 0x19, PIN_VREF50 },
2275                         {}
2276                 }
2277         },
2278         [ALC882_FIXUP_ACER_ASPIRE_7736] = {
2279                 .type = HDA_FIXUP_FUNC,
2280                 .v.func = alc_fixup_sku_ignore,
2281         },
2282         [ALC882_FIXUP_ASUS_W90V] = {
2283                 .type = HDA_FIXUP_PINS,
2284                 .v.pins = (const struct hda_pintbl[]) {
2285                         { 0x16, 0x99130110 }, /* fix sequence for CLFE */
2286                         { }
2287                 }
2288         },
2289         [ALC889_FIXUP_CD] = {
2290                 .type = HDA_FIXUP_PINS,
2291                 .v.pins = (const struct hda_pintbl[]) {
2292                         { 0x1c, 0x993301f0 }, /* CD */
2293                         { }
2294                 }
2295         },
2296         [ALC889_FIXUP_FRONT_HP_NO_PRESENCE] = {
2297                 .type = HDA_FIXUP_PINS,
2298                 .v.pins = (const struct hda_pintbl[]) {
2299                         { 0x1b, 0x02214120 }, /* Front HP jack is flaky, disable jack detect */
2300                         { }
2301                 },
2302                 .chained = true,
2303                 .chain_id = ALC889_FIXUP_CD,
2304         },
2305         [ALC889_FIXUP_VAIO_TT] = {
2306                 .type = HDA_FIXUP_PINS,
2307                 .v.pins = (const struct hda_pintbl[]) {
2308                         { 0x17, 0x90170111 }, /* hidden surround speaker */
2309                         { }
2310                 }
2311         },
2312         [ALC888_FIXUP_EEE1601] = {
2313                 .type = HDA_FIXUP_VERBS,
2314                 .v.verbs = (const struct hda_verb[]) {
2315                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x0b },
2316                         { 0x20, AC_VERB_SET_PROC_COEF,  0x0838 },
2317                         { }
2318                 }
2319         },
2320         [ALC886_FIXUP_EAPD] = {
2321                 .type = HDA_FIXUP_VERBS,
2322                 .v.verbs = (const struct hda_verb[]) {
2323                         /* change to EAPD mode */
2324                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x07 },
2325                         { 0x20, AC_VERB_SET_PROC_COEF, 0x0068 },
2326                         { }
2327                 }
2328         },
2329         [ALC882_FIXUP_EAPD] = {
2330                 .type = HDA_FIXUP_VERBS,
2331                 .v.verbs = (const struct hda_verb[]) {
2332                         /* change to EAPD mode */
2333                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x07 },
2334                         { 0x20, AC_VERB_SET_PROC_COEF, 0x3060 },
2335                         { }
2336                 }
2337         },
2338         [ALC883_FIXUP_EAPD] = {
2339                 .type = HDA_FIXUP_VERBS,
2340                 .v.verbs = (const struct hda_verb[]) {
2341                         /* change to EAPD mode */
2342                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x07 },
2343                         { 0x20, AC_VERB_SET_PROC_COEF, 0x3070 },
2344                         { }
2345                 }
2346         },
2347         [ALC883_FIXUP_ACER_EAPD] = {
2348                 .type = HDA_FIXUP_VERBS,
2349                 .v.verbs = (const struct hda_verb[]) {
2350                         /* eanable EAPD on Acer laptops */
2351                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x07 },
2352                         { 0x20, AC_VERB_SET_PROC_COEF, 0x3050 },
2353                         { }
2354                 }
2355         },
2356         [ALC882_FIXUP_GPIO1] = {
2357                 .type = HDA_FIXUP_FUNC,
2358                 .v.func = alc_fixup_gpio1,
2359         },
2360         [ALC882_FIXUP_GPIO2] = {
2361                 .type = HDA_FIXUP_FUNC,
2362                 .v.func = alc_fixup_gpio2,
2363         },
2364         [ALC882_FIXUP_GPIO3] = {
2365                 .type = HDA_FIXUP_FUNC,
2366                 .v.func = alc_fixup_gpio3,
2367         },
2368         [ALC882_FIXUP_ASUS_W2JC] = {
2369                 .type = HDA_FIXUP_FUNC,
2370                 .v.func = alc_fixup_gpio1,
2371                 .chained = true,
2372                 .chain_id = ALC882_FIXUP_EAPD,
2373         },
2374         [ALC889_FIXUP_COEF] = {
2375                 .type = HDA_FIXUP_FUNC,
2376                 .v.func = alc889_fixup_coef,
2377         },
2378         [ALC882_FIXUP_ACER_ASPIRE_4930G] = {
2379                 .type = HDA_FIXUP_PINS,
2380                 .v.pins = (const struct hda_pintbl[]) {
2381                         { 0x16, 0x99130111 }, /* CLFE speaker */
2382                         { 0x17, 0x99130112 }, /* surround speaker */
2383                         { }
2384                 },
2385                 .chained = true,
2386                 .chain_id = ALC882_FIXUP_GPIO1,
2387         },
2388         [ALC882_FIXUP_ACER_ASPIRE_8930G] = {
2389                 .type = HDA_FIXUP_PINS,
2390                 .v.pins = (const struct hda_pintbl[]) {
2391                         { 0x16, 0x99130111 }, /* CLFE speaker */
2392                         { 0x1b, 0x99130112 }, /* surround speaker */
2393                         { }
2394                 },
2395                 .chained = true,
2396                 .chain_id = ALC882_FIXUP_ASPIRE_8930G_VERBS,
2397         },
2398         [ALC882_FIXUP_ASPIRE_8930G_VERBS] = {
2399                 /* additional init verbs for Acer Aspire 8930G */
2400                 .type = HDA_FIXUP_VERBS,
2401                 .v.verbs = (const struct hda_verb[]) {
2402                         /* Enable all DACs */
2403                         /* DAC DISABLE/MUTE 1? */
2404                         /*  setting bits 1-5 disables DAC nids 0x02-0x06
2405                          *  apparently. Init=0x38 */
2406                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x03 },
2407                         { 0x20, AC_VERB_SET_PROC_COEF, 0x0000 },
2408                         /* DAC DISABLE/MUTE 2? */
2409                         /*  some bit here disables the other DACs.
2410                          *  Init=0x4900 */
2411                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x08 },
2412                         { 0x20, AC_VERB_SET_PROC_COEF, 0x0000 },
2413                         /* DMIC fix
2414                          * This laptop has a stereo digital microphone.
2415                          * The mics are only 1cm apart which makes the stereo
2416                          * useless. However, either the mic or the ALC889
2417                          * makes the signal become a difference/sum signal
2418                          * instead of standard stereo, which is annoying.
2419                          * So instead we flip this bit which makes the
2420                          * codec replicate the sum signal to both channels,
2421                          * turning it into a normal mono mic.
2422                          */
2423                         /* DMIC_CONTROL? Init value = 0x0001 */
2424                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x0b },
2425                         { 0x20, AC_VERB_SET_PROC_COEF, 0x0003 },
2426                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x07 },
2427                         { 0x20, AC_VERB_SET_PROC_COEF, 0x3050 },
2428                         { }
2429                 },
2430                 .chained = true,
2431                 .chain_id = ALC882_FIXUP_GPIO1,
2432         },
2433         [ALC885_FIXUP_MACPRO_GPIO] = {
2434                 .type = HDA_FIXUP_FUNC,
2435                 .v.func = alc885_fixup_macpro_gpio,
2436         },
2437         [ALC889_FIXUP_DAC_ROUTE] = {
2438                 .type = HDA_FIXUP_FUNC,
2439                 .v.func = alc889_fixup_dac_route,
2440         },
2441         [ALC889_FIXUP_MBP_VREF] = {
2442                 .type = HDA_FIXUP_FUNC,
2443                 .v.func = alc889_fixup_mbp_vref,
2444                 .chained = true,
2445                 .chain_id = ALC882_FIXUP_GPIO1,
2446         },
2447         [ALC889_FIXUP_IMAC91_VREF] = {
2448                 .type = HDA_FIXUP_FUNC,
2449                 .v.func = alc889_fixup_imac91_vref,
2450                 .chained = true,
2451                 .chain_id = ALC882_FIXUP_GPIO1,
2452         },
2453         [ALC889_FIXUP_MBA11_VREF] = {
2454                 .type = HDA_FIXUP_FUNC,
2455                 .v.func = alc889_fixup_mba11_vref,
2456                 .chained = true,
2457                 .chain_id = ALC889_FIXUP_MBP_VREF,
2458         },
2459         [ALC889_FIXUP_MBA21_VREF] = {
2460                 .type = HDA_FIXUP_FUNC,
2461                 .v.func = alc889_fixup_mba21_vref,
2462                 .chained = true,
2463                 .chain_id = ALC889_FIXUP_MBP_VREF,
2464         },
2465         [ALC889_FIXUP_MP11_VREF] = {
2466                 .type = HDA_FIXUP_FUNC,
2467                 .v.func = alc889_fixup_mba11_vref,
2468                 .chained = true,
2469                 .chain_id = ALC885_FIXUP_MACPRO_GPIO,
2470         },
2471         [ALC889_FIXUP_MP41_VREF] = {
2472                 .type = HDA_FIXUP_FUNC,
2473                 .v.func = alc889_fixup_mbp_vref,
2474                 .chained = true,
2475                 .chain_id = ALC885_FIXUP_MACPRO_GPIO,
2476         },
2477         [ALC882_FIXUP_INV_DMIC] = {
2478                 .type = HDA_FIXUP_FUNC,
2479                 .v.func = alc_fixup_inv_dmic,
2480         },
2481         [ALC882_FIXUP_NO_PRIMARY_HP] = {
2482                 .type = HDA_FIXUP_FUNC,
2483                 .v.func = alc882_fixup_no_primary_hp,
2484         },
2485         [ALC887_FIXUP_ASUS_BASS] = {
2486                 .type = HDA_FIXUP_PINS,
2487                 .v.pins = (const struct hda_pintbl[]) {
2488                         {0x16, 0x99130130}, /* bass speaker */
2489                         {}
2490                 },
2491                 .chained = true,
2492                 .chain_id = ALC887_FIXUP_BASS_CHMAP,
2493         },
2494         [ALC887_FIXUP_BASS_CHMAP] = {
2495                 .type = HDA_FIXUP_FUNC,
2496                 .v.func = alc_fixup_bass_chmap,
2497         },
2498         [ALC1220_FIXUP_GB_DUAL_CODECS] = {
2499                 .type = HDA_FIXUP_FUNC,
2500                 .v.func = alc1220_fixup_gb_dual_codecs,
2501         },
2502         [ALC1220_FIXUP_GB_X570] = {
2503                 .type = HDA_FIXUP_FUNC,
2504                 .v.func = alc1220_fixup_gb_x570,
2505         },
2506         [ALC1220_FIXUP_CLEVO_P950] = {
2507                 .type = HDA_FIXUP_FUNC,
2508                 .v.func = alc1220_fixup_clevo_p950,
2509         },
2510         [ALC1220_FIXUP_CLEVO_PB51ED] = {
2511                 .type = HDA_FIXUP_FUNC,
2512                 .v.func = alc1220_fixup_clevo_pb51ed,
2513         },
2514         [ALC1220_FIXUP_CLEVO_PB51ED_PINS] = {
2515                 .type = HDA_FIXUP_PINS,
2516                 .v.pins = (const struct hda_pintbl[]) {
2517                         { 0x19, 0x01a1913c }, /* use as headset mic, without its own jack detect */
2518                         {}
2519                 },
2520                 .chained = true,
2521                 .chain_id = ALC1220_FIXUP_CLEVO_PB51ED,
2522         },
2523         [ALC887_FIXUP_ASUS_AUDIO] = {
2524                 .type = HDA_FIXUP_PINS,
2525                 .v.pins = (const struct hda_pintbl[]) {
2526                         { 0x15, 0x02a14150 }, /* use as headset mic, without its own jack detect */
2527                         { 0x19, 0x22219420 },
2528                         {}
2529                 },
2530         },
2531         [ALC887_FIXUP_ASUS_HMIC] = {
2532                 .type = HDA_FIXUP_FUNC,
2533                 .v.func = alc887_fixup_asus_jack,
2534                 .chained = true,
2535                 .chain_id = ALC887_FIXUP_ASUS_AUDIO,
2536         },
2537         [ALCS1200A_FIXUP_MIC_VREF] = {
2538                 .type = HDA_FIXUP_PINCTLS,
2539                 .v.pins = (const struct hda_pintbl[]) {
2540                         { 0x18, PIN_VREF50 }, /* rear mic */
2541                         { 0x19, PIN_VREF50 }, /* front mic */
2542                         {}
2543                 }
2544         },
2545         [ALC888VD_FIXUP_MIC_100VREF] = {
2546                 .type = HDA_FIXUP_PINCTLS,
2547                 .v.pins = (const struct hda_pintbl[]) {
2548                         { 0x18, PIN_VREF100 }, /* headset mic */
2549                         {}
2550                 }
2551         },
2552 };
2553
2554 static const struct snd_pci_quirk alc882_fixup_tbl[] = {
2555         SND_PCI_QUIRK(0x1025, 0x006c, "Acer Aspire 9810", ALC883_FIXUP_ACER_EAPD),
2556         SND_PCI_QUIRK(0x1025, 0x0090, "Acer Aspire", ALC883_FIXUP_ACER_EAPD),
2557         SND_PCI_QUIRK(0x1025, 0x0107, "Acer Aspire", ALC883_FIXUP_ACER_EAPD),
2558         SND_PCI_QUIRK(0x1025, 0x010a, "Acer Ferrari 5000", ALC883_FIXUP_ACER_EAPD),
2559         SND_PCI_QUIRK(0x1025, 0x0110, "Acer Aspire", ALC883_FIXUP_ACER_EAPD),
2560         SND_PCI_QUIRK(0x1025, 0x0112, "Acer Aspire 9303", ALC883_FIXUP_ACER_EAPD),
2561         SND_PCI_QUIRK(0x1025, 0x0121, "Acer Aspire 5920G", ALC883_FIXUP_ACER_EAPD),
2562         SND_PCI_QUIRK(0x1025, 0x013e, "Acer Aspire 4930G",
2563                       ALC882_FIXUP_ACER_ASPIRE_4930G),
2564         SND_PCI_QUIRK(0x1025, 0x013f, "Acer Aspire 5930G",
2565                       ALC882_FIXUP_ACER_ASPIRE_4930G),
2566         SND_PCI_QUIRK(0x1025, 0x0145, "Acer Aspire 8930G",
2567                       ALC882_FIXUP_ACER_ASPIRE_8930G),
2568         SND_PCI_QUIRK(0x1025, 0x0146, "Acer Aspire 6935G",
2569                       ALC882_FIXUP_ACER_ASPIRE_8930G),
2570         SND_PCI_QUIRK(0x1025, 0x0142, "Acer Aspire 7730G",
2571                       ALC882_FIXUP_ACER_ASPIRE_4930G),
2572         SND_PCI_QUIRK(0x1025, 0x0155, "Packard-Bell M5120", ALC882_FIXUP_PB_M5210),
2573         SND_PCI_QUIRK(0x1025, 0x015e, "Acer Aspire 6930G",
2574                       ALC882_FIXUP_ACER_ASPIRE_4930G),
2575         SND_PCI_QUIRK(0x1025, 0x0166, "Acer Aspire 6530G",
2576                       ALC882_FIXUP_ACER_ASPIRE_4930G),
2577         SND_PCI_QUIRK(0x1025, 0x021e, "Acer Aspire 5739G",
2578                       ALC882_FIXUP_ACER_ASPIRE_4930G),
2579         SND_PCI_QUIRK(0x1025, 0x0259, "Acer Aspire 5935", ALC889_FIXUP_DAC_ROUTE),
2580         SND_PCI_QUIRK(0x1025, 0x026b, "Acer Aspire 8940G", ALC882_FIXUP_ACER_ASPIRE_8930G),
2581         SND_PCI_QUIRK(0x1025, 0x0296, "Acer Aspire 7736z", ALC882_FIXUP_ACER_ASPIRE_7736),
2582         SND_PCI_QUIRK(0x1043, 0x13c2, "Asus A7M", ALC882_FIXUP_EAPD),
2583         SND_PCI_QUIRK(0x1043, 0x1873, "ASUS W90V", ALC882_FIXUP_ASUS_W90V),
2584         SND_PCI_QUIRK(0x1043, 0x1971, "Asus W2JC", ALC882_FIXUP_ASUS_W2JC),
2585         SND_PCI_QUIRK(0x1043, 0x2390, "Asus D700SA", ALC887_FIXUP_ASUS_HMIC),
2586         SND_PCI_QUIRK(0x1043, 0x835f, "Asus Eee 1601", ALC888_FIXUP_EEE1601),
2587         SND_PCI_QUIRK(0x1043, 0x84bc, "ASUS ET2700", ALC887_FIXUP_ASUS_BASS),
2588         SND_PCI_QUIRK(0x1043, 0x8691, "ASUS ROG Ranger VIII", ALC882_FIXUP_GPIO3),
2589         SND_PCI_QUIRK(0x1043, 0x8797, "ASUS TUF B550M-PLUS", ALCS1200A_FIXUP_MIC_VREF),
2590         SND_PCI_QUIRK(0x104d, 0x9043, "Sony Vaio VGC-LN51JGB", ALC882_FIXUP_NO_PRIMARY_HP),
2591         SND_PCI_QUIRK(0x104d, 0x9044, "Sony VAIO AiO", ALC882_FIXUP_NO_PRIMARY_HP),
2592         SND_PCI_QUIRK(0x104d, 0x9047, "Sony Vaio TT", ALC889_FIXUP_VAIO_TT),
2593         SND_PCI_QUIRK(0x104d, 0x905a, "Sony Vaio Z", ALC882_FIXUP_NO_PRIMARY_HP),
2594         SND_PCI_QUIRK(0x104d, 0x9060, "Sony Vaio VPCL14M1R", ALC882_FIXUP_NO_PRIMARY_HP),
2595
2596         /* All Apple entries are in codec SSIDs */
2597         SND_PCI_QUIRK(0x106b, 0x00a0, "MacBookPro 3,1", ALC889_FIXUP_MBP_VREF),
2598         SND_PCI_QUIRK(0x106b, 0x00a1, "Macbook", ALC889_FIXUP_MBP_VREF),
2599         SND_PCI_QUIRK(0x106b, 0x00a4, "MacbookPro 4,1", ALC889_FIXUP_MBP_VREF),
2600         SND_PCI_QUIRK(0x106b, 0x0c00, "Mac Pro", ALC889_FIXUP_MP11_VREF),
2601         SND_PCI_QUIRK(0x106b, 0x1000, "iMac 24", ALC885_FIXUP_MACPRO_GPIO),
2602         SND_PCI_QUIRK(0x106b, 0x2800, "AppleTV", ALC885_FIXUP_MACPRO_GPIO),
2603         SND_PCI_QUIRK(0x106b, 0x2c00, "MacbookPro rev3", ALC889_FIXUP_MBP_VREF),
2604         SND_PCI_QUIRK(0x106b, 0x3000, "iMac", ALC889_FIXUP_MBP_VREF),
2605         SND_PCI_QUIRK(0x106b, 0x3200, "iMac 7,1 Aluminum", ALC882_FIXUP_EAPD),
2606         SND_PCI_QUIRK(0x106b, 0x3400, "MacBookAir 1,1", ALC889_FIXUP_MBA11_VREF),
2607         SND_PCI_QUIRK(0x106b, 0x3500, "MacBookAir 2,1", ALC889_FIXUP_MBA21_VREF),
2608         SND_PCI_QUIRK(0x106b, 0x3600, "Macbook 3,1", ALC889_FIXUP_MBP_VREF),
2609         SND_PCI_QUIRK(0x106b, 0x3800, "MacbookPro 4,1", ALC889_FIXUP_MBP_VREF),
2610         SND_PCI_QUIRK(0x106b, 0x3e00, "iMac 24 Aluminum", ALC885_FIXUP_MACPRO_GPIO),
2611         SND_PCI_QUIRK(0x106b, 0x3f00, "Macbook 5,1", ALC889_FIXUP_IMAC91_VREF),
2612         SND_PCI_QUIRK(0x106b, 0x4000, "MacbookPro 5,1", ALC889_FIXUP_IMAC91_VREF),
2613         SND_PCI_QUIRK(0x106b, 0x4100, "Macmini 3,1", ALC889_FIXUP_IMAC91_VREF),
2614         SND_PCI_QUIRK(0x106b, 0x4200, "Mac Pro 4,1/5,1", ALC889_FIXUP_MP41_VREF),
2615         SND_PCI_QUIRK(0x106b, 0x4300, "iMac 9,1", ALC889_FIXUP_IMAC91_VREF),
2616         SND_PCI_QUIRK(0x106b, 0x4600, "MacbookPro 5,2", ALC889_FIXUP_IMAC91_VREF),
2617         SND_PCI_QUIRK(0x106b, 0x4900, "iMac 9,1 Aluminum", ALC889_FIXUP_IMAC91_VREF),
2618         SND_PCI_QUIRK(0x106b, 0x4a00, "Macbook 5,2", ALC889_FIXUP_MBA11_VREF),
2619
2620         SND_PCI_QUIRK(0x1071, 0x8258, "Evesham Voyaeger", ALC882_FIXUP_EAPD),
2621         SND_PCI_QUIRK(0x10ec, 0x12d8, "iBase Elo Touch", ALC888VD_FIXUP_MIC_100VREF),
2622         SND_PCI_QUIRK(0x13fe, 0x1009, "Advantech MIT-W101", ALC886_FIXUP_EAPD),
2623         SND_PCI_QUIRK(0x1458, 0xa002, "Gigabyte EP45-DS3/Z87X-UD3H", ALC889_FIXUP_FRONT_HP_NO_PRESENCE),
2624         SND_PCI_QUIRK(0x1458, 0xa0b8, "Gigabyte AZ370-Gaming", ALC1220_FIXUP_GB_DUAL_CODECS),
2625         SND_PCI_QUIRK(0x1458, 0xa0cd, "Gigabyte X570 Aorus Master", ALC1220_FIXUP_GB_X570),
2626         SND_PCI_QUIRK(0x1458, 0xa0ce, "Gigabyte X570 Aorus Xtreme", ALC1220_FIXUP_GB_X570),
2627         SND_PCI_QUIRK(0x1458, 0xa0d5, "Gigabyte X570S Aorus Master", ALC1220_FIXUP_GB_X570),
2628         SND_PCI_QUIRK(0x1462, 0x11f7, "MSI-GE63", ALC1220_FIXUP_CLEVO_P950),
2629         SND_PCI_QUIRK(0x1462, 0x1228, "MSI-GP63", ALC1220_FIXUP_CLEVO_P950),
2630         SND_PCI_QUIRK(0x1462, 0x1229, "MSI-GP73", ALC1220_FIXUP_CLEVO_P950),
2631         SND_PCI_QUIRK(0x1462, 0x1275, "MSI-GL63", ALC1220_FIXUP_CLEVO_P950),
2632         SND_PCI_QUIRK(0x1462, 0x1276, "MSI-GL73", ALC1220_FIXUP_CLEVO_P950),
2633         SND_PCI_QUIRK(0x1462, 0x1293, "MSI-GP65", ALC1220_FIXUP_CLEVO_P950),
2634         SND_PCI_QUIRK(0x1462, 0x7350, "MSI-7350", ALC889_FIXUP_CD),
2635         SND_PCI_QUIRK(0x1462, 0xcc34, "MSI Godlike X570", ALC1220_FIXUP_GB_DUAL_CODECS),
2636         SND_PCI_QUIRK(0x1462, 0xda57, "MSI Z270-Gaming", ALC1220_FIXUP_GB_DUAL_CODECS),
2637         SND_PCI_QUIRK_VENDOR(0x1462, "MSI", ALC882_FIXUP_GPIO3),
2638         SND_PCI_QUIRK(0x147b, 0x107a, "Abit AW9D-MAX", ALC882_FIXUP_ABIT_AW9D_MAX),
2639         SND_PCI_QUIRK(0x1558, 0x3702, "Clevo X370SN[VW]", ALC1220_FIXUP_CLEVO_PB51ED_PINS),
2640         SND_PCI_QUIRK(0x1558, 0x50d3, "Clevo PC50[ER][CDF]", ALC1220_FIXUP_CLEVO_PB51ED_PINS),
2641         SND_PCI_QUIRK(0x1558, 0x65d1, "Clevo PB51[ER][CDF]", ALC1220_FIXUP_CLEVO_PB51ED_PINS),
2642         SND_PCI_QUIRK(0x1558, 0x65d2, "Clevo PB51R[CDF]", ALC1220_FIXUP_CLEVO_PB51ED_PINS),
2643         SND_PCI_QUIRK(0x1558, 0x65e1, "Clevo PB51[ED][DF]", ALC1220_FIXUP_CLEVO_PB51ED_PINS),
2644         SND_PCI_QUIRK(0x1558, 0x65e5, "Clevo PC50D[PRS](?:-D|-G)?", ALC1220_FIXUP_CLEVO_PB51ED_PINS),
2645         SND_PCI_QUIRK(0x1558, 0x65f1, "Clevo PC50HS", ALC1220_FIXUP_CLEVO_PB51ED_PINS),
2646         SND_PCI_QUIRK(0x1558, 0x65f5, "Clevo PD50PN[NRT]", ALC1220_FIXUP_CLEVO_PB51ED_PINS),
2647         SND_PCI_QUIRK(0x1558, 0x66a2, "Clevo PE60RNE", ALC1220_FIXUP_CLEVO_PB51ED_PINS),
2648         SND_PCI_QUIRK(0x1558, 0x66a6, "Clevo PE60SN[CDE]-[GS]", ALC1220_FIXUP_CLEVO_PB51ED_PINS),
2649         SND_PCI_QUIRK(0x1558, 0x67d1, "Clevo PB71[ER][CDF]", ALC1220_FIXUP_CLEVO_PB51ED_PINS),
2650         SND_PCI_QUIRK(0x1558, 0x67e1, "Clevo PB71[DE][CDF]", ALC1220_FIXUP_CLEVO_PB51ED_PINS),
2651         SND_PCI_QUIRK(0x1558, 0x67e5, "Clevo PC70D[PRS](?:-D|-G)?", ALC1220_FIXUP_CLEVO_PB51ED_PINS),
2652         SND_PCI_QUIRK(0x1558, 0x67f1, "Clevo PC70H[PRS]", ALC1220_FIXUP_CLEVO_PB51ED_PINS),
2653         SND_PCI_QUIRK(0x1558, 0x67f5, "Clevo PD70PN[NRT]", ALC1220_FIXUP_CLEVO_PB51ED_PINS),
2654         SND_PCI_QUIRK(0x1558, 0x70d1, "Clevo PC70[ER][CDF]", ALC1220_FIXUP_CLEVO_PB51ED_PINS),
2655         SND_PCI_QUIRK(0x1558, 0x7714, "Clevo X170SM", ALC1220_FIXUP_CLEVO_PB51ED_PINS),
2656         SND_PCI_QUIRK(0x1558, 0x7715, "Clevo X170KM-G", ALC1220_FIXUP_CLEVO_PB51ED),
2657         SND_PCI_QUIRK(0x1558, 0x9501, "Clevo P950HR", ALC1220_FIXUP_CLEVO_P950),
2658         SND_PCI_QUIRK(0x1558, 0x9506, "Clevo P955HQ", ALC1220_FIXUP_CLEVO_P950),
2659         SND_PCI_QUIRK(0x1558, 0x950a, "Clevo P955H[PR]", ALC1220_FIXUP_CLEVO_P950),
2660         SND_PCI_QUIRK(0x1558, 0x95e1, "Clevo P95xER", ALC1220_FIXUP_CLEVO_P950),
2661         SND_PCI_QUIRK(0x1558, 0x95e2, "Clevo P950ER", ALC1220_FIXUP_CLEVO_P950),
2662         SND_PCI_QUIRK(0x1558, 0x95e3, "Clevo P955[ER]T", ALC1220_FIXUP_CLEVO_P950),
2663         SND_PCI_QUIRK(0x1558, 0x95e4, "Clevo P955ER", ALC1220_FIXUP_CLEVO_P950),
2664         SND_PCI_QUIRK(0x1558, 0x95e5, "Clevo P955EE6", ALC1220_FIXUP_CLEVO_P950),
2665         SND_PCI_QUIRK(0x1558, 0x95e6, "Clevo P950R[CDF]", ALC1220_FIXUP_CLEVO_P950),
2666         SND_PCI_QUIRK(0x1558, 0x96e1, "Clevo P960[ER][CDFN]-K", ALC1220_FIXUP_CLEVO_P950),
2667         SND_PCI_QUIRK(0x1558, 0x97e1, "Clevo P970[ER][CDFN]", ALC1220_FIXUP_CLEVO_P950),
2668         SND_PCI_QUIRK(0x1558, 0x97e2, "Clevo P970RC-M", ALC1220_FIXUP_CLEVO_P950),
2669         SND_PCI_QUIRK(0x1558, 0xd502, "Clevo PD50SNE", ALC1220_FIXUP_CLEVO_PB51ED_PINS),
2670         SND_PCI_QUIRK_VENDOR(0x1558, "Clevo laptop", ALC882_FIXUP_EAPD),
2671         SND_PCI_QUIRK(0x161f, 0x2054, "Medion laptop", ALC883_FIXUP_EAPD),
2672         SND_PCI_QUIRK(0x17aa, 0x3a0d, "Lenovo Y530", ALC882_FIXUP_LENOVO_Y530),
2673         SND_PCI_QUIRK(0x8086, 0x0022, "DX58SO", ALC889_FIXUP_COEF),
2674         {}
2675 };
2676
2677 static const struct hda_model_fixup alc882_fixup_models[] = {
2678         {.id = ALC882_FIXUP_ABIT_AW9D_MAX, .name = "abit-aw9d"},
2679         {.id = ALC882_FIXUP_LENOVO_Y530, .name = "lenovo-y530"},
2680         {.id = ALC882_FIXUP_ACER_ASPIRE_7736, .name = "acer-aspire-7736"},
2681         {.id = ALC882_FIXUP_ASUS_W90V, .name = "asus-w90v"},
2682         {.id = ALC889_FIXUP_CD, .name = "cd"},
2683         {.id = ALC889_FIXUP_FRONT_HP_NO_PRESENCE, .name = "no-front-hp"},
2684         {.id = ALC889_FIXUP_VAIO_TT, .name = "vaio-tt"},
2685         {.id = ALC888_FIXUP_EEE1601, .name = "eee1601"},
2686         {.id = ALC882_FIXUP_EAPD, .name = "alc882-eapd"},
2687         {.id = ALC883_FIXUP_EAPD, .name = "alc883-eapd"},
2688         {.id = ALC882_FIXUP_GPIO1, .name = "gpio1"},
2689         {.id = ALC882_FIXUP_GPIO2, .name = "gpio2"},
2690         {.id = ALC882_FIXUP_GPIO3, .name = "gpio3"},
2691         {.id = ALC889_FIXUP_COEF, .name = "alc889-coef"},
2692         {.id = ALC882_FIXUP_ASUS_W2JC, .name = "asus-w2jc"},
2693         {.id = ALC882_FIXUP_ACER_ASPIRE_4930G, .name = "acer-aspire-4930g"},
2694         {.id = ALC882_FIXUP_ACER_ASPIRE_8930G, .name = "acer-aspire-8930g"},
2695         {.id = ALC883_FIXUP_ACER_EAPD, .name = "acer-aspire"},
2696         {.id = ALC885_FIXUP_MACPRO_GPIO, .name = "macpro-gpio"},
2697         {.id = ALC889_FIXUP_DAC_ROUTE, .name = "dac-route"},
2698         {.id = ALC889_FIXUP_MBP_VREF, .name = "mbp-vref"},
2699         {.id = ALC889_FIXUP_IMAC91_VREF, .name = "imac91-vref"},
2700         {.id = ALC889_FIXUP_MBA11_VREF, .name = "mba11-vref"},
2701         {.id = ALC889_FIXUP_MBA21_VREF, .name = "mba21-vref"},
2702         {.id = ALC889_FIXUP_MP11_VREF, .name = "mp11-vref"},
2703         {.id = ALC889_FIXUP_MP41_VREF, .name = "mp41-vref"},
2704         {.id = ALC882_FIXUP_INV_DMIC, .name = "inv-dmic"},
2705         {.id = ALC882_FIXUP_NO_PRIMARY_HP, .name = "no-primary-hp"},
2706         {.id = ALC887_FIXUP_ASUS_BASS, .name = "asus-bass"},
2707         {.id = ALC1220_FIXUP_GB_DUAL_CODECS, .name = "dual-codecs"},
2708         {.id = ALC1220_FIXUP_GB_X570, .name = "gb-x570"},
2709         {.id = ALC1220_FIXUP_CLEVO_P950, .name = "clevo-p950"},
2710         {}
2711 };
2712
2713 static const struct snd_hda_pin_quirk alc882_pin_fixup_tbl[] = {
2714         SND_HDA_PIN_QUIRK(0x10ec1220, 0x1043, "ASUS", ALC1220_FIXUP_CLEVO_P950,
2715                 {0x14, 0x01014010},
2716                 {0x15, 0x01011012},
2717                 {0x16, 0x01016011},
2718                 {0x18, 0x01a19040},
2719                 {0x19, 0x02a19050},
2720                 {0x1a, 0x0181304f},
2721                 {0x1b, 0x0221401f},
2722                 {0x1e, 0x01456130}),
2723         SND_HDA_PIN_QUIRK(0x10ec1220, 0x1462, "MS-7C35", ALC1220_FIXUP_CLEVO_P950,
2724                 {0x14, 0x01015010},
2725                 {0x15, 0x01011012},
2726                 {0x16, 0x01011011},
2727                 {0x18, 0x01a11040},
2728                 {0x19, 0x02a19050},
2729                 {0x1a, 0x0181104f},
2730                 {0x1b, 0x0221401f},
2731                 {0x1e, 0x01451130}),
2732         {}
2733 };
2734
2735 /*
2736  * BIOS auto configuration
2737  */
2738 /* almost identical with ALC880 parser... */
2739 static int alc882_parse_auto_config(struct hda_codec *codec)
2740 {
2741         static const hda_nid_t alc882_ignore[] = { 0x1d, 0 };
2742         static const hda_nid_t alc882_ssids[] = { 0x15, 0x1b, 0x14, 0 };
2743         return alc_parse_auto_config(codec, alc882_ignore, alc882_ssids);
2744 }
2745
2746 /*
2747  */
2748 static int patch_alc882(struct hda_codec *codec)
2749 {
2750         struct alc_spec *spec;
2751         int err;
2752
2753         err = alc_alloc_spec(codec, 0x0b);
2754         if (err < 0)
2755                 return err;
2756
2757         spec = codec->spec;
2758
2759         switch (codec->core.vendor_id) {
2760         case 0x10ec0882:
2761         case 0x10ec0885:
2762         case 0x10ec0900:
2763         case 0x10ec0b00:
2764         case 0x10ec1220:
2765                 break;
2766         default:
2767                 /* ALC883 and variants */
2768                 alc_fix_pll_init(codec, 0x20, 0x0a, 10);
2769                 break;
2770         }
2771
2772         alc_pre_init(codec);
2773
2774         snd_hda_pick_fixup(codec, alc882_fixup_models, alc882_fixup_tbl,
2775                        alc882_fixups);
2776         snd_hda_pick_pin_fixup(codec, alc882_pin_fixup_tbl, alc882_fixups, true);
2777         snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE);
2778
2779         alc_auto_parse_customize_define(codec);
2780
2781         if (has_cdefine_beep(codec))
2782                 spec->gen.beep_nid = 0x01;
2783
2784         /* automatic parse from the BIOS config */
2785         err = alc882_parse_auto_config(codec);
2786         if (err < 0)
2787                 goto error;
2788
2789         if (!spec->gen.no_analog && spec->gen.beep_nid) {
2790                 err = set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
2791                 if (err < 0)
2792                         goto error;
2793         }
2794
2795         snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE);
2796
2797         return 0;
2798
2799  error:
2800         alc_free(codec);
2801         return err;
2802 }
2803
2804
2805 /*
2806  * ALC262 support
2807  */
2808 static int alc262_parse_auto_config(struct hda_codec *codec)
2809 {
2810         static const hda_nid_t alc262_ignore[] = { 0x1d, 0 };
2811         static const hda_nid_t alc262_ssids[] = { 0x15, 0x1b, 0x14, 0 };
2812         return alc_parse_auto_config(codec, alc262_ignore, alc262_ssids);
2813 }
2814
2815 /*
2816  * Pin config fixes
2817  */
2818 enum {
2819         ALC262_FIXUP_FSC_H270,
2820         ALC262_FIXUP_FSC_S7110,
2821         ALC262_FIXUP_HP_Z200,
2822         ALC262_FIXUP_TYAN,
2823         ALC262_FIXUP_LENOVO_3000,
2824         ALC262_FIXUP_BENQ,
2825         ALC262_FIXUP_BENQ_T31,
2826         ALC262_FIXUP_INV_DMIC,
2827         ALC262_FIXUP_INTEL_BAYLEYBAY,
2828 };
2829
2830 static const struct hda_fixup alc262_fixups[] = {
2831         [ALC262_FIXUP_FSC_H270] = {
2832                 .type = HDA_FIXUP_PINS,
2833                 .v.pins = (const struct hda_pintbl[]) {
2834                         { 0x14, 0x99130110 }, /* speaker */
2835                         { 0x15, 0x0221142f }, /* front HP */
2836                         { 0x1b, 0x0121141f }, /* rear HP */
2837                         { }
2838                 }
2839         },
2840         [ALC262_FIXUP_FSC_S7110] = {
2841                 .type = HDA_FIXUP_PINS,
2842                 .v.pins = (const struct hda_pintbl[]) {
2843                         { 0x15, 0x90170110 }, /* speaker */
2844                         { }
2845                 },
2846                 .chained = true,
2847                 .chain_id = ALC262_FIXUP_BENQ,
2848         },
2849         [ALC262_FIXUP_HP_Z200] = {
2850                 .type = HDA_FIXUP_PINS,
2851                 .v.pins = (const struct hda_pintbl[]) {
2852                         { 0x16, 0x99130120 }, /* internal speaker */
2853                         { }
2854                 }
2855         },
2856         [ALC262_FIXUP_TYAN] = {
2857                 .type = HDA_FIXUP_PINS,
2858                 .v.pins = (const struct hda_pintbl[]) {
2859                         { 0x14, 0x1993e1f0 }, /* int AUX */
2860                         { }
2861                 }
2862         },
2863         [ALC262_FIXUP_LENOVO_3000] = {
2864                 .type = HDA_FIXUP_PINCTLS,
2865                 .v.pins = (const struct hda_pintbl[]) {
2866                         { 0x19, PIN_VREF50 },
2867                         {}
2868                 },
2869                 .chained = true,
2870                 .chain_id = ALC262_FIXUP_BENQ,
2871         },
2872         [ALC262_FIXUP_BENQ] = {
2873                 .type = HDA_FIXUP_VERBS,
2874                 .v.verbs = (const struct hda_verb[]) {
2875                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x07 },
2876                         { 0x20, AC_VERB_SET_PROC_COEF, 0x3070 },
2877                         {}
2878                 }
2879         },
2880         [ALC262_FIXUP_BENQ_T31] = {
2881                 .type = HDA_FIXUP_VERBS,
2882                 .v.verbs = (const struct hda_verb[]) {
2883                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x07 },
2884                         { 0x20, AC_VERB_SET_PROC_COEF, 0x3050 },
2885                         {}
2886                 }
2887         },
2888         [ALC262_FIXUP_INV_DMIC] = {
2889                 .type = HDA_FIXUP_FUNC,
2890                 .v.func = alc_fixup_inv_dmic,
2891         },
2892         [ALC262_FIXUP_INTEL_BAYLEYBAY] = {
2893                 .type = HDA_FIXUP_FUNC,
2894                 .v.func = alc_fixup_no_depop_delay,
2895         },
2896 };
2897
2898 static const struct snd_pci_quirk alc262_fixup_tbl[] = {
2899         SND_PCI_QUIRK(0x103c, 0x170b, "HP Z200", ALC262_FIXUP_HP_Z200),
2900         SND_PCI_QUIRK(0x10cf, 0x1397, "Fujitsu Lifebook S7110", ALC262_FIXUP_FSC_S7110),
2901         SND_PCI_QUIRK(0x10cf, 0x142d, "Fujitsu Lifebook E8410", ALC262_FIXUP_BENQ),
2902         SND_PCI_QUIRK(0x10f1, 0x2915, "Tyan Thunder n6650W", ALC262_FIXUP_TYAN),
2903         SND_PCI_QUIRK(0x1734, 0x1141, "FSC ESPRIMO U9210", ALC262_FIXUP_FSC_H270),
2904         SND_PCI_QUIRK(0x1734, 0x1147, "FSC Celsius H270", ALC262_FIXUP_FSC_H270),
2905         SND_PCI_QUIRK(0x17aa, 0x384e, "Lenovo 3000", ALC262_FIXUP_LENOVO_3000),
2906         SND_PCI_QUIRK(0x17ff, 0x0560, "Benq ED8", ALC262_FIXUP_BENQ),
2907         SND_PCI_QUIRK(0x17ff, 0x058d, "Benq T31-16", ALC262_FIXUP_BENQ_T31),
2908         SND_PCI_QUIRK(0x8086, 0x7270, "BayleyBay", ALC262_FIXUP_INTEL_BAYLEYBAY),
2909         {}
2910 };
2911
2912 static const struct hda_model_fixup alc262_fixup_models[] = {
2913         {.id = ALC262_FIXUP_INV_DMIC, .name = "inv-dmic"},
2914         {.id = ALC262_FIXUP_FSC_H270, .name = "fsc-h270"},
2915         {.id = ALC262_FIXUP_FSC_S7110, .name = "fsc-s7110"},
2916         {.id = ALC262_FIXUP_HP_Z200, .name = "hp-z200"},
2917         {.id = ALC262_FIXUP_TYAN, .name = "tyan"},
2918         {.id = ALC262_FIXUP_LENOVO_3000, .name = "lenovo-3000"},
2919         {.id = ALC262_FIXUP_BENQ, .name = "benq"},
2920         {.id = ALC262_FIXUP_BENQ_T31, .name = "benq-t31"},
2921         {.id = ALC262_FIXUP_INTEL_BAYLEYBAY, .name = "bayleybay"},
2922         {}
2923 };
2924
2925 /*
2926  */
2927 static int patch_alc262(struct hda_codec *codec)
2928 {
2929         struct alc_spec *spec;
2930         int err;
2931
2932         err = alc_alloc_spec(codec, 0x0b);
2933         if (err < 0)
2934                 return err;
2935
2936         spec = codec->spec;
2937         spec->gen.shared_mic_vref_pin = 0x18;
2938
2939         spec->shutup = alc_eapd_shutup;
2940
2941 #if 0
2942         /* pshou 07/11/05  set a zero PCM sample to DAC when FIFO is
2943          * under-run
2944          */
2945         alc_update_coefex_idx(codec, 0x1a, 7, 0, 0x80);
2946 #endif
2947         alc_fix_pll_init(codec, 0x20, 0x0a, 10);
2948
2949         alc_pre_init(codec);
2950
2951         snd_hda_pick_fixup(codec, alc262_fixup_models, alc262_fixup_tbl,
2952                        alc262_fixups);
2953         snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE);
2954
2955         alc_auto_parse_customize_define(codec);
2956
2957         if (has_cdefine_beep(codec))
2958                 spec->gen.beep_nid = 0x01;
2959
2960         /* automatic parse from the BIOS config */
2961         err = alc262_parse_auto_config(codec);
2962         if (err < 0)
2963                 goto error;
2964
2965         if (!spec->gen.no_analog && spec->gen.beep_nid) {
2966                 err = set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
2967                 if (err < 0)
2968                         goto error;
2969         }
2970
2971         snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE);
2972
2973         return 0;
2974
2975  error:
2976         alc_free(codec);
2977         return err;
2978 }
2979
2980 /*
2981  *  ALC268
2982  */
2983 /* bind Beep switches of both NID 0x0f and 0x10 */
2984 static int alc268_beep_switch_put(struct snd_kcontrol *kcontrol,
2985                                   struct snd_ctl_elem_value *ucontrol)
2986 {
2987         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2988         unsigned long pval;
2989         int err;
2990
2991         mutex_lock(&codec->control_mutex);
2992         pval = kcontrol->private_value;
2993         kcontrol->private_value = (pval & ~0xff) | 0x0f;
2994         err = snd_hda_mixer_amp_switch_put(kcontrol, ucontrol);
2995         if (err >= 0) {
2996                 kcontrol->private_value = (pval & ~0xff) | 0x10;
2997                 err = snd_hda_mixer_amp_switch_put(kcontrol, ucontrol);
2998         }
2999         kcontrol->private_value = pval;
3000         mutex_unlock(&codec->control_mutex);
3001         return err;
3002 }
3003
3004 static const struct snd_kcontrol_new alc268_beep_mixer[] = {
3005         HDA_CODEC_VOLUME("Beep Playback Volume", 0x1d, 0x0, HDA_INPUT),
3006         {
3007                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3008                 .name = "Beep Playback Switch",
3009                 .subdevice = HDA_SUBDEV_AMP_FLAG,
3010                 .info = snd_hda_mixer_amp_switch_info,
3011                 .get = snd_hda_mixer_amp_switch_get,
3012                 .put = alc268_beep_switch_put,
3013                 .private_value = HDA_COMPOSE_AMP_VAL(0x0f, 3, 1, HDA_INPUT)
3014         },
3015 };
3016
3017 /* set PCBEEP vol = 0, mute connections */
3018 static const struct hda_verb alc268_beep_init_verbs[] = {
3019         {0x1d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
3020         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
3021         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
3022         { }
3023 };
3024
3025 enum {
3026         ALC268_FIXUP_INV_DMIC,
3027         ALC268_FIXUP_HP_EAPD,
3028         ALC268_FIXUP_SPDIF,
3029 };
3030
3031 static const struct hda_fixup alc268_fixups[] = {
3032         [ALC268_FIXUP_INV_DMIC] = {
3033                 .type = HDA_FIXUP_FUNC,
3034                 .v.func = alc_fixup_inv_dmic,
3035         },
3036         [ALC268_FIXUP_HP_EAPD] = {
3037                 .type = HDA_FIXUP_VERBS,
3038                 .v.verbs = (const struct hda_verb[]) {
3039                         {0x15, AC_VERB_SET_EAPD_BTLENABLE, 0},
3040                         {}
3041                 }
3042         },
3043         [ALC268_FIXUP_SPDIF] = {
3044                 .type = HDA_FIXUP_PINS,
3045                 .v.pins = (const struct hda_pintbl[]) {
3046                         { 0x1e, 0x014b1180 }, /* enable SPDIF out */
3047                         {}
3048                 }
3049         },
3050 };
3051
3052 static const struct hda_model_fixup alc268_fixup_models[] = {
3053         {.id = ALC268_FIXUP_INV_DMIC, .name = "inv-dmic"},
3054         {.id = ALC268_FIXUP_HP_EAPD, .name = "hp-eapd"},
3055         {.id = ALC268_FIXUP_SPDIF, .name = "spdif"},
3056         {}
3057 };
3058
3059 static const struct snd_pci_quirk alc268_fixup_tbl[] = {
3060         SND_PCI_QUIRK(0x1025, 0x0139, "Acer TravelMate 6293", ALC268_FIXUP_SPDIF),
3061         SND_PCI_QUIRK(0x1025, 0x015b, "Acer AOA 150 (ZG5)", ALC268_FIXUP_INV_DMIC),
3062         /* below is codec SSID since multiple Toshiba laptops have the
3063          * same PCI SSID 1179:ff00
3064          */
3065         SND_PCI_QUIRK(0x1179, 0xff06, "Toshiba P200", ALC268_FIXUP_HP_EAPD),
3066         {}
3067 };
3068
3069 /*
3070  * BIOS auto configuration
3071  */
3072 static int alc268_parse_auto_config(struct hda_codec *codec)
3073 {
3074         static const hda_nid_t alc268_ssids[] = { 0x15, 0x1b, 0x14, 0 };
3075         return alc_parse_auto_config(codec, NULL, alc268_ssids);
3076 }
3077
3078 /*
3079  */
3080 static int patch_alc268(struct hda_codec *codec)
3081 {
3082         struct alc_spec *spec;
3083         int i, err;
3084
3085         /* ALC268 has no aa-loopback mixer */
3086         err = alc_alloc_spec(codec, 0);
3087         if (err < 0)
3088                 return err;
3089
3090         spec = codec->spec;
3091         if (has_cdefine_beep(codec))
3092                 spec->gen.beep_nid = 0x01;
3093
3094         spec->shutup = alc_eapd_shutup;
3095
3096         alc_pre_init(codec);
3097
3098         snd_hda_pick_fixup(codec, alc268_fixup_models, alc268_fixup_tbl, alc268_fixups);
3099         snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE);
3100
3101         /* automatic parse from the BIOS config */
3102         err = alc268_parse_auto_config(codec);
3103         if (err < 0)
3104                 goto error;
3105
3106         if (err > 0 && !spec->gen.no_analog &&
3107             spec->gen.autocfg.speaker_pins[0] != 0x1d) {
3108                 for (i = 0; i < ARRAY_SIZE(alc268_beep_mixer); i++) {
3109                         if (!snd_hda_gen_add_kctl(&spec->gen, NULL,
3110                                                   &alc268_beep_mixer[i])) {
3111                                 err = -ENOMEM;
3112                                 goto error;
3113                         }
3114                 }
3115                 snd_hda_add_verbs(codec, alc268_beep_init_verbs);
3116                 if (!query_amp_caps(codec, 0x1d, HDA_INPUT))
3117                         /* override the amp caps for beep generator */
3118                         snd_hda_override_amp_caps(codec, 0x1d, HDA_INPUT,
3119                                           (0x0c << AC_AMPCAP_OFFSET_SHIFT) |
3120                                           (0x0c << AC_AMPCAP_NUM_STEPS_SHIFT) |
3121                                           (0x07 << AC_AMPCAP_STEP_SIZE_SHIFT) |
3122                                           (0 << AC_AMPCAP_MUTE_SHIFT));
3123         }
3124
3125         snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE);
3126
3127         return 0;
3128
3129  error:
3130         alc_free(codec);
3131         return err;
3132 }
3133
3134 /*
3135  * ALC269
3136  */
3137
3138 static const struct hda_pcm_stream alc269_44k_pcm_analog_playback = {
3139         .rates = SNDRV_PCM_RATE_44100, /* fixed rate */
3140 };
3141
3142 static const struct hda_pcm_stream alc269_44k_pcm_analog_capture = {
3143         .rates = SNDRV_PCM_RATE_44100, /* fixed rate */
3144 };
3145
3146 /* different alc269-variants */
3147 enum {
3148         ALC269_TYPE_ALC269VA,
3149         ALC269_TYPE_ALC269VB,
3150         ALC269_TYPE_ALC269VC,
3151         ALC269_TYPE_ALC269VD,
3152         ALC269_TYPE_ALC280,
3153         ALC269_TYPE_ALC282,
3154         ALC269_TYPE_ALC283,
3155         ALC269_TYPE_ALC284,
3156         ALC269_TYPE_ALC293,
3157         ALC269_TYPE_ALC286,
3158         ALC269_TYPE_ALC298,
3159         ALC269_TYPE_ALC255,
3160         ALC269_TYPE_ALC256,
3161         ALC269_TYPE_ALC257,
3162         ALC269_TYPE_ALC215,
3163         ALC269_TYPE_ALC225,
3164         ALC269_TYPE_ALC245,
3165         ALC269_TYPE_ALC287,
3166         ALC269_TYPE_ALC294,
3167         ALC269_TYPE_ALC300,
3168         ALC269_TYPE_ALC623,
3169         ALC269_TYPE_ALC700,
3170 };
3171
3172 /*
3173  * BIOS auto configuration
3174  */
3175 static int alc269_parse_auto_config(struct hda_codec *codec)
3176 {
3177         static const hda_nid_t alc269_ignore[] = { 0x1d, 0 };
3178         static const hda_nid_t alc269_ssids[] = { 0, 0x1b, 0x14, 0x21 };
3179         static const hda_nid_t alc269va_ssids[] = { 0x15, 0x1b, 0x14, 0 };
3180         struct alc_spec *spec = codec->spec;
3181         const hda_nid_t *ssids;
3182
3183         switch (spec->codec_variant) {
3184         case ALC269_TYPE_ALC269VA:
3185         case ALC269_TYPE_ALC269VC:
3186         case ALC269_TYPE_ALC280:
3187         case ALC269_TYPE_ALC284:
3188         case ALC269_TYPE_ALC293:
3189                 ssids = alc269va_ssids;
3190                 break;
3191         case ALC269_TYPE_ALC269VB:
3192         case ALC269_TYPE_ALC269VD:
3193         case ALC269_TYPE_ALC282:
3194         case ALC269_TYPE_ALC283:
3195         case ALC269_TYPE_ALC286:
3196         case ALC269_TYPE_ALC298:
3197         case ALC269_TYPE_ALC255:
3198         case ALC269_TYPE_ALC256:
3199         case ALC269_TYPE_ALC257:
3200         case ALC269_TYPE_ALC215:
3201         case ALC269_TYPE_ALC225:
3202         case ALC269_TYPE_ALC245:
3203         case ALC269_TYPE_ALC287:
3204         case ALC269_TYPE_ALC294:
3205         case ALC269_TYPE_ALC300:
3206         case ALC269_TYPE_ALC623:
3207         case ALC269_TYPE_ALC700:
3208                 ssids = alc269_ssids;
3209                 break;
3210         default:
3211                 ssids = alc269_ssids;
3212                 break;
3213         }
3214
3215         return alc_parse_auto_config(codec, alc269_ignore, ssids);
3216 }
3217
3218 static const struct hda_jack_keymap alc_headset_btn_keymap[] = {
3219         { SND_JACK_BTN_0, KEY_PLAYPAUSE },
3220         { SND_JACK_BTN_1, KEY_VOICECOMMAND },
3221         { SND_JACK_BTN_2, KEY_VOLUMEUP },
3222         { SND_JACK_BTN_3, KEY_VOLUMEDOWN },
3223         {}
3224 };
3225
3226 static void alc_headset_btn_callback(struct hda_codec *codec,
3227                                      struct hda_jack_callback *jack)
3228 {
3229         int report = 0;
3230
3231         if (jack->unsol_res & (7 << 13))
3232                 report |= SND_JACK_BTN_0;
3233
3234         if (jack->unsol_res  & (1 << 16 | 3 << 8))
3235                 report |= SND_JACK_BTN_1;
3236
3237         /* Volume up key */
3238         if (jack->unsol_res & (7 << 23))
3239                 report |= SND_JACK_BTN_2;
3240
3241         /* Volume down key */
3242         if (jack->unsol_res & (7 << 10))
3243                 report |= SND_JACK_BTN_3;
3244
3245         snd_hda_jack_set_button_state(codec, jack->nid, report);
3246 }
3247
3248 static void alc_disable_headset_jack_key(struct hda_codec *codec)
3249 {
3250         struct alc_spec *spec = codec->spec;
3251
3252         if (!spec->has_hs_key)
3253                 return;
3254
3255         switch (codec->core.vendor_id) {
3256         case 0x10ec0215:
3257         case 0x10ec0225:
3258         case 0x10ec0285:
3259         case 0x10ec0287:
3260         case 0x10ec0295:
3261         case 0x10ec0289:
3262         case 0x10ec0299:
3263                 alc_write_coef_idx(codec, 0x48, 0x0);
3264                 alc_update_coef_idx(codec, 0x49, 0x0045, 0x0);
3265                 alc_update_coef_idx(codec, 0x44, 0x0045 << 8, 0x0);
3266                 break;
3267         case 0x10ec0230:
3268         case 0x10ec0236:
3269         case 0x10ec0256:
3270         case 0x10ec0257:
3271         case 0x19e58326:
3272                 alc_write_coef_idx(codec, 0x48, 0x0);
3273                 alc_update_coef_idx(codec, 0x49, 0x0045, 0x0);
3274                 break;
3275         }
3276 }
3277
3278 static void alc_enable_headset_jack_key(struct hda_codec *codec)
3279 {
3280         struct alc_spec *spec = codec->spec;
3281
3282         if (!spec->has_hs_key)
3283                 return;
3284
3285         switch (codec->core.vendor_id) {
3286         case 0x10ec0215:
3287         case 0x10ec0225:
3288         case 0x10ec0285:
3289         case 0x10ec0287:
3290         case 0x10ec0295:
3291         case 0x10ec0289:
3292         case 0x10ec0299:
3293                 alc_write_coef_idx(codec, 0x48, 0xd011);
3294                 alc_update_coef_idx(codec, 0x49, 0x007f, 0x0045);
3295                 alc_update_coef_idx(codec, 0x44, 0x007f << 8, 0x0045 << 8);
3296                 break;
3297         case 0x10ec0230:
3298         case 0x10ec0236:
3299         case 0x10ec0256:
3300         case 0x10ec0257:
3301         case 0x19e58326:
3302                 alc_write_coef_idx(codec, 0x48, 0xd011);
3303                 alc_update_coef_idx(codec, 0x49, 0x007f, 0x0045);
3304                 break;
3305         }
3306 }
3307
3308 static void alc_fixup_headset_jack(struct hda_codec *codec,
3309                                     const struct hda_fixup *fix, int action)
3310 {
3311         struct alc_spec *spec = codec->spec;
3312         hda_nid_t hp_pin;
3313
3314         switch (action) {
3315         case HDA_FIXUP_ACT_PRE_PROBE:
3316                 spec->has_hs_key = 1;
3317                 snd_hda_jack_detect_enable_callback(codec, 0x55,
3318                                                     alc_headset_btn_callback);
3319                 break;
3320         case HDA_FIXUP_ACT_BUILD:
3321                 hp_pin = alc_get_hp_pin(spec);
3322                 if (!hp_pin || snd_hda_jack_bind_keymap(codec, 0x55,
3323                                                         alc_headset_btn_keymap,
3324                                                         hp_pin))
3325                         snd_hda_jack_add_kctl(codec, 0x55, "Headset Jack",
3326                                               false, SND_JACK_HEADSET,
3327                                               alc_headset_btn_keymap);
3328
3329                 alc_enable_headset_jack_key(codec);
3330                 break;
3331         }
3332 }
3333
3334 static void alc269vb_toggle_power_output(struct hda_codec *codec, int power_up)
3335 {
3336         alc_update_coef_idx(codec, 0x04, 1 << 11, power_up ? (1 << 11) : 0);
3337 }
3338
3339 static void alc269_shutup(struct hda_codec *codec)
3340 {
3341         struct alc_spec *spec = codec->spec;
3342
3343         if (spec->codec_variant == ALC269_TYPE_ALC269VB)
3344                 alc269vb_toggle_power_output(codec, 0);
3345         if (spec->codec_variant == ALC269_TYPE_ALC269VB &&
3346                         (alc_get_coef0(codec) & 0x00ff) == 0x018) {
3347                 msleep(150);
3348         }
3349         alc_shutup_pins(codec);
3350 }
3351
3352 static const struct coef_fw alc282_coefs[] = {
3353         WRITE_COEF(0x03, 0x0002), /* Power Down Control */
3354         UPDATE_COEF(0x05, 0xff3f, 0x0700), /* FIFO and filter clock */
3355         WRITE_COEF(0x07, 0x0200), /* DMIC control */
3356         UPDATE_COEF(0x06, 0x00f0, 0), /* Analog clock */
3357         UPDATE_COEF(0x08, 0xfffc, 0x0c2c), /* JD */
3358         WRITE_COEF(0x0a, 0xcccc), /* JD offset1 */
3359         WRITE_COEF(0x0b, 0xcccc), /* JD offset2 */
3360         WRITE_COEF(0x0e, 0x6e00), /* LDO1/2/3, DAC/ADC */
3361         UPDATE_COEF(0x0f, 0xf800, 0x1000), /* JD */
3362         UPDATE_COEF(0x10, 0xfc00, 0x0c00), /* Capless */
3363         WRITE_COEF(0x6f, 0x0), /* Class D test 4 */
3364         UPDATE_COEF(0x0c, 0xfe00, 0), /* IO power down directly */
3365         WRITE_COEF(0x34, 0xa0c0), /* ANC */
3366         UPDATE_COEF(0x16, 0x0008, 0), /* AGC MUX */
3367         UPDATE_COEF(0x1d, 0x00e0, 0), /* DAC simple content protection */
3368         UPDATE_COEF(0x1f, 0x00e0, 0), /* ADC simple content protection */
3369         WRITE_COEF(0x21, 0x8804), /* DAC ADC Zero Detection */
3370         WRITE_COEF(0x63, 0x2902), /* PLL */
3371         WRITE_COEF(0x68, 0xa080), /* capless control 2 */
3372         WRITE_COEF(0x69, 0x3400), /* capless control 3 */
3373         WRITE_COEF(0x6a, 0x2f3e), /* capless control 4 */
3374         WRITE_COEF(0x6b, 0x0), /* capless control 5 */
3375         UPDATE_COEF(0x6d, 0x0fff, 0x0900), /* class D test 2 */
3376         WRITE_COEF(0x6e, 0x110a), /* class D test 3 */
3377         UPDATE_COEF(0x70, 0x00f8, 0x00d8), /* class D test 5 */
3378         WRITE_COEF(0x71, 0x0014), /* class D test 6 */
3379         WRITE_COEF(0x72, 0xc2ba), /* classD OCP */
3380         UPDATE_COEF(0x77, 0x0f80, 0), /* classD pure DC test */
3381         WRITE_COEF(0x6c, 0xfc06), /* Class D amp control */
3382         {}
3383 };
3384
3385 static void alc282_restore_default_value(struct hda_codec *codec)
3386 {
3387         alc_process_coef_fw(codec, alc282_coefs);
3388 }
3389
3390 static void alc282_init(struct hda_codec *codec)
3391 {
3392         struct alc_spec *spec = codec->spec;
3393         hda_nid_t hp_pin = alc_get_hp_pin(spec);
3394         bool hp_pin_sense;
3395         int coef78;
3396
3397         alc282_restore_default_value(codec);
3398
3399         if (!hp_pin)
3400                 return;
3401         hp_pin_sense = snd_hda_jack_detect(codec, hp_pin);
3402         coef78 = alc_read_coef_idx(codec, 0x78);
3403
3404         /* Index 0x78 Direct Drive HP AMP LPM Control 1 */
3405         /* Headphone capless set to high power mode */
3406         alc_write_coef_idx(codec, 0x78, 0x9004);
3407
3408         if (hp_pin_sense)
3409                 msleep(2);
3410
3411         snd_hda_codec_write(codec, hp_pin, 0,
3412                             AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);
3413
3414         if (hp_pin_sense)
3415                 msleep(85);
3416
3417         snd_hda_codec_write(codec, hp_pin, 0,
3418                             AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT);
3419
3420         if (hp_pin_sense)
3421                 msleep(100);
3422
3423         /* Headphone capless set to normal mode */
3424         alc_write_coef_idx(codec, 0x78, coef78);
3425 }
3426
3427 static void alc282_shutup(struct hda_codec *codec)
3428 {
3429         struct alc_spec *spec = codec->spec;
3430         hda_nid_t hp_pin = alc_get_hp_pin(spec);
3431         bool hp_pin_sense;
3432         int coef78;
3433
3434         if (!hp_pin) {
3435                 alc269_shutup(codec);
3436                 return;
3437         }
3438
3439         hp_pin_sense = snd_hda_jack_detect(codec, hp_pin);
3440         coef78 = alc_read_coef_idx(codec, 0x78);
3441         alc_write_coef_idx(codec, 0x78, 0x9004);
3442
3443         if (hp_pin_sense)
3444                 msleep(2);
3445
3446         snd_hda_codec_write(codec, hp_pin, 0,
3447                             AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);
3448
3449         if (hp_pin_sense)
3450                 msleep(85);
3451
3452         if (!spec->no_shutup_pins)
3453                 snd_hda_codec_write(codec, hp_pin, 0,
3454                                     AC_VERB_SET_PIN_WIDGET_CONTROL, 0x0);
3455
3456         if (hp_pin_sense)
3457                 msleep(100);
3458
3459         alc_auto_setup_eapd(codec, false);
3460         alc_shutup_pins(codec);
3461         alc_write_coef_idx(codec, 0x78, coef78);
3462 }
3463
3464 static const struct coef_fw alc283_coefs[] = {
3465         WRITE_COEF(0x03, 0x0002), /* Power Down Control */
3466         UPDATE_COEF(0x05, 0xff3f, 0x0700), /* FIFO and filter clock */
3467         WRITE_COEF(0x07, 0x0200), /* DMIC control */
3468         UPDATE_COEF(0x06, 0x00f0, 0), /* Analog clock */
3469         UPDATE_COEF(0x08, 0xfffc, 0x0c2c), /* JD */
3470         WRITE_COEF(0x0a, 0xcccc), /* JD offset1 */
3471         WRITE_COEF(0x0b, 0xcccc), /* JD offset2 */
3472         WRITE_COEF(0x0e, 0x6fc0), /* LDO1/2/3, DAC/ADC */
3473         UPDATE_COEF(0x0f, 0xf800, 0x1000), /* JD */
3474         UPDATE_COEF(0x10, 0xfc00, 0x0c00), /* Capless */
3475         WRITE_COEF(0x3a, 0x0), /* Class D test 4 */
3476         UPDATE_COEF(0x0c, 0xfe00, 0x0), /* IO power down directly */
3477         WRITE_COEF(0x22, 0xa0c0), /* ANC */
3478         UPDATE_COEFEX(0x53, 0x01, 0x000f, 0x0008), /* AGC MUX */
3479         UPDATE_COEF(0x1d, 0x00e0, 0), /* DAC simple content protection */
3480         UPDATE_COEF(0x1f, 0x00e0, 0), /* ADC simple content protection */
3481         WRITE_COEF(0x21, 0x8804), /* DAC ADC Zero Detection */
3482         WRITE_COEF(0x2e, 0x2902), /* PLL */
3483         WRITE_COEF(0x33, 0xa080), /* capless control 2 */
3484         WRITE_COEF(0x34, 0x3400), /* capless control 3 */
3485         WRITE_COEF(0x35, 0x2f3e), /* capless control 4 */
3486         WRITE_COEF(0x36, 0x0), /* capless control 5 */
3487         UPDATE_COEF(0x38, 0x0fff, 0x0900), /* class D test 2 */
3488         WRITE_COEF(0x39, 0x110a), /* class D test 3 */
3489         UPDATE_COEF(0x3b, 0x00f8, 0x00d8), /* class D test 5 */
3490         WRITE_COEF(0x3c, 0x0014), /* class D test 6 */
3491         WRITE_COEF(0x3d, 0xc2ba), /* classD OCP */
3492         UPDATE_COEF(0x42, 0x0f80, 0x0), /* classD pure DC test */
3493         WRITE_COEF(0x49, 0x0), /* test mode */
3494         UPDATE_COEF(0x40, 0xf800, 0x9800), /* Class D DC enable */
3495         UPDATE_COEF(0x42, 0xf000, 0x2000), /* DC offset */
3496         WRITE_COEF(0x37, 0xfc06), /* Class D amp control */
3497         UPDATE_COEF(0x1b, 0x8000, 0), /* HP JD control */
3498         {}
3499 };
3500
3501 static void alc283_restore_default_value(struct hda_codec *codec)
3502 {
3503         alc_process_coef_fw(codec, alc283_coefs);
3504 }
3505
3506 static void alc283_init(struct hda_codec *codec)
3507 {
3508         struct alc_spec *spec = codec->spec;
3509         hda_nid_t hp_pin = alc_get_hp_pin(spec);
3510         bool hp_pin_sense;
3511
3512         alc283_restore_default_value(codec);
3513
3514         if (!hp_pin)
3515                 return;
3516
3517         msleep(30);
3518         hp_pin_sense = snd_hda_jack_detect(codec, hp_pin);
3519
3520         /* Index 0x43 Direct Drive HP AMP LPM Control 1 */
3521         /* Headphone capless set to high power mode */
3522         alc_write_coef_idx(codec, 0x43, 0x9004);
3523
3524         snd_hda_codec_write(codec, hp_pin, 0,
3525                             AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);
3526
3527         if (hp_pin_sense)
3528                 msleep(85);
3529
3530         snd_hda_codec_write(codec, hp_pin, 0,
3531                             AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT);
3532
3533         if (hp_pin_sense)
3534                 msleep(85);
3535         /* Index 0x46 Combo jack auto switch control 2 */
3536         /* 3k pull low control for Headset jack. */
3537         alc_update_coef_idx(codec, 0x46, 3 << 12, 0);
3538         /* Headphone capless set to normal mode */
3539         alc_write_coef_idx(codec, 0x43, 0x9614);
3540 }
3541
3542 static void alc283_shutup(struct hda_codec *codec)
3543 {
3544         struct alc_spec *spec = codec->spec;
3545         hda_nid_t hp_pin = alc_get_hp_pin(spec);
3546         bool hp_pin_sense;
3547
3548         if (!hp_pin) {
3549                 alc269_shutup(codec);
3550                 return;
3551         }
3552
3553         hp_pin_sense = snd_hda_jack_detect(codec, hp_pin);
3554
3555         alc_write_coef_idx(codec, 0x43, 0x9004);
3556
3557         /*depop hp during suspend*/
3558         alc_write_coef_idx(codec, 0x06, 0x2100);
3559
3560         snd_hda_codec_write(codec, hp_pin, 0,
3561                             AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);
3562
3563         if (hp_pin_sense)
3564                 msleep(100);
3565
3566         if (!spec->no_shutup_pins)
3567                 snd_hda_codec_write(codec, hp_pin, 0,
3568                                     AC_VERB_SET_PIN_WIDGET_CONTROL, 0x0);
3569
3570         alc_update_coef_idx(codec, 0x46, 0, 3 << 12);
3571
3572         if (hp_pin_sense)
3573                 msleep(100);
3574         alc_auto_setup_eapd(codec, false);
3575         alc_shutup_pins(codec);
3576         alc_write_coef_idx(codec, 0x43, 0x9614);
3577 }
3578
3579 static void alc256_init(struct hda_codec *codec)
3580 {
3581         struct alc_spec *spec = codec->spec;
3582         hda_nid_t hp_pin = alc_get_hp_pin(spec);
3583         bool hp_pin_sense;
3584
3585         if (spec->ultra_low_power) {
3586                 alc_update_coef_idx(codec, 0x03, 1<<1, 1<<1);
3587                 alc_update_coef_idx(codec, 0x08, 3<<2, 3<<2);
3588                 alc_update_coef_idx(codec, 0x08, 7<<4, 0);
3589                 alc_update_coef_idx(codec, 0x3b, 1<<15, 0);
3590                 alc_update_coef_idx(codec, 0x0e, 7<<6, 7<<6);
3591                 msleep(30);
3592         }
3593
3594         if (!hp_pin)
3595                 hp_pin = 0x21;
3596
3597         msleep(30);
3598
3599         hp_pin_sense = snd_hda_jack_detect(codec, hp_pin);
3600
3601         if (hp_pin_sense)
3602                 msleep(2);
3603
3604         alc_update_coefex_idx(codec, 0x57, 0x04, 0x0007, 0x1); /* Low power */
3605
3606         snd_hda_codec_write(codec, hp_pin, 0,
3607                             AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);
3608
3609         if (hp_pin_sense || spec->ultra_low_power)
3610                 msleep(85);
3611
3612         snd_hda_codec_write(codec, hp_pin, 0,
3613                             AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT);
3614
3615         if (hp_pin_sense || spec->ultra_low_power)
3616                 msleep(100);
3617
3618         alc_update_coef_idx(codec, 0x46, 3 << 12, 0);
3619         alc_update_coefex_idx(codec, 0x57, 0x04, 0x0007, 0x4); /* Hight power */
3620         alc_update_coefex_idx(codec, 0x53, 0x02, 0x8000, 1 << 15); /* Clear bit */
3621         alc_update_coefex_idx(codec, 0x53, 0x02, 0x8000, 0 << 15);
3622         /*
3623          * Expose headphone mic (or possibly Line In on some machines) instead
3624          * of PC Beep on 1Ah, and disable 1Ah loopback for all outputs. See
3625          * Documentation/sound/hd-audio/realtek-pc-beep.rst for details of
3626          * this register.
3627          */
3628         alc_write_coef_idx(codec, 0x36, 0x5757);
3629 }
3630
3631 static void alc256_shutup(struct hda_codec *codec)
3632 {
3633         struct alc_spec *spec = codec->spec;
3634         hda_nid_t hp_pin = alc_get_hp_pin(spec);
3635         bool hp_pin_sense;
3636
3637         if (!hp_pin)
3638                 hp_pin = 0x21;
3639
3640         alc_update_coefex_idx(codec, 0x57, 0x04, 0x0007, 0x1); /* Low power */
3641         hp_pin_sense = snd_hda_jack_detect(codec, hp_pin);
3642
3643         if (hp_pin_sense)
3644                 msleep(2);
3645
3646         snd_hda_codec_write(codec, hp_pin, 0,
3647                             AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);
3648
3649         if (hp_pin_sense || spec->ultra_low_power)
3650                 msleep(85);
3651
3652         /* 3k pull low control for Headset jack. */
3653         /* NOTE: call this before clearing the pin, otherwise codec stalls */
3654         /* If disable 3k pulldown control for alc257, the Mic detection will not work correctly
3655          * when booting with headset plugged. So skip setting it for the codec alc257
3656          */
3657         if (spec->en_3kpull_low)
3658                 alc_update_coef_idx(codec, 0x46, 0, 3 << 12);
3659
3660         if (!spec->no_shutup_pins)
3661                 snd_hda_codec_write(codec, hp_pin, 0,
3662                                     AC_VERB_SET_PIN_WIDGET_CONTROL, 0x0);
3663
3664         if (hp_pin_sense || spec->ultra_low_power)
3665                 msleep(100);
3666
3667         alc_auto_setup_eapd(codec, false);
3668         alc_shutup_pins(codec);
3669         if (spec->ultra_low_power) {
3670                 msleep(50);
3671                 alc_update_coef_idx(codec, 0x03, 1<<1, 0);
3672                 alc_update_coef_idx(codec, 0x08, 7<<4, 7<<4);
3673                 alc_update_coef_idx(codec, 0x08, 3<<2, 0);
3674                 alc_update_coef_idx(codec, 0x3b, 1<<15, 1<<15);
3675                 alc_update_coef_idx(codec, 0x0e, 7<<6, 0);
3676                 msleep(30);
3677         }
3678 }
3679
3680 static void alc285_hp_init(struct hda_codec *codec)
3681 {
3682         struct alc_spec *spec = codec->spec;
3683         hda_nid_t hp_pin = alc_get_hp_pin(spec);
3684         int i, val;
3685         int coef38, coef0d, coef36;
3686
3687         alc_write_coefex_idx(codec, 0x58, 0x00, 0x1888); /* write default value */
3688         alc_update_coef_idx(codec, 0x4a, 1<<15, 1<<15); /* Reset HP JD */
3689         coef38 = alc_read_coef_idx(codec, 0x38); /* Amp control */
3690         coef0d = alc_read_coef_idx(codec, 0x0d); /* Digital Misc control */
3691         coef36 = alc_read_coef_idx(codec, 0x36); /* Passthrough Control */
3692         alc_update_coef_idx(codec, 0x38, 1<<4, 0x0);
3693         alc_update_coef_idx(codec, 0x0d, 0x110, 0x0);
3694
3695         alc_update_coef_idx(codec, 0x67, 0xf000, 0x3000);
3696
3697         if (hp_pin)
3698                 snd_hda_codec_write(codec, hp_pin, 0,
3699                             AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);
3700
3701         msleep(130);
3702         alc_update_coef_idx(codec, 0x36, 1<<14, 1<<14);
3703         alc_update_coef_idx(codec, 0x36, 1<<13, 0x0);
3704
3705         if (hp_pin)
3706                 snd_hda_codec_write(codec, hp_pin, 0,
3707                             AC_VERB_SET_PIN_WIDGET_CONTROL, 0x0);
3708         msleep(10);
3709         alc_write_coef_idx(codec, 0x67, 0x0); /* Set HP depop to manual mode */
3710         alc_write_coefex_idx(codec, 0x58, 0x00, 0x7880);
3711         alc_write_coefex_idx(codec, 0x58, 0x0f, 0xf049);
3712         alc_update_coefex_idx(codec, 0x58, 0x03, 0x00f0, 0x00c0);
3713
3714         alc_write_coefex_idx(codec, 0x58, 0x00, 0xf888); /* HP depop procedure start */
3715         val = alc_read_coefex_idx(codec, 0x58, 0x00);
3716         for (i = 0; i < 20 && val & 0x8000; i++) {
3717                 msleep(50);
3718                 val = alc_read_coefex_idx(codec, 0x58, 0x00);
3719         } /* Wait for depop procedure finish  */
3720
3721         alc_write_coefex_idx(codec, 0x58, 0x00, val); /* write back the result */
3722         alc_update_coef_idx(codec, 0x38, 1<<4, coef38);
3723         alc_update_coef_idx(codec, 0x0d, 0x110, coef0d);
3724         alc_update_coef_idx(codec, 0x36, 3<<13, coef36);
3725
3726         msleep(50);
3727         alc_update_coef_idx(codec, 0x4a, 1<<15, 0);
3728 }
3729
3730 static void alc225_init(struct hda_codec *codec)
3731 {
3732         struct alc_spec *spec = codec->spec;
3733         hda_nid_t hp_pin = alc_get_hp_pin(spec);
3734         bool hp1_pin_sense, hp2_pin_sense;
3735
3736         if (spec->ultra_low_power) {
3737                 alc_update_coef_idx(codec, 0x08, 0x0f << 2, 3<<2);
3738                 alc_update_coef_idx(codec, 0x0e, 7<<6, 7<<6);
3739                 alc_update_coef_idx(codec, 0x33, 1<<11, 0);
3740                 msleep(30);
3741         }
3742
3743         if (spec->codec_variant != ALC269_TYPE_ALC287 &&
3744                 spec->codec_variant != ALC269_TYPE_ALC245)
3745                 /* required only at boot or S3 and S4 resume time */
3746                 if (!spec->done_hp_init ||
3747                         is_s3_resume(codec) ||
3748                         is_s4_resume(codec)) {
3749                         alc285_hp_init(codec);
3750                         spec->done_hp_init = true;
3751                 }
3752
3753         if (!hp_pin)
3754                 hp_pin = 0x21;
3755         msleep(30);
3756
3757         hp1_pin_sense = snd_hda_jack_detect(codec, hp_pin);
3758         hp2_pin_sense = snd_hda_jack_detect(codec, 0x16);
3759
3760         if (hp1_pin_sense || hp2_pin_sense)
3761                 msleep(2);
3762
3763         alc_update_coefex_idx(codec, 0x57, 0x04, 0x0007, 0x1); /* Low power */
3764
3765         if (hp1_pin_sense || spec->ultra_low_power)
3766                 snd_hda_codec_write(codec, hp_pin, 0,
3767                             AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);
3768         if (hp2_pin_sense)
3769                 snd_hda_codec_write(codec, 0x16, 0,
3770                             AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);
3771
3772         if (hp1_pin_sense || hp2_pin_sense || spec->ultra_low_power)
3773                 msleep(85);
3774
3775         if (hp1_pin_sense || spec->ultra_low_power)
3776                 snd_hda_codec_write(codec, hp_pin, 0,
3777                             AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT);
3778         if (hp2_pin_sense)
3779                 snd_hda_codec_write(codec, 0x16, 0,
3780                             AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT);
3781
3782         if (hp1_pin_sense || hp2_pin_sense || spec->ultra_low_power)
3783                 msleep(100);
3784
3785         alc_update_coef_idx(codec, 0x4a, 3 << 10, 0);
3786         alc_update_coefex_idx(codec, 0x57, 0x04, 0x0007, 0x4); /* Hight power */
3787 }
3788
3789 static void alc225_shutup(struct hda_codec *codec)
3790 {
3791         struct alc_spec *spec = codec->spec;
3792         hda_nid_t hp_pin = alc_get_hp_pin(spec);
3793         bool hp1_pin_sense, hp2_pin_sense;
3794
3795         if (!hp_pin)
3796                 hp_pin = 0x21;
3797
3798         alc_disable_headset_jack_key(codec);
3799         /* 3k pull low control for Headset jack. */
3800         alc_update_coef_idx(codec, 0x4a, 0, 3 << 10);
3801
3802         hp1_pin_sense = snd_hda_jack_detect(codec, hp_pin);
3803         hp2_pin_sense = snd_hda_jack_detect(codec, 0x16);
3804
3805         if (hp1_pin_sense || hp2_pin_sense)
3806                 msleep(2);
3807
3808         if (hp1_pin_sense || spec->ultra_low_power)
3809                 snd_hda_codec_write(codec, hp_pin, 0,
3810                             AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);
3811         if (hp2_pin_sense)
3812                 snd_hda_codec_write(codec, 0x16, 0,
3813                             AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);
3814
3815         if (hp1_pin_sense || hp2_pin_sense || spec->ultra_low_power)
3816                 msleep(85);
3817
3818         if (hp1_pin_sense || spec->ultra_low_power)
3819                 snd_hda_codec_write(codec, hp_pin, 0,
3820                             AC_VERB_SET_PIN_WIDGET_CONTROL, 0x0);
3821         if (hp2_pin_sense)
3822                 snd_hda_codec_write(codec, 0x16, 0,
3823                             AC_VERB_SET_PIN_WIDGET_CONTROL, 0x0);
3824
3825         if (hp1_pin_sense || hp2_pin_sense || spec->ultra_low_power)
3826                 msleep(100);
3827
3828         alc_auto_setup_eapd(codec, false);
3829         alc_shutup_pins(codec);
3830         if (spec->ultra_low_power) {
3831                 msleep(50);
3832                 alc_update_coef_idx(codec, 0x08, 0x0f << 2, 0x0c << 2);
3833                 alc_update_coef_idx(codec, 0x0e, 7<<6, 0);
3834                 alc_update_coef_idx(codec, 0x33, 1<<11, 1<<11);
3835                 alc_update_coef_idx(codec, 0x4a, 3<<4, 2<<4);
3836                 msleep(30);
3837         }
3838
3839         alc_update_coef_idx(codec, 0x4a, 3 << 10, 0);
3840         alc_enable_headset_jack_key(codec);
3841 }
3842
3843 static void alc_default_init(struct hda_codec *codec)
3844 {
3845         struct alc_spec *spec = codec->spec;
3846         hda_nid_t hp_pin = alc_get_hp_pin(spec);
3847         bool hp_pin_sense;
3848
3849         if (!hp_pin)
3850                 return;
3851
3852         msleep(30);
3853
3854         hp_pin_sense = snd_hda_jack_detect(codec, hp_pin);
3855
3856         if (hp_pin_sense)
3857                 msleep(2);
3858
3859         snd_hda_codec_write(codec, hp_pin, 0,
3860                             AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);
3861
3862         if (hp_pin_sense)
3863                 msleep(85);
3864
3865         snd_hda_codec_write(codec, hp_pin, 0,
3866                             AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT);
3867
3868         if (hp_pin_sense)
3869                 msleep(100);
3870 }
3871
3872 static void alc_default_shutup(struct hda_codec *codec)
3873 {
3874         struct alc_spec *spec = codec->spec;
3875         hda_nid_t hp_pin = alc_get_hp_pin(spec);
3876         bool hp_pin_sense;
3877
3878         if (!hp_pin) {
3879                 alc269_shutup(codec);
3880                 return;
3881         }
3882
3883         hp_pin_sense = snd_hda_jack_detect(codec, hp_pin);
3884
3885         if (hp_pin_sense)
3886                 msleep(2);
3887
3888         snd_hda_codec_write(codec, hp_pin, 0,
3889                             AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);
3890
3891         if (hp_pin_sense)
3892                 msleep(85);
3893
3894         if (!spec->no_shutup_pins)
3895                 snd_hda_codec_write(codec, hp_pin, 0,
3896                                     AC_VERB_SET_PIN_WIDGET_CONTROL, 0x0);
3897
3898         if (hp_pin_sense)
3899                 msleep(100);
3900
3901         alc_auto_setup_eapd(codec, false);
3902         alc_shutup_pins(codec);
3903 }
3904
3905 static void alc294_hp_init(struct hda_codec *codec)
3906 {
3907         struct alc_spec *spec = codec->spec;
3908         hda_nid_t hp_pin = alc_get_hp_pin(spec);
3909         int i, val;
3910
3911         if (!hp_pin)
3912                 return;
3913
3914         snd_hda_codec_write(codec, hp_pin, 0,
3915                             AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);
3916
3917         msleep(100);
3918
3919         if (!spec->no_shutup_pins)
3920                 snd_hda_codec_write(codec, hp_pin, 0,
3921                                     AC_VERB_SET_PIN_WIDGET_CONTROL, 0x0);
3922
3923         alc_update_coef_idx(codec, 0x6f, 0x000f, 0);/* Set HP depop to manual mode */
3924         alc_update_coefex_idx(codec, 0x58, 0x00, 0x8000, 0x8000); /* HP depop procedure start */
3925
3926         /* Wait for depop procedure finish  */
3927         val = alc_read_coefex_idx(codec, 0x58, 0x01);
3928         for (i = 0; i < 20 && val & 0x0080; i++) {
3929                 msleep(50);
3930                 val = alc_read_coefex_idx(codec, 0x58, 0x01);
3931         }
3932         /* Set HP depop to auto mode */
3933         alc_update_coef_idx(codec, 0x6f, 0x000f, 0x000b);
3934         msleep(50);
3935 }
3936
3937 static void alc294_init(struct hda_codec *codec)
3938 {
3939         struct alc_spec *spec = codec->spec;
3940
3941         /* required only at boot or S4 resume time */
3942         if (!spec->done_hp_init ||
3943             codec->core.dev.power.power_state.event == PM_EVENT_RESTORE) {
3944                 alc294_hp_init(codec);
3945                 spec->done_hp_init = true;
3946         }
3947         alc_default_init(codec);
3948 }
3949
3950 static void alc5505_coef_set(struct hda_codec *codec, unsigned int index_reg,
3951                              unsigned int val)
3952 {
3953         snd_hda_codec_write(codec, 0x51, 0, AC_VERB_SET_COEF_INDEX, index_reg >> 1);
3954         snd_hda_codec_write(codec, 0x51, 0, AC_VERB_SET_PROC_COEF, val & 0xffff); /* LSB */
3955         snd_hda_codec_write(codec, 0x51, 0, AC_VERB_SET_PROC_COEF, val >> 16); /* MSB */
3956 }
3957
3958 static int alc5505_coef_get(struct hda_codec *codec, unsigned int index_reg)
3959 {
3960         unsigned int val;
3961
3962         snd_hda_codec_write(codec, 0x51, 0, AC_VERB_SET_COEF_INDEX, index_reg >> 1);
3963         val = snd_hda_codec_read(codec, 0x51, 0, AC_VERB_GET_PROC_COEF, 0)
3964                 & 0xffff;
3965         val |= snd_hda_codec_read(codec, 0x51, 0, AC_VERB_GET_PROC_COEF, 0)
3966                 << 16;
3967         return val;
3968 }
3969
3970 static void alc5505_dsp_halt(struct hda_codec *codec)
3971 {
3972         unsigned int val;
3973
3974         alc5505_coef_set(codec, 0x3000, 0x000c); /* DSP CPU stop */
3975         alc5505_coef_set(codec, 0x880c, 0x0008); /* DDR enter self refresh */
3976         alc5505_coef_set(codec, 0x61c0, 0x11110080); /* Clock control for PLL and CPU */
3977         alc5505_coef_set(codec, 0x6230, 0xfc0d4011); /* Disable Input OP */
3978         alc5505_coef_set(codec, 0x61b4, 0x040a2b03); /* Stop PLL2 */
3979         alc5505_coef_set(codec, 0x61b0, 0x00005b17); /* Stop PLL1 */
3980         alc5505_coef_set(codec, 0x61b8, 0x04133303); /* Stop PLL3 */
3981         val = alc5505_coef_get(codec, 0x6220);
3982         alc5505_coef_set(codec, 0x6220, (val | 0x3000)); /* switch Ringbuffer clock to DBUS clock */
3983 }
3984
3985 static void alc5505_dsp_back_from_halt(struct hda_codec *codec)
3986 {
3987         alc5505_coef_set(codec, 0x61b8, 0x04133302);
3988         alc5505_coef_set(codec, 0x61b0, 0x00005b16);
3989         alc5505_coef_set(codec, 0x61b4, 0x040a2b02);
3990         alc5505_coef_set(codec, 0x6230, 0xf80d4011);
3991         alc5505_coef_set(codec, 0x6220, 0x2002010f);
3992         alc5505_coef_set(codec, 0x880c, 0x00000004);
3993 }
3994
3995 static void alc5505_dsp_init(struct hda_codec *codec)
3996 {
3997         unsigned int val;
3998
3999         alc5505_dsp_halt(codec);
4000         alc5505_dsp_back_from_halt(codec);
4001         alc5505_coef_set(codec, 0x61b0, 0x5b14); /* PLL1 control */
4002         alc5505_coef_set(codec, 0x61b0, 0x5b16);
4003         alc5505_coef_set(codec, 0x61b4, 0x04132b00); /* PLL2 control */
4004         alc5505_coef_set(codec, 0x61b4, 0x04132b02);
4005         alc5505_coef_set(codec, 0x61b8, 0x041f3300); /* PLL3 control*/
4006         alc5505_coef_set(codec, 0x61b8, 0x041f3302);
4007         snd_hda_codec_write(codec, 0x51, 0, AC_VERB_SET_CODEC_RESET, 0); /* Function reset */
4008         alc5505_coef_set(codec, 0x61b8, 0x041b3302);
4009         alc5505_coef_set(codec, 0x61b8, 0x04173302);
4010         alc5505_coef_set(codec, 0x61b8, 0x04163302);
4011         alc5505_coef_set(codec, 0x8800, 0x348b328b); /* DRAM control */
4012         alc5505_coef_set(codec, 0x8808, 0x00020022); /* DRAM control */
4013         alc5505_coef_set(codec, 0x8818, 0x00000400); /* DRAM control */
4014
4015         val = alc5505_coef_get(codec, 0x6200) >> 16; /* Read revision ID */
4016         if (val <= 3)
4017                 alc5505_coef_set(codec, 0x6220, 0x2002010f); /* I/O PAD Configuration */
4018         else
4019                 alc5505_coef_set(codec, 0x6220, 0x6002018f);
4020
4021         alc5505_coef_set(codec, 0x61ac, 0x055525f0); /**/
4022         alc5505_coef_set(codec, 0x61c0, 0x12230080); /* Clock control */
4023         alc5505_coef_set(codec, 0x61b4, 0x040e2b02); /* PLL2 control */
4024         alc5505_coef_set(codec, 0x61bc, 0x010234f8); /* OSC Control */
4025         alc5505_coef_set(codec, 0x880c, 0x00000004); /* DRAM Function control */
4026         alc5505_coef_set(codec, 0x880c, 0x00000003);
4027         alc5505_coef_set(codec, 0x880c, 0x00000010);
4028
4029 #ifdef HALT_REALTEK_ALC5505
4030         alc5505_dsp_halt(codec);
4031 #endif
4032 }
4033
4034 #ifdef HALT_REALTEK_ALC5505
4035 #define alc5505_dsp_suspend(codec)      do { } while (0) /* NOP */
4036 #define alc5505_dsp_resume(codec)       do { } while (0) /* NOP */
4037 #else
4038 #define alc5505_dsp_suspend(codec)      alc5505_dsp_halt(codec)
4039 #define alc5505_dsp_resume(codec)       alc5505_dsp_back_from_halt(codec)
4040 #endif
4041
4042 #ifdef CONFIG_PM
4043 static int alc269_suspend(struct hda_codec *codec)
4044 {
4045         struct alc_spec *spec = codec->spec;
4046
4047         if (spec->has_alc5505_dsp)
4048                 alc5505_dsp_suspend(codec);
4049
4050         return alc_suspend(codec);
4051 }
4052
4053 static int alc269_resume(struct hda_codec *codec)
4054 {
4055         struct alc_spec *spec = codec->spec;
4056
4057         if (spec->codec_variant == ALC269_TYPE_ALC269VB)
4058                 alc269vb_toggle_power_output(codec, 0);
4059         if (spec->codec_variant == ALC269_TYPE_ALC269VB &&
4060                         (alc_get_coef0(codec) & 0x00ff) == 0x018) {
4061                 msleep(150);
4062         }
4063
4064         codec->patch_ops.init(codec);
4065
4066         if (spec->codec_variant == ALC269_TYPE_ALC269VB)
4067                 alc269vb_toggle_power_output(codec, 1);
4068         if (spec->codec_variant == ALC269_TYPE_ALC269VB &&
4069                         (alc_get_coef0(codec) & 0x00ff) == 0x017) {
4070                 msleep(200);
4071         }
4072
4073         snd_hda_regmap_sync(codec);
4074         hda_call_check_power_status(codec, 0x01);
4075
4076         /* on some machine, the BIOS will clear the codec gpio data when enter
4077          * suspend, and won't restore the data after resume, so we restore it
4078          * in the driver.
4079          */
4080         if (spec->gpio_data)
4081                 alc_write_gpio_data(codec);
4082
4083         if (spec->has_alc5505_dsp)
4084                 alc5505_dsp_resume(codec);
4085
4086         return 0;
4087 }
4088 #endif /* CONFIG_PM */
4089
4090 static void alc269_fixup_pincfg_no_hp_to_lineout(struct hda_codec *codec,
4091                                                  const struct hda_fixup *fix, int action)
4092 {
4093         struct alc_spec *spec = codec->spec;
4094
4095         if (action == HDA_FIXUP_ACT_PRE_PROBE)
4096                 spec->parse_flags = HDA_PINCFG_NO_HP_FIXUP;
4097 }
4098
4099 static void alc269_fixup_pincfg_U7x7_headset_mic(struct hda_codec *codec,
4100                                                  const struct hda_fixup *fix,
4101                                                  int action)
4102 {
4103         unsigned int cfg_headphone = snd_hda_codec_get_pincfg(codec, 0x21);
4104         unsigned int cfg_headset_mic = snd_hda_codec_get_pincfg(codec, 0x19);
4105
4106         if (cfg_headphone && cfg_headset_mic == 0x411111f0)
4107                 snd_hda_codec_set_pincfg(codec, 0x19,
4108                         (cfg_headphone & ~AC_DEFCFG_DEVICE) |
4109                         (AC_JACK_MIC_IN << AC_DEFCFG_DEVICE_SHIFT));
4110 }
4111
4112 static void alc269_fixup_hweq(struct hda_codec *codec,
4113                                const struct hda_fixup *fix, int action)
4114 {
4115         if (action == HDA_FIXUP_ACT_INIT)
4116                 alc_update_coef_idx(codec, 0x1e, 0, 0x80);
4117 }
4118
4119 static void alc269_fixup_headset_mic(struct hda_codec *codec,
4120                                        const struct hda_fixup *fix, int action)
4121 {
4122         struct alc_spec *spec = codec->spec;
4123
4124         if (action == HDA_FIXUP_ACT_PRE_PROBE)
4125                 spec->parse_flags |= HDA_PINCFG_HEADSET_MIC;
4126 }
4127
4128 static void alc271_fixup_dmic(struct hda_codec *codec,
4129                               const struct hda_fixup *fix, int action)
4130 {
4131         static const struct hda_verb verbs[] = {
4132                 {0x20, AC_VERB_SET_COEF_INDEX, 0x0d},
4133                 {0x20, AC_VERB_SET_PROC_COEF, 0x4000},
4134                 {}
4135         };
4136         unsigned int cfg;
4137
4138         if (strcmp(codec->core.chip_name, "ALC271X") &&
4139             strcmp(codec->core.chip_name, "ALC269VB"))
4140                 return;
4141         cfg = snd_hda_codec_get_pincfg(codec, 0x12);
4142         if (get_defcfg_connect(cfg) == AC_JACK_PORT_FIXED)
4143                 snd_hda_sequence_write(codec, verbs);
4144 }
4145
4146 /* Fix the speaker amp after resume, etc */
4147 static void alc269vb_fixup_aspire_e1_coef(struct hda_codec *codec,
4148                                           const struct hda_fixup *fix,
4149                                           int action)
4150 {
4151         if (action == HDA_FIXUP_ACT_INIT)
4152                 alc_update_coef_idx(codec, 0x0d, 0x6000, 0x6000);
4153 }
4154
4155 static void alc269_fixup_pcm_44k(struct hda_codec *codec,
4156                                  const struct hda_fixup *fix, int action)
4157 {
4158         struct alc_spec *spec = codec->spec;
4159
4160         if (action != HDA_FIXUP_ACT_PROBE)
4161                 return;
4162
4163         /* Due to a hardware problem on Lenovo Ideadpad, we need to
4164          * fix the sample rate of analog I/O to 44.1kHz
4165          */
4166         spec->gen.stream_analog_playback = &alc269_44k_pcm_analog_playback;
4167         spec->gen.stream_analog_capture = &alc269_44k_pcm_analog_capture;
4168 }
4169
4170 static void alc269_fixup_stereo_dmic(struct hda_codec *codec,
4171                                      const struct hda_fixup *fix, int action)
4172 {
4173         /* The digital-mic unit sends PDM (differential signal) instead of
4174          * the standard PCM, thus you can't record a valid mono stream as is.
4175          * Below is a workaround specific to ALC269 to control the dmic
4176          * signal source as mono.
4177          */
4178         if (action == HDA_FIXUP_ACT_INIT)
4179                 alc_update_coef_idx(codec, 0x07, 0, 0x80);
4180 }
4181
4182 static void alc269_quanta_automute(struct hda_codec *codec)
4183 {
4184         snd_hda_gen_update_outputs(codec);
4185
4186         alc_write_coef_idx(codec, 0x0c, 0x680);
4187         alc_write_coef_idx(codec, 0x0c, 0x480);
4188 }
4189
4190 static void alc269_fixup_quanta_mute(struct hda_codec *codec,
4191                                      const struct hda_fixup *fix, int action)
4192 {
4193         struct alc_spec *spec = codec->spec;
4194         if (action != HDA_FIXUP_ACT_PROBE)
4195                 return;
4196         spec->gen.automute_hook = alc269_quanta_automute;
4197 }
4198
4199 static void alc269_x101_hp_automute_hook(struct hda_codec *codec,
4200                                          struct hda_jack_callback *jack)
4201 {
4202         struct alc_spec *spec = codec->spec;
4203         int vref;
4204         msleep(200);
4205         snd_hda_gen_hp_automute(codec, jack);
4206
4207         vref = spec->gen.hp_jack_present ? PIN_VREF80 : 0;
4208         msleep(100);
4209         snd_hda_codec_write(codec, 0x18, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
4210                             vref);
4211         msleep(500);
4212         snd_hda_codec_write(codec, 0x18, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
4213                             vref);
4214 }
4215
4216 /*
4217  * Magic sequence to make Huawei Matebook X right speaker working (bko#197801)
4218  */
4219 struct hda_alc298_mbxinit {
4220         unsigned char value_0x23;
4221         unsigned char value_0x25;
4222 };
4223
4224 static void alc298_huawei_mbx_stereo_seq(struct hda_codec *codec,
4225                                          const struct hda_alc298_mbxinit *initval,
4226                                          bool first)
4227 {
4228         snd_hda_codec_write(codec, 0x06, 0, AC_VERB_SET_DIGI_CONVERT_3, 0x0);
4229         alc_write_coef_idx(codec, 0x26, 0xb000);
4230
4231         if (first)
4232                 snd_hda_codec_write(codec, 0x21, 0, AC_VERB_GET_PIN_SENSE, 0x0);
4233
4234         snd_hda_codec_write(codec, 0x6, 0, AC_VERB_SET_DIGI_CONVERT_3, 0x80);
4235         alc_write_coef_idx(codec, 0x26, 0xf000);
4236         alc_write_coef_idx(codec, 0x23, initval->value_0x23);
4237
4238         if (initval->value_0x23 != 0x1e)
4239                 alc_write_coef_idx(codec, 0x25, initval->value_0x25);
4240
4241         snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_COEF_INDEX, 0x26);
4242         snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_PROC_COEF, 0xb010);
4243 }
4244
4245 static void alc298_fixup_huawei_mbx_stereo(struct hda_codec *codec,
4246                                            const struct hda_fixup *fix,
4247                                            int action)
4248 {
4249         /* Initialization magic */
4250         static const struct hda_alc298_mbxinit dac_init[] = {
4251                 {0x0c, 0x00}, {0x0d, 0x00}, {0x0e, 0x00}, {0x0f, 0x00},
4252                 {0x10, 0x00}, {0x1a, 0x40}, {0x1b, 0x82}, {0x1c, 0x00},
4253                 {0x1d, 0x00}, {0x1e, 0x00}, {0x1f, 0x00},
4254                 {0x20, 0xc2}, {0x21, 0xc8}, {0x22, 0x26}, {0x23, 0x24},
4255                 {0x27, 0xff}, {0x28, 0xff}, {0x29, 0xff}, {0x2a, 0x8f},
4256                 {0x2b, 0x02}, {0x2c, 0x48}, {0x2d, 0x34}, {0x2e, 0x00},
4257                 {0x2f, 0x00},
4258                 {0x30, 0x00}, {0x31, 0x00}, {0x32, 0x00}, {0x33, 0x00},
4259                 {0x34, 0x00}, {0x35, 0x01}, {0x36, 0x93}, {0x37, 0x0c},
4260                 {0x38, 0x00}, {0x39, 0x00}, {0x3a, 0xf8}, {0x38, 0x80},
4261                 {}
4262         };
4263         const struct hda_alc298_mbxinit *seq;
4264
4265         if (action != HDA_FIXUP_ACT_INIT)
4266                 return;
4267
4268         /* Start */
4269         snd_hda_codec_write(codec, 0x06, 0, AC_VERB_SET_DIGI_CONVERT_3, 0x00);
4270         snd_hda_codec_write(codec, 0x06, 0, AC_VERB_SET_DIGI_CONVERT_3, 0x80);
4271         alc_write_coef_idx(codec, 0x26, 0xf000);
4272         alc_write_coef_idx(codec, 0x22, 0x31);
4273         alc_write_coef_idx(codec, 0x23, 0x0b);
4274         alc_write_coef_idx(codec, 0x25, 0x00);
4275         snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_COEF_INDEX, 0x26);
4276         snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_PROC_COEF, 0xb010);
4277
4278         for (seq = dac_init; seq->value_0x23; seq++)
4279                 alc298_huawei_mbx_stereo_seq(codec, seq, seq == dac_init);
4280 }
4281
4282 static void alc269_fixup_x101_headset_mic(struct hda_codec *codec,
4283                                      const struct hda_fixup *fix, int action)
4284 {
4285         struct alc_spec *spec = codec->spec;
4286         if (action == HDA_FIXUP_ACT_PRE_PROBE) {
4287                 spec->parse_flags |= HDA_PINCFG_HEADSET_MIC;
4288                 spec->gen.hp_automute_hook = alc269_x101_hp_automute_hook;
4289         }
4290 }
4291
4292 static void alc_update_vref_led(struct hda_codec *codec, hda_nid_t pin,
4293                                 bool polarity, bool on)
4294 {
4295         unsigned int pinval;
4296
4297         if (!pin)
4298                 return;
4299         if (polarity)
4300                 on = !on;
4301         pinval = snd_hda_codec_get_pin_target(codec, pin);
4302         pinval &= ~AC_PINCTL_VREFEN;
4303         pinval |= on ? AC_PINCTL_VREF_80 : AC_PINCTL_VREF_HIZ;
4304         /* temporarily power up/down for setting VREF */
4305         snd_hda_power_up_pm(codec);
4306         snd_hda_set_pin_ctl_cache(codec, pin, pinval);
4307         snd_hda_power_down_pm(codec);
4308 }
4309
4310 /* update mute-LED according to the speaker mute state via mic VREF pin */
4311 static int vref_mute_led_set(struct led_classdev *led_cdev,
4312                              enum led_brightness brightness)
4313 {
4314         struct hda_codec *codec = dev_to_hda_codec(led_cdev->dev->parent);
4315         struct alc_spec *spec = codec->spec;
4316
4317         alc_update_vref_led(codec, spec->mute_led_nid,
4318                             spec->mute_led_polarity, brightness);
4319         return 0;
4320 }
4321
4322 /* Make sure the led works even in runtime suspend */
4323 static unsigned int led_power_filter(struct hda_codec *codec,
4324                                                   hda_nid_t nid,
4325                                                   unsigned int power_state)
4326 {
4327         struct alc_spec *spec = codec->spec;
4328
4329         if (power_state != AC_PWRST_D3 || nid == 0 ||
4330             (nid != spec->mute_led_nid && nid != spec->cap_mute_led_nid))
4331                 return power_state;
4332
4333         /* Set pin ctl again, it might have just been set to 0 */
4334         snd_hda_set_pin_ctl(codec, nid,
4335                             snd_hda_codec_get_pin_target(codec, nid));
4336
4337         return snd_hda_gen_path_power_filter(codec, nid, power_state);
4338 }
4339
4340 static void alc269_fixup_hp_mute_led(struct hda_codec *codec,
4341                                      const struct hda_fixup *fix, int action)
4342 {
4343         struct alc_spec *spec = codec->spec;
4344         const struct dmi_device *dev = NULL;
4345
4346         if (action != HDA_FIXUP_ACT_PRE_PROBE)
4347                 return;
4348
4349         while ((dev = dmi_find_device(DMI_DEV_TYPE_OEM_STRING, NULL, dev))) {
4350                 int pol, pin;
4351                 if (sscanf(dev->name, "HP_Mute_LED_%d_%x", &pol, &pin) != 2)
4352                         continue;
4353                 if (pin < 0x0a || pin >= 0x10)
4354                         break;
4355                 spec->mute_led_polarity = pol;
4356                 spec->mute_led_nid = pin - 0x0a + 0x18;
4357                 snd_hda_gen_add_mute_led_cdev(codec, vref_mute_led_set);
4358                 codec->power_filter = led_power_filter;
4359                 codec_dbg(codec,
4360                           "Detected mute LED for %x:%d\n", spec->mute_led_nid,
4361                            spec->mute_led_polarity);
4362                 break;
4363         }
4364 }
4365
4366 static void alc269_fixup_hp_mute_led_micx(struct hda_codec *codec,
4367                                           const struct hda_fixup *fix,
4368                                           int action, hda_nid_t pin)
4369 {
4370         struct alc_spec *spec = codec->spec;
4371
4372         if (action == HDA_FIXUP_ACT_PRE_PROBE) {
4373                 spec->mute_led_polarity = 0;
4374                 spec->mute_led_nid = pin;
4375                 snd_hda_gen_add_mute_led_cdev(codec, vref_mute_led_set);
4376                 codec->power_filter = led_power_filter;
4377         }
4378 }
4379
4380 static void alc269_fixup_hp_mute_led_mic1(struct hda_codec *codec,
4381                                 const struct hda_fixup *fix, int action)
4382 {
4383         alc269_fixup_hp_mute_led_micx(codec, fix, action, 0x18);
4384 }
4385
4386 static void alc269_fixup_hp_mute_led_mic2(struct hda_codec *codec,
4387                                 const struct hda_fixup *fix, int action)
4388 {
4389         alc269_fixup_hp_mute_led_micx(codec, fix, action, 0x19);
4390 }
4391
4392 static void alc269_fixup_hp_mute_led_mic3(struct hda_codec *codec,
4393                                 const struct hda_fixup *fix, int action)
4394 {
4395         alc269_fixup_hp_mute_led_micx(codec, fix, action, 0x1b);
4396 }
4397
4398 /* update LED status via GPIO */
4399 static void alc_update_gpio_led(struct hda_codec *codec, unsigned int mask,
4400                                 int polarity, bool enabled)
4401 {
4402         if (polarity)
4403                 enabled = !enabled;
4404         alc_update_gpio_data(codec, mask, !enabled); /* muted -> LED on */
4405 }
4406
4407 /* turn on/off mute LED via GPIO per vmaster hook */
4408 static int gpio_mute_led_set(struct led_classdev *led_cdev,
4409                              enum led_brightness brightness)
4410 {
4411         struct hda_codec *codec = dev_to_hda_codec(led_cdev->dev->parent);
4412         struct alc_spec *spec = codec->spec;
4413
4414         alc_update_gpio_led(codec, spec->gpio_mute_led_mask,
4415                             spec->mute_led_polarity, !brightness);
4416         return 0;
4417 }
4418
4419 /* turn on/off mic-mute LED via GPIO per capture hook */
4420 static int micmute_led_set(struct led_classdev *led_cdev,
4421                            enum led_brightness brightness)
4422 {
4423         struct hda_codec *codec = dev_to_hda_codec(led_cdev->dev->parent);
4424         struct alc_spec *spec = codec->spec;
4425
4426         alc_update_gpio_led(codec, spec->gpio_mic_led_mask,
4427                             spec->micmute_led_polarity, !brightness);
4428         return 0;
4429 }
4430
4431 /* setup mute and mic-mute GPIO bits, add hooks appropriately */
4432 static void alc_fixup_hp_gpio_led(struct hda_codec *codec,
4433                                   int action,
4434                                   unsigned int mute_mask,
4435                                   unsigned int micmute_mask)
4436 {
4437         struct alc_spec *spec = codec->spec;
4438
4439         alc_fixup_gpio(codec, action, mute_mask | micmute_mask);
4440
4441         if (action != HDA_FIXUP_ACT_PRE_PROBE)
4442                 return;
4443         if (mute_mask) {
4444                 spec->gpio_mute_led_mask = mute_mask;
4445                 snd_hda_gen_add_mute_led_cdev(codec, gpio_mute_led_set);
4446         }
4447         if (micmute_mask) {
4448                 spec->gpio_mic_led_mask = micmute_mask;
4449                 snd_hda_gen_add_micmute_led_cdev(codec, micmute_led_set);
4450         }
4451 }
4452
4453 static void alc236_fixup_hp_gpio_led(struct hda_codec *codec,
4454                                 const struct hda_fixup *fix, int action)
4455 {
4456         alc_fixup_hp_gpio_led(codec, action, 0x02, 0x01);
4457 }
4458
4459 static void alc269_fixup_hp_gpio_led(struct hda_codec *codec,
4460                                 const struct hda_fixup *fix, int action)
4461 {
4462         alc_fixup_hp_gpio_led(codec, action, 0x08, 0x10);
4463 }
4464
4465 static void alc285_fixup_hp_gpio_led(struct hda_codec *codec,
4466                                 const struct hda_fixup *fix, int action)
4467 {
4468         alc_fixup_hp_gpio_led(codec, action, 0x04, 0x01);
4469 }
4470
4471 static void alc286_fixup_hp_gpio_led(struct hda_codec *codec,
4472                                 const struct hda_fixup *fix, int action)
4473 {
4474         alc_fixup_hp_gpio_led(codec, action, 0x02, 0x20);
4475 }
4476
4477 static void alc287_fixup_hp_gpio_led(struct hda_codec *codec,
4478                                 const struct hda_fixup *fix, int action)
4479 {
4480         alc_fixup_hp_gpio_led(codec, action, 0x10, 0);
4481 }
4482
4483 static void alc245_fixup_hp_gpio_led(struct hda_codec *codec,
4484                                 const struct hda_fixup *fix, int action)
4485 {
4486         struct alc_spec *spec = codec->spec;
4487
4488         if (action == HDA_FIXUP_ACT_PRE_PROBE)
4489                 spec->micmute_led_polarity = 1;
4490         alc_fixup_hp_gpio_led(codec, action, 0, 0x04);
4491 }
4492
4493 /* turn on/off mic-mute LED per capture hook via VREF change */
4494 static int vref_micmute_led_set(struct led_classdev *led_cdev,
4495                                 enum led_brightness brightness)
4496 {
4497         struct hda_codec *codec = dev_to_hda_codec(led_cdev->dev->parent);
4498         struct alc_spec *spec = codec->spec;
4499
4500         alc_update_vref_led(codec, spec->cap_mute_led_nid,
4501                             spec->micmute_led_polarity, brightness);
4502         return 0;
4503 }
4504
4505 static void alc269_fixup_hp_gpio_mic1_led(struct hda_codec *codec,
4506                                 const struct hda_fixup *fix, int action)
4507 {
4508         struct alc_spec *spec = codec->spec;
4509
4510         alc_fixup_hp_gpio_led(codec, action, 0x08, 0);
4511         if (action == HDA_FIXUP_ACT_PRE_PROBE) {
4512                 /* Like hp_gpio_mic1_led, but also needs GPIO4 low to
4513                  * enable headphone amp
4514                  */
4515                 spec->gpio_mask |= 0x10;
4516                 spec->gpio_dir |= 0x10;
4517                 spec->cap_mute_led_nid = 0x18;
4518                 snd_hda_gen_add_micmute_led_cdev(codec, vref_micmute_led_set);
4519                 codec->power_filter = led_power_filter;
4520         }
4521 }
4522
4523 static void alc280_fixup_hp_gpio4(struct hda_codec *codec,
4524                                    const struct hda_fixup *fix, int action)
4525 {
4526         struct alc_spec *spec = codec->spec;
4527
4528         alc_fixup_hp_gpio_led(codec, action, 0x08, 0);
4529         if (action == HDA_FIXUP_ACT_PRE_PROBE) {
4530                 spec->cap_mute_led_nid = 0x18;
4531                 snd_hda_gen_add_micmute_led_cdev(codec, vref_micmute_led_set);
4532                 codec->power_filter = led_power_filter;
4533         }
4534 }
4535
4536 /* HP Spectre x360 14 model needs a unique workaround for enabling the amp;
4537  * it needs to toggle the GPIO0 once on and off at each time (bko#210633)
4538  */
4539 static void alc245_fixup_hp_x360_amp(struct hda_codec *codec,
4540                                      const struct hda_fixup *fix, int action)
4541 {
4542         struct alc_spec *spec = codec->spec;
4543
4544         switch (action) {
4545         case HDA_FIXUP_ACT_PRE_PROBE:
4546                 spec->gpio_mask |= 0x01;
4547                 spec->gpio_dir |= 0x01;
4548                 break;
4549         case HDA_FIXUP_ACT_INIT:
4550                 /* need to toggle GPIO to enable the amp */
4551                 alc_update_gpio_data(codec, 0x01, true);
4552                 msleep(100);
4553                 alc_update_gpio_data(codec, 0x01, false);
4554                 break;
4555         }
4556 }
4557
4558 /* toggle GPIO2 at each time stream is started; we use PREPARE state instead */
4559 static void alc274_hp_envy_pcm_hook(struct hda_pcm_stream *hinfo,
4560                                     struct hda_codec *codec,
4561                                     struct snd_pcm_substream *substream,
4562                                     int action)
4563 {
4564         switch (action) {
4565         case HDA_GEN_PCM_ACT_PREPARE:
4566                 alc_update_gpio_data(codec, 0x04, true);
4567                 break;
4568         case HDA_GEN_PCM_ACT_CLEANUP:
4569                 alc_update_gpio_data(codec, 0x04, false);
4570                 break;
4571         }
4572 }
4573
4574 static void alc274_fixup_hp_envy_gpio(struct hda_codec *codec,
4575                                       const struct hda_fixup *fix,
4576                                       int action)
4577 {
4578         struct alc_spec *spec = codec->spec;
4579
4580         if (action == HDA_FIXUP_ACT_PROBE) {
4581                 spec->gpio_mask |= 0x04;
4582                 spec->gpio_dir |= 0x04;
4583                 spec->gen.pcm_playback_hook = alc274_hp_envy_pcm_hook;
4584         }
4585 }
4586
4587 static void alc_update_coef_led(struct hda_codec *codec,
4588                                 struct alc_coef_led *led,
4589                                 bool polarity, bool on)
4590 {
4591         if (polarity)
4592                 on = !on;
4593         /* temporarily power up/down for setting COEF bit */
4594         alc_update_coef_idx(codec, led->idx, led->mask,
4595                             on ? led->on : led->off);
4596 }
4597
4598 /* update mute-LED according to the speaker mute state via COEF bit */
4599 static int coef_mute_led_set(struct led_classdev *led_cdev,
4600                              enum led_brightness brightness)
4601 {
4602         struct hda_codec *codec = dev_to_hda_codec(led_cdev->dev->parent);
4603         struct alc_spec *spec = codec->spec;
4604
4605         alc_update_coef_led(codec, &spec->mute_led_coef,
4606                             spec->mute_led_polarity, brightness);
4607         return 0;
4608 }
4609
4610 static void alc285_fixup_hp_mute_led_coefbit(struct hda_codec *codec,
4611                                           const struct hda_fixup *fix,
4612                                           int action)
4613 {
4614         struct alc_spec *spec = codec->spec;
4615
4616         if (action == HDA_FIXUP_ACT_PRE_PROBE) {
4617                 spec->mute_led_polarity = 0;
4618                 spec->mute_led_coef.idx = 0x0b;
4619                 spec->mute_led_coef.mask = 1 << 3;
4620                 spec->mute_led_coef.on = 1 << 3;
4621                 spec->mute_led_coef.off = 0;
4622                 snd_hda_gen_add_mute_led_cdev(codec, coef_mute_led_set);
4623         }
4624 }
4625
4626 static void alc236_fixup_hp_mute_led_coefbit(struct hda_codec *codec,
4627                                           const struct hda_fixup *fix,
4628                                           int action)
4629 {
4630         struct alc_spec *spec = codec->spec;
4631
4632         if (action == HDA_FIXUP_ACT_PRE_PROBE) {
4633                 spec->mute_led_polarity = 0;
4634                 spec->mute_led_coef.idx = 0x34;
4635                 spec->mute_led_coef.mask = 1 << 5;
4636                 spec->mute_led_coef.on = 0;
4637                 spec->mute_led_coef.off = 1 << 5;
4638                 snd_hda_gen_add_mute_led_cdev(codec, coef_mute_led_set);
4639         }
4640 }
4641
4642 static void alc236_fixup_hp_mute_led_coefbit2(struct hda_codec *codec,
4643                                           const struct hda_fixup *fix, int action)
4644 {
4645         struct alc_spec *spec = codec->spec;
4646
4647         if (action == HDA_FIXUP_ACT_PRE_PROBE) {
4648                 spec->mute_led_polarity = 0;
4649                 spec->mute_led_coef.idx = 0x07;
4650                 spec->mute_led_coef.mask = 1;
4651                 spec->mute_led_coef.on = 1;
4652                 spec->mute_led_coef.off = 0;
4653                 snd_hda_gen_add_mute_led_cdev(codec, coef_mute_led_set);
4654         }
4655 }
4656
4657 static void alc245_fixup_hp_mute_led_coefbit(struct hda_codec *codec,
4658                                           const struct hda_fixup *fix,
4659                                           int action)
4660 {
4661         struct alc_spec *spec = codec->spec;
4662
4663         if (action == HDA_FIXUP_ACT_PRE_PROBE) {
4664                 spec->mute_led_polarity = 0;
4665                 spec->mute_led_coef.idx = 0x0b;
4666                 spec->mute_led_coef.mask = 3 << 2;
4667                 spec->mute_led_coef.on = 2 << 2;
4668                 spec->mute_led_coef.off = 1 << 2;
4669                 snd_hda_gen_add_mute_led_cdev(codec, coef_mute_led_set);
4670         }
4671 }
4672
4673 /* turn on/off mic-mute LED per capture hook by coef bit */
4674 static int coef_micmute_led_set(struct led_classdev *led_cdev,
4675                                 enum led_brightness brightness)
4676 {
4677         struct hda_codec *codec = dev_to_hda_codec(led_cdev->dev->parent);
4678         struct alc_spec *spec = codec->spec;
4679
4680         alc_update_coef_led(codec, &spec->mic_led_coef,
4681                             spec->micmute_led_polarity, brightness);
4682         return 0;
4683 }
4684
4685 static void alc285_fixup_hp_coef_micmute_led(struct hda_codec *codec,
4686                                 const struct hda_fixup *fix, int action)
4687 {
4688         struct alc_spec *spec = codec->spec;
4689
4690         if (action == HDA_FIXUP_ACT_PRE_PROBE) {
4691                 spec->mic_led_coef.idx = 0x19;
4692                 spec->mic_led_coef.mask = 1 << 13;
4693                 spec->mic_led_coef.on = 1 << 13;
4694                 spec->mic_led_coef.off = 0;
4695                 snd_hda_gen_add_micmute_led_cdev(codec, coef_micmute_led_set);
4696         }
4697 }
4698
4699 static void alc285_fixup_hp_gpio_micmute_led(struct hda_codec *codec,
4700                                 const struct hda_fixup *fix, int action)
4701 {
4702         struct alc_spec *spec = codec->spec;
4703
4704         if (action == HDA_FIXUP_ACT_PRE_PROBE)
4705                 spec->micmute_led_polarity = 1;
4706         alc_fixup_hp_gpio_led(codec, action, 0, 0x04);
4707 }
4708
4709 static void alc236_fixup_hp_coef_micmute_led(struct hda_codec *codec,
4710                                 const struct hda_fixup *fix, int action)
4711 {
4712         struct alc_spec *spec = codec->spec;
4713
4714         if (action == HDA_FIXUP_ACT_PRE_PROBE) {
4715                 spec->mic_led_coef.idx = 0x35;
4716                 spec->mic_led_coef.mask = 3 << 2;
4717                 spec->mic_led_coef.on = 2 << 2;
4718                 spec->mic_led_coef.off = 1 << 2;
4719                 snd_hda_gen_add_micmute_led_cdev(codec, coef_micmute_led_set);
4720         }
4721 }
4722
4723 static void alc285_fixup_hp_mute_led(struct hda_codec *codec,
4724                                 const struct hda_fixup *fix, int action)
4725 {
4726         alc285_fixup_hp_mute_led_coefbit(codec, fix, action);
4727         alc285_fixup_hp_coef_micmute_led(codec, fix, action);
4728 }
4729
4730 static void alc285_fixup_hp_spectre_x360_mute_led(struct hda_codec *codec,
4731                                 const struct hda_fixup *fix, int action)
4732 {
4733         alc285_fixup_hp_mute_led_coefbit(codec, fix, action);
4734         alc285_fixup_hp_gpio_micmute_led(codec, fix, action);
4735 }
4736
4737 static void alc236_fixup_hp_mute_led(struct hda_codec *codec,
4738                                 const struct hda_fixup *fix, int action)
4739 {
4740         alc236_fixup_hp_mute_led_coefbit(codec, fix, action);
4741         alc236_fixup_hp_coef_micmute_led(codec, fix, action);
4742 }
4743
4744 static void alc236_fixup_hp_micmute_led_vref(struct hda_codec *codec,
4745                                 const struct hda_fixup *fix, int action)
4746 {
4747         struct alc_spec *spec = codec->spec;
4748
4749         if (action == HDA_FIXUP_ACT_PRE_PROBE) {
4750                 spec->cap_mute_led_nid = 0x1a;
4751                 snd_hda_gen_add_micmute_led_cdev(codec, vref_micmute_led_set);
4752                 codec->power_filter = led_power_filter;
4753         }
4754 }
4755
4756 static void alc236_fixup_hp_mute_led_micmute_vref(struct hda_codec *codec,
4757                                 const struct hda_fixup *fix, int action)
4758 {
4759         alc236_fixup_hp_mute_led_coefbit(codec, fix, action);
4760         alc236_fixup_hp_micmute_led_vref(codec, fix, action);
4761 }
4762
4763 static inline void alc298_samsung_write_coef_pack(struct hda_codec *codec,
4764                                                   const unsigned short coefs[2])
4765 {
4766         alc_write_coef_idx(codec, 0x23, coefs[0]);
4767         alc_write_coef_idx(codec, 0x25, coefs[1]);
4768         alc_write_coef_idx(codec, 0x26, 0xb011);
4769 }
4770
4771 struct alc298_samsung_amp_desc {
4772         unsigned char nid;
4773         unsigned short init_seq[2][2];
4774 };
4775
4776 static void alc298_fixup_samsung_amp(struct hda_codec *codec,
4777                                      const struct hda_fixup *fix, int action)
4778 {
4779         int i, j;
4780         static const unsigned short init_seq[][2] = {
4781                 { 0x19, 0x00 }, { 0x20, 0xc0 }, { 0x22, 0x44 }, { 0x23, 0x08 },
4782                 { 0x24, 0x85 }, { 0x25, 0x41 }, { 0x35, 0x40 }, { 0x36, 0x01 },
4783                 { 0x38, 0x81 }, { 0x3a, 0x03 }, { 0x3b, 0x81 }, { 0x40, 0x3e },
4784                 { 0x41, 0x07 }, { 0x400, 0x1 }
4785         };
4786         static const struct alc298_samsung_amp_desc amps[] = {
4787                 { 0x3a, { { 0x18, 0x1 }, { 0x26, 0x0 } } },
4788                 { 0x39, { { 0x18, 0x2 }, { 0x26, 0x1 } } }
4789         };
4790
4791         if (action != HDA_FIXUP_ACT_INIT)
4792                 return;
4793
4794         for (i = 0; i < ARRAY_SIZE(amps); i++) {
4795                 alc_write_coef_idx(codec, 0x22, amps[i].nid);
4796
4797                 for (j = 0; j < ARRAY_SIZE(amps[i].init_seq); j++)
4798                         alc298_samsung_write_coef_pack(codec, amps[i].init_seq[j]);
4799
4800                 for (j = 0; j < ARRAY_SIZE(init_seq); j++)
4801                         alc298_samsung_write_coef_pack(codec, init_seq[j]);
4802         }
4803 }
4804
4805 #if IS_REACHABLE(CONFIG_INPUT)
4806 static void gpio2_mic_hotkey_event(struct hda_codec *codec,
4807                                    struct hda_jack_callback *event)
4808 {
4809         struct alc_spec *spec = codec->spec;
4810
4811         /* GPIO2 just toggles on a keypress/keyrelease cycle. Therefore
4812            send both key on and key off event for every interrupt. */
4813         input_report_key(spec->kb_dev, spec->alc_mute_keycode_map[ALC_KEY_MICMUTE_INDEX], 1);
4814         input_sync(spec->kb_dev);
4815         input_report_key(spec->kb_dev, spec->alc_mute_keycode_map[ALC_KEY_MICMUTE_INDEX], 0);
4816         input_sync(spec->kb_dev);
4817 }
4818
4819 static int alc_register_micmute_input_device(struct hda_codec *codec)
4820 {
4821         struct alc_spec *spec = codec->spec;
4822         int i;
4823
4824         spec->kb_dev = input_allocate_device();
4825         if (!spec->kb_dev) {
4826                 codec_err(codec, "Out of memory (input_allocate_device)\n");
4827                 return -ENOMEM;
4828         }
4829
4830         spec->alc_mute_keycode_map[ALC_KEY_MICMUTE_INDEX] = KEY_MICMUTE;
4831
4832         spec->kb_dev->name = "Microphone Mute Button";
4833         spec->kb_dev->evbit[0] = BIT_MASK(EV_KEY);
4834         spec->kb_dev->keycodesize = sizeof(spec->alc_mute_keycode_map[0]);
4835         spec->kb_dev->keycodemax = ARRAY_SIZE(spec->alc_mute_keycode_map);
4836         spec->kb_dev->keycode = spec->alc_mute_keycode_map;
4837         for (i = 0; i < ARRAY_SIZE(spec->alc_mute_keycode_map); i++)
4838                 set_bit(spec->alc_mute_keycode_map[i], spec->kb_dev->keybit);
4839
4840         if (input_register_device(spec->kb_dev)) {
4841                 codec_err(codec, "input_register_device failed\n");
4842                 input_free_device(spec->kb_dev);
4843                 spec->kb_dev = NULL;
4844                 return -ENOMEM;
4845         }
4846
4847         return 0;
4848 }
4849
4850 /* GPIO1 = set according to SKU external amp
4851  * GPIO2 = mic mute hotkey
4852  * GPIO3 = mute LED
4853  * GPIO4 = mic mute LED
4854  */
4855 static void alc280_fixup_hp_gpio2_mic_hotkey(struct hda_codec *codec,
4856                                              const struct hda_fixup *fix, int action)
4857 {
4858         struct alc_spec *spec = codec->spec;
4859
4860         alc_fixup_hp_gpio_led(codec, action, 0x08, 0x10);
4861         if (action == HDA_FIXUP_ACT_PRE_PROBE) {
4862                 spec->init_amp = ALC_INIT_DEFAULT;
4863                 if (alc_register_micmute_input_device(codec) != 0)
4864                         return;
4865
4866                 spec->gpio_mask |= 0x06;
4867                 spec->gpio_dir |= 0x02;
4868                 spec->gpio_data |= 0x02;
4869                 snd_hda_codec_write_cache(codec, codec->core.afg, 0,
4870                                           AC_VERB_SET_GPIO_UNSOLICITED_RSP_MASK, 0x04);
4871                 snd_hda_jack_detect_enable_callback(codec, codec->core.afg,
4872                                                     gpio2_mic_hotkey_event);
4873                 return;
4874         }
4875
4876         if (!spec->kb_dev)
4877                 return;
4878
4879         switch (action) {
4880         case HDA_FIXUP_ACT_FREE:
4881                 input_unregister_device(spec->kb_dev);
4882                 spec->kb_dev = NULL;
4883         }
4884 }
4885
4886 /* Line2 = mic mute hotkey
4887  * GPIO2 = mic mute LED
4888  */
4889 static void alc233_fixup_lenovo_line2_mic_hotkey(struct hda_codec *codec,
4890                                              const struct hda_fixup *fix, int action)
4891 {
4892         struct alc_spec *spec = codec->spec;
4893
4894         alc_fixup_hp_gpio_led(codec, action, 0, 0x04);
4895         if (action == HDA_FIXUP_ACT_PRE_PROBE) {
4896                 spec->init_amp = ALC_INIT_DEFAULT;
4897                 if (alc_register_micmute_input_device(codec) != 0)
4898                         return;
4899
4900                 snd_hda_jack_detect_enable_callback(codec, 0x1b,
4901                                                     gpio2_mic_hotkey_event);
4902                 return;
4903         }
4904
4905         if (!spec->kb_dev)
4906                 return;
4907
4908         switch (action) {
4909         case HDA_FIXUP_ACT_FREE:
4910                 input_unregister_device(spec->kb_dev);
4911                 spec->kb_dev = NULL;
4912         }
4913 }
4914 #else /* INPUT */
4915 #define alc280_fixup_hp_gpio2_mic_hotkey        NULL
4916 #define alc233_fixup_lenovo_line2_mic_hotkey    NULL
4917 #endif /* INPUT */
4918
4919 static void alc269_fixup_hp_line1_mic1_led(struct hda_codec *codec,
4920                                 const struct hda_fixup *fix, int action)
4921 {
4922         struct alc_spec *spec = codec->spec;
4923
4924         alc269_fixup_hp_mute_led_micx(codec, fix, action, 0x1a);
4925         if (action == HDA_FIXUP_ACT_PRE_PROBE) {
4926                 spec->cap_mute_led_nid = 0x18;
4927                 snd_hda_gen_add_micmute_led_cdev(codec, vref_micmute_led_set);
4928         }
4929 }
4930
4931 static const struct coef_fw alc225_pre_hsmode[] = {
4932         UPDATE_COEF(0x4a, 1<<8, 0),
4933         UPDATE_COEFEX(0x57, 0x05, 1<<14, 0),
4934         UPDATE_COEF(0x63, 3<<14, 3<<14),
4935         UPDATE_COEF(0x4a, 3<<4, 2<<4),
4936         UPDATE_COEF(0x4a, 3<<10, 3<<10),
4937         UPDATE_COEF(0x45, 0x3f<<10, 0x34<<10),
4938         UPDATE_COEF(0x4a, 3<<10, 0),
4939         {}
4940 };
4941
4942 static void alc_headset_mode_unplugged(struct hda_codec *codec)
4943 {
4944         struct alc_spec *spec = codec->spec;
4945         static const struct coef_fw coef0255[] = {
4946                 WRITE_COEF(0x1b, 0x0c0b), /* LDO and MISC control */
4947                 WRITE_COEF(0x45, 0xd089), /* UAJ function set to menual mode */
4948                 UPDATE_COEFEX(0x57, 0x05, 1<<14, 0), /* Direct Drive HP Amp control(Set to verb control)*/
4949                 WRITE_COEF(0x06, 0x6104), /* Set MIC2 Vref gate with HP */
4950                 WRITE_COEFEX(0x57, 0x03, 0x8aa6), /* Direct Drive HP Amp control */
4951                 {}
4952         };
4953         static const struct coef_fw coef0256[] = {
4954                 WRITE_COEF(0x1b, 0x0c4b), /* LDO and MISC control */
4955                 WRITE_COEF(0x45, 0xd089), /* UAJ function set to menual mode */
4956                 WRITE_COEF(0x06, 0x6104), /* Set MIC2 Vref gate with HP */
4957                 WRITE_COEFEX(0x57, 0x03, 0x09a3), /* Direct Drive HP Amp control */
4958                 UPDATE_COEFEX(0x57, 0x05, 1<<14, 0), /* Direct Drive HP Amp control(Set to verb control)*/
4959                 {}
4960         };
4961         static const struct coef_fw coef0233[] = {
4962                 WRITE_COEF(0x1b, 0x0c0b),
4963                 WRITE_COEF(0x45, 0xc429),
4964                 UPDATE_COEF(0x35, 0x4000, 0),
4965                 WRITE_COEF(0x06, 0x2104),
4966                 WRITE_COEF(0x1a, 0x0001),
4967                 WRITE_COEF(0x26, 0x0004),
4968                 WRITE_COEF(0x32, 0x42a3),
4969                 {}
4970         };
4971         static const struct coef_fw coef0288[] = {
4972                 UPDATE_COEF(0x4f, 0xfcc0, 0xc400),
4973                 UPDATE_COEF(0x50, 0x2000, 0x2000),
4974                 UPDATE_COEF(0x56, 0x0006, 0x0006),
4975                 UPDATE_COEF(0x66, 0x0008, 0),
4976                 UPDATE_COEF(0x67, 0x2000, 0),
4977                 {}
4978         };
4979         static const struct coef_fw coef0298[] = {
4980                 UPDATE_COEF(0x19, 0x1300, 0x0300),
4981                 {}
4982         };
4983         static const struct coef_fw coef0292[] = {
4984                 WRITE_COEF(0x76, 0x000e),
4985                 WRITE_COEF(0x6c, 0x2400),
4986                 WRITE_COEF(0x18, 0x7308),
4987                 WRITE_COEF(0x6b, 0xc429),
4988                 {}
4989         };
4990         static const struct coef_fw coef0293[] = {
4991                 UPDATE_COEF(0x10, 7<<8, 6<<8), /* SET Line1 JD to 0 */
4992                 UPDATE_COEFEX(0x57, 0x05, 1<<15|1<<13, 0x0), /* SET charge pump by verb */
4993                 UPDATE_COEFEX(0x57, 0x03, 1<<10, 1<<10), /* SET EN_OSW to 1 */
4994                 UPDATE_COEF(0x1a, 1<<3, 1<<3), /* Combo JD gating with LINE1-VREFO */
4995                 WRITE_COEF(0x45, 0xc429), /* Set to TRS type */
4996                 UPDATE_COEF(0x4a, 0x000f, 0x000e), /* Combo Jack auto detect */
4997                 {}
4998         };
4999         static const struct coef_fw coef0668[] = {
5000                 WRITE_COEF(0x15, 0x0d40),
5001                 WRITE_COEF(0xb7, 0x802b),
5002                 {}
5003         };
5004         static const struct coef_fw coef0225[] = {
5005                 UPDATE_COEF(0x63, 3<<14, 0),
5006                 {}
5007         };
5008         static const struct coef_fw coef0274[] = {
5009                 UPDATE_COEF(0x4a, 0x0100, 0),
5010                 UPDATE_COEFEX(0x57, 0x05, 0x4000, 0),
5011                 UPDATE_COEF(0x6b, 0xf000, 0x5000),
5012                 UPDATE_COEF(0x4a, 0x0010, 0),
5013                 UPDATE_COEF(0x4a, 0x0c00, 0x0c00),
5014                 WRITE_COEF(0x45, 0x5289),
5015                 UPDATE_COEF(0x4a, 0x0c00, 0),
5016                 {}
5017         };
5018
5019         if (spec->no_internal_mic_pin) {
5020                 alc_update_coef_idx(codec, 0x45, 0xf<<12 | 1<<10, 5<<12);
5021                 return;
5022         }
5023
5024         switch (codec->core.vendor_id) {
5025         case 0x10ec0255:
5026                 alc_process_coef_fw(codec, coef0255);
5027                 break;
5028         case 0x10ec0230:
5029         case 0x10ec0236:
5030         case 0x10ec0256:
5031         case 0x19e58326:
5032                 alc_process_coef_fw(codec, coef0256);
5033                 break;
5034         case 0x10ec0234:
5035         case 0x10ec0274:
5036         case 0x10ec0294:
5037                 alc_process_coef_fw(codec, coef0274);
5038                 break;
5039         case 0x10ec0233:
5040         case 0x10ec0283:
5041                 alc_process_coef_fw(codec, coef0233);
5042                 break;
5043         case 0x10ec0286:
5044         case 0x10ec0288:
5045                 alc_process_coef_fw(codec, coef0288);
5046                 break;
5047         case 0x10ec0298:
5048                 alc_process_coef_fw(codec, coef0298);
5049                 alc_process_coef_fw(codec, coef0288);
5050                 break;
5051         case 0x10ec0292:
5052                 alc_process_coef_fw(codec, coef0292);
5053                 break;
5054         case 0x10ec0293:
5055                 alc_process_coef_fw(codec, coef0293);
5056                 break;
5057         case 0x10ec0668:
5058                 alc_process_coef_fw(codec, coef0668);
5059                 break;
5060         case 0x10ec0215:
5061         case 0x10ec0225:
5062         case 0x10ec0285:
5063         case 0x10ec0295:
5064         case 0x10ec0289:
5065         case 0x10ec0299:
5066                 alc_process_coef_fw(codec, alc225_pre_hsmode);
5067                 alc_process_coef_fw(codec, coef0225);
5068                 break;
5069         case 0x10ec0867:
5070                 alc_update_coefex_idx(codec, 0x57, 0x5, 1<<14, 0);
5071                 break;
5072         }
5073         codec_dbg(codec, "Headset jack set to unplugged mode.\n");
5074 }
5075
5076
5077 static void alc_headset_mode_mic_in(struct hda_codec *codec, hda_nid_t hp_pin,
5078                                     hda_nid_t mic_pin)
5079 {
5080         static const struct coef_fw coef0255[] = {
5081                 WRITE_COEFEX(0x57, 0x03, 0x8aa6),
5082                 WRITE_COEF(0x06, 0x6100), /* Set MIC2 Vref gate to normal */
5083                 {}
5084         };
5085         static const struct coef_fw coef0256[] = {
5086                 UPDATE_COEFEX(0x57, 0x05, 1<<14, 1<<14), /* Direct Drive HP Amp control(Set to verb control)*/
5087                 WRITE_COEFEX(0x57, 0x03, 0x09a3),
5088                 WRITE_COEF(0x06, 0x6100), /* Set MIC2 Vref gate to normal */
5089                 {}
5090         };
5091         static const struct coef_fw coef0233[] = {
5092                 UPDATE_COEF(0x35, 0, 1<<14),
5093                 WRITE_COEF(0x06, 0x2100),
5094                 WRITE_COEF(0x1a, 0x0021),
5095                 WRITE_COEF(0x26, 0x008c),
5096                 {}
5097         };
5098         static const struct coef_fw coef0288[] = {
5099                 UPDATE_COEF(0x4f, 0x00c0, 0),
5100                 UPDATE_COEF(0x50, 0x2000, 0),
5101                 UPDATE_COEF(0x56, 0x0006, 0),
5102                 UPDATE_COEF(0x4f, 0xfcc0, 0xc400),
5103                 UPDATE_COEF(0x66, 0x0008, 0x0008),
5104                 UPDATE_COEF(0x67, 0x2000, 0x2000),
5105                 {}
5106         };
5107         static const struct coef_fw coef0292[] = {
5108                 WRITE_COEF(0x19, 0xa208),
5109                 WRITE_COEF(0x2e, 0xacf0),
5110                 {}
5111         };
5112         static const struct coef_fw coef0293[] = {
5113                 UPDATE_COEFEX(0x57, 0x05, 0, 1<<15|1<<13), /* SET charge pump by verb */
5114                 UPDATE_COEFEX(0x57, 0x03, 1<<10, 0), /* SET EN_OSW to 0 */
5115                 UPDATE_COEF(0x1a, 1<<3, 0), /* Combo JD gating without LINE1-VREFO */
5116                 {}
5117         };
5118         static const struct coef_fw coef0688[] = {
5119                 WRITE_COEF(0xb7, 0x802b),
5120                 WRITE_COEF(0xb5, 0x1040),
5121                 UPDATE_COEF(0xc3, 0, 1<<12),
5122                 {}
5123         };
5124         static const struct coef_fw coef0225[] = {
5125                 UPDATE_COEFEX(0x57, 0x05, 1<<14, 1<<14),
5126                 UPDATE_COEF(0x4a, 3<<4, 2<<4),
5127                 UPDATE_COEF(0x63, 3<<14, 0),
5128                 {}
5129         };
5130         static const struct coef_fw coef0274[] = {
5131                 UPDATE_COEFEX(0x57, 0x05, 0x4000, 0x4000),
5132                 UPDATE_COEF(0x4a, 0x0010, 0),
5133                 UPDATE_COEF(0x6b, 0xf000, 0),
5134                 {}
5135         };
5136
5137         switch (codec->core.vendor_id) {
5138         case 0x10ec0255:
5139                 alc_write_coef_idx(codec, 0x45, 0xc489);
5140                 snd_hda_set_pin_ctl_cache(codec, hp_pin, 0);
5141                 alc_process_coef_fw(codec, coef0255);
5142                 snd_hda_set_pin_ctl_cache(codec, mic_pin, PIN_VREF50);
5143                 break;
5144         case 0x10ec0230:
5145         case 0x10ec0236:
5146         case 0x10ec0256:
5147         case 0x19e58326:
5148                 alc_write_coef_idx(codec, 0x45, 0xc489);
5149                 snd_hda_set_pin_ctl_cache(codec, hp_pin, 0);
5150                 alc_process_coef_fw(codec, coef0256);
5151                 snd_hda_set_pin_ctl_cache(codec, mic_pin, PIN_VREF50);
5152                 break;
5153         case 0x10ec0234:
5154         case 0x10ec0274:
5155         case 0x10ec0294:
5156                 alc_write_coef_idx(codec, 0x45, 0x4689);
5157                 snd_hda_set_pin_ctl_cache(codec, hp_pin, 0);
5158                 alc_process_coef_fw(codec, coef0274);
5159                 snd_hda_set_pin_ctl_cache(codec, mic_pin, PIN_VREF50);
5160                 break;
5161         case 0x10ec0233:
5162         case 0x10ec0283:
5163                 alc_write_coef_idx(codec, 0x45, 0xc429);
5164                 snd_hda_set_pin_ctl_cache(codec, hp_pin, 0);
5165                 alc_process_coef_fw(codec, coef0233);
5166                 snd_hda_set_pin_ctl_cache(codec, mic_pin, PIN_VREF50);
5167                 break;
5168         case 0x10ec0286:
5169         case 0x10ec0288:
5170         case 0x10ec0298:
5171                 snd_hda_set_pin_ctl_cache(codec, hp_pin, 0);
5172                 alc_process_coef_fw(codec, coef0288);
5173                 snd_hda_set_pin_ctl_cache(codec, mic_pin, PIN_VREF50);
5174                 break;
5175         case 0x10ec0292:
5176                 snd_hda_set_pin_ctl_cache(codec, hp_pin, 0);
5177                 alc_process_coef_fw(codec, coef0292);
5178                 break;
5179         case 0x10ec0293:
5180                 /* Set to TRS mode */
5181                 alc_write_coef_idx(codec, 0x45, 0xc429);
5182                 snd_hda_set_pin_ctl_cache(codec, hp_pin, 0);
5183                 alc_process_coef_fw(codec, coef0293);
5184                 snd_hda_set_pin_ctl_cache(codec, mic_pin, PIN_VREF50);
5185                 break;
5186         case 0x10ec0867:
5187                 alc_update_coefex_idx(codec, 0x57, 0x5, 0, 1<<14);
5188                 fallthrough;
5189         case 0x10ec0221:
5190         case 0x10ec0662:
5191                 snd_hda_set_pin_ctl_cache(codec, hp_pin, 0);
5192                 snd_hda_set_pin_ctl_cache(codec, mic_pin, PIN_VREF50);
5193                 break;
5194         case 0x10ec0668:
5195                 alc_write_coef_idx(codec, 0x11, 0x0001);
5196                 snd_hda_set_pin_ctl_cache(codec, hp_pin, 0);
5197                 alc_process_coef_fw(codec, coef0688);
5198                 snd_hda_set_pin_ctl_cache(codec, mic_pin, PIN_VREF50);
5199                 break;
5200         case 0x10ec0215:
5201         case 0x10ec0225:
5202         case 0x10ec0285:
5203         case 0x10ec0295:
5204         case 0x10ec0289:
5205         case 0x10ec0299:
5206                 alc_process_coef_fw(codec, alc225_pre_hsmode);
5207                 alc_update_coef_idx(codec, 0x45, 0x3f<<10, 0x31<<10);
5208                 snd_hda_set_pin_ctl_cache(codec, hp_pin, 0);
5209                 alc_process_coef_fw(codec, coef0225);
5210                 snd_hda_set_pin_ctl_cache(codec, mic_pin, PIN_VREF50);
5211                 break;
5212         }
5213         codec_dbg(codec, "Headset jack set to mic-in mode.\n");
5214 }
5215
5216 static void alc_headset_mode_default(struct hda_codec *codec)
5217 {
5218         static const struct coef_fw coef0225[] = {
5219                 UPDATE_COEF(0x45, 0x3f<<10, 0x30<<10),
5220                 UPDATE_COEF(0x45, 0x3f<<10, 0x31<<10),
5221                 UPDATE_COEF(0x49, 3<<8, 0<<8),
5222                 UPDATE_COEF(0x4a, 3<<4, 3<<4),
5223                 UPDATE_COEF(0x63, 3<<14, 0),
5224                 UPDATE_COEF(0x67, 0xf000, 0x3000),
5225                 {}
5226         };
5227         static const struct coef_fw coef0255[] = {
5228                 WRITE_COEF(0x45, 0xc089),
5229                 WRITE_COEF(0x45, 0xc489),
5230                 WRITE_COEFEX(0x57, 0x03, 0x8ea6),
5231                 WRITE_COEF(0x49, 0x0049),
5232                 {}
5233         };
5234         static const struct coef_fw coef0256[] = {
5235                 WRITE_COEF(0x45, 0xc489),
5236                 WRITE_COEFEX(0x57, 0x03, 0x0da3),
5237                 WRITE_COEF(0x49, 0x0049),
5238                 UPDATE_COEFEX(0x57, 0x05, 1<<14, 0), /* Direct Drive HP Amp control(Set to verb control)*/
5239                 WRITE_COEF(0x06, 0x6100),
5240                 {}
5241         };
5242         static const struct coef_fw coef0233[] = {
5243                 WRITE_COEF(0x06, 0x2100),
5244                 WRITE_COEF(0x32, 0x4ea3),
5245                 {}
5246         };
5247         static const struct coef_fw coef0288[] = {
5248                 UPDATE_COEF(0x4f, 0xfcc0, 0xc400), /* Set to TRS type */
5249                 UPDATE_COEF(0x50, 0x2000, 0x2000),
5250                 UPDATE_COEF(0x56, 0x0006, 0x0006),
5251                 UPDATE_COEF(0x66, 0x0008, 0),
5252                 UPDATE_COEF(0x67, 0x2000, 0),
5253                 {}
5254         };
5255         static const struct coef_fw coef0292[] = {
5256                 WRITE_COEF(0x76, 0x000e),
5257                 WRITE_COEF(0x6c, 0x2400),
5258                 WRITE_COEF(0x6b, 0xc429),
5259                 WRITE_COEF(0x18, 0x7308),
5260                 {}
5261         };
5262         static const struct coef_fw coef0293[] = {
5263                 UPDATE_COEF(0x4a, 0x000f, 0x000e), /* Combo Jack auto detect */
5264                 WRITE_COEF(0x45, 0xC429), /* Set to TRS type */
5265                 UPDATE_COEF(0x1a, 1<<3, 0), /* Combo JD gating without LINE1-VREFO */
5266                 {}
5267         };
5268         static const struct coef_fw coef0688[] = {
5269                 WRITE_COEF(0x11, 0x0041),
5270                 WRITE_COEF(0x15, 0x0d40),
5271                 WRITE_COEF(0xb7, 0x802b),
5272                 {}
5273         };
5274         static const struct coef_fw coef0274[] = {
5275                 WRITE_COEF(0x45, 0x4289),
5276                 UPDATE_COEF(0x4a, 0x0010, 0x0010),
5277                 UPDATE_COEF(0x6b, 0x0f00, 0),
5278                 UPDATE_COEF(0x49, 0x0300, 0x0300),
5279                 {}
5280         };
5281
5282         switch (codec->core.vendor_id) {
5283         case 0x10ec0215:
5284         case 0x10ec0225:
5285         case 0x10ec0285:
5286         case 0x10ec0295:
5287         case 0x10ec0289:
5288         case 0x10ec0299:
5289                 alc_process_coef_fw(codec, alc225_pre_hsmode);
5290                 alc_process_coef_fw(codec, coef0225);
5291                 break;
5292         case 0x10ec0255:
5293                 alc_process_coef_fw(codec, coef0255);
5294                 break;
5295         case 0x10ec0230:
5296         case 0x10ec0236:
5297         case 0x10ec0256:
5298         case 0x19e58326:
5299                 alc_write_coef_idx(codec, 0x1b, 0x0e4b);
5300                 alc_write_coef_idx(codec, 0x45, 0xc089);
5301                 msleep(50);
5302                 alc_process_coef_fw(codec, coef0256);
5303                 break;
5304         case 0x10ec0234:
5305         case 0x10ec0274:
5306         case 0x10ec0294:
5307                 alc_process_coef_fw(codec, coef0274);
5308                 break;
5309         case 0x10ec0233:
5310         case 0x10ec0283:
5311                 alc_process_coef_fw(codec, coef0233);
5312                 break;
5313         case 0x10ec0286:
5314         case 0x10ec0288:
5315         case 0x10ec0298:
5316                 alc_process_coef_fw(codec, coef0288);
5317                 break;
5318         case 0x10ec0292:
5319                 alc_process_coef_fw(codec, coef0292);
5320                 break;
5321         case 0x10ec0293:
5322                 alc_process_coef_fw(codec, coef0293);
5323                 break;
5324         case 0x10ec0668:
5325                 alc_process_coef_fw(codec, coef0688);
5326                 break;
5327         case 0x10ec0867:
5328                 alc_update_coefex_idx(codec, 0x57, 0x5, 1<<14, 0);
5329                 break;
5330         }
5331         codec_dbg(codec, "Headset jack set to headphone (default) mode.\n");
5332 }
5333
5334 /* Iphone type */
5335 static void alc_headset_mode_ctia(struct hda_codec *codec)
5336 {
5337         int val;
5338
5339         static const struct coef_fw coef0255[] = {
5340                 WRITE_COEF(0x45, 0xd489), /* Set to CTIA type */
5341                 WRITE_COEF(0x1b, 0x0c2b),
5342                 WRITE_COEFEX(0x57, 0x03, 0x8ea6),
5343                 {}
5344         };
5345         static const struct coef_fw coef0256[] = {
5346                 WRITE_COEF(0x45, 0xd489), /* Set to CTIA type */
5347                 WRITE_COEF(0x1b, 0x0e6b),
5348                 {}
5349         };
5350         static const struct coef_fw coef0233[] = {
5351                 WRITE_COEF(0x45, 0xd429),
5352                 WRITE_COEF(0x1b, 0x0c2b),
5353                 WRITE_COEF(0x32, 0x4ea3),
5354                 {}
5355         };
5356         static const struct coef_fw coef0288[] = {
5357                 UPDATE_COEF(0x50, 0x2000, 0x2000),
5358                 UPDATE_COEF(0x56, 0x0006, 0x0006),
5359                 UPDATE_COEF(0x66, 0x0008, 0),
5360                 UPDATE_COEF(0x67, 0x2000, 0),
5361                 {}
5362         };
5363         static const struct coef_fw coef0292[] = {
5364                 WRITE_COEF(0x6b, 0xd429),
5365                 WRITE_COEF(0x76, 0x0008),
5366                 WRITE_COEF(0x18, 0x7388),
5367                 {}
5368         };
5369         static const struct coef_fw coef0293[] = {
5370                 WRITE_COEF(0x45, 0xd429), /* Set to ctia type */
5371                 UPDATE_COEF(0x10, 7<<8, 7<<8), /* SET Line1 JD to 1 */
5372                 {}
5373         };
5374         static const struct coef_fw coef0688[] = {
5375                 WRITE_COEF(0x11, 0x0001),
5376                 WRITE_COEF(0x15, 0x0d60),
5377                 WRITE_COEF(0xc3, 0x0000),
5378                 {}
5379         };
5380         static const struct coef_fw coef0225_1[] = {
5381                 UPDATE_COEF(0x45, 0x3f<<10, 0x35<<10),
5382                 UPDATE_COEF(0x63, 3<<14, 2<<14),
5383                 {}
5384         };
5385         static const struct coef_fw coef0225_2[] = {
5386                 UPDATE_COEF(0x45, 0x3f<<10, 0x35<<10),
5387                 UPDATE_COEF(0x63, 3<<14, 1<<14),
5388                 {}
5389         };
5390
5391         switch (codec->core.vendor_id) {
5392         case 0x10ec0255:
5393                 alc_process_coef_fw(codec, coef0255);
5394                 break;
5395         case 0x10ec0230:
5396         case 0x10ec0236:
5397         case 0x10ec0256:
5398         case 0x19e58326:
5399                 alc_process_coef_fw(codec, coef0256);
5400                 break;
5401         case 0x10ec0234:
5402         case 0x10ec0274:
5403         case 0x10ec0294:
5404                 alc_write_coef_idx(codec, 0x45, 0xd689);
5405                 break;
5406         case 0x10ec0233:
5407         case 0x10ec0283:
5408                 alc_process_coef_fw(codec, coef0233);
5409                 break;
5410         case 0x10ec0298:
5411                 val = alc_read_coef_idx(codec, 0x50);
5412                 if (val & (1 << 12)) {
5413                         alc_update_coef_idx(codec, 0x8e, 0x0070, 0x0020);
5414                         alc_update_coef_idx(codec, 0x4f, 0xfcc0, 0xd400);
5415                         msleep(300);
5416                 } else {
5417                         alc_update_coef_idx(codec, 0x8e, 0x0070, 0x0010);
5418                         alc_update_coef_idx(codec, 0x4f, 0xfcc0, 0xd400);
5419                         msleep(300);
5420                 }
5421                 break;
5422         case 0x10ec0286:
5423         case 0x10ec0288:
5424                 alc_update_coef_idx(codec, 0x4f, 0xfcc0, 0xd400);
5425                 msleep(300);
5426                 alc_process_coef_fw(codec, coef0288);
5427                 break;
5428         case 0x10ec0292:
5429                 alc_process_coef_fw(codec, coef0292);
5430                 break;
5431         case 0x10ec0293:
5432                 alc_process_coef_fw(codec, coef0293);
5433                 break;
5434         case 0x10ec0668:
5435                 alc_process_coef_fw(codec, coef0688);
5436                 break;
5437         case 0x10ec0215:
5438         case 0x10ec0225:
5439         case 0x10ec0285:
5440         case 0x10ec0295:
5441         case 0x10ec0289:
5442         case 0x10ec0299:
5443                 val = alc_read_coef_idx(codec, 0x45);
5444                 if (val & (1 << 9))
5445                         alc_process_coef_fw(codec, coef0225_2);
5446                 else
5447                         alc_process_coef_fw(codec, coef0225_1);
5448                 break;
5449         case 0x10ec0867:
5450                 alc_update_coefex_idx(codec, 0x57, 0x5, 1<<14, 0);
5451                 break;
5452         }
5453         codec_dbg(codec, "Headset jack set to iPhone-style headset mode.\n");
5454 }
5455
5456 /* Nokia type */
5457 static void alc_headset_mode_omtp(struct hda_codec *codec)
5458 {
5459         static const struct coef_fw coef0255[] = {
5460                 WRITE_COEF(0x45, 0xe489), /* Set to OMTP Type */
5461                 WRITE_COEF(0x1b, 0x0c2b),
5462                 WRITE_COEFEX(0x57, 0x03, 0x8ea6),
5463                 {}
5464         };
5465         static const struct coef_fw coef0256[] = {
5466                 WRITE_COEF(0x45, 0xe489), /* Set to OMTP Type */
5467                 WRITE_COEF(0x1b, 0x0e6b),
5468                 {}
5469         };
5470         static const struct coef_fw coef0233[] = {
5471                 WRITE_COEF(0x45, 0xe429),
5472                 WRITE_COEF(0x1b, 0x0c2b),
5473                 WRITE_COEF(0x32, 0x4ea3),
5474                 {}
5475         };
5476         static const struct coef_fw coef0288[] = {
5477                 UPDATE_COEF(0x50, 0x2000, 0x2000),
5478                 UPDATE_COEF(0x56, 0x0006, 0x0006),
5479                 UPDATE_COEF(0x66, 0x0008, 0),
5480                 UPDATE_COEF(0x67, 0x2000, 0),
5481                 {}
5482         };
5483         static const struct coef_fw coef0292[] = {
5484                 WRITE_COEF(0x6b, 0xe429),
5485                 WRITE_COEF(0x76, 0x0008),
5486                 WRITE_COEF(0x18, 0x7388),
5487                 {}
5488         };
5489         static const struct coef_fw coef0293[] = {
5490                 WRITE_COEF(0x45, 0xe429), /* Set to omtp type */
5491                 UPDATE_COEF(0x10, 7<<8, 7<<8), /* SET Line1 JD to 1 */
5492                 {}
5493         };
5494         static const struct coef_fw coef0688[] = {
5495                 WRITE_COEF(0x11, 0x0001),
5496                 WRITE_COEF(0x15, 0x0d50),
5497                 WRITE_COEF(0xc3, 0x0000),
5498                 {}
5499         };
5500         static const struct coef_fw coef0225[] = {
5501                 UPDATE_COEF(0x45, 0x3f<<10, 0x39<<10),
5502                 UPDATE_COEF(0x63, 3<<14, 2<<14),
5503                 {}
5504         };
5505
5506         switch (codec->core.vendor_id) {
5507         case 0x10ec0255:
5508                 alc_process_coef_fw(codec, coef0255);
5509                 break;
5510         case 0x10ec0230:
5511         case 0x10ec0236:
5512         case 0x10ec0256:
5513         case 0x19e58326:
5514                 alc_process_coef_fw(codec, coef0256);
5515                 break;
5516         case 0x10ec0234:
5517         case 0x10ec0274:
5518         case 0x10ec0294:
5519                 alc_write_coef_idx(codec, 0x45, 0xe689);
5520                 break;
5521         case 0x10ec0233:
5522         case 0x10ec0283:
5523                 alc_process_coef_fw(codec, coef0233);
5524                 break;
5525         case 0x10ec0298:
5526                 alc_update_coef_idx(codec, 0x8e, 0x0070, 0x0010);/* Headset output enable */
5527                 alc_update_coef_idx(codec, 0x4f, 0xfcc0, 0xe400);
5528                 msleep(300);
5529                 break;
5530         case 0x10ec0286:
5531         case 0x10ec0288:
5532                 alc_update_coef_idx(codec, 0x4f, 0xfcc0, 0xe400);
5533                 msleep(300);
5534                 alc_process_coef_fw(codec, coef0288);
5535                 break;
5536         case 0x10ec0292:
5537                 alc_process_coef_fw(codec, coef0292);
5538                 break;
5539         case 0x10ec0293:
5540                 alc_process_coef_fw(codec, coef0293);
5541                 break;
5542         case 0x10ec0668:
5543                 alc_process_coef_fw(codec, coef0688);
5544                 break;
5545         case 0x10ec0215:
5546         case 0x10ec0225:
5547         case 0x10ec0285:
5548         case 0x10ec0295:
5549         case 0x10ec0289:
5550         case 0x10ec0299:
5551                 alc_process_coef_fw(codec, coef0225);
5552                 break;
5553         }
5554         codec_dbg(codec, "Headset jack set to Nokia-style headset mode.\n");
5555 }
5556
5557 static void alc_determine_headset_type(struct hda_codec *codec)
5558 {
5559         int val;
5560         bool is_ctia = false;
5561         struct alc_spec *spec = codec->spec;
5562         static const struct coef_fw coef0255[] = {
5563                 WRITE_COEF(0x45, 0xd089), /* combo jack auto switch control(Check type)*/
5564                 WRITE_COEF(0x49, 0x0149), /* combo jack auto switch control(Vref
5565  conteol) */
5566                 {}
5567         };
5568         static const struct coef_fw coef0288[] = {
5569                 UPDATE_COEF(0x4f, 0xfcc0, 0xd400), /* Check Type */
5570                 {}
5571         };
5572         static const struct coef_fw coef0298[] = {
5573                 UPDATE_COEF(0x50, 0x2000, 0x2000),
5574                 UPDATE_COEF(0x56, 0x0006, 0x0006),
5575                 UPDATE_COEF(0x66, 0x0008, 0),
5576                 UPDATE_COEF(0x67, 0x2000, 0),
5577                 UPDATE_COEF(0x19, 0x1300, 0x1300),
5578                 {}
5579         };
5580         static const struct coef_fw coef0293[] = {
5581                 UPDATE_COEF(0x4a, 0x000f, 0x0008), /* Combo Jack auto detect */
5582                 WRITE_COEF(0x45, 0xD429), /* Set to ctia type */
5583                 {}
5584         };
5585         static const struct coef_fw coef0688[] = {
5586                 WRITE_COEF(0x11, 0x0001),
5587                 WRITE_COEF(0xb7, 0x802b),
5588                 WRITE_COEF(0x15, 0x0d60),
5589                 WRITE_COEF(0xc3, 0x0c00),
5590                 {}
5591         };
5592         static const struct coef_fw coef0274[] = {
5593                 UPDATE_COEF(0x4a, 0x0010, 0),
5594                 UPDATE_COEF(0x4a, 0x8000, 0),
5595                 WRITE_COEF(0x45, 0xd289),
5596                 UPDATE_COEF(0x49, 0x0300, 0x0300),
5597                 {}
5598         };
5599
5600         if (spec->no_internal_mic_pin) {
5601                 alc_update_coef_idx(codec, 0x45, 0xf<<12 | 1<<10, 5<<12);
5602                 return;
5603         }
5604
5605         switch (codec->core.vendor_id) {
5606         case 0x10ec0255:
5607                 alc_process_coef_fw(codec, coef0255);
5608                 msleep(300);
5609                 val = alc_read_coef_idx(codec, 0x46);
5610                 is_ctia = (val & 0x0070) == 0x0070;
5611                 break;
5612         case 0x10ec0230:
5613         case 0x10ec0236:
5614         case 0x10ec0256:
5615         case 0x19e58326:
5616                 alc_write_coef_idx(codec, 0x1b, 0x0e4b);
5617                 alc_write_coef_idx(codec, 0x06, 0x6104);
5618                 alc_write_coefex_idx(codec, 0x57, 0x3, 0x09a3);
5619
5620                 snd_hda_codec_write(codec, 0x21, 0,
5621                             AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);
5622                 msleep(80);
5623                 snd_hda_codec_write(codec, 0x21, 0,
5624                             AC_VERB_SET_PIN_WIDGET_CONTROL, 0x0);
5625
5626                 alc_process_coef_fw(codec, coef0255);
5627                 msleep(300);
5628                 val = alc_read_coef_idx(codec, 0x46);
5629                 is_ctia = (val & 0x0070) == 0x0070;
5630
5631                 alc_write_coefex_idx(codec, 0x57, 0x3, 0x0da3);
5632                 alc_update_coefex_idx(codec, 0x57, 0x5, 1<<14, 0);
5633
5634                 snd_hda_codec_write(codec, 0x21, 0,
5635                             AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT);
5636                 msleep(80);
5637                 snd_hda_codec_write(codec, 0x21, 0,
5638                             AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE);
5639                 break;
5640         case 0x10ec0234:
5641         case 0x10ec0274:
5642         case 0x10ec0294:
5643                 alc_process_coef_fw(codec, coef0274);
5644                 msleep(850);
5645                 val = alc_read_coef_idx(codec, 0x46);
5646                 is_ctia = (val & 0x00f0) == 0x00f0;
5647                 break;
5648         case 0x10ec0233:
5649         case 0x10ec0283:
5650                 alc_write_coef_idx(codec, 0x45, 0xd029);
5651                 msleep(300);
5652                 val = alc_read_coef_idx(codec, 0x46);
5653                 is_ctia = (val & 0x0070) == 0x0070;
5654                 break;
5655         case 0x10ec0298:
5656                 snd_hda_codec_write(codec, 0x21, 0,
5657                             AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);
5658                 msleep(100);
5659                 snd_hda_codec_write(codec, 0x21, 0,
5660                             AC_VERB_SET_PIN_WIDGET_CONTROL, 0x0);
5661                 msleep(200);
5662
5663                 val = alc_read_coef_idx(codec, 0x50);
5664                 if (val & (1 << 12)) {
5665                         alc_update_coef_idx(codec, 0x8e, 0x0070, 0x0020);
5666                         alc_process_coef_fw(codec, coef0288);
5667                         msleep(350);
5668                         val = alc_read_coef_idx(codec, 0x50);
5669                         is_ctia = (val & 0x0070) == 0x0070;
5670                 } else {
5671                         alc_update_coef_idx(codec, 0x8e, 0x0070, 0x0010);
5672                         alc_process_coef_fw(codec, coef0288);
5673                         msleep(350);
5674                         val = alc_read_coef_idx(codec, 0x50);
5675                         is_ctia = (val & 0x0070) == 0x0070;
5676                 }
5677                 alc_process_coef_fw(codec, coef0298);
5678                 snd_hda_codec_write(codec, 0x21, 0,
5679                             AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP);
5680                 msleep(75);
5681                 snd_hda_codec_write(codec, 0x21, 0,
5682                             AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE);
5683                 break;
5684         case 0x10ec0286:
5685         case 0x10ec0288:
5686                 alc_process_coef_fw(codec, coef0288);
5687                 msleep(350);
5688                 val = alc_read_coef_idx(codec, 0x50);
5689                 is_ctia = (val & 0x0070) == 0x0070;
5690                 break;
5691         case 0x10ec0292:
5692                 alc_write_coef_idx(codec, 0x6b, 0xd429);
5693                 msleep(300);
5694                 val = alc_read_coef_idx(codec, 0x6c);
5695                 is_ctia = (val & 0x001c) == 0x001c;
5696                 break;
5697         case 0x10ec0293:
5698                 alc_process_coef_fw(codec, coef0293);
5699                 msleep(300);
5700                 val = alc_read_coef_idx(codec, 0x46);
5701                 is_ctia = (val & 0x0070) == 0x0070;
5702                 break;
5703         case 0x10ec0668:
5704                 alc_process_coef_fw(codec, coef0688);
5705                 msleep(300);
5706                 val = alc_read_coef_idx(codec, 0xbe);
5707                 is_ctia = (val & 0x1c02) == 0x1c02;
5708                 break;
5709         case 0x10ec0215:
5710         case 0x10ec0225:
5711         case 0x10ec0285:
5712         case 0x10ec0295:
5713         case 0x10ec0289:
5714         case 0x10ec0299:
5715                 snd_hda_codec_write(codec, 0x21, 0,
5716                             AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);
5717                 msleep(80);
5718                 snd_hda_codec_write(codec, 0x21, 0,
5719                             AC_VERB_SET_PIN_WIDGET_CONTROL, 0x0);
5720
5721                 alc_process_coef_fw(codec, alc225_pre_hsmode);
5722                 alc_update_coef_idx(codec, 0x67, 0xf000, 0x1000);
5723                 val = alc_read_coef_idx(codec, 0x45);
5724                 if (val & (1 << 9)) {
5725                         alc_update_coef_idx(codec, 0x45, 0x3f<<10, 0x34<<10);
5726                         alc_update_coef_idx(codec, 0x49, 3<<8, 2<<8);
5727                         msleep(800);
5728                         val = alc_read_coef_idx(codec, 0x46);
5729                         is_ctia = (val & 0x00f0) == 0x00f0;
5730                 } else {
5731                         alc_update_coef_idx(codec, 0x45, 0x3f<<10, 0x34<<10);
5732                         alc_update_coef_idx(codec, 0x49, 3<<8, 1<<8);
5733                         msleep(800);
5734                         val = alc_read_coef_idx(codec, 0x46);
5735                         is_ctia = (val & 0x00f0) == 0x00f0;
5736                 }
5737                 alc_update_coef_idx(codec, 0x4a, 7<<6, 7<<6);
5738                 alc_update_coef_idx(codec, 0x4a, 3<<4, 3<<4);
5739                 alc_update_coef_idx(codec, 0x67, 0xf000, 0x3000);
5740
5741                 snd_hda_codec_write(codec, 0x21, 0,
5742                             AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT);
5743                 msleep(80);
5744                 snd_hda_codec_write(codec, 0x21, 0,
5745                             AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE);
5746                 break;
5747         case 0x10ec0867:
5748                 is_ctia = true;
5749                 break;
5750         }
5751
5752         codec_dbg(codec, "Headset jack detected iPhone-style headset: %s\n",
5753                     is_ctia ? "yes" : "no");
5754         spec->current_headset_type = is_ctia ? ALC_HEADSET_TYPE_CTIA : ALC_HEADSET_TYPE_OMTP;
5755 }
5756
5757 static void alc_update_headset_mode(struct hda_codec *codec)
5758 {
5759         struct alc_spec *spec = codec->spec;
5760
5761         hda_nid_t mux_pin = spec->gen.imux_pins[spec->gen.cur_mux[0]];
5762         hda_nid_t hp_pin = alc_get_hp_pin(spec);
5763
5764         int new_headset_mode;
5765
5766         if (!snd_hda_jack_detect(codec, hp_pin))
5767                 new_headset_mode = ALC_HEADSET_MODE_UNPLUGGED;
5768         else if (mux_pin == spec->headset_mic_pin)
5769                 new_headset_mode = ALC_HEADSET_MODE_HEADSET;
5770         else if (mux_pin == spec->headphone_mic_pin)
5771                 new_headset_mode = ALC_HEADSET_MODE_MIC;
5772         else
5773                 new_headset_mode = ALC_HEADSET_MODE_HEADPHONE;
5774
5775         if (new_headset_mode == spec->current_headset_mode) {
5776                 snd_hda_gen_update_outputs(codec);
5777                 return;
5778         }
5779
5780         switch (new_headset_mode) {
5781         case ALC_HEADSET_MODE_UNPLUGGED:
5782                 alc_headset_mode_unplugged(codec);
5783                 spec->current_headset_mode = ALC_HEADSET_MODE_UNKNOWN;
5784                 spec->current_headset_type = ALC_HEADSET_TYPE_UNKNOWN;
5785                 spec->gen.hp_jack_present = false;
5786                 break;
5787         case ALC_HEADSET_MODE_HEADSET:
5788                 if (spec->current_headset_type == ALC_HEADSET_TYPE_UNKNOWN)
5789                         alc_determine_headset_type(codec);
5790                 if (spec->current_headset_type == ALC_HEADSET_TYPE_CTIA)
5791                         alc_headset_mode_ctia(codec);
5792                 else if (spec->current_headset_type == ALC_HEADSET_TYPE_OMTP)
5793                         alc_headset_mode_omtp(codec);
5794                 spec->gen.hp_jack_present = true;
5795                 break;
5796         case ALC_HEADSET_MODE_MIC:
5797                 alc_headset_mode_mic_in(codec, hp_pin, spec->headphone_mic_pin);
5798                 spec->gen.hp_jack_present = false;
5799                 break;
5800         case ALC_HEADSET_MODE_HEADPHONE:
5801                 alc_headset_mode_default(codec);
5802                 spec->gen.hp_jack_present = true;
5803                 break;
5804         }
5805         if (new_headset_mode != ALC_HEADSET_MODE_MIC) {
5806                 snd_hda_set_pin_ctl_cache(codec, hp_pin,
5807                                           AC_PINCTL_OUT_EN | AC_PINCTL_HP_EN);
5808                 if (spec->headphone_mic_pin && spec->headphone_mic_pin != hp_pin)
5809                         snd_hda_set_pin_ctl_cache(codec, spec->headphone_mic_pin,
5810                                                   PIN_VREFHIZ);
5811         }
5812         spec->current_headset_mode = new_headset_mode;
5813
5814         snd_hda_gen_update_outputs(codec);
5815 }
5816
5817 static void alc_update_headset_mode_hook(struct hda_codec *codec,
5818                                          struct snd_kcontrol *kcontrol,
5819                                          struct snd_ctl_elem_value *ucontrol)
5820 {
5821         alc_update_headset_mode(codec);
5822 }
5823
5824 static void alc_update_headset_jack_cb(struct hda_codec *codec,
5825                                        struct hda_jack_callback *jack)
5826 {
5827         snd_hda_gen_hp_automute(codec, jack);
5828         alc_update_headset_mode(codec);
5829 }
5830
5831 static void alc_probe_headset_mode(struct hda_codec *codec)
5832 {
5833         int i;
5834         struct alc_spec *spec = codec->spec;
5835         struct auto_pin_cfg *cfg = &spec->gen.autocfg;
5836
5837         /* Find mic pins */
5838         for (i = 0; i < cfg->num_inputs; i++) {
5839                 if (cfg->inputs[i].is_headset_mic && !spec->headset_mic_pin)
5840                         spec->headset_mic_pin = cfg->inputs[i].pin;
5841                 if (cfg->inputs[i].is_headphone_mic && !spec->headphone_mic_pin)
5842                         spec->headphone_mic_pin = cfg->inputs[i].pin;
5843         }
5844
5845         WARN_ON(spec->gen.cap_sync_hook);
5846         spec->gen.cap_sync_hook = alc_update_headset_mode_hook;
5847         spec->gen.automute_hook = alc_update_headset_mode;
5848         spec->gen.hp_automute_hook = alc_update_headset_jack_cb;
5849 }
5850
5851 static void alc_fixup_headset_mode(struct hda_codec *codec,
5852                                 const struct hda_fixup *fix, int action)
5853 {
5854         struct alc_spec *spec = codec->spec;
5855
5856         switch (action) {
5857         case HDA_FIXUP_ACT_PRE_PROBE:
5858                 spec->parse_flags |= HDA_PINCFG_HEADSET_MIC | HDA_PINCFG_HEADPHONE_MIC;
5859                 break;
5860         case HDA_FIXUP_ACT_PROBE:
5861                 alc_probe_headset_mode(codec);
5862                 break;
5863         case HDA_FIXUP_ACT_INIT:
5864                 if (is_s3_resume(codec) || is_s4_resume(codec)) {
5865                         spec->current_headset_mode = ALC_HEADSET_MODE_UNKNOWN;
5866                         spec->current_headset_type = ALC_HEADSET_TYPE_UNKNOWN;
5867                 }
5868                 alc_update_headset_mode(codec);
5869                 break;
5870         }
5871 }
5872
5873 static void alc_fixup_headset_mode_no_hp_mic(struct hda_codec *codec,
5874                                 const struct hda_fixup *fix, int action)
5875 {
5876         if (action == HDA_FIXUP_ACT_PRE_PROBE) {
5877                 struct alc_spec *spec = codec->spec;
5878                 spec->parse_flags |= HDA_PINCFG_HEADSET_MIC;
5879         }
5880         else
5881                 alc_fixup_headset_mode(codec, fix, action);
5882 }
5883
5884 static void alc255_set_default_jack_type(struct hda_codec *codec)
5885 {
5886         /* Set to iphone type */
5887         static const struct coef_fw alc255fw[] = {
5888                 WRITE_COEF(0x1b, 0x880b),
5889                 WRITE_COEF(0x45, 0xd089),
5890                 WRITE_COEF(0x1b, 0x080b),
5891                 WRITE_COEF(0x46, 0x0004),
5892                 WRITE_COEF(0x1b, 0x0c0b),
5893                 {}
5894         };
5895         static const struct coef_fw alc256fw[] = {
5896                 WRITE_COEF(0x1b, 0x884b),
5897                 WRITE_COEF(0x45, 0xd089),
5898                 WRITE_COEF(0x1b, 0x084b),
5899                 WRITE_COEF(0x46, 0x0004),
5900                 WRITE_COEF(0x1b, 0x0c4b),
5901                 {}
5902         };
5903         switch (codec->core.vendor_id) {
5904         case 0x10ec0255:
5905                 alc_process_coef_fw(codec, alc255fw);
5906                 break;
5907         case 0x10ec0230:
5908         case 0x10ec0236:
5909         case 0x10ec0256:
5910         case 0x19e58326:
5911                 alc_process_coef_fw(codec, alc256fw);
5912                 break;
5913         }
5914         msleep(30);
5915 }
5916
5917 static void alc_fixup_headset_mode_alc255(struct hda_codec *codec,
5918                                 const struct hda_fixup *fix, int action)
5919 {
5920         if (action == HDA_FIXUP_ACT_PRE_PROBE) {
5921                 alc255_set_default_jack_type(codec);
5922         }
5923         alc_fixup_headset_mode(codec, fix, action);
5924 }
5925
5926 static void alc_fixup_headset_mode_alc255_no_hp_mic(struct hda_codec *codec,
5927                                 const struct hda_fixup *fix, int action)
5928 {
5929         if (action == HDA_FIXUP_ACT_PRE_PROBE) {
5930                 struct alc_spec *spec = codec->spec;
5931                 spec->parse_flags |= HDA_PINCFG_HEADSET_MIC;
5932                 alc255_set_default_jack_type(codec);
5933         }
5934         else
5935                 alc_fixup_headset_mode(codec, fix, action);
5936 }
5937
5938 static void alc288_update_headset_jack_cb(struct hda_codec *codec,
5939                                        struct hda_jack_callback *jack)
5940 {
5941         struct alc_spec *spec = codec->spec;
5942
5943         alc_update_headset_jack_cb(codec, jack);
5944         /* Headset Mic enable or disable, only for Dell Dino */
5945         alc_update_gpio_data(codec, 0x40, spec->gen.hp_jack_present);
5946 }
5947
5948 static void alc_fixup_headset_mode_dell_alc288(struct hda_codec *codec,
5949                                 const struct hda_fixup *fix, int action)
5950 {
5951         alc_fixup_headset_mode(codec, fix, action);
5952         if (action == HDA_FIXUP_ACT_PROBE) {
5953                 struct alc_spec *spec = codec->spec;
5954                 /* toggled via hp_automute_hook */
5955                 spec->gpio_mask |= 0x40;
5956                 spec->gpio_dir |= 0x40;
5957                 spec->gen.hp_automute_hook = alc288_update_headset_jack_cb;
5958         }
5959 }
5960
5961 static void alc_fixup_auto_mute_via_amp(struct hda_codec *codec,
5962                                         const struct hda_fixup *fix, int action)
5963 {
5964         if (action == HDA_FIXUP_ACT_PRE_PROBE) {
5965                 struct alc_spec *spec = codec->spec;
5966                 spec->gen.auto_mute_via_amp = 1;
5967         }
5968 }
5969
5970 static void alc_fixup_no_shutup(struct hda_codec *codec,
5971                                 const struct hda_fixup *fix, int action)
5972 {
5973         if (action == HDA_FIXUP_ACT_PRE_PROBE) {
5974                 struct alc_spec *spec = codec->spec;
5975                 spec->no_shutup_pins = 1;
5976         }
5977 }
5978
5979 static void alc_fixup_disable_aamix(struct hda_codec *codec,
5980                                     const struct hda_fixup *fix, int action)
5981 {
5982         if (action == HDA_FIXUP_ACT_PRE_PROBE) {
5983                 struct alc_spec *spec = codec->spec;
5984                 /* Disable AA-loopback as it causes white noise */
5985                 spec->gen.mixer_nid = 0;
5986         }
5987 }
5988
5989 /* fixup for Thinkpad docks: add dock pins, avoid HP parser fixup */
5990 static void alc_fixup_tpt440_dock(struct hda_codec *codec,
5991                                   const struct hda_fixup *fix, int action)
5992 {
5993         static const struct hda_pintbl pincfgs[] = {
5994                 { 0x16, 0x21211010 }, /* dock headphone */
5995                 { 0x19, 0x21a11010 }, /* dock mic */
5996                 { }
5997         };
5998         struct alc_spec *spec = codec->spec;
5999
6000         if (action == HDA_FIXUP_ACT_PRE_PROBE) {
6001                 spec->parse_flags = HDA_PINCFG_NO_HP_FIXUP;
6002                 codec->power_save_node = 0; /* avoid click noises */
6003                 snd_hda_apply_pincfgs(codec, pincfgs);
6004         }
6005 }
6006
6007 static void alc_fixup_tpt470_dock(struct hda_codec *codec,
6008                                   const struct hda_fixup *fix, int action)
6009 {
6010         static const struct hda_pintbl pincfgs[] = {
6011                 { 0x17, 0x21211010 }, /* dock headphone */
6012                 { 0x19, 0x21a11010 }, /* dock mic */
6013                 { }
6014         };
6015         struct alc_spec *spec = codec->spec;
6016
6017         if (action == HDA_FIXUP_ACT_PRE_PROBE) {
6018                 spec->parse_flags = HDA_PINCFG_NO_HP_FIXUP;
6019                 snd_hda_apply_pincfgs(codec, pincfgs);
6020         } else if (action == HDA_FIXUP_ACT_INIT) {
6021                 /* Enable DOCK device */
6022                 snd_hda_codec_write(codec, 0x17, 0,
6023                             AC_VERB_SET_CONFIG_DEFAULT_BYTES_3, 0);
6024                 /* Enable DOCK device */
6025                 snd_hda_codec_write(codec, 0x19, 0,
6026                             AC_VERB_SET_CONFIG_DEFAULT_BYTES_3, 0);
6027         }
6028 }
6029
6030 static void alc_fixup_tpt470_dacs(struct hda_codec *codec,
6031                                   const struct hda_fixup *fix, int action)
6032 {
6033         /* Assure the speaker pin to be coupled with DAC NID 0x03; otherwise
6034          * the speaker output becomes too low by some reason on Thinkpads with
6035          * ALC298 codec
6036          */
6037         static const hda_nid_t preferred_pairs[] = {
6038                 0x14, 0x03, 0x17, 0x02, 0x21, 0x02,
6039                 0
6040         };
6041         struct alc_spec *spec = codec->spec;
6042
6043         if (action == HDA_FIXUP_ACT_PRE_PROBE)
6044                 spec->gen.preferred_dacs = preferred_pairs;
6045 }
6046
6047 static void alc295_fixup_asus_dacs(struct hda_codec *codec,
6048                                    const struct hda_fixup *fix, int action)
6049 {
6050         static const hda_nid_t preferred_pairs[] = {
6051                 0x17, 0x02, 0x21, 0x03, 0
6052         };
6053         struct alc_spec *spec = codec->spec;
6054
6055         if (action == HDA_FIXUP_ACT_PRE_PROBE)
6056                 spec->gen.preferred_dacs = preferred_pairs;
6057 }
6058
6059 static void alc_shutup_dell_xps13(struct hda_codec *codec)
6060 {
6061         struct alc_spec *spec = codec->spec;
6062         int hp_pin = alc_get_hp_pin(spec);
6063
6064         /* Prevent pop noises when headphones are plugged in */
6065         snd_hda_codec_write(codec, hp_pin, 0,
6066                             AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);
6067         msleep(20);
6068 }
6069
6070 static void alc_fixup_dell_xps13(struct hda_codec *codec,
6071                                 const struct hda_fixup *fix, int action)
6072 {
6073         struct alc_spec *spec = codec->spec;
6074         struct hda_input_mux *imux = &spec->gen.input_mux;
6075         int i;
6076
6077         switch (action) {
6078         case HDA_FIXUP_ACT_PRE_PROBE:
6079                 /* mic pin 0x19 must be initialized with Vref Hi-Z, otherwise
6080                  * it causes a click noise at start up
6081                  */
6082                 snd_hda_codec_set_pin_target(codec, 0x19, PIN_VREFHIZ);
6083                 spec->shutup = alc_shutup_dell_xps13;
6084                 break;
6085         case HDA_FIXUP_ACT_PROBE:
6086                 /* Make the internal mic the default input source. */
6087                 for (i = 0; i < imux->num_items; i++) {
6088                         if (spec->gen.imux_pins[i] == 0x12) {
6089                                 spec->gen.cur_mux[0] = i;
6090                                 break;
6091                         }
6092                 }
6093                 break;
6094         }
6095 }
6096
6097 static void alc_fixup_headset_mode_alc662(struct hda_codec *codec,
6098                                 const struct hda_fixup *fix, int action)
6099 {
6100         struct alc_spec *spec = codec->spec;
6101
6102         if (action == HDA_FIXUP_ACT_PRE_PROBE) {
6103                 spec->parse_flags |= HDA_PINCFG_HEADSET_MIC;
6104                 spec->gen.hp_mic = 1; /* Mic-in is same pin as headphone */
6105
6106                 /* Disable boost for mic-in permanently. (This code is only called
6107                    from quirks that guarantee that the headphone is at NID 0x1b.) */
6108                 snd_hda_codec_write(codec, 0x1b, 0, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000);
6109                 snd_hda_override_wcaps(codec, 0x1b, get_wcaps(codec, 0x1b) & ~AC_WCAP_IN_AMP);
6110         } else
6111                 alc_fixup_headset_mode(codec, fix, action);
6112 }
6113
6114 static void alc_fixup_headset_mode_alc668(struct hda_codec *codec,
6115                                 const struct hda_fixup *fix, int action)
6116 {
6117         if (action == HDA_FIXUP_ACT_PRE_PROBE) {
6118                 alc_write_coef_idx(codec, 0xc4, 0x8000);
6119                 alc_update_coef_idx(codec, 0xc2, ~0xfe, 0);
6120                 snd_hda_set_pin_ctl_cache(codec, 0x18, 0);
6121         }
6122         alc_fixup_headset_mode(codec, fix, action);
6123 }
6124
6125 /* Returns the nid of the external mic input pin, or 0 if it cannot be found. */
6126 static int find_ext_mic_pin(struct hda_codec *codec)
6127 {
6128         struct alc_spec *spec = codec->spec;
6129         struct auto_pin_cfg *cfg = &spec->gen.autocfg;
6130         hda_nid_t nid;
6131         unsigned int defcfg;
6132         int i;
6133
6134         for (i = 0; i < cfg->num_inputs; i++) {
6135                 if (cfg->inputs[i].type != AUTO_PIN_MIC)
6136                         continue;
6137                 nid = cfg->inputs[i].pin;
6138                 defcfg = snd_hda_codec_get_pincfg(codec, nid);
6139                 if (snd_hda_get_input_pin_attr(defcfg) == INPUT_PIN_ATTR_INT)
6140                         continue;
6141                 return nid;
6142         }
6143
6144         return 0;
6145 }
6146
6147 static void alc271_hp_gate_mic_jack(struct hda_codec *codec,
6148                                     const struct hda_fixup *fix,
6149                                     int action)
6150 {
6151         struct alc_spec *spec = codec->spec;
6152
6153         if (action == HDA_FIXUP_ACT_PROBE) {
6154                 int mic_pin = find_ext_mic_pin(codec);
6155                 int hp_pin = alc_get_hp_pin(spec);
6156
6157                 if (snd_BUG_ON(!mic_pin || !hp_pin))
6158                         return;
6159                 snd_hda_jack_set_gating_jack(codec, mic_pin, hp_pin);
6160         }
6161 }
6162
6163 static void alc269_fixup_limit_int_mic_boost(struct hda_codec *codec,
6164                                              const struct hda_fixup *fix,
6165                                              int action)
6166 {
6167         struct alc_spec *spec = codec->spec;
6168         struct auto_pin_cfg *cfg = &spec->gen.autocfg;
6169         int i;
6170
6171         /* The mic boosts on level 2 and 3 are too noisy
6172            on the internal mic input.
6173            Therefore limit the boost to 0 or 1. */
6174
6175         if (action != HDA_FIXUP_ACT_PROBE)
6176                 return;
6177
6178         for (i = 0; i < cfg->num_inputs; i++) {
6179                 hda_nid_t nid = cfg->inputs[i].pin;
6180                 unsigned int defcfg;
6181                 if (cfg->inputs[i].type != AUTO_PIN_MIC)
6182                         continue;
6183                 defcfg = snd_hda_codec_get_pincfg(codec, nid);
6184                 if (snd_hda_get_input_pin_attr(defcfg) != INPUT_PIN_ATTR_INT)
6185                         continue;
6186
6187                 snd_hda_override_amp_caps(codec, nid, HDA_INPUT,
6188                                           (0x00 << AC_AMPCAP_OFFSET_SHIFT) |
6189                                           (0x01 << AC_AMPCAP_NUM_STEPS_SHIFT) |
6190                                           (0x2f << AC_AMPCAP_STEP_SIZE_SHIFT) |
6191                                           (0 << AC_AMPCAP_MUTE_SHIFT));
6192         }
6193 }
6194
6195 static void alc283_hp_automute_hook(struct hda_codec *codec,
6196                                     struct hda_jack_callback *jack)
6197 {
6198         struct alc_spec *spec = codec->spec;
6199         int vref;
6200
6201         msleep(200);
6202         snd_hda_gen_hp_automute(codec, jack);
6203
6204         vref = spec->gen.hp_jack_present ? PIN_VREF80 : 0;
6205
6206         msleep(600);
6207         snd_hda_codec_write(codec, 0x19, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
6208                             vref);
6209 }
6210
6211 static void alc283_fixup_chromebook(struct hda_codec *codec,
6212                                     const struct hda_fixup *fix, int action)
6213 {
6214         struct alc_spec *spec = codec->spec;
6215
6216         switch (action) {
6217         case HDA_FIXUP_ACT_PRE_PROBE:
6218                 snd_hda_override_wcaps(codec, 0x03, 0);
6219                 /* Disable AA-loopback as it causes white noise */
6220                 spec->gen.mixer_nid = 0;
6221                 break;
6222         case HDA_FIXUP_ACT_INIT:
6223                 /* MIC2-VREF control */
6224                 /* Set to manual mode */
6225                 alc_update_coef_idx(codec, 0x06, 0x000c, 0);
6226                 /* Enable Line1 input control by verb */
6227                 alc_update_coef_idx(codec, 0x1a, 0, 1 << 4);
6228                 break;
6229         }
6230 }
6231
6232 static void alc283_fixup_sense_combo_jack(struct hda_codec *codec,
6233                                     const struct hda_fixup *fix, int action)
6234 {
6235         struct alc_spec *spec = codec->spec;
6236
6237         switch (action) {
6238         case HDA_FIXUP_ACT_PRE_PROBE:
6239                 spec->gen.hp_automute_hook = alc283_hp_automute_hook;
6240                 break;
6241         case HDA_FIXUP_ACT_INIT:
6242                 /* MIC2-VREF control */
6243                 /* Set to manual mode */
6244                 alc_update_coef_idx(codec, 0x06, 0x000c, 0);
6245                 break;
6246         }
6247 }
6248
6249 /* mute tablet speaker pin (0x14) via dock plugging in addition */
6250 static void asus_tx300_automute(struct hda_codec *codec)
6251 {
6252         struct alc_spec *spec = codec->spec;
6253         snd_hda_gen_update_outputs(codec);
6254         if (snd_hda_jack_detect(codec, 0x1b))
6255                 spec->gen.mute_bits |= (1ULL << 0x14);
6256 }
6257
6258 static void alc282_fixup_asus_tx300(struct hda_codec *codec,
6259                                     const struct hda_fixup *fix, int action)
6260 {
6261         struct alc_spec *spec = codec->spec;
6262         static const struct hda_pintbl dock_pins[] = {
6263                 { 0x1b, 0x21114000 }, /* dock speaker pin */
6264                 {}
6265         };
6266
6267         switch (action) {
6268         case HDA_FIXUP_ACT_PRE_PROBE:
6269                 spec->init_amp = ALC_INIT_DEFAULT;
6270                 /* TX300 needs to set up GPIO2 for the speaker amp */
6271                 alc_setup_gpio(codec, 0x04);
6272                 snd_hda_apply_pincfgs(codec, dock_pins);
6273                 spec->gen.auto_mute_via_amp = 1;
6274                 spec->gen.automute_hook = asus_tx300_automute;
6275                 snd_hda_jack_detect_enable_callback(codec, 0x1b,
6276                                                     snd_hda_gen_hp_automute);
6277                 break;
6278         case HDA_FIXUP_ACT_PROBE:
6279                 spec->init_amp = ALC_INIT_DEFAULT;
6280                 break;
6281         case HDA_FIXUP_ACT_BUILD:
6282                 /* this is a bit tricky; give more sane names for the main
6283                  * (tablet) speaker and the dock speaker, respectively
6284                  */
6285                 rename_ctl(codec, "Speaker Playback Switch",
6286                            "Dock Speaker Playback Switch");
6287                 rename_ctl(codec, "Bass Speaker Playback Switch",
6288                            "Speaker Playback Switch");
6289                 break;
6290         }
6291 }
6292
6293 static void alc290_fixup_mono_speakers(struct hda_codec *codec,
6294                                        const struct hda_fixup *fix, int action)
6295 {
6296         if (action == HDA_FIXUP_ACT_PRE_PROBE) {
6297                 /* DAC node 0x03 is giving mono output. We therefore want to
6298                    make sure 0x14 (front speaker) and 0x15 (headphones) use the
6299                    stereo DAC, while leaving 0x17 (bass speaker) for node 0x03. */
6300                 static const hda_nid_t conn1[] = { 0x0c };
6301                 snd_hda_override_conn_list(codec, 0x14, ARRAY_SIZE(conn1), conn1);
6302                 snd_hda_override_conn_list(codec, 0x15, ARRAY_SIZE(conn1), conn1);
6303         }
6304 }
6305
6306 static void alc298_fixup_speaker_volume(struct hda_codec *codec,
6307                                         const struct hda_fixup *fix, int action)
6308 {
6309         if (action == HDA_FIXUP_ACT_PRE_PROBE) {
6310                 /* The speaker is routed to the Node 0x06 by a mistake, as a result
6311                    we can't adjust the speaker's volume since this node does not has
6312                    Amp-out capability. we change the speaker's route to:
6313                    Node 0x02 (Audio Output) -> Node 0x0c (Audio Mixer) -> Node 0x17 (
6314                    Pin Complex), since Node 0x02 has Amp-out caps, we can adjust
6315                    speaker's volume now. */
6316
6317                 static const hda_nid_t conn1[] = { 0x0c };
6318                 snd_hda_override_conn_list(codec, 0x17, ARRAY_SIZE(conn1), conn1);
6319         }
6320 }
6321
6322 /* disable DAC3 (0x06) selection on NID 0x17 as it has no volume amp control */
6323 static void alc295_fixup_disable_dac3(struct hda_codec *codec,
6324                                       const struct hda_fixup *fix, int action)
6325 {
6326         if (action == HDA_FIXUP_ACT_PRE_PROBE) {
6327                 static const hda_nid_t conn[] = { 0x02, 0x03 };
6328                 snd_hda_override_conn_list(codec, 0x17, ARRAY_SIZE(conn), conn);
6329         }
6330 }
6331
6332 /* force NID 0x17 (Bass Speaker) to DAC1 to share it with the main speaker */
6333 static void alc285_fixup_speaker2_to_dac1(struct hda_codec *codec,
6334                                           const struct hda_fixup *fix, int action)
6335 {
6336         if (action == HDA_FIXUP_ACT_PRE_PROBE) {
6337                 static const hda_nid_t conn[] = { 0x02 };
6338                 snd_hda_override_conn_list(codec, 0x17, ARRAY_SIZE(conn), conn);
6339         }
6340 }
6341
6342 /* Hook to update amp GPIO4 for automute */
6343 static void alc280_hp_gpio4_automute_hook(struct hda_codec *codec,
6344                                           struct hda_jack_callback *jack)
6345 {
6346         struct alc_spec *spec = codec->spec;
6347
6348         snd_hda_gen_hp_automute(codec, jack);
6349         /* mute_led_polarity is set to 0, so we pass inverted value here */
6350         alc_update_gpio_led(codec, 0x10, spec->mute_led_polarity,
6351                             !spec->gen.hp_jack_present);
6352 }
6353
6354 /* Manage GPIOs for HP EliteBook Folio 9480m.
6355  *
6356  * GPIO4 is the headphone amplifier power control
6357  * GPIO3 is the audio output mute indicator LED
6358  */
6359
6360 static void alc280_fixup_hp_9480m(struct hda_codec *codec,
6361                                   const struct hda_fixup *fix,
6362                                   int action)
6363 {
6364         struct alc_spec *spec = codec->spec;
6365
6366         alc_fixup_hp_gpio_led(codec, action, 0x08, 0);
6367         if (action == HDA_FIXUP_ACT_PRE_PROBE) {
6368                 /* amp at GPIO4; toggled via alc280_hp_gpio4_automute_hook() */
6369                 spec->gpio_mask |= 0x10;
6370                 spec->gpio_dir |= 0x10;
6371                 spec->gen.hp_automute_hook = alc280_hp_gpio4_automute_hook;
6372         }
6373 }
6374
6375 static void alc275_fixup_gpio4_off(struct hda_codec *codec,
6376                                    const struct hda_fixup *fix,
6377                                    int action)
6378 {
6379         struct alc_spec *spec = codec->spec;
6380
6381         if (action == HDA_FIXUP_ACT_PRE_PROBE) {
6382                 spec->gpio_mask |= 0x04;
6383                 spec->gpio_dir |= 0x04;
6384                 /* set data bit low */
6385         }
6386 }
6387
6388 /* Quirk for Thinkpad X1 7th and 8th Gen
6389  * The following fixed routing needed
6390  * DAC1 (NID 0x02) -> Speaker (NID 0x14); some eq applied secretly
6391  * DAC2 (NID 0x03) -> Bass (NID 0x17) & Headphone (NID 0x21); sharing a DAC
6392  * DAC3 (NID 0x06) -> Unused, due to the lack of volume amp
6393  */
6394 static void alc285_fixup_thinkpad_x1_gen7(struct hda_codec *codec,
6395                                           const struct hda_fixup *fix, int action)
6396 {
6397         static const hda_nid_t conn[] = { 0x02, 0x03 }; /* exclude 0x06 */
6398         static const hda_nid_t preferred_pairs[] = {
6399                 0x14, 0x02, 0x17, 0x03, 0x21, 0x03, 0
6400         };
6401         struct alc_spec *spec = codec->spec;
6402
6403         switch (action) {
6404         case HDA_FIXUP_ACT_PRE_PROBE:
6405                 snd_hda_override_conn_list(codec, 0x17, ARRAY_SIZE(conn), conn);
6406                 spec->gen.preferred_dacs = preferred_pairs;
6407                 break;
6408         case HDA_FIXUP_ACT_BUILD:
6409                 /* The generic parser creates somewhat unintuitive volume ctls
6410                  * with the fixed routing above, and the shared DAC2 may be
6411                  * confusing for PA.
6412                  * Rename those to unique names so that PA doesn't touch them
6413                  * and use only Master volume.
6414                  */
6415                 rename_ctl(codec, "Front Playback Volume", "DAC1 Playback Volume");
6416                 rename_ctl(codec, "Bass Speaker Playback Volume", "DAC2 Playback Volume");
6417                 break;
6418         }
6419 }
6420
6421 static void alc233_alc662_fixup_lenovo_dual_codecs(struct hda_codec *codec,
6422                                          const struct hda_fixup *fix,
6423                                          int action)
6424 {
6425         alc_fixup_dual_codecs(codec, fix, action);
6426         switch (action) {
6427         case HDA_FIXUP_ACT_PRE_PROBE:
6428                 /* override card longname to provide a unique UCM profile */
6429                 strcpy(codec->card->longname, "HDAudio-Lenovo-DualCodecs");
6430                 break;
6431         case HDA_FIXUP_ACT_BUILD:
6432                 /* rename Capture controls depending on the codec */
6433                 rename_ctl(codec, "Capture Volume",
6434                            codec->addr == 0 ?
6435                            "Rear-Panel Capture Volume" :
6436                            "Front-Panel Capture Volume");
6437                 rename_ctl(codec, "Capture Switch",
6438                            codec->addr == 0 ?
6439                            "Rear-Panel Capture Switch" :
6440                            "Front-Panel Capture Switch");
6441                 break;
6442         }
6443 }
6444
6445 static void alc225_fixup_s3_pop_noise(struct hda_codec *codec,
6446                                       const struct hda_fixup *fix, int action)
6447 {
6448         if (action != HDA_FIXUP_ACT_PRE_PROBE)
6449                 return;
6450
6451         codec->power_save_node = 1;
6452 }
6453
6454 /* Forcibly assign NID 0x03 to HP/LO while NID 0x02 to SPK for EQ */
6455 static void alc274_fixup_bind_dacs(struct hda_codec *codec,
6456                                     const struct hda_fixup *fix, int action)
6457 {
6458         struct alc_spec *spec = codec->spec;
6459         static const hda_nid_t preferred_pairs[] = {
6460                 0x21, 0x03, 0x1b, 0x03, 0x16, 0x02,
6461                 0
6462         };
6463
6464         if (action != HDA_FIXUP_ACT_PRE_PROBE)
6465                 return;
6466
6467         spec->gen.preferred_dacs = preferred_pairs;
6468         spec->gen.auto_mute_via_amp = 1;
6469         codec->power_save_node = 0;
6470 }
6471
6472 /* avoid DAC 0x06 for bass speaker 0x17; it has no volume control */
6473 static void alc289_fixup_asus_ga401(struct hda_codec *codec,
6474                                     const struct hda_fixup *fix, int action)
6475 {
6476         static const hda_nid_t preferred_pairs[] = {
6477                 0x14, 0x02, 0x17, 0x02, 0x21, 0x03, 0
6478         };
6479         struct alc_spec *spec = codec->spec;
6480
6481         if (action == HDA_FIXUP_ACT_PRE_PROBE) {
6482                 spec->gen.preferred_dacs = preferred_pairs;
6483                 spec->gen.obey_preferred_dacs = 1;
6484         }
6485 }
6486
6487 /* The DAC of NID 0x3 will introduce click/pop noise on headphones, so invalidate it */
6488 static void alc285_fixup_invalidate_dacs(struct hda_codec *codec,
6489                               const struct hda_fixup *fix, int action)
6490 {
6491         if (action != HDA_FIXUP_ACT_PRE_PROBE)
6492                 return;
6493
6494         snd_hda_override_wcaps(codec, 0x03, 0);
6495 }
6496
6497 static void alc_combo_jack_hp_jd_restart(struct hda_codec *codec)
6498 {
6499         switch (codec->core.vendor_id) {
6500         case 0x10ec0274:
6501         case 0x10ec0294:
6502         case 0x10ec0225:
6503         case 0x10ec0295:
6504         case 0x10ec0299:
6505                 alc_update_coef_idx(codec, 0x4a, 0x8000, 1 << 15); /* Reset HP JD */
6506                 alc_update_coef_idx(codec, 0x4a, 0x8000, 0 << 15);
6507                 break;
6508         case 0x10ec0230:
6509         case 0x10ec0235:
6510         case 0x10ec0236:
6511         case 0x10ec0255:
6512         case 0x10ec0256:
6513         case 0x10ec0257:
6514         case 0x19e58326:
6515                 alc_update_coef_idx(codec, 0x1b, 0x8000, 1 << 15); /* Reset HP JD */
6516                 alc_update_coef_idx(codec, 0x1b, 0x8000, 0 << 15);
6517                 break;
6518         }
6519 }
6520
6521 static void alc295_fixup_chromebook(struct hda_codec *codec,
6522                                     const struct hda_fixup *fix, int action)
6523 {
6524         struct alc_spec *spec = codec->spec;
6525
6526         switch (action) {
6527         case HDA_FIXUP_ACT_PRE_PROBE:
6528                 spec->ultra_low_power = true;
6529                 break;
6530         case HDA_FIXUP_ACT_INIT:
6531                 alc_combo_jack_hp_jd_restart(codec);
6532                 break;
6533         }
6534 }
6535
6536 static void alc_fixup_disable_mic_vref(struct hda_codec *codec,
6537                                   const struct hda_fixup *fix, int action)
6538 {
6539         if (action == HDA_FIXUP_ACT_PRE_PROBE)
6540                 snd_hda_codec_set_pin_target(codec, 0x19, PIN_VREFHIZ);
6541 }
6542
6543
6544 static void alc294_gx502_toggle_output(struct hda_codec *codec,
6545                                         struct hda_jack_callback *cb)
6546 {
6547         /* The Windows driver sets the codec up in a very different way where
6548          * it appears to leave 0x10 = 0x8a20 set. For Linux we need to toggle it
6549          */
6550         if (snd_hda_jack_detect_state(codec, 0x21) == HDA_JACK_PRESENT)
6551                 alc_write_coef_idx(codec, 0x10, 0x8a20);
6552         else
6553                 alc_write_coef_idx(codec, 0x10, 0x0a20);
6554 }
6555
6556 static void alc294_fixup_gx502_hp(struct hda_codec *codec,
6557                                         const struct hda_fixup *fix, int action)
6558 {
6559         /* Pin 0x21: headphones/headset mic */
6560         if (!is_jack_detectable(codec, 0x21))
6561                 return;
6562
6563         switch (action) {
6564         case HDA_FIXUP_ACT_PRE_PROBE:
6565                 snd_hda_jack_detect_enable_callback(codec, 0x21,
6566                                 alc294_gx502_toggle_output);
6567                 break;
6568         case HDA_FIXUP_ACT_INIT:
6569                 /* Make sure to start in a correct state, i.e. if
6570                  * headphones have been plugged in before powering up the system
6571                  */
6572                 alc294_gx502_toggle_output(codec, NULL);
6573                 break;
6574         }
6575 }
6576
6577 static void alc294_gu502_toggle_output(struct hda_codec *codec,
6578                                        struct hda_jack_callback *cb)
6579 {
6580         /* Windows sets 0x10 to 0x8420 for Node 0x20 which is
6581          * responsible from changes between speakers and headphones
6582          */
6583         if (snd_hda_jack_detect_state(codec, 0x21) == HDA_JACK_PRESENT)
6584                 alc_write_coef_idx(codec, 0x10, 0x8420);
6585         else
6586                 alc_write_coef_idx(codec, 0x10, 0x0a20);
6587 }
6588
6589 static void alc294_fixup_gu502_hp(struct hda_codec *codec,
6590                                   const struct hda_fixup *fix, int action)
6591 {
6592         if (!is_jack_detectable(codec, 0x21))
6593                 return;
6594
6595         switch (action) {
6596         case HDA_FIXUP_ACT_PRE_PROBE:
6597                 snd_hda_jack_detect_enable_callback(codec, 0x21,
6598                                 alc294_gu502_toggle_output);
6599                 break;
6600         case HDA_FIXUP_ACT_INIT:
6601                 alc294_gu502_toggle_output(codec, NULL);
6602                 break;
6603         }
6604 }
6605
6606 static void  alc285_fixup_hp_gpio_amp_init(struct hda_codec *codec,
6607                               const struct hda_fixup *fix, int action)
6608 {
6609         if (action != HDA_FIXUP_ACT_INIT)
6610                 return;
6611
6612         msleep(100);
6613         alc_write_coef_idx(codec, 0x65, 0x0);
6614 }
6615
6616 static void alc274_fixup_hp_headset_mic(struct hda_codec *codec,
6617                                     const struct hda_fixup *fix, int action)
6618 {
6619         switch (action) {
6620         case HDA_FIXUP_ACT_INIT:
6621                 alc_combo_jack_hp_jd_restart(codec);
6622                 break;
6623         }
6624 }
6625
6626 static void alc_fixup_no_int_mic(struct hda_codec *codec,
6627                                     const struct hda_fixup *fix, int action)
6628 {
6629         struct alc_spec *spec = codec->spec;
6630
6631         switch (action) {
6632         case HDA_FIXUP_ACT_PRE_PROBE:
6633                 /* Mic RING SLEEVE swap for combo jack */
6634                 alc_update_coef_idx(codec, 0x45, 0xf<<12 | 1<<10, 5<<12);
6635                 spec->no_internal_mic_pin = true;
6636                 break;
6637         case HDA_FIXUP_ACT_INIT:
6638                 alc_combo_jack_hp_jd_restart(codec);
6639                 break;
6640         }
6641 }
6642
6643 /* GPIO1 = amplifier on/off
6644  * GPIO3 = mic mute LED
6645  */
6646 static void alc285_fixup_hp_spectre_x360_eb1(struct hda_codec *codec,
6647                                           const struct hda_fixup *fix, int action)
6648 {
6649         static const hda_nid_t conn[] = { 0x02 };
6650
6651         struct alc_spec *spec = codec->spec;
6652         static const struct hda_pintbl pincfgs[] = {
6653                 { 0x14, 0x90170110 },  /* front/high speakers */
6654                 { 0x17, 0x90170130 },  /* back/bass speakers */
6655                 { }
6656         };
6657
6658         //enable micmute led
6659         alc_fixup_hp_gpio_led(codec, action, 0x00, 0x04);
6660
6661         switch (action) {
6662         case HDA_FIXUP_ACT_PRE_PROBE:
6663                 spec->micmute_led_polarity = 1;
6664                 /* needed for amp of back speakers */
6665                 spec->gpio_mask |= 0x01;
6666                 spec->gpio_dir |= 0x01;
6667                 snd_hda_apply_pincfgs(codec, pincfgs);
6668                 /* share DAC to have unified volume control */
6669                 snd_hda_override_conn_list(codec, 0x14, ARRAY_SIZE(conn), conn);
6670                 snd_hda_override_conn_list(codec, 0x17, ARRAY_SIZE(conn), conn);
6671                 break;
6672         case HDA_FIXUP_ACT_INIT:
6673                 /* need to toggle GPIO to enable the amp of back speakers */
6674                 alc_update_gpio_data(codec, 0x01, true);
6675                 msleep(100);
6676                 alc_update_gpio_data(codec, 0x01, false);
6677                 break;
6678         }
6679 }
6680
6681 static void alc285_fixup_hp_spectre_x360(struct hda_codec *codec,
6682                                           const struct hda_fixup *fix, int action)
6683 {
6684         static const hda_nid_t conn[] = { 0x02 };
6685         static const struct hda_pintbl pincfgs[] = {
6686                 { 0x14, 0x90170110 },  /* rear speaker */
6687                 { }
6688         };
6689
6690         switch (action) {
6691         case HDA_FIXUP_ACT_PRE_PROBE:
6692                 snd_hda_apply_pincfgs(codec, pincfgs);
6693                 /* force front speaker to DAC1 */
6694                 snd_hda_override_conn_list(codec, 0x17, ARRAY_SIZE(conn), conn);
6695                 break;
6696         }
6697 }
6698
6699 static void alc285_fixup_hp_envy_x360(struct hda_codec *codec,
6700                                       const struct hda_fixup *fix,
6701                                       int action)
6702 {
6703         static const struct coef_fw coefs[] = {
6704                 WRITE_COEF(0x08, 0x6a0c), WRITE_COEF(0x0d, 0xa023),
6705                 WRITE_COEF(0x10, 0x0320), WRITE_COEF(0x1a, 0x8c03),
6706                 WRITE_COEF(0x25, 0x1800), WRITE_COEF(0x26, 0x003a),
6707                 WRITE_COEF(0x28, 0x1dfe), WRITE_COEF(0x29, 0xb014),
6708                 WRITE_COEF(0x2b, 0x1dfe), WRITE_COEF(0x37, 0xfe15),
6709                 WRITE_COEF(0x38, 0x7909), WRITE_COEF(0x45, 0xd489),
6710                 WRITE_COEF(0x46, 0x00f4), WRITE_COEF(0x4a, 0x21e0),
6711                 WRITE_COEF(0x66, 0x03f0), WRITE_COEF(0x67, 0x1000),
6712                 WRITE_COEF(0x6e, 0x1005), { }
6713         };
6714
6715         static const struct hda_pintbl pincfgs[] = {
6716                 { 0x12, 0xb7a60130 },  /* Internal microphone*/
6717                 { 0x14, 0x90170150 },  /* B&O soundbar speakers */
6718                 { 0x17, 0x90170153 },  /* Side speakers */
6719                 { 0x19, 0x03a11040 },  /* Headset microphone */
6720                 { }
6721         };
6722
6723         switch (action) {
6724         case HDA_FIXUP_ACT_PRE_PROBE:
6725                 snd_hda_apply_pincfgs(codec, pincfgs);
6726
6727                 /* Fixes volume control problem for side speakers */
6728                 alc295_fixup_disable_dac3(codec, fix, action);
6729
6730                 /* Fixes no sound from headset speaker */
6731                 snd_hda_codec_amp_stereo(codec, 0x21, HDA_OUTPUT, 0, -1, 0);
6732
6733                 /* Auto-enable headset mic when plugged */
6734                 snd_hda_jack_set_gating_jack(codec, 0x19, 0x21);
6735
6736                 /* Headset mic volume enhancement */
6737                 snd_hda_codec_set_pin_target(codec, 0x19, PIN_VREF50);
6738                 break;
6739         case HDA_FIXUP_ACT_INIT:
6740                 alc_process_coef_fw(codec, coefs);
6741                 break;
6742         case HDA_FIXUP_ACT_BUILD:
6743                 rename_ctl(codec, "Bass Speaker Playback Volume",
6744                            "B&O-Tuned Playback Volume");
6745                 rename_ctl(codec, "Front Playback Switch",
6746                            "B&O Soundbar Playback Switch");
6747                 rename_ctl(codec, "Bass Speaker Playback Switch",
6748                            "Side Speaker Playback Switch");
6749                 break;
6750         }
6751 }
6752
6753 /* for hda_fixup_thinkpad_acpi() */
6754 #include "thinkpad_helper.c"
6755
6756 static void alc_fixup_thinkpad_acpi(struct hda_codec *codec,
6757                                     const struct hda_fixup *fix, int action)
6758 {
6759         alc_fixup_no_shutup(codec, fix, action); /* reduce click noise */
6760         hda_fixup_thinkpad_acpi(codec, fix, action);
6761 }
6762
6763 /* Fixup for Lenovo Legion 15IMHg05 speaker output on headset removal. */
6764 static void alc287_fixup_legion_15imhg05_speakers(struct hda_codec *codec,
6765                                                   const struct hda_fixup *fix,
6766                                                   int action)
6767 {
6768         struct alc_spec *spec = codec->spec;
6769
6770         switch (action) {
6771         case HDA_FIXUP_ACT_PRE_PROBE:
6772                 spec->gen.suppress_auto_mute = 1;
6773                 break;
6774         }
6775 }
6776
6777 static void comp_acpi_device_notify(acpi_handle handle, u32 event, void *data)
6778 {
6779         struct hda_codec *cdc = data;
6780         struct alc_spec *spec = cdc->spec;
6781
6782         codec_info(cdc, "ACPI Notification %d\n", event);
6783
6784         hda_component_acpi_device_notify(spec->comps, ARRAY_SIZE(spec->comps),
6785                                          handle, event, data);
6786 }
6787
6788 static int comp_bind(struct device *dev)
6789 {
6790         struct hda_codec *cdc = dev_to_hda_codec(dev);
6791         struct alc_spec *spec = cdc->spec;
6792         int ret;
6793
6794         ret = hda_component_manager_bind(cdc, spec->comps);
6795         if (ret)
6796                 return ret;
6797
6798         return hda_component_manager_bind_acpi_notifications(cdc,
6799                                                              spec->comps, ARRAY_SIZE(spec->comps),
6800                                                              comp_acpi_device_notify, cdc);
6801 }
6802
6803 static void comp_unbind(struct device *dev)
6804 {
6805         struct hda_codec *cdc = dev_to_hda_codec(dev);
6806         struct alc_spec *spec = cdc->spec;
6807
6808         hda_component_manager_unbind_acpi_notifications(cdc, spec->comps, comp_acpi_device_notify);
6809         hda_component_manager_unbind(cdc, spec->comps);
6810 }
6811
6812 static const struct component_master_ops comp_master_ops = {
6813         .bind = comp_bind,
6814         .unbind = comp_unbind,
6815 };
6816
6817 static void comp_generic_playback_hook(struct hda_pcm_stream *hinfo, struct hda_codec *cdc,
6818                                        struct snd_pcm_substream *sub, int action)
6819 {
6820         struct alc_spec *spec = cdc->spec;
6821
6822         hda_component_manager_playback_hook(spec->comps, ARRAY_SIZE(spec->comps), action);
6823 }
6824
6825 static void comp_generic_fixup(struct hda_codec *cdc, int action, const char *bus,
6826                                const char *hid, const char *match_str, int count)
6827 {
6828         struct alc_spec *spec = cdc->spec;
6829         int ret;
6830
6831         switch (action) {
6832         case HDA_FIXUP_ACT_PRE_PROBE:
6833                 ret = hda_component_manager_init(cdc, spec->comps, count, bus, hid,
6834                                                  match_str, &comp_master_ops);
6835                 if (ret)
6836                         return;
6837
6838                 spec->gen.pcm_playback_hook = comp_generic_playback_hook;
6839                 break;
6840         case HDA_FIXUP_ACT_FREE:
6841                 hda_component_manager_free(cdc, &comp_master_ops);
6842                 break;
6843         }
6844 }
6845
6846 static void cs35l41_fixup_i2c_two(struct hda_codec *cdc, const struct hda_fixup *fix, int action)
6847 {
6848         comp_generic_fixup(cdc, action, "i2c", "CSC3551", "-%s:00-cs35l41-hda.%d", 2);
6849 }
6850
6851 static void cs35l41_fixup_i2c_four(struct hda_codec *cdc, const struct hda_fixup *fix, int action)
6852 {
6853         comp_generic_fixup(cdc, action, "i2c", "CSC3551", "-%s:00-cs35l41-hda.%d", 4);
6854 }
6855
6856 static void cs35l41_fixup_spi_two(struct hda_codec *codec, const struct hda_fixup *fix, int action)
6857 {
6858         comp_generic_fixup(codec, action, "spi", "CSC3551", "-%s:00-cs35l41-hda.%d", 2);
6859 }
6860
6861 static void cs35l41_fixup_spi_four(struct hda_codec *codec, const struct hda_fixup *fix, int action)
6862 {
6863         comp_generic_fixup(codec, action, "spi", "CSC3551", "-%s:00-cs35l41-hda.%d", 4);
6864 }
6865
6866 static void alc287_fixup_legion_16achg6_speakers(struct hda_codec *cdc, const struct hda_fixup *fix,
6867                                                  int action)
6868 {
6869         comp_generic_fixup(cdc, action, "i2c", "CLSA0100", "-%s:00-cs35l41-hda.%d", 2);
6870 }
6871
6872 static void alc287_fixup_legion_16ithg6_speakers(struct hda_codec *cdc, const struct hda_fixup *fix,
6873                                                  int action)
6874 {
6875         comp_generic_fixup(cdc, action, "i2c", "CLSA0101", "-%s:00-cs35l41-hda.%d", 2);
6876 }
6877
6878 static void cs35l56_fixup_spi_four(struct hda_codec *cdc, const struct hda_fixup *fix, int action)
6879 {
6880         comp_generic_fixup(cdc, action, "spi", "CSC3556", "-%s:00-cs35l56-hda.%d", 4);
6881 }
6882
6883 static void tas2781_fixup_i2c(struct hda_codec *cdc,
6884         const struct hda_fixup *fix, int action)
6885 {
6886         comp_generic_fixup(cdc, action, "i2c", "TIAS2781", "-%s:00", 1);
6887 }
6888
6889 static void yoga7_14arb7_fixup_i2c(struct hda_codec *cdc,
6890         const struct hda_fixup *fix, int action)
6891 {
6892         comp_generic_fixup(cdc, action, "i2c", "INT8866", "-%s:00", 1);
6893 }
6894
6895 static void alc256_fixup_acer_sfg16_micmute_led(struct hda_codec *codec,
6896         const struct hda_fixup *fix, int action)
6897 {
6898         alc_fixup_hp_gpio_led(codec, action, 0, 0x04);
6899 }
6900
6901
6902 /* for alc295_fixup_hp_top_speakers */
6903 #include "hp_x360_helper.c"
6904
6905 /* for alc285_fixup_ideapad_s740_coef() */
6906 #include "ideapad_s740_helper.c"
6907
6908 static const struct coef_fw alc256_fixup_set_coef_defaults_coefs[] = {
6909         WRITE_COEF(0x10, 0x0020), WRITE_COEF(0x24, 0x0000),
6910         WRITE_COEF(0x26, 0x0000), WRITE_COEF(0x29, 0x3000),
6911         WRITE_COEF(0x37, 0xfe05), WRITE_COEF(0x45, 0x5089),
6912         {}
6913 };
6914
6915 static void alc256_fixup_set_coef_defaults(struct hda_codec *codec,
6916                                            const struct hda_fixup *fix,
6917                                            int action)
6918 {
6919         /*
6920          * A certain other OS sets these coeffs to different values. On at least
6921          * one TongFang barebone these settings might survive even a cold
6922          * reboot. So to restore a clean slate the values are explicitly reset
6923          * to default here. Without this, the external microphone is always in a
6924          * plugged-in state, while the internal microphone is always in an
6925          * unplugged state, breaking the ability to use the internal microphone.
6926          */
6927         alc_process_coef_fw(codec, alc256_fixup_set_coef_defaults_coefs);
6928 }
6929
6930 static const struct coef_fw alc233_fixup_no_audio_jack_coefs[] = {
6931         WRITE_COEF(0x1a, 0x9003), WRITE_COEF(0x1b, 0x0e2b), WRITE_COEF(0x37, 0xfe06),
6932         WRITE_COEF(0x38, 0x4981), WRITE_COEF(0x45, 0xd489), WRITE_COEF(0x46, 0x0074),
6933         WRITE_COEF(0x49, 0x0149),
6934         {}
6935 };
6936
6937 static void alc233_fixup_no_audio_jack(struct hda_codec *codec,
6938                                        const struct hda_fixup *fix,
6939                                        int action)
6940 {
6941         /*
6942          * The audio jack input and output is not detected on the ASRock NUC Box
6943          * 1100 series when cold booting without this fix. Warm rebooting from a
6944          * certain other OS makes the audio functional, as COEF settings are
6945          * preserved in this case. This fix sets these altered COEF values as
6946          * the default.
6947          */
6948         alc_process_coef_fw(codec, alc233_fixup_no_audio_jack_coefs);
6949 }
6950
6951 static void alc256_fixup_mic_no_presence_and_resume(struct hda_codec *codec,
6952                                                     const struct hda_fixup *fix,
6953                                                     int action)
6954 {
6955         /*
6956          * The Clevo NJ51CU comes either with the ALC293 or the ALC256 codec,
6957          * but uses the 0x8686 subproduct id in both cases. The ALC256 codec
6958          * needs an additional quirk for sound working after suspend and resume.
6959          */
6960         if (codec->core.vendor_id == 0x10ec0256) {
6961                 alc_update_coef_idx(codec, 0x10, 1<<9, 0);
6962                 snd_hda_codec_set_pincfg(codec, 0x19, 0x04a11120);
6963         } else {
6964                 snd_hda_codec_set_pincfg(codec, 0x1a, 0x04a1113c);
6965         }
6966 }
6967
6968 static void alc256_decrease_headphone_amp_val(struct hda_codec *codec,
6969                                               const struct hda_fixup *fix, int action)
6970 {
6971         u32 caps;
6972         u8 nsteps, offs;
6973
6974         if (action != HDA_FIXUP_ACT_PRE_PROBE)
6975                 return;
6976
6977         caps = query_amp_caps(codec, 0x3, HDA_OUTPUT);
6978         nsteps = ((caps & AC_AMPCAP_NUM_STEPS) >> AC_AMPCAP_NUM_STEPS_SHIFT) - 10;
6979         offs = ((caps & AC_AMPCAP_OFFSET) >> AC_AMPCAP_OFFSET_SHIFT) - 10;
6980         caps &= ~AC_AMPCAP_NUM_STEPS & ~AC_AMPCAP_OFFSET;
6981         caps |= (nsteps << AC_AMPCAP_NUM_STEPS_SHIFT) | (offs << AC_AMPCAP_OFFSET_SHIFT);
6982
6983         if (snd_hda_override_amp_caps(codec, 0x3, HDA_OUTPUT, caps))
6984                 codec_warn(codec, "failed to override amp caps for NID 0x3\n");
6985 }
6986
6987 static void alc_fixup_dell4_mic_no_presence_quiet(struct hda_codec *codec,
6988                                                   const struct hda_fixup *fix,
6989                                                   int action)
6990 {
6991         struct alc_spec *spec = codec->spec;
6992         struct hda_input_mux *imux = &spec->gen.input_mux;
6993         int i;
6994
6995         alc269_fixup_limit_int_mic_boost(codec, fix, action);
6996
6997         switch (action) {
6998         case HDA_FIXUP_ACT_PRE_PROBE:
6999                 /**
7000                  * Set the vref of pin 0x19 (Headset Mic) and pin 0x1b (Headphone Mic)
7001                  * to Hi-Z to avoid pop noises at startup and when plugging and
7002                  * unplugging headphones.
7003                  */
7004                 snd_hda_codec_set_pin_target(codec, 0x19, PIN_VREFHIZ);
7005                 snd_hda_codec_set_pin_target(codec, 0x1b, PIN_VREFHIZ);
7006                 break;
7007         case HDA_FIXUP_ACT_PROBE:
7008                 /**
7009                  * Make the internal mic (0x12) the default input source to
7010                  * prevent pop noises on cold boot.
7011                  */
7012                 for (i = 0; i < imux->num_items; i++) {
7013                         if (spec->gen.imux_pins[i] == 0x12) {
7014                                 spec->gen.cur_mux[0] = i;
7015                                 break;
7016                         }
7017                 }
7018                 break;
7019         }
7020 }
7021
7022 static void alc287_fixup_yoga9_14iap7_bass_spk_pin(struct hda_codec *codec,
7023                                           const struct hda_fixup *fix, int action)
7024 {
7025         /*
7026          * The Pin Complex 0x17 for the bass speakers is wrongly reported as
7027          * unconnected.
7028          */
7029         static const struct hda_pintbl pincfgs[] = {
7030                 { 0x17, 0x90170121 },
7031                 { }
7032         };
7033         /*
7034          * Avoid DAC 0x06 and 0x08, as they have no volume controls.
7035          * DAC 0x02 and 0x03 would be fine.
7036          */
7037         static const hda_nid_t conn[] = { 0x02, 0x03 };
7038         /*
7039          * Prefer both speakerbar (0x14) and bass speakers (0x17) connected to DAC 0x02.
7040          * Headphones (0x21) are connected to DAC 0x03.
7041          */
7042         static const hda_nid_t preferred_pairs[] = {
7043                 0x14, 0x02,
7044                 0x17, 0x02,
7045                 0x21, 0x03,
7046                 0
7047         };
7048         struct alc_spec *spec = codec->spec;
7049
7050         switch (action) {
7051         case HDA_FIXUP_ACT_PRE_PROBE:
7052                 snd_hda_apply_pincfgs(codec, pincfgs);
7053                 snd_hda_override_conn_list(codec, 0x17, ARRAY_SIZE(conn), conn);
7054                 spec->gen.preferred_dacs = preferred_pairs;
7055                 break;
7056         }
7057 }
7058
7059 static void alc295_fixup_dell_inspiron_top_speakers(struct hda_codec *codec,
7060                                           const struct hda_fixup *fix, int action)
7061 {
7062         static const struct hda_pintbl pincfgs[] = {
7063                 { 0x14, 0x90170151 },
7064                 { 0x17, 0x90170150 },
7065                 { }
7066         };
7067         static const hda_nid_t conn[] = { 0x02, 0x03 };
7068         static const hda_nid_t preferred_pairs[] = {
7069                 0x14, 0x02,
7070                 0x17, 0x03,
7071                 0x21, 0x02,
7072                 0
7073         };
7074         struct alc_spec *spec = codec->spec;
7075
7076         alc_fixup_no_shutup(codec, fix, action);
7077
7078         switch (action) {
7079         case HDA_FIXUP_ACT_PRE_PROBE:
7080                 snd_hda_apply_pincfgs(codec, pincfgs);
7081                 snd_hda_override_conn_list(codec, 0x17, ARRAY_SIZE(conn), conn);
7082                 spec->gen.preferred_dacs = preferred_pairs;
7083                 break;
7084         }
7085 }
7086
7087 /* Forcibly assign NID 0x03 to HP while NID 0x02 to SPK */
7088 static void alc287_fixup_bind_dacs(struct hda_codec *codec,
7089                                     const struct hda_fixup *fix, int action)
7090 {
7091         struct alc_spec *spec = codec->spec;
7092         static const hda_nid_t conn[] = { 0x02, 0x03 }; /* exclude 0x06 */
7093         static const hda_nid_t preferred_pairs[] = {
7094                 0x17, 0x02, 0x21, 0x03, 0
7095         };
7096
7097         if (action != HDA_FIXUP_ACT_PRE_PROBE)
7098                 return;
7099
7100         snd_hda_override_conn_list(codec, 0x17, ARRAY_SIZE(conn), conn);
7101         spec->gen.preferred_dacs = preferred_pairs;
7102         spec->gen.auto_mute_via_amp = 1;
7103         if (spec->gen.autocfg.speaker_pins[0] != 0x14) {
7104                 snd_hda_codec_write_cache(codec, 0x14, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
7105                                         0x0); /* Make sure 0x14 was disable */
7106         }
7107 }
7108 /* Fix none verb table of Headset Mic pin */
7109 static void alc_fixup_headset_mic(struct hda_codec *codec,
7110                                    const struct hda_fixup *fix, int action)
7111 {
7112         struct alc_spec *spec = codec->spec;
7113         static const struct hda_pintbl pincfgs[] = {
7114                 { 0x19, 0x03a1103c },
7115                 { }
7116         };
7117
7118         switch (action) {
7119         case HDA_FIXUP_ACT_PRE_PROBE:
7120                 snd_hda_apply_pincfgs(codec, pincfgs);
7121                 alc_update_coef_idx(codec, 0x45, 0xf<<12 | 1<<10, 5<<12);
7122                 spec->parse_flags |= HDA_PINCFG_HEADSET_MIC;
7123                 break;
7124         }
7125 }
7126
7127 static void alc245_fixup_hp_spectre_x360_eu0xxx(struct hda_codec *codec,
7128                                           const struct hda_fixup *fix, int action)
7129 {
7130         /*
7131          * The Pin Complex 0x14 for the treble speakers is wrongly reported as
7132          * unconnected.
7133          * The Pin Complex 0x17 for the bass speakers has the lowest association
7134          * and sequence values so shift it up a bit to squeeze 0x14 in.
7135          */
7136         static const struct hda_pintbl pincfgs[] = {
7137                 { 0x14, 0x90170110 }, // top/treble
7138                 { 0x17, 0x90170111 }, // bottom/bass
7139                 { }
7140         };
7141
7142         /*
7143          * Force DAC 0x02 for the bass speakers 0x17.
7144          */
7145         static const hda_nid_t conn[] = { 0x02 };
7146
7147         switch (action) {
7148         case HDA_FIXUP_ACT_PRE_PROBE:
7149                 snd_hda_apply_pincfgs(codec, pincfgs);
7150                 snd_hda_override_conn_list(codec, 0x17, ARRAY_SIZE(conn), conn);
7151                 break;
7152         }
7153
7154         cs35l41_fixup_i2c_two(codec, fix, action);
7155         alc245_fixup_hp_mute_led_coefbit(codec, fix, action);
7156         alc245_fixup_hp_gpio_led(codec, fix, action);
7157 }
7158
7159
7160 enum {
7161         ALC269_FIXUP_GPIO2,
7162         ALC269_FIXUP_SONY_VAIO,
7163         ALC275_FIXUP_SONY_VAIO_GPIO2,
7164         ALC269_FIXUP_DELL_M101Z,
7165         ALC269_FIXUP_SKU_IGNORE,
7166         ALC269_FIXUP_ASUS_G73JW,
7167         ALC269_FIXUP_ASUS_N7601ZM_PINS,
7168         ALC269_FIXUP_ASUS_N7601ZM,
7169         ALC269_FIXUP_LENOVO_EAPD,
7170         ALC275_FIXUP_SONY_HWEQ,
7171         ALC275_FIXUP_SONY_DISABLE_AAMIX,
7172         ALC271_FIXUP_DMIC,
7173         ALC269_FIXUP_PCM_44K,
7174         ALC269_FIXUP_STEREO_DMIC,
7175         ALC269_FIXUP_HEADSET_MIC,
7176         ALC269_FIXUP_QUANTA_MUTE,
7177         ALC269_FIXUP_LIFEBOOK,
7178         ALC269_FIXUP_LIFEBOOK_EXTMIC,
7179         ALC269_FIXUP_LIFEBOOK_HP_PIN,
7180         ALC269_FIXUP_LIFEBOOK_NO_HP_TO_LINEOUT,
7181         ALC255_FIXUP_LIFEBOOK_U7x7_HEADSET_MIC,
7182         ALC269_FIXUP_AMIC,
7183         ALC269_FIXUP_DMIC,
7184         ALC269VB_FIXUP_AMIC,
7185         ALC269VB_FIXUP_DMIC,
7186         ALC269_FIXUP_HP_MUTE_LED,
7187         ALC269_FIXUP_HP_MUTE_LED_MIC1,
7188         ALC269_FIXUP_HP_MUTE_LED_MIC2,
7189         ALC269_FIXUP_HP_MUTE_LED_MIC3,
7190         ALC269_FIXUP_HP_GPIO_LED,
7191         ALC269_FIXUP_HP_GPIO_MIC1_LED,
7192         ALC269_FIXUP_HP_LINE1_MIC1_LED,
7193         ALC269_FIXUP_INV_DMIC,
7194         ALC269_FIXUP_LENOVO_DOCK,
7195         ALC269_FIXUP_LENOVO_DOCK_LIMIT_BOOST,
7196         ALC269_FIXUP_NO_SHUTUP,
7197         ALC286_FIXUP_SONY_MIC_NO_PRESENCE,
7198         ALC269_FIXUP_PINCFG_NO_HP_TO_LINEOUT,
7199         ALC269_FIXUP_DELL1_MIC_NO_PRESENCE,
7200         ALC269_FIXUP_DELL2_MIC_NO_PRESENCE,
7201         ALC269_FIXUP_DELL3_MIC_NO_PRESENCE,
7202         ALC269_FIXUP_DELL4_MIC_NO_PRESENCE,
7203         ALC269_FIXUP_DELL4_MIC_NO_PRESENCE_QUIET,
7204         ALC269_FIXUP_HEADSET_MODE,
7205         ALC269_FIXUP_HEADSET_MODE_NO_HP_MIC,
7206         ALC269_FIXUP_ASPIRE_HEADSET_MIC,
7207         ALC269_FIXUP_ASUS_X101_FUNC,
7208         ALC269_FIXUP_ASUS_X101_VERB,
7209         ALC269_FIXUP_ASUS_X101,
7210         ALC271_FIXUP_AMIC_MIC2,
7211         ALC271_FIXUP_HP_GATE_MIC_JACK,
7212         ALC271_FIXUP_HP_GATE_MIC_JACK_E1_572,
7213         ALC269_FIXUP_ACER_AC700,
7214         ALC269_FIXUP_LIMIT_INT_MIC_BOOST,
7215         ALC269VB_FIXUP_ASUS_ZENBOOK,
7216         ALC269VB_FIXUP_ASUS_ZENBOOK_UX31A,
7217         ALC269VB_FIXUP_ASUS_MIC_NO_PRESENCE,
7218         ALC269_FIXUP_LIMIT_INT_MIC_BOOST_MUTE_LED,
7219         ALC269VB_FIXUP_ORDISSIMO_EVE2,
7220         ALC283_FIXUP_CHROME_BOOK,
7221         ALC283_FIXUP_SENSE_COMBO_JACK,
7222         ALC282_FIXUP_ASUS_TX300,
7223         ALC283_FIXUP_INT_MIC,
7224         ALC290_FIXUP_MONO_SPEAKERS,
7225         ALC290_FIXUP_MONO_SPEAKERS_HSJACK,
7226         ALC290_FIXUP_SUBWOOFER,
7227         ALC290_FIXUP_SUBWOOFER_HSJACK,
7228         ALC269_FIXUP_THINKPAD_ACPI,
7229         ALC269_FIXUP_DMIC_THINKPAD_ACPI,
7230         ALC269VB_FIXUP_CHUWI_COREBOOK_XPRO,
7231         ALC255_FIXUP_ACER_MIC_NO_PRESENCE,
7232         ALC255_FIXUP_ASUS_MIC_NO_PRESENCE,
7233         ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
7234         ALC255_FIXUP_DELL2_MIC_NO_PRESENCE,
7235         ALC255_FIXUP_HEADSET_MODE,
7236         ALC255_FIXUP_HEADSET_MODE_NO_HP_MIC,
7237         ALC293_FIXUP_DELL1_MIC_NO_PRESENCE,
7238         ALC292_FIXUP_TPT440_DOCK,
7239         ALC292_FIXUP_TPT440,
7240         ALC283_FIXUP_HEADSET_MIC,
7241         ALC255_FIXUP_MIC_MUTE_LED,
7242         ALC282_FIXUP_ASPIRE_V5_PINS,
7243         ALC269VB_FIXUP_ASPIRE_E1_COEF,
7244         ALC280_FIXUP_HP_GPIO4,
7245         ALC286_FIXUP_HP_GPIO_LED,
7246         ALC280_FIXUP_HP_GPIO2_MIC_HOTKEY,
7247         ALC280_FIXUP_HP_DOCK_PINS,
7248         ALC269_FIXUP_HP_DOCK_GPIO_MIC1_LED,
7249         ALC280_FIXUP_HP_9480M,
7250         ALC245_FIXUP_HP_X360_AMP,
7251         ALC285_FIXUP_HP_SPECTRE_X360_EB1,
7252         ALC285_FIXUP_HP_ENVY_X360,
7253         ALC288_FIXUP_DELL_HEADSET_MODE,
7254         ALC288_FIXUP_DELL1_MIC_NO_PRESENCE,
7255         ALC288_FIXUP_DELL_XPS_13,
7256         ALC288_FIXUP_DISABLE_AAMIX,
7257         ALC292_FIXUP_DELL_E7X_AAMIX,
7258         ALC292_FIXUP_DELL_E7X,
7259         ALC292_FIXUP_DISABLE_AAMIX,
7260         ALC293_FIXUP_DISABLE_AAMIX_MULTIJACK,
7261         ALC298_FIXUP_ALIENWARE_MIC_NO_PRESENCE,
7262         ALC298_FIXUP_DELL1_MIC_NO_PRESENCE,
7263         ALC298_FIXUP_DELL_AIO_MIC_NO_PRESENCE,
7264         ALC275_FIXUP_DELL_XPS,
7265         ALC293_FIXUP_LENOVO_SPK_NOISE,
7266         ALC233_FIXUP_LENOVO_LINE2_MIC_HOTKEY,
7267         ALC255_FIXUP_DELL_SPK_NOISE,
7268         ALC225_FIXUP_DISABLE_MIC_VREF,
7269         ALC225_FIXUP_DELL1_MIC_NO_PRESENCE,
7270         ALC295_FIXUP_DISABLE_DAC3,
7271         ALC285_FIXUP_SPEAKER2_TO_DAC1,
7272         ALC285_FIXUP_ASUS_SPEAKER2_TO_DAC1,
7273         ALC285_FIXUP_ASUS_HEADSET_MIC,
7274         ALC285_FIXUP_ASUS_SPI_REAR_SPEAKERS,
7275         ALC285_FIXUP_ASUS_I2C_SPEAKER2_TO_DAC1,
7276         ALC285_FIXUP_ASUS_I2C_HEADSET_MIC,
7277         ALC280_FIXUP_HP_HEADSET_MIC,
7278         ALC221_FIXUP_HP_FRONT_MIC,
7279         ALC292_FIXUP_TPT460,
7280         ALC298_FIXUP_SPK_VOLUME,
7281         ALC298_FIXUP_LENOVO_SPK_VOLUME,
7282         ALC256_FIXUP_DELL_INSPIRON_7559_SUBWOOFER,
7283         ALC269_FIXUP_ATIV_BOOK_8,
7284         ALC221_FIXUP_HP_288PRO_MIC_NO_PRESENCE,
7285         ALC221_FIXUP_HP_MIC_NO_PRESENCE,
7286         ALC256_FIXUP_ASUS_HEADSET_MODE,
7287         ALC256_FIXUP_ASUS_MIC,
7288         ALC256_FIXUP_ASUS_AIO_GPIO2,
7289         ALC233_FIXUP_ASUS_MIC_NO_PRESENCE,
7290         ALC233_FIXUP_EAPD_COEF_AND_MIC_NO_PRESENCE,
7291         ALC233_FIXUP_LENOVO_MULTI_CODECS,
7292         ALC233_FIXUP_ACER_HEADSET_MIC,
7293         ALC294_FIXUP_LENOVO_MIC_LOCATION,
7294         ALC225_FIXUP_DELL_WYSE_MIC_NO_PRESENCE,
7295         ALC225_FIXUP_S3_POP_NOISE,
7296         ALC700_FIXUP_INTEL_REFERENCE,
7297         ALC274_FIXUP_DELL_BIND_DACS,
7298         ALC274_FIXUP_DELL_AIO_LINEOUT_VERB,
7299         ALC298_FIXUP_TPT470_DOCK_FIX,
7300         ALC298_FIXUP_TPT470_DOCK,
7301         ALC255_FIXUP_DUMMY_LINEOUT_VERB,
7302         ALC255_FIXUP_DELL_HEADSET_MIC,
7303         ALC256_FIXUP_HUAWEI_MACH_WX9_PINS,
7304         ALC298_FIXUP_HUAWEI_MBX_STEREO,
7305         ALC295_FIXUP_HP_X360,
7306         ALC221_FIXUP_HP_HEADSET_MIC,
7307         ALC285_FIXUP_LENOVO_HEADPHONE_NOISE,
7308         ALC295_FIXUP_HP_AUTO_MUTE,
7309         ALC286_FIXUP_ACER_AIO_MIC_NO_PRESENCE,
7310         ALC294_FIXUP_ASUS_MIC,
7311         ALC294_FIXUP_ASUS_HEADSET_MIC,
7312         ALC294_FIXUP_ASUS_SPK,
7313         ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE,
7314         ALC285_FIXUP_LENOVO_PC_BEEP_IN_NOISE,
7315         ALC255_FIXUP_ACER_HEADSET_MIC,
7316         ALC295_FIXUP_CHROME_BOOK,
7317         ALC225_FIXUP_HEADSET_JACK,
7318         ALC225_FIXUP_DELL_WYSE_AIO_MIC_NO_PRESENCE,
7319         ALC225_FIXUP_WYSE_AUTO_MUTE,
7320         ALC225_FIXUP_WYSE_DISABLE_MIC_VREF,
7321         ALC286_FIXUP_ACER_AIO_HEADSET_MIC,
7322         ALC256_FIXUP_ASUS_HEADSET_MIC,
7323         ALC256_FIXUP_ASUS_MIC_NO_PRESENCE,
7324         ALC299_FIXUP_PREDATOR_SPK,
7325         ALC256_FIXUP_MEDION_HEADSET_NO_PRESENCE,
7326         ALC289_FIXUP_DELL_SPK1,
7327         ALC289_FIXUP_DELL_SPK2,
7328         ALC289_FIXUP_DUAL_SPK,
7329         ALC289_FIXUP_RTK_AMP_DUAL_SPK,
7330         ALC294_FIXUP_SPK2_TO_DAC1,
7331         ALC294_FIXUP_ASUS_DUAL_SPK,
7332         ALC285_FIXUP_THINKPAD_X1_GEN7,
7333         ALC285_FIXUP_THINKPAD_HEADSET_JACK,
7334         ALC294_FIXUP_ASUS_ALLY,
7335         ALC294_FIXUP_ASUS_ALLY_PINS,
7336         ALC294_FIXUP_ASUS_ALLY_VERBS,
7337         ALC294_FIXUP_ASUS_ALLY_SPEAKER,
7338         ALC294_FIXUP_ASUS_HPE,
7339         ALC294_FIXUP_ASUS_COEF_1B,
7340         ALC294_FIXUP_ASUS_GX502_HP,
7341         ALC294_FIXUP_ASUS_GX502_PINS,
7342         ALC294_FIXUP_ASUS_GX502_VERBS,
7343         ALC294_FIXUP_ASUS_GU502_HP,
7344         ALC294_FIXUP_ASUS_GU502_PINS,
7345         ALC294_FIXUP_ASUS_GU502_VERBS,
7346         ALC294_FIXUP_ASUS_G513_PINS,
7347         ALC285_FIXUP_ASUS_G533Z_PINS,
7348         ALC285_FIXUP_HP_GPIO_LED,
7349         ALC285_FIXUP_HP_MUTE_LED,
7350         ALC285_FIXUP_HP_SPECTRE_X360_MUTE_LED,
7351         ALC236_FIXUP_HP_MUTE_LED_COEFBIT2,
7352         ALC236_FIXUP_HP_GPIO_LED,
7353         ALC236_FIXUP_HP_MUTE_LED,
7354         ALC236_FIXUP_HP_MUTE_LED_MICMUTE_VREF,
7355         ALC298_FIXUP_SAMSUNG_AMP,
7356         ALC298_FIXUP_SAMSUNG_HEADPHONE_VERY_QUIET,
7357         ALC256_FIXUP_SAMSUNG_HEADPHONE_VERY_QUIET,
7358         ALC295_FIXUP_ASUS_MIC_NO_PRESENCE,
7359         ALC269VC_FIXUP_ACER_VCOPPERBOX_PINS,
7360         ALC269VC_FIXUP_ACER_HEADSET_MIC,
7361         ALC269VC_FIXUP_ACER_MIC_NO_PRESENCE,
7362         ALC289_FIXUP_ASUS_GA401,
7363         ALC289_FIXUP_ASUS_GA502,
7364         ALC256_FIXUP_ACER_MIC_NO_PRESENCE,
7365         ALC285_FIXUP_HP_GPIO_AMP_INIT,
7366         ALC269_FIXUP_CZC_B20,
7367         ALC269_FIXUP_CZC_TMI,
7368         ALC269_FIXUP_CZC_L101,
7369         ALC269_FIXUP_LEMOTE_A1802,
7370         ALC269_FIXUP_LEMOTE_A190X,
7371         ALC256_FIXUP_INTEL_NUC8_RUGGED,
7372         ALC233_FIXUP_INTEL_NUC8_DMIC,
7373         ALC233_FIXUP_INTEL_NUC8_BOOST,
7374         ALC256_FIXUP_INTEL_NUC10,
7375         ALC255_FIXUP_XIAOMI_HEADSET_MIC,
7376         ALC274_FIXUP_HP_MIC,
7377         ALC274_FIXUP_HP_HEADSET_MIC,
7378         ALC274_FIXUP_HP_ENVY_GPIO,
7379         ALC256_FIXUP_ASUS_HPE,
7380         ALC285_FIXUP_THINKPAD_NO_BASS_SPK_HEADSET_JACK,
7381         ALC287_FIXUP_HP_GPIO_LED,
7382         ALC256_FIXUP_HP_HEADSET_MIC,
7383         ALC245_FIXUP_HP_GPIO_LED,
7384         ALC236_FIXUP_DELL_AIO_HEADSET_MIC,
7385         ALC282_FIXUP_ACER_DISABLE_LINEOUT,
7386         ALC255_FIXUP_ACER_LIMIT_INT_MIC_BOOST,
7387         ALC256_FIXUP_ACER_HEADSET_MIC,
7388         ALC285_FIXUP_IDEAPAD_S740_COEF,
7389         ALC285_FIXUP_HP_LIMIT_INT_MIC_BOOST,
7390         ALC295_FIXUP_ASUS_DACS,
7391         ALC295_FIXUP_HP_OMEN,
7392         ALC285_FIXUP_HP_SPECTRE_X360,
7393         ALC287_FIXUP_IDEAPAD_BASS_SPK_AMP,
7394         ALC623_FIXUP_LENOVO_THINKSTATION_P340,
7395         ALC255_FIXUP_ACER_HEADPHONE_AND_MIC,
7396         ALC236_FIXUP_HP_LIMIT_INT_MIC_BOOST,
7397         ALC287_FIXUP_LEGION_15IMHG05_SPEAKERS,
7398         ALC287_FIXUP_LEGION_15IMHG05_AUTOMUTE,
7399         ALC287_FIXUP_YOGA7_14ITL_SPEAKERS,
7400         ALC298_FIXUP_LENOVO_C940_DUET7,
7401         ALC287_FIXUP_LENOVO_14IRP8_DUETITL,
7402         ALC287_FIXUP_13S_GEN2_SPEAKERS,
7403         ALC256_FIXUP_SET_COEF_DEFAULTS,
7404         ALC256_FIXUP_SYSTEM76_MIC_NO_PRESENCE,
7405         ALC233_FIXUP_NO_AUDIO_JACK,
7406         ALC256_FIXUP_MIC_NO_PRESENCE_AND_RESUME,
7407         ALC285_FIXUP_LEGION_Y9000X_SPEAKERS,
7408         ALC285_FIXUP_LEGION_Y9000X_AUTOMUTE,
7409         ALC287_FIXUP_LEGION_16ACHG6,
7410         ALC287_FIXUP_CS35L41_I2C_2,
7411         ALC287_FIXUP_CS35L41_I2C_2_HP_GPIO_LED,
7412         ALC287_FIXUP_CS35L41_I2C_4,
7413         ALC245_FIXUP_CS35L41_SPI_2,
7414         ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED,
7415         ALC245_FIXUP_CS35L41_SPI_4,
7416         ALC245_FIXUP_CS35L41_SPI_4_HP_GPIO_LED,
7417         ALC285_FIXUP_HP_SPEAKERS_MICMUTE_LED,
7418         ALC295_FIXUP_FRAMEWORK_LAPTOP_MIC_NO_PRESENCE,
7419         ALC287_FIXUP_LEGION_16ITHG6,
7420         ALC287_FIXUP_YOGA9_14IAP7_BASS_SPK,
7421         ALC287_FIXUP_YOGA9_14IAP7_BASS_SPK_PIN,
7422         ALC287_FIXUP_YOGA9_14IMH9_BASS_SPK_PIN,
7423         ALC295_FIXUP_DELL_INSPIRON_TOP_SPEAKERS,
7424         ALC236_FIXUP_DELL_DUAL_CODECS,
7425         ALC287_FIXUP_CS35L41_I2C_2_THINKPAD_ACPI,
7426         ALC287_FIXUP_TAS2781_I2C,
7427         ALC287_FIXUP_YOGA7_14ARB7_I2C,
7428         ALC245_FIXUP_HP_MUTE_LED_COEFBIT,
7429         ALC245_FIXUP_HP_X360_MUTE_LEDS,
7430         ALC287_FIXUP_THINKPAD_I2S_SPK,
7431         ALC287_FIXUP_MG_RTKC_CSAMP_CS35L41_I2C_THINKPAD,
7432         ALC2XX_FIXUP_HEADSET_MIC,
7433         ALC289_FIXUP_DELL_CS35L41_SPI_2,
7434         ALC294_FIXUP_CS35L41_I2C_2,
7435         ALC245_FIXUP_CS35L56_SPI_4_HP_GPIO_LED,
7436         ALC256_FIXUP_ACER_SFG16_MICMUTE_LED,
7437         ALC256_FIXUP_HEADPHONE_AMP_VOL,
7438         ALC245_FIXUP_HP_SPECTRE_X360_EU0XXX,
7439 };
7440
7441 /* A special fixup for Lenovo C940 and Yoga Duet 7;
7442  * both have the very same PCI SSID, and we need to apply different fixups
7443  * depending on the codec ID
7444  */
7445 static void alc298_fixup_lenovo_c940_duet7(struct hda_codec *codec,
7446                                            const struct hda_fixup *fix,
7447                                            int action)
7448 {
7449         int id;
7450
7451         if (codec->core.vendor_id == 0x10ec0298)
7452                 id = ALC298_FIXUP_LENOVO_SPK_VOLUME; /* C940 */
7453         else
7454                 id = ALC287_FIXUP_YOGA7_14ITL_SPEAKERS; /* Duet 7 */
7455         __snd_hda_apply_fixup(codec, id, action, 0);
7456 }
7457
7458 /* A special fixup for Lenovo Slim/Yoga Pro 9 14IRP8 and Yoga DuetITL 2021;
7459  * 14IRP8 PCI SSID will mistakenly be matched with the DuetITL codec SSID,
7460  * so we need to apply a different fixup in this case. The only DuetITL codec
7461  * SSID reported so far is the 17aa:3802 while the 14IRP8 has the 17aa:38be
7462  * and 17aa:38bf. If it weren't for the PCI SSID, the 14IRP8 models would
7463  * have matched correctly by their codecs.
7464  */
7465 static void alc287_fixup_lenovo_14irp8_duetitl(struct hda_codec *codec,
7466                                               const struct hda_fixup *fix,
7467                                               int action)
7468 {
7469         int id;
7470
7471         if (codec->core.subsystem_id == 0x17aa3802)
7472                 id = ALC287_FIXUP_YOGA7_14ITL_SPEAKERS; /* DuetITL */
7473         else
7474                 id = ALC287_FIXUP_TAS2781_I2C; /* 14IRP8 */
7475         __snd_hda_apply_fixup(codec, id, action, 0);
7476 }
7477
7478 static const struct hda_fixup alc269_fixups[] = {
7479         [ALC269_FIXUP_GPIO2] = {
7480                 .type = HDA_FIXUP_FUNC,
7481                 .v.func = alc_fixup_gpio2,
7482         },
7483         [ALC269_FIXUP_SONY_VAIO] = {
7484                 .type = HDA_FIXUP_PINCTLS,
7485                 .v.pins = (const struct hda_pintbl[]) {
7486                         {0x19, PIN_VREFGRD},
7487                         {}
7488                 }
7489         },
7490         [ALC275_FIXUP_SONY_VAIO_GPIO2] = {
7491                 .type = HDA_FIXUP_FUNC,
7492                 .v.func = alc275_fixup_gpio4_off,
7493                 .chained = true,
7494                 .chain_id = ALC269_FIXUP_SONY_VAIO
7495         },
7496         [ALC269_FIXUP_DELL_M101Z] = {
7497                 .type = HDA_FIXUP_VERBS,
7498                 .v.verbs = (const struct hda_verb[]) {
7499                         /* Enables internal speaker */
7500                         {0x20, AC_VERB_SET_COEF_INDEX, 13},
7501                         {0x20, AC_VERB_SET_PROC_COEF, 0x4040},
7502                         {}
7503                 }
7504         },
7505         [ALC269_FIXUP_SKU_IGNORE] = {
7506                 .type = HDA_FIXUP_FUNC,
7507                 .v.func = alc_fixup_sku_ignore,
7508         },
7509         [ALC269_FIXUP_ASUS_G73JW] = {
7510                 .type = HDA_FIXUP_PINS,
7511                 .v.pins = (const struct hda_pintbl[]) {
7512                         { 0x17, 0x99130111 }, /* subwoofer */
7513                         { }
7514                 }
7515         },
7516         [ALC269_FIXUP_ASUS_N7601ZM_PINS] = {
7517                 .type = HDA_FIXUP_PINS,
7518                 .v.pins = (const struct hda_pintbl[]) {
7519                         { 0x19, 0x03A11050 },
7520                         { 0x1a, 0x03A11C30 },
7521                         { 0x21, 0x03211420 },
7522                         { }
7523                 }
7524         },
7525         [ALC269_FIXUP_ASUS_N7601ZM] = {
7526                 .type = HDA_FIXUP_VERBS,
7527                 .v.verbs = (const struct hda_verb[]) {
7528                         {0x20, AC_VERB_SET_COEF_INDEX, 0x62},
7529                         {0x20, AC_VERB_SET_PROC_COEF, 0xa007},
7530                         {0x20, AC_VERB_SET_COEF_INDEX, 0x10},
7531                         {0x20, AC_VERB_SET_PROC_COEF, 0x8420},
7532                         {0x20, AC_VERB_SET_COEF_INDEX, 0x0f},
7533                         {0x20, AC_VERB_SET_PROC_COEF, 0x7774},
7534                         { }
7535                 },
7536                 .chained = true,
7537                 .chain_id = ALC269_FIXUP_ASUS_N7601ZM_PINS,
7538         },
7539         [ALC269_FIXUP_LENOVO_EAPD] = {
7540                 .type = HDA_FIXUP_VERBS,
7541                 .v.verbs = (const struct hda_verb[]) {
7542                         {0x14, AC_VERB_SET_EAPD_BTLENABLE, 0},
7543                         {}
7544                 }
7545         },
7546         [ALC275_FIXUP_SONY_HWEQ] = {
7547                 .type = HDA_FIXUP_FUNC,
7548                 .v.func = alc269_fixup_hweq,
7549                 .chained = true,
7550                 .chain_id = ALC275_FIXUP_SONY_VAIO_GPIO2
7551         },
7552         [ALC275_FIXUP_SONY_DISABLE_AAMIX] = {
7553                 .type = HDA_FIXUP_FUNC,
7554                 .v.func = alc_fixup_disable_aamix,
7555                 .chained = true,
7556                 .chain_id = ALC269_FIXUP_SONY_VAIO
7557         },
7558         [ALC271_FIXUP_DMIC] = {
7559                 .type = HDA_FIXUP_FUNC,
7560                 .v.func = alc271_fixup_dmic,
7561         },
7562         [ALC269_FIXUP_PCM_44K] = {
7563                 .type = HDA_FIXUP_FUNC,
7564                 .v.func = alc269_fixup_pcm_44k,
7565                 .chained = true,
7566                 .chain_id = ALC269_FIXUP_QUANTA_MUTE
7567         },
7568         [ALC269_FIXUP_STEREO_DMIC] = {
7569                 .type = HDA_FIXUP_FUNC,
7570                 .v.func = alc269_fixup_stereo_dmic,
7571         },
7572         [ALC269_FIXUP_HEADSET_MIC] = {
7573                 .type = HDA_FIXUP_FUNC,
7574                 .v.func = alc269_fixup_headset_mic,
7575         },
7576         [ALC269_FIXUP_QUANTA_MUTE] = {
7577                 .type = HDA_FIXUP_FUNC,
7578                 .v.func = alc269_fixup_quanta_mute,
7579         },
7580         [ALC269_FIXUP_LIFEBOOK] = {
7581                 .type = HDA_FIXUP_PINS,
7582                 .v.pins = (const struct hda_pintbl[]) {
7583                         { 0x1a, 0x2101103f }, /* dock line-out */
7584                         { 0x1b, 0x23a11040 }, /* dock mic-in */
7585                         { }
7586                 },
7587                 .chained = true,
7588                 .chain_id = ALC269_FIXUP_QUANTA_MUTE
7589         },
7590         [ALC269_FIXUP_LIFEBOOK_EXTMIC] = {
7591                 .type = HDA_FIXUP_PINS,
7592                 .v.pins = (const struct hda_pintbl[]) {
7593                         { 0x19, 0x01a1903c }, /* headset mic, with jack detect */
7594                         { }
7595                 },
7596         },
7597         [ALC269_FIXUP_LIFEBOOK_HP_PIN] = {
7598                 .type = HDA_FIXUP_PINS,
7599                 .v.pins = (const struct hda_pintbl[]) {
7600                         { 0x21, 0x0221102f }, /* HP out */
7601                         { }
7602                 },
7603         },
7604         [ALC269_FIXUP_LIFEBOOK_NO_HP_TO_LINEOUT] = {
7605                 .type = HDA_FIXUP_FUNC,
7606                 .v.func = alc269_fixup_pincfg_no_hp_to_lineout,
7607         },
7608         [ALC255_FIXUP_LIFEBOOK_U7x7_HEADSET_MIC] = {
7609                 .type = HDA_FIXUP_FUNC,
7610                 .v.func = alc269_fixup_pincfg_U7x7_headset_mic,
7611         },
7612         [ALC269VB_FIXUP_CHUWI_COREBOOK_XPRO] = {
7613                 .type = HDA_FIXUP_PINS,
7614                 .v.pins = (const struct hda_pintbl[]) {
7615                         { 0x18, 0x03a19020 }, /* headset mic */
7616                         { 0x1b, 0x90170150 }, /* speaker */
7617                         { }
7618                 },
7619         },
7620         [ALC269_FIXUP_AMIC] = {
7621                 .type = HDA_FIXUP_PINS,
7622                 .v.pins = (const struct hda_pintbl[]) {
7623                         { 0x14, 0x99130110 }, /* speaker */
7624                         { 0x15, 0x0121401f }, /* HP out */
7625                         { 0x18, 0x01a19c20 }, /* mic */
7626                         { 0x19, 0x99a3092f }, /* int-mic */
7627                         { }
7628                 },
7629         },
7630         [ALC269_FIXUP_DMIC] = {
7631                 .type = HDA_FIXUP_PINS,
7632                 .v.pins = (const struct hda_pintbl[]) {
7633                         { 0x12, 0x99a3092f }, /* int-mic */
7634                         { 0x14, 0x99130110 }, /* speaker */
7635                         { 0x15, 0x0121401f }, /* HP out */
7636                         { 0x18, 0x01a19c20 }, /* mic */
7637                         { }
7638                 },
7639         },
7640         [ALC269VB_FIXUP_AMIC] = {
7641                 .type = HDA_FIXUP_PINS,
7642                 .v.pins = (const struct hda_pintbl[]) {
7643                         { 0x14, 0x99130110 }, /* speaker */
7644                         { 0x18, 0x01a19c20 }, /* mic */
7645                         { 0x19, 0x99a3092f }, /* int-mic */
7646                         { 0x21, 0x0121401f }, /* HP out */
7647                         { }
7648                 },
7649         },
7650         [ALC269VB_FIXUP_DMIC] = {
7651                 .type = HDA_FIXUP_PINS,
7652                 .v.pins = (const struct hda_pintbl[]) {
7653                         { 0x12, 0x99a3092f }, /* int-mic */
7654                         { 0x14, 0x99130110 }, /* speaker */
7655                         { 0x18, 0x01a19c20 }, /* mic */
7656                         { 0x21, 0x0121401f }, /* HP out */
7657                         { }
7658                 },
7659         },
7660         [ALC269_FIXUP_HP_MUTE_LED] = {
7661                 .type = HDA_FIXUP_FUNC,
7662                 .v.func = alc269_fixup_hp_mute_led,
7663         },
7664         [ALC269_FIXUP_HP_MUTE_LED_MIC1] = {
7665                 .type = HDA_FIXUP_FUNC,
7666                 .v.func = alc269_fixup_hp_mute_led_mic1,
7667         },
7668         [ALC269_FIXUP_HP_MUTE_LED_MIC2] = {
7669                 .type = HDA_FIXUP_FUNC,
7670                 .v.func = alc269_fixup_hp_mute_led_mic2,
7671         },
7672         [ALC269_FIXUP_HP_MUTE_LED_MIC3] = {
7673                 .type = HDA_FIXUP_FUNC,
7674                 .v.func = alc269_fixup_hp_mute_led_mic3,
7675                 .chained = true,
7676                 .chain_id = ALC295_FIXUP_HP_AUTO_MUTE
7677         },
7678         [ALC269_FIXUP_HP_GPIO_LED] = {
7679                 .type = HDA_FIXUP_FUNC,
7680                 .v.func = alc269_fixup_hp_gpio_led,
7681         },
7682         [ALC269_FIXUP_HP_GPIO_MIC1_LED] = {
7683                 .type = HDA_FIXUP_FUNC,
7684                 .v.func = alc269_fixup_hp_gpio_mic1_led,
7685         },
7686         [ALC269_FIXUP_HP_LINE1_MIC1_LED] = {
7687                 .type = HDA_FIXUP_FUNC,
7688                 .v.func = alc269_fixup_hp_line1_mic1_led,
7689         },
7690         [ALC269_FIXUP_INV_DMIC] = {
7691                 .type = HDA_FIXUP_FUNC,
7692                 .v.func = alc_fixup_inv_dmic,
7693         },
7694         [ALC269_FIXUP_NO_SHUTUP] = {
7695                 .type = HDA_FIXUP_FUNC,
7696                 .v.func = alc_fixup_no_shutup,
7697         },
7698         [ALC269_FIXUP_LENOVO_DOCK] = {
7699                 .type = HDA_FIXUP_PINS,
7700                 .v.pins = (const struct hda_pintbl[]) {
7701                         { 0x19, 0x23a11040 }, /* dock mic */
7702                         { 0x1b, 0x2121103f }, /* dock headphone */
7703                         { }
7704                 },
7705                 .chained = true,
7706                 .chain_id = ALC269_FIXUP_PINCFG_NO_HP_TO_LINEOUT
7707         },
7708         [ALC269_FIXUP_LENOVO_DOCK_LIMIT_BOOST] = {
7709                 .type = HDA_FIXUP_FUNC,
7710                 .v.func = alc269_fixup_limit_int_mic_boost,
7711                 .chained = true,
7712                 .chain_id = ALC269_FIXUP_LENOVO_DOCK,
7713         },
7714         [ALC269_FIXUP_PINCFG_NO_HP_TO_LINEOUT] = {
7715                 .type = HDA_FIXUP_FUNC,
7716                 .v.func = alc269_fixup_pincfg_no_hp_to_lineout,
7717                 .chained = true,
7718                 .chain_id = ALC269_FIXUP_THINKPAD_ACPI,
7719         },
7720         [ALC269_FIXUP_DELL1_MIC_NO_PRESENCE] = {
7721                 .type = HDA_FIXUP_PINS,
7722                 .v.pins = (const struct hda_pintbl[]) {
7723                         { 0x19, 0x01a1913c }, /* use as headset mic, without its own jack detect */
7724                         { 0x1a, 0x01a1913d }, /* use as headphone mic, without its own jack detect */
7725                         { }
7726                 },
7727                 .chained = true,
7728                 .chain_id = ALC269_FIXUP_HEADSET_MODE
7729         },
7730         [ALC269_FIXUP_DELL2_MIC_NO_PRESENCE] = {
7731                 .type = HDA_FIXUP_PINS,
7732                 .v.pins = (const struct hda_pintbl[]) {
7733                         { 0x16, 0x21014020 }, /* dock line out */
7734                         { 0x19, 0x21a19030 }, /* dock mic */
7735                         { 0x1a, 0x01a1913c }, /* use as headset mic, without its own jack detect */
7736                         { }
7737                 },
7738                 .chained = true,
7739                 .chain_id = ALC269_FIXUP_HEADSET_MODE_NO_HP_MIC
7740         },
7741         [ALC269_FIXUP_DELL3_MIC_NO_PRESENCE] = {
7742                 .type = HDA_FIXUP_PINS,
7743                 .v.pins = (const struct hda_pintbl[]) {
7744                         { 0x1a, 0x01a1913c }, /* use as headset mic, without its own jack detect */
7745                         { }
7746                 },
7747                 .chained = true,
7748                 .chain_id = ALC269_FIXUP_HEADSET_MODE_NO_HP_MIC
7749         },
7750         [ALC269_FIXUP_DELL4_MIC_NO_PRESENCE] = {
7751                 .type = HDA_FIXUP_PINS,
7752                 .v.pins = (const struct hda_pintbl[]) {
7753                         { 0x19, 0x01a1913c }, /* use as headset mic, without its own jack detect */
7754                         { 0x1b, 0x01a1913d }, /* use as headphone mic, without its own jack detect */
7755                         { }
7756                 },
7757                 .chained = true,
7758                 .chain_id = ALC269_FIXUP_HEADSET_MODE
7759         },
7760         [ALC269_FIXUP_HEADSET_MODE] = {
7761                 .type = HDA_FIXUP_FUNC,
7762                 .v.func = alc_fixup_headset_mode,
7763                 .chained = true,
7764                 .chain_id = ALC255_FIXUP_MIC_MUTE_LED
7765         },
7766         [ALC269_FIXUP_HEADSET_MODE_NO_HP_MIC] = {
7767                 .type = HDA_FIXUP_FUNC,
7768                 .v.func = alc_fixup_headset_mode_no_hp_mic,
7769         },
7770         [ALC269_FIXUP_ASPIRE_HEADSET_MIC] = {
7771                 .type = HDA_FIXUP_PINS,
7772                 .v.pins = (const struct hda_pintbl[]) {
7773                         { 0x19, 0x01a1913c }, /* headset mic w/o jack detect */
7774                         { }
7775                 },
7776                 .chained = true,
7777                 .chain_id = ALC269_FIXUP_HEADSET_MODE,
7778         },
7779         [ALC286_FIXUP_SONY_MIC_NO_PRESENCE] = {
7780                 .type = HDA_FIXUP_PINS,
7781                 .v.pins = (const struct hda_pintbl[]) {
7782                         { 0x18, 0x01a1913c }, /* use as headset mic, without its own jack detect */
7783                         { }
7784                 },
7785                 .chained = true,
7786                 .chain_id = ALC269_FIXUP_HEADSET_MIC
7787         },
7788         [ALC256_FIXUP_HUAWEI_MACH_WX9_PINS] = {
7789                 .type = HDA_FIXUP_PINS,
7790                 .v.pins = (const struct hda_pintbl[]) {
7791                         {0x12, 0x90a60130},
7792                         {0x13, 0x40000000},
7793                         {0x14, 0x90170110},
7794                         {0x18, 0x411111f0},
7795                         {0x19, 0x04a11040},
7796                         {0x1a, 0x411111f0},
7797                         {0x1b, 0x90170112},
7798                         {0x1d, 0x40759a05},
7799                         {0x1e, 0x411111f0},
7800                         {0x21, 0x04211020},
7801                         { }
7802                 },
7803                 .chained = true,
7804                 .chain_id = ALC255_FIXUP_MIC_MUTE_LED
7805         },
7806         [ALC298_FIXUP_HUAWEI_MBX_STEREO] = {
7807                 .type = HDA_FIXUP_FUNC,
7808                 .v.func = alc298_fixup_huawei_mbx_stereo,
7809                 .chained = true,
7810                 .chain_id = ALC255_FIXUP_MIC_MUTE_LED
7811         },
7812         [ALC269_FIXUP_ASUS_X101_FUNC] = {
7813                 .type = HDA_FIXUP_FUNC,
7814                 .v.func = alc269_fixup_x101_headset_mic,
7815         },
7816         [ALC269_FIXUP_ASUS_X101_VERB] = {
7817                 .type = HDA_FIXUP_VERBS,
7818                 .v.verbs = (const struct hda_verb[]) {
7819                         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
7820                         {0x20, AC_VERB_SET_COEF_INDEX, 0x08},
7821                         {0x20, AC_VERB_SET_PROC_COEF,  0x0310},
7822                         { }
7823                 },
7824                 .chained = true,
7825                 .chain_id = ALC269_FIXUP_ASUS_X101_FUNC
7826         },
7827         [ALC269_FIXUP_ASUS_X101] = {
7828                 .type = HDA_FIXUP_PINS,
7829                 .v.pins = (const struct hda_pintbl[]) {
7830                         { 0x18, 0x04a1182c }, /* Headset mic */
7831                         { }
7832                 },
7833                 .chained = true,
7834                 .chain_id = ALC269_FIXUP_ASUS_X101_VERB
7835         },
7836         [ALC271_FIXUP_AMIC_MIC2] = {
7837                 .type = HDA_FIXUP_PINS,
7838                 .v.pins = (const struct hda_pintbl[]) {
7839                         { 0x14, 0x99130110 }, /* speaker */
7840                         { 0x19, 0x01a19c20 }, /* mic */
7841                         { 0x1b, 0x99a7012f }, /* int-mic */
7842                         { 0x21, 0x0121401f }, /* HP out */
7843                         { }
7844                 },
7845         },
7846         [ALC271_FIXUP_HP_GATE_MIC_JACK] = {
7847                 .type = HDA_FIXUP_FUNC,
7848                 .v.func = alc271_hp_gate_mic_jack,
7849                 .chained = true,
7850                 .chain_id = ALC271_FIXUP_AMIC_MIC2,
7851         },
7852         [ALC271_FIXUP_HP_GATE_MIC_JACK_E1_572] = {
7853                 .type = HDA_FIXUP_FUNC,
7854                 .v.func = alc269_fixup_limit_int_mic_boost,
7855                 .chained = true,
7856                 .chain_id = ALC271_FIXUP_HP_GATE_MIC_JACK,
7857         },
7858         [ALC269_FIXUP_ACER_AC700] = {
7859                 .type = HDA_FIXUP_PINS,
7860                 .v.pins = (const struct hda_pintbl[]) {
7861                         { 0x12, 0x99a3092f }, /* int-mic */
7862                         { 0x14, 0x99130110 }, /* speaker */
7863                         { 0x18, 0x03a11c20 }, /* mic */
7864                         { 0x1e, 0x0346101e }, /* SPDIF1 */
7865                         { 0x21, 0x0321101f }, /* HP out */
7866                         { }
7867                 },
7868                 .chained = true,
7869                 .chain_id = ALC271_FIXUP_DMIC,
7870         },
7871         [ALC269_FIXUP_LIMIT_INT_MIC_BOOST] = {
7872                 .type = HDA_FIXUP_FUNC,
7873                 .v.func = alc269_fixup_limit_int_mic_boost,
7874                 .chained = true,
7875                 .chain_id = ALC269_FIXUP_THINKPAD_ACPI,
7876         },
7877         [ALC269VB_FIXUP_ASUS_ZENBOOK] = {
7878                 .type = HDA_FIXUP_FUNC,
7879                 .v.func = alc269_fixup_limit_int_mic_boost,
7880                 .chained = true,
7881                 .chain_id = ALC269VB_FIXUP_DMIC,
7882         },
7883         [ALC269VB_FIXUP_ASUS_ZENBOOK_UX31A] = {
7884                 .type = HDA_FIXUP_VERBS,
7885                 .v.verbs = (const struct hda_verb[]) {
7886                         /* class-D output amp +5dB */
7887                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x12 },
7888                         { 0x20, AC_VERB_SET_PROC_COEF, 0x2800 },
7889                         {}
7890                 },
7891                 .chained = true,
7892                 .chain_id = ALC269VB_FIXUP_ASUS_ZENBOOK,
7893         },
7894         [ALC269VB_FIXUP_ASUS_MIC_NO_PRESENCE] = {
7895                 .type = HDA_FIXUP_PINS,
7896                 .v.pins = (const struct hda_pintbl[]) {
7897                         { 0x18, 0x01a110f0 },  /* use as headset mic */
7898                         { }
7899                 },
7900                 .chained = true,
7901                 .chain_id = ALC269_FIXUP_HEADSET_MIC
7902         },
7903         [ALC269_FIXUP_LIMIT_INT_MIC_BOOST_MUTE_LED] = {
7904                 .type = HDA_FIXUP_FUNC,
7905                 .v.func = alc269_fixup_limit_int_mic_boost,
7906                 .chained = true,
7907                 .chain_id = ALC269_FIXUP_HP_MUTE_LED_MIC1,
7908         },
7909         [ALC269VB_FIXUP_ORDISSIMO_EVE2] = {
7910                 .type = HDA_FIXUP_PINS,
7911                 .v.pins = (const struct hda_pintbl[]) {
7912                         { 0x12, 0x99a3092f }, /* int-mic */
7913                         { 0x18, 0x03a11d20 }, /* mic */
7914                         { 0x19, 0x411111f0 }, /* Unused bogus pin */
7915                         { }
7916                 },
7917         },
7918         [ALC283_FIXUP_CHROME_BOOK] = {
7919                 .type = HDA_FIXUP_FUNC,
7920                 .v.func = alc283_fixup_chromebook,
7921         },
7922         [ALC283_FIXUP_SENSE_COMBO_JACK] = {
7923                 .type = HDA_FIXUP_FUNC,
7924                 .v.func = alc283_fixup_sense_combo_jack,
7925                 .chained = true,
7926                 .chain_id = ALC283_FIXUP_CHROME_BOOK,
7927         },
7928         [ALC282_FIXUP_ASUS_TX300] = {
7929                 .type = HDA_FIXUP_FUNC,
7930                 .v.func = alc282_fixup_asus_tx300,
7931         },
7932         [ALC283_FIXUP_INT_MIC] = {
7933                 .type = HDA_FIXUP_VERBS,
7934                 .v.verbs = (const struct hda_verb[]) {
7935                         {0x20, AC_VERB_SET_COEF_INDEX, 0x1a},
7936                         {0x20, AC_VERB_SET_PROC_COEF, 0x0011},
7937                         { }
7938                 },
7939                 .chained = true,
7940                 .chain_id = ALC269_FIXUP_LIMIT_INT_MIC_BOOST
7941         },
7942         [ALC290_FIXUP_SUBWOOFER_HSJACK] = {
7943                 .type = HDA_FIXUP_PINS,
7944                 .v.pins = (const struct hda_pintbl[]) {
7945                         { 0x17, 0x90170112 }, /* subwoofer */
7946                         { }
7947                 },
7948                 .chained = true,
7949                 .chain_id = ALC290_FIXUP_MONO_SPEAKERS_HSJACK,
7950         },
7951         [ALC290_FIXUP_SUBWOOFER] = {
7952                 .type = HDA_FIXUP_PINS,
7953                 .v.pins = (const struct hda_pintbl[]) {
7954                         { 0x17, 0x90170112 }, /* subwoofer */
7955                         { }
7956                 },
7957                 .chained = true,
7958                 .chain_id = ALC290_FIXUP_MONO_SPEAKERS,
7959         },
7960         [ALC290_FIXUP_MONO_SPEAKERS] = {
7961                 .type = HDA_FIXUP_FUNC,
7962                 .v.func = alc290_fixup_mono_speakers,
7963         },
7964         [ALC290_FIXUP_MONO_SPEAKERS_HSJACK] = {
7965                 .type = HDA_FIXUP_FUNC,
7966                 .v.func = alc290_fixup_mono_speakers,
7967                 .chained = true,
7968                 .chain_id = ALC269_FIXUP_DELL3_MIC_NO_PRESENCE,
7969         },
7970         [ALC269_FIXUP_THINKPAD_ACPI] = {
7971                 .type = HDA_FIXUP_FUNC,
7972                 .v.func = alc_fixup_thinkpad_acpi,
7973                 .chained = true,
7974                 .chain_id = ALC269_FIXUP_SKU_IGNORE,
7975         },
7976         [ALC269_FIXUP_DMIC_THINKPAD_ACPI] = {
7977                 .type = HDA_FIXUP_FUNC,
7978                 .v.func = alc_fixup_inv_dmic,
7979                 .chained = true,
7980                 .chain_id = ALC269_FIXUP_THINKPAD_ACPI,
7981         },
7982         [ALC255_FIXUP_ACER_MIC_NO_PRESENCE] = {
7983                 .type = HDA_FIXUP_PINS,
7984                 .v.pins = (const struct hda_pintbl[]) {
7985                         { 0x19, 0x01a1913c }, /* use as headset mic, without its own jack detect */
7986                         { }
7987                 },
7988                 .chained = true,
7989                 .chain_id = ALC255_FIXUP_HEADSET_MODE
7990         },
7991         [ALC255_FIXUP_ASUS_MIC_NO_PRESENCE] = {
7992                 .type = HDA_FIXUP_PINS,
7993                 .v.pins = (const struct hda_pintbl[]) {
7994                         { 0x19, 0x01a1913c }, /* use as headset mic, without its own jack detect */
7995                         { }
7996                 },
7997                 .chained = true,
7998                 .chain_id = ALC255_FIXUP_HEADSET_MODE
7999         },
8000         [ALC255_FIXUP_DELL1_MIC_NO_PRESENCE] = {
8001                 .type = HDA_FIXUP_PINS,
8002                 .v.pins = (const struct hda_pintbl[]) {
8003                         { 0x19, 0x01a1913c }, /* use as headset mic, without its own jack detect */
8004                         { 0x1a, 0x01a1913d }, /* use as headphone mic, without its own jack detect */
8005                         { }
8006                 },
8007                 .chained = true,
8008                 .chain_id = ALC255_FIXUP_HEADSET_MODE
8009         },
8010         [ALC255_FIXUP_DELL2_MIC_NO_PRESENCE] = {
8011                 .type = HDA_FIXUP_PINS,
8012                 .v.pins = (const struct hda_pintbl[]) {
8013                         { 0x19, 0x01a1913c }, /* use as headset mic, without its own jack detect */
8014                         { }
8015                 },
8016                 .chained = true,
8017                 .chain_id = ALC255_FIXUP_HEADSET_MODE_NO_HP_MIC
8018         },
8019         [ALC255_FIXUP_HEADSET_MODE] = {
8020                 .type = HDA_FIXUP_FUNC,
8021                 .v.func = alc_fixup_headset_mode_alc255,
8022                 .chained = true,
8023                 .chain_id = ALC255_FIXUP_MIC_MUTE_LED
8024         },
8025         [ALC255_FIXUP_HEADSET_MODE_NO_HP_MIC] = {
8026                 .type = HDA_FIXUP_FUNC,
8027                 .v.func = alc_fixup_headset_mode_alc255_no_hp_mic,
8028         },
8029         [ALC293_FIXUP_DELL1_MIC_NO_PRESENCE] = {
8030                 .type = HDA_FIXUP_PINS,
8031                 .v.pins = (const struct hda_pintbl[]) {
8032                         { 0x18, 0x01a1913d }, /* use as headphone mic, without its own jack detect */
8033                         { 0x1a, 0x01a1913c }, /* use as headset mic, without its own jack detect */
8034                         { }
8035                 },
8036                 .chained = true,
8037                 .chain_id = ALC269_FIXUP_HEADSET_MODE
8038         },
8039         [ALC292_FIXUP_TPT440_DOCK] = {
8040                 .type = HDA_FIXUP_FUNC,
8041                 .v.func = alc_fixup_tpt440_dock,
8042                 .chained = true,
8043                 .chain_id = ALC269_FIXUP_LIMIT_INT_MIC_BOOST
8044         },
8045         [ALC292_FIXUP_TPT440] = {
8046                 .type = HDA_FIXUP_FUNC,
8047                 .v.func = alc_fixup_disable_aamix,
8048                 .chained = true,
8049                 .chain_id = ALC292_FIXUP_TPT440_DOCK,
8050         },
8051         [ALC283_FIXUP_HEADSET_MIC] = {
8052                 .type = HDA_FIXUP_PINS,
8053                 .v.pins = (const struct hda_pintbl[]) {
8054                         { 0x19, 0x04a110f0 },
8055                         { },
8056                 },
8057         },
8058         [ALC255_FIXUP_MIC_MUTE_LED] = {
8059                 .type = HDA_FIXUP_FUNC,
8060                 .v.func = alc_fixup_micmute_led,
8061         },
8062         [ALC282_FIXUP_ASPIRE_V5_PINS] = {
8063                 .type = HDA_FIXUP_PINS,
8064                 .v.pins = (const struct hda_pintbl[]) {
8065                         { 0x12, 0x90a60130 },
8066                         { 0x14, 0x90170110 },
8067                         { 0x17, 0x40000008 },
8068                         { 0x18, 0x411111f0 },
8069                         { 0x19, 0x01a1913c },
8070                         { 0x1a, 0x411111f0 },
8071                         { 0x1b, 0x411111f0 },
8072                         { 0x1d, 0x40f89b2d },
8073                         { 0x1e, 0x411111f0 },
8074                         { 0x21, 0x0321101f },
8075                         { },
8076                 },
8077         },
8078         [ALC269VB_FIXUP_ASPIRE_E1_COEF] = {
8079                 .type = HDA_FIXUP_FUNC,
8080                 .v.func = alc269vb_fixup_aspire_e1_coef,
8081         },
8082         [ALC280_FIXUP_HP_GPIO4] = {
8083                 .type = HDA_FIXUP_FUNC,
8084                 .v.func = alc280_fixup_hp_gpio4,
8085         },
8086         [ALC286_FIXUP_HP_GPIO_LED] = {
8087                 .type = HDA_FIXUP_FUNC,
8088                 .v.func = alc286_fixup_hp_gpio_led,
8089         },
8090         [ALC280_FIXUP_HP_GPIO2_MIC_HOTKEY] = {
8091                 .type = HDA_FIXUP_FUNC,
8092                 .v.func = alc280_fixup_hp_gpio2_mic_hotkey,
8093         },
8094         [ALC280_FIXUP_HP_DOCK_PINS] = {
8095                 .type = HDA_FIXUP_PINS,
8096                 .v.pins = (const struct hda_pintbl[]) {
8097                         { 0x1b, 0x21011020 }, /* line-out */
8098                         { 0x1a, 0x01a1903c }, /* headset mic */
8099                         { 0x18, 0x2181103f }, /* line-in */
8100                         { },
8101                 },
8102                 .chained = true,
8103                 .chain_id = ALC280_FIXUP_HP_GPIO4
8104         },
8105         [ALC269_FIXUP_HP_DOCK_GPIO_MIC1_LED] = {
8106                 .type = HDA_FIXUP_PINS,
8107                 .v.pins = (const struct hda_pintbl[]) {
8108                         { 0x1b, 0x21011020 }, /* line-out */
8109                         { 0x18, 0x2181103f }, /* line-in */
8110                         { },
8111                 },
8112                 .chained = true,
8113                 .chain_id = ALC269_FIXUP_HP_GPIO_MIC1_LED
8114         },
8115         [ALC280_FIXUP_HP_9480M] = {
8116                 .type = HDA_FIXUP_FUNC,
8117                 .v.func = alc280_fixup_hp_9480m,
8118         },
8119         [ALC245_FIXUP_HP_X360_AMP] = {
8120                 .type = HDA_FIXUP_FUNC,
8121                 .v.func = alc245_fixup_hp_x360_amp,
8122                 .chained = true,
8123                 .chain_id = ALC245_FIXUP_HP_GPIO_LED
8124         },
8125         [ALC288_FIXUP_DELL_HEADSET_MODE] = {
8126                 .type = HDA_FIXUP_FUNC,
8127                 .v.func = alc_fixup_headset_mode_dell_alc288,
8128                 .chained = true,
8129                 .chain_id = ALC255_FIXUP_MIC_MUTE_LED
8130         },
8131         [ALC288_FIXUP_DELL1_MIC_NO_PRESENCE] = {
8132                 .type = HDA_FIXUP_PINS,
8133                 .v.pins = (const struct hda_pintbl[]) {
8134                         { 0x18, 0x01a1913c }, /* use as headset mic, without its own jack detect */
8135                         { 0x1a, 0x01a1913d }, /* use as headphone mic, without its own jack detect */
8136                         { }
8137                 },
8138                 .chained = true,
8139                 .chain_id = ALC288_FIXUP_DELL_HEADSET_MODE
8140         },
8141         [ALC288_FIXUP_DISABLE_AAMIX] = {
8142                 .type = HDA_FIXUP_FUNC,
8143                 .v.func = alc_fixup_disable_aamix,
8144                 .chained = true,
8145                 .chain_id = ALC288_FIXUP_DELL1_MIC_NO_PRESENCE
8146         },
8147         [ALC288_FIXUP_DELL_XPS_13] = {
8148                 .type = HDA_FIXUP_FUNC,
8149                 .v.func = alc_fixup_dell_xps13,
8150                 .chained = true,
8151                 .chain_id = ALC288_FIXUP_DISABLE_AAMIX
8152         },
8153         [ALC292_FIXUP_DISABLE_AAMIX] = {
8154                 .type = HDA_FIXUP_FUNC,
8155                 .v.func = alc_fixup_disable_aamix,
8156                 .chained = true,
8157                 .chain_id = ALC269_FIXUP_DELL2_MIC_NO_PRESENCE
8158         },
8159         [ALC293_FIXUP_DISABLE_AAMIX_MULTIJACK] = {
8160                 .type = HDA_FIXUP_FUNC,
8161                 .v.func = alc_fixup_disable_aamix,
8162                 .chained = true,
8163                 .chain_id = ALC293_FIXUP_DELL1_MIC_NO_PRESENCE
8164         },
8165         [ALC292_FIXUP_DELL_E7X_AAMIX] = {
8166                 .type = HDA_FIXUP_FUNC,
8167                 .v.func = alc_fixup_dell_xps13,
8168                 .chained = true,
8169                 .chain_id = ALC292_FIXUP_DISABLE_AAMIX
8170         },
8171         [ALC292_FIXUP_DELL_E7X] = {
8172                 .type = HDA_FIXUP_FUNC,
8173                 .v.func = alc_fixup_micmute_led,
8174                 /* micmute fixup must be applied at last */
8175                 .chained_before = true,
8176                 .chain_id = ALC292_FIXUP_DELL_E7X_AAMIX,
8177         },
8178         [ALC298_FIXUP_ALIENWARE_MIC_NO_PRESENCE] = {
8179                 .type = HDA_FIXUP_PINS,
8180                 .v.pins = (const struct hda_pintbl[]) {
8181                         { 0x18, 0x01a1913c }, /* headset mic w/o jack detect */
8182                         { }
8183                 },
8184                 .chained_before = true,
8185                 .chain_id = ALC269_FIXUP_HEADSET_MODE,
8186         },
8187         [ALC298_FIXUP_DELL1_MIC_NO_PRESENCE] = {
8188                 .type = HDA_FIXUP_PINS,
8189                 .v.pins = (const struct hda_pintbl[]) {
8190                         { 0x18, 0x01a1913c }, /* use as headset mic, without its own jack detect */
8191                         { 0x1a, 0x01a1913d }, /* use as headphone mic, without its own jack detect */
8192                         { }
8193                 },
8194                 .chained = true,
8195                 .chain_id = ALC269_FIXUP_HEADSET_MODE
8196         },
8197         [ALC298_FIXUP_DELL_AIO_MIC_NO_PRESENCE] = {
8198                 .type = HDA_FIXUP_PINS,
8199                 .v.pins = (const struct hda_pintbl[]) {
8200                         { 0x18, 0x01a1913c }, /* use as headset mic, without its own jack detect */
8201                         { }
8202                 },
8203                 .chained = true,
8204                 .chain_id = ALC269_FIXUP_HEADSET_MODE
8205         },
8206         [ALC275_FIXUP_DELL_XPS] = {
8207                 .type = HDA_FIXUP_VERBS,
8208                 .v.verbs = (const struct hda_verb[]) {
8209                         /* Enables internal speaker */
8210                         {0x20, AC_VERB_SET_COEF_INDEX, 0x1f},
8211                         {0x20, AC_VERB_SET_PROC_COEF, 0x00c0},
8212                         {0x20, AC_VERB_SET_COEF_INDEX, 0x30},
8213                         {0x20, AC_VERB_SET_PROC_COEF, 0x00b1},
8214                         {}
8215                 }
8216         },
8217         [ALC293_FIXUP_LENOVO_SPK_NOISE] = {
8218                 .type = HDA_FIXUP_FUNC,
8219                 .v.func = alc_fixup_disable_aamix,
8220                 .chained = true,
8221                 .chain_id = ALC269_FIXUP_THINKPAD_ACPI
8222         },
8223         [ALC233_FIXUP_LENOVO_LINE2_MIC_HOTKEY] = {
8224                 .type = HDA_FIXUP_FUNC,
8225                 .v.func = alc233_fixup_lenovo_line2_mic_hotkey,
8226         },
8227         [ALC233_FIXUP_INTEL_NUC8_DMIC] = {
8228                 .type = HDA_FIXUP_FUNC,
8229                 .v.func = alc_fixup_inv_dmic,
8230                 .chained = true,
8231                 .chain_id = ALC233_FIXUP_INTEL_NUC8_BOOST,
8232         },
8233         [ALC233_FIXUP_INTEL_NUC8_BOOST] = {
8234                 .type = HDA_FIXUP_FUNC,
8235                 .v.func = alc269_fixup_limit_int_mic_boost
8236         },
8237         [ALC255_FIXUP_DELL_SPK_NOISE] = {
8238                 .type = HDA_FIXUP_FUNC,
8239                 .v.func = alc_fixup_disable_aamix,
8240                 .chained = true,
8241                 .chain_id = ALC255_FIXUP_DELL1_MIC_NO_PRESENCE
8242         },
8243         [ALC225_FIXUP_DISABLE_MIC_VREF] = {
8244                 .type = HDA_FIXUP_FUNC,
8245                 .v.func = alc_fixup_disable_mic_vref,
8246                 .chained = true,
8247                 .chain_id = ALC269_FIXUP_DELL1_MIC_NO_PRESENCE
8248         },
8249         [ALC225_FIXUP_DELL1_MIC_NO_PRESENCE] = {
8250                 .type = HDA_FIXUP_VERBS,
8251                 .v.verbs = (const struct hda_verb[]) {
8252                         /* Disable pass-through path for FRONT 14h */
8253                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x36 },
8254                         { 0x20, AC_VERB_SET_PROC_COEF, 0x57d7 },
8255                         {}
8256                 },
8257                 .chained = true,
8258                 .chain_id = ALC225_FIXUP_DISABLE_MIC_VREF
8259         },
8260         [ALC280_FIXUP_HP_HEADSET_MIC] = {
8261                 .type = HDA_FIXUP_FUNC,
8262                 .v.func = alc_fixup_disable_aamix,
8263                 .chained = true,
8264                 .chain_id = ALC269_FIXUP_HEADSET_MIC,
8265         },
8266         [ALC221_FIXUP_HP_FRONT_MIC] = {
8267                 .type = HDA_FIXUP_PINS,
8268                 .v.pins = (const struct hda_pintbl[]) {
8269                         { 0x19, 0x02a19020 }, /* Front Mic */
8270                         { }
8271                 },
8272         },
8273         [ALC292_FIXUP_TPT460] = {
8274                 .type = HDA_FIXUP_FUNC,
8275                 .v.func = alc_fixup_tpt440_dock,
8276                 .chained = true,
8277                 .chain_id = ALC293_FIXUP_LENOVO_SPK_NOISE,
8278         },
8279         [ALC298_FIXUP_SPK_VOLUME] = {
8280                 .type = HDA_FIXUP_FUNC,
8281                 .v.func = alc298_fixup_speaker_volume,
8282                 .chained = true,
8283                 .chain_id = ALC298_FIXUP_DELL_AIO_MIC_NO_PRESENCE,
8284         },
8285         [ALC298_FIXUP_LENOVO_SPK_VOLUME] = {
8286                 .type = HDA_FIXUP_FUNC,
8287                 .v.func = alc298_fixup_speaker_volume,
8288         },
8289         [ALC295_FIXUP_DISABLE_DAC3] = {
8290                 .type = HDA_FIXUP_FUNC,
8291                 .v.func = alc295_fixup_disable_dac3,
8292         },
8293         [ALC285_FIXUP_SPEAKER2_TO_DAC1] = {
8294                 .type = HDA_FIXUP_FUNC,
8295                 .v.func = alc285_fixup_speaker2_to_dac1,
8296                 .chained = true,
8297                 .chain_id = ALC269_FIXUP_THINKPAD_ACPI
8298         },
8299         [ALC285_FIXUP_ASUS_SPEAKER2_TO_DAC1] = {
8300                 .type = HDA_FIXUP_FUNC,
8301                 .v.func = alc285_fixup_speaker2_to_dac1,
8302                 .chained = true,
8303                 .chain_id = ALC245_FIXUP_CS35L41_SPI_2
8304         },
8305         [ALC285_FIXUP_ASUS_HEADSET_MIC] = {
8306                 .type = HDA_FIXUP_PINS,
8307                 .v.pins = (const struct hda_pintbl[]) {
8308                         { 0x19, 0x03a11050 },
8309                         { 0x1b, 0x03a11c30 },
8310                         { }
8311                 },
8312                 .chained = true,
8313                 .chain_id = ALC285_FIXUP_ASUS_SPEAKER2_TO_DAC1
8314         },
8315         [ALC285_FIXUP_ASUS_SPI_REAR_SPEAKERS] = {
8316                 .type = HDA_FIXUP_PINS,
8317                 .v.pins = (const struct hda_pintbl[]) {
8318                         { 0x14, 0x90170120 },
8319                         { }
8320                 },
8321                 .chained = true,
8322                 .chain_id = ALC285_FIXUP_ASUS_HEADSET_MIC
8323         },
8324         [ALC285_FIXUP_ASUS_I2C_SPEAKER2_TO_DAC1] = {
8325                 .type = HDA_FIXUP_FUNC,
8326                 .v.func = alc285_fixup_speaker2_to_dac1,
8327                 .chained = true,
8328                 .chain_id = ALC287_FIXUP_CS35L41_I2C_2
8329         },
8330         [ALC285_FIXUP_ASUS_I2C_HEADSET_MIC] = {
8331                 .type = HDA_FIXUP_PINS,
8332                 .v.pins = (const struct hda_pintbl[]) {
8333                         { 0x19, 0x03a11050 },
8334                         { 0x1b, 0x03a11c30 },
8335                         { }
8336                 },
8337                 .chained = true,
8338                 .chain_id = ALC285_FIXUP_ASUS_I2C_SPEAKER2_TO_DAC1
8339         },
8340         [ALC256_FIXUP_DELL_INSPIRON_7559_SUBWOOFER] = {
8341                 .type = HDA_FIXUP_PINS,
8342                 .v.pins = (const struct hda_pintbl[]) {
8343                         { 0x1b, 0x90170151 },
8344                         { }
8345                 },
8346                 .chained = true,
8347                 .chain_id = ALC255_FIXUP_DELL1_MIC_NO_PRESENCE
8348         },
8349         [ALC269_FIXUP_ATIV_BOOK_8] = {
8350                 .type = HDA_FIXUP_FUNC,
8351                 .v.func = alc_fixup_auto_mute_via_amp,
8352                 .chained = true,
8353                 .chain_id = ALC269_FIXUP_NO_SHUTUP
8354         },
8355         [ALC221_FIXUP_HP_288PRO_MIC_NO_PRESENCE] = {
8356                 .type = HDA_FIXUP_PINS,
8357                 .v.pins = (const struct hda_pintbl[]) {
8358                         { 0x19, 0x01a1913c }, /* use as headset mic, without its own jack detect */
8359                         { 0x1a, 0x01813030 }, /* use as headphone mic, without its own jack detect */
8360                         { }
8361                 },
8362                 .chained = true,
8363                 .chain_id = ALC269_FIXUP_HEADSET_MODE
8364         },
8365         [ALC221_FIXUP_HP_MIC_NO_PRESENCE] = {
8366                 .type = HDA_FIXUP_PINS,
8367                 .v.pins = (const struct hda_pintbl[]) {
8368                         { 0x18, 0x01a1913c }, /* use as headset mic, without its own jack detect */
8369                         { 0x1a, 0x01a1913d }, /* use as headphone mic, without its own jack detect */
8370                         { }
8371                 },
8372                 .chained = true,
8373                 .chain_id = ALC269_FIXUP_HEADSET_MODE
8374         },
8375         [ALC256_FIXUP_ASUS_HEADSET_MODE] = {
8376                 .type = HDA_FIXUP_FUNC,
8377                 .v.func = alc_fixup_headset_mode,
8378         },
8379         [ALC256_FIXUP_ASUS_MIC] = {
8380                 .type = HDA_FIXUP_PINS,
8381                 .v.pins = (const struct hda_pintbl[]) {
8382                         { 0x13, 0x90a60160 }, /* use as internal mic */
8383                         { 0x19, 0x04a11120 }, /* use as headset mic, without its own jack detect */
8384                         { }
8385                 },
8386                 .chained = true,
8387                 .chain_id = ALC256_FIXUP_ASUS_HEADSET_MODE
8388         },
8389         [ALC256_FIXUP_ASUS_AIO_GPIO2] = {
8390                 .type = HDA_FIXUP_FUNC,
8391                 /* Set up GPIO2 for the speaker amp */
8392                 .v.func = alc_fixup_gpio4,
8393         },
8394         [ALC233_FIXUP_ASUS_MIC_NO_PRESENCE] = {
8395                 .type = HDA_FIXUP_PINS,
8396                 .v.pins = (const struct hda_pintbl[]) {
8397                         { 0x19, 0x01a1913c }, /* use as headset mic, without its own jack detect */
8398                         { }
8399                 },
8400                 .chained = true,
8401                 .chain_id = ALC269_FIXUP_HEADSET_MIC
8402         },
8403         [ALC233_FIXUP_EAPD_COEF_AND_MIC_NO_PRESENCE] = {
8404                 .type = HDA_FIXUP_VERBS,
8405                 .v.verbs = (const struct hda_verb[]) {
8406                         /* Enables internal speaker */
8407                         {0x20, AC_VERB_SET_COEF_INDEX, 0x40},
8408                         {0x20, AC_VERB_SET_PROC_COEF, 0x8800},
8409                         {}
8410                 },
8411                 .chained = true,
8412                 .chain_id = ALC233_FIXUP_ASUS_MIC_NO_PRESENCE
8413         },
8414         [ALC233_FIXUP_LENOVO_MULTI_CODECS] = {
8415                 .type = HDA_FIXUP_FUNC,
8416                 .v.func = alc233_alc662_fixup_lenovo_dual_codecs,
8417                 .chained = true,
8418                 .chain_id = ALC269_FIXUP_GPIO2
8419         },
8420         [ALC233_FIXUP_ACER_HEADSET_MIC] = {
8421                 .type = HDA_FIXUP_VERBS,
8422                 .v.verbs = (const struct hda_verb[]) {
8423                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x45 },
8424                         { 0x20, AC_VERB_SET_PROC_COEF, 0x5089 },
8425                         { }
8426                 },
8427                 .chained = true,
8428                 .chain_id = ALC233_FIXUP_ASUS_MIC_NO_PRESENCE
8429         },
8430         [ALC294_FIXUP_LENOVO_MIC_LOCATION] = {
8431                 .type = HDA_FIXUP_PINS,
8432                 .v.pins = (const struct hda_pintbl[]) {
8433                         /* Change the mic location from front to right, otherwise there are
8434                            two front mics with the same name, pulseaudio can't handle them.
8435                            This is just a temporary workaround, after applying this fixup,
8436                            there will be one "Front Mic" and one "Mic" in this machine.
8437                          */
8438                         { 0x1a, 0x04a19040 },
8439                         { }
8440                 },
8441         },
8442         [ALC225_FIXUP_DELL_WYSE_MIC_NO_PRESENCE] = {
8443                 .type = HDA_FIXUP_PINS,
8444                 .v.pins = (const struct hda_pintbl[]) {
8445                         { 0x16, 0x0101102f }, /* Rear Headset HP */
8446                         { 0x19, 0x02a1913c }, /* use as Front headset mic, without its own jack detect */
8447                         { 0x1a, 0x01a19030 }, /* Rear Headset MIC */
8448                         { 0x1b, 0x02011020 },
8449                         { }
8450                 },
8451                 .chained = true,
8452                 .chain_id = ALC225_FIXUP_S3_POP_NOISE
8453         },
8454         [ALC225_FIXUP_S3_POP_NOISE] = {
8455                 .type = HDA_FIXUP_FUNC,
8456                 .v.func = alc225_fixup_s3_pop_noise,
8457                 .chained = true,
8458                 .chain_id = ALC269_FIXUP_HEADSET_MODE_NO_HP_MIC
8459         },
8460         [ALC700_FIXUP_INTEL_REFERENCE] = {
8461                 .type = HDA_FIXUP_VERBS,
8462                 .v.verbs = (const struct hda_verb[]) {
8463                         /* Enables internal speaker */
8464                         {0x20, AC_VERB_SET_COEF_INDEX, 0x45},
8465                         {0x20, AC_VERB_SET_PROC_COEF, 0x5289},
8466                         {0x20, AC_VERB_SET_COEF_INDEX, 0x4A},
8467                         {0x20, AC_VERB_SET_PROC_COEF, 0x001b},
8468                         {0x58, AC_VERB_SET_COEF_INDEX, 0x00},
8469                         {0x58, AC_VERB_SET_PROC_COEF, 0x3888},
8470                         {0x20, AC_VERB_SET_COEF_INDEX, 0x6f},
8471                         {0x20, AC_VERB_SET_PROC_COEF, 0x2c0b},
8472                         {}
8473                 }
8474         },
8475         [ALC274_FIXUP_DELL_BIND_DACS] = {
8476                 .type = HDA_FIXUP_FUNC,
8477                 .v.func = alc274_fixup_bind_dacs,
8478                 .chained = true,
8479                 .chain_id = ALC269_FIXUP_DELL1_MIC_NO_PRESENCE
8480         },
8481         [ALC274_FIXUP_DELL_AIO_LINEOUT_VERB] = {
8482                 .type = HDA_FIXUP_PINS,
8483                 .v.pins = (const struct hda_pintbl[]) {
8484                         { 0x1b, 0x0401102f },
8485                         { }
8486                 },
8487                 .chained = true,
8488                 .chain_id = ALC274_FIXUP_DELL_BIND_DACS
8489         },
8490         [ALC298_FIXUP_TPT470_DOCK_FIX] = {
8491                 .type = HDA_FIXUP_FUNC,
8492                 .v.func = alc_fixup_tpt470_dock,
8493                 .chained = true,
8494                 .chain_id = ALC293_FIXUP_LENOVO_SPK_NOISE
8495         },
8496         [ALC298_FIXUP_TPT470_DOCK] = {
8497                 .type = HDA_FIXUP_FUNC,
8498                 .v.func = alc_fixup_tpt470_dacs,
8499                 .chained = true,
8500                 .chain_id = ALC298_FIXUP_TPT470_DOCK_FIX
8501         },
8502         [ALC255_FIXUP_DUMMY_LINEOUT_VERB] = {
8503                 .type = HDA_FIXUP_PINS,
8504                 .v.pins = (const struct hda_pintbl[]) {
8505                         { 0x14, 0x0201101f },
8506                         { }
8507                 },
8508                 .chained = true,
8509                 .chain_id = ALC255_FIXUP_DELL1_MIC_NO_PRESENCE
8510         },
8511         [ALC255_FIXUP_DELL_HEADSET_MIC] = {
8512                 .type = HDA_FIXUP_PINS,
8513                 .v.pins = (const struct hda_pintbl[]) {
8514                         { 0x19, 0x01a1913c }, /* use as headset mic, without its own jack detect */
8515                         { }
8516                 },
8517                 .chained = true,
8518                 .chain_id = ALC269_FIXUP_HEADSET_MIC
8519         },
8520         [ALC295_FIXUP_HP_X360] = {
8521                 .type = HDA_FIXUP_FUNC,
8522                 .v.func = alc295_fixup_hp_top_speakers,
8523                 .chained = true,
8524                 .chain_id = ALC269_FIXUP_HP_MUTE_LED_MIC3
8525         },
8526         [ALC221_FIXUP_HP_HEADSET_MIC] = {
8527                 .type = HDA_FIXUP_PINS,
8528                 .v.pins = (const struct hda_pintbl[]) {
8529                         { 0x19, 0x0181313f},
8530                         { }
8531                 },
8532                 .chained = true,
8533                 .chain_id = ALC269_FIXUP_HEADSET_MIC
8534         },
8535         [ALC285_FIXUP_LENOVO_HEADPHONE_NOISE] = {
8536                 .type = HDA_FIXUP_FUNC,
8537                 .v.func = alc285_fixup_invalidate_dacs,
8538                 .chained = true,
8539                 .chain_id = ALC269_FIXUP_THINKPAD_ACPI
8540         },
8541         [ALC295_FIXUP_HP_AUTO_MUTE] = {
8542                 .type = HDA_FIXUP_FUNC,
8543                 .v.func = alc_fixup_auto_mute_via_amp,
8544         },
8545         [ALC286_FIXUP_ACER_AIO_MIC_NO_PRESENCE] = {
8546                 .type = HDA_FIXUP_PINS,
8547                 .v.pins = (const struct hda_pintbl[]) {
8548                         { 0x18, 0x01a1913c }, /* use as headset mic, without its own jack detect */
8549                         { }
8550                 },
8551                 .chained = true,
8552                 .chain_id = ALC269_FIXUP_HEADSET_MIC
8553         },
8554         [ALC294_FIXUP_ASUS_MIC] = {
8555                 .type = HDA_FIXUP_PINS,
8556                 .v.pins = (const struct hda_pintbl[]) {
8557                         { 0x13, 0x90a60160 }, /* use as internal mic */
8558                         { 0x19, 0x04a11120 }, /* use as headset mic, without its own jack detect */
8559                         { }
8560                 },
8561                 .chained = true,
8562                 .chain_id = ALC269_FIXUP_HEADSET_MIC
8563         },
8564         [ALC294_FIXUP_ASUS_HEADSET_MIC] = {
8565                 .type = HDA_FIXUP_PINS,
8566                 .v.pins = (const struct hda_pintbl[]) {
8567                         { 0x19, 0x01a1103c }, /* use as headset mic */
8568                         { }
8569                 },
8570                 .chained = true,
8571                 .chain_id = ALC269_FIXUP_HEADSET_MIC
8572         },
8573         [ALC294_FIXUP_ASUS_SPK] = {
8574                 .type = HDA_FIXUP_VERBS,
8575                 .v.verbs = (const struct hda_verb[]) {
8576                         /* Set EAPD high */
8577                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x40 },
8578                         { 0x20, AC_VERB_SET_PROC_COEF, 0x8800 },
8579                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x0f },
8580                         { 0x20, AC_VERB_SET_PROC_COEF, 0x7774 },
8581                         { }
8582                 },
8583                 .chained = true,
8584                 .chain_id = ALC294_FIXUP_ASUS_HEADSET_MIC
8585         },
8586         [ALC295_FIXUP_CHROME_BOOK] = {
8587                 .type = HDA_FIXUP_FUNC,
8588                 .v.func = alc295_fixup_chromebook,
8589                 .chained = true,
8590                 .chain_id = ALC225_FIXUP_HEADSET_JACK
8591         },
8592         [ALC225_FIXUP_HEADSET_JACK] = {
8593                 .type = HDA_FIXUP_FUNC,
8594                 .v.func = alc_fixup_headset_jack,
8595         },
8596         [ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE] = {
8597                 .type = HDA_FIXUP_PINS,
8598                 .v.pins = (const struct hda_pintbl[]) {
8599                         { 0x1a, 0x01a1913c }, /* use as headset mic, without its own jack detect */
8600                         { }
8601                 },
8602                 .chained = true,
8603                 .chain_id = ALC269_FIXUP_HEADSET_MODE_NO_HP_MIC
8604         },
8605         [ALC285_FIXUP_LENOVO_PC_BEEP_IN_NOISE] = {
8606                 .type = HDA_FIXUP_VERBS,
8607                 .v.verbs = (const struct hda_verb[]) {
8608                         /* Disable PCBEEP-IN passthrough */
8609                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x36 },
8610                         { 0x20, AC_VERB_SET_PROC_COEF, 0x57d7 },
8611                         { }
8612                 },
8613                 .chained = true,
8614                 .chain_id = ALC285_FIXUP_LENOVO_HEADPHONE_NOISE
8615         },
8616         [ALC255_FIXUP_ACER_HEADSET_MIC] = {
8617                 .type = HDA_FIXUP_PINS,
8618                 .v.pins = (const struct hda_pintbl[]) {
8619                         { 0x19, 0x03a11130 },
8620                         { 0x1a, 0x90a60140 }, /* use as internal mic */
8621                         { }
8622                 },
8623                 .chained = true,
8624                 .chain_id = ALC255_FIXUP_HEADSET_MODE_NO_HP_MIC
8625         },
8626         [ALC225_FIXUP_DELL_WYSE_AIO_MIC_NO_PRESENCE] = {
8627                 .type = HDA_FIXUP_PINS,
8628                 .v.pins = (const struct hda_pintbl[]) {
8629                         { 0x16, 0x01011020 }, /* Rear Line out */
8630                         { 0x19, 0x01a1913c }, /* use as Front headset mic, without its own jack detect */
8631                         { }
8632                 },
8633                 .chained = true,
8634                 .chain_id = ALC225_FIXUP_WYSE_AUTO_MUTE
8635         },
8636         [ALC225_FIXUP_WYSE_AUTO_MUTE] = {
8637                 .type = HDA_FIXUP_FUNC,
8638                 .v.func = alc_fixup_auto_mute_via_amp,
8639                 .chained = true,
8640                 .chain_id = ALC225_FIXUP_WYSE_DISABLE_MIC_VREF
8641         },
8642         [ALC225_FIXUP_WYSE_DISABLE_MIC_VREF] = {
8643                 .type = HDA_FIXUP_FUNC,
8644                 .v.func = alc_fixup_disable_mic_vref,
8645                 .chained = true,
8646                 .chain_id = ALC269_FIXUP_HEADSET_MODE_NO_HP_MIC
8647         },
8648         [ALC286_FIXUP_ACER_AIO_HEADSET_MIC] = {
8649                 .type = HDA_FIXUP_VERBS,
8650                 .v.verbs = (const struct hda_verb[]) {
8651                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x4f },
8652                         { 0x20, AC_VERB_SET_PROC_COEF, 0x5029 },
8653                         { }
8654                 },
8655                 .chained = true,
8656                 .chain_id = ALC286_FIXUP_ACER_AIO_MIC_NO_PRESENCE
8657         },
8658         [ALC256_FIXUP_ASUS_HEADSET_MIC] = {
8659                 .type = HDA_FIXUP_PINS,
8660                 .v.pins = (const struct hda_pintbl[]) {
8661                         { 0x19, 0x03a11020 }, /* headset mic with jack detect */
8662                         { }
8663                 },
8664                 .chained = true,
8665                 .chain_id = ALC256_FIXUP_ASUS_HEADSET_MODE
8666         },
8667         [ALC256_FIXUP_ASUS_MIC_NO_PRESENCE] = {
8668                 .type = HDA_FIXUP_PINS,
8669                 .v.pins = (const struct hda_pintbl[]) {
8670                         { 0x19, 0x04a11120 }, /* use as headset mic, without its own jack detect */
8671                         { }
8672                 },
8673                 .chained = true,
8674                 .chain_id = ALC256_FIXUP_ASUS_HEADSET_MODE
8675         },
8676         [ALC299_FIXUP_PREDATOR_SPK] = {
8677                 .type = HDA_FIXUP_PINS,
8678                 .v.pins = (const struct hda_pintbl[]) {
8679                         { 0x21, 0x90170150 }, /* use as headset mic, without its own jack detect */
8680                         { }
8681                 }
8682         },
8683         [ALC256_FIXUP_MEDION_HEADSET_NO_PRESENCE] = {
8684                 .type = HDA_FIXUP_PINS,
8685                 .v.pins = (const struct hda_pintbl[]) {
8686                         { 0x19, 0x04a11040 },
8687                         { 0x21, 0x04211020 },
8688                         { }
8689                 },
8690                 .chained = true,
8691                 .chain_id = ALC256_FIXUP_ASUS_HEADSET_MODE
8692         },
8693         [ALC289_FIXUP_DELL_SPK1] = {
8694                 .type = HDA_FIXUP_PINS,
8695                 .v.pins = (const struct hda_pintbl[]) {
8696                         { 0x14, 0x90170140 },
8697                         { }
8698                 },
8699                 .chained = true,
8700                 .chain_id = ALC269_FIXUP_DELL4_MIC_NO_PRESENCE
8701         },
8702         [ALC289_FIXUP_DELL_SPK2] = {
8703                 .type = HDA_FIXUP_PINS,
8704                 .v.pins = (const struct hda_pintbl[]) {
8705                         { 0x17, 0x90170130 }, /* bass spk */
8706                         { }
8707                 },
8708                 .chained = true,
8709                 .chain_id = ALC269_FIXUP_DELL4_MIC_NO_PRESENCE
8710         },
8711         [ALC289_FIXUP_DUAL_SPK] = {
8712                 .type = HDA_FIXUP_FUNC,
8713                 .v.func = alc285_fixup_speaker2_to_dac1,
8714                 .chained = true,
8715                 .chain_id = ALC289_FIXUP_DELL_SPK2
8716         },
8717         [ALC289_FIXUP_RTK_AMP_DUAL_SPK] = {
8718                 .type = HDA_FIXUP_FUNC,
8719                 .v.func = alc285_fixup_speaker2_to_dac1,
8720                 .chained = true,
8721                 .chain_id = ALC289_FIXUP_DELL_SPK1
8722         },
8723         [ALC294_FIXUP_SPK2_TO_DAC1] = {
8724                 .type = HDA_FIXUP_FUNC,
8725                 .v.func = alc285_fixup_speaker2_to_dac1,
8726                 .chained = true,
8727                 .chain_id = ALC294_FIXUP_ASUS_HEADSET_MIC
8728         },
8729         [ALC294_FIXUP_ASUS_DUAL_SPK] = {
8730                 .type = HDA_FIXUP_FUNC,
8731                 /* The GPIO must be pulled to initialize the AMP */
8732                 .v.func = alc_fixup_gpio4,
8733                 .chained = true,
8734                 .chain_id = ALC294_FIXUP_SPK2_TO_DAC1
8735         },
8736         [ALC294_FIXUP_ASUS_ALLY] = {
8737                 .type = HDA_FIXUP_FUNC,
8738                 .v.func = cs35l41_fixup_i2c_two,
8739                 .chained = true,
8740                 .chain_id = ALC294_FIXUP_ASUS_ALLY_PINS
8741         },
8742         [ALC294_FIXUP_ASUS_ALLY_PINS] = {
8743                 .type = HDA_FIXUP_PINS,
8744                 .v.pins = (const struct hda_pintbl[]) {
8745                         { 0x19, 0x03a11050 },
8746                         { 0x1a, 0x03a11c30 },
8747                         { 0x21, 0x03211420 },
8748                         { }
8749                 },
8750                 .chained = true,
8751                 .chain_id = ALC294_FIXUP_ASUS_ALLY_VERBS
8752         },
8753         [ALC294_FIXUP_ASUS_ALLY_VERBS] = {
8754                 .type = HDA_FIXUP_VERBS,
8755                 .v.verbs = (const struct hda_verb[]) {
8756                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x45 },
8757                         { 0x20, AC_VERB_SET_PROC_COEF, 0x5089 },
8758                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x46 },
8759                         { 0x20, AC_VERB_SET_PROC_COEF, 0x0004 },
8760                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x47 },
8761                         { 0x20, AC_VERB_SET_PROC_COEF, 0xa47a },
8762                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x49 },
8763                         { 0x20, AC_VERB_SET_PROC_COEF, 0x0049},
8764                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x4a },
8765                         { 0x20, AC_VERB_SET_PROC_COEF, 0x201b },
8766                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x6b },
8767                         { 0x20, AC_VERB_SET_PROC_COEF, 0x4278},
8768                         { }
8769                 },
8770                 .chained = true,
8771                 .chain_id = ALC294_FIXUP_ASUS_ALLY_SPEAKER
8772         },
8773         [ALC294_FIXUP_ASUS_ALLY_SPEAKER] = {
8774                 .type = HDA_FIXUP_FUNC,
8775                 .v.func = alc285_fixup_speaker2_to_dac1,
8776         },
8777         [ALC285_FIXUP_THINKPAD_X1_GEN7] = {
8778                 .type = HDA_FIXUP_FUNC,
8779                 .v.func = alc285_fixup_thinkpad_x1_gen7,
8780                 .chained = true,
8781                 .chain_id = ALC269_FIXUP_THINKPAD_ACPI
8782         },
8783         [ALC285_FIXUP_THINKPAD_HEADSET_JACK] = {
8784                 .type = HDA_FIXUP_FUNC,
8785                 .v.func = alc_fixup_headset_jack,
8786                 .chained = true,
8787                 .chain_id = ALC285_FIXUP_THINKPAD_X1_GEN7
8788         },
8789         [ALC294_FIXUP_ASUS_HPE] = {
8790                 .type = HDA_FIXUP_VERBS,
8791                 .v.verbs = (const struct hda_verb[]) {
8792                         /* Set EAPD high */
8793                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x0f },
8794                         { 0x20, AC_VERB_SET_PROC_COEF, 0x7774 },
8795                         { }
8796                 },
8797                 .chained = true,
8798                 .chain_id = ALC294_FIXUP_ASUS_HEADSET_MIC
8799         },
8800         [ALC294_FIXUP_ASUS_GX502_PINS] = {
8801                 .type = HDA_FIXUP_PINS,
8802                 .v.pins = (const struct hda_pintbl[]) {
8803                         { 0x19, 0x03a11050 }, /* front HP mic */
8804                         { 0x1a, 0x01a11830 }, /* rear external mic */
8805                         { 0x21, 0x03211020 }, /* front HP out */
8806                         { }
8807                 },
8808                 .chained = true,
8809                 .chain_id = ALC294_FIXUP_ASUS_GX502_VERBS
8810         },
8811         [ALC294_FIXUP_ASUS_GX502_VERBS] = {
8812                 .type = HDA_FIXUP_VERBS,
8813                 .v.verbs = (const struct hda_verb[]) {
8814                         /* set 0x15 to HP-OUT ctrl */
8815                         { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0 },
8816                         /* unmute the 0x15 amp */
8817                         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000 },
8818                         { }
8819                 },
8820                 .chained = true,
8821                 .chain_id = ALC294_FIXUP_ASUS_GX502_HP
8822         },
8823         [ALC294_FIXUP_ASUS_GX502_HP] = {
8824                 .type = HDA_FIXUP_FUNC,
8825                 .v.func = alc294_fixup_gx502_hp,
8826         },
8827         [ALC294_FIXUP_ASUS_GU502_PINS] = {
8828                 .type = HDA_FIXUP_PINS,
8829                 .v.pins = (const struct hda_pintbl[]) {
8830                         { 0x19, 0x01a11050 }, /* rear HP mic */
8831                         { 0x1a, 0x01a11830 }, /* rear external mic */
8832                         { 0x21, 0x012110f0 }, /* rear HP out */
8833                         { }
8834                 },
8835                 .chained = true,
8836                 .chain_id = ALC294_FIXUP_ASUS_GU502_VERBS
8837         },
8838         [ALC294_FIXUP_ASUS_GU502_VERBS] = {
8839                 .type = HDA_FIXUP_VERBS,
8840                 .v.verbs = (const struct hda_verb[]) {
8841                         /* set 0x15 to HP-OUT ctrl */
8842                         { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0 },
8843                         /* unmute the 0x15 amp */
8844                         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000 },
8845                         /* set 0x1b to HP-OUT */
8846                         { 0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
8847                         { }
8848                 },
8849                 .chained = true,
8850                 .chain_id = ALC294_FIXUP_ASUS_GU502_HP
8851         },
8852         [ALC294_FIXUP_ASUS_GU502_HP] = {
8853                 .type = HDA_FIXUP_FUNC,
8854                 .v.func = alc294_fixup_gu502_hp,
8855         },
8856          [ALC294_FIXUP_ASUS_G513_PINS] = {
8857                 .type = HDA_FIXUP_PINS,
8858                 .v.pins = (const struct hda_pintbl[]) {
8859                                 { 0x19, 0x03a11050 }, /* front HP mic */
8860                                 { 0x1a, 0x03a11c30 }, /* rear external mic */
8861                                 { 0x21, 0x03211420 }, /* front HP out */
8862                                 { }
8863                 },
8864         },
8865         [ALC285_FIXUP_ASUS_G533Z_PINS] = {
8866                 .type = HDA_FIXUP_PINS,
8867                 .v.pins = (const struct hda_pintbl[]) {
8868                         { 0x14, 0x90170152 }, /* Speaker Surround Playback Switch */
8869                         { 0x19, 0x03a19020 }, /* Mic Boost Volume */
8870                         { 0x1a, 0x03a11c30 }, /* Mic Boost Volume */
8871                         { 0x1e, 0x90170151 }, /* Rear jack, IN OUT EAPD Detect */
8872                         { 0x21, 0x03211420 },
8873                         { }
8874                 },
8875         },
8876         [ALC294_FIXUP_ASUS_COEF_1B] = {
8877                 .type = HDA_FIXUP_VERBS,
8878                 .v.verbs = (const struct hda_verb[]) {
8879                         /* Set bit 10 to correct noisy output after reboot from
8880                          * Windows 10 (due to pop noise reduction?)
8881                          */
8882                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x1b },
8883                         { 0x20, AC_VERB_SET_PROC_COEF, 0x4e4b },
8884                         { }
8885                 },
8886                 .chained = true,
8887                 .chain_id = ALC289_FIXUP_ASUS_GA401,
8888         },
8889         [ALC285_FIXUP_HP_GPIO_LED] = {
8890                 .type = HDA_FIXUP_FUNC,
8891                 .v.func = alc285_fixup_hp_gpio_led,
8892         },
8893         [ALC285_FIXUP_HP_MUTE_LED] = {
8894                 .type = HDA_FIXUP_FUNC,
8895                 .v.func = alc285_fixup_hp_mute_led,
8896         },
8897         [ALC285_FIXUP_HP_SPECTRE_X360_MUTE_LED] = {
8898                 .type = HDA_FIXUP_FUNC,
8899                 .v.func = alc285_fixup_hp_spectre_x360_mute_led,
8900         },
8901         [ALC236_FIXUP_HP_MUTE_LED_COEFBIT2] = {
8902             .type = HDA_FIXUP_FUNC,
8903             .v.func = alc236_fixup_hp_mute_led_coefbit2,
8904         },
8905         [ALC236_FIXUP_HP_GPIO_LED] = {
8906                 .type = HDA_FIXUP_FUNC,
8907                 .v.func = alc236_fixup_hp_gpio_led,
8908         },
8909         [ALC236_FIXUP_HP_MUTE_LED] = {
8910                 .type = HDA_FIXUP_FUNC,
8911                 .v.func = alc236_fixup_hp_mute_led,
8912         },
8913         [ALC236_FIXUP_HP_MUTE_LED_MICMUTE_VREF] = {
8914                 .type = HDA_FIXUP_FUNC,
8915                 .v.func = alc236_fixup_hp_mute_led_micmute_vref,
8916         },
8917         [ALC298_FIXUP_SAMSUNG_AMP] = {
8918                 .type = HDA_FIXUP_FUNC,
8919                 .v.func = alc298_fixup_samsung_amp,
8920                 .chained = true,
8921                 .chain_id = ALC298_FIXUP_SAMSUNG_HEADPHONE_VERY_QUIET
8922         },
8923         [ALC298_FIXUP_SAMSUNG_HEADPHONE_VERY_QUIET] = {
8924                 .type = HDA_FIXUP_VERBS,
8925                 .v.verbs = (const struct hda_verb[]) {
8926                         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc5 },
8927                         { }
8928                 },
8929         },
8930         [ALC256_FIXUP_SAMSUNG_HEADPHONE_VERY_QUIET] = {
8931                 .type = HDA_FIXUP_VERBS,
8932                 .v.verbs = (const struct hda_verb[]) {
8933                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x08},
8934                         { 0x20, AC_VERB_SET_PROC_COEF, 0x2fcf},
8935                         { }
8936                 },
8937         },
8938         [ALC295_FIXUP_ASUS_MIC_NO_PRESENCE] = {
8939                 .type = HDA_FIXUP_PINS,
8940                 .v.pins = (const struct hda_pintbl[]) {
8941                         { 0x19, 0x01a1913c }, /* use as headset mic, without its own jack detect */
8942                         { }
8943                 },
8944                 .chained = true,
8945                 .chain_id = ALC269_FIXUP_HEADSET_MODE
8946         },
8947         [ALC269VC_FIXUP_ACER_VCOPPERBOX_PINS] = {
8948                 .type = HDA_FIXUP_PINS,
8949                 .v.pins = (const struct hda_pintbl[]) {
8950                         { 0x14, 0x90100120 }, /* use as internal speaker */
8951                         { 0x18, 0x02a111f0 }, /* use as headset mic, without its own jack detect */
8952                         { 0x1a, 0x01011020 }, /* use as line out */
8953                         { },
8954                 },
8955                 .chained = true,
8956                 .chain_id = ALC269_FIXUP_HEADSET_MIC
8957         },
8958         [ALC269VC_FIXUP_ACER_HEADSET_MIC] = {
8959                 .type = HDA_FIXUP_PINS,
8960                 .v.pins = (const struct hda_pintbl[]) {
8961                         { 0x18, 0x02a11030 }, /* use as headset mic */
8962                         { }
8963                 },
8964                 .chained = true,
8965                 .chain_id = ALC269_FIXUP_HEADSET_MIC
8966         },
8967         [ALC269VC_FIXUP_ACER_MIC_NO_PRESENCE] = {
8968                 .type = HDA_FIXUP_PINS,
8969                 .v.pins = (const struct hda_pintbl[]) {
8970                         { 0x18, 0x01a11130 }, /* use as headset mic, without its own jack detect */
8971                         { }
8972                 },
8973                 .chained = true,
8974                 .chain_id = ALC269_FIXUP_HEADSET_MIC
8975         },
8976         [ALC289_FIXUP_ASUS_GA401] = {
8977                 .type = HDA_FIXUP_FUNC,
8978                 .v.func = alc289_fixup_asus_ga401,
8979                 .chained = true,
8980                 .chain_id = ALC289_FIXUP_ASUS_GA502,
8981         },
8982         [ALC289_FIXUP_ASUS_GA502] = {
8983                 .type = HDA_FIXUP_PINS,
8984                 .v.pins = (const struct hda_pintbl[]) {
8985                         { 0x19, 0x03a11020 }, /* headset mic with jack detect */
8986                         { }
8987                 },
8988         },
8989         [ALC256_FIXUP_ACER_MIC_NO_PRESENCE] = {
8990                 .type = HDA_FIXUP_PINS,
8991                 .v.pins = (const struct hda_pintbl[]) {
8992                         { 0x19, 0x02a11120 }, /* use as headset mic, without its own jack detect */
8993                         { }
8994                 },
8995                 .chained = true,
8996                 .chain_id = ALC256_FIXUP_ASUS_HEADSET_MODE
8997         },
8998         [ALC285_FIXUP_HP_GPIO_AMP_INIT] = {
8999                 .type = HDA_FIXUP_FUNC,
9000                 .v.func = alc285_fixup_hp_gpio_amp_init,
9001                 .chained = true,
9002                 .chain_id = ALC285_FIXUP_HP_GPIO_LED
9003         },
9004         [ALC269_FIXUP_CZC_B20] = {
9005                 .type = HDA_FIXUP_PINS,
9006                 .v.pins = (const struct hda_pintbl[]) {
9007                         { 0x12, 0x411111f0 },
9008                         { 0x14, 0x90170110 }, /* speaker */
9009                         { 0x15, 0x032f1020 }, /* HP out */
9010                         { 0x17, 0x411111f0 },
9011                         { 0x18, 0x03ab1040 }, /* mic */
9012                         { 0x19, 0xb7a7013f },
9013                         { 0x1a, 0x0181305f },
9014                         { 0x1b, 0x411111f0 },
9015                         { 0x1d, 0x411111f0 },
9016                         { 0x1e, 0x411111f0 },
9017                         { }
9018                 },
9019                 .chain_id = ALC269_FIXUP_DMIC,
9020         },
9021         [ALC269_FIXUP_CZC_TMI] = {
9022                 .type = HDA_FIXUP_PINS,
9023                 .v.pins = (const struct hda_pintbl[]) {
9024                         { 0x12, 0x4000c000 },
9025                         { 0x14, 0x90170110 }, /* speaker */
9026                         { 0x15, 0x0421401f }, /* HP out */
9027                         { 0x17, 0x411111f0 },
9028                         { 0x18, 0x04a19020 }, /* mic */
9029                         { 0x19, 0x411111f0 },
9030                         { 0x1a, 0x411111f0 },
9031                         { 0x1b, 0x411111f0 },
9032                         { 0x1d, 0x40448505 },
9033                         { 0x1e, 0x411111f0 },
9034                         { 0x20, 0x8000ffff },
9035                         { }
9036                 },
9037                 .chain_id = ALC269_FIXUP_DMIC,
9038         },
9039         [ALC269_FIXUP_CZC_L101] = {
9040                 .type = HDA_FIXUP_PINS,
9041                 .v.pins = (const struct hda_pintbl[]) {
9042                         { 0x12, 0x40000000 },
9043                         { 0x14, 0x01014010 }, /* speaker */
9044                         { 0x15, 0x411111f0 }, /* HP out */
9045                         { 0x16, 0x411111f0 },
9046                         { 0x18, 0x01a19020 }, /* mic */
9047                         { 0x19, 0x02a19021 },
9048                         { 0x1a, 0x0181302f },
9049                         { 0x1b, 0x0221401f },
9050                         { 0x1c, 0x411111f0 },
9051                         { 0x1d, 0x4044c601 },
9052                         { 0x1e, 0x411111f0 },
9053                         { }
9054                 },
9055                 .chain_id = ALC269_FIXUP_DMIC,
9056         },
9057         [ALC269_FIXUP_LEMOTE_A1802] = {
9058                 .type = HDA_FIXUP_PINS,
9059                 .v.pins = (const struct hda_pintbl[]) {
9060                         { 0x12, 0x40000000 },
9061                         { 0x14, 0x90170110 }, /* speaker */
9062                         { 0x17, 0x411111f0 },
9063                         { 0x18, 0x03a19040 }, /* mic1 */
9064                         { 0x19, 0x90a70130 }, /* mic2 */
9065                         { 0x1a, 0x411111f0 },
9066                         { 0x1b, 0x411111f0 },
9067                         { 0x1d, 0x40489d2d },
9068                         { 0x1e, 0x411111f0 },
9069                         { 0x20, 0x0003ffff },
9070                         { 0x21, 0x03214020 },
9071                         { }
9072                 },
9073                 .chain_id = ALC269_FIXUP_DMIC,
9074         },
9075         [ALC269_FIXUP_LEMOTE_A190X] = {
9076                 .type = HDA_FIXUP_PINS,
9077                 .v.pins = (const struct hda_pintbl[]) {
9078                         { 0x14, 0x99130110 }, /* speaker */
9079                         { 0x15, 0x0121401f }, /* HP out */
9080                         { 0x18, 0x01a19c20 }, /* rear  mic */
9081                         { 0x19, 0x99a3092f }, /* front mic */
9082                         { 0x1b, 0x0201401f }, /* front lineout */
9083                         { }
9084                 },
9085                 .chain_id = ALC269_FIXUP_DMIC,
9086         },
9087         [ALC256_FIXUP_INTEL_NUC8_RUGGED] = {
9088                 .type = HDA_FIXUP_PINS,
9089                 .v.pins = (const struct hda_pintbl[]) {
9090                         { 0x1b, 0x01a1913c }, /* use as headset mic, without its own jack detect */
9091                         { }
9092                 },
9093                 .chained = true,
9094                 .chain_id = ALC269_FIXUP_HEADSET_MODE
9095         },
9096         [ALC256_FIXUP_INTEL_NUC10] = {
9097                 .type = HDA_FIXUP_PINS,
9098                 .v.pins = (const struct hda_pintbl[]) {
9099                         { 0x19, 0x01a1913c }, /* use as headset mic, without its own jack detect */
9100                         { }
9101                 },
9102                 .chained = true,
9103                 .chain_id = ALC269_FIXUP_HEADSET_MODE
9104         },
9105         [ALC255_FIXUP_XIAOMI_HEADSET_MIC] = {
9106                 .type = HDA_FIXUP_VERBS,
9107                 .v.verbs = (const struct hda_verb[]) {
9108                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x45 },
9109                         { 0x20, AC_VERB_SET_PROC_COEF, 0x5089 },
9110                         { }
9111                 },
9112                 .chained = true,
9113                 .chain_id = ALC289_FIXUP_ASUS_GA502
9114         },
9115         [ALC274_FIXUP_HP_MIC] = {
9116                 .type = HDA_FIXUP_VERBS,
9117                 .v.verbs = (const struct hda_verb[]) {
9118                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x45 },
9119                         { 0x20, AC_VERB_SET_PROC_COEF, 0x5089 },
9120                         { }
9121                 },
9122         },
9123         [ALC274_FIXUP_HP_HEADSET_MIC] = {
9124                 .type = HDA_FIXUP_FUNC,
9125                 .v.func = alc274_fixup_hp_headset_mic,
9126                 .chained = true,
9127                 .chain_id = ALC274_FIXUP_HP_MIC
9128         },
9129         [ALC274_FIXUP_HP_ENVY_GPIO] = {
9130                 .type = HDA_FIXUP_FUNC,
9131                 .v.func = alc274_fixup_hp_envy_gpio,
9132         },
9133         [ALC256_FIXUP_ASUS_HPE] = {
9134                 .type = HDA_FIXUP_VERBS,
9135                 .v.verbs = (const struct hda_verb[]) {
9136                         /* Set EAPD high */
9137                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x0f },
9138                         { 0x20, AC_VERB_SET_PROC_COEF, 0x7778 },
9139                         { }
9140                 },
9141                 .chained = true,
9142                 .chain_id = ALC294_FIXUP_ASUS_HEADSET_MIC
9143         },
9144         [ALC285_FIXUP_THINKPAD_NO_BASS_SPK_HEADSET_JACK] = {
9145                 .type = HDA_FIXUP_FUNC,
9146                 .v.func = alc_fixup_headset_jack,
9147                 .chained = true,
9148                 .chain_id = ALC269_FIXUP_THINKPAD_ACPI
9149         },
9150         [ALC287_FIXUP_HP_GPIO_LED] = {
9151                 .type = HDA_FIXUP_FUNC,
9152                 .v.func = alc287_fixup_hp_gpio_led,
9153         },
9154         [ALC256_FIXUP_HP_HEADSET_MIC] = {
9155                 .type = HDA_FIXUP_FUNC,
9156                 .v.func = alc274_fixup_hp_headset_mic,
9157         },
9158         [ALC236_FIXUP_DELL_AIO_HEADSET_MIC] = {
9159                 .type = HDA_FIXUP_FUNC,
9160                 .v.func = alc_fixup_no_int_mic,
9161                 .chained = true,
9162                 .chain_id = ALC255_FIXUP_DELL1_MIC_NO_PRESENCE
9163         },
9164         [ALC282_FIXUP_ACER_DISABLE_LINEOUT] = {
9165                 .type = HDA_FIXUP_PINS,
9166                 .v.pins = (const struct hda_pintbl[]) {
9167                         { 0x1b, 0x411111f0 },
9168                         { 0x18, 0x01a1913c }, /* use as headset mic, without its own jack detect */
9169                         { },
9170                 },
9171                 .chained = true,
9172                 .chain_id = ALC269_FIXUP_HEADSET_MODE
9173         },
9174         [ALC255_FIXUP_ACER_LIMIT_INT_MIC_BOOST] = {
9175                 .type = HDA_FIXUP_FUNC,
9176                 .v.func = alc269_fixup_limit_int_mic_boost,
9177                 .chained = true,
9178                 .chain_id = ALC255_FIXUP_ACER_MIC_NO_PRESENCE,
9179         },
9180         [ALC256_FIXUP_ACER_HEADSET_MIC] = {
9181                 .type = HDA_FIXUP_PINS,
9182                 .v.pins = (const struct hda_pintbl[]) {
9183                         { 0x19, 0x02a1113c }, /* use as headset mic, without its own jack detect */
9184                         { 0x1a, 0x90a1092f }, /* use as internal mic */
9185                         { }
9186                 },
9187                 .chained = true,
9188                 .chain_id = ALC269_FIXUP_HEADSET_MODE_NO_HP_MIC
9189         },
9190         [ALC285_FIXUP_IDEAPAD_S740_COEF] = {
9191                 .type = HDA_FIXUP_FUNC,
9192                 .v.func = alc285_fixup_ideapad_s740_coef,
9193                 .chained = true,
9194                 .chain_id = ALC269_FIXUP_THINKPAD_ACPI,
9195         },
9196         [ALC285_FIXUP_HP_LIMIT_INT_MIC_BOOST] = {
9197                 .type = HDA_FIXUP_FUNC,
9198                 .v.func = alc269_fixup_limit_int_mic_boost,
9199                 .chained = true,
9200                 .chain_id = ALC285_FIXUP_HP_MUTE_LED,
9201         },
9202         [ALC295_FIXUP_ASUS_DACS] = {
9203                 .type = HDA_FIXUP_FUNC,
9204                 .v.func = alc295_fixup_asus_dacs,
9205         },
9206         [ALC295_FIXUP_HP_OMEN] = {
9207                 .type = HDA_FIXUP_PINS,
9208                 .v.pins = (const struct hda_pintbl[]) {
9209                         { 0x12, 0xb7a60130 },
9210                         { 0x13, 0x40000000 },
9211                         { 0x14, 0x411111f0 },
9212                         { 0x16, 0x411111f0 },
9213                         { 0x17, 0x90170110 },
9214                         { 0x18, 0x411111f0 },
9215                         { 0x19, 0x02a11030 },
9216                         { 0x1a, 0x411111f0 },
9217                         { 0x1b, 0x04a19030 },
9218                         { 0x1d, 0x40600001 },
9219                         { 0x1e, 0x411111f0 },
9220                         { 0x21, 0x03211020 },
9221                         {}
9222                 },
9223                 .chained = true,
9224                 .chain_id = ALC269_FIXUP_HP_LINE1_MIC1_LED,
9225         },
9226         [ALC285_FIXUP_HP_SPECTRE_X360] = {
9227                 .type = HDA_FIXUP_FUNC,
9228                 .v.func = alc285_fixup_hp_spectre_x360,
9229         },
9230         [ALC285_FIXUP_HP_SPECTRE_X360_EB1] = {
9231                 .type = HDA_FIXUP_FUNC,
9232                 .v.func = alc285_fixup_hp_spectre_x360_eb1
9233         },
9234         [ALC285_FIXUP_HP_ENVY_X360] = {
9235                 .type = HDA_FIXUP_FUNC,
9236                 .v.func = alc285_fixup_hp_envy_x360,
9237                 .chained = true,
9238                 .chain_id = ALC285_FIXUP_HP_GPIO_AMP_INIT,
9239         },
9240         [ALC287_FIXUP_IDEAPAD_BASS_SPK_AMP] = {
9241                 .type = HDA_FIXUP_FUNC,
9242                 .v.func = alc285_fixup_ideapad_s740_coef,
9243                 .chained = true,
9244                 .chain_id = ALC285_FIXUP_THINKPAD_HEADSET_JACK,
9245         },
9246         [ALC623_FIXUP_LENOVO_THINKSTATION_P340] = {
9247                 .type = HDA_FIXUP_FUNC,
9248                 .v.func = alc_fixup_no_shutup,
9249                 .chained = true,
9250                 .chain_id = ALC283_FIXUP_HEADSET_MIC,
9251         },
9252         [ALC255_FIXUP_ACER_HEADPHONE_AND_MIC] = {
9253                 .type = HDA_FIXUP_PINS,
9254                 .v.pins = (const struct hda_pintbl[]) {
9255                         { 0x21, 0x03211030 }, /* Change the Headphone location to Left */
9256                         { }
9257                 },
9258                 .chained = true,
9259                 .chain_id = ALC255_FIXUP_XIAOMI_HEADSET_MIC
9260         },
9261         [ALC236_FIXUP_HP_LIMIT_INT_MIC_BOOST] = {
9262                 .type = HDA_FIXUP_FUNC,
9263                 .v.func = alc269_fixup_limit_int_mic_boost,
9264                 .chained = true,
9265                 .chain_id = ALC236_FIXUP_HP_MUTE_LED_MICMUTE_VREF,
9266         },
9267         [ALC285_FIXUP_LEGION_Y9000X_SPEAKERS] = {
9268                 .type = HDA_FIXUP_FUNC,
9269                 .v.func = alc285_fixup_ideapad_s740_coef,
9270                 .chained = true,
9271                 .chain_id = ALC285_FIXUP_LEGION_Y9000X_AUTOMUTE,
9272         },
9273         [ALC285_FIXUP_LEGION_Y9000X_AUTOMUTE] = {
9274                 .type = HDA_FIXUP_FUNC,
9275                 .v.func = alc287_fixup_legion_15imhg05_speakers,
9276                 .chained = true,
9277                 .chain_id = ALC269_FIXUP_THINKPAD_ACPI,
9278         },
9279         [ALC287_FIXUP_LEGION_15IMHG05_SPEAKERS] = {
9280                 .type = HDA_FIXUP_VERBS,
9281                 //.v.verbs = legion_15imhg05_coefs,
9282                 .v.verbs = (const struct hda_verb[]) {
9283                          // set left speaker Legion 7i.
9284                          { 0x20, AC_VERB_SET_COEF_INDEX, 0x24 },
9285                          { 0x20, AC_VERB_SET_PROC_COEF, 0x41 },
9286
9287                          { 0x20, AC_VERB_SET_COEF_INDEX, 0x26 },
9288                          { 0x20, AC_VERB_SET_PROC_COEF, 0xc },
9289                          { 0x20, AC_VERB_SET_PROC_COEF, 0x0 },
9290                          { 0x20, AC_VERB_SET_PROC_COEF, 0x1a },
9291                          { 0x20, AC_VERB_SET_PROC_COEF, 0xb020 },
9292
9293                          { 0x20, AC_VERB_SET_COEF_INDEX, 0x26 },
9294                          { 0x20, AC_VERB_SET_PROC_COEF, 0x2 },
9295                          { 0x20, AC_VERB_SET_PROC_COEF, 0x0 },
9296                          { 0x20, AC_VERB_SET_PROC_COEF, 0x0 },
9297                          { 0x20, AC_VERB_SET_PROC_COEF, 0xb020 },
9298
9299                          // set right speaker Legion 7i.
9300                          { 0x20, AC_VERB_SET_COEF_INDEX, 0x24 },
9301                          { 0x20, AC_VERB_SET_PROC_COEF, 0x42 },
9302
9303                          { 0x20, AC_VERB_SET_COEF_INDEX, 0x26 },
9304                          { 0x20, AC_VERB_SET_PROC_COEF, 0xc },
9305                          { 0x20, AC_VERB_SET_PROC_COEF, 0x0 },
9306                          { 0x20, AC_VERB_SET_PROC_COEF, 0x2a },
9307                          { 0x20, AC_VERB_SET_PROC_COEF, 0xb020 },
9308
9309                          { 0x20, AC_VERB_SET_COEF_INDEX, 0x26 },
9310                          { 0x20, AC_VERB_SET_PROC_COEF, 0x2 },
9311                          { 0x20, AC_VERB_SET_PROC_COEF, 0x0 },
9312                          { 0x20, AC_VERB_SET_PROC_COEF, 0x0 },
9313                          { 0x20, AC_VERB_SET_PROC_COEF, 0xb020 },
9314                          {}
9315                 },
9316                 .chained = true,
9317                 .chain_id = ALC287_FIXUP_LEGION_15IMHG05_AUTOMUTE,
9318         },
9319         [ALC287_FIXUP_LEGION_15IMHG05_AUTOMUTE] = {
9320                 .type = HDA_FIXUP_FUNC,
9321                 .v.func = alc287_fixup_legion_15imhg05_speakers,
9322                 .chained = true,
9323                 .chain_id = ALC269_FIXUP_HEADSET_MODE,
9324         },
9325         [ALC287_FIXUP_YOGA7_14ITL_SPEAKERS] = {
9326                 .type = HDA_FIXUP_VERBS,
9327                 .v.verbs = (const struct hda_verb[]) {
9328                          // set left speaker Yoga 7i.
9329                          { 0x20, AC_VERB_SET_COEF_INDEX, 0x24 },
9330                          { 0x20, AC_VERB_SET_PROC_COEF, 0x41 },
9331
9332                          { 0x20, AC_VERB_SET_COEF_INDEX, 0x26 },
9333                          { 0x20, AC_VERB_SET_PROC_COEF, 0xc },
9334                          { 0x20, AC_VERB_SET_PROC_COEF, 0x0 },
9335                          { 0x20, AC_VERB_SET_PROC_COEF, 0x1a },
9336                          { 0x20, AC_VERB_SET_PROC_COEF, 0xb020 },
9337
9338                          { 0x20, AC_VERB_SET_COEF_INDEX, 0x26 },
9339                          { 0x20, AC_VERB_SET_PROC_COEF, 0x2 },
9340                          { 0x20, AC_VERB_SET_PROC_COEF, 0x0 },
9341                          { 0x20, AC_VERB_SET_PROC_COEF, 0x0 },
9342                          { 0x20, AC_VERB_SET_PROC_COEF, 0xb020 },
9343
9344                          // set right speaker Yoga 7i.
9345                          { 0x20, AC_VERB_SET_COEF_INDEX, 0x24 },
9346                          { 0x20, AC_VERB_SET_PROC_COEF, 0x46 },
9347
9348                          { 0x20, AC_VERB_SET_COEF_INDEX, 0x26 },
9349                          { 0x20, AC_VERB_SET_PROC_COEF, 0xc },
9350                          { 0x20, AC_VERB_SET_PROC_COEF, 0x0 },
9351                          { 0x20, AC_VERB_SET_PROC_COEF, 0x2a },
9352                          { 0x20, AC_VERB_SET_PROC_COEF, 0xb020 },
9353
9354                          { 0x20, AC_VERB_SET_COEF_INDEX, 0x26 },
9355                          { 0x20, AC_VERB_SET_PROC_COEF, 0x2 },
9356                          { 0x20, AC_VERB_SET_PROC_COEF, 0x0 },
9357                          { 0x20, AC_VERB_SET_PROC_COEF, 0x0 },
9358                          { 0x20, AC_VERB_SET_PROC_COEF, 0xb020 },
9359                          {}
9360                 },
9361                 .chained = true,
9362                 .chain_id = ALC269_FIXUP_HEADSET_MODE,
9363         },
9364         [ALC298_FIXUP_LENOVO_C940_DUET7] = {
9365                 .type = HDA_FIXUP_FUNC,
9366                 .v.func = alc298_fixup_lenovo_c940_duet7,
9367         },
9368         [ALC287_FIXUP_LENOVO_14IRP8_DUETITL] = {
9369                 .type = HDA_FIXUP_FUNC,
9370                 .v.func = alc287_fixup_lenovo_14irp8_duetitl,
9371         },
9372         [ALC287_FIXUP_13S_GEN2_SPEAKERS] = {
9373                 .type = HDA_FIXUP_VERBS,
9374                 .v.verbs = (const struct hda_verb[]) {
9375                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x24 },
9376                         { 0x20, AC_VERB_SET_PROC_COEF, 0x41 },
9377                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x26 },
9378                         { 0x20, AC_VERB_SET_PROC_COEF, 0x2 },
9379                         { 0x20, AC_VERB_SET_PROC_COEF, 0x0 },
9380                         { 0x20, AC_VERB_SET_PROC_COEF, 0x0 },
9381                         { 0x20, AC_VERB_SET_PROC_COEF, 0xb020 },
9382                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x24 },
9383                         { 0x20, AC_VERB_SET_PROC_COEF, 0x42 },
9384                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x26 },
9385                         { 0x20, AC_VERB_SET_PROC_COEF, 0x2 },
9386                         { 0x20, AC_VERB_SET_PROC_COEF, 0x0 },
9387                         { 0x20, AC_VERB_SET_PROC_COEF, 0x0 },
9388                         { 0x20, AC_VERB_SET_PROC_COEF, 0xb020 },
9389                         {}
9390                 },
9391                 .chained = true,
9392                 .chain_id = ALC269_FIXUP_HEADSET_MODE,
9393         },
9394         [ALC256_FIXUP_SET_COEF_DEFAULTS] = {
9395                 .type = HDA_FIXUP_FUNC,
9396                 .v.func = alc256_fixup_set_coef_defaults,
9397         },
9398         [ALC245_FIXUP_HP_GPIO_LED] = {
9399                 .type = HDA_FIXUP_FUNC,
9400                 .v.func = alc245_fixup_hp_gpio_led,
9401         },
9402         [ALC256_FIXUP_SYSTEM76_MIC_NO_PRESENCE] = {
9403                 .type = HDA_FIXUP_PINS,
9404                 .v.pins = (const struct hda_pintbl[]) {
9405                         { 0x19, 0x03a11120 }, /* use as headset mic, without its own jack detect */
9406                         { }
9407                 },
9408                 .chained = true,
9409                 .chain_id = ALC269_FIXUP_HEADSET_MODE_NO_HP_MIC,
9410         },
9411         [ALC233_FIXUP_NO_AUDIO_JACK] = {
9412                 .type = HDA_FIXUP_FUNC,
9413                 .v.func = alc233_fixup_no_audio_jack,
9414         },
9415         [ALC256_FIXUP_MIC_NO_PRESENCE_AND_RESUME] = {
9416                 .type = HDA_FIXUP_FUNC,
9417                 .v.func = alc256_fixup_mic_no_presence_and_resume,
9418                 .chained = true,
9419                 .chain_id = ALC269_FIXUP_HEADSET_MODE_NO_HP_MIC
9420         },
9421         [ALC287_FIXUP_LEGION_16ACHG6] = {
9422                 .type = HDA_FIXUP_FUNC,
9423                 .v.func = alc287_fixup_legion_16achg6_speakers,
9424         },
9425         [ALC287_FIXUP_CS35L41_I2C_2] = {
9426                 .type = HDA_FIXUP_FUNC,
9427                 .v.func = cs35l41_fixup_i2c_two,
9428         },
9429         [ALC287_FIXUP_CS35L41_I2C_2_HP_GPIO_LED] = {
9430                 .type = HDA_FIXUP_FUNC,
9431                 .v.func = cs35l41_fixup_i2c_two,
9432                 .chained = true,
9433                 .chain_id = ALC285_FIXUP_HP_MUTE_LED,
9434         },
9435         [ALC287_FIXUP_CS35L41_I2C_4] = {
9436                 .type = HDA_FIXUP_FUNC,
9437                 .v.func = cs35l41_fixup_i2c_four,
9438         },
9439         [ALC245_FIXUP_CS35L41_SPI_2] = {
9440                 .type = HDA_FIXUP_FUNC,
9441                 .v.func = cs35l41_fixup_spi_two,
9442         },
9443         [ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED] = {
9444                 .type = HDA_FIXUP_FUNC,
9445                 .v.func = cs35l41_fixup_spi_two,
9446                 .chained = true,
9447                 .chain_id = ALC285_FIXUP_HP_GPIO_LED,
9448         },
9449         [ALC245_FIXUP_CS35L41_SPI_4] = {
9450                 .type = HDA_FIXUP_FUNC,
9451                 .v.func = cs35l41_fixup_spi_four,
9452         },
9453         [ALC245_FIXUP_CS35L41_SPI_4_HP_GPIO_LED] = {
9454                 .type = HDA_FIXUP_FUNC,
9455                 .v.func = cs35l41_fixup_spi_four,
9456                 .chained = true,
9457                 .chain_id = ALC285_FIXUP_HP_GPIO_LED,
9458         },
9459         [ALC285_FIXUP_HP_SPEAKERS_MICMUTE_LED] = {
9460                 .type = HDA_FIXUP_VERBS,
9461                 .v.verbs = (const struct hda_verb[]) {
9462                          { 0x20, AC_VERB_SET_COEF_INDEX, 0x19 },
9463                          { 0x20, AC_VERB_SET_PROC_COEF, 0x8e11 },
9464                          { }
9465                 },
9466                 .chained = true,
9467                 .chain_id = ALC285_FIXUP_HP_MUTE_LED,
9468         },
9469         [ALC269_FIXUP_DELL4_MIC_NO_PRESENCE_QUIET] = {
9470                 .type = HDA_FIXUP_FUNC,
9471                 .v.func = alc_fixup_dell4_mic_no_presence_quiet,
9472                 .chained = true,
9473                 .chain_id = ALC269_FIXUP_DELL4_MIC_NO_PRESENCE,
9474         },
9475         [ALC295_FIXUP_FRAMEWORK_LAPTOP_MIC_NO_PRESENCE] = {
9476                 .type = HDA_FIXUP_PINS,
9477                 .v.pins = (const struct hda_pintbl[]) {
9478                         { 0x19, 0x02a1112c }, /* use as headset mic, without its own jack detect */
9479                         { }
9480                 },
9481                 .chained = true,
9482                 .chain_id = ALC269_FIXUP_HEADSET_MODE_NO_HP_MIC
9483         },
9484         [ALC287_FIXUP_LEGION_16ITHG6] = {
9485                 .type = HDA_FIXUP_FUNC,
9486                 .v.func = alc287_fixup_legion_16ithg6_speakers,
9487         },
9488         [ALC287_FIXUP_YOGA9_14IAP7_BASS_SPK] = {
9489                 .type = HDA_FIXUP_VERBS,
9490                 .v.verbs = (const struct hda_verb[]) {
9491                         // enable left speaker
9492                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x24 },
9493                         { 0x20, AC_VERB_SET_PROC_COEF, 0x41 },
9494
9495                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x26 },
9496                         { 0x20, AC_VERB_SET_PROC_COEF, 0xc },
9497                         { 0x20, AC_VERB_SET_PROC_COEF, 0x0 },
9498                         { 0x20, AC_VERB_SET_PROC_COEF, 0x1a },
9499                         { 0x20, AC_VERB_SET_PROC_COEF, 0xb020 },
9500
9501                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x26 },
9502                         { 0x20, AC_VERB_SET_PROC_COEF, 0xf },
9503                         { 0x20, AC_VERB_SET_PROC_COEF, 0x0 },
9504                         { 0x20, AC_VERB_SET_PROC_COEF, 0x42 },
9505                         { 0x20, AC_VERB_SET_PROC_COEF, 0xb020 },
9506
9507                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x26 },
9508                         { 0x20, AC_VERB_SET_PROC_COEF, 0x10 },
9509                         { 0x20, AC_VERB_SET_PROC_COEF, 0x0 },
9510                         { 0x20, AC_VERB_SET_PROC_COEF, 0x40 },
9511                         { 0x20, AC_VERB_SET_PROC_COEF, 0xb020 },
9512
9513                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x26 },
9514                         { 0x20, AC_VERB_SET_PROC_COEF, 0x2 },
9515                         { 0x20, AC_VERB_SET_PROC_COEF, 0x0 },
9516                         { 0x20, AC_VERB_SET_PROC_COEF, 0x0 },
9517                         { 0x20, AC_VERB_SET_PROC_COEF, 0xb020 },
9518
9519                         // enable right speaker
9520                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x24 },
9521                         { 0x20, AC_VERB_SET_PROC_COEF, 0x46 },
9522
9523                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x26 },
9524                         { 0x20, AC_VERB_SET_PROC_COEF, 0xc },
9525                         { 0x20, AC_VERB_SET_PROC_COEF, 0x0 },
9526                         { 0x20, AC_VERB_SET_PROC_COEF, 0x2a },
9527                         { 0x20, AC_VERB_SET_PROC_COEF, 0xb020 },
9528
9529                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x26 },
9530                         { 0x20, AC_VERB_SET_PROC_COEF, 0xf },
9531                         { 0x20, AC_VERB_SET_PROC_COEF, 0x0 },
9532                         { 0x20, AC_VERB_SET_PROC_COEF, 0x46 },
9533                         { 0x20, AC_VERB_SET_PROC_COEF, 0xb020 },
9534
9535                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x26 },
9536                         { 0x20, AC_VERB_SET_PROC_COEF, 0x10 },
9537                         { 0x20, AC_VERB_SET_PROC_COEF, 0x0 },
9538                         { 0x20, AC_VERB_SET_PROC_COEF, 0x44 },
9539                         { 0x20, AC_VERB_SET_PROC_COEF, 0xb020 },
9540
9541                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x26 },
9542                         { 0x20, AC_VERB_SET_PROC_COEF, 0x2 },
9543                         { 0x20, AC_VERB_SET_PROC_COEF, 0x0 },
9544                         { 0x20, AC_VERB_SET_PROC_COEF, 0x0 },
9545                         { 0x20, AC_VERB_SET_PROC_COEF, 0xb020 },
9546
9547                         { },
9548                 },
9549         },
9550         [ALC287_FIXUP_YOGA9_14IAP7_BASS_SPK_PIN] = {
9551                 .type = HDA_FIXUP_FUNC,
9552                 .v.func = alc287_fixup_yoga9_14iap7_bass_spk_pin,
9553                 .chained = true,
9554                 .chain_id = ALC287_FIXUP_YOGA9_14IAP7_BASS_SPK,
9555         },
9556         [ALC287_FIXUP_YOGA9_14IMH9_BASS_SPK_PIN] = {
9557                 .type = HDA_FIXUP_FUNC,
9558                 .v.func = alc287_fixup_yoga9_14iap7_bass_spk_pin,
9559                 .chained = true,
9560                 .chain_id = ALC287_FIXUP_CS35L41_I2C_2,
9561         },
9562         [ALC295_FIXUP_DELL_INSPIRON_TOP_SPEAKERS] = {
9563                 .type = HDA_FIXUP_FUNC,
9564                 .v.func = alc295_fixup_dell_inspiron_top_speakers,
9565                 .chained = true,
9566                 .chain_id = ALC269_FIXUP_DELL4_MIC_NO_PRESENCE,
9567         },
9568         [ALC236_FIXUP_DELL_DUAL_CODECS] = {
9569                 .type = HDA_FIXUP_PINS,
9570                 .v.func = alc1220_fixup_gb_dual_codecs,
9571                 .chained = true,
9572                 .chain_id = ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
9573         },
9574         [ALC287_FIXUP_CS35L41_I2C_2_THINKPAD_ACPI] = {
9575                 .type = HDA_FIXUP_FUNC,
9576                 .v.func = cs35l41_fixup_i2c_two,
9577                 .chained = true,
9578                 .chain_id = ALC285_FIXUP_THINKPAD_NO_BASS_SPK_HEADSET_JACK,
9579         },
9580         [ALC287_FIXUP_TAS2781_I2C] = {
9581                 .type = HDA_FIXUP_FUNC,
9582                 .v.func = tas2781_fixup_i2c,
9583                 .chained = true,
9584                 .chain_id = ALC285_FIXUP_THINKPAD_HEADSET_JACK,
9585         },
9586         [ALC287_FIXUP_YOGA7_14ARB7_I2C] = {
9587                 .type = HDA_FIXUP_FUNC,
9588                 .v.func = yoga7_14arb7_fixup_i2c,
9589                 .chained = true,
9590                 .chain_id = ALC285_FIXUP_THINKPAD_HEADSET_JACK,
9591         },
9592         [ALC245_FIXUP_HP_MUTE_LED_COEFBIT] = {
9593                 .type = HDA_FIXUP_FUNC,
9594                 .v.func = alc245_fixup_hp_mute_led_coefbit,
9595         },
9596         [ALC245_FIXUP_HP_X360_MUTE_LEDS] = {
9597                 .type = HDA_FIXUP_FUNC,
9598                 .v.func = alc245_fixup_hp_mute_led_coefbit,
9599                 .chained = true,
9600                 .chain_id = ALC245_FIXUP_HP_GPIO_LED
9601         },
9602         [ALC287_FIXUP_THINKPAD_I2S_SPK] = {
9603                 .type = HDA_FIXUP_FUNC,
9604                 .v.func = alc287_fixup_bind_dacs,
9605                 .chained = true,
9606                 .chain_id = ALC285_FIXUP_THINKPAD_NO_BASS_SPK_HEADSET_JACK,
9607         },
9608         [ALC287_FIXUP_MG_RTKC_CSAMP_CS35L41_I2C_THINKPAD] = {
9609                 .type = HDA_FIXUP_FUNC,
9610                 .v.func = alc287_fixup_bind_dacs,
9611                 .chained = true,
9612                 .chain_id = ALC287_FIXUP_CS35L41_I2C_2_THINKPAD_ACPI,
9613         },
9614         [ALC2XX_FIXUP_HEADSET_MIC] = {
9615                 .type = HDA_FIXUP_FUNC,
9616                 .v.func = alc_fixup_headset_mic,
9617         },
9618         [ALC289_FIXUP_DELL_CS35L41_SPI_2] = {
9619                 .type = HDA_FIXUP_FUNC,
9620                 .v.func = cs35l41_fixup_spi_two,
9621                 .chained = true,
9622                 .chain_id = ALC289_FIXUP_DUAL_SPK
9623         },
9624         [ALC294_FIXUP_CS35L41_I2C_2] = {
9625                 .type = HDA_FIXUP_FUNC,
9626                 .v.func = cs35l41_fixup_i2c_two,
9627         },
9628         [ALC245_FIXUP_CS35L56_SPI_4_HP_GPIO_LED] = {
9629                 .type = HDA_FIXUP_FUNC,
9630                 .v.func = cs35l56_fixup_spi_four,
9631                 .chained = true,
9632                 .chain_id = ALC285_FIXUP_HP_GPIO_LED,
9633         },
9634         [ALC256_FIXUP_ACER_SFG16_MICMUTE_LED] = {
9635                 .type = HDA_FIXUP_FUNC,
9636                 .v.func = alc256_fixup_acer_sfg16_micmute_led,
9637         },
9638         [ALC256_FIXUP_HEADPHONE_AMP_VOL] = {
9639                 .type = HDA_FIXUP_FUNC,
9640                 .v.func = alc256_decrease_headphone_amp_val,
9641         },
9642         [ALC245_FIXUP_HP_SPECTRE_X360_EU0XXX] = {
9643                 .type = HDA_FIXUP_FUNC,
9644                 .v.func = alc245_fixup_hp_spectre_x360_eu0xxx,
9645         },
9646 };
9647
9648 static const struct snd_pci_quirk alc269_fixup_tbl[] = {
9649         SND_PCI_QUIRK(0x1025, 0x0283, "Acer TravelMate 8371", ALC269_FIXUP_INV_DMIC),
9650         SND_PCI_QUIRK(0x1025, 0x029b, "Acer 1810TZ", ALC269_FIXUP_INV_DMIC),
9651         SND_PCI_QUIRK(0x1025, 0x0349, "Acer AOD260", ALC269_FIXUP_INV_DMIC),
9652         SND_PCI_QUIRK(0x1025, 0x047c, "Acer AC700", ALC269_FIXUP_ACER_AC700),
9653         SND_PCI_QUIRK(0x1025, 0x072d, "Acer Aspire V5-571G", ALC269_FIXUP_ASPIRE_HEADSET_MIC),
9654         SND_PCI_QUIRK(0x1025, 0x0740, "Acer AO725", ALC271_FIXUP_HP_GATE_MIC_JACK),
9655         SND_PCI_QUIRK(0x1025, 0x0742, "Acer AO756", ALC271_FIXUP_HP_GATE_MIC_JACK),
9656         SND_PCI_QUIRK(0x1025, 0x0762, "Acer Aspire E1-472", ALC271_FIXUP_HP_GATE_MIC_JACK_E1_572),
9657         SND_PCI_QUIRK(0x1025, 0x0775, "Acer Aspire E1-572", ALC271_FIXUP_HP_GATE_MIC_JACK_E1_572),
9658         SND_PCI_QUIRK(0x1025, 0x079b, "Acer Aspire V5-573G", ALC282_FIXUP_ASPIRE_V5_PINS),
9659         SND_PCI_QUIRK(0x1025, 0x080d, "Acer Aspire V5-122P", ALC269_FIXUP_ASPIRE_HEADSET_MIC),
9660         SND_PCI_QUIRK(0x1025, 0x0840, "Acer Aspire E1", ALC269VB_FIXUP_ASPIRE_E1_COEF),
9661         SND_PCI_QUIRK(0x1025, 0x101c, "Acer Veriton N2510G", ALC269_FIXUP_LIFEBOOK),
9662         SND_PCI_QUIRK(0x1025, 0x102b, "Acer Aspire C24-860", ALC286_FIXUP_ACER_AIO_MIC_NO_PRESENCE),
9663         SND_PCI_QUIRK(0x1025, 0x1065, "Acer Aspire C20-820", ALC269VC_FIXUP_ACER_HEADSET_MIC),
9664         SND_PCI_QUIRK(0x1025, 0x106d, "Acer Cloudbook 14", ALC283_FIXUP_CHROME_BOOK),
9665         SND_PCI_QUIRK(0x1025, 0x1094, "Acer Aspire E5-575T", ALC255_FIXUP_ACER_LIMIT_INT_MIC_BOOST),
9666         SND_PCI_QUIRK(0x1025, 0x1099, "Acer Aspire E5-523G", ALC255_FIXUP_ACER_MIC_NO_PRESENCE),
9667         SND_PCI_QUIRK(0x1025, 0x110e, "Acer Aspire ES1-432", ALC255_FIXUP_ACER_MIC_NO_PRESENCE),
9668         SND_PCI_QUIRK(0x1025, 0x1166, "Acer Veriton N4640G", ALC269_FIXUP_LIFEBOOK),
9669         SND_PCI_QUIRK(0x1025, 0x1167, "Acer Veriton N6640G", ALC269_FIXUP_LIFEBOOK),
9670         SND_PCI_QUIRK(0x1025, 0x1246, "Acer Predator Helios 500", ALC299_FIXUP_PREDATOR_SPK),
9671         SND_PCI_QUIRK(0x1025, 0x1247, "Acer vCopperbox", ALC269VC_FIXUP_ACER_VCOPPERBOX_PINS),
9672         SND_PCI_QUIRK(0x1025, 0x1248, "Acer Veriton N4660G", ALC269VC_FIXUP_ACER_MIC_NO_PRESENCE),
9673         SND_PCI_QUIRK(0x1025, 0x1269, "Acer SWIFT SF314-54", ALC256_FIXUP_ACER_HEADSET_MIC),
9674         SND_PCI_QUIRK(0x1025, 0x126a, "Acer Swift SF114-32", ALC256_FIXUP_ACER_MIC_NO_PRESENCE),
9675         SND_PCI_QUIRK(0x1025, 0x128f, "Acer Veriton Z6860G", ALC286_FIXUP_ACER_AIO_HEADSET_MIC),
9676         SND_PCI_QUIRK(0x1025, 0x1290, "Acer Veriton Z4860G", ALC286_FIXUP_ACER_AIO_HEADSET_MIC),
9677         SND_PCI_QUIRK(0x1025, 0x1291, "Acer Veriton Z4660G", ALC286_FIXUP_ACER_AIO_HEADSET_MIC),
9678         SND_PCI_QUIRK(0x1025, 0x129c, "Acer SWIFT SF314-55", ALC256_FIXUP_ACER_HEADSET_MIC),
9679         SND_PCI_QUIRK(0x1025, 0x129d, "Acer SWIFT SF313-51", ALC256_FIXUP_ACER_MIC_NO_PRESENCE),
9680         SND_PCI_QUIRK(0x1025, 0x1300, "Acer SWIFT SF314-56", ALC256_FIXUP_ACER_MIC_NO_PRESENCE),
9681         SND_PCI_QUIRK(0x1025, 0x1308, "Acer Aspire Z24-890", ALC286_FIXUP_ACER_AIO_HEADSET_MIC),
9682         SND_PCI_QUIRK(0x1025, 0x132a, "Acer TravelMate B114-21", ALC233_FIXUP_ACER_HEADSET_MIC),
9683         SND_PCI_QUIRK(0x1025, 0x1330, "Acer TravelMate X514-51T", ALC255_FIXUP_ACER_HEADSET_MIC),
9684         SND_PCI_QUIRK(0x1025, 0x141f, "Acer Spin SP513-54N", ALC255_FIXUP_ACER_MIC_NO_PRESENCE),
9685         SND_PCI_QUIRK(0x1025, 0x142b, "Acer Swift SF314-42", ALC255_FIXUP_ACER_MIC_NO_PRESENCE),
9686         SND_PCI_QUIRK(0x1025, 0x1430, "Acer TravelMate B311R-31", ALC256_FIXUP_ACER_MIC_NO_PRESENCE),
9687         SND_PCI_QUIRK(0x1025, 0x1466, "Acer Aspire A515-56", ALC255_FIXUP_ACER_HEADPHONE_AND_MIC),
9688         SND_PCI_QUIRK(0x1025, 0x1534, "Acer Predator PH315-54", ALC255_FIXUP_ACER_MIC_NO_PRESENCE),
9689         SND_PCI_QUIRK(0x1025, 0x169a, "Acer Swift SFG16", ALC256_FIXUP_ACER_SFG16_MICMUTE_LED),
9690         SND_PCI_QUIRK(0x1028, 0x0470, "Dell M101z", ALC269_FIXUP_DELL_M101Z),
9691         SND_PCI_QUIRK(0x1028, 0x053c, "Dell Latitude E5430", ALC292_FIXUP_DELL_E7X),
9692         SND_PCI_QUIRK(0x1028, 0x054b, "Dell XPS one 2710", ALC275_FIXUP_DELL_XPS),
9693         SND_PCI_QUIRK(0x1028, 0x05bd, "Dell Latitude E6440", ALC292_FIXUP_DELL_E7X),
9694         SND_PCI_QUIRK(0x1028, 0x05be, "Dell Latitude E6540", ALC292_FIXUP_DELL_E7X),
9695         SND_PCI_QUIRK(0x1028, 0x05ca, "Dell Latitude E7240", ALC292_FIXUP_DELL_E7X),
9696         SND_PCI_QUIRK(0x1028, 0x05cb, "Dell Latitude E7440", ALC292_FIXUP_DELL_E7X),
9697         SND_PCI_QUIRK(0x1028, 0x05da, "Dell Vostro 5460", ALC290_FIXUP_SUBWOOFER),
9698         SND_PCI_QUIRK(0x1028, 0x05f4, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE),
9699         SND_PCI_QUIRK(0x1028, 0x05f5, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE),
9700         SND_PCI_QUIRK(0x1028, 0x05f6, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE),
9701         SND_PCI_QUIRK(0x1028, 0x0615, "Dell Vostro 5470", ALC290_FIXUP_SUBWOOFER_HSJACK),
9702         SND_PCI_QUIRK(0x1028, 0x0616, "Dell Vostro 5470", ALC290_FIXUP_SUBWOOFER_HSJACK),
9703         SND_PCI_QUIRK(0x1028, 0x062c, "Dell Latitude E5550", ALC292_FIXUP_DELL_E7X),
9704         SND_PCI_QUIRK(0x1028, 0x062e, "Dell Latitude E7450", ALC292_FIXUP_DELL_E7X),
9705         SND_PCI_QUIRK(0x1028, 0x0638, "Dell Inspiron 5439", ALC290_FIXUP_MONO_SPEAKERS_HSJACK),
9706         SND_PCI_QUIRK(0x1028, 0x064a, "Dell", ALC293_FIXUP_DELL1_MIC_NO_PRESENCE),
9707         SND_PCI_QUIRK(0x1028, 0x064b, "Dell", ALC293_FIXUP_DELL1_MIC_NO_PRESENCE),
9708         SND_PCI_QUIRK(0x1028, 0x0665, "Dell XPS 13", ALC288_FIXUP_DELL_XPS_13),
9709         SND_PCI_QUIRK(0x1028, 0x0669, "Dell Optiplex 9020m", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE),
9710         SND_PCI_QUIRK(0x1028, 0x069a, "Dell Vostro 5480", ALC290_FIXUP_SUBWOOFER_HSJACK),
9711         SND_PCI_QUIRK(0x1028, 0x06c7, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE),
9712         SND_PCI_QUIRK(0x1028, 0x06d9, "Dell", ALC293_FIXUP_DELL1_MIC_NO_PRESENCE),
9713         SND_PCI_QUIRK(0x1028, 0x06da, "Dell", ALC293_FIXUP_DELL1_MIC_NO_PRESENCE),
9714         SND_PCI_QUIRK(0x1028, 0x06db, "Dell", ALC293_FIXUP_DISABLE_AAMIX_MULTIJACK),
9715         SND_PCI_QUIRK(0x1028, 0x06dd, "Dell", ALC293_FIXUP_DISABLE_AAMIX_MULTIJACK),
9716         SND_PCI_QUIRK(0x1028, 0x06de, "Dell", ALC293_FIXUP_DISABLE_AAMIX_MULTIJACK),
9717         SND_PCI_QUIRK(0x1028, 0x06df, "Dell", ALC293_FIXUP_DISABLE_AAMIX_MULTIJACK),
9718         SND_PCI_QUIRK(0x1028, 0x06e0, "Dell", ALC293_FIXUP_DISABLE_AAMIX_MULTIJACK),
9719         SND_PCI_QUIRK(0x1028, 0x0706, "Dell Inspiron 7559", ALC256_FIXUP_DELL_INSPIRON_7559_SUBWOOFER),
9720         SND_PCI_QUIRK(0x1028, 0x0725, "Dell Inspiron 3162", ALC255_FIXUP_DELL_SPK_NOISE),
9721         SND_PCI_QUIRK(0x1028, 0x0738, "Dell Precision 5820", ALC269_FIXUP_NO_SHUTUP),
9722         SND_PCI_QUIRK(0x1028, 0x075c, "Dell XPS 27 7760", ALC298_FIXUP_SPK_VOLUME),
9723         SND_PCI_QUIRK(0x1028, 0x075d, "Dell AIO", ALC298_FIXUP_SPK_VOLUME),
9724         SND_PCI_QUIRK(0x1028, 0x0798, "Dell Inspiron 17 7000 Gaming", ALC256_FIXUP_DELL_INSPIRON_7559_SUBWOOFER),
9725         SND_PCI_QUIRK(0x1028, 0x07b0, "Dell Precision 7520", ALC295_FIXUP_DISABLE_DAC3),
9726         SND_PCI_QUIRK(0x1028, 0x080c, "Dell WYSE", ALC225_FIXUP_DELL_WYSE_MIC_NO_PRESENCE),
9727         SND_PCI_QUIRK(0x1028, 0x084b, "Dell", ALC274_FIXUP_DELL_AIO_LINEOUT_VERB),
9728         SND_PCI_QUIRK(0x1028, 0x084e, "Dell", ALC274_FIXUP_DELL_AIO_LINEOUT_VERB),
9729         SND_PCI_QUIRK(0x1028, 0x0871, "Dell Precision 3630", ALC255_FIXUP_DELL_HEADSET_MIC),
9730         SND_PCI_QUIRK(0x1028, 0x0872, "Dell Precision 3630", ALC255_FIXUP_DELL_HEADSET_MIC),
9731         SND_PCI_QUIRK(0x1028, 0x0873, "Dell Precision 3930", ALC255_FIXUP_DUMMY_LINEOUT_VERB),
9732         SND_PCI_QUIRK(0x1028, 0x08ad, "Dell WYSE AIO", ALC225_FIXUP_DELL_WYSE_AIO_MIC_NO_PRESENCE),
9733         SND_PCI_QUIRK(0x1028, 0x08ae, "Dell WYSE NB", ALC225_FIXUP_DELL1_MIC_NO_PRESENCE),
9734         SND_PCI_QUIRK(0x1028, 0x0935, "Dell", ALC274_FIXUP_DELL_AIO_LINEOUT_VERB),
9735         SND_PCI_QUIRK(0x1028, 0x097d, "Dell Precision", ALC289_FIXUP_DUAL_SPK),
9736         SND_PCI_QUIRK(0x1028, 0x097e, "Dell Precision", ALC289_FIXUP_DUAL_SPK),
9737         SND_PCI_QUIRK(0x1028, 0x098d, "Dell Precision", ALC233_FIXUP_ASUS_MIC_NO_PRESENCE),
9738         SND_PCI_QUIRK(0x1028, 0x09bf, "Dell Precision", ALC233_FIXUP_ASUS_MIC_NO_PRESENCE),
9739         SND_PCI_QUIRK(0x1028, 0x0a2e, "Dell", ALC236_FIXUP_DELL_AIO_HEADSET_MIC),
9740         SND_PCI_QUIRK(0x1028, 0x0a30, "Dell", ALC236_FIXUP_DELL_AIO_HEADSET_MIC),
9741         SND_PCI_QUIRK(0x1028, 0x0a38, "Dell Latitude 7520", ALC269_FIXUP_DELL4_MIC_NO_PRESENCE_QUIET),
9742         SND_PCI_QUIRK(0x1028, 0x0a58, "Dell", ALC255_FIXUP_DELL_HEADSET_MIC),
9743         SND_PCI_QUIRK(0x1028, 0x0a61, "Dell XPS 15 9510", ALC289_FIXUP_DUAL_SPK),
9744         SND_PCI_QUIRK(0x1028, 0x0a62, "Dell Precision 5560", ALC289_FIXUP_DUAL_SPK),
9745         SND_PCI_QUIRK(0x1028, 0x0a9d, "Dell Latitude 5430", ALC269_FIXUP_DELL4_MIC_NO_PRESENCE),
9746         SND_PCI_QUIRK(0x1028, 0x0a9e, "Dell Latitude 5430", ALC269_FIXUP_DELL4_MIC_NO_PRESENCE),
9747         SND_PCI_QUIRK(0x1028, 0x0b19, "Dell XPS 15 9520", ALC289_FIXUP_DUAL_SPK),
9748         SND_PCI_QUIRK(0x1028, 0x0b1a, "Dell Precision 5570", ALC289_FIXUP_DUAL_SPK),
9749         SND_PCI_QUIRK(0x1028, 0x0b27, "Dell", ALC245_FIXUP_CS35L41_SPI_2),
9750         SND_PCI_QUIRK(0x1028, 0x0b28, "Dell", ALC245_FIXUP_CS35L41_SPI_2),
9751         SND_PCI_QUIRK(0x1028, 0x0b37, "Dell Inspiron 16 Plus 7620 2-in-1", ALC295_FIXUP_DELL_INSPIRON_TOP_SPEAKERS),
9752         SND_PCI_QUIRK(0x1028, 0x0b71, "Dell Inspiron 16 Plus 7620", ALC295_FIXUP_DELL_INSPIRON_TOP_SPEAKERS),
9753         SND_PCI_QUIRK(0x1028, 0x0beb, "Dell XPS 15 9530 (2023)", ALC289_FIXUP_DELL_CS35L41_SPI_2),
9754         SND_PCI_QUIRK(0x1028, 0x0c03, "Dell Precision 5340", ALC269_FIXUP_DELL4_MIC_NO_PRESENCE),
9755         SND_PCI_QUIRK(0x1028, 0x0c0b, "Dell Oasis 14 RPL-P", ALC289_FIXUP_RTK_AMP_DUAL_SPK),
9756         SND_PCI_QUIRK(0x1028, 0x0c0d, "Dell Oasis", ALC289_FIXUP_RTK_AMP_DUAL_SPK),
9757         SND_PCI_QUIRK(0x1028, 0x0c0e, "Dell Oasis 16", ALC289_FIXUP_RTK_AMP_DUAL_SPK),
9758         SND_PCI_QUIRK(0x1028, 0x0c19, "Dell Precision 3340", ALC236_FIXUP_DELL_DUAL_CODECS),
9759         SND_PCI_QUIRK(0x1028, 0x0c1a, "Dell Precision 3340", ALC236_FIXUP_DELL_DUAL_CODECS),
9760         SND_PCI_QUIRK(0x1028, 0x0c1b, "Dell Precision 3440", ALC236_FIXUP_DELL_DUAL_CODECS),
9761         SND_PCI_QUIRK(0x1028, 0x0c1c, "Dell Precision 3540", ALC236_FIXUP_DELL_DUAL_CODECS),
9762         SND_PCI_QUIRK(0x1028, 0x0c1d, "Dell Precision 3440", ALC236_FIXUP_DELL_DUAL_CODECS),
9763         SND_PCI_QUIRK(0x1028, 0x0c1e, "Dell Precision 3540", ALC236_FIXUP_DELL_DUAL_CODECS),
9764         SND_PCI_QUIRK(0x1028, 0x0c28, "Dell Inspiron 16 Plus 7630", ALC295_FIXUP_DELL_INSPIRON_TOP_SPEAKERS),
9765         SND_PCI_QUIRK(0x1028, 0x0c4d, "Dell", ALC287_FIXUP_CS35L41_I2C_4),
9766         SND_PCI_QUIRK(0x1028, 0x0cbd, "Dell Oasis 13 CS MTL-U", ALC289_FIXUP_DELL_CS35L41_SPI_2),
9767         SND_PCI_QUIRK(0x1028, 0x0cbe, "Dell Oasis 13 2-IN-1 MTL-U", ALC289_FIXUP_DELL_CS35L41_SPI_2),
9768         SND_PCI_QUIRK(0x1028, 0x0cbf, "Dell Oasis 13 Low Weight MTU-L", ALC289_FIXUP_DELL_CS35L41_SPI_2),
9769         SND_PCI_QUIRK(0x1028, 0x0cc0, "Dell Oasis 13", ALC289_FIXUP_RTK_AMP_DUAL_SPK),
9770         SND_PCI_QUIRK(0x1028, 0x0cc1, "Dell Oasis 14 MTL-H/U", ALC289_FIXUP_DELL_CS35L41_SPI_2),
9771         SND_PCI_QUIRK(0x1028, 0x0cc2, "Dell Oasis 14 2-in-1 MTL-H/U", ALC289_FIXUP_DELL_CS35L41_SPI_2),
9772         SND_PCI_QUIRK(0x1028, 0x0cc3, "Dell Oasis 14 Low Weight MTL-U", ALC289_FIXUP_DELL_CS35L41_SPI_2),
9773         SND_PCI_QUIRK(0x1028, 0x0cc4, "Dell Oasis 16 MTL-H/U", ALC289_FIXUP_DELL_CS35L41_SPI_2),
9774         SND_PCI_QUIRK(0x1028, 0x0cc5, "Dell Oasis 14", ALC289_FIXUP_RTK_AMP_DUAL_SPK),
9775         SND_PCI_QUIRK(0x1028, 0x164a, "Dell", ALC293_FIXUP_DELL1_MIC_NO_PRESENCE),
9776         SND_PCI_QUIRK(0x1028, 0x164b, "Dell", ALC293_FIXUP_DELL1_MIC_NO_PRESENCE),
9777         SND_PCI_QUIRK(0x103c, 0x1586, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC2),
9778         SND_PCI_QUIRK(0x103c, 0x18e6, "HP", ALC269_FIXUP_HP_GPIO_LED),
9779         SND_PCI_QUIRK(0x103c, 0x218b, "HP", ALC269_FIXUP_LIMIT_INT_MIC_BOOST_MUTE_LED),
9780         SND_PCI_QUIRK(0x103c, 0x21f9, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
9781         SND_PCI_QUIRK(0x103c, 0x2210, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
9782         SND_PCI_QUIRK(0x103c, 0x2214, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
9783         SND_PCI_QUIRK(0x103c, 0x221b, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),
9784         SND_PCI_QUIRK(0x103c, 0x221c, "HP EliteBook 755 G2", ALC280_FIXUP_HP_HEADSET_MIC),
9785         SND_PCI_QUIRK(0x103c, 0x2221, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),
9786         SND_PCI_QUIRK(0x103c, 0x2225, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),
9787         SND_PCI_QUIRK(0x103c, 0x2236, "HP", ALC269_FIXUP_HP_LINE1_MIC1_LED),
9788         SND_PCI_QUIRK(0x103c, 0x2237, "HP", ALC269_FIXUP_HP_LINE1_MIC1_LED),
9789         SND_PCI_QUIRK(0x103c, 0x2238, "HP", ALC269_FIXUP_HP_LINE1_MIC1_LED),
9790         SND_PCI_QUIRK(0x103c, 0x2239, "HP", ALC269_FIXUP_HP_LINE1_MIC1_LED),
9791         SND_PCI_QUIRK(0x103c, 0x224b, "HP", ALC269_FIXUP_HP_LINE1_MIC1_LED),
9792         SND_PCI_QUIRK(0x103c, 0x2253, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),
9793         SND_PCI_QUIRK(0x103c, 0x2254, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),
9794         SND_PCI_QUIRK(0x103c, 0x2255, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),
9795         SND_PCI_QUIRK(0x103c, 0x2256, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),
9796         SND_PCI_QUIRK(0x103c, 0x2257, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),
9797         SND_PCI_QUIRK(0x103c, 0x2259, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),
9798         SND_PCI_QUIRK(0x103c, 0x225a, "HP", ALC269_FIXUP_HP_DOCK_GPIO_MIC1_LED),
9799         SND_PCI_QUIRK(0x103c, 0x225f, "HP", ALC280_FIXUP_HP_GPIO2_MIC_HOTKEY),
9800         SND_PCI_QUIRK(0x103c, 0x2260, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
9801         SND_PCI_QUIRK(0x103c, 0x2263, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
9802         SND_PCI_QUIRK(0x103c, 0x2264, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
9803         SND_PCI_QUIRK(0x103c, 0x2265, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
9804         SND_PCI_QUIRK(0x103c, 0x2268, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
9805         SND_PCI_QUIRK(0x103c, 0x226a, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
9806         SND_PCI_QUIRK(0x103c, 0x226b, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
9807         SND_PCI_QUIRK(0x103c, 0x226e, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
9808         SND_PCI_QUIRK(0x103c, 0x2271, "HP", ALC286_FIXUP_HP_GPIO_LED),
9809         SND_PCI_QUIRK(0x103c, 0x2272, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),
9810         SND_PCI_QUIRK(0x103c, 0x2272, "HP", ALC280_FIXUP_HP_DOCK_PINS),
9811         SND_PCI_QUIRK(0x103c, 0x2273, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),
9812         SND_PCI_QUIRK(0x103c, 0x2273, "HP", ALC280_FIXUP_HP_DOCK_PINS),
9813         SND_PCI_QUIRK(0x103c, 0x2278, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),
9814         SND_PCI_QUIRK(0x103c, 0x227f, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
9815         SND_PCI_QUIRK(0x103c, 0x2282, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
9816         SND_PCI_QUIRK(0x103c, 0x228b, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
9817         SND_PCI_QUIRK(0x103c, 0x228e, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
9818         SND_PCI_QUIRK(0x103c, 0x229e, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
9819         SND_PCI_QUIRK(0x103c, 0x22b2, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
9820         SND_PCI_QUIRK(0x103c, 0x22b7, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
9821         SND_PCI_QUIRK(0x103c, 0x22bf, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
9822         SND_PCI_QUIRK(0x103c, 0x22c4, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
9823         SND_PCI_QUIRK(0x103c, 0x22c5, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
9824         SND_PCI_QUIRK(0x103c, 0x22c7, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
9825         SND_PCI_QUIRK(0x103c, 0x22c8, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
9826         SND_PCI_QUIRK(0x103c, 0x22cf, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
9827         SND_PCI_QUIRK(0x103c, 0x22db, "HP", ALC280_FIXUP_HP_9480M),
9828         SND_PCI_QUIRK(0x103c, 0x22dc, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),
9829         SND_PCI_QUIRK(0x103c, 0x22fb, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),
9830         SND_PCI_QUIRK(0x103c, 0x2334, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
9831         SND_PCI_QUIRK(0x103c, 0x2335, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
9832         SND_PCI_QUIRK(0x103c, 0x2336, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
9833         SND_PCI_QUIRK(0x103c, 0x2337, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
9834         SND_PCI_QUIRK(0x103c, 0x2b5e, "HP 288 Pro G2 MT", ALC221_FIXUP_HP_288PRO_MIC_NO_PRESENCE),
9835         SND_PCI_QUIRK(0x103c, 0x802e, "HP Z240 SFF", ALC221_FIXUP_HP_MIC_NO_PRESENCE),
9836         SND_PCI_QUIRK(0x103c, 0x802f, "HP Z240", ALC221_FIXUP_HP_MIC_NO_PRESENCE),
9837         SND_PCI_QUIRK(0x103c, 0x8077, "HP", ALC256_FIXUP_HP_HEADSET_MIC),
9838         SND_PCI_QUIRK(0x103c, 0x8158, "HP", ALC256_FIXUP_HP_HEADSET_MIC),
9839         SND_PCI_QUIRK(0x103c, 0x820d, "HP Pavilion 15", ALC295_FIXUP_HP_X360),
9840         SND_PCI_QUIRK(0x103c, 0x8256, "HP", ALC221_FIXUP_HP_FRONT_MIC),
9841         SND_PCI_QUIRK(0x103c, 0x827e, "HP x360", ALC295_FIXUP_HP_X360),
9842         SND_PCI_QUIRK(0x103c, 0x827f, "HP x360", ALC269_FIXUP_HP_MUTE_LED_MIC3),
9843         SND_PCI_QUIRK(0x103c, 0x82bf, "HP G3 mini", ALC221_FIXUP_HP_MIC_NO_PRESENCE),
9844         SND_PCI_QUIRK(0x103c, 0x82c0, "HP G3 mini premium", ALC221_FIXUP_HP_MIC_NO_PRESENCE),
9845         SND_PCI_QUIRK(0x103c, 0x83b9, "HP Spectre x360", ALC269_FIXUP_HP_MUTE_LED_MIC3),
9846         SND_PCI_QUIRK(0x103c, 0x841c, "HP Pavilion 15-CK0xx", ALC269_FIXUP_HP_MUTE_LED_MIC3),
9847         SND_PCI_QUIRK(0x103c, 0x8497, "HP Envy x360", ALC269_FIXUP_HP_MUTE_LED_MIC3),
9848         SND_PCI_QUIRK(0x103c, 0x84ae, "HP 15-db0403ng", ALC236_FIXUP_HP_MUTE_LED_COEFBIT2),
9849         SND_PCI_QUIRK(0x103c, 0x84da, "HP OMEN dc0019-ur", ALC295_FIXUP_HP_OMEN),
9850         SND_PCI_QUIRK(0x103c, 0x84e7, "HP Pavilion 15", ALC269_FIXUP_HP_MUTE_LED_MIC3),
9851         SND_PCI_QUIRK(0x103c, 0x8519, "HP Spectre x360 15-df0xxx", ALC285_FIXUP_HP_SPECTRE_X360),
9852         SND_PCI_QUIRK(0x103c, 0x8537, "HP ProBook 440 G6", ALC236_FIXUP_HP_MUTE_LED_MICMUTE_VREF),
9853         SND_PCI_QUIRK(0x103c, 0x85de, "HP Envy x360 13-ar0xxx", ALC285_FIXUP_HP_ENVY_X360),
9854         SND_PCI_QUIRK(0x103c, 0x860f, "HP ZBook 15 G6", ALC285_FIXUP_HP_GPIO_AMP_INIT),
9855         SND_PCI_QUIRK(0x103c, 0x861f, "HP Elite Dragonfly G1", ALC285_FIXUP_HP_GPIO_AMP_INIT),
9856         SND_PCI_QUIRK(0x103c, 0x869d, "HP", ALC236_FIXUP_HP_MUTE_LED),
9857         SND_PCI_QUIRK(0x103c, 0x86c7, "HP Envy AiO 32", ALC274_FIXUP_HP_ENVY_GPIO),
9858         SND_PCI_QUIRK(0x103c, 0x86e7, "HP Spectre x360 15-eb0xxx", ALC285_FIXUP_HP_SPECTRE_X360_EB1),
9859         SND_PCI_QUIRK(0x103c, 0x86e8, "HP Spectre x360 15-eb0xxx", ALC285_FIXUP_HP_SPECTRE_X360_EB1),
9860         SND_PCI_QUIRK(0x103c, 0x86f9, "HP Spectre x360 13-aw0xxx", ALC285_FIXUP_HP_SPECTRE_X360_MUTE_LED),
9861         SND_PCI_QUIRK(0x103c, 0x8716, "HP Elite Dragonfly G2 Notebook PC", ALC285_FIXUP_HP_GPIO_AMP_INIT),
9862         SND_PCI_QUIRK(0x103c, 0x8720, "HP EliteBook x360 1040 G8 Notebook PC", ALC285_FIXUP_HP_GPIO_AMP_INIT),
9863         SND_PCI_QUIRK(0x103c, 0x8724, "HP EliteBook 850 G7", ALC285_FIXUP_HP_GPIO_LED),
9864         SND_PCI_QUIRK(0x103c, 0x8728, "HP EliteBook 840 G7", ALC285_FIXUP_HP_GPIO_LED),
9865         SND_PCI_QUIRK(0x103c, 0x8729, "HP", ALC285_FIXUP_HP_GPIO_LED),
9866         SND_PCI_QUIRK(0x103c, 0x8730, "HP ProBook 445 G7", ALC236_FIXUP_HP_MUTE_LED_MICMUTE_VREF),
9867         SND_PCI_QUIRK(0x103c, 0x8735, "HP ProBook 435 G7", ALC236_FIXUP_HP_MUTE_LED_MICMUTE_VREF),
9868         SND_PCI_QUIRK(0x103c, 0x8736, "HP", ALC285_FIXUP_HP_GPIO_AMP_INIT),
9869         SND_PCI_QUIRK(0x103c, 0x8760, "HP", ALC285_FIXUP_HP_MUTE_LED),
9870         SND_PCI_QUIRK(0x103c, 0x876e, "HP ENVY x360 Convertible 13-ay0xxx", ALC245_FIXUP_HP_X360_MUTE_LEDS),
9871         SND_PCI_QUIRK(0x103c, 0x877a, "HP", ALC285_FIXUP_HP_MUTE_LED),
9872         SND_PCI_QUIRK(0x103c, 0x877d, "HP", ALC236_FIXUP_HP_MUTE_LED),
9873         SND_PCI_QUIRK(0x103c, 0x8780, "HP ZBook Fury 17 G7 Mobile Workstation",
9874                       ALC285_FIXUP_HP_GPIO_AMP_INIT),
9875         SND_PCI_QUIRK(0x103c, 0x8783, "HP ZBook Fury 15 G7 Mobile Workstation",
9876                       ALC285_FIXUP_HP_GPIO_AMP_INIT),
9877         SND_PCI_QUIRK(0x103c, 0x8786, "HP OMEN 15", ALC285_FIXUP_HP_MUTE_LED),
9878         SND_PCI_QUIRK(0x103c, 0x8787, "HP OMEN 15", ALC285_FIXUP_HP_MUTE_LED),
9879         SND_PCI_QUIRK(0x103c, 0x8788, "HP OMEN 15", ALC285_FIXUP_HP_MUTE_LED),
9880         SND_PCI_QUIRK(0x103c, 0x87b7, "HP Laptop 14-fq0xxx", ALC236_FIXUP_HP_MUTE_LED_COEFBIT2),
9881         SND_PCI_QUIRK(0x103c, 0x87c8, "HP", ALC287_FIXUP_HP_GPIO_LED),
9882         SND_PCI_QUIRK(0x103c, 0x87e5, "HP ProBook 440 G8 Notebook PC", ALC236_FIXUP_HP_GPIO_LED),
9883         SND_PCI_QUIRK(0x103c, 0x87e7, "HP ProBook 450 G8 Notebook PC", ALC236_FIXUP_HP_GPIO_LED),
9884         SND_PCI_QUIRK(0x103c, 0x87f1, "HP ProBook 630 G8 Notebook PC", ALC236_FIXUP_HP_GPIO_LED),
9885         SND_PCI_QUIRK(0x103c, 0x87f2, "HP ProBook 640 G8 Notebook PC", ALC236_FIXUP_HP_GPIO_LED),
9886         SND_PCI_QUIRK(0x103c, 0x87f4, "HP", ALC287_FIXUP_HP_GPIO_LED),
9887         SND_PCI_QUIRK(0x103c, 0x87f5, "HP", ALC287_FIXUP_HP_GPIO_LED),
9888         SND_PCI_QUIRK(0x103c, 0x87f6, "HP Spectre x360 14", ALC245_FIXUP_HP_X360_AMP),
9889         SND_PCI_QUIRK(0x103c, 0x87f7, "HP Spectre x360 14", ALC245_FIXUP_HP_X360_AMP),
9890         SND_PCI_QUIRK(0x103c, 0x87fe, "HP Laptop 15s-fq2xxx", ALC236_FIXUP_HP_MUTE_LED_COEFBIT2),
9891         SND_PCI_QUIRK(0x103c, 0x8805, "HP ProBook 650 G8 Notebook PC", ALC236_FIXUP_HP_GPIO_LED),
9892         SND_PCI_QUIRK(0x103c, 0x880d, "HP EliteBook 830 G8 Notebook PC", ALC285_FIXUP_HP_GPIO_LED),
9893         SND_PCI_QUIRK(0x103c, 0x8811, "HP Spectre x360 15-eb1xxx", ALC285_FIXUP_HP_SPECTRE_X360_EB1),
9894         SND_PCI_QUIRK(0x103c, 0x8812, "HP Spectre x360 15-eb1xxx", ALC285_FIXUP_HP_SPECTRE_X360_EB1),
9895         SND_PCI_QUIRK(0x103c, 0x881d, "HP 250 G8 Notebook PC", ALC236_FIXUP_HP_MUTE_LED_COEFBIT2),
9896         SND_PCI_QUIRK(0x103c, 0x8846, "HP EliteBook 850 G8 Notebook PC", ALC285_FIXUP_HP_GPIO_LED),
9897         SND_PCI_QUIRK(0x103c, 0x8847, "HP EliteBook x360 830 G8 Notebook PC", ALC285_FIXUP_HP_GPIO_LED),
9898         SND_PCI_QUIRK(0x103c, 0x884b, "HP EliteBook 840 Aero G8 Notebook PC", ALC285_FIXUP_HP_GPIO_LED),
9899         SND_PCI_QUIRK(0x103c, 0x884c, "HP EliteBook 840 G8 Notebook PC", ALC285_FIXUP_HP_GPIO_LED),
9900         SND_PCI_QUIRK(0x103c, 0x8862, "HP ProBook 445 G8 Notebook PC", ALC236_FIXUP_HP_LIMIT_INT_MIC_BOOST),
9901         SND_PCI_QUIRK(0x103c, 0x8863, "HP ProBook 445 G8 Notebook PC", ALC236_FIXUP_HP_LIMIT_INT_MIC_BOOST),
9902         SND_PCI_QUIRK(0x103c, 0x886d, "HP ZBook Fury 17.3 Inch G8 Mobile Workstation PC", ALC285_FIXUP_HP_GPIO_AMP_INIT),
9903         SND_PCI_QUIRK(0x103c, 0x8870, "HP ZBook Fury 15.6 Inch G8 Mobile Workstation PC", ALC285_FIXUP_HP_GPIO_AMP_INIT),
9904         SND_PCI_QUIRK(0x103c, 0x8873, "HP ZBook Studio 15.6 Inch G8 Mobile Workstation PC", ALC285_FIXUP_HP_GPIO_AMP_INIT),
9905         SND_PCI_QUIRK(0x103c, 0x887a, "HP Laptop 15s-eq2xxx", ALC236_FIXUP_HP_MUTE_LED_COEFBIT2),
9906         SND_PCI_QUIRK(0x103c, 0x888a, "HP ENVY x360 Convertible 15-eu0xxx", ALC245_FIXUP_HP_X360_MUTE_LEDS),
9907         SND_PCI_QUIRK(0x103c, 0x888d, "HP ZBook Power 15.6 inch G8 Mobile Workstation PC", ALC236_FIXUP_HP_GPIO_LED),
9908         SND_PCI_QUIRK(0x103c, 0x8895, "HP EliteBook 855 G8 Notebook PC", ALC285_FIXUP_HP_SPEAKERS_MICMUTE_LED),
9909         SND_PCI_QUIRK(0x103c, 0x8896, "HP EliteBook 855 G8 Notebook PC", ALC285_FIXUP_HP_MUTE_LED),
9910         SND_PCI_QUIRK(0x103c, 0x8898, "HP EliteBook 845 G8 Notebook PC", ALC285_FIXUP_HP_LIMIT_INT_MIC_BOOST),
9911         SND_PCI_QUIRK(0x103c, 0x88d0, "HP Pavilion 15-eh1xxx (mainboard 88D0)", ALC287_FIXUP_HP_GPIO_LED),
9912         SND_PCI_QUIRK(0x103c, 0x8902, "HP OMEN 16", ALC285_FIXUP_HP_MUTE_LED),
9913         SND_PCI_QUIRK(0x103c, 0x890e, "HP 255 G8 Notebook PC", ALC236_FIXUP_HP_MUTE_LED_COEFBIT2),
9914         SND_PCI_QUIRK(0x103c, 0x8919, "HP Pavilion Aero Laptop 13-be0xxx", ALC287_FIXUP_HP_GPIO_LED),
9915         SND_PCI_QUIRK(0x103c, 0x896d, "HP ZBook Firefly 16 G9", ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED),
9916         SND_PCI_QUIRK(0x103c, 0x896e, "HP EliteBook x360 830 G9", ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED),
9917         SND_PCI_QUIRK(0x103c, 0x8971, "HP EliteBook 830 G9", ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED),
9918         SND_PCI_QUIRK(0x103c, 0x8972, "HP EliteBook 840 G9", ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED),
9919         SND_PCI_QUIRK(0x103c, 0x8973, "HP EliteBook 860 G9", ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED),
9920         SND_PCI_QUIRK(0x103c, 0x8974, "HP EliteBook 840 Aero G9", ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED),
9921         SND_PCI_QUIRK(0x103c, 0x8975, "HP EliteBook x360 840 Aero G9", ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED),
9922         SND_PCI_QUIRK(0x103c, 0x897d, "HP mt440 Mobile Thin Client U74", ALC236_FIXUP_HP_GPIO_LED),
9923         SND_PCI_QUIRK(0x103c, 0x8981, "HP Elite Dragonfly G3", ALC245_FIXUP_CS35L41_SPI_4),
9924         SND_PCI_QUIRK(0x103c, 0x898e, "HP EliteBook 835 G9", ALC287_FIXUP_CS35L41_I2C_2),
9925         SND_PCI_QUIRK(0x103c, 0x898f, "HP EliteBook 835 G9", ALC287_FIXUP_CS35L41_I2C_2),
9926         SND_PCI_QUIRK(0x103c, 0x8991, "HP EliteBook 845 G9", ALC287_FIXUP_CS35L41_I2C_2_HP_GPIO_LED),
9927         SND_PCI_QUIRK(0x103c, 0x8992, "HP EliteBook 845 G9", ALC287_FIXUP_CS35L41_I2C_2),
9928         SND_PCI_QUIRK(0x103c, 0x8994, "HP EliteBook 855 G9", ALC287_FIXUP_CS35L41_I2C_2_HP_GPIO_LED),
9929         SND_PCI_QUIRK(0x103c, 0x8995, "HP EliteBook 855 G9", ALC287_FIXUP_CS35L41_I2C_2),
9930         SND_PCI_QUIRK(0x103c, 0x89a4, "HP ProBook 440 G9", ALC236_FIXUP_HP_GPIO_LED),
9931         SND_PCI_QUIRK(0x103c, 0x89a6, "HP ProBook 450 G9", ALC236_FIXUP_HP_GPIO_LED),
9932         SND_PCI_QUIRK(0x103c, 0x89aa, "HP EliteBook 630 G9", ALC236_FIXUP_HP_GPIO_LED),
9933         SND_PCI_QUIRK(0x103c, 0x89ac, "HP EliteBook 640 G9", ALC236_FIXUP_HP_GPIO_LED),
9934         SND_PCI_QUIRK(0x103c, 0x89ae, "HP EliteBook 650 G9", ALC236_FIXUP_HP_GPIO_LED),
9935         SND_PCI_QUIRK(0x103c, 0x89c0, "HP ZBook Power 15.6 G9", ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED),
9936         SND_PCI_QUIRK(0x103c, 0x89c3, "Zbook Studio G9", ALC245_FIXUP_CS35L41_SPI_4_HP_GPIO_LED),
9937         SND_PCI_QUIRK(0x103c, 0x89c6, "Zbook Fury 17 G9", ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED),
9938         SND_PCI_QUIRK(0x103c, 0x89ca, "HP", ALC236_FIXUP_HP_MUTE_LED_MICMUTE_VREF),
9939         SND_PCI_QUIRK(0x103c, 0x89d3, "HP EliteBook 645 G9 (MB 89D2)", ALC236_FIXUP_HP_MUTE_LED_MICMUTE_VREF),
9940         SND_PCI_QUIRK(0x103c, 0x89e7, "HP Elite x2 G9", ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED),
9941         SND_PCI_QUIRK(0x103c, 0x8a0f, "HP Pavilion 14-ec1xxx", ALC287_FIXUP_HP_GPIO_LED),
9942         SND_PCI_QUIRK(0x103c, 0x8a20, "HP Laptop 15s-fq5xxx", ALC236_FIXUP_HP_MUTE_LED_COEFBIT2),
9943         SND_PCI_QUIRK(0x103c, 0x8a25, "HP Victus 16-d1xxx (MB 8A25)", ALC245_FIXUP_HP_MUTE_LED_COEFBIT),
9944         SND_PCI_QUIRK(0x103c, 0x8a28, "HP Envy 13", ALC287_FIXUP_CS35L41_I2C_2),
9945         SND_PCI_QUIRK(0x103c, 0x8a29, "HP Envy 15", ALC287_FIXUP_CS35L41_I2C_2),
9946         SND_PCI_QUIRK(0x103c, 0x8a2a, "HP Envy 15", ALC287_FIXUP_CS35L41_I2C_2),
9947         SND_PCI_QUIRK(0x103c, 0x8a2b, "HP Envy 15", ALC287_FIXUP_CS35L41_I2C_2),
9948         SND_PCI_QUIRK(0x103c, 0x8a2c, "HP Envy 16", ALC287_FIXUP_CS35L41_I2C_2),
9949         SND_PCI_QUIRK(0x103c, 0x8a2d, "HP Envy 16", ALC287_FIXUP_CS35L41_I2C_2),
9950         SND_PCI_QUIRK(0x103c, 0x8a2e, "HP Envy 16", ALC287_FIXUP_CS35L41_I2C_2),
9951         SND_PCI_QUIRK(0x103c, 0x8a2e, "HP Envy 17", ALC287_FIXUP_CS35L41_I2C_2),
9952         SND_PCI_QUIRK(0x103c, 0x8a30, "HP Envy 17", ALC287_FIXUP_CS35L41_I2C_2),
9953         SND_PCI_QUIRK(0x103c, 0x8a31, "HP Envy 15", ALC287_FIXUP_CS35L41_I2C_2),
9954         SND_PCI_QUIRK(0x103c, 0x8a6e, "HP EDNA 360", ALC287_FIXUP_CS35L41_I2C_4),
9955         SND_PCI_QUIRK(0x103c, 0x8a74, "HP ProBook 440 G8 Notebook PC", ALC236_FIXUP_HP_GPIO_LED),
9956         SND_PCI_QUIRK(0x103c, 0x8a78, "HP Dev One", ALC285_FIXUP_HP_LIMIT_INT_MIC_BOOST),
9957         SND_PCI_QUIRK(0x103c, 0x8aa0, "HP ProBook 440 G9 (MB 8A9E)", ALC236_FIXUP_HP_GPIO_LED),
9958         SND_PCI_QUIRK(0x103c, 0x8aa3, "HP ProBook 450 G9 (MB 8AA1)", ALC236_FIXUP_HP_GPIO_LED),
9959         SND_PCI_QUIRK(0x103c, 0x8aa8, "HP EliteBook 640 G9 (MB 8AA6)", ALC236_FIXUP_HP_GPIO_LED),
9960         SND_PCI_QUIRK(0x103c, 0x8aab, "HP EliteBook 650 G9 (MB 8AA9)", ALC236_FIXUP_HP_GPIO_LED),
9961         SND_PCI_QUIRK(0x103c, 0x8ab9, "HP EliteBook 840 G8 (MB 8AB8)", ALC285_FIXUP_HP_GPIO_LED),
9962         SND_PCI_QUIRK(0x103c, 0x8abb, "HP ZBook Firefly 14 G9", ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED),
9963         SND_PCI_QUIRK(0x103c, 0x8ad1, "HP EliteBook 840 14 inch G9 Notebook PC", ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED),
9964         SND_PCI_QUIRK(0x103c, 0x8ad2, "HP EliteBook 860 16 inch G9 Notebook PC", ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED),
9965         SND_PCI_QUIRK(0x103c, 0x8ad8, "HP 800 G9", ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED),
9966         SND_PCI_QUIRK(0x103c, 0x8b0f, "HP Elite mt645 G7 Mobile Thin Client U81", ALC236_FIXUP_HP_MUTE_LED_MICMUTE_VREF),
9967         SND_PCI_QUIRK(0x103c, 0x8b2f, "HP 255 15.6 inch G10 Notebook PC", ALC236_FIXUP_HP_MUTE_LED_COEFBIT2),
9968         SND_PCI_QUIRK(0x103c, 0x8b3a, "HP Envy 15", ALC287_FIXUP_CS35L41_I2C_2),
9969         SND_PCI_QUIRK(0x103c, 0x8b3f, "HP mt440 Mobile Thin Client U91", ALC236_FIXUP_HP_GPIO_LED),
9970         SND_PCI_QUIRK(0x103c, 0x8b42, "HP", ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED),
9971         SND_PCI_QUIRK(0x103c, 0x8b43, "HP", ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED),
9972         SND_PCI_QUIRK(0x103c, 0x8b44, "HP", ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED),
9973         SND_PCI_QUIRK(0x103c, 0x8b45, "HP", ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED),
9974         SND_PCI_QUIRK(0x103c, 0x8b46, "HP", ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED),
9975         SND_PCI_QUIRK(0x103c, 0x8b47, "HP", ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED),
9976         SND_PCI_QUIRK(0x103c, 0x8b59, "HP Elite mt645 G7 Mobile Thin Client U89", ALC236_FIXUP_HP_MUTE_LED_MICMUTE_VREF),
9977         SND_PCI_QUIRK(0x103c, 0x8b5d, "HP", ALC236_FIXUP_HP_MUTE_LED_MICMUTE_VREF),
9978         SND_PCI_QUIRK(0x103c, 0x8b5e, "HP", ALC236_FIXUP_HP_MUTE_LED_MICMUTE_VREF),
9979         SND_PCI_QUIRK(0x103c, 0x8b63, "HP Elite Dragonfly 13.5 inch G4", ALC245_FIXUP_CS35L41_SPI_4_HP_GPIO_LED),
9980         SND_PCI_QUIRK(0x103c, 0x8b65, "HP ProBook 455 15.6 inch G10 Notebook PC", ALC236_FIXUP_HP_MUTE_LED_MICMUTE_VREF),
9981         SND_PCI_QUIRK(0x103c, 0x8b66, "HP", ALC236_FIXUP_HP_MUTE_LED_MICMUTE_VREF),
9982         SND_PCI_QUIRK(0x103c, 0x8b70, "HP EliteBook 835 G10", ALC287_FIXUP_CS35L41_I2C_2_HP_GPIO_LED),
9983         SND_PCI_QUIRK(0x103c, 0x8b72, "HP EliteBook 845 G10", ALC287_FIXUP_CS35L41_I2C_2_HP_GPIO_LED),
9984         SND_PCI_QUIRK(0x103c, 0x8b74, "HP EliteBook 845W G10", ALC287_FIXUP_CS35L41_I2C_2_HP_GPIO_LED),
9985         SND_PCI_QUIRK(0x103c, 0x8b77, "HP ElieBook 865 G10", ALC287_FIXUP_CS35L41_I2C_2),
9986         SND_PCI_QUIRK(0x103c, 0x8b7a, "HP", ALC236_FIXUP_HP_GPIO_LED),
9987         SND_PCI_QUIRK(0x103c, 0x8b7d, "HP", ALC236_FIXUP_HP_GPIO_LED),
9988         SND_PCI_QUIRK(0x103c, 0x8b87, "HP", ALC236_FIXUP_HP_GPIO_LED),
9989         SND_PCI_QUIRK(0x103c, 0x8b8a, "HP", ALC236_FIXUP_HP_GPIO_LED),
9990         SND_PCI_QUIRK(0x103c, 0x8b8b, "HP", ALC236_FIXUP_HP_GPIO_LED),
9991         SND_PCI_QUIRK(0x103c, 0x8b8d, "HP", ALC236_FIXUP_HP_GPIO_LED),
9992         SND_PCI_QUIRK(0x103c, 0x8b8f, "HP", ALC245_FIXUP_CS35L41_SPI_4_HP_GPIO_LED),
9993         SND_PCI_QUIRK(0x103c, 0x8b92, "HP", ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED),
9994         SND_PCI_QUIRK(0x103c, 0x8b96, "HP", ALC236_FIXUP_HP_MUTE_LED_MICMUTE_VREF),
9995         SND_PCI_QUIRK(0x103c, 0x8b97, "HP", ALC236_FIXUP_HP_MUTE_LED_MICMUTE_VREF),
9996         SND_PCI_QUIRK(0x103c, 0x8bdd, "HP Envy 17", ALC287_FIXUP_CS35L41_I2C_2),
9997         SND_PCI_QUIRK(0x103c, 0x8bde, "HP Envy 17", ALC287_FIXUP_CS35L41_I2C_2),
9998         SND_PCI_QUIRK(0x103c, 0x8bdf, "HP Envy 15", ALC287_FIXUP_CS35L41_I2C_2),
9999         SND_PCI_QUIRK(0x103c, 0x8be0, "HP Envy 15", ALC287_FIXUP_CS35L41_I2C_2),
10000         SND_PCI_QUIRK(0x103c, 0x8be1, "HP Envy 15", ALC287_FIXUP_CS35L41_I2C_2),
10001         SND_PCI_QUIRK(0x103c, 0x8be2, "HP Envy 15", ALC287_FIXUP_CS35L41_I2C_2),
10002         SND_PCI_QUIRK(0x103c, 0x8be3, "HP Envy 15", ALC287_FIXUP_CS35L41_I2C_2),
10003         SND_PCI_QUIRK(0x103c, 0x8be5, "HP Envy 16", ALC287_FIXUP_CS35L41_I2C_2),
10004         SND_PCI_QUIRK(0x103c, 0x8be6, "HP Envy 16", ALC287_FIXUP_CS35L41_I2C_2),
10005         SND_PCI_QUIRK(0x103c, 0x8be7, "HP Envy 17", ALC287_FIXUP_CS35L41_I2C_2),
10006         SND_PCI_QUIRK(0x103c, 0x8be8, "HP Envy 17", ALC287_FIXUP_CS35L41_I2C_2),
10007         SND_PCI_QUIRK(0x103c, 0x8be9, "HP Envy 15", ALC287_FIXUP_CS35L41_I2C_2),
10008         SND_PCI_QUIRK(0x103c, 0x8bf0, "HP", ALC236_FIXUP_HP_GPIO_LED),
10009         SND_PCI_QUIRK(0x103c, 0x8c15, "HP Spectre x360 2-in-1 Laptop 14-eu0xxx", ALC245_FIXUP_HP_SPECTRE_X360_EU0XXX),
10010         SND_PCI_QUIRK(0x103c, 0x8c16, "HP Spectre 16", ALC287_FIXUP_CS35L41_I2C_2),
10011         SND_PCI_QUIRK(0x103c, 0x8c17, "HP Spectre 16", ALC287_FIXUP_CS35L41_I2C_2),
10012         SND_PCI_QUIRK(0x103c, 0x8c46, "HP EliteBook 830 G11", ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED),
10013         SND_PCI_QUIRK(0x103c, 0x8c47, "HP EliteBook 840 G11", ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED),
10014         SND_PCI_QUIRK(0x103c, 0x8c48, "HP EliteBook 860 G11", ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED),
10015         SND_PCI_QUIRK(0x103c, 0x8c49, "HP Elite x360 830 2-in-1 G11", ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED),
10016         SND_PCI_QUIRK(0x103c, 0x8c4f, "HP Envy 15", ALC287_FIXUP_CS35L41_I2C_2),
10017         SND_PCI_QUIRK(0x103c, 0x8c50, "HP Envy 17", ALC287_FIXUP_CS35L41_I2C_2),
10018         SND_PCI_QUIRK(0x103c, 0x8c51, "HP Envy 17", ALC287_FIXUP_CS35L41_I2C_2),
10019         SND_PCI_QUIRK(0x103c, 0x8c52, "HP EliteBook 1040 G11", ALC245_FIXUP_CS35L56_SPI_4_HP_GPIO_LED),
10020         SND_PCI_QUIRK(0x103c, 0x8c53, "HP Elite x360 1040 2-in-1 G11", ALC245_FIXUP_CS35L56_SPI_4_HP_GPIO_LED),
10021         SND_PCI_QUIRK(0x103c, 0x8c66, "HP Envy 16", ALC287_FIXUP_CS35L41_I2C_2),
10022         SND_PCI_QUIRK(0x103c, 0x8c67, "HP Envy 17", ALC287_FIXUP_CS35L41_I2C_2),
10023         SND_PCI_QUIRK(0x103c, 0x8c68, "HP Envy 17", ALC287_FIXUP_CS35L41_I2C_2),
10024         SND_PCI_QUIRK(0x103c, 0x8c6a, "HP Envy 16", ALC287_FIXUP_CS35L41_I2C_2),
10025         SND_PCI_QUIRK(0x103c, 0x8c70, "HP EliteBook 835 G11", ALC287_FIXUP_CS35L41_I2C_2_HP_GPIO_LED),
10026         SND_PCI_QUIRK(0x103c, 0x8c71, "HP EliteBook 845 G11", ALC287_FIXUP_CS35L41_I2C_2_HP_GPIO_LED),
10027         SND_PCI_QUIRK(0x103c, 0x8c72, "HP EliteBook 865 G11", ALC287_FIXUP_CS35L41_I2C_2_HP_GPIO_LED),
10028         SND_PCI_QUIRK(0x103c, 0x8c8a, "HP EliteBook 630", ALC236_FIXUP_HP_GPIO_LED),
10029         SND_PCI_QUIRK(0x103c, 0x8c8c, "HP EliteBook 660", ALC236_FIXUP_HP_GPIO_LED),
10030         SND_PCI_QUIRK(0x103c, 0x8c90, "HP EliteBook 640", ALC236_FIXUP_HP_GPIO_LED),
10031         SND_PCI_QUIRK(0x103c, 0x8c91, "HP EliteBook 660", ALC236_FIXUP_HP_GPIO_LED),
10032         SND_PCI_QUIRK(0x103c, 0x8c96, "HP", ALC236_FIXUP_HP_MUTE_LED_MICMUTE_VREF),
10033         SND_PCI_QUIRK(0x103c, 0x8c97, "HP ZBook", ALC236_FIXUP_HP_MUTE_LED_MICMUTE_VREF),
10034         SND_PCI_QUIRK(0x103c, 0x8ca1, "HP ZBook Power", ALC236_FIXUP_HP_GPIO_LED),
10035         SND_PCI_QUIRK(0x103c, 0x8ca2, "HP ZBook Power", ALC236_FIXUP_HP_GPIO_LED),
10036         SND_PCI_QUIRK(0x103c, 0x8ca4, "HP ZBook Fury", ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED),
10037         SND_PCI_QUIRK(0x103c, 0x8ca7, "HP ZBook Fury", ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED),
10038         SND_PCI_QUIRK(0x103c, 0x8cdd, "HP Spectre", ALC287_FIXUP_CS35L41_I2C_2),
10039         SND_PCI_QUIRK(0x103c, 0x8cde, "HP Spectre", ALC287_FIXUP_CS35L41_I2C_2),
10040         SND_PCI_QUIRK(0x103c, 0x8cf5, "HP ZBook Studio 16", ALC245_FIXUP_CS35L41_SPI_4_HP_GPIO_LED),
10041         SND_PCI_QUIRK(0x1043, 0x103e, "ASUS X540SA", ALC256_FIXUP_ASUS_MIC),
10042         SND_PCI_QUIRK(0x1043, 0x103f, "ASUS TX300", ALC282_FIXUP_ASUS_TX300),
10043         SND_PCI_QUIRK(0x1043, 0x106d, "Asus K53BE", ALC269_FIXUP_LIMIT_INT_MIC_BOOST),
10044         SND_PCI_QUIRK(0x1043, 0x10a1, "ASUS UX391UA", ALC294_FIXUP_ASUS_SPK),
10045         SND_PCI_QUIRK(0x1043, 0x10c0, "ASUS X540SA", ALC256_FIXUP_ASUS_MIC),
10046         SND_PCI_QUIRK(0x1043, 0x10d0, "ASUS X540LA/X540LJ", ALC255_FIXUP_ASUS_MIC_NO_PRESENCE),
10047         SND_PCI_QUIRK(0x1043, 0x10d3, "ASUS K6500ZC", ALC294_FIXUP_ASUS_SPK),
10048         SND_PCI_QUIRK(0x1043, 0x115d, "Asus 1015E", ALC269_FIXUP_LIMIT_INT_MIC_BOOST),
10049         SND_PCI_QUIRK(0x1043, 0x11c0, "ASUS X556UR", ALC255_FIXUP_ASUS_MIC_NO_PRESENCE),
10050         SND_PCI_QUIRK(0x1043, 0x125e, "ASUS Q524UQK", ALC255_FIXUP_ASUS_MIC_NO_PRESENCE),
10051         SND_PCI_QUIRK(0x1043, 0x1271, "ASUS X430UN", ALC256_FIXUP_ASUS_MIC_NO_PRESENCE),
10052         SND_PCI_QUIRK(0x1043, 0x1290, "ASUS X441SA", ALC233_FIXUP_EAPD_COEF_AND_MIC_NO_PRESENCE),
10053         SND_PCI_QUIRK(0x1043, 0x12a0, "ASUS X441UV", ALC233_FIXUP_EAPD_COEF_AND_MIC_NO_PRESENCE),
10054         SND_PCI_QUIRK(0x1043, 0x12a3, "Asus N7691ZM", ALC269_FIXUP_ASUS_N7601ZM),
10055         SND_PCI_QUIRK(0x1043, 0x12af, "ASUS UX582ZS", ALC245_FIXUP_CS35L41_SPI_2),
10056         SND_PCI_QUIRK(0x1043, 0x12e0, "ASUS X541SA", ALC256_FIXUP_ASUS_MIC),
10057         SND_PCI_QUIRK(0x1043, 0x12f0, "ASUS X541UV", ALC256_FIXUP_ASUS_MIC),
10058         SND_PCI_QUIRK(0x1043, 0x1313, "Asus K42JZ", ALC269VB_FIXUP_ASUS_MIC_NO_PRESENCE),
10059         SND_PCI_QUIRK(0x1043, 0x13b0, "ASUS Z550SA", ALC256_FIXUP_ASUS_MIC),
10060         SND_PCI_QUIRK(0x1043, 0x1427, "Asus Zenbook UX31E", ALC269VB_FIXUP_ASUS_ZENBOOK),
10061         SND_PCI_QUIRK(0x1043, 0x1433, "ASUS GX650PY/PZ/PV/PU/PYV/PZV/PIV/PVV", ALC285_FIXUP_ASUS_I2C_HEADSET_MIC),
10062         SND_PCI_QUIRK(0x1043, 0x1463, "Asus GA402X/GA402N", ALC285_FIXUP_ASUS_I2C_HEADSET_MIC),
10063         SND_PCI_QUIRK(0x1043, 0x1473, "ASUS GU604VI/VC/VE/VG/VJ/VQ/VU/VV/VY/VZ", ALC285_FIXUP_ASUS_HEADSET_MIC),
10064         SND_PCI_QUIRK(0x1043, 0x1483, "ASUS GU603VQ/VU/VV/VJ/VI", ALC285_FIXUP_ASUS_HEADSET_MIC),
10065         SND_PCI_QUIRK(0x1043, 0x1493, "ASUS GV601VV/VU/VJ/VQ/VI", ALC285_FIXUP_ASUS_HEADSET_MIC),
10066         SND_PCI_QUIRK(0x1043, 0x14d3, "ASUS G614JY/JZ/JG", ALC245_FIXUP_CS35L41_SPI_2),
10067         SND_PCI_QUIRK(0x1043, 0x14e3, "ASUS G513PI/PU/PV", ALC287_FIXUP_CS35L41_I2C_2),
10068         SND_PCI_QUIRK(0x1043, 0x1503, "ASUS G733PY/PZ/PZV/PYV", ALC287_FIXUP_CS35L41_I2C_2),
10069         SND_PCI_QUIRK(0x1043, 0x1517, "Asus Zenbook UX31A", ALC269VB_FIXUP_ASUS_ZENBOOK_UX31A),
10070         SND_PCI_QUIRK(0x1043, 0x1533, "ASUS GV302XA/XJ/XQ/XU/XV/XI", ALC287_FIXUP_CS35L41_I2C_2),
10071         SND_PCI_QUIRK(0x1043, 0x1573, "ASUS GZ301VV/VQ/VU/VJ/VA/VC/VE/VVC/VQC/VUC/VJC/VEC/VCC", ALC285_FIXUP_ASUS_HEADSET_MIC),
10072         SND_PCI_QUIRK(0x1043, 0x1662, "ASUS GV301QH", ALC294_FIXUP_ASUS_DUAL_SPK),
10073         SND_PCI_QUIRK(0x1043, 0x1663, "ASUS GU603ZI/ZJ/ZQ/ZU/ZV", ALC285_FIXUP_ASUS_HEADSET_MIC),
10074         SND_PCI_QUIRK(0x1043, 0x1683, "ASUS UM3402YAR", ALC287_FIXUP_CS35L41_I2C_2),
10075         SND_PCI_QUIRK(0x1043, 0x16a3, "ASUS UX3402VA", ALC245_FIXUP_CS35L41_SPI_2),
10076         SND_PCI_QUIRK(0x1043, 0x16b2, "ASUS GU603", ALC289_FIXUP_ASUS_GA401),
10077         SND_PCI_QUIRK(0x1043, 0x16d3, "ASUS UX5304VA", ALC245_FIXUP_CS35L41_SPI_2),
10078         SND_PCI_QUIRK(0x1043, 0x16e3, "ASUS UX50", ALC269_FIXUP_STEREO_DMIC),
10079         SND_PCI_QUIRK(0x1043, 0x16f3, "ASUS UX7602VI/BZ", ALC245_FIXUP_CS35L41_SPI_2),
10080         SND_PCI_QUIRK(0x1043, 0x1740, "ASUS UX430UA", ALC295_FIXUP_ASUS_DACS),
10081         SND_PCI_QUIRK(0x1043, 0x17d1, "ASUS UX431FL", ALC294_FIXUP_ASUS_DUAL_SPK),
10082         SND_PCI_QUIRK(0x1043, 0x17f3, "ROG Ally NR2301L/X", ALC294_FIXUP_ASUS_ALLY),
10083         SND_PCI_QUIRK(0x1043, 0x1863, "ASUS UX6404VI/VV", ALC245_FIXUP_CS35L41_SPI_2),
10084         SND_PCI_QUIRK(0x1043, 0x1881, "ASUS Zephyrus S/M", ALC294_FIXUP_ASUS_GX502_PINS),
10085         SND_PCI_QUIRK(0x1043, 0x18b1, "Asus MJ401TA", ALC256_FIXUP_ASUS_HEADSET_MIC),
10086         SND_PCI_QUIRK(0x1043, 0x18d3, "ASUS UM3504DA", ALC294_FIXUP_CS35L41_I2C_2),
10087         SND_PCI_QUIRK(0x1043, 0x18f1, "Asus FX505DT", ALC256_FIXUP_ASUS_HEADSET_MIC),
10088         SND_PCI_QUIRK(0x1043, 0x194e, "ASUS UX563FD", ALC294_FIXUP_ASUS_HPE),
10089         SND_PCI_QUIRK(0x1043, 0x1970, "ASUS UX550VE", ALC289_FIXUP_ASUS_GA401),
10090         SND_PCI_QUIRK(0x1043, 0x1982, "ASUS B1400CEPE", ALC256_FIXUP_ASUS_HPE),
10091         SND_PCI_QUIRK(0x1043, 0x19ce, "ASUS B9450FA", ALC294_FIXUP_ASUS_HPE),
10092         SND_PCI_QUIRK(0x1043, 0x19e1, "ASUS UX581LV", ALC295_FIXUP_ASUS_MIC_NO_PRESENCE),
10093         SND_PCI_QUIRK(0x1043, 0x1a13, "Asus G73Jw", ALC269_FIXUP_ASUS_G73JW),
10094         SND_PCI_QUIRK(0x1043, 0x1a30, "ASUS X705UD", ALC256_FIXUP_ASUS_MIC),
10095         SND_PCI_QUIRK(0x1043, 0x1a63, "ASUS UX3405MA", ALC245_FIXUP_CS35L41_SPI_2),
10096         SND_PCI_QUIRK(0x1043, 0x1a83, "ASUS UM5302LA", ALC294_FIXUP_CS35L41_I2C_2),
10097         SND_PCI_QUIRK(0x1043, 0x1a8f, "ASUS UX582ZS", ALC245_FIXUP_CS35L41_SPI_2),
10098         SND_PCI_QUIRK(0x1043, 0x1b11, "ASUS UX431DA", ALC294_FIXUP_ASUS_COEF_1B),
10099         SND_PCI_QUIRK(0x1043, 0x1b13, "Asus U41SV", ALC269_FIXUP_INV_DMIC),
10100         SND_PCI_QUIRK(0x1043, 0x1b93, "ASUS G614JVR/JIR", ALC245_FIXUP_CS35L41_SPI_2),
10101         SND_PCI_QUIRK(0x1043, 0x1bbd, "ASUS Z550MA", ALC255_FIXUP_ASUS_MIC_NO_PRESENCE),
10102         SND_PCI_QUIRK(0x1043, 0x1c03, "ASUS UM3406HA", ALC287_FIXUP_CS35L41_I2C_2),
10103         SND_PCI_QUIRK(0x1043, 0x1c23, "Asus X55U", ALC269_FIXUP_LIMIT_INT_MIC_BOOST),
10104         SND_PCI_QUIRK(0x1043, 0x1c33, "ASUS UX5304MA", ALC245_FIXUP_CS35L41_SPI_2),
10105         SND_PCI_QUIRK(0x1043, 0x1c43, "ASUS UX8406MA", ALC245_FIXUP_CS35L41_SPI_2),
10106         SND_PCI_QUIRK(0x1043, 0x1c62, "ASUS GU603", ALC289_FIXUP_ASUS_GA401),
10107         SND_PCI_QUIRK(0x1043, 0x1c92, "ASUS ROG Strix G15", ALC285_FIXUP_ASUS_G533Z_PINS),
10108         SND_PCI_QUIRK(0x1043, 0x1c9f, "ASUS G614JU/JV/JI", ALC285_FIXUP_ASUS_HEADSET_MIC),
10109         SND_PCI_QUIRK(0x1043, 0x1caf, "ASUS G634JY/JZ/JI/JG", ALC285_FIXUP_ASUS_SPI_REAR_SPEAKERS),
10110         SND_PCI_QUIRK(0x1043, 0x1ccd, "ASUS X555UB", ALC256_FIXUP_ASUS_MIC),
10111         SND_PCI_QUIRK(0x1043, 0x1ccf, "ASUS G814JU/JV/JI", ALC245_FIXUP_CS35L41_SPI_2),
10112         SND_PCI_QUIRK(0x1043, 0x1cdf, "ASUS G814JY/JZ/JG", ALC245_FIXUP_CS35L41_SPI_2),
10113         SND_PCI_QUIRK(0x1043, 0x1cef, "ASUS G834JY/JZ/JI/JG", ALC285_FIXUP_ASUS_HEADSET_MIC),
10114         SND_PCI_QUIRK(0x1043, 0x1d1f, "ASUS G713PI/PU/PV/PVN", ALC287_FIXUP_CS35L41_I2C_2),
10115         SND_PCI_QUIRK(0x1043, 0x1d42, "ASUS Zephyrus G14 2022", ALC289_FIXUP_ASUS_GA401),
10116         SND_PCI_QUIRK(0x1043, 0x1d4e, "ASUS TM420", ALC256_FIXUP_ASUS_HPE),
10117         SND_PCI_QUIRK(0x1043, 0x1da2, "ASUS UP6502ZA/ZD", ALC245_FIXUP_CS35L41_SPI_2),
10118         SND_PCI_QUIRK(0x1043, 0x1e02, "ASUS UX3402ZA", ALC245_FIXUP_CS35L41_SPI_2),
10119         SND_PCI_QUIRK(0x1043, 0x1e11, "ASUS Zephyrus G15", ALC289_FIXUP_ASUS_GA502),
10120         SND_PCI_QUIRK(0x1043, 0x1e12, "ASUS UM3402", ALC287_FIXUP_CS35L41_I2C_2),
10121         SND_PCI_QUIRK(0x1043, 0x1e51, "ASUS Zephyrus M15", ALC294_FIXUP_ASUS_GU502_PINS),
10122         SND_PCI_QUIRK(0x1043, 0x1e5e, "ASUS ROG Strix G513", ALC294_FIXUP_ASUS_G513_PINS),
10123         SND_PCI_QUIRK(0x1043, 0x1e8e, "ASUS Zephyrus G15", ALC289_FIXUP_ASUS_GA401),
10124         SND_PCI_QUIRK(0x1043, 0x1ee2, "ASUS UM6702RA/RC", ALC287_FIXUP_CS35L41_I2C_2),
10125         SND_PCI_QUIRK(0x1043, 0x1c52, "ASUS Zephyrus G15 2022", ALC289_FIXUP_ASUS_GA401),
10126         SND_PCI_QUIRK(0x1043, 0x1f11, "ASUS Zephyrus G14", ALC289_FIXUP_ASUS_GA401),
10127         SND_PCI_QUIRK(0x1043, 0x1f12, "ASUS UM5302", ALC287_FIXUP_CS35L41_I2C_2),
10128         SND_PCI_QUIRK(0x1043, 0x1f1f, "ASUS H7604JI/JV/J3D", ALC245_FIXUP_CS35L41_SPI_2),
10129         SND_PCI_QUIRK(0x1043, 0x1f62, "ASUS UX7602ZM", ALC245_FIXUP_CS35L41_SPI_2),
10130         SND_PCI_QUIRK(0x1043, 0x1f92, "ASUS ROG Flow X16", ALC289_FIXUP_ASUS_GA401),
10131         SND_PCI_QUIRK(0x1043, 0x3030, "ASUS ZN270IE", ALC256_FIXUP_ASUS_AIO_GPIO2),
10132         SND_PCI_QUIRK(0x1043, 0x3a20, "ASUS G614JZR", ALC245_FIXUP_CS35L41_SPI_2),
10133         SND_PCI_QUIRK(0x1043, 0x3a30, "ASUS G814JVR/JIR", ALC245_FIXUP_CS35L41_SPI_2),
10134         SND_PCI_QUIRK(0x1043, 0x3a40, "ASUS G814JZR", ALC245_FIXUP_CS35L41_SPI_2),
10135         SND_PCI_QUIRK(0x1043, 0x3a50, "ASUS G834JYR/JZR", ALC245_FIXUP_CS35L41_SPI_2),
10136         SND_PCI_QUIRK(0x1043, 0x3a60, "ASUS G634JYR/JZR", ALC245_FIXUP_CS35L41_SPI_2),
10137         SND_PCI_QUIRK(0x1043, 0x831a, "ASUS P901", ALC269_FIXUP_STEREO_DMIC),
10138         SND_PCI_QUIRK(0x1043, 0x834a, "ASUS S101", ALC269_FIXUP_STEREO_DMIC),
10139         SND_PCI_QUIRK(0x1043, 0x8398, "ASUS P1005", ALC269_FIXUP_STEREO_DMIC),
10140         SND_PCI_QUIRK(0x1043, 0x83ce, "ASUS P1005", ALC269_FIXUP_STEREO_DMIC),
10141         SND_PCI_QUIRK(0x1043, 0x8516, "ASUS X101CH", ALC269_FIXUP_ASUS_X101),
10142         SND_PCI_QUIRK(0x104d, 0x9073, "Sony VAIO", ALC275_FIXUP_SONY_VAIO_GPIO2),
10143         SND_PCI_QUIRK(0x104d, 0x907b, "Sony VAIO", ALC275_FIXUP_SONY_HWEQ),
10144         SND_PCI_QUIRK(0x104d, 0x9084, "Sony VAIO", ALC275_FIXUP_SONY_HWEQ),
10145         SND_PCI_QUIRK(0x104d, 0x9099, "Sony VAIO S13", ALC275_FIXUP_SONY_DISABLE_AAMIX),
10146         SND_PCI_QUIRK(0x104d, 0x90b5, "Sony VAIO Pro 11", ALC286_FIXUP_SONY_MIC_NO_PRESENCE),
10147         SND_PCI_QUIRK(0x104d, 0x90b6, "Sony VAIO Pro 13", ALC286_FIXUP_SONY_MIC_NO_PRESENCE),
10148         SND_PCI_QUIRK(0x10cf, 0x1475, "Lifebook", ALC269_FIXUP_LIFEBOOK),
10149         SND_PCI_QUIRK(0x10cf, 0x159f, "Lifebook E780", ALC269_FIXUP_LIFEBOOK_NO_HP_TO_LINEOUT),
10150         SND_PCI_QUIRK(0x10cf, 0x15dc, "Lifebook T731", ALC269_FIXUP_LIFEBOOK_HP_PIN),
10151         SND_PCI_QUIRK(0x10cf, 0x1629, "Lifebook U7x7", ALC255_FIXUP_LIFEBOOK_U7x7_HEADSET_MIC),
10152         SND_PCI_QUIRK(0x10cf, 0x1757, "Lifebook E752", ALC269_FIXUP_LIFEBOOK_HP_PIN),
10153         SND_PCI_QUIRK(0x10cf, 0x1845, "Lifebook U904", ALC269_FIXUP_LIFEBOOK_EXTMIC),
10154         SND_PCI_QUIRK(0x10ec, 0x10f2, "Intel Reference board", ALC700_FIXUP_INTEL_REFERENCE),
10155         SND_PCI_QUIRK(0x10ec, 0x118c, "Medion EE4254 MD62100", ALC256_FIXUP_MEDION_HEADSET_NO_PRESENCE),
10156         SND_PCI_QUIRK(0x10ec, 0x1230, "Intel Reference board", ALC295_FIXUP_CHROME_BOOK),
10157         SND_PCI_QUIRK(0x10ec, 0x124c, "Intel Reference board", ALC295_FIXUP_CHROME_BOOK),
10158         SND_PCI_QUIRK(0x10ec, 0x1252, "Intel Reference board", ALC295_FIXUP_CHROME_BOOK),
10159         SND_PCI_QUIRK(0x10ec, 0x1254, "Intel Reference board", ALC295_FIXUP_CHROME_BOOK),
10160         SND_PCI_QUIRK(0x10ec, 0x12cc, "Intel Reference board", ALC295_FIXUP_CHROME_BOOK),
10161         SND_PCI_QUIRK(0x10ec, 0x12f6, "Intel Reference board", ALC295_FIXUP_CHROME_BOOK),
10162         SND_PCI_QUIRK(0x10f7, 0x8338, "Panasonic CF-SZ6", ALC269_FIXUP_HEADSET_MODE),
10163         SND_PCI_QUIRK(0x144d, 0xc109, "Samsung Ativ book 9 (NP900X3G)", ALC269_FIXUP_INV_DMIC),
10164         SND_PCI_QUIRK(0x144d, 0xc169, "Samsung Notebook 9 Pen (NP930SBE-K01US)", ALC298_FIXUP_SAMSUNG_AMP),
10165         SND_PCI_QUIRK(0x144d, 0xc176, "Samsung Notebook 9 Pro (NP930MBE-K04US)", ALC298_FIXUP_SAMSUNG_AMP),
10166         SND_PCI_QUIRK(0x144d, 0xc189, "Samsung Galaxy Flex Book (NT950QCG-X716)", ALC298_FIXUP_SAMSUNG_AMP),
10167         SND_PCI_QUIRK(0x144d, 0xc18a, "Samsung Galaxy Book Ion (NP930XCJ-K01US)", ALC298_FIXUP_SAMSUNG_AMP),
10168         SND_PCI_QUIRK(0x144d, 0xc1a3, "Samsung Galaxy Book Pro (NP935XDB-KC1SE)", ALC298_FIXUP_SAMSUNG_AMP),
10169         SND_PCI_QUIRK(0x144d, 0xc1a6, "Samsung Galaxy Book Pro 360 (NP930QBD)", ALC298_FIXUP_SAMSUNG_AMP),
10170         SND_PCI_QUIRK(0x144d, 0xc740, "Samsung Ativ book 8 (NP870Z5G)", ALC269_FIXUP_ATIV_BOOK_8),
10171         SND_PCI_QUIRK(0x144d, 0xc812, "Samsung Notebook Pen S (NT950SBE-X58)", ALC298_FIXUP_SAMSUNG_AMP),
10172         SND_PCI_QUIRK(0x144d, 0xc830, "Samsung Galaxy Book Ion (NT950XCJ-X716A)", ALC298_FIXUP_SAMSUNG_AMP),
10173         SND_PCI_QUIRK(0x144d, 0xc832, "Samsung Galaxy Book Flex Alpha (NP730QCJ)", ALC256_FIXUP_SAMSUNG_HEADPHONE_VERY_QUIET),
10174         SND_PCI_QUIRK(0x144d, 0xca03, "Samsung Galaxy Book2 Pro 360 (NP930QED)", ALC298_FIXUP_SAMSUNG_AMP),
10175         SND_PCI_QUIRK(0x144d, 0xc868, "Samsung Galaxy Book2 Pro (NP930XED)", ALC298_FIXUP_SAMSUNG_AMP),
10176         SND_PCI_QUIRK(0x1458, 0xfa53, "Gigabyte BXBT-2807", ALC283_FIXUP_HEADSET_MIC),
10177         SND_PCI_QUIRK(0x1462, 0xb120, "MSI Cubi MS-B120", ALC283_FIXUP_HEADSET_MIC),
10178         SND_PCI_QUIRK(0x1462, 0xb171, "Cubi N 8GL (MS-B171)", ALC283_FIXUP_HEADSET_MIC),
10179         SND_PCI_QUIRK(0x152d, 0x1082, "Quanta NL3", ALC269_FIXUP_LIFEBOOK),
10180         SND_PCI_QUIRK(0x1558, 0x0353, "Clevo V35[05]SN[CDE]Q", ALC256_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10181         SND_PCI_QUIRK(0x1558, 0x1323, "Clevo N130ZU", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10182         SND_PCI_QUIRK(0x1558, 0x1325, "Clevo N15[01][CW]U", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10183         SND_PCI_QUIRK(0x1558, 0x1401, "Clevo L140[CZ]U", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10184         SND_PCI_QUIRK(0x1558, 0x1403, "Clevo N140CU", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10185         SND_PCI_QUIRK(0x1558, 0x1404, "Clevo N150CU", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10186         SND_PCI_QUIRK(0x1558, 0x14a1, "Clevo L141MU", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10187         SND_PCI_QUIRK(0x1558, 0x2624, "Clevo L240TU", ALC256_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10188         SND_PCI_QUIRK(0x1558, 0x4018, "Clevo NV40M[BE]", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10189         SND_PCI_QUIRK(0x1558, 0x4019, "Clevo NV40MZ", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10190         SND_PCI_QUIRK(0x1558, 0x4020, "Clevo NV40MB", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10191         SND_PCI_QUIRK(0x1558, 0x4041, "Clevo NV4[15]PZ", ALC256_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10192         SND_PCI_QUIRK(0x1558, 0x40a1, "Clevo NL40GU", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10193         SND_PCI_QUIRK(0x1558, 0x40c1, "Clevo NL40[CZ]U", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10194         SND_PCI_QUIRK(0x1558, 0x40d1, "Clevo NL41DU", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10195         SND_PCI_QUIRK(0x1558, 0x5015, "Clevo NH5[58]H[HJK]Q", ALC256_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10196         SND_PCI_QUIRK(0x1558, 0x5017, "Clevo NH7[79]H[HJK]Q", ALC256_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10197         SND_PCI_QUIRK(0x1558, 0x50a3, "Clevo NJ51GU", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10198         SND_PCI_QUIRK(0x1558, 0x50b3, "Clevo NK50S[BEZ]", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10199         SND_PCI_QUIRK(0x1558, 0x50b6, "Clevo NK50S5", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10200         SND_PCI_QUIRK(0x1558, 0x50b8, "Clevo NK50SZ", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10201         SND_PCI_QUIRK(0x1558, 0x50d5, "Clevo NP50D5", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10202         SND_PCI_QUIRK(0x1558, 0x50e1, "Clevo NH5[58]HPQ", ALC256_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10203         SND_PCI_QUIRK(0x1558, 0x50e2, "Clevo NH7[79]HPQ", ALC256_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10204         SND_PCI_QUIRK(0x1558, 0x50f0, "Clevo NH50A[CDF]", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10205         SND_PCI_QUIRK(0x1558, 0x50f2, "Clevo NH50E[PR]", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10206         SND_PCI_QUIRK(0x1558, 0x50f3, "Clevo NH58DPQ", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10207         SND_PCI_QUIRK(0x1558, 0x50f5, "Clevo NH55EPY", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10208         SND_PCI_QUIRK(0x1558, 0x50f6, "Clevo NH55DPQ", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10209         SND_PCI_QUIRK(0x1558, 0x5101, "Clevo S510WU", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10210         SND_PCI_QUIRK(0x1558, 0x5157, "Clevo W517GU1", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10211         SND_PCI_QUIRK(0x1558, 0x51a1, "Clevo NS50MU", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10212         SND_PCI_QUIRK(0x1558, 0x51b1, "Clevo NS50AU", ALC256_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10213         SND_PCI_QUIRK(0x1558, 0x51b3, "Clevo NS70AU", ALC256_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10214         SND_PCI_QUIRK(0x1558, 0x5630, "Clevo NP50RNJS", ALC256_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10215         SND_PCI_QUIRK(0x1558, 0x70a1, "Clevo NB70T[HJK]", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10216         SND_PCI_QUIRK(0x1558, 0x70b3, "Clevo NK70SB", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10217         SND_PCI_QUIRK(0x1558, 0x70f2, "Clevo NH79EPY", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10218         SND_PCI_QUIRK(0x1558, 0x70f3, "Clevo NH77DPQ", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10219         SND_PCI_QUIRK(0x1558, 0x70f4, "Clevo NH77EPY", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10220         SND_PCI_QUIRK(0x1558, 0x70f6, "Clevo NH77DPQ-Y", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10221         SND_PCI_QUIRK(0x1558, 0x7716, "Clevo NS50PU", ALC256_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10222         SND_PCI_QUIRK(0x1558, 0x7717, "Clevo NS70PU", ALC256_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10223         SND_PCI_QUIRK(0x1558, 0x7718, "Clevo L140PU", ALC256_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10224         SND_PCI_QUIRK(0x1558, 0x7724, "Clevo L140AU", ALC256_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10225         SND_PCI_QUIRK(0x1558, 0x8228, "Clevo NR40BU", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10226         SND_PCI_QUIRK(0x1558, 0x8520, "Clevo NH50D[CD]", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10227         SND_PCI_QUIRK(0x1558, 0x8521, "Clevo NH77D[CD]", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10228         SND_PCI_QUIRK(0x1558, 0x8535, "Clevo NH50D[BE]", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10229         SND_PCI_QUIRK(0x1558, 0x8536, "Clevo NH79D[BE]", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10230         SND_PCI_QUIRK(0x1558, 0x8550, "Clevo NH[57][0-9][ER][ACDH]Q", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10231         SND_PCI_QUIRK(0x1558, 0x8551, "Clevo NH[57][0-9][ER][ACDH]Q", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10232         SND_PCI_QUIRK(0x1558, 0x8560, "Clevo NH[57][0-9][ER][ACDH]Q", ALC269_FIXUP_HEADSET_MIC),
10233         SND_PCI_QUIRK(0x1558, 0x8561, "Clevo NH[57][0-9][ER][ACDH]Q", ALC269_FIXUP_HEADSET_MIC),
10234         SND_PCI_QUIRK(0x1558, 0x8562, "Clevo NH[57][0-9]RZ[Q]", ALC269_FIXUP_DMIC),
10235         SND_PCI_QUIRK(0x1558, 0x8668, "Clevo NP50B[BE]", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10236         SND_PCI_QUIRK(0x1558, 0x866d, "Clevo NP5[05]PN[HJK]", ALC256_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10237         SND_PCI_QUIRK(0x1558, 0x867c, "Clevo NP7[01]PNP", ALC256_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10238         SND_PCI_QUIRK(0x1558, 0x867d, "Clevo NP7[01]PN[HJK]", ALC256_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10239         SND_PCI_QUIRK(0x1558, 0x8680, "Clevo NJ50LU", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10240         SND_PCI_QUIRK(0x1558, 0x8686, "Clevo NH50[CZ]U", ALC256_FIXUP_MIC_NO_PRESENCE_AND_RESUME),
10241         SND_PCI_QUIRK(0x1558, 0x8a20, "Clevo NH55DCQ-Y", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10242         SND_PCI_QUIRK(0x1558, 0x8a51, "Clevo NH70RCQ-Y", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10243         SND_PCI_QUIRK(0x1558, 0x8d50, "Clevo NH55RCQ-M", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10244         SND_PCI_QUIRK(0x1558, 0x951d, "Clevo N950T[CDF]", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10245         SND_PCI_QUIRK(0x1558, 0x9600, "Clevo N960K[PR]", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10246         SND_PCI_QUIRK(0x1558, 0x961d, "Clevo N960S[CDF]", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10247         SND_PCI_QUIRK(0x1558, 0x971d, "Clevo N970T[CDF]", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10248         SND_PCI_QUIRK(0x1558, 0xa500, "Clevo NL5[03]RU", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10249         SND_PCI_QUIRK(0x1558, 0xa600, "Clevo NL50NU", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10250         SND_PCI_QUIRK(0x1558, 0xa650, "Clevo NP[567]0SN[CD]", ALC256_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10251         SND_PCI_QUIRK(0x1558, 0xa671, "Clevo NP70SN[CDE]", ALC256_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10252         SND_PCI_QUIRK(0x1558, 0xb018, "Clevo NP50D[BE]", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10253         SND_PCI_QUIRK(0x1558, 0xb019, "Clevo NH77D[BE]Q", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10254         SND_PCI_QUIRK(0x1558, 0xb022, "Clevo NH77D[DC][QW]", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10255         SND_PCI_QUIRK(0x1558, 0xc018, "Clevo NP50D[BE]", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10256         SND_PCI_QUIRK(0x1558, 0xc019, "Clevo NH77D[BE]Q", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10257         SND_PCI_QUIRK(0x1558, 0xc022, "Clevo NH77[DC][QW]", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10258         SND_PCI_QUIRK(0x17aa, 0x1036, "Lenovo P520", ALC233_FIXUP_LENOVO_MULTI_CODECS),
10259         SND_PCI_QUIRK(0x17aa, 0x1048, "ThinkCentre Station", ALC623_FIXUP_LENOVO_THINKSTATION_P340),
10260         SND_PCI_QUIRK(0x17aa, 0x20f2, "Thinkpad SL410/510", ALC269_FIXUP_SKU_IGNORE),
10261         SND_PCI_QUIRK(0x17aa, 0x215e, "Thinkpad L512", ALC269_FIXUP_SKU_IGNORE),
10262         SND_PCI_QUIRK(0x17aa, 0x21b8, "Thinkpad Edge 14", ALC269_FIXUP_SKU_IGNORE),
10263         SND_PCI_QUIRK(0x17aa, 0x21ca, "Thinkpad L412", ALC269_FIXUP_SKU_IGNORE),
10264         SND_PCI_QUIRK(0x17aa, 0x21e9, "Thinkpad Edge 15", ALC269_FIXUP_SKU_IGNORE),
10265         SND_PCI_QUIRK(0x17aa, 0x21f3, "Thinkpad T430", ALC269_FIXUP_LENOVO_DOCK),
10266         SND_PCI_QUIRK(0x17aa, 0x21f6, "Thinkpad T530", ALC269_FIXUP_LENOVO_DOCK_LIMIT_BOOST),
10267         SND_PCI_QUIRK(0x17aa, 0x21fa, "Thinkpad X230", ALC269_FIXUP_LENOVO_DOCK),
10268         SND_PCI_QUIRK(0x17aa, 0x21fb, "Thinkpad T430s", ALC269_FIXUP_LENOVO_DOCK),
10269         SND_PCI_QUIRK(0x17aa, 0x2203, "Thinkpad X230 Tablet", ALC269_FIXUP_LENOVO_DOCK),
10270         SND_PCI_QUIRK(0x17aa, 0x2208, "Thinkpad T431s", ALC269_FIXUP_LENOVO_DOCK),
10271         SND_PCI_QUIRK(0x17aa, 0x220c, "Thinkpad T440s", ALC292_FIXUP_TPT440),
10272         SND_PCI_QUIRK(0x17aa, 0x220e, "Thinkpad T440p", ALC292_FIXUP_TPT440_DOCK),
10273         SND_PCI_QUIRK(0x17aa, 0x2210, "Thinkpad T540p", ALC292_FIXUP_TPT440_DOCK),
10274         SND_PCI_QUIRK(0x17aa, 0x2211, "Thinkpad W541", ALC292_FIXUP_TPT440_DOCK),
10275         SND_PCI_QUIRK(0x17aa, 0x2212, "Thinkpad T440", ALC292_FIXUP_TPT440_DOCK),
10276         SND_PCI_QUIRK(0x17aa, 0x2214, "Thinkpad X240", ALC292_FIXUP_TPT440_DOCK),
10277         SND_PCI_QUIRK(0x17aa, 0x2215, "Thinkpad", ALC269_FIXUP_LIMIT_INT_MIC_BOOST),
10278         SND_PCI_QUIRK(0x17aa, 0x2218, "Thinkpad X1 Carbon 2nd", ALC292_FIXUP_TPT440_DOCK),
10279         SND_PCI_QUIRK(0x17aa, 0x2223, "ThinkPad T550", ALC292_FIXUP_TPT440_DOCK),
10280         SND_PCI_QUIRK(0x17aa, 0x2226, "ThinkPad X250", ALC292_FIXUP_TPT440_DOCK),
10281         SND_PCI_QUIRK(0x17aa, 0x222d, "Thinkpad", ALC298_FIXUP_TPT470_DOCK),
10282         SND_PCI_QUIRK(0x17aa, 0x222e, "Thinkpad", ALC298_FIXUP_TPT470_DOCK),
10283         SND_PCI_QUIRK(0x17aa, 0x2231, "Thinkpad T560", ALC292_FIXUP_TPT460),
10284         SND_PCI_QUIRK(0x17aa, 0x2233, "Thinkpad", ALC292_FIXUP_TPT460),
10285         SND_PCI_QUIRK(0x17aa, 0x2245, "Thinkpad T470", ALC298_FIXUP_TPT470_DOCK),
10286         SND_PCI_QUIRK(0x17aa, 0x2246, "Thinkpad", ALC298_FIXUP_TPT470_DOCK),
10287         SND_PCI_QUIRK(0x17aa, 0x2247, "Thinkpad", ALC298_FIXUP_TPT470_DOCK),
10288         SND_PCI_QUIRK(0x17aa, 0x2249, "Thinkpad", ALC292_FIXUP_TPT460),
10289         SND_PCI_QUIRK(0x17aa, 0x224b, "Thinkpad", ALC298_FIXUP_TPT470_DOCK),
10290         SND_PCI_QUIRK(0x17aa, 0x224c, "Thinkpad", ALC298_FIXUP_TPT470_DOCK),
10291         SND_PCI_QUIRK(0x17aa, 0x224d, "Thinkpad", ALC298_FIXUP_TPT470_DOCK),
10292         SND_PCI_QUIRK(0x17aa, 0x225d, "Thinkpad T480", ALC269_FIXUP_LIMIT_INT_MIC_BOOST),
10293         SND_PCI_QUIRK(0x17aa, 0x2292, "Thinkpad X1 Carbon 7th", ALC285_FIXUP_THINKPAD_HEADSET_JACK),
10294         SND_PCI_QUIRK(0x17aa, 0x22be, "Thinkpad X1 Carbon 8th", ALC285_FIXUP_THINKPAD_HEADSET_JACK),
10295         SND_PCI_QUIRK(0x17aa, 0x22c1, "Thinkpad P1 Gen 3", ALC285_FIXUP_THINKPAD_NO_BASS_SPK_HEADSET_JACK),
10296         SND_PCI_QUIRK(0x17aa, 0x22c2, "Thinkpad X1 Extreme Gen 3", ALC285_FIXUP_THINKPAD_NO_BASS_SPK_HEADSET_JACK),
10297         SND_PCI_QUIRK(0x17aa, 0x22f1, "Thinkpad", ALC287_FIXUP_MG_RTKC_CSAMP_CS35L41_I2C_THINKPAD),
10298         SND_PCI_QUIRK(0x17aa, 0x22f2, "Thinkpad", ALC287_FIXUP_MG_RTKC_CSAMP_CS35L41_I2C_THINKPAD),
10299         SND_PCI_QUIRK(0x17aa, 0x22f3, "Thinkpad", ALC287_FIXUP_MG_RTKC_CSAMP_CS35L41_I2C_THINKPAD),
10300         SND_PCI_QUIRK(0x17aa, 0x2316, "Thinkpad P1 Gen 6", ALC287_FIXUP_MG_RTKC_CSAMP_CS35L41_I2C_THINKPAD),
10301         SND_PCI_QUIRK(0x17aa, 0x2317, "Thinkpad P1 Gen 6", ALC287_FIXUP_MG_RTKC_CSAMP_CS35L41_I2C_THINKPAD),
10302         SND_PCI_QUIRK(0x17aa, 0x2318, "Thinkpad Z13 Gen2", ALC287_FIXUP_MG_RTKC_CSAMP_CS35L41_I2C_THINKPAD),
10303         SND_PCI_QUIRK(0x17aa, 0x2319, "Thinkpad Z16 Gen2", ALC287_FIXUP_MG_RTKC_CSAMP_CS35L41_I2C_THINKPAD),
10304         SND_PCI_QUIRK(0x17aa, 0x231a, "Thinkpad Z16 Gen2", ALC287_FIXUP_MG_RTKC_CSAMP_CS35L41_I2C_THINKPAD),
10305         SND_PCI_QUIRK(0x17aa, 0x30bb, "ThinkCentre AIO", ALC233_FIXUP_LENOVO_LINE2_MIC_HOTKEY),
10306         SND_PCI_QUIRK(0x17aa, 0x30e2, "ThinkCentre AIO", ALC233_FIXUP_LENOVO_LINE2_MIC_HOTKEY),
10307         SND_PCI_QUIRK(0x17aa, 0x310c, "ThinkCentre Station", ALC294_FIXUP_LENOVO_MIC_LOCATION),
10308         SND_PCI_QUIRK(0x17aa, 0x3111, "ThinkCentre Station", ALC294_FIXUP_LENOVO_MIC_LOCATION),
10309         SND_PCI_QUIRK(0x17aa, 0x312a, "ThinkCentre Station", ALC294_FIXUP_LENOVO_MIC_LOCATION),
10310         SND_PCI_QUIRK(0x17aa, 0x312f, "ThinkCentre Station", ALC294_FIXUP_LENOVO_MIC_LOCATION),
10311         SND_PCI_QUIRK(0x17aa, 0x313c, "ThinkCentre Station", ALC294_FIXUP_LENOVO_MIC_LOCATION),
10312         SND_PCI_QUIRK(0x17aa, 0x3151, "ThinkCentre Station", ALC283_FIXUP_HEADSET_MIC),
10313         SND_PCI_QUIRK(0x17aa, 0x3176, "ThinkCentre Station", ALC283_FIXUP_HEADSET_MIC),
10314         SND_PCI_QUIRK(0x17aa, 0x3178, "ThinkCentre Station", ALC283_FIXUP_HEADSET_MIC),
10315         SND_PCI_QUIRK(0x17aa, 0x31af, "ThinkCentre Station", ALC623_FIXUP_LENOVO_THINKSTATION_P340),
10316         SND_PCI_QUIRK(0x17aa, 0x334b, "Lenovo ThinkCentre M70 Gen5", ALC283_FIXUP_HEADSET_MIC),
10317         SND_PCI_QUIRK(0x17aa, 0x3801, "Lenovo Yoga9 14IAP7", ALC287_FIXUP_YOGA9_14IAP7_BASS_SPK_PIN),
10318         SND_PCI_QUIRK(0x17aa, 0x3802, "Lenovo Yoga Pro 9 14IRP8 / DuetITL 2021", ALC287_FIXUP_LENOVO_14IRP8_DUETITL),
10319         SND_PCI_QUIRK(0x17aa, 0x3813, "Legion 7i 15IMHG05", ALC287_FIXUP_LEGION_15IMHG05_SPEAKERS),
10320         SND_PCI_QUIRK(0x17aa, 0x3818, "Lenovo C940 / Yoga Duet 7", ALC298_FIXUP_LENOVO_C940_DUET7),
10321         SND_PCI_QUIRK(0x17aa, 0x3819, "Lenovo 13s Gen2 ITL", ALC287_FIXUP_13S_GEN2_SPEAKERS),
10322         SND_PCI_QUIRK(0x17aa, 0x3820, "Yoga Duet 7 13ITL6", ALC287_FIXUP_YOGA7_14ITL_SPEAKERS),
10323         SND_PCI_QUIRK(0x17aa, 0x3824, "Legion Y9000X 2020", ALC285_FIXUP_LEGION_Y9000X_SPEAKERS),
10324         SND_PCI_QUIRK(0x17aa, 0x3827, "Ideapad S740", ALC285_FIXUP_IDEAPAD_S740_COEF),
10325         SND_PCI_QUIRK(0x17aa, 0x3834, "Lenovo IdeaPad Slim 9i 14ITL5", ALC287_FIXUP_YOGA7_14ITL_SPEAKERS),
10326         SND_PCI_QUIRK(0x17aa, 0x383d, "Legion Y9000X 2019", ALC285_FIXUP_LEGION_Y9000X_SPEAKERS),
10327         SND_PCI_QUIRK(0x17aa, 0x3843, "Yoga 9i", ALC287_FIXUP_IDEAPAD_BASS_SPK_AMP),
10328         SND_PCI_QUIRK(0x17aa, 0x3847, "Legion 7 16ACHG6", ALC287_FIXUP_LEGION_16ACHG6),
10329         SND_PCI_QUIRK(0x17aa, 0x384a, "Lenovo Yoga 7 15ITL5", ALC287_FIXUP_YOGA7_14ITL_SPEAKERS),
10330         SND_PCI_QUIRK(0x17aa, 0x3852, "Lenovo Yoga 7 14ITL5", ALC287_FIXUP_YOGA7_14ITL_SPEAKERS),
10331         SND_PCI_QUIRK(0x17aa, 0x3853, "Lenovo Yoga 7 15ITL5", ALC287_FIXUP_YOGA7_14ITL_SPEAKERS),
10332         SND_PCI_QUIRK(0x17aa, 0x3855, "Legion 7 16ITHG6", ALC287_FIXUP_LEGION_16ITHG6),
10333         SND_PCI_QUIRK(0x17aa, 0x3869, "Lenovo Yoga7 14IAL7", ALC287_FIXUP_YOGA9_14IAP7_BASS_SPK_PIN),
10334         SND_PCI_QUIRK(0x17aa, 0x386f, "Legion 7i 16IAX7", ALC287_FIXUP_CS35L41_I2C_2),
10335         SND_PCI_QUIRK(0x17aa, 0x3870, "Lenovo Yoga 7 14ARB7", ALC287_FIXUP_YOGA7_14ARB7_I2C),
10336         SND_PCI_QUIRK(0x17aa, 0x387d, "Yoga S780-16 pro Quad AAC", ALC287_FIXUP_TAS2781_I2C),
10337         SND_PCI_QUIRK(0x17aa, 0x387e, "Yoga S780-16 pro Quad YC", ALC287_FIXUP_TAS2781_I2C),
10338         SND_PCI_QUIRK(0x17aa, 0x3881, "YB9 dual power mode2 YC", ALC287_FIXUP_TAS2781_I2C),
10339         SND_PCI_QUIRK(0x17aa, 0x3882, "Lenovo Yoga Pro 7 14APH8", ALC287_FIXUP_YOGA9_14IAP7_BASS_SPK_PIN),
10340         SND_PCI_QUIRK(0x17aa, 0x3884, "Y780 YG DUAL", ALC287_FIXUP_TAS2781_I2C),
10341         SND_PCI_QUIRK(0x17aa, 0x3886, "Y780 VECO DUAL", ALC287_FIXUP_TAS2781_I2C),
10342         SND_PCI_QUIRK(0x17aa, 0x38a7, "Y780P AMD YG dual", ALC287_FIXUP_TAS2781_I2C),
10343         SND_PCI_QUIRK(0x17aa, 0x38a8, "Y780P AMD VECO dual", ALC287_FIXUP_TAS2781_I2C),
10344         SND_PCI_QUIRK(0x17aa, 0x38a9, "Thinkbook 16P", ALC287_FIXUP_CS35L41_I2C_2),
10345         SND_PCI_QUIRK(0x17aa, 0x38ab, "Thinkbook 16P", ALC287_FIXUP_CS35L41_I2C_2),
10346         SND_PCI_QUIRK(0x17aa, 0x38b4, "Legion Slim 7 16IRH8", ALC287_FIXUP_CS35L41_I2C_2),
10347         SND_PCI_QUIRK(0x17aa, 0x38b5, "Legion Slim 7 16IRH8", ALC287_FIXUP_CS35L41_I2C_2),
10348         SND_PCI_QUIRK(0x17aa, 0x38b6, "Legion Slim 7 16APH8", ALC287_FIXUP_CS35L41_I2C_2),
10349         SND_PCI_QUIRK(0x17aa, 0x38b7, "Legion Slim 7 16APH8", ALC287_FIXUP_CS35L41_I2C_2),
10350         SND_PCI_QUIRK(0x17aa, 0x38ba, "Yoga S780-14.5 Air AMD quad YC", ALC287_FIXUP_TAS2781_I2C),
10351         SND_PCI_QUIRK(0x17aa, 0x38bb, "Yoga S780-14.5 Air AMD quad AAC", ALC287_FIXUP_TAS2781_I2C),
10352         SND_PCI_QUIRK(0x17aa, 0x38be, "Yoga S980-14.5 proX YC Dual", ALC287_FIXUP_TAS2781_I2C),
10353         SND_PCI_QUIRK(0x17aa, 0x38bf, "Yoga S980-14.5 proX LX Dual", ALC287_FIXUP_TAS2781_I2C),
10354         SND_PCI_QUIRK(0x17aa, 0x38c3, "Y980 DUAL", ALC287_FIXUP_TAS2781_I2C),
10355         SND_PCI_QUIRK(0x17aa, 0x38cb, "Y790 YG DUAL", ALC287_FIXUP_TAS2781_I2C),
10356         SND_PCI_QUIRK(0x17aa, 0x38cd, "Y790 VECO DUAL", ALC287_FIXUP_TAS2781_I2C),
10357         SND_PCI_QUIRK(0x17aa, 0x38d2, "Lenovo Yoga 9 14IMH9", ALC287_FIXUP_YOGA9_14IMH9_BASS_SPK_PIN),
10358         SND_PCI_QUIRK(0x17aa, 0x38d7, "Lenovo Yoga 9 14IMH9", ALC287_FIXUP_YOGA9_14IMH9_BASS_SPK_PIN),
10359         SND_PCI_QUIRK(0x17aa, 0x3902, "Lenovo E50-80", ALC269_FIXUP_DMIC_THINKPAD_ACPI),
10360         SND_PCI_QUIRK(0x17aa, 0x3977, "IdeaPad S210", ALC283_FIXUP_INT_MIC),
10361         SND_PCI_QUIRK(0x17aa, 0x3978, "Lenovo B50-70", ALC269_FIXUP_DMIC_THINKPAD_ACPI),
10362         SND_PCI_QUIRK(0x17aa, 0x3bf8, "Quanta FL1", ALC269_FIXUP_PCM_44K),
10363         SND_PCI_QUIRK(0x17aa, 0x5013, "Thinkpad", ALC269_FIXUP_LIMIT_INT_MIC_BOOST),
10364         SND_PCI_QUIRK(0x17aa, 0x501a, "Thinkpad", ALC283_FIXUP_INT_MIC),
10365         SND_PCI_QUIRK(0x17aa, 0x501e, "Thinkpad L440", ALC292_FIXUP_TPT440_DOCK),
10366         SND_PCI_QUIRK(0x17aa, 0x5026, "Thinkpad", ALC269_FIXUP_LIMIT_INT_MIC_BOOST),
10367         SND_PCI_QUIRK(0x17aa, 0x5034, "Thinkpad T450", ALC292_FIXUP_TPT440_DOCK),
10368         SND_PCI_QUIRK(0x17aa, 0x5036, "Thinkpad T450s", ALC292_FIXUP_TPT440_DOCK),
10369         SND_PCI_QUIRK(0x17aa, 0x503c, "Thinkpad L450", ALC292_FIXUP_TPT440_DOCK),
10370         SND_PCI_QUIRK(0x17aa, 0x504a, "ThinkPad X260", ALC292_FIXUP_TPT440_DOCK),
10371         SND_PCI_QUIRK(0x17aa, 0x504b, "Thinkpad", ALC293_FIXUP_LENOVO_SPK_NOISE),
10372         SND_PCI_QUIRK(0x17aa, 0x5050, "Thinkpad T560p", ALC292_FIXUP_TPT460),
10373         SND_PCI_QUIRK(0x17aa, 0x5051, "Thinkpad L460", ALC292_FIXUP_TPT460),
10374         SND_PCI_QUIRK(0x17aa, 0x5053, "Thinkpad T460", ALC292_FIXUP_TPT460),
10375         SND_PCI_QUIRK(0x17aa, 0x505d, "Thinkpad", ALC298_FIXUP_TPT470_DOCK),
10376         SND_PCI_QUIRK(0x17aa, 0x505f, "Thinkpad", ALC298_FIXUP_TPT470_DOCK),
10377         SND_PCI_QUIRK(0x17aa, 0x5062, "Thinkpad", ALC298_FIXUP_TPT470_DOCK),
10378         SND_PCI_QUIRK(0x17aa, 0x508b, "Thinkpad X12 Gen 1", ALC287_FIXUP_LEGION_15IMHG05_SPEAKERS),
10379         SND_PCI_QUIRK(0x17aa, 0x5109, "Thinkpad", ALC269_FIXUP_LIMIT_INT_MIC_BOOST),
10380         SND_PCI_QUIRK(0x17aa, 0x511e, "Thinkpad", ALC298_FIXUP_TPT470_DOCK),
10381         SND_PCI_QUIRK(0x17aa, 0x511f, "Thinkpad", ALC298_FIXUP_TPT470_DOCK),
10382         SND_PCI_QUIRK(0x17aa, 0x9e54, "LENOVO NB", ALC269_FIXUP_LENOVO_EAPD),
10383         SND_PCI_QUIRK(0x17aa, 0x9e56, "Lenovo ZhaoYang CF4620Z", ALC286_FIXUP_SONY_MIC_NO_PRESENCE),
10384         SND_PCI_QUIRK(0x1849, 0x1233, "ASRock NUC Box 1100", ALC233_FIXUP_NO_AUDIO_JACK),
10385         SND_PCI_QUIRK(0x1849, 0xa233, "Positivo Master C6300", ALC269_FIXUP_HEADSET_MIC),
10386         SND_PCI_QUIRK(0x1854, 0x0440, "LG CQ6", ALC256_FIXUP_HEADPHONE_AMP_VOL),
10387         SND_PCI_QUIRK(0x1854, 0x0441, "LG CQ6 AIO", ALC256_FIXUP_HEADPHONE_AMP_VOL),
10388         SND_PCI_QUIRK(0x19e5, 0x3204, "Huawei MACH-WX9", ALC256_FIXUP_HUAWEI_MACH_WX9_PINS),
10389         SND_PCI_QUIRK(0x19e5, 0x320f, "Huawei WRT-WX9 ", ALC256_FIXUP_ASUS_MIC_NO_PRESENCE),
10390         SND_PCI_QUIRK(0x1b35, 0x1235, "CZC B20", ALC269_FIXUP_CZC_B20),
10391         SND_PCI_QUIRK(0x1b35, 0x1236, "CZC TMI", ALC269_FIXUP_CZC_TMI),
10392         SND_PCI_QUIRK(0x1b35, 0x1237, "CZC L101", ALC269_FIXUP_CZC_L101),
10393         SND_PCI_QUIRK(0x1b7d, 0xa831, "Ordissimo EVE2 ", ALC269VB_FIXUP_ORDISSIMO_EVE2), /* Also known as Malata PC-B1303 */
10394         SND_PCI_QUIRK(0x1c06, 0x2013, "Lemote A1802", ALC269_FIXUP_LEMOTE_A1802),
10395         SND_PCI_QUIRK(0x1c06, 0x2015, "Lemote A190X", ALC269_FIXUP_LEMOTE_A190X),
10396         SND_PCI_QUIRK(0x1c6c, 0x1251, "Positivo N14KP6-TG", ALC288_FIXUP_DELL1_MIC_NO_PRESENCE),
10397         SND_PCI_QUIRK(0x1d05, 0x1132, "TongFang PHxTxX1", ALC256_FIXUP_SET_COEF_DEFAULTS),
10398         SND_PCI_QUIRK(0x1d05, 0x1096, "TongFang GMxMRxx", ALC269_FIXUP_NO_SHUTUP),
10399         SND_PCI_QUIRK(0x1d05, 0x1100, "TongFang GKxNRxx", ALC269_FIXUP_NO_SHUTUP),
10400         SND_PCI_QUIRK(0x1d05, 0x1111, "TongFang GMxZGxx", ALC269_FIXUP_NO_SHUTUP),
10401         SND_PCI_QUIRK(0x1d05, 0x1119, "TongFang GMxZGxx", ALC269_FIXUP_NO_SHUTUP),
10402         SND_PCI_QUIRK(0x1d05, 0x1129, "TongFang GMxZGxx", ALC269_FIXUP_NO_SHUTUP),
10403         SND_PCI_QUIRK(0x1d05, 0x1147, "TongFang GMxTGxx", ALC269_FIXUP_NO_SHUTUP),
10404         SND_PCI_QUIRK(0x1d05, 0x115c, "TongFang GMxTGxx", ALC269_FIXUP_NO_SHUTUP),
10405         SND_PCI_QUIRK(0x1d05, 0x121b, "TongFang GMxAGxx", ALC269_FIXUP_NO_SHUTUP),
10406         SND_PCI_QUIRK(0x1d72, 0x1602, "RedmiBook", ALC255_FIXUP_XIAOMI_HEADSET_MIC),
10407         SND_PCI_QUIRK(0x1d72, 0x1701, "XiaomiNotebook Pro", ALC298_FIXUP_DELL1_MIC_NO_PRESENCE),
10408         SND_PCI_QUIRK(0x1d72, 0x1901, "RedmiBook 14", ALC256_FIXUP_ASUS_HEADSET_MIC),
10409         SND_PCI_QUIRK(0x1d72, 0x1945, "Redmi G", ALC256_FIXUP_ASUS_HEADSET_MIC),
10410         SND_PCI_QUIRK(0x1d72, 0x1947, "RedmiBook Air", ALC255_FIXUP_XIAOMI_HEADSET_MIC),
10411         SND_PCI_QUIRK(0x2782, 0x0232, "CHUWI CoreBook XPro", ALC269VB_FIXUP_CHUWI_COREBOOK_XPRO),
10412         SND_PCI_QUIRK(0x2782, 0x1707, "Vaio VJFE-ADL", ALC298_FIXUP_SPK_VOLUME),
10413         SND_PCI_QUIRK(0x8086, 0x2074, "Intel NUC 8", ALC233_FIXUP_INTEL_NUC8_DMIC),
10414         SND_PCI_QUIRK(0x8086, 0x2080, "Intel NUC 8 Rugged", ALC256_FIXUP_INTEL_NUC8_RUGGED),
10415         SND_PCI_QUIRK(0x8086, 0x2081, "Intel NUC 10", ALC256_FIXUP_INTEL_NUC10),
10416         SND_PCI_QUIRK(0x8086, 0x3038, "Intel NUC 13", ALC295_FIXUP_CHROME_BOOK),
10417         SND_PCI_QUIRK(0xf111, 0x0001, "Framework Laptop", ALC295_FIXUP_FRAMEWORK_LAPTOP_MIC_NO_PRESENCE),
10418         SND_PCI_QUIRK(0xf111, 0x0005, "Framework Laptop", ALC295_FIXUP_FRAMEWORK_LAPTOP_MIC_NO_PRESENCE),
10419         SND_PCI_QUIRK(0xf111, 0x0006, "Framework Laptop", ALC295_FIXUP_FRAMEWORK_LAPTOP_MIC_NO_PRESENCE),
10420
10421 #if 0
10422         /* Below is a quirk table taken from the old code.
10423          * Basically the device should work as is without the fixup table.
10424          * If BIOS doesn't give a proper info, enable the corresponding
10425          * fixup entry.
10426          */
10427         SND_PCI_QUIRK(0x1043, 0x8330, "ASUS Eeepc P703 P900A",
10428                       ALC269_FIXUP_AMIC),
10429         SND_PCI_QUIRK(0x1043, 0x1013, "ASUS N61Da", ALC269_FIXUP_AMIC),
10430         SND_PCI_QUIRK(0x1043, 0x1143, "ASUS B53f", ALC269_FIXUP_AMIC),
10431         SND_PCI_QUIRK(0x1043, 0x1133, "ASUS UJ20ft", ALC269_FIXUP_AMIC),
10432         SND_PCI_QUIRK(0x1043, 0x1183, "ASUS K72DR", ALC269_FIXUP_AMIC),
10433         SND_PCI_QUIRK(0x1043, 0x11b3, "ASUS K52DR", ALC269_FIXUP_AMIC),
10434         SND_PCI_QUIRK(0x1043, 0x11e3, "ASUS U33Jc", ALC269_FIXUP_AMIC),
10435         SND_PCI_QUIRK(0x1043, 0x1273, "ASUS UL80Jt", ALC269_FIXUP_AMIC),
10436         SND_PCI_QUIRK(0x1043, 0x1283, "ASUS U53Jc", ALC269_FIXUP_AMIC),
10437         SND_PCI_QUIRK(0x1043, 0x12b3, "ASUS N82JV", ALC269_FIXUP_AMIC),
10438         SND_PCI_QUIRK(0x1043, 0x12d3, "ASUS N61Jv", ALC269_FIXUP_AMIC),
10439         SND_PCI_QUIRK(0x1043, 0x13a3, "ASUS UL30Vt", ALC269_FIXUP_AMIC),
10440         SND_PCI_QUIRK(0x1043, 0x1373, "ASUS G73JX", ALC269_FIXUP_AMIC),
10441         SND_PCI_QUIRK(0x1043, 0x1383, "ASUS UJ30Jc", ALC269_FIXUP_AMIC),
10442         SND_PCI_QUIRK(0x1043, 0x13d3, "ASUS N61JA", ALC269_FIXUP_AMIC),
10443         SND_PCI_QUIRK(0x1043, 0x1413, "ASUS UL50", ALC269_FIXUP_AMIC),
10444         SND_PCI_QUIRK(0x1043, 0x1443, "ASUS UL30", ALC269_FIXUP_AMIC),
10445         SND_PCI_QUIRK(0x1043, 0x1453, "ASUS M60Jv", ALC269_FIXUP_AMIC),
10446         SND_PCI_QUIRK(0x1043, 0x1483, "ASUS UL80", ALC269_FIXUP_AMIC),
10447         SND_PCI_QUIRK(0x1043, 0x14f3, "ASUS F83Vf", ALC269_FIXUP_AMIC),
10448         SND_PCI_QUIRK(0x1043, 0x14e3, "ASUS UL20", ALC269_FIXUP_AMIC),
10449         SND_PCI_QUIRK(0x1043, 0x1513, "ASUS UX30", ALC269_FIXUP_AMIC),
10450         SND_PCI_QUIRK(0x1043, 0x1593, "ASUS N51Vn", ALC269_FIXUP_AMIC),
10451         SND_PCI_QUIRK(0x1043, 0x15a3, "ASUS N60Jv", ALC269_FIXUP_AMIC),
10452         SND_PCI_QUIRK(0x1043, 0x15b3, "ASUS N60Dp", ALC269_FIXUP_AMIC),
10453         SND_PCI_QUIRK(0x1043, 0x15c3, "ASUS N70De", ALC269_FIXUP_AMIC),
10454         SND_PCI_QUIRK(0x1043, 0x15e3, "ASUS F83T", ALC269_FIXUP_AMIC),
10455         SND_PCI_QUIRK(0x1043, 0x1643, "ASUS M60J", ALC269_FIXUP_AMIC),
10456         SND_PCI_QUIRK(0x1043, 0x1653, "ASUS U50", ALC269_FIXUP_AMIC),
10457         SND_PCI_QUIRK(0x1043, 0x1693, "ASUS F50N", ALC269_FIXUP_AMIC),
10458         SND_PCI_QUIRK(0x1043, 0x16a3, "ASUS F5Q", ALC269_FIXUP_AMIC),
10459         SND_PCI_QUIRK(0x1043, 0x1723, "ASUS P80", ALC269_FIXUP_AMIC),
10460         SND_PCI_QUIRK(0x1043, 0x1743, "ASUS U80", ALC269_FIXUP_AMIC),
10461         SND_PCI_QUIRK(0x1043, 0x1773, "ASUS U20A", ALC269_FIXUP_AMIC),
10462         SND_PCI_QUIRK(0x1043, 0x1883, "ASUS F81Se", ALC269_FIXUP_AMIC),
10463         SND_PCI_QUIRK(0x152d, 0x1778, "Quanta ON1", ALC269_FIXUP_DMIC),
10464         SND_PCI_QUIRK(0x17aa, 0x3be9, "Quanta Wistron", ALC269_FIXUP_AMIC),
10465         SND_PCI_QUIRK(0x17aa, 0x3bf8, "Quanta FL1", ALC269_FIXUP_AMIC),
10466         SND_PCI_QUIRK(0x17ff, 0x059a, "Quanta EL3", ALC269_FIXUP_DMIC),
10467         SND_PCI_QUIRK(0x17ff, 0x059b, "Quanta JR1", ALC269_FIXUP_DMIC),
10468 #endif
10469         {}
10470 };
10471
10472 static const struct snd_pci_quirk alc269_fixup_vendor_tbl[] = {
10473         SND_PCI_QUIRK_VENDOR(0x1025, "Acer Aspire", ALC271_FIXUP_DMIC),
10474         SND_PCI_QUIRK_VENDOR(0x103c, "HP", ALC269_FIXUP_HP_MUTE_LED),
10475         SND_PCI_QUIRK_VENDOR(0x104d, "Sony VAIO", ALC269_FIXUP_SONY_VAIO),
10476         SND_PCI_QUIRK_VENDOR(0x17aa, "Thinkpad", ALC269_FIXUP_THINKPAD_ACPI),
10477         SND_PCI_QUIRK_VENDOR(0x19e5, "Huawei Matebook", ALC255_FIXUP_MIC_MUTE_LED),
10478         {}
10479 };
10480
10481 static const struct hda_model_fixup alc269_fixup_models[] = {
10482         {.id = ALC269_FIXUP_AMIC, .name = "laptop-amic"},
10483         {.id = ALC269_FIXUP_DMIC, .name = "laptop-dmic"},
10484         {.id = ALC269_FIXUP_STEREO_DMIC, .name = "alc269-dmic"},
10485         {.id = ALC271_FIXUP_DMIC, .name = "alc271-dmic"},
10486         {.id = ALC269_FIXUP_INV_DMIC, .name = "inv-dmic"},
10487         {.id = ALC269_FIXUP_HEADSET_MIC, .name = "headset-mic"},
10488         {.id = ALC269_FIXUP_HEADSET_MODE, .name = "headset-mode"},
10489         {.id = ALC269_FIXUP_HEADSET_MODE_NO_HP_MIC, .name = "headset-mode-no-hp-mic"},
10490         {.id = ALC269_FIXUP_LENOVO_DOCK, .name = "lenovo-dock"},
10491         {.id = ALC269_FIXUP_LENOVO_DOCK_LIMIT_BOOST, .name = "lenovo-dock-limit-boost"},
10492         {.id = ALC269_FIXUP_HP_GPIO_LED, .name = "hp-gpio-led"},
10493         {.id = ALC269_FIXUP_HP_DOCK_GPIO_MIC1_LED, .name = "hp-dock-gpio-mic1-led"},
10494         {.id = ALC269_FIXUP_DELL1_MIC_NO_PRESENCE, .name = "dell-headset-multi"},
10495         {.id = ALC269_FIXUP_DELL2_MIC_NO_PRESENCE, .name = "dell-headset-dock"},
10496         {.id = ALC269_FIXUP_DELL3_MIC_NO_PRESENCE, .name = "dell-headset3"},
10497         {.id = ALC269_FIXUP_DELL4_MIC_NO_PRESENCE, .name = "dell-headset4"},
10498         {.id = ALC283_FIXUP_CHROME_BOOK, .name = "alc283-dac-wcaps"},
10499         {.id = ALC283_FIXUP_SENSE_COMBO_JACK, .name = "alc283-sense-combo"},
10500         {.id = ALC292_FIXUP_TPT440_DOCK, .name = "tpt440-dock"},
10501         {.id = ALC292_FIXUP_TPT440, .name = "tpt440"},
10502         {.id = ALC292_FIXUP_TPT460, .name = "tpt460"},
10503         {.id = ALC298_FIXUP_TPT470_DOCK_FIX, .name = "tpt470-dock-fix"},
10504         {.id = ALC298_FIXUP_TPT470_DOCK, .name = "tpt470-dock"},
10505         {.id = ALC233_FIXUP_LENOVO_MULTI_CODECS, .name = "dual-codecs"},
10506         {.id = ALC700_FIXUP_INTEL_REFERENCE, .name = "alc700-ref"},
10507         {.id = ALC269_FIXUP_SONY_VAIO, .name = "vaio"},
10508         {.id = ALC269_FIXUP_DELL_M101Z, .name = "dell-m101z"},
10509         {.id = ALC269_FIXUP_ASUS_G73JW, .name = "asus-g73jw"},
10510         {.id = ALC269_FIXUP_LENOVO_EAPD, .name = "lenovo-eapd"},
10511         {.id = ALC275_FIXUP_SONY_HWEQ, .name = "sony-hweq"},
10512         {.id = ALC269_FIXUP_PCM_44K, .name = "pcm44k"},
10513         {.id = ALC269_FIXUP_LIFEBOOK, .name = "lifebook"},
10514         {.id = ALC269_FIXUP_LIFEBOOK_EXTMIC, .name = "lifebook-extmic"},
10515         {.id = ALC269_FIXUP_LIFEBOOK_HP_PIN, .name = "lifebook-hp-pin"},
10516         {.id = ALC255_FIXUP_LIFEBOOK_U7x7_HEADSET_MIC, .name = "lifebook-u7x7"},
10517         {.id = ALC269VB_FIXUP_AMIC, .name = "alc269vb-amic"},
10518         {.id = ALC269VB_FIXUP_DMIC, .name = "alc269vb-dmic"},
10519         {.id = ALC269_FIXUP_HP_MUTE_LED_MIC1, .name = "hp-mute-led-mic1"},
10520         {.id = ALC269_FIXUP_HP_MUTE_LED_MIC2, .name = "hp-mute-led-mic2"},
10521         {.id = ALC269_FIXUP_HP_MUTE_LED_MIC3, .name = "hp-mute-led-mic3"},
10522         {.id = ALC269_FIXUP_HP_GPIO_MIC1_LED, .name = "hp-gpio-mic1"},
10523         {.id = ALC269_FIXUP_HP_LINE1_MIC1_LED, .name = "hp-line1-mic1"},
10524         {.id = ALC269_FIXUP_NO_SHUTUP, .name = "noshutup"},
10525         {.id = ALC286_FIXUP_SONY_MIC_NO_PRESENCE, .name = "sony-nomic"},
10526         {.id = ALC269_FIXUP_ASPIRE_HEADSET_MIC, .name = "aspire-headset-mic"},
10527         {.id = ALC269_FIXUP_ASUS_X101, .name = "asus-x101"},
10528         {.id = ALC271_FIXUP_HP_GATE_MIC_JACK, .name = "acer-ao7xx"},
10529         {.id = ALC271_FIXUP_HP_GATE_MIC_JACK_E1_572, .name = "acer-aspire-e1"},
10530         {.id = ALC269_FIXUP_ACER_AC700, .name = "acer-ac700"},
10531         {.id = ALC269_FIXUP_LIMIT_INT_MIC_BOOST, .name = "limit-mic-boost"},
10532         {.id = ALC269VB_FIXUP_ASUS_ZENBOOK, .name = "asus-zenbook"},
10533         {.id = ALC269VB_FIXUP_ASUS_ZENBOOK_UX31A, .name = "asus-zenbook-ux31a"},
10534         {.id = ALC269VB_FIXUP_ORDISSIMO_EVE2, .name = "ordissimo"},
10535         {.id = ALC282_FIXUP_ASUS_TX300, .name = "asus-tx300"},
10536         {.id = ALC283_FIXUP_INT_MIC, .name = "alc283-int-mic"},
10537         {.id = ALC290_FIXUP_MONO_SPEAKERS_HSJACK, .name = "mono-speakers"},
10538         {.id = ALC290_FIXUP_SUBWOOFER_HSJACK, .name = "alc290-subwoofer"},
10539         {.id = ALC269_FIXUP_THINKPAD_ACPI, .name = "thinkpad"},
10540         {.id = ALC269_FIXUP_DMIC_THINKPAD_ACPI, .name = "dmic-thinkpad"},
10541         {.id = ALC255_FIXUP_ACER_MIC_NO_PRESENCE, .name = "alc255-acer"},
10542         {.id = ALC255_FIXUP_ASUS_MIC_NO_PRESENCE, .name = "alc255-asus"},
10543         {.id = ALC255_FIXUP_DELL1_MIC_NO_PRESENCE, .name = "alc255-dell1"},
10544         {.id = ALC255_FIXUP_DELL2_MIC_NO_PRESENCE, .name = "alc255-dell2"},
10545         {.id = ALC293_FIXUP_DELL1_MIC_NO_PRESENCE, .name = "alc293-dell1"},
10546         {.id = ALC283_FIXUP_HEADSET_MIC, .name = "alc283-headset"},
10547         {.id = ALC255_FIXUP_MIC_MUTE_LED, .name = "alc255-dell-mute"},
10548         {.id = ALC282_FIXUP_ASPIRE_V5_PINS, .name = "aspire-v5"},
10549         {.id = ALC269VB_FIXUP_ASPIRE_E1_COEF, .name = "aspire-e1-coef"},
10550         {.id = ALC280_FIXUP_HP_GPIO4, .name = "hp-gpio4"},
10551         {.id = ALC286_FIXUP_HP_GPIO_LED, .name = "hp-gpio-led"},
10552         {.id = ALC280_FIXUP_HP_GPIO2_MIC_HOTKEY, .name = "hp-gpio2-hotkey"},
10553         {.id = ALC280_FIXUP_HP_DOCK_PINS, .name = "hp-dock-pins"},
10554         {.id = ALC269_FIXUP_HP_DOCK_GPIO_MIC1_LED, .name = "hp-dock-gpio-mic"},
10555         {.id = ALC280_FIXUP_HP_9480M, .name = "hp-9480m"},
10556         {.id = ALC288_FIXUP_DELL_HEADSET_MODE, .name = "alc288-dell-headset"},
10557         {.id = ALC288_FIXUP_DELL1_MIC_NO_PRESENCE, .name = "alc288-dell1"},
10558         {.id = ALC288_FIXUP_DELL_XPS_13, .name = "alc288-dell-xps13"},
10559         {.id = ALC292_FIXUP_DELL_E7X, .name = "dell-e7x"},
10560         {.id = ALC293_FIXUP_DISABLE_AAMIX_MULTIJACK, .name = "alc293-dell"},
10561         {.id = ALC298_FIXUP_DELL1_MIC_NO_PRESENCE, .name = "alc298-dell1"},
10562         {.id = ALC298_FIXUP_DELL_AIO_MIC_NO_PRESENCE, .name = "alc298-dell-aio"},
10563         {.id = ALC275_FIXUP_DELL_XPS, .name = "alc275-dell-xps"},
10564         {.id = ALC293_FIXUP_LENOVO_SPK_NOISE, .name = "lenovo-spk-noise"},
10565         {.id = ALC233_FIXUP_LENOVO_LINE2_MIC_HOTKEY, .name = "lenovo-hotkey"},
10566         {.id = ALC255_FIXUP_DELL_SPK_NOISE, .name = "dell-spk-noise"},
10567         {.id = ALC225_FIXUP_DELL1_MIC_NO_PRESENCE, .name = "alc225-dell1"},
10568         {.id = ALC295_FIXUP_DISABLE_DAC3, .name = "alc295-disable-dac3"},
10569         {.id = ALC285_FIXUP_SPEAKER2_TO_DAC1, .name = "alc285-speaker2-to-dac1"},
10570         {.id = ALC280_FIXUP_HP_HEADSET_MIC, .name = "alc280-hp-headset"},
10571         {.id = ALC221_FIXUP_HP_FRONT_MIC, .name = "alc221-hp-mic"},
10572         {.id = ALC298_FIXUP_SPK_VOLUME, .name = "alc298-spk-volume"},
10573         {.id = ALC256_FIXUP_DELL_INSPIRON_7559_SUBWOOFER, .name = "dell-inspiron-7559"},
10574         {.id = ALC269_FIXUP_ATIV_BOOK_8, .name = "ativ-book"},
10575         {.id = ALC221_FIXUP_HP_MIC_NO_PRESENCE, .name = "alc221-hp-mic"},
10576         {.id = ALC256_FIXUP_ASUS_HEADSET_MODE, .name = "alc256-asus-headset"},
10577         {.id = ALC256_FIXUP_ASUS_MIC, .name = "alc256-asus-mic"},
10578         {.id = ALC256_FIXUP_ASUS_AIO_GPIO2, .name = "alc256-asus-aio"},
10579         {.id = ALC233_FIXUP_ASUS_MIC_NO_PRESENCE, .name = "alc233-asus"},
10580         {.id = ALC233_FIXUP_EAPD_COEF_AND_MIC_NO_PRESENCE, .name = "alc233-eapd"},
10581         {.id = ALC294_FIXUP_LENOVO_MIC_LOCATION, .name = "alc294-lenovo-mic"},
10582         {.id = ALC225_FIXUP_DELL_WYSE_MIC_NO_PRESENCE, .name = "alc225-wyse"},
10583         {.id = ALC274_FIXUP_DELL_AIO_LINEOUT_VERB, .name = "alc274-dell-aio"},
10584         {.id = ALC255_FIXUP_DUMMY_LINEOUT_VERB, .name = "alc255-dummy-lineout"},
10585         {.id = ALC255_FIXUP_DELL_HEADSET_MIC, .name = "alc255-dell-headset"},
10586         {.id = ALC295_FIXUP_HP_X360, .name = "alc295-hp-x360"},
10587         {.id = ALC225_FIXUP_HEADSET_JACK, .name = "alc-headset-jack"},
10588         {.id = ALC295_FIXUP_CHROME_BOOK, .name = "alc-chrome-book"},
10589         {.id = ALC299_FIXUP_PREDATOR_SPK, .name = "predator-spk"},
10590         {.id = ALC298_FIXUP_HUAWEI_MBX_STEREO, .name = "huawei-mbx-stereo"},
10591         {.id = ALC256_FIXUP_MEDION_HEADSET_NO_PRESENCE, .name = "alc256-medion-headset"},
10592         {.id = ALC298_FIXUP_SAMSUNG_AMP, .name = "alc298-samsung-amp"},
10593         {.id = ALC256_FIXUP_SAMSUNG_HEADPHONE_VERY_QUIET, .name = "alc256-samsung-headphone"},
10594         {.id = ALC255_FIXUP_XIAOMI_HEADSET_MIC, .name = "alc255-xiaomi-headset"},
10595         {.id = ALC274_FIXUP_HP_MIC, .name = "alc274-hp-mic-detect"},
10596         {.id = ALC245_FIXUP_HP_X360_AMP, .name = "alc245-hp-x360-amp"},
10597         {.id = ALC295_FIXUP_HP_OMEN, .name = "alc295-hp-omen"},
10598         {.id = ALC285_FIXUP_HP_SPECTRE_X360, .name = "alc285-hp-spectre-x360"},
10599         {.id = ALC285_FIXUP_HP_SPECTRE_X360_EB1, .name = "alc285-hp-spectre-x360-eb1"},
10600         {.id = ALC285_FIXUP_HP_ENVY_X360, .name = "alc285-hp-envy-x360"},
10601         {.id = ALC287_FIXUP_IDEAPAD_BASS_SPK_AMP, .name = "alc287-ideapad-bass-spk-amp"},
10602         {.id = ALC287_FIXUP_YOGA9_14IAP7_BASS_SPK_PIN, .name = "alc287-yoga9-bass-spk-pin"},
10603         {.id = ALC623_FIXUP_LENOVO_THINKSTATION_P340, .name = "alc623-lenovo-thinkstation-p340"},
10604         {.id = ALC255_FIXUP_ACER_HEADPHONE_AND_MIC, .name = "alc255-acer-headphone-and-mic"},
10605         {.id = ALC285_FIXUP_HP_GPIO_AMP_INIT, .name = "alc285-hp-amp-init"},
10606         {}
10607 };
10608 #define ALC225_STANDARD_PINS \
10609         {0x21, 0x04211020}
10610
10611 #define ALC256_STANDARD_PINS \
10612         {0x12, 0x90a60140}, \
10613         {0x14, 0x90170110}, \
10614         {0x21, 0x02211020}
10615
10616 #define ALC282_STANDARD_PINS \
10617         {0x14, 0x90170110}
10618
10619 #define ALC290_STANDARD_PINS \
10620         {0x12, 0x99a30130}
10621
10622 #define ALC292_STANDARD_PINS \
10623         {0x14, 0x90170110}, \
10624         {0x15, 0x0221401f}
10625
10626 #define ALC295_STANDARD_PINS \
10627         {0x12, 0xb7a60130}, \
10628         {0x14, 0x90170110}, \
10629         {0x21, 0x04211020}
10630
10631 #define ALC298_STANDARD_PINS \
10632         {0x12, 0x90a60130}, \
10633         {0x21, 0x03211020}
10634
10635 static const struct snd_hda_pin_quirk alc269_pin_fixup_tbl[] = {
10636         SND_HDA_PIN_QUIRK(0x10ec0221, 0x103c, "HP Workstation", ALC221_FIXUP_HP_HEADSET_MIC,
10637                 {0x14, 0x01014020},
10638                 {0x17, 0x90170110},
10639                 {0x18, 0x02a11030},
10640                 {0x19, 0x0181303F},
10641                 {0x21, 0x0221102f}),
10642         SND_HDA_PIN_QUIRK(0x10ec0255, 0x1025, "Acer", ALC255_FIXUP_ACER_MIC_NO_PRESENCE,
10643                 {0x12, 0x90a601c0},
10644                 {0x14, 0x90171120},
10645                 {0x21, 0x02211030}),
10646         SND_HDA_PIN_QUIRK(0x10ec0255, 0x1043, "ASUS", ALC255_FIXUP_ASUS_MIC_NO_PRESENCE,
10647                 {0x14, 0x90170110},
10648                 {0x1b, 0x90a70130},
10649                 {0x21, 0x03211020}),
10650         SND_HDA_PIN_QUIRK(0x10ec0255, 0x1043, "ASUS", ALC255_FIXUP_ASUS_MIC_NO_PRESENCE,
10651                 {0x1a, 0x90a70130},
10652                 {0x1b, 0x90170110},
10653                 {0x21, 0x03211020}),
10654         SND_HDA_PIN_QUIRK(0x10ec0225, 0x1028, "Dell", ALC225_FIXUP_DELL1_MIC_NO_PRESENCE,
10655                 ALC225_STANDARD_PINS,
10656                 {0x12, 0xb7a60130},
10657                 {0x14, 0x901701a0}),
10658         SND_HDA_PIN_QUIRK(0x10ec0225, 0x1028, "Dell", ALC225_FIXUP_DELL1_MIC_NO_PRESENCE,
10659                 ALC225_STANDARD_PINS,
10660                 {0x12, 0xb7a60130},
10661                 {0x14, 0x901701b0}),
10662         SND_HDA_PIN_QUIRK(0x10ec0225, 0x1028, "Dell", ALC225_FIXUP_DELL1_MIC_NO_PRESENCE,
10663                 ALC225_STANDARD_PINS,
10664                 {0x12, 0xb7a60150},
10665                 {0x14, 0x901701a0}),
10666         SND_HDA_PIN_QUIRK(0x10ec0225, 0x1028, "Dell", ALC225_FIXUP_DELL1_MIC_NO_PRESENCE,
10667                 ALC225_STANDARD_PINS,
10668                 {0x12, 0xb7a60150},
10669                 {0x14, 0x901701b0}),
10670         SND_HDA_PIN_QUIRK(0x10ec0225, 0x1028, "Dell", ALC225_FIXUP_DELL1_MIC_NO_PRESENCE,
10671                 ALC225_STANDARD_PINS,
10672                 {0x12, 0xb7a60130},
10673                 {0x1b, 0x90170110}),
10674         SND_HDA_PIN_QUIRK(0x10ec0233, 0x8086, "Intel NUC Skull Canyon", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE,
10675                 {0x1b, 0x01111010},
10676                 {0x1e, 0x01451130},
10677                 {0x21, 0x02211020}),
10678         SND_HDA_PIN_QUIRK(0x10ec0235, 0x17aa, "Lenovo", ALC233_FIXUP_LENOVO_LINE2_MIC_HOTKEY,
10679                 {0x12, 0x90a60140},
10680                 {0x14, 0x90170110},
10681                 {0x19, 0x02a11030},
10682                 {0x21, 0x02211020}),
10683         SND_HDA_PIN_QUIRK(0x10ec0235, 0x17aa, "Lenovo", ALC294_FIXUP_LENOVO_MIC_LOCATION,
10684                 {0x14, 0x90170110},
10685                 {0x19, 0x02a11030},
10686                 {0x1a, 0x02a11040},
10687                 {0x1b, 0x01014020},
10688                 {0x21, 0x0221101f}),
10689         SND_HDA_PIN_QUIRK(0x10ec0235, 0x17aa, "Lenovo", ALC294_FIXUP_LENOVO_MIC_LOCATION,
10690                 {0x14, 0x90170110},
10691                 {0x19, 0x02a11030},
10692                 {0x1a, 0x02a11040},
10693                 {0x1b, 0x01011020},
10694                 {0x21, 0x0221101f}),
10695         SND_HDA_PIN_QUIRK(0x10ec0235, 0x17aa, "Lenovo", ALC294_FIXUP_LENOVO_MIC_LOCATION,
10696                 {0x14, 0x90170110},
10697                 {0x19, 0x02a11020},
10698                 {0x1a, 0x02a11030},
10699                 {0x21, 0x0221101f}),
10700         SND_HDA_PIN_QUIRK(0x10ec0236, 0x1028, "Dell", ALC236_FIXUP_DELL_AIO_HEADSET_MIC,
10701                 {0x21, 0x02211010}),
10702         SND_HDA_PIN_QUIRK(0x10ec0236, 0x103c, "HP", ALC256_FIXUP_HP_HEADSET_MIC,
10703                 {0x14, 0x90170110},
10704                 {0x19, 0x02a11020},
10705                 {0x21, 0x02211030}),
10706         SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL2_MIC_NO_PRESENCE,
10707                 {0x14, 0x90170110},
10708                 {0x21, 0x02211020}),
10709         SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
10710                 {0x14, 0x90170130},
10711                 {0x21, 0x02211040}),
10712         SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
10713                 {0x12, 0x90a60140},
10714                 {0x14, 0x90170110},
10715                 {0x21, 0x02211020}),
10716         SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
10717                 {0x12, 0x90a60160},
10718                 {0x14, 0x90170120},
10719                 {0x21, 0x02211030}),
10720         SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
10721                 {0x14, 0x90170110},
10722                 {0x1b, 0x02011020},
10723                 {0x21, 0x0221101f}),
10724         SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
10725                 {0x14, 0x90170110},
10726                 {0x1b, 0x01011020},
10727                 {0x21, 0x0221101f}),
10728         SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
10729                 {0x14, 0x90170130},
10730                 {0x1b, 0x01014020},
10731                 {0x21, 0x0221103f}),
10732         SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
10733                 {0x14, 0x90170130},
10734                 {0x1b, 0x01011020},
10735                 {0x21, 0x0221103f}),
10736         SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
10737                 {0x14, 0x90170130},
10738                 {0x1b, 0x02011020},
10739                 {0x21, 0x0221103f}),
10740         SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
10741                 {0x14, 0x90170150},
10742                 {0x1b, 0x02011020},
10743                 {0x21, 0x0221105f}),
10744         SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
10745                 {0x14, 0x90170110},
10746                 {0x1b, 0x01014020},
10747                 {0x21, 0x0221101f}),
10748         SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
10749                 {0x12, 0x90a60160},
10750                 {0x14, 0x90170120},
10751                 {0x17, 0x90170140},
10752                 {0x21, 0x0321102f}),
10753         SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
10754                 {0x12, 0x90a60160},
10755                 {0x14, 0x90170130},
10756                 {0x21, 0x02211040}),
10757         SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
10758                 {0x12, 0x90a60160},
10759                 {0x14, 0x90170140},
10760                 {0x21, 0x02211050}),
10761         SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
10762                 {0x12, 0x90a60170},
10763                 {0x14, 0x90170120},
10764                 {0x21, 0x02211030}),
10765         SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
10766                 {0x12, 0x90a60170},
10767                 {0x14, 0x90170130},
10768                 {0x21, 0x02211040}),
10769         SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
10770                 {0x12, 0x90a60170},
10771                 {0x14, 0x90171130},
10772                 {0x21, 0x02211040}),
10773         SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
10774                 {0x12, 0x90a60170},
10775                 {0x14, 0x90170140},
10776                 {0x21, 0x02211050}),
10777         SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell Inspiron 5548", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
10778                 {0x12, 0x90a60180},
10779                 {0x14, 0x90170130},
10780                 {0x21, 0x02211040}),
10781         SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell Inspiron 5565", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
10782                 {0x12, 0x90a60180},
10783                 {0x14, 0x90170120},
10784                 {0x21, 0x02211030}),
10785         SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
10786                 {0x1b, 0x01011020},
10787                 {0x21, 0x02211010}),
10788         SND_HDA_PIN_QUIRK(0x10ec0256, 0x1043, "ASUS", ALC256_FIXUP_ASUS_MIC,
10789                 {0x14, 0x90170110},
10790                 {0x1b, 0x90a70130},
10791                 {0x21, 0x04211020}),
10792         SND_HDA_PIN_QUIRK(0x10ec0256, 0x1043, "ASUS", ALC256_FIXUP_ASUS_MIC,
10793                 {0x14, 0x90170110},
10794                 {0x1b, 0x90a70130},
10795                 {0x21, 0x03211020}),
10796         SND_HDA_PIN_QUIRK(0x10ec0256, 0x1043, "ASUS", ALC256_FIXUP_ASUS_MIC_NO_PRESENCE,
10797                 {0x12, 0x90a60130},
10798                 {0x14, 0x90170110},
10799                 {0x21, 0x03211020}),
10800         SND_HDA_PIN_QUIRK(0x10ec0256, 0x1043, "ASUS", ALC256_FIXUP_ASUS_MIC_NO_PRESENCE,
10801                 {0x12, 0x90a60130},
10802                 {0x14, 0x90170110},
10803                 {0x21, 0x04211020}),
10804         SND_HDA_PIN_QUIRK(0x10ec0256, 0x1043, "ASUS", ALC256_FIXUP_ASUS_MIC_NO_PRESENCE,
10805                 {0x1a, 0x90a70130},
10806                 {0x1b, 0x90170110},
10807                 {0x21, 0x03211020}),
10808        SND_HDA_PIN_QUIRK(0x10ec0256, 0x103c, "HP", ALC256_FIXUP_HP_HEADSET_MIC,
10809                 {0x14, 0x90170110},
10810                 {0x19, 0x02a11020},
10811                 {0x21, 0x0221101f}),
10812        SND_HDA_PIN_QUIRK(0x10ec0274, 0x103c, "HP", ALC274_FIXUP_HP_HEADSET_MIC,
10813                 {0x17, 0x90170110},
10814                 {0x19, 0x03a11030},
10815                 {0x21, 0x03211020}),
10816         SND_HDA_PIN_QUIRK(0x10ec0280, 0x103c, "HP", ALC280_FIXUP_HP_GPIO4,
10817                 {0x12, 0x90a60130},
10818                 {0x14, 0x90170110},
10819                 {0x15, 0x0421101f},
10820                 {0x1a, 0x04a11020}),
10821         SND_HDA_PIN_QUIRK(0x10ec0280, 0x103c, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED,
10822                 {0x12, 0x90a60140},
10823                 {0x14, 0x90170110},
10824                 {0x15, 0x0421101f},
10825                 {0x18, 0x02811030},
10826                 {0x1a, 0x04a1103f},
10827                 {0x1b, 0x02011020}),
10828         SND_HDA_PIN_QUIRK(0x10ec0282, 0x103c, "HP 15 Touchsmart", ALC269_FIXUP_HP_MUTE_LED_MIC1,
10829                 ALC282_STANDARD_PINS,
10830                 {0x12, 0x99a30130},
10831                 {0x19, 0x03a11020},
10832                 {0x21, 0x0321101f}),
10833         SND_HDA_PIN_QUIRK(0x10ec0282, 0x103c, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1,
10834                 ALC282_STANDARD_PINS,
10835                 {0x12, 0x99a30130},
10836                 {0x19, 0x03a11020},
10837                 {0x21, 0x03211040}),
10838         SND_HDA_PIN_QUIRK(0x10ec0282, 0x103c, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1,
10839                 ALC282_STANDARD_PINS,
10840                 {0x12, 0x99a30130},
10841                 {0x19, 0x03a11030},
10842                 {0x21, 0x03211020}),
10843         SND_HDA_PIN_QUIRK(0x10ec0282, 0x103c, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1,
10844                 ALC282_STANDARD_PINS,
10845                 {0x12, 0x99a30130},
10846                 {0x19, 0x04a11020},
10847                 {0x21, 0x0421101f}),
10848         SND_HDA_PIN_QUIRK(0x10ec0282, 0x103c, "HP", ALC269_FIXUP_HP_LINE1_MIC1_LED,
10849                 ALC282_STANDARD_PINS,
10850                 {0x12, 0x90a60140},
10851                 {0x19, 0x04a11030},
10852                 {0x21, 0x04211020}),
10853         SND_HDA_PIN_QUIRK(0x10ec0282, 0x1025, "Acer", ALC282_FIXUP_ACER_DISABLE_LINEOUT,
10854                 ALC282_STANDARD_PINS,
10855                 {0x12, 0x90a609c0},
10856                 {0x18, 0x03a11830},
10857                 {0x19, 0x04a19831},
10858                 {0x1a, 0x0481303f},
10859                 {0x1b, 0x04211020},
10860                 {0x21, 0x0321101f}),
10861         SND_HDA_PIN_QUIRK(0x10ec0282, 0x1025, "Acer", ALC282_FIXUP_ACER_DISABLE_LINEOUT,
10862                 ALC282_STANDARD_PINS,
10863                 {0x12, 0x90a60940},
10864                 {0x18, 0x03a11830},
10865                 {0x19, 0x04a19831},
10866                 {0x1a, 0x0481303f},
10867                 {0x1b, 0x04211020},
10868                 {0x21, 0x0321101f}),
10869         SND_HDA_PIN_QUIRK(0x10ec0283, 0x1028, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE,
10870                 ALC282_STANDARD_PINS,
10871                 {0x12, 0x90a60130},
10872                 {0x21, 0x0321101f}),
10873         SND_HDA_PIN_QUIRK(0x10ec0283, 0x1028, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE,
10874                 {0x12, 0x90a60160},
10875                 {0x14, 0x90170120},
10876                 {0x21, 0x02211030}),
10877         SND_HDA_PIN_QUIRK(0x10ec0283, 0x1028, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE,
10878                 ALC282_STANDARD_PINS,
10879                 {0x12, 0x90a60130},
10880                 {0x19, 0x03a11020},
10881                 {0x21, 0x0321101f}),
10882         SND_HDA_PIN_QUIRK(0x10ec0285, 0x17aa, "Lenovo", ALC285_FIXUP_LENOVO_PC_BEEP_IN_NOISE,
10883                 {0x12, 0x90a60130},
10884                 {0x14, 0x90170110},
10885                 {0x19, 0x04a11040},
10886                 {0x21, 0x04211020}),
10887         SND_HDA_PIN_QUIRK(0x10ec0285, 0x17aa, "Lenovo", ALC285_FIXUP_LENOVO_PC_BEEP_IN_NOISE,
10888                 {0x14, 0x90170110},
10889                 {0x19, 0x04a11040},
10890                 {0x1d, 0x40600001},
10891                 {0x21, 0x04211020}),
10892         SND_HDA_PIN_QUIRK(0x10ec0285, 0x17aa, "Lenovo", ALC285_FIXUP_THINKPAD_NO_BASS_SPK_HEADSET_JACK,
10893                 {0x14, 0x90170110},
10894                 {0x19, 0x04a11040},
10895                 {0x21, 0x04211020}),
10896         SND_HDA_PIN_QUIRK(0x10ec0287, 0x17aa, "Lenovo", ALC285_FIXUP_THINKPAD_HEADSET_JACK,
10897                 {0x14, 0x90170110},
10898                 {0x17, 0x90170111},
10899                 {0x19, 0x03a11030},
10900                 {0x21, 0x03211020}),
10901         SND_HDA_PIN_QUIRK(0x10ec0287, 0x17aa, "Lenovo", ALC287_FIXUP_THINKPAD_I2S_SPK,
10902                 {0x17, 0x90170110},
10903                 {0x19, 0x03a11030},
10904                 {0x21, 0x03211020}),
10905         SND_HDA_PIN_QUIRK(0x10ec0287, 0x17aa, "Lenovo", ALC287_FIXUP_THINKPAD_I2S_SPK,
10906                 {0x17, 0x90170110}, /* 0x231f with RTK I2S AMP */
10907                 {0x19, 0x04a11040},
10908                 {0x21, 0x04211020}),
10909         SND_HDA_PIN_QUIRK(0x10ec0286, 0x1025, "Acer", ALC286_FIXUP_ACER_AIO_MIC_NO_PRESENCE,
10910                 {0x12, 0x90a60130},
10911                 {0x17, 0x90170110},
10912                 {0x21, 0x02211020}),
10913         SND_HDA_PIN_QUIRK(0x10ec0288, 0x1028, "Dell", ALC288_FIXUP_DELL1_MIC_NO_PRESENCE,
10914                 {0x12, 0x90a60120},
10915                 {0x14, 0x90170110},
10916                 {0x21, 0x0321101f}),
10917         SND_HDA_PIN_QUIRK(0x10ec0290, 0x103c, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1,
10918                 ALC290_STANDARD_PINS,
10919                 {0x15, 0x04211040},
10920                 {0x18, 0x90170112},
10921                 {0x1a, 0x04a11020}),
10922         SND_HDA_PIN_QUIRK(0x10ec0290, 0x103c, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1,
10923                 ALC290_STANDARD_PINS,
10924                 {0x15, 0x04211040},
10925                 {0x18, 0x90170110},
10926                 {0x1a, 0x04a11020}),
10927         SND_HDA_PIN_QUIRK(0x10ec0290, 0x103c, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1,
10928                 ALC290_STANDARD_PINS,
10929                 {0x15, 0x0421101f},
10930                 {0x1a, 0x04a11020}),
10931         SND_HDA_PIN_QUIRK(0x10ec0290, 0x103c, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1,
10932                 ALC290_STANDARD_PINS,
10933                 {0x15, 0x04211020},
10934                 {0x1a, 0x04a11040}),
10935         SND_HDA_PIN_QUIRK(0x10ec0290, 0x103c, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1,
10936                 ALC290_STANDARD_PINS,
10937                 {0x14, 0x90170110},
10938                 {0x15, 0x04211020},
10939                 {0x1a, 0x04a11040}),
10940         SND_HDA_PIN_QUIRK(0x10ec0290, 0x103c, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1,
10941                 ALC290_STANDARD_PINS,
10942                 {0x14, 0x90170110},
10943                 {0x15, 0x04211020},
10944                 {0x1a, 0x04a11020}),
10945         SND_HDA_PIN_QUIRK(0x10ec0290, 0x103c, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1,
10946                 ALC290_STANDARD_PINS,
10947                 {0x14, 0x90170110},
10948                 {0x15, 0x0421101f},
10949                 {0x1a, 0x04a11020}),
10950         SND_HDA_PIN_QUIRK(0x10ec0292, 0x1028, "Dell", ALC269_FIXUP_DELL2_MIC_NO_PRESENCE,
10951                 ALC292_STANDARD_PINS,
10952                 {0x12, 0x90a60140},
10953                 {0x16, 0x01014020},
10954                 {0x19, 0x01a19030}),
10955         SND_HDA_PIN_QUIRK(0x10ec0292, 0x1028, "Dell", ALC269_FIXUP_DELL2_MIC_NO_PRESENCE,
10956                 ALC292_STANDARD_PINS,
10957                 {0x12, 0x90a60140},
10958                 {0x16, 0x01014020},
10959                 {0x18, 0x02a19031},
10960                 {0x19, 0x01a1903e}),
10961         SND_HDA_PIN_QUIRK(0x10ec0292, 0x1028, "Dell", ALC269_FIXUP_DELL3_MIC_NO_PRESENCE,
10962                 ALC292_STANDARD_PINS,
10963                 {0x12, 0x90a60140}),
10964         SND_HDA_PIN_QUIRK(0x10ec0293, 0x1028, "Dell", ALC293_FIXUP_DELL1_MIC_NO_PRESENCE,
10965                 ALC292_STANDARD_PINS,
10966                 {0x13, 0x90a60140},
10967                 {0x16, 0x21014020},
10968                 {0x19, 0x21a19030}),
10969         SND_HDA_PIN_QUIRK(0x10ec0293, 0x1028, "Dell", ALC293_FIXUP_DELL1_MIC_NO_PRESENCE,
10970                 ALC292_STANDARD_PINS,
10971                 {0x13, 0x90a60140}),
10972         SND_HDA_PIN_QUIRK(0x10ec0294, 0x1043, "ASUS", ALC294_FIXUP_ASUS_HPE,
10973                 {0x17, 0x90170110},
10974                 {0x21, 0x04211020}),
10975         SND_HDA_PIN_QUIRK(0x10ec0294, 0x1043, "ASUS", ALC294_FIXUP_ASUS_MIC,
10976                 {0x14, 0x90170110},
10977                 {0x1b, 0x90a70130},
10978                 {0x21, 0x04211020}),
10979         SND_HDA_PIN_QUIRK(0x10ec0294, 0x1043, "ASUS", ALC294_FIXUP_ASUS_SPK,
10980                 {0x12, 0x90a60130},
10981                 {0x17, 0x90170110},
10982                 {0x21, 0x03211020}),
10983         SND_HDA_PIN_QUIRK(0x10ec0294, 0x1043, "ASUS", ALC294_FIXUP_ASUS_SPK,
10984                 {0x12, 0x90a60130},
10985                 {0x17, 0x90170110},
10986                 {0x21, 0x04211020}),
10987         SND_HDA_PIN_QUIRK(0x10ec0295, 0x1043, "ASUS", ALC294_FIXUP_ASUS_SPK,
10988                 {0x12, 0x90a60130},
10989                 {0x17, 0x90170110},
10990                 {0x21, 0x03211020}),
10991         SND_HDA_PIN_QUIRK(0x10ec0295, 0x1043, "ASUS", ALC295_FIXUP_ASUS_MIC_NO_PRESENCE,
10992                 {0x12, 0x90a60120},
10993                 {0x17, 0x90170110},
10994                 {0x21, 0x04211030}),
10995         SND_HDA_PIN_QUIRK(0x10ec0295, 0x1043, "ASUS", ALC295_FIXUP_ASUS_MIC_NO_PRESENCE,
10996                 {0x12, 0x90a60130},
10997                 {0x17, 0x90170110},
10998                 {0x21, 0x03211020}),
10999         SND_HDA_PIN_QUIRK(0x10ec0295, 0x1043, "ASUS", ALC295_FIXUP_ASUS_MIC_NO_PRESENCE,
11000                 {0x12, 0x90a60130},
11001                 {0x17, 0x90170110},
11002                 {0x21, 0x03211020}),
11003         SND_HDA_PIN_QUIRK(0x10ec0298, 0x1028, "Dell", ALC298_FIXUP_DELL1_MIC_NO_PRESENCE,
11004                 ALC298_STANDARD_PINS,
11005                 {0x17, 0x90170110}),
11006         SND_HDA_PIN_QUIRK(0x10ec0298, 0x1028, "Dell", ALC298_FIXUP_DELL1_MIC_NO_PRESENCE,
11007                 ALC298_STANDARD_PINS,
11008                 {0x17, 0x90170140}),
11009         SND_HDA_PIN_QUIRK(0x10ec0298, 0x1028, "Dell", ALC298_FIXUP_DELL1_MIC_NO_PRESENCE,
11010                 ALC298_STANDARD_PINS,
11011                 {0x17, 0x90170150}),
11012         SND_HDA_PIN_QUIRK(0x10ec0298, 0x1028, "Dell", ALC298_FIXUP_SPK_VOLUME,
11013                 {0x12, 0xb7a60140},
11014                 {0x13, 0xb7a60150},
11015                 {0x17, 0x90170110},
11016                 {0x1a, 0x03011020},
11017                 {0x21, 0x03211030}),
11018         SND_HDA_PIN_QUIRK(0x10ec0298, 0x1028, "Dell", ALC298_FIXUP_ALIENWARE_MIC_NO_PRESENCE,
11019                 {0x12, 0xb7a60140},
11020                 {0x17, 0x90170110},
11021                 {0x1a, 0x03a11030},
11022                 {0x21, 0x03211020}),
11023         SND_HDA_PIN_QUIRK(0x10ec0299, 0x1028, "Dell", ALC269_FIXUP_DELL4_MIC_NO_PRESENCE,
11024                 ALC225_STANDARD_PINS,
11025                 {0x12, 0xb7a60130},
11026                 {0x17, 0x90170110}),
11027         SND_HDA_PIN_QUIRK(0x10ec0623, 0x17aa, "Lenovo", ALC283_FIXUP_HEADSET_MIC,
11028                 {0x14, 0x01014010},
11029                 {0x17, 0x90170120},
11030                 {0x18, 0x02a11030},
11031                 {0x19, 0x02a1103f},
11032                 {0x21, 0x0221101f}),
11033         {}
11034 };
11035
11036 /* This is the fallback pin_fixup_tbl for alc269 family, to make the tbl match
11037  * more machines, don't need to match all valid pins, just need to match
11038  * all the pins defined in the tbl. Just because of this reason, it is possible
11039  * that a single machine matches multiple tbls, so there is one limitation:
11040  *   at most one tbl is allowed to define for the same vendor and same codec
11041  */
11042 static const struct snd_hda_pin_quirk alc269_fallback_pin_fixup_tbl[] = {
11043         SND_HDA_PIN_QUIRK(0x10ec0256, 0x1025, "Acer", ALC2XX_FIXUP_HEADSET_MIC,
11044                 {0x19, 0x40000000}),
11045         SND_HDA_PIN_QUIRK(0x10ec0289, 0x1028, "Dell", ALC269_FIXUP_DELL4_MIC_NO_PRESENCE,
11046                 {0x19, 0x40000000},
11047                 {0x1b, 0x40000000}),
11048         SND_HDA_PIN_QUIRK(0x10ec0295, 0x1028, "Dell", ALC269_FIXUP_DELL4_MIC_NO_PRESENCE,
11049                 {0x19, 0x40000000},
11050                 {0x1b, 0x40000000}),
11051         SND_HDA_PIN_QUIRK(0x10ec0256, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
11052                 {0x19, 0x40000000},
11053                 {0x1a, 0x40000000}),
11054         SND_HDA_PIN_QUIRK(0x10ec0236, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
11055                 {0x19, 0x40000000},
11056                 {0x1a, 0x40000000}),
11057         SND_HDA_PIN_QUIRK(0x10ec0274, 0x1028, "Dell", ALC274_FIXUP_DELL_AIO_LINEOUT_VERB,
11058                 {0x19, 0x40000000},
11059                 {0x1a, 0x40000000}),
11060         SND_HDA_PIN_QUIRK(0x10ec0256, 0x1043, "ASUS", ALC2XX_FIXUP_HEADSET_MIC,
11061                 {0x19, 0x40000000}),
11062         {}
11063 };
11064
11065 static void alc269_fill_coef(struct hda_codec *codec)
11066 {
11067         struct alc_spec *spec = codec->spec;
11068         int val;
11069
11070         if (spec->codec_variant != ALC269_TYPE_ALC269VB)
11071                 return;
11072
11073         if ((alc_get_coef0(codec) & 0x00ff) < 0x015) {
11074                 alc_write_coef_idx(codec, 0xf, 0x960b);
11075                 alc_write_coef_idx(codec, 0xe, 0x8817);
11076         }
11077
11078         if ((alc_get_coef0(codec) & 0x00ff) == 0x016) {
11079                 alc_write_coef_idx(codec, 0xf, 0x960b);
11080                 alc_write_coef_idx(codec, 0xe, 0x8814);
11081         }
11082
11083         if ((alc_get_coef0(codec) & 0x00ff) == 0x017) {
11084                 /* Power up output pin */
11085                 alc_update_coef_idx(codec, 0x04, 0, 1<<11);
11086         }
11087
11088         if ((alc_get_coef0(codec) & 0x00ff) == 0x018) {
11089                 val = alc_read_coef_idx(codec, 0xd);
11090                 if (val != -1 && (val & 0x0c00) >> 10 != 0x1) {
11091                         /* Capless ramp up clock control */
11092                         alc_write_coef_idx(codec, 0xd, val | (1<<10));
11093                 }
11094                 val = alc_read_coef_idx(codec, 0x17);
11095                 if (val != -1 && (val & 0x01c0) >> 6 != 0x4) {
11096                         /* Class D power on reset */
11097                         alc_write_coef_idx(codec, 0x17, val | (1<<7));
11098                 }
11099         }
11100
11101         /* HP */
11102         alc_update_coef_idx(codec, 0x4, 0, 1<<11);
11103 }
11104
11105 /*
11106  */
11107 static int patch_alc269(struct hda_codec *codec)
11108 {
11109         struct alc_spec *spec;
11110         int err;
11111
11112         err = alc_alloc_spec(codec, 0x0b);
11113         if (err < 0)
11114                 return err;
11115
11116         spec = codec->spec;
11117         spec->gen.shared_mic_vref_pin = 0x18;
11118         codec->power_save_node = 0;
11119         spec->en_3kpull_low = true;
11120
11121 #ifdef CONFIG_PM
11122         codec->patch_ops.suspend = alc269_suspend;
11123         codec->patch_ops.resume = alc269_resume;
11124 #endif
11125         spec->shutup = alc_default_shutup;
11126         spec->init_hook = alc_default_init;
11127
11128         switch (codec->core.vendor_id) {
11129         case 0x10ec0269:
11130                 spec->codec_variant = ALC269_TYPE_ALC269VA;
11131                 switch (alc_get_coef0(codec) & 0x00f0) {
11132                 case 0x0010:
11133                         if (codec->bus->pci &&
11134                             codec->bus->pci->subsystem_vendor == 0x1025 &&
11135                             spec->cdefine.platform_type == 1)
11136                                 err = alc_codec_rename(codec, "ALC271X");
11137                         spec->codec_variant = ALC269_TYPE_ALC269VB;
11138                         break;
11139                 case 0x0020:
11140                         if (codec->bus->pci &&
11141                             codec->bus->pci->subsystem_vendor == 0x17aa &&
11142                             codec->bus->pci->subsystem_device == 0x21f3)
11143                                 err = alc_codec_rename(codec, "ALC3202");
11144                         spec->codec_variant = ALC269_TYPE_ALC269VC;
11145                         break;
11146                 case 0x0030:
11147                         spec->codec_variant = ALC269_TYPE_ALC269VD;
11148                         break;
11149                 default:
11150                         alc_fix_pll_init(codec, 0x20, 0x04, 15);
11151                 }
11152                 if (err < 0)
11153                         goto error;
11154                 spec->shutup = alc269_shutup;
11155                 spec->init_hook = alc269_fill_coef;
11156                 alc269_fill_coef(codec);
11157                 break;
11158
11159         case 0x10ec0280:
11160         case 0x10ec0290:
11161                 spec->codec_variant = ALC269_TYPE_ALC280;
11162                 break;
11163         case 0x10ec0282:
11164                 spec->codec_variant = ALC269_TYPE_ALC282;
11165                 spec->shutup = alc282_shutup;
11166                 spec->init_hook = alc282_init;
11167                 break;
11168         case 0x10ec0233:
11169         case 0x10ec0283:
11170                 spec->codec_variant = ALC269_TYPE_ALC283;
11171                 spec->shutup = alc283_shutup;
11172                 spec->init_hook = alc283_init;
11173                 break;
11174         case 0x10ec0284:
11175         case 0x10ec0292:
11176                 spec->codec_variant = ALC269_TYPE_ALC284;
11177                 break;
11178         case 0x10ec0293:
11179                 spec->codec_variant = ALC269_TYPE_ALC293;
11180                 break;
11181         case 0x10ec0286:
11182         case 0x10ec0288:
11183                 spec->codec_variant = ALC269_TYPE_ALC286;
11184                 break;
11185         case 0x10ec0298:
11186                 spec->codec_variant = ALC269_TYPE_ALC298;
11187                 break;
11188         case 0x10ec0235:
11189         case 0x10ec0255:
11190                 spec->codec_variant = ALC269_TYPE_ALC255;
11191                 spec->shutup = alc256_shutup;
11192                 spec->init_hook = alc256_init;
11193                 break;
11194         case 0x10ec0230:
11195         case 0x10ec0236:
11196         case 0x10ec0256:
11197         case 0x19e58326:
11198                 spec->codec_variant = ALC269_TYPE_ALC256;
11199                 spec->shutup = alc256_shutup;
11200                 spec->init_hook = alc256_init;
11201                 spec->gen.mixer_nid = 0; /* ALC256 does not have any loopback mixer path */
11202                 if (codec->core.vendor_id == 0x10ec0236 &&
11203                     codec->bus->pci->vendor != PCI_VENDOR_ID_AMD)
11204                         spec->en_3kpull_low = false;
11205                 break;
11206         case 0x10ec0257:
11207                 spec->codec_variant = ALC269_TYPE_ALC257;
11208                 spec->shutup = alc256_shutup;
11209                 spec->init_hook = alc256_init;
11210                 spec->gen.mixer_nid = 0;
11211                 spec->en_3kpull_low = false;
11212                 break;
11213         case 0x10ec0215:
11214         case 0x10ec0245:
11215         case 0x10ec0285:
11216         case 0x10ec0289:
11217                 if (alc_get_coef0(codec) & 0x0010)
11218                         spec->codec_variant = ALC269_TYPE_ALC245;
11219                 else
11220                         spec->codec_variant = ALC269_TYPE_ALC215;
11221                 spec->shutup = alc225_shutup;
11222                 spec->init_hook = alc225_init;
11223                 spec->gen.mixer_nid = 0;
11224                 break;
11225         case 0x10ec0225:
11226         case 0x10ec0295:
11227         case 0x10ec0299:
11228                 spec->codec_variant = ALC269_TYPE_ALC225;
11229                 spec->shutup = alc225_shutup;
11230                 spec->init_hook = alc225_init;
11231                 spec->gen.mixer_nid = 0; /* no loopback on ALC225, ALC295 and ALC299 */
11232                 break;
11233         case 0x10ec0287:
11234                 spec->codec_variant = ALC269_TYPE_ALC287;
11235                 spec->shutup = alc225_shutup;
11236                 spec->init_hook = alc225_init;
11237                 spec->gen.mixer_nid = 0; /* no loopback on ALC287 */
11238                 break;
11239         case 0x10ec0234:
11240         case 0x10ec0274:
11241         case 0x10ec0294:
11242                 spec->codec_variant = ALC269_TYPE_ALC294;
11243                 spec->gen.mixer_nid = 0; /* ALC2x4 does not have any loopback mixer path */
11244                 alc_update_coef_idx(codec, 0x6b, 0x0018, (1<<4) | (1<<3)); /* UAJ MIC Vref control by verb */
11245                 spec->init_hook = alc294_init;
11246                 break;
11247         case 0x10ec0300:
11248                 spec->codec_variant = ALC269_TYPE_ALC300;
11249                 spec->gen.mixer_nid = 0; /* no loopback on ALC300 */
11250                 break;
11251         case 0x10ec0623:
11252                 spec->codec_variant = ALC269_TYPE_ALC623;
11253                 break;
11254         case 0x10ec0700:
11255         case 0x10ec0701:
11256         case 0x10ec0703:
11257         case 0x10ec0711:
11258                 spec->codec_variant = ALC269_TYPE_ALC700;
11259                 spec->gen.mixer_nid = 0; /* ALC700 does not have any loopback mixer path */
11260                 alc_update_coef_idx(codec, 0x4a, 1 << 15, 0); /* Combo jack auto trigger control */
11261                 spec->init_hook = alc294_init;
11262                 break;
11263
11264         }
11265
11266         if (snd_hda_codec_read(codec, 0x51, 0, AC_VERB_PARAMETERS, 0) == 0x10ec5505) {
11267                 spec->has_alc5505_dsp = 1;
11268                 spec->init_hook = alc5505_dsp_init;
11269         }
11270
11271         alc_pre_init(codec);
11272
11273         snd_hda_pick_fixup(codec, alc269_fixup_models,
11274                        alc269_fixup_tbl, alc269_fixups);
11275         /* FIXME: both TX300 and ROG Strix G17 have the same SSID, and
11276          * the quirk breaks the latter (bko#214101).
11277          * Clear the wrong entry.
11278          */
11279         if (codec->fixup_id == ALC282_FIXUP_ASUS_TX300 &&
11280             codec->core.vendor_id == 0x10ec0294) {
11281                 codec_dbg(codec, "Clear wrong fixup for ASUS ROG Strix G17\n");
11282                 codec->fixup_id = HDA_FIXUP_ID_NOT_SET;
11283         }
11284
11285         snd_hda_pick_pin_fixup(codec, alc269_pin_fixup_tbl, alc269_fixups, true);
11286         snd_hda_pick_pin_fixup(codec, alc269_fallback_pin_fixup_tbl, alc269_fixups, false);
11287         snd_hda_pick_fixup(codec, NULL, alc269_fixup_vendor_tbl,
11288                            alc269_fixups);
11289         snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE);
11290
11291         alc_auto_parse_customize_define(codec);
11292
11293         if (has_cdefine_beep(codec))
11294                 spec->gen.beep_nid = 0x01;
11295
11296         /* automatic parse from the BIOS config */
11297         err = alc269_parse_auto_config(codec);
11298         if (err < 0)
11299                 goto error;
11300
11301         if (!spec->gen.no_analog && spec->gen.beep_nid && spec->gen.mixer_nid) {
11302                 err = set_beep_amp(spec, spec->gen.mixer_nid, 0x04, HDA_INPUT);
11303                 if (err < 0)
11304                         goto error;
11305         }
11306
11307         snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE);
11308
11309         return 0;
11310
11311  error:
11312         alc_free(codec);
11313         return err;
11314 }
11315
11316 /*
11317  * ALC861
11318  */
11319
11320 static int alc861_parse_auto_config(struct hda_codec *codec)
11321 {
11322         static const hda_nid_t alc861_ignore[] = { 0x1d, 0 };
11323         static const hda_nid_t alc861_ssids[] = { 0x0e, 0x0f, 0x0b, 0 };
11324         return alc_parse_auto_config(codec, alc861_ignore, alc861_ssids);
11325 }
11326
11327 /* Pin config fixes */
11328 enum {
11329         ALC861_FIXUP_FSC_AMILO_PI1505,
11330         ALC861_FIXUP_AMP_VREF_0F,
11331         ALC861_FIXUP_NO_JACK_DETECT,
11332         ALC861_FIXUP_ASUS_A6RP,
11333         ALC660_FIXUP_ASUS_W7J,
11334 };
11335
11336 /* On some laptops, VREF of pin 0x0f is abused for controlling the main amp */
11337 static void alc861_fixup_asus_amp_vref_0f(struct hda_codec *codec,
11338                         const struct hda_fixup *fix, int action)
11339 {
11340         struct alc_spec *spec = codec->spec;
11341         unsigned int val;
11342
11343         if (action != HDA_FIXUP_ACT_INIT)
11344                 return;
11345         val = snd_hda_codec_get_pin_target(codec, 0x0f);
11346         if (!(val & (AC_PINCTL_IN_EN | AC_PINCTL_OUT_EN)))
11347                 val |= AC_PINCTL_IN_EN;
11348         val |= AC_PINCTL_VREF_50;
11349         snd_hda_set_pin_ctl(codec, 0x0f, val);
11350         spec->gen.keep_vref_in_automute = 1;
11351 }
11352
11353 /* suppress the jack-detection */
11354 static void alc_fixup_no_jack_detect(struct hda_codec *codec,
11355                                      const struct hda_fixup *fix, int action)
11356 {
11357         if (action == HDA_FIXUP_ACT_PRE_PROBE)
11358                 codec->no_jack_detect = 1;
11359 }
11360
11361 static const struct hda_fixup alc861_fixups[] = {
11362         [ALC861_FIXUP_FSC_AMILO_PI1505] = {
11363                 .type = HDA_FIXUP_PINS,
11364                 .v.pins = (const struct hda_pintbl[]) {
11365                         { 0x0b, 0x0221101f }, /* HP */
11366                         { 0x0f, 0x90170310 }, /* speaker */
11367                         { }
11368                 }
11369         },
11370         [ALC861_FIXUP_AMP_VREF_0F] = {
11371                 .type = HDA_FIXUP_FUNC,
11372                 .v.func = alc861_fixup_asus_amp_vref_0f,
11373         },
11374         [ALC861_FIXUP_NO_JACK_DETECT] = {
11375                 .type = HDA_FIXUP_FUNC,
11376                 .v.func = alc_fixup_no_jack_detect,
11377         },
11378         [ALC861_FIXUP_ASUS_A6RP] = {
11379                 .type = HDA_FIXUP_FUNC,
11380                 .v.func = alc861_fixup_asus_amp_vref_0f,
11381                 .chained = true,
11382                 .chain_id = ALC861_FIXUP_NO_JACK_DETECT,
11383         },
11384         [ALC660_FIXUP_ASUS_W7J] = {
11385                 .type = HDA_FIXUP_VERBS,
11386                 .v.verbs = (const struct hda_verb[]) {
11387                         /* ASUS W7J needs a magic pin setup on unused NID 0x10
11388                          * for enabling outputs
11389                          */
11390                         {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
11391                         { }
11392                 },
11393         }
11394 };
11395
11396 static const struct snd_pci_quirk alc861_fixup_tbl[] = {
11397         SND_PCI_QUIRK(0x1043, 0x1253, "ASUS W7J", ALC660_FIXUP_ASUS_W7J),
11398         SND_PCI_QUIRK(0x1043, 0x1263, "ASUS Z35HL", ALC660_FIXUP_ASUS_W7J),
11399         SND_PCI_QUIRK(0x1043, 0x1393, "ASUS A6Rp", ALC861_FIXUP_ASUS_A6RP),
11400         SND_PCI_QUIRK_VENDOR(0x1043, "ASUS laptop", ALC861_FIXUP_AMP_VREF_0F),
11401         SND_PCI_QUIRK(0x1462, 0x7254, "HP DX2200", ALC861_FIXUP_NO_JACK_DETECT),
11402         SND_PCI_QUIRK_VENDOR(0x1584, "Haier/Uniwill", ALC861_FIXUP_AMP_VREF_0F),
11403         SND_PCI_QUIRK(0x1734, 0x10c7, "FSC Amilo Pi1505", ALC861_FIXUP_FSC_AMILO_PI1505),
11404         {}
11405 };
11406
11407 /*
11408  */
11409 static int patch_alc861(struct hda_codec *codec)
11410 {
11411         struct alc_spec *spec;
11412         int err;
11413
11414         err = alc_alloc_spec(codec, 0x15);
11415         if (err < 0)
11416                 return err;
11417
11418         spec = codec->spec;
11419         if (has_cdefine_beep(codec))
11420                 spec->gen.beep_nid = 0x23;
11421
11422 #ifdef CONFIG_PM
11423         spec->power_hook = alc_power_eapd;
11424 #endif
11425
11426         alc_pre_init(codec);
11427
11428         snd_hda_pick_fixup(codec, NULL, alc861_fixup_tbl, alc861_fixups);
11429         snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE);
11430
11431         /* automatic parse from the BIOS config */
11432         err = alc861_parse_auto_config(codec);
11433         if (err < 0)
11434                 goto error;
11435
11436         if (!spec->gen.no_analog) {
11437                 err = set_beep_amp(spec, 0x23, 0, HDA_OUTPUT);
11438                 if (err < 0)
11439                         goto error;
11440         }
11441
11442         snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE);
11443
11444         return 0;
11445
11446  error:
11447         alc_free(codec);
11448         return err;
11449 }
11450
11451 /*
11452  * ALC861-VD support
11453  *
11454  * Based on ALC882
11455  *
11456  * In addition, an independent DAC
11457  */
11458 static int alc861vd_parse_auto_config(struct hda_codec *codec)
11459 {
11460         static const hda_nid_t alc861vd_ignore[] = { 0x1d, 0 };
11461         static const hda_nid_t alc861vd_ssids[] = { 0x15, 0x1b, 0x14, 0 };
11462         return alc_parse_auto_config(codec, alc861vd_ignore, alc861vd_ssids);
11463 }
11464
11465 enum {
11466         ALC660VD_FIX_ASUS_GPIO1,
11467         ALC861VD_FIX_DALLAS,
11468 };
11469
11470 /* exclude VREF80 */
11471 static void alc861vd_fixup_dallas(struct hda_codec *codec,
11472                                   const struct hda_fixup *fix, int action)
11473 {
11474         if (action == HDA_FIXUP_ACT_PRE_PROBE) {
11475                 snd_hda_override_pin_caps(codec, 0x18, 0x00000734);
11476                 snd_hda_override_pin_caps(codec, 0x19, 0x0000073c);
11477         }
11478 }
11479
11480 /* reset GPIO1 */
11481 static void alc660vd_fixup_asus_gpio1(struct hda_codec *codec,
11482                                       const struct hda_fixup *fix, int action)
11483 {
11484         struct alc_spec *spec = codec->spec;
11485
11486         if (action == HDA_FIXUP_ACT_PRE_PROBE)
11487                 spec->gpio_mask |= 0x02;
11488         alc_fixup_gpio(codec, action, 0x01);
11489 }
11490
11491 static const struct hda_fixup alc861vd_fixups[] = {
11492         [ALC660VD_FIX_ASUS_GPIO1] = {
11493                 .type = HDA_FIXUP_FUNC,
11494                 .v.func = alc660vd_fixup_asus_gpio1,
11495         },
11496         [ALC861VD_FIX_DALLAS] = {
11497                 .type = HDA_FIXUP_FUNC,
11498                 .v.func = alc861vd_fixup_dallas,
11499         },
11500 };
11501
11502 static const struct snd_pci_quirk alc861vd_fixup_tbl[] = {
11503         SND_PCI_QUIRK(0x103c, 0x30bf, "HP TX1000", ALC861VD_FIX_DALLAS),
11504         SND_PCI_QUIRK(0x1043, 0x1339, "ASUS A7-K", ALC660VD_FIX_ASUS_GPIO1),
11505         SND_PCI_QUIRK(0x1179, 0xff31, "Toshiba L30-149", ALC861VD_FIX_DALLAS),
11506         {}
11507 };
11508
11509 /*
11510  */
11511 static int patch_alc861vd(struct hda_codec *codec)
11512 {
11513         struct alc_spec *spec;
11514         int err;
11515
11516         err = alc_alloc_spec(codec, 0x0b);
11517         if (err < 0)
11518                 return err;
11519
11520         spec = codec->spec;
11521         if (has_cdefine_beep(codec))
11522                 spec->gen.beep_nid = 0x23;
11523
11524         spec->shutup = alc_eapd_shutup;
11525
11526         alc_pre_init(codec);
11527
11528         snd_hda_pick_fixup(codec, NULL, alc861vd_fixup_tbl, alc861vd_fixups);
11529         snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE);
11530
11531         /* automatic parse from the BIOS config */
11532         err = alc861vd_parse_auto_config(codec);
11533         if (err < 0)
11534                 goto error;
11535
11536         if (!spec->gen.no_analog) {
11537                 err = set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
11538                 if (err < 0)
11539                         goto error;
11540         }
11541
11542         snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE);
11543
11544         return 0;
11545
11546  error:
11547         alc_free(codec);
11548         return err;
11549 }
11550
11551 /*
11552  * ALC662 support
11553  *
11554  * ALC662 is almost identical with ALC880 but has cleaner and more flexible
11555  * configuration.  Each pin widget can choose any input DACs and a mixer.
11556  * Each ADC is connected from a mixer of all inputs.  This makes possible
11557  * 6-channel independent captures.
11558  *
11559  * In addition, an independent DAC for the multi-playback (not used in this
11560  * driver yet).
11561  */
11562
11563 /*
11564  * BIOS auto configuration
11565  */
11566
11567 static int alc662_parse_auto_config(struct hda_codec *codec)
11568 {
11569         static const hda_nid_t alc662_ignore[] = { 0x1d, 0 };
11570         static const hda_nid_t alc663_ssids[] = { 0x15, 0x1b, 0x14, 0x21 };
11571         static const hda_nid_t alc662_ssids[] = { 0x15, 0x1b, 0x14, 0 };
11572         const hda_nid_t *ssids;
11573
11574         if (codec->core.vendor_id == 0x10ec0272 || codec->core.vendor_id == 0x10ec0663 ||
11575             codec->core.vendor_id == 0x10ec0665 || codec->core.vendor_id == 0x10ec0670 ||
11576             codec->core.vendor_id == 0x10ec0671)
11577                 ssids = alc663_ssids;
11578         else
11579                 ssids = alc662_ssids;
11580         return alc_parse_auto_config(codec, alc662_ignore, ssids);
11581 }
11582
11583 static void alc272_fixup_mario(struct hda_codec *codec,
11584                                const struct hda_fixup *fix, int action)
11585 {
11586         if (action != HDA_FIXUP_ACT_PRE_PROBE)
11587                 return;
11588         if (snd_hda_override_amp_caps(codec, 0x2, HDA_OUTPUT,
11589                                       (0x3b << AC_AMPCAP_OFFSET_SHIFT) |
11590                                       (0x3b << AC_AMPCAP_NUM_STEPS_SHIFT) |
11591                                       (0x03 << AC_AMPCAP_STEP_SIZE_SHIFT) |
11592                                       (0 << AC_AMPCAP_MUTE_SHIFT)))
11593                 codec_warn(codec, "failed to override amp caps for NID 0x2\n");
11594 }
11595
11596 static const struct snd_pcm_chmap_elem asus_pcm_2_1_chmaps[] = {
11597         { .channels = 2,
11598           .map = { SNDRV_CHMAP_FL, SNDRV_CHMAP_FR } },
11599         { .channels = 4,
11600           .map = { SNDRV_CHMAP_FL, SNDRV_CHMAP_FR,
11601                    SNDRV_CHMAP_NA, SNDRV_CHMAP_LFE } }, /* LFE only on right */
11602         { }
11603 };
11604
11605 /* override the 2.1 chmap */
11606 static void alc_fixup_bass_chmap(struct hda_codec *codec,
11607                                     const struct hda_fixup *fix, int action)
11608 {
11609         if (action == HDA_FIXUP_ACT_BUILD) {
11610                 struct alc_spec *spec = codec->spec;
11611                 spec->gen.pcm_rec[0]->stream[0].chmap = asus_pcm_2_1_chmaps;
11612         }
11613 }
11614
11615 /* avoid D3 for keeping GPIO up */
11616 static unsigned int gpio_led_power_filter(struct hda_codec *codec,
11617                                           hda_nid_t nid,
11618                                           unsigned int power_state)
11619 {
11620         struct alc_spec *spec = codec->spec;
11621         if (nid == codec->core.afg && power_state == AC_PWRST_D3 && spec->gpio_data)
11622                 return AC_PWRST_D0;
11623         return power_state;
11624 }
11625
11626 static void alc662_fixup_led_gpio1(struct hda_codec *codec,
11627                                    const struct hda_fixup *fix, int action)
11628 {
11629         struct alc_spec *spec = codec->spec;
11630
11631         alc_fixup_hp_gpio_led(codec, action, 0x01, 0);
11632         if (action == HDA_FIXUP_ACT_PRE_PROBE) {
11633                 spec->mute_led_polarity = 1;
11634                 codec->power_filter = gpio_led_power_filter;
11635         }
11636 }
11637
11638 static void alc662_usi_automute_hook(struct hda_codec *codec,
11639                                          struct hda_jack_callback *jack)
11640 {
11641         struct alc_spec *spec = codec->spec;
11642         int vref;
11643         msleep(200);
11644         snd_hda_gen_hp_automute(codec, jack);
11645
11646         vref = spec->gen.hp_jack_present ? PIN_VREF80 : 0;
11647         msleep(100);
11648         snd_hda_codec_write(codec, 0x19, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
11649                             vref);
11650 }
11651
11652 static void alc662_fixup_usi_headset_mic(struct hda_codec *codec,
11653                                      const struct hda_fixup *fix, int action)
11654 {
11655         struct alc_spec *spec = codec->spec;
11656         if (action == HDA_FIXUP_ACT_PRE_PROBE) {
11657                 spec->parse_flags |= HDA_PINCFG_HEADSET_MIC;
11658                 spec->gen.hp_automute_hook = alc662_usi_automute_hook;
11659         }
11660 }
11661
11662 static void alc662_aspire_ethos_mute_speakers(struct hda_codec *codec,
11663                                         struct hda_jack_callback *cb)
11664 {
11665         /* surround speakers at 0x1b already get muted automatically when
11666          * headphones are plugged in, but we have to mute/unmute the remaining
11667          * channels manually:
11668          * 0x15 - front left/front right
11669          * 0x18 - front center/ LFE
11670          */
11671         if (snd_hda_jack_detect_state(codec, 0x1b) == HDA_JACK_PRESENT) {
11672                 snd_hda_set_pin_ctl_cache(codec, 0x15, 0);
11673                 snd_hda_set_pin_ctl_cache(codec, 0x18, 0);
11674         } else {
11675                 snd_hda_set_pin_ctl_cache(codec, 0x15, PIN_OUT);
11676                 snd_hda_set_pin_ctl_cache(codec, 0x18, PIN_OUT);
11677         }
11678 }
11679
11680 static void alc662_fixup_aspire_ethos_hp(struct hda_codec *codec,
11681                                         const struct hda_fixup *fix, int action)
11682 {
11683     /* Pin 0x1b: shared headphones jack and surround speakers */
11684         if (!is_jack_detectable(codec, 0x1b))
11685                 return;
11686
11687         switch (action) {
11688         case HDA_FIXUP_ACT_PRE_PROBE:
11689                 snd_hda_jack_detect_enable_callback(codec, 0x1b,
11690                                 alc662_aspire_ethos_mute_speakers);
11691                 /* subwoofer needs an extra GPIO setting to become audible */
11692                 alc_setup_gpio(codec, 0x02);
11693                 break;
11694         case HDA_FIXUP_ACT_INIT:
11695                 /* Make sure to start in a correct state, i.e. if
11696                  * headphones have been plugged in before powering up the system
11697                  */
11698                 alc662_aspire_ethos_mute_speakers(codec, NULL);
11699                 break;
11700         }
11701 }
11702
11703 static void alc671_fixup_hp_headset_mic2(struct hda_codec *codec,
11704                                              const struct hda_fixup *fix, int action)
11705 {
11706         struct alc_spec *spec = codec->spec;
11707
11708         static const struct hda_pintbl pincfgs[] = {
11709                 { 0x19, 0x02a11040 }, /* use as headset mic, with its own jack detect */
11710                 { 0x1b, 0x0181304f },
11711                 { }
11712         };
11713
11714         switch (action) {
11715         case HDA_FIXUP_ACT_PRE_PROBE:
11716                 spec->gen.mixer_nid = 0;
11717                 spec->parse_flags |= HDA_PINCFG_HEADSET_MIC;
11718                 snd_hda_apply_pincfgs(codec, pincfgs);
11719                 break;
11720         case HDA_FIXUP_ACT_INIT:
11721                 alc_write_coef_idx(codec, 0x19, 0xa054);
11722                 break;
11723         }
11724 }
11725
11726 static void alc897_hp_automute_hook(struct hda_codec *codec,
11727                                          struct hda_jack_callback *jack)
11728 {
11729         struct alc_spec *spec = codec->spec;
11730         int vref;
11731
11732         snd_hda_gen_hp_automute(codec, jack);
11733         vref = spec->gen.hp_jack_present ? (PIN_HP | AC_PINCTL_VREF_100) : PIN_HP;
11734         snd_hda_set_pin_ctl(codec, 0x1b, vref);
11735 }
11736
11737 static void alc897_fixup_lenovo_headset_mic(struct hda_codec *codec,
11738                                      const struct hda_fixup *fix, int action)
11739 {
11740         struct alc_spec *spec = codec->spec;
11741         if (action == HDA_FIXUP_ACT_PRE_PROBE) {
11742                 spec->gen.hp_automute_hook = alc897_hp_automute_hook;
11743                 spec->no_shutup_pins = 1;
11744         }
11745         if (action == HDA_FIXUP_ACT_PROBE) {
11746                 snd_hda_set_pin_ctl_cache(codec, 0x1a, PIN_IN | AC_PINCTL_VREF_100);
11747         }
11748 }
11749
11750 static void alc897_fixup_lenovo_headset_mode(struct hda_codec *codec,
11751                                      const struct hda_fixup *fix, int action)
11752 {
11753         struct alc_spec *spec = codec->spec;
11754
11755         if (action == HDA_FIXUP_ACT_PRE_PROBE) {
11756                 spec->parse_flags |= HDA_PINCFG_HEADSET_MIC;
11757                 spec->gen.hp_automute_hook = alc897_hp_automute_hook;
11758         }
11759 }
11760
11761 static const struct coef_fw alc668_coefs[] = {
11762         WRITE_COEF(0x01, 0xbebe), WRITE_COEF(0x02, 0xaaaa), WRITE_COEF(0x03,    0x0),
11763         WRITE_COEF(0x04, 0x0180), WRITE_COEF(0x06,    0x0), WRITE_COEF(0x07, 0x0f80),
11764         WRITE_COEF(0x08, 0x0031), WRITE_COEF(0x0a, 0x0060), WRITE_COEF(0x0b,    0x0),
11765         WRITE_COEF(0x0c, 0x7cf7), WRITE_COEF(0x0d, 0x1080), WRITE_COEF(0x0e, 0x7f7f),
11766         WRITE_COEF(0x0f, 0xcccc), WRITE_COEF(0x10, 0xddcc), WRITE_COEF(0x11, 0x0001),
11767         WRITE_COEF(0x13,    0x0), WRITE_COEF(0x14, 0x2aa0), WRITE_COEF(0x17, 0xa940),
11768         WRITE_COEF(0x19,    0x0), WRITE_COEF(0x1a,    0x0), WRITE_COEF(0x1b,    0x0),
11769         WRITE_COEF(0x1c,    0x0), WRITE_COEF(0x1d,    0x0), WRITE_COEF(0x1e, 0x7418),
11770         WRITE_COEF(0x1f, 0x0804), WRITE_COEF(0x20, 0x4200), WRITE_COEF(0x21, 0x0468),
11771         WRITE_COEF(0x22, 0x8ccc), WRITE_COEF(0x23, 0x0250), WRITE_COEF(0x24, 0x7418),
11772         WRITE_COEF(0x27,    0x0), WRITE_COEF(0x28, 0x8ccc), WRITE_COEF(0x2a, 0xff00),
11773         WRITE_COEF(0x2b, 0x8000), WRITE_COEF(0xa7, 0xff00), WRITE_COEF(0xa8, 0x8000),
11774         WRITE_COEF(0xaa, 0x2e17), WRITE_COEF(0xab, 0xa0c0), WRITE_COEF(0xac,    0x0),
11775         WRITE_COEF(0xad,    0x0), WRITE_COEF(0xae, 0x2ac6), WRITE_COEF(0xaf, 0xa480),
11776         WRITE_COEF(0xb0,    0x0), WRITE_COEF(0xb1,    0x0), WRITE_COEF(0xb2,    0x0),
11777         WRITE_COEF(0xb3,    0x0), WRITE_COEF(0xb4,    0x0), WRITE_COEF(0xb5, 0x1040),
11778         WRITE_COEF(0xb6, 0xd697), WRITE_COEF(0xb7, 0x902b), WRITE_COEF(0xb8, 0xd697),
11779         WRITE_COEF(0xb9, 0x902b), WRITE_COEF(0xba, 0xb8ba), WRITE_COEF(0xbb, 0xaaab),
11780         WRITE_COEF(0xbc, 0xaaaf), WRITE_COEF(0xbd, 0x6aaa), WRITE_COEF(0xbe, 0x1c02),
11781         WRITE_COEF(0xc0, 0x00ff), WRITE_COEF(0xc1, 0x0fa6),
11782         {}
11783 };
11784
11785 static void alc668_restore_default_value(struct hda_codec *codec)
11786 {
11787         alc_process_coef_fw(codec, alc668_coefs);
11788 }
11789
11790 enum {
11791         ALC662_FIXUP_ASPIRE,
11792         ALC662_FIXUP_LED_GPIO1,
11793         ALC662_FIXUP_IDEAPAD,
11794         ALC272_FIXUP_MARIO,
11795         ALC662_FIXUP_CZC_ET26,
11796         ALC662_FIXUP_CZC_P10T,
11797         ALC662_FIXUP_SKU_IGNORE,
11798         ALC662_FIXUP_HP_RP5800,
11799         ALC662_FIXUP_ASUS_MODE1,
11800         ALC662_FIXUP_ASUS_MODE2,
11801         ALC662_FIXUP_ASUS_MODE3,
11802         ALC662_FIXUP_ASUS_MODE4,
11803         ALC662_FIXUP_ASUS_MODE5,
11804         ALC662_FIXUP_ASUS_MODE6,
11805         ALC662_FIXUP_ASUS_MODE7,
11806         ALC662_FIXUP_ASUS_MODE8,
11807         ALC662_FIXUP_NO_JACK_DETECT,
11808         ALC662_FIXUP_ZOTAC_Z68,
11809         ALC662_FIXUP_INV_DMIC,
11810         ALC662_FIXUP_DELL_MIC_NO_PRESENCE,
11811         ALC668_FIXUP_DELL_MIC_NO_PRESENCE,
11812         ALC662_FIXUP_HEADSET_MODE,
11813         ALC668_FIXUP_HEADSET_MODE,
11814         ALC662_FIXUP_BASS_MODE4_CHMAP,
11815         ALC662_FIXUP_BASS_16,
11816         ALC662_FIXUP_BASS_1A,
11817         ALC662_FIXUP_BASS_CHMAP,
11818         ALC668_FIXUP_AUTO_MUTE,
11819         ALC668_FIXUP_DELL_DISABLE_AAMIX,
11820         ALC668_FIXUP_DELL_XPS13,
11821         ALC662_FIXUP_ASUS_Nx50,
11822         ALC668_FIXUP_ASUS_Nx51_HEADSET_MODE,
11823         ALC668_FIXUP_ASUS_Nx51,
11824         ALC668_FIXUP_MIC_COEF,
11825         ALC668_FIXUP_ASUS_G751,
11826         ALC891_FIXUP_HEADSET_MODE,
11827         ALC891_FIXUP_DELL_MIC_NO_PRESENCE,
11828         ALC662_FIXUP_ACER_VERITON,
11829         ALC892_FIXUP_ASROCK_MOBO,
11830         ALC662_FIXUP_USI_FUNC,
11831         ALC662_FIXUP_USI_HEADSET_MODE,
11832         ALC662_FIXUP_LENOVO_MULTI_CODECS,
11833         ALC669_FIXUP_ACER_ASPIRE_ETHOS,
11834         ALC669_FIXUP_ACER_ASPIRE_ETHOS_HEADSET,
11835         ALC671_FIXUP_HP_HEADSET_MIC2,
11836         ALC662_FIXUP_ACER_X2660G_HEADSET_MODE,
11837         ALC662_FIXUP_ACER_NITRO_HEADSET_MODE,
11838         ALC668_FIXUP_ASUS_NO_HEADSET_MIC,
11839         ALC668_FIXUP_HEADSET_MIC,
11840         ALC668_FIXUP_MIC_DET_COEF,
11841         ALC897_FIXUP_LENOVO_HEADSET_MIC,
11842         ALC897_FIXUP_HEADSET_MIC_PIN,
11843         ALC897_FIXUP_HP_HSMIC_VERB,
11844         ALC897_FIXUP_LENOVO_HEADSET_MODE,
11845         ALC897_FIXUP_HEADSET_MIC_PIN2,
11846         ALC897_FIXUP_UNIS_H3C_X500S,
11847 };
11848
11849 static const struct hda_fixup alc662_fixups[] = {
11850         [ALC662_FIXUP_ASPIRE] = {
11851                 .type = HDA_FIXUP_PINS,
11852                 .v.pins = (const struct hda_pintbl[]) {
11853                         { 0x15, 0x99130112 }, /* subwoofer */
11854                         { }
11855                 }
11856         },
11857         [ALC662_FIXUP_LED_GPIO1] = {
11858                 .type = HDA_FIXUP_FUNC,
11859                 .v.func = alc662_fixup_led_gpio1,
11860         },
11861         [ALC662_FIXUP_IDEAPAD] = {
11862                 .type = HDA_FIXUP_PINS,
11863                 .v.pins = (const struct hda_pintbl[]) {
11864                         { 0x17, 0x99130112 }, /* subwoofer */
11865                         { }
11866                 },
11867                 .chained = true,
11868                 .chain_id = ALC662_FIXUP_LED_GPIO1,
11869         },
11870         [ALC272_FIXUP_MARIO] = {
11871                 .type = HDA_FIXUP_FUNC,
11872                 .v.func = alc272_fixup_mario,
11873         },
11874         [ALC662_FIXUP_CZC_ET26] = {
11875                 .type = HDA_FIXUP_PINS,
11876                 .v.pins = (const struct hda_pintbl[]) {
11877                         {0x12, 0x403cc000},
11878                         {0x14, 0x90170110}, /* speaker */
11879                         {0x15, 0x411111f0},
11880                         {0x16, 0x411111f0},
11881                         {0x18, 0x01a19030}, /* mic */
11882                         {0x19, 0x90a7013f}, /* int-mic */
11883                         {0x1a, 0x01014020},
11884                         {0x1b, 0x0121401f},
11885                         {0x1c, 0x411111f0},
11886                         {0x1d, 0x411111f0},
11887                         {0x1e, 0x40478e35},
11888                         {}
11889                 },
11890                 .chained = true,
11891                 .chain_id = ALC662_FIXUP_SKU_IGNORE
11892         },
11893         [ALC662_FIXUP_CZC_P10T] = {
11894                 .type = HDA_FIXUP_VERBS,
11895                 .v.verbs = (const struct hda_verb[]) {
11896                         {0x14, AC_VERB_SET_EAPD_BTLENABLE, 0},
11897                         {}
11898                 }
11899         },
11900         [ALC662_FIXUP_SKU_IGNORE] = {
11901                 .type = HDA_FIXUP_FUNC,
11902                 .v.func = alc_fixup_sku_ignore,
11903         },
11904         [ALC662_FIXUP_HP_RP5800] = {
11905                 .type = HDA_FIXUP_PINS,
11906                 .v.pins = (const struct hda_pintbl[]) {
11907                         { 0x14, 0x0221201f }, /* HP out */
11908                         { }
11909                 },
11910                 .chained = true,
11911                 .chain_id = ALC662_FIXUP_SKU_IGNORE
11912         },
11913         [ALC662_FIXUP_ASUS_MODE1] = {
11914                 .type = HDA_FIXUP_PINS,
11915                 .v.pins = (const struct hda_pintbl[]) {
11916                         { 0x14, 0x99130110 }, /* speaker */
11917                         { 0x18, 0x01a19c20 }, /* mic */
11918                         { 0x19, 0x99a3092f }, /* int-mic */
11919                         { 0x21, 0x0121401f }, /* HP out */
11920                         { }
11921                 },
11922                 .chained = true,
11923                 .chain_id = ALC662_FIXUP_SKU_IGNORE
11924         },
11925         [ALC662_FIXUP_ASUS_MODE2] = {
11926                 .type = HDA_FIXUP_PINS,
11927                 .v.pins = (const struct hda_pintbl[]) {
11928                         { 0x14, 0x99130110 }, /* speaker */
11929                         { 0x18, 0x01a19820 }, /* mic */
11930                         { 0x19, 0x99a3092f }, /* int-mic */
11931                         { 0x1b, 0x0121401f }, /* HP out */
11932                         { }
11933                 },
11934                 .chained = true,
11935                 .chain_id = ALC662_FIXUP_SKU_IGNORE
11936         },
11937         [ALC662_FIXUP_ASUS_MODE3] = {
11938                 .type = HDA_FIXUP_PINS,
11939                 .v.pins = (const struct hda_pintbl[]) {
11940                         { 0x14, 0x99130110 }, /* speaker */
11941                         { 0x15, 0x0121441f }, /* HP */
11942                         { 0x18, 0x01a19840 }, /* mic */
11943                         { 0x19, 0x99a3094f }, /* int-mic */
11944                         { 0x21, 0x01211420 }, /* HP2 */
11945                         { }
11946                 },
11947                 .chained = true,
11948                 .chain_id = ALC662_FIXUP_SKU_IGNORE
11949         },
11950         [ALC662_FIXUP_ASUS_MODE4] = {
11951                 .type = HDA_FIXUP_PINS,
11952                 .v.pins = (const struct hda_pintbl[]) {
11953                         { 0x14, 0x99130110 }, /* speaker */
11954                         { 0x16, 0x99130111 }, /* speaker */
11955                         { 0x18, 0x01a19840 }, /* mic */
11956                         { 0x19, 0x99a3094f }, /* int-mic */
11957                         { 0x21, 0x0121441f }, /* HP */
11958                         { }
11959                 },
11960                 .chained = true,
11961                 .chain_id = ALC662_FIXUP_SKU_IGNORE
11962         },
11963         [ALC662_FIXUP_ASUS_MODE5] = {
11964                 .type = HDA_FIXUP_PINS,
11965                 .v.pins = (const struct hda_pintbl[]) {
11966                         { 0x14, 0x99130110 }, /* speaker */
11967                         { 0x15, 0x0121441f }, /* HP */
11968                         { 0x16, 0x99130111 }, /* speaker */
11969                         { 0x18, 0x01a19840 }, /* mic */
11970                         { 0x19, 0x99a3094f }, /* int-mic */
11971                         { }
11972                 },
11973                 .chained = true,
11974                 .chain_id = ALC662_FIXUP_SKU_IGNORE
11975         },
11976         [ALC662_FIXUP_ASUS_MODE6] = {
11977                 .type = HDA_FIXUP_PINS,
11978                 .v.pins = (const struct hda_pintbl[]) {
11979                         { 0x14, 0x99130110 }, /* speaker */
11980                         { 0x15, 0x01211420 }, /* HP2 */
11981                         { 0x18, 0x01a19840 }, /* mic */
11982                         { 0x19, 0x99a3094f }, /* int-mic */
11983                         { 0x1b, 0x0121441f }, /* HP */
11984                         { }
11985                 },
11986                 .chained = true,
11987                 .chain_id = ALC662_FIXUP_SKU_IGNORE
11988         },
11989         [ALC662_FIXUP_ASUS_MODE7] = {
11990                 .type = HDA_FIXUP_PINS,
11991                 .v.pins = (const struct hda_pintbl[]) {
11992                         { 0x14, 0x99130110 }, /* speaker */
11993                         { 0x17, 0x99130111 }, /* speaker */
11994                         { 0x18, 0x01a19840 }, /* mic */
11995                         { 0x19, 0x99a3094f }, /* int-mic */
11996                         { 0x1b, 0x01214020 }, /* HP */
11997                         { 0x21, 0x0121401f }, /* HP */
11998                         { }
11999                 },
12000                 .chained = true,
12001                 .chain_id = ALC662_FIXUP_SKU_IGNORE
12002         },
12003         [ALC662_FIXUP_ASUS_MODE8] = {
12004                 .type = HDA_FIXUP_PINS,
12005                 .v.pins = (const struct hda_pintbl[]) {
12006                         { 0x14, 0x99130110 }, /* speaker */
12007                         { 0x12, 0x99a30970 }, /* int-mic */
12008                         { 0x15, 0x01214020 }, /* HP */
12009                         { 0x17, 0x99130111 }, /* speaker */
12010                         { 0x18, 0x01a19840 }, /* mic */
12011                         { 0x21, 0x0121401f }, /* HP */
12012                         { }
12013                 },
12014                 .chained = true,
12015                 .chain_id = ALC662_FIXUP_SKU_IGNORE
12016         },
12017         [ALC662_FIXUP_NO_JACK_DETECT] = {
12018                 .type = HDA_FIXUP_FUNC,
12019                 .v.func = alc_fixup_no_jack_detect,
12020         },
12021         [ALC662_FIXUP_ZOTAC_Z68] = {
12022                 .type = HDA_FIXUP_PINS,
12023                 .v.pins = (const struct hda_pintbl[]) {
12024                         { 0x1b, 0x02214020 }, /* Front HP */
12025                         { }
12026                 }
12027         },
12028         [ALC662_FIXUP_INV_DMIC] = {
12029                 .type = HDA_FIXUP_FUNC,
12030                 .v.func = alc_fixup_inv_dmic,
12031         },
12032         [ALC668_FIXUP_DELL_XPS13] = {
12033                 .type = HDA_FIXUP_FUNC,
12034                 .v.func = alc_fixup_dell_xps13,
12035                 .chained = true,
12036                 .chain_id = ALC668_FIXUP_DELL_DISABLE_AAMIX
12037         },
12038         [ALC668_FIXUP_DELL_DISABLE_AAMIX] = {
12039                 .type = HDA_FIXUP_FUNC,
12040                 .v.func = alc_fixup_disable_aamix,
12041                 .chained = true,
12042                 .chain_id = ALC668_FIXUP_DELL_MIC_NO_PRESENCE
12043         },
12044         [ALC668_FIXUP_AUTO_MUTE] = {
12045                 .type = HDA_FIXUP_FUNC,
12046                 .v.func = alc_fixup_auto_mute_via_amp,
12047                 .chained = true,
12048                 .chain_id = ALC668_FIXUP_DELL_MIC_NO_PRESENCE
12049         },
12050         [ALC662_FIXUP_DELL_MIC_NO_PRESENCE] = {
12051                 .type = HDA_FIXUP_PINS,
12052                 .v.pins = (const struct hda_pintbl[]) {
12053                         { 0x19, 0x03a1113c }, /* use as headset mic, without its own jack detect */
12054                         /* headphone mic by setting pin control of 0x1b (headphone out) to in + vref_50 */
12055                         { }
12056                 },
12057                 .chained = true,
12058                 .chain_id = ALC662_FIXUP_HEADSET_MODE
12059         },
12060         [ALC662_FIXUP_HEADSET_MODE] = {
12061                 .type = HDA_FIXUP_FUNC,
12062                 .v.func = alc_fixup_headset_mode_alc662,
12063         },
12064         [ALC668_FIXUP_DELL_MIC_NO_PRESENCE] = {
12065                 .type = HDA_FIXUP_PINS,
12066                 .v.pins = (const struct hda_pintbl[]) {
12067                         { 0x19, 0x03a1913d }, /* use as headphone mic, without its own jack detect */
12068                         { 0x1b, 0x03a1113c }, /* use as headset mic, without its own jack detect */
12069                         { }
12070                 },
12071                 .chained = true,
12072                 .chain_id = ALC668_FIXUP_HEADSET_MODE
12073         },
12074         [ALC668_FIXUP_HEADSET_MODE] = {
12075                 .type = HDA_FIXUP_FUNC,
12076                 .v.func = alc_fixup_headset_mode_alc668,
12077         },
12078         [ALC662_FIXUP_BASS_MODE4_CHMAP] = {
12079                 .type = HDA_FIXUP_FUNC,
12080                 .v.func = alc_fixup_bass_chmap,
12081                 .chained = true,
12082                 .chain_id = ALC662_FIXUP_ASUS_MODE4
12083         },
12084         [ALC662_FIXUP_BASS_16] = {
12085                 .type = HDA_FIXUP_PINS,
12086                 .v.pins = (const struct hda_pintbl[]) {
12087                         {0x16, 0x80106111}, /* bass speaker */
12088                         {}
12089                 },
12090                 .chained = true,
12091                 .chain_id = ALC662_FIXUP_BASS_CHMAP,
12092         },
12093         [ALC662_FIXUP_BASS_1A] = {
12094                 .type = HDA_FIXUP_PINS,
12095                 .v.pins = (const struct hda_pintbl[]) {
12096                         {0x1a, 0x80106111}, /* bass speaker */
12097                         {}
12098                 },
12099                 .chained = true,
12100                 .chain_id = ALC662_FIXUP_BASS_CHMAP,
12101         },
12102         [ALC662_FIXUP_BASS_CHMAP] = {
12103                 .type = HDA_FIXUP_FUNC,
12104                 .v.func = alc_fixup_bass_chmap,
12105         },
12106         [ALC662_FIXUP_ASUS_Nx50] = {
12107                 .type = HDA_FIXUP_FUNC,
12108                 .v.func = alc_fixup_auto_mute_via_amp,
12109                 .chained = true,
12110                 .chain_id = ALC662_FIXUP_BASS_1A
12111         },
12112         [ALC668_FIXUP_ASUS_Nx51_HEADSET_MODE] = {
12113                 .type = HDA_FIXUP_FUNC,
12114                 .v.func = alc_fixup_headset_mode_alc668,
12115                 .chain_id = ALC662_FIXUP_BASS_CHMAP
12116         },
12117         [ALC668_FIXUP_ASUS_Nx51] = {
12118                 .type = HDA_FIXUP_PINS,
12119                 .v.pins = (const struct hda_pintbl[]) {
12120                         { 0x19, 0x03a1913d }, /* use as headphone mic, without its own jack detect */
12121                         { 0x1a, 0x90170151 }, /* bass speaker */
12122                         { 0x1b, 0x03a1113c }, /* use as headset mic, without its own jack detect */
12123                         {}
12124                 },
12125                 .chained = true,
12126                 .chain_id = ALC668_FIXUP_ASUS_Nx51_HEADSET_MODE,
12127         },
12128         [ALC668_FIXUP_MIC_COEF] = {
12129                 .type = HDA_FIXUP_VERBS,
12130                 .v.verbs = (const struct hda_verb[]) {
12131                         { 0x20, AC_VERB_SET_COEF_INDEX, 0xc3 },
12132                         { 0x20, AC_VERB_SET_PROC_COEF, 0x4000 },
12133                         {}
12134                 },
12135         },
12136         [ALC668_FIXUP_ASUS_G751] = {
12137                 .type = HDA_FIXUP_PINS,
12138                 .v.pins = (const struct hda_pintbl[]) {
12139                         { 0x16, 0x0421101f }, /* HP */
12140                         {}
12141                 },
12142                 .chained = true,
12143                 .chain_id = ALC668_FIXUP_MIC_COEF
12144         },
12145         [ALC891_FIXUP_HEADSET_MODE] = {
12146                 .type = HDA_FIXUP_FUNC,
12147                 .v.func = alc_fixup_headset_mode,
12148         },
12149         [ALC891_FIXUP_DELL_MIC_NO_PRESENCE] = {
12150                 .type = HDA_FIXUP_PINS,
12151                 .v.pins = (const struct hda_pintbl[]) {
12152                         { 0x19, 0x03a1913d }, /* use as headphone mic, without its own jack detect */
12153                         { 0x1b, 0x03a1113c }, /* use as headset mic, without its own jack detect */
12154                         { }
12155                 },
12156                 .chained = true,
12157                 .chain_id = ALC891_FIXUP_HEADSET_MODE
12158         },
12159         [ALC662_FIXUP_ACER_VERITON] = {
12160                 .type = HDA_FIXUP_PINS,
12161                 .v.pins = (const struct hda_pintbl[]) {
12162                         { 0x15, 0x50170120 }, /* no internal speaker */
12163                         { }
12164                 }
12165         },
12166         [ALC892_FIXUP_ASROCK_MOBO] = {
12167                 .type = HDA_FIXUP_PINS,
12168                 .v.pins = (const struct hda_pintbl[]) {
12169                         { 0x15, 0x40f000f0 }, /* disabled */
12170                         { 0x16, 0x40f000f0 }, /* disabled */
12171                         { }
12172                 }
12173         },
12174         [ALC662_FIXUP_USI_FUNC] = {
12175                 .type = HDA_FIXUP_FUNC,
12176                 .v.func = alc662_fixup_usi_headset_mic,
12177         },
12178         [ALC662_FIXUP_USI_HEADSET_MODE] = {
12179                 .type = HDA_FIXUP_PINS,
12180                 .v.pins = (const struct hda_pintbl[]) {
12181                         { 0x19, 0x02a1913c }, /* use as headset mic, without its own jack detect */
12182                         { 0x18, 0x01a1903d },
12183                         { }
12184                 },
12185                 .chained = true,
12186                 .chain_id = ALC662_FIXUP_USI_FUNC
12187         },
12188         [ALC662_FIXUP_LENOVO_MULTI_CODECS] = {
12189                 .type = HDA_FIXUP_FUNC,
12190                 .v.func = alc233_alc662_fixup_lenovo_dual_codecs,
12191         },
12192         [ALC669_FIXUP_ACER_ASPIRE_ETHOS_HEADSET] = {
12193                 .type = HDA_FIXUP_FUNC,
12194                 .v.func = alc662_fixup_aspire_ethos_hp,
12195         },
12196         [ALC669_FIXUP_ACER_ASPIRE_ETHOS] = {
12197                 .type = HDA_FIXUP_PINS,
12198                 .v.pins = (const struct hda_pintbl[]) {
12199                         { 0x15, 0x92130110 }, /* front speakers */
12200                         { 0x18, 0x99130111 }, /* center/subwoofer */
12201                         { 0x1b, 0x11130012 }, /* surround plus jack for HP */
12202                         { }
12203                 },
12204                 .chained = true,
12205                 .chain_id = ALC669_FIXUP_ACER_ASPIRE_ETHOS_HEADSET
12206         },
12207         [ALC671_FIXUP_HP_HEADSET_MIC2] = {
12208                 .type = HDA_FIXUP_FUNC,
12209                 .v.func = alc671_fixup_hp_headset_mic2,
12210         },
12211         [ALC662_FIXUP_ACER_X2660G_HEADSET_MODE] = {
12212                 .type = HDA_FIXUP_PINS,
12213                 .v.pins = (const struct hda_pintbl[]) {
12214                         { 0x1a, 0x02a1113c }, /* use as headset mic, without its own jack detect */
12215                         { }
12216                 },
12217                 .chained = true,
12218                 .chain_id = ALC662_FIXUP_USI_FUNC
12219         },
12220         [ALC662_FIXUP_ACER_NITRO_HEADSET_MODE] = {
12221                 .type = HDA_FIXUP_PINS,
12222                 .v.pins = (const struct hda_pintbl[]) {
12223                         { 0x1a, 0x01a11140 }, /* use as headset mic, without its own jack detect */
12224                         { 0x1b, 0x0221144f },
12225                         { }
12226                 },
12227                 .chained = true,
12228                 .chain_id = ALC662_FIXUP_USI_FUNC
12229         },
12230         [ALC668_FIXUP_ASUS_NO_HEADSET_MIC] = {
12231                 .type = HDA_FIXUP_PINS,
12232                 .v.pins = (const struct hda_pintbl[]) {
12233                         { 0x1b, 0x04a1112c },
12234                         { }
12235                 },
12236                 .chained = true,
12237                 .chain_id = ALC668_FIXUP_HEADSET_MIC
12238         },
12239         [ALC668_FIXUP_HEADSET_MIC] = {
12240                 .type = HDA_FIXUP_FUNC,
12241                 .v.func = alc269_fixup_headset_mic,
12242                 .chained = true,
12243                 .chain_id = ALC668_FIXUP_MIC_DET_COEF
12244         },
12245         [ALC668_FIXUP_MIC_DET_COEF] = {
12246                 .type = HDA_FIXUP_VERBS,
12247                 .v.verbs = (const struct hda_verb[]) {
12248                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x15 },
12249                         { 0x20, AC_VERB_SET_PROC_COEF, 0x0d60 },
12250                         {}
12251                 },
12252         },
12253         [ALC897_FIXUP_LENOVO_HEADSET_MIC] = {
12254                 .type = HDA_FIXUP_FUNC,
12255                 .v.func = alc897_fixup_lenovo_headset_mic,
12256         },
12257         [ALC897_FIXUP_HEADSET_MIC_PIN] = {
12258                 .type = HDA_FIXUP_PINS,
12259                 .v.pins = (const struct hda_pintbl[]) {
12260                         { 0x1a, 0x03a11050 },
12261                         { }
12262                 },
12263                 .chained = true,
12264                 .chain_id = ALC897_FIXUP_LENOVO_HEADSET_MIC
12265         },
12266         [ALC897_FIXUP_HP_HSMIC_VERB] = {
12267                 .type = HDA_FIXUP_PINS,
12268                 .v.pins = (const struct hda_pintbl[]) {
12269                         { 0x19, 0x01a1913c }, /* use as headset mic, without its own jack detect */
12270                         { }
12271                 },
12272         },
12273         [ALC897_FIXUP_LENOVO_HEADSET_MODE] = {
12274                 .type = HDA_FIXUP_FUNC,
12275                 .v.func = alc897_fixup_lenovo_headset_mode,
12276         },
12277         [ALC897_FIXUP_HEADSET_MIC_PIN2] = {
12278                 .type = HDA_FIXUP_PINS,
12279                 .v.pins = (const struct hda_pintbl[]) {
12280                         { 0x1a, 0x01a11140 }, /* use as headset mic, without its own jack detect */
12281                         { }
12282                 },
12283                 .chained = true,
12284                 .chain_id = ALC897_FIXUP_LENOVO_HEADSET_MODE
12285         },
12286         [ALC897_FIXUP_UNIS_H3C_X500S] = {
12287                 .type = HDA_FIXUP_VERBS,
12288                 .v.verbs = (const struct hda_verb[]) {
12289                         { 0x14, AC_VERB_SET_EAPD_BTLENABLE, 0 },
12290                         {}
12291                 },
12292         },
12293 };
12294
12295 static const struct snd_pci_quirk alc662_fixup_tbl[] = {
12296         SND_PCI_QUIRK(0x1019, 0x9087, "ECS", ALC662_FIXUP_ASUS_MODE2),
12297         SND_PCI_QUIRK(0x1025, 0x022f, "Acer Aspire One", ALC662_FIXUP_INV_DMIC),
12298         SND_PCI_QUIRK(0x1025, 0x0241, "Packard Bell DOTS", ALC662_FIXUP_INV_DMIC),
12299         SND_PCI_QUIRK(0x1025, 0x0308, "Acer Aspire 8942G", ALC662_FIXUP_ASPIRE),
12300         SND_PCI_QUIRK(0x1025, 0x031c, "Gateway NV79", ALC662_FIXUP_SKU_IGNORE),
12301         SND_PCI_QUIRK(0x1025, 0x0349, "eMachines eM250", ALC662_FIXUP_INV_DMIC),
12302         SND_PCI_QUIRK(0x1025, 0x034a, "Gateway LT27", ALC662_FIXUP_INV_DMIC),
12303         SND_PCI_QUIRK(0x1025, 0x038b, "Acer Aspire 8943G", ALC662_FIXUP_ASPIRE),
12304         SND_PCI_QUIRK(0x1025, 0x0566, "Acer Aspire Ethos 8951G", ALC669_FIXUP_ACER_ASPIRE_ETHOS),
12305         SND_PCI_QUIRK(0x1025, 0x123c, "Acer Nitro N50-600", ALC662_FIXUP_ACER_NITRO_HEADSET_MODE),
12306         SND_PCI_QUIRK(0x1025, 0x124e, "Acer 2660G", ALC662_FIXUP_ACER_X2660G_HEADSET_MODE),
12307         SND_PCI_QUIRK(0x1028, 0x05d8, "Dell", ALC668_FIXUP_DELL_MIC_NO_PRESENCE),
12308         SND_PCI_QUIRK(0x1028, 0x05db, "Dell", ALC668_FIXUP_DELL_MIC_NO_PRESENCE),
12309         SND_PCI_QUIRK(0x1028, 0x05fe, "Dell XPS 15", ALC668_FIXUP_DELL_XPS13),
12310         SND_PCI_QUIRK(0x1028, 0x060a, "Dell XPS 13", ALC668_FIXUP_DELL_XPS13),
12311         SND_PCI_QUIRK(0x1028, 0x060d, "Dell M3800", ALC668_FIXUP_DELL_XPS13),
12312         SND_PCI_QUIRK(0x1028, 0x0625, "Dell", ALC668_FIXUP_DELL_MIC_NO_PRESENCE),
12313         SND_PCI_QUIRK(0x1028, 0x0626, "Dell", ALC668_FIXUP_DELL_MIC_NO_PRESENCE),
12314         SND_PCI_QUIRK(0x1028, 0x0696, "Dell", ALC668_FIXUP_DELL_MIC_NO_PRESENCE),
12315         SND_PCI_QUIRK(0x1028, 0x0698, "Dell", ALC668_FIXUP_DELL_MIC_NO_PRESENCE),
12316         SND_PCI_QUIRK(0x1028, 0x069f, "Dell", ALC668_FIXUP_DELL_MIC_NO_PRESENCE),
12317         SND_PCI_QUIRK(0x103c, 0x1632, "HP RP5800", ALC662_FIXUP_HP_RP5800),
12318         SND_PCI_QUIRK(0x103c, 0x870c, "HP", ALC897_FIXUP_HP_HSMIC_VERB),
12319         SND_PCI_QUIRK(0x103c, 0x8719, "HP", ALC897_FIXUP_HP_HSMIC_VERB),
12320         SND_PCI_QUIRK(0x103c, 0x872b, "HP", ALC897_FIXUP_HP_HSMIC_VERB),
12321         SND_PCI_QUIRK(0x103c, 0x873e, "HP", ALC671_FIXUP_HP_HEADSET_MIC2),
12322         SND_PCI_QUIRK(0x103c, 0x8768, "HP Slim Desktop S01", ALC671_FIXUP_HP_HEADSET_MIC2),
12323         SND_PCI_QUIRK(0x103c, 0x877e, "HP 288 Pro G6", ALC671_FIXUP_HP_HEADSET_MIC2),
12324         SND_PCI_QUIRK(0x103c, 0x885f, "HP 288 Pro G8", ALC671_FIXUP_HP_HEADSET_MIC2),
12325         SND_PCI_QUIRK(0x1043, 0x1080, "Asus UX501VW", ALC668_FIXUP_HEADSET_MODE),
12326         SND_PCI_QUIRK(0x1043, 0x11cd, "Asus N550", ALC662_FIXUP_ASUS_Nx50),
12327         SND_PCI_QUIRK(0x1043, 0x129d, "Asus N750", ALC662_FIXUP_ASUS_Nx50),
12328         SND_PCI_QUIRK(0x1043, 0x12ff, "ASUS G751", ALC668_FIXUP_ASUS_G751),
12329         SND_PCI_QUIRK(0x1043, 0x13df, "Asus N550JX", ALC662_FIXUP_BASS_1A),
12330         SND_PCI_QUIRK(0x1043, 0x1477, "ASUS N56VZ", ALC662_FIXUP_BASS_MODE4_CHMAP),
12331         SND_PCI_QUIRK(0x1043, 0x15a7, "ASUS UX51VZH", ALC662_FIXUP_BASS_16),
12332         SND_PCI_QUIRK(0x1043, 0x177d, "ASUS N551", ALC668_FIXUP_ASUS_Nx51),
12333         SND_PCI_QUIRK(0x1043, 0x17bd, "ASUS N751", ALC668_FIXUP_ASUS_Nx51),
12334         SND_PCI_QUIRK(0x1043, 0x185d, "ASUS G551JW", ALC668_FIXUP_ASUS_NO_HEADSET_MIC),
12335         SND_PCI_QUIRK(0x1043, 0x1963, "ASUS X71SL", ALC662_FIXUP_ASUS_MODE8),
12336         SND_PCI_QUIRK(0x1043, 0x1b73, "ASUS N55SF", ALC662_FIXUP_BASS_16),
12337         SND_PCI_QUIRK(0x1043, 0x1bf3, "ASUS N76VZ", ALC662_FIXUP_BASS_MODE4_CHMAP),
12338         SND_PCI_QUIRK(0x1043, 0x8469, "ASUS mobo", ALC662_FIXUP_NO_JACK_DETECT),
12339         SND_PCI_QUIRK(0x105b, 0x0cd6, "Foxconn", ALC662_FIXUP_ASUS_MODE2),
12340         SND_PCI_QUIRK(0x144d, 0xc051, "Samsung R720", ALC662_FIXUP_IDEAPAD),
12341         SND_PCI_QUIRK(0x14cd, 0x5003, "USI", ALC662_FIXUP_USI_HEADSET_MODE),
12342         SND_PCI_QUIRK(0x17aa, 0x1036, "Lenovo P520", ALC662_FIXUP_LENOVO_MULTI_CODECS),
12343         SND_PCI_QUIRK(0x17aa, 0x1057, "Lenovo P360", ALC897_FIXUP_HEADSET_MIC_PIN),
12344         SND_PCI_QUIRK(0x17aa, 0x1064, "Lenovo P3 Tower", ALC897_FIXUP_HEADSET_MIC_PIN),
12345         SND_PCI_QUIRK(0x17aa, 0x32ca, "Lenovo ThinkCentre M80", ALC897_FIXUP_HEADSET_MIC_PIN),
12346         SND_PCI_QUIRK(0x17aa, 0x32cb, "Lenovo ThinkCentre M70", ALC897_FIXUP_HEADSET_MIC_PIN),
12347         SND_PCI_QUIRK(0x17aa, 0x32cf, "Lenovo ThinkCentre M950", ALC897_FIXUP_HEADSET_MIC_PIN),
12348         SND_PCI_QUIRK(0x17aa, 0x32f7, "Lenovo ThinkCentre M90", ALC897_FIXUP_HEADSET_MIC_PIN),
12349         SND_PCI_QUIRK(0x17aa, 0x3321, "Lenovo ThinkCentre M70 Gen4", ALC897_FIXUP_HEADSET_MIC_PIN),
12350         SND_PCI_QUIRK(0x17aa, 0x331b, "Lenovo ThinkCentre M90 Gen4", ALC897_FIXUP_HEADSET_MIC_PIN),
12351         SND_PCI_QUIRK(0x17aa, 0x3364, "Lenovo ThinkCentre M90 Gen5", ALC897_FIXUP_HEADSET_MIC_PIN),
12352         SND_PCI_QUIRK(0x17aa, 0x3742, "Lenovo TianYi510Pro-14IOB", ALC897_FIXUP_HEADSET_MIC_PIN2),
12353         SND_PCI_QUIRK(0x17aa, 0x38af, "Lenovo Ideapad Y550P", ALC662_FIXUP_IDEAPAD),
12354         SND_PCI_QUIRK(0x17aa, 0x3a0d, "Lenovo Ideapad Y550", ALC662_FIXUP_IDEAPAD),
12355         SND_PCI_QUIRK(0x1849, 0x5892, "ASRock B150M", ALC892_FIXUP_ASROCK_MOBO),
12356         SND_PCI_QUIRK(0x19da, 0xa130, "Zotac Z68", ALC662_FIXUP_ZOTAC_Z68),
12357         SND_PCI_QUIRK(0x1b0a, 0x01b8, "ACER Veriton", ALC662_FIXUP_ACER_VERITON),
12358         SND_PCI_QUIRK(0x1b35, 0x1234, "CZC ET26", ALC662_FIXUP_CZC_ET26),
12359         SND_PCI_QUIRK(0x1b35, 0x2206, "CZC P10T", ALC662_FIXUP_CZC_P10T),
12360         SND_PCI_QUIRK(0x1c6c, 0x1239, "Compaq N14JP6-V2", ALC897_FIXUP_HP_HSMIC_VERB),
12361
12362 #if 0
12363         /* Below is a quirk table taken from the old code.
12364          * Basically the device should work as is without the fixup table.
12365          * If BIOS doesn't give a proper info, enable the corresponding
12366          * fixup entry.
12367          */
12368         SND_PCI_QUIRK(0x1043, 0x1000, "ASUS N50Vm", ALC662_FIXUP_ASUS_MODE1),
12369         SND_PCI_QUIRK(0x1043, 0x1092, "ASUS NB", ALC662_FIXUP_ASUS_MODE3),
12370         SND_PCI_QUIRK(0x1043, 0x1173, "ASUS K73Jn", ALC662_FIXUP_ASUS_MODE1),
12371         SND_PCI_QUIRK(0x1043, 0x11c3, "ASUS M70V", ALC662_FIXUP_ASUS_MODE3),
12372         SND_PCI_QUIRK(0x1043, 0x11d3, "ASUS NB", ALC662_FIXUP_ASUS_MODE1),
12373         SND_PCI_QUIRK(0x1043, 0x11f3, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),
12374         SND_PCI_QUIRK(0x1043, 0x1203, "ASUS NB", ALC662_FIXUP_ASUS_MODE1),
12375         SND_PCI_QUIRK(0x1043, 0x1303, "ASUS G60J", ALC662_FIXUP_ASUS_MODE1),
12376         SND_PCI_QUIRK(0x1043, 0x1333, "ASUS G60Jx", ALC662_FIXUP_ASUS_MODE1),
12377         SND_PCI_QUIRK(0x1043, 0x1339, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),
12378         SND_PCI_QUIRK(0x1043, 0x13e3, "ASUS N71JA", ALC662_FIXUP_ASUS_MODE7),
12379         SND_PCI_QUIRK(0x1043, 0x1463, "ASUS N71", ALC662_FIXUP_ASUS_MODE7),
12380         SND_PCI_QUIRK(0x1043, 0x14d3, "ASUS G72", ALC662_FIXUP_ASUS_MODE8),
12381         SND_PCI_QUIRK(0x1043, 0x1563, "ASUS N90", ALC662_FIXUP_ASUS_MODE3),
12382         SND_PCI_QUIRK(0x1043, 0x15d3, "ASUS N50SF F50SF", ALC662_FIXUP_ASUS_MODE1),
12383         SND_PCI_QUIRK(0x1043, 0x16c3, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),
12384         SND_PCI_QUIRK(0x1043, 0x16f3, "ASUS K40C K50C", ALC662_FIXUP_ASUS_MODE2),
12385         SND_PCI_QUIRK(0x1043, 0x1733, "ASUS N81De", ALC662_FIXUP_ASUS_MODE1),
12386         SND_PCI_QUIRK(0x1043, 0x1753, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),
12387         SND_PCI_QUIRK(0x1043, 0x1763, "ASUS NB", ALC662_FIXUP_ASUS_MODE6),
12388         SND_PCI_QUIRK(0x1043, 0x1765, "ASUS NB", ALC662_FIXUP_ASUS_MODE6),
12389         SND_PCI_QUIRK(0x1043, 0x1783, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),
12390         SND_PCI_QUIRK(0x1043, 0x1793, "ASUS F50GX", ALC662_FIXUP_ASUS_MODE1),
12391         SND_PCI_QUIRK(0x1043, 0x17b3, "ASUS F70SL", ALC662_FIXUP_ASUS_MODE3),
12392         SND_PCI_QUIRK(0x1043, 0x17f3, "ASUS X58LE", ALC662_FIXUP_ASUS_MODE2),
12393         SND_PCI_QUIRK(0x1043, 0x1813, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),
12394         SND_PCI_QUIRK(0x1043, 0x1823, "ASUS NB", ALC662_FIXUP_ASUS_MODE5),
12395         SND_PCI_QUIRK(0x1043, 0x1833, "ASUS NB", ALC662_FIXUP_ASUS_MODE6),
12396         SND_PCI_QUIRK(0x1043, 0x1843, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),
12397         SND_PCI_QUIRK(0x1043, 0x1853, "ASUS F50Z", ALC662_FIXUP_ASUS_MODE1),
12398         SND_PCI_QUIRK(0x1043, 0x1864, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),
12399         SND_PCI_QUIRK(0x1043, 0x1876, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),
12400         SND_PCI_QUIRK(0x1043, 0x1893, "ASUS M50Vm", ALC662_FIXUP_ASUS_MODE3),
12401         SND_PCI_QUIRK(0x1043, 0x1894, "ASUS X55", ALC662_FIXUP_ASUS_MODE3),
12402         SND_PCI_QUIRK(0x1043, 0x18b3, "ASUS N80Vc", ALC662_FIXUP_ASUS_MODE1),
12403         SND_PCI_QUIRK(0x1043, 0x18c3, "ASUS VX5", ALC662_FIXUP_ASUS_MODE1),
12404         SND_PCI_QUIRK(0x1043, 0x18d3, "ASUS N81Te", ALC662_FIXUP_ASUS_MODE1),
12405         SND_PCI_QUIRK(0x1043, 0x18f3, "ASUS N505Tp", ALC662_FIXUP_ASUS_MODE1),
12406         SND_PCI_QUIRK(0x1043, 0x1903, "ASUS F5GL", ALC662_FIXUP_ASUS_MODE1),
12407         SND_PCI_QUIRK(0x1043, 0x1913, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),
12408         SND_PCI_QUIRK(0x1043, 0x1933, "ASUS F80Q", ALC662_FIXUP_ASUS_MODE2),
12409         SND_PCI_QUIRK(0x1043, 0x1943, "ASUS Vx3V", ALC662_FIXUP_ASUS_MODE1),
12410         SND_PCI_QUIRK(0x1043, 0x1953, "ASUS NB", ALC662_FIXUP_ASUS_MODE1),
12411         SND_PCI_QUIRK(0x1043, 0x1963, "ASUS X71C", ALC662_FIXUP_ASUS_MODE3),
12412         SND_PCI_QUIRK(0x1043, 0x1983, "ASUS N5051A", ALC662_FIXUP_ASUS_MODE1),
12413         SND_PCI_QUIRK(0x1043, 0x1993, "ASUS N20", ALC662_FIXUP_ASUS_MODE1),
12414         SND_PCI_QUIRK(0x1043, 0x19b3, "ASUS F7Z", ALC662_FIXUP_ASUS_MODE1),
12415         SND_PCI_QUIRK(0x1043, 0x19c3, "ASUS F5Z/F6x", ALC662_FIXUP_ASUS_MODE2),
12416         SND_PCI_QUIRK(0x1043, 0x19e3, "ASUS NB", ALC662_FIXUP_ASUS_MODE1),
12417         SND_PCI_QUIRK(0x1043, 0x19f3, "ASUS NB", ALC662_FIXUP_ASUS_MODE4),
12418 #endif
12419         {}
12420 };
12421
12422 static const struct hda_model_fixup alc662_fixup_models[] = {
12423         {.id = ALC662_FIXUP_ASPIRE, .name = "aspire"},
12424         {.id = ALC662_FIXUP_IDEAPAD, .name = "ideapad"},
12425         {.id = ALC272_FIXUP_MARIO, .name = "mario"},
12426         {.id = ALC662_FIXUP_HP_RP5800, .name = "hp-rp5800"},
12427         {.id = ALC662_FIXUP_ASUS_MODE1, .name = "asus-mode1"},
12428         {.id = ALC662_FIXUP_ASUS_MODE2, .name = "asus-mode2"},
12429         {.id = ALC662_FIXUP_ASUS_MODE3, .name = "asus-mode3"},
12430         {.id = ALC662_FIXUP_ASUS_MODE4, .name = "asus-mode4"},
12431         {.id = ALC662_FIXUP_ASUS_MODE5, .name = "asus-mode5"},
12432         {.id = ALC662_FIXUP_ASUS_MODE6, .name = "asus-mode6"},
12433         {.id = ALC662_FIXUP_ASUS_MODE7, .name = "asus-mode7"},
12434         {.id = ALC662_FIXUP_ASUS_MODE8, .name = "asus-mode8"},
12435         {.id = ALC662_FIXUP_ZOTAC_Z68, .name = "zotac-z68"},
12436         {.id = ALC662_FIXUP_INV_DMIC, .name = "inv-dmic"},
12437         {.id = ALC662_FIXUP_DELL_MIC_NO_PRESENCE, .name = "alc662-headset-multi"},
12438         {.id = ALC668_FIXUP_DELL_MIC_NO_PRESENCE, .name = "dell-headset-multi"},
12439         {.id = ALC662_FIXUP_HEADSET_MODE, .name = "alc662-headset"},
12440         {.id = ALC668_FIXUP_HEADSET_MODE, .name = "alc668-headset"},
12441         {.id = ALC662_FIXUP_BASS_16, .name = "bass16"},
12442         {.id = ALC662_FIXUP_BASS_1A, .name = "bass1a"},
12443         {.id = ALC668_FIXUP_AUTO_MUTE, .name = "automute"},
12444         {.id = ALC668_FIXUP_DELL_XPS13, .name = "dell-xps13"},
12445         {.id = ALC662_FIXUP_ASUS_Nx50, .name = "asus-nx50"},
12446         {.id = ALC668_FIXUP_ASUS_Nx51, .name = "asus-nx51"},
12447         {.id = ALC668_FIXUP_ASUS_G751, .name = "asus-g751"},
12448         {.id = ALC891_FIXUP_HEADSET_MODE, .name = "alc891-headset"},
12449         {.id = ALC891_FIXUP_DELL_MIC_NO_PRESENCE, .name = "alc891-headset-multi"},
12450         {.id = ALC662_FIXUP_ACER_VERITON, .name = "acer-veriton"},
12451         {.id = ALC892_FIXUP_ASROCK_MOBO, .name = "asrock-mobo"},
12452         {.id = ALC662_FIXUP_USI_HEADSET_MODE, .name = "usi-headset"},
12453         {.id = ALC662_FIXUP_LENOVO_MULTI_CODECS, .name = "dual-codecs"},
12454         {.id = ALC669_FIXUP_ACER_ASPIRE_ETHOS, .name = "aspire-ethos"},
12455         {.id = ALC897_FIXUP_UNIS_H3C_X500S, .name = "unis-h3c-x500s"},
12456         {}
12457 };
12458
12459 static const struct snd_hda_pin_quirk alc662_pin_fixup_tbl[] = {
12460         SND_HDA_PIN_QUIRK(0x10ec0867, 0x1028, "Dell", ALC891_FIXUP_DELL_MIC_NO_PRESENCE,
12461                 {0x17, 0x02211010},
12462                 {0x18, 0x01a19030},
12463                 {0x1a, 0x01813040},
12464                 {0x21, 0x01014020}),
12465         SND_HDA_PIN_QUIRK(0x10ec0867, 0x1028, "Dell", ALC891_FIXUP_DELL_MIC_NO_PRESENCE,
12466                 {0x16, 0x01813030},
12467                 {0x17, 0x02211010},
12468                 {0x18, 0x01a19040},
12469                 {0x21, 0x01014020}),
12470         SND_HDA_PIN_QUIRK(0x10ec0662, 0x1028, "Dell", ALC662_FIXUP_DELL_MIC_NO_PRESENCE,
12471                 {0x14, 0x01014010},
12472                 {0x18, 0x01a19020},
12473                 {0x1a, 0x0181302f},
12474                 {0x1b, 0x0221401f}),
12475         SND_HDA_PIN_QUIRK(0x10ec0668, 0x1028, "Dell", ALC668_FIXUP_AUTO_MUTE,
12476                 {0x12, 0x99a30130},
12477                 {0x14, 0x90170110},
12478                 {0x15, 0x0321101f},
12479                 {0x16, 0x03011020}),
12480         SND_HDA_PIN_QUIRK(0x10ec0668, 0x1028, "Dell", ALC668_FIXUP_AUTO_MUTE,
12481                 {0x12, 0x99a30140},
12482                 {0x14, 0x90170110},
12483                 {0x15, 0x0321101f},
12484                 {0x16, 0x03011020}),
12485         SND_HDA_PIN_QUIRK(0x10ec0668, 0x1028, "Dell", ALC668_FIXUP_AUTO_MUTE,
12486                 {0x12, 0x99a30150},
12487                 {0x14, 0x90170110},
12488                 {0x15, 0x0321101f},
12489                 {0x16, 0x03011020}),
12490         SND_HDA_PIN_QUIRK(0x10ec0668, 0x1028, "Dell", ALC668_FIXUP_AUTO_MUTE,
12491                 {0x14, 0x90170110},
12492                 {0x15, 0x0321101f},
12493                 {0x16, 0x03011020}),
12494         SND_HDA_PIN_QUIRK(0x10ec0668, 0x1028, "Dell XPS 15", ALC668_FIXUP_AUTO_MUTE,
12495                 {0x12, 0x90a60130},
12496                 {0x14, 0x90170110},
12497                 {0x15, 0x0321101f}),
12498         SND_HDA_PIN_QUIRK(0x10ec0671, 0x103c, "HP cPC", ALC671_FIXUP_HP_HEADSET_MIC2,
12499                 {0x14, 0x01014010},
12500                 {0x17, 0x90170150},
12501                 {0x19, 0x02a11060},
12502                 {0x1b, 0x01813030},
12503                 {0x21, 0x02211020}),
12504         SND_HDA_PIN_QUIRK(0x10ec0671, 0x103c, "HP cPC", ALC671_FIXUP_HP_HEADSET_MIC2,
12505                 {0x14, 0x01014010},
12506                 {0x18, 0x01a19040},
12507                 {0x1b, 0x01813030},
12508                 {0x21, 0x02211020}),
12509         SND_HDA_PIN_QUIRK(0x10ec0671, 0x103c, "HP cPC", ALC671_FIXUP_HP_HEADSET_MIC2,
12510                 {0x14, 0x01014020},
12511                 {0x17, 0x90170110},
12512                 {0x18, 0x01a19050},
12513                 {0x1b, 0x01813040},
12514                 {0x21, 0x02211030}),
12515         {}
12516 };
12517
12518 /*
12519  */
12520 static int patch_alc662(struct hda_codec *codec)
12521 {
12522         struct alc_spec *spec;
12523         int err;
12524
12525         err = alc_alloc_spec(codec, 0x0b);
12526         if (err < 0)
12527                 return err;
12528
12529         spec = codec->spec;
12530
12531         spec->shutup = alc_eapd_shutup;
12532
12533         /* handle multiple HPs as is */
12534         spec->parse_flags = HDA_PINCFG_NO_HP_FIXUP;
12535
12536         alc_fix_pll_init(codec, 0x20, 0x04, 15);
12537
12538         switch (codec->core.vendor_id) {
12539         case 0x10ec0668:
12540                 spec->init_hook = alc668_restore_default_value;
12541                 break;
12542         }
12543
12544         alc_pre_init(codec);
12545
12546         snd_hda_pick_fixup(codec, alc662_fixup_models,
12547                        alc662_fixup_tbl, alc662_fixups);
12548         snd_hda_pick_pin_fixup(codec, alc662_pin_fixup_tbl, alc662_fixups, true);
12549         snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE);
12550
12551         alc_auto_parse_customize_define(codec);
12552
12553         if (has_cdefine_beep(codec))
12554                 spec->gen.beep_nid = 0x01;
12555
12556         if ((alc_get_coef0(codec) & (1 << 14)) &&
12557             codec->bus->pci && codec->bus->pci->subsystem_vendor == 0x1025 &&
12558             spec->cdefine.platform_type == 1) {
12559                 err = alc_codec_rename(codec, "ALC272X");
12560                 if (err < 0)
12561                         goto error;
12562         }
12563
12564         /* automatic parse from the BIOS config */
12565         err = alc662_parse_auto_config(codec);
12566         if (err < 0)
12567                 goto error;
12568
12569         if (!spec->gen.no_analog && spec->gen.beep_nid) {
12570                 switch (codec->core.vendor_id) {
12571                 case 0x10ec0662:
12572                         err = set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
12573                         break;
12574                 case 0x10ec0272:
12575                 case 0x10ec0663:
12576                 case 0x10ec0665:
12577                 case 0x10ec0668:
12578                         err = set_beep_amp(spec, 0x0b, 0x04, HDA_INPUT);
12579                         break;
12580                 case 0x10ec0273:
12581                         err = set_beep_amp(spec, 0x0b, 0x03, HDA_INPUT);
12582                         break;
12583                 }
12584                 if (err < 0)
12585                         goto error;
12586         }
12587
12588         snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE);
12589
12590         return 0;
12591
12592  error:
12593         alc_free(codec);
12594         return err;
12595 }
12596
12597 /*
12598  * ALC680 support
12599  */
12600
12601 static int alc680_parse_auto_config(struct hda_codec *codec)
12602 {
12603         return alc_parse_auto_config(codec, NULL, NULL);
12604 }
12605
12606 /*
12607  */
12608 static int patch_alc680(struct hda_codec *codec)
12609 {
12610         int err;
12611
12612         /* ALC680 has no aa-loopback mixer */
12613         err = alc_alloc_spec(codec, 0);
12614         if (err < 0)
12615                 return err;
12616
12617         /* automatic parse from the BIOS config */
12618         err = alc680_parse_auto_config(codec);
12619         if (err < 0) {
12620                 alc_free(codec);
12621                 return err;
12622         }
12623
12624         return 0;
12625 }
12626
12627 /*
12628  * patch entries
12629  */
12630 static const struct hda_device_id snd_hda_id_realtek[] = {
12631         HDA_CODEC_ENTRY(0x10ec0215, "ALC215", patch_alc269),
12632         HDA_CODEC_ENTRY(0x10ec0221, "ALC221", patch_alc269),
12633         HDA_CODEC_ENTRY(0x10ec0222, "ALC222", patch_alc269),
12634         HDA_CODEC_ENTRY(0x10ec0225, "ALC225", patch_alc269),
12635         HDA_CODEC_ENTRY(0x10ec0230, "ALC236", patch_alc269),
12636         HDA_CODEC_ENTRY(0x10ec0231, "ALC231", patch_alc269),
12637         HDA_CODEC_ENTRY(0x10ec0233, "ALC233", patch_alc269),
12638         HDA_CODEC_ENTRY(0x10ec0234, "ALC234", patch_alc269),
12639         HDA_CODEC_ENTRY(0x10ec0235, "ALC233", patch_alc269),
12640         HDA_CODEC_ENTRY(0x10ec0236, "ALC236", patch_alc269),
12641         HDA_CODEC_ENTRY(0x10ec0245, "ALC245", patch_alc269),
12642         HDA_CODEC_ENTRY(0x10ec0255, "ALC255", patch_alc269),
12643         HDA_CODEC_ENTRY(0x10ec0256, "ALC256", patch_alc269),
12644         HDA_CODEC_ENTRY(0x10ec0257, "ALC257", patch_alc269),
12645         HDA_CODEC_ENTRY(0x10ec0260, "ALC260", patch_alc260),
12646         HDA_CODEC_ENTRY(0x10ec0262, "ALC262", patch_alc262),
12647         HDA_CODEC_ENTRY(0x10ec0267, "ALC267", patch_alc268),
12648         HDA_CODEC_ENTRY(0x10ec0268, "ALC268", patch_alc268),
12649         HDA_CODEC_ENTRY(0x10ec0269, "ALC269", patch_alc269),
12650         HDA_CODEC_ENTRY(0x10ec0270, "ALC270", patch_alc269),
12651         HDA_CODEC_ENTRY(0x10ec0272, "ALC272", patch_alc662),
12652         HDA_CODEC_ENTRY(0x10ec0274, "ALC274", patch_alc269),
12653         HDA_CODEC_ENTRY(0x10ec0275, "ALC275", patch_alc269),
12654         HDA_CODEC_ENTRY(0x10ec0276, "ALC276", patch_alc269),
12655         HDA_CODEC_ENTRY(0x10ec0280, "ALC280", patch_alc269),
12656         HDA_CODEC_ENTRY(0x10ec0282, "ALC282", patch_alc269),
12657         HDA_CODEC_ENTRY(0x10ec0283, "ALC283", patch_alc269),
12658         HDA_CODEC_ENTRY(0x10ec0284, "ALC284", patch_alc269),
12659         HDA_CODEC_ENTRY(0x10ec0285, "ALC285", patch_alc269),
12660         HDA_CODEC_ENTRY(0x10ec0286, "ALC286", patch_alc269),
12661         HDA_CODEC_ENTRY(0x10ec0287, "ALC287", patch_alc269),
12662         HDA_CODEC_ENTRY(0x10ec0288, "ALC288", patch_alc269),
12663         HDA_CODEC_ENTRY(0x10ec0289, "ALC289", patch_alc269),
12664         HDA_CODEC_ENTRY(0x10ec0290, "ALC290", patch_alc269),
12665         HDA_CODEC_ENTRY(0x10ec0292, "ALC292", patch_alc269),
12666         HDA_CODEC_ENTRY(0x10ec0293, "ALC293", patch_alc269),
12667         HDA_CODEC_ENTRY(0x10ec0294, "ALC294", patch_alc269),
12668         HDA_CODEC_ENTRY(0x10ec0295, "ALC295", patch_alc269),
12669         HDA_CODEC_ENTRY(0x10ec0298, "ALC298", patch_alc269),
12670         HDA_CODEC_ENTRY(0x10ec0299, "ALC299", patch_alc269),
12671         HDA_CODEC_ENTRY(0x10ec0300, "ALC300", patch_alc269),
12672         HDA_CODEC_ENTRY(0x10ec0623, "ALC623", patch_alc269),
12673         HDA_CODEC_REV_ENTRY(0x10ec0861, 0x100340, "ALC660", patch_alc861),
12674         HDA_CODEC_ENTRY(0x10ec0660, "ALC660-VD", patch_alc861vd),
12675         HDA_CODEC_ENTRY(0x10ec0861, "ALC861", patch_alc861),
12676         HDA_CODEC_ENTRY(0x10ec0862, "ALC861-VD", patch_alc861vd),
12677         HDA_CODEC_REV_ENTRY(0x10ec0662, 0x100002, "ALC662 rev2", patch_alc882),
12678         HDA_CODEC_REV_ENTRY(0x10ec0662, 0x100101, "ALC662 rev1", patch_alc662),
12679         HDA_CODEC_REV_ENTRY(0x10ec0662, 0x100300, "ALC662 rev3", patch_alc662),
12680         HDA_CODEC_ENTRY(0x10ec0663, "ALC663", patch_alc662),
12681         HDA_CODEC_ENTRY(0x10ec0665, "ALC665", patch_alc662),
12682         HDA_CODEC_ENTRY(0x10ec0667, "ALC667", patch_alc662),
12683         HDA_CODEC_ENTRY(0x10ec0668, "ALC668", patch_alc662),
12684         HDA_CODEC_ENTRY(0x10ec0670, "ALC670", patch_alc662),
12685         HDA_CODEC_ENTRY(0x10ec0671, "ALC671", patch_alc662),
12686         HDA_CODEC_ENTRY(0x10ec0680, "ALC680", patch_alc680),
12687         HDA_CODEC_ENTRY(0x10ec0700, "ALC700", patch_alc269),
12688         HDA_CODEC_ENTRY(0x10ec0701, "ALC701", patch_alc269),
12689         HDA_CODEC_ENTRY(0x10ec0703, "ALC703", patch_alc269),
12690         HDA_CODEC_ENTRY(0x10ec0711, "ALC711", patch_alc269),
12691         HDA_CODEC_ENTRY(0x10ec0867, "ALC891", patch_alc662),
12692         HDA_CODEC_ENTRY(0x10ec0880, "ALC880", patch_alc880),
12693         HDA_CODEC_ENTRY(0x10ec0882, "ALC882", patch_alc882),
12694         HDA_CODEC_ENTRY(0x10ec0883, "ALC883", patch_alc882),
12695         HDA_CODEC_REV_ENTRY(0x10ec0885, 0x100101, "ALC889A", patch_alc882),
12696         HDA_CODEC_REV_ENTRY(0x10ec0885, 0x100103, "ALC889A", patch_alc882),
12697         HDA_CODEC_ENTRY(0x10ec0885, "ALC885", patch_alc882),
12698         HDA_CODEC_ENTRY(0x10ec0887, "ALC887", patch_alc882),
12699         HDA_CODEC_REV_ENTRY(0x10ec0888, 0x100101, "ALC1200", patch_alc882),
12700         HDA_CODEC_ENTRY(0x10ec0888, "ALC888", patch_alc882),
12701         HDA_CODEC_ENTRY(0x10ec0889, "ALC889", patch_alc882),
12702         HDA_CODEC_ENTRY(0x10ec0892, "ALC892", patch_alc662),
12703         HDA_CODEC_ENTRY(0x10ec0897, "ALC897", patch_alc662),
12704         HDA_CODEC_ENTRY(0x10ec0899, "ALC898", patch_alc882),
12705         HDA_CODEC_ENTRY(0x10ec0900, "ALC1150", patch_alc882),
12706         HDA_CODEC_ENTRY(0x10ec0b00, "ALCS1200A", patch_alc882),
12707         HDA_CODEC_ENTRY(0x10ec1168, "ALC1220", patch_alc882),
12708         HDA_CODEC_ENTRY(0x10ec1220, "ALC1220", patch_alc882),
12709         HDA_CODEC_ENTRY(0x19e58326, "HW8326", patch_alc269),
12710         {} /* terminator */
12711 };
12712 MODULE_DEVICE_TABLE(hdaudio, snd_hda_id_realtek);
12713
12714 MODULE_LICENSE("GPL");
12715 MODULE_DESCRIPTION("Realtek HD-audio codec");
12716 MODULE_IMPORT_NS(SND_HDA_SCODEC_COMPONENT);
12717
12718 static struct hda_codec_driver realtek_driver = {
12719         .id = snd_hda_id_realtek,
12720 };
12721
12722 module_hda_codec_driver(realtek_driver);