sound/pci/hda/patch_realtek.c

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