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