sound/pci/hda/patch_realtek.c

   1 // SPDX-License-Identifier: GPL-2.0-or-later
   2 /*
   3  * Universal Interface for Intel High Definition Audio Codec
   4  *
   5  * HD audio interface patch for Realtek ALC codecs
   6  *
   7  * Copyright (c) 2004 Kailang Yang <kailang@realtek.com.tw>
   8  *                    PeiSen Hou <pshou@realtek.com.tw>
   9  *                    Takashi Iwai <tiwai@suse.de>
  10  *                    Jonathan Woithe <jwoithe@just42.net>
  11  */
  12
  13 #include <linux/init.h>
  14 #include <linux/delay.h>
  15 #include <linux/slab.h>
  16 #include <linux/pci.h>
  17 #include <linux/dmi.h>
  18 #include <linux/module.h>
  19 #include <linux/input.h>
  20 #include <linux/leds.h>
  21 #include <sound/core.h>
  22 #include <sound/jack.h>
  23 #include <sound/hda_codec.h>
  24 #include "hda_local.h"
  25 #include "hda_auto_parser.h"
  26 #include "hda_jack.h"
  27 #include "hda_generic.h"
  28
  29 /* keep halting ALC5505 DSP, for power saving */
  30 #define HALT_REALTEK_ALC5505
  31
  32 /* extra amp-initialization sequence types */
  33 enum {
  34         ALC_INIT_UNDEFINED,
  35         ALC_INIT_NONE,
  36         ALC_INIT_DEFAULT,
  37 };
  38
  39 enum {
  40         ALC_HEADSET_MODE_UNKNOWN,
  41         ALC_HEADSET_MODE_UNPLUGGED,
  42         ALC_HEADSET_MODE_HEADSET,
  43         ALC_HEADSET_MODE_MIC,
  44         ALC_HEADSET_MODE_HEADPHONE,
  45 };
  46
  47 enum {
  48         ALC_HEADSET_TYPE_UNKNOWN,
  49         ALC_HEADSET_TYPE_CTIA,
  50         ALC_HEADSET_TYPE_OMTP,
  51 };
  52
  53 enum {
  54         ALC_KEY_MICMUTE_INDEX,
  55 };
  56
  57 struct alc_customize_define {
  58         unsigned int  sku_cfg;
  59         unsigned char port_connectivity;
  60         unsigned char check_sum;
  61         unsigned char customization;
  62         unsigned char external_amp;
  63         unsigned int  enable_pcbeep:1;
  64         unsigned int  platform_type:1;
  65         unsigned int  swap:1;
  66         unsigned int  override:1;
  67         unsigned int  fixup:1; /* Means that this sku is set by driver, not read from hw */
  68 };
  69
  70 struct alc_coef_led {
  71         unsigned int idx;
  72         unsigned int mask;
  73         unsigned int on;
  74         unsigned int off;
  75 };
  76
  77 struct alc_spec {
  78         struct hda_gen_spec gen; /* must be at head */
  79
  80         /* codec parameterization */
  81         struct alc_customize_define cdefine;
  82         unsigned int parse_flags; /* flag for snd_hda_parse_pin_defcfg() */
  83
  84         /* GPIO bits */
  85         unsigned int gpio_mask;
  86         unsigned int gpio_dir;
  87         unsigned int gpio_data;
  88         bool gpio_write_delay;  /* add a delay before writing gpio_data */
  89
  90         /* mute LED for HP laptops, see vref_mute_led_set() */
  91         int mute_led_polarity;
  92         int micmute_led_polarity;
  93         hda_nid_t mute_led_nid;
  94         hda_nid_t cap_mute_led_nid;
  95
  96         unsigned int gpio_mute_led_mask;
  97         unsigned int gpio_mic_led_mask;
  98         struct alc_coef_led mute_led_coef;
  99         struct alc_coef_led mic_led_coef;
 100
 101         hda_nid_t headset_mic_pin;
 102         hda_nid_t headphone_mic_pin;
 103         int current_headset_mode;
 104         int current_headset_type;
 105
 106         /* hooks */
 107         void (*init_hook)(struct hda_codec *codec);
 108 #ifdef CONFIG_PM
 109         void (*power_hook)(struct hda_codec *codec);
 110 #endif
 111         void (*shutup)(struct hda_codec *codec);
 112
 113         int init_amp;
 114         int codec_variant;      /* flag for other variants */
 115         unsigned int has_alc5505_dsp:1;
 116         unsigned int no_depop_delay:1;
 117         unsigned int done_hp_init:1;
 118         unsigned int no_shutup_pins:1;
 119         unsigned int ultra_low_power:1;
 120         unsigned int has_hs_key:1;
 121         unsigned int no_internal_mic_pin:1;
 122
 123         /* for PLL fix */
 124         hda_nid_t pll_nid;
 125         unsigned int pll_coef_idx, pll_coef_bit;
 126         unsigned int coef0;
 127         struct input_dev *kb_dev;
 128         u8 alc_mute_keycode_map[1];
 129 };
 130
 131 /*
 132  * COEF access helper functions
 133  */
 134
 135 static int alc_read_coefex_idx(struct hda_codec *codec, hda_nid_t nid,
 136                                unsigned int coef_idx)
 137 {
 138         unsigned int val;
 139
 140         snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_COEF_INDEX, coef_idx);
 141         val = snd_hda_codec_read(codec, nid, 0, AC_VERB_GET_PROC_COEF, 0);
 142         return val;
 143 }
 144
 145 #define alc_read_coef_idx(codec, coef_idx) \
 146         alc_read_coefex_idx(codec, 0x20, coef_idx)
 147
 148 static void alc_write_coefex_idx(struct hda_codec *codec, hda_nid_t nid,
 149                                  unsigned int coef_idx, unsigned int coef_val)
 150 {
 151         snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_COEF_INDEX, coef_idx);
 152         snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_PROC_COEF, coef_val);
 153 }
 154
 155 #define alc_write_coef_idx(codec, coef_idx, coef_val) \
 156         alc_write_coefex_idx(codec, 0x20, coef_idx, coef_val)
 157
 158 static void alc_update_coefex_idx(struct hda_codec *codec, hda_nid_t nid,
 159                                   unsigned int coef_idx, unsigned int mask,
 160                                   unsigned int bits_set)
 161 {
 162         unsigned int val = alc_read_coefex_idx(codec, nid, coef_idx);
 163
 164         if (val != -1)
 165                 alc_write_coefex_idx(codec, nid, coef_idx,
 166                                      (val & ~mask) | bits_set);
 167 }
 168
 169 #define alc_update_coef_idx(codec, coef_idx, mask, bits_set)    \
 170         alc_update_coefex_idx(codec, 0x20, coef_idx, mask, bits_set)
 171
 172 /* a special bypass for COEF 0; read the cached value at the second time */
 173 static unsigned int alc_get_coef0(struct hda_codec *codec)
 174 {
 175         struct alc_spec *spec = codec->spec;
 176
 177         if (!spec->coef0)
 178                 spec->coef0 = alc_read_coef_idx(codec, 0);
 179         return spec->coef0;
 180 }
 181
 182 /* coef writes/updates batch */
 183 struct coef_fw {
 184         unsigned char nid;
 185         unsigned char idx;
 186         unsigned short mask;
 187         unsigned short val;
 188 };
 189
 190 #define UPDATE_COEFEX(_nid, _idx, _mask, _val) \
 191         { .nid = (_nid), .idx = (_idx), .mask = (_mask), .val = (_val) }
 192 #define WRITE_COEFEX(_nid, _idx, _val) UPDATE_COEFEX(_nid, _idx, -1, _val)
 193 #define WRITE_COEF(_idx, _val) WRITE_COEFEX(0x20, _idx, _val)
 194 #define UPDATE_COEF(_idx, _mask, _val) UPDATE_COEFEX(0x20, _idx, _mask, _val)
 195
 196 static void alc_process_coef_fw(struct hda_codec *codec,
 197                                 const struct coef_fw *fw)
 198 {
 199         for (; fw->nid; fw++) {
 200                 if (fw->mask == (unsigned short)-1)
 201                         alc_write_coefex_idx(codec, fw->nid, fw->idx, fw->val);
 202                 else
 203                         alc_update_coefex_idx(codec, fw->nid, fw->idx,
 204                                               fw->mask, fw->val);
 205         }
 206 }
 207
 208 /*
 209  * GPIO setup tables, used in initialization
 210  */
 211
 212 /* Enable GPIO mask and set output */
 213 static void alc_setup_gpio(struct hda_codec *codec, unsigned int mask)
 214 {
 215         struct alc_spec *spec = codec->spec;
 216
 217         spec->gpio_mask |= mask;
 218         spec->gpio_dir |= mask;
 219         spec->gpio_data |= mask;
 220 }
 221
 222 static void alc_write_gpio_data(struct hda_codec *codec)
 223 {
 224         struct alc_spec *spec = codec->spec;
 225
 226         snd_hda_codec_write(codec, 0x01, 0, AC_VERB_SET_GPIO_DATA,
 227                             spec->gpio_data);
 228 }
 229
 230 static void alc_update_gpio_data(struct hda_codec *codec, unsigned int mask,
 231                                  bool on)
 232 {
 233         struct alc_spec *spec = codec->spec;
 234         unsigned int oldval = spec->gpio_data;
 235
 236         if (on)
 237                 spec->gpio_data |= mask;
 238         else
 239                 spec->gpio_data &= ~mask;
 240         if (oldval != spec->gpio_data)
 241                 alc_write_gpio_data(codec);
 242 }
 243
 244 static void alc_write_gpio(struct hda_codec *codec)
 245 {
 246         struct alc_spec *spec = codec->spec;
 247
 248         if (!spec->gpio_mask)
 249                 return;
 250
 251         snd_hda_codec_write(codec, codec->core.afg, 0,
 252                             AC_VERB_SET_GPIO_MASK, spec->gpio_mask);
 253         snd_hda_codec_write(codec, codec->core.afg, 0,
 254                             AC_VERB_SET_GPIO_DIRECTION, spec->gpio_dir);
 255         if (spec->gpio_write_delay)
 256                 msleep(1);
 257         alc_write_gpio_data(codec);
 258 }
 259
 260 static void alc_fixup_gpio(struct hda_codec *codec, int action,
 261                            unsigned int mask)
 262 {
 263         if (action == HDA_FIXUP_ACT_PRE_PROBE)
 264                 alc_setup_gpio(codec, mask);
 265 }
 266
 267 static void alc_fixup_gpio1(struct hda_codec *codec,
 268                             const struct hda_fixup *fix, int action)
 269 {
 270         alc_fixup_gpio(codec, action, 0x01);
 271 }
 272
 273 static void alc_fixup_gpio2(struct hda_codec *codec,
 274                             const struct hda_fixup *fix, int action)
 275 {
 276         alc_fixup_gpio(codec, action, 0x02);
 277 }
 278
 279 static void alc_fixup_gpio3(struct hda_codec *codec,
 280                             const struct hda_fixup *fix, int action)
 281 {
 282         alc_fixup_gpio(codec, action, 0x03);
 283 }
 284
 285 static void alc_fixup_gpio4(struct hda_codec *codec,
 286                             const struct hda_fixup *fix, int action)
 287 {
 288         alc_fixup_gpio(codec, action, 0x04);
 289 }
 290
 291 static void alc_fixup_micmute_led(struct hda_codec *codec,
 292                                   const struct hda_fixup *fix, int action)
 293 {
 294         if (action == HDA_FIXUP_ACT_PRE_PROBE)
 295                 snd_hda_gen_add_micmute_led_cdev(codec, NULL);
 296 }
 297
 298 /*
 299  * Fix hardware PLL issue
 300  * On some codecs, the analog PLL gating control must be off while
 301  * the default value is 1.
 302  */
 303 static void alc_fix_pll(struct hda_codec *codec)
 304 {
 305         struct alc_spec *spec = codec->spec;
 306
 307         if (spec->pll_nid)
 308                 alc_update_coefex_idx(codec, spec->pll_nid, spec->pll_coef_idx,
 309                                       1 << spec->pll_coef_bit, 0);
 310 }
 311
 312 static void alc_fix_pll_init(struct hda_codec *codec, hda_nid_t nid,
 313                              unsigned int coef_idx, unsigned int coef_bit)
 314 {
 315         struct alc_spec *spec = codec->spec;
 316         spec->pll_nid = nid;
 317         spec->pll_coef_idx = coef_idx;
 318         spec->pll_coef_bit = coef_bit;
 319         alc_fix_pll(codec);
 320 }
 321
 322 /* update the master volume per volume-knob's unsol event */
 323 static void alc_update_knob_master(struct hda_codec *codec,
 324                                    struct hda_jack_callback *jack)
 325 {
 326         unsigned int val;
 327         struct snd_kcontrol *kctl;
 328         struct snd_ctl_elem_value *uctl;
 329
 330         kctl = snd_hda_find_mixer_ctl(codec, "Master Playback Volume");
 331         if (!kctl)
 332                 return;
 333         uctl = kzalloc(sizeof(*uctl), GFP_KERNEL);
 334         if (!uctl)
 335                 return;
 336         val = snd_hda_codec_read(codec, jack->nid, 0,
 337                                  AC_VERB_GET_VOLUME_KNOB_CONTROL, 0);
 338         val &= HDA_AMP_VOLMASK;
 339         uctl->value.integer.value[0] = val;
 340         uctl->value.integer.value[1] = val;
 341         kctl->put(kctl, uctl);
 342         kfree(uctl);
 343 }
 344
 345 static void alc880_unsol_event(struct hda_codec *codec, unsigned int res)
 346 {
 347         /* For some reason, the res given from ALC880 is broken.
 348            Here we adjust it properly. */
 349         snd_hda_jack_unsol_event(codec, res >> 2);
 350 }
 351
 352 /* Change EAPD to verb control */
 353 static void alc_fill_eapd_coef(struct hda_codec *codec)
 354 {
 355         int coef;
 356
 357         coef = alc_get_coef0(codec);
 358
 359         switch (codec->core.vendor_id) {
 360         case 0x10ec0262:
 361                 alc_update_coef_idx(codec, 0x7, 0, 1<<5);
 362                 break;
 363         case 0x10ec0267:
 364         case 0x10ec0268:
 365                 alc_update_coef_idx(codec, 0x7, 0, 1<<13);
 366                 break;
 367         case 0x10ec0269:
 368                 if ((coef & 0x00f0) == 0x0010)
 369                         alc_update_coef_idx(codec, 0xd, 0, 1<<14);
 370                 if ((coef & 0x00f0) == 0x0020)
 371                         alc_update_coef_idx(codec, 0x4, 1<<15, 0);
 372                 if ((coef & 0x00f0) == 0x0030)
 373                         alc_update_coef_idx(codec, 0x10, 1<<9, 0);
 374                 break;
 375         case 0x10ec0280:
 376         case 0x10ec0284:
 377         case 0x10ec0290:
 378         case 0x10ec0292:
 379                 alc_update_coef_idx(codec, 0x4, 1<<15, 0);
 380                 break;
 381         case 0x10ec0225:
 382         case 0x10ec0295:
 383         case 0x10ec0299:
 384                 alc_update_coef_idx(codec, 0x67, 0xf000, 0x3000);
 385                 fallthrough;
 386         case 0x10ec0215:
 387         case 0x10ec0230:
 388         case 0x10ec0233:
 389         case 0x10ec0235:
 390         case 0x10ec0236:
 391         case 0x10ec0245:
 392         case 0x10ec0255:
 393         case 0x10ec0256:
 394         case 0x10ec0257:
 395         case 0x10ec0282:
 396         case 0x10ec0283:
 397         case 0x10ec0286:
 398         case 0x10ec0288:
 399         case 0x10ec0285:
 400         case 0x10ec0298:
 401         case 0x10ec0289:
 402         case 0x10ec0300:
 403                 alc_update_coef_idx(codec, 0x10, 1<<9, 0);
 404                 break;
 405         case 0x10ec0275:
 406                 alc_update_coef_idx(codec, 0xe, 0, 1<<0);
 407                 break;
 408         case 0x10ec0287:
 409                 alc_update_coef_idx(codec, 0x10, 1<<9, 0);
 410                 alc_write_coef_idx(codec, 0x8, 0x4ab7);
 411                 break;
 412         case 0x10ec0293:
 413                 alc_update_coef_idx(codec, 0xa, 1<<13, 0);
 414                 break;
 415         case 0x10ec0234:
 416         case 0x10ec0274:
 417         case 0x10ec0294:
 418         case 0x10ec0700:
 419         case 0x10ec0701:
 420         case 0x10ec0703:
 421         case 0x10ec0711:
 422                 alc_update_coef_idx(codec, 0x10, 1<<15, 0);
 423                 break;
 424         case 0x10ec0662:
 425                 if ((coef & 0x00f0) == 0x0030)
 426                         alc_update_coef_idx(codec, 0x4, 1<<10, 0); /* EAPD Ctrl */
 427                 break;
 428         case 0x10ec0272:
 429         case 0x10ec0273:
 430         case 0x10ec0663:
 431         case 0x10ec0665:
 432         case 0x10ec0670:
 433         case 0x10ec0671:
 434         case 0x10ec0672:
 435                 alc_update_coef_idx(codec, 0xd, 0, 1<<14); /* EAPD Ctrl */
 436                 break;
 437         case 0x10ec0222:
 438         case 0x10ec0623:
 439                 alc_update_coef_idx(codec, 0x19, 1<<13, 0);
 440                 break;
 441         case 0x10ec0668:
 442                 alc_update_coef_idx(codec, 0x7, 3<<13, 0);
 443                 break;
 444         case 0x10ec0867:
 445                 alc_update_coef_idx(codec, 0x4, 1<<10, 0);
 446                 break;
 447         case 0x10ec0888:
 448                 if ((coef & 0x00f0) == 0x0020 || (coef & 0x00f0) == 0x0030)
 449                         alc_update_coef_idx(codec, 0x7, 1<<5, 0);
 450                 break;
 451         case 0x10ec0892:
 452         case 0x10ec0897:
 453                 alc_update_coef_idx(codec, 0x7, 1<<5, 0);
 454                 break;
 455         case 0x10ec0899:
 456         case 0x10ec0900:
 457         case 0x10ec0b00:
 458         case 0x10ec1168:
 459         case 0x10ec1220:
 460                 alc_update_coef_idx(codec, 0x7, 1<<1, 0);
 461                 break;
 462         }
 463 }
 464
 465 /* additional initialization for ALC888 variants */
 466 static void alc888_coef_init(struct hda_codec *codec)
 467 {
 468         switch (alc_get_coef0(codec) & 0x00f0) {
 469         /* alc888-VA */
 470         case 0x00:
 471         /* alc888-VB */
 472         case 0x10:
 473                 alc_update_coef_idx(codec, 7, 0, 0x2030); /* Turn EAPD to High */
 474                 break;
 475         }
 476 }
 477
 478 /* turn on/off EAPD control (only if available) */
 479 static void set_eapd(struct hda_codec *codec, hda_nid_t nid, int on)
 480 {
 481         if (get_wcaps_type(get_wcaps(codec, nid)) != AC_WID_PIN)
 482                 return;
 483         if (snd_hda_query_pin_caps(codec, nid) & AC_PINCAP_EAPD)
 484                 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_EAPD_BTLENABLE,
 485                                     on ? 2 : 0);
 486 }
 487
 488 /* turn on/off EAPD controls of the codec */
 489 static void alc_auto_setup_eapd(struct hda_codec *codec, bool on)
 490 {
 491         /* We currently only handle front, HP */
 492         static const hda_nid_t pins[] = {
 493                 0x0f, 0x10, 0x14, 0x15, 0x17, 0
 494         };
 495         const hda_nid_t *p;
 496         for (p = pins; *p; p++)
 497                 set_eapd(codec, *p, on);
 498 }
 499
 500 static int find_ext_mic_pin(struct hda_codec *codec);
 501
 502 static void alc_headset_mic_no_shutup(struct hda_codec *codec)
 503 {
 504         const struct hda_pincfg *pin;
 505         int mic_pin = find_ext_mic_pin(codec);
 506         int i;
 507
 508         /* don't shut up pins when unloading the driver; otherwise it breaks
 509          * the default pin setup at the next load of the driver
 510          */
 511         if (codec->bus->shutdown)
 512                 return;
 513
 514         snd_array_for_each(&codec->init_pins, i, pin) {
 515                 /* use read here for syncing after issuing each verb */
 516                 if (pin->nid != mic_pin)
 517                         snd_hda_codec_read(codec, pin->nid, 0,
 518                                         AC_VERB_SET_PIN_WIDGET_CONTROL, 0);
 519         }
 520
 521         codec->pins_shutup = 1;
 522 }
 523
 524 static void alc_shutup_pins(struct hda_codec *codec)
 525 {
 526         struct alc_spec *spec = codec->spec;
 527
 528         switch (codec->core.vendor_id) {
 529         case 0x10ec0236:
 530         case 0x10ec0256:
 531         case 0x10ec0283:
 532         case 0x10ec0286:
 533         case 0x10ec0288:
 534         case 0x10ec0298:
 535                 alc_headset_mic_no_shutup(codec);
 536                 break;
 537         default:
 538                 if (!spec->no_shutup_pins)
 539                         snd_hda_shutup_pins(codec);
 540                 break;
 541         }
 542 }
 543
 544 /* generic shutup callback;
 545  * just turning off EAPD and a little pause for avoiding pop-noise
 546  */
 547 static void alc_eapd_shutup(struct hda_codec *codec)
 548 {
 549         struct alc_spec *spec = codec->spec;
 550
 551         alc_auto_setup_eapd(codec, false);
 552         if (!spec->no_depop_delay)
 553                 msleep(200);
 554         alc_shutup_pins(codec);
 555 }
 556
 557 /* generic EAPD initialization */
 558 static void alc_auto_init_amp(struct hda_codec *codec, int type)
 559 {
 560         alc_auto_setup_eapd(codec, true);
 561         alc_write_gpio(codec);
 562         switch (type) {
 563         case ALC_INIT_DEFAULT:
 564                 switch (codec->core.vendor_id) {
 565                 case 0x10ec0260:
 566                         alc_update_coefex_idx(codec, 0x1a, 7, 0, 0x2010);
 567                         break;
 568                 case 0x10ec0880:
 569                 case 0x10ec0882:
 570                 case 0x10ec0883:
 571                 case 0x10ec0885:
 572                         alc_update_coef_idx(codec, 7, 0, 0x2030);
 573                         break;
 574                 case 0x10ec0888:
 575                         alc888_coef_init(codec);
 576                         break;
 577                 }
 578                 break;
 579         }
 580 }
 581
 582 /* get a primary headphone pin if available */
 583 static hda_nid_t alc_get_hp_pin(struct alc_spec *spec)
 584 {
 585         if (spec->gen.autocfg.hp_pins[0])
 586                 return spec->gen.autocfg.hp_pins[0];
 587         if (spec->gen.autocfg.line_out_type == AC_JACK_HP_OUT)
 588                 return spec->gen.autocfg.line_out_pins[0];
 589         return 0;
 590 }
 591
 592 /*
 593  * Realtek SSID verification
 594  */
 595
 596 /* Could be any non-zero and even value. When used as fixup, tells
 597  * the driver to ignore any present sku defines.
 598  */
 599 #define ALC_FIXUP_SKU_IGNORE (2)
 600
 601 static void alc_fixup_sku_ignore(struct hda_codec *codec,
 602                                  const struct hda_fixup *fix, int action)
 603 {
 604         struct alc_spec *spec = codec->spec;
 605         if (action == HDA_FIXUP_ACT_PRE_PROBE) {
 606                 spec->cdefine.fixup = 1;
 607                 spec->cdefine.sku_cfg = ALC_FIXUP_SKU_IGNORE;
 608         }
 609 }
 610
 611 static void alc_fixup_no_depop_delay(struct hda_codec *codec,
 612                                     const struct hda_fixup *fix, int action)
 613 {
 614         struct alc_spec *spec = codec->spec;
 615
 616         if (action == HDA_FIXUP_ACT_PROBE) {
 617                 spec->no_depop_delay = 1;
 618                 codec->depop_delay = 0;
 619         }
 620 }
 621
 622 static int alc_auto_parse_customize_define(struct hda_codec *codec)
 623 {
 624         unsigned int ass, tmp, i;
 625         unsigned nid = 0;
 626         struct alc_spec *spec = codec->spec;
 627
 628         spec->cdefine.enable_pcbeep = 1; /* assume always enabled */
 629
 630         if (spec->cdefine.fixup) {
 631                 ass = spec->cdefine.sku_cfg;
 632                 if (ass == ALC_FIXUP_SKU_IGNORE)
 633                         return -1;
 634                 goto do_sku;
 635         }
 636
 637         if (!codec->bus->pci)
 638                 return -1;
 639         ass = codec->core.subsystem_id & 0xffff;
 640         if (ass != codec->bus->pci->subsystem_device && (ass & 1))
 641                 goto do_sku;
 642
 643         nid = 0x1d;
 644         if (codec->core.vendor_id == 0x10ec0260)
 645                 nid = 0x17;
 646         ass = snd_hda_codec_get_pincfg(codec, nid);
 647
 648         if (!(ass & 1)) {
 649                 codec_info(codec, "%s: SKU not ready 0x%08x\n",
 650                            codec->core.chip_name, ass);
 651                 return -1;
 652         }
 653
 654         /* check sum */
 655         tmp = 0;
 656         for (i = 1; i < 16; i++) {
 657                 if ((ass >> i) & 1)
 658                         tmp++;
 659         }
 660         if (((ass >> 16) & 0xf) != tmp)
 661                 return -1;
 662
 663         spec->cdefine.port_connectivity = ass >> 30;
 664         spec->cdefine.enable_pcbeep = (ass & 0x100000) >> 20;
 665         spec->cdefine.check_sum = (ass >> 16) & 0xf;
 666         spec->cdefine.customization = ass >> 8;
 667 do_sku:
 668         spec->cdefine.sku_cfg = ass;
 669         spec->cdefine.external_amp = (ass & 0x38) >> 3;
 670         spec->cdefine.platform_type = (ass & 0x4) >> 2;
 671         spec->cdefine.swap = (ass & 0x2) >> 1;
 672         spec->cdefine.override = ass & 0x1;
 673
 674         codec_dbg(codec, "SKU: Nid=0x%x sku_cfg=0x%08x\n",
 675                    nid, spec->cdefine.sku_cfg);
 676         codec_dbg(codec, "SKU: port_connectivity=0x%x\n",
 677                    spec->cdefine.port_connectivity);
 678         codec_dbg(codec, "SKU: enable_pcbeep=0x%x\n", spec->cdefine.enable_pcbeep);
 679         codec_dbg(codec, "SKU: check_sum=0x%08x\n", spec->cdefine.check_sum);
 680         codec_dbg(codec, "SKU: customization=0x%08x\n", spec->cdefine.customization);
 681         codec_dbg(codec, "SKU: external_amp=0x%x\n", spec->cdefine.external_amp);
 682         codec_dbg(codec, "SKU: platform_type=0x%x\n", spec->cdefine.platform_type);
 683         codec_dbg(codec, "SKU: swap=0x%x\n", spec->cdefine.swap);
 684         codec_dbg(codec, "SKU: override=0x%x\n", spec->cdefine.override);
 685
 686         return 0;
 687 }
 688
 689 /* return the position of NID in the list, or -1 if not found */
 690 static int find_idx_in_nid_list(hda_nid_t nid, const hda_nid_t *list, int nums)
 691 {
 692         int i;
 693         for (i = 0; i < nums; i++)
 694                 if (list[i] == nid)
 695                         return i;
 696         return -1;
 697 }
 698 /* return true if the given NID is found in the list */
 699 static bool found_in_nid_list(hda_nid_t nid, const hda_nid_t *list, int nums)
 700 {
 701         return find_idx_in_nid_list(nid, list, nums) >= 0;
 702 }
 703
 704 /* check subsystem ID and set up device-specific initialization;
 705  * return 1 if initialized, 0 if invalid SSID
 706  */
 707 /* 32-bit subsystem ID for BIOS loading in HD Audio codec.
 708  *      31 ~ 16 :       Manufacture ID
 709  *      15 ~ 8  :       SKU ID
 710  *      7  ~ 0  :       Assembly ID
 711  *      port-A --> pin 39/41, port-E --> pin 14/15, port-D --> pin 35/36
 712  */
 713 static int alc_subsystem_id(struct hda_codec *codec, const hda_nid_t *ports)
 714 {
 715         unsigned int ass, tmp, i;
 716         unsigned nid;
 717         struct alc_spec *spec = codec->spec;
 718
 719         if (spec->cdefine.fixup) {
 720                 ass = spec->cdefine.sku_cfg;
 721                 if (ass == ALC_FIXUP_SKU_IGNORE)
 722                         return 0;
 723                 goto do_sku;
 724         }
 725
 726         ass = codec->core.subsystem_id & 0xffff;
 727         if (codec->bus->pci &&
 728             ass != codec->bus->pci->subsystem_device && (ass & 1))
 729                 goto do_sku;
 730
 731         /* invalid SSID, check the special NID pin defcfg instead */
 732         /*
 733          * 31~30        : port connectivity
 734          * 29~21        : reserve
 735          * 20           : PCBEEP input
 736          * 19~16        : Check sum (15:1)
 737          * 15~1         : Custom
 738          * 0            : override
 739         */
 740         nid = 0x1d;
 741         if (codec->core.vendor_id == 0x10ec0260)
 742                 nid = 0x17;
 743         ass = snd_hda_codec_get_pincfg(codec, nid);
 744         codec_dbg(codec,
 745                   "realtek: No valid SSID, checking pincfg 0x%08x for NID 0x%x\n",
 746                    ass, nid);
 747         if (!(ass & 1))
 748                 return 0;
 749         if ((ass >> 30) != 1)   /* no physical connection */
 750                 return 0;
 751
 752         /* check sum */
 753         tmp = 0;
 754         for (i = 1; i < 16; i++) {
 755                 if ((ass >> i) & 1)
 756                         tmp++;
 757         }
 758         if (((ass >> 16) & 0xf) != tmp)
 759                 return 0;
 760 do_sku:
 761         codec_dbg(codec, "realtek: Enabling init ASM_ID=0x%04x CODEC_ID=%08x\n",
 762                    ass & 0xffff, codec->core.vendor_id);
 763         /*
 764          * 0 : override
 765          * 1 :  Swap Jack
 766          * 2 : 0 --> Desktop, 1 --> Laptop
 767          * 3~5 : External Amplifier control
 768          * 7~6 : Reserved
 769         */
 770         tmp = (ass & 0x38) >> 3;        /* external Amp control */
 771         if (spec->init_amp == ALC_INIT_UNDEFINED) {
 772                 switch (tmp) {
 773                 case 1:
 774                         alc_setup_gpio(codec, 0x01);
 775                         break;
 776                 case 3:
 777                         alc_setup_gpio(codec, 0x02);
 778                         break;
 779                 case 7:
 780                         alc_setup_gpio(codec, 0x03);
 781                         break;
 782                 case 5:
 783                 default:
 784                         spec->init_amp = ALC_INIT_DEFAULT;
 785                         break;
 786                 }
 787         }
 788
 789         /* is laptop or Desktop and enable the function "Mute internal speaker
 790          * when the external headphone out jack is plugged"
 791          */
 792         if (!(ass & 0x8000))
 793                 return 1;
 794         /*
 795          * 10~8 : Jack location
 796          * 12~11: Headphone out -> 00: PortA, 01: PortE, 02: PortD, 03: Resvered
 797          * 14~13: Resvered
 798          * 15   : 1 --> enable the function "Mute internal speaker
 799          *              when the external headphone out jack is plugged"
 800          */
 801         if (!alc_get_hp_pin(spec)) {
 802                 hda_nid_t nid;
 803                 tmp = (ass >> 11) & 0x3;        /* HP to chassis */
 804                 nid = ports[tmp];
 805                 if (found_in_nid_list(nid, spec->gen.autocfg.line_out_pins,
 806                                       spec->gen.autocfg.line_outs))
 807                         return 1;
 808                 spec->gen.autocfg.hp_pins[0] = nid;
 809         }
 810         return 1;
 811 }
 812
 813 /* Check the validity of ALC subsystem-id
 814  * ports contains an array of 4 pin NIDs for port-A, E, D and I */
 815 static void alc_ssid_check(struct hda_codec *codec, const hda_nid_t *ports)
 816 {
 817         if (!alc_subsystem_id(codec, ports)) {
 818                 struct alc_spec *spec = codec->spec;
 819                 if (spec->init_amp == ALC_INIT_UNDEFINED) {
 820                         codec_dbg(codec,
 821                                   "realtek: Enable default setup for auto mode as fallback\n");
 822                         spec->init_amp = ALC_INIT_DEFAULT;
 823                 }
 824         }
 825 }
 826
 827 /*
 828  */
 829
 830 static void alc_fixup_inv_dmic(struct hda_codec *codec,
 831                                const struct hda_fixup *fix, int action)
 832 {
 833         struct alc_spec *spec = codec->spec;
 834
 835         spec->gen.inv_dmic_split = 1;
 836 }
 837
 838
 839 static int alc_build_controls(struct hda_codec *codec)
 840 {
 841         int err;
 842
 843         err = snd_hda_gen_build_controls(codec);
 844         if (err < 0)
 845                 return err;
 846
 847         snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_BUILD);
 848         return 0;
 849 }
 850
 851
 852 /*
 853  * Common callbacks
 854  */
 855
 856 static void alc_pre_init(struct hda_codec *codec)
 857 {
 858         alc_fill_eapd_coef(codec);
 859 }
 860
 861 #define is_s3_resume(codec) \
 862         ((codec)->core.dev.power.power_state.event == PM_EVENT_RESUME)
 863 #define is_s4_resume(codec) \
 864         ((codec)->core.dev.power.power_state.event == PM_EVENT_RESTORE)
 865
 866 static int alc_init(struct hda_codec *codec)
 867 {
 868         struct alc_spec *spec = codec->spec;
 869
 870         /* hibernation resume needs the full chip initialization */
 871         if (is_s4_resume(codec))
 872                 alc_pre_init(codec);
 873
 874         if (spec->init_hook)
 875                 spec->init_hook(codec);
 876
 877         spec->gen.skip_verbs = 1; /* applied in below */
 878         snd_hda_gen_init(codec);
 879         alc_fix_pll(codec);
 880         alc_auto_init_amp(codec, spec->init_amp);
 881         snd_hda_apply_verbs(codec); /* apply verbs here after own init */
 882
 883         snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_INIT);
 884
 885         return 0;
 886 }
 887
 888 static inline void alc_shutup(struct hda_codec *codec)
 889 {
 890         struct alc_spec *spec = codec->spec;
 891
 892         if (!snd_hda_get_bool_hint(codec, "shutup"))
 893                 return; /* disabled explicitly by hints */
 894
 895         if (spec && spec->shutup)
 896                 spec->shutup(codec);
 897         else
 898                 alc_shutup_pins(codec);
 899 }
 900
 901 #define alc_free        snd_hda_gen_free
 902
 903 #ifdef CONFIG_PM
 904 static void alc_power_eapd(struct hda_codec *codec)
 905 {
 906         alc_auto_setup_eapd(codec, false);
 907 }
 908
 909 static int alc_suspend(struct hda_codec *codec)
 910 {
 911         struct alc_spec *spec = codec->spec;
 912         alc_shutup(codec);
 913         if (spec && spec->power_hook)
 914                 spec->power_hook(codec);
 915         return 0;
 916 }
 917 #endif
 918
 919 #ifdef CONFIG_PM
 920 static int alc_resume(struct hda_codec *codec)
 921 {
 922         struct alc_spec *spec = codec->spec;
 923
 924         if (!spec->no_depop_delay)
 925                 msleep(150); /* to avoid pop noise */
 926         codec->patch_ops.init(codec);
 927         snd_hda_regmap_sync(codec);
 928         hda_call_check_power_status(codec, 0x01);
 929         return 0;
 930 }
 931 #endif
 932
 933 /*
 934  */
 935 static const struct hda_codec_ops alc_patch_ops = {
 936         .build_controls = alc_build_controls,
 937         .build_pcms = snd_hda_gen_build_pcms,
 938         .init = alc_init,
 939         .free = alc_free,
 940         .unsol_event = snd_hda_jack_unsol_event,
 941 #ifdef CONFIG_PM
 942         .resume = alc_resume,
 943         .suspend = alc_suspend,
 944         .check_power_status = snd_hda_gen_check_power_status,
 945 #endif
 946 };
 947
 948
 949 #define alc_codec_rename(codec, name) snd_hda_codec_set_name(codec, name)
 950
 951 /*
 952  * Rename codecs appropriately from COEF value or subvendor id
 953  */
 954 struct alc_codec_rename_table {
 955         unsigned int vendor_id;
 956         unsigned short coef_mask;
 957         unsigned short coef_bits;
 958         const char *name;
 959 };
 960
 961 struct alc_codec_rename_pci_table {
 962         unsigned int codec_vendor_id;
 963         unsigned short pci_subvendor;
 964         unsigned short pci_subdevice;
 965         const char *name;
 966 };
 967
 968 static const struct alc_codec_rename_table rename_tbl[] = {
 969         { 0x10ec0221, 0xf00f, 0x1003, "ALC231" },
 970         { 0x10ec0269, 0xfff0, 0x3010, "ALC277" },
 971         { 0x10ec0269, 0xf0f0, 0x2010, "ALC259" },
 972         { 0x10ec0269, 0xf0f0, 0x3010, "ALC258" },
 973         { 0x10ec0269, 0x00f0, 0x0010, "ALC269VB" },
 974         { 0x10ec0269, 0xffff, 0xa023, "ALC259" },
 975         { 0x10ec0269, 0xffff, 0x6023, "ALC281X" },
 976         { 0x10ec0269, 0x00f0, 0x0020, "ALC269VC" },
 977         { 0x10ec0269, 0x00f0, 0x0030, "ALC269VD" },
 978         { 0x10ec0662, 0xffff, 0x4020, "ALC656" },
 979         { 0x10ec0887, 0x00f0, 0x0030, "ALC887-VD" },
 980         { 0x10ec0888, 0x00f0, 0x0030, "ALC888-VD" },
 981         { 0x10ec0888, 0xf0f0, 0x3020, "ALC886" },
 982         { 0x10ec0899, 0x2000, 0x2000, "ALC899" },
 983         { 0x10ec0892, 0xffff, 0x8020, "ALC661" },
 984         { 0x10ec0892, 0xffff, 0x8011, "ALC661" },
 985         { 0x10ec0892, 0xffff, 0x4011, "ALC656" },
 986         { } /* terminator */
 987 };
 988
 989 static const struct alc_codec_rename_pci_table rename_pci_tbl[] = {
 990         { 0x10ec0280, 0x1028, 0, "ALC3220" },
 991         { 0x10ec0282, 0x1028, 0, "ALC3221" },
 992         { 0x10ec0283, 0x1028, 0, "ALC3223" },
 993         { 0x10ec0288, 0x1028, 0, "ALC3263" },
 994         { 0x10ec0292, 0x1028, 0, "ALC3226" },
 995         { 0x10ec0293, 0x1028, 0, "ALC3235" },
 996         { 0x10ec0255, 0x1028, 0, "ALC3234" },
 997         { 0x10ec0668, 0x1028, 0, "ALC3661" },
 998         { 0x10ec0275, 0x1028, 0, "ALC3260" },
 999         { 0x10ec0899, 0x1028, 0, "ALC3861" },
1000         { 0x10ec0298, 0x1028, 0, "ALC3266" },
1001         { 0x10ec0236, 0x1028, 0, "ALC3204" },
1002         { 0x10ec0256, 0x1028, 0, "ALC3246" },
1003         { 0x10ec0225, 0x1028, 0, "ALC3253" },
1004         { 0x10ec0295, 0x1028, 0, "ALC3254" },
1005         { 0x10ec0299, 0x1028, 0, "ALC3271" },
1006         { 0x10ec0670, 0x1025, 0, "ALC669X" },
1007         { 0x10ec0676, 0x1025, 0, "ALC679X" },
1008         { 0x10ec0282, 0x1043, 0, "ALC3229" },
1009         { 0x10ec0233, 0x1043, 0, "ALC3236" },
1010         { 0x10ec0280, 0x103c, 0, "ALC3228" },
1011         { 0x10ec0282, 0x103c, 0, "ALC3227" },
1012         { 0x10ec0286, 0x103c, 0, "ALC3242" },
1013         { 0x10ec0290, 0x103c, 0, "ALC3241" },
1014         { 0x10ec0668, 0x103c, 0, "ALC3662" },
1015         { 0x10ec0283, 0x17aa, 0, "ALC3239" },
1016         { 0x10ec0292, 0x17aa, 0, "ALC3232" },
1017         { } /* terminator */
1018 };
1019
1020 static int alc_codec_rename_from_preset(struct hda_codec *codec)
1021 {
1022         const struct alc_codec_rename_table *p;
1023         const struct alc_codec_rename_pci_table *q;
1024
1025         for (p = rename_tbl; p->vendor_id; p++) {
1026                 if (p->vendor_id != codec->core.vendor_id)
1027                         continue;
1028                 if ((alc_get_coef0(codec) & p->coef_mask) == p->coef_bits)
1029                         return alc_codec_rename(codec, p->name);
1030         }
1031
1032         if (!codec->bus->pci)
1033                 return 0;
1034         for (q = rename_pci_tbl; q->codec_vendor_id; q++) {
1035                 if (q->codec_vendor_id != codec->core.vendor_id)
1036                         continue;
1037                 if (q->pci_subvendor != codec->bus->pci->subsystem_vendor)
1038                         continue;
1039                 if (!q->pci_subdevice ||
1040                     q->pci_subdevice == codec->bus->pci->subsystem_device)
1041                         return alc_codec_rename(codec, q->name);
1042         }
1043
1044         return 0;
1045 }
1046
1047
1048 /*
1049  * Digital-beep handlers
1050  */
1051 #ifdef CONFIG_SND_HDA_INPUT_BEEP
1052
1053 /* additional beep mixers; private_value will be overwritten */
1054 static const struct snd_kcontrol_new alc_beep_mixer[] = {
1055         HDA_CODEC_VOLUME("Beep Playback Volume", 0, 0, HDA_INPUT),
1056         HDA_CODEC_MUTE_BEEP("Beep Playback Switch", 0, 0, HDA_INPUT),
1057 };
1058
1059 /* set up and create beep controls */
1060 static int set_beep_amp(struct alc_spec *spec, hda_nid_t nid,
1061                         int idx, int dir)
1062 {
1063         struct snd_kcontrol_new *knew;
1064         unsigned int beep_amp = HDA_COMPOSE_AMP_VAL(nid, 3, idx, dir);
1065         int i;
1066
1067         for (i = 0; i < ARRAY_SIZE(alc_beep_mixer); i++) {
1068                 knew = snd_hda_gen_add_kctl(&spec->gen, NULL,
1069                                             &alc_beep_mixer[i]);
1070                 if (!knew)
1071                         return -ENOMEM;
1072                 knew->private_value = beep_amp;
1073         }
1074         return 0;
1075 }
1076
1077 static const struct snd_pci_quirk beep_allow_list[] = {
1078         SND_PCI_QUIRK(0x1043, 0x103c, "ASUS", 1),
1079         SND_PCI_QUIRK(0x1043, 0x115d, "ASUS", 1),
1080         SND_PCI_QUIRK(0x1043, 0x829f, "ASUS", 1),
1081         SND_PCI_QUIRK(0x1043, 0x8376, "EeePC", 1),
1082         SND_PCI_QUIRK(0x1043, 0x83ce, "EeePC", 1),
1083         SND_PCI_QUIRK(0x1043, 0x831a, "EeePC", 1),
1084         SND_PCI_QUIRK(0x1043, 0x834a, "EeePC", 1),
1085         SND_PCI_QUIRK(0x1458, 0xa002, "GA-MA790X", 1),
1086         SND_PCI_QUIRK(0x8086, 0xd613, "Intel", 1),
1087         /* denylist -- no beep available */
1088         SND_PCI_QUIRK(0x17aa, 0x309e, "Lenovo ThinkCentre M73", 0),
1089         SND_PCI_QUIRK(0x17aa, 0x30a3, "Lenovo ThinkCentre M93", 0),
1090         {}
1091 };
1092
1093 static inline int has_cdefine_beep(struct hda_codec *codec)
1094 {
1095         struct alc_spec *spec = codec->spec;
1096         const struct snd_pci_quirk *q;
1097         q = snd_pci_quirk_lookup(codec->bus->pci, beep_allow_list);
1098         if (q)
1099                 return q->value;
1100         return spec->cdefine.enable_pcbeep;
1101 }
1102 #else
1103 #define set_beep_amp(spec, nid, idx, dir)       0
1104 #define has_cdefine_beep(codec)         0
1105 #endif
1106
1107 /* parse the BIOS configuration and set up the alc_spec */
1108 /* return 1 if successful, 0 if the proper config is not found,
1109  * or a negative error code
1110  */
1111 static int alc_parse_auto_config(struct hda_codec *codec,
1112                                  const hda_nid_t *ignore_nids,
1113                                  const hda_nid_t *ssid_nids)
1114 {
1115         struct alc_spec *spec = codec->spec;
1116         struct auto_pin_cfg *cfg = &spec->gen.autocfg;
1117         int err;
1118
1119         err = snd_hda_parse_pin_defcfg(codec, cfg, ignore_nids,
1120                                        spec->parse_flags);
1121         if (err < 0)
1122                 return err;
1123
1124         if (ssid_nids)
1125                 alc_ssid_check(codec, ssid_nids);
1126
1127         err = snd_hda_gen_parse_auto_config(codec, cfg);
1128         if (err < 0)
1129                 return err;
1130
1131         return 1;
1132 }
1133
1134 /* common preparation job for alc_spec */
1135 static int alc_alloc_spec(struct hda_codec *codec, hda_nid_t mixer_nid)
1136 {
1137         struct alc_spec *spec = kzalloc(sizeof(*spec), GFP_KERNEL);
1138         int err;
1139
1140         if (!spec)
1141                 return -ENOMEM;
1142         codec->spec = spec;
1143         snd_hda_gen_spec_init(&spec->gen);
1144         spec->gen.mixer_nid = mixer_nid;
1145         spec->gen.own_eapd_ctl = 1;
1146         codec->single_adc_amp = 1;
1147         /* FIXME: do we need this for all Realtek codec models? */
1148         codec->spdif_status_reset = 1;
1149         codec->forced_resume = 1;
1150         codec->patch_ops = alc_patch_ops;
1151
1152         err = alc_codec_rename_from_preset(codec);
1153         if (err < 0) {
1154                 kfree(spec);
1155                 return err;
1156         }
1157         return 0;
1158 }
1159
1160 static int alc880_parse_auto_config(struct hda_codec *codec)
1161 {
1162         static const hda_nid_t alc880_ignore[] = { 0x1d, 0 };
1163         static const hda_nid_t alc880_ssids[] = { 0x15, 0x1b, 0x14, 0 };
1164         return alc_parse_auto_config(codec, alc880_ignore, alc880_ssids);
1165 }
1166
1167 /*
1168  * ALC880 fix-ups
1169  */
1170 enum {
1171         ALC880_FIXUP_GPIO1,
1172         ALC880_FIXUP_GPIO2,
1173         ALC880_FIXUP_MEDION_RIM,
1174         ALC880_FIXUP_LG,
1175         ALC880_FIXUP_LG_LW25,
1176         ALC880_FIXUP_W810,
1177         ALC880_FIXUP_EAPD_COEF,
1178         ALC880_FIXUP_TCL_S700,
1179         ALC880_FIXUP_VOL_KNOB,
1180         ALC880_FIXUP_FUJITSU,
1181         ALC880_FIXUP_F1734,
1182         ALC880_FIXUP_UNIWILL,
1183         ALC880_FIXUP_UNIWILL_DIG,
1184         ALC880_FIXUP_Z71V,
1185         ALC880_FIXUP_ASUS_W5A,
1186         ALC880_FIXUP_3ST_BASE,
1187         ALC880_FIXUP_3ST,
1188         ALC880_FIXUP_3ST_DIG,
1189         ALC880_FIXUP_5ST_BASE,
1190         ALC880_FIXUP_5ST,
1191         ALC880_FIXUP_5ST_DIG,
1192         ALC880_FIXUP_6ST_BASE,
1193         ALC880_FIXUP_6ST,
1194         ALC880_FIXUP_6ST_DIG,
1195         ALC880_FIXUP_6ST_AUTOMUTE,
1196 };
1197
1198 /* enable the volume-knob widget support on NID 0x21 */
1199 static void alc880_fixup_vol_knob(struct hda_codec *codec,
1200                                   const struct hda_fixup *fix, int action)
1201 {
1202         if (action == HDA_FIXUP_ACT_PROBE)
1203                 snd_hda_jack_detect_enable_callback(codec, 0x21,
1204                                                     alc_update_knob_master);
1205 }
1206
1207 static const struct hda_fixup alc880_fixups[] = {
1208         [ALC880_FIXUP_GPIO1] = {
1209                 .type = HDA_FIXUP_FUNC,
1210                 .v.func = alc_fixup_gpio1,
1211         },
1212         [ALC880_FIXUP_GPIO2] = {
1213                 .type = HDA_FIXUP_FUNC,
1214                 .v.func = alc_fixup_gpio2,
1215         },
1216         [ALC880_FIXUP_MEDION_RIM] = {
1217                 .type = HDA_FIXUP_VERBS,
1218                 .v.verbs = (const struct hda_verb[]) {
1219                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x07 },
1220                         { 0x20, AC_VERB_SET_PROC_COEF,  0x3060 },
1221                         { }
1222                 },
1223                 .chained = true,
1224                 .chain_id = ALC880_FIXUP_GPIO2,
1225         },
1226         [ALC880_FIXUP_LG] = {
1227                 .type = HDA_FIXUP_PINS,
1228                 .v.pins = (const struct hda_pintbl[]) {
1229                         /* disable bogus unused pins */
1230                         { 0x16, 0x411111f0 },
1231                         { 0x18, 0x411111f0 },
1232                         { 0x1a, 0x411111f0 },
1233                         { }
1234                 }
1235         },
1236         [ALC880_FIXUP_LG_LW25] = {
1237                 .type = HDA_FIXUP_PINS,
1238                 .v.pins = (const struct hda_pintbl[]) {
1239                         { 0x1a, 0x0181344f }, /* line-in */
1240                         { 0x1b, 0x0321403f }, /* headphone */
1241                         { }
1242                 }
1243         },
1244         [ALC880_FIXUP_W810] = {
1245                 .type = HDA_FIXUP_PINS,
1246                 .v.pins = (const struct hda_pintbl[]) {
1247                         /* disable bogus unused pins */
1248                         { 0x17, 0x411111f0 },
1249                         { }
1250                 },
1251                 .chained = true,
1252                 .chain_id = ALC880_FIXUP_GPIO2,
1253         },
1254         [ALC880_FIXUP_EAPD_COEF] = {
1255                 .type = HDA_FIXUP_VERBS,
1256                 .v.verbs = (const struct hda_verb[]) {
1257                         /* change to EAPD mode */
1258                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x07 },
1259                         { 0x20, AC_VERB_SET_PROC_COEF,  0x3060 },
1260                         {}
1261                 },
1262         },
1263         [ALC880_FIXUP_TCL_S700] = {
1264                 .type = HDA_FIXUP_VERBS,
1265                 .v.verbs = (const struct hda_verb[]) {
1266                         /* change to EAPD mode */
1267                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x07 },
1268                         { 0x20, AC_VERB_SET_PROC_COEF,  0x3070 },
1269                         {}
1270                 },
1271                 .chained = true,
1272                 .chain_id = ALC880_FIXUP_GPIO2,
1273         },
1274         [ALC880_FIXUP_VOL_KNOB] = {
1275                 .type = HDA_FIXUP_FUNC,
1276                 .v.func = alc880_fixup_vol_knob,
1277         },
1278         [ALC880_FIXUP_FUJITSU] = {
1279                 /* override all pins as BIOS on old Amilo is broken */
1280                 .type = HDA_FIXUP_PINS,
1281                 .v.pins = (const struct hda_pintbl[]) {
1282                         { 0x14, 0x0121401f }, /* HP */
1283                         { 0x15, 0x99030120 }, /* speaker */
1284                         { 0x16, 0x99030130 }, /* bass speaker */
1285                         { 0x17, 0x411111f0 }, /* N/A */
1286                         { 0x18, 0x411111f0 }, /* N/A */
1287                         { 0x19, 0x01a19950 }, /* mic-in */
1288                         { 0x1a, 0x411111f0 }, /* N/A */
1289                         { 0x1b, 0x411111f0 }, /* N/A */
1290                         { 0x1c, 0x411111f0 }, /* N/A */
1291                         { 0x1d, 0x411111f0 }, /* N/A */
1292                         { 0x1e, 0x01454140 }, /* SPDIF out */
1293                         { }
1294                 },
1295                 .chained = true,
1296                 .chain_id = ALC880_FIXUP_VOL_KNOB,
1297         },
1298         [ALC880_FIXUP_F1734] = {
1299                 /* almost compatible with FUJITSU, but no bass and SPDIF */
1300                 .type = HDA_FIXUP_PINS,
1301                 .v.pins = (const struct hda_pintbl[]) {
1302                         { 0x14, 0x0121401f }, /* HP */
1303                         { 0x15, 0x99030120 }, /* speaker */
1304                         { 0x16, 0x411111f0 }, /* N/A */
1305                         { 0x17, 0x411111f0 }, /* N/A */
1306                         { 0x18, 0x411111f0 }, /* N/A */
1307                         { 0x19, 0x01a19950 }, /* mic-in */
1308                         { 0x1a, 0x411111f0 }, /* N/A */
1309                         { 0x1b, 0x411111f0 }, /* N/A */
1310                         { 0x1c, 0x411111f0 }, /* N/A */
1311                         { 0x1d, 0x411111f0 }, /* N/A */
1312                         { 0x1e, 0x411111f0 }, /* N/A */
1313                         { }
1314                 },
1315                 .chained = true,
1316                 .chain_id = ALC880_FIXUP_VOL_KNOB,
1317         },
1318         [ALC880_FIXUP_UNIWILL] = {
1319                 /* need to fix HP and speaker pins to be parsed correctly */
1320                 .type = HDA_FIXUP_PINS,
1321                 .v.pins = (const struct hda_pintbl[]) {
1322                         { 0x14, 0x0121411f }, /* HP */
1323                         { 0x15, 0x99030120 }, /* speaker */
1324                         { 0x16, 0x99030130 }, /* bass speaker */
1325                         { }
1326                 },
1327         },
1328         [ALC880_FIXUP_UNIWILL_DIG] = {
1329                 .type = HDA_FIXUP_PINS,
1330                 .v.pins = (const struct hda_pintbl[]) {
1331                         /* disable bogus unused pins */
1332                         { 0x17, 0x411111f0 },
1333                         { 0x19, 0x411111f0 },
1334                         { 0x1b, 0x411111f0 },
1335                         { 0x1f, 0x411111f0 },
1336                         { }
1337                 }
1338         },
1339         [ALC880_FIXUP_Z71V] = {
1340                 .type = HDA_FIXUP_PINS,
1341                 .v.pins = (const struct hda_pintbl[]) {
1342                         /* set up the whole pins as BIOS is utterly broken */
1343                         { 0x14, 0x99030120 }, /* speaker */
1344                         { 0x15, 0x0121411f }, /* HP */
1345                         { 0x16, 0x411111f0 }, /* N/A */
1346                         { 0x17, 0x411111f0 }, /* N/A */
1347                         { 0x18, 0x01a19950 }, /* mic-in */
1348                         { 0x19, 0x411111f0 }, /* N/A */
1349                         { 0x1a, 0x01813031 }, /* line-in */
1350                         { 0x1b, 0x411111f0 }, /* N/A */
1351                         { 0x1c, 0x411111f0 }, /* N/A */
1352                         { 0x1d, 0x411111f0 }, /* N/A */
1353                         { 0x1e, 0x0144111e }, /* SPDIF */
1354                         { }
1355                 }
1356         },
1357         [ALC880_FIXUP_ASUS_W5A] = {
1358                 .type = HDA_FIXUP_PINS,
1359                 .v.pins = (const struct hda_pintbl[]) {
1360                         /* set up the whole pins as BIOS is utterly broken */
1361                         { 0x14, 0x0121411f }, /* HP */
1362                         { 0x15, 0x411111f0 }, /* N/A */
1363                         { 0x16, 0x411111f0 }, /* N/A */
1364                         { 0x17, 0x411111f0 }, /* N/A */
1365                         { 0x18, 0x90a60160 }, /* mic */
1366                         { 0x19, 0x411111f0 }, /* N/A */
1367                         { 0x1a, 0x411111f0 }, /* N/A */
1368                         { 0x1b, 0x411111f0 }, /* N/A */
1369                         { 0x1c, 0x411111f0 }, /* N/A */
1370                         { 0x1d, 0x411111f0 }, /* N/A */
1371                         { 0x1e, 0xb743111e }, /* SPDIF out */
1372                         { }
1373                 },
1374                 .chained = true,
1375                 .chain_id = ALC880_FIXUP_GPIO1,
1376         },
1377         [ALC880_FIXUP_3ST_BASE] = {
1378                 .type = HDA_FIXUP_PINS,
1379                 .v.pins = (const struct hda_pintbl[]) {
1380                         { 0x14, 0x01014010 }, /* line-out */
1381                         { 0x15, 0x411111f0 }, /* N/A */
1382                         { 0x16, 0x411111f0 }, /* N/A */
1383                         { 0x17, 0x411111f0 }, /* N/A */
1384                         { 0x18, 0x01a19c30 }, /* mic-in */
1385                         { 0x19, 0x0121411f }, /* HP */
1386                         { 0x1a, 0x01813031 }, /* line-in */
1387                         { 0x1b, 0x02a19c40 }, /* front-mic */
1388                         { 0x1c, 0x411111f0 }, /* N/A */
1389                         { 0x1d, 0x411111f0 }, /* N/A */
1390                         /* 0x1e is filled in below */
1391                         { 0x1f, 0x411111f0 }, /* N/A */
1392                         { }
1393                 }
1394         },
1395         [ALC880_FIXUP_3ST] = {
1396                 .type = HDA_FIXUP_PINS,
1397                 .v.pins = (const struct hda_pintbl[]) {
1398                         { 0x1e, 0x411111f0 }, /* N/A */
1399                         { }
1400                 },
1401                 .chained = true,
1402                 .chain_id = ALC880_FIXUP_3ST_BASE,
1403         },
1404         [ALC880_FIXUP_3ST_DIG] = {
1405                 .type = HDA_FIXUP_PINS,
1406                 .v.pins = (const struct hda_pintbl[]) {
1407                         { 0x1e, 0x0144111e }, /* SPDIF */
1408                         { }
1409                 },
1410                 .chained = true,
1411                 .chain_id = ALC880_FIXUP_3ST_BASE,
1412         },
1413         [ALC880_FIXUP_5ST_BASE] = {
1414                 .type = HDA_FIXUP_PINS,
1415                 .v.pins = (const struct hda_pintbl[]) {
1416                         { 0x14, 0x01014010 }, /* front */
1417                         { 0x15, 0x411111f0 }, /* N/A */
1418                         { 0x16, 0x01011411 }, /* CLFE */
1419                         { 0x17, 0x01016412 }, /* surr */
1420                         { 0x18, 0x01a19c30 }, /* mic-in */
1421                         { 0x19, 0x0121411f }, /* HP */
1422                         { 0x1a, 0x01813031 }, /* line-in */
1423                         { 0x1b, 0x02a19c40 }, /* front-mic */
1424                         { 0x1c, 0x411111f0 }, /* N/A */
1425                         { 0x1d, 0x411111f0 }, /* N/A */
1426                         /* 0x1e is filled in below */
1427                         { 0x1f, 0x411111f0 }, /* N/A */
1428                         { }
1429                 }
1430         },
1431         [ALC880_FIXUP_5ST] = {
1432                 .type = HDA_FIXUP_PINS,
1433                 .v.pins = (const struct hda_pintbl[]) {
1434                         { 0x1e, 0x411111f0 }, /* N/A */
1435                         { }
1436                 },
1437                 .chained = true,
1438                 .chain_id = ALC880_FIXUP_5ST_BASE,
1439         },
1440         [ALC880_FIXUP_5ST_DIG] = {
1441                 .type = HDA_FIXUP_PINS,
1442                 .v.pins = (const struct hda_pintbl[]) {
1443                         { 0x1e, 0x0144111e }, /* SPDIF */
1444                         { }
1445                 },
1446                 .chained = true,
1447                 .chain_id = ALC880_FIXUP_5ST_BASE,
1448         },
1449         [ALC880_FIXUP_6ST_BASE] = {
1450                 .type = HDA_FIXUP_PINS,
1451                 .v.pins = (const struct hda_pintbl[]) {
1452                         { 0x14, 0x01014010 }, /* front */
1453                         { 0x15, 0x01016412 }, /* surr */
1454                         { 0x16, 0x01011411 }, /* CLFE */
1455                         { 0x17, 0x01012414 }, /* side */
1456                         { 0x18, 0x01a19c30 }, /* mic-in */
1457                         { 0x19, 0x02a19c40 }, /* front-mic */
1458                         { 0x1a, 0x01813031 }, /* line-in */
1459                         { 0x1b, 0x0121411f }, /* HP */
1460                         { 0x1c, 0x411111f0 }, /* N/A */
1461                         { 0x1d, 0x411111f0 }, /* N/A */
1462                         /* 0x1e is filled in below */
1463                         { 0x1f, 0x411111f0 }, /* N/A */
1464                         { }
1465                 }
1466         },
1467         [ALC880_FIXUP_6ST] = {
1468                 .type = HDA_FIXUP_PINS,
1469                 .v.pins = (const struct hda_pintbl[]) {
1470                         { 0x1e, 0x411111f0 }, /* N/A */
1471                         { }
1472                 },
1473                 .chained = true,
1474                 .chain_id = ALC880_FIXUP_6ST_BASE,
1475         },
1476         [ALC880_FIXUP_6ST_DIG] = {
1477                 .type = HDA_FIXUP_PINS,
1478                 .v.pins = (const struct hda_pintbl[]) {
1479                         { 0x1e, 0x0144111e }, /* SPDIF */
1480                         { }
1481                 },
1482                 .chained = true,
1483                 .chain_id = ALC880_FIXUP_6ST_BASE,
1484         },
1485         [ALC880_FIXUP_6ST_AUTOMUTE] = {
1486                 .type = HDA_FIXUP_PINS,
1487                 .v.pins = (const struct hda_pintbl[]) {
1488                         { 0x1b, 0x0121401f }, /* HP with jack detect */
1489                         { }
1490                 },
1491                 .chained_before = true,
1492                 .chain_id = ALC880_FIXUP_6ST_BASE,
1493         },
1494 };
1495
1496 static const struct snd_pci_quirk alc880_fixup_tbl[] = {
1497         SND_PCI_QUIRK(0x1019, 0x0f69, "Coeus G610P", ALC880_FIXUP_W810),
1498         SND_PCI_QUIRK(0x1043, 0x10c3, "ASUS W5A", ALC880_FIXUP_ASUS_W5A),
1499         SND_PCI_QUIRK(0x1043, 0x1964, "ASUS Z71V", ALC880_FIXUP_Z71V),
1500         SND_PCI_QUIRK_VENDOR(0x1043, "ASUS", ALC880_FIXUP_GPIO1),
1501         SND_PCI_QUIRK(0x147b, 0x1045, "ABit AA8XE", ALC880_FIXUP_6ST_AUTOMUTE),
1502         SND_PCI_QUIRK(0x1558, 0x5401, "Clevo GPIO2", ALC880_FIXUP_GPIO2),
1503         SND_PCI_QUIRK_VENDOR(0x1558, "Clevo", ALC880_FIXUP_EAPD_COEF),
1504         SND_PCI_QUIRK(0x1584, 0x9050, "Uniwill", ALC880_FIXUP_UNIWILL_DIG),
1505         SND_PCI_QUIRK(0x1584, 0x9054, "Uniwill", ALC880_FIXUP_F1734),
1506         SND_PCI_QUIRK(0x1584, 0x9070, "Uniwill", ALC880_FIXUP_UNIWILL),
1507         SND_PCI_QUIRK(0x1584, 0x9077, "Uniwill P53", ALC880_FIXUP_VOL_KNOB),
1508         SND_PCI_QUIRK(0x161f, 0x203d, "W810", ALC880_FIXUP_W810),
1509         SND_PCI_QUIRK(0x161f, 0x205d, "Medion Rim 2150", ALC880_FIXUP_MEDION_RIM),
1510         SND_PCI_QUIRK(0x1631, 0xe011, "PB 13201056", ALC880_FIXUP_6ST_AUTOMUTE),
1511         SND_PCI_QUIRK(0x1734, 0x107c, "FSC Amilo M1437", ALC880_FIXUP_FUJITSU),
1512         SND_PCI_QUIRK(0x1734, 0x1094, "FSC Amilo M1451G", ALC880_FIXUP_FUJITSU),
1513         SND_PCI_QUIRK(0x1734, 0x10ac, "FSC AMILO Xi 1526", ALC880_FIXUP_F1734),
1514         SND_PCI_QUIRK(0x1734, 0x10b0, "FSC Amilo Pi1556", ALC880_FIXUP_FUJITSU),
1515         SND_PCI_QUIRK(0x1854, 0x003b, "LG", ALC880_FIXUP_LG),
1516         SND_PCI_QUIRK(0x1854, 0x005f, "LG P1 Express", ALC880_FIXUP_LG),
1517         SND_PCI_QUIRK(0x1854, 0x0068, "LG w1", ALC880_FIXUP_LG),
1518         SND_PCI_QUIRK(0x1854, 0x0077, "LG LW25", ALC880_FIXUP_LG_LW25),
1519         SND_PCI_QUIRK(0x19db, 0x4188, "TCL S700", ALC880_FIXUP_TCL_S700),
1520
1521         /* Below is the copied entries from alc880_quirks.c.
1522          * It's not quite sure whether BIOS sets the correct pin-config table
1523          * on these machines, thus they are kept to be compatible with
1524          * the old static quirks.  Once when it's confirmed to work without
1525          * these overrides, it'd be better to remove.
1526          */
1527         SND_PCI_QUIRK(0x1019, 0xa880, "ECS", ALC880_FIXUP_5ST_DIG),
1528         SND_PCI_QUIRK(0x1019, 0xa884, "Acer APFV", ALC880_FIXUP_6ST),
1529         SND_PCI_QUIRK(0x1025, 0x0070, "ULI", ALC880_FIXUP_3ST_DIG),
1530         SND_PCI_QUIRK(0x1025, 0x0077, "ULI", ALC880_FIXUP_6ST_DIG),
1531         SND_PCI_QUIRK(0x1025, 0x0078, "ULI", ALC880_FIXUP_6ST_DIG),
1532         SND_PCI_QUIRK(0x1025, 0x0087, "ULI", ALC880_FIXUP_6ST_DIG),
1533         SND_PCI_QUIRK(0x1025, 0xe309, "ULI", ALC880_FIXUP_3ST_DIG),
1534         SND_PCI_QUIRK(0x1025, 0xe310, "ULI", ALC880_FIXUP_3ST),
1535         SND_PCI_QUIRK(0x1039, 0x1234, NULL, ALC880_FIXUP_6ST_DIG),
1536         SND_PCI_QUIRK(0x104d, 0x81a0, "Sony", ALC880_FIXUP_3ST),
1537         SND_PCI_QUIRK(0x104d, 0x81d6, "Sony", ALC880_FIXUP_3ST),
1538         SND_PCI_QUIRK(0x107b, 0x3032, "Gateway", ALC880_FIXUP_5ST),
1539         SND_PCI_QUIRK(0x107b, 0x3033, "Gateway", ALC880_FIXUP_5ST),
1540         SND_PCI_QUIRK(0x107b, 0x4039, "Gateway", ALC880_FIXUP_5ST),
1541         SND_PCI_QUIRK(0x1297, 0xc790, "Shuttle ST20G5", ALC880_FIXUP_6ST_DIG),
1542         SND_PCI_QUIRK(0x1458, 0xa102, "Gigabyte K8", ALC880_FIXUP_6ST_DIG),
1543         SND_PCI_QUIRK(0x1462, 0x1150, "MSI", ALC880_FIXUP_6ST_DIG),
1544         SND_PCI_QUIRK(0x1509, 0x925d, "FIC P4M", ALC880_FIXUP_6ST_DIG),
1545         SND_PCI_QUIRK(0x1565, 0x8202, "Biostar", ALC880_FIXUP_5ST_DIG),
1546         SND_PCI_QUIRK(0x1695, 0x400d, "EPoX", ALC880_FIXUP_5ST_DIG),
1547         SND_PCI_QUIRK(0x1695, 0x4012, "EPox EP-5LDA", ALC880_FIXUP_5ST_DIG),
1548         SND_PCI_QUIRK(0x2668, 0x8086, NULL, ALC880_FIXUP_6ST_DIG), /* broken BIOS */
1549         SND_PCI_QUIRK(0x8086, 0x2668, NULL, ALC880_FIXUP_6ST_DIG),
1550         SND_PCI_QUIRK(0x8086, 0xa100, "Intel mobo", ALC880_FIXUP_5ST_DIG),
1551         SND_PCI_QUIRK(0x8086, 0xd400, "Intel mobo", ALC880_FIXUP_5ST_DIG),
1552         SND_PCI_QUIRK(0x8086, 0xd401, "Intel mobo", ALC880_FIXUP_5ST_DIG),
1553         SND_PCI_QUIRK(0x8086, 0xd402, "Intel mobo", ALC880_FIXUP_3ST_DIG),
1554         SND_PCI_QUIRK(0x8086, 0xe224, "Intel mobo", ALC880_FIXUP_5ST_DIG),
1555         SND_PCI_QUIRK(0x8086, 0xe305, "Intel mobo", ALC880_FIXUP_3ST_DIG),
1556         SND_PCI_QUIRK(0x8086, 0xe308, "Intel mobo", ALC880_FIXUP_3ST_DIG),
1557         SND_PCI_QUIRK(0x8086, 0xe400, "Intel mobo", ALC880_FIXUP_5ST_DIG),
1558         SND_PCI_QUIRK(0x8086, 0xe401, "Intel mobo", ALC880_FIXUP_5ST_DIG),
1559         SND_PCI_QUIRK(0x8086, 0xe402, "Intel mobo", ALC880_FIXUP_5ST_DIG),
1560         /* default Intel */
1561         SND_PCI_QUIRK_VENDOR(0x8086, "Intel mobo", ALC880_FIXUP_3ST),
1562         SND_PCI_QUIRK(0xa0a0, 0x0560, "AOpen i915GMm-HFS", ALC880_FIXUP_5ST_DIG),
1563         SND_PCI_QUIRK(0xe803, 0x1019, NULL, ALC880_FIXUP_6ST_DIG),
1564         {}
1565 };
1566
1567 static const struct hda_model_fixup alc880_fixup_models[] = {
1568         {.id = ALC880_FIXUP_3ST, .name = "3stack"},
1569         {.id = ALC880_FIXUP_3ST_DIG, .name = "3stack-digout"},
1570         {.id = ALC880_FIXUP_5ST, .name = "5stack"},
1571         {.id = ALC880_FIXUP_5ST_DIG, .name = "5stack-digout"},
1572         {.id = ALC880_FIXUP_6ST, .name = "6stack"},
1573         {.id = ALC880_FIXUP_6ST_DIG, .name = "6stack-digout"},
1574         {.id = ALC880_FIXUP_6ST_AUTOMUTE, .name = "6stack-automute"},
1575         {}
1576 };
1577
1578
1579 /*
1580  * OK, here we have finally the patch for ALC880
1581  */
1582 static int patch_alc880(struct hda_codec *codec)
1583 {
1584         struct alc_spec *spec;
1585         int err;
1586
1587         err = alc_alloc_spec(codec, 0x0b);
1588         if (err < 0)
1589                 return err;
1590
1591         spec = codec->spec;
1592         spec->gen.need_dac_fix = 1;
1593         spec->gen.beep_nid = 0x01;
1594
1595         codec->patch_ops.unsol_event = alc880_unsol_event;
1596
1597         alc_pre_init(codec);
1598
1599         snd_hda_pick_fixup(codec, alc880_fixup_models, alc880_fixup_tbl,
1600                        alc880_fixups);
1601         snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE);
1602
1603         /* automatic parse from the BIOS config */
1604         err = alc880_parse_auto_config(codec);
1605         if (err < 0)
1606                 goto error;
1607
1608         if (!spec->gen.no_analog) {
1609                 err = set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
1610                 if (err < 0)
1611                         goto error;
1612         }
1613
1614         snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE);
1615
1616         return 0;
1617
1618  error:
1619         alc_free(codec);
1620         return err;
1621 }
1622
1623
1624 /*
1625  * ALC260 support
1626  */
1627 static int alc260_parse_auto_config(struct hda_codec *codec)
1628 {
1629         static const hda_nid_t alc260_ignore[] = { 0x17, 0 };
1630         static const hda_nid_t alc260_ssids[] = { 0x10, 0x15, 0x0f, 0 };
1631         return alc_parse_auto_config(codec, alc260_ignore, alc260_ssids);
1632 }
1633
1634 /*
1635  * Pin config fixes
1636  */
1637 enum {
1638         ALC260_FIXUP_HP_DC5750,
1639         ALC260_FIXUP_HP_PIN_0F,
1640         ALC260_FIXUP_COEF,
1641         ALC260_FIXUP_GPIO1,
1642         ALC260_FIXUP_GPIO1_TOGGLE,
1643         ALC260_FIXUP_REPLACER,
1644         ALC260_FIXUP_HP_B1900,
1645         ALC260_FIXUP_KN1,
1646         ALC260_FIXUP_FSC_S7020,
1647         ALC260_FIXUP_FSC_S7020_JWSE,
1648         ALC260_FIXUP_VAIO_PINS,
1649 };
1650
1651 static void alc260_gpio1_automute(struct hda_codec *codec)
1652 {
1653         struct alc_spec *spec = codec->spec;
1654
1655         alc_update_gpio_data(codec, 0x01, spec->gen.hp_jack_present);
1656 }
1657
1658 static void alc260_fixup_gpio1_toggle(struct hda_codec *codec,
1659                                       const struct hda_fixup *fix, int action)
1660 {
1661         struct alc_spec *spec = codec->spec;
1662         if (action == HDA_FIXUP_ACT_PROBE) {
1663                 /* although the machine has only one output pin, we need to
1664                  * toggle GPIO1 according to the jack state
1665                  */
1666                 spec->gen.automute_hook = alc260_gpio1_automute;
1667                 spec->gen.detect_hp = 1;
1668                 spec->gen.automute_speaker = 1;
1669                 spec->gen.autocfg.hp_pins[0] = 0x0f; /* copy it for automute */
1670                 snd_hda_jack_detect_enable_callback(codec, 0x0f,
1671                                                     snd_hda_gen_hp_automute);
1672                 alc_setup_gpio(codec, 0x01);
1673         }
1674 }
1675
1676 static void alc260_fixup_kn1(struct hda_codec *codec,
1677                              const struct hda_fixup *fix, int action)
1678 {
1679         struct alc_spec *spec = codec->spec;
1680         static const struct hda_pintbl pincfgs[] = {
1681                 { 0x0f, 0x02214000 }, /* HP/speaker */
1682                 { 0x12, 0x90a60160 }, /* int mic */
1683                 { 0x13, 0x02a19000 }, /* ext mic */
1684                 { 0x18, 0x01446000 }, /* SPDIF out */
1685                 /* disable bogus I/O pins */
1686                 { 0x10, 0x411111f0 },
1687                 { 0x11, 0x411111f0 },
1688                 { 0x14, 0x411111f0 },
1689                 { 0x15, 0x411111f0 },
1690                 { 0x16, 0x411111f0 },
1691                 { 0x17, 0x411111f0 },
1692                 { 0x19, 0x411111f0 },
1693                 { }
1694         };
1695
1696         switch (action) {
1697         case HDA_FIXUP_ACT_PRE_PROBE:
1698                 snd_hda_apply_pincfgs(codec, pincfgs);
1699                 spec->init_amp = ALC_INIT_NONE;
1700                 break;
1701         }
1702 }
1703
1704 static void alc260_fixup_fsc_s7020(struct hda_codec *codec,
1705                                    const struct hda_fixup *fix, int action)
1706 {
1707         struct alc_spec *spec = codec->spec;
1708         if (action == HDA_FIXUP_ACT_PRE_PROBE)
1709                 spec->init_amp = ALC_INIT_NONE;
1710 }
1711
1712 static void alc260_fixup_fsc_s7020_jwse(struct hda_codec *codec,
1713                                    const struct hda_fixup *fix, int action)
1714 {
1715         struct alc_spec *spec = codec->spec;
1716         if (action == HDA_FIXUP_ACT_PRE_PROBE) {
1717                 spec->gen.add_jack_modes = 1;
1718                 spec->gen.hp_mic = 1;
1719         }
1720 }
1721
1722 static const struct hda_fixup alc260_fixups[] = {
1723         [ALC260_FIXUP_HP_DC5750] = {
1724                 .type = HDA_FIXUP_PINS,
1725                 .v.pins = (const struct hda_pintbl[]) {
1726                         { 0x11, 0x90130110 }, /* speaker */
1727                         { }
1728                 }
1729         },
1730         [ALC260_FIXUP_HP_PIN_0F] = {
1731                 .type = HDA_FIXUP_PINS,
1732                 .v.pins = (const struct hda_pintbl[]) {
1733                         { 0x0f, 0x01214000 }, /* HP */
1734                         { }
1735                 }
1736         },
1737         [ALC260_FIXUP_COEF] = {
1738                 .type = HDA_FIXUP_VERBS,
1739                 .v.verbs = (const struct hda_verb[]) {
1740                         { 0x1a, AC_VERB_SET_COEF_INDEX, 0x07 },
1741                         { 0x1a, AC_VERB_SET_PROC_COEF,  0x3040 },
1742                         { }
1743                 },
1744         },
1745         [ALC260_FIXUP_GPIO1] = {
1746                 .type = HDA_FIXUP_FUNC,
1747                 .v.func = alc_fixup_gpio1,
1748         },
1749         [ALC260_FIXUP_GPIO1_TOGGLE] = {
1750                 .type = HDA_FIXUP_FUNC,
1751                 .v.func = alc260_fixup_gpio1_toggle,
1752                 .chained = true,
1753                 .chain_id = ALC260_FIXUP_HP_PIN_0F,
1754         },
1755         [ALC260_FIXUP_REPLACER] = {
1756                 .type = HDA_FIXUP_VERBS,
1757                 .v.verbs = (const struct hda_verb[]) {
1758                         { 0x1a, AC_VERB_SET_COEF_INDEX, 0x07 },
1759                         { 0x1a, AC_VERB_SET_PROC_COEF,  0x3050 },
1760                         { }
1761                 },
1762                 .chained = true,
1763                 .chain_id = ALC260_FIXUP_GPIO1_TOGGLE,
1764         },
1765         [ALC260_FIXUP_HP_B1900] = {
1766                 .type = HDA_FIXUP_FUNC,
1767                 .v.func = alc260_fixup_gpio1_toggle,
1768                 .chained = true,
1769                 .chain_id = ALC260_FIXUP_COEF,
1770         },
1771         [ALC260_FIXUP_KN1] = {
1772                 .type = HDA_FIXUP_FUNC,
1773                 .v.func = alc260_fixup_kn1,
1774         },
1775         [ALC260_FIXUP_FSC_S7020] = {
1776                 .type = HDA_FIXUP_FUNC,
1777                 .v.func = alc260_fixup_fsc_s7020,
1778         },
1779         [ALC260_FIXUP_FSC_S7020_JWSE] = {
1780                 .type = HDA_FIXUP_FUNC,
1781                 .v.func = alc260_fixup_fsc_s7020_jwse,
1782                 .chained = true,
1783                 .chain_id = ALC260_FIXUP_FSC_S7020,
1784         },
1785         [ALC260_FIXUP_VAIO_PINS] = {
1786                 .type = HDA_FIXUP_PINS,
1787                 .v.pins = (const struct hda_pintbl[]) {
1788                         /* Pin configs are missing completely on some VAIOs */
1789                         { 0x0f, 0x01211020 },
1790                         { 0x10, 0x0001003f },
1791                         { 0x11, 0x411111f0 },
1792                         { 0x12, 0x01a15930 },
1793                         { 0x13, 0x411111f0 },
1794                         { 0x14, 0x411111f0 },
1795                         { 0x15, 0x411111f0 },
1796                         { 0x16, 0x411111f0 },
1797                         { 0x17, 0x411111f0 },
1798                         { 0x18, 0x411111f0 },
1799                         { 0x19, 0x411111f0 },
1800                         { }
1801                 }
1802         },
1803 };
1804
1805 static const struct snd_pci_quirk alc260_fixup_tbl[] = {
1806         SND_PCI_QUIRK(0x1025, 0x007b, "Acer C20x", ALC260_FIXUP_GPIO1),
1807         SND_PCI_QUIRK(0x1025, 0x007f, "Acer Aspire 9500", ALC260_FIXUP_COEF),
1808         SND_PCI_QUIRK(0x1025, 0x008f, "Acer", ALC260_FIXUP_GPIO1),
1809         SND_PCI_QUIRK(0x103c, 0x280a, "HP dc5750", ALC260_FIXUP_HP_DC5750),
1810         SND_PCI_QUIRK(0x103c, 0x30ba, "HP Presario B1900", ALC260_FIXUP_HP_B1900),
1811         SND_PCI_QUIRK(0x104d, 0x81bb, "Sony VAIO", ALC260_FIXUP_VAIO_PINS),
1812         SND_PCI_QUIRK(0x104d, 0x81e2, "Sony VAIO TX", ALC260_FIXUP_HP_PIN_0F),
1813         SND_PCI_QUIRK(0x10cf, 0x1326, "FSC LifeBook S7020", ALC260_FIXUP_FSC_S7020),
1814         SND_PCI_QUIRK(0x1509, 0x4540, "Favorit 100XS", ALC260_FIXUP_GPIO1),
1815         SND_PCI_QUIRK(0x152d, 0x0729, "Quanta KN1", ALC260_FIXUP_KN1),
1816         SND_PCI_QUIRK(0x161f, 0x2057, "Replacer 672V", ALC260_FIXUP_REPLACER),
1817         SND_PCI_QUIRK(0x1631, 0xc017, "PB V7900", ALC260_FIXUP_COEF),
1818         {}
1819 };
1820
1821 static const struct hda_model_fixup alc260_fixup_models[] = {
1822         {.id = ALC260_FIXUP_GPIO1, .name = "gpio1"},
1823         {.id = ALC260_FIXUP_COEF, .name = "coef"},
1824         {.id = ALC260_FIXUP_FSC_S7020, .name = "fujitsu"},
1825         {.id = ALC260_FIXUP_FSC_S7020_JWSE, .name = "fujitsu-jwse"},
1826         {}
1827 };
1828
1829 /*
1830  */
1831 static int patch_alc260(struct hda_codec *codec)
1832 {
1833         struct alc_spec *spec;
1834         int err;
1835
1836         err = alc_alloc_spec(codec, 0x07);
1837         if (err < 0)
1838                 return err;
1839
1840         spec = codec->spec;
1841         /* as quite a few machines require HP amp for speaker outputs,
1842          * it's easier to enable it unconditionally; even if it's unneeded,
1843          * it's almost harmless.
1844          */
1845         spec->gen.prefer_hp_amp = 1;
1846         spec->gen.beep_nid = 0x01;
1847
1848         spec->shutup = alc_eapd_shutup;
1849
1850         alc_pre_init(codec);
1851
1852         snd_hda_pick_fixup(codec, alc260_fixup_models, alc260_fixup_tbl,
1853                            alc260_fixups);
1854         snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE);
1855
1856         /* automatic parse from the BIOS config */
1857         err = alc260_parse_auto_config(codec);
1858         if (err < 0)
1859                 goto error;
1860
1861         if (!spec->gen.no_analog) {
1862                 err = set_beep_amp(spec, 0x07, 0x05, HDA_INPUT);
1863                 if (err < 0)
1864                         goto error;
1865         }
1866
1867         snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE);
1868
1869         return 0;
1870
1871  error:
1872         alc_free(codec);
1873         return err;
1874 }
1875
1876
1877 /*
1878  * ALC882/883/885/888/889 support
1879  *
1880  * ALC882 is almost identical with ALC880 but has cleaner and more flexible
1881  * configuration.  Each pin widget can choose any input DACs and a mixer.
1882  * Each ADC is connected from a mixer of all inputs.  This makes possible
1883  * 6-channel independent captures.
1884  *
1885  * In addition, an independent DAC for the multi-playback (not used in this
1886  * driver yet).
1887  */
1888
1889 /*
1890  * Pin config fixes
1891  */
1892 enum {
1893         ALC882_FIXUP_ABIT_AW9D_MAX,
1894         ALC882_FIXUP_LENOVO_Y530,
1895         ALC882_FIXUP_PB_M5210,
1896         ALC882_FIXUP_ACER_ASPIRE_7736,
1897         ALC882_FIXUP_ASUS_W90V,
1898         ALC889_FIXUP_CD,
1899         ALC889_FIXUP_FRONT_HP_NO_PRESENCE,
1900         ALC889_FIXUP_VAIO_TT,
1901         ALC888_FIXUP_EEE1601,
1902         ALC886_FIXUP_EAPD,
1903         ALC882_FIXUP_EAPD,
1904         ALC883_FIXUP_EAPD,
1905         ALC883_FIXUP_ACER_EAPD,
1906         ALC882_FIXUP_GPIO1,
1907         ALC882_FIXUP_GPIO2,
1908         ALC882_FIXUP_GPIO3,
1909         ALC889_FIXUP_COEF,
1910         ALC882_FIXUP_ASUS_W2JC,
1911         ALC882_FIXUP_ACER_ASPIRE_4930G,
1912         ALC882_FIXUP_ACER_ASPIRE_8930G,
1913         ALC882_FIXUP_ASPIRE_8930G_VERBS,
1914         ALC885_FIXUP_MACPRO_GPIO,
1915         ALC889_FIXUP_DAC_ROUTE,
1916         ALC889_FIXUP_MBP_VREF,
1917         ALC889_FIXUP_IMAC91_VREF,
1918         ALC889_FIXUP_MBA11_VREF,
1919         ALC889_FIXUP_MBA21_VREF,
1920         ALC889_FIXUP_MP11_VREF,
1921         ALC889_FIXUP_MP41_VREF,
1922         ALC882_FIXUP_INV_DMIC,
1923         ALC882_FIXUP_NO_PRIMARY_HP,
1924         ALC887_FIXUP_ASUS_BASS,
1925         ALC887_FIXUP_BASS_CHMAP,
1926         ALC1220_FIXUP_GB_DUAL_CODECS,
1927         ALC1220_FIXUP_CLEVO_P950,
1928         ALC1220_FIXUP_CLEVO_PB51ED,
1929         ALC1220_FIXUP_CLEVO_PB51ED_PINS,
1930         ALC887_FIXUP_ASUS_AUDIO,
1931         ALC887_FIXUP_ASUS_HMIC,
1932 };
1933
1934 static void alc889_fixup_coef(struct hda_codec *codec,
1935                               const struct hda_fixup *fix, int action)
1936 {
1937         if (action != HDA_FIXUP_ACT_INIT)
1938                 return;
1939         alc_update_coef_idx(codec, 7, 0, 0x2030);
1940 }
1941
1942 /* set up GPIO at initialization */
1943 static void alc885_fixup_macpro_gpio(struct hda_codec *codec,
1944                                      const struct hda_fixup *fix, int action)
1945 {
1946         struct alc_spec *spec = codec->spec;
1947
1948         spec->gpio_write_delay = true;
1949         alc_fixup_gpio3(codec, fix, action);
1950 }
1951
1952 /* Fix the connection of some pins for ALC889:
1953  * At least, Acer Aspire 5935 shows the connections to DAC3/4 don't
1954  * work correctly (bko#42740)
1955  */
1956 static void alc889_fixup_dac_route(struct hda_codec *codec,
1957                                    const struct hda_fixup *fix, int action)
1958 {
1959         if (action == HDA_FIXUP_ACT_PRE_PROBE) {
1960                 /* fake the connections during parsing the tree */
1961                 static const hda_nid_t conn1[] = { 0x0c, 0x0d };
1962                 static const hda_nid_t conn2[] = { 0x0e, 0x0f };
1963                 snd_hda_override_conn_list(codec, 0x14, ARRAY_SIZE(conn1), conn1);
1964                 snd_hda_override_conn_list(codec, 0x15, ARRAY_SIZE(conn1), conn1);
1965                 snd_hda_override_conn_list(codec, 0x18, ARRAY_SIZE(conn2), conn2);
1966                 snd_hda_override_conn_list(codec, 0x1a, ARRAY_SIZE(conn2), conn2);
1967         } else if (action == HDA_FIXUP_ACT_PROBE) {
1968                 /* restore the connections */
1969                 static const hda_nid_t conn[] = { 0x0c, 0x0d, 0x0e, 0x0f, 0x26 };
1970                 snd_hda_override_conn_list(codec, 0x14, ARRAY_SIZE(conn), conn);
1971                 snd_hda_override_conn_list(codec, 0x15, ARRAY_SIZE(conn), conn);
1972                 snd_hda_override_conn_list(codec, 0x18, ARRAY_SIZE(conn), conn);
1973                 snd_hda_override_conn_list(codec, 0x1a, ARRAY_SIZE(conn), conn);
1974         }
1975 }
1976
1977 /* Set VREF on HP pin */
1978 static void alc889_fixup_mbp_vref(struct hda_codec *codec,
1979                                   const struct hda_fixup *fix, int action)
1980 {
1981         static const hda_nid_t nids[] = { 0x14, 0x15, 0x19 };
1982         struct alc_spec *spec = codec->spec;
1983         int i;
1984
1985         if (action != HDA_FIXUP_ACT_INIT)
1986                 return;
1987         for (i = 0; i < ARRAY_SIZE(nids); i++) {
1988                 unsigned int val = snd_hda_codec_get_pincfg(codec, nids[i]);
1989                 if (get_defcfg_device(val) != AC_JACK_HP_OUT)
1990                         continue;
1991                 val = snd_hda_codec_get_pin_target(codec, nids[i]);
1992                 val |= AC_PINCTL_VREF_80;
1993                 snd_hda_set_pin_ctl(codec, nids[i], val);
1994                 spec->gen.keep_vref_in_automute = 1;
1995                 break;
1996         }
1997 }
1998
1999 static void alc889_fixup_mac_pins(struct hda_codec *codec,
2000                                   const hda_nid_t *nids, int num_nids)
2001 {
2002         struct alc_spec *spec = codec->spec;
2003         int i;
2004
2005         for (i = 0; i < num_nids; i++) {
2006                 unsigned int val;
2007                 val = snd_hda_codec_get_pin_target(codec, nids[i]);
2008                 val |= AC_PINCTL_VREF_50;
2009                 snd_hda_set_pin_ctl(codec, nids[i], val);
2010         }
2011         spec->gen.keep_vref_in_automute = 1;
2012 }
2013
2014 /* Set VREF on speaker pins on imac91 */
2015 static void alc889_fixup_imac91_vref(struct hda_codec *codec,
2016                                      const struct hda_fixup *fix, int action)
2017 {
2018         static const hda_nid_t nids[] = { 0x18, 0x1a };
2019
2020         if (action == HDA_FIXUP_ACT_INIT)
2021                 alc889_fixup_mac_pins(codec, nids, ARRAY_SIZE(nids));
2022 }
2023
2024 /* Set VREF on speaker pins on mba11 */
2025 static void alc889_fixup_mba11_vref(struct hda_codec *codec,
2026                                     const struct hda_fixup *fix, int action)
2027 {
2028         static const hda_nid_t nids[] = { 0x18 };
2029
2030         if (action == HDA_FIXUP_ACT_INIT)
2031                 alc889_fixup_mac_pins(codec, nids, ARRAY_SIZE(nids));
2032 }
2033
2034 /* Set VREF on speaker pins on mba21 */
2035 static void alc889_fixup_mba21_vref(struct hda_codec *codec,
2036                                     const struct hda_fixup *fix, int action)
2037 {
2038         static const hda_nid_t nids[] = { 0x18, 0x19 };
2039
2040         if (action == HDA_FIXUP_ACT_INIT)
2041                 alc889_fixup_mac_pins(codec, nids, ARRAY_SIZE(nids));
2042 }
2043
2044 /* Don't take HP output as primary
2045  * Strangely, the speaker output doesn't work on Vaio Z and some Vaio
2046  * all-in-one desktop PCs (for example VGC-LN51JGB) through DAC 0x05
2047  */
2048 static void alc882_fixup_no_primary_hp(struct hda_codec *codec,
2049                                        const struct hda_fixup *fix, int action)
2050 {
2051         struct alc_spec *spec = codec->spec;
2052         if (action == HDA_FIXUP_ACT_PRE_PROBE) {
2053                 spec->gen.no_primary_hp = 1;
2054                 spec->gen.no_multi_io = 1;
2055         }
2056 }
2057
2058 static void alc_fixup_bass_chmap(struct hda_codec *codec,
2059                                  const struct hda_fixup *fix, int action);
2060
2061 /* For dual-codec configuration, we need to disable some features to avoid
2062  * conflicts of kctls and PCM streams
2063  */
2064 static void alc_fixup_dual_codecs(struct hda_codec *codec,
2065                                   const struct hda_fixup *fix, int action)
2066 {
2067         struct alc_spec *spec = codec->spec;
2068
2069         if (action != HDA_FIXUP_ACT_PRE_PROBE)
2070                 return;
2071         /* disable vmaster */
2072         spec->gen.suppress_vmaster = 1;
2073         /* auto-mute and auto-mic switch don't work with multiple codecs */
2074         spec->gen.suppress_auto_mute = 1;
2075         spec->gen.suppress_auto_mic = 1;
2076         /* disable aamix as well */
2077         spec->gen.mixer_nid = 0;
2078         /* add location prefix to avoid conflicts */
2079         codec->force_pin_prefix = 1;
2080 }
2081
2082 static void rename_ctl(struct hda_codec *codec, const char *oldname,
2083                        const char *newname)
2084 {
2085         struct snd_kcontrol *kctl;
2086
2087         kctl = snd_hda_find_mixer_ctl(codec, oldname);
2088         if (kctl)
2089                 strcpy(kctl->id.name, newname);
2090 }
2091
2092 static void alc1220_fixup_gb_dual_codecs(struct hda_codec *codec,
2093                                          const struct hda_fixup *fix,
2094                                          int action)
2095 {
2096         alc_fixup_dual_codecs(codec, fix, action);
2097         switch (action) {
2098         case HDA_FIXUP_ACT_PRE_PROBE:
2099                 /* override card longname to provide a unique UCM profile */
2100                 strcpy(codec->card->longname, "HDAudio-Gigabyte-ALC1220DualCodecs");
2101                 break;
2102         case HDA_FIXUP_ACT_BUILD:
2103                 /* rename Capture controls depending on the codec */
2104                 rename_ctl(codec, "Capture Volume",
2105                            codec->addr == 0 ?
2106                            "Rear-Panel Capture Volume" :
2107                            "Front-Panel Capture Volume");
2108                 rename_ctl(codec, "Capture Switch",
2109                            codec->addr == 0 ?
2110                            "Rear-Panel Capture Switch" :
2111                            "Front-Panel Capture Switch");
2112                 break;
2113         }
2114 }
2115
2116 static void alc1220_fixup_clevo_p950(struct hda_codec *codec,
2117                                      const struct hda_fixup *fix,
2118                                      int action)
2119 {
2120         static const hda_nid_t conn1[] = { 0x0c };
2121
2122         if (action != HDA_FIXUP_ACT_PRE_PROBE)
2123                 return;
2124
2125         alc_update_coef_idx(codec, 0x7, 0, 0x3c3);
2126         /* We therefore want to make sure 0x14 (front headphone) and
2127          * 0x1b (speakers) use the stereo DAC 0x02
2128          */
2129         snd_hda_override_conn_list(codec, 0x14, ARRAY_SIZE(conn1), conn1);
2130         snd_hda_override_conn_list(codec, 0x1b, ARRAY_SIZE(conn1), conn1);
2131 }
2132
2133 static void alc_fixup_headset_mode_no_hp_mic(struct hda_codec *codec,
2134                                 const struct hda_fixup *fix, int action);
2135
2136 static void alc1220_fixup_clevo_pb51ed(struct hda_codec *codec,
2137                                      const struct hda_fixup *fix,
2138                                      int action)
2139 {
2140         alc1220_fixup_clevo_p950(codec, fix, action);
2141         alc_fixup_headset_mode_no_hp_mic(codec, fix, action);
2142 }
2143
2144 static void alc887_asus_hp_automute_hook(struct hda_codec *codec,
2145                                          struct hda_jack_callback *jack)
2146 {
2147         struct alc_spec *spec = codec->spec;
2148         unsigned int vref;
2149
2150         snd_hda_gen_hp_automute(codec, jack);
2151
2152         if (spec->gen.hp_jack_present)
2153                 vref = AC_PINCTL_VREF_80;
2154         else
2155                 vref = AC_PINCTL_VREF_HIZ;
2156         snd_hda_set_pin_ctl(codec, 0x19, PIN_HP | vref);
2157 }
2158
2159 static void alc887_fixup_asus_jack(struct hda_codec *codec,
2160                                      const struct hda_fixup *fix, int action)
2161 {
2162         struct alc_spec *spec = codec->spec;
2163         if (action != HDA_FIXUP_ACT_PROBE)
2164                 return;
2165         snd_hda_set_pin_ctl_cache(codec, 0x1b, PIN_HP);
2166         spec->gen.hp_automute_hook = alc887_asus_hp_automute_hook;
2167 }
2168
2169 static const struct hda_fixup alc882_fixups[] = {
2170         [ALC882_FIXUP_ABIT_AW9D_MAX] = {
2171                 .type = HDA_FIXUP_PINS,
2172                 .v.pins = (const struct hda_pintbl[]) {
2173                         { 0x15, 0x01080104 }, /* side */
2174                         { 0x16, 0x01011012 }, /* rear */
2175                         { 0x17, 0x01016011 }, /* clfe */
2176                         { }
2177                 }
2178         },
2179         [ALC882_FIXUP_LENOVO_Y530] = {
2180                 .type = HDA_FIXUP_PINS,
2181                 .v.pins = (const struct hda_pintbl[]) {
2182                         { 0x15, 0x99130112 }, /* rear int speakers */
2183                         { 0x16, 0x99130111 }, /* subwoofer */
2184                         { }
2185                 }
2186         },
2187         [ALC882_FIXUP_PB_M5210] = {
2188                 .type = HDA_FIXUP_PINCTLS,
2189                 .v.pins = (const struct hda_pintbl[]) {
2190                         { 0x19, PIN_VREF50 },
2191                         {}
2192                 }
2193         },
2194         [ALC882_FIXUP_ACER_ASPIRE_7736] = {
2195                 .type = HDA_FIXUP_FUNC,
2196                 .v.func = alc_fixup_sku_ignore,
2197         },
2198         [ALC882_FIXUP_ASUS_W90V] = {
2199                 .type = HDA_FIXUP_PINS,
2200                 .v.pins = (const struct hda_pintbl[]) {
2201                         { 0x16, 0x99130110 }, /* fix sequence for CLFE */
2202                         { }
2203                 }
2204         },
2205         [ALC889_FIXUP_CD] = {
2206                 .type = HDA_FIXUP_PINS,
2207                 .v.pins = (const struct hda_pintbl[]) {
2208                         { 0x1c, 0x993301f0 }, /* CD */
2209                         { }
2210                 }
2211         },
2212         [ALC889_FIXUP_FRONT_HP_NO_PRESENCE] = {
2213                 .type = HDA_FIXUP_PINS,
2214                 .v.pins = (const struct hda_pintbl[]) {
2215                         { 0x1b, 0x02214120 }, /* Front HP jack is flaky, disable jack detect */
2216                         { }
2217                 },
2218                 .chained = true,
2219                 .chain_id = ALC889_FIXUP_CD,
2220         },
2221         [ALC889_FIXUP_VAIO_TT] = {
2222                 .type = HDA_FIXUP_PINS,
2223                 .v.pins = (const struct hda_pintbl[]) {
2224                         { 0x17, 0x90170111 }, /* hidden surround speaker */
2225                         { }
2226                 }
2227         },
2228         [ALC888_FIXUP_EEE1601] = {
2229                 .type = HDA_FIXUP_VERBS,
2230                 .v.verbs = (const struct hda_verb[]) {
2231                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x0b },
2232                         { 0x20, AC_VERB_SET_PROC_COEF,  0x0838 },
2233                         { }
2234                 }
2235         },
2236         [ALC886_FIXUP_EAPD] = {
2237                 .type = HDA_FIXUP_VERBS,
2238                 .v.verbs = (const struct hda_verb[]) {
2239                         /* change to EAPD mode */
2240                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x07 },
2241                         { 0x20, AC_VERB_SET_PROC_COEF, 0x0068 },
2242                         { }
2243                 }
2244         },
2245         [ALC882_FIXUP_EAPD] = {
2246                 .type = HDA_FIXUP_VERBS,
2247                 .v.verbs = (const struct hda_verb[]) {
2248                         /* change to EAPD mode */
2249                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x07 },
2250                         { 0x20, AC_VERB_SET_PROC_COEF, 0x3060 },
2251                         { }
2252                 }
2253         },
2254         [ALC883_FIXUP_EAPD] = {
2255                 .type = HDA_FIXUP_VERBS,
2256                 .v.verbs = (const struct hda_verb[]) {
2257                         /* change to EAPD mode */
2258                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x07 },
2259                         { 0x20, AC_VERB_SET_PROC_COEF, 0x3070 },
2260                         { }
2261                 }
2262         },
2263         [ALC883_FIXUP_ACER_EAPD] = {
2264                 .type = HDA_FIXUP_VERBS,
2265                 .v.verbs = (const struct hda_verb[]) {
2266                         /* eanable EAPD on Acer laptops */
2267                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x07 },
2268                         { 0x20, AC_VERB_SET_PROC_COEF, 0x3050 },
2269                         { }
2270                 }
2271         },
2272         [ALC882_FIXUP_GPIO1] = {
2273                 .type = HDA_FIXUP_FUNC,
2274                 .v.func = alc_fixup_gpio1,
2275         },
2276         [ALC882_FIXUP_GPIO2] = {
2277                 .type = HDA_FIXUP_FUNC,
2278                 .v.func = alc_fixup_gpio2,
2279         },
2280         [ALC882_FIXUP_GPIO3] = {
2281                 .type = HDA_FIXUP_FUNC,
2282                 .v.func = alc_fixup_gpio3,
2283         },
2284         [ALC882_FIXUP_ASUS_W2JC] = {
2285                 .type = HDA_FIXUP_FUNC,
2286                 .v.func = alc_fixup_gpio1,
2287                 .chained = true,
2288                 .chain_id = ALC882_FIXUP_EAPD,
2289         },
2290         [ALC889_FIXUP_COEF] = {
2291                 .type = HDA_FIXUP_FUNC,
2292                 .v.func = alc889_fixup_coef,
2293         },
2294         [ALC882_FIXUP_ACER_ASPIRE_4930G] = {
2295                 .type = HDA_FIXUP_PINS,
2296                 .v.pins = (const struct hda_pintbl[]) {
2297                         { 0x16, 0x99130111 }, /* CLFE speaker */
2298                         { 0x17, 0x99130112 }, /* surround speaker */
2299                         { }
2300                 },
2301                 .chained = true,
2302                 .chain_id = ALC882_FIXUP_GPIO1,
2303         },
2304         [ALC882_FIXUP_ACER_ASPIRE_8930G] = {
2305                 .type = HDA_FIXUP_PINS,
2306                 .v.pins = (const struct hda_pintbl[]) {
2307                         { 0x16, 0x99130111 }, /* CLFE speaker */
2308                         { 0x1b, 0x99130112 }, /* surround speaker */
2309                         { }
2310                 },
2311                 .chained = true,
2312                 .chain_id = ALC882_FIXUP_ASPIRE_8930G_VERBS,
2313         },
2314         [ALC882_FIXUP_ASPIRE_8930G_VERBS] = {
2315                 /* additional init verbs for Acer Aspire 8930G */
2316                 .type = HDA_FIXUP_VERBS,
2317                 .v.verbs = (const struct hda_verb[]) {
2318                         /* Enable all DACs */
2319                         /* DAC DISABLE/MUTE 1? */
2320                         /*  setting bits 1-5 disables DAC nids 0x02-0x06
2321                          *  apparently. Init=0x38 */
2322                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x03 },
2323                         { 0x20, AC_VERB_SET_PROC_COEF, 0x0000 },
2324                         /* DAC DISABLE/MUTE 2? */
2325                         /*  some bit here disables the other DACs.
2326                          *  Init=0x4900 */
2327                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x08 },
2328                         { 0x20, AC_VERB_SET_PROC_COEF, 0x0000 },
2329                         /* DMIC fix
2330                          * This laptop has a stereo digital microphone.
2331                          * The mics are only 1cm apart which makes the stereo
2332                          * useless. However, either the mic or the ALC889
2333                          * makes the signal become a difference/sum signal
2334                          * instead of standard stereo, which is annoying.
2335                          * So instead we flip this bit which makes the
2336                          * codec replicate the sum signal to both channels,
2337                          * turning it into a normal mono mic.
2338                          */
2339                         /* DMIC_CONTROL? Init value = 0x0001 */
2340                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x0b },
2341                         { 0x20, AC_VERB_SET_PROC_COEF, 0x0003 },
2342                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x07 },
2343                         { 0x20, AC_VERB_SET_PROC_COEF, 0x3050 },
2344                         { }
2345                 },
2346                 .chained = true,
2347                 .chain_id = ALC882_FIXUP_GPIO1,
2348         },
2349         [ALC885_FIXUP_MACPRO_GPIO] = {
2350                 .type = HDA_FIXUP_FUNC,
2351                 .v.func = alc885_fixup_macpro_gpio,
2352         },
2353         [ALC889_FIXUP_DAC_ROUTE] = {
2354                 .type = HDA_FIXUP_FUNC,
2355                 .v.func = alc889_fixup_dac_route,
2356         },
2357         [ALC889_FIXUP_MBP_VREF] = {
2358                 .type = HDA_FIXUP_FUNC,
2359                 .v.func = alc889_fixup_mbp_vref,
2360                 .chained = true,
2361                 .chain_id = ALC882_FIXUP_GPIO1,
2362         },
2363         [ALC889_FIXUP_IMAC91_VREF] = {
2364                 .type = HDA_FIXUP_FUNC,
2365                 .v.func = alc889_fixup_imac91_vref,
2366                 .chained = true,
2367                 .chain_id = ALC882_FIXUP_GPIO1,
2368         },
2369         [ALC889_FIXUP_MBA11_VREF] = {
2370                 .type = HDA_FIXUP_FUNC,
2371                 .v.func = alc889_fixup_mba11_vref,
2372                 .chained = true,
2373                 .chain_id = ALC889_FIXUP_MBP_VREF,
2374         },
2375         [ALC889_FIXUP_MBA21_VREF] = {
2376                 .type = HDA_FIXUP_FUNC,
2377                 .v.func = alc889_fixup_mba21_vref,
2378                 .chained = true,
2379                 .chain_id = ALC889_FIXUP_MBP_VREF,
2380         },
2381         [ALC889_FIXUP_MP11_VREF] = {
2382                 .type = HDA_FIXUP_FUNC,
2383                 .v.func = alc889_fixup_mba11_vref,
2384                 .chained = true,
2385                 .chain_id = ALC885_FIXUP_MACPRO_GPIO,
2386         },
2387         [ALC889_FIXUP_MP41_VREF] = {
2388                 .type = HDA_FIXUP_FUNC,
2389                 .v.func = alc889_fixup_mbp_vref,
2390                 .chained = true,
2391                 .chain_id = ALC885_FIXUP_MACPRO_GPIO,
2392         },
2393         [ALC882_FIXUP_INV_DMIC] = {
2394                 .type = HDA_FIXUP_FUNC,
2395                 .v.func = alc_fixup_inv_dmic,
2396         },
2397         [ALC882_FIXUP_NO_PRIMARY_HP] = {
2398                 .type = HDA_FIXUP_FUNC,
2399                 .v.func = alc882_fixup_no_primary_hp,
2400         },
2401         [ALC887_FIXUP_ASUS_BASS] = {
2402                 .type = HDA_FIXUP_PINS,
2403                 .v.pins = (const struct hda_pintbl[]) {
2404                         {0x16, 0x99130130}, /* bass speaker */
2405                         {}
2406                 },
2407                 .chained = true,
2408                 .chain_id = ALC887_FIXUP_BASS_CHMAP,
2409         },
2410         [ALC887_FIXUP_BASS_CHMAP] = {
2411                 .type = HDA_FIXUP_FUNC,
2412                 .v.func = alc_fixup_bass_chmap,
2413         },
2414         [ALC1220_FIXUP_GB_DUAL_CODECS] = {
2415                 .type = HDA_FIXUP_FUNC,
2416                 .v.func = alc1220_fixup_gb_dual_codecs,
2417         },
2418         [ALC1220_FIXUP_CLEVO_P950] = {
2419                 .type = HDA_FIXUP_FUNC,
2420                 .v.func = alc1220_fixup_clevo_p950,
2421         },
2422         [ALC1220_FIXUP_CLEVO_PB51ED] = {
2423                 .type = HDA_FIXUP_FUNC,
2424                 .v.func = alc1220_fixup_clevo_pb51ed,
2425         },
2426         [ALC1220_FIXUP_CLEVO_PB51ED_PINS] = {
2427                 .type = HDA_FIXUP_PINS,
2428                 .v.pins = (const struct hda_pintbl[]) {
2429                         { 0x19, 0x01a1913c }, /* use as headset mic, without its own jack detect */
2430                         {}
2431                 },
2432                 .chained = true,
2433                 .chain_id = ALC1220_FIXUP_CLEVO_PB51ED,
2434         },
2435         [ALC887_FIXUP_ASUS_AUDIO] = {
2436                 .type = HDA_FIXUP_PINS,
2437                 .v.pins = (const struct hda_pintbl[]) {
2438                         { 0x15, 0x02a14150 }, /* use as headset mic, without its own jack detect */
2439                         { 0x19, 0x22219420 },
2440                         {}
2441                 },
2442         },
2443         [ALC887_FIXUP_ASUS_HMIC] = {
2444                 .type = HDA_FIXUP_FUNC,
2445                 .v.func = alc887_fixup_asus_jack,
2446                 .chained = true,
2447                 .chain_id = ALC887_FIXUP_ASUS_AUDIO,
2448         },
2449 };
2450
2451 static const struct snd_pci_quirk alc882_fixup_tbl[] = {
2452         SND_PCI_QUIRK(0x1025, 0x006c, "Acer Aspire 9810", ALC883_FIXUP_ACER_EAPD),
2453         SND_PCI_QUIRK(0x1025, 0x0090, "Acer Aspire", ALC883_FIXUP_ACER_EAPD),
2454         SND_PCI_QUIRK(0x1025, 0x0107, "Acer Aspire", ALC883_FIXUP_ACER_EAPD),
2455         SND_PCI_QUIRK(0x1025, 0x010a, "Acer Ferrari 5000", ALC883_FIXUP_ACER_EAPD),
2456         SND_PCI_QUIRK(0x1025, 0x0110, "Acer Aspire", ALC883_FIXUP_ACER_EAPD),
2457         SND_PCI_QUIRK(0x1025, 0x0112, "Acer Aspire 9303", ALC883_FIXUP_ACER_EAPD),
2458         SND_PCI_QUIRK(0x1025, 0x0121, "Acer Aspire 5920G", ALC883_FIXUP_ACER_EAPD),
2459         SND_PCI_QUIRK(0x1025, 0x013e, "Acer Aspire 4930G",
2460                       ALC882_FIXUP_ACER_ASPIRE_4930G),
2461         SND_PCI_QUIRK(0x1025, 0x013f, "Acer Aspire 5930G",
2462                       ALC882_FIXUP_ACER_ASPIRE_4930G),
2463         SND_PCI_QUIRK(0x1025, 0x0145, "Acer Aspire 8930G",
2464                       ALC882_FIXUP_ACER_ASPIRE_8930G),
2465         SND_PCI_QUIRK(0x1025, 0x0146, "Acer Aspire 6935G",
2466                       ALC882_FIXUP_ACER_ASPIRE_8930G),
2467         SND_PCI_QUIRK(0x1025, 0x0142, "Acer Aspire 7730G",
2468                       ALC882_FIXUP_ACER_ASPIRE_4930G),
2469         SND_PCI_QUIRK(0x1025, 0x0155, "Packard-Bell M5120", ALC882_FIXUP_PB_M5210),
2470         SND_PCI_QUIRK(0x1025, 0x015e, "Acer Aspire 6930G",
2471                       ALC882_FIXUP_ACER_ASPIRE_4930G),
2472         SND_PCI_QUIRK(0x1025, 0x0166, "Acer Aspire 6530G",
2473                       ALC882_FIXUP_ACER_ASPIRE_4930G),
2474         SND_PCI_QUIRK(0x1025, 0x021e, "Acer Aspire 5739G",
2475                       ALC882_FIXUP_ACER_ASPIRE_4930G),
2476         SND_PCI_QUIRK(0x1025, 0x0259, "Acer Aspire 5935", ALC889_FIXUP_DAC_ROUTE),
2477         SND_PCI_QUIRK(0x1025, 0x026b, "Acer Aspire 8940G", ALC882_FIXUP_ACER_ASPIRE_8930G),
2478         SND_PCI_QUIRK(0x1025, 0x0296, "Acer Aspire 7736z", ALC882_FIXUP_ACER_ASPIRE_7736),
2479         SND_PCI_QUIRK(0x1043, 0x13c2, "Asus A7M", ALC882_FIXUP_EAPD),
2480         SND_PCI_QUIRK(0x1043, 0x1873, "ASUS W90V", ALC882_FIXUP_ASUS_W90V),
2481         SND_PCI_QUIRK(0x1043, 0x1971, "Asus W2JC", ALC882_FIXUP_ASUS_W2JC),
2482         SND_PCI_QUIRK(0x1043, 0x2390, "Asus D700SA", ALC887_FIXUP_ASUS_HMIC),
2483         SND_PCI_QUIRK(0x1043, 0x835f, "Asus Eee 1601", ALC888_FIXUP_EEE1601),
2484         SND_PCI_QUIRK(0x1043, 0x84bc, "ASUS ET2700", ALC887_FIXUP_ASUS_BASS),
2485         SND_PCI_QUIRK(0x1043, 0x8691, "ASUS ROG Ranger VIII", ALC882_FIXUP_GPIO3),
2486         SND_PCI_QUIRK(0x104d, 0x9043, "Sony Vaio VGC-LN51JGB", ALC882_FIXUP_NO_PRIMARY_HP),
2487         SND_PCI_QUIRK(0x104d, 0x9044, "Sony VAIO AiO", ALC882_FIXUP_NO_PRIMARY_HP),
2488         SND_PCI_QUIRK(0x104d, 0x9047, "Sony Vaio TT", ALC889_FIXUP_VAIO_TT),
2489         SND_PCI_QUIRK(0x104d, 0x905a, "Sony Vaio Z", ALC882_FIXUP_NO_PRIMARY_HP),
2490         SND_PCI_QUIRK(0x104d, 0x9060, "Sony Vaio VPCL14M1R", ALC882_FIXUP_NO_PRIMARY_HP),
2491
2492         /* All Apple entries are in codec SSIDs */
2493         SND_PCI_QUIRK(0x106b, 0x00a0, "MacBookPro 3,1", ALC889_FIXUP_MBP_VREF),
2494         SND_PCI_QUIRK(0x106b, 0x00a1, "Macbook", ALC889_FIXUP_MBP_VREF),
2495         SND_PCI_QUIRK(0x106b, 0x00a4, "MacbookPro 4,1", ALC889_FIXUP_MBP_VREF),
2496         SND_PCI_QUIRK(0x106b, 0x0c00, "Mac Pro", ALC889_FIXUP_MP11_VREF),
2497         SND_PCI_QUIRK(0x106b, 0x1000, "iMac 24", ALC885_FIXUP_MACPRO_GPIO),
2498         SND_PCI_QUIRK(0x106b, 0x2800, "AppleTV", ALC885_FIXUP_MACPRO_GPIO),
2499         SND_PCI_QUIRK(0x106b, 0x2c00, "MacbookPro rev3", ALC889_FIXUP_MBP_VREF),
2500         SND_PCI_QUIRK(0x106b, 0x3000, "iMac", ALC889_FIXUP_MBP_VREF),
2501         SND_PCI_QUIRK(0x106b, 0x3200, "iMac 7,1 Aluminum", ALC882_FIXUP_EAPD),
2502         SND_PCI_QUIRK(0x106b, 0x3400, "MacBookAir 1,1", ALC889_FIXUP_MBA11_VREF),
2503         SND_PCI_QUIRK(0x106b, 0x3500, "MacBookAir 2,1", ALC889_FIXUP_MBA21_VREF),
2504         SND_PCI_QUIRK(0x106b, 0x3600, "Macbook 3,1", ALC889_FIXUP_MBP_VREF),
2505         SND_PCI_QUIRK(0x106b, 0x3800, "MacbookPro 4,1", ALC889_FIXUP_MBP_VREF),
2506         SND_PCI_QUIRK(0x106b, 0x3e00, "iMac 24 Aluminum", ALC885_FIXUP_MACPRO_GPIO),
2507         SND_PCI_QUIRK(0x106b, 0x3f00, "Macbook 5,1", ALC889_FIXUP_IMAC91_VREF),
2508         SND_PCI_QUIRK(0x106b, 0x4000, "MacbookPro 5,1", ALC889_FIXUP_IMAC91_VREF),
2509         SND_PCI_QUIRK(0x106b, 0x4100, "Macmini 3,1", ALC889_FIXUP_IMAC91_VREF),
2510         SND_PCI_QUIRK(0x106b, 0x4200, "Mac Pro 4,1/5,1", ALC889_FIXUP_MP41_VREF),
2511         SND_PCI_QUIRK(0x106b, 0x4300, "iMac 9,1", ALC889_FIXUP_IMAC91_VREF),
2512         SND_PCI_QUIRK(0x106b, 0x4600, "MacbookPro 5,2", ALC889_FIXUP_IMAC91_VREF),
2513         SND_PCI_QUIRK(0x106b, 0x4900, "iMac 9,1 Aluminum", ALC889_FIXUP_IMAC91_VREF),
2514         SND_PCI_QUIRK(0x106b, 0x4a00, "Macbook 5,2", ALC889_FIXUP_MBA11_VREF),
2515
2516         SND_PCI_QUIRK(0x1071, 0x8258, "Evesham Voyaeger", ALC882_FIXUP_EAPD),
2517         SND_PCI_QUIRK(0x13fe, 0x1009, "Advantech MIT-W101", ALC886_FIXUP_EAPD),
2518         SND_PCI_QUIRK(0x1458, 0xa002, "Gigabyte EP45-DS3/Z87X-UD3H", ALC889_FIXUP_FRONT_HP_NO_PRESENCE),
2519         SND_PCI_QUIRK(0x1458, 0xa0b8, "Gigabyte AZ370-Gaming", ALC1220_FIXUP_GB_DUAL_CODECS),
2520         SND_PCI_QUIRK(0x1458, 0xa0cd, "Gigabyte X570 Aorus Master", ALC1220_FIXUP_CLEVO_P950),
2521         SND_PCI_QUIRK(0x1458, 0xa0ce, "Gigabyte X570 Aorus Xtreme", ALC1220_FIXUP_CLEVO_P950),
2522         SND_PCI_QUIRK(0x1462, 0x11f7, "MSI-GE63", ALC1220_FIXUP_CLEVO_P950),
2523         SND_PCI_QUIRK(0x1462, 0x1228, "MSI-GP63", ALC1220_FIXUP_CLEVO_P950),
2524         SND_PCI_QUIRK(0x1462, 0x1229, "MSI-GP73", ALC1220_FIXUP_CLEVO_P950),
2525         SND_PCI_QUIRK(0x1462, 0x1275, "MSI-GL63", ALC1220_FIXUP_CLEVO_P950),
2526         SND_PCI_QUIRK(0x1462, 0x1276, "MSI-GL73", ALC1220_FIXUP_CLEVO_P950),
2527         SND_PCI_QUIRK(0x1462, 0x1293, "MSI-GP65", ALC1220_FIXUP_CLEVO_P950),
2528         SND_PCI_QUIRK(0x1462, 0x7350, "MSI-7350", ALC889_FIXUP_CD),
2529         SND_PCI_QUIRK(0x1462, 0xcc34, "MSI Godlike X570", ALC1220_FIXUP_GB_DUAL_CODECS),
2530         SND_PCI_QUIRK(0x1462, 0xda57, "MSI Z270-Gaming", ALC1220_FIXUP_GB_DUAL_CODECS),
2531         SND_PCI_QUIRK_VENDOR(0x1462, "MSI", ALC882_FIXUP_GPIO3),
2532         SND_PCI_QUIRK(0x147b, 0x107a, "Abit AW9D-MAX", ALC882_FIXUP_ABIT_AW9D_MAX),
2533         SND_PCI_QUIRK(0x1558, 0x50d3, "Clevo PC50[ER][CDF]", ALC1220_FIXUP_CLEVO_PB51ED_PINS),
2534         SND_PCI_QUIRK(0x1558, 0x65d1, "Clevo PB51[ER][CDF]", ALC1220_FIXUP_CLEVO_PB51ED_PINS),
2535         SND_PCI_QUIRK(0x1558, 0x65d2, "Clevo PB51R[CDF]", ALC1220_FIXUP_CLEVO_PB51ED_PINS),
2536         SND_PCI_QUIRK(0x1558, 0x65e1, "Clevo PB51[ED][DF]", ALC1220_FIXUP_CLEVO_PB51ED_PINS),
2537         SND_PCI_QUIRK(0x1558, 0x65e5, "Clevo PC50D[PRS](?:-D|-G)?", ALC1220_FIXUP_CLEVO_PB51ED_PINS),
2538         SND_PCI_QUIRK(0x1558, 0x65f1, "Clevo PC50HS", ALC1220_FIXUP_CLEVO_PB51ED_PINS),
2539         SND_PCI_QUIRK(0x1558, 0x67d1, "Clevo PB71[ER][CDF]", ALC1220_FIXUP_CLEVO_PB51ED_PINS),
2540         SND_PCI_QUIRK(0x1558, 0x67e1, "Clevo PB71[DE][CDF]", ALC1220_FIXUP_CLEVO_PB51ED_PINS),
2541         SND_PCI_QUIRK(0x1558, 0x67e5, "Clevo PC70D[PRS](?:-D|-G)?", ALC1220_FIXUP_CLEVO_PB51ED_PINS),
2542         SND_PCI_QUIRK(0x1558, 0x67f1, "Clevo PC70H[PRS]", ALC1220_FIXUP_CLEVO_PB51ED_PINS),
2543         SND_PCI_QUIRK(0x1558, 0x70d1, "Clevo PC70[ER][CDF]", ALC1220_FIXUP_CLEVO_PB51ED_PINS),
2544         SND_PCI_QUIRK(0x1558, 0x7714, "Clevo X170SM", ALC1220_FIXUP_CLEVO_PB51ED_PINS),
2545         SND_PCI_QUIRK(0x1558, 0x7715, "Clevo X170KM-G", ALC1220_FIXUP_CLEVO_PB51ED),
2546         SND_PCI_QUIRK(0x1558, 0x9501, "Clevo P950HR", ALC1220_FIXUP_CLEVO_P950),
2547         SND_PCI_QUIRK(0x1558, 0x9506, "Clevo P955HQ", ALC1220_FIXUP_CLEVO_P950),
2548         SND_PCI_QUIRK(0x1558, 0x950a, "Clevo P955H[PR]", ALC1220_FIXUP_CLEVO_P950),
2549         SND_PCI_QUIRK(0x1558, 0x95e1, "Clevo P95xER", ALC1220_FIXUP_CLEVO_P950),
2550         SND_PCI_QUIRK(0x1558, 0x95e2, "Clevo P950ER", ALC1220_FIXUP_CLEVO_P950),
2551         SND_PCI_QUIRK(0x1558, 0x95e3, "Clevo P955[ER]T", ALC1220_FIXUP_CLEVO_P950),
2552         SND_PCI_QUIRK(0x1558, 0x95e4, "Clevo P955ER", ALC1220_FIXUP_CLEVO_P950),
2553         SND_PCI_QUIRK(0x1558, 0x95e5, "Clevo P955EE6", ALC1220_FIXUP_CLEVO_P950),
2554         SND_PCI_QUIRK(0x1558, 0x95e6, "Clevo P950R[CDF]", ALC1220_FIXUP_CLEVO_P950),
2555         SND_PCI_QUIRK(0x1558, 0x96e1, "Clevo P960[ER][CDFN]-K", ALC1220_FIXUP_CLEVO_P950),
2556         SND_PCI_QUIRK(0x1558, 0x97e1, "Clevo P970[ER][CDFN]", ALC1220_FIXUP_CLEVO_P950),
2557         SND_PCI_QUIRK(0x1558, 0x97e2, "Clevo P970RC-M", ALC1220_FIXUP_CLEVO_P950),
2558         SND_PCI_QUIRK_VENDOR(0x1558, "Clevo laptop", ALC882_FIXUP_EAPD),
2559         SND_PCI_QUIRK(0x161f, 0x2054, "Medion laptop", ALC883_FIXUP_EAPD),
2560         SND_PCI_QUIRK(0x17aa, 0x3a0d, "Lenovo Y530", ALC882_FIXUP_LENOVO_Y530),
2561         SND_PCI_QUIRK(0x8086, 0x0022, "DX58SO", ALC889_FIXUP_COEF),
2562         {}
2563 };
2564
2565 static const struct hda_model_fixup alc882_fixup_models[] = {
2566         {.id = ALC882_FIXUP_ABIT_AW9D_MAX, .name = "abit-aw9d"},
2567         {.id = ALC882_FIXUP_LENOVO_Y530, .name = "lenovo-y530"},
2568         {.id = ALC882_FIXUP_ACER_ASPIRE_7736, .name = "acer-aspire-7736"},
2569         {.id = ALC882_FIXUP_ASUS_W90V, .name = "asus-w90v"},
2570         {.id = ALC889_FIXUP_CD, .name = "cd"},
2571         {.id = ALC889_FIXUP_FRONT_HP_NO_PRESENCE, .name = "no-front-hp"},
2572         {.id = ALC889_FIXUP_VAIO_TT, .name = "vaio-tt"},
2573         {.id = ALC888_FIXUP_EEE1601, .name = "eee1601"},
2574         {.id = ALC882_FIXUP_EAPD, .name = "alc882-eapd"},
2575         {.id = ALC883_FIXUP_EAPD, .name = "alc883-eapd"},
2576         {.id = ALC882_FIXUP_GPIO1, .name = "gpio1"},
2577         {.id = ALC882_FIXUP_GPIO2, .name = "gpio2"},
2578         {.id = ALC882_FIXUP_GPIO3, .name = "gpio3"},
2579         {.id = ALC889_FIXUP_COEF, .name = "alc889-coef"},
2580         {.id = ALC882_FIXUP_ASUS_W2JC, .name = "asus-w2jc"},
2581         {.id = ALC882_FIXUP_ACER_ASPIRE_4930G, .name = "acer-aspire-4930g"},
2582         {.id = ALC882_FIXUP_ACER_ASPIRE_8930G, .name = "acer-aspire-8930g"},
2583         {.id = ALC883_FIXUP_ACER_EAPD, .name = "acer-aspire"},
2584         {.id = ALC885_FIXUP_MACPRO_GPIO, .name = "macpro-gpio"},
2585         {.id = ALC889_FIXUP_DAC_ROUTE, .name = "dac-route"},
2586         {.id = ALC889_FIXUP_MBP_VREF, .name = "mbp-vref"},
2587         {.id = ALC889_FIXUP_IMAC91_VREF, .name = "imac91-vref"},
2588         {.id = ALC889_FIXUP_MBA11_VREF, .name = "mba11-vref"},
2589         {.id = ALC889_FIXUP_MBA21_VREF, .name = "mba21-vref"},
2590         {.id = ALC889_FIXUP_MP11_VREF, .name = "mp11-vref"},
2591         {.id = ALC889_FIXUP_MP41_VREF, .name = "mp41-vref"},
2592         {.id = ALC882_FIXUP_INV_DMIC, .name = "inv-dmic"},
2593         {.id = ALC882_FIXUP_NO_PRIMARY_HP, .name = "no-primary-hp"},
2594         {.id = ALC887_FIXUP_ASUS_BASS, .name = "asus-bass"},
2595         {.id = ALC1220_FIXUP_GB_DUAL_CODECS, .name = "dual-codecs"},
2596         {.id = ALC1220_FIXUP_CLEVO_P950, .name = "clevo-p950"},
2597         {}
2598 };
2599
2600 static const struct snd_hda_pin_quirk alc882_pin_fixup_tbl[] = {
2601         SND_HDA_PIN_QUIRK(0x10ec1220, 0x1043, "ASUS", ALC1220_FIXUP_CLEVO_P950,
2602                 {0x14, 0x01014010},
2603                 {0x15, 0x01011012},
2604                 {0x16, 0x01016011},
2605                 {0x18, 0x01a19040},
2606                 {0x19, 0x02a19050},
2607                 {0x1a, 0x0181304f},
2608                 {0x1b, 0x0221401f},
2609                 {0x1e, 0x01456130}),
2610         SND_HDA_PIN_QUIRK(0x10ec1220, 0x1462, "MS-7C35", ALC1220_FIXUP_CLEVO_P950,
2611                 {0x14, 0x01015010},
2612                 {0x15, 0x01011012},
2613                 {0x16, 0x01011011},
2614                 {0x18, 0x01a11040},
2615                 {0x19, 0x02a19050},
2616                 {0x1a, 0x0181104f},
2617                 {0x1b, 0x0221401f},
2618                 {0x1e, 0x01451130}),
2619         {}
2620 };
2621
2622 /*
2623  * BIOS auto configuration
2624  */
2625 /* almost identical with ALC880 parser... */
2626 static int alc882_parse_auto_config(struct hda_codec *codec)
2627 {
2628         static const hda_nid_t alc882_ignore[] = { 0x1d, 0 };
2629         static const hda_nid_t alc882_ssids[] = { 0x15, 0x1b, 0x14, 0 };
2630         return alc_parse_auto_config(codec, alc882_ignore, alc882_ssids);
2631 }
2632
2633 /*
2634  */
2635 static int patch_alc882(struct hda_codec *codec)
2636 {
2637         struct alc_spec *spec;
2638         int err;
2639
2640         err = alc_alloc_spec(codec, 0x0b);
2641         if (err < 0)
2642                 return err;
2643
2644         spec = codec->spec;
2645
2646         switch (codec->core.vendor_id) {
2647         case 0x10ec0882:
2648         case 0x10ec0885:
2649         case 0x10ec0900:
2650         case 0x10ec0b00:
2651         case 0x10ec1220:
2652                 break;
2653         default:
2654                 /* ALC883 and variants */
2655                 alc_fix_pll_init(codec, 0x20, 0x0a, 10);
2656                 break;
2657         }
2658
2659         alc_pre_init(codec);
2660
2661         snd_hda_pick_fixup(codec, alc882_fixup_models, alc882_fixup_tbl,
2662                        alc882_fixups);
2663         snd_hda_pick_pin_fixup(codec, alc882_pin_fixup_tbl, alc882_fixups, true);
2664         snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE);
2665
2666         alc_auto_parse_customize_define(codec);
2667
2668         if (has_cdefine_beep(codec))
2669                 spec->gen.beep_nid = 0x01;
2670
2671         /* automatic parse from the BIOS config */
2672         err = alc882_parse_auto_config(codec);
2673         if (err < 0)
2674                 goto error;
2675
2676         if (!spec->gen.no_analog && spec->gen.beep_nid) {
2677                 err = set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
2678                 if (err < 0)
2679                         goto error;
2680         }
2681
2682         snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE);
2683
2684         return 0;
2685
2686  error:
2687         alc_free(codec);
2688         return err;
2689 }
2690
2691
2692 /*
2693  * ALC262 support
2694  */
2695 static int alc262_parse_auto_config(struct hda_codec *codec)
2696 {
2697         static const hda_nid_t alc262_ignore[] = { 0x1d, 0 };
2698         static const hda_nid_t alc262_ssids[] = { 0x15, 0x1b, 0x14, 0 };
2699         return alc_parse_auto_config(codec, alc262_ignore, alc262_ssids);
2700 }
2701
2702 /*
2703  * Pin config fixes
2704  */
2705 enum {
2706         ALC262_FIXUP_FSC_H270,
2707         ALC262_FIXUP_FSC_S7110,
2708         ALC262_FIXUP_HP_Z200,
2709         ALC262_FIXUP_TYAN,
2710         ALC262_FIXUP_LENOVO_3000,
2711         ALC262_FIXUP_BENQ,
2712         ALC262_FIXUP_BENQ_T31,
2713         ALC262_FIXUP_INV_DMIC,
2714         ALC262_FIXUP_INTEL_BAYLEYBAY,
2715 };
2716
2717 static const struct hda_fixup alc262_fixups[] = {
2718         [ALC262_FIXUP_FSC_H270] = {
2719                 .type = HDA_FIXUP_PINS,
2720                 .v.pins = (const struct hda_pintbl[]) {
2721                         { 0x14, 0x99130110 }, /* speaker */
2722                         { 0x15, 0x0221142f }, /* front HP */
2723                         { 0x1b, 0x0121141f }, /* rear HP */
2724                         { }
2725                 }
2726         },
2727         [ALC262_FIXUP_FSC_S7110] = {
2728                 .type = HDA_FIXUP_PINS,
2729                 .v.pins = (const struct hda_pintbl[]) {
2730                         { 0x15, 0x90170110 }, /* speaker */
2731                         { }
2732                 },
2733                 .chained = true,
2734                 .chain_id = ALC262_FIXUP_BENQ,
2735         },
2736         [ALC262_FIXUP_HP_Z200] = {
2737                 .type = HDA_FIXUP_PINS,
2738                 .v.pins = (const struct hda_pintbl[]) {
2739                         { 0x16, 0x99130120 }, /* internal speaker */
2740                         { }
2741                 }
2742         },
2743         [ALC262_FIXUP_TYAN] = {
2744                 .type = HDA_FIXUP_PINS,
2745                 .v.pins = (const struct hda_pintbl[]) {
2746                         { 0x14, 0x1993e1f0 }, /* int AUX */
2747                         { }
2748                 }
2749         },
2750         [ALC262_FIXUP_LENOVO_3000] = {
2751                 .type = HDA_FIXUP_PINCTLS,
2752                 .v.pins = (const struct hda_pintbl[]) {
2753                         { 0x19, PIN_VREF50 },
2754                         {}
2755                 },
2756                 .chained = true,
2757                 .chain_id = ALC262_FIXUP_BENQ,
2758         },
2759         [ALC262_FIXUP_BENQ] = {
2760                 .type = HDA_FIXUP_VERBS,
2761                 .v.verbs = (const struct hda_verb[]) {
2762                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x07 },
2763                         { 0x20, AC_VERB_SET_PROC_COEF, 0x3070 },
2764                         {}
2765                 }
2766         },
2767         [ALC262_FIXUP_BENQ_T31] = {
2768                 .type = HDA_FIXUP_VERBS,
2769                 .v.verbs = (const struct hda_verb[]) {
2770                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x07 },
2771                         { 0x20, AC_VERB_SET_PROC_COEF, 0x3050 },
2772                         {}
2773                 }
2774         },
2775         [ALC262_FIXUP_INV_DMIC] = {
2776                 .type = HDA_FIXUP_FUNC,
2777                 .v.func = alc_fixup_inv_dmic,
2778         },
2779         [ALC262_FIXUP_INTEL_BAYLEYBAY] = {
2780                 .type = HDA_FIXUP_FUNC,
2781                 .v.func = alc_fixup_no_depop_delay,
2782         },
2783 };
2784
2785 static const struct snd_pci_quirk alc262_fixup_tbl[] = {
2786         SND_PCI_QUIRK(0x103c, 0x170b, "HP Z200", ALC262_FIXUP_HP_Z200),
2787         SND_PCI_QUIRK(0x10cf, 0x1397, "Fujitsu Lifebook S7110", ALC262_FIXUP_FSC_S7110),
2788         SND_PCI_QUIRK(0x10cf, 0x142d, "Fujitsu Lifebook E8410", ALC262_FIXUP_BENQ),
2789         SND_PCI_QUIRK(0x10f1, 0x2915, "Tyan Thunder n6650W", ALC262_FIXUP_TYAN),
2790         SND_PCI_QUIRK(0x1734, 0x1141, "FSC ESPRIMO U9210", ALC262_FIXUP_FSC_H270),
2791         SND_PCI_QUIRK(0x1734, 0x1147, "FSC Celsius H270", ALC262_FIXUP_FSC_H270),
2792         SND_PCI_QUIRK(0x17aa, 0x384e, "Lenovo 3000", ALC262_FIXUP_LENOVO_3000),
2793         SND_PCI_QUIRK(0x17ff, 0x0560, "Benq ED8", ALC262_FIXUP_BENQ),
2794         SND_PCI_QUIRK(0x17ff, 0x058d, "Benq T31-16", ALC262_FIXUP_BENQ_T31),
2795         SND_PCI_QUIRK(0x8086, 0x7270, "BayleyBay", ALC262_FIXUP_INTEL_BAYLEYBAY),
2796         {}
2797 };
2798
2799 static const struct hda_model_fixup alc262_fixup_models[] = {
2800         {.id = ALC262_FIXUP_INV_DMIC, .name = "inv-dmic"},
2801         {.id = ALC262_FIXUP_FSC_H270, .name = "fsc-h270"},
2802         {.id = ALC262_FIXUP_FSC_S7110, .name = "fsc-s7110"},
2803         {.id = ALC262_FIXUP_HP_Z200, .name = "hp-z200"},
2804         {.id = ALC262_FIXUP_TYAN, .name = "tyan"},
2805         {.id = ALC262_FIXUP_LENOVO_3000, .name = "lenovo-3000"},
2806         {.id = ALC262_FIXUP_BENQ, .name = "benq"},
2807         {.id = ALC262_FIXUP_BENQ_T31, .name = "benq-t31"},
2808         {.id = ALC262_FIXUP_INTEL_BAYLEYBAY, .name = "bayleybay"},
2809         {}
2810 };
2811
2812 /*
2813  */
2814 static int patch_alc262(struct hda_codec *codec)
2815 {
2816         struct alc_spec *spec;
2817         int err;
2818
2819         err = alc_alloc_spec(codec, 0x0b);
2820         if (err < 0)
2821                 return err;
2822
2823         spec = codec->spec;
2824         spec->gen.shared_mic_vref_pin = 0x18;
2825
2826         spec->shutup = alc_eapd_shutup;
2827
2828 #if 0
2829         /* pshou 07/11/05  set a zero PCM sample to DAC when FIFO is
2830          * under-run
2831          */
2832         alc_update_coefex_idx(codec, 0x1a, 7, 0, 0x80);
2833 #endif
2834         alc_fix_pll_init(codec, 0x20, 0x0a, 10);
2835
2836         alc_pre_init(codec);
2837
2838         snd_hda_pick_fixup(codec, alc262_fixup_models, alc262_fixup_tbl,
2839                        alc262_fixups);
2840         snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE);
2841
2842         alc_auto_parse_customize_define(codec);
2843
2844         if (has_cdefine_beep(codec))
2845                 spec->gen.beep_nid = 0x01;
2846
2847         /* automatic parse from the BIOS config */
2848         err = alc262_parse_auto_config(codec);
2849         if (err < 0)
2850                 goto error;
2851
2852         if (!spec->gen.no_analog && spec->gen.beep_nid) {
2853                 err = set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
2854                 if (err < 0)
2855                         goto error;
2856         }
2857
2858         snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE);
2859
2860         return 0;
2861
2862  error:
2863         alc_free(codec);
2864         return err;
2865 }
2866
2867 /*
2868  *  ALC268
2869  */
2870 /* bind Beep switches of both NID 0x0f and 0x10 */
2871 static int alc268_beep_switch_put(struct snd_kcontrol *kcontrol,
2872                                   struct snd_ctl_elem_value *ucontrol)
2873 {
2874         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2875         unsigned long pval;
2876         int err;
2877
2878         mutex_lock(&codec->control_mutex);
2879         pval = kcontrol->private_value;
2880         kcontrol->private_value = (pval & ~0xff) | 0x0f;
2881         err = snd_hda_mixer_amp_switch_put(kcontrol, ucontrol);
2882         if (err >= 0) {
2883                 kcontrol->private_value = (pval & ~0xff) | 0x10;
2884                 err = snd_hda_mixer_amp_switch_put(kcontrol, ucontrol);
2885         }
2886         kcontrol->private_value = pval;
2887         mutex_unlock(&codec->control_mutex);
2888         return err;
2889 }
2890
2891 static const struct snd_kcontrol_new alc268_beep_mixer[] = {
2892         HDA_CODEC_VOLUME("Beep Playback Volume", 0x1d, 0x0, HDA_INPUT),
2893         {
2894                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2895                 .name = "Beep Playback Switch",
2896                 .subdevice = HDA_SUBDEV_AMP_FLAG,
2897                 .info = snd_hda_mixer_amp_switch_info,
2898                 .get = snd_hda_mixer_amp_switch_get,
2899                 .put = alc268_beep_switch_put,
2900                 .private_value = HDA_COMPOSE_AMP_VAL(0x0f, 3, 1, HDA_INPUT)
2901         },
2902 };
2903
2904 /* set PCBEEP vol = 0, mute connections */
2905 static const struct hda_verb alc268_beep_init_verbs[] = {
2906         {0x1d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
2907         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
2908         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
2909         { }
2910 };
2911
2912 enum {
2913         ALC268_FIXUP_INV_DMIC,
2914         ALC268_FIXUP_HP_EAPD,
2915         ALC268_FIXUP_SPDIF,
2916 };
2917
2918 static const struct hda_fixup alc268_fixups[] = {
2919         [ALC268_FIXUP_INV_DMIC] = {
2920                 .type = HDA_FIXUP_FUNC,
2921                 .v.func = alc_fixup_inv_dmic,
2922         },
2923         [ALC268_FIXUP_HP_EAPD] = {
2924                 .type = HDA_FIXUP_VERBS,
2925                 .v.verbs = (const struct hda_verb[]) {
2926                         {0x15, AC_VERB_SET_EAPD_BTLENABLE, 0},
2927                         {}
2928                 }
2929         },
2930         [ALC268_FIXUP_SPDIF] = {
2931                 .type = HDA_FIXUP_PINS,
2932                 .v.pins = (const struct hda_pintbl[]) {
2933                         { 0x1e, 0x014b1180 }, /* enable SPDIF out */
2934                         {}
2935                 }
2936         },
2937 };
2938
2939 static const struct hda_model_fixup alc268_fixup_models[] = {
2940         {.id = ALC268_FIXUP_INV_DMIC, .name = "inv-dmic"},
2941         {.id = ALC268_FIXUP_HP_EAPD, .name = "hp-eapd"},
2942         {.id = ALC268_FIXUP_SPDIF, .name = "spdif"},
2943         {}
2944 };
2945
2946 static const struct snd_pci_quirk alc268_fixup_tbl[] = {
2947         SND_PCI_QUIRK(0x1025, 0x0139, "Acer TravelMate 6293", ALC268_FIXUP_SPDIF),
2948         SND_PCI_QUIRK(0x1025, 0x015b, "Acer AOA 150 (ZG5)", ALC268_FIXUP_INV_DMIC),
2949         /* below is codec SSID since multiple Toshiba laptops have the
2950          * same PCI SSID 1179:ff00
2951          */
2952         SND_PCI_QUIRK(0x1179, 0xff06, "Toshiba P200", ALC268_FIXUP_HP_EAPD),
2953         {}
2954 };
2955
2956 /*
2957  * BIOS auto configuration
2958  */
2959 static int alc268_parse_auto_config(struct hda_codec *codec)
2960 {
2961         static const hda_nid_t alc268_ssids[] = { 0x15, 0x1b, 0x14, 0 };
2962         return alc_parse_auto_config(codec, NULL, alc268_ssids);
2963 }
2964
2965 /*
2966  */
2967 static int patch_alc268(struct hda_codec *codec)
2968 {
2969         struct alc_spec *spec;
2970         int i, err;
2971
2972         /* ALC268 has no aa-loopback mixer */
2973         err = alc_alloc_spec(codec, 0);
2974         if (err < 0)
2975                 return err;
2976
2977         spec = codec->spec;
2978         if (has_cdefine_beep(codec))
2979                 spec->gen.beep_nid = 0x01;
2980
2981         spec->shutup = alc_eapd_shutup;
2982
2983         alc_pre_init(codec);
2984
2985         snd_hda_pick_fixup(codec, alc268_fixup_models, alc268_fixup_tbl, alc268_fixups);
2986         snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE);
2987
2988         /* automatic parse from the BIOS config */
2989         err = alc268_parse_auto_config(codec);
2990         if (err < 0)
2991                 goto error;
2992
2993         if (err > 0 && !spec->gen.no_analog &&
2994             spec->gen.autocfg.speaker_pins[0] != 0x1d) {
2995                 for (i = 0; i < ARRAY_SIZE(alc268_beep_mixer); i++) {
2996                         if (!snd_hda_gen_add_kctl(&spec->gen, NULL,
2997                                                   &alc268_beep_mixer[i])) {
2998                                 err = -ENOMEM;
2999                                 goto error;
3000                         }
3001                 }
3002                 snd_hda_add_verbs(codec, alc268_beep_init_verbs);
3003                 if (!query_amp_caps(codec, 0x1d, HDA_INPUT))
3004                         /* override the amp caps for beep generator */
3005                         snd_hda_override_amp_caps(codec, 0x1d, HDA_INPUT,
3006                                           (0x0c << AC_AMPCAP_OFFSET_SHIFT) |
3007                                           (0x0c << AC_AMPCAP_NUM_STEPS_SHIFT) |
3008                                           (0x07 << AC_AMPCAP_STEP_SIZE_SHIFT) |
3009                                           (0 << AC_AMPCAP_MUTE_SHIFT));
3010         }
3011
3012         snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE);
3013
3014         return 0;
3015
3016  error:
3017         alc_free(codec);
3018         return err;
3019 }
3020
3021 /*
3022  * ALC269
3023  */
3024
3025 static const struct hda_pcm_stream alc269_44k_pcm_analog_playback = {
3026         .rates = SNDRV_PCM_RATE_44100, /* fixed rate */
3027 };
3028
3029 static const struct hda_pcm_stream alc269_44k_pcm_analog_capture = {
3030         .rates = SNDRV_PCM_RATE_44100, /* fixed rate */
3031 };
3032
3033 /* different alc269-variants */
3034 enum {
3035         ALC269_TYPE_ALC269VA,
3036         ALC269_TYPE_ALC269VB,
3037         ALC269_TYPE_ALC269VC,
3038         ALC269_TYPE_ALC269VD,
3039         ALC269_TYPE_ALC280,
3040         ALC269_TYPE_ALC282,
3041         ALC269_TYPE_ALC283,
3042         ALC269_TYPE_ALC284,
3043         ALC269_TYPE_ALC293,
3044         ALC269_TYPE_ALC286,
3045         ALC269_TYPE_ALC298,
3046         ALC269_TYPE_ALC255,
3047         ALC269_TYPE_ALC256,
3048         ALC269_TYPE_ALC257,
3049         ALC269_TYPE_ALC215,
3050         ALC269_TYPE_ALC225,
3051         ALC269_TYPE_ALC287,
3052         ALC269_TYPE_ALC294,
3053         ALC269_TYPE_ALC300,
3054         ALC269_TYPE_ALC623,
3055         ALC269_TYPE_ALC700,
3056 };
3057
3058 /*
3059  * BIOS auto configuration
3060  */
3061 static int alc269_parse_auto_config(struct hda_codec *codec)
3062 {
3063         static const hda_nid_t alc269_ignore[] = { 0x1d, 0 };
3064         static const hda_nid_t alc269_ssids[] = { 0, 0x1b, 0x14, 0x21 };
3065         static const hda_nid_t alc269va_ssids[] = { 0x15, 0x1b, 0x14, 0 };
3066         struct alc_spec *spec = codec->spec;
3067         const hda_nid_t *ssids;
3068
3069         switch (spec->codec_variant) {
3070         case ALC269_TYPE_ALC269VA:
3071         case ALC269_TYPE_ALC269VC:
3072         case ALC269_TYPE_ALC280:
3073         case ALC269_TYPE_ALC284:
3074         case ALC269_TYPE_ALC293:
3075                 ssids = alc269va_ssids;
3076                 break;
3077         case ALC269_TYPE_ALC269VB:
3078         case ALC269_TYPE_ALC269VD:
3079         case ALC269_TYPE_ALC282:
3080         case ALC269_TYPE_ALC283:
3081         case ALC269_TYPE_ALC286:
3082         case ALC269_TYPE_ALC298:
3083         case ALC269_TYPE_ALC255:
3084         case ALC269_TYPE_ALC256:
3085         case ALC269_TYPE_ALC257:
3086         case ALC269_TYPE_ALC215:
3087         case ALC269_TYPE_ALC225:
3088         case ALC269_TYPE_ALC287:
3089         case ALC269_TYPE_ALC294:
3090         case ALC269_TYPE_ALC300:
3091         case ALC269_TYPE_ALC623:
3092         case ALC269_TYPE_ALC700:
3093                 ssids = alc269_ssids;
3094                 break;
3095         default:
3096                 ssids = alc269_ssids;
3097                 break;
3098         }
3099
3100         return alc_parse_auto_config(codec, alc269_ignore, ssids);
3101 }
3102
3103 static const struct hda_jack_keymap alc_headset_btn_keymap[] = {
3104         { SND_JACK_BTN_0, KEY_PLAYPAUSE },
3105         { SND_JACK_BTN_1, KEY_VOICECOMMAND },
3106         { SND_JACK_BTN_2, KEY_VOLUMEUP },
3107         { SND_JACK_BTN_3, KEY_VOLUMEDOWN },
3108         {}
3109 };
3110
3111 static void alc_headset_btn_callback(struct hda_codec *codec,
3112                                      struct hda_jack_callback *jack)
3113 {
3114         int report = 0;
3115
3116         if (jack->unsol_res & (7 << 13))
3117                 report |= SND_JACK_BTN_0;
3118
3119         if (jack->unsol_res  & (1 << 16 | 3 << 8))
3120                 report |= SND_JACK_BTN_1;
3121
3122         /* Volume up key */
3123         if (jack->unsol_res & (7 << 23))
3124                 report |= SND_JACK_BTN_2;
3125
3126         /* Volume down key */
3127         if (jack->unsol_res & (7 << 10))
3128                 report |= SND_JACK_BTN_3;
3129
3130         snd_hda_jack_set_button_state(codec, jack->nid, report);
3131 }
3132
3133 static void alc_disable_headset_jack_key(struct hda_codec *codec)
3134 {
3135         struct alc_spec *spec = codec->spec;
3136
3137         if (!spec->has_hs_key)
3138                 return;
3139
3140         switch (codec->core.vendor_id) {
3141         case 0x10ec0215:
3142         case 0x10ec0225:
3143         case 0x10ec0285:
3144         case 0x10ec0287:
3145         case 0x10ec0295:
3146         case 0x10ec0289:
3147         case 0x10ec0299:
3148                 alc_write_coef_idx(codec, 0x48, 0x0);
3149                 alc_update_coef_idx(codec, 0x49, 0x0045, 0x0);
3150                 alc_update_coef_idx(codec, 0x44, 0x0045 << 8, 0x0);
3151                 break;
3152         case 0x10ec0230:
3153         case 0x10ec0236:
3154         case 0x10ec0256:
3155                 alc_write_coef_idx(codec, 0x48, 0x0);
3156                 alc_update_coef_idx(codec, 0x49, 0x0045, 0x0);
3157                 break;
3158         }
3159 }
3160
3161 static void alc_enable_headset_jack_key(struct hda_codec *codec)
3162 {
3163         struct alc_spec *spec = codec->spec;
3164
3165         if (!spec->has_hs_key)
3166                 return;
3167
3168         switch (codec->core.vendor_id) {
3169         case 0x10ec0215:
3170         case 0x10ec0225:
3171         case 0x10ec0285:
3172         case 0x10ec0287:
3173         case 0x10ec0295:
3174         case 0x10ec0289:
3175         case 0x10ec0299:
3176                 alc_write_coef_idx(codec, 0x48, 0xd011);
3177                 alc_update_coef_idx(codec, 0x49, 0x007f, 0x0045);
3178                 alc_update_coef_idx(codec, 0x44, 0x007f << 8, 0x0045 << 8);
3179                 break;
3180         case 0x10ec0230:
3181         case 0x10ec0236:
3182         case 0x10ec0256:
3183                 alc_write_coef_idx(codec, 0x48, 0xd011);
3184                 alc_update_coef_idx(codec, 0x49, 0x007f, 0x0045);
3185                 break;
3186         }
3187 }
3188
3189 static void alc_fixup_headset_jack(struct hda_codec *codec,
3190                                     const struct hda_fixup *fix, int action)
3191 {
3192         struct alc_spec *spec = codec->spec;
3193         hda_nid_t hp_pin;
3194
3195         switch (action) {
3196         case HDA_FIXUP_ACT_PRE_PROBE:
3197                 spec->has_hs_key = 1;
3198                 snd_hda_jack_detect_enable_callback(codec, 0x55,
3199                                                     alc_headset_btn_callback);
3200                 break;
3201         case HDA_FIXUP_ACT_BUILD:
3202                 hp_pin = alc_get_hp_pin(spec);
3203                 if (!hp_pin || snd_hda_jack_bind_keymap(codec, 0x55,
3204                                                         alc_headset_btn_keymap,
3205                                                         hp_pin))
3206                         snd_hda_jack_add_kctl(codec, 0x55, "Headset Jack",
3207                                               false, SND_JACK_HEADSET,
3208                                               alc_headset_btn_keymap);
3209
3210                 alc_enable_headset_jack_key(codec);
3211                 break;
3212         }
3213 }
3214
3215 static void alc269vb_toggle_power_output(struct hda_codec *codec, int power_up)
3216 {
3217         alc_update_coef_idx(codec, 0x04, 1 << 11, power_up ? (1 << 11) : 0);
3218 }
3219
3220 static void alc269_shutup(struct hda_codec *codec)
3221 {
3222         struct alc_spec *spec = codec->spec;
3223
3224         if (spec->codec_variant == ALC269_TYPE_ALC269VB)
3225                 alc269vb_toggle_power_output(codec, 0);
3226         if (spec->codec_variant == ALC269_TYPE_ALC269VB &&
3227                         (alc_get_coef0(codec) & 0x00ff) == 0x018) {
3228                 msleep(150);
3229         }
3230         alc_shutup_pins(codec);
3231 }
3232
3233 static const struct coef_fw alc282_coefs[] = {
3234         WRITE_COEF(0x03, 0x0002), /* Power Down Control */
3235         UPDATE_COEF(0x05, 0xff3f, 0x0700), /* FIFO and filter clock */
3236         WRITE_COEF(0x07, 0x0200), /* DMIC control */
3237         UPDATE_COEF(0x06, 0x00f0, 0), /* Analog clock */
3238         UPDATE_COEF(0x08, 0xfffc, 0x0c2c), /* JD */
3239         WRITE_COEF(0x0a, 0xcccc), /* JD offset1 */
3240         WRITE_COEF(0x0b, 0xcccc), /* JD offset2 */
3241         WRITE_COEF(0x0e, 0x6e00), /* LDO1/2/3, DAC/ADC */
3242         UPDATE_COEF(0x0f, 0xf800, 0x1000), /* JD */
3243         UPDATE_COEF(0x10, 0xfc00, 0x0c00), /* Capless */
3244         WRITE_COEF(0x6f, 0x0), /* Class D test 4 */
3245         UPDATE_COEF(0x0c, 0xfe00, 0), /* IO power down directly */
3246         WRITE_COEF(0x34, 0xa0c0), /* ANC */
3247         UPDATE_COEF(0x16, 0x0008, 0), /* AGC MUX */
3248         UPDATE_COEF(0x1d, 0x00e0, 0), /* DAC simple content protection */
3249         UPDATE_COEF(0x1f, 0x00e0, 0), /* ADC simple content protection */
3250         WRITE_COEF(0x21, 0x8804), /* DAC ADC Zero Detection */
3251         WRITE_COEF(0x63, 0x2902), /* PLL */
3252         WRITE_COEF(0x68, 0xa080), /* capless control 2 */
3253         WRITE_COEF(0x69, 0x3400), /* capless control 3 */
3254         WRITE_COEF(0x6a, 0x2f3e), /* capless control 4 */
3255         WRITE_COEF(0x6b, 0x0), /* capless control 5 */
3256         UPDATE_COEF(0x6d, 0x0fff, 0x0900), /* class D test 2 */
3257         WRITE_COEF(0x6e, 0x110a), /* class D test 3 */
3258         UPDATE_COEF(0x70, 0x00f8, 0x00d8), /* class D test 5 */
3259         WRITE_COEF(0x71, 0x0014), /* class D test 6 */
3260         WRITE_COEF(0x72, 0xc2ba), /* classD OCP */
3261         UPDATE_COEF(0x77, 0x0f80, 0), /* classD pure DC test */
3262         WRITE_COEF(0x6c, 0xfc06), /* Class D amp control */
3263         {}
3264 };
3265
3266 static void alc282_restore_default_value(struct hda_codec *codec)
3267 {
3268         alc_process_coef_fw(codec, alc282_coefs);
3269 }
3270
3271 static void alc282_init(struct hda_codec *codec)
3272 {
3273         struct alc_spec *spec = codec->spec;
3274         hda_nid_t hp_pin = alc_get_hp_pin(spec);
3275         bool hp_pin_sense;
3276         int coef78;
3277
3278         alc282_restore_default_value(codec);
3279
3280         if (!hp_pin)
3281                 return;
3282         hp_pin_sense = snd_hda_jack_detect(codec, hp_pin);
3283         coef78 = alc_read_coef_idx(codec, 0x78);
3284
3285         /* Index 0x78 Direct Drive HP AMP LPM Control 1 */
3286         /* Headphone capless set to high power mode */
3287         alc_write_coef_idx(codec, 0x78, 0x9004);
3288
3289         if (hp_pin_sense)
3290                 msleep(2);
3291
3292         snd_hda_codec_write(codec, hp_pin, 0,
3293                             AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);
3294
3295         if (hp_pin_sense)
3296                 msleep(85);
3297
3298         snd_hda_codec_write(codec, hp_pin, 0,
3299                             AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT);
3300
3301         if (hp_pin_sense)
3302                 msleep(100);
3303
3304         /* Headphone capless set to normal mode */
3305         alc_write_coef_idx(codec, 0x78, coef78);
3306 }
3307
3308 static void alc282_shutup(struct hda_codec *codec)
3309 {
3310         struct alc_spec *spec = codec->spec;
3311         hda_nid_t hp_pin = alc_get_hp_pin(spec);
3312         bool hp_pin_sense;
3313         int coef78;
3314
3315         if (!hp_pin) {
3316                 alc269_shutup(codec);
3317                 return;
3318         }
3319
3320         hp_pin_sense = snd_hda_jack_detect(codec, hp_pin);
3321         coef78 = alc_read_coef_idx(codec, 0x78);
3322         alc_write_coef_idx(codec, 0x78, 0x9004);
3323
3324         if (hp_pin_sense)
3325                 msleep(2);
3326
3327         snd_hda_codec_write(codec, hp_pin, 0,
3328                             AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);
3329
3330         if (hp_pin_sense)
3331                 msleep(85);
3332
3333         if (!spec->no_shutup_pins)
3334                 snd_hda_codec_write(codec, hp_pin, 0,
3335                                     AC_VERB_SET_PIN_WIDGET_CONTROL, 0x0);
3336
3337         if (hp_pin_sense)
3338                 msleep(100);
3339
3340         alc_auto_setup_eapd(codec, false);
3341         alc_shutup_pins(codec);
3342         alc_write_coef_idx(codec, 0x78, coef78);
3343 }
3344
3345 static const struct coef_fw alc283_coefs[] = {
3346         WRITE_COEF(0x03, 0x0002), /* Power Down Control */
3347         UPDATE_COEF(0x05, 0xff3f, 0x0700), /* FIFO and filter clock */
3348         WRITE_COEF(0x07, 0x0200), /* DMIC control */
3349         UPDATE_COEF(0x06, 0x00f0, 0), /* Analog clock */
3350         UPDATE_COEF(0x08, 0xfffc, 0x0c2c), /* JD */
3351         WRITE_COEF(0x0a, 0xcccc), /* JD offset1 */
3352         WRITE_COEF(0x0b, 0xcccc), /* JD offset2 */
3353         WRITE_COEF(0x0e, 0x6fc0), /* LDO1/2/3, DAC/ADC */
3354         UPDATE_COEF(0x0f, 0xf800, 0x1000), /* JD */
3355         UPDATE_COEF(0x10, 0xfc00, 0x0c00), /* Capless */
3356         WRITE_COEF(0x3a, 0x0), /* Class D test 4 */
3357         UPDATE_COEF(0x0c, 0xfe00, 0x0), /* IO power down directly */
3358         WRITE_COEF(0x22, 0xa0c0), /* ANC */
3359         UPDATE_COEFEX(0x53, 0x01, 0x000f, 0x0008), /* AGC MUX */
3360         UPDATE_COEF(0x1d, 0x00e0, 0), /* DAC simple content protection */
3361         UPDATE_COEF(0x1f, 0x00e0, 0), /* ADC simple content protection */
3362         WRITE_COEF(0x21, 0x8804), /* DAC ADC Zero Detection */
3363         WRITE_COEF(0x2e, 0x2902), /* PLL */
3364         WRITE_COEF(0x33, 0xa080), /* capless control 2 */
3365         WRITE_COEF(0x34, 0x3400), /* capless control 3 */
3366         WRITE_COEF(0x35, 0x2f3e), /* capless control 4 */
3367         WRITE_COEF(0x36, 0x0), /* capless control 5 */
3368         UPDATE_COEF(0x38, 0x0fff, 0x0900), /* class D test 2 */
3369         WRITE_COEF(0x39, 0x110a), /* class D test 3 */
3370         UPDATE_COEF(0x3b, 0x00f8, 0x00d8), /* class D test 5 */
3371         WRITE_COEF(0x3c, 0x0014), /* class D test 6 */
3372         WRITE_COEF(0x3d, 0xc2ba), /* classD OCP */
3373         UPDATE_COEF(0x42, 0x0f80, 0x0), /* classD pure DC test */
3374         WRITE_COEF(0x49, 0x0), /* test mode */
3375         UPDATE_COEF(0x40, 0xf800, 0x9800), /* Class D DC enable */
3376         UPDATE_COEF(0x42, 0xf000, 0x2000), /* DC offset */
3377         WRITE_COEF(0x37, 0xfc06), /* Class D amp control */
3378         UPDATE_COEF(0x1b, 0x8000, 0), /* HP JD control */
3379         {}
3380 };
3381
3382 static void alc283_restore_default_value(struct hda_codec *codec)
3383 {
3384         alc_process_coef_fw(codec, alc283_coefs);
3385 }
3386
3387 static void alc283_init(struct hda_codec *codec)
3388 {
3389         struct alc_spec *spec = codec->spec;
3390         hda_nid_t hp_pin = alc_get_hp_pin(spec);
3391         bool hp_pin_sense;
3392
3393         alc283_restore_default_value(codec);
3394
3395         if (!hp_pin)
3396                 return;
3397
3398         msleep(30);
3399         hp_pin_sense = snd_hda_jack_detect(codec, hp_pin);
3400
3401         /* Index 0x43 Direct Drive HP AMP LPM Control 1 */
3402         /* Headphone capless set to high power mode */
3403         alc_write_coef_idx(codec, 0x43, 0x9004);
3404
3405         snd_hda_codec_write(codec, hp_pin, 0,
3406                             AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);
3407
3408         if (hp_pin_sense)
3409                 msleep(85);
3410
3411         snd_hda_codec_write(codec, hp_pin, 0,
3412                             AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT);
3413
3414         if (hp_pin_sense)
3415                 msleep(85);
3416         /* Index 0x46 Combo jack auto switch control 2 */
3417         /* 3k pull low control for Headset jack. */
3418         alc_update_coef_idx(codec, 0x46, 3 << 12, 0);
3419         /* Headphone capless set to normal mode */
3420         alc_write_coef_idx(codec, 0x43, 0x9614);
3421 }
3422
3423 static void alc283_shutup(struct hda_codec *codec)
3424 {
3425         struct alc_spec *spec = codec->spec;
3426         hda_nid_t hp_pin = alc_get_hp_pin(spec);
3427         bool hp_pin_sense;
3428
3429         if (!hp_pin) {
3430                 alc269_shutup(codec);
3431                 return;
3432         }
3433
3434         hp_pin_sense = snd_hda_jack_detect(codec, hp_pin);
3435
3436         alc_write_coef_idx(codec, 0x43, 0x9004);
3437
3438         /*depop hp during suspend*/
3439         alc_write_coef_idx(codec, 0x06, 0x2100);
3440
3441         snd_hda_codec_write(codec, hp_pin, 0,
3442                             AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);
3443
3444         if (hp_pin_sense)
3445                 msleep(100);
3446
3447         if (!spec->no_shutup_pins)
3448                 snd_hda_codec_write(codec, hp_pin, 0,
3449                                     AC_VERB_SET_PIN_WIDGET_CONTROL, 0x0);
3450
3451         alc_update_coef_idx(codec, 0x46, 0, 3 << 12);
3452
3453         if (hp_pin_sense)
3454                 msleep(100);
3455         alc_auto_setup_eapd(codec, false);
3456         alc_shutup_pins(codec);
3457         alc_write_coef_idx(codec, 0x43, 0x9614);
3458 }
3459
3460 static void alc256_init(struct hda_codec *codec)
3461 {
3462         struct alc_spec *spec = codec->spec;
3463         hda_nid_t hp_pin = alc_get_hp_pin(spec);
3464         bool hp_pin_sense;
3465
3466         if (!hp_pin)
3467                 hp_pin = 0x21;
3468
3469         msleep(30);
3470
3471         hp_pin_sense = snd_hda_jack_detect(codec, hp_pin);
3472
3473         if (hp_pin_sense)
3474                 msleep(2);
3475
3476         alc_update_coefex_idx(codec, 0x57, 0x04, 0x0007, 0x1); /* Low power */
3477         if (spec->ultra_low_power) {
3478                 alc_update_coef_idx(codec, 0x03, 1<<1, 1<<1);
3479                 alc_update_coef_idx(codec, 0x08, 3<<2, 3<<2);
3480                 alc_update_coef_idx(codec, 0x08, 7<<4, 0);
3481                 alc_update_coef_idx(codec, 0x3b, 1<<15, 0);
3482                 alc_update_coef_idx(codec, 0x0e, 7<<6, 7<<6);
3483                 msleep(30);
3484         }
3485
3486         snd_hda_codec_write(codec, hp_pin, 0,
3487                             AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);
3488
3489         if (hp_pin_sense || spec->ultra_low_power)
3490                 msleep(85);
3491
3492         snd_hda_codec_write(codec, hp_pin, 0,
3493                             AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT);
3494
3495         if (hp_pin_sense || spec->ultra_low_power)
3496                 msleep(100);
3497
3498         alc_update_coef_idx(codec, 0x46, 3 << 12, 0);
3499         alc_update_coefex_idx(codec, 0x57, 0x04, 0x0007, 0x4); /* Hight power */
3500         alc_update_coefex_idx(codec, 0x53, 0x02, 0x8000, 1 << 15); /* Clear bit */
3501         alc_update_coefex_idx(codec, 0x53, 0x02, 0x8000, 0 << 15);
3502         /*
3503          * Expose headphone mic (or possibly Line In on some machines) instead
3504          * of PC Beep on 1Ah, and disable 1Ah loopback for all outputs. See
3505          * Documentation/sound/hd-audio/realtek-pc-beep.rst for details of
3506          * this register.
3507          */
3508         alc_write_coef_idx(codec, 0x36, 0x5757);
3509 }
3510
3511 static void alc256_shutup(struct hda_codec *codec)
3512 {
3513         struct alc_spec *spec = codec->spec;
3514         hda_nid_t hp_pin = alc_get_hp_pin(spec);
3515         bool hp_pin_sense;
3516
3517         if (!hp_pin)
3518                 hp_pin = 0x21;
3519
3520         hp_pin_sense = snd_hda_jack_detect(codec, hp_pin);
3521
3522         if (hp_pin_sense)
3523                 msleep(2);
3524
3525         snd_hda_codec_write(codec, hp_pin, 0,
3526                             AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);
3527
3528         if (hp_pin_sense || spec->ultra_low_power)
3529                 msleep(85);
3530
3531         /* 3k pull low control for Headset jack. */
3532         /* NOTE: call this before clearing the pin, otherwise codec stalls */
3533         /* If disable 3k pulldown control for alc257, the Mic detection will not work correctly
3534          * when booting with headset plugged. So skip setting it for the codec alc257
3535          */
3536         if (spec->codec_variant != ALC269_TYPE_ALC257 &&
3537             spec->codec_variant != ALC269_TYPE_ALC256)
3538                 alc_update_coef_idx(codec, 0x46, 0, 3 << 12);
3539
3540         if (!spec->no_shutup_pins)
3541                 snd_hda_codec_write(codec, hp_pin, 0,
3542                                     AC_VERB_SET_PIN_WIDGET_CONTROL, 0x0);
3543
3544         if (hp_pin_sense || spec->ultra_low_power)
3545                 msleep(100);
3546
3547         alc_auto_setup_eapd(codec, false);
3548         alc_shutup_pins(codec);
3549         if (spec->ultra_low_power) {
3550                 msleep(50);
3551                 alc_update_coef_idx(codec, 0x03, 1<<1, 0);
3552                 alc_update_coef_idx(codec, 0x08, 7<<4, 7<<4);
3553                 alc_update_coef_idx(codec, 0x08, 3<<2, 0);
3554                 alc_update_coef_idx(codec, 0x3b, 1<<15, 1<<15);
3555                 alc_update_coef_idx(codec, 0x0e, 7<<6, 0);
3556                 msleep(30);
3557         }
3558 }
3559
3560 static void alc285_hp_init(struct hda_codec *codec)
3561 {
3562         struct alc_spec *spec = codec->spec;
3563         hda_nid_t hp_pin = alc_get_hp_pin(spec);
3564         int i, val;
3565         int coef38, coef0d, coef36;
3566
3567         alc_update_coef_idx(codec, 0x4a, 1<<15, 1<<15); /* Reset HP JD */
3568         coef38 = alc_read_coef_idx(codec, 0x38); /* Amp control */
3569         coef0d = alc_read_coef_idx(codec, 0x0d); /* Digital Misc control */
3570         coef36 = alc_read_coef_idx(codec, 0x36); /* Passthrough Control */
3571         alc_update_coef_idx(codec, 0x38, 1<<4, 0x0);
3572         alc_update_coef_idx(codec, 0x0d, 0x110, 0x0);
3573
3574         alc_update_coef_idx(codec, 0x67, 0xf000, 0x3000);
3575
3576         if (hp_pin)
3577                 snd_hda_codec_write(codec, hp_pin, 0,
3578                             AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);
3579
3580         msleep(130);
3581         alc_update_coef_idx(codec, 0x36, 1<<14, 1<<14);
3582         alc_update_coef_idx(codec, 0x36, 1<<13, 0x0);
3583
3584         if (hp_pin)
3585                 snd_hda_codec_write(codec, hp_pin, 0,
3586                             AC_VERB_SET_PIN_WIDGET_CONTROL, 0x0);
3587         msleep(10);
3588         alc_write_coef_idx(codec, 0x67, 0x0); /* Set HP depop to manual mode */
3589         alc_write_coefex_idx(codec, 0x58, 0x00, 0x7880);
3590         alc_write_coefex_idx(codec, 0x58, 0x0f, 0xf049);
3591         alc_update_coefex_idx(codec, 0x58, 0x03, 0x00f0, 0x00c0);
3592
3593         alc_write_coefex_idx(codec, 0x58, 0x00, 0xf888); /* HP depop procedure start */
3594         val = alc_read_coefex_idx(codec, 0x58, 0x00);
3595         for (i = 0; i < 20 && val & 0x8000; i++) {
3596                 msleep(50);
3597                 val = alc_read_coefex_idx(codec, 0x58, 0x00);
3598         } /* Wait for depop procedure finish  */
3599
3600         alc_write_coefex_idx(codec, 0x58, 0x00, val); /* write back the result */
3601         alc_update_coef_idx(codec, 0x38, 1<<4, coef38);
3602         alc_update_coef_idx(codec, 0x0d, 0x110, coef0d);
3603         alc_update_coef_idx(codec, 0x36, 3<<13, coef36);
3604
3605         msleep(50);
3606         alc_update_coef_idx(codec, 0x4a, 1<<15, 0);
3607 }
3608
3609 static void alc225_init(struct hda_codec *codec)
3610 {
3611         struct alc_spec *spec = codec->spec;
3612         hda_nid_t hp_pin = alc_get_hp_pin(spec);
3613         bool hp1_pin_sense, hp2_pin_sense;
3614
3615         if (spec->codec_variant != ALC269_TYPE_ALC287)
3616                 /* required only at boot or S3 and S4 resume time */
3617                 if (!spec->done_hp_init ||
3618                         is_s3_resume(codec) ||
3619                         is_s4_resume(codec)) {
3620                         alc285_hp_init(codec);
3621                         spec->done_hp_init = true;
3622                 }
3623
3624         if (!hp_pin)
3625                 hp_pin = 0x21;
3626         msleep(30);
3627
3628         hp1_pin_sense = snd_hda_jack_detect(codec, hp_pin);
3629         hp2_pin_sense = snd_hda_jack_detect(codec, 0x16);
3630
3631         if (hp1_pin_sense || hp2_pin_sense)
3632                 msleep(2);
3633
3634         alc_update_coefex_idx(codec, 0x57, 0x04, 0x0007, 0x1); /* Low power */
3635         if (spec->ultra_low_power) {
3636                 alc_update_coef_idx(codec, 0x08, 0x0f << 2, 3<<2);
3637                 alc_update_coef_idx(codec, 0x0e, 7<<6, 7<<6);
3638                 alc_update_coef_idx(codec, 0x33, 1<<11, 0);
3639                 msleep(30);
3640         }
3641
3642         if (hp1_pin_sense || spec->ultra_low_power)
3643                 snd_hda_codec_write(codec, hp_pin, 0,
3644                             AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);
3645         if (hp2_pin_sense)
3646                 snd_hda_codec_write(codec, 0x16, 0,
3647                             AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);
3648
3649         if (hp1_pin_sense || hp2_pin_sense || spec->ultra_low_power)
3650                 msleep(85);
3651
3652         if (hp1_pin_sense || spec->ultra_low_power)
3653                 snd_hda_codec_write(codec, hp_pin, 0,
3654                             AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT);
3655         if (hp2_pin_sense)
3656                 snd_hda_codec_write(codec, 0x16, 0,
3657                             AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT);
3658
3659         if (hp1_pin_sense || hp2_pin_sense || spec->ultra_low_power)
3660                 msleep(100);
3661
3662         alc_update_coef_idx(codec, 0x4a, 3 << 10, 0);
3663         alc_update_coefex_idx(codec, 0x57, 0x04, 0x0007, 0x4); /* Hight power */
3664 }
3665
3666 static void alc225_shutup(struct hda_codec *codec)
3667 {
3668         struct alc_spec *spec = codec->spec;
3669         hda_nid_t hp_pin = alc_get_hp_pin(spec);
3670         bool hp1_pin_sense, hp2_pin_sense;
3671
3672         if (!hp_pin)
3673                 hp_pin = 0x21;
3674
3675         alc_disable_headset_jack_key(codec);
3676         /* 3k pull low control for Headset jack. */
3677         alc_update_coef_idx(codec, 0x4a, 0, 3 << 10);
3678
3679         hp1_pin_sense = snd_hda_jack_detect(codec, hp_pin);
3680         hp2_pin_sense = snd_hda_jack_detect(codec, 0x16);
3681
3682         if (hp1_pin_sense || hp2_pin_sense)
3683                 msleep(2);
3684
3685         if (hp1_pin_sense || spec->ultra_low_power)
3686                 snd_hda_codec_write(codec, hp_pin, 0,
3687                             AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);
3688         if (hp2_pin_sense)
3689                 snd_hda_codec_write(codec, 0x16, 0,
3690                             AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);
3691
3692         if (hp1_pin_sense || hp2_pin_sense || spec->ultra_low_power)
3693                 msleep(85);
3694
3695         if (hp1_pin_sense || spec->ultra_low_power)
3696                 snd_hda_codec_write(codec, hp_pin, 0,
3697                             AC_VERB_SET_PIN_WIDGET_CONTROL, 0x0);
3698         if (hp2_pin_sense)
3699                 snd_hda_codec_write(codec, 0x16, 0,
3700                             AC_VERB_SET_PIN_WIDGET_CONTROL, 0x0);
3701
3702         if (hp1_pin_sense || hp2_pin_sense || spec->ultra_low_power)
3703                 msleep(100);
3704
3705         alc_auto_setup_eapd(codec, false);
3706         alc_shutup_pins(codec);
3707         if (spec->ultra_low_power) {
3708                 msleep(50);
3709                 alc_update_coef_idx(codec, 0x08, 0x0f << 2, 0x0c << 2);
3710                 alc_update_coef_idx(codec, 0x0e, 7<<6, 0);
3711                 alc_update_coef_idx(codec, 0x33, 1<<11, 1<<11);
3712                 alc_update_coef_idx(codec, 0x4a, 3<<4, 2<<4);
3713                 msleep(30);
3714         }
3715
3716         alc_update_coef_idx(codec, 0x4a, 3 << 10, 0);
3717         alc_enable_headset_jack_key(codec);
3718 }
3719
3720 static void alc_default_init(struct hda_codec *codec)
3721 {
3722         struct alc_spec *spec = codec->spec;
3723         hda_nid_t hp_pin = alc_get_hp_pin(spec);
3724         bool hp_pin_sense;
3725
3726         if (!hp_pin)
3727                 return;
3728
3729         msleep(30);
3730
3731         hp_pin_sense = snd_hda_jack_detect(codec, hp_pin);
3732
3733         if (hp_pin_sense)
3734                 msleep(2);
3735
3736         snd_hda_codec_write(codec, hp_pin, 0,
3737                             AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);
3738
3739         if (hp_pin_sense)
3740                 msleep(85);
3741
3742         snd_hda_codec_write(codec, hp_pin, 0,
3743                             AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT);
3744
3745         if (hp_pin_sense)
3746                 msleep(100);
3747 }
3748
3749 static void alc_default_shutup(struct hda_codec *codec)
3750 {
3751         struct alc_spec *spec = codec->spec;
3752         hda_nid_t hp_pin = alc_get_hp_pin(spec);
3753         bool hp_pin_sense;
3754
3755         if (!hp_pin) {
3756                 alc269_shutup(codec);
3757                 return;
3758         }
3759
3760         hp_pin_sense = snd_hda_jack_detect(codec, hp_pin);
3761
3762         if (hp_pin_sense)
3763                 msleep(2);
3764
3765         snd_hda_codec_write(codec, hp_pin, 0,
3766                             AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);
3767
3768         if (hp_pin_sense)
3769                 msleep(85);
3770
3771         if (!spec->no_shutup_pins)
3772                 snd_hda_codec_write(codec, hp_pin, 0,
3773                                     AC_VERB_SET_PIN_WIDGET_CONTROL, 0x0);
3774
3775         if (hp_pin_sense)
3776                 msleep(100);
3777
3778         alc_auto_setup_eapd(codec, false);
3779         alc_shutup_pins(codec);
3780 }
3781
3782 static void alc294_hp_init(struct hda_codec *codec)
3783 {
3784         struct alc_spec *spec = codec->spec;
3785         hda_nid_t hp_pin = alc_get_hp_pin(spec);
3786         int i, val;
3787
3788         if (!hp_pin)
3789                 return;
3790
3791         snd_hda_codec_write(codec, hp_pin, 0,
3792                             AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);
3793
3794         msleep(100);
3795
3796         if (!spec->no_shutup_pins)
3797                 snd_hda_codec_write(codec, hp_pin, 0,
3798                                     AC_VERB_SET_PIN_WIDGET_CONTROL, 0x0);
3799
3800         alc_update_coef_idx(codec, 0x6f, 0x000f, 0);/* Set HP depop to manual mode */
3801         alc_update_coefex_idx(codec, 0x58, 0x00, 0x8000, 0x8000); /* HP depop procedure start */
3802
3803         /* Wait for depop procedure finish  */
3804         val = alc_read_coefex_idx(codec, 0x58, 0x01);
3805         for (i = 0; i < 20 && val & 0x0080; i++) {
3806                 msleep(50);
3807                 val = alc_read_coefex_idx(codec, 0x58, 0x01);
3808         }
3809         /* Set HP depop to auto mode */
3810         alc_update_coef_idx(codec, 0x6f, 0x000f, 0x000b);
3811         msleep(50);
3812 }
3813
3814 static void alc294_init(struct hda_codec *codec)
3815 {
3816         struct alc_spec *spec = codec->spec;
3817
3818         /* required only at boot or S4 resume time */
3819         if (!spec->done_hp_init ||
3820             codec->core.dev.power.power_state.event == PM_EVENT_RESTORE) {
3821                 alc294_hp_init(codec);
3822                 spec->done_hp_init = true;
3823         }
3824         alc_default_init(codec);
3825 }
3826
3827 static void alc5505_coef_set(struct hda_codec *codec, unsigned int index_reg,
3828                              unsigned int val)
3829 {
3830         snd_hda_codec_write(codec, 0x51, 0, AC_VERB_SET_COEF_INDEX, index_reg >> 1);
3831         snd_hda_codec_write(codec, 0x51, 0, AC_VERB_SET_PROC_COEF, val & 0xffff); /* LSB */
3832         snd_hda_codec_write(codec, 0x51, 0, AC_VERB_SET_PROC_COEF, val >> 16); /* MSB */
3833 }
3834
3835 static int alc5505_coef_get(struct hda_codec *codec, unsigned int index_reg)
3836 {
3837         unsigned int val;
3838
3839         snd_hda_codec_write(codec, 0x51, 0, AC_VERB_SET_COEF_INDEX, index_reg >> 1);
3840         val = snd_hda_codec_read(codec, 0x51, 0, AC_VERB_GET_PROC_COEF, 0)
3841                 & 0xffff;
3842         val |= snd_hda_codec_read(codec, 0x51, 0, AC_VERB_GET_PROC_COEF, 0)
3843                 << 16;
3844         return val;
3845 }
3846
3847 static void alc5505_dsp_halt(struct hda_codec *codec)
3848 {
3849         unsigned int val;
3850
3851         alc5505_coef_set(codec, 0x3000, 0x000c); /* DSP CPU stop */
3852         alc5505_coef_set(codec, 0x880c, 0x0008); /* DDR enter self refresh */
3853         alc5505_coef_set(codec, 0x61c0, 0x11110080); /* Clock control for PLL and CPU */
3854         alc5505_coef_set(codec, 0x6230, 0xfc0d4011); /* Disable Input OP */
3855         alc5505_coef_set(codec, 0x61b4, 0x040a2b03); /* Stop PLL2 */
3856         alc5505_coef_set(codec, 0x61b0, 0x00005b17); /* Stop PLL1 */
3857         alc5505_coef_set(codec, 0x61b8, 0x04133303); /* Stop PLL3 */
3858         val = alc5505_coef_get(codec, 0x6220);
3859         alc5505_coef_set(codec, 0x6220, (val | 0x3000)); /* switch Ringbuffer clock to DBUS clock */
3860 }
3861
3862 static void alc5505_dsp_back_from_halt(struct hda_codec *codec)
3863 {
3864         alc5505_coef_set(codec, 0x61b8, 0x04133302);
3865         alc5505_coef_set(codec, 0x61b0, 0x00005b16);
3866         alc5505_coef_set(codec, 0x61b4, 0x040a2b02);
3867         alc5505_coef_set(codec, 0x6230, 0xf80d4011);
3868         alc5505_coef_set(codec, 0x6220, 0x2002010f);
3869         alc5505_coef_set(codec, 0x880c, 0x00000004);
3870 }
3871
3872 static void alc5505_dsp_init(struct hda_codec *codec)
3873 {
3874         unsigned int val;
3875
3876         alc5505_dsp_halt(codec);
3877         alc5505_dsp_back_from_halt(codec);
3878         alc5505_coef_set(codec, 0x61b0, 0x5b14); /* PLL1 control */
3879         alc5505_coef_set(codec, 0x61b0, 0x5b16);
3880         alc5505_coef_set(codec, 0x61b4, 0x04132b00); /* PLL2 control */
3881         alc5505_coef_set(codec, 0x61b4, 0x04132b02);
3882         alc5505_coef_set(codec, 0x61b8, 0x041f3300); /* PLL3 control*/
3883         alc5505_coef_set(codec, 0x61b8, 0x041f3302);
3884         snd_hda_codec_write(codec, 0x51, 0, AC_VERB_SET_CODEC_RESET, 0); /* Function reset */
3885         alc5505_coef_set(codec, 0x61b8, 0x041b3302);
3886         alc5505_coef_set(codec, 0x61b8, 0x04173302);
3887         alc5505_coef_set(codec, 0x61b8, 0x04163302);
3888         alc5505_coef_set(codec, 0x8800, 0x348b328b); /* DRAM control */
3889         alc5505_coef_set(codec, 0x8808, 0x00020022); /* DRAM control */
3890         alc5505_coef_set(codec, 0x8818, 0x00000400); /* DRAM control */
3891
3892         val = alc5505_coef_get(codec, 0x6200) >> 16; /* Read revision ID */
3893         if (val <= 3)
3894                 alc5505_coef_set(codec, 0x6220, 0x2002010f); /* I/O PAD Configuration */
3895         else
3896                 alc5505_coef_set(codec, 0x6220, 0x6002018f);
3897
3898         alc5505_coef_set(codec, 0x61ac, 0x055525f0); /**/
3899         alc5505_coef_set(codec, 0x61c0, 0x12230080); /* Clock control */
3900         alc5505_coef_set(codec, 0x61b4, 0x040e2b02); /* PLL2 control */
3901         alc5505_coef_set(codec, 0x61bc, 0x010234f8); /* OSC Control */
3902         alc5505_coef_set(codec, 0x880c, 0x00000004); /* DRAM Function control */
3903         alc5505_coef_set(codec, 0x880c, 0x00000003);
3904         alc5505_coef_set(codec, 0x880c, 0x00000010);
3905
3906 #ifdef HALT_REALTEK_ALC5505
3907         alc5505_dsp_halt(codec);
3908 #endif
3909 }
3910
3911 #ifdef HALT_REALTEK_ALC5505
3912 #define alc5505_dsp_suspend(codec)      do { } while (0) /* NOP */
3913 #define alc5505_dsp_resume(codec)       do { } while (0) /* NOP */
3914 #else
3915 #define alc5505_dsp_suspend(codec)      alc5505_dsp_halt(codec)
3916 #define alc5505_dsp_resume(codec)       alc5505_dsp_back_from_halt(codec)
3917 #endif
3918
3919 #ifdef CONFIG_PM
3920 static int alc269_suspend(struct hda_codec *codec)
3921 {
3922         struct alc_spec *spec = codec->spec;
3923
3924         if (spec->has_alc5505_dsp)
3925                 alc5505_dsp_suspend(codec);
3926         return alc_suspend(codec);
3927 }
3928
3929 static int alc269_resume(struct hda_codec *codec)
3930 {
3931         struct alc_spec *spec = codec->spec;
3932
3933         if (spec->codec_variant == ALC269_TYPE_ALC269VB)
3934                 alc269vb_toggle_power_output(codec, 0);
3935         if (spec->codec_variant == ALC269_TYPE_ALC269VB &&
3936                         (alc_get_coef0(codec) & 0x00ff) == 0x018) {
3937                 msleep(150);
3938         }
3939
3940         codec->patch_ops.init(codec);
3941
3942         if (spec->codec_variant == ALC269_TYPE_ALC269VB)
3943                 alc269vb_toggle_power_output(codec, 1);
3944         if (spec->codec_variant == ALC269_TYPE_ALC269VB &&
3945                         (alc_get_coef0(codec) & 0x00ff) == 0x017) {
3946                 msleep(200);
3947         }
3948
3949         snd_hda_regmap_sync(codec);
3950         hda_call_check_power_status(codec, 0x01);
3951
3952         /* on some machine, the BIOS will clear the codec gpio data when enter
3953          * suspend, and won't restore the data after resume, so we restore it
3954          * in the driver.
3955          */
3956         if (spec->gpio_data)
3957                 alc_write_gpio_data(codec);
3958
3959         if (spec->has_alc5505_dsp)
3960                 alc5505_dsp_resume(codec);
3961
3962         return 0;
3963 }
3964 #endif /* CONFIG_PM */
3965
3966 static void alc269_fixup_pincfg_no_hp_to_lineout(struct hda_codec *codec,
3967                                                  const struct hda_fixup *fix, int action)
3968 {
3969         struct alc_spec *spec = codec->spec;
3970
3971         if (action == HDA_FIXUP_ACT_PRE_PROBE)
3972                 spec->parse_flags = HDA_PINCFG_NO_HP_FIXUP;
3973 }
3974
3975 static void alc269_fixup_pincfg_U7x7_headset_mic(struct hda_codec *codec,
3976                                                  const struct hda_fixup *fix,
3977                                                  int action)
3978 {
3979         unsigned int cfg_headphone = snd_hda_codec_get_pincfg(codec, 0x21);
3980         unsigned int cfg_headset_mic = snd_hda_codec_get_pincfg(codec, 0x19);
3981
3982         if (cfg_headphone && cfg_headset_mic == 0x411111f0)
3983                 snd_hda_codec_set_pincfg(codec, 0x19,
3984                         (cfg_headphone & ~AC_DEFCFG_DEVICE) |
3985                         (AC_JACK_MIC_IN << AC_DEFCFG_DEVICE_SHIFT));
3986 }
3987
3988 static void alc269_fixup_hweq(struct hda_codec *codec,
3989                                const struct hda_fixup *fix, int action)
3990 {
3991         if (action == HDA_FIXUP_ACT_INIT)
3992                 alc_update_coef_idx(codec, 0x1e, 0, 0x80);
3993 }
3994
3995 static void alc269_fixup_headset_mic(struct hda_codec *codec,
3996                                        const struct hda_fixup *fix, int action)
3997 {
3998         struct alc_spec *spec = codec->spec;
3999
4000         if (action == HDA_FIXUP_ACT_PRE_PROBE)
4001                 spec->parse_flags |= HDA_PINCFG_HEADSET_MIC;
4002 }
4003
4004 static void alc271_fixup_dmic(struct hda_codec *codec,
4005                               const struct hda_fixup *fix, int action)
4006 {
4007         static const struct hda_verb verbs[] = {
4008                 {0x20, AC_VERB_SET_COEF_INDEX, 0x0d},
4009                 {0x20, AC_VERB_SET_PROC_COEF, 0x4000},
4010                 {}
4011         };
4012         unsigned int cfg;
4013
4014         if (strcmp(codec->core.chip_name, "ALC271X") &&
4015             strcmp(codec->core.chip_name, "ALC269VB"))
4016                 return;
4017         cfg = snd_hda_codec_get_pincfg(codec, 0x12);
4018         if (get_defcfg_connect(cfg) == AC_JACK_PORT_FIXED)
4019                 snd_hda_sequence_write(codec, verbs);
4020 }
4021
4022 /* Fix the speaker amp after resume, etc */
4023 static void alc269vb_fixup_aspire_e1_coef(struct hda_codec *codec,
4024                                           const struct hda_fixup *fix,
4025                                           int action)
4026 {
4027         if (action == HDA_FIXUP_ACT_INIT)
4028                 alc_update_coef_idx(codec, 0x0d, 0x6000, 0x6000);
4029 }
4030
4031 static void alc269_fixup_pcm_44k(struct hda_codec *codec,
4032                                  const struct hda_fixup *fix, int action)
4033 {
4034         struct alc_spec *spec = codec->spec;
4035
4036         if (action != HDA_FIXUP_ACT_PROBE)
4037                 return;
4038
4039         /* Due to a hardware problem on Lenovo Ideadpad, we need to
4040          * fix the sample rate of analog I/O to 44.1kHz
4041          */
4042         spec->gen.stream_analog_playback = &alc269_44k_pcm_analog_playback;
4043         spec->gen.stream_analog_capture = &alc269_44k_pcm_analog_capture;
4044 }
4045
4046 static void alc269_fixup_stereo_dmic(struct hda_codec *codec,
4047                                      const struct hda_fixup *fix, int action)
4048 {
4049         /* The digital-mic unit sends PDM (differential signal) instead of
4050          * the standard PCM, thus you can't record a valid mono stream as is.
4051          * Below is a workaround specific to ALC269 to control the dmic
4052          * signal source as mono.
4053          */
4054         if (action == HDA_FIXUP_ACT_INIT)
4055                 alc_update_coef_idx(codec, 0x07, 0, 0x80);
4056 }
4057
4058 static void alc269_quanta_automute(struct hda_codec *codec)
4059 {
4060         snd_hda_gen_update_outputs(codec);
4061
4062         alc_write_coef_idx(codec, 0x0c, 0x680);
4063         alc_write_coef_idx(codec, 0x0c, 0x480);
4064 }
4065
4066 static void alc269_fixup_quanta_mute(struct hda_codec *codec,
4067                                      const struct hda_fixup *fix, int action)
4068 {
4069         struct alc_spec *spec = codec->spec;
4070         if (action != HDA_FIXUP_ACT_PROBE)
4071                 return;
4072         spec->gen.automute_hook = alc269_quanta_automute;
4073 }
4074
4075 static void alc269_x101_hp_automute_hook(struct hda_codec *codec,
4076                                          struct hda_jack_callback *jack)
4077 {
4078         struct alc_spec *spec = codec->spec;
4079         int vref;
4080         msleep(200);
4081         snd_hda_gen_hp_automute(codec, jack);
4082
4083         vref = spec->gen.hp_jack_present ? PIN_VREF80 : 0;
4084         msleep(100);
4085         snd_hda_codec_write(codec, 0x18, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
4086                             vref);
4087         msleep(500);
4088         snd_hda_codec_write(codec, 0x18, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
4089                             vref);
4090 }
4091
4092 /*
4093  * Magic sequence to make Huawei Matebook X right speaker working (bko#197801)
4094  */
4095 struct hda_alc298_mbxinit {
4096         unsigned char value_0x23;
4097         unsigned char value_0x25;
4098 };
4099
4100 static void alc298_huawei_mbx_stereo_seq(struct hda_codec *codec,
4101                                          const struct hda_alc298_mbxinit *initval,
4102                                          bool first)
4103 {
4104         snd_hda_codec_write(codec, 0x06, 0, AC_VERB_SET_DIGI_CONVERT_3, 0x0);
4105         alc_write_coef_idx(codec, 0x26, 0xb000);
4106
4107         if (first)
4108                 snd_hda_codec_write(codec, 0x21, 0, AC_VERB_GET_PIN_SENSE, 0x0);
4109
4110         snd_hda_codec_write(codec, 0x6, 0, AC_VERB_SET_DIGI_CONVERT_3, 0x80);
4111         alc_write_coef_idx(codec, 0x26, 0xf000);
4112         alc_write_coef_idx(codec, 0x23, initval->value_0x23);
4113
4114         if (initval->value_0x23 != 0x1e)
4115                 alc_write_coef_idx(codec, 0x25, initval->value_0x25);
4116
4117         snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_COEF_INDEX, 0x26);
4118         snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_PROC_COEF, 0xb010);
4119 }
4120
4121 static void alc298_fixup_huawei_mbx_stereo(struct hda_codec *codec,
4122                                            const struct hda_fixup *fix,
4123                                            int action)
4124 {
4125         /* Initialization magic */
4126         static const struct hda_alc298_mbxinit dac_init[] = {
4127                 {0x0c, 0x00}, {0x0d, 0x00}, {0x0e, 0x00}, {0x0f, 0x00},
4128                 {0x10, 0x00}, {0x1a, 0x40}, {0x1b, 0x82}, {0x1c, 0x00},
4129                 {0x1d, 0x00}, {0x1e, 0x00}, {0x1f, 0x00},
4130                 {0x20, 0xc2}, {0x21, 0xc8}, {0x22, 0x26}, {0x23, 0x24},
4131                 {0x27, 0xff}, {0x28, 0xff}, {0x29, 0xff}, {0x2a, 0x8f},
4132                 {0x2b, 0x02}, {0x2c, 0x48}, {0x2d, 0x34}, {0x2e, 0x00},
4133                 {0x2f, 0x00},
4134                 {0x30, 0x00}, {0x31, 0x00}, {0x32, 0x00}, {0x33, 0x00},
4135                 {0x34, 0x00}, {0x35, 0x01}, {0x36, 0x93}, {0x37, 0x0c},
4136                 {0x38, 0x00}, {0x39, 0x00}, {0x3a, 0xf8}, {0x38, 0x80},
4137                 {}
4138         };
4139         const struct hda_alc298_mbxinit *seq;
4140
4141         if (action != HDA_FIXUP_ACT_INIT)
4142                 return;
4143
4144         /* Start */
4145         snd_hda_codec_write(codec, 0x06, 0, AC_VERB_SET_DIGI_CONVERT_3, 0x00);
4146         snd_hda_codec_write(codec, 0x06, 0, AC_VERB_SET_DIGI_CONVERT_3, 0x80);
4147         alc_write_coef_idx(codec, 0x26, 0xf000);
4148         alc_write_coef_idx(codec, 0x22, 0x31);
4149         alc_write_coef_idx(codec, 0x23, 0x0b);
4150         alc_write_coef_idx(codec, 0x25, 0x00);
4151         snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_COEF_INDEX, 0x26);
4152         snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_PROC_COEF, 0xb010);
4153
4154         for (seq = dac_init; seq->value_0x23; seq++)
4155                 alc298_huawei_mbx_stereo_seq(codec, seq, seq == dac_init);
4156 }
4157
4158 static void alc269_fixup_x101_headset_mic(struct hda_codec *codec,
4159                                      const struct hda_fixup *fix, int action)
4160 {
4161         struct alc_spec *spec = codec->spec;
4162         if (action == HDA_FIXUP_ACT_PRE_PROBE) {
4163                 spec->parse_flags |= HDA_PINCFG_HEADSET_MIC;
4164                 spec->gen.hp_automute_hook = alc269_x101_hp_automute_hook;
4165         }
4166 }
4167
4168 static void alc_update_vref_led(struct hda_codec *codec, hda_nid_t pin,
4169                                 bool polarity, bool on)
4170 {
4171         unsigned int pinval;
4172
4173         if (!pin)
4174                 return;
4175         if (polarity)
4176                 on = !on;
4177         pinval = snd_hda_codec_get_pin_target(codec, pin);
4178         pinval &= ~AC_PINCTL_VREFEN;
4179         pinval |= on ? AC_PINCTL_VREF_80 : AC_PINCTL_VREF_HIZ;
4180         /* temporarily power up/down for setting VREF */
4181         snd_hda_power_up_pm(codec);
4182         snd_hda_set_pin_ctl_cache(codec, pin, pinval);
4183         snd_hda_power_down_pm(codec);
4184 }
4185
4186 /* update mute-LED according to the speaker mute state via mic VREF pin */
4187 static int vref_mute_led_set(struct led_classdev *led_cdev,
4188                              enum led_brightness brightness)
4189 {
4190         struct hda_codec *codec = dev_to_hda_codec(led_cdev->dev->parent);
4191         struct alc_spec *spec = codec->spec;
4192
4193         alc_update_vref_led(codec, spec->mute_led_nid,
4194                             spec->mute_led_polarity, brightness);
4195         return 0;
4196 }
4197
4198 /* Make sure the led works even in runtime suspend */
4199 static unsigned int led_power_filter(struct hda_codec *codec,
4200                                                   hda_nid_t nid,
4201                                                   unsigned int power_state)
4202 {
4203         struct alc_spec *spec = codec->spec;
4204
4205         if (power_state != AC_PWRST_D3 || nid == 0 ||
4206             (nid != spec->mute_led_nid && nid != spec->cap_mute_led_nid))
4207                 return power_state;
4208
4209         /* Set pin ctl again, it might have just been set to 0 */
4210         snd_hda_set_pin_ctl(codec, nid,
4211                             snd_hda_codec_get_pin_target(codec, nid));
4212
4213         return snd_hda_gen_path_power_filter(codec, nid, power_state);
4214 }
4215
4216 static void alc269_fixup_hp_mute_led(struct hda_codec *codec,
4217                                      const struct hda_fixup *fix, int action)
4218 {
4219         struct alc_spec *spec = codec->spec;
4220         const struct dmi_device *dev = NULL;
4221
4222         if (action != HDA_FIXUP_ACT_PRE_PROBE)
4223                 return;
4224
4225         while ((dev = dmi_find_device(DMI_DEV_TYPE_OEM_STRING, NULL, dev))) {
4226                 int pol, pin;
4227                 if (sscanf(dev->name, "HP_Mute_LED_%d_%x", &pol, &pin) != 2)
4228                         continue;
4229                 if (pin < 0x0a || pin >= 0x10)
4230                         break;
4231                 spec->mute_led_polarity = pol;
4232                 spec->mute_led_nid = pin - 0x0a + 0x18;
4233                 snd_hda_gen_add_mute_led_cdev(codec, vref_mute_led_set);
4234                 codec->power_filter = led_power_filter;
4235                 codec_dbg(codec,
4236                           "Detected mute LED for %x:%d\n", spec->mute_led_nid,
4237                            spec->mute_led_polarity);
4238                 break;
4239         }
4240 }
4241
4242 static void alc269_fixup_hp_mute_led_micx(struct hda_codec *codec,
4243                                           const struct hda_fixup *fix,
4244                                           int action, hda_nid_t pin)
4245 {
4246         struct alc_spec *spec = codec->spec;
4247
4248         if (action == HDA_FIXUP_ACT_PRE_PROBE) {
4249                 spec->mute_led_polarity = 0;
4250                 spec->mute_led_nid = pin;
4251                 snd_hda_gen_add_mute_led_cdev(codec, vref_mute_led_set);
4252                 codec->power_filter = led_power_filter;
4253         }
4254 }
4255
4256 static void alc269_fixup_hp_mute_led_mic1(struct hda_codec *codec,
4257                                 const struct hda_fixup *fix, int action)
4258 {
4259         alc269_fixup_hp_mute_led_micx(codec, fix, action, 0x18);
4260 }
4261
4262 static void alc269_fixup_hp_mute_led_mic2(struct hda_codec *codec,
4263                                 const struct hda_fixup *fix, int action)
4264 {
4265         alc269_fixup_hp_mute_led_micx(codec, fix, action, 0x19);
4266 }
4267
4268 static void alc269_fixup_hp_mute_led_mic3(struct hda_codec *codec,
4269                                 const struct hda_fixup *fix, int action)
4270 {
4271         alc269_fixup_hp_mute_led_micx(codec, fix, action, 0x1b);
4272 }
4273
4274 /* update LED status via GPIO */
4275 static void alc_update_gpio_led(struct hda_codec *codec, unsigned int mask,
4276                                 int polarity, bool enabled)
4277 {
4278         if (polarity)
4279                 enabled = !enabled;
4280         alc_update_gpio_data(codec, mask, !enabled); /* muted -> LED on */
4281 }
4282
4283 /* turn on/off mute LED via GPIO per vmaster hook */
4284 static int gpio_mute_led_set(struct led_classdev *led_cdev,
4285                              enum led_brightness brightness)
4286 {
4287         struct hda_codec *codec = dev_to_hda_codec(led_cdev->dev->parent);
4288         struct alc_spec *spec = codec->spec;
4289
4290         alc_update_gpio_led(codec, spec->gpio_mute_led_mask,
4291                             spec->mute_led_polarity, !brightness);
4292         return 0;
4293 }
4294
4295 /* turn on/off mic-mute LED via GPIO per capture hook */
4296 static int micmute_led_set(struct led_classdev *led_cdev,
4297                            enum led_brightness brightness)
4298 {
4299         struct hda_codec *codec = dev_to_hda_codec(led_cdev->dev->parent);
4300         struct alc_spec *spec = codec->spec;
4301
4302         alc_update_gpio_led(codec, spec->gpio_mic_led_mask,
4303                             spec->micmute_led_polarity, !brightness);
4304         return 0;
4305 }
4306
4307 /* setup mute and mic-mute GPIO bits, add hooks appropriately */
4308 static void alc_fixup_hp_gpio_led(struct hda_codec *codec,
4309                                   int action,
4310                                   unsigned int mute_mask,
4311                                   unsigned int micmute_mask)
4312 {
4313         struct alc_spec *spec = codec->spec;
4314
4315         alc_fixup_gpio(codec, action, mute_mask | micmute_mask);
4316
4317         if (action != HDA_FIXUP_ACT_PRE_PROBE)
4318                 return;
4319         if (mute_mask) {
4320                 spec->gpio_mute_led_mask = mute_mask;
4321                 snd_hda_gen_add_mute_led_cdev(codec, gpio_mute_led_set);
4322         }
4323         if (micmute_mask) {
4324                 spec->gpio_mic_led_mask = micmute_mask;
4325                 snd_hda_gen_add_micmute_led_cdev(codec, micmute_led_set);
4326         }
4327 }
4328
4329 static void alc236_fixup_hp_gpio_led(struct hda_codec *codec,
4330                                 const struct hda_fixup *fix, int action)
4331 {
4332         alc_fixup_hp_gpio_led(codec, action, 0x02, 0x01);
4333 }
4334
4335 static void alc269_fixup_hp_gpio_led(struct hda_codec *codec,
4336                                 const struct hda_fixup *fix, int action)
4337 {
4338         alc_fixup_hp_gpio_led(codec, action, 0x08, 0x10);
4339 }
4340
4341 static void alc285_fixup_hp_gpio_led(struct hda_codec *codec,
4342                                 const struct hda_fixup *fix, int action)
4343 {
4344         alc_fixup_hp_gpio_led(codec, action, 0x04, 0x01);
4345 }
4346
4347 static void alc286_fixup_hp_gpio_led(struct hda_codec *codec,
4348                                 const struct hda_fixup *fix, int action)
4349 {
4350         alc_fixup_hp_gpio_led(codec, action, 0x02, 0x20);
4351 }
4352
4353 static void alc287_fixup_hp_gpio_led(struct hda_codec *codec,
4354                                 const struct hda_fixup *fix, int action)
4355 {
4356         alc_fixup_hp_gpio_led(codec, action, 0x10, 0);
4357 }
4358
4359 static void alc245_fixup_hp_gpio_led(struct hda_codec *codec,
4360                                 const struct hda_fixup *fix, int action)
4361 {
4362         struct alc_spec *spec = codec->spec;
4363
4364         if (action == HDA_FIXUP_ACT_PRE_PROBE)
4365                 spec->micmute_led_polarity = 1;
4366         alc_fixup_hp_gpio_led(codec, action, 0, 0x04);
4367 }
4368
4369 /* turn on/off mic-mute LED per capture hook via VREF change */
4370 static int vref_micmute_led_set(struct led_classdev *led_cdev,
4371                                 enum led_brightness brightness)
4372 {
4373         struct hda_codec *codec = dev_to_hda_codec(led_cdev->dev->parent);
4374         struct alc_spec *spec = codec->spec;
4375
4376         alc_update_vref_led(codec, spec->cap_mute_led_nid,
4377                             spec->micmute_led_polarity, brightness);
4378         return 0;
4379 }
4380
4381 static void alc269_fixup_hp_gpio_mic1_led(struct hda_codec *codec,
4382                                 const struct hda_fixup *fix, int action)
4383 {
4384         struct alc_spec *spec = codec->spec;
4385
4386         alc_fixup_hp_gpio_led(codec, action, 0x08, 0);
4387         if (action == HDA_FIXUP_ACT_PRE_PROBE) {
4388                 /* Like hp_gpio_mic1_led, but also needs GPIO4 low to
4389                  * enable headphone amp
4390                  */
4391                 spec->gpio_mask |= 0x10;
4392                 spec->gpio_dir |= 0x10;
4393                 spec->cap_mute_led_nid = 0x18;
4394                 snd_hda_gen_add_micmute_led_cdev(codec, vref_micmute_led_set);
4395                 codec->power_filter = led_power_filter;
4396         }
4397 }
4398
4399 static void alc280_fixup_hp_gpio4(struct hda_codec *codec,
4400                                    const struct hda_fixup *fix, int action)
4401 {
4402         struct alc_spec *spec = codec->spec;
4403
4404         alc_fixup_hp_gpio_led(codec, action, 0x08, 0);
4405         if (action == HDA_FIXUP_ACT_PRE_PROBE) {
4406                 spec->cap_mute_led_nid = 0x18;
4407                 snd_hda_gen_add_micmute_led_cdev(codec, vref_micmute_led_set);
4408                 codec->power_filter = led_power_filter;
4409         }
4410 }
4411
4412 /* HP Spectre x360 14 model needs a unique workaround for enabling the amp;
4413  * it needs to toggle the GPIO0 once on and off at each time (bko#210633)
4414  */
4415 static void alc245_fixup_hp_x360_amp(struct hda_codec *codec,
4416                                      const struct hda_fixup *fix, int action)
4417 {
4418         struct alc_spec *spec = codec->spec;
4419
4420         switch (action) {
4421         case HDA_FIXUP_ACT_PRE_PROBE:
4422                 spec->gpio_mask |= 0x01;
4423                 spec->gpio_dir |= 0x01;
4424                 break;
4425         case HDA_FIXUP_ACT_INIT:
4426                 /* need to toggle GPIO to enable the amp */
4427                 alc_update_gpio_data(codec, 0x01, true);
4428                 msleep(100);
4429                 alc_update_gpio_data(codec, 0x01, false);
4430                 break;
4431         }
4432 }
4433
4434 /* toggle GPIO2 at each time stream is started; we use PREPARE state instead */
4435 static void alc274_hp_envy_pcm_hook(struct hda_pcm_stream *hinfo,
4436                                     struct hda_codec *codec,
4437                                     struct snd_pcm_substream *substream,
4438                                     int action)
4439 {
4440         switch (action) {
4441         case HDA_GEN_PCM_ACT_PREPARE:
4442                 alc_update_gpio_data(codec, 0x04, true);
4443                 break;
4444         case HDA_GEN_PCM_ACT_CLEANUP:
4445                 alc_update_gpio_data(codec, 0x04, false);
4446                 break;
4447         }
4448 }
4449
4450 static void alc274_fixup_hp_envy_gpio(struct hda_codec *codec,
4451                                       const struct hda_fixup *fix,
4452                                       int action)
4453 {
4454         struct alc_spec *spec = codec->spec;
4455
4456         if (action == HDA_FIXUP_ACT_PROBE) {
4457                 spec->gpio_mask |= 0x04;
4458                 spec->gpio_dir |= 0x04;
4459                 spec->gen.pcm_playback_hook = alc274_hp_envy_pcm_hook;
4460         }
4461 }
4462
4463 static void alc_update_coef_led(struct hda_codec *codec,
4464                                 struct alc_coef_led *led,
4465                                 bool polarity, bool on)
4466 {
4467         if (polarity)
4468                 on = !on;
4469         /* temporarily power up/down for setting COEF bit */
4470         alc_update_coef_idx(codec, led->idx, led->mask,
4471                             on ? led->on : led->off);
4472 }
4473
4474 /* update mute-LED according to the speaker mute state via COEF bit */
4475 static int coef_mute_led_set(struct led_classdev *led_cdev,
4476                              enum led_brightness brightness)
4477 {
4478         struct hda_codec *codec = dev_to_hda_codec(led_cdev->dev->parent);
4479         struct alc_spec *spec = codec->spec;
4480
4481         alc_update_coef_led(codec, &spec->mute_led_coef,
4482                             spec->mute_led_polarity, brightness);
4483         return 0;
4484 }
4485
4486 static void alc285_fixup_hp_mute_led_coefbit(struct hda_codec *codec,
4487                                           const struct hda_fixup *fix,
4488                                           int action)
4489 {
4490         struct alc_spec *spec = codec->spec;
4491
4492         if (action == HDA_FIXUP_ACT_PRE_PROBE) {
4493                 spec->mute_led_polarity = 0;
4494                 spec->mute_led_coef.idx = 0x0b;
4495                 spec->mute_led_coef.mask = 1 << 3;
4496                 spec->mute_led_coef.on = 1 << 3;
4497                 spec->mute_led_coef.off = 0;
4498                 snd_hda_gen_add_mute_led_cdev(codec, coef_mute_led_set);
4499         }
4500 }
4501
4502 static void alc236_fixup_hp_mute_led_coefbit(struct hda_codec *codec,
4503                                           const struct hda_fixup *fix,
4504                                           int action)
4505 {
4506         struct alc_spec *spec = codec->spec;
4507
4508         if (action == HDA_FIXUP_ACT_PRE_PROBE) {
4509                 spec->mute_led_polarity = 0;
4510                 spec->mute_led_coef.idx = 0x34;
4511                 spec->mute_led_coef.mask = 1 << 5;
4512                 spec->mute_led_coef.on = 0;
4513                 spec->mute_led_coef.off = 1 << 5;
4514                 snd_hda_gen_add_mute_led_cdev(codec, coef_mute_led_set);
4515         }
4516 }
4517
4518 /* turn on/off mic-mute LED per capture hook by coef bit */
4519 static int coef_micmute_led_set(struct led_classdev *led_cdev,
4520                                 enum led_brightness brightness)
4521 {
4522         struct hda_codec *codec = dev_to_hda_codec(led_cdev->dev->parent);
4523         struct alc_spec *spec = codec->spec;
4524
4525         alc_update_coef_led(codec, &spec->mic_led_coef,
4526                             spec->micmute_led_polarity, brightness);
4527         return 0;
4528 }
4529
4530 static void alc285_fixup_hp_coef_micmute_led(struct hda_codec *codec,
4531                                 const struct hda_fixup *fix, int action)
4532 {
4533         struct alc_spec *spec = codec->spec;
4534
4535         if (action == HDA_FIXUP_ACT_PRE_PROBE) {
4536                 spec->mic_led_coef.idx = 0x19;
4537                 spec->mic_led_coef.mask = 1 << 13;
4538                 spec->mic_led_coef.on = 1 << 13;
4539                 spec->mic_led_coef.off = 0;
4540                 snd_hda_gen_add_micmute_led_cdev(codec, coef_micmute_led_set);
4541         }
4542 }
4543
4544 static void alc236_fixup_hp_coef_micmute_led(struct hda_codec *codec,
4545                                 const struct hda_fixup *fix, int action)
4546 {
4547         struct alc_spec *spec = codec->spec;
4548
4549         if (action == HDA_FIXUP_ACT_PRE_PROBE) {
4550                 spec->mic_led_coef.idx = 0x35;
4551                 spec->mic_led_coef.mask = 3 << 2;
4552                 spec->mic_led_coef.on = 2 << 2;
4553                 spec->mic_led_coef.off = 1 << 2;
4554                 snd_hda_gen_add_micmute_led_cdev(codec, coef_micmute_led_set);
4555         }
4556 }
4557
4558 static void alc285_fixup_hp_mute_led(struct hda_codec *codec,
4559                                 const struct hda_fixup *fix, int action)
4560 {
4561         alc285_fixup_hp_mute_led_coefbit(codec, fix, action);
4562         alc285_fixup_hp_coef_micmute_led(codec, fix, action);
4563 }
4564
4565 static void alc236_fixup_hp_mute_led(struct hda_codec *codec,
4566                                 const struct hda_fixup *fix, int action)
4567 {
4568         alc236_fixup_hp_mute_led_coefbit(codec, fix, action);
4569         alc236_fixup_hp_coef_micmute_led(codec, fix, action);
4570 }
4571
4572 static void alc236_fixup_hp_micmute_led_vref(struct hda_codec *codec,
4573                                 const struct hda_fixup *fix, int action)
4574 {
4575         struct alc_spec *spec = codec->spec;
4576
4577         if (action == HDA_FIXUP_ACT_PRE_PROBE) {
4578                 spec->cap_mute_led_nid = 0x1a;
4579                 snd_hda_gen_add_micmute_led_cdev(codec, vref_micmute_led_set);
4580                 codec->power_filter = led_power_filter;
4581         }
4582 }
4583
4584 static void alc236_fixup_hp_mute_led_micmute_vref(struct hda_codec *codec,
4585                                 const struct hda_fixup *fix, int action)
4586 {
4587         alc236_fixup_hp_mute_led_coefbit(codec, fix, action);
4588         alc236_fixup_hp_micmute_led_vref(codec, fix, action);
4589 }
4590
4591 #if IS_REACHABLE(CONFIG_INPUT)
4592 static void gpio2_mic_hotkey_event(struct hda_codec *codec,
4593                                    struct hda_jack_callback *event)
4594 {
4595         struct alc_spec *spec = codec->spec;
4596
4597         /* GPIO2 just toggles on a keypress/keyrelease cycle. Therefore
4598            send both key on and key off event for every interrupt. */
4599         input_report_key(spec->kb_dev, spec->alc_mute_keycode_map[ALC_KEY_MICMUTE_INDEX], 1);
4600         input_sync(spec->kb_dev);
4601         input_report_key(spec->kb_dev, spec->alc_mute_keycode_map[ALC_KEY_MICMUTE_INDEX], 0);
4602         input_sync(spec->kb_dev);
4603 }
4604
4605 static int alc_register_micmute_input_device(struct hda_codec *codec)
4606 {
4607         struct alc_spec *spec = codec->spec;
4608         int i;
4609
4610         spec->kb_dev = input_allocate_device();
4611         if (!spec->kb_dev) {
4612                 codec_err(codec, "Out of memory (input_allocate_device)\n");
4613                 return -ENOMEM;
4614         }
4615
4616         spec->alc_mute_keycode_map[ALC_KEY_MICMUTE_INDEX] = KEY_MICMUTE;
4617
4618         spec->kb_dev->name = "Microphone Mute Button";
4619         spec->kb_dev->evbit[0] = BIT_MASK(EV_KEY);
4620         spec->kb_dev->keycodesize = sizeof(spec->alc_mute_keycode_map[0]);
4621         spec->kb_dev->keycodemax = ARRAY_SIZE(spec->alc_mute_keycode_map);
4622         spec->kb_dev->keycode = spec->alc_mute_keycode_map;
4623         for (i = 0; i < ARRAY_SIZE(spec->alc_mute_keycode_map); i++)
4624                 set_bit(spec->alc_mute_keycode_map[i], spec->kb_dev->keybit);
4625
4626         if (input_register_device(spec->kb_dev)) {
4627                 codec_err(codec, "input_register_device failed\n");
4628                 input_free_device(spec->kb_dev);
4629                 spec->kb_dev = NULL;
4630                 return -ENOMEM;
4631         }
4632
4633         return 0;
4634 }
4635
4636 /* GPIO1 = set according to SKU external amp
4637  * GPIO2 = mic mute hotkey
4638  * GPIO3 = mute LED
4639  * GPIO4 = mic mute LED
4640  */
4641 static void alc280_fixup_hp_gpio2_mic_hotkey(struct hda_codec *codec,
4642                                              const struct hda_fixup *fix, int action)
4643 {
4644         struct alc_spec *spec = codec->spec;
4645
4646         alc_fixup_hp_gpio_led(codec, action, 0x08, 0x10);
4647         if (action == HDA_FIXUP_ACT_PRE_PROBE) {
4648                 spec->init_amp = ALC_INIT_DEFAULT;
4649                 if (alc_register_micmute_input_device(codec) != 0)
4650                         return;
4651
4652                 spec->gpio_mask |= 0x06;
4653                 spec->gpio_dir |= 0x02;
4654                 spec->gpio_data |= 0x02;
4655                 snd_hda_codec_write_cache(codec, codec->core.afg, 0,
4656                                           AC_VERB_SET_GPIO_UNSOLICITED_RSP_MASK, 0x04);
4657                 snd_hda_jack_detect_enable_callback(codec, codec->core.afg,
4658                                                     gpio2_mic_hotkey_event);
4659                 return;
4660         }
4661
4662         if (!spec->kb_dev)
4663                 return;
4664
4665         switch (action) {
4666         case HDA_FIXUP_ACT_FREE:
4667                 input_unregister_device(spec->kb_dev);
4668                 spec->kb_dev = NULL;
4669         }
4670 }
4671
4672 /* Line2 = mic mute hotkey
4673  * GPIO2 = mic mute LED
4674  */
4675 static void alc233_fixup_lenovo_line2_mic_hotkey(struct hda_codec *codec,
4676                                              const struct hda_fixup *fix, int action)
4677 {
4678         struct alc_spec *spec = codec->spec;
4679
4680         alc_fixup_hp_gpio_led(codec, action, 0, 0x04);
4681         if (action == HDA_FIXUP_ACT_PRE_PROBE) {
4682                 spec->init_amp = ALC_INIT_DEFAULT;
4683                 if (alc_register_micmute_input_device(codec) != 0)
4684                         return;
4685
4686                 snd_hda_jack_detect_enable_callback(codec, 0x1b,
4687                                                     gpio2_mic_hotkey_event);
4688                 return;
4689         }
4690
4691         if (!spec->kb_dev)
4692                 return;
4693
4694         switch (action) {
4695         case HDA_FIXUP_ACT_FREE:
4696                 input_unregister_device(spec->kb_dev);
4697                 spec->kb_dev = NULL;
4698         }
4699 }
4700 #else /* INPUT */
4701 #define alc280_fixup_hp_gpio2_mic_hotkey        NULL
4702 #define alc233_fixup_lenovo_line2_mic_hotkey    NULL
4703 #endif /* INPUT */
4704
4705 static void alc269_fixup_hp_line1_mic1_led(struct hda_codec *codec,
4706                                 const struct hda_fixup *fix, int action)
4707 {
4708         struct alc_spec *spec = codec->spec;
4709
4710         alc269_fixup_hp_mute_led_micx(codec, fix, action, 0x1a);
4711         if (action == HDA_FIXUP_ACT_PRE_PROBE) {
4712                 spec->cap_mute_led_nid = 0x18;
4713                 snd_hda_gen_add_micmute_led_cdev(codec, vref_micmute_led_set);
4714         }
4715 }
4716
4717 static const struct coef_fw alc225_pre_hsmode[] = {
4718         UPDATE_COEF(0x4a, 1<<8, 0),
4719         UPDATE_COEFEX(0x57, 0x05, 1<<14, 0),
4720         UPDATE_COEF(0x63, 3<<14, 3<<14),
4721         UPDATE_COEF(0x4a, 3<<4, 2<<4),
4722         UPDATE_COEF(0x4a, 3<<10, 3<<10),
4723         UPDATE_COEF(0x45, 0x3f<<10, 0x34<<10),
4724         UPDATE_COEF(0x4a, 3<<10, 0),
4725         {}
4726 };
4727
4728 static void alc_headset_mode_unplugged(struct hda_codec *codec)
4729 {
4730         struct alc_spec *spec = codec->spec;
4731         static const struct coef_fw coef0255[] = {
4732                 WRITE_COEF(0x1b, 0x0c0b), /* LDO and MISC control */
4733                 WRITE_COEF(0x45, 0xd089), /* UAJ function set to menual mode */
4734                 UPDATE_COEFEX(0x57, 0x05, 1<<14, 0), /* Direct Drive HP Amp control(Set to verb control)*/
4735                 WRITE_COEF(0x06, 0x6104), /* Set MIC2 Vref gate with HP */
4736                 WRITE_COEFEX(0x57, 0x03, 0x8aa6), /* Direct Drive HP Amp control */
4737                 {}
4738         };
4739         static const struct coef_fw coef0256[] = {
4740                 WRITE_COEF(0x1b, 0x0c4b), /* LDO and MISC control */
4741                 WRITE_COEF(0x45, 0xd089), /* UAJ function set to menual mode */
4742                 WRITE_COEF(0x06, 0x6104), /* Set MIC2 Vref gate with HP */
4743                 WRITE_COEFEX(0x57, 0x03, 0x09a3), /* Direct Drive HP Amp control */
4744                 UPDATE_COEFEX(0x57, 0x05, 1<<14, 0), /* Direct Drive HP Amp control(Set to verb control)*/
4745                 {}
4746         };
4747         static const struct coef_fw coef0233[] = {
4748                 WRITE_COEF(0x1b, 0x0c0b),
4749                 WRITE_COEF(0x45, 0xc429),
4750                 UPDATE_COEF(0x35, 0x4000, 0),
4751                 WRITE_COEF(0x06, 0x2104),
4752                 WRITE_COEF(0x1a, 0x0001),
4753                 WRITE_COEF(0x26, 0x0004),
4754                 WRITE_COEF(0x32, 0x42a3),
4755                 {}
4756         };
4757         static const struct coef_fw coef0288[] = {
4758                 UPDATE_COEF(0x4f, 0xfcc0, 0xc400),
4759                 UPDATE_COEF(0x50, 0x2000, 0x2000),
4760                 UPDATE_COEF(0x56, 0x0006, 0x0006),
4761                 UPDATE_COEF(0x66, 0x0008, 0),
4762                 UPDATE_COEF(0x67, 0x2000, 0),
4763                 {}
4764         };
4765         static const struct coef_fw coef0298[] = {
4766                 UPDATE_COEF(0x19, 0x1300, 0x0300),
4767                 {}
4768         };
4769         static const struct coef_fw coef0292[] = {
4770                 WRITE_COEF(0x76, 0x000e),
4771                 WRITE_COEF(0x6c, 0x2400),
4772                 WRITE_COEF(0x18, 0x7308),
4773                 WRITE_COEF(0x6b, 0xc429),
4774                 {}
4775         };
4776         static const struct coef_fw coef0293[] = {
4777                 UPDATE_COEF(0x10, 7<<8, 6<<8), /* SET Line1 JD to 0 */
4778                 UPDATE_COEFEX(0x57, 0x05, 1<<15|1<<13, 0x0), /* SET charge pump by verb */
4779                 UPDATE_COEFEX(0x57, 0x03, 1<<10, 1<<10), /* SET EN_OSW to 1 */
4780                 UPDATE_COEF(0x1a, 1<<3, 1<<3), /* Combo JD gating with LINE1-VREFO */
4781                 WRITE_COEF(0x45, 0xc429), /* Set to TRS type */
4782                 UPDATE_COEF(0x4a, 0x000f, 0x000e), /* Combo Jack auto detect */
4783                 {}
4784         };
4785         static const struct coef_fw coef0668[] = {
4786                 WRITE_COEF(0x15, 0x0d40),
4787                 WRITE_COEF(0xb7, 0x802b),
4788                 {}
4789         };
4790         static const struct coef_fw coef0225[] = {
4791                 UPDATE_COEF(0x63, 3<<14, 0),
4792                 {}
4793         };
4794         static const struct coef_fw coef0274[] = {
4795                 UPDATE_COEF(0x4a, 0x0100, 0),
4796                 UPDATE_COEFEX(0x57, 0x05, 0x4000, 0),
4797                 UPDATE_COEF(0x6b, 0xf000, 0x5000),
4798                 UPDATE_COEF(0x4a, 0x0010, 0),
4799                 UPDATE_COEF(0x4a, 0x0c00, 0x0c00),
4800                 WRITE_COEF(0x45, 0x5289),
4801                 UPDATE_COEF(0x4a, 0x0c00, 0),
4802                 {}
4803         };
4804
4805         if (spec->no_internal_mic_pin) {
4806                 alc_update_coef_idx(codec, 0x45, 0xf<<12 | 1<<10, 5<<12);
4807                 return;
4808         }
4809
4810         switch (codec->core.vendor_id) {
4811         case 0x10ec0255:
4812                 alc_process_coef_fw(codec, coef0255);
4813                 break;
4814         case 0x10ec0230:
4815         case 0x10ec0236:
4816         case 0x10ec0256:
4817                 alc_process_coef_fw(codec, coef0256);
4818                 break;
4819         case 0x10ec0234:
4820         case 0x10ec0274:
4821         case 0x10ec0294:
4822                 alc_process_coef_fw(codec, coef0274);
4823                 break;
4824         case 0x10ec0233:
4825         case 0x10ec0283:
4826                 alc_process_coef_fw(codec, coef0233);
4827                 break;
4828         case 0x10ec0286:
4829         case 0x10ec0288:
4830                 alc_process_coef_fw(codec, coef0288);
4831                 break;
4832         case 0x10ec0298:
4833                 alc_process_coef_fw(codec, coef0298);
4834                 alc_process_coef_fw(codec, coef0288);
4835                 break;
4836         case 0x10ec0292:
4837                 alc_process_coef_fw(codec, coef0292);
4838                 break;
4839         case 0x10ec0293:
4840                 alc_process_coef_fw(codec, coef0293);
4841                 break;
4842         case 0x10ec0668:
4843                 alc_process_coef_fw(codec, coef0668);
4844                 break;
4845         case 0x10ec0215:
4846         case 0x10ec0225:
4847         case 0x10ec0285:
4848         case 0x10ec0295:
4849         case 0x10ec0289:
4850         case 0x10ec0299:
4851                 alc_process_coef_fw(codec, alc225_pre_hsmode);
4852                 alc_process_coef_fw(codec, coef0225);
4853                 break;
4854         case 0x10ec0867:
4855                 alc_update_coefex_idx(codec, 0x57, 0x5, 1<<14, 0);
4856                 break;
4857         }
4858         codec_dbg(codec, "Headset jack set to unplugged mode.\n");
4859 }
4860
4861
4862 static void alc_headset_mode_mic_in(struct hda_codec *codec, hda_nid_t hp_pin,
4863                                     hda_nid_t mic_pin)
4864 {
4865         static const struct coef_fw coef0255[] = {
4866                 WRITE_COEFEX(0x57, 0x03, 0x8aa6),
4867                 WRITE_COEF(0x06, 0x6100), /* Set MIC2 Vref gate to normal */
4868                 {}
4869         };
4870         static const struct coef_fw coef0256[] = {
4871                 UPDATE_COEFEX(0x57, 0x05, 1<<14, 1<<14), /* Direct Drive HP Amp control(Set to verb control)*/
4872                 WRITE_COEFEX(0x57, 0x03, 0x09a3),
4873                 WRITE_COEF(0x06, 0x6100), /* Set MIC2 Vref gate to normal */
4874                 {}
4875         };
4876         static const struct coef_fw coef0233[] = {
4877                 UPDATE_COEF(0x35, 0, 1<<14),
4878                 WRITE_COEF(0x06, 0x2100),
4879                 WRITE_COEF(0x1a, 0x0021),
4880                 WRITE_COEF(0x26, 0x008c),
4881                 {}
4882         };
4883         static const struct coef_fw coef0288[] = {
4884                 UPDATE_COEF(0x4f, 0x00c0, 0),
4885                 UPDATE_COEF(0x50, 0x2000, 0),
4886                 UPDATE_COEF(0x56, 0x0006, 0),
4887                 UPDATE_COEF(0x4f, 0xfcc0, 0xc400),
4888                 UPDATE_COEF(0x66, 0x0008, 0x0008),
4889                 UPDATE_COEF(0x67, 0x2000, 0x2000),
4890                 {}
4891         };
4892         static const struct coef_fw coef0292[] = {
4893                 WRITE_COEF(0x19, 0xa208),
4894                 WRITE_COEF(0x2e, 0xacf0),
4895                 {}
4896         };
4897         static const struct coef_fw coef0293[] = {
4898                 UPDATE_COEFEX(0x57, 0x05, 0, 1<<15|1<<13), /* SET charge pump by verb */
4899                 UPDATE_COEFEX(0x57, 0x03, 1<<10, 0), /* SET EN_OSW to 0 */
4900                 UPDATE_COEF(0x1a, 1<<3, 0), /* Combo JD gating without LINE1-VREFO */
4901                 {}
4902         };
4903         static const struct coef_fw coef0688[] = {
4904                 WRITE_COEF(0xb7, 0x802b),
4905                 WRITE_COEF(0xb5, 0x1040),
4906                 UPDATE_COEF(0xc3, 0, 1<<12),
4907                 {}
4908         };
4909         static const struct coef_fw coef0225[] = {
4910                 UPDATE_COEFEX(0x57, 0x05, 1<<14, 1<<14),
4911                 UPDATE_COEF(0x4a, 3<<4, 2<<4),
4912                 UPDATE_COEF(0x63, 3<<14, 0),
4913                 {}
4914         };
4915         static const struct coef_fw coef0274[] = {
4916                 UPDATE_COEFEX(0x57, 0x05, 0x4000, 0x4000),
4917                 UPDATE_COEF(0x4a, 0x0010, 0),
4918                 UPDATE_COEF(0x6b, 0xf000, 0),
4919                 {}
4920         };
4921
4922         switch (codec->core.vendor_id) {
4923         case 0x10ec0255:
4924                 alc_write_coef_idx(codec, 0x45, 0xc489);
4925                 snd_hda_set_pin_ctl_cache(codec, hp_pin, 0);
4926                 alc_process_coef_fw(codec, coef0255);
4927                 snd_hda_set_pin_ctl_cache(codec, mic_pin, PIN_VREF50);
4928                 break;
4929         case 0x10ec0230:
4930         case 0x10ec0236:
4931         case 0x10ec0256:
4932                 alc_write_coef_idx(codec, 0x45, 0xc489);
4933                 snd_hda_set_pin_ctl_cache(codec, hp_pin, 0);
4934                 alc_process_coef_fw(codec, coef0256);
4935                 snd_hda_set_pin_ctl_cache(codec, mic_pin, PIN_VREF50);
4936                 break;
4937         case 0x10ec0234:
4938         case 0x10ec0274:
4939         case 0x10ec0294:
4940                 alc_write_coef_idx(codec, 0x45, 0x4689);
4941                 snd_hda_set_pin_ctl_cache(codec, hp_pin, 0);
4942                 alc_process_coef_fw(codec, coef0274);
4943                 snd_hda_set_pin_ctl_cache(codec, mic_pin, PIN_VREF50);
4944                 break;
4945         case 0x10ec0233:
4946         case 0x10ec0283:
4947                 alc_write_coef_idx(codec, 0x45, 0xc429);
4948                 snd_hda_set_pin_ctl_cache(codec, hp_pin, 0);
4949                 alc_process_coef_fw(codec, coef0233);
4950                 snd_hda_set_pin_ctl_cache(codec, mic_pin, PIN_VREF50);
4951                 break;
4952         case 0x10ec0286:
4953         case 0x10ec0288:
4954         case 0x10ec0298:
4955                 snd_hda_set_pin_ctl_cache(codec, hp_pin, 0);
4956                 alc_process_coef_fw(codec, coef0288);
4957                 snd_hda_set_pin_ctl_cache(codec, mic_pin, PIN_VREF50);
4958                 break;
4959         case 0x10ec0292:
4960                 snd_hda_set_pin_ctl_cache(codec, hp_pin, 0);
4961                 alc_process_coef_fw(codec, coef0292);
4962                 break;
4963         case 0x10ec0293:
4964                 /* Set to TRS mode */
4965                 alc_write_coef_idx(codec, 0x45, 0xc429);
4966                 snd_hda_set_pin_ctl_cache(codec, hp_pin, 0);
4967                 alc_process_coef_fw(codec, coef0293);
4968                 snd_hda_set_pin_ctl_cache(codec, mic_pin, PIN_VREF50);
4969                 break;
4970         case 0x10ec0867:
4971                 alc_update_coefex_idx(codec, 0x57, 0x5, 0, 1<<14);
4972                 fallthrough;
4973         case 0x10ec0221:
4974         case 0x10ec0662:
4975                 snd_hda_set_pin_ctl_cache(codec, hp_pin, 0);
4976                 snd_hda_set_pin_ctl_cache(codec, mic_pin, PIN_VREF50);
4977                 break;
4978         case 0x10ec0668:
4979                 alc_write_coef_idx(codec, 0x11, 0x0001);
4980                 snd_hda_set_pin_ctl_cache(codec, hp_pin, 0);
4981                 alc_process_coef_fw(codec, coef0688);
4982                 snd_hda_set_pin_ctl_cache(codec, mic_pin, PIN_VREF50);
4983                 break;
4984         case 0x10ec0215:
4985         case 0x10ec0225:
4986         case 0x10ec0285:
4987         case 0x10ec0295:
4988         case 0x10ec0289:
4989         case 0x10ec0299:
4990                 alc_process_coef_fw(codec, alc225_pre_hsmode);
4991                 alc_update_coef_idx(codec, 0x45, 0x3f<<10, 0x31<<10);
4992                 snd_hda_set_pin_ctl_cache(codec, hp_pin, 0);
4993                 alc_process_coef_fw(codec, coef0225);
4994                 snd_hda_set_pin_ctl_cache(codec, mic_pin, PIN_VREF50);
4995                 break;
4996         }
4997         codec_dbg(codec, "Headset jack set to mic-in mode.\n");
4998 }
4999
5000 static void alc_headset_mode_default(struct hda_codec *codec)
5001 {
5002         static const struct coef_fw coef0225[] = {
5003                 UPDATE_COEF(0x45, 0x3f<<10, 0x30<<10),
5004                 UPDATE_COEF(0x45, 0x3f<<10, 0x31<<10),
5005                 UPDATE_COEF(0x49, 3<<8, 0<<8),
5006                 UPDATE_COEF(0x4a, 3<<4, 3<<4),
5007                 UPDATE_COEF(0x63, 3<<14, 0),
5008                 UPDATE_COEF(0x67, 0xf000, 0x3000),
5009                 {}
5010         };
5011         static const struct coef_fw coef0255[] = {
5012                 WRITE_COEF(0x45, 0xc089),
5013                 WRITE_COEF(0x45, 0xc489),
5014                 WRITE_COEFEX(0x57, 0x03, 0x8ea6),
5015                 WRITE_COEF(0x49, 0x0049),
5016                 {}
5017         };
5018         static const struct coef_fw coef0256[] = {
5019                 WRITE_COEF(0x45, 0xc489),
5020                 WRITE_COEFEX(0x57, 0x03, 0x0da3),
5021                 WRITE_COEF(0x49, 0x0049),
5022                 UPDATE_COEFEX(0x57, 0x05, 1<<14, 0), /* Direct Drive HP Amp control(Set to verb control)*/
5023                 WRITE_COEF(0x06, 0x6100),
5024                 {}
5025         };
5026         static const struct coef_fw coef0233[] = {
5027                 WRITE_COEF(0x06, 0x2100),
5028                 WRITE_COEF(0x32, 0x4ea3),
5029                 {}
5030         };
5031         static const struct coef_fw coef0288[] = {
5032                 UPDATE_COEF(0x4f, 0xfcc0, 0xc400), /* Set to TRS type */
5033                 UPDATE_COEF(0x50, 0x2000, 0x2000),
5034                 UPDATE_COEF(0x56, 0x0006, 0x0006),
5035                 UPDATE_COEF(0x66, 0x0008, 0),
5036                 UPDATE_COEF(0x67, 0x2000, 0),
5037                 {}
5038         };
5039         static const struct coef_fw coef0292[] = {
5040                 WRITE_COEF(0x76, 0x000e),
5041                 WRITE_COEF(0x6c, 0x2400),
5042                 WRITE_COEF(0x6b, 0xc429),
5043                 WRITE_COEF(0x18, 0x7308),
5044                 {}
5045         };
5046         static const struct coef_fw coef0293[] = {
5047                 UPDATE_COEF(0x4a, 0x000f, 0x000e), /* Combo Jack auto detect */
5048                 WRITE_COEF(0x45, 0xC429), /* Set to TRS type */
5049                 UPDATE_COEF(0x1a, 1<<3, 0), /* Combo JD gating without LINE1-VREFO */
5050                 {}
5051         };
5052         static const struct coef_fw coef0688[] = {
5053                 WRITE_COEF(0x11, 0x0041),
5054                 WRITE_COEF(0x15, 0x0d40),
5055                 WRITE_COEF(0xb7, 0x802b),
5056                 {}
5057         };
5058         static const struct coef_fw coef0274[] = {
5059                 WRITE_COEF(0x45, 0x4289),
5060                 UPDATE_COEF(0x4a, 0x0010, 0x0010),
5061                 UPDATE_COEF(0x6b, 0x0f00, 0),
5062                 UPDATE_COEF(0x49, 0x0300, 0x0300),
5063                 {}
5064         };
5065
5066         switch (codec->core.vendor_id) {
5067         case 0x10ec0215:
5068         case 0x10ec0225:
5069         case 0x10ec0285:
5070         case 0x10ec0295:
5071         case 0x10ec0289:
5072         case 0x10ec0299:
5073                 alc_process_coef_fw(codec, alc225_pre_hsmode);
5074                 alc_process_coef_fw(codec, coef0225);
5075                 break;
5076         case 0x10ec0255:
5077                 alc_process_coef_fw(codec, coef0255);
5078                 break;
5079         case 0x10ec0230:
5080         case 0x10ec0236:
5081         case 0x10ec0256:
5082                 alc_write_coef_idx(codec, 0x1b, 0x0e4b);
5083                 alc_write_coef_idx(codec, 0x45, 0xc089);
5084                 msleep(50);
5085                 alc_process_coef_fw(codec, coef0256);
5086                 break;
5087         case 0x10ec0234:
5088         case 0x10ec0274:
5089         case 0x10ec0294:
5090                 alc_process_coef_fw(codec, coef0274);
5091                 break;
5092         case 0x10ec0233:
5093         case 0x10ec0283:
5094                 alc_process_coef_fw(codec, coef0233);
5095                 break;
5096         case 0x10ec0286:
5097         case 0x10ec0288:
5098         case 0x10ec0298:
5099                 alc_process_coef_fw(codec, coef0288);
5100                 break;
5101         case 0x10ec0292:
5102                 alc_process_coef_fw(codec, coef0292);
5103                 break;
5104         case 0x10ec0293:
5105                 alc_process_coef_fw(codec, coef0293);
5106                 break;
5107         case 0x10ec0668:
5108                 alc_process_coef_fw(codec, coef0688);
5109                 break;
5110         case 0x10ec0867:
5111                 alc_update_coefex_idx(codec, 0x57, 0x5, 1<<14, 0);
5112                 break;
5113         }
5114         codec_dbg(codec, "Headset jack set to headphone (default) mode.\n");
5115 }
5116
5117 /* Iphone type */
5118 static void alc_headset_mode_ctia(struct hda_codec *codec)
5119 {
5120         int val;
5121
5122         static const struct coef_fw coef0255[] = {
5123                 WRITE_COEF(0x45, 0xd489), /* Set to CTIA type */
5124                 WRITE_COEF(0x1b, 0x0c2b),
5125                 WRITE_COEFEX(0x57, 0x03, 0x8ea6),
5126                 {}
5127         };
5128         static const struct coef_fw coef0256[] = {
5129                 WRITE_COEF(0x45, 0xd489), /* Set to CTIA type */
5130                 WRITE_COEF(0x1b, 0x0e6b),
5131                 {}
5132         };
5133         static const struct coef_fw coef0233[] = {
5134                 WRITE_COEF(0x45, 0xd429),
5135                 WRITE_COEF(0x1b, 0x0c2b),
5136                 WRITE_COEF(0x32, 0x4ea3),
5137                 {}
5138         };
5139         static const struct coef_fw coef0288[] = {
5140                 UPDATE_COEF(0x50, 0x2000, 0x2000),
5141                 UPDATE_COEF(0x56, 0x0006, 0x0006),
5142                 UPDATE_COEF(0x66, 0x0008, 0),
5143                 UPDATE_COEF(0x67, 0x2000, 0),
5144                 {}
5145         };
5146         static const struct coef_fw coef0292[] = {
5147                 WRITE_COEF(0x6b, 0xd429),
5148                 WRITE_COEF(0x76, 0x0008),
5149                 WRITE_COEF(0x18, 0x7388),
5150                 {}
5151         };
5152         static const struct coef_fw coef0293[] = {
5153                 WRITE_COEF(0x45, 0xd429), /* Set to ctia type */
5154                 UPDATE_COEF(0x10, 7<<8, 7<<8), /* SET Line1 JD to 1 */
5155                 {}
5156         };
5157         static const struct coef_fw coef0688[] = {
5158                 WRITE_COEF(0x11, 0x0001),
5159                 WRITE_COEF(0x15, 0x0d60),
5160                 WRITE_COEF(0xc3, 0x0000),
5161                 {}
5162         };
5163         static const struct coef_fw coef0225_1[] = {
5164                 UPDATE_COEF(0x45, 0x3f<<10, 0x35<<10),
5165                 UPDATE_COEF(0x63, 3<<14, 2<<14),
5166                 {}
5167         };
5168         static const struct coef_fw coef0225_2[] = {
5169                 UPDATE_COEF(0x45, 0x3f<<10, 0x35<<10),
5170                 UPDATE_COEF(0x63, 3<<14, 1<<14),
5171                 {}
5172         };
5173
5174         switch (codec->core.vendor_id) {
5175         case 0x10ec0255:
5176                 alc_process_coef_fw(codec, coef0255);
5177                 break;
5178         case 0x10ec0230:
5179         case 0x10ec0236:
5180         case 0x10ec0256:
5181                 alc_process_coef_fw(codec, coef0256);
5182                 break;
5183         case 0x10ec0234:
5184         case 0x10ec0274:
5185         case 0x10ec0294:
5186                 alc_write_coef_idx(codec, 0x45, 0xd689);
5187                 break;
5188         case 0x10ec0233:
5189         case 0x10ec0283:
5190                 alc_process_coef_fw(codec, coef0233);
5191                 break;
5192         case 0x10ec0298:
5193                 val = alc_read_coef_idx(codec, 0x50);
5194                 if (val & (1 << 12)) {
5195                         alc_update_coef_idx(codec, 0x8e, 0x0070, 0x0020);
5196                         alc_update_coef_idx(codec, 0x4f, 0xfcc0, 0xd400);
5197                         msleep(300);
5198                 } else {
5199                         alc_update_coef_idx(codec, 0x8e, 0x0070, 0x0010);
5200                         alc_update_coef_idx(codec, 0x4f, 0xfcc0, 0xd400);
5201                         msleep(300);
5202                 }
5203                 break;
5204         case 0x10ec0286:
5205         case 0x10ec0288:
5206                 alc_update_coef_idx(codec, 0x4f, 0xfcc0, 0xd400);
5207                 msleep(300);
5208                 alc_process_coef_fw(codec, coef0288);
5209                 break;
5210         case 0x10ec0292:
5211                 alc_process_coef_fw(codec, coef0292);
5212                 break;
5213         case 0x10ec0293:
5214                 alc_process_coef_fw(codec, coef0293);
5215                 break;
5216         case 0x10ec0668:
5217                 alc_process_coef_fw(codec, coef0688);
5218                 break;
5219         case 0x10ec0215:
5220         case 0x10ec0225:
5221         case 0x10ec0285:
5222         case 0x10ec0295:
5223         case 0x10ec0289:
5224         case 0x10ec0299:
5225                 val = alc_read_coef_idx(codec, 0x45);
5226                 if (val & (1 << 9))
5227                         alc_process_coef_fw(codec, coef0225_2);
5228                 else
5229                         alc_process_coef_fw(codec, coef0225_1);
5230                 break;
5231         case 0x10ec0867:
5232                 alc_update_coefex_idx(codec, 0x57, 0x5, 1<<14, 0);
5233                 break;
5234         }
5235         codec_dbg(codec, "Headset jack set to iPhone-style headset mode.\n");
5236 }
5237
5238 /* Nokia type */
5239 static void alc_headset_mode_omtp(struct hda_codec *codec)
5240 {
5241         static const struct coef_fw coef0255[] = {
5242                 WRITE_COEF(0x45, 0xe489), /* Set to OMTP Type */
5243                 WRITE_COEF(0x1b, 0x0c2b),
5244                 WRITE_COEFEX(0x57, 0x03, 0x8ea6),
5245                 {}
5246         };
5247         static const struct coef_fw coef0256[] = {
5248                 WRITE_COEF(0x45, 0xe489), /* Set to OMTP Type */
5249                 WRITE_COEF(0x1b, 0x0e6b),
5250                 {}
5251         };
5252         static const struct coef_fw coef0233[] = {
5253                 WRITE_COEF(0x45, 0xe429),
5254                 WRITE_COEF(0x1b, 0x0c2b),
5255                 WRITE_COEF(0x32, 0x4ea3),
5256                 {}
5257         };
5258         static const struct coef_fw coef0288[] = {
5259                 UPDATE_COEF(0x50, 0x2000, 0x2000),
5260                 UPDATE_COEF(0x56, 0x0006, 0x0006),
5261                 UPDATE_COEF(0x66, 0x0008, 0),
5262                 UPDATE_COEF(0x67, 0x2000, 0),
5263                 {}
5264         };
5265         static const struct coef_fw coef0292[] = {
5266                 WRITE_COEF(0x6b, 0xe429),
5267                 WRITE_COEF(0x76, 0x0008),
5268                 WRITE_COEF(0x18, 0x7388),
5269                 {}
5270         };
5271         static const struct coef_fw coef0293[] = {
5272                 WRITE_COEF(0x45, 0xe429), /* Set to omtp type */
5273                 UPDATE_COEF(0x10, 7<<8, 7<<8), /* SET Line1 JD to 1 */
5274                 {}
5275         };
5276         static const struct coef_fw coef0688[] = {
5277                 WRITE_COEF(0x11, 0x0001),
5278                 WRITE_COEF(0x15, 0x0d50),
5279                 WRITE_COEF(0xc3, 0x0000),
5280                 {}
5281         };
5282         static const struct coef_fw coef0225[] = {
5283                 UPDATE_COEF(0x45, 0x3f<<10, 0x39<<10),
5284                 UPDATE_COEF(0x63, 3<<14, 2<<14),
5285                 {}
5286         };
5287
5288         switch (codec->core.vendor_id) {
5289         case 0x10ec0255:
5290                 alc_process_coef_fw(codec, coef0255);
5291                 break;
5292         case 0x10ec0230:
5293         case 0x10ec0236:
5294         case 0x10ec0256:
5295                 alc_process_coef_fw(codec, coef0256);
5296                 break;
5297         case 0x10ec0234:
5298         case 0x10ec0274:
5299         case 0x10ec0294:
5300                 alc_write_coef_idx(codec, 0x45, 0xe689);
5301                 break;
5302         case 0x10ec0233:
5303         case 0x10ec0283:
5304                 alc_process_coef_fw(codec, coef0233);
5305                 break;
5306         case 0x10ec0298:
5307                 alc_update_coef_idx(codec, 0x8e, 0x0070, 0x0010);/* Headset output enable */
5308                 alc_update_coef_idx(codec, 0x4f, 0xfcc0, 0xe400);
5309                 msleep(300);
5310                 break;
5311         case 0x10ec0286:
5312         case 0x10ec0288:
5313                 alc_update_coef_idx(codec, 0x4f, 0xfcc0, 0xe400);
5314                 msleep(300);
5315                 alc_process_coef_fw(codec, coef0288);
5316                 break;
5317         case 0x10ec0292:
5318                 alc_process_coef_fw(codec, coef0292);
5319                 break;
5320         case 0x10ec0293:
5321                 alc_process_coef_fw(codec, coef0293);
5322                 break;
5323         case 0x10ec0668:
5324                 alc_process_coef_fw(codec, coef0688);
5325                 break;
5326         case 0x10ec0215:
5327         case 0x10ec0225:
5328         case 0x10ec0285:
5329         case 0x10ec0295:
5330         case 0x10ec0289:
5331         case 0x10ec0299:
5332                 alc_process_coef_fw(codec, coef0225);
5333                 break;
5334         }
5335         codec_dbg(codec, "Headset jack set to Nokia-style headset mode.\n");
5336 }
5337
5338 static void alc_determine_headset_type(struct hda_codec *codec)
5339 {
5340         int val;
5341         bool is_ctia = false;
5342         struct alc_spec *spec = codec->spec;
5343         static const struct coef_fw coef0255[] = {
5344                 WRITE_COEF(0x45, 0xd089), /* combo jack auto switch control(Check type)*/
5345                 WRITE_COEF(0x49, 0x0149), /* combo jack auto switch control(Vref
5346  conteol) */
5347                 {}
5348         };
5349         static const struct coef_fw coef0288[] = {
5350                 UPDATE_COEF(0x4f, 0xfcc0, 0xd400), /* Check Type */
5351                 {}
5352         };
5353         static const struct coef_fw coef0298[] = {
5354                 UPDATE_COEF(0x50, 0x2000, 0x2000),
5355                 UPDATE_COEF(0x56, 0x0006, 0x0006),
5356                 UPDATE_COEF(0x66, 0x0008, 0),
5357                 UPDATE_COEF(0x67, 0x2000, 0),
5358                 UPDATE_COEF(0x19, 0x1300, 0x1300),
5359                 {}
5360         };
5361         static const struct coef_fw coef0293[] = {
5362                 UPDATE_COEF(0x4a, 0x000f, 0x0008), /* Combo Jack auto detect */
5363                 WRITE_COEF(0x45, 0xD429), /* Set to ctia type */
5364                 {}
5365         };
5366         static const struct coef_fw coef0688[] = {
5367                 WRITE_COEF(0x11, 0x0001),
5368                 WRITE_COEF(0xb7, 0x802b),
5369                 WRITE_COEF(0x15, 0x0d60),
5370                 WRITE_COEF(0xc3, 0x0c00),
5371                 {}
5372         };
5373         static const struct coef_fw coef0274[] = {
5374                 UPDATE_COEF(0x4a, 0x0010, 0),
5375                 UPDATE_COEF(0x4a, 0x8000, 0),
5376                 WRITE_COEF(0x45, 0xd289),
5377                 UPDATE_COEF(0x49, 0x0300, 0x0300),
5378                 {}
5379         };
5380
5381         if (spec->no_internal_mic_pin) {
5382                 alc_update_coef_idx(codec, 0x45, 0xf<<12 | 1<<10, 5<<12);
5383                 return;
5384         }
5385
5386         switch (codec->core.vendor_id) {
5387         case 0x10ec0255:
5388                 alc_process_coef_fw(codec, coef0255);
5389                 msleep(300);
5390                 val = alc_read_coef_idx(codec, 0x46);
5391                 is_ctia = (val & 0x0070) == 0x0070;
5392                 break;
5393         case 0x10ec0230:
5394         case 0x10ec0236:
5395         case 0x10ec0256:
5396                 alc_write_coef_idx(codec, 0x1b, 0x0e4b);
5397                 alc_write_coef_idx(codec, 0x06, 0x6104);
5398                 alc_write_coefex_idx(codec, 0x57, 0x3, 0x09a3);
5399
5400                 snd_hda_codec_write(codec, 0x21, 0,
5401                             AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);
5402                 msleep(80);
5403                 snd_hda_codec_write(codec, 0x21, 0,
5404                             AC_VERB_SET_PIN_WIDGET_CONTROL, 0x0);
5405
5406                 alc_process_coef_fw(codec, coef0255);
5407                 msleep(300);
5408                 val = alc_read_coef_idx(codec, 0x46);
5409                 is_ctia = (val & 0x0070) == 0x0070;
5410
5411                 alc_write_coefex_idx(codec, 0x57, 0x3, 0x0da3);
5412                 alc_update_coefex_idx(codec, 0x57, 0x5, 1<<14, 0);
5413
5414                 snd_hda_codec_write(codec, 0x21, 0,
5415                             AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT);
5416                 msleep(80);
5417                 snd_hda_codec_write(codec, 0x21, 0,
5418                             AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE);
5419                 break;
5420         case 0x10ec0234:
5421         case 0x10ec0274:
5422         case 0x10ec0294:
5423                 alc_process_coef_fw(codec, coef0274);
5424                 msleep(850);
5425                 val = alc_read_coef_idx(codec, 0x46);
5426                 is_ctia = (val & 0x00f0) == 0x00f0;
5427                 break;
5428         case 0x10ec0233:
5429         case 0x10ec0283:
5430                 alc_write_coef_idx(codec, 0x45, 0xd029);
5431                 msleep(300);
5432                 val = alc_read_coef_idx(codec, 0x46);
5433                 is_ctia = (val & 0x0070) == 0x0070;
5434                 break;
5435         case 0x10ec0298:
5436                 snd_hda_codec_write(codec, 0x21, 0,
5437                             AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);
5438                 msleep(100);
5439                 snd_hda_codec_write(codec, 0x21, 0,
5440                             AC_VERB_SET_PIN_WIDGET_CONTROL, 0x0);
5441                 msleep(200);
5442
5443                 val = alc_read_coef_idx(codec, 0x50);
5444                 if (val & (1 << 12)) {
5445                         alc_update_coef_idx(codec, 0x8e, 0x0070, 0x0020);
5446                         alc_process_coef_fw(codec, coef0288);
5447                         msleep(350);
5448                         val = alc_read_coef_idx(codec, 0x50);
5449                         is_ctia = (val & 0x0070) == 0x0070;
5450                 } else {
5451                         alc_update_coef_idx(codec, 0x8e, 0x0070, 0x0010);
5452                         alc_process_coef_fw(codec, coef0288);
5453                         msleep(350);
5454                         val = alc_read_coef_idx(codec, 0x50);
5455                         is_ctia = (val & 0x0070) == 0x0070;
5456                 }
5457                 alc_process_coef_fw(codec, coef0298);
5458                 snd_hda_codec_write(codec, 0x21, 0,
5459                             AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP);
5460                 msleep(75);
5461                 snd_hda_codec_write(codec, 0x21, 0,
5462                             AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE);
5463                 break;
5464         case 0x10ec0286:
5465         case 0x10ec0288:
5466                 alc_process_coef_fw(codec, coef0288);
5467                 msleep(350);
5468                 val = alc_read_coef_idx(codec, 0x50);
5469                 is_ctia = (val & 0x0070) == 0x0070;
5470                 break;
5471         case 0x10ec0292:
5472                 alc_write_coef_idx(codec, 0x6b, 0xd429);
5473                 msleep(300);
5474                 val = alc_read_coef_idx(codec, 0x6c);
5475                 is_ctia = (val & 0x001c) == 0x001c;
5476                 break;
5477         case 0x10ec0293:
5478                 alc_process_coef_fw(codec, coef0293);
5479                 msleep(300);
5480                 val = alc_read_coef_idx(codec, 0x46);
5481                 is_ctia = (val & 0x0070) == 0x0070;
5482                 break;
5483         case 0x10ec0668:
5484                 alc_process_coef_fw(codec, coef0688);
5485                 msleep(300);
5486                 val = alc_read_coef_idx(codec, 0xbe);
5487                 is_ctia = (val & 0x1c02) == 0x1c02;
5488                 break;
5489         case 0x10ec0215:
5490         case 0x10ec0225:
5491         case 0x10ec0285:
5492         case 0x10ec0295:
5493         case 0x10ec0289:
5494         case 0x10ec0299:
5495                 snd_hda_codec_write(codec, 0x21, 0,
5496                             AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);
5497                 msleep(80);
5498                 snd_hda_codec_write(codec, 0x21, 0,
5499                             AC_VERB_SET_PIN_WIDGET_CONTROL, 0x0);
5500
5501                 alc_process_coef_fw(codec, alc225_pre_hsmode);
5502                 alc_update_coef_idx(codec, 0x67, 0xf000, 0x1000);
5503                 val = alc_read_coef_idx(codec, 0x45);
5504                 if (val & (1 << 9)) {
5505                         alc_update_coef_idx(codec, 0x45, 0x3f<<10, 0x34<<10);
5506                         alc_update_coef_idx(codec, 0x49, 3<<8, 2<<8);
5507                         msleep(800);
5508                         val = alc_read_coef_idx(codec, 0x46);
5509                         is_ctia = (val & 0x00f0) == 0x00f0;
5510                 } else {
5511                         alc_update_coef_idx(codec, 0x45, 0x3f<<10, 0x34<<10);
5512                         alc_update_coef_idx(codec, 0x49, 3<<8, 1<<8);
5513                         msleep(800);
5514                         val = alc_read_coef_idx(codec, 0x46);
5515                         is_ctia = (val & 0x00f0) == 0x00f0;
5516                 }
5517                 alc_update_coef_idx(codec, 0x4a, 7<<6, 7<<6);
5518                 alc_update_coef_idx(codec, 0x4a, 3<<4, 3<<4);
5519                 alc_update_coef_idx(codec, 0x67, 0xf000, 0x3000);
5520
5521                 snd_hda_codec_write(codec, 0x21, 0,
5522                             AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT);
5523                 msleep(80);
5524                 snd_hda_codec_write(codec, 0x21, 0,
5525                             AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE);
5526                 break;
5527         case 0x10ec0867:
5528                 is_ctia = true;
5529                 break;
5530         }
5531
5532         codec_dbg(codec, "Headset jack detected iPhone-style headset: %s\n",
5533                     is_ctia ? "yes" : "no");
5534         spec->current_headset_type = is_ctia ? ALC_HEADSET_TYPE_CTIA : ALC_HEADSET_TYPE_OMTP;
5535 }
5536
5537 static void alc_update_headset_mode(struct hda_codec *codec)
5538 {
5539         struct alc_spec *spec = codec->spec;
5540
5541         hda_nid_t mux_pin = spec->gen.imux_pins[spec->gen.cur_mux[0]];
5542         hda_nid_t hp_pin = alc_get_hp_pin(spec);
5543
5544         int new_headset_mode;
5545
5546         if (!snd_hda_jack_detect(codec, hp_pin))
5547                 new_headset_mode = ALC_HEADSET_MODE_UNPLUGGED;
5548         else if (mux_pin == spec->headset_mic_pin)
5549                 new_headset_mode = ALC_HEADSET_MODE_HEADSET;
5550         else if (mux_pin == spec->headphone_mic_pin)
5551                 new_headset_mode = ALC_HEADSET_MODE_MIC;
5552         else
5553                 new_headset_mode = ALC_HEADSET_MODE_HEADPHONE;
5554
5555         if (new_headset_mode == spec->current_headset_mode) {
5556                 snd_hda_gen_update_outputs(codec);
5557                 return;
5558         }
5559
5560         switch (new_headset_mode) {
5561         case ALC_HEADSET_MODE_UNPLUGGED:
5562                 alc_headset_mode_unplugged(codec);
5563                 spec->current_headset_mode = ALC_HEADSET_MODE_UNKNOWN;
5564                 spec->current_headset_type = ALC_HEADSET_TYPE_UNKNOWN;
5565                 spec->gen.hp_jack_present = false;
5566                 break;
5567         case ALC_HEADSET_MODE_HEADSET:
5568                 if (spec->current_headset_type == ALC_HEADSET_TYPE_UNKNOWN)
5569                         alc_determine_headset_type(codec);
5570                 if (spec->current_headset_type == ALC_HEADSET_TYPE_CTIA)
5571                         alc_headset_mode_ctia(codec);
5572                 else if (spec->current_headset_type == ALC_HEADSET_TYPE_OMTP)
5573                         alc_headset_mode_omtp(codec);
5574                 spec->gen.hp_jack_present = true;
5575                 break;
5576         case ALC_HEADSET_MODE_MIC:
5577                 alc_headset_mode_mic_in(codec, hp_pin, spec->headphone_mic_pin);
5578                 spec->gen.hp_jack_present = false;
5579                 break;
5580         case ALC_HEADSET_MODE_HEADPHONE:
5581                 alc_headset_mode_default(codec);
5582                 spec->gen.hp_jack_present = true;
5583                 break;
5584         }
5585         if (new_headset_mode != ALC_HEADSET_MODE_MIC) {
5586                 snd_hda_set_pin_ctl_cache(codec, hp_pin,
5587                                           AC_PINCTL_OUT_EN | AC_PINCTL_HP_EN);
5588                 if (spec->headphone_mic_pin && spec->headphone_mic_pin != hp_pin)
5589                         snd_hda_set_pin_ctl_cache(codec, spec->headphone_mic_pin,
5590                                                   PIN_VREFHIZ);
5591         }
5592         spec->current_headset_mode = new_headset_mode;
5593
5594         snd_hda_gen_update_outputs(codec);
5595 }
5596
5597 static void alc_update_headset_mode_hook(struct hda_codec *codec,
5598                                          struct snd_kcontrol *kcontrol,
5599                                          struct snd_ctl_elem_value *ucontrol)
5600 {
5601         alc_update_headset_mode(codec);
5602 }
5603
5604 static void alc_update_headset_jack_cb(struct hda_codec *codec,
5605                                        struct hda_jack_callback *jack)
5606 {
5607         snd_hda_gen_hp_automute(codec, jack);
5608         alc_update_headset_mode(codec);
5609 }
5610
5611 static void alc_probe_headset_mode(struct hda_codec *codec)
5612 {
5613         int i;
5614         struct alc_spec *spec = codec->spec;
5615         struct auto_pin_cfg *cfg = &spec->gen.autocfg;
5616
5617         /* Find mic pins */
5618         for (i = 0; i < cfg->num_inputs; i++) {
5619                 if (cfg->inputs[i].is_headset_mic && !spec->headset_mic_pin)
5620                         spec->headset_mic_pin = cfg->inputs[i].pin;
5621                 if (cfg->inputs[i].is_headphone_mic && !spec->headphone_mic_pin)
5622                         spec->headphone_mic_pin = cfg->inputs[i].pin;
5623         }
5624
5625         WARN_ON(spec->gen.cap_sync_hook);
5626         spec->gen.cap_sync_hook = alc_update_headset_mode_hook;
5627         spec->gen.automute_hook = alc_update_headset_mode;
5628         spec->gen.hp_automute_hook = alc_update_headset_jack_cb;
5629 }
5630
5631 static void alc_fixup_headset_mode(struct hda_codec *codec,
5632                                 const struct hda_fixup *fix, int action)
5633 {
5634         struct alc_spec *spec = codec->spec;
5635
5636         switch (action) {
5637         case HDA_FIXUP_ACT_PRE_PROBE:
5638                 spec->parse_flags |= HDA_PINCFG_HEADSET_MIC | HDA_PINCFG_HEADPHONE_MIC;
5639                 break;
5640         case HDA_FIXUP_ACT_PROBE:
5641                 alc_probe_headset_mode(codec);
5642                 break;
5643         case HDA_FIXUP_ACT_INIT:
5644                 if (is_s3_resume(codec) || is_s4_resume(codec)) {
5645                         spec->current_headset_mode = ALC_HEADSET_MODE_UNKNOWN;
5646                         spec->current_headset_type = ALC_HEADSET_TYPE_UNKNOWN;
5647                 }
5648                 alc_update_headset_mode(codec);
5649                 break;
5650         }
5651 }
5652
5653 static void alc_fixup_headset_mode_no_hp_mic(struct hda_codec *codec,
5654                                 const struct hda_fixup *fix, int action)
5655 {
5656         if (action == HDA_FIXUP_ACT_PRE_PROBE) {
5657                 struct alc_spec *spec = codec->spec;
5658                 spec->parse_flags |= HDA_PINCFG_HEADSET_MIC;
5659         }
5660         else
5661                 alc_fixup_headset_mode(codec, fix, action);
5662 }
5663
5664 static void alc255_set_default_jack_type(struct hda_codec *codec)
5665 {
5666         /* Set to iphone type */
5667         static const struct coef_fw alc255fw[] = {
5668                 WRITE_COEF(0x1b, 0x880b),
5669                 WRITE_COEF(0x45, 0xd089),
5670                 WRITE_COEF(0x1b, 0x080b),
5671                 WRITE_COEF(0x46, 0x0004),
5672                 WRITE_COEF(0x1b, 0x0c0b),
5673                 {}
5674         };
5675         static const struct coef_fw alc256fw[] = {
5676                 WRITE_COEF(0x1b, 0x884b),
5677                 WRITE_COEF(0x45, 0xd089),
5678                 WRITE_COEF(0x1b, 0x084b),
5679                 WRITE_COEF(0x46, 0x0004),
5680                 WRITE_COEF(0x1b, 0x0c4b),
5681                 {}
5682         };
5683         switch (codec->core.vendor_id) {
5684         case 0x10ec0255:
5685                 alc_process_coef_fw(codec, alc255fw);
5686                 break;
5687         case 0x10ec0230:
5688         case 0x10ec0236:
5689         case 0x10ec0256:
5690                 alc_process_coef_fw(codec, alc256fw);
5691                 break;
5692         }
5693         msleep(30);
5694 }
5695
5696 static void alc_fixup_headset_mode_alc255(struct hda_codec *codec,
5697                                 const struct hda_fixup *fix, int action)
5698 {
5699         if (action == HDA_FIXUP_ACT_PRE_PROBE) {
5700                 alc255_set_default_jack_type(codec);
5701         }
5702         alc_fixup_headset_mode(codec, fix, action);
5703 }
5704
5705 static void alc_fixup_headset_mode_alc255_no_hp_mic(struct hda_codec *codec,
5706                                 const struct hda_fixup *fix, int action)
5707 {
5708         if (action == HDA_FIXUP_ACT_PRE_PROBE) {
5709                 struct alc_spec *spec = codec->spec;
5710                 spec->parse_flags |= HDA_PINCFG_HEADSET_MIC;
5711                 alc255_set_default_jack_type(codec);
5712         }
5713         else
5714                 alc_fixup_headset_mode(codec, fix, action);
5715 }
5716
5717 static void alc288_update_headset_jack_cb(struct hda_codec *codec,
5718                                        struct hda_jack_callback *jack)
5719 {
5720         struct alc_spec *spec = codec->spec;
5721
5722         alc_update_headset_jack_cb(codec, jack);
5723         /* Headset Mic enable or disable, only for Dell Dino */
5724         alc_update_gpio_data(codec, 0x40, spec->gen.hp_jack_present);
5725 }
5726
5727 static void alc_fixup_headset_mode_dell_alc288(struct hda_codec *codec,
5728                                 const struct hda_fixup *fix, int action)
5729 {
5730         alc_fixup_headset_mode(codec, fix, action);
5731         if (action == HDA_FIXUP_ACT_PROBE) {
5732                 struct alc_spec *spec = codec->spec;
5733                 /* toggled via hp_automute_hook */
5734                 spec->gpio_mask |= 0x40;
5735                 spec->gpio_dir |= 0x40;
5736                 spec->gen.hp_automute_hook = alc288_update_headset_jack_cb;
5737         }
5738 }
5739
5740 static void alc_fixup_auto_mute_via_amp(struct hda_codec *codec,
5741                                         const struct hda_fixup *fix, int action)
5742 {
5743         if (action == HDA_FIXUP_ACT_PRE_PROBE) {
5744                 struct alc_spec *spec = codec->spec;
5745                 spec->gen.auto_mute_via_amp = 1;
5746         }
5747 }
5748
5749 static void alc_fixup_no_shutup(struct hda_codec *codec,
5750                                 const struct hda_fixup *fix, int action)
5751 {
5752         if (action == HDA_FIXUP_ACT_PRE_PROBE) {
5753                 struct alc_spec *spec = codec->spec;
5754                 spec->no_shutup_pins = 1;
5755         }
5756 }
5757
5758 static void alc_fixup_disable_aamix(struct hda_codec *codec,
5759                                     const struct hda_fixup *fix, int action)
5760 {
5761         if (action == HDA_FIXUP_ACT_PRE_PROBE) {
5762                 struct alc_spec *spec = codec->spec;
5763                 /* Disable AA-loopback as it causes white noise */
5764                 spec->gen.mixer_nid = 0;
5765         }
5766 }
5767
5768 /* fixup for Thinkpad docks: add dock pins, avoid HP parser fixup */
5769 static void alc_fixup_tpt440_dock(struct hda_codec *codec,
5770                                   const struct hda_fixup *fix, int action)
5771 {
5772         static const struct hda_pintbl pincfgs[] = {
5773                 { 0x16, 0x21211010 }, /* dock headphone */
5774                 { 0x19, 0x21a11010 }, /* dock mic */
5775                 { }
5776         };
5777         struct alc_spec *spec = codec->spec;
5778
5779         if (action == HDA_FIXUP_ACT_PRE_PROBE) {
5780                 spec->parse_flags = HDA_PINCFG_NO_HP_FIXUP;
5781                 codec->power_save_node = 0; /* avoid click noises */
5782                 snd_hda_apply_pincfgs(codec, pincfgs);
5783         }
5784 }
5785
5786 static void alc_fixup_tpt470_dock(struct hda_codec *codec,
5787                                   const struct hda_fixup *fix, int action)
5788 {
5789         static const struct hda_pintbl pincfgs[] = {
5790                 { 0x17, 0x21211010 }, /* dock headphone */
5791                 { 0x19, 0x21a11010 }, /* dock mic */
5792                 { }
5793         };
5794         struct alc_spec *spec = codec->spec;
5795
5796         if (action == HDA_FIXUP_ACT_PRE_PROBE) {
5797                 spec->parse_flags = HDA_PINCFG_NO_HP_FIXUP;
5798                 snd_hda_apply_pincfgs(codec, pincfgs);
5799         } else if (action == HDA_FIXUP_ACT_INIT) {
5800                 /* Enable DOCK device */
5801                 snd_hda_codec_write(codec, 0x17, 0,
5802                             AC_VERB_SET_CONFIG_DEFAULT_BYTES_3, 0);
5803                 /* Enable DOCK device */
5804                 snd_hda_codec_write(codec, 0x19, 0,
5805                             AC_VERB_SET_CONFIG_DEFAULT_BYTES_3, 0);
5806         }
5807 }
5808
5809 static void alc_fixup_tpt470_dacs(struct hda_codec *codec,
5810                                   const struct hda_fixup *fix, int action)
5811 {
5812         /* Assure the speaker pin to be coupled with DAC NID 0x03; otherwise
5813          * the speaker output becomes too low by some reason on Thinkpads with
5814          * ALC298 codec
5815          */
5816         static const hda_nid_t preferred_pairs[] = {
5817                 0x14, 0x03, 0x17, 0x02, 0x21, 0x02,
5818                 0
5819         };
5820         struct alc_spec *spec = codec->spec;
5821
5822         if (action == HDA_FIXUP_ACT_PRE_PROBE)
5823                 spec->gen.preferred_dacs = preferred_pairs;
5824 }
5825
5826 static void alc295_fixup_asus_dacs(struct hda_codec *codec,
5827                                    const struct hda_fixup *fix, int action)
5828 {
5829         static const hda_nid_t preferred_pairs[] = {
5830                 0x17, 0x02, 0x21, 0x03, 0
5831         };
5832         struct alc_spec *spec = codec->spec;
5833
5834         if (action == HDA_FIXUP_ACT_PRE_PROBE)
5835                 spec->gen.preferred_dacs = preferred_pairs;
5836 }
5837
5838 static void alc_shutup_dell_xps13(struct hda_codec *codec)
5839 {
5840         struct alc_spec *spec = codec->spec;
5841         int hp_pin = alc_get_hp_pin(spec);
5842
5843         /* Prevent pop noises when headphones are plugged in */
5844         snd_hda_codec_write(codec, hp_pin, 0,
5845                             AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);
5846         msleep(20);
5847 }
5848
5849 static void alc_fixup_dell_xps13(struct hda_codec *codec,
5850                                 const struct hda_fixup *fix, int action)
5851 {
5852         struct alc_spec *spec = codec->spec;
5853         struct hda_input_mux *imux = &spec->gen.input_mux;
5854         int i;
5855
5856         switch (action) {
5857         case HDA_FIXUP_ACT_PRE_PROBE:
5858                 /* mic pin 0x19 must be initialized with Vref Hi-Z, otherwise
5859                  * it causes a click noise at start up
5860                  */
5861                 snd_hda_codec_set_pin_target(codec, 0x19, PIN_VREFHIZ);
5862                 spec->shutup = alc_shutup_dell_xps13;
5863                 break;
5864         case HDA_FIXUP_ACT_PROBE:
5865                 /* Make the internal mic the default input source. */
5866                 for (i = 0; i < imux->num_items; i++) {
5867                         if (spec->gen.imux_pins[i] == 0x12) {
5868                                 spec->gen.cur_mux[0] = i;
5869                                 break;
5870                         }
5871                 }
5872                 break;
5873         }
5874 }
5875
5876 static void alc_fixup_headset_mode_alc662(struct hda_codec *codec,
5877                                 const struct hda_fixup *fix, int action)
5878 {
5879         struct alc_spec *spec = codec->spec;
5880
5881         if (action == HDA_FIXUP_ACT_PRE_PROBE) {
5882                 spec->parse_flags |= HDA_PINCFG_HEADSET_MIC;
5883                 spec->gen.hp_mic = 1; /* Mic-in is same pin as headphone */
5884
5885                 /* Disable boost for mic-in permanently. (This code is only called
5886                    from quirks that guarantee that the headphone is at NID 0x1b.) */
5887                 snd_hda_codec_write(codec, 0x1b, 0, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000);
5888                 snd_hda_override_wcaps(codec, 0x1b, get_wcaps(codec, 0x1b) & ~AC_WCAP_IN_AMP);
5889         } else
5890                 alc_fixup_headset_mode(codec, fix, action);
5891 }
5892
5893 static void alc_fixup_headset_mode_alc668(struct hda_codec *codec,
5894                                 const struct hda_fixup *fix, int action)
5895 {
5896         if (action == HDA_FIXUP_ACT_PRE_PROBE) {
5897                 alc_write_coef_idx(codec, 0xc4, 0x8000);
5898                 alc_update_coef_idx(codec, 0xc2, ~0xfe, 0);
5899                 snd_hda_set_pin_ctl_cache(codec, 0x18, 0);
5900         }
5901         alc_fixup_headset_mode(codec, fix, action);
5902 }
5903
5904 /* Returns the nid of the external mic input pin, or 0 if it cannot be found. */
5905 static int find_ext_mic_pin(struct hda_codec *codec)
5906 {
5907         struct alc_spec *spec = codec->spec;
5908         struct auto_pin_cfg *cfg = &spec->gen.autocfg;
5909         hda_nid_t nid;
5910         unsigned int defcfg;
5911         int i;
5912
5913         for (i = 0; i < cfg->num_inputs; i++) {
5914                 if (cfg->inputs[i].type != AUTO_PIN_MIC)
5915                         continue;
5916                 nid = cfg->inputs[i].pin;
5917                 defcfg = snd_hda_codec_get_pincfg(codec, nid);
5918                 if (snd_hda_get_input_pin_attr(defcfg) == INPUT_PIN_ATTR_INT)
5919                         continue;
5920                 return nid;
5921         }
5922
5923         return 0;
5924 }
5925
5926 static void alc271_hp_gate_mic_jack(struct hda_codec *codec,
5927                                     const struct hda_fixup *fix,
5928                                     int action)
5929 {
5930         struct alc_spec *spec = codec->spec;
5931
5932         if (action == HDA_FIXUP_ACT_PROBE) {
5933                 int mic_pin = find_ext_mic_pin(codec);
5934                 int hp_pin = alc_get_hp_pin(spec);
5935
5936                 if (snd_BUG_ON(!mic_pin || !hp_pin))
5937                         return;
5938                 snd_hda_jack_set_gating_jack(codec, mic_pin, hp_pin);
5939         }
5940 }
5941
5942 static void alc269_fixup_limit_int_mic_boost(struct hda_codec *codec,
5943                                              const struct hda_fixup *fix,
5944                                              int action)
5945 {
5946         struct alc_spec *spec = codec->spec;
5947         struct auto_pin_cfg *cfg = &spec->gen.autocfg;
5948         int i;
5949
5950         /* The mic boosts on level 2 and 3 are too noisy
5951            on the internal mic input.
5952            Therefore limit the boost to 0 or 1. */
5953
5954         if (action != HDA_FIXUP_ACT_PROBE)
5955                 return;
5956
5957         for (i = 0; i < cfg->num_inputs; i++) {
5958                 hda_nid_t nid = cfg->inputs[i].pin;
5959                 unsigned int defcfg;
5960                 if (cfg->inputs[i].type != AUTO_PIN_MIC)
5961                         continue;
5962                 defcfg = snd_hda_codec_get_pincfg(codec, nid);
5963                 if (snd_hda_get_input_pin_attr(defcfg) != INPUT_PIN_ATTR_INT)
5964                         continue;
5965
5966                 snd_hda_override_amp_caps(codec, nid, HDA_INPUT,
5967                                           (0x00 << AC_AMPCAP_OFFSET_SHIFT) |
5968                                           (0x01 << AC_AMPCAP_NUM_STEPS_SHIFT) |
5969                                           (0x2f << AC_AMPCAP_STEP_SIZE_SHIFT) |
5970                                           (0 << AC_AMPCAP_MUTE_SHIFT));
5971         }
5972 }
5973
5974 static void alc283_hp_automute_hook(struct hda_codec *codec,
5975                                     struct hda_jack_callback *jack)
5976 {
5977         struct alc_spec *spec = codec->spec;
5978         int vref;
5979
5980         msleep(200);
5981         snd_hda_gen_hp_automute(codec, jack);
5982
5983         vref = spec->gen.hp_jack_present ? PIN_VREF80 : 0;
5984
5985         msleep(600);
5986         snd_hda_codec_write(codec, 0x19, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
5987                             vref);
5988 }
5989
5990 static void alc283_fixup_chromebook(struct hda_codec *codec,
5991                                     const struct hda_fixup *fix, int action)
5992 {
5993         struct alc_spec *spec = codec->spec;
5994
5995         switch (action) {
5996         case HDA_FIXUP_ACT_PRE_PROBE:
5997                 snd_hda_override_wcaps(codec, 0x03, 0);
5998                 /* Disable AA-loopback as it causes white noise */
5999                 spec->gen.mixer_nid = 0;
6000                 break;
6001         case HDA_FIXUP_ACT_INIT:
6002                 /* MIC2-VREF control */
6003                 /* Set to manual mode */
6004                 alc_update_coef_idx(codec, 0x06, 0x000c, 0);
6005                 /* Enable Line1 input control by verb */
6006                 alc_update_coef_idx(codec, 0x1a, 0, 1 << 4);
6007                 break;
6008         }
6009 }
6010
6011 static void alc283_fixup_sense_combo_jack(struct hda_codec *codec,
6012                                     const struct hda_fixup *fix, int action)
6013 {
6014         struct alc_spec *spec = codec->spec;
6015
6016         switch (action) {
6017         case HDA_FIXUP_ACT_PRE_PROBE:
6018                 spec->gen.hp_automute_hook = alc283_hp_automute_hook;
6019                 break;
6020         case HDA_FIXUP_ACT_INIT:
6021                 /* MIC2-VREF control */
6022                 /* Set to manual mode */
6023                 alc_update_coef_idx(codec, 0x06, 0x000c, 0);
6024                 break;
6025         }
6026 }
6027
6028 /* mute tablet speaker pin (0x14) via dock plugging in addition */
6029 static void asus_tx300_automute(struct hda_codec *codec)
6030 {
6031         struct alc_spec *spec = codec->spec;
6032         snd_hda_gen_update_outputs(codec);
6033         if (snd_hda_jack_detect(codec, 0x1b))
6034                 spec->gen.mute_bits |= (1ULL << 0x14);
6035 }
6036
6037 static void alc282_fixup_asus_tx300(struct hda_codec *codec,
6038                                     const struct hda_fixup *fix, int action)
6039 {
6040         struct alc_spec *spec = codec->spec;
6041         static const struct hda_pintbl dock_pins[] = {
6042                 { 0x1b, 0x21114000 }, /* dock speaker pin */
6043                 {}
6044         };
6045
6046         switch (action) {
6047         case HDA_FIXUP_ACT_PRE_PROBE:
6048                 spec->init_amp = ALC_INIT_DEFAULT;
6049                 /* TX300 needs to set up GPIO2 for the speaker amp */
6050                 alc_setup_gpio(codec, 0x04);
6051                 snd_hda_apply_pincfgs(codec, dock_pins);
6052                 spec->gen.auto_mute_via_amp = 1;
6053                 spec->gen.automute_hook = asus_tx300_automute;
6054                 snd_hda_jack_detect_enable_callback(codec, 0x1b,
6055                                                     snd_hda_gen_hp_automute);
6056                 break;
6057         case HDA_FIXUP_ACT_PROBE:
6058                 spec->init_amp = ALC_INIT_DEFAULT;
6059                 break;
6060         case HDA_FIXUP_ACT_BUILD:
6061                 /* this is a bit tricky; give more sane names for the main
6062                  * (tablet) speaker and the dock speaker, respectively
6063                  */
6064                 rename_ctl(codec, "Speaker Playback Switch",
6065                            "Dock Speaker Playback Switch");
6066                 rename_ctl(codec, "Bass Speaker Playback Switch",
6067                            "Speaker Playback Switch");
6068                 break;
6069         }
6070 }
6071
6072 static void alc290_fixup_mono_speakers(struct hda_codec *codec,
6073                                        const struct hda_fixup *fix, int action)
6074 {
6075         if (action == HDA_FIXUP_ACT_PRE_PROBE) {
6076                 /* DAC node 0x03 is giving mono output. We therefore want to
6077                    make sure 0x14 (front speaker) and 0x15 (headphones) use the
6078                    stereo DAC, while leaving 0x17 (bass speaker) for node 0x03. */
6079                 static const hda_nid_t conn1[] = { 0x0c };
6080                 snd_hda_override_conn_list(codec, 0x14, ARRAY_SIZE(conn1), conn1);
6081                 snd_hda_override_conn_list(codec, 0x15, ARRAY_SIZE(conn1), conn1);
6082         }
6083 }
6084
6085 static void alc298_fixup_speaker_volume(struct hda_codec *codec,
6086                                         const struct hda_fixup *fix, int action)
6087 {
6088         if (action == HDA_FIXUP_ACT_PRE_PROBE) {
6089                 /* The speaker is routed to the Node 0x06 by a mistake, as a result
6090                    we can't adjust the speaker's volume since this node does not has
6091                    Amp-out capability. we change the speaker's route to:
6092                    Node 0x02 (Audio Output) -> Node 0x0c (Audio Mixer) -> Node 0x17 (
6093                    Pin Complex), since Node 0x02 has Amp-out caps, we can adjust
6094                    speaker's volume now. */
6095
6096                 static const hda_nid_t conn1[] = { 0x0c };
6097                 snd_hda_override_conn_list(codec, 0x17, ARRAY_SIZE(conn1), conn1);
6098         }
6099 }
6100
6101 /* disable DAC3 (0x06) selection on NID 0x17 as it has no volume amp control */
6102 static void alc295_fixup_disable_dac3(struct hda_codec *codec,
6103                                       const struct hda_fixup *fix, int action)
6104 {
6105         if (action == HDA_FIXUP_ACT_PRE_PROBE) {
6106                 static const hda_nid_t conn[] = { 0x02, 0x03 };
6107                 snd_hda_override_conn_list(codec, 0x17, ARRAY_SIZE(conn), conn);
6108         }
6109 }
6110
6111 /* force NID 0x17 (Bass Speaker) to DAC1 to share it with the main speaker */
6112 static void alc285_fixup_speaker2_to_dac1(struct hda_codec *codec,
6113                                           const struct hda_fixup *fix, int action)
6114 {
6115         if (action == HDA_FIXUP_ACT_PRE_PROBE) {
6116                 static const hda_nid_t conn[] = { 0x02 };
6117                 snd_hda_override_conn_list(codec, 0x17, ARRAY_SIZE(conn), conn);
6118         }
6119 }
6120
6121 /* Hook to update amp GPIO4 for automute */
6122 static void alc280_hp_gpio4_automute_hook(struct hda_codec *codec,
6123                                           struct hda_jack_callback *jack)
6124 {
6125         struct alc_spec *spec = codec->spec;
6126
6127         snd_hda_gen_hp_automute(codec, jack);
6128         /* mute_led_polarity is set to 0, so we pass inverted value here */
6129         alc_update_gpio_led(codec, 0x10, spec->mute_led_polarity,
6130                             !spec->gen.hp_jack_present);
6131 }
6132
6133 /* Manage GPIOs for HP EliteBook Folio 9480m.
6134  *
6135  * GPIO4 is the headphone amplifier power control
6136  * GPIO3 is the audio output mute indicator LED
6137  */
6138
6139 static void alc280_fixup_hp_9480m(struct hda_codec *codec,
6140                                   const struct hda_fixup *fix,
6141                                   int action)
6142 {
6143         struct alc_spec *spec = codec->spec;
6144
6145         alc_fixup_hp_gpio_led(codec, action, 0x08, 0);
6146         if (action == HDA_FIXUP_ACT_PRE_PROBE) {
6147                 /* amp at GPIO4; toggled via alc280_hp_gpio4_automute_hook() */
6148                 spec->gpio_mask |= 0x10;
6149                 spec->gpio_dir |= 0x10;
6150                 spec->gen.hp_automute_hook = alc280_hp_gpio4_automute_hook;
6151         }
6152 }
6153
6154 static void alc275_fixup_gpio4_off(struct hda_codec *codec,
6155                                    const struct hda_fixup *fix,
6156                                    int action)
6157 {
6158         struct alc_spec *spec = codec->spec;
6159
6160         if (action == HDA_FIXUP_ACT_PRE_PROBE) {
6161                 spec->gpio_mask |= 0x04;
6162                 spec->gpio_dir |= 0x04;
6163                 /* set data bit low */
6164         }
6165 }
6166
6167 /* Quirk for Thinkpad X1 7th and 8th Gen
6168  * The following fixed routing needed
6169  * DAC1 (NID 0x02) -> Speaker (NID 0x14); some eq applied secretly
6170  * DAC2 (NID 0x03) -> Bass (NID 0x17) & Headphone (NID 0x21); sharing a DAC
6171  * DAC3 (NID 0x06) -> Unused, due to the lack of volume amp
6172  */
6173 static void alc285_fixup_thinkpad_x1_gen7(struct hda_codec *codec,
6174                                           const struct hda_fixup *fix, int action)
6175 {
6176         static const hda_nid_t conn[] = { 0x02, 0x03 }; /* exclude 0x06 */
6177         static const hda_nid_t preferred_pairs[] = {
6178                 0x14, 0x02, 0x17, 0x03, 0x21, 0x03, 0
6179         };
6180         struct alc_spec *spec = codec->spec;
6181
6182         switch (action) {
6183         case HDA_FIXUP_ACT_PRE_PROBE:
6184                 snd_hda_override_conn_list(codec, 0x17, ARRAY_SIZE(conn), conn);
6185                 spec->gen.preferred_dacs = preferred_pairs;
6186                 break;
6187         case HDA_FIXUP_ACT_BUILD:
6188                 /* The generic parser creates somewhat unintuitive volume ctls
6189                  * with the fixed routing above, and the shared DAC2 may be
6190                  * confusing for PA.
6191                  * Rename those to unique names so that PA doesn't touch them
6192                  * and use only Master volume.
6193                  */
6194                 rename_ctl(codec, "Front Playback Volume", "DAC1 Playback Volume");
6195                 rename_ctl(codec, "Bass Speaker Playback Volume", "DAC2 Playback Volume");
6196                 break;
6197         }
6198 }
6199
6200 static void alc233_alc662_fixup_lenovo_dual_codecs(struct hda_codec *codec,
6201                                          const struct hda_fixup *fix,
6202                                          int action)
6203 {
6204         alc_fixup_dual_codecs(codec, fix, action);
6205         switch (action) {
6206         case HDA_FIXUP_ACT_PRE_PROBE:
6207                 /* override card longname to provide a unique UCM profile */
6208                 strcpy(codec->card->longname, "HDAudio-Lenovo-DualCodecs");
6209                 break;
6210         case HDA_FIXUP_ACT_BUILD:
6211                 /* rename Capture controls depending on the codec */
6212                 rename_ctl(codec, "Capture Volume",
6213                            codec->addr == 0 ?
6214                            "Rear-Panel Capture Volume" :
6215                            "Front-Panel Capture Volume");
6216                 rename_ctl(codec, "Capture Switch",
6217                            codec->addr == 0 ?
6218                            "Rear-Panel Capture Switch" :
6219                            "Front-Panel Capture Switch");
6220                 break;
6221         }
6222 }
6223
6224 static void alc225_fixup_s3_pop_noise(struct hda_codec *codec,
6225                                       const struct hda_fixup *fix, int action)
6226 {
6227         if (action != HDA_FIXUP_ACT_PRE_PROBE)
6228                 return;
6229
6230         codec->power_save_node = 1;
6231 }
6232
6233 /* Forcibly assign NID 0x03 to HP/LO while NID 0x02 to SPK for EQ */
6234 static void alc274_fixup_bind_dacs(struct hda_codec *codec,
6235                                     const struct hda_fixup *fix, int action)
6236 {
6237         struct alc_spec *spec = codec->spec;
6238         static const hda_nid_t preferred_pairs[] = {
6239                 0x21, 0x03, 0x1b, 0x03, 0x16, 0x02,
6240                 0
6241         };
6242
6243         if (action != HDA_FIXUP_ACT_PRE_PROBE)
6244                 return;
6245
6246         spec->gen.preferred_dacs = preferred_pairs;
6247         spec->gen.auto_mute_via_amp = 1;
6248         codec->power_save_node = 0;
6249 }
6250
6251 /* avoid DAC 0x06 for bass speaker 0x17; it has no volume control */
6252 static void alc289_fixup_asus_ga401(struct hda_codec *codec,
6253                                     const struct hda_fixup *fix, int action)
6254 {
6255         static const hda_nid_t preferred_pairs[] = {
6256                 0x14, 0x02, 0x17, 0x02, 0x21, 0x03, 0
6257         };
6258         struct alc_spec *spec = codec->spec;
6259
6260         if (action == HDA_FIXUP_ACT_PRE_PROBE) {
6261                 spec->gen.preferred_dacs = preferred_pairs;
6262                 spec->gen.obey_preferred_dacs = 1;
6263         }
6264 }
6265
6266 /* The DAC of NID 0x3 will introduce click/pop noise on headphones, so invalidate it */
6267 static void alc285_fixup_invalidate_dacs(struct hda_codec *codec,
6268                               const struct hda_fixup *fix, int action)
6269 {
6270         if (action != HDA_FIXUP_ACT_PRE_PROBE)
6271                 return;
6272
6273         snd_hda_override_wcaps(codec, 0x03, 0);
6274 }
6275
6276 static void alc_combo_jack_hp_jd_restart(struct hda_codec *codec)
6277 {
6278         switch (codec->core.vendor_id) {
6279         case 0x10ec0274:
6280         case 0x10ec0294:
6281         case 0x10ec0225:
6282         case 0x10ec0295:
6283         case 0x10ec0299:
6284                 alc_update_coef_idx(codec, 0x4a, 0x8000, 1 << 15); /* Reset HP JD */
6285                 alc_update_coef_idx(codec, 0x4a, 0x8000, 0 << 15);
6286                 break;
6287         case 0x10ec0230:
6288         case 0x10ec0235:
6289         case 0x10ec0236:
6290         case 0x10ec0255:
6291         case 0x10ec0256:
6292                 alc_update_coef_idx(codec, 0x1b, 0x8000, 1 << 15); /* Reset HP JD */
6293                 alc_update_coef_idx(codec, 0x1b, 0x8000, 0 << 15);
6294                 break;
6295         }
6296 }
6297
6298 static void alc295_fixup_chromebook(struct hda_codec *codec,
6299                                     const struct hda_fixup *fix, int action)
6300 {
6301         struct alc_spec *spec = codec->spec;
6302
6303         switch (action) {
6304         case HDA_FIXUP_ACT_PRE_PROBE:
6305                 spec->ultra_low_power = true;
6306                 break;
6307         case HDA_FIXUP_ACT_INIT:
6308                 alc_combo_jack_hp_jd_restart(codec);
6309                 break;
6310         }
6311 }
6312
6313 static void alc_fixup_disable_mic_vref(struct hda_codec *codec,
6314                                   const struct hda_fixup *fix, int action)
6315 {
6316         if (action == HDA_FIXUP_ACT_PRE_PROBE)
6317                 snd_hda_codec_set_pin_target(codec, 0x19, PIN_VREFHIZ);
6318 }
6319
6320
6321 static void alc294_gx502_toggle_output(struct hda_codec *codec,
6322                                         struct hda_jack_callback *cb)
6323 {
6324         /* The Windows driver sets the codec up in a very different way where
6325          * it appears to leave 0x10 = 0x8a20 set. For Linux we need to toggle it
6326          */
6327         if (snd_hda_jack_detect_state(codec, 0x21) == HDA_JACK_PRESENT)
6328                 alc_write_coef_idx(codec, 0x10, 0x8a20);
6329         else
6330                 alc_write_coef_idx(codec, 0x10, 0x0a20);
6331 }
6332
6333 static void alc294_fixup_gx502_hp(struct hda_codec *codec,
6334                                         const struct hda_fixup *fix, int action)
6335 {
6336         /* Pin 0x21: headphones/headset mic */
6337         if (!is_jack_detectable(codec, 0x21))
6338                 return;
6339
6340         switch (action) {
6341         case HDA_FIXUP_ACT_PRE_PROBE:
6342                 snd_hda_jack_detect_enable_callback(codec, 0x21,
6343                                 alc294_gx502_toggle_output);
6344                 break;
6345         case HDA_FIXUP_ACT_INIT:
6346                 /* Make sure to start in a correct state, i.e. if
6347                  * headphones have been plugged in before powering up the system
6348                  */
6349                 alc294_gx502_toggle_output(codec, NULL);
6350                 break;
6351         }
6352 }
6353
6354 static void alc294_gu502_toggle_output(struct hda_codec *codec,
6355                                        struct hda_jack_callback *cb)
6356 {
6357         /* Windows sets 0x10 to 0x8420 for Node 0x20 which is
6358          * responsible from changes between speakers and headphones
6359          */
6360         if (snd_hda_jack_detect_state(codec, 0x21) == HDA_JACK_PRESENT)
6361                 alc_write_coef_idx(codec, 0x10, 0x8420);
6362         else
6363                 alc_write_coef_idx(codec, 0x10, 0x0a20);
6364 }
6365
6366 static void alc294_fixup_gu502_hp(struct hda_codec *codec,
6367                                   const struct hda_fixup *fix, int action)
6368 {
6369         if (!is_jack_detectable(codec, 0x21))
6370                 return;
6371
6372         switch (action) {
6373         case HDA_FIXUP_ACT_PRE_PROBE:
6374                 snd_hda_jack_detect_enable_callback(codec, 0x21,
6375                                 alc294_gu502_toggle_output);
6376                 break;
6377         case HDA_FIXUP_ACT_INIT:
6378                 alc294_gu502_toggle_output(codec, NULL);
6379                 break;
6380         }
6381 }
6382
6383 static void  alc285_fixup_hp_gpio_amp_init(struct hda_codec *codec,
6384                               const struct hda_fixup *fix, int action)
6385 {
6386         if (action != HDA_FIXUP_ACT_INIT)
6387                 return;
6388
6389         msleep(100);
6390         alc_write_coef_idx(codec, 0x65, 0x0);
6391 }
6392
6393 static void alc274_fixup_hp_headset_mic(struct hda_codec *codec,
6394                                     const struct hda_fixup *fix, int action)
6395 {
6396         switch (action) {
6397         case HDA_FIXUP_ACT_INIT:
6398                 alc_combo_jack_hp_jd_restart(codec);
6399                 break;
6400         }
6401 }
6402
6403 static void alc_fixup_no_int_mic(struct hda_codec *codec,
6404                                     const struct hda_fixup *fix, int action)
6405 {
6406         struct alc_spec *spec = codec->spec;
6407
6408         switch (action) {
6409         case HDA_FIXUP_ACT_PRE_PROBE:
6410                 /* Mic RING SLEEVE swap for combo jack */
6411                 alc_update_coef_idx(codec, 0x45, 0xf<<12 | 1<<10, 5<<12);
6412                 spec->no_internal_mic_pin = true;
6413                 break;
6414         case HDA_FIXUP_ACT_INIT:
6415                 alc_combo_jack_hp_jd_restart(codec);
6416                 break;
6417         }
6418 }
6419
6420 /* GPIO1 = amplifier on/off
6421  * GPIO3 = mic mute LED
6422  */
6423 static void alc285_fixup_hp_spectre_x360_eb1(struct hda_codec *codec,
6424                                           const struct hda_fixup *fix, int action)
6425 {
6426         static const hda_nid_t conn[] = { 0x02 };
6427
6428         struct alc_spec *spec = codec->spec;
6429         static const struct hda_pintbl pincfgs[] = {
6430                 { 0x14, 0x90170110 },  /* front/high speakers */
6431                 { 0x17, 0x90170130 },  /* back/bass speakers */
6432                 { }
6433         };
6434
6435         //enable micmute led
6436         alc_fixup_hp_gpio_led(codec, action, 0x00, 0x04);
6437
6438         switch (action) {
6439         case HDA_FIXUP_ACT_PRE_PROBE:
6440                 spec->micmute_led_polarity = 1;
6441                 /* needed for amp of back speakers */
6442                 spec->gpio_mask |= 0x01;
6443                 spec->gpio_dir |= 0x01;
6444                 snd_hda_apply_pincfgs(codec, pincfgs);
6445                 /* share DAC to have unified volume control */
6446                 snd_hda_override_conn_list(codec, 0x14, ARRAY_SIZE(conn), conn);
6447                 snd_hda_override_conn_list(codec, 0x17, ARRAY_SIZE(conn), conn);
6448                 break;
6449         case HDA_FIXUP_ACT_INIT:
6450                 /* need to toggle GPIO to enable the amp of back speakers */
6451                 alc_update_gpio_data(codec, 0x01, true);
6452                 msleep(100);
6453                 alc_update_gpio_data(codec, 0x01, false);
6454                 break;
6455         }
6456 }
6457
6458 static void alc285_fixup_hp_spectre_x360(struct hda_codec *codec,
6459                                           const struct hda_fixup *fix, int action)
6460 {
6461         static const hda_nid_t conn[] = { 0x02 };
6462         static const struct hda_pintbl pincfgs[] = {
6463                 { 0x14, 0x90170110 },  /* rear speaker */
6464                 { }
6465         };
6466
6467         switch (action) {
6468         case HDA_FIXUP_ACT_PRE_PROBE:
6469                 snd_hda_apply_pincfgs(codec, pincfgs);
6470                 /* force front speaker to DAC1 */
6471                 snd_hda_override_conn_list(codec, 0x17, ARRAY_SIZE(conn), conn);
6472                 break;
6473         }
6474 }
6475
6476 /* for hda_fixup_thinkpad_acpi() */
6477 #include "thinkpad_helper.c"
6478
6479 static void alc_fixup_thinkpad_acpi(struct hda_codec *codec,
6480                                     const struct hda_fixup *fix, int action)
6481 {
6482         alc_fixup_no_shutup(codec, fix, action); /* reduce click noise */
6483         hda_fixup_thinkpad_acpi(codec, fix, action);
6484 }
6485
6486 /* Fixup for Lenovo Legion 15IMHg05 speaker output on headset removal. */
6487 static void alc287_fixup_legion_15imhg05_speakers(struct hda_codec *codec,
6488                                                   const struct hda_fixup *fix,
6489                                                   int action)
6490 {
6491         struct alc_spec *spec = codec->spec;
6492
6493         switch (action) {
6494         case HDA_FIXUP_ACT_PRE_PROBE:
6495                 spec->gen.suppress_auto_mute = 1;
6496                 break;
6497         }
6498 }
6499
6500 /* for alc295_fixup_hp_top_speakers */
6501 #include "hp_x360_helper.c"
6502
6503 /* for alc285_fixup_ideapad_s740_coef() */
6504 #include "ideapad_s740_helper.c"
6505
6506 static void alc256_fixup_tongfang_reset_persistent_settings(struct hda_codec *codec,
6507                                                             const struct hda_fixup *fix,
6508                                                             int action)
6509 {
6510         /*
6511         * A certain other OS sets these coeffs to different values. On at least one TongFang
6512         * barebone these settings might survive even a cold reboot. So to restore a clean slate the
6513         * values are explicitly reset to default here. Without this, the external microphone is
6514         * always in a plugged-in state, while the internal microphone is always in an unplugged
6515         * state, breaking the ability to use the internal microphone.
6516         */
6517         alc_write_coef_idx(codec, 0x24, 0x0000);
6518         alc_write_coef_idx(codec, 0x26, 0x0000);
6519         alc_write_coef_idx(codec, 0x29, 0x3000);
6520         alc_write_coef_idx(codec, 0x37, 0xfe05);
6521         alc_write_coef_idx(codec, 0x45, 0x5089);
6522 }
6523
6524 enum {
6525         ALC269_FIXUP_GPIO2,
6526         ALC269_FIXUP_SONY_VAIO,
6527         ALC275_FIXUP_SONY_VAIO_GPIO2,
6528         ALC269_FIXUP_DELL_M101Z,
6529         ALC269_FIXUP_SKU_IGNORE,
6530         ALC269_FIXUP_ASUS_G73JW,
6531         ALC269_FIXUP_LENOVO_EAPD,
6532         ALC275_FIXUP_SONY_HWEQ,
6533         ALC275_FIXUP_SONY_DISABLE_AAMIX,
6534         ALC271_FIXUP_DMIC,
6535         ALC269_FIXUP_PCM_44K,
6536         ALC269_FIXUP_STEREO_DMIC,
6537         ALC269_FIXUP_HEADSET_MIC,
6538         ALC269_FIXUP_QUANTA_MUTE,
6539         ALC269_FIXUP_LIFEBOOK,
6540         ALC269_FIXUP_LIFEBOOK_EXTMIC,
6541         ALC269_FIXUP_LIFEBOOK_HP_PIN,
6542         ALC269_FIXUP_LIFEBOOK_NO_HP_TO_LINEOUT,
6543         ALC255_FIXUP_LIFEBOOK_U7x7_HEADSET_MIC,
6544         ALC269_FIXUP_AMIC,
6545         ALC269_FIXUP_DMIC,
6546         ALC269VB_FIXUP_AMIC,
6547         ALC269VB_FIXUP_DMIC,
6548         ALC269_FIXUP_HP_MUTE_LED,
6549         ALC269_FIXUP_HP_MUTE_LED_MIC1,
6550         ALC269_FIXUP_HP_MUTE_LED_MIC2,
6551         ALC269_FIXUP_HP_MUTE_LED_MIC3,
6552         ALC269_FIXUP_HP_GPIO_LED,
6553         ALC269_FIXUP_HP_GPIO_MIC1_LED,
6554         ALC269_FIXUP_HP_LINE1_MIC1_LED,
6555         ALC269_FIXUP_INV_DMIC,
6556         ALC269_FIXUP_LENOVO_DOCK,
6557         ALC269_FIXUP_LENOVO_DOCK_LIMIT_BOOST,
6558         ALC269_FIXUP_NO_SHUTUP,
6559         ALC286_FIXUP_SONY_MIC_NO_PRESENCE,
6560         ALC269_FIXUP_PINCFG_NO_HP_TO_LINEOUT,
6561         ALC269_FIXUP_DELL1_MIC_NO_PRESENCE,
6562         ALC269_FIXUP_DELL2_MIC_NO_PRESENCE,
6563         ALC269_FIXUP_DELL3_MIC_NO_PRESENCE,
6564         ALC269_FIXUP_DELL4_MIC_NO_PRESENCE,
6565         ALC269_FIXUP_HEADSET_MODE,
6566         ALC269_FIXUP_HEADSET_MODE_NO_HP_MIC,
6567         ALC269_FIXUP_ASPIRE_HEADSET_MIC,
6568         ALC269_FIXUP_ASUS_X101_FUNC,
6569         ALC269_FIXUP_ASUS_X101_VERB,
6570         ALC269_FIXUP_ASUS_X101,
6571         ALC271_FIXUP_AMIC_MIC2,
6572         ALC271_FIXUP_HP_GATE_MIC_JACK,
6573         ALC271_FIXUP_HP_GATE_MIC_JACK_E1_572,
6574         ALC269_FIXUP_ACER_AC700,
6575         ALC269_FIXUP_LIMIT_INT_MIC_BOOST,
6576         ALC269VB_FIXUP_ASUS_ZENBOOK,
6577         ALC269VB_FIXUP_ASUS_ZENBOOK_UX31A,
6578         ALC269_FIXUP_LIMIT_INT_MIC_BOOST_MUTE_LED,
6579         ALC269VB_FIXUP_ORDISSIMO_EVE2,
6580         ALC283_FIXUP_CHROME_BOOK,
6581         ALC283_FIXUP_SENSE_COMBO_JACK,
6582         ALC282_FIXUP_ASUS_TX300,
6583         ALC283_FIXUP_INT_MIC,
6584         ALC290_FIXUP_MONO_SPEAKERS,
6585         ALC290_FIXUP_MONO_SPEAKERS_HSJACK,
6586         ALC290_FIXUP_SUBWOOFER,
6587         ALC290_FIXUP_SUBWOOFER_HSJACK,
6588         ALC269_FIXUP_THINKPAD_ACPI,
6589         ALC269_FIXUP_DMIC_THINKPAD_ACPI,
6590         ALC255_FIXUP_ACER_MIC_NO_PRESENCE,
6591         ALC255_FIXUP_ASUS_MIC_NO_PRESENCE,
6592         ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
6593         ALC255_FIXUP_DELL2_MIC_NO_PRESENCE,
6594         ALC255_FIXUP_HEADSET_MODE,
6595         ALC255_FIXUP_HEADSET_MODE_NO_HP_MIC,
6596         ALC293_FIXUP_DELL1_MIC_NO_PRESENCE,
6597         ALC292_FIXUP_TPT440_DOCK,
6598         ALC292_FIXUP_TPT440,
6599         ALC283_FIXUP_HEADSET_MIC,
6600         ALC255_FIXUP_MIC_MUTE_LED,
6601         ALC282_FIXUP_ASPIRE_V5_PINS,
6602         ALC269VB_FIXUP_ASPIRE_E1_COEF,
6603         ALC280_FIXUP_HP_GPIO4,
6604         ALC286_FIXUP_HP_GPIO_LED,
6605         ALC280_FIXUP_HP_GPIO2_MIC_HOTKEY,
6606         ALC280_FIXUP_HP_DOCK_PINS,
6607         ALC269_FIXUP_HP_DOCK_GPIO_MIC1_LED,
6608         ALC280_FIXUP_HP_9480M,
6609         ALC245_FIXUP_HP_X360_AMP,
6610         ALC285_FIXUP_HP_SPECTRE_X360_EB1,
6611         ALC288_FIXUP_DELL_HEADSET_MODE,
6612         ALC288_FIXUP_DELL1_MIC_NO_PRESENCE,
6613         ALC288_FIXUP_DELL_XPS_13,
6614         ALC288_FIXUP_DISABLE_AAMIX,
6615         ALC292_FIXUP_DELL_E7X_AAMIX,
6616         ALC292_FIXUP_DELL_E7X,
6617         ALC292_FIXUP_DISABLE_AAMIX,
6618         ALC293_FIXUP_DISABLE_AAMIX_MULTIJACK,
6619         ALC298_FIXUP_ALIENWARE_MIC_NO_PRESENCE,
6620         ALC298_FIXUP_DELL1_MIC_NO_PRESENCE,
6621         ALC298_FIXUP_DELL_AIO_MIC_NO_PRESENCE,
6622         ALC275_FIXUP_DELL_XPS,
6623         ALC293_FIXUP_LENOVO_SPK_NOISE,
6624         ALC233_FIXUP_LENOVO_LINE2_MIC_HOTKEY,
6625         ALC255_FIXUP_DELL_SPK_NOISE,
6626         ALC225_FIXUP_DISABLE_MIC_VREF,
6627         ALC225_FIXUP_DELL1_MIC_NO_PRESENCE,
6628         ALC295_FIXUP_DISABLE_DAC3,
6629         ALC285_FIXUP_SPEAKER2_TO_DAC1,
6630         ALC280_FIXUP_HP_HEADSET_MIC,
6631         ALC221_FIXUP_HP_FRONT_MIC,
6632         ALC292_FIXUP_TPT460,
6633         ALC298_FIXUP_SPK_VOLUME,
6634         ALC298_FIXUP_LENOVO_SPK_VOLUME,
6635         ALC256_FIXUP_DELL_INSPIRON_7559_SUBWOOFER,
6636         ALC269_FIXUP_ATIV_BOOK_8,
6637         ALC221_FIXUP_HP_MIC_NO_PRESENCE,
6638         ALC256_FIXUP_ASUS_HEADSET_MODE,
6639         ALC256_FIXUP_ASUS_MIC,
6640         ALC256_FIXUP_ASUS_AIO_GPIO2,
6641         ALC233_FIXUP_ASUS_MIC_NO_PRESENCE,
6642         ALC233_FIXUP_EAPD_COEF_AND_MIC_NO_PRESENCE,
6643         ALC233_FIXUP_LENOVO_MULTI_CODECS,
6644         ALC233_FIXUP_ACER_HEADSET_MIC,
6645         ALC294_FIXUP_LENOVO_MIC_LOCATION,
6646         ALC225_FIXUP_DELL_WYSE_MIC_NO_PRESENCE,
6647         ALC225_FIXUP_S3_POP_NOISE,
6648         ALC700_FIXUP_INTEL_REFERENCE,
6649         ALC274_FIXUP_DELL_BIND_DACS,
6650         ALC274_FIXUP_DELL_AIO_LINEOUT_VERB,
6651         ALC298_FIXUP_TPT470_DOCK_FIX,
6652         ALC298_FIXUP_TPT470_DOCK,
6653         ALC255_FIXUP_DUMMY_LINEOUT_VERB,
6654         ALC255_FIXUP_DELL_HEADSET_MIC,
6655         ALC256_FIXUP_HUAWEI_MACH_WX9_PINS,
6656         ALC298_FIXUP_HUAWEI_MBX_STEREO,
6657         ALC295_FIXUP_HP_X360,
6658         ALC221_FIXUP_HP_HEADSET_MIC,
6659         ALC285_FIXUP_LENOVO_HEADPHONE_NOISE,
6660         ALC295_FIXUP_HP_AUTO_MUTE,
6661         ALC286_FIXUP_ACER_AIO_MIC_NO_PRESENCE,
6662         ALC294_FIXUP_ASUS_MIC,
6663         ALC294_FIXUP_ASUS_HEADSET_MIC,
6664         ALC294_FIXUP_ASUS_SPK,
6665         ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE,
6666         ALC285_FIXUP_LENOVO_PC_BEEP_IN_NOISE,
6667         ALC255_FIXUP_ACER_HEADSET_MIC,
6668         ALC295_FIXUP_CHROME_BOOK,
6669         ALC225_FIXUP_HEADSET_JACK,
6670         ALC225_FIXUP_DELL_WYSE_AIO_MIC_NO_PRESENCE,
6671         ALC225_FIXUP_WYSE_AUTO_MUTE,
6672         ALC225_FIXUP_WYSE_DISABLE_MIC_VREF,
6673         ALC286_FIXUP_ACER_AIO_HEADSET_MIC,
6674         ALC256_FIXUP_ASUS_HEADSET_MIC,
6675         ALC256_FIXUP_ASUS_MIC_NO_PRESENCE,
6676         ALC299_FIXUP_PREDATOR_SPK,
6677         ALC256_FIXUP_MEDION_HEADSET_NO_PRESENCE,
6678         ALC289_FIXUP_DELL_SPK2,
6679         ALC289_FIXUP_DUAL_SPK,
6680         ALC294_FIXUP_SPK2_TO_DAC1,
6681         ALC294_FIXUP_ASUS_DUAL_SPK,
6682         ALC285_FIXUP_THINKPAD_X1_GEN7,
6683         ALC285_FIXUP_THINKPAD_HEADSET_JACK,
6684         ALC294_FIXUP_ASUS_HPE,
6685         ALC294_FIXUP_ASUS_COEF_1B,
6686         ALC294_FIXUP_ASUS_GX502_HP,
6687         ALC294_FIXUP_ASUS_GX502_PINS,
6688         ALC294_FIXUP_ASUS_GX502_VERBS,
6689         ALC294_FIXUP_ASUS_GU502_HP,
6690         ALC294_FIXUP_ASUS_GU502_PINS,
6691         ALC294_FIXUP_ASUS_GU502_VERBS,
6692         ALC285_FIXUP_HP_GPIO_LED,
6693         ALC285_FIXUP_HP_MUTE_LED,
6694         ALC236_FIXUP_HP_GPIO_LED,
6695         ALC236_FIXUP_HP_MUTE_LED,
6696         ALC236_FIXUP_HP_MUTE_LED_MICMUTE_VREF,
6697         ALC298_FIXUP_SAMSUNG_HEADPHONE_VERY_QUIET,
6698         ALC295_FIXUP_ASUS_MIC_NO_PRESENCE,
6699         ALC269VC_FIXUP_ACER_VCOPPERBOX_PINS,
6700         ALC269VC_FIXUP_ACER_HEADSET_MIC,
6701         ALC269VC_FIXUP_ACER_MIC_NO_PRESENCE,
6702         ALC289_FIXUP_ASUS_GA401,
6703         ALC289_FIXUP_ASUS_GA502,
6704         ALC256_FIXUP_ACER_MIC_NO_PRESENCE,
6705         ALC285_FIXUP_HP_GPIO_AMP_INIT,
6706         ALC269_FIXUP_CZC_B20,
6707         ALC269_FIXUP_CZC_TMI,
6708         ALC269_FIXUP_CZC_L101,
6709         ALC269_FIXUP_LEMOTE_A1802,
6710         ALC269_FIXUP_LEMOTE_A190X,
6711         ALC256_FIXUP_INTEL_NUC8_RUGGED,
6712         ALC233_FIXUP_INTEL_NUC8_DMIC,
6713         ALC233_FIXUP_INTEL_NUC8_BOOST,
6714         ALC256_FIXUP_INTEL_NUC10,
6715         ALC255_FIXUP_XIAOMI_HEADSET_MIC,
6716         ALC274_FIXUP_HP_MIC,
6717         ALC274_FIXUP_HP_HEADSET_MIC,
6718         ALC274_FIXUP_HP_ENVY_GPIO,
6719         ALC256_FIXUP_ASUS_HPE,
6720         ALC285_FIXUP_THINKPAD_NO_BASS_SPK_HEADSET_JACK,
6721         ALC287_FIXUP_HP_GPIO_LED,
6722         ALC256_FIXUP_HP_HEADSET_MIC,
6723         ALC245_FIXUP_HP_GPIO_LED,
6724         ALC236_FIXUP_DELL_AIO_HEADSET_MIC,
6725         ALC282_FIXUP_ACER_DISABLE_LINEOUT,
6726         ALC255_FIXUP_ACER_LIMIT_INT_MIC_BOOST,
6727         ALC256_FIXUP_ACER_HEADSET_MIC,
6728         ALC285_FIXUP_IDEAPAD_S740_COEF,
6729         ALC285_FIXUP_HP_LIMIT_INT_MIC_BOOST,
6730         ALC295_FIXUP_ASUS_DACS,
6731         ALC295_FIXUP_HP_OMEN,
6732         ALC285_FIXUP_HP_SPECTRE_X360,
6733         ALC287_FIXUP_IDEAPAD_BASS_SPK_AMP,
6734         ALC623_FIXUP_LENOVO_THINKSTATION_P340,
6735         ALC255_FIXUP_ACER_HEADPHONE_AND_MIC,
6736         ALC236_FIXUP_HP_LIMIT_INT_MIC_BOOST,
6737         ALC287_FIXUP_LEGION_15IMHG05_SPEAKERS,
6738         ALC287_FIXUP_LEGION_15IMHG05_AUTOMUTE,
6739         ALC287_FIXUP_YOGA7_14ITL_SPEAKERS,
6740         ALC287_FIXUP_13S_GEN2_SPEAKERS,
6741         ALC256_FIXUP_TONGFANG_RESET_PERSISTENT_SETTINGS,
6742         ALC256_FIXUP_SYSTEM76_MIC_NO_PRESENCE,
6743 };
6744
6745 static const struct hda_fixup alc269_fixups[] = {
6746         [ALC269_FIXUP_GPIO2] = {
6747                 .type = HDA_FIXUP_FUNC,
6748                 .v.func = alc_fixup_gpio2,
6749         },
6750         [ALC269_FIXUP_SONY_VAIO] = {
6751                 .type = HDA_FIXUP_PINCTLS,
6752                 .v.pins = (const struct hda_pintbl[]) {
6753                         {0x19, PIN_VREFGRD},
6754                         {}
6755                 }
6756         },
6757         [ALC275_FIXUP_SONY_VAIO_GPIO2] = {
6758                 .type = HDA_FIXUP_FUNC,
6759                 .v.func = alc275_fixup_gpio4_off,
6760                 .chained = true,
6761                 .chain_id = ALC269_FIXUP_SONY_VAIO
6762         },
6763         [ALC269_FIXUP_DELL_M101Z] = {
6764                 .type = HDA_FIXUP_VERBS,
6765                 .v.verbs = (const struct hda_verb[]) {
6766                         /* Enables internal speaker */
6767                         {0x20, AC_VERB_SET_COEF_INDEX, 13},
6768                         {0x20, AC_VERB_SET_PROC_COEF, 0x4040},
6769                         {}
6770                 }
6771         },
6772         [ALC269_FIXUP_SKU_IGNORE] = {
6773                 .type = HDA_FIXUP_FUNC,
6774                 .v.func = alc_fixup_sku_ignore,
6775         },
6776         [ALC269_FIXUP_ASUS_G73JW] = {
6777                 .type = HDA_FIXUP_PINS,
6778                 .v.pins = (const struct hda_pintbl[]) {
6779                         { 0x17, 0x99130111 }, /* subwoofer */
6780                         { }
6781                 }
6782         },
6783         [ALC269_FIXUP_LENOVO_EAPD] = {
6784                 .type = HDA_FIXUP_VERBS,
6785                 .v.verbs = (const struct hda_verb[]) {
6786                         {0x14, AC_VERB_SET_EAPD_BTLENABLE, 0},
6787                         {}
6788                 }
6789         },
6790         [ALC275_FIXUP_SONY_HWEQ] = {
6791                 .type = HDA_FIXUP_FUNC,
6792                 .v.func = alc269_fixup_hweq,
6793                 .chained = true,
6794                 .chain_id = ALC275_FIXUP_SONY_VAIO_GPIO2
6795         },
6796         [ALC275_FIXUP_SONY_DISABLE_AAMIX] = {
6797                 .type = HDA_FIXUP_FUNC,
6798                 .v.func = alc_fixup_disable_aamix,
6799                 .chained = true,
6800                 .chain_id = ALC269_FIXUP_SONY_VAIO
6801         },
6802         [ALC271_FIXUP_DMIC] = {
6803                 .type = HDA_FIXUP_FUNC,
6804                 .v.func = alc271_fixup_dmic,
6805         },
6806         [ALC269_FIXUP_PCM_44K] = {
6807                 .type = HDA_FIXUP_FUNC,
6808                 .v.func = alc269_fixup_pcm_44k,
6809                 .chained = true,
6810                 .chain_id = ALC269_FIXUP_QUANTA_MUTE
6811         },
6812         [ALC269_FIXUP_STEREO_DMIC] = {
6813                 .type = HDA_FIXUP_FUNC,
6814                 .v.func = alc269_fixup_stereo_dmic,
6815         },
6816         [ALC269_FIXUP_HEADSET_MIC] = {
6817                 .type = HDA_FIXUP_FUNC,
6818                 .v.func = alc269_fixup_headset_mic,
6819         },
6820         [ALC269_FIXUP_QUANTA_MUTE] = {
6821                 .type = HDA_FIXUP_FUNC,
6822                 .v.func = alc269_fixup_quanta_mute,
6823         },
6824         [ALC269_FIXUP_LIFEBOOK] = {
6825                 .type = HDA_FIXUP_PINS,
6826                 .v.pins = (const struct hda_pintbl[]) {
6827                         { 0x1a, 0x2101103f }, /* dock line-out */
6828                         { 0x1b, 0x23a11040 }, /* dock mic-in */
6829                         { }
6830                 },
6831                 .chained = true,
6832                 .chain_id = ALC269_FIXUP_QUANTA_MUTE
6833         },
6834         [ALC269_FIXUP_LIFEBOOK_EXTMIC] = {
6835                 .type = HDA_FIXUP_PINS,
6836                 .v.pins = (const struct hda_pintbl[]) {
6837                         { 0x19, 0x01a1903c }, /* headset mic, with jack detect */
6838                         { }
6839                 },
6840         },
6841         [ALC269_FIXUP_LIFEBOOK_HP_PIN] = {
6842                 .type = HDA_FIXUP_PINS,
6843                 .v.pins = (const struct hda_pintbl[]) {
6844                         { 0x21, 0x0221102f }, /* HP out */
6845                         { }
6846                 },
6847         },
6848         [ALC269_FIXUP_LIFEBOOK_NO_HP_TO_LINEOUT] = {
6849                 .type = HDA_FIXUP_FUNC,
6850                 .v.func = alc269_fixup_pincfg_no_hp_to_lineout,
6851         },
6852         [ALC255_FIXUP_LIFEBOOK_U7x7_HEADSET_MIC] = {
6853                 .type = HDA_FIXUP_FUNC,
6854                 .v.func = alc269_fixup_pincfg_U7x7_headset_mic,
6855         },
6856         [ALC269_FIXUP_AMIC] = {
6857                 .type = HDA_FIXUP_PINS,
6858                 .v.pins = (const struct hda_pintbl[]) {
6859                         { 0x14, 0x99130110 }, /* speaker */
6860                         { 0x15, 0x0121401f }, /* HP out */
6861                         { 0x18, 0x01a19c20 }, /* mic */
6862                         { 0x19, 0x99a3092f }, /* int-mic */
6863                         { }
6864                 },
6865         },
6866         [ALC269_FIXUP_DMIC] = {
6867                 .type = HDA_FIXUP_PINS,
6868                 .v.pins = (const struct hda_pintbl[]) {
6869                         { 0x12, 0x99a3092f }, /* int-mic */
6870                         { 0x14, 0x99130110 }, /* speaker */
6871                         { 0x15, 0x0121401f }, /* HP out */
6872                         { 0x18, 0x01a19c20 }, /* mic */
6873                         { }
6874                 },
6875         },
6876         [ALC269VB_FIXUP_AMIC] = {
6877                 .type = HDA_FIXUP_PINS,
6878                 .v.pins = (const struct hda_pintbl[]) {
6879                         { 0x14, 0x99130110 }, /* speaker */
6880                         { 0x18, 0x01a19c20 }, /* mic */
6881                         { 0x19, 0x99a3092f }, /* int-mic */
6882                         { 0x21, 0x0121401f }, /* HP out */
6883                         { }
6884                 },
6885         },
6886         [ALC269VB_FIXUP_DMIC] = {
6887                 .type = HDA_FIXUP_PINS,
6888                 .v.pins = (const struct hda_pintbl[]) {
6889                         { 0x12, 0x99a3092f }, /* int-mic */
6890                         { 0x14, 0x99130110 }, /* speaker */
6891                         { 0x18, 0x01a19c20 }, /* mic */
6892                         { 0x21, 0x0121401f }, /* HP out */
6893                         { }
6894                 },
6895         },
6896         [ALC269_FIXUP_HP_MUTE_LED] = {
6897                 .type = HDA_FIXUP_FUNC,
6898                 .v.func = alc269_fixup_hp_mute_led,
6899         },
6900         [ALC269_FIXUP_HP_MUTE_LED_MIC1] = {
6901                 .type = HDA_FIXUP_FUNC,
6902                 .v.func = alc269_fixup_hp_mute_led_mic1,
6903         },
6904         [ALC269_FIXUP_HP_MUTE_LED_MIC2] = {
6905                 .type = HDA_FIXUP_FUNC,
6906                 .v.func = alc269_fixup_hp_mute_led_mic2,
6907         },
6908         [ALC269_FIXUP_HP_MUTE_LED_MIC3] = {
6909                 .type = HDA_FIXUP_FUNC,
6910                 .v.func = alc269_fixup_hp_mute_led_mic3,
6911                 .chained = true,
6912                 .chain_id = ALC295_FIXUP_HP_AUTO_MUTE
6913         },
6914         [ALC269_FIXUP_HP_GPIO_LED] = {
6915                 .type = HDA_FIXUP_FUNC,
6916                 .v.func = alc269_fixup_hp_gpio_led,
6917         },
6918         [ALC269_FIXUP_HP_GPIO_MIC1_LED] = {
6919                 .type = HDA_FIXUP_FUNC,
6920                 .v.func = alc269_fixup_hp_gpio_mic1_led,
6921         },
6922         [ALC269_FIXUP_HP_LINE1_MIC1_LED] = {
6923                 .type = HDA_FIXUP_FUNC,
6924                 .v.func = alc269_fixup_hp_line1_mic1_led,
6925         },
6926         [ALC269_FIXUP_INV_DMIC] = {
6927                 .type = HDA_FIXUP_FUNC,
6928                 .v.func = alc_fixup_inv_dmic,
6929         },
6930         [ALC269_FIXUP_NO_SHUTUP] = {
6931                 .type = HDA_FIXUP_FUNC,
6932                 .v.func = alc_fixup_no_shutup,
6933         },
6934         [ALC269_FIXUP_LENOVO_DOCK] = {
6935                 .type = HDA_FIXUP_PINS,
6936                 .v.pins = (const struct hda_pintbl[]) {
6937                         { 0x19, 0x23a11040 }, /* dock mic */
6938                         { 0x1b, 0x2121103f }, /* dock headphone */
6939                         { }
6940                 },
6941                 .chained = true,
6942                 .chain_id = ALC269_FIXUP_PINCFG_NO_HP_TO_LINEOUT
6943         },
6944         [ALC269_FIXUP_LENOVO_DOCK_LIMIT_BOOST] = {
6945                 .type = HDA_FIXUP_FUNC,
6946                 .v.func = alc269_fixup_limit_int_mic_boost,
6947                 .chained = true,
6948                 .chain_id = ALC269_FIXUP_LENOVO_DOCK,
6949         },
6950         [ALC269_FIXUP_PINCFG_NO_HP_TO_LINEOUT] = {
6951                 .type = HDA_FIXUP_FUNC,
6952                 .v.func = alc269_fixup_pincfg_no_hp_to_lineout,
6953                 .chained = true,
6954                 .chain_id = ALC269_FIXUP_THINKPAD_ACPI,
6955         },
6956         [ALC269_FIXUP_DELL1_MIC_NO_PRESENCE] = {
6957                 .type = HDA_FIXUP_PINS,
6958                 .v.pins = (const struct hda_pintbl[]) {
6959                         { 0x19, 0x01a1913c }, /* use as headset mic, without its own jack detect */
6960                         { 0x1a, 0x01a1913d }, /* use as headphone mic, without its own jack detect */
6961                         { }
6962                 },
6963                 .chained = true,
6964                 .chain_id = ALC269_FIXUP_HEADSET_MODE
6965         },
6966         [ALC269_FIXUP_DELL2_MIC_NO_PRESENCE] = {
6967                 .type = HDA_FIXUP_PINS,
6968                 .v.pins = (const struct hda_pintbl[]) {
6969                         { 0x16, 0x21014020 }, /* dock line out */
6970                         { 0x19, 0x21a19030 }, /* dock mic */
6971                         { 0x1a, 0x01a1913c }, /* use as headset mic, without its own jack detect */
6972                         { }
6973                 },
6974                 .chained = true,
6975                 .chain_id = ALC269_FIXUP_HEADSET_MODE_NO_HP_MIC
6976         },
6977         [ALC269_FIXUP_DELL3_MIC_NO_PRESENCE] = {
6978                 .type = HDA_FIXUP_PINS,
6979                 .v.pins = (const struct hda_pintbl[]) {
6980                         { 0x1a, 0x01a1913c }, /* use as headset mic, without its own jack detect */
6981                         { }
6982                 },
6983                 .chained = true,
6984                 .chain_id = ALC269_FIXUP_HEADSET_MODE_NO_HP_MIC
6985         },
6986         [ALC269_FIXUP_DELL4_MIC_NO_PRESENCE] = {
6987                 .type = HDA_FIXUP_PINS,
6988                 .v.pins = (const struct hda_pintbl[]) {
6989                         { 0x19, 0x01a1913c }, /* use as headset mic, without its own jack detect */
6990                         { 0x1b, 0x01a1913d }, /* use as headphone mic, without its own jack detect */
6991                         { }
6992                 },
6993                 .chained = true,
6994                 .chain_id = ALC269_FIXUP_HEADSET_MODE
6995         },
6996         [ALC269_FIXUP_HEADSET_MODE] = {
6997                 .type = HDA_FIXUP_FUNC,
6998                 .v.func = alc_fixup_headset_mode,
6999                 .chained = true,
7000                 .chain_id = ALC255_FIXUP_MIC_MUTE_LED
7001         },
7002         [ALC269_FIXUP_HEADSET_MODE_NO_HP_MIC] = {
7003                 .type = HDA_FIXUP_FUNC,
7004                 .v.func = alc_fixup_headset_mode_no_hp_mic,
7005         },
7006         [ALC269_FIXUP_ASPIRE_HEADSET_MIC] = {
7007                 .type = HDA_FIXUP_PINS,
7008                 .v.pins = (const struct hda_pintbl[]) {
7009                         { 0x19, 0x01a1913c }, /* headset mic w/o jack detect */
7010                         { }
7011                 },
7012                 .chained = true,
7013                 .chain_id = ALC269_FIXUP_HEADSET_MODE,
7014         },
7015         [ALC286_FIXUP_SONY_MIC_NO_PRESENCE] = {
7016                 .type = HDA_FIXUP_PINS,
7017                 .v.pins = (const struct hda_pintbl[]) {
7018                         { 0x18, 0x01a1913c }, /* use as headset mic, without its own jack detect */
7019                         { }
7020                 },
7021                 .chained = true,
7022                 .chain_id = ALC269_FIXUP_HEADSET_MIC
7023         },
7024         [ALC256_FIXUP_HUAWEI_MACH_WX9_PINS] = {
7025                 .type = HDA_FIXUP_PINS,
7026                 .v.pins = (const struct hda_pintbl[]) {
7027                         {0x12, 0x90a60130},
7028                         {0x13, 0x40000000},
7029                         {0x14, 0x90170110},
7030                         {0x18, 0x411111f0},
7031                         {0x19, 0x04a11040},
7032                         {0x1a, 0x411111f0},
7033                         {0x1b, 0x90170112},
7034                         {0x1d, 0x40759a05},
7035                         {0x1e, 0x411111f0},
7036                         {0x21, 0x04211020},
7037                         { }
7038                 },
7039                 .chained = true,
7040                 .chain_id = ALC255_FIXUP_MIC_MUTE_LED
7041         },
7042         [ALC298_FIXUP_HUAWEI_MBX_STEREO] = {
7043                 .type = HDA_FIXUP_FUNC,
7044                 .v.func = alc298_fixup_huawei_mbx_stereo,
7045                 .chained = true,
7046                 .chain_id = ALC255_FIXUP_MIC_MUTE_LED
7047         },
7048         [ALC269_FIXUP_ASUS_X101_FUNC] = {
7049                 .type = HDA_FIXUP_FUNC,
7050                 .v.func = alc269_fixup_x101_headset_mic,
7051         },
7052         [ALC269_FIXUP_ASUS_X101_VERB] = {
7053                 .type = HDA_FIXUP_VERBS,
7054                 .v.verbs = (const struct hda_verb[]) {
7055                         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
7056                         {0x20, AC_VERB_SET_COEF_INDEX, 0x08},
7057                         {0x20, AC_VERB_SET_PROC_COEF,  0x0310},
7058                         { }
7059                 },
7060                 .chained = true,
7061                 .chain_id = ALC269_FIXUP_ASUS_X101_FUNC
7062         },
7063         [ALC269_FIXUP_ASUS_X101] = {
7064                 .type = HDA_FIXUP_PINS,
7065                 .v.pins = (const struct hda_pintbl[]) {
7066                         { 0x18, 0x04a1182c }, /* Headset mic */
7067                         { }
7068                 },
7069                 .chained = true,
7070                 .chain_id = ALC269_FIXUP_ASUS_X101_VERB
7071         },
7072         [ALC271_FIXUP_AMIC_MIC2] = {
7073                 .type = HDA_FIXUP_PINS,
7074                 .v.pins = (const struct hda_pintbl[]) {
7075                         { 0x14, 0x99130110 }, /* speaker */
7076                         { 0x19, 0x01a19c20 }, /* mic */
7077                         { 0x1b, 0x99a7012f }, /* int-mic */
7078                         { 0x21, 0x0121401f }, /* HP out */
7079                         { }
7080                 },
7081         },
7082         [ALC271_FIXUP_HP_GATE_MIC_JACK] = {
7083                 .type = HDA_FIXUP_FUNC,
7084                 .v.func = alc271_hp_gate_mic_jack,
7085                 .chained = true,
7086                 .chain_id = ALC271_FIXUP_AMIC_MIC2,
7087         },
7088         [ALC271_FIXUP_HP_GATE_MIC_JACK_E1_572] = {
7089                 .type = HDA_FIXUP_FUNC,
7090                 .v.func = alc269_fixup_limit_int_mic_boost,
7091                 .chained = true,
7092                 .chain_id = ALC271_FIXUP_HP_GATE_MIC_JACK,
7093         },
7094         [ALC269_FIXUP_ACER_AC700] = {
7095                 .type = HDA_FIXUP_PINS,
7096                 .v.pins = (const struct hda_pintbl[]) {
7097                         { 0x12, 0x99a3092f }, /* int-mic */
7098                         { 0x14, 0x99130110 }, /* speaker */
7099                         { 0x18, 0x03a11c20 }, /* mic */
7100                         { 0x1e, 0x0346101e }, /* SPDIF1 */
7101                         { 0x21, 0x0321101f }, /* HP out */
7102                         { }
7103                 },
7104                 .chained = true,
7105                 .chain_id = ALC271_FIXUP_DMIC,
7106         },
7107         [ALC269_FIXUP_LIMIT_INT_MIC_BOOST] = {
7108                 .type = HDA_FIXUP_FUNC,
7109                 .v.func = alc269_fixup_limit_int_mic_boost,
7110                 .chained = true,
7111                 .chain_id = ALC269_FIXUP_THINKPAD_ACPI,
7112         },
7113         [ALC269VB_FIXUP_ASUS_ZENBOOK] = {
7114                 .type = HDA_FIXUP_FUNC,
7115                 .v.func = alc269_fixup_limit_int_mic_boost,
7116                 .chained = true,
7117                 .chain_id = ALC269VB_FIXUP_DMIC,
7118         },
7119         [ALC269VB_FIXUP_ASUS_ZENBOOK_UX31A] = {
7120                 .type = HDA_FIXUP_VERBS,
7121                 .v.verbs = (const struct hda_verb[]) {
7122                         /* class-D output amp +5dB */
7123                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x12 },
7124                         { 0x20, AC_VERB_SET_PROC_COEF, 0x2800 },
7125                         {}
7126                 },
7127                 .chained = true,
7128                 .chain_id = ALC269VB_FIXUP_ASUS_ZENBOOK,
7129         },
7130         [ALC269_FIXUP_LIMIT_INT_MIC_BOOST_MUTE_LED] = {
7131                 .type = HDA_FIXUP_FUNC,
7132                 .v.func = alc269_fixup_limit_int_mic_boost,
7133                 .chained = true,
7134                 .chain_id = ALC269_FIXUP_HP_MUTE_LED_MIC1,
7135         },
7136         [ALC269VB_FIXUP_ORDISSIMO_EVE2] = {
7137                 .type = HDA_FIXUP_PINS,
7138                 .v.pins = (const struct hda_pintbl[]) {
7139                         { 0x12, 0x99a3092f }, /* int-mic */
7140                         { 0x18, 0x03a11d20 }, /* mic */
7141                         { 0x19, 0x411111f0 }, /* Unused bogus pin */
7142                         { }
7143                 },
7144         },
7145         [ALC283_FIXUP_CHROME_BOOK] = {
7146                 .type = HDA_FIXUP_FUNC,
7147                 .v.func = alc283_fixup_chromebook,
7148         },
7149         [ALC283_FIXUP_SENSE_COMBO_JACK] = {
7150                 .type = HDA_FIXUP_FUNC,
7151                 .v.func = alc283_fixup_sense_combo_jack,
7152                 .chained = true,
7153                 .chain_id = ALC283_FIXUP_CHROME_BOOK,
7154         },
7155         [ALC282_FIXUP_ASUS_TX300] = {
7156                 .type = HDA_FIXUP_FUNC,
7157                 .v.func = alc282_fixup_asus_tx300,
7158         },
7159         [ALC283_FIXUP_INT_MIC] = {
7160                 .type = HDA_FIXUP_VERBS,
7161                 .v.verbs = (const struct hda_verb[]) {
7162                         {0x20, AC_VERB_SET_COEF_INDEX, 0x1a},
7163                         {0x20, AC_VERB_SET_PROC_COEF, 0x0011},
7164                         { }
7165                 },
7166                 .chained = true,
7167                 .chain_id = ALC269_FIXUP_LIMIT_INT_MIC_BOOST
7168         },
7169         [ALC290_FIXUP_SUBWOOFER_HSJACK] = {
7170                 .type = HDA_FIXUP_PINS,
7171                 .v.pins = (const struct hda_pintbl[]) {
7172                         { 0x17, 0x90170112 }, /* subwoofer */
7173                         { }
7174                 },
7175                 .chained = true,
7176                 .chain_id = ALC290_FIXUP_MONO_SPEAKERS_HSJACK,
7177         },
7178         [ALC290_FIXUP_SUBWOOFER] = {
7179                 .type = HDA_FIXUP_PINS,
7180                 .v.pins = (const struct hda_pintbl[]) {
7181                         { 0x17, 0x90170112 }, /* subwoofer */
7182                         { }
7183                 },
7184                 .chained = true,
7185                 .chain_id = ALC290_FIXUP_MONO_SPEAKERS,
7186         },
7187         [ALC290_FIXUP_MONO_SPEAKERS] = {
7188                 .type = HDA_FIXUP_FUNC,
7189                 .v.func = alc290_fixup_mono_speakers,
7190         },
7191         [ALC290_FIXUP_MONO_SPEAKERS_HSJACK] = {
7192                 .type = HDA_FIXUP_FUNC,
7193                 .v.func = alc290_fixup_mono_speakers,
7194                 .chained = true,
7195                 .chain_id = ALC269_FIXUP_DELL3_MIC_NO_PRESENCE,
7196         },
7197         [ALC269_FIXUP_THINKPAD_ACPI] = {
7198                 .type = HDA_FIXUP_FUNC,
7199                 .v.func = alc_fixup_thinkpad_acpi,
7200                 .chained = true,
7201                 .chain_id = ALC269_FIXUP_SKU_IGNORE,
7202         },
7203         [ALC269_FIXUP_DMIC_THINKPAD_ACPI] = {
7204                 .type = HDA_FIXUP_FUNC,
7205                 .v.func = alc_fixup_inv_dmic,
7206                 .chained = true,
7207                 .chain_id = ALC269_FIXUP_THINKPAD_ACPI,
7208         },
7209         [ALC255_FIXUP_ACER_MIC_NO_PRESENCE] = {
7210                 .type = HDA_FIXUP_PINS,
7211                 .v.pins = (const struct hda_pintbl[]) {
7212                         { 0x19, 0x01a1913c }, /* use as headset mic, without its own jack detect */
7213                         { }
7214                 },
7215                 .chained = true,
7216                 .chain_id = ALC255_FIXUP_HEADSET_MODE
7217         },
7218         [ALC255_FIXUP_ASUS_MIC_NO_PRESENCE] = {
7219                 .type = HDA_FIXUP_PINS,
7220                 .v.pins = (const struct hda_pintbl[]) {
7221                         { 0x19, 0x01a1913c }, /* use as headset mic, without its own jack detect */
7222                         { }
7223                 },
7224                 .chained = true,
7225                 .chain_id = ALC255_FIXUP_HEADSET_MODE
7226         },
7227         [ALC255_FIXUP_DELL1_MIC_NO_PRESENCE] = {
7228                 .type = HDA_FIXUP_PINS,
7229                 .v.pins = (const struct hda_pintbl[]) {
7230                         { 0x19, 0x01a1913c }, /* use as headset mic, without its own jack detect */
7231                         { 0x1a, 0x01a1913d }, /* use as headphone mic, without its own jack detect */
7232                         { }
7233                 },
7234                 .chained = true,
7235                 .chain_id = ALC255_FIXUP_HEADSET_MODE
7236         },
7237         [ALC255_FIXUP_DELL2_MIC_NO_PRESENCE] = {
7238                 .type = HDA_FIXUP_PINS,
7239                 .v.pins = (const struct hda_pintbl[]) {
7240                         { 0x19, 0x01a1913c }, /* use as headset mic, without its own jack detect */
7241                         { }
7242                 },
7243                 .chained = true,
7244                 .chain_id = ALC255_FIXUP_HEADSET_MODE_NO_HP_MIC
7245         },
7246         [ALC255_FIXUP_HEADSET_MODE] = {
7247                 .type = HDA_FIXUP_FUNC,
7248                 .v.func = alc_fixup_headset_mode_alc255,
7249                 .chained = true,
7250                 .chain_id = ALC255_FIXUP_MIC_MUTE_LED
7251         },
7252         [ALC255_FIXUP_HEADSET_MODE_NO_HP_MIC] = {
7253                 .type = HDA_FIXUP_FUNC,
7254                 .v.func = alc_fixup_headset_mode_alc255_no_hp_mic,
7255         },
7256         [ALC293_FIXUP_DELL1_MIC_NO_PRESENCE] = {
7257                 .type = HDA_FIXUP_PINS,
7258                 .v.pins = (const struct hda_pintbl[]) {
7259                         { 0x18, 0x01a1913d }, /* use as headphone mic, without its own jack detect */
7260                         { 0x1a, 0x01a1913c }, /* use as headset mic, without its own jack detect */
7261                         { }
7262                 },
7263                 .chained = true,
7264                 .chain_id = ALC269_FIXUP_HEADSET_MODE
7265         },
7266         [ALC292_FIXUP_TPT440_DOCK] = {
7267                 .type = HDA_FIXUP_FUNC,
7268                 .v.func = alc_fixup_tpt440_dock,
7269                 .chained = true,
7270                 .chain_id = ALC269_FIXUP_LIMIT_INT_MIC_BOOST
7271         },
7272         [ALC292_FIXUP_TPT440] = {
7273                 .type = HDA_FIXUP_FUNC,
7274                 .v.func = alc_fixup_disable_aamix,
7275                 .chained = true,
7276                 .chain_id = ALC292_FIXUP_TPT440_DOCK,
7277         },
7278         [ALC283_FIXUP_HEADSET_MIC] = {
7279                 .type = HDA_FIXUP_PINS,
7280                 .v.pins = (const struct hda_pintbl[]) {
7281                         { 0x19, 0x04a110f0 },
7282                         { },
7283                 },
7284         },
7285         [ALC255_FIXUP_MIC_MUTE_LED] = {
7286                 .type = HDA_FIXUP_FUNC,
7287                 .v.func = alc_fixup_micmute_led,
7288         },
7289         [ALC282_FIXUP_ASPIRE_V5_PINS] = {
7290                 .type = HDA_FIXUP_PINS,
7291                 .v.pins = (const struct hda_pintbl[]) {
7292                         { 0x12, 0x90a60130 },
7293                         { 0x14, 0x90170110 },
7294                         { 0x17, 0x40000008 },
7295                         { 0x18, 0x411111f0 },
7296                         { 0x19, 0x01a1913c },
7297                         { 0x1a, 0x411111f0 },
7298                         { 0x1b, 0x411111f0 },
7299                         { 0x1d, 0x40f89b2d },
7300                         { 0x1e, 0x411111f0 },
7301                         { 0x21, 0x0321101f },
7302                         { },
7303                 },
7304         },
7305         [ALC269VB_FIXUP_ASPIRE_E1_COEF] = {
7306                 .type = HDA_FIXUP_FUNC,
7307                 .v.func = alc269vb_fixup_aspire_e1_coef,
7308         },
7309         [ALC280_FIXUP_HP_GPIO4] = {
7310                 .type = HDA_FIXUP_FUNC,
7311                 .v.func = alc280_fixup_hp_gpio4,
7312         },
7313         [ALC286_FIXUP_HP_GPIO_LED] = {
7314                 .type = HDA_FIXUP_FUNC,
7315                 .v.func = alc286_fixup_hp_gpio_led,
7316         },
7317         [ALC280_FIXUP_HP_GPIO2_MIC_HOTKEY] = {
7318                 .type = HDA_FIXUP_FUNC,
7319                 .v.func = alc280_fixup_hp_gpio2_mic_hotkey,
7320         },
7321         [ALC280_FIXUP_HP_DOCK_PINS] = {
7322                 .type = HDA_FIXUP_PINS,
7323                 .v.pins = (const struct hda_pintbl[]) {
7324                         { 0x1b, 0x21011020 }, /* line-out */
7325                         { 0x1a, 0x01a1903c }, /* headset mic */
7326                         { 0x18, 0x2181103f }, /* line-in */
7327                         { },
7328                 },
7329                 .chained = true,
7330                 .chain_id = ALC280_FIXUP_HP_GPIO4
7331         },
7332         [ALC269_FIXUP_HP_DOCK_GPIO_MIC1_LED] = {
7333                 .type = HDA_FIXUP_PINS,
7334                 .v.pins = (const struct hda_pintbl[]) {
7335                         { 0x1b, 0x21011020 }, /* line-out */
7336                         { 0x18, 0x2181103f }, /* line-in */
7337                         { },
7338                 },
7339                 .chained = true,
7340                 .chain_id = ALC269_FIXUP_HP_GPIO_MIC1_LED
7341         },
7342         [ALC280_FIXUP_HP_9480M] = {
7343                 .type = HDA_FIXUP_FUNC,
7344                 .v.func = alc280_fixup_hp_9480m,
7345         },
7346         [ALC245_FIXUP_HP_X360_AMP] = {
7347                 .type = HDA_FIXUP_FUNC,
7348                 .v.func = alc245_fixup_hp_x360_amp,
7349                 .chained = true,
7350                 .chain_id = ALC245_FIXUP_HP_GPIO_LED
7351         },
7352         [ALC288_FIXUP_DELL_HEADSET_MODE] = {
7353                 .type = HDA_FIXUP_FUNC,
7354                 .v.func = alc_fixup_headset_mode_dell_alc288,
7355                 .chained = true,
7356                 .chain_id = ALC255_FIXUP_MIC_MUTE_LED
7357         },
7358         [ALC288_FIXUP_DELL1_MIC_NO_PRESENCE] = {
7359                 .type = HDA_FIXUP_PINS,
7360                 .v.pins = (const struct hda_pintbl[]) {
7361                         { 0x18, 0x01a1913c }, /* use as headset mic, without its own jack detect */
7362                         { 0x1a, 0x01a1913d }, /* use as headphone mic, without its own jack detect */
7363                         { }
7364                 },
7365                 .chained = true,
7366                 .chain_id = ALC288_FIXUP_DELL_HEADSET_MODE
7367         },
7368         [ALC288_FIXUP_DISABLE_AAMIX] = {
7369                 .type = HDA_FIXUP_FUNC,
7370                 .v.func = alc_fixup_disable_aamix,
7371                 .chained = true,
7372                 .chain_id = ALC288_FIXUP_DELL1_MIC_NO_PRESENCE
7373         },
7374         [ALC288_FIXUP_DELL_XPS_13] = {
7375                 .type = HDA_FIXUP_FUNC,
7376                 .v.func = alc_fixup_dell_xps13,
7377                 .chained = true,
7378                 .chain_id = ALC288_FIXUP_DISABLE_AAMIX
7379         },
7380         [ALC292_FIXUP_DISABLE_AAMIX] = {
7381                 .type = HDA_FIXUP_FUNC,
7382                 .v.func = alc_fixup_disable_aamix,
7383                 .chained = true,
7384                 .chain_id = ALC269_FIXUP_DELL2_MIC_NO_PRESENCE
7385         },
7386         [ALC293_FIXUP_DISABLE_AAMIX_MULTIJACK] = {
7387                 .type = HDA_FIXUP_FUNC,
7388                 .v.func = alc_fixup_disable_aamix,
7389                 .chained = true,
7390                 .chain_id = ALC293_FIXUP_DELL1_MIC_NO_PRESENCE
7391         },
7392         [ALC292_FIXUP_DELL_E7X_AAMIX] = {
7393                 .type = HDA_FIXUP_FUNC,
7394                 .v.func = alc_fixup_dell_xps13,
7395                 .chained = true,
7396                 .chain_id = ALC292_FIXUP_DISABLE_AAMIX
7397         },
7398         [ALC292_FIXUP_DELL_E7X] = {
7399                 .type = HDA_FIXUP_FUNC,
7400                 .v.func = alc_fixup_micmute_led,
7401                 /* micmute fixup must be applied at last */
7402                 .chained_before = true,
7403                 .chain_id = ALC292_FIXUP_DELL_E7X_AAMIX,
7404         },
7405         [ALC298_FIXUP_ALIENWARE_MIC_NO_PRESENCE] = {
7406                 .type = HDA_FIXUP_PINS,
7407                 .v.pins = (const struct hda_pintbl[]) {
7408                         { 0x18, 0x01a1913c }, /* headset mic w/o jack detect */
7409                         { }
7410                 },
7411                 .chained_before = true,
7412                 .chain_id = ALC269_FIXUP_HEADSET_MODE,
7413         },
7414         [ALC298_FIXUP_DELL1_MIC_NO_PRESENCE] = {
7415                 .type = HDA_FIXUP_PINS,
7416                 .v.pins = (const struct hda_pintbl[]) {
7417                         { 0x18, 0x01a1913c }, /* use as headset mic, without its own jack detect */
7418                         { 0x1a, 0x01a1913d }, /* use as headphone mic, without its own jack detect */
7419                         { }
7420                 },
7421                 .chained = true,
7422                 .chain_id = ALC269_FIXUP_HEADSET_MODE
7423         },
7424         [ALC298_FIXUP_DELL_AIO_MIC_NO_PRESENCE] = {
7425                 .type = HDA_FIXUP_PINS,
7426                 .v.pins = (const struct hda_pintbl[]) {
7427                         { 0x18, 0x01a1913c }, /* use as headset mic, without its own jack detect */
7428                         { }
7429                 },
7430                 .chained = true,
7431                 .chain_id = ALC269_FIXUP_HEADSET_MODE
7432         },
7433         [ALC275_FIXUP_DELL_XPS] = {
7434                 .type = HDA_FIXUP_VERBS,
7435                 .v.verbs = (const struct hda_verb[]) {
7436                         /* Enables internal speaker */
7437                         {0x20, AC_VERB_SET_COEF_INDEX, 0x1f},
7438                         {0x20, AC_VERB_SET_PROC_COEF, 0x00c0},
7439                         {0x20, AC_VERB_SET_COEF_INDEX, 0x30},
7440                         {0x20, AC_VERB_SET_PROC_COEF, 0x00b1},
7441                         {}
7442                 }
7443         },
7444         [ALC293_FIXUP_LENOVO_SPK_NOISE] = {
7445                 .type = HDA_FIXUP_FUNC,
7446                 .v.func = alc_fixup_disable_aamix,
7447                 .chained = true,
7448                 .chain_id = ALC269_FIXUP_THINKPAD_ACPI
7449         },
7450         [ALC233_FIXUP_LENOVO_LINE2_MIC_HOTKEY] = {
7451                 .type = HDA_FIXUP_FUNC,
7452                 .v.func = alc233_fixup_lenovo_line2_mic_hotkey,
7453         },
7454         [ALC233_FIXUP_INTEL_NUC8_DMIC] = {
7455                 .type = HDA_FIXUP_FUNC,
7456                 .v.func = alc_fixup_inv_dmic,
7457                 .chained = true,
7458                 .chain_id = ALC233_FIXUP_INTEL_NUC8_BOOST,
7459         },
7460         [ALC233_FIXUP_INTEL_NUC8_BOOST] = {
7461                 .type = HDA_FIXUP_FUNC,
7462                 .v.func = alc269_fixup_limit_int_mic_boost
7463         },
7464         [ALC255_FIXUP_DELL_SPK_NOISE] = {
7465                 .type = HDA_FIXUP_FUNC,
7466                 .v.func = alc_fixup_disable_aamix,
7467                 .chained = true,
7468                 .chain_id = ALC255_FIXUP_DELL1_MIC_NO_PRESENCE
7469         },
7470         [ALC225_FIXUP_DISABLE_MIC_VREF] = {
7471                 .type = HDA_FIXUP_FUNC,
7472                 .v.func = alc_fixup_disable_mic_vref,
7473                 .chained = true,
7474                 .chain_id = ALC269_FIXUP_DELL1_MIC_NO_PRESENCE
7475         },
7476         [ALC225_FIXUP_DELL1_MIC_NO_PRESENCE] = {
7477                 .type = HDA_FIXUP_VERBS,
7478                 .v.verbs = (const struct hda_verb[]) {
7479                         /* Disable pass-through path for FRONT 14h */
7480                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x36 },
7481                         { 0x20, AC_VERB_SET_PROC_COEF, 0x57d7 },
7482                         {}
7483                 },
7484                 .chained = true,
7485                 .chain_id = ALC225_FIXUP_DISABLE_MIC_VREF
7486         },
7487         [ALC280_FIXUP_HP_HEADSET_MIC] = {
7488                 .type = HDA_FIXUP_FUNC,
7489                 .v.func = alc_fixup_disable_aamix,
7490                 .chained = true,
7491                 .chain_id = ALC269_FIXUP_HEADSET_MIC,
7492         },
7493         [ALC221_FIXUP_HP_FRONT_MIC] = {
7494                 .type = HDA_FIXUP_PINS,
7495                 .v.pins = (const struct hda_pintbl[]) {
7496                         { 0x19, 0x02a19020 }, /* Front Mic */
7497                         { }
7498                 },
7499         },
7500         [ALC292_FIXUP_TPT460] = {
7501                 .type = HDA_FIXUP_FUNC,
7502                 .v.func = alc_fixup_tpt440_dock,
7503                 .chained = true,
7504                 .chain_id = ALC293_FIXUP_LENOVO_SPK_NOISE,
7505         },
7506         [ALC298_FIXUP_SPK_VOLUME] = {
7507                 .type = HDA_FIXUP_FUNC,
7508                 .v.func = alc298_fixup_speaker_volume,
7509                 .chained = true,
7510                 .chain_id = ALC298_FIXUP_DELL_AIO_MIC_NO_PRESENCE,
7511         },
7512         [ALC298_FIXUP_LENOVO_SPK_VOLUME] = {
7513                 .type = HDA_FIXUP_FUNC,
7514                 .v.func = alc298_fixup_speaker_volume,
7515         },
7516         [ALC295_FIXUP_DISABLE_DAC3] = {
7517                 .type = HDA_FIXUP_FUNC,
7518                 .v.func = alc295_fixup_disable_dac3,
7519         },
7520         [ALC285_FIXUP_SPEAKER2_TO_DAC1] = {
7521                 .type = HDA_FIXUP_FUNC,
7522                 .v.func = alc285_fixup_speaker2_to_dac1,
7523                 .chained = true,
7524                 .chain_id = ALC269_FIXUP_THINKPAD_ACPI
7525         },
7526         [ALC256_FIXUP_DELL_INSPIRON_7559_SUBWOOFER] = {
7527                 .type = HDA_FIXUP_PINS,
7528                 .v.pins = (const struct hda_pintbl[]) {
7529                         { 0x1b, 0x90170151 },
7530                         { }
7531                 },
7532                 .chained = true,
7533                 .chain_id = ALC255_FIXUP_DELL1_MIC_NO_PRESENCE
7534         },
7535         [ALC269_FIXUP_ATIV_BOOK_8] = {
7536                 .type = HDA_FIXUP_FUNC,
7537                 .v.func = alc_fixup_auto_mute_via_amp,
7538                 .chained = true,
7539                 .chain_id = ALC269_FIXUP_NO_SHUTUP
7540         },
7541         [ALC221_FIXUP_HP_MIC_NO_PRESENCE] = {
7542                 .type = HDA_FIXUP_PINS,
7543                 .v.pins = (const struct hda_pintbl[]) {
7544                         { 0x18, 0x01a1913c }, /* use as headset mic, without its own jack detect */
7545                         { 0x1a, 0x01a1913d }, /* use as headphone mic, without its own jack detect */
7546                         { }
7547                 },
7548                 .chained = true,
7549                 .chain_id = ALC269_FIXUP_HEADSET_MODE
7550         },
7551         [ALC256_FIXUP_ASUS_HEADSET_MODE] = {
7552                 .type = HDA_FIXUP_FUNC,
7553                 .v.func = alc_fixup_headset_mode,
7554         },
7555         [ALC256_FIXUP_ASUS_MIC] = {
7556                 .type = HDA_FIXUP_PINS,
7557                 .v.pins = (const struct hda_pintbl[]) {
7558                         { 0x13, 0x90a60160 }, /* use as internal mic */
7559                         { 0x19, 0x04a11120 }, /* use as headset mic, without its own jack detect */
7560                         { }
7561                 },
7562                 .chained = true,
7563                 .chain_id = ALC256_FIXUP_ASUS_HEADSET_MODE
7564         },
7565         [ALC256_FIXUP_ASUS_AIO_GPIO2] = {
7566                 .type = HDA_FIXUP_FUNC,
7567                 /* Set up GPIO2 for the speaker amp */
7568                 .v.func = alc_fixup_gpio4,
7569         },
7570         [ALC233_FIXUP_ASUS_MIC_NO_PRESENCE] = {
7571                 .type = HDA_FIXUP_PINS,
7572                 .v.pins = (const struct hda_pintbl[]) {
7573                         { 0x19, 0x01a1913c }, /* use as headset mic, without its own jack detect */
7574                         { }
7575                 },
7576                 .chained = true,
7577                 .chain_id = ALC269_FIXUP_HEADSET_MIC
7578         },
7579         [ALC233_FIXUP_EAPD_COEF_AND_MIC_NO_PRESENCE] = {
7580                 .type = HDA_FIXUP_VERBS,
7581                 .v.verbs = (const struct hda_verb[]) {
7582                         /* Enables internal speaker */
7583                         {0x20, AC_VERB_SET_COEF_INDEX, 0x40},
7584                         {0x20, AC_VERB_SET_PROC_COEF, 0x8800},
7585                         {}
7586                 },
7587                 .chained = true,
7588                 .chain_id = ALC233_FIXUP_ASUS_MIC_NO_PRESENCE
7589         },
7590         [ALC233_FIXUP_LENOVO_MULTI_CODECS] = {
7591                 .type = HDA_FIXUP_FUNC,
7592                 .v.func = alc233_alc662_fixup_lenovo_dual_codecs,
7593                 .chained = true,
7594                 .chain_id = ALC269_FIXUP_GPIO2
7595         },
7596         [ALC233_FIXUP_ACER_HEADSET_MIC] = {
7597                 .type = HDA_FIXUP_VERBS,
7598                 .v.verbs = (const struct hda_verb[]) {
7599                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x45 },
7600                         { 0x20, AC_VERB_SET_PROC_COEF, 0x5089 },
7601                         { }
7602                 },
7603                 .chained = true,
7604                 .chain_id = ALC233_FIXUP_ASUS_MIC_NO_PRESENCE
7605         },
7606         [ALC294_FIXUP_LENOVO_MIC_LOCATION] = {
7607                 .type = HDA_FIXUP_PINS,
7608                 .v.pins = (const struct hda_pintbl[]) {
7609                         /* Change the mic location from front to right, otherwise there are
7610                            two front mics with the same name, pulseaudio can't handle them.
7611                            This is just a temporary workaround, after applying this fixup,
7612                            there will be one "Front Mic" and one "Mic" in this machine.
7613                          */
7614                         { 0x1a, 0x04a19040 },
7615                         { }
7616                 },
7617         },
7618         [ALC225_FIXUP_DELL_WYSE_MIC_NO_PRESENCE] = {
7619                 .type = HDA_FIXUP_PINS,
7620                 .v.pins = (const struct hda_pintbl[]) {
7621                         { 0x16, 0x0101102f }, /* Rear Headset HP */
7622                         { 0x19, 0x02a1913c }, /* use as Front headset mic, without its own jack detect */
7623                         { 0x1a, 0x01a19030 }, /* Rear Headset MIC */
7624                         { 0x1b, 0x02011020 },
7625                         { }
7626                 },
7627                 .chained = true,
7628                 .chain_id = ALC225_FIXUP_S3_POP_NOISE
7629         },
7630         [ALC225_FIXUP_S3_POP_NOISE] = {
7631                 .type = HDA_FIXUP_FUNC,
7632                 .v.func = alc225_fixup_s3_pop_noise,
7633                 .chained = true,
7634                 .chain_id = ALC269_FIXUP_HEADSET_MODE_NO_HP_MIC
7635         },
7636         [ALC700_FIXUP_INTEL_REFERENCE] = {
7637                 .type = HDA_FIXUP_VERBS,
7638                 .v.verbs = (const struct hda_verb[]) {
7639                         /* Enables internal speaker */
7640                         {0x20, AC_VERB_SET_COEF_INDEX, 0x45},
7641                         {0x20, AC_VERB_SET_PROC_COEF, 0x5289},
7642                         {0x20, AC_VERB_SET_COEF_INDEX, 0x4A},
7643                         {0x20, AC_VERB_SET_PROC_COEF, 0x001b},
7644                         {0x58, AC_VERB_SET_COEF_INDEX, 0x00},
7645                         {0x58, AC_VERB_SET_PROC_COEF, 0x3888},
7646                         {0x20, AC_VERB_SET_COEF_INDEX, 0x6f},
7647                         {0x20, AC_VERB_SET_PROC_COEF, 0x2c0b},
7648                         {}
7649                 }
7650         },
7651         [ALC274_FIXUP_DELL_BIND_DACS] = {
7652                 .type = HDA_FIXUP_FUNC,
7653                 .v.func = alc274_fixup_bind_dacs,
7654                 .chained = true,
7655                 .chain_id = ALC269_FIXUP_DELL1_MIC_NO_PRESENCE
7656         },
7657         [ALC274_FIXUP_DELL_AIO_LINEOUT_VERB] = {
7658                 .type = HDA_FIXUP_PINS,
7659                 .v.pins = (const struct hda_pintbl[]) {
7660                         { 0x1b, 0x0401102f },
7661                         { }
7662                 },
7663                 .chained = true,
7664                 .chain_id = ALC274_FIXUP_DELL_BIND_DACS
7665         },
7666         [ALC298_FIXUP_TPT470_DOCK_FIX] = {
7667                 .type = HDA_FIXUP_FUNC,
7668                 .v.func = alc_fixup_tpt470_dock,
7669                 .chained = true,
7670                 .chain_id = ALC293_FIXUP_LENOVO_SPK_NOISE
7671         },
7672         [ALC298_FIXUP_TPT470_DOCK] = {
7673                 .type = HDA_FIXUP_FUNC,
7674                 .v.func = alc_fixup_tpt470_dacs,
7675                 .chained = true,
7676                 .chain_id = ALC298_FIXUP_TPT470_DOCK_FIX
7677         },
7678         [ALC255_FIXUP_DUMMY_LINEOUT_VERB] = {
7679                 .type = HDA_FIXUP_PINS,
7680                 .v.pins = (const struct hda_pintbl[]) {
7681                         { 0x14, 0x0201101f },
7682                         { }
7683                 },
7684                 .chained = true,
7685                 .chain_id = ALC255_FIXUP_DELL1_MIC_NO_PRESENCE
7686         },
7687         [ALC255_FIXUP_DELL_HEADSET_MIC] = {
7688                 .type = HDA_FIXUP_PINS,
7689                 .v.pins = (const struct hda_pintbl[]) {
7690                         { 0x19, 0x01a1913c }, /* use as headset mic, without its own jack detect */
7691                         { }
7692                 },
7693                 .chained = true,
7694                 .chain_id = ALC269_FIXUP_HEADSET_MIC
7695         },
7696         [ALC295_FIXUP_HP_X360] = {
7697                 .type = HDA_FIXUP_FUNC,
7698                 .v.func = alc295_fixup_hp_top_speakers,
7699                 .chained = true,
7700                 .chain_id = ALC269_FIXUP_HP_MUTE_LED_MIC3
7701         },
7702         [ALC221_FIXUP_HP_HEADSET_MIC] = {
7703                 .type = HDA_FIXUP_PINS,
7704                 .v.pins = (const struct hda_pintbl[]) {
7705                         { 0x19, 0x0181313f},
7706                         { }
7707                 },
7708                 .chained = true,
7709                 .chain_id = ALC269_FIXUP_HEADSET_MIC
7710         },
7711         [ALC285_FIXUP_LENOVO_HEADPHONE_NOISE] = {
7712                 .type = HDA_FIXUP_FUNC,
7713                 .v.func = alc285_fixup_invalidate_dacs,
7714                 .chained = true,
7715                 .chain_id = ALC269_FIXUP_THINKPAD_ACPI
7716         },
7717         [ALC295_FIXUP_HP_AUTO_MUTE] = {
7718                 .type = HDA_FIXUP_FUNC,
7719                 .v.func = alc_fixup_auto_mute_via_amp,
7720         },
7721         [ALC286_FIXUP_ACER_AIO_MIC_NO_PRESENCE] = {
7722                 .type = HDA_FIXUP_PINS,
7723                 .v.pins = (const struct hda_pintbl[]) {
7724                         { 0x18, 0x01a1913c }, /* use as headset mic, without its own jack detect */
7725                         { }
7726                 },
7727                 .chained = true,
7728                 .chain_id = ALC269_FIXUP_HEADSET_MIC
7729         },
7730         [ALC294_FIXUP_ASUS_MIC] = {
7731                 .type = HDA_FIXUP_PINS,
7732                 .v.pins = (const struct hda_pintbl[]) {
7733                         { 0x13, 0x90a60160 }, /* use as internal mic */
7734                         { 0x19, 0x04a11120 }, /* use as headset mic, without its own jack detect */
7735                         { }
7736                 },
7737                 .chained = true,
7738                 .chain_id = ALC269_FIXUP_HEADSET_MIC
7739         },
7740         [ALC294_FIXUP_ASUS_HEADSET_MIC] = {
7741                 .type = HDA_FIXUP_PINS,
7742                 .v.pins = (const struct hda_pintbl[]) {
7743                         { 0x19, 0x01a1103c }, /* use as headset mic */
7744                         { }
7745                 },
7746                 .chained = true,
7747                 .chain_id = ALC269_FIXUP_HEADSET_MIC
7748         },
7749         [ALC294_FIXUP_ASUS_SPK] = {
7750                 .type = HDA_FIXUP_VERBS,
7751                 .v.verbs = (const struct hda_verb[]) {
7752                         /* Set EAPD high */
7753                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x40 },
7754                         { 0x20, AC_VERB_SET_PROC_COEF, 0x8800 },
7755                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x0f },
7756                         { 0x20, AC_VERB_SET_PROC_COEF, 0x7774 },
7757                         { }
7758                 },
7759                 .chained = true,
7760                 .chain_id = ALC294_FIXUP_ASUS_HEADSET_MIC
7761         },
7762         [ALC295_FIXUP_CHROME_BOOK] = {
7763                 .type = HDA_FIXUP_FUNC,
7764                 .v.func = alc295_fixup_chromebook,
7765                 .chained = true,
7766                 .chain_id = ALC225_FIXUP_HEADSET_JACK
7767         },
7768         [ALC225_FIXUP_HEADSET_JACK] = {
7769                 .type = HDA_FIXUP_FUNC,
7770                 .v.func = alc_fixup_headset_jack,
7771         },
7772         [ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE] = {
7773                 .type = HDA_FIXUP_PINS,
7774                 .v.pins = (const struct hda_pintbl[]) {
7775                         { 0x1a, 0x01a1913c }, /* use as headset mic, without its own jack detect */
7776                         { }
7777                 },
7778                 .chained = true,
7779                 .chain_id = ALC269_FIXUP_HEADSET_MODE_NO_HP_MIC
7780         },
7781         [ALC285_FIXUP_LENOVO_PC_BEEP_IN_NOISE] = {
7782                 .type = HDA_FIXUP_VERBS,
7783                 .v.verbs = (const struct hda_verb[]) {
7784                         /* Disable PCBEEP-IN passthrough */
7785                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x36 },
7786                         { 0x20, AC_VERB_SET_PROC_COEF, 0x57d7 },
7787                         { }
7788                 },
7789                 .chained = true,
7790                 .chain_id = ALC285_FIXUP_LENOVO_HEADPHONE_NOISE
7791         },
7792         [ALC255_FIXUP_ACER_HEADSET_MIC] = {
7793                 .type = HDA_FIXUP_PINS,
7794                 .v.pins = (const struct hda_pintbl[]) {
7795                         { 0x19, 0x03a11130 },
7796                         { 0x1a, 0x90a60140 }, /* use as internal mic */
7797                         { }
7798                 },
7799                 .chained = true,
7800                 .chain_id = ALC255_FIXUP_HEADSET_MODE_NO_HP_MIC
7801         },
7802         [ALC225_FIXUP_DELL_WYSE_AIO_MIC_NO_PRESENCE] = {
7803                 .type = HDA_FIXUP_PINS,
7804                 .v.pins = (const struct hda_pintbl[]) {
7805                         { 0x16, 0x01011020 }, /* Rear Line out */
7806                         { 0x19, 0x01a1913c }, /* use as Front headset mic, without its own jack detect */
7807                         { }
7808                 },
7809                 .chained = true,
7810                 .chain_id = ALC225_FIXUP_WYSE_AUTO_MUTE
7811         },
7812         [ALC225_FIXUP_WYSE_AUTO_MUTE] = {
7813                 .type = HDA_FIXUP_FUNC,
7814                 .v.func = alc_fixup_auto_mute_via_amp,
7815                 .chained = true,
7816                 .chain_id = ALC225_FIXUP_WYSE_DISABLE_MIC_VREF
7817         },
7818         [ALC225_FIXUP_WYSE_DISABLE_MIC_VREF] = {
7819                 .type = HDA_FIXUP_FUNC,
7820                 .v.func = alc_fixup_disable_mic_vref,
7821                 .chained = true,
7822                 .chain_id = ALC269_FIXUP_HEADSET_MODE_NO_HP_MIC
7823         },
7824         [ALC286_FIXUP_ACER_AIO_HEADSET_MIC] = {
7825                 .type = HDA_FIXUP_VERBS,
7826                 .v.verbs = (const struct hda_verb[]) {
7827                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x4f },
7828                         { 0x20, AC_VERB_SET_PROC_COEF, 0x5029 },
7829                         { }
7830                 },
7831                 .chained = true,
7832                 .chain_id = ALC286_FIXUP_ACER_AIO_MIC_NO_PRESENCE
7833         },
7834         [ALC256_FIXUP_ASUS_HEADSET_MIC] = {
7835                 .type = HDA_FIXUP_PINS,
7836                 .v.pins = (const struct hda_pintbl[]) {
7837                         { 0x19, 0x03a11020 }, /* headset mic with jack detect */
7838                         { }
7839                 },
7840                 .chained = true,
7841                 .chain_id = ALC256_FIXUP_ASUS_HEADSET_MODE
7842         },
7843         [ALC256_FIXUP_ASUS_MIC_NO_PRESENCE] = {
7844                 .type = HDA_FIXUP_PINS,
7845                 .v.pins = (const struct hda_pintbl[]) {
7846                         { 0x19, 0x04a11120 }, /* use as headset mic, without its own jack detect */
7847                         { }
7848                 },
7849                 .chained = true,
7850                 .chain_id = ALC256_FIXUP_ASUS_HEADSET_MODE
7851         },
7852         [ALC299_FIXUP_PREDATOR_SPK] = {
7853                 .type = HDA_FIXUP_PINS,
7854                 .v.pins = (const struct hda_pintbl[]) {
7855                         { 0x21, 0x90170150 }, /* use as headset mic, without its own jack detect */
7856                         { }
7857                 }
7858         },
7859         [ALC256_FIXUP_MEDION_HEADSET_NO_PRESENCE] = {
7860                 .type = HDA_FIXUP_PINS,
7861                 .v.pins = (const struct hda_pintbl[]) {
7862                         { 0x19, 0x04a11040 },
7863                         { 0x21, 0x04211020 },
7864                         { }
7865                 },
7866                 .chained = true,
7867                 .chain_id = ALC256_FIXUP_ASUS_HEADSET_MODE
7868         },
7869         [ALC289_FIXUP_DELL_SPK2] = {
7870                 .type = HDA_FIXUP_PINS,
7871                 .v.pins = (const struct hda_pintbl[]) {
7872                         { 0x17, 0x90170130 }, /* bass spk */
7873                         { }
7874                 },
7875                 .chained = true,
7876                 .chain_id = ALC269_FIXUP_DELL4_MIC_NO_PRESENCE
7877         },
7878         [ALC289_FIXUP_DUAL_SPK] = {
7879                 .type = HDA_FIXUP_FUNC,
7880                 .v.func = alc285_fixup_speaker2_to_dac1,
7881                 .chained = true,
7882                 .chain_id = ALC289_FIXUP_DELL_SPK2
7883         },
7884         [ALC294_FIXUP_SPK2_TO_DAC1] = {
7885                 .type = HDA_FIXUP_FUNC,
7886                 .v.func = alc285_fixup_speaker2_to_dac1,
7887                 .chained = true,
7888                 .chain_id = ALC294_FIXUP_ASUS_HEADSET_MIC
7889         },
7890         [ALC294_FIXUP_ASUS_DUAL_SPK] = {
7891                 .type = HDA_FIXUP_FUNC,
7892                 /* The GPIO must be pulled to initialize the AMP */
7893                 .v.func = alc_fixup_gpio4,
7894                 .chained = true,
7895                 .chain_id = ALC294_FIXUP_SPK2_TO_DAC1
7896         },
7897         [ALC285_FIXUP_THINKPAD_X1_GEN7] = {
7898                 .type = HDA_FIXUP_FUNC,
7899                 .v.func = alc285_fixup_thinkpad_x1_gen7,
7900                 .chained = true,
7901                 .chain_id = ALC269_FIXUP_THINKPAD_ACPI
7902         },
7903         [ALC285_FIXUP_THINKPAD_HEADSET_JACK] = {
7904                 .type = HDA_FIXUP_FUNC,
7905                 .v.func = alc_fixup_headset_jack,
7906                 .chained = true,
7907                 .chain_id = ALC285_FIXUP_THINKPAD_X1_GEN7
7908         },
7909         [ALC294_FIXUP_ASUS_HPE] = {
7910                 .type = HDA_FIXUP_VERBS,
7911                 .v.verbs = (const struct hda_verb[]) {
7912                         /* Set EAPD high */
7913                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x0f },
7914                         { 0x20, AC_VERB_SET_PROC_COEF, 0x7774 },
7915                         { }
7916                 },
7917                 .chained = true,
7918                 .chain_id = ALC294_FIXUP_ASUS_HEADSET_MIC
7919         },
7920         [ALC294_FIXUP_ASUS_GX502_PINS] = {
7921                 .type = HDA_FIXUP_PINS,
7922                 .v.pins = (const struct hda_pintbl[]) {
7923                         { 0x19, 0x03a11050 }, /* front HP mic */
7924                         { 0x1a, 0x01a11830 }, /* rear external mic */
7925                         { 0x21, 0x03211020 }, /* front HP out */
7926                         { }
7927                 },
7928                 .chained = true,
7929                 .chain_id = ALC294_FIXUP_ASUS_GX502_VERBS
7930         },
7931         [ALC294_FIXUP_ASUS_GX502_VERBS] = {
7932                 .type = HDA_FIXUP_VERBS,
7933                 .v.verbs = (const struct hda_verb[]) {
7934                         /* set 0x15 to HP-OUT ctrl */
7935                         { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0 },
7936                         /* unmute the 0x15 amp */
7937                         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000 },
7938                         { }
7939                 },
7940                 .chained = true,
7941                 .chain_id = ALC294_FIXUP_ASUS_GX502_HP
7942         },
7943         [ALC294_FIXUP_ASUS_GX502_HP] = {
7944                 .type = HDA_FIXUP_FUNC,
7945                 .v.func = alc294_fixup_gx502_hp,
7946         },
7947         [ALC294_FIXUP_ASUS_GU502_PINS] = {
7948                 .type = HDA_FIXUP_PINS,
7949                 .v.pins = (const struct hda_pintbl[]) {
7950                         { 0x19, 0x01a11050 }, /* rear HP mic */
7951                         { 0x1a, 0x01a11830 }, /* rear external mic */
7952                         { 0x21, 0x012110f0 }, /* rear HP out */
7953                         { }
7954                 },
7955                 .chained = true,
7956                 .chain_id = ALC294_FIXUP_ASUS_GU502_VERBS
7957         },
7958         [ALC294_FIXUP_ASUS_GU502_VERBS] = {
7959                 .type = HDA_FIXUP_VERBS,
7960                 .v.verbs = (const struct hda_verb[]) {
7961                         /* set 0x15 to HP-OUT ctrl */
7962                         { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0 },
7963                         /* unmute the 0x15 amp */
7964                         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000 },
7965                         /* set 0x1b to HP-OUT */
7966                         { 0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
7967                         { }
7968                 },
7969                 .chained = true,
7970                 .chain_id = ALC294_FIXUP_ASUS_GU502_HP
7971         },
7972         [ALC294_FIXUP_ASUS_GU502_HP] = {
7973                 .type = HDA_FIXUP_FUNC,
7974                 .v.func = alc294_fixup_gu502_hp,
7975         },
7976         [ALC294_FIXUP_ASUS_COEF_1B] = {
7977                 .type = HDA_FIXUP_VERBS,
7978                 .v.verbs = (const struct hda_verb[]) {
7979                         /* Set bit 10 to correct noisy output after reboot from
7980                          * Windows 10 (due to pop noise reduction?)
7981                          */
7982                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x1b },
7983                         { 0x20, AC_VERB_SET_PROC_COEF, 0x4e4b },
7984                         { }
7985                 },
7986                 .chained = true,
7987                 .chain_id = ALC289_FIXUP_ASUS_GA401,
7988         },
7989         [ALC285_FIXUP_HP_GPIO_LED] = {
7990                 .type = HDA_FIXUP_FUNC,
7991                 .v.func = alc285_fixup_hp_gpio_led,
7992         },
7993         [ALC285_FIXUP_HP_MUTE_LED] = {
7994                 .type = HDA_FIXUP_FUNC,
7995                 .v.func = alc285_fixup_hp_mute_led,
7996         },
7997         [ALC236_FIXUP_HP_GPIO_LED] = {
7998                 .type = HDA_FIXUP_FUNC,
7999                 .v.func = alc236_fixup_hp_gpio_led,
8000         },
8001         [ALC236_FIXUP_HP_MUTE_LED] = {
8002                 .type = HDA_FIXUP_FUNC,
8003                 .v.func = alc236_fixup_hp_mute_led,
8004         },
8005         [ALC236_FIXUP_HP_MUTE_LED_MICMUTE_VREF] = {
8006                 .type = HDA_FIXUP_FUNC,
8007                 .v.func = alc236_fixup_hp_mute_led_micmute_vref,
8008         },
8009         [ALC298_FIXUP_SAMSUNG_HEADPHONE_VERY_QUIET] = {
8010                 .type = HDA_FIXUP_VERBS,
8011                 .v.verbs = (const struct hda_verb[]) {
8012                         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc5 },
8013                         { }
8014                 },
8015         },
8016         [ALC295_FIXUP_ASUS_MIC_NO_PRESENCE] = {
8017                 .type = HDA_FIXUP_PINS,
8018                 .v.pins = (const struct hda_pintbl[]) {
8019                         { 0x19, 0x01a1913c }, /* use as headset mic, without its own jack detect */
8020                         { }
8021                 },
8022                 .chained = true,
8023                 .chain_id = ALC269_FIXUP_HEADSET_MODE
8024         },
8025         [ALC269VC_FIXUP_ACER_VCOPPERBOX_PINS] = {
8026                 .type = HDA_FIXUP_PINS,
8027                 .v.pins = (const struct hda_pintbl[]) {
8028                         { 0x14, 0x90100120 }, /* use as internal speaker */
8029                         { 0x18, 0x02a111f0 }, /* use as headset mic, without its own jack detect */
8030                         { 0x1a, 0x01011020 }, /* use as line out */
8031                         { },
8032                 },
8033                 .chained = true,
8034                 .chain_id = ALC269_FIXUP_HEADSET_MIC
8035         },
8036         [ALC269VC_FIXUP_ACER_HEADSET_MIC] = {
8037                 .type = HDA_FIXUP_PINS,
8038                 .v.pins = (const struct hda_pintbl[]) {
8039                         { 0x18, 0x02a11030 }, /* use as headset mic */
8040                         { }
8041                 },
8042                 .chained = true,
8043                 .chain_id = ALC269_FIXUP_HEADSET_MIC
8044         },
8045         [ALC269VC_FIXUP_ACER_MIC_NO_PRESENCE] = {
8046                 .type = HDA_FIXUP_PINS,
8047                 .v.pins = (const struct hda_pintbl[]) {
8048                         { 0x18, 0x01a11130 }, /* use as headset mic, without its own jack detect */
8049                         { }
8050                 },
8051                 .chained = true,
8052                 .chain_id = ALC269_FIXUP_HEADSET_MIC
8053         },
8054         [ALC289_FIXUP_ASUS_GA401] = {
8055                 .type = HDA_FIXUP_FUNC,
8056                 .v.func = alc289_fixup_asus_ga401,
8057                 .chained = true,
8058                 .chain_id = ALC289_FIXUP_ASUS_GA502,
8059         },
8060         [ALC289_FIXUP_ASUS_GA502] = {
8061                 .type = HDA_FIXUP_PINS,
8062                 .v.pins = (const struct hda_pintbl[]) {
8063                         { 0x19, 0x03a11020 }, /* headset mic with jack detect */
8064                         { }
8065                 },
8066         },
8067         [ALC256_FIXUP_ACER_MIC_NO_PRESENCE] = {
8068                 .type = HDA_FIXUP_PINS,
8069                 .v.pins = (const struct hda_pintbl[]) {
8070                         { 0x19, 0x02a11120 }, /* use as headset mic, without its own jack detect */
8071                         { }
8072                 },
8073                 .chained = true,
8074                 .chain_id = ALC256_FIXUP_ASUS_HEADSET_MODE
8075         },
8076         [ALC285_FIXUP_HP_GPIO_AMP_INIT] = {
8077                 .type = HDA_FIXUP_FUNC,
8078                 .v.func = alc285_fixup_hp_gpio_amp_init,
8079                 .chained = true,
8080                 .chain_id = ALC285_FIXUP_HP_GPIO_LED
8081         },
8082         [ALC269_FIXUP_CZC_B20] = {
8083                 .type = HDA_FIXUP_PINS,
8084                 .v.pins = (const struct hda_pintbl[]) {
8085                         { 0x12, 0x411111f0 },
8086                         { 0x14, 0x90170110 }, /* speaker */
8087                         { 0x15, 0x032f1020 }, /* HP out */
8088                         { 0x17, 0x411111f0 },
8089                         { 0x18, 0x03ab1040 }, /* mic */
8090                         { 0x19, 0xb7a7013f },
8091                         { 0x1a, 0x0181305f },
8092                         { 0x1b, 0x411111f0 },
8093                         { 0x1d, 0x411111f0 },
8094                         { 0x1e, 0x411111f0 },
8095                         { }
8096                 },
8097                 .chain_id = ALC269_FIXUP_DMIC,
8098         },
8099         [ALC269_FIXUP_CZC_TMI] = {
8100                 .type = HDA_FIXUP_PINS,
8101                 .v.pins = (const struct hda_pintbl[]) {
8102                         { 0x12, 0x4000c000 },
8103                         { 0x14, 0x90170110 }, /* speaker */
8104                         { 0x15, 0x0421401f }, /* HP out */
8105                         { 0x17, 0x411111f0 },
8106                         { 0x18, 0x04a19020 }, /* mic */
8107                         { 0x19, 0x411111f0 },
8108                         { 0x1a, 0x411111f0 },
8109                         { 0x1b, 0x411111f0 },
8110                         { 0x1d, 0x40448505 },
8111                         { 0x1e, 0x411111f0 },
8112                         { 0x20, 0x8000ffff },
8113                         { }
8114                 },
8115                 .chain_id = ALC269_FIXUP_DMIC,
8116         },
8117         [ALC269_FIXUP_CZC_L101] = {
8118                 .type = HDA_FIXUP_PINS,
8119                 .v.pins = (const struct hda_pintbl[]) {
8120                         { 0x12, 0x40000000 },
8121                         { 0x14, 0x01014010 }, /* speaker */
8122                         { 0x15, 0x411111f0 }, /* HP out */
8123                         { 0x16, 0x411111f0 },
8124                         { 0x18, 0x01a19020 }, /* mic */
8125                         { 0x19, 0x02a19021 },
8126                         { 0x1a, 0x0181302f },
8127                         { 0x1b, 0x0221401f },
8128                         { 0x1c, 0x411111f0 },
8129                         { 0x1d, 0x4044c601 },
8130                         { 0x1e, 0x411111f0 },
8131                         { }
8132                 },
8133                 .chain_id = ALC269_FIXUP_DMIC,
8134         },
8135         [ALC269_FIXUP_LEMOTE_A1802] = {
8136                 .type = HDA_FIXUP_PINS,
8137                 .v.pins = (const struct hda_pintbl[]) {
8138                         { 0x12, 0x40000000 },
8139                         { 0x14, 0x90170110 }, /* speaker */
8140                         { 0x17, 0x411111f0 },
8141                         { 0x18, 0x03a19040 }, /* mic1 */
8142                         { 0x19, 0x90a70130 }, /* mic2 */
8143                         { 0x1a, 0x411111f0 },
8144                         { 0x1b, 0x411111f0 },
8145                         { 0x1d, 0x40489d2d },
8146                         { 0x1e, 0x411111f0 },
8147                         { 0x20, 0x0003ffff },
8148                         { 0x21, 0x03214020 },
8149                         { }
8150                 },
8151                 .chain_id = ALC269_FIXUP_DMIC,
8152         },
8153         [ALC269_FIXUP_LEMOTE_A190X] = {
8154                 .type = HDA_FIXUP_PINS,
8155                 .v.pins = (const struct hda_pintbl[]) {
8156                         { 0x14, 0x99130110 }, /* speaker */
8157                         { 0x15, 0x0121401f }, /* HP out */
8158                         { 0x18, 0x01a19c20 }, /* rear  mic */
8159                         { 0x19, 0x99a3092f }, /* front mic */
8160                         { 0x1b, 0x0201401f }, /* front lineout */
8161                         { }
8162                 },
8163                 .chain_id = ALC269_FIXUP_DMIC,
8164         },
8165         [ALC256_FIXUP_INTEL_NUC8_RUGGED] = {
8166                 .type = HDA_FIXUP_PINS,
8167                 .v.pins = (const struct hda_pintbl[]) {
8168                         { 0x1b, 0x01a1913c }, /* use as headset mic, without its own jack detect */
8169                         { }
8170                 },
8171                 .chained = true,
8172                 .chain_id = ALC269_FIXUP_HEADSET_MODE
8173         },
8174         [ALC256_FIXUP_INTEL_NUC10] = {
8175                 .type = HDA_FIXUP_PINS,
8176                 .v.pins = (const struct hda_pintbl[]) {
8177                         { 0x19, 0x01a1913c }, /* use as headset mic, without its own jack detect */
8178                         { }
8179                 },
8180                 .chained = true,
8181                 .chain_id = ALC269_FIXUP_HEADSET_MODE
8182         },
8183         [ALC255_FIXUP_XIAOMI_HEADSET_MIC] = {
8184                 .type = HDA_FIXUP_VERBS,
8185                 .v.verbs = (const struct hda_verb[]) {
8186                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x45 },
8187                         { 0x20, AC_VERB_SET_PROC_COEF, 0x5089 },
8188                         { }
8189                 },
8190                 .chained = true,
8191                 .chain_id = ALC289_FIXUP_ASUS_GA502
8192         },
8193         [ALC274_FIXUP_HP_MIC] = {
8194                 .type = HDA_FIXUP_VERBS,
8195                 .v.verbs = (const struct hda_verb[]) {
8196                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x45 },
8197                         { 0x20, AC_VERB_SET_PROC_COEF, 0x5089 },
8198                         { }
8199                 },
8200         },
8201         [ALC274_FIXUP_HP_HEADSET_MIC] = {
8202                 .type = HDA_FIXUP_FUNC,
8203                 .v.func = alc274_fixup_hp_headset_mic,
8204                 .chained = true,
8205                 .chain_id = ALC274_FIXUP_HP_MIC
8206         },
8207         [ALC274_FIXUP_HP_ENVY_GPIO] = {
8208                 .type = HDA_FIXUP_FUNC,
8209                 .v.func = alc274_fixup_hp_envy_gpio,
8210         },
8211         [ALC256_FIXUP_ASUS_HPE] = {
8212                 .type = HDA_FIXUP_VERBS,
8213                 .v.verbs = (const struct hda_verb[]) {
8214                         /* Set EAPD high */
8215                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x0f },
8216                         { 0x20, AC_VERB_SET_PROC_COEF, 0x7778 },
8217                         { }
8218                 },
8219                 .chained = true,
8220                 .chain_id = ALC294_FIXUP_ASUS_HEADSET_MIC
8221         },
8222         [ALC285_FIXUP_THINKPAD_NO_BASS_SPK_HEADSET_JACK] = {
8223                 .type = HDA_FIXUP_FUNC,
8224                 .v.func = alc_fixup_headset_jack,
8225                 .chained = true,
8226                 .chain_id = ALC269_FIXUP_THINKPAD_ACPI
8227         },
8228         [ALC287_FIXUP_HP_GPIO_LED] = {
8229                 .type = HDA_FIXUP_FUNC,
8230                 .v.func = alc287_fixup_hp_gpio_led,
8231         },
8232         [ALC256_FIXUP_HP_HEADSET_MIC] = {
8233                 .type = HDA_FIXUP_FUNC,
8234                 .v.func = alc274_fixup_hp_headset_mic,
8235         },
8236         [ALC236_FIXUP_DELL_AIO_HEADSET_MIC] = {
8237                 .type = HDA_FIXUP_FUNC,
8238                 .v.func = alc_fixup_no_int_mic,
8239                 .chained = true,
8240                 .chain_id = ALC255_FIXUP_DELL1_MIC_NO_PRESENCE
8241         },
8242         [ALC282_FIXUP_ACER_DISABLE_LINEOUT] = {
8243                 .type = HDA_FIXUP_PINS,
8244                 .v.pins = (const struct hda_pintbl[]) {
8245                         { 0x1b, 0x411111f0 },
8246                         { 0x18, 0x01a1913c }, /* use as headset mic, without its own jack detect */
8247                         { },
8248                 },
8249                 .chained = true,
8250                 .chain_id = ALC269_FIXUP_HEADSET_MODE
8251         },
8252         [ALC255_FIXUP_ACER_LIMIT_INT_MIC_BOOST] = {
8253                 .type = HDA_FIXUP_FUNC,
8254                 .v.func = alc269_fixup_limit_int_mic_boost,
8255                 .chained = true,
8256                 .chain_id = ALC255_FIXUP_ACER_MIC_NO_PRESENCE,
8257         },
8258         [ALC256_FIXUP_ACER_HEADSET_MIC] = {
8259                 .type = HDA_FIXUP_PINS,
8260                 .v.pins = (const struct hda_pintbl[]) {
8261                         { 0x19, 0x02a1113c }, /* use as headset mic, without its own jack detect */
8262                         { 0x1a, 0x90a1092f }, /* use as internal mic */
8263                         { }
8264                 },
8265                 .chained = true,
8266                 .chain_id = ALC269_FIXUP_HEADSET_MODE_NO_HP_MIC
8267         },
8268         [ALC285_FIXUP_IDEAPAD_S740_COEF] = {
8269                 .type = HDA_FIXUP_FUNC,
8270                 .v.func = alc285_fixup_ideapad_s740_coef,
8271                 .chained = true,
8272                 .chain_id = ALC269_FIXUP_THINKPAD_ACPI,
8273         },
8274         [ALC285_FIXUP_HP_LIMIT_INT_MIC_BOOST] = {
8275                 .type = HDA_FIXUP_FUNC,
8276                 .v.func = alc269_fixup_limit_int_mic_boost,
8277                 .chained = true,
8278                 .chain_id = ALC285_FIXUP_HP_MUTE_LED,
8279         },
8280         [ALC295_FIXUP_ASUS_DACS] = {
8281                 .type = HDA_FIXUP_FUNC,
8282                 .v.func = alc295_fixup_asus_dacs,
8283         },
8284         [ALC295_FIXUP_HP_OMEN] = {
8285                 .type = HDA_FIXUP_PINS,
8286                 .v.pins = (const struct hda_pintbl[]) {
8287                         { 0x12, 0xb7a60130 },
8288                         { 0x13, 0x40000000 },
8289                         { 0x14, 0x411111f0 },
8290                         { 0x16, 0x411111f0 },
8291                         { 0x17, 0x90170110 },
8292                         { 0x18, 0x411111f0 },
8293                         { 0x19, 0x02a11030 },
8294                         { 0x1a, 0x411111f0 },
8295                         { 0x1b, 0x04a19030 },
8296                         { 0x1d, 0x40600001 },
8297                         { 0x1e, 0x411111f0 },
8298                         { 0x21, 0x03211020 },
8299                         {}
8300                 },
8301                 .chained = true,
8302                 .chain_id = ALC269_FIXUP_HP_LINE1_MIC1_LED,
8303         },
8304         [ALC285_FIXUP_HP_SPECTRE_X360] = {
8305                 .type = HDA_FIXUP_FUNC,
8306                 .v.func = alc285_fixup_hp_spectre_x360,
8307         },
8308         [ALC285_FIXUP_HP_SPECTRE_X360_EB1] = {
8309                 .type = HDA_FIXUP_FUNC,
8310                 .v.func = alc285_fixup_hp_spectre_x360_eb1
8311         },
8312         [ALC287_FIXUP_IDEAPAD_BASS_SPK_AMP] = {
8313                 .type = HDA_FIXUP_FUNC,
8314                 .v.func = alc285_fixup_ideapad_s740_coef,
8315                 .chained = true,
8316                 .chain_id = ALC285_FIXUP_THINKPAD_HEADSET_JACK,
8317         },
8318         [ALC623_FIXUP_LENOVO_THINKSTATION_P340] = {
8319                 .type = HDA_FIXUP_FUNC,
8320                 .v.func = alc_fixup_no_shutup,
8321                 .chained = true,
8322                 .chain_id = ALC283_FIXUP_HEADSET_MIC,
8323         },
8324         [ALC255_FIXUP_ACER_HEADPHONE_AND_MIC] = {
8325                 .type = HDA_FIXUP_PINS,
8326                 .v.pins = (const struct hda_pintbl[]) {
8327                         { 0x21, 0x03211030 }, /* Change the Headphone location to Left */
8328                         { }
8329                 },
8330                 .chained = true,
8331                 .chain_id = ALC255_FIXUP_XIAOMI_HEADSET_MIC
8332         },
8333         [ALC236_FIXUP_HP_LIMIT_INT_MIC_BOOST] = {
8334                 .type = HDA_FIXUP_FUNC,
8335                 .v.func = alc269_fixup_limit_int_mic_boost,
8336                 .chained = true,
8337                 .chain_id = ALC236_FIXUP_HP_MUTE_LED_MICMUTE_VREF,
8338         },
8339         [ALC287_FIXUP_LEGION_15IMHG05_SPEAKERS] = {
8340                 .type = HDA_FIXUP_VERBS,
8341                 //.v.verbs = legion_15imhg05_coefs,
8342                 .v.verbs = (const struct hda_verb[]) {
8343                          // set left speaker Legion 7i.
8344                          { 0x20, AC_VERB_SET_COEF_INDEX, 0x24 },
8345                          { 0x20, AC_VERB_SET_PROC_COEF, 0x41 },
8346
8347                          { 0x20, AC_VERB_SET_COEF_INDEX, 0x26 },
8348                          { 0x20, AC_VERB_SET_PROC_COEF, 0xc },
8349                          { 0x20, AC_VERB_SET_PROC_COEF, 0x0 },
8350                          { 0x20, AC_VERB_SET_PROC_COEF, 0x1a },
8351                          { 0x20, AC_VERB_SET_PROC_COEF, 0xb020 },
8352
8353                          { 0x20, AC_VERB_SET_COEF_INDEX, 0x26 },
8354                          { 0x20, AC_VERB_SET_PROC_COEF, 0x2 },
8355                          { 0x20, AC_VERB_SET_PROC_COEF, 0x0 },
8356                          { 0x20, AC_VERB_SET_PROC_COEF, 0x0 },
8357                          { 0x20, AC_VERB_SET_PROC_COEF, 0xb020 },
8358
8359                          // set right speaker Legion 7i.
8360                          { 0x20, AC_VERB_SET_COEF_INDEX, 0x24 },
8361                          { 0x20, AC_VERB_SET_PROC_COEF, 0x42 },
8362
8363                          { 0x20, AC_VERB_SET_COEF_INDEX, 0x26 },
8364                          { 0x20, AC_VERB_SET_PROC_COEF, 0xc },
8365                          { 0x20, AC_VERB_SET_PROC_COEF, 0x0 },
8366                          { 0x20, AC_VERB_SET_PROC_COEF, 0x2a },
8367                          { 0x20, AC_VERB_SET_PROC_COEF, 0xb020 },
8368
8369                          { 0x20, AC_VERB_SET_COEF_INDEX, 0x26 },
8370                          { 0x20, AC_VERB_SET_PROC_COEF, 0x2 },
8371                          { 0x20, AC_VERB_SET_PROC_COEF, 0x0 },
8372                          { 0x20, AC_VERB_SET_PROC_COEF, 0x0 },
8373                          { 0x20, AC_VERB_SET_PROC_COEF, 0xb020 },
8374                          {}
8375                 },
8376                 .chained = true,
8377                 .chain_id = ALC287_FIXUP_LEGION_15IMHG05_AUTOMUTE,
8378         },
8379         [ALC287_FIXUP_LEGION_15IMHG05_AUTOMUTE] = {
8380                 .type = HDA_FIXUP_FUNC,
8381                 .v.func = alc287_fixup_legion_15imhg05_speakers,
8382                 .chained = true,
8383                 .chain_id = ALC269_FIXUP_HEADSET_MODE,
8384         },
8385         [ALC287_FIXUP_YOGA7_14ITL_SPEAKERS] = {
8386                 .type = HDA_FIXUP_VERBS,
8387                 .v.verbs = (const struct hda_verb[]) {
8388                          // set left speaker Yoga 7i.
8389                          { 0x20, AC_VERB_SET_COEF_INDEX, 0x24 },
8390                          { 0x20, AC_VERB_SET_PROC_COEF, 0x41 },
8391
8392                          { 0x20, AC_VERB_SET_COEF_INDEX, 0x26 },
8393                          { 0x20, AC_VERB_SET_PROC_COEF, 0xc },
8394                          { 0x20, AC_VERB_SET_PROC_COEF, 0x0 },
8395                          { 0x20, AC_VERB_SET_PROC_COEF, 0x1a },
8396                          { 0x20, AC_VERB_SET_PROC_COEF, 0xb020 },
8397
8398                          { 0x20, AC_VERB_SET_COEF_INDEX, 0x26 },
8399                          { 0x20, AC_VERB_SET_PROC_COEF, 0x2 },
8400                          { 0x20, AC_VERB_SET_PROC_COEF, 0x0 },
8401                          { 0x20, AC_VERB_SET_PROC_COEF, 0x0 },
8402                          { 0x20, AC_VERB_SET_PROC_COEF, 0xb020 },
8403
8404                          // set right speaker Yoga 7i.
8405                          { 0x20, AC_VERB_SET_COEF_INDEX, 0x24 },
8406                          { 0x20, AC_VERB_SET_PROC_COEF, 0x46 },
8407
8408                          { 0x20, AC_VERB_SET_COEF_INDEX, 0x26 },
8409                          { 0x20, AC_VERB_SET_PROC_COEF, 0xc },
8410                          { 0x20, AC_VERB_SET_PROC_COEF, 0x0 },
8411                          { 0x20, AC_VERB_SET_PROC_COEF, 0x2a },
8412                          { 0x20, AC_VERB_SET_PROC_COEF, 0xb020 },
8413
8414                          { 0x20, AC_VERB_SET_COEF_INDEX, 0x26 },
8415                          { 0x20, AC_VERB_SET_PROC_COEF, 0x2 },
8416                          { 0x20, AC_VERB_SET_PROC_COEF, 0x0 },
8417                          { 0x20, AC_VERB_SET_PROC_COEF, 0x0 },
8418                          { 0x20, AC_VERB_SET_PROC_COEF, 0xb020 },
8419                          {}
8420                 },
8421                 .chained = true,
8422                 .chain_id = ALC269_FIXUP_HEADSET_MODE,
8423         },
8424         [ALC287_FIXUP_13S_GEN2_SPEAKERS] = {
8425                 .type = HDA_FIXUP_VERBS,
8426                 .v.verbs = (const struct hda_verb[]) {
8427                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x24 },
8428                         { 0x20, AC_VERB_SET_PROC_COEF, 0x41 },
8429                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x26 },
8430                         { 0x20, AC_VERB_SET_PROC_COEF, 0x2 },
8431                         { 0x20, AC_VERB_SET_PROC_COEF, 0x0 },
8432                         { 0x20, AC_VERB_SET_PROC_COEF, 0x0 },
8433                         { 0x20, AC_VERB_SET_PROC_COEF, 0xb020 },
8434                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x24 },
8435                         { 0x20, AC_VERB_SET_PROC_COEF, 0x42 },
8436                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x26 },
8437                         { 0x20, AC_VERB_SET_PROC_COEF, 0x2 },
8438                         { 0x20, AC_VERB_SET_PROC_COEF, 0x0 },
8439                         { 0x20, AC_VERB_SET_PROC_COEF, 0x0 },
8440                         { 0x20, AC_VERB_SET_PROC_COEF, 0xb020 },
8441                         {}
8442                 },
8443                 .chained = true,
8444                 .chain_id = ALC269_FIXUP_HEADSET_MODE,
8445         },
8446         [ALC256_FIXUP_TONGFANG_RESET_PERSISTENT_SETTINGS] = {
8447                 .type = HDA_FIXUP_FUNC,
8448                 .v.func = alc256_fixup_tongfang_reset_persistent_settings,
8449         },
8450         [ALC245_FIXUP_HP_GPIO_LED] = {
8451                 .type = HDA_FIXUP_FUNC,
8452                 .v.func = alc245_fixup_hp_gpio_led,
8453         },
8454         [ALC256_FIXUP_SYSTEM76_MIC_NO_PRESENCE] = {
8455                 .type = HDA_FIXUP_PINS,
8456                 .v.pins = (const struct hda_pintbl[]) {
8457                         { 0x19, 0x03a11120 }, /* use as headset mic, without its own jack detect */
8458                         { }
8459                 },
8460                 .chained = true,
8461                 .chain_id = ALC269_FIXUP_HEADSET_MODE_NO_HP_MIC,
8462         },
8463 };
8464
8465 static const struct snd_pci_quirk alc269_fixup_tbl[] = {
8466         SND_PCI_QUIRK(0x1025, 0x0283, "Acer TravelMate 8371", ALC269_FIXUP_INV_DMIC),
8467         SND_PCI_QUIRK(0x1025, 0x029b, "Acer 1810TZ", ALC269_FIXUP_INV_DMIC),
8468         SND_PCI_QUIRK(0x1025, 0x0349, "Acer AOD260", ALC269_FIXUP_INV_DMIC),
8469         SND_PCI_QUIRK(0x1025, 0x047c, "Acer AC700", ALC269_FIXUP_ACER_AC700),
8470         SND_PCI_QUIRK(0x1025, 0x072d, "Acer Aspire V5-571G", ALC269_FIXUP_ASPIRE_HEADSET_MIC),
8471         SND_PCI_QUIRK(0x1025, 0x0740, "Acer AO725", ALC271_FIXUP_HP_GATE_MIC_JACK),
8472         SND_PCI_QUIRK(0x1025, 0x0742, "Acer AO756", ALC271_FIXUP_HP_GATE_MIC_JACK),
8473         SND_PCI_QUIRK(0x1025, 0x0762, "Acer Aspire E1-472", ALC271_FIXUP_HP_GATE_MIC_JACK_E1_572),
8474         SND_PCI_QUIRK(0x1025, 0x0775, "Acer Aspire E1-572", ALC271_FIXUP_HP_GATE_MIC_JACK_E1_572),
8475         SND_PCI_QUIRK(0x1025, 0x079b, "Acer Aspire V5-573G", ALC282_FIXUP_ASPIRE_V5_PINS),
8476         SND_PCI_QUIRK(0x1025, 0x080d, "Acer Aspire V5-122P", ALC269_FIXUP_ASPIRE_HEADSET_MIC),
8477         SND_PCI_QUIRK(0x1025, 0x0840, "Acer Aspire E1", ALC269VB_FIXUP_ASPIRE_E1_COEF),
8478         SND_PCI_QUIRK(0x1025, 0x101c, "Acer Veriton N2510G", ALC269_FIXUP_LIFEBOOK),
8479         SND_PCI_QUIRK(0x1025, 0x102b, "Acer Aspire C24-860", ALC286_FIXUP_ACER_AIO_MIC_NO_PRESENCE),
8480         SND_PCI_QUIRK(0x1025, 0x1065, "Acer Aspire C20-820", ALC269VC_FIXUP_ACER_HEADSET_MIC),
8481         SND_PCI_QUIRK(0x1025, 0x106d, "Acer Cloudbook 14", ALC283_FIXUP_CHROME_BOOK),
8482         SND_PCI_QUIRK(0x1025, 0x1094, "Acer Aspire E5-575T", ALC255_FIXUP_ACER_LIMIT_INT_MIC_BOOST),
8483         SND_PCI_QUIRK(0x1025, 0x1099, "Acer Aspire E5-523G", ALC255_FIXUP_ACER_MIC_NO_PRESENCE),
8484         SND_PCI_QUIRK(0x1025, 0x110e, "Acer Aspire ES1-432", ALC255_FIXUP_ACER_MIC_NO_PRESENCE),
8485         SND_PCI_QUIRK(0x1025, 0x1166, "Acer Veriton N4640G", ALC269_FIXUP_LIFEBOOK),
8486         SND_PCI_QUIRK(0x1025, 0x1167, "Acer Veriton N6640G", ALC269_FIXUP_LIFEBOOK),
8487         SND_PCI_QUIRK(0x1025, 0x1246, "Acer Predator Helios 500", ALC299_FIXUP_PREDATOR_SPK),
8488         SND_PCI_QUIRK(0x1025, 0x1247, "Acer vCopperbox", ALC269VC_FIXUP_ACER_VCOPPERBOX_PINS),
8489         SND_PCI_QUIRK(0x1025, 0x1248, "Acer Veriton N4660G", ALC269VC_FIXUP_ACER_MIC_NO_PRESENCE),
8490         SND_PCI_QUIRK(0x1025, 0x1269, "Acer SWIFT SF314-54", ALC256_FIXUP_ACER_HEADSET_MIC),
8491         SND_PCI_QUIRK(0x1025, 0x128f, "Acer Veriton Z6860G", ALC286_FIXUP_ACER_AIO_HEADSET_MIC),
8492         SND_PCI_QUIRK(0x1025, 0x1290, "Acer Veriton Z4860G", ALC286_FIXUP_ACER_AIO_HEADSET_MIC),
8493         SND_PCI_QUIRK(0x1025, 0x1291, "Acer Veriton Z4660G", ALC286_FIXUP_ACER_AIO_HEADSET_MIC),
8494         SND_PCI_QUIRK(0x1025, 0x129c, "Acer SWIFT SF314-55", ALC256_FIXUP_ACER_HEADSET_MIC),
8495         SND_PCI_QUIRK(0x1025, 0x1300, "Acer SWIFT SF314-56", ALC256_FIXUP_ACER_MIC_NO_PRESENCE),
8496         SND_PCI_QUIRK(0x1025, 0x1308, "Acer Aspire Z24-890", ALC286_FIXUP_ACER_AIO_HEADSET_MIC),
8497         SND_PCI_QUIRK(0x1025, 0x132a, "Acer TravelMate B114-21", ALC233_FIXUP_ACER_HEADSET_MIC),
8498         SND_PCI_QUIRK(0x1025, 0x1330, "Acer TravelMate X514-51T", ALC255_FIXUP_ACER_HEADSET_MIC),
8499         SND_PCI_QUIRK(0x1025, 0x141f, "Acer Spin SP513-54N", ALC255_FIXUP_ACER_MIC_NO_PRESENCE),
8500         SND_PCI_QUIRK(0x1025, 0x142b, "Acer Swift SF314-42", ALC255_FIXUP_ACER_MIC_NO_PRESENCE),
8501         SND_PCI_QUIRK(0x1025, 0x1430, "Acer TravelMate B311R-31", ALC256_FIXUP_ACER_MIC_NO_PRESENCE),
8502         SND_PCI_QUIRK(0x1025, 0x1466, "Acer Aspire A515-56", ALC255_FIXUP_ACER_HEADPHONE_AND_MIC),
8503         SND_PCI_QUIRK(0x1028, 0x0470, "Dell M101z", ALC269_FIXUP_DELL_M101Z),
8504         SND_PCI_QUIRK(0x1028, 0x054b, "Dell XPS one 2710", ALC275_FIXUP_DELL_XPS),
8505         SND_PCI_QUIRK(0x1028, 0x05bd, "Dell Latitude E6440", ALC292_FIXUP_DELL_E7X),
8506         SND_PCI_QUIRK(0x1028, 0x05be, "Dell Latitude E6540", ALC292_FIXUP_DELL_E7X),
8507         SND_PCI_QUIRK(0x1028, 0x05ca, "Dell Latitude E7240", ALC292_FIXUP_DELL_E7X),
8508         SND_PCI_QUIRK(0x1028, 0x05cb, "Dell Latitude E7440", ALC292_FIXUP_DELL_E7X),
8509         SND_PCI_QUIRK(0x1028, 0x05da, "Dell Vostro 5460", ALC290_FIXUP_SUBWOOFER),
8510         SND_PCI_QUIRK(0x1028, 0x05f4, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE),
8511         SND_PCI_QUIRK(0x1028, 0x05f5, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE),
8512         SND_PCI_QUIRK(0x1028, 0x05f6, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE),
8513         SND_PCI_QUIRK(0x1028, 0x0615, "Dell Vostro 5470", ALC290_FIXUP_SUBWOOFER_HSJACK),
8514         SND_PCI_QUIRK(0x1028, 0x0616, "Dell Vostro 5470", ALC290_FIXUP_SUBWOOFER_HSJACK),
8515         SND_PCI_QUIRK(0x1028, 0x062c, "Dell Latitude E5550", ALC292_FIXUP_DELL_E7X),
8516         SND_PCI_QUIRK(0x1028, 0x062e, "Dell Latitude E7450", ALC292_FIXUP_DELL_E7X),
8517         SND_PCI_QUIRK(0x1028, 0x0638, "Dell Inspiron 5439", ALC290_FIXUP_MONO_SPEAKERS_HSJACK),
8518         SND_PCI_QUIRK(0x1028, 0x064a, "Dell", ALC293_FIXUP_DELL1_MIC_NO_PRESENCE),
8519         SND_PCI_QUIRK(0x1028, 0x064b, "Dell", ALC293_FIXUP_DELL1_MIC_NO_PRESENCE),
8520         SND_PCI_QUIRK(0x1028, 0x0665, "Dell XPS 13", ALC288_FIXUP_DELL_XPS_13),
8521         SND_PCI_QUIRK(0x1028, 0x0669, "Dell Optiplex 9020m", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE),
8522         SND_PCI_QUIRK(0x1028, 0x069a, "Dell Vostro 5480", ALC290_FIXUP_SUBWOOFER_HSJACK),
8523         SND_PCI_QUIRK(0x1028, 0x06c7, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE),
8524         SND_PCI_QUIRK(0x1028, 0x06d9, "Dell", ALC293_FIXUP_DELL1_MIC_NO_PRESENCE),
8525         SND_PCI_QUIRK(0x1028, 0x06da, "Dell", ALC293_FIXUP_DELL1_MIC_NO_PRESENCE),
8526         SND_PCI_QUIRK(0x1028, 0x06db, "Dell", ALC293_FIXUP_DISABLE_AAMIX_MULTIJACK),
8527         SND_PCI_QUIRK(0x1028, 0x06dd, "Dell", ALC293_FIXUP_DISABLE_AAMIX_MULTIJACK),
8528         SND_PCI_QUIRK(0x1028, 0x06de, "Dell", ALC293_FIXUP_DISABLE_AAMIX_MULTIJACK),
8529         SND_PCI_QUIRK(0x1028, 0x06df, "Dell", ALC293_FIXUP_DISABLE_AAMIX_MULTIJACK),
8530         SND_PCI_QUIRK(0x1028, 0x06e0, "Dell", ALC293_FIXUP_DISABLE_AAMIX_MULTIJACK),
8531         SND_PCI_QUIRK(0x1028, 0x0706, "Dell Inspiron 7559", ALC256_FIXUP_DELL_INSPIRON_7559_SUBWOOFER),
8532         SND_PCI_QUIRK(0x1028, 0x0725, "Dell Inspiron 3162", ALC255_FIXUP_DELL_SPK_NOISE),
8533         SND_PCI_QUIRK(0x1028, 0x0738, "Dell Precision 5820", ALC269_FIXUP_NO_SHUTUP),
8534         SND_PCI_QUIRK(0x1028, 0x075c, "Dell XPS 27 7760", ALC298_FIXUP_SPK_VOLUME),
8535         SND_PCI_QUIRK(0x1028, 0x075d, "Dell AIO", ALC298_FIXUP_SPK_VOLUME),
8536         SND_PCI_QUIRK(0x1028, 0x0798, "Dell Inspiron 17 7000 Gaming", ALC256_FIXUP_DELL_INSPIRON_7559_SUBWOOFER),
8537         SND_PCI_QUIRK(0x1028, 0x07b0, "Dell Precision 7520", ALC295_FIXUP_DISABLE_DAC3),
8538         SND_PCI_QUIRK(0x1028, 0x080c, "Dell WYSE", ALC225_FIXUP_DELL_WYSE_MIC_NO_PRESENCE),
8539         SND_PCI_QUIRK(0x1028, 0x084b, "Dell", ALC274_FIXUP_DELL_AIO_LINEOUT_VERB),
8540         SND_PCI_QUIRK(0x1028, 0x084e, "Dell", ALC274_FIXUP_DELL_AIO_LINEOUT_VERB),
8541         SND_PCI_QUIRK(0x1028, 0x0871, "Dell Precision 3630", ALC255_FIXUP_DELL_HEADSET_MIC),
8542         SND_PCI_QUIRK(0x1028, 0x0872, "Dell Precision 3630", ALC255_FIXUP_DELL_HEADSET_MIC),
8543         SND_PCI_QUIRK(0x1028, 0x0873, "Dell Precision 3930", ALC255_FIXUP_DUMMY_LINEOUT_VERB),
8544         SND_PCI_QUIRK(0x1028, 0x08ad, "Dell WYSE AIO", ALC225_FIXUP_DELL_WYSE_AIO_MIC_NO_PRESENCE),
8545         SND_PCI_QUIRK(0x1028, 0x08ae, "Dell WYSE NB", ALC225_FIXUP_DELL1_MIC_NO_PRESENCE),
8546         SND_PCI_QUIRK(0x1028, 0x0935, "Dell", ALC274_FIXUP_DELL_AIO_LINEOUT_VERB),
8547         SND_PCI_QUIRK(0x1028, 0x097d, "Dell Precision", ALC289_FIXUP_DUAL_SPK),
8548         SND_PCI_QUIRK(0x1028, 0x097e, "Dell Precision", ALC289_FIXUP_DUAL_SPK),
8549         SND_PCI_QUIRK(0x1028, 0x098d, "Dell Precision", ALC233_FIXUP_ASUS_MIC_NO_PRESENCE),
8550         SND_PCI_QUIRK(0x1028, 0x09bf, "Dell Precision", ALC233_FIXUP_ASUS_MIC_NO_PRESENCE),
8551         SND_PCI_QUIRK(0x1028, 0x0a2e, "Dell", ALC236_FIXUP_DELL_AIO_HEADSET_MIC),
8552         SND_PCI_QUIRK(0x1028, 0x0a30, "Dell", ALC236_FIXUP_DELL_AIO_HEADSET_MIC),
8553         SND_PCI_QUIRK(0x1028, 0x0a58, "Dell", ALC255_FIXUP_DELL_HEADSET_MIC),
8554         SND_PCI_QUIRK(0x1028, 0x0a61, "Dell XPS 15 9510", ALC289_FIXUP_DUAL_SPK),
8555         SND_PCI_QUIRK(0x1028, 0x0a62, "Dell Precision 5560", ALC289_FIXUP_DUAL_SPK),
8556         SND_PCI_QUIRK(0x1028, 0x0a9d, "Dell Latitude 5430", ALC269_FIXUP_DELL4_MIC_NO_PRESENCE),
8557         SND_PCI_QUIRK(0x1028, 0x0a9e, "Dell Latitude 5430", ALC269_FIXUP_DELL4_MIC_NO_PRESENCE),
8558         SND_PCI_QUIRK(0x1028, 0x164a, "Dell", ALC293_FIXUP_DELL1_MIC_NO_PRESENCE),
8559         SND_PCI_QUIRK(0x1028, 0x164b, "Dell", ALC293_FIXUP_DELL1_MIC_NO_PRESENCE),
8560         SND_PCI_QUIRK(0x103c, 0x1586, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC2),
8561         SND_PCI_QUIRK(0x103c, 0x18e6, "HP", ALC269_FIXUP_HP_GPIO_LED),
8562         SND_PCI_QUIRK(0x103c, 0x218b, "HP", ALC269_FIXUP_LIMIT_INT_MIC_BOOST_MUTE_LED),
8563         SND_PCI_QUIRK(0x103c, 0x21f9, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
8564         SND_PCI_QUIRK(0x103c, 0x2210, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
8565         SND_PCI_QUIRK(0x103c, 0x2214, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
8566         SND_PCI_QUIRK(0x103c, 0x221b, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),
8567         SND_PCI_QUIRK(0x103c, 0x221c, "HP EliteBook 755 G2", ALC280_FIXUP_HP_HEADSET_MIC),
8568         SND_PCI_QUIRK(0x103c, 0x2221, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),
8569         SND_PCI_QUIRK(0x103c, 0x2225, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),
8570         SND_PCI_QUIRK(0x103c, 0x2236, "HP", ALC269_FIXUP_HP_LINE1_MIC1_LED),
8571         SND_PCI_QUIRK(0x103c, 0x2237, "HP", ALC269_FIXUP_HP_LINE1_MIC1_LED),
8572         SND_PCI_QUIRK(0x103c, 0x2238, "HP", ALC269_FIXUP_HP_LINE1_MIC1_LED),
8573         SND_PCI_QUIRK(0x103c, 0x2239, "HP", ALC269_FIXUP_HP_LINE1_MIC1_LED),
8574         SND_PCI_QUIRK(0x103c, 0x224b, "HP", ALC269_FIXUP_HP_LINE1_MIC1_LED),
8575         SND_PCI_QUIRK(0x103c, 0x2253, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),
8576         SND_PCI_QUIRK(0x103c, 0x2254, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),
8577         SND_PCI_QUIRK(0x103c, 0x2255, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),
8578         SND_PCI_QUIRK(0x103c, 0x2256, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),
8579         SND_PCI_QUIRK(0x103c, 0x2257, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),
8580         SND_PCI_QUIRK(0x103c, 0x2259, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),
8581         SND_PCI_QUIRK(0x103c, 0x225a, "HP", ALC269_FIXUP_HP_DOCK_GPIO_MIC1_LED),
8582         SND_PCI_QUIRK(0x103c, 0x225f, "HP", ALC280_FIXUP_HP_GPIO2_MIC_HOTKEY),
8583         SND_PCI_QUIRK(0x103c, 0x2260, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
8584         SND_PCI_QUIRK(0x103c, 0x2263, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
8585         SND_PCI_QUIRK(0x103c, 0x2264, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
8586         SND_PCI_QUIRK(0x103c, 0x2265, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
8587         SND_PCI_QUIRK(0x103c, 0x2268, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
8588         SND_PCI_QUIRK(0x103c, 0x226a, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
8589         SND_PCI_QUIRK(0x103c, 0x226b, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
8590         SND_PCI_QUIRK(0x103c, 0x226e, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
8591         SND_PCI_QUIRK(0x103c, 0x2271, "HP", ALC286_FIXUP_HP_GPIO_LED),
8592         SND_PCI_QUIRK(0x103c, 0x2272, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),
8593         SND_PCI_QUIRK(0x103c, 0x2272, "HP", ALC280_FIXUP_HP_DOCK_PINS),
8594         SND_PCI_QUIRK(0x103c, 0x2273, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),
8595         SND_PCI_QUIRK(0x103c, 0x2273, "HP", ALC280_FIXUP_HP_DOCK_PINS),
8596         SND_PCI_QUIRK(0x103c, 0x2278, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),
8597         SND_PCI_QUIRK(0x103c, 0x227f, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
8598         SND_PCI_QUIRK(0x103c, 0x2282, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
8599         SND_PCI_QUIRK(0x103c, 0x228b, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
8600         SND_PCI_QUIRK(0x103c, 0x228e, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
8601         SND_PCI_QUIRK(0x103c, 0x229e, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
8602         SND_PCI_QUIRK(0x103c, 0x22b2, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
8603         SND_PCI_QUIRK(0x103c, 0x22b7, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
8604         SND_PCI_QUIRK(0x103c, 0x22bf, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
8605         SND_PCI_QUIRK(0x103c, 0x22c4, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
8606         SND_PCI_QUIRK(0x103c, 0x22c5, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
8607         SND_PCI_QUIRK(0x103c, 0x22c7, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
8608         SND_PCI_QUIRK(0x103c, 0x22c8, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
8609         SND_PCI_QUIRK(0x103c, 0x22cf, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
8610         SND_PCI_QUIRK(0x103c, 0x22db, "HP", ALC280_FIXUP_HP_9480M),
8611         SND_PCI_QUIRK(0x103c, 0x22dc, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),
8612         SND_PCI_QUIRK(0x103c, 0x22fb, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),
8613         SND_PCI_QUIRK(0x103c, 0x2334, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
8614         SND_PCI_QUIRK(0x103c, 0x2335, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
8615         SND_PCI_QUIRK(0x103c, 0x2336, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
8616         SND_PCI_QUIRK(0x103c, 0x2337, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
8617         SND_PCI_QUIRK(0x103c, 0x802e, "HP Z240 SFF", ALC221_FIXUP_HP_MIC_NO_PRESENCE),
8618         SND_PCI_QUIRK(0x103c, 0x802f, "HP Z240", ALC221_FIXUP_HP_MIC_NO_PRESENCE),
8619         SND_PCI_QUIRK(0x103c, 0x8077, "HP", ALC256_FIXUP_HP_HEADSET_MIC),
8620         SND_PCI_QUIRK(0x103c, 0x8158, "HP", ALC256_FIXUP_HP_HEADSET_MIC),
8621         SND_PCI_QUIRK(0x103c, 0x820d, "HP Pavilion 15", ALC269_FIXUP_HP_MUTE_LED_MIC3),
8622         SND_PCI_QUIRK(0x103c, 0x8256, "HP", ALC221_FIXUP_HP_FRONT_MIC),
8623         SND_PCI_QUIRK(0x103c, 0x827e, "HP x360", ALC295_FIXUP_HP_X360),
8624         SND_PCI_QUIRK(0x103c, 0x827f, "HP x360", ALC269_FIXUP_HP_MUTE_LED_MIC3),
8625         SND_PCI_QUIRK(0x103c, 0x82bf, "HP G3 mini", ALC221_FIXUP_HP_MIC_NO_PRESENCE),
8626         SND_PCI_QUIRK(0x103c, 0x82c0, "HP G3 mini premium", ALC221_FIXUP_HP_MIC_NO_PRESENCE),
8627         SND_PCI_QUIRK(0x103c, 0x83b9, "HP Spectre x360", ALC269_FIXUP_HP_MUTE_LED_MIC3),
8628         SND_PCI_QUIRK(0x103c, 0x841c, "HP Pavilion 15-CK0xx", ALC269_FIXUP_HP_MUTE_LED_MIC3),
8629         SND_PCI_QUIRK(0x103c, 0x8497, "HP Envy x360", ALC269_FIXUP_HP_MUTE_LED_MIC3),
8630         SND_PCI_QUIRK(0x103c, 0x84da, "HP OMEN dc0019-ur", ALC295_FIXUP_HP_OMEN),
8631         SND_PCI_QUIRK(0x103c, 0x84e7, "HP Pavilion 15", ALC269_FIXUP_HP_MUTE_LED_MIC3),
8632         SND_PCI_QUIRK(0x103c, 0x8519, "HP Spectre x360 15-df0xxx", ALC285_FIXUP_HP_SPECTRE_X360),
8633         SND_PCI_QUIRK(0x103c, 0x861f, "HP Elite Dragonfly G1", ALC285_FIXUP_HP_GPIO_AMP_INIT),
8634         SND_PCI_QUIRK(0x103c, 0x869d, "HP", ALC236_FIXUP_HP_MUTE_LED),
8635         SND_PCI_QUIRK(0x103c, 0x86c7, "HP Envy AiO 32", ALC274_FIXUP_HP_ENVY_GPIO),
8636         SND_PCI_QUIRK(0x103c, 0x8716, "HP Elite Dragonfly G2 Notebook PC", ALC285_FIXUP_HP_GPIO_AMP_INIT),
8637         SND_PCI_QUIRK(0x103c, 0x8720, "HP EliteBook x360 1040 G8 Notebook PC", ALC285_FIXUP_HP_GPIO_AMP_INIT),
8638         SND_PCI_QUIRK(0x103c, 0x8724, "HP EliteBook 850 G7", ALC285_FIXUP_HP_GPIO_LED),
8639         SND_PCI_QUIRK(0x103c, 0x8728, "HP EliteBook 840 G7", ALC285_FIXUP_HP_GPIO_LED),
8640         SND_PCI_QUIRK(0x103c, 0x8729, "HP", ALC285_FIXUP_HP_GPIO_LED),
8641         SND_PCI_QUIRK(0x103c, 0x8730, "HP ProBook 445 G7", ALC236_FIXUP_HP_MUTE_LED_MICMUTE_VREF),
8642         SND_PCI_QUIRK(0x103c, 0x8736, "HP", ALC285_FIXUP_HP_GPIO_AMP_INIT),
8643         SND_PCI_QUIRK(0x103c, 0x8760, "HP", ALC285_FIXUP_HP_MUTE_LED),
8644         SND_PCI_QUIRK(0x103c, 0x877a, "HP", ALC285_FIXUP_HP_MUTE_LED),
8645         SND_PCI_QUIRK(0x103c, 0x877d, "HP", ALC236_FIXUP_HP_MUTE_LED),
8646         SND_PCI_QUIRK(0x103c, 0x8780, "HP ZBook Fury 17 G7 Mobile Workstation",
8647                       ALC285_FIXUP_HP_GPIO_AMP_INIT),
8648         SND_PCI_QUIRK(0x103c, 0x8783, "HP ZBook Fury 15 G7 Mobile Workstation",
8649                       ALC285_FIXUP_HP_GPIO_AMP_INIT),
8650         SND_PCI_QUIRK(0x103c, 0x8788, "HP OMEN 15", ALC285_FIXUP_HP_MUTE_LED),
8651         SND_PCI_QUIRK(0x103c, 0x87c8, "HP", ALC287_FIXUP_HP_GPIO_LED),
8652         SND_PCI_QUIRK(0x103c, 0x87e5, "HP ProBook 440 G8 Notebook PC", ALC236_FIXUP_HP_GPIO_LED),
8653         SND_PCI_QUIRK(0x103c, 0x87e7, "HP ProBook 450 G8 Notebook PC", ALC236_FIXUP_HP_GPIO_LED),
8654         SND_PCI_QUIRK(0x103c, 0x87f1, "HP ProBook 630 G8 Notebook PC", ALC236_FIXUP_HP_GPIO_LED),
8655         SND_PCI_QUIRK(0x103c, 0x87f2, "HP ProBook 640 G8 Notebook PC", ALC236_FIXUP_HP_GPIO_LED),
8656         SND_PCI_QUIRK(0x103c, 0x87f4, "HP", ALC287_FIXUP_HP_GPIO_LED),
8657         SND_PCI_QUIRK(0x103c, 0x87f5, "HP", ALC287_FIXUP_HP_GPIO_LED),
8658         SND_PCI_QUIRK(0x103c, 0x87f6, "HP Spectre x360 14", ALC245_FIXUP_HP_X360_AMP),
8659         SND_PCI_QUIRK(0x103c, 0x87f7, "HP Spectre x360 14", ALC245_FIXUP_HP_X360_AMP),
8660         SND_PCI_QUIRK(0x103c, 0x8805, "HP ProBook 650 G8 Notebook PC", ALC236_FIXUP_HP_GPIO_LED),
8661         SND_PCI_QUIRK(0x103c, 0x880d, "HP EliteBook 830 G8 Notebook PC", ALC285_FIXUP_HP_GPIO_LED),
8662         SND_PCI_QUIRK(0x103c, 0x8811, "HP Spectre x360 15-eb1xxx", ALC285_FIXUP_HP_SPECTRE_X360_EB1),
8663         SND_PCI_QUIRK(0x103c, 0x8812, "HP Spectre x360 15-eb1xxx", ALC285_FIXUP_HP_SPECTRE_X360_EB1),
8664         SND_PCI_QUIRK(0x103c, 0x8846, "HP EliteBook 850 G8 Notebook PC", ALC285_FIXUP_HP_GPIO_LED),
8665         SND_PCI_QUIRK(0x103c, 0x8847, "HP EliteBook x360 830 G8 Notebook PC", ALC285_FIXUP_HP_GPIO_LED),
8666         SND_PCI_QUIRK(0x103c, 0x884b, "HP EliteBook 840 Aero G8 Notebook PC", ALC285_FIXUP_HP_GPIO_LED),
8667         SND_PCI_QUIRK(0x103c, 0x884c, "HP EliteBook 840 G8 Notebook PC", ALC285_FIXUP_HP_GPIO_LED),
8668         SND_PCI_QUIRK(0x103c, 0x8862, "HP ProBook 445 G8 Notebook PC", ALC236_FIXUP_HP_LIMIT_INT_MIC_BOOST),
8669         SND_PCI_QUIRK(0x103c, 0x8863, "HP ProBook 445 G8 Notebook PC", ALC236_FIXUP_HP_LIMIT_INT_MIC_BOOST),
8670         SND_PCI_QUIRK(0x103c, 0x886d, "HP ZBook Fury 17.3 Inch G8 Mobile Workstation PC", ALC285_FIXUP_HP_GPIO_AMP_INIT),
8671         SND_PCI_QUIRK(0x103c, 0x8870, "HP ZBook Fury 15.6 Inch G8 Mobile Workstation PC", ALC285_FIXUP_HP_GPIO_AMP_INIT),
8672         SND_PCI_QUIRK(0x103c, 0x8873, "HP ZBook Studio 15.6 Inch G8 Mobile Workstation PC", ALC285_FIXUP_HP_GPIO_AMP_INIT),
8673         SND_PCI_QUIRK(0x103c, 0x888d, "HP ZBook Power 15.6 inch G8 Mobile Workstation PC", ALC236_FIXUP_HP_GPIO_LED),
8674         SND_PCI_QUIRK(0x103c, 0x8896, "HP EliteBook 855 G8 Notebook PC", ALC285_FIXUP_HP_MUTE_LED),
8675         SND_PCI_QUIRK(0x103c, 0x8898, "HP EliteBook 845 G8 Notebook PC", ALC285_FIXUP_HP_LIMIT_INT_MIC_BOOST),
8676         SND_PCI_QUIRK(0x103c, 0x88d0, "HP Pavilion 15-eh1xxx (mainboard 88D0)", ALC287_FIXUP_HP_GPIO_LED),
8677         SND_PCI_QUIRK(0x1043, 0x103e, "ASUS X540SA", ALC256_FIXUP_ASUS_MIC),
8678         SND_PCI_QUIRK(0x1043, 0x103f, "ASUS TX300", ALC282_FIXUP_ASUS_TX300),
8679         SND_PCI_QUIRK(0x1043, 0x106d, "Asus K53BE", ALC269_FIXUP_LIMIT_INT_MIC_BOOST),
8680         SND_PCI_QUIRK(0x1043, 0x10a1, "ASUS UX391UA", ALC294_FIXUP_ASUS_SPK),
8681         SND_PCI_QUIRK(0x1043, 0x10c0, "ASUS X540SA", ALC256_FIXUP_ASUS_MIC),
8682         SND_PCI_QUIRK(0x1043, 0x10d0, "ASUS X540LA/X540LJ", ALC255_FIXUP_ASUS_MIC_NO_PRESENCE),
8683         SND_PCI_QUIRK(0x1043, 0x115d, "Asus 1015E", ALC269_FIXUP_LIMIT_INT_MIC_BOOST),
8684         SND_PCI_QUIRK(0x1043, 0x11c0, "ASUS X556UR", ALC255_FIXUP_ASUS_MIC_NO_PRESENCE),
8685         SND_PCI_QUIRK(0x1043, 0x125e, "ASUS Q524UQK", ALC255_FIXUP_ASUS_MIC_NO_PRESENCE),
8686         SND_PCI_QUIRK(0x1043, 0x1271, "ASUS X430UN", ALC256_FIXUP_ASUS_MIC_NO_PRESENCE),
8687         SND_PCI_QUIRK(0x1043, 0x1290, "ASUS X441SA", ALC233_FIXUP_EAPD_COEF_AND_MIC_NO_PRESENCE),
8688         SND_PCI_QUIRK(0x1043, 0x12a0, "ASUS X441UV", ALC233_FIXUP_EAPD_COEF_AND_MIC_NO_PRESENCE),
8689         SND_PCI_QUIRK(0x1043, 0x12e0, "ASUS X541SA", ALC256_FIXUP_ASUS_MIC),
8690         SND_PCI_QUIRK(0x1043, 0x12f0, "ASUS X541UV", ALC256_FIXUP_ASUS_MIC),
8691         SND_PCI_QUIRK(0x1043, 0x13b0, "ASUS Z550SA", ALC256_FIXUP_ASUS_MIC),
8692         SND_PCI_QUIRK(0x1043, 0x1427, "Asus Zenbook UX31E", ALC269VB_FIXUP_ASUS_ZENBOOK),
8693         SND_PCI_QUIRK(0x1043, 0x1517, "Asus Zenbook UX31A", ALC269VB_FIXUP_ASUS_ZENBOOK_UX31A),
8694         SND_PCI_QUIRK(0x1043, 0x16e3, "ASUS UX50", ALC269_FIXUP_STEREO_DMIC),
8695         SND_PCI_QUIRK(0x1043, 0x1740, "ASUS UX430UA", ALC295_FIXUP_ASUS_DACS),
8696         SND_PCI_QUIRK(0x1043, 0x17d1, "ASUS UX431FL", ALC294_FIXUP_ASUS_DUAL_SPK),
8697         SND_PCI_QUIRK(0x1043, 0x1662, "ASUS GV301QH", ALC294_FIXUP_ASUS_DUAL_SPK),
8698         SND_PCI_QUIRK(0x1043, 0x1881, "ASUS Zephyrus S/M", ALC294_FIXUP_ASUS_GX502_PINS),
8699         SND_PCI_QUIRK(0x1043, 0x18b1, "Asus MJ401TA", ALC256_FIXUP_ASUS_HEADSET_MIC),
8700         SND_PCI_QUIRK(0x1043, 0x18f1, "Asus FX505DT", ALC256_FIXUP_ASUS_HEADSET_MIC),
8701         SND_PCI_QUIRK(0x1043, 0x194e, "ASUS UX563FD", ALC294_FIXUP_ASUS_HPE),
8702         SND_PCI_QUIRK(0x1043, 0x1970, "ASUS UX550VE", ALC289_FIXUP_ASUS_GA401),
8703         SND_PCI_QUIRK(0x1043, 0x1982, "ASUS B1400CEPE", ALC256_FIXUP_ASUS_HPE),
8704         SND_PCI_QUIRK(0x1043, 0x19ce, "ASUS B9450FA", ALC294_FIXUP_ASUS_HPE),
8705         SND_PCI_QUIRK(0x1043, 0x19e1, "ASUS UX581LV", ALC295_FIXUP_ASUS_MIC_NO_PRESENCE),
8706         SND_PCI_QUIRK(0x1043, 0x1a13, "Asus G73Jw", ALC269_FIXUP_ASUS_G73JW),
8707         SND_PCI_QUIRK(0x1043, 0x1a30, "ASUS X705UD", ALC256_FIXUP_ASUS_MIC),
8708         SND_PCI_QUIRK(0x1043, 0x1b11, "ASUS UX431DA", ALC294_FIXUP_ASUS_COEF_1B),
8709         SND_PCI_QUIRK(0x1043, 0x1b13, "Asus U41SV", ALC269_FIXUP_INV_DMIC),
8710         SND_PCI_QUIRK(0x1043, 0x1bbd, "ASUS Z550MA", ALC255_FIXUP_ASUS_MIC_NO_PRESENCE),
8711         SND_PCI_QUIRK(0x1043, 0x1c23, "Asus X55U", ALC269_FIXUP_LIMIT_INT_MIC_BOOST),
8712         SND_PCI_QUIRK(0x1043, 0x1ccd, "ASUS X555UB", ALC256_FIXUP_ASUS_MIC),
8713         SND_PCI_QUIRK(0x1043, 0x1d4e, "ASUS TM420", ALC256_FIXUP_ASUS_HPE),
8714         SND_PCI_QUIRK(0x1043, 0x1e11, "ASUS Zephyrus G15", ALC289_FIXUP_ASUS_GA502),
8715         SND_PCI_QUIRK(0x1043, 0x1e51, "ASUS Zephyrus M15", ALC294_FIXUP_ASUS_GU502_PINS),
8716         SND_PCI_QUIRK(0x1043, 0x1e8e, "ASUS Zephyrus G15", ALC289_FIXUP_ASUS_GA401),
8717         SND_PCI_QUIRK(0x1043, 0x1f11, "ASUS Zephyrus G14", ALC289_FIXUP_ASUS_GA401),
8718         SND_PCI_QUIRK(0x1043, 0x3030, "ASUS ZN270IE", ALC256_FIXUP_ASUS_AIO_GPIO2),
8719         SND_PCI_QUIRK(0x1043, 0x831a, "ASUS P901", ALC269_FIXUP_STEREO_DMIC),
8720         SND_PCI_QUIRK(0x1043, 0x834a, "ASUS S101", ALC269_FIXUP_STEREO_DMIC),
8721         SND_PCI_QUIRK(0x1043, 0x8398, "ASUS P1005", ALC269_FIXUP_STEREO_DMIC),
8722         SND_PCI_QUIRK(0x1043, 0x83ce, "ASUS P1005", ALC269_FIXUP_STEREO_DMIC),
8723         SND_PCI_QUIRK(0x1043, 0x8516, "ASUS X101CH", ALC269_FIXUP_ASUS_X101),
8724         SND_PCI_QUIRK(0x104d, 0x9073, "Sony VAIO", ALC275_FIXUP_SONY_VAIO_GPIO2),
8725         SND_PCI_QUIRK(0x104d, 0x907b, "Sony VAIO", ALC275_FIXUP_SONY_HWEQ),
8726         SND_PCI_QUIRK(0x104d, 0x9084, "Sony VAIO", ALC275_FIXUP_SONY_HWEQ),
8727         SND_PCI_QUIRK(0x104d, 0x9099, "Sony VAIO S13", ALC275_FIXUP_SONY_DISABLE_AAMIX),
8728         SND_PCI_QUIRK(0x104d, 0x90b5, "Sony VAIO Pro 11", ALC286_FIXUP_SONY_MIC_NO_PRESENCE),
8729         SND_PCI_QUIRK(0x104d, 0x90b6, "Sony VAIO Pro 13", ALC286_FIXUP_SONY_MIC_NO_PRESENCE),
8730         SND_PCI_QUIRK(0x10cf, 0x1475, "Lifebook", ALC269_FIXUP_LIFEBOOK),
8731         SND_PCI_QUIRK(0x10cf, 0x159f, "Lifebook E780", ALC269_FIXUP_LIFEBOOK_NO_HP_TO_LINEOUT),
8732         SND_PCI_QUIRK(0x10cf, 0x15dc, "Lifebook T731", ALC269_FIXUP_LIFEBOOK_HP_PIN),
8733         SND_PCI_QUIRK(0x10cf, 0x1629, "Lifebook U7x7", ALC255_FIXUP_LIFEBOOK_U7x7_HEADSET_MIC),
8734         SND_PCI_QUIRK(0x10cf, 0x1757, "Lifebook E752", ALC269_FIXUP_LIFEBOOK_HP_PIN),
8735         SND_PCI_QUIRK(0x10cf, 0x1845, "Lifebook U904", ALC269_FIXUP_LIFEBOOK_EXTMIC),
8736         SND_PCI_QUIRK(0x10ec, 0x10f2, "Intel Reference board", ALC700_FIXUP_INTEL_REFERENCE),
8737         SND_PCI_QUIRK(0x10ec, 0x118c, "Medion EE4254 MD62100", ALC256_FIXUP_MEDION_HEADSET_NO_PRESENCE),
8738         SND_PCI_QUIRK(0x10ec, 0x1230, "Intel Reference board", ALC295_FIXUP_CHROME_BOOK),
8739         SND_PCI_QUIRK(0x10ec, 0x1252, "Intel Reference board", ALC295_FIXUP_CHROME_BOOK),
8740         SND_PCI_QUIRK(0x10ec, 0x1254, "Intel Reference board", ALC295_FIXUP_CHROME_BOOK),
8741         SND_PCI_QUIRK(0x10f7, 0x8338, "Panasonic CF-SZ6", ALC269_FIXUP_HEADSET_MODE),
8742         SND_PCI_QUIRK(0x144d, 0xc109, "Samsung Ativ book 9 (NP900X3G)", ALC269_FIXUP_INV_DMIC),
8743         SND_PCI_QUIRK(0x144d, 0xc169, "Samsung Notebook 9 Pen (NP930SBE-K01US)", ALC298_FIXUP_SAMSUNG_HEADPHONE_VERY_QUIET),
8744         SND_PCI_QUIRK(0x144d, 0xc176, "Samsung Notebook 9 Pro (NP930MBE-K04US)", ALC298_FIXUP_SAMSUNG_HEADPHONE_VERY_QUIET),
8745         SND_PCI_QUIRK(0x144d, 0xc189, "Samsung Galaxy Flex Book (NT950QCG-X716)", ALC298_FIXUP_SAMSUNG_HEADPHONE_VERY_QUIET),
8746         SND_PCI_QUIRK(0x144d, 0xc18a, "Samsung Galaxy Book Ion (NP930XCJ-K01US)", ALC298_FIXUP_SAMSUNG_HEADPHONE_VERY_QUIET),
8747         SND_PCI_QUIRK(0x144d, 0xc740, "Samsung Ativ book 8 (NP870Z5G)", ALC269_FIXUP_ATIV_BOOK_8),
8748         SND_PCI_QUIRK(0x144d, 0xc812, "Samsung Notebook Pen S (NT950SBE-X58)", ALC298_FIXUP_SAMSUNG_HEADPHONE_VERY_QUIET),
8749         SND_PCI_QUIRK(0x144d, 0xc830, "Samsung Galaxy Book Ion (NT950XCJ-X716A)", ALC298_FIXUP_SAMSUNG_HEADPHONE_VERY_QUIET),
8750         SND_PCI_QUIRK(0x1458, 0xfa53, "Gigabyte BXBT-2807", ALC283_FIXUP_HEADSET_MIC),
8751         SND_PCI_QUIRK(0x1462, 0xb120, "MSI Cubi MS-B120", ALC283_FIXUP_HEADSET_MIC),
8752         SND_PCI_QUIRK(0x1462, 0xb171, "Cubi N 8GL (MS-B171)", ALC283_FIXUP_HEADSET_MIC),
8753         SND_PCI_QUIRK(0x152d, 0x1082, "Quanta NL3", ALC269_FIXUP_LIFEBOOK),
8754         SND_PCI_QUIRK(0x1558, 0x1323, "Clevo N130ZU", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
8755         SND_PCI_QUIRK(0x1558, 0x1325, "Clevo N15[01][CW]U", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
8756         SND_PCI_QUIRK(0x1558, 0x1401, "Clevo L140[CZ]U", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
8757         SND_PCI_QUIRK(0x1558, 0x1403, "Clevo N140CU", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
8758         SND_PCI_QUIRK(0x1558, 0x1404, "Clevo N150CU", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
8759         SND_PCI_QUIRK(0x1558, 0x14a1, "Clevo L141MU", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
8760         SND_PCI_QUIRK(0x1558, 0x4018, "Clevo NV40M[BE]", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
8761         SND_PCI_QUIRK(0x1558, 0x4019, "Clevo NV40MZ", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
8762         SND_PCI_QUIRK(0x1558, 0x4020, "Clevo NV40MB", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
8763         SND_PCI_QUIRK(0x1558, 0x40a1, "Clevo NL40GU", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
8764         SND_PCI_QUIRK(0x1558, 0x40c1, "Clevo NL40[CZ]U", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
8765         SND_PCI_QUIRK(0x1558, 0x40d1, "Clevo NL41DU", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
8766         SND_PCI_QUIRK(0x1558, 0x5015, "Clevo NH5[58]H[HJK]Q", ALC256_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
8767         SND_PCI_QUIRK(0x1558, 0x5017, "Clevo NH7[79]H[HJK]Q", ALC256_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
8768         SND_PCI_QUIRK(0x1558, 0x50a3, "Clevo NJ51GU", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
8769         SND_PCI_QUIRK(0x1558, 0x50b3, "Clevo NK50S[BEZ]", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
8770         SND_PCI_QUIRK(0x1558, 0x50b6, "Clevo NK50S5", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
8771         SND_PCI_QUIRK(0x1558, 0x50b8, "Clevo NK50SZ", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
8772         SND_PCI_QUIRK(0x1558, 0x50d5, "Clevo NP50D5", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
8773         SND_PCI_QUIRK(0x1558, 0x50e1, "Clevo NH5[58]HPQ", ALC256_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
8774         SND_PCI_QUIRK(0x1558, 0x50e2, "Clevo NH7[79]HPQ", ALC256_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
8775         SND_PCI_QUIRK(0x1558, 0x50f0, "Clevo NH50A[CDF]", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
8776         SND_PCI_QUIRK(0x1558, 0x50f2, "Clevo NH50E[PR]", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
8777         SND_PCI_QUIRK(0x1558, 0x50f3, "Clevo NH58DPQ", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
8778         SND_PCI_QUIRK(0x1558, 0x50f5, "Clevo NH55EPY", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
8779         SND_PCI_QUIRK(0x1558, 0x50f6, "Clevo NH55DPQ", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
8780         SND_PCI_QUIRK(0x1558, 0x5101, "Clevo S510WU", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
8781         SND_PCI_QUIRK(0x1558, 0x5157, "Clevo W517GU1", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
8782         SND_PCI_QUIRK(0x1558, 0x51a1, "Clevo NS50MU", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
8783         SND_PCI_QUIRK(0x1558, 0x70a1, "Clevo NB70T[HJK]", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
8784         SND_PCI_QUIRK(0x1558, 0x70b3, "Clevo NK70SB", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
8785         SND_PCI_QUIRK(0x1558, 0x70f2, "Clevo NH79EPY", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
8786         SND_PCI_QUIRK(0x1558, 0x70f3, "Clevo NH77DPQ", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
8787         SND_PCI_QUIRK(0x1558, 0x70f4, "Clevo NH77EPY", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
8788         SND_PCI_QUIRK(0x1558, 0x70f6, "Clevo NH77DPQ-Y", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
8789         SND_PCI_QUIRK(0x1558, 0x8228, "Clevo NR40BU", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
8790         SND_PCI_QUIRK(0x1558, 0x8520, "Clevo NH50D[CD]", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
8791         SND_PCI_QUIRK(0x1558, 0x8521, "Clevo NH77D[CD]", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
8792         SND_PCI_QUIRK(0x1558, 0x8535, "Clevo NH50D[BE]", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
8793         SND_PCI_QUIRK(0x1558, 0x8536, "Clevo NH79D[BE]", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
8794         SND_PCI_QUIRK(0x1558, 0x8550, "Clevo NH[57][0-9][ER][ACDH]Q", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
8795         SND_PCI_QUIRK(0x1558, 0x8551, "Clevo NH[57][0-9][ER][ACDH]Q", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
8796         SND_PCI_QUIRK(0x1558, 0x8560, "Clevo NH[57][0-9][ER][ACDH]Q", ALC269_FIXUP_HEADSET_MIC),
8797         SND_PCI_QUIRK(0x1558, 0x8561, "Clevo NH[57][0-9][ER][ACDH]Q", ALC269_FIXUP_HEADSET_MIC),
8798         SND_PCI_QUIRK(0x1558, 0x8562, "Clevo NH[57][0-9]RZ[Q]", ALC269_FIXUP_DMIC),
8799         SND_PCI_QUIRK(0x1558, 0x8668, "Clevo NP50B[BE]", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
8800         SND_PCI_QUIRK(0x1558, 0x8680, "Clevo NJ50LU", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
8801         SND_PCI_QUIRK(0x1558, 0x8686, "Clevo NH50[CZ]U", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
8802         SND_PCI_QUIRK(0x1558, 0x8a20, "Clevo NH55DCQ-Y", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
8803         SND_PCI_QUIRK(0x1558, 0x8a51, "Clevo NH70RCQ-Y", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
8804         SND_PCI_QUIRK(0x1558, 0x8d50, "Clevo NH55RCQ-M", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
8805         SND_PCI_QUIRK(0x1558, 0x951d, "Clevo N950T[CDF]", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
8806         SND_PCI_QUIRK(0x1558, 0x9600, "Clevo N960K[PR]", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
8807         SND_PCI_QUIRK(0x1558, 0x961d, "Clevo N960S[CDF]", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
8808         SND_PCI_QUIRK(0x1558, 0x971d, "Clevo N970T[CDF]", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
8809         SND_PCI_QUIRK(0x1558, 0xa500, "Clevo NL5[03]RU", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
8810         SND_PCI_QUIRK(0x1558, 0xa600, "Clevo NL50NU", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
8811         SND_PCI_QUIRK(0x1558, 0xb018, "Clevo NP50D[BE]", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
8812         SND_PCI_QUIRK(0x1558, 0xb019, "Clevo NH77D[BE]Q", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
8813         SND_PCI_QUIRK(0x1558, 0xb022, "Clevo NH77D[DC][QW]", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
8814         SND_PCI_QUIRK(0x1558, 0xc018, "Clevo NP50D[BE]", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
8815         SND_PCI_QUIRK(0x1558, 0xc019, "Clevo NH77D[BE]Q", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
8816         SND_PCI_QUIRK(0x1558, 0xc022, "Clevo NH77[DC][QW]", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
8817         SND_PCI_QUIRK(0x17aa, 0x1036, "Lenovo P520", ALC233_FIXUP_LENOVO_MULTI_CODECS),
8818         SND_PCI_QUIRK(0x17aa, 0x1048, "ThinkCentre Station", ALC623_FIXUP_LENOVO_THINKSTATION_P340),
8819         SND_PCI_QUIRK(0x17aa, 0x20f2, "Thinkpad SL410/510", ALC269_FIXUP_SKU_IGNORE),
8820         SND_PCI_QUIRK(0x17aa, 0x215e, "Thinkpad L512", ALC269_FIXUP_SKU_IGNORE),
8821         SND_PCI_QUIRK(0x17aa, 0x21b8, "Thinkpad Edge 14", ALC269_FIXUP_SKU_IGNORE),
8822         SND_PCI_QUIRK(0x17aa, 0x21ca, "Thinkpad L412", ALC269_FIXUP_SKU_IGNORE),
8823         SND_PCI_QUIRK(0x17aa, 0x21e9, "Thinkpad Edge 15", ALC269_FIXUP_SKU_IGNORE),
8824         SND_PCI_QUIRK(0x17aa, 0x21f3, "Thinkpad T430", ALC269_FIXUP_LENOVO_DOCK),
8825         SND_PCI_QUIRK(0x17aa, 0x21f6, "Thinkpad T530", ALC269_FIXUP_LENOVO_DOCK_LIMIT_BOOST),
8826         SND_PCI_QUIRK(0x17aa, 0x21fa, "Thinkpad X230", ALC269_FIXUP_LENOVO_DOCK),
8827         SND_PCI_QUIRK(0x17aa, 0x21fb, "Thinkpad T430s", ALC269_FIXUP_LENOVO_DOCK),
8828         SND_PCI_QUIRK(0x17aa, 0x2203, "Thinkpad X230 Tablet", ALC269_FIXUP_LENOVO_DOCK),
8829         SND_PCI_QUIRK(0x17aa, 0x2208, "Thinkpad T431s", ALC269_FIXUP_LENOVO_DOCK),
8830         SND_PCI_QUIRK(0x17aa, 0x220c, "Thinkpad T440s", ALC292_FIXUP_TPT440),
8831         SND_PCI_QUIRK(0x17aa, 0x220e, "Thinkpad T440p", ALC292_FIXUP_TPT440_DOCK),
8832         SND_PCI_QUIRK(0x17aa, 0x2210, "Thinkpad T540p", ALC292_FIXUP_TPT440_DOCK),
8833         SND_PCI_QUIRK(0x17aa, 0x2211, "Thinkpad W541", ALC292_FIXUP_TPT440_DOCK),
8834         SND_PCI_QUIRK(0x17aa, 0x2212, "Thinkpad T440", ALC292_FIXUP_TPT440_DOCK),
8835         SND_PCI_QUIRK(0x17aa, 0x2214, "Thinkpad X240", ALC292_FIXUP_TPT440_DOCK),
8836         SND_PCI_QUIRK(0x17aa, 0x2215, "Thinkpad", ALC269_FIXUP_LIMIT_INT_MIC_BOOST),
8837         SND_PCI_QUIRK(0x17aa, 0x2218, "Thinkpad X1 Carbon 2nd", ALC292_FIXUP_TPT440_DOCK),
8838         SND_PCI_QUIRK(0x17aa, 0x2223, "ThinkPad T550", ALC292_FIXUP_TPT440_DOCK),
8839         SND_PCI_QUIRK(0x17aa, 0x2226, "ThinkPad X250", ALC292_FIXUP_TPT440_DOCK),
8840         SND_PCI_QUIRK(0x17aa, 0x222d, "Thinkpad", ALC298_FIXUP_TPT470_DOCK),
8841         SND_PCI_QUIRK(0x17aa, 0x222e, "Thinkpad", ALC298_FIXUP_TPT470_DOCK),
8842         SND_PCI_QUIRK(0x17aa, 0x2231, "Thinkpad T560", ALC292_FIXUP_TPT460),
8843         SND_PCI_QUIRK(0x17aa, 0x2233, "Thinkpad", ALC292_FIXUP_TPT460),
8844         SND_PCI_QUIRK(0x17aa, 0x2245, "Thinkpad T470", ALC298_FIXUP_TPT470_DOCK),
8845         SND_PCI_QUIRK(0x17aa, 0x2246, "Thinkpad", ALC298_FIXUP_TPT470_DOCK),
8846         SND_PCI_QUIRK(0x17aa, 0x2247, "Thinkpad", ALC298_FIXUP_TPT470_DOCK),
8847         SND_PCI_QUIRK(0x17aa, 0x2249, "Thinkpad", ALC292_FIXUP_TPT460),
8848         SND_PCI_QUIRK(0x17aa, 0x224b, "Thinkpad", ALC298_FIXUP_TPT470_DOCK),
8849         SND_PCI_QUIRK(0x17aa, 0x224c, "Thinkpad", ALC298_FIXUP_TPT470_DOCK),
8850         SND_PCI_QUIRK(0x17aa, 0x224d, "Thinkpad", ALC298_FIXUP_TPT470_DOCK),
8851         SND_PCI_QUIRK(0x17aa, 0x225d, "Thinkpad T480", ALC269_FIXUP_LIMIT_INT_MIC_BOOST),
8852         SND_PCI_QUIRK(0x17aa, 0x2292, "Thinkpad X1 Carbon 7th", ALC285_FIXUP_THINKPAD_HEADSET_JACK),
8853         SND_PCI_QUIRK(0x17aa, 0x22be, "Thinkpad X1 Carbon 8th", ALC285_FIXUP_THINKPAD_HEADSET_JACK),
8854         SND_PCI_QUIRK(0x17aa, 0x22c1, "Thinkpad P1 Gen 3", ALC285_FIXUP_THINKPAD_NO_BASS_SPK_HEADSET_JACK),
8855         SND_PCI_QUIRK(0x17aa, 0x22c2, "Thinkpad X1 Extreme Gen 3", ALC285_FIXUP_THINKPAD_NO_BASS_SPK_HEADSET_JACK),
8856         SND_PCI_QUIRK(0x17aa, 0x30bb, "ThinkCentre AIO", ALC233_FIXUP_LENOVO_LINE2_MIC_HOTKEY),
8857         SND_PCI_QUIRK(0x17aa, 0x30e2, "ThinkCentre AIO", ALC233_FIXUP_LENOVO_LINE2_MIC_HOTKEY),
8858         SND_PCI_QUIRK(0x17aa, 0x310c, "ThinkCentre Station", ALC294_FIXUP_LENOVO_MIC_LOCATION),
8859         SND_PCI_QUIRK(0x17aa, 0x3111, "ThinkCentre Station", ALC294_FIXUP_LENOVO_MIC_LOCATION),
8860         SND_PCI_QUIRK(0x17aa, 0x312a, "ThinkCentre Station", ALC294_FIXUP_LENOVO_MIC_LOCATION),
8861         SND_PCI_QUIRK(0x17aa, 0x312f, "ThinkCentre Station", ALC294_FIXUP_LENOVO_MIC_LOCATION),
8862         SND_PCI_QUIRK(0x17aa, 0x313c, "ThinkCentre Station", ALC294_FIXUP_LENOVO_MIC_LOCATION),
8863         SND_PCI_QUIRK(0x17aa, 0x3151, "ThinkCentre Station", ALC283_FIXUP_HEADSET_MIC),
8864         SND_PCI_QUIRK(0x17aa, 0x3176, "ThinkCentre Station", ALC283_FIXUP_HEADSET_MIC),
8865         SND_PCI_QUIRK(0x17aa, 0x3178, "ThinkCentre Station", ALC283_FIXUP_HEADSET_MIC),
8866         SND_PCI_QUIRK(0x17aa, 0x31af, "ThinkCentre Station", ALC623_FIXUP_LENOVO_THINKSTATION_P340),
8867         SND_PCI_QUIRK(0x17aa, 0x3818, "Lenovo C940", ALC298_FIXUP_LENOVO_SPK_VOLUME),
8868         SND_PCI_QUIRK(0x17aa, 0x3827, "Ideapad S740", ALC285_FIXUP_IDEAPAD_S740_COEF),
8869         SND_PCI_QUIRK(0x17aa, 0x3843, "Yoga 9i", ALC287_FIXUP_IDEAPAD_BASS_SPK_AMP),
8870         SND_PCI_QUIRK(0x17aa, 0x3813, "Legion 7i 15IMHG05", ALC287_FIXUP_LEGION_15IMHG05_SPEAKERS),
8871         SND_PCI_QUIRK(0x17aa, 0x3852, "Lenovo Yoga 7 14ITL5", ALC287_FIXUP_YOGA7_14ITL_SPEAKERS),
8872         SND_PCI_QUIRK(0x17aa, 0x3853, "Lenovo Yoga 7 15ITL5", ALC287_FIXUP_YOGA7_14ITL_SPEAKERS),
8873         SND_PCI_QUIRK(0x17aa, 0x3819, "Lenovo 13s Gen2 ITL", ALC287_FIXUP_13S_GEN2_SPEAKERS),
8874         SND_PCI_QUIRK(0x17aa, 0x3902, "Lenovo E50-80", ALC269_FIXUP_DMIC_THINKPAD_ACPI),
8875         SND_PCI_QUIRK(0x17aa, 0x3977, "IdeaPad S210", ALC283_FIXUP_INT_MIC),
8876         SND_PCI_QUIRK(0x17aa, 0x3978, "Lenovo B50-70", ALC269_FIXUP_DMIC_THINKPAD_ACPI),
8877         SND_PCI_QUIRK(0x17aa, 0x3bf8, "Quanta FL1", ALC269_FIXUP_PCM_44K),
8878         SND_PCI_QUIRK(0x17aa, 0x5013, "Thinkpad", ALC269_FIXUP_LIMIT_INT_MIC_BOOST),
8879         SND_PCI_QUIRK(0x17aa, 0x501a, "Thinkpad", ALC283_FIXUP_INT_MIC),
8880         SND_PCI_QUIRK(0x17aa, 0x501e, "Thinkpad L440", ALC292_FIXUP_TPT440_DOCK),
8881         SND_PCI_QUIRK(0x17aa, 0x5026, "Thinkpad", ALC269_FIXUP_LIMIT_INT_MIC_BOOST),
8882         SND_PCI_QUIRK(0x17aa, 0x5034, "Thinkpad T450", ALC292_FIXUP_TPT440_DOCK),
8883         SND_PCI_QUIRK(0x17aa, 0x5036, "Thinkpad T450s", ALC292_FIXUP_TPT440_DOCK),
8884         SND_PCI_QUIRK(0x17aa, 0x503c, "Thinkpad L450", ALC292_FIXUP_TPT440_DOCK),
8885         SND_PCI_QUIRK(0x17aa, 0x504a, "ThinkPad X260", ALC292_FIXUP_TPT440_DOCK),
8886         SND_PCI_QUIRK(0x17aa, 0x504b, "Thinkpad", ALC293_FIXUP_LENOVO_SPK_NOISE),
8887         SND_PCI_QUIRK(0x17aa, 0x5050, "Thinkpad T560p", ALC292_FIXUP_TPT460),
8888         SND_PCI_QUIRK(0x17aa, 0x5051, "Thinkpad L460", ALC292_FIXUP_TPT460),
8889         SND_PCI_QUIRK(0x17aa, 0x5053, "Thinkpad T460", ALC292_FIXUP_TPT460),
8890         SND_PCI_QUIRK(0x17aa, 0x505d, "Thinkpad", ALC298_FIXUP_TPT470_DOCK),
8891         SND_PCI_QUIRK(0x17aa, 0x505f, "Thinkpad", ALC298_FIXUP_TPT470_DOCK),
8892         SND_PCI_QUIRK(0x17aa, 0x5062, "Thinkpad", ALC298_FIXUP_TPT470_DOCK),
8893         SND_PCI_QUIRK(0x17aa, 0x5109, "Thinkpad", ALC269_FIXUP_LIMIT_INT_MIC_BOOST),
8894         SND_PCI_QUIRK(0x17aa, 0x511e, "Thinkpad", ALC298_FIXUP_TPT470_DOCK),
8895         SND_PCI_QUIRK(0x17aa, 0x511f, "Thinkpad", ALC298_FIXUP_TPT470_DOCK),
8896         SND_PCI_QUIRK(0x17aa, 0x9e54, "LENOVO NB", ALC269_FIXUP_LENOVO_EAPD),
8897         SND_PCI_QUIRK(0x19e5, 0x3204, "Huawei MACH-WX9", ALC256_FIXUP_HUAWEI_MACH_WX9_PINS),
8898         SND_PCI_QUIRK(0x1b35, 0x1235, "CZC B20", ALC269_FIXUP_CZC_B20),
8899         SND_PCI_QUIRK(0x1b35, 0x1236, "CZC TMI", ALC269_FIXUP_CZC_TMI),
8900         SND_PCI_QUIRK(0x1b35, 0x1237, "CZC L101", ALC269_FIXUP_CZC_L101),
8901         SND_PCI_QUIRK(0x1b7d, 0xa831, "Ordissimo EVE2 ", ALC269VB_FIXUP_ORDISSIMO_EVE2), /* Also known as Malata PC-B1303 */
8902         SND_PCI_QUIRK(0x1c06, 0x2013, "Lemote A1802", ALC269_FIXUP_LEMOTE_A1802),
8903         SND_PCI_QUIRK(0x1c06, 0x2015, "Lemote A190X", ALC269_FIXUP_LEMOTE_A190X),
8904         SND_PCI_QUIRK(0x1d05, 0x1132, "TongFang PHxTxX1", ALC256_FIXUP_TONGFANG_RESET_PERSISTENT_SETTINGS),
8905         SND_PCI_QUIRK(0x1d72, 0x1602, "RedmiBook", ALC255_FIXUP_XIAOMI_HEADSET_MIC),
8906         SND_PCI_QUIRK(0x1d72, 0x1701, "XiaomiNotebook Pro", ALC298_FIXUP_DELL1_MIC_NO_PRESENCE),
8907         SND_PCI_QUIRK(0x1d72, 0x1901, "RedmiBook 14", ALC256_FIXUP_ASUS_HEADSET_MIC),
8908         SND_PCI_QUIRK(0x1d72, 0x1947, "RedmiBook Air", ALC255_FIXUP_XIAOMI_HEADSET_MIC),
8909         SND_PCI_QUIRK(0x8086, 0x2074, "Intel NUC 8", ALC233_FIXUP_INTEL_NUC8_DMIC),
8910         SND_PCI_QUIRK(0x8086, 0x2080, "Intel NUC 8 Rugged", ALC256_FIXUP_INTEL_NUC8_RUGGED),
8911         SND_PCI_QUIRK(0x8086, 0x2081, "Intel NUC 10", ALC256_FIXUP_INTEL_NUC10),
8912
8913 #if 0
8914         /* Below is a quirk table taken from the old code.
8915          * Basically the device should work as is without the fixup table.
8916          * If BIOS doesn't give a proper info, enable the corresponding
8917          * fixup entry.
8918          */
8919         SND_PCI_QUIRK(0x1043, 0x8330, "ASUS Eeepc P703 P900A",
8920                       ALC269_FIXUP_AMIC),
8921         SND_PCI_QUIRK(0x1043, 0x1013, "ASUS N61Da", ALC269_FIXUP_AMIC),
8922         SND_PCI_QUIRK(0x1043, 0x1143, "ASUS B53f", ALC269_FIXUP_AMIC),
8923         SND_PCI_QUIRK(0x1043, 0x1133, "ASUS UJ20ft", ALC269_FIXUP_AMIC),
8924         SND_PCI_QUIRK(0x1043, 0x1183, "ASUS K72DR", ALC269_FIXUP_AMIC),
8925         SND_PCI_QUIRK(0x1043, 0x11b3, "ASUS K52DR", ALC269_FIXUP_AMIC),
8926         SND_PCI_QUIRK(0x1043, 0x11e3, "ASUS U33Jc", ALC269_FIXUP_AMIC),
8927         SND_PCI_QUIRK(0x1043, 0x1273, "ASUS UL80Jt", ALC269_FIXUP_AMIC),
8928         SND_PCI_QUIRK(0x1043, 0x1283, "ASUS U53Jc", ALC269_FIXUP_AMIC),
8929         SND_PCI_QUIRK(0x1043, 0x12b3, "ASUS N82JV", ALC269_FIXUP_AMIC),
8930         SND_PCI_QUIRK(0x1043, 0x12d3, "ASUS N61Jv", ALC269_FIXUP_AMIC),
8931         SND_PCI_QUIRK(0x1043, 0x13a3, "ASUS UL30Vt", ALC269_FIXUP_AMIC),
8932         SND_PCI_QUIRK(0x1043, 0x1373, "ASUS G73JX", ALC269_FIXUP_AMIC),
8933         SND_PCI_QUIRK(0x1043, 0x1383, "ASUS UJ30Jc", ALC269_FIXUP_AMIC),
8934         SND_PCI_QUIRK(0x1043, 0x13d3, "ASUS N61JA", ALC269_FIXUP_AMIC),
8935         SND_PCI_QUIRK(0x1043, 0x1413, "ASUS UL50", ALC269_FIXUP_AMIC),
8936         SND_PCI_QUIRK(0x1043, 0x1443, "ASUS UL30", ALC269_FIXUP_AMIC),
8937         SND_PCI_QUIRK(0x1043, 0x1453, "ASUS M60Jv", ALC269_FIXUP_AMIC),
8938         SND_PCI_QUIRK(0x1043, 0x1483, "ASUS UL80", ALC269_FIXUP_AMIC),
8939         SND_PCI_QUIRK(0x1043, 0x14f3, "ASUS F83Vf", ALC269_FIXUP_AMIC),
8940         SND_PCI_QUIRK(0x1043, 0x14e3, "ASUS UL20", ALC269_FIXUP_AMIC),
8941         SND_PCI_QUIRK(0x1043, 0x1513, "ASUS UX30", ALC269_FIXUP_AMIC),
8942         SND_PCI_QUIRK(0x1043, 0x1593, "ASUS N51Vn", ALC269_FIXUP_AMIC),
8943         SND_PCI_QUIRK(0x1043, 0x15a3, "ASUS N60Jv", ALC269_FIXUP_AMIC),
8944         SND_PCI_QUIRK(0x1043, 0x15b3, "ASUS N60Dp", ALC269_FIXUP_AMIC),
8945         SND_PCI_QUIRK(0x1043, 0x15c3, "ASUS N70De", ALC269_FIXUP_AMIC),
8946         SND_PCI_QUIRK(0x1043, 0x15e3, "ASUS F83T", ALC269_FIXUP_AMIC),
8947         SND_PCI_QUIRK(0x1043, 0x1643, "ASUS M60J", ALC269_FIXUP_AMIC),
8948         SND_PCI_QUIRK(0x1043, 0x1653, "ASUS U50", ALC269_FIXUP_AMIC),
8949         SND_PCI_QUIRK(0x1043, 0x1693, "ASUS F50N", ALC269_FIXUP_AMIC),
8950         SND_PCI_QUIRK(0x1043, 0x16a3, "ASUS F5Q", ALC269_FIXUP_AMIC),
8951         SND_PCI_QUIRK(0x1043, 0x1723, "ASUS P80", ALC269_FIXUP_AMIC),
8952         SND_PCI_QUIRK(0x1043, 0x1743, "ASUS U80", ALC269_FIXUP_AMIC),
8953         SND_PCI_QUIRK(0x1043, 0x1773, "ASUS U20A", ALC269_FIXUP_AMIC),
8954         SND_PCI_QUIRK(0x1043, 0x1883, "ASUS F81Se", ALC269_FIXUP_AMIC),
8955         SND_PCI_QUIRK(0x152d, 0x1778, "Quanta ON1", ALC269_FIXUP_DMIC),
8956         SND_PCI_QUIRK(0x17aa, 0x3be9, "Quanta Wistron", ALC269_FIXUP_AMIC),
8957         SND_PCI_QUIRK(0x17aa, 0x3bf8, "Quanta FL1", ALC269_FIXUP_AMIC),
8958         SND_PCI_QUIRK(0x17ff, 0x059a, "Quanta EL3", ALC269_FIXUP_DMIC),
8959         SND_PCI_QUIRK(0x17ff, 0x059b, "Quanta JR1", ALC269_FIXUP_DMIC),
8960 #endif
8961         {}
8962 };
8963
8964 static const struct snd_pci_quirk alc269_fixup_vendor_tbl[] = {
8965         SND_PCI_QUIRK_VENDOR(0x1025, "Acer Aspire", ALC271_FIXUP_DMIC),
8966         SND_PCI_QUIRK_VENDOR(0x103c, "HP", ALC269_FIXUP_HP_MUTE_LED),
8967         SND_PCI_QUIRK_VENDOR(0x104d, "Sony VAIO", ALC269_FIXUP_SONY_VAIO),
8968         SND_PCI_QUIRK_VENDOR(0x17aa, "Thinkpad", ALC269_FIXUP_THINKPAD_ACPI),
8969         SND_PCI_QUIRK_VENDOR(0x19e5, "Huawei Matebook", ALC255_FIXUP_MIC_MUTE_LED),
8970         {}
8971 };
8972
8973 static const struct hda_model_fixup alc269_fixup_models[] = {
8974         {.id = ALC269_FIXUP_AMIC, .name = "laptop-amic"},
8975         {.id = ALC269_FIXUP_DMIC, .name = "laptop-dmic"},
8976         {.id = ALC269_FIXUP_STEREO_DMIC, .name = "alc269-dmic"},
8977         {.id = ALC271_FIXUP_DMIC, .name = "alc271-dmic"},
8978         {.id = ALC269_FIXUP_INV_DMIC, .name = "inv-dmic"},
8979         {.id = ALC269_FIXUP_HEADSET_MIC, .name = "headset-mic"},
8980         {.id = ALC269_FIXUP_HEADSET_MODE, .name = "headset-mode"},
8981         {.id = ALC269_FIXUP_HEADSET_MODE_NO_HP_MIC, .name = "headset-mode-no-hp-mic"},
8982         {.id = ALC269_FIXUP_LENOVO_DOCK, .name = "lenovo-dock"},
8983         {.id = ALC269_FIXUP_LENOVO_DOCK_LIMIT_BOOST, .name = "lenovo-dock-limit-boost"},
8984         {.id = ALC269_FIXUP_HP_GPIO_LED, .name = "hp-gpio-led"},
8985         {.id = ALC269_FIXUP_HP_DOCK_GPIO_MIC1_LED, .name = "hp-dock-gpio-mic1-led"},
8986         {.id = ALC269_FIXUP_DELL1_MIC_NO_PRESENCE, .name = "dell-headset-multi"},
8987         {.id = ALC269_FIXUP_DELL2_MIC_NO_PRESENCE, .name = "dell-headset-dock"},
8988         {.id = ALC269_FIXUP_DELL3_MIC_NO_PRESENCE, .name = "dell-headset3"},
8989         {.id = ALC269_FIXUP_DELL4_MIC_NO_PRESENCE, .name = "dell-headset4"},
8990         {.id = ALC283_FIXUP_CHROME_BOOK, .name = "alc283-dac-wcaps"},
8991         {.id = ALC283_FIXUP_SENSE_COMBO_JACK, .name = "alc283-sense-combo"},
8992         {.id = ALC292_FIXUP_TPT440_DOCK, .name = "tpt440-dock"},
8993         {.id = ALC292_FIXUP_TPT440, .name = "tpt440"},
8994         {.id = ALC292_FIXUP_TPT460, .name = "tpt460"},
8995         {.id = ALC298_FIXUP_TPT470_DOCK_FIX, .name = "tpt470-dock-fix"},
8996         {.id = ALC298_FIXUP_TPT470_DOCK, .name = "tpt470-dock"},
8997         {.id = ALC233_FIXUP_LENOVO_MULTI_CODECS, .name = "dual-codecs"},
8998         {.id = ALC700_FIXUP_INTEL_REFERENCE, .name = "alc700-ref"},
8999         {.id = ALC269_FIXUP_SONY_VAIO, .name = "vaio"},
9000         {.id = ALC269_FIXUP_DELL_M101Z, .name = "dell-m101z"},
9001         {.id = ALC269_FIXUP_ASUS_G73JW, .name = "asus-g73jw"},
9002         {.id = ALC269_FIXUP_LENOVO_EAPD, .name = "lenovo-eapd"},
9003         {.id = ALC275_FIXUP_SONY_HWEQ, .name = "sony-hweq"},
9004         {.id = ALC269_FIXUP_PCM_44K, .name = "pcm44k"},
9005         {.id = ALC269_FIXUP_LIFEBOOK, .name = "lifebook"},
9006         {.id = ALC269_FIXUP_LIFEBOOK_EXTMIC, .name = "lifebook-extmic"},
9007         {.id = ALC269_FIXUP_LIFEBOOK_HP_PIN, .name = "lifebook-hp-pin"},
9008         {.id = ALC255_FIXUP_LIFEBOOK_U7x7_HEADSET_MIC, .name = "lifebook-u7x7"},
9009         {.id = ALC269VB_FIXUP_AMIC, .name = "alc269vb-amic"},
9010         {.id = ALC269VB_FIXUP_DMIC, .name = "alc269vb-dmic"},
9011         {.id = ALC269_FIXUP_HP_MUTE_LED_MIC1, .name = "hp-mute-led-mic1"},
9012         {.id = ALC269_FIXUP_HP_MUTE_LED_MIC2, .name = "hp-mute-led-mic2"},
9013         {.id = ALC269_FIXUP_HP_MUTE_LED_MIC3, .name = "hp-mute-led-mic3"},
9014         {.id = ALC269_FIXUP_HP_GPIO_MIC1_LED, .name = "hp-gpio-mic1"},
9015         {.id = ALC269_FIXUP_HP_LINE1_MIC1_LED, .name = "hp-line1-mic1"},
9016         {.id = ALC269_FIXUP_NO_SHUTUP, .name = "noshutup"},
9017         {.id = ALC286_FIXUP_SONY_MIC_NO_PRESENCE, .name = "sony-nomic"},
9018         {.id = ALC269_FIXUP_ASPIRE_HEADSET_MIC, .name = "aspire-headset-mic"},
9019         {.id = ALC269_FIXUP_ASUS_X101, .name = "asus-x101"},
9020         {.id = ALC271_FIXUP_HP_GATE_MIC_JACK, .name = "acer-ao7xx"},
9021         {.id = ALC271_FIXUP_HP_GATE_MIC_JACK_E1_572, .name = "acer-aspire-e1"},
9022         {.id = ALC269_FIXUP_ACER_AC700, .name = "acer-ac700"},
9023         {.id = ALC269_FIXUP_LIMIT_INT_MIC_BOOST, .name = "limit-mic-boost"},
9024         {.id = ALC269VB_FIXUP_ASUS_ZENBOOK, .name = "asus-zenbook"},
9025         {.id = ALC269VB_FIXUP_ASUS_ZENBOOK_UX31A, .name = "asus-zenbook-ux31a"},
9026         {.id = ALC269VB_FIXUP_ORDISSIMO_EVE2, .name = "ordissimo"},
9027         {.id = ALC282_FIXUP_ASUS_TX300, .name = "asus-tx300"},
9028         {.id = ALC283_FIXUP_INT_MIC, .name = "alc283-int-mic"},
9029         {.id = ALC290_FIXUP_MONO_SPEAKERS_HSJACK, .name = "mono-speakers"},
9030         {.id = ALC290_FIXUP_SUBWOOFER_HSJACK, .name = "alc290-subwoofer"},
9031         {.id = ALC269_FIXUP_THINKPAD_ACPI, .name = "thinkpad"},
9032         {.id = ALC269_FIXUP_DMIC_THINKPAD_ACPI, .name = "dmic-thinkpad"},
9033         {.id = ALC255_FIXUP_ACER_MIC_NO_PRESENCE, .name = "alc255-acer"},
9034         {.id = ALC255_FIXUP_ASUS_MIC_NO_PRESENCE, .name = "alc255-asus"},
9035         {.id = ALC255_FIXUP_DELL1_MIC_NO_PRESENCE, .name = "alc255-dell1"},
9036         {.id = ALC255_FIXUP_DELL2_MIC_NO_PRESENCE, .name = "alc255-dell2"},
9037         {.id = ALC293_FIXUP_DELL1_MIC_NO_PRESENCE, .name = "alc293-dell1"},
9038         {.id = ALC283_FIXUP_HEADSET_MIC, .name = "alc283-headset"},
9039         {.id = ALC255_FIXUP_MIC_MUTE_LED, .name = "alc255-dell-mute"},
9040         {.id = ALC282_FIXUP_ASPIRE_V5_PINS, .name = "aspire-v5"},
9041         {.id = ALC269VB_FIXUP_ASPIRE_E1_COEF, .name = "aspire-e1-coef"},
9042         {.id = ALC280_FIXUP_HP_GPIO4, .name = "hp-gpio4"},
9043         {.id = ALC286_FIXUP_HP_GPIO_LED, .name = "hp-gpio-led"},
9044         {.id = ALC280_FIXUP_HP_GPIO2_MIC_HOTKEY, .name = "hp-gpio2-hotkey"},
9045         {.id = ALC280_FIXUP_HP_DOCK_PINS, .name = "hp-dock-pins"},
9046         {.id = ALC269_FIXUP_HP_DOCK_GPIO_MIC1_LED, .name = "hp-dock-gpio-mic"},
9047         {.id = ALC280_FIXUP_HP_9480M, .name = "hp-9480m"},
9048         {.id = ALC288_FIXUP_DELL_HEADSET_MODE, .name = "alc288-dell-headset"},
9049         {.id = ALC288_FIXUP_DELL1_MIC_NO_PRESENCE, .name = "alc288-dell1"},
9050         {.id = ALC288_FIXUP_DELL_XPS_13, .name = "alc288-dell-xps13"},
9051         {.id = ALC292_FIXUP_DELL_E7X, .name = "dell-e7x"},
9052         {.id = ALC293_FIXUP_DISABLE_AAMIX_MULTIJACK, .name = "alc293-dell"},
9053         {.id = ALC298_FIXUP_DELL1_MIC_NO_PRESENCE, .name = "alc298-dell1"},
9054         {.id = ALC298_FIXUP_DELL_AIO_MIC_NO_PRESENCE, .name = "alc298-dell-aio"},
9055         {.id = ALC275_FIXUP_DELL_XPS, .name = "alc275-dell-xps"},
9056         {.id = ALC293_FIXUP_LENOVO_SPK_NOISE, .name = "lenovo-spk-noise"},
9057         {.id = ALC233_FIXUP_LENOVO_LINE2_MIC_HOTKEY, .name = "lenovo-hotkey"},
9058         {.id = ALC255_FIXUP_DELL_SPK_NOISE, .name = "dell-spk-noise"},
9059         {.id = ALC225_FIXUP_DELL1_MIC_NO_PRESENCE, .name = "alc225-dell1"},
9060         {.id = ALC295_FIXUP_DISABLE_DAC3, .name = "alc295-disable-dac3"},
9061         {.id = ALC285_FIXUP_SPEAKER2_TO_DAC1, .name = "alc285-speaker2-to-dac1"},
9062         {.id = ALC280_FIXUP_HP_HEADSET_MIC, .name = "alc280-hp-headset"},
9063         {.id = ALC221_FIXUP_HP_FRONT_MIC, .name = "alc221-hp-mic"},
9064         {.id = ALC298_FIXUP_SPK_VOLUME, .name = "alc298-spk-volume"},
9065         {.id = ALC256_FIXUP_DELL_INSPIRON_7559_SUBWOOFER, .name = "dell-inspiron-7559"},
9066         {.id = ALC269_FIXUP_ATIV_BOOK_8, .name = "ativ-book"},
9067         {.id = ALC221_FIXUP_HP_MIC_NO_PRESENCE, .name = "alc221-hp-mic"},
9068         {.id = ALC256_FIXUP_ASUS_HEADSET_MODE, .name = "alc256-asus-headset"},
9069         {.id = ALC256_FIXUP_ASUS_MIC, .name = "alc256-asus-mic"},
9070         {.id = ALC256_FIXUP_ASUS_AIO_GPIO2, .name = "alc256-asus-aio"},
9071         {.id = ALC233_FIXUP_ASUS_MIC_NO_PRESENCE, .name = "alc233-asus"},
9072         {.id = ALC233_FIXUP_EAPD_COEF_AND_MIC_NO_PRESENCE, .name = "alc233-eapd"},
9073         {.id = ALC294_FIXUP_LENOVO_MIC_LOCATION, .name = "alc294-lenovo-mic"},
9074         {.id = ALC225_FIXUP_DELL_WYSE_MIC_NO_PRESENCE, .name = "alc225-wyse"},
9075         {.id = ALC274_FIXUP_DELL_AIO_LINEOUT_VERB, .name = "alc274-dell-aio"},
9076         {.id = ALC255_FIXUP_DUMMY_LINEOUT_VERB, .name = "alc255-dummy-lineout"},
9077         {.id = ALC255_FIXUP_DELL_HEADSET_MIC, .name = "alc255-dell-headset"},
9078         {.id = ALC295_FIXUP_HP_X360, .name = "alc295-hp-x360"},
9079         {.id = ALC225_FIXUP_HEADSET_JACK, .name = "alc-headset-jack"},
9080         {.id = ALC295_FIXUP_CHROME_BOOK, .name = "alc-chrome-book"},
9081         {.id = ALC299_FIXUP_PREDATOR_SPK, .name = "predator-spk"},
9082         {.id = ALC298_FIXUP_HUAWEI_MBX_STEREO, .name = "huawei-mbx-stereo"},
9083         {.id = ALC256_FIXUP_MEDION_HEADSET_NO_PRESENCE, .name = "alc256-medion-headset"},
9084         {.id = ALC298_FIXUP_SAMSUNG_HEADPHONE_VERY_QUIET, .name = "alc298-samsung-headphone"},
9085         {.id = ALC255_FIXUP_XIAOMI_HEADSET_MIC, .name = "alc255-xiaomi-headset"},
9086         {.id = ALC274_FIXUP_HP_MIC, .name = "alc274-hp-mic-detect"},
9087         {.id = ALC245_FIXUP_HP_X360_AMP, .name = "alc245-hp-x360-amp"},
9088         {.id = ALC295_FIXUP_HP_OMEN, .name = "alc295-hp-omen"},
9089         {.id = ALC285_FIXUP_HP_SPECTRE_X360, .name = "alc285-hp-spectre-x360"},
9090         {.id = ALC285_FIXUP_HP_SPECTRE_X360_EB1, .name = "alc285-hp-spectre-x360-eb1"},
9091         {.id = ALC287_FIXUP_IDEAPAD_BASS_SPK_AMP, .name = "alc287-ideapad-bass-spk-amp"},
9092         {.id = ALC623_FIXUP_LENOVO_THINKSTATION_P340, .name = "alc623-lenovo-thinkstation-p340"},
9093         {.id = ALC255_FIXUP_ACER_HEADPHONE_AND_MIC, .name = "alc255-acer-headphone-and-mic"},
9094         {}
9095 };
9096 #define ALC225_STANDARD_PINS \
9097         {0x21, 0x04211020}
9098
9099 #define ALC256_STANDARD_PINS \
9100         {0x12, 0x90a60140}, \
9101         {0x14, 0x90170110}, \
9102         {0x21, 0x02211020}
9103
9104 #define ALC282_STANDARD_PINS \
9105         {0x14, 0x90170110}
9106
9107 #define ALC290_STANDARD_PINS \
9108         {0x12, 0x99a30130}
9109
9110 #define ALC292_STANDARD_PINS \
9111         {0x14, 0x90170110}, \
9112         {0x15, 0x0221401f}
9113
9114 #define ALC295_STANDARD_PINS \
9115         {0x12, 0xb7a60130}, \
9116         {0x14, 0x90170110}, \
9117         {0x21, 0x04211020}
9118
9119 #define ALC298_STANDARD_PINS \
9120         {0x12, 0x90a60130}, \
9121         {0x21, 0x03211020}
9122
9123 static const struct snd_hda_pin_quirk alc269_pin_fixup_tbl[] = {
9124         SND_HDA_PIN_QUIRK(0x10ec0221, 0x103c, "HP Workstation", ALC221_FIXUP_HP_HEADSET_MIC,
9125                 {0x14, 0x01014020},
9126                 {0x17, 0x90170110},
9127                 {0x18, 0x02a11030},
9128                 {0x19, 0x0181303F},
9129                 {0x21, 0x0221102f}),
9130         SND_HDA_PIN_QUIRK(0x10ec0255, 0x1025, "Acer", ALC255_FIXUP_ACER_MIC_NO_PRESENCE,
9131                 {0x12, 0x90a601c0},
9132                 {0x14, 0x90171120},
9133                 {0x21, 0x02211030}),
9134         SND_HDA_PIN_QUIRK(0x10ec0255, 0x1043, "ASUS", ALC255_FIXUP_ASUS_MIC_NO_PRESENCE,
9135                 {0x14, 0x90170110},
9136                 {0x1b, 0x90a70130},
9137                 {0x21, 0x03211020}),
9138         SND_HDA_PIN_QUIRK(0x10ec0255, 0x1043, "ASUS", ALC255_FIXUP_ASUS_MIC_NO_PRESENCE,
9139                 {0x1a, 0x90a70130},
9140                 {0x1b, 0x90170110},
9141                 {0x21, 0x03211020}),
9142         SND_HDA_PIN_QUIRK(0x10ec0225, 0x1028, "Dell", ALC225_FIXUP_DELL1_MIC_NO_PRESENCE,
9143                 ALC225_STANDARD_PINS,
9144                 {0x12, 0xb7a60130},
9145                 {0x14, 0x901701a0}),
9146         SND_HDA_PIN_QUIRK(0x10ec0225, 0x1028, "Dell", ALC225_FIXUP_DELL1_MIC_NO_PRESENCE,
9147                 ALC225_STANDARD_PINS,
9148                 {0x12, 0xb7a60130},
9149                 {0x14, 0x901701b0}),
9150         SND_HDA_PIN_QUIRK(0x10ec0225, 0x1028, "Dell", ALC225_FIXUP_DELL1_MIC_NO_PRESENCE,
9151                 ALC225_STANDARD_PINS,
9152                 {0x12, 0xb7a60150},
9153                 {0x14, 0x901701a0}),
9154         SND_HDA_PIN_QUIRK(0x10ec0225, 0x1028, "Dell", ALC225_FIXUP_DELL1_MIC_NO_PRESENCE,
9155                 ALC225_STANDARD_PINS,
9156                 {0x12, 0xb7a60150},
9157                 {0x14, 0x901701b0}),
9158         SND_HDA_PIN_QUIRK(0x10ec0225, 0x1028, "Dell", ALC225_FIXUP_DELL1_MIC_NO_PRESENCE,
9159                 ALC225_STANDARD_PINS,
9160                 {0x12, 0xb7a60130},
9161                 {0x1b, 0x90170110}),
9162         SND_HDA_PIN_QUIRK(0x10ec0233, 0x8086, "Intel NUC Skull Canyon", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE,
9163                 {0x1b, 0x01111010},
9164                 {0x1e, 0x01451130},
9165                 {0x21, 0x02211020}),
9166         SND_HDA_PIN_QUIRK(0x10ec0235, 0x17aa, "Lenovo", ALC233_FIXUP_LENOVO_LINE2_MIC_HOTKEY,
9167                 {0x12, 0x90a60140},
9168                 {0x14, 0x90170110},
9169                 {0x19, 0x02a11030},
9170                 {0x21, 0x02211020}),
9171         SND_HDA_PIN_QUIRK(0x10ec0235, 0x17aa, "Lenovo", ALC294_FIXUP_LENOVO_MIC_LOCATION,
9172                 {0x14, 0x90170110},
9173                 {0x19, 0x02a11030},
9174                 {0x1a, 0x02a11040},
9175                 {0x1b, 0x01014020},
9176                 {0x21, 0x0221101f}),
9177         SND_HDA_PIN_QUIRK(0x10ec0235, 0x17aa, "Lenovo", ALC294_FIXUP_LENOVO_MIC_LOCATION,
9178                 {0x14, 0x90170110},
9179                 {0x19, 0x02a11030},
9180                 {0x1a, 0x02a11040},
9181                 {0x1b, 0x01011020},
9182                 {0x21, 0x0221101f}),
9183         SND_HDA_PIN_QUIRK(0x10ec0235, 0x17aa, "Lenovo", ALC294_FIXUP_LENOVO_MIC_LOCATION,
9184                 {0x14, 0x90170110},
9185                 {0x19, 0x02a11020},
9186                 {0x1a, 0x02a11030},
9187                 {0x21, 0x0221101f}),
9188         SND_HDA_PIN_QUIRK(0x10ec0236, 0x1028, "Dell", ALC236_FIXUP_DELL_AIO_HEADSET_MIC,
9189                 {0x21, 0x02211010}),
9190         SND_HDA_PIN_QUIRK(0x10ec0236, 0x103c, "HP", ALC256_FIXUP_HP_HEADSET_MIC,
9191                 {0x14, 0x90170110},
9192                 {0x19, 0x02a11020},
9193                 {0x21, 0x02211030}),
9194         SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL2_MIC_NO_PRESENCE,
9195                 {0x14, 0x90170110},
9196                 {0x21, 0x02211020}),
9197         SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
9198                 {0x14, 0x90170130},
9199                 {0x21, 0x02211040}),
9200         SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
9201                 {0x12, 0x90a60140},
9202                 {0x14, 0x90170110},
9203                 {0x21, 0x02211020}),
9204         SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
9205                 {0x12, 0x90a60160},
9206                 {0x14, 0x90170120},
9207                 {0x21, 0x02211030}),
9208         SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
9209                 {0x14, 0x90170110},
9210                 {0x1b, 0x02011020},
9211                 {0x21, 0x0221101f}),
9212         SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
9213                 {0x14, 0x90170110},
9214                 {0x1b, 0x01011020},
9215                 {0x21, 0x0221101f}),
9216         SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
9217                 {0x14, 0x90170130},
9218                 {0x1b, 0x01014020},
9219                 {0x21, 0x0221103f}),
9220         SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
9221                 {0x14, 0x90170130},
9222                 {0x1b, 0x01011020},
9223                 {0x21, 0x0221103f}),
9224         SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
9225                 {0x14, 0x90170130},
9226                 {0x1b, 0x02011020},
9227                 {0x21, 0x0221103f}),
9228         SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
9229                 {0x14, 0x90170150},
9230                 {0x1b, 0x02011020},
9231                 {0x21, 0x0221105f}),
9232         SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
9233                 {0x14, 0x90170110},
9234                 {0x1b, 0x01014020},
9235                 {0x21, 0x0221101f}),
9236         SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
9237                 {0x12, 0x90a60160},
9238                 {0x14, 0x90170120},
9239                 {0x17, 0x90170140},
9240                 {0x21, 0x0321102f}),
9241         SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
9242                 {0x12, 0x90a60160},
9243                 {0x14, 0x90170130},
9244                 {0x21, 0x02211040}),
9245         SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
9246                 {0x12, 0x90a60160},
9247                 {0x14, 0x90170140},
9248                 {0x21, 0x02211050}),
9249         SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
9250                 {0x12, 0x90a60170},
9251                 {0x14, 0x90170120},
9252                 {0x21, 0x02211030}),
9253         SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
9254                 {0x12, 0x90a60170},
9255                 {0x14, 0x90170130},
9256                 {0x21, 0x02211040}),
9257         SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
9258                 {0x12, 0x90a60170},
9259                 {0x14, 0x90171130},
9260                 {0x21, 0x02211040}),
9261         SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
9262                 {0x12, 0x90a60170},
9263                 {0x14, 0x90170140},
9264                 {0x21, 0x02211050}),
9265         SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell Inspiron 5548", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
9266                 {0x12, 0x90a60180},
9267                 {0x14, 0x90170130},
9268                 {0x21, 0x02211040}),
9269         SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell Inspiron 5565", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
9270                 {0x12, 0x90a60180},
9271                 {0x14, 0x90170120},
9272                 {0x21, 0x02211030}),
9273         SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
9274                 {0x1b, 0x01011020},
9275                 {0x21, 0x02211010}),
9276         SND_HDA_PIN_QUIRK(0x10ec0256, 0x1043, "ASUS", ALC256_FIXUP_ASUS_MIC,
9277                 {0x14, 0x90170110},
9278                 {0x1b, 0x90a70130},
9279                 {0x21, 0x04211020}),
9280         SND_HDA_PIN_QUIRK(0x10ec0256, 0x1043, "ASUS", ALC256_FIXUP_ASUS_MIC,
9281                 {0x14, 0x90170110},
9282                 {0x1b, 0x90a70130},
9283                 {0x21, 0x03211020}),
9284         SND_HDA_PIN_QUIRK(0x10ec0256, 0x1043, "ASUS", ALC256_FIXUP_ASUS_MIC_NO_PRESENCE,
9285                 {0x12, 0x90a60130},
9286                 {0x14, 0x90170110},
9287                 {0x21, 0x03211020}),
9288         SND_HDA_PIN_QUIRK(0x10ec0256, 0x1043, "ASUS", ALC256_FIXUP_ASUS_MIC_NO_PRESENCE,
9289                 {0x12, 0x90a60130},
9290                 {0x14, 0x90170110},
9291                 {0x21, 0x04211020}),
9292         SND_HDA_PIN_QUIRK(0x10ec0256, 0x1043, "ASUS", ALC256_FIXUP_ASUS_MIC_NO_PRESENCE,
9293                 {0x1a, 0x90a70130},
9294                 {0x1b, 0x90170110},
9295                 {0x21, 0x03211020}),
9296        SND_HDA_PIN_QUIRK(0x10ec0256, 0x103c, "HP", ALC256_FIXUP_HP_HEADSET_MIC,
9297                 {0x14, 0x90170110},
9298                 {0x19, 0x02a11020},
9299                 {0x21, 0x0221101f}),
9300        SND_HDA_PIN_QUIRK(0x10ec0274, 0x103c, "HP", ALC274_FIXUP_HP_HEADSET_MIC,
9301                 {0x17, 0x90170110},
9302                 {0x19, 0x03a11030},
9303                 {0x21, 0x03211020}),
9304         SND_HDA_PIN_QUIRK(0x10ec0280, 0x103c, "HP", ALC280_FIXUP_HP_GPIO4,
9305                 {0x12, 0x90a60130},
9306                 {0x14, 0x90170110},
9307                 {0x15, 0x0421101f},
9308                 {0x1a, 0x04a11020}),
9309         SND_HDA_PIN_QUIRK(0x10ec0280, 0x103c, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED,
9310                 {0x12, 0x90a60140},
9311                 {0x14, 0x90170110},
9312                 {0x15, 0x0421101f},
9313                 {0x18, 0x02811030},
9314                 {0x1a, 0x04a1103f},
9315                 {0x1b, 0x02011020}),
9316         SND_HDA_PIN_QUIRK(0x10ec0282, 0x103c, "HP 15 Touchsmart", ALC269_FIXUP_HP_MUTE_LED_MIC1,
9317                 ALC282_STANDARD_PINS,
9318                 {0x12, 0x99a30130},
9319                 {0x19, 0x03a11020},
9320                 {0x21, 0x0321101f}),
9321         SND_HDA_PIN_QUIRK(0x10ec0282, 0x103c, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1,
9322                 ALC282_STANDARD_PINS,
9323                 {0x12, 0x99a30130},
9324                 {0x19, 0x03a11020},
9325                 {0x21, 0x03211040}),
9326         SND_HDA_PIN_QUIRK(0x10ec0282, 0x103c, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1,
9327                 ALC282_STANDARD_PINS,
9328                 {0x12, 0x99a30130},
9329                 {0x19, 0x03a11030},
9330                 {0x21, 0x03211020}),
9331         SND_HDA_PIN_QUIRK(0x10ec0282, 0x103c, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1,
9332                 ALC282_STANDARD_PINS,
9333                 {0x12, 0x99a30130},
9334                 {0x19, 0x04a11020},
9335                 {0x21, 0x0421101f}),
9336         SND_HDA_PIN_QUIRK(0x10ec0282, 0x103c, "HP", ALC269_FIXUP_HP_LINE1_MIC1_LED,
9337                 ALC282_STANDARD_PINS,
9338                 {0x12, 0x90a60140},
9339                 {0x19, 0x04a11030},
9340                 {0x21, 0x04211020}),
9341         SND_HDA_PIN_QUIRK(0x10ec0282, 0x1025, "Acer", ALC282_FIXUP_ACER_DISABLE_LINEOUT,
9342                 ALC282_STANDARD_PINS,
9343                 {0x12, 0x90a609c0},
9344                 {0x18, 0x03a11830},
9345                 {0x19, 0x04a19831},
9346                 {0x1a, 0x0481303f},
9347                 {0x1b, 0x04211020},
9348                 {0x21, 0x0321101f}),
9349         SND_HDA_PIN_QUIRK(0x10ec0282, 0x1025, "Acer", ALC282_FIXUP_ACER_DISABLE_LINEOUT,
9350                 ALC282_STANDARD_PINS,
9351                 {0x12, 0x90a60940},
9352                 {0x18, 0x03a11830},
9353                 {0x19, 0x04a19831},
9354                 {0x1a, 0x0481303f},
9355                 {0x1b, 0x04211020},
9356                 {0x21, 0x0321101f}),
9357         SND_HDA_PIN_QUIRK(0x10ec0283, 0x1028, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE,
9358                 ALC282_STANDARD_PINS,
9359                 {0x12, 0x90a60130},
9360                 {0x21, 0x0321101f}),
9361         SND_HDA_PIN_QUIRK(0x10ec0283, 0x1028, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE,
9362                 {0x12, 0x90a60160},
9363                 {0x14, 0x90170120},
9364                 {0x21, 0x02211030}),
9365         SND_HDA_PIN_QUIRK(0x10ec0283, 0x1028, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE,
9366                 ALC282_STANDARD_PINS,
9367                 {0x12, 0x90a60130},
9368                 {0x19, 0x03a11020},
9369                 {0x21, 0x0321101f}),
9370         SND_HDA_PIN_QUIRK(0x10ec0285, 0x17aa, "Lenovo", ALC285_FIXUP_LENOVO_PC_BEEP_IN_NOISE,
9371                 {0x12, 0x90a60130},
9372                 {0x14, 0x90170110},
9373                 {0x19, 0x04a11040},
9374                 {0x21, 0x04211020}),
9375         SND_HDA_PIN_QUIRK(0x10ec0285, 0x17aa, "Lenovo", ALC285_FIXUP_LENOVO_PC_BEEP_IN_NOISE,
9376                 {0x14, 0x90170110},
9377                 {0x19, 0x04a11040},
9378                 {0x1d, 0x40600001},
9379                 {0x21, 0x04211020}),
9380         SND_HDA_PIN_QUIRK(0x10ec0285, 0x17aa, "Lenovo", ALC285_FIXUP_THINKPAD_NO_BASS_SPK_HEADSET_JACK,
9381                 {0x14, 0x90170110},
9382                 {0x19, 0x04a11040},
9383                 {0x21, 0x04211020}),
9384         SND_HDA_PIN_QUIRK(0x10ec0287, 0x17aa, "Lenovo", ALC285_FIXUP_THINKPAD_HEADSET_JACK,
9385                 {0x14, 0x90170110},
9386                 {0x17, 0x90170111},
9387                 {0x19, 0x03a11030},
9388                 {0x21, 0x03211020}),
9389         SND_HDA_PIN_QUIRK(0x10ec0286, 0x1025, "Acer", ALC286_FIXUP_ACER_AIO_MIC_NO_PRESENCE,
9390                 {0x12, 0x90a60130},
9391                 {0x17, 0x90170110},
9392                 {0x21, 0x02211020}),
9393         SND_HDA_PIN_QUIRK(0x10ec0288, 0x1028, "Dell", ALC288_FIXUP_DELL1_MIC_NO_PRESENCE,
9394                 {0x12, 0x90a60120},
9395                 {0x14, 0x90170110},
9396                 {0x21, 0x0321101f}),
9397         SND_HDA_PIN_QUIRK(0x10ec0290, 0x103c, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1,
9398                 ALC290_STANDARD_PINS,
9399                 {0x15, 0x04211040},
9400                 {0x18, 0x90170112},
9401                 {0x1a, 0x04a11020}),
9402         SND_HDA_PIN_QUIRK(0x10ec0290, 0x103c, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1,
9403                 ALC290_STANDARD_PINS,
9404                 {0x15, 0x04211040},
9405                 {0x18, 0x90170110},
9406                 {0x1a, 0x04a11020}),
9407         SND_HDA_PIN_QUIRK(0x10ec0290, 0x103c, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1,
9408                 ALC290_STANDARD_PINS,
9409                 {0x15, 0x0421101f},
9410                 {0x1a, 0x04a11020}),
9411         SND_HDA_PIN_QUIRK(0x10ec0290, 0x103c, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1,
9412                 ALC290_STANDARD_PINS,
9413                 {0x15, 0x04211020},
9414                 {0x1a, 0x04a11040}),
9415         SND_HDA_PIN_QUIRK(0x10ec0290, 0x103c, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1,
9416                 ALC290_STANDARD_PINS,
9417                 {0x14, 0x90170110},
9418                 {0x15, 0x04211020},
9419                 {0x1a, 0x04a11040}),
9420         SND_HDA_PIN_QUIRK(0x10ec0290, 0x103c, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1,
9421                 ALC290_STANDARD_PINS,
9422                 {0x14, 0x90170110},
9423                 {0x15, 0x04211020},
9424                 {0x1a, 0x04a11020}),
9425         SND_HDA_PIN_QUIRK(0x10ec0290, 0x103c, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1,
9426                 ALC290_STANDARD_PINS,
9427                 {0x14, 0x90170110},
9428                 {0x15, 0x0421101f},
9429                 {0x1a, 0x04a11020}),
9430         SND_HDA_PIN_QUIRK(0x10ec0292, 0x1028, "Dell", ALC269_FIXUP_DELL2_MIC_NO_PRESENCE,
9431                 ALC292_STANDARD_PINS,
9432                 {0x12, 0x90a60140},
9433                 {0x16, 0x01014020},
9434                 {0x19, 0x01a19030}),
9435         SND_HDA_PIN_QUIRK(0x10ec0292, 0x1028, "Dell", ALC269_FIXUP_DELL2_MIC_NO_PRESENCE,
9436                 ALC292_STANDARD_PINS,
9437                 {0x12, 0x90a60140},
9438                 {0x16, 0x01014020},
9439                 {0x18, 0x02a19031},
9440                 {0x19, 0x01a1903e}),
9441         SND_HDA_PIN_QUIRK(0x10ec0292, 0x1028, "Dell", ALC269_FIXUP_DELL3_MIC_NO_PRESENCE,
9442                 ALC292_STANDARD_PINS,
9443                 {0x12, 0x90a60140}),
9444         SND_HDA_PIN_QUIRK(0x10ec0293, 0x1028, "Dell", ALC293_FIXUP_DELL1_MIC_NO_PRESENCE,
9445                 ALC292_STANDARD_PINS,
9446                 {0x13, 0x90a60140},
9447                 {0x16, 0x21014020},
9448                 {0x19, 0x21a19030}),
9449         SND_HDA_PIN_QUIRK(0x10ec0293, 0x1028, "Dell", ALC293_FIXUP_DELL1_MIC_NO_PRESENCE,
9450                 ALC292_STANDARD_PINS,
9451                 {0x13, 0x90a60140}),
9452         SND_HDA_PIN_QUIRK(0x10ec0294, 0x1043, "ASUS", ALC294_FIXUP_ASUS_HPE,
9453                 {0x17, 0x90170110},
9454                 {0x21, 0x04211020}),
9455         SND_HDA_PIN_QUIRK(0x10ec0294, 0x1043, "ASUS", ALC294_FIXUP_ASUS_MIC,
9456                 {0x14, 0x90170110},
9457                 {0x1b, 0x90a70130},
9458                 {0x21, 0x04211020}),
9459         SND_HDA_PIN_QUIRK(0x10ec0294, 0x1043, "ASUS", ALC294_FIXUP_ASUS_SPK,
9460                 {0x12, 0x90a60130},
9461                 {0x17, 0x90170110},
9462                 {0x21, 0x03211020}),
9463         SND_HDA_PIN_QUIRK(0x10ec0294, 0x1043, "ASUS", ALC294_FIXUP_ASUS_SPK,
9464                 {0x12, 0x90a60130},
9465                 {0x17, 0x90170110},
9466                 {0x21, 0x04211020}),
9467         SND_HDA_PIN_QUIRK(0x10ec0295, 0x1043, "ASUS", ALC294_FIXUP_ASUS_SPK,
9468                 {0x12, 0x90a60130},
9469                 {0x17, 0x90170110},
9470                 {0x21, 0x03211020}),
9471         SND_HDA_PIN_QUIRK(0x10ec0295, 0x1043, "ASUS", ALC295_FIXUP_ASUS_MIC_NO_PRESENCE,
9472                 {0x12, 0x90a60120},
9473                 {0x17, 0x90170110},
9474                 {0x21, 0x04211030}),
9475         SND_HDA_PIN_QUIRK(0x10ec0295, 0x1043, "ASUS", ALC295_FIXUP_ASUS_MIC_NO_PRESENCE,
9476                 {0x12, 0x90a60130},
9477                 {0x17, 0x90170110},
9478                 {0x21, 0x03211020}),
9479         SND_HDA_PIN_QUIRK(0x10ec0295, 0x1043, "ASUS", ALC295_FIXUP_ASUS_MIC_NO_PRESENCE,
9480                 {0x12, 0x90a60130},
9481                 {0x17, 0x90170110},
9482                 {0x21, 0x03211020}),
9483         SND_HDA_PIN_QUIRK(0x10ec0295, 0x1028, "Dell", ALC269_FIXUP_DELL4_MIC_NO_PRESENCE,
9484                 {0x14, 0x90170110},
9485                 {0x21, 0x04211020}),
9486         SND_HDA_PIN_QUIRK(0x10ec0295, 0x1028, "Dell", ALC269_FIXUP_DELL4_MIC_NO_PRESENCE,
9487                 {0x14, 0x90170110},
9488                 {0x21, 0x04211030}),
9489         SND_HDA_PIN_QUIRK(0x10ec0295, 0x1028, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE,
9490                 ALC295_STANDARD_PINS,
9491                 {0x17, 0x21014020},
9492                 {0x18, 0x21a19030}),
9493         SND_HDA_PIN_QUIRK(0x10ec0295, 0x1028, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE,
9494                 ALC295_STANDARD_PINS,
9495                 {0x17, 0x21014040},
9496                 {0x18, 0x21a19050}),
9497         SND_HDA_PIN_QUIRK(0x10ec0295, 0x1028, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE,
9498                 ALC295_STANDARD_PINS),
9499         SND_HDA_PIN_QUIRK(0x10ec0298, 0x1028, "Dell", ALC298_FIXUP_DELL1_MIC_NO_PRESENCE,
9500                 ALC298_STANDARD_PINS,
9501                 {0x17, 0x90170110}),
9502         SND_HDA_PIN_QUIRK(0x10ec0298, 0x1028, "Dell", ALC298_FIXUP_DELL1_MIC_NO_PRESENCE,
9503                 ALC298_STANDARD_PINS,
9504                 {0x17, 0x90170140}),
9505         SND_HDA_PIN_QUIRK(0x10ec0298, 0x1028, "Dell", ALC298_FIXUP_DELL1_MIC_NO_PRESENCE,
9506                 ALC298_STANDARD_PINS,
9507                 {0x17, 0x90170150}),
9508         SND_HDA_PIN_QUIRK(0x10ec0298, 0x1028, "Dell", ALC298_FIXUP_SPK_VOLUME,
9509                 {0x12, 0xb7a60140},
9510                 {0x13, 0xb7a60150},
9511                 {0x17, 0x90170110},
9512                 {0x1a, 0x03011020},
9513                 {0x21, 0x03211030}),
9514         SND_HDA_PIN_QUIRK(0x10ec0298, 0x1028, "Dell", ALC298_FIXUP_ALIENWARE_MIC_NO_PRESENCE,
9515                 {0x12, 0xb7a60140},
9516                 {0x17, 0x90170110},
9517                 {0x1a, 0x03a11030},
9518                 {0x21, 0x03211020}),
9519         SND_HDA_PIN_QUIRK(0x10ec0299, 0x1028, "Dell", ALC269_FIXUP_DELL4_MIC_NO_PRESENCE,
9520                 ALC225_STANDARD_PINS,
9521                 {0x12, 0xb7a60130},
9522                 {0x17, 0x90170110}),
9523         SND_HDA_PIN_QUIRK(0x10ec0623, 0x17aa, "Lenovo", ALC283_FIXUP_HEADSET_MIC,
9524                 {0x14, 0x01014010},
9525                 {0x17, 0x90170120},
9526                 {0x18, 0x02a11030},
9527                 {0x19, 0x02a1103f},
9528                 {0x21, 0x0221101f}),
9529         {}
9530 };
9531
9532 /* This is the fallback pin_fixup_tbl for alc269 family, to make the tbl match
9533  * more machines, don't need to match all valid pins, just need to match
9534  * all the pins defined in the tbl. Just because of this reason, it is possible
9535  * that a single machine matches multiple tbls, so there is one limitation:
9536  *   at most one tbl is allowed to define for the same vendor and same codec
9537  */
9538 static const struct snd_hda_pin_quirk alc269_fallback_pin_fixup_tbl[] = {
9539         SND_HDA_PIN_QUIRK(0x10ec0289, 0x1028, "Dell", ALC269_FIXUP_DELL4_MIC_NO_PRESENCE,
9540                 {0x19, 0x40000000},
9541                 {0x1b, 0x40000000}),
9542         SND_HDA_PIN_QUIRK(0x10ec0256, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
9543                 {0x19, 0x40000000},
9544                 {0x1a, 0x40000000}),
9545         SND_HDA_PIN_QUIRK(0x10ec0236, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
9546                 {0x19, 0x40000000},
9547                 {0x1a, 0x40000000}),
9548         SND_HDA_PIN_QUIRK(0x10ec0274, 0x1028, "Dell", ALC274_FIXUP_DELL_AIO_LINEOUT_VERB,
9549                 {0x19, 0x40000000},
9550                 {0x1a, 0x40000000}),
9551         {}
9552 };
9553
9554 static void alc269_fill_coef(struct hda_codec *codec)
9555 {
9556         struct alc_spec *spec = codec->spec;
9557         int val;
9558
9559         if (spec->codec_variant != ALC269_TYPE_ALC269VB)
9560                 return;
9561
9562         if ((alc_get_coef0(codec) & 0x00ff) < 0x015) {
9563                 alc_write_coef_idx(codec, 0xf, 0x960b);
9564                 alc_write_coef_idx(codec, 0xe, 0x8817);
9565         }
9566
9567         if ((alc_get_coef0(codec) & 0x00ff) == 0x016) {
9568                 alc_write_coef_idx(codec, 0xf, 0x960b);
9569                 alc_write_coef_idx(codec, 0xe, 0x8814);
9570         }
9571
9572         if ((alc_get_coef0(codec) & 0x00ff) == 0x017) {
9573                 /* Power up output pin */
9574                 alc_update_coef_idx(codec, 0x04, 0, 1<<11);
9575         }
9576
9577         if ((alc_get_coef0(codec) & 0x00ff) == 0x018) {
9578                 val = alc_read_coef_idx(codec, 0xd);
9579                 if (val != -1 && (val & 0x0c00) >> 10 != 0x1) {
9580                         /* Capless ramp up clock control */
9581                         alc_write_coef_idx(codec, 0xd, val | (1<<10));
9582                 }
9583                 val = alc_read_coef_idx(codec, 0x17);
9584                 if (val != -1 && (val & 0x01c0) >> 6 != 0x4) {
9585                         /* Class D power on reset */
9586                         alc_write_coef_idx(codec, 0x17, val | (1<<7));
9587                 }
9588         }
9589
9590         /* HP */
9591         alc_update_coef_idx(codec, 0x4, 0, 1<<11);
9592 }
9593
9594 /*
9595  */
9596 static int patch_alc269(struct hda_codec *codec)
9597 {
9598         struct alc_spec *spec;
9599         int err;
9600
9601         err = alc_alloc_spec(codec, 0x0b);
9602         if (err < 0)
9603                 return err;
9604
9605         spec = codec->spec;
9606         spec->gen.shared_mic_vref_pin = 0x18;
9607         codec->power_save_node = 0;
9608
9609 #ifdef CONFIG_PM
9610         codec->patch_ops.suspend = alc269_suspend;
9611         codec->patch_ops.resume = alc269_resume;
9612 #endif
9613         spec->shutup = alc_default_shutup;
9614         spec->init_hook = alc_default_init;
9615
9616         switch (codec->core.vendor_id) {
9617         case 0x10ec0269:
9618                 spec->codec_variant = ALC269_TYPE_ALC269VA;
9619                 switch (alc_get_coef0(codec) & 0x00f0) {
9620                 case 0x0010:
9621                         if (codec->bus->pci &&
9622                             codec->bus->pci->subsystem_vendor == 0x1025 &&
9623                             spec->cdefine.platform_type == 1)
9624                                 err = alc_codec_rename(codec, "ALC271X");
9625                         spec->codec_variant = ALC269_TYPE_ALC269VB;
9626                         break;
9627                 case 0x0020:
9628                         if (codec->bus->pci &&
9629                             codec->bus->pci->subsystem_vendor == 0x17aa &&
9630                             codec->bus->pci->subsystem_device == 0x21f3)
9631                                 err = alc_codec_rename(codec, "ALC3202");
9632                         spec->codec_variant = ALC269_TYPE_ALC269VC;
9633                         break;
9634                 case 0x0030:
9635                         spec->codec_variant = ALC269_TYPE_ALC269VD;
9636                         break;
9637                 default:
9638                         alc_fix_pll_init(codec, 0x20, 0x04, 15);
9639                 }
9640                 if (err < 0)
9641                         goto error;
9642                 spec->shutup = alc269_shutup;
9643                 spec->init_hook = alc269_fill_coef;
9644                 alc269_fill_coef(codec);
9645                 break;
9646
9647         case 0x10ec0280:
9648         case 0x10ec0290:
9649                 spec->codec_variant = ALC269_TYPE_ALC280;
9650                 break;
9651         case 0x10ec0282:
9652                 spec->codec_variant = ALC269_TYPE_ALC282;
9653                 spec->shutup = alc282_shutup;
9654                 spec->init_hook = alc282_init;
9655                 break;
9656         case 0x10ec0233:
9657         case 0x10ec0283:
9658                 spec->codec_variant = ALC269_TYPE_ALC283;
9659                 spec->shutup = alc283_shutup;
9660                 spec->init_hook = alc283_init;
9661                 break;
9662         case 0x10ec0284:
9663         case 0x10ec0292:
9664                 spec->codec_variant = ALC269_TYPE_ALC284;
9665                 break;
9666         case 0x10ec0293:
9667                 spec->codec_variant = ALC269_TYPE_ALC293;
9668                 break;
9669         case 0x10ec0286:
9670         case 0x10ec0288:
9671                 spec->codec_variant = ALC269_TYPE_ALC286;
9672                 break;
9673         case 0x10ec0298:
9674                 spec->codec_variant = ALC269_TYPE_ALC298;
9675                 break;
9676         case 0x10ec0235:
9677         case 0x10ec0255:
9678                 spec->codec_variant = ALC269_TYPE_ALC255;
9679                 spec->shutup = alc256_shutup;
9680                 spec->init_hook = alc256_init;
9681                 break;
9682         case 0x10ec0230:
9683         case 0x10ec0236:
9684         case 0x10ec0256:
9685                 spec->codec_variant = ALC269_TYPE_ALC256;
9686                 spec->shutup = alc256_shutup;
9687                 spec->init_hook = alc256_init;
9688                 spec->gen.mixer_nid = 0; /* ALC256 does not have any loopback mixer path */
9689                 break;
9690         case 0x10ec0257:
9691                 spec->codec_variant = ALC269_TYPE_ALC257;
9692                 spec->shutup = alc256_shutup;
9693                 spec->init_hook = alc256_init;
9694                 spec->gen.mixer_nid = 0;
9695                 break;
9696         case 0x10ec0215:
9697         case 0x10ec0245:
9698         case 0x10ec0285:
9699         case 0x10ec0289:
9700                 spec->codec_variant = ALC269_TYPE_ALC215;
9701                 spec->shutup = alc225_shutup;
9702                 spec->init_hook = alc225_init;
9703                 spec->gen.mixer_nid = 0;
9704                 break;
9705         case 0x10ec0225:
9706         case 0x10ec0295:
9707         case 0x10ec0299:
9708                 spec->codec_variant = ALC269_TYPE_ALC225;
9709                 spec->shutup = alc225_shutup;
9710                 spec->init_hook = alc225_init;
9711                 spec->gen.mixer_nid = 0; /* no loopback on ALC225, ALC295 and ALC299 */
9712                 break;
9713         case 0x10ec0287:
9714                 spec->codec_variant = ALC269_TYPE_ALC287;
9715                 spec->shutup = alc225_shutup;
9716                 spec->init_hook = alc225_init;
9717                 spec->gen.mixer_nid = 0; /* no loopback on ALC287 */
9718                 break;
9719         case 0x10ec0234:
9720         case 0x10ec0274:
9721         case 0x10ec0294:
9722                 spec->codec_variant = ALC269_TYPE_ALC294;
9723                 spec->gen.mixer_nid = 0; /* ALC2x4 does not have any loopback mixer path */
9724                 alc_update_coef_idx(codec, 0x6b, 0x0018, (1<<4) | (1<<3)); /* UAJ MIC Vref control by verb */
9725                 spec->init_hook = alc294_init;
9726                 break;
9727         case 0x10ec0300:
9728                 spec->codec_variant = ALC269_TYPE_ALC300;
9729                 spec->gen.mixer_nid = 0; /* no loopback on ALC300 */
9730                 break;
9731         case 0x10ec0623:
9732                 spec->codec_variant = ALC269_TYPE_ALC623;
9733                 break;
9734         case 0x10ec0700:
9735         case 0x10ec0701:
9736         case 0x10ec0703:
9737         case 0x10ec0711:
9738                 spec->codec_variant = ALC269_TYPE_ALC700;
9739                 spec->gen.mixer_nid = 0; /* ALC700 does not have any loopback mixer path */
9740                 alc_update_coef_idx(codec, 0x4a, 1 << 15, 0); /* Combo jack auto trigger control */
9741                 spec->init_hook = alc294_init;
9742                 break;
9743
9744         }
9745
9746         if (snd_hda_codec_read(codec, 0x51, 0, AC_VERB_PARAMETERS, 0) == 0x10ec5505) {
9747                 spec->has_alc5505_dsp = 1;
9748                 spec->init_hook = alc5505_dsp_init;
9749         }
9750
9751         alc_pre_init(codec);
9752
9753         snd_hda_pick_fixup(codec, alc269_fixup_models,
9754                        alc269_fixup_tbl, alc269_fixups);
9755         /* FIXME: both TX300 and ROG Strix G17 have the same SSID, and
9756          * the quirk breaks the latter (bko#214101).
9757          * Clear the wrong entry.
9758          */
9759         if (codec->fixup_id == ALC282_FIXUP_ASUS_TX300 &&
9760             codec->core.vendor_id == 0x10ec0294) {
9761                 codec_dbg(codec, "Clear wrong fixup for ASUS ROG Strix G17\n");
9762                 codec->fixup_id = HDA_FIXUP_ID_NOT_SET;
9763         }
9764
9765         snd_hda_pick_pin_fixup(codec, alc269_pin_fixup_tbl, alc269_fixups, true);
9766         snd_hda_pick_pin_fixup(codec, alc269_fallback_pin_fixup_tbl, alc269_fixups, false);
9767         snd_hda_pick_fixup(codec, NULL, alc269_fixup_vendor_tbl,
9768                            alc269_fixups);
9769         snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE);
9770
9771         alc_auto_parse_customize_define(codec);
9772
9773         if (has_cdefine_beep(codec))
9774                 spec->gen.beep_nid = 0x01;
9775
9776         /* automatic parse from the BIOS config */
9777         err = alc269_parse_auto_config(codec);
9778         if (err < 0)
9779                 goto error;
9780
9781         if (!spec->gen.no_analog && spec->gen.beep_nid && spec->gen.mixer_nid) {
9782                 err = set_beep_amp(spec, spec->gen.mixer_nid, 0x04, HDA_INPUT);
9783                 if (err < 0)
9784                         goto error;
9785         }
9786
9787         snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE);
9788
9789         return 0;
9790
9791  error:
9792         alc_free(codec);
9793         return err;
9794 }
9795
9796 /*
9797  * ALC861
9798  */
9799
9800 static int alc861_parse_auto_config(struct hda_codec *codec)
9801 {
9802         static const hda_nid_t alc861_ignore[] = { 0x1d, 0 };
9803         static const hda_nid_t alc861_ssids[] = { 0x0e, 0x0f, 0x0b, 0 };
9804         return alc_parse_auto_config(codec, alc861_ignore, alc861_ssids);
9805 }
9806
9807 /* Pin config fixes */
9808 enum {
9809         ALC861_FIXUP_FSC_AMILO_PI1505,
9810         ALC861_FIXUP_AMP_VREF_0F,
9811         ALC861_FIXUP_NO_JACK_DETECT,
9812         ALC861_FIXUP_ASUS_A6RP,
9813         ALC660_FIXUP_ASUS_W7J,
9814 };
9815
9816 /* On some laptops, VREF of pin 0x0f is abused for controlling the main amp */
9817 static void alc861_fixup_asus_amp_vref_0f(struct hda_codec *codec,
9818                         const struct hda_fixup *fix, int action)
9819 {
9820         struct alc_spec *spec = codec->spec;
9821         unsigned int val;
9822
9823         if (action != HDA_FIXUP_ACT_INIT)
9824                 return;
9825         val = snd_hda_codec_get_pin_target(codec, 0x0f);
9826         if (!(val & (AC_PINCTL_IN_EN | AC_PINCTL_OUT_EN)))
9827                 val |= AC_PINCTL_IN_EN;
9828         val |= AC_PINCTL_VREF_50;
9829         snd_hda_set_pin_ctl(codec, 0x0f, val);
9830         spec->gen.keep_vref_in_automute = 1;
9831 }
9832
9833 /* suppress the jack-detection */
9834 static void alc_fixup_no_jack_detect(struct hda_codec *codec,
9835                                      const struct hda_fixup *fix, int action)
9836 {
9837         if (action == HDA_FIXUP_ACT_PRE_PROBE)
9838                 codec->no_jack_detect = 1;
9839 }
9840
9841 static const struct hda_fixup alc861_fixups[] = {
9842         [ALC861_FIXUP_FSC_AMILO_PI1505] = {
9843                 .type = HDA_FIXUP_PINS,
9844                 .v.pins = (const struct hda_pintbl[]) {
9845                         { 0x0b, 0x0221101f }, /* HP */
9846                         { 0x0f, 0x90170310 }, /* speaker */
9847                         { }
9848                 }
9849         },
9850         [ALC861_FIXUP_AMP_VREF_0F] = {
9851                 .type = HDA_FIXUP_FUNC,
9852                 .v.func = alc861_fixup_asus_amp_vref_0f,
9853         },
9854         [ALC861_FIXUP_NO_JACK_DETECT] = {
9855                 .type = HDA_FIXUP_FUNC,
9856                 .v.func = alc_fixup_no_jack_detect,
9857         },
9858         [ALC861_FIXUP_ASUS_A6RP] = {
9859                 .type = HDA_FIXUP_FUNC,
9860                 .v.func = alc861_fixup_asus_amp_vref_0f,
9861                 .chained = true,
9862                 .chain_id = ALC861_FIXUP_NO_JACK_DETECT,
9863         },
9864         [ALC660_FIXUP_ASUS_W7J] = {
9865                 .type = HDA_FIXUP_VERBS,
9866                 .v.verbs = (const struct hda_verb[]) {
9867                         /* ASUS W7J needs a magic pin setup on unused NID 0x10
9868                          * for enabling outputs
9869                          */
9870                         {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
9871                         { }
9872                 },
9873         }
9874 };
9875
9876 static const struct snd_pci_quirk alc861_fixup_tbl[] = {
9877         SND_PCI_QUIRK(0x1043, 0x1253, "ASUS W7J", ALC660_FIXUP_ASUS_W7J),
9878         SND_PCI_QUIRK(0x1043, 0x1263, "ASUS Z35HL", ALC660_FIXUP_ASUS_W7J),
9879         SND_PCI_QUIRK(0x1043, 0x1393, "ASUS A6Rp", ALC861_FIXUP_ASUS_A6RP),
9880         SND_PCI_QUIRK_VENDOR(0x1043, "ASUS laptop", ALC861_FIXUP_AMP_VREF_0F),
9881         SND_PCI_QUIRK(0x1462, 0x7254, "HP DX2200", ALC861_FIXUP_NO_JACK_DETECT),
9882         SND_PCI_QUIRK_VENDOR(0x1584, "Haier/Uniwill", ALC861_FIXUP_AMP_VREF_0F),
9883         SND_PCI_QUIRK(0x1734, 0x10c7, "FSC Amilo Pi1505", ALC861_FIXUP_FSC_AMILO_PI1505),
9884         {}
9885 };
9886
9887 /*
9888  */
9889 static int patch_alc861(struct hda_codec *codec)
9890 {
9891         struct alc_spec *spec;
9892         int err;
9893
9894         err = alc_alloc_spec(codec, 0x15);
9895         if (err < 0)
9896                 return err;
9897
9898         spec = codec->spec;
9899         if (has_cdefine_beep(codec))
9900                 spec->gen.beep_nid = 0x23;
9901
9902 #ifdef CONFIG_PM
9903         spec->power_hook = alc_power_eapd;
9904 #endif
9905
9906         alc_pre_init(codec);
9907
9908         snd_hda_pick_fixup(codec, NULL, alc861_fixup_tbl, alc861_fixups);
9909         snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE);
9910
9911         /* automatic parse from the BIOS config */
9912         err = alc861_parse_auto_config(codec);
9913         if (err < 0)
9914                 goto error;
9915
9916         if (!spec->gen.no_analog) {
9917                 err = set_beep_amp(spec, 0x23, 0, HDA_OUTPUT);
9918                 if (err < 0)
9919                         goto error;
9920         }
9921
9922         snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE);
9923
9924         return 0;
9925
9926  error:
9927         alc_free(codec);
9928         return err;
9929 }
9930
9931 /*
9932  * ALC861-VD support
9933  *
9934  * Based on ALC882
9935  *
9936  * In addition, an independent DAC
9937  */
9938 static int alc861vd_parse_auto_config(struct hda_codec *codec)
9939 {
9940         static const hda_nid_t alc861vd_ignore[] = { 0x1d, 0 };
9941         static const hda_nid_t alc861vd_ssids[] = { 0x15, 0x1b, 0x14, 0 };
9942         return alc_parse_auto_config(codec, alc861vd_ignore, alc861vd_ssids);
9943 }
9944
9945 enum {
9946         ALC660VD_FIX_ASUS_GPIO1,
9947         ALC861VD_FIX_DALLAS,
9948 };
9949
9950 /* exclude VREF80 */
9951 static void alc861vd_fixup_dallas(struct hda_codec *codec,
9952                                   const struct hda_fixup *fix, int action)
9953 {
9954         if (action == HDA_FIXUP_ACT_PRE_PROBE) {
9955                 snd_hda_override_pin_caps(codec, 0x18, 0x00000734);
9956                 snd_hda_override_pin_caps(codec, 0x19, 0x0000073c);
9957         }
9958 }
9959
9960 /* reset GPIO1 */
9961 static void alc660vd_fixup_asus_gpio1(struct hda_codec *codec,
9962                                       const struct hda_fixup *fix, int action)
9963 {
9964         struct alc_spec *spec = codec->spec;
9965
9966         if (action == HDA_FIXUP_ACT_PRE_PROBE)
9967                 spec->gpio_mask |= 0x02;
9968         alc_fixup_gpio(codec, action, 0x01);
9969 }
9970
9971 static const struct hda_fixup alc861vd_fixups[] = {
9972         [ALC660VD_FIX_ASUS_GPIO1] = {
9973                 .type = HDA_FIXUP_FUNC,
9974                 .v.func = alc660vd_fixup_asus_gpio1,
9975         },
9976         [ALC861VD_FIX_DALLAS] = {
9977                 .type = HDA_FIXUP_FUNC,
9978                 .v.func = alc861vd_fixup_dallas,
9979         },
9980 };
9981
9982 static const struct snd_pci_quirk alc861vd_fixup_tbl[] = {
9983         SND_PCI_QUIRK(0x103c, 0x30bf, "HP TX1000", ALC861VD_FIX_DALLAS),
9984         SND_PCI_QUIRK(0x1043, 0x1339, "ASUS A7-K", ALC660VD_FIX_ASUS_GPIO1),
9985         SND_PCI_QUIRK(0x1179, 0xff31, "Toshiba L30-149", ALC861VD_FIX_DALLAS),
9986         {}
9987 };
9988
9989 /*
9990  */
9991 static int patch_alc861vd(struct hda_codec *codec)
9992 {
9993         struct alc_spec *spec;
9994         int err;
9995
9996         err = alc_alloc_spec(codec, 0x0b);
9997         if (err < 0)
9998                 return err;
9999
10000         spec = codec->spec;
10001         if (has_cdefine_beep(codec))
10002                 spec->gen.beep_nid = 0x23;
10003
10004         spec->shutup = alc_eapd_shutup;
10005
10006         alc_pre_init(codec);
10007
10008         snd_hda_pick_fixup(codec, NULL, alc861vd_fixup_tbl, alc861vd_fixups);
10009         snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE);
10010
10011         /* automatic parse from the BIOS config */
10012         err = alc861vd_parse_auto_config(codec);
10013         if (err < 0)
10014                 goto error;
10015
10016         if (!spec->gen.no_analog) {
10017                 err = set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
10018                 if (err < 0)
10019                         goto error;
10020         }
10021
10022         snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE);
10023
10024         return 0;
10025
10026  error:
10027         alc_free(codec);
10028         return err;
10029 }
10030
10031 /*
10032  * ALC662 support
10033  *
10034  * ALC662 is almost identical with ALC880 but has cleaner and more flexible
10035  * configuration.  Each pin widget can choose any input DACs and a mixer.
10036  * Each ADC is connected from a mixer of all inputs.  This makes possible
10037  * 6-channel independent captures.
10038  *
10039  * In addition, an independent DAC for the multi-playback (not used in this
10040  * driver yet).
10041  */
10042
10043 /*
10044  * BIOS auto configuration
10045  */
10046
10047 static int alc662_parse_auto_config(struct hda_codec *codec)
10048 {
10049         static const hda_nid_t alc662_ignore[] = { 0x1d, 0 };
10050         static const hda_nid_t alc663_ssids[] = { 0x15, 0x1b, 0x14, 0x21 };
10051         static const hda_nid_t alc662_ssids[] = { 0x15, 0x1b, 0x14, 0 };
10052         const hda_nid_t *ssids;
10053
10054         if (codec->core.vendor_id == 0x10ec0272 || codec->core.vendor_id == 0x10ec0663 ||
10055             codec->core.vendor_id == 0x10ec0665 || codec->core.vendor_id == 0x10ec0670 ||
10056             codec->core.vendor_id == 0x10ec0671)
10057                 ssids = alc663_ssids;
10058         else
10059                 ssids = alc662_ssids;
10060         return alc_parse_auto_config(codec, alc662_ignore, ssids);
10061 }
10062
10063 static void alc272_fixup_mario(struct hda_codec *codec,
10064                                const struct hda_fixup *fix, int action)
10065 {
10066         if (action != HDA_FIXUP_ACT_PRE_PROBE)
10067                 return;
10068         if (snd_hda_override_amp_caps(codec, 0x2, HDA_OUTPUT,
10069                                       (0x3b << AC_AMPCAP_OFFSET_SHIFT) |
10070                                       (0x3b << AC_AMPCAP_NUM_STEPS_SHIFT) |
10071                                       (0x03 << AC_AMPCAP_STEP_SIZE_SHIFT) |
10072                                       (0 << AC_AMPCAP_MUTE_SHIFT)))
10073                 codec_warn(codec, "failed to override amp caps for NID 0x2\n");
10074 }
10075
10076 static const struct snd_pcm_chmap_elem asus_pcm_2_1_chmaps[] = {
10077         { .channels = 2,
10078           .map = { SNDRV_CHMAP_FL, SNDRV_CHMAP_FR } },
10079         { .channels = 4,
10080           .map = { SNDRV_CHMAP_FL, SNDRV_CHMAP_FR,
10081                    SNDRV_CHMAP_NA, SNDRV_CHMAP_LFE } }, /* LFE only on right */
10082         { }
10083 };
10084
10085 /* override the 2.1 chmap */
10086 static void alc_fixup_bass_chmap(struct hda_codec *codec,
10087                                     const struct hda_fixup *fix, int action)
10088 {
10089         if (action == HDA_FIXUP_ACT_BUILD) {
10090                 struct alc_spec *spec = codec->spec;
10091                 spec->gen.pcm_rec[0]->stream[0].chmap = asus_pcm_2_1_chmaps;
10092         }
10093 }
10094
10095 /* avoid D3 for keeping GPIO up */
10096 static unsigned int gpio_led_power_filter(struct hda_codec *codec,
10097                                           hda_nid_t nid,
10098                                           unsigned int power_state)
10099 {
10100         struct alc_spec *spec = codec->spec;
10101         if (nid == codec->core.afg && power_state == AC_PWRST_D3 && spec->gpio_data)
10102                 return AC_PWRST_D0;
10103         return power_state;
10104 }
10105
10106 static void alc662_fixup_led_gpio1(struct hda_codec *codec,
10107                                    const struct hda_fixup *fix, int action)
10108 {
10109         struct alc_spec *spec = codec->spec;
10110
10111         alc_fixup_hp_gpio_led(codec, action, 0x01, 0);
10112         if (action == HDA_FIXUP_ACT_PRE_PROBE) {
10113                 spec->mute_led_polarity = 1;
10114                 codec->power_filter = gpio_led_power_filter;
10115         }
10116 }
10117
10118 static void alc662_usi_automute_hook(struct hda_codec *codec,
10119                                          struct hda_jack_callback *jack)
10120 {
10121         struct alc_spec *spec = codec->spec;
10122         int vref;
10123         msleep(200);
10124         snd_hda_gen_hp_automute(codec, jack);
10125
10126         vref = spec->gen.hp_jack_present ? PIN_VREF80 : 0;
10127         msleep(100);
10128         snd_hda_codec_write(codec, 0x19, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
10129                             vref);
10130 }
10131
10132 static void alc662_fixup_usi_headset_mic(struct hda_codec *codec,
10133                                      const struct hda_fixup *fix, int action)
10134 {
10135         struct alc_spec *spec = codec->spec;
10136         if (action == HDA_FIXUP_ACT_PRE_PROBE) {
10137                 spec->parse_flags |= HDA_PINCFG_HEADSET_MIC;
10138                 spec->gen.hp_automute_hook = alc662_usi_automute_hook;
10139         }
10140 }
10141
10142 static void alc662_aspire_ethos_mute_speakers(struct hda_codec *codec,
10143                                         struct hda_jack_callback *cb)
10144 {
10145         /* surround speakers at 0x1b already get muted automatically when
10146          * headphones are plugged in, but we have to mute/unmute the remaining
10147          * channels manually:
10148          * 0x15 - front left/front right
10149          * 0x18 - front center/ LFE
10150          */
10151         if (snd_hda_jack_detect_state(codec, 0x1b) == HDA_JACK_PRESENT) {
10152                 snd_hda_set_pin_ctl_cache(codec, 0x15, 0);
10153                 snd_hda_set_pin_ctl_cache(codec, 0x18, 0);
10154         } else {
10155                 snd_hda_set_pin_ctl_cache(codec, 0x15, PIN_OUT);
10156                 snd_hda_set_pin_ctl_cache(codec, 0x18, PIN_OUT);
10157         }
10158 }
10159
10160 static void alc662_fixup_aspire_ethos_hp(struct hda_codec *codec,
10161                                         const struct hda_fixup *fix, int action)
10162 {
10163     /* Pin 0x1b: shared headphones jack and surround speakers */
10164         if (!is_jack_detectable(codec, 0x1b))
10165                 return;
10166
10167         switch (action) {
10168         case HDA_FIXUP_ACT_PRE_PROBE:
10169                 snd_hda_jack_detect_enable_callback(codec, 0x1b,
10170                                 alc662_aspire_ethos_mute_speakers);
10171                 /* subwoofer needs an extra GPIO setting to become audible */
10172                 alc_setup_gpio(codec, 0x02);
10173                 break;
10174         case HDA_FIXUP_ACT_INIT:
10175                 /* Make sure to start in a correct state, i.e. if
10176                  * headphones have been plugged in before powering up the system
10177                  */
10178                 alc662_aspire_ethos_mute_speakers(codec, NULL);
10179                 break;
10180         }
10181 }
10182
10183 static void alc671_fixup_hp_headset_mic2(struct hda_codec *codec,
10184                                              const struct hda_fixup *fix, int action)
10185 {
10186         struct alc_spec *spec = codec->spec;
10187
10188         static const struct hda_pintbl pincfgs[] = {
10189                 { 0x19, 0x02a11040 }, /* use as headset mic, with its own jack detect */
10190                 { 0x1b, 0x0181304f },
10191                 { }
10192         };
10193
10194         switch (action) {
10195         case HDA_FIXUP_ACT_PRE_PROBE:
10196                 spec->gen.mixer_nid = 0;
10197                 spec->parse_flags |= HDA_PINCFG_HEADSET_MIC;
10198                 snd_hda_apply_pincfgs(codec, pincfgs);
10199                 break;
10200         case HDA_FIXUP_ACT_INIT:
10201                 alc_write_coef_idx(codec, 0x19, 0xa054);
10202                 break;
10203         }
10204 }
10205
10206 static const struct coef_fw alc668_coefs[] = {
10207         WRITE_COEF(0x01, 0xbebe), WRITE_COEF(0x02, 0xaaaa), WRITE_COEF(0x03,    0x0),
10208         WRITE_COEF(0x04, 0x0180), WRITE_COEF(0x06,    0x0), WRITE_COEF(0x07, 0x0f80),
10209         WRITE_COEF(0x08, 0x0031), WRITE_COEF(0x0a, 0x0060), WRITE_COEF(0x0b,    0x0),
10210         WRITE_COEF(0x0c, 0x7cf7), WRITE_COEF(0x0d, 0x1080), WRITE_COEF(0x0e, 0x7f7f),
10211         WRITE_COEF(0x0f, 0xcccc), WRITE_COEF(0x10, 0xddcc), WRITE_COEF(0x11, 0x0001),
10212         WRITE_COEF(0x13,    0x0), WRITE_COEF(0x14, 0x2aa0), WRITE_COEF(0x17, 0xa940),
10213         WRITE_COEF(0x19,    0x0), WRITE_COEF(0x1a,    0x0), WRITE_COEF(0x1b,    0x0),
10214         WRITE_COEF(0x1c,    0x0), WRITE_COEF(0x1d,    0x0), WRITE_COEF(0x1e, 0x7418),
10215         WRITE_COEF(0x1f, 0x0804), WRITE_COEF(0x20, 0x4200), WRITE_COEF(0x21, 0x0468),
10216         WRITE_COEF(0x22, 0x8ccc), WRITE_COEF(0x23, 0x0250), WRITE_COEF(0x24, 0x7418),
10217         WRITE_COEF(0x27,    0x0), WRITE_COEF(0x28, 0x8ccc), WRITE_COEF(0x2a, 0xff00),
10218         WRITE_COEF(0x2b, 0x8000), WRITE_COEF(0xa7, 0xff00), WRITE_COEF(0xa8, 0x8000),
10219         WRITE_COEF(0xaa, 0x2e17), WRITE_COEF(0xab, 0xa0c0), WRITE_COEF(0xac,    0x0),
10220         WRITE_COEF(0xad,    0x0), WRITE_COEF(0xae, 0x2ac6), WRITE_COEF(0xaf, 0xa480),
10221         WRITE_COEF(0xb0,    0x0), WRITE_COEF(0xb1,    0x0), WRITE_COEF(0xb2,    0x0),
10222         WRITE_COEF(0xb3,    0x0), WRITE_COEF(0xb4,    0x0), WRITE_COEF(0xb5, 0x1040),
10223         WRITE_COEF(0xb6, 0xd697), WRITE_COEF(0xb7, 0x902b), WRITE_COEF(0xb8, 0xd697),
10224         WRITE_COEF(0xb9, 0x902b), WRITE_COEF(0xba, 0xb8ba), WRITE_COEF(0xbb, 0xaaab),
10225         WRITE_COEF(0xbc, 0xaaaf), WRITE_COEF(0xbd, 0x6aaa), WRITE_COEF(0xbe, 0x1c02),
10226         WRITE_COEF(0xc0, 0x00ff), WRITE_COEF(0xc1, 0x0fa6),
10227         {}
10228 };
10229
10230 static void alc668_restore_default_value(struct hda_codec *codec)
10231 {
10232         alc_process_coef_fw(codec, alc668_coefs);
10233 }
10234
10235 enum {
10236         ALC662_FIXUP_ASPIRE,
10237         ALC662_FIXUP_LED_GPIO1,
10238         ALC662_FIXUP_IDEAPAD,
10239         ALC272_FIXUP_MARIO,
10240         ALC662_FIXUP_CZC_ET26,
10241         ALC662_FIXUP_CZC_P10T,
10242         ALC662_FIXUP_SKU_IGNORE,
10243         ALC662_FIXUP_HP_RP5800,
10244         ALC662_FIXUP_ASUS_MODE1,
10245         ALC662_FIXUP_ASUS_MODE2,
10246         ALC662_FIXUP_ASUS_MODE3,
10247         ALC662_FIXUP_ASUS_MODE4,
10248         ALC662_FIXUP_ASUS_MODE5,
10249         ALC662_FIXUP_ASUS_MODE6,
10250         ALC662_FIXUP_ASUS_MODE7,
10251         ALC662_FIXUP_ASUS_MODE8,
10252         ALC662_FIXUP_NO_JACK_DETECT,
10253         ALC662_FIXUP_ZOTAC_Z68,
10254         ALC662_FIXUP_INV_DMIC,
10255         ALC662_FIXUP_DELL_MIC_NO_PRESENCE,
10256         ALC668_FIXUP_DELL_MIC_NO_PRESENCE,
10257         ALC662_FIXUP_HEADSET_MODE,
10258         ALC668_FIXUP_HEADSET_MODE,
10259         ALC662_FIXUP_BASS_MODE4_CHMAP,
10260         ALC662_FIXUP_BASS_16,
10261         ALC662_FIXUP_BASS_1A,
10262         ALC662_FIXUP_BASS_CHMAP,
10263         ALC668_FIXUP_AUTO_MUTE,
10264         ALC668_FIXUP_DELL_DISABLE_AAMIX,
10265         ALC668_FIXUP_DELL_XPS13,
10266         ALC662_FIXUP_ASUS_Nx50,
10267         ALC668_FIXUP_ASUS_Nx51_HEADSET_MODE,
10268         ALC668_FIXUP_ASUS_Nx51,
10269         ALC668_FIXUP_MIC_COEF,
10270         ALC668_FIXUP_ASUS_G751,
10271         ALC891_FIXUP_HEADSET_MODE,
10272         ALC891_FIXUP_DELL_MIC_NO_PRESENCE,
10273         ALC662_FIXUP_ACER_VERITON,
10274         ALC892_FIXUP_ASROCK_MOBO,
10275         ALC662_FIXUP_USI_FUNC,
10276         ALC662_FIXUP_USI_HEADSET_MODE,
10277         ALC662_FIXUP_LENOVO_MULTI_CODECS,
10278         ALC669_FIXUP_ACER_ASPIRE_ETHOS,
10279         ALC669_FIXUP_ACER_ASPIRE_ETHOS_HEADSET,
10280         ALC671_FIXUP_HP_HEADSET_MIC2,
10281         ALC662_FIXUP_ACER_X2660G_HEADSET_MODE,
10282         ALC662_FIXUP_ACER_NITRO_HEADSET_MODE,
10283         ALC668_FIXUP_ASUS_NO_HEADSET_MIC,
10284         ALC668_FIXUP_HEADSET_MIC,
10285         ALC668_FIXUP_MIC_DET_COEF,
10286 };
10287
10288 static const struct hda_fixup alc662_fixups[] = {
10289         [ALC662_FIXUP_ASPIRE] = {
10290                 .type = HDA_FIXUP_PINS,
10291                 .v.pins = (const struct hda_pintbl[]) {
10292                         { 0x15, 0x99130112 }, /* subwoofer */
10293                         { }
10294                 }
10295         },
10296         [ALC662_FIXUP_LED_GPIO1] = {
10297                 .type = HDA_FIXUP_FUNC,
10298                 .v.func = alc662_fixup_led_gpio1,
10299         },
10300         [ALC662_FIXUP_IDEAPAD] = {
10301                 .type = HDA_FIXUP_PINS,
10302                 .v.pins = (const struct hda_pintbl[]) {
10303                         { 0x17, 0x99130112 }, /* subwoofer */
10304                         { }
10305                 },
10306                 .chained = true,
10307                 .chain_id = ALC662_FIXUP_LED_GPIO1,
10308         },
10309         [ALC272_FIXUP_MARIO] = {
10310                 .type = HDA_FIXUP_FUNC,
10311                 .v.func = alc272_fixup_mario,
10312         },
10313         [ALC662_FIXUP_CZC_ET26] = {
10314                 .type = HDA_FIXUP_PINS,
10315                 .v.pins = (const struct hda_pintbl[]) {
10316                         {0x12, 0x403cc000},
10317                         {0x14, 0x90170110}, /* speaker */
10318                         {0x15, 0x411111f0},
10319                         {0x16, 0x411111f0},
10320                         {0x18, 0x01a19030}, /* mic */
10321                         {0x19, 0x90a7013f}, /* int-mic */
10322                         {0x1a, 0x01014020},
10323                         {0x1b, 0x0121401f},
10324                         {0x1c, 0x411111f0},
10325                         {0x1d, 0x411111f0},
10326                         {0x1e, 0x40478e35},
10327                         {}
10328                 },
10329                 .chained = true,
10330                 .chain_id = ALC662_FIXUP_SKU_IGNORE
10331         },
10332         [ALC662_FIXUP_CZC_P10T] = {
10333                 .type = HDA_FIXUP_VERBS,
10334                 .v.verbs = (const struct hda_verb[]) {
10335                         {0x14, AC_VERB_SET_EAPD_BTLENABLE, 0},
10336                         {}
10337                 }
10338         },
10339         [ALC662_FIXUP_SKU_IGNORE] = {
10340                 .type = HDA_FIXUP_FUNC,
10341                 .v.func = alc_fixup_sku_ignore,
10342         },
10343         [ALC662_FIXUP_HP_RP5800] = {
10344                 .type = HDA_FIXUP_PINS,
10345                 .v.pins = (const struct hda_pintbl[]) {
10346                         { 0x14, 0x0221201f }, /* HP out */
10347                         { }
10348                 },
10349                 .chained = true,
10350                 .chain_id = ALC662_FIXUP_SKU_IGNORE
10351         },
10352         [ALC662_FIXUP_ASUS_MODE1] = {
10353                 .type = HDA_FIXUP_PINS,
10354                 .v.pins = (const struct hda_pintbl[]) {
10355                         { 0x14, 0x99130110 }, /* speaker */
10356                         { 0x18, 0x01a19c20 }, /* mic */
10357                         { 0x19, 0x99a3092f }, /* int-mic */
10358                         { 0x21, 0x0121401f }, /* HP out */
10359                         { }
10360                 },
10361                 .chained = true,
10362                 .chain_id = ALC662_FIXUP_SKU_IGNORE
10363         },
10364         [ALC662_FIXUP_ASUS_MODE2] = {
10365                 .type = HDA_FIXUP_PINS,
10366                 .v.pins = (const struct hda_pintbl[]) {
10367                         { 0x14, 0x99130110 }, /* speaker */
10368                         { 0x18, 0x01a19820 }, /* mic */
10369                         { 0x19, 0x99a3092f }, /* int-mic */
10370                         { 0x1b, 0x0121401f }, /* HP out */
10371                         { }
10372                 },
10373                 .chained = true,
10374                 .chain_id = ALC662_FIXUP_SKU_IGNORE
10375         },
10376         [ALC662_FIXUP_ASUS_MODE3] = {
10377                 .type = HDA_FIXUP_PINS,
10378                 .v.pins = (const struct hda_pintbl[]) {
10379                         { 0x14, 0x99130110 }, /* speaker */
10380                         { 0x15, 0x0121441f }, /* HP */
10381                         { 0x18, 0x01a19840 }, /* mic */
10382                         { 0x19, 0x99a3094f }, /* int-mic */
10383                         { 0x21, 0x01211420 }, /* HP2 */
10384                         { }
10385                 },
10386                 .chained = true,
10387                 .chain_id = ALC662_FIXUP_SKU_IGNORE
10388         },
10389         [ALC662_FIXUP_ASUS_MODE4] = {
10390                 .type = HDA_FIXUP_PINS,
10391                 .v.pins = (const struct hda_pintbl[]) {
10392                         { 0x14, 0x99130110 }, /* speaker */
10393                         { 0x16, 0x99130111 }, /* speaker */
10394                         { 0x18, 0x01a19840 }, /* mic */
10395                         { 0x19, 0x99a3094f }, /* int-mic */
10396                         { 0x21, 0x0121441f }, /* HP */
10397                         { }
10398                 },
10399                 .chained = true,
10400                 .chain_id = ALC662_FIXUP_SKU_IGNORE
10401         },
10402         [ALC662_FIXUP_ASUS_MODE5] = {
10403                 .type = HDA_FIXUP_PINS,
10404                 .v.pins = (const struct hda_pintbl[]) {
10405                         { 0x14, 0x99130110 }, /* speaker */
10406                         { 0x15, 0x0121441f }, /* HP */
10407                         { 0x16, 0x99130111 }, /* speaker */
10408                         { 0x18, 0x01a19840 }, /* mic */
10409                         { 0x19, 0x99a3094f }, /* int-mic */
10410                         { }
10411                 },
10412                 .chained = true,
10413                 .chain_id = ALC662_FIXUP_SKU_IGNORE
10414         },
10415         [ALC662_FIXUP_ASUS_MODE6] = {
10416                 .type = HDA_FIXUP_PINS,
10417                 .v.pins = (const struct hda_pintbl[]) {
10418                         { 0x14, 0x99130110 }, /* speaker */
10419                         { 0x15, 0x01211420 }, /* HP2 */
10420                         { 0x18, 0x01a19840 }, /* mic */
10421                         { 0x19, 0x99a3094f }, /* int-mic */
10422                         { 0x1b, 0x0121441f }, /* HP */
10423                         { }
10424                 },
10425                 .chained = true,
10426                 .chain_id = ALC662_FIXUP_SKU_IGNORE
10427         },
10428         [ALC662_FIXUP_ASUS_MODE7] = {
10429                 .type = HDA_FIXUP_PINS,
10430                 .v.pins = (const struct hda_pintbl[]) {
10431                         { 0x14, 0x99130110 }, /* speaker */
10432                         { 0x17, 0x99130111 }, /* speaker */
10433                         { 0x18, 0x01a19840 }, /* mic */
10434                         { 0x19, 0x99a3094f }, /* int-mic */
10435                         { 0x1b, 0x01214020 }, /* HP */
10436                         { 0x21, 0x0121401f }, /* HP */
10437                         { }
10438                 },
10439                 .chained = true,
10440                 .chain_id = ALC662_FIXUP_SKU_IGNORE
10441         },
10442         [ALC662_FIXUP_ASUS_MODE8] = {
10443                 .type = HDA_FIXUP_PINS,
10444                 .v.pins = (const struct hda_pintbl[]) {
10445                         { 0x14, 0x99130110 }, /* speaker */
10446                         { 0x12, 0x99a30970 }, /* int-mic */
10447                         { 0x15, 0x01214020 }, /* HP */
10448                         { 0x17, 0x99130111 }, /* speaker */
10449                         { 0x18, 0x01a19840 }, /* mic */
10450                         { 0x21, 0x0121401f }, /* HP */
10451                         { }
10452                 },
10453                 .chained = true,
10454                 .chain_id = ALC662_FIXUP_SKU_IGNORE
10455         },
10456         [ALC662_FIXUP_NO_JACK_DETECT] = {
10457                 .type = HDA_FIXUP_FUNC,
10458                 .v.func = alc_fixup_no_jack_detect,
10459         },
10460         [ALC662_FIXUP_ZOTAC_Z68] = {
10461                 .type = HDA_FIXUP_PINS,
10462                 .v.pins = (const struct hda_pintbl[]) {
10463                         { 0x1b, 0x02214020 }, /* Front HP */
10464                         { }
10465                 }
10466         },
10467         [ALC662_FIXUP_INV_DMIC] = {
10468                 .type = HDA_FIXUP_FUNC,
10469                 .v.func = alc_fixup_inv_dmic,
10470         },
10471         [ALC668_FIXUP_DELL_XPS13] = {
10472                 .type = HDA_FIXUP_FUNC,
10473                 .v.func = alc_fixup_dell_xps13,
10474                 .chained = true,
10475                 .chain_id = ALC668_FIXUP_DELL_DISABLE_AAMIX
10476         },
10477         [ALC668_FIXUP_DELL_DISABLE_AAMIX] = {
10478                 .type = HDA_FIXUP_FUNC,
10479                 .v.func = alc_fixup_disable_aamix,
10480                 .chained = true,
10481                 .chain_id = ALC668_FIXUP_DELL_MIC_NO_PRESENCE
10482         },
10483         [ALC668_FIXUP_AUTO_MUTE] = {
10484                 .type = HDA_FIXUP_FUNC,
10485                 .v.func = alc_fixup_auto_mute_via_amp,
10486                 .chained = true,
10487                 .chain_id = ALC668_FIXUP_DELL_MIC_NO_PRESENCE
10488         },
10489         [ALC662_FIXUP_DELL_MIC_NO_PRESENCE] = {
10490                 .type = HDA_FIXUP_PINS,
10491                 .v.pins = (const struct hda_pintbl[]) {
10492                         { 0x19, 0x03a1113c }, /* use as headset mic, without its own jack detect */
10493                         /* headphone mic by setting pin control of 0x1b (headphone out) to in + vref_50 */
10494                         { }
10495                 },
10496                 .chained = true,
10497                 .chain_id = ALC662_FIXUP_HEADSET_MODE
10498         },
10499         [ALC662_FIXUP_HEADSET_MODE] = {
10500                 .type = HDA_FIXUP_FUNC,
10501                 .v.func = alc_fixup_headset_mode_alc662,
10502         },
10503         [ALC668_FIXUP_DELL_MIC_NO_PRESENCE] = {
10504                 .type = HDA_FIXUP_PINS,
10505                 .v.pins = (const struct hda_pintbl[]) {
10506                         { 0x19, 0x03a1913d }, /* use as headphone mic, without its own jack detect */
10507                         { 0x1b, 0x03a1113c }, /* use as headset mic, without its own jack detect */
10508                         { }
10509                 },
10510                 .chained = true,
10511                 .chain_id = ALC668_FIXUP_HEADSET_MODE
10512         },
10513         [ALC668_FIXUP_HEADSET_MODE] = {
10514                 .type = HDA_FIXUP_FUNC,
10515                 .v.func = alc_fixup_headset_mode_alc668,
10516         },
10517         [ALC662_FIXUP_BASS_MODE4_CHMAP] = {
10518                 .type = HDA_FIXUP_FUNC,
10519                 .v.func = alc_fixup_bass_chmap,
10520                 .chained = true,
10521                 .chain_id = ALC662_FIXUP_ASUS_MODE4
10522         },
10523         [ALC662_FIXUP_BASS_16] = {
10524                 .type = HDA_FIXUP_PINS,
10525                 .v.pins = (const struct hda_pintbl[]) {
10526                         {0x16, 0x80106111}, /* bass speaker */
10527                         {}
10528                 },
10529                 .chained = true,
10530                 .chain_id = ALC662_FIXUP_BASS_CHMAP,
10531         },
10532         [ALC662_FIXUP_BASS_1A] = {
10533                 .type = HDA_FIXUP_PINS,
10534                 .v.pins = (const struct hda_pintbl[]) {
10535                         {0x1a, 0x80106111}, /* bass speaker */
10536                         {}
10537                 },
10538                 .chained = true,
10539                 .chain_id = ALC662_FIXUP_BASS_CHMAP,
10540         },
10541         [ALC662_FIXUP_BASS_CHMAP] = {
10542                 .type = HDA_FIXUP_FUNC,
10543                 .v.func = alc_fixup_bass_chmap,
10544         },
10545         [ALC662_FIXUP_ASUS_Nx50] = {
10546                 .type = HDA_FIXUP_FUNC,
10547                 .v.func = alc_fixup_auto_mute_via_amp,
10548                 .chained = true,
10549                 .chain_id = ALC662_FIXUP_BASS_1A
10550         },
10551         [ALC668_FIXUP_ASUS_Nx51_HEADSET_MODE] = {
10552                 .type = HDA_FIXUP_FUNC,
10553                 .v.func = alc_fixup_headset_mode_alc668,
10554                 .chain_id = ALC662_FIXUP_BASS_CHMAP
10555         },
10556         [ALC668_FIXUP_ASUS_Nx51] = {
10557                 .type = HDA_FIXUP_PINS,
10558                 .v.pins = (const struct hda_pintbl[]) {
10559                         { 0x19, 0x03a1913d }, /* use as headphone mic, without its own jack detect */
10560                         { 0x1a, 0x90170151 }, /* bass speaker */
10561                         { 0x1b, 0x03a1113c }, /* use as headset mic, without its own jack detect */
10562                         {}
10563                 },
10564                 .chained = true,
10565                 .chain_id = ALC668_FIXUP_ASUS_Nx51_HEADSET_MODE,
10566         },
10567         [ALC668_FIXUP_MIC_COEF] = {
10568                 .type = HDA_FIXUP_VERBS,
10569                 .v.verbs = (const struct hda_verb[]) {
10570                         { 0x20, AC_VERB_SET_COEF_INDEX, 0xc3 },
10571                         { 0x20, AC_VERB_SET_PROC_COEF, 0x4000 },
10572                         {}
10573                 },
10574         },
10575         [ALC668_FIXUP_ASUS_G751] = {
10576                 .type = HDA_FIXUP_PINS,
10577                 .v.pins = (const struct hda_pintbl[]) {
10578                         { 0x16, 0x0421101f }, /* HP */
10579                         {}
10580                 },
10581                 .chained = true,
10582                 .chain_id = ALC668_FIXUP_MIC_COEF
10583         },
10584         [ALC891_FIXUP_HEADSET_MODE] = {
10585                 .type = HDA_FIXUP_FUNC,
10586                 .v.func = alc_fixup_headset_mode,
10587         },
10588         [ALC891_FIXUP_DELL_MIC_NO_PRESENCE] = {
10589                 .type = HDA_FIXUP_PINS,
10590                 .v.pins = (const struct hda_pintbl[]) {
10591                         { 0x19, 0x03a1913d }, /* use as headphone mic, without its own jack detect */
10592                         { 0x1b, 0x03a1113c }, /* use as headset mic, without its own jack detect */
10593                         { }
10594                 },
10595                 .chained = true,
10596                 .chain_id = ALC891_FIXUP_HEADSET_MODE
10597         },
10598         [ALC662_FIXUP_ACER_VERITON] = {
10599                 .type = HDA_FIXUP_PINS,
10600                 .v.pins = (const struct hda_pintbl[]) {
10601                         { 0x15, 0x50170120 }, /* no internal speaker */
10602                         { }
10603                 }
10604         },
10605         [ALC892_FIXUP_ASROCK_MOBO] = {
10606                 .type = HDA_FIXUP_PINS,
10607                 .v.pins = (const struct hda_pintbl[]) {
10608                         { 0x15, 0x40f000f0 }, /* disabled */
10609                         { 0x16, 0x40f000f0 }, /* disabled */
10610                         { }
10611                 }
10612         },
10613         [ALC662_FIXUP_USI_FUNC] = {
10614                 .type = HDA_FIXUP_FUNC,
10615                 .v.func = alc662_fixup_usi_headset_mic,
10616         },
10617         [ALC662_FIXUP_USI_HEADSET_MODE] = {
10618                 .type = HDA_FIXUP_PINS,
10619                 .v.pins = (const struct hda_pintbl[]) {
10620                         { 0x19, 0x02a1913c }, /* use as headset mic, without its own jack detect */
10621                         { 0x18, 0x01a1903d },
10622                         { }
10623                 },
10624                 .chained = true,
10625                 .chain_id = ALC662_FIXUP_USI_FUNC
10626         },
10627         [ALC662_FIXUP_LENOVO_MULTI_CODECS] = {
10628                 .type = HDA_FIXUP_FUNC,
10629                 .v.func = alc233_alc662_fixup_lenovo_dual_codecs,
10630         },
10631         [ALC669_FIXUP_ACER_ASPIRE_ETHOS_HEADSET] = {
10632                 .type = HDA_FIXUP_FUNC,
10633                 .v.func = alc662_fixup_aspire_ethos_hp,
10634         },
10635         [ALC669_FIXUP_ACER_ASPIRE_ETHOS] = {
10636                 .type = HDA_FIXUP_PINS,
10637                 .v.pins = (const struct hda_pintbl[]) {
10638                         { 0x15, 0x92130110 }, /* front speakers */
10639                         { 0x18, 0x99130111 }, /* center/subwoofer */
10640                         { 0x1b, 0x11130012 }, /* surround plus jack for HP */
10641                         { }
10642                 },
10643                 .chained = true,
10644                 .chain_id = ALC669_FIXUP_ACER_ASPIRE_ETHOS_HEADSET
10645         },
10646         [ALC671_FIXUP_HP_HEADSET_MIC2] = {
10647                 .type = HDA_FIXUP_FUNC,
10648                 .v.func = alc671_fixup_hp_headset_mic2,
10649         },
10650         [ALC662_FIXUP_ACER_X2660G_HEADSET_MODE] = {
10651                 .type = HDA_FIXUP_PINS,
10652                 .v.pins = (const struct hda_pintbl[]) {
10653                         { 0x1a, 0x02a1113c }, /* use as headset mic, without its own jack detect */
10654                         { }
10655                 },
10656                 .chained = true,
10657                 .chain_id = ALC662_FIXUP_USI_FUNC
10658         },
10659         [ALC662_FIXUP_ACER_NITRO_HEADSET_MODE] = {
10660                 .type = HDA_FIXUP_PINS,
10661                 .v.pins = (const struct hda_pintbl[]) {
10662                         { 0x1a, 0x01a11140 }, /* use as headset mic, without its own jack detect */
10663                         { 0x1b, 0x0221144f },
10664                         { }
10665                 },
10666                 .chained = true,
10667                 .chain_id = ALC662_FIXUP_USI_FUNC
10668         },
10669         [ALC668_FIXUP_ASUS_NO_HEADSET_MIC] = {
10670                 .type = HDA_FIXUP_PINS,
10671                 .v.pins = (const struct hda_pintbl[]) {
10672                         { 0x1b, 0x04a1112c },
10673                         { }
10674                 },
10675                 .chained = true,
10676                 .chain_id = ALC668_FIXUP_HEADSET_MIC
10677         },
10678         [ALC668_FIXUP_HEADSET_MIC] = {
10679                 .type = HDA_FIXUP_FUNC,
10680                 .v.func = alc269_fixup_headset_mic,
10681                 .chained = true,
10682                 .chain_id = ALC668_FIXUP_MIC_DET_COEF
10683         },
10684         [ALC668_FIXUP_MIC_DET_COEF] = {
10685                 .type = HDA_FIXUP_VERBS,
10686                 .v.verbs = (const struct hda_verb[]) {
10687                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x15 },
10688                         { 0x20, AC_VERB_SET_PROC_COEF, 0x0d60 },
10689                         {}
10690                 },
10691         },
10692 };
10693
10694 static const struct snd_pci_quirk alc662_fixup_tbl[] = {
10695         SND_PCI_QUIRK(0x1019, 0x9087, "ECS", ALC662_FIXUP_ASUS_MODE2),
10696         SND_PCI_QUIRK(0x1025, 0x022f, "Acer Aspire One", ALC662_FIXUP_INV_DMIC),
10697         SND_PCI_QUIRK(0x1025, 0x0241, "Packard Bell DOTS", ALC662_FIXUP_INV_DMIC),
10698         SND_PCI_QUIRK(0x1025, 0x0308, "Acer Aspire 8942G", ALC662_FIXUP_ASPIRE),
10699         SND_PCI_QUIRK(0x1025, 0x031c, "Gateway NV79", ALC662_FIXUP_SKU_IGNORE),
10700         SND_PCI_QUIRK(0x1025, 0x0349, "eMachines eM250", ALC662_FIXUP_INV_DMIC),
10701         SND_PCI_QUIRK(0x1025, 0x034a, "Gateway LT27", ALC662_FIXUP_INV_DMIC),
10702         SND_PCI_QUIRK(0x1025, 0x038b, "Acer Aspire 8943G", ALC662_FIXUP_ASPIRE),
10703         SND_PCI_QUIRK(0x1025, 0x0566, "Acer Aspire Ethos 8951G", ALC669_FIXUP_ACER_ASPIRE_ETHOS),
10704         SND_PCI_QUIRK(0x1025, 0x123c, "Acer Nitro N50-600", ALC662_FIXUP_ACER_NITRO_HEADSET_MODE),
10705         SND_PCI_QUIRK(0x1025, 0x124e, "Acer 2660G", ALC662_FIXUP_ACER_X2660G_HEADSET_MODE),
10706         SND_PCI_QUIRK(0x1028, 0x05d8, "Dell", ALC668_FIXUP_DELL_MIC_NO_PRESENCE),
10707         SND_PCI_QUIRK(0x1028, 0x05db, "Dell", ALC668_FIXUP_DELL_MIC_NO_PRESENCE),
10708         SND_PCI_QUIRK(0x1028, 0x05fe, "Dell XPS 15", ALC668_FIXUP_DELL_XPS13),
10709         SND_PCI_QUIRK(0x1028, 0x060a, "Dell XPS 13", ALC668_FIXUP_DELL_XPS13),
10710         SND_PCI_QUIRK(0x1028, 0x060d, "Dell M3800", ALC668_FIXUP_DELL_XPS13),
10711         SND_PCI_QUIRK(0x1028, 0x0625, "Dell", ALC668_FIXUP_DELL_MIC_NO_PRESENCE),
10712         SND_PCI_QUIRK(0x1028, 0x0626, "Dell", ALC668_FIXUP_DELL_MIC_NO_PRESENCE),
10713         SND_PCI_QUIRK(0x1028, 0x0696, "Dell", ALC668_FIXUP_DELL_MIC_NO_PRESENCE),
10714         SND_PCI_QUIRK(0x1028, 0x0698, "Dell", ALC668_FIXUP_DELL_MIC_NO_PRESENCE),
10715         SND_PCI_QUIRK(0x1028, 0x069f, "Dell", ALC668_FIXUP_DELL_MIC_NO_PRESENCE),
10716         SND_PCI_QUIRK(0x103c, 0x1632, "HP RP5800", ALC662_FIXUP_HP_RP5800),
10717         SND_PCI_QUIRK(0x103c, 0x873e, "HP", ALC671_FIXUP_HP_HEADSET_MIC2),
10718         SND_PCI_QUIRK(0x1043, 0x1080, "Asus UX501VW", ALC668_FIXUP_HEADSET_MODE),
10719         SND_PCI_QUIRK(0x1043, 0x11cd, "Asus N550", ALC662_FIXUP_ASUS_Nx50),
10720         SND_PCI_QUIRK(0x1043, 0x129d, "Asus N750", ALC662_FIXUP_ASUS_Nx50),
10721         SND_PCI_QUIRK(0x1043, 0x12ff, "ASUS G751", ALC668_FIXUP_ASUS_G751),
10722         SND_PCI_QUIRK(0x1043, 0x13df, "Asus N550JX", ALC662_FIXUP_BASS_1A),
10723         SND_PCI_QUIRK(0x1043, 0x1477, "ASUS N56VZ", ALC662_FIXUP_BASS_MODE4_CHMAP),
10724         SND_PCI_QUIRK(0x1043, 0x15a7, "ASUS UX51VZH", ALC662_FIXUP_BASS_16),
10725         SND_PCI_QUIRK(0x1043, 0x177d, "ASUS N551", ALC668_FIXUP_ASUS_Nx51),
10726         SND_PCI_QUIRK(0x1043, 0x17bd, "ASUS N751", ALC668_FIXUP_ASUS_Nx51),
10727         SND_PCI_QUIRK(0x1043, 0x185d, "ASUS G551JW", ALC668_FIXUP_ASUS_NO_HEADSET_MIC),
10728         SND_PCI_QUIRK(0x1043, 0x1963, "ASUS X71SL", ALC662_FIXUP_ASUS_MODE8),
10729         SND_PCI_QUIRK(0x1043, 0x1b73, "ASUS N55SF", ALC662_FIXUP_BASS_16),
10730         SND_PCI_QUIRK(0x1043, 0x1bf3, "ASUS N76VZ", ALC662_FIXUP_BASS_MODE4_CHMAP),
10731         SND_PCI_QUIRK(0x1043, 0x8469, "ASUS mobo", ALC662_FIXUP_NO_JACK_DETECT),
10732         SND_PCI_QUIRK(0x105b, 0x0cd6, "Foxconn", ALC662_FIXUP_ASUS_MODE2),
10733         SND_PCI_QUIRK(0x144d, 0xc051, "Samsung R720", ALC662_FIXUP_IDEAPAD),
10734         SND_PCI_QUIRK(0x14cd, 0x5003, "USI", ALC662_FIXUP_USI_HEADSET_MODE),
10735         SND_PCI_QUIRK(0x17aa, 0x1036, "Lenovo P520", ALC662_FIXUP_LENOVO_MULTI_CODECS),
10736         SND_PCI_QUIRK(0x17aa, 0x38af, "Lenovo Ideapad Y550P", ALC662_FIXUP_IDEAPAD),
10737         SND_PCI_QUIRK(0x17aa, 0x3a0d, "Lenovo Ideapad Y550", ALC662_FIXUP_IDEAPAD),
10738         SND_PCI_QUIRK(0x1849, 0x5892, "ASRock B150M", ALC892_FIXUP_ASROCK_MOBO),
10739         SND_PCI_QUIRK(0x19da, 0xa130, "Zotac Z68", ALC662_FIXUP_ZOTAC_Z68),
10740         SND_PCI_QUIRK(0x1b0a, 0x01b8, "ACER Veriton", ALC662_FIXUP_ACER_VERITON),
10741         SND_PCI_QUIRK(0x1b35, 0x1234, "CZC ET26", ALC662_FIXUP_CZC_ET26),
10742         SND_PCI_QUIRK(0x1b35, 0x2206, "CZC P10T", ALC662_FIXUP_CZC_P10T),
10743
10744 #if 0
10745         /* Below is a quirk table taken from the old code.
10746          * Basically the device should work as is without the fixup table.
10747          * If BIOS doesn't give a proper info, enable the corresponding
10748          * fixup entry.
10749          */
10750         SND_PCI_QUIRK(0x1043, 0x1000, "ASUS N50Vm", ALC662_FIXUP_ASUS_MODE1),
10751         SND_PCI_QUIRK(0x1043, 0x1092, "ASUS NB", ALC662_FIXUP_ASUS_MODE3),
10752         SND_PCI_QUIRK(0x1043, 0x1173, "ASUS K73Jn", ALC662_FIXUP_ASUS_MODE1),
10753         SND_PCI_QUIRK(0x1043, 0x11c3, "ASUS M70V", ALC662_FIXUP_ASUS_MODE3),
10754         SND_PCI_QUIRK(0x1043, 0x11d3, "ASUS NB", ALC662_FIXUP_ASUS_MODE1),
10755         SND_PCI_QUIRK(0x1043, 0x11f3, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),
10756         SND_PCI_QUIRK(0x1043, 0x1203, "ASUS NB", ALC662_FIXUP_ASUS_MODE1),
10757         SND_PCI_QUIRK(0x1043, 0x1303, "ASUS G60J", ALC662_FIXUP_ASUS_MODE1),
10758         SND_PCI_QUIRK(0x1043, 0x1333, "ASUS G60Jx", ALC662_FIXUP_ASUS_MODE1),
10759         SND_PCI_QUIRK(0x1043, 0x1339, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),
10760         SND_PCI_QUIRK(0x1043, 0x13e3, "ASUS N71JA", ALC662_FIXUP_ASUS_MODE7),
10761         SND_PCI_QUIRK(0x1043, 0x1463, "ASUS N71", ALC662_FIXUP_ASUS_MODE7),
10762         SND_PCI_QUIRK(0x1043, 0x14d3, "ASUS G72", ALC662_FIXUP_ASUS_MODE8),
10763         SND_PCI_QUIRK(0x1043, 0x1563, "ASUS N90", ALC662_FIXUP_ASUS_MODE3),
10764         SND_PCI_QUIRK(0x1043, 0x15d3, "ASUS N50SF F50SF", ALC662_FIXUP_ASUS_MODE1),
10765         SND_PCI_QUIRK(0x1043, 0x16c3, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),
10766         SND_PCI_QUIRK(0x1043, 0x16f3, "ASUS K40C K50C", ALC662_FIXUP_ASUS_MODE2),
10767         SND_PCI_QUIRK(0x1043, 0x1733, "ASUS N81De", ALC662_FIXUP_ASUS_MODE1),
10768         SND_PCI_QUIRK(0x1043, 0x1753, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),
10769         SND_PCI_QUIRK(0x1043, 0x1763, "ASUS NB", ALC662_FIXUP_ASUS_MODE6),
10770         SND_PCI_QUIRK(0x1043, 0x1765, "ASUS NB", ALC662_FIXUP_ASUS_MODE6),
10771         SND_PCI_QUIRK(0x1043, 0x1783, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),
10772         SND_PCI_QUIRK(0x1043, 0x1793, "ASUS F50GX", ALC662_FIXUP_ASUS_MODE1),
10773         SND_PCI_QUIRK(0x1043, 0x17b3, "ASUS F70SL", ALC662_FIXUP_ASUS_MODE3),
10774         SND_PCI_QUIRK(0x1043, 0x17f3, "ASUS X58LE", ALC662_FIXUP_ASUS_MODE2),
10775         SND_PCI_QUIRK(0x1043, 0x1813, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),
10776         SND_PCI_QUIRK(0x1043, 0x1823, "ASUS NB", ALC662_FIXUP_ASUS_MODE5),
10777         SND_PCI_QUIRK(0x1043, 0x1833, "ASUS NB", ALC662_FIXUP_ASUS_MODE6),
10778         SND_PCI_QUIRK(0x1043, 0x1843, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),
10779         SND_PCI_QUIRK(0x1043, 0x1853, "ASUS F50Z", ALC662_FIXUP_ASUS_MODE1),
10780         SND_PCI_QUIRK(0x1043, 0x1864, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),
10781         SND_PCI_QUIRK(0x1043, 0x1876, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),
10782         SND_PCI_QUIRK(0x1043, 0x1893, "ASUS M50Vm", ALC662_FIXUP_ASUS_MODE3),
10783         SND_PCI_QUIRK(0x1043, 0x1894, "ASUS X55", ALC662_FIXUP_ASUS_MODE3),
10784         SND_PCI_QUIRK(0x1043, 0x18b3, "ASUS N80Vc", ALC662_FIXUP_ASUS_MODE1),
10785         SND_PCI_QUIRK(0x1043, 0x18c3, "ASUS VX5", ALC662_FIXUP_ASUS_MODE1),
10786         SND_PCI_QUIRK(0x1043, 0x18d3, "ASUS N81Te", ALC662_FIXUP_ASUS_MODE1),
10787         SND_PCI_QUIRK(0x1043, 0x18f3, "ASUS N505Tp", ALC662_FIXUP_ASUS_MODE1),
10788         SND_PCI_QUIRK(0x1043, 0x1903, "ASUS F5GL", ALC662_FIXUP_ASUS_MODE1),
10789         SND_PCI_QUIRK(0x1043, 0x1913, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),
10790         SND_PCI_QUIRK(0x1043, 0x1933, "ASUS F80Q", ALC662_FIXUP_ASUS_MODE2),
10791         SND_PCI_QUIRK(0x1043, 0x1943, "ASUS Vx3V", ALC662_FIXUP_ASUS_MODE1),
10792         SND_PCI_QUIRK(0x1043, 0x1953, "ASUS NB", ALC662_FIXUP_ASUS_MODE1),
10793         SND_PCI_QUIRK(0x1043, 0x1963, "ASUS X71C", ALC662_FIXUP_ASUS_MODE3),
10794         SND_PCI_QUIRK(0x1043, 0x1983, "ASUS N5051A", ALC662_FIXUP_ASUS_MODE1),
10795         SND_PCI_QUIRK(0x1043, 0x1993, "ASUS N20", ALC662_FIXUP_ASUS_MODE1),
10796         SND_PCI_QUIRK(0x1043, 0x19b3, "ASUS F7Z", ALC662_FIXUP_ASUS_MODE1),
10797         SND_PCI_QUIRK(0x1043, 0x19c3, "ASUS F5Z/F6x", ALC662_FIXUP_ASUS_MODE2),
10798         SND_PCI_QUIRK(0x1043, 0x19e3, "ASUS NB", ALC662_FIXUP_ASUS_MODE1),
10799         SND_PCI_QUIRK(0x1043, 0x19f3, "ASUS NB", ALC662_FIXUP_ASUS_MODE4),
10800 #endif
10801         {}
10802 };
10803
10804 static const struct hda_model_fixup alc662_fixup_models[] = {
10805         {.id = ALC662_FIXUP_ASPIRE, .name = "aspire"},
10806         {.id = ALC662_FIXUP_IDEAPAD, .name = "ideapad"},
10807         {.id = ALC272_FIXUP_MARIO, .name = "mario"},
10808         {.id = ALC662_FIXUP_HP_RP5800, .name = "hp-rp5800"},
10809         {.id = ALC662_FIXUP_ASUS_MODE1, .name = "asus-mode1"},
10810         {.id = ALC662_FIXUP_ASUS_MODE2, .name = "asus-mode2"},
10811         {.id = ALC662_FIXUP_ASUS_MODE3, .name = "asus-mode3"},
10812         {.id = ALC662_FIXUP_ASUS_MODE4, .name = "asus-mode4"},
10813         {.id = ALC662_FIXUP_ASUS_MODE5, .name = "asus-mode5"},
10814         {.id = ALC662_FIXUP_ASUS_MODE6, .name = "asus-mode6"},
10815         {.id = ALC662_FIXUP_ASUS_MODE7, .name = "asus-mode7"},
10816         {.id = ALC662_FIXUP_ASUS_MODE8, .name = "asus-mode8"},
10817         {.id = ALC662_FIXUP_ZOTAC_Z68, .name = "zotac-z68"},
10818         {.id = ALC662_FIXUP_INV_DMIC, .name = "inv-dmic"},
10819         {.id = ALC662_FIXUP_DELL_MIC_NO_PRESENCE, .name = "alc662-headset-multi"},
10820         {.id = ALC668_FIXUP_DELL_MIC_NO_PRESENCE, .name = "dell-headset-multi"},
10821         {.id = ALC662_FIXUP_HEADSET_MODE, .name = "alc662-headset"},
10822         {.id = ALC668_FIXUP_HEADSET_MODE, .name = "alc668-headset"},
10823         {.id = ALC662_FIXUP_BASS_16, .name = "bass16"},
10824         {.id = ALC662_FIXUP_BASS_1A, .name = "bass1a"},
10825         {.id = ALC668_FIXUP_AUTO_MUTE, .name = "automute"},
10826         {.id = ALC668_FIXUP_DELL_XPS13, .name = "dell-xps13"},
10827         {.id = ALC662_FIXUP_ASUS_Nx50, .name = "asus-nx50"},
10828         {.id = ALC668_FIXUP_ASUS_Nx51, .name = "asus-nx51"},
10829         {.id = ALC668_FIXUP_ASUS_G751, .name = "asus-g751"},
10830         {.id = ALC891_FIXUP_HEADSET_MODE, .name = "alc891-headset"},
10831         {.id = ALC891_FIXUP_DELL_MIC_NO_PRESENCE, .name = "alc891-headset-multi"},
10832         {.id = ALC662_FIXUP_ACER_VERITON, .name = "acer-veriton"},
10833         {.id = ALC892_FIXUP_ASROCK_MOBO, .name = "asrock-mobo"},
10834         {.id = ALC662_FIXUP_USI_HEADSET_MODE, .name = "usi-headset"},
10835         {.id = ALC662_FIXUP_LENOVO_MULTI_CODECS, .name = "dual-codecs"},
10836         {.id = ALC669_FIXUP_ACER_ASPIRE_ETHOS, .name = "aspire-ethos"},
10837         {}
10838 };
10839
10840 static const struct snd_hda_pin_quirk alc662_pin_fixup_tbl[] = {
10841         SND_HDA_PIN_QUIRK(0x10ec0867, 0x1028, "Dell", ALC891_FIXUP_DELL_MIC_NO_PRESENCE,
10842                 {0x17, 0x02211010},
10843                 {0x18, 0x01a19030},
10844                 {0x1a, 0x01813040},
10845                 {0x21, 0x01014020}),
10846         SND_HDA_PIN_QUIRK(0x10ec0867, 0x1028, "Dell", ALC891_FIXUP_DELL_MIC_NO_PRESENCE,
10847                 {0x16, 0x01813030},
10848                 {0x17, 0x02211010},
10849                 {0x18, 0x01a19040},
10850                 {0x21, 0x01014020}),
10851         SND_HDA_PIN_QUIRK(0x10ec0662, 0x1028, "Dell", ALC662_FIXUP_DELL_MIC_NO_PRESENCE,
10852                 {0x14, 0x01014010},
10853                 {0x18, 0x01a19020},
10854                 {0x1a, 0x0181302f},
10855                 {0x1b, 0x0221401f}),
10856         SND_HDA_PIN_QUIRK(0x10ec0668, 0x1028, "Dell", ALC668_FIXUP_AUTO_MUTE,
10857                 {0x12, 0x99a30130},
10858                 {0x14, 0x90170110},
10859                 {0x15, 0x0321101f},
10860                 {0x16, 0x03011020}),
10861         SND_HDA_PIN_QUIRK(0x10ec0668, 0x1028, "Dell", ALC668_FIXUP_AUTO_MUTE,
10862                 {0x12, 0x99a30140},
10863                 {0x14, 0x90170110},
10864                 {0x15, 0x0321101f},
10865                 {0x16, 0x03011020}),
10866         SND_HDA_PIN_QUIRK(0x10ec0668, 0x1028, "Dell", ALC668_FIXUP_AUTO_MUTE,
10867                 {0x12, 0x99a30150},
10868                 {0x14, 0x90170110},
10869                 {0x15, 0x0321101f},
10870                 {0x16, 0x03011020}),
10871         SND_HDA_PIN_QUIRK(0x10ec0668, 0x1028, "Dell", ALC668_FIXUP_AUTO_MUTE,
10872                 {0x14, 0x90170110},
10873                 {0x15, 0x0321101f},
10874                 {0x16, 0x03011020}),
10875         SND_HDA_PIN_QUIRK(0x10ec0668, 0x1028, "Dell XPS 15", ALC668_FIXUP_AUTO_MUTE,
10876                 {0x12, 0x90a60130},
10877                 {0x14, 0x90170110},
10878                 {0x15, 0x0321101f}),
10879         SND_HDA_PIN_QUIRK(0x10ec0671, 0x103c, "HP cPC", ALC671_FIXUP_HP_HEADSET_MIC2,
10880                 {0x14, 0x01014010},
10881                 {0x17, 0x90170150},
10882                 {0x19, 0x02a11060},
10883                 {0x1b, 0x01813030},
10884                 {0x21, 0x02211020}),
10885         SND_HDA_PIN_QUIRK(0x10ec0671, 0x103c, "HP cPC", ALC671_FIXUP_HP_HEADSET_MIC2,
10886                 {0x14, 0x01014010},
10887                 {0x18, 0x01a19040},
10888                 {0x1b, 0x01813030},
10889                 {0x21, 0x02211020}),
10890         SND_HDA_PIN_QUIRK(0x10ec0671, 0x103c, "HP cPC", ALC671_FIXUP_HP_HEADSET_MIC2,
10891                 {0x14, 0x01014020},
10892                 {0x17, 0x90170110},
10893                 {0x18, 0x01a19050},
10894                 {0x1b, 0x01813040},
10895                 {0x21, 0x02211030}),
10896         {}
10897 };
10898
10899 /*
10900  */
10901 static int patch_alc662(struct hda_codec *codec)
10902 {
10903         struct alc_spec *spec;
10904         int err;
10905
10906         err = alc_alloc_spec(codec, 0x0b);
10907         if (err < 0)
10908                 return err;
10909
10910         spec = codec->spec;
10911
10912         spec->shutup = alc_eapd_shutup;
10913
10914         /* handle multiple HPs as is */
10915         spec->parse_flags = HDA_PINCFG_NO_HP_FIXUP;
10916
10917         alc_fix_pll_init(codec, 0x20, 0x04, 15);
10918
10919         switch (codec->core.vendor_id) {
10920         case 0x10ec0668:
10921                 spec->init_hook = alc668_restore_default_value;
10922                 break;
10923         }
10924
10925         alc_pre_init(codec);
10926
10927         snd_hda_pick_fixup(codec, alc662_fixup_models,
10928                        alc662_fixup_tbl, alc662_fixups);
10929         snd_hda_pick_pin_fixup(codec, alc662_pin_fixup_tbl, alc662_fixups, true);
10930         snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE);
10931
10932         alc_auto_parse_customize_define(codec);
10933
10934         if (has_cdefine_beep(codec))
10935                 spec->gen.beep_nid = 0x01;
10936
10937         if ((alc_get_coef0(codec) & (1 << 14)) &&
10938             codec->bus->pci && codec->bus->pci->subsystem_vendor == 0x1025 &&
10939             spec->cdefine.platform_type == 1) {
10940                 err = alc_codec_rename(codec, "ALC272X");
10941                 if (err < 0)
10942                         goto error;
10943         }
10944
10945         /* automatic parse from the BIOS config */
10946         err = alc662_parse_auto_config(codec);
10947         if (err < 0)
10948                 goto error;
10949
10950         if (!spec->gen.no_analog && spec->gen.beep_nid) {
10951                 switch (codec->core.vendor_id) {
10952                 case 0x10ec0662:
10953                         err = set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
10954                         break;
10955                 case 0x10ec0272:
10956                 case 0x10ec0663:
10957                 case 0x10ec0665:
10958                 case 0x10ec0668:
10959                         err = set_beep_amp(spec, 0x0b, 0x04, HDA_INPUT);
10960                         break;
10961                 case 0x10ec0273:
10962                         err = set_beep_amp(spec, 0x0b, 0x03, HDA_INPUT);
10963                         break;
10964                 }
10965                 if (err < 0)
10966                         goto error;
10967         }
10968
10969         snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE);
10970
10971         return 0;
10972
10973  error:
10974         alc_free(codec);
10975         return err;
10976 }
10977
10978 /*
10979  * ALC680 support
10980  */
10981
10982 static int alc680_parse_auto_config(struct hda_codec *codec)
10983 {
10984         return alc_parse_auto_config(codec, NULL, NULL);
10985 }
10986
10987 /*
10988  */
10989 static int patch_alc680(struct hda_codec *codec)
10990 {
10991         int err;
10992
10993         /* ALC680 has no aa-loopback mixer */
10994         err = alc_alloc_spec(codec, 0);
10995         if (err < 0)
10996                 return err;
10997
10998         /* automatic parse from the BIOS config */
10999         err = alc680_parse_auto_config(codec);
11000         if (err < 0) {
11001                 alc_free(codec);
11002                 return err;
11003         }
11004
11005         return 0;
11006 }
11007
11008 /*
11009  * patch entries
11010  */
11011 static const struct hda_device_id snd_hda_id_realtek[] = {
11012         HDA_CODEC_ENTRY(0x10ec0215, "ALC215", patch_alc269),
11013         HDA_CODEC_ENTRY(0x10ec0221, "ALC221", patch_alc269),
11014         HDA_CODEC_ENTRY(0x10ec0222, "ALC222", patch_alc269),
11015         HDA_CODEC_ENTRY(0x10ec0225, "ALC225", patch_alc269),
11016         HDA_CODEC_ENTRY(0x10ec0230, "ALC236", patch_alc269),
11017         HDA_CODEC_ENTRY(0x10ec0231, "ALC231", patch_alc269),
11018         HDA_CODEC_ENTRY(0x10ec0233, "ALC233", patch_alc269),
11019         HDA_CODEC_ENTRY(0x10ec0234, "ALC234", patch_alc269),
11020         HDA_CODEC_ENTRY(0x10ec0235, "ALC233", patch_alc269),
11021         HDA_CODEC_ENTRY(0x10ec0236, "ALC236", patch_alc269),
11022         HDA_CODEC_ENTRY(0x10ec0245, "ALC245", patch_alc269),
11023         HDA_CODEC_ENTRY(0x10ec0255, "ALC255", patch_alc269),
11024         HDA_CODEC_ENTRY(0x10ec0256, "ALC256", patch_alc269),
11025         HDA_CODEC_ENTRY(0x10ec0257, "ALC257", patch_alc269),
11026         HDA_CODEC_ENTRY(0x10ec0260, "ALC260", patch_alc260),
11027         HDA_CODEC_ENTRY(0x10ec0262, "ALC262", patch_alc262),
11028         HDA_CODEC_ENTRY(0x10ec0267, "ALC267", patch_alc268),
11029         HDA_CODEC_ENTRY(0x10ec0268, "ALC268", patch_alc268),
11030         HDA_CODEC_ENTRY(0x10ec0269, "ALC269", patch_alc269),
11031         HDA_CODEC_ENTRY(0x10ec0270, "ALC270", patch_alc269),
11032         HDA_CODEC_ENTRY(0x10ec0272, "ALC272", patch_alc662),
11033         HDA_CODEC_ENTRY(0x10ec0274, "ALC274", patch_alc269),
11034         HDA_CODEC_ENTRY(0x10ec0275, "ALC275", patch_alc269),
11035         HDA_CODEC_ENTRY(0x10ec0276, "ALC276", patch_alc269),
11036         HDA_CODEC_ENTRY(0x10ec0280, "ALC280", patch_alc269),
11037         HDA_CODEC_ENTRY(0x10ec0282, "ALC282", patch_alc269),
11038         HDA_CODEC_ENTRY(0x10ec0283, "ALC283", patch_alc269),
11039         HDA_CODEC_ENTRY(0x10ec0284, "ALC284", patch_alc269),
11040         HDA_CODEC_ENTRY(0x10ec0285, "ALC285", patch_alc269),
11041         HDA_CODEC_ENTRY(0x10ec0286, "ALC286", patch_alc269),
11042         HDA_CODEC_ENTRY(0x10ec0287, "ALC287", patch_alc269),
11043         HDA_CODEC_ENTRY(0x10ec0288, "ALC288", patch_alc269),
11044         HDA_CODEC_ENTRY(0x10ec0289, "ALC289", patch_alc269),
11045         HDA_CODEC_ENTRY(0x10ec0290, "ALC290", patch_alc269),
11046         HDA_CODEC_ENTRY(0x10ec0292, "ALC292", patch_alc269),
11047         HDA_CODEC_ENTRY(0x10ec0293, "ALC293", patch_alc269),
11048         HDA_CODEC_ENTRY(0x10ec0294, "ALC294", patch_alc269),
11049         HDA_CODEC_ENTRY(0x10ec0295, "ALC295", patch_alc269),
11050         HDA_CODEC_ENTRY(0x10ec0298, "ALC298", patch_alc269),
11051         HDA_CODEC_ENTRY(0x10ec0299, "ALC299", patch_alc269),
11052         HDA_CODEC_ENTRY(0x10ec0300, "ALC300", patch_alc269),
11053         HDA_CODEC_ENTRY(0x10ec0623, "ALC623", patch_alc269),
11054         HDA_CODEC_REV_ENTRY(0x10ec0861, 0x100340, "ALC660", patch_alc861),
11055         HDA_CODEC_ENTRY(0x10ec0660, "ALC660-VD", patch_alc861vd),
11056         HDA_CODEC_ENTRY(0x10ec0861, "ALC861", patch_alc861),
11057         HDA_CODEC_ENTRY(0x10ec0862, "ALC861-VD", patch_alc861vd),
11058         HDA_CODEC_REV_ENTRY(0x10ec0662, 0x100002, "ALC662 rev2", patch_alc882),
11059         HDA_CODEC_REV_ENTRY(0x10ec0662, 0x100101, "ALC662 rev1", patch_alc662),
11060         HDA_CODEC_REV_ENTRY(0x10ec0662, 0x100300, "ALC662 rev3", patch_alc662),
11061         HDA_CODEC_ENTRY(0x10ec0663, "ALC663", patch_alc662),
11062         HDA_CODEC_ENTRY(0x10ec0665, "ALC665", patch_alc662),
11063         HDA_CODEC_ENTRY(0x10ec0667, "ALC667", patch_alc662),
11064         HDA_CODEC_ENTRY(0x10ec0668, "ALC668", patch_alc662),
11065         HDA_CODEC_ENTRY(0x10ec0670, "ALC670", patch_alc662),
11066         HDA_CODEC_ENTRY(0x10ec0671, "ALC671", patch_alc662),
11067         HDA_CODEC_ENTRY(0x10ec0680, "ALC680", patch_alc680),
11068         HDA_CODEC_ENTRY(0x10ec0700, "ALC700", patch_alc269),
11069         HDA_CODEC_ENTRY(0x10ec0701, "ALC701", patch_alc269),
11070         HDA_CODEC_ENTRY(0x10ec0703, "ALC703", patch_alc269),
11071         HDA_CODEC_ENTRY(0x10ec0711, "ALC711", patch_alc269),
11072         HDA_CODEC_ENTRY(0x10ec0867, "ALC891", patch_alc662),
11073         HDA_CODEC_ENTRY(0x10ec0880, "ALC880", patch_alc880),
11074         HDA_CODEC_ENTRY(0x10ec0882, "ALC882", patch_alc882),
11075         HDA_CODEC_ENTRY(0x10ec0883, "ALC883", patch_alc882),
11076         HDA_CODEC_REV_ENTRY(0x10ec0885, 0x100101, "ALC889A", patch_alc882),
11077         HDA_CODEC_REV_ENTRY(0x10ec0885, 0x100103, "ALC889A", patch_alc882),
11078         HDA_CODEC_ENTRY(0x10ec0885, "ALC885", patch_alc882),
11079         HDA_CODEC_ENTRY(0x10ec0887, "ALC887", patch_alc882),
11080         HDA_CODEC_REV_ENTRY(0x10ec0888, 0x100101, "ALC1200", patch_alc882),
11081         HDA_CODEC_ENTRY(0x10ec0888, "ALC888", patch_alc882),
11082         HDA_CODEC_ENTRY(0x10ec0889, "ALC889", patch_alc882),
11083         HDA_CODEC_ENTRY(0x10ec0892, "ALC892", patch_alc662),
11084         HDA_CODEC_ENTRY(0x10ec0897, "ALC897", patch_alc662),
11085         HDA_CODEC_ENTRY(0x10ec0899, "ALC898", patch_alc882),
11086         HDA_CODEC_ENTRY(0x10ec0900, "ALC1150", patch_alc882),
11087         HDA_CODEC_ENTRY(0x10ec0b00, "ALCS1200A", patch_alc882),
11088         HDA_CODEC_ENTRY(0x10ec1168, "ALC1220", patch_alc882),
11089         HDA_CODEC_ENTRY(0x10ec1220, "ALC1220", patch_alc882),
11090         {} /* terminator */
11091 };
11092 MODULE_DEVICE_TABLE(hdaudio, snd_hda_id_realtek);
11093
11094 MODULE_LICENSE("GPL");
11095 MODULE_DESCRIPTION("Realtek HD-audio codec");
11096
11097 static struct hda_codec_driver realtek_driver = {
11098         .id = snd_hda_id_realtek,
11099 };
11100
11101 module_hda_codec_driver(realtek_driver);