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