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, alc225_pre_hsmode);
4106                 alc_process_coef_fw(codec, coef0225);
4107                 break;
4108         case 0x10ec0867:
4109                 alc_update_coefex_idx(codec, 0x57, 0x5, 1<<14, 0);
4110                 break;
4111         }
4112         codec_dbg(codec, "Headset jack set to unplugged mode.\n");
4113 }
4114
4115
4116 static void alc_headset_mode_mic_in(struct hda_codec *codec, hda_nid_t hp_pin,
4117                                     hda_nid_t mic_pin)
4118 {
4119         static struct coef_fw coef0255[] = {
4120                 WRITE_COEFEX(0x57, 0x03, 0x8aa6),
4121                 WRITE_COEF(0x06, 0x6100), /* Set MIC2 Vref gate to normal */
4122                 {}
4123         };
4124         static struct coef_fw coef0233[] = {
4125                 UPDATE_COEF(0x35, 0, 1<<14),
4126                 WRITE_COEF(0x06, 0x2100),
4127                 WRITE_COEF(0x1a, 0x0021),
4128                 WRITE_COEF(0x26, 0x008c),
4129                 {}
4130         };
4131         static struct coef_fw coef0288[] = {
4132                 UPDATE_COEF(0x4f, 0x00c0, 0),
4133                 UPDATE_COEF(0x50, 0x2000, 0),
4134                 UPDATE_COEF(0x56, 0x0006, 0),
4135                 UPDATE_COEF(0x4f, 0xfcc0, 0xc400),
4136                 UPDATE_COEF(0x66, 0x0008, 0x0008),
4137                 UPDATE_COEF(0x67, 0x2000, 0x2000),
4138                 {}
4139         };
4140         static struct coef_fw coef0292[] = {
4141                 WRITE_COEF(0x19, 0xa208),
4142                 WRITE_COEF(0x2e, 0xacf0),
4143                 {}
4144         };
4145         static struct coef_fw coef0293[] = {
4146                 UPDATE_COEFEX(0x57, 0x05, 0, 1<<15|1<<13), /* SET charge pump by verb */
4147                 UPDATE_COEFEX(0x57, 0x03, 1<<10, 0), /* SET EN_OSW to 0 */
4148                 UPDATE_COEF(0x1a, 1<<3, 0), /* Combo JD gating without LINE1-VREFO */
4149                 {}
4150         };
4151         static struct coef_fw coef0688[] = {
4152                 WRITE_COEF(0xb7, 0x802b),
4153                 WRITE_COEF(0xb5, 0x1040),
4154                 UPDATE_COEF(0xc3, 0, 1<<12),
4155                 {}
4156         };
4157         static struct coef_fw coef0225[] = {
4158                 UPDATE_COEFEX(0x57, 0x05, 1<<14, 1<<14),
4159                 UPDATE_COEF(0x4a, 3<<4, 2<<4),
4160                 UPDATE_COEF(0x63, 3<<14, 0),
4161                 {}
4162         };
4163         static struct coef_fw coef0274[] = {
4164                 UPDATE_COEFEX(0x57, 0x05, 0x4000, 0x4000),
4165                 UPDATE_COEF(0x4a, 0x0010, 0),
4166                 UPDATE_COEF(0x6b, 0xf000, 0),
4167                 {}
4168         };
4169
4170         switch (codec->core.vendor_id) {
4171         case 0x10ec0236:
4172         case 0x10ec0255:
4173         case 0x10ec0256:
4174                 alc_write_coef_idx(codec, 0x45, 0xc489);
4175                 snd_hda_set_pin_ctl_cache(codec, hp_pin, 0);
4176                 alc_process_coef_fw(codec, coef0255);
4177                 snd_hda_set_pin_ctl_cache(codec, mic_pin, PIN_VREF50);
4178                 break;
4179         case 0x10ec0234:
4180         case 0x10ec0274:
4181         case 0x10ec0294:
4182                 alc_write_coef_idx(codec, 0x45, 0x4689);
4183                 snd_hda_set_pin_ctl_cache(codec, hp_pin, 0);
4184                 alc_process_coef_fw(codec, coef0274);
4185                 snd_hda_set_pin_ctl_cache(codec, mic_pin, PIN_VREF50);
4186                 break;
4187         case 0x10ec0233:
4188         case 0x10ec0283:
4189                 alc_write_coef_idx(codec, 0x45, 0xc429);
4190                 snd_hda_set_pin_ctl_cache(codec, hp_pin, 0);
4191                 alc_process_coef_fw(codec, coef0233);
4192                 snd_hda_set_pin_ctl_cache(codec, mic_pin, PIN_VREF50);
4193                 break;
4194         case 0x10ec0286:
4195         case 0x10ec0288:
4196         case 0x10ec0298:
4197                 snd_hda_set_pin_ctl_cache(codec, hp_pin, 0);
4198                 alc_process_coef_fw(codec, coef0288);
4199                 snd_hda_set_pin_ctl_cache(codec, mic_pin, PIN_VREF50);
4200                 break;
4201         case 0x10ec0292:
4202                 snd_hda_set_pin_ctl_cache(codec, hp_pin, 0);
4203                 alc_process_coef_fw(codec, coef0292);
4204                 break;
4205         case 0x10ec0293:
4206                 /* Set to TRS mode */
4207                 alc_write_coef_idx(codec, 0x45, 0xc429);
4208                 snd_hda_set_pin_ctl_cache(codec, hp_pin, 0);
4209                 alc_process_coef_fw(codec, coef0293);
4210                 snd_hda_set_pin_ctl_cache(codec, mic_pin, PIN_VREF50);
4211                 break;
4212         case 0x10ec0867:
4213                 alc_update_coefex_idx(codec, 0x57, 0x5, 0, 1<<14);
4214                 /* fallthru */
4215         case 0x10ec0221:
4216         case 0x10ec0662:
4217                 snd_hda_set_pin_ctl_cache(codec, hp_pin, 0);
4218                 snd_hda_set_pin_ctl_cache(codec, mic_pin, PIN_VREF50);
4219                 break;
4220         case 0x10ec0668:
4221                 alc_write_coef_idx(codec, 0x11, 0x0001);
4222                 snd_hda_set_pin_ctl_cache(codec, hp_pin, 0);
4223                 alc_process_coef_fw(codec, coef0688);
4224                 snd_hda_set_pin_ctl_cache(codec, mic_pin, PIN_VREF50);
4225                 break;
4226         case 0x10ec0215:
4227         case 0x10ec0225:
4228         case 0x10ec0285:
4229         case 0x10ec0295:
4230         case 0x10ec0289:
4231         case 0x10ec0299:
4232                 alc_process_coef_fw(codec, alc225_pre_hsmode);
4233                 alc_update_coef_idx(codec, 0x45, 0x3f<<10, 0x31<<10);
4234                 snd_hda_set_pin_ctl_cache(codec, hp_pin, 0);
4235                 alc_process_coef_fw(codec, coef0225);
4236                 snd_hda_set_pin_ctl_cache(codec, mic_pin, PIN_VREF50);
4237                 break;
4238         }
4239         codec_dbg(codec, "Headset jack set to mic-in mode.\n");
4240 }
4241
4242 static void alc_headset_mode_default(struct hda_codec *codec)
4243 {
4244         static struct coef_fw coef0225[] = {
4245                 UPDATE_COEF(0x45, 0x3f<<10, 0x30<<10),
4246                 UPDATE_COEF(0x45, 0x3f<<10, 0x31<<10),
4247                 UPDATE_COEF(0x49, 3<<8, 0<<8),
4248                 UPDATE_COEF(0x4a, 3<<4, 3<<4),
4249                 UPDATE_COEF(0x63, 3<<14, 0),
4250                 UPDATE_COEF(0x67, 0xf000, 0x3000),
4251                 {}
4252         };
4253         static struct coef_fw coef0255[] = {
4254                 WRITE_COEF(0x45, 0xc089),
4255                 WRITE_COEF(0x45, 0xc489),
4256                 WRITE_COEFEX(0x57, 0x03, 0x8ea6),
4257                 WRITE_COEF(0x49, 0x0049),
4258                 {}
4259         };
4260         static struct coef_fw coef0233[] = {
4261                 WRITE_COEF(0x06, 0x2100),
4262                 WRITE_COEF(0x32, 0x4ea3),
4263                 {}
4264         };
4265         static struct coef_fw coef0288[] = {
4266                 UPDATE_COEF(0x4f, 0xfcc0, 0xc400), /* Set to TRS type */
4267                 UPDATE_COEF(0x50, 0x2000, 0x2000),
4268                 UPDATE_COEF(0x56, 0x0006, 0x0006),
4269                 UPDATE_COEF(0x66, 0x0008, 0),
4270                 UPDATE_COEF(0x67, 0x2000, 0),
4271                 {}
4272         };
4273         static struct coef_fw coef0292[] = {
4274                 WRITE_COEF(0x76, 0x000e),
4275                 WRITE_COEF(0x6c, 0x2400),
4276                 WRITE_COEF(0x6b, 0xc429),
4277                 WRITE_COEF(0x18, 0x7308),
4278                 {}
4279         };
4280         static struct coef_fw coef0293[] = {
4281                 UPDATE_COEF(0x4a, 0x000f, 0x000e), /* Combo Jack auto detect */
4282                 WRITE_COEF(0x45, 0xC429), /* Set to TRS type */
4283                 UPDATE_COEF(0x1a, 1<<3, 0), /* Combo JD gating without LINE1-VREFO */
4284                 {}
4285         };
4286         static struct coef_fw coef0688[] = {
4287                 WRITE_COEF(0x11, 0x0041),
4288                 WRITE_COEF(0x15, 0x0d40),
4289                 WRITE_COEF(0xb7, 0x802b),
4290                 {}
4291         };
4292         static struct coef_fw coef0274[] = {
4293                 WRITE_COEF(0x45, 0x4289),
4294                 UPDATE_COEF(0x4a, 0x0010, 0x0010),
4295                 UPDATE_COEF(0x6b, 0x0f00, 0),
4296                 UPDATE_COEF(0x49, 0x0300, 0x0300),
4297                 {}
4298         };
4299
4300         switch (codec->core.vendor_id) {
4301         case 0x10ec0215:
4302         case 0x10ec0225:
4303         case 0x10ec0285:
4304         case 0x10ec0295:
4305         case 0x10ec0289:
4306         case 0x10ec0299:
4307                 alc_process_coef_fw(codec, alc225_pre_hsmode);
4308                 alc_process_coef_fw(codec, coef0225);
4309                 break;
4310         case 0x10ec0236:
4311         case 0x10ec0255:
4312         case 0x10ec0256:
4313                 alc_process_coef_fw(codec, coef0255);
4314                 break;
4315         case 0x10ec0234:
4316         case 0x10ec0274:
4317         case 0x10ec0294:
4318                 alc_process_coef_fw(codec, coef0274);
4319                 break;
4320         case 0x10ec0233:
4321         case 0x10ec0283:
4322                 alc_process_coef_fw(codec, coef0233);
4323                 break;
4324         case 0x10ec0286:
4325         case 0x10ec0288:
4326         case 0x10ec0298:
4327                 alc_process_coef_fw(codec, coef0288);
4328                 break;
4329         case 0x10ec0292:
4330                 alc_process_coef_fw(codec, coef0292);
4331                 break;
4332         case 0x10ec0293:
4333                 alc_process_coef_fw(codec, coef0293);
4334                 break;
4335         case 0x10ec0668:
4336                 alc_process_coef_fw(codec, coef0688);
4337                 break;
4338         case 0x10ec0867:
4339                 alc_update_coefex_idx(codec, 0x57, 0x5, 1<<14, 0);
4340                 break;
4341         }
4342         codec_dbg(codec, "Headset jack set to headphone (default) mode.\n");
4343 }
4344
4345 /* Iphone type */
4346 static void alc_headset_mode_ctia(struct hda_codec *codec)
4347 {
4348         int val;
4349
4350         static struct coef_fw coef0255[] = {
4351                 WRITE_COEF(0x45, 0xd489), /* Set to CTIA type */
4352                 WRITE_COEF(0x1b, 0x0c2b),
4353                 WRITE_COEFEX(0x57, 0x03, 0x8ea6),
4354                 {}
4355         };
4356         static struct coef_fw coef0256[] = {
4357                 WRITE_COEF(0x45, 0xd489), /* Set to CTIA type */
4358                 WRITE_COEF(0x1b, 0x0c6b),
4359                 WRITE_COEFEX(0x57, 0x03, 0x8ea6),
4360                 {}
4361         };
4362         static struct coef_fw coef0233[] = {
4363                 WRITE_COEF(0x45, 0xd429),
4364                 WRITE_COEF(0x1b, 0x0c2b),
4365                 WRITE_COEF(0x32, 0x4ea3),
4366                 {}
4367         };
4368         static struct coef_fw coef0288[] = {
4369                 UPDATE_COEF(0x50, 0x2000, 0x2000),
4370                 UPDATE_COEF(0x56, 0x0006, 0x0006),
4371                 UPDATE_COEF(0x66, 0x0008, 0),
4372                 UPDATE_COEF(0x67, 0x2000, 0),
4373                 {}
4374         };
4375         static struct coef_fw coef0292[] = {
4376                 WRITE_COEF(0x6b, 0xd429),
4377                 WRITE_COEF(0x76, 0x0008),
4378                 WRITE_COEF(0x18, 0x7388),
4379                 {}
4380         };
4381         static struct coef_fw coef0293[] = {
4382                 WRITE_COEF(0x45, 0xd429), /* Set to ctia type */
4383                 UPDATE_COEF(0x10, 7<<8, 7<<8), /* SET Line1 JD to 1 */
4384                 {}
4385         };
4386         static struct coef_fw coef0688[] = {
4387                 WRITE_COEF(0x11, 0x0001),
4388                 WRITE_COEF(0x15, 0x0d60),
4389                 WRITE_COEF(0xc3, 0x0000),
4390                 {}
4391         };
4392         static struct coef_fw coef0225_1[] = {
4393                 UPDATE_COEF(0x45, 0x3f<<10, 0x35<<10),
4394                 UPDATE_COEF(0x63, 3<<14, 2<<14),
4395                 {}
4396         };
4397         static struct coef_fw coef0225_2[] = {
4398                 UPDATE_COEF(0x45, 0x3f<<10, 0x35<<10),
4399                 UPDATE_COEF(0x63, 3<<14, 1<<14),
4400                 {}
4401         };
4402
4403         switch (codec->core.vendor_id) {
4404         case 0x10ec0255:
4405                 alc_process_coef_fw(codec, coef0255);
4406                 break;
4407         case 0x10ec0236:
4408         case 0x10ec0256:
4409                 alc_process_coef_fw(codec, coef0256);
4410                 break;
4411         case 0x10ec0234:
4412         case 0x10ec0274:
4413         case 0x10ec0294:
4414                 alc_write_coef_idx(codec, 0x45, 0xd689);
4415                 break;
4416         case 0x10ec0233:
4417         case 0x10ec0283:
4418                 alc_process_coef_fw(codec, coef0233);
4419                 break;
4420         case 0x10ec0298:
4421                 val = alc_read_coef_idx(codec, 0x50);
4422                 if (val & (1 << 12)) {
4423                         alc_update_coef_idx(codec, 0x8e, 0x0070, 0x0020);
4424                         alc_update_coef_idx(codec, 0x4f, 0xfcc0, 0xd400);
4425                         msleep(300);
4426                 } else {
4427                         alc_update_coef_idx(codec, 0x8e, 0x0070, 0x0010);
4428                         alc_update_coef_idx(codec, 0x4f, 0xfcc0, 0xd400);
4429                         msleep(300);
4430                 }
4431                 break;
4432         case 0x10ec0286:
4433         case 0x10ec0288:
4434                 alc_update_coef_idx(codec, 0x4f, 0xfcc0, 0xd400);
4435                 msleep(300);
4436                 alc_process_coef_fw(codec, coef0288);
4437                 break;
4438         case 0x10ec0292:
4439                 alc_process_coef_fw(codec, coef0292);
4440                 break;
4441         case 0x10ec0293:
4442                 alc_process_coef_fw(codec, coef0293);
4443                 break;
4444         case 0x10ec0668:
4445                 alc_process_coef_fw(codec, coef0688);
4446                 break;
4447         case 0x10ec0215:
4448         case 0x10ec0225:
4449         case 0x10ec0285:
4450         case 0x10ec0295:
4451         case 0x10ec0289:
4452         case 0x10ec0299:
4453                 val = alc_read_coef_idx(codec, 0x45);
4454                 if (val & (1 << 9))
4455                         alc_process_coef_fw(codec, coef0225_2);
4456                 else
4457                         alc_process_coef_fw(codec, coef0225_1);
4458                 break;
4459         case 0x10ec0867:
4460                 alc_update_coefex_idx(codec, 0x57, 0x5, 1<<14, 0);
4461                 break;
4462         }
4463         codec_dbg(codec, "Headset jack set to iPhone-style headset mode.\n");
4464 }
4465
4466 /* Nokia type */
4467 static void alc_headset_mode_omtp(struct hda_codec *codec)
4468 {
4469         static struct coef_fw coef0255[] = {
4470                 WRITE_COEF(0x45, 0xe489), /* Set to OMTP Type */
4471                 WRITE_COEF(0x1b, 0x0c2b),
4472                 WRITE_COEFEX(0x57, 0x03, 0x8ea6),
4473                 {}
4474         };
4475         static struct coef_fw coef0256[] = {
4476                 WRITE_COEF(0x45, 0xe489), /* Set to OMTP Type */
4477                 WRITE_COEF(0x1b, 0x0c6b),
4478                 WRITE_COEFEX(0x57, 0x03, 0x8ea6),
4479                 {}
4480         };
4481         static struct coef_fw coef0233[] = {
4482                 WRITE_COEF(0x45, 0xe429),
4483                 WRITE_COEF(0x1b, 0x0c2b),
4484                 WRITE_COEF(0x32, 0x4ea3),
4485                 {}
4486         };
4487         static struct coef_fw coef0288[] = {
4488                 UPDATE_COEF(0x50, 0x2000, 0x2000),
4489                 UPDATE_COEF(0x56, 0x0006, 0x0006),
4490                 UPDATE_COEF(0x66, 0x0008, 0),
4491                 UPDATE_COEF(0x67, 0x2000, 0),
4492                 {}
4493         };
4494         static struct coef_fw coef0292[] = {
4495                 WRITE_COEF(0x6b, 0xe429),
4496                 WRITE_COEF(0x76, 0x0008),
4497                 WRITE_COEF(0x18, 0x7388),
4498                 {}
4499         };
4500         static struct coef_fw coef0293[] = {
4501                 WRITE_COEF(0x45, 0xe429), /* Set to omtp type */
4502                 UPDATE_COEF(0x10, 7<<8, 7<<8), /* SET Line1 JD to 1 */
4503                 {}
4504         };
4505         static struct coef_fw coef0688[] = {
4506                 WRITE_COEF(0x11, 0x0001),
4507                 WRITE_COEF(0x15, 0x0d50),
4508                 WRITE_COEF(0xc3, 0x0000),
4509                 {}
4510         };
4511         static struct coef_fw coef0225[] = {
4512                 UPDATE_COEF(0x45, 0x3f<<10, 0x39<<10),
4513                 UPDATE_COEF(0x63, 3<<14, 2<<14),
4514                 {}
4515         };
4516
4517         switch (codec->core.vendor_id) {
4518         case 0x10ec0255:
4519                 alc_process_coef_fw(codec, coef0255);
4520                 break;
4521         case 0x10ec0236:
4522         case 0x10ec0256:
4523                 alc_process_coef_fw(codec, coef0256);
4524                 break;
4525         case 0x10ec0234:
4526         case 0x10ec0274:
4527         case 0x10ec0294:
4528                 alc_write_coef_idx(codec, 0x45, 0xe689);
4529                 break;
4530         case 0x10ec0233:
4531         case 0x10ec0283:
4532                 alc_process_coef_fw(codec, coef0233);
4533                 break;
4534         case 0x10ec0298:
4535                 alc_update_coef_idx(codec, 0x8e, 0x0070, 0x0010);/* Headset output enable */
4536                 alc_update_coef_idx(codec, 0x4f, 0xfcc0, 0xe400);
4537                 msleep(300);
4538                 break;
4539         case 0x10ec0286:
4540         case 0x10ec0288:
4541                 alc_update_coef_idx(codec, 0x4f, 0xfcc0, 0xe400);
4542                 msleep(300);
4543                 alc_process_coef_fw(codec, coef0288);
4544                 break;
4545         case 0x10ec0292:
4546                 alc_process_coef_fw(codec, coef0292);
4547                 break;
4548         case 0x10ec0293:
4549                 alc_process_coef_fw(codec, coef0293);
4550                 break;
4551         case 0x10ec0668:
4552                 alc_process_coef_fw(codec, coef0688);
4553                 break;
4554         case 0x10ec0215:
4555         case 0x10ec0225:
4556         case 0x10ec0285:
4557         case 0x10ec0295:
4558         case 0x10ec0289:
4559         case 0x10ec0299:
4560                 alc_process_coef_fw(codec, coef0225);
4561                 break;
4562         }
4563         codec_dbg(codec, "Headset jack set to Nokia-style headset mode.\n");
4564 }
4565
4566 static void alc_determine_headset_type(struct hda_codec *codec)
4567 {
4568         int val;
4569         bool is_ctia = false;
4570         struct alc_spec *spec = codec->spec;
4571         static struct coef_fw coef0255[] = {
4572                 WRITE_COEF(0x45, 0xd089), /* combo jack auto switch control(Check type)*/
4573                 WRITE_COEF(0x49, 0x0149), /* combo jack auto switch control(Vref
4574  conteol) */
4575                 {}
4576         };
4577         static struct coef_fw coef0288[] = {
4578                 UPDATE_COEF(0x4f, 0xfcc0, 0xd400), /* Check Type */
4579                 {}
4580         };
4581         static struct coef_fw coef0298[] = {
4582                 UPDATE_COEF(0x50, 0x2000, 0x2000),
4583                 UPDATE_COEF(0x56, 0x0006, 0x0006),
4584                 UPDATE_COEF(0x66, 0x0008, 0),
4585                 UPDATE_COEF(0x67, 0x2000, 0),
4586                 UPDATE_COEF(0x19, 0x1300, 0x1300),
4587                 {}
4588         };
4589         static struct coef_fw coef0293[] = {
4590                 UPDATE_COEF(0x4a, 0x000f, 0x0008), /* Combo Jack auto detect */
4591                 WRITE_COEF(0x45, 0xD429), /* Set to ctia type */
4592                 {}
4593         };
4594         static struct coef_fw coef0688[] = {
4595                 WRITE_COEF(0x11, 0x0001),
4596                 WRITE_COEF(0xb7, 0x802b),
4597                 WRITE_COEF(0x15, 0x0d60),
4598                 WRITE_COEF(0xc3, 0x0c00),
4599                 {}
4600         };
4601         static struct coef_fw coef0274[] = {
4602                 UPDATE_COEF(0x4a, 0x0010, 0),
4603                 UPDATE_COEF(0x4a, 0x8000, 0),
4604                 WRITE_COEF(0x45, 0xd289),
4605                 UPDATE_COEF(0x49, 0x0300, 0x0300),
4606                 {}
4607         };
4608
4609         switch (codec->core.vendor_id) {
4610         case 0x10ec0236:
4611         case 0x10ec0255:
4612         case 0x10ec0256:
4613                 alc_process_coef_fw(codec, coef0255);
4614                 msleep(300);
4615                 val = alc_read_coef_idx(codec, 0x46);
4616                 is_ctia = (val & 0x0070) == 0x0070;
4617                 break;
4618         case 0x10ec0234:
4619         case 0x10ec0274:
4620         case 0x10ec0294:
4621                 alc_process_coef_fw(codec, coef0274);
4622                 msleep(80);
4623                 val = alc_read_coef_idx(codec, 0x46);
4624                 is_ctia = (val & 0x00f0) == 0x00f0;
4625                 break;
4626         case 0x10ec0233:
4627         case 0x10ec0283:
4628                 alc_write_coef_idx(codec, 0x45, 0xd029);
4629                 msleep(300);
4630                 val = alc_read_coef_idx(codec, 0x46);
4631                 is_ctia = (val & 0x0070) == 0x0070;
4632                 break;
4633         case 0x10ec0298:
4634                 snd_hda_codec_write(codec, 0x21, 0,
4635                             AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);
4636                 msleep(100);
4637                 snd_hda_codec_write(codec, 0x21, 0,
4638                             AC_VERB_SET_PIN_WIDGET_CONTROL, 0x0);
4639                 msleep(200);
4640
4641                 val = alc_read_coef_idx(codec, 0x50);
4642                 if (val & (1 << 12)) {
4643                         alc_update_coef_idx(codec, 0x8e, 0x0070, 0x0020);
4644                         alc_process_coef_fw(codec, coef0288);
4645                         msleep(350);
4646                         val = alc_read_coef_idx(codec, 0x50);
4647                         is_ctia = (val & 0x0070) == 0x0070;
4648                 } else {
4649                         alc_update_coef_idx(codec, 0x8e, 0x0070, 0x0010);
4650                         alc_process_coef_fw(codec, coef0288);
4651                         msleep(350);
4652                         val = alc_read_coef_idx(codec, 0x50);
4653                         is_ctia = (val & 0x0070) == 0x0070;
4654                 }
4655                 alc_process_coef_fw(codec, coef0298);
4656                 snd_hda_codec_write(codec, 0x21, 0,
4657                             AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP);
4658                 msleep(75);
4659                 snd_hda_codec_write(codec, 0x21, 0,
4660                             AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE);
4661                 break;
4662         case 0x10ec0286:
4663         case 0x10ec0288:
4664                 alc_process_coef_fw(codec, coef0288);
4665                 msleep(350);
4666                 val = alc_read_coef_idx(codec, 0x50);
4667                 is_ctia = (val & 0x0070) == 0x0070;
4668                 break;
4669         case 0x10ec0292:
4670                 alc_write_coef_idx(codec, 0x6b, 0xd429);
4671                 msleep(300);
4672                 val = alc_read_coef_idx(codec, 0x6c);
4673                 is_ctia = (val & 0x001c) == 0x001c;
4674                 break;
4675         case 0x10ec0293:
4676                 alc_process_coef_fw(codec, coef0293);
4677                 msleep(300);
4678                 val = alc_read_coef_idx(codec, 0x46);
4679                 is_ctia = (val & 0x0070) == 0x0070;
4680                 break;
4681         case 0x10ec0668:
4682                 alc_process_coef_fw(codec, coef0688);
4683                 msleep(300);
4684                 val = alc_read_coef_idx(codec, 0xbe);
4685                 is_ctia = (val & 0x1c02) == 0x1c02;
4686                 break;
4687         case 0x10ec0215:
4688         case 0x10ec0225:
4689         case 0x10ec0285:
4690         case 0x10ec0295:
4691         case 0x10ec0289:
4692         case 0x10ec0299:
4693                 snd_hda_codec_write(codec, 0x21, 0,
4694                             AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);
4695                 msleep(80);
4696                 snd_hda_codec_write(codec, 0x21, 0,
4697                             AC_VERB_SET_PIN_WIDGET_CONTROL, 0x0);
4698
4699                 alc_process_coef_fw(codec, alc225_pre_hsmode);
4700                 alc_update_coef_idx(codec, 0x67, 0xf000, 0x1000);
4701                 val = alc_read_coef_idx(codec, 0x45);
4702                 if (val & (1 << 9)) {
4703                         alc_update_coef_idx(codec, 0x45, 0x3f<<10, 0x34<<10);
4704                         alc_update_coef_idx(codec, 0x49, 3<<8, 2<<8);
4705                         msleep(800);
4706                         val = alc_read_coef_idx(codec, 0x46);
4707                         is_ctia = (val & 0x00f0) == 0x00f0;
4708                 } else {
4709                         alc_update_coef_idx(codec, 0x45, 0x3f<<10, 0x34<<10);
4710                         alc_update_coef_idx(codec, 0x49, 3<<8, 1<<8);
4711                         msleep(800);
4712                         val = alc_read_coef_idx(codec, 0x46);
4713                         is_ctia = (val & 0x00f0) == 0x00f0;
4714                 }
4715                 alc_update_coef_idx(codec, 0x4a, 7<<6, 7<<6);
4716                 alc_update_coef_idx(codec, 0x4a, 3<<4, 3<<4);
4717                 alc_update_coef_idx(codec, 0x67, 0xf000, 0x3000);
4718
4719                 snd_hda_codec_write(codec, 0x21, 0,
4720                             AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT);
4721                 msleep(80);
4722                 snd_hda_codec_write(codec, 0x21, 0,
4723                             AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE);
4724                 break;
4725         case 0x10ec0867:
4726                 is_ctia = true;
4727                 break;
4728         }
4729
4730         codec_dbg(codec, "Headset jack detected iPhone-style headset: %s\n",
4731                     is_ctia ? "yes" : "no");
4732         spec->current_headset_type = is_ctia ? ALC_HEADSET_TYPE_CTIA : ALC_HEADSET_TYPE_OMTP;
4733 }
4734
4735 static void alc_update_headset_mode(struct hda_codec *codec)
4736 {
4737         struct alc_spec *spec = codec->spec;
4738
4739         hda_nid_t mux_pin = spec->gen.imux_pins[spec->gen.cur_mux[0]];
4740         hda_nid_t hp_pin = spec->gen.autocfg.hp_pins[0];
4741
4742         int new_headset_mode;
4743
4744         if (!snd_hda_jack_detect(codec, hp_pin))
4745                 new_headset_mode = ALC_HEADSET_MODE_UNPLUGGED;
4746         else if (mux_pin == spec->headset_mic_pin)
4747                 new_headset_mode = ALC_HEADSET_MODE_HEADSET;
4748         else if (mux_pin == spec->headphone_mic_pin)
4749                 new_headset_mode = ALC_HEADSET_MODE_MIC;
4750         else
4751                 new_headset_mode = ALC_HEADSET_MODE_HEADPHONE;
4752
4753         if (new_headset_mode == spec->current_headset_mode) {
4754                 snd_hda_gen_update_outputs(codec);
4755                 return;
4756         }
4757
4758         switch (new_headset_mode) {
4759         case ALC_HEADSET_MODE_UNPLUGGED:
4760                 alc_headset_mode_unplugged(codec);
4761                 spec->gen.hp_jack_present = false;
4762                 break;
4763         case ALC_HEADSET_MODE_HEADSET:
4764                 if (spec->current_headset_type == ALC_HEADSET_TYPE_UNKNOWN)
4765                         alc_determine_headset_type(codec);
4766                 if (spec->current_headset_type == ALC_HEADSET_TYPE_CTIA)
4767                         alc_headset_mode_ctia(codec);
4768                 else if (spec->current_headset_type == ALC_HEADSET_TYPE_OMTP)
4769                         alc_headset_mode_omtp(codec);
4770                 spec->gen.hp_jack_present = true;
4771                 break;
4772         case ALC_HEADSET_MODE_MIC:
4773                 alc_headset_mode_mic_in(codec, hp_pin, spec->headphone_mic_pin);
4774                 spec->gen.hp_jack_present = false;
4775                 break;
4776         case ALC_HEADSET_MODE_HEADPHONE:
4777                 alc_headset_mode_default(codec);
4778                 spec->gen.hp_jack_present = true;
4779                 break;
4780         }
4781         if (new_headset_mode != ALC_HEADSET_MODE_MIC) {
4782                 snd_hda_set_pin_ctl_cache(codec, hp_pin,
4783                                           AC_PINCTL_OUT_EN | AC_PINCTL_HP_EN);
4784                 if (spec->headphone_mic_pin && spec->headphone_mic_pin != hp_pin)
4785                         snd_hda_set_pin_ctl_cache(codec, spec->headphone_mic_pin,
4786                                                   PIN_VREFHIZ);
4787         }
4788         spec->current_headset_mode = new_headset_mode;
4789
4790         snd_hda_gen_update_outputs(codec);
4791 }
4792
4793 static void alc_update_headset_mode_hook(struct hda_codec *codec,
4794                                          struct snd_kcontrol *kcontrol,
4795                                          struct snd_ctl_elem_value *ucontrol)
4796 {
4797         alc_update_headset_mode(codec);
4798 }
4799
4800 static void alc_update_headset_jack_cb(struct hda_codec *codec,
4801                                        struct hda_jack_callback *jack)
4802 {
4803         struct alc_spec *spec = codec->spec;
4804         spec->current_headset_type = ALC_HEADSET_TYPE_UNKNOWN;
4805         snd_hda_gen_hp_automute(codec, jack);
4806 }
4807
4808 static void alc_probe_headset_mode(struct hda_codec *codec)
4809 {
4810         int i;
4811         struct alc_spec *spec = codec->spec;
4812         struct auto_pin_cfg *cfg = &spec->gen.autocfg;
4813
4814         /* Find mic pins */
4815         for (i = 0; i < cfg->num_inputs; i++) {
4816                 if (cfg->inputs[i].is_headset_mic && !spec->headset_mic_pin)
4817                         spec->headset_mic_pin = cfg->inputs[i].pin;
4818                 if (cfg->inputs[i].is_headphone_mic && !spec->headphone_mic_pin)
4819                         spec->headphone_mic_pin = cfg->inputs[i].pin;
4820         }
4821
4822         WARN_ON(spec->gen.cap_sync_hook);
4823         spec->gen.cap_sync_hook = alc_update_headset_mode_hook;
4824         spec->gen.automute_hook = alc_update_headset_mode;
4825         spec->gen.hp_automute_hook = alc_update_headset_jack_cb;
4826 }
4827
4828 static void alc_fixup_headset_mode(struct hda_codec *codec,
4829                                 const struct hda_fixup *fix, int action)
4830 {
4831         struct alc_spec *spec = codec->spec;
4832
4833         switch (action) {
4834         case HDA_FIXUP_ACT_PRE_PROBE:
4835                 spec->parse_flags |= HDA_PINCFG_HEADSET_MIC | HDA_PINCFG_HEADPHONE_MIC;
4836                 break;
4837         case HDA_FIXUP_ACT_PROBE:
4838                 alc_probe_headset_mode(codec);
4839                 break;
4840         case HDA_FIXUP_ACT_INIT:
4841                 spec->current_headset_mode = 0;
4842                 alc_update_headset_mode(codec);
4843                 break;
4844         }
4845 }
4846
4847 static void alc_fixup_headset_mode_no_hp_mic(struct hda_codec *codec,
4848                                 const struct hda_fixup *fix, int action)
4849 {
4850         if (action == HDA_FIXUP_ACT_PRE_PROBE) {
4851                 struct alc_spec *spec = codec->spec;
4852                 spec->parse_flags |= HDA_PINCFG_HEADSET_MIC;
4853         }
4854         else
4855                 alc_fixup_headset_mode(codec, fix, action);
4856 }
4857
4858 static void alc255_set_default_jack_type(struct hda_codec *codec)
4859 {
4860         /* Set to iphone type */
4861         static struct coef_fw alc255fw[] = {
4862                 WRITE_COEF(0x1b, 0x880b),
4863                 WRITE_COEF(0x45, 0xd089),
4864                 WRITE_COEF(0x1b, 0x080b),
4865                 WRITE_COEF(0x46, 0x0004),
4866                 WRITE_COEF(0x1b, 0x0c0b),
4867                 {}
4868         };
4869         static struct coef_fw alc256fw[] = {
4870                 WRITE_COEF(0x1b, 0x884b),
4871                 WRITE_COEF(0x45, 0xd089),
4872                 WRITE_COEF(0x1b, 0x084b),
4873                 WRITE_COEF(0x46, 0x0004),
4874                 WRITE_COEF(0x1b, 0x0c4b),
4875                 {}
4876         };
4877         switch (codec->core.vendor_id) {
4878         case 0x10ec0255:
4879                 alc_process_coef_fw(codec, alc255fw);
4880                 break;
4881         case 0x10ec0236:
4882         case 0x10ec0256:
4883                 alc_process_coef_fw(codec, alc256fw);
4884                 break;
4885         }
4886         msleep(30);
4887 }
4888
4889 static void alc_fixup_headset_mode_alc255(struct hda_codec *codec,
4890                                 const struct hda_fixup *fix, int action)
4891 {
4892         if (action == HDA_FIXUP_ACT_PRE_PROBE) {
4893                 alc255_set_default_jack_type(codec);
4894         }
4895         alc_fixup_headset_mode(codec, fix, action);
4896 }
4897
4898 static void alc_fixup_headset_mode_alc255_no_hp_mic(struct hda_codec *codec,
4899                                 const struct hda_fixup *fix, int action)
4900 {
4901         if (action == HDA_FIXUP_ACT_PRE_PROBE) {
4902                 struct alc_spec *spec = codec->spec;
4903                 spec->parse_flags |= HDA_PINCFG_HEADSET_MIC;
4904                 alc255_set_default_jack_type(codec);
4905         }
4906         else
4907                 alc_fixup_headset_mode(codec, fix, action);
4908 }
4909
4910 static void alc288_update_headset_jack_cb(struct hda_codec *codec,
4911                                        struct hda_jack_callback *jack)
4912 {
4913         struct alc_spec *spec = codec->spec;
4914
4915         alc_update_headset_jack_cb(codec, jack);
4916         /* Headset Mic enable or disable, only for Dell Dino */
4917         alc_update_gpio_data(codec, 0x40, spec->gen.hp_jack_present);
4918 }
4919
4920 static void alc_fixup_headset_mode_dell_alc288(struct hda_codec *codec,
4921                                 const struct hda_fixup *fix, int action)
4922 {
4923         alc_fixup_headset_mode(codec, fix, action);
4924         if (action == HDA_FIXUP_ACT_PROBE) {
4925                 struct alc_spec *spec = codec->spec;
4926                 /* toggled via hp_automute_hook */
4927                 spec->gpio_mask |= 0x40;
4928                 spec->gpio_dir |= 0x40;
4929                 spec->gen.hp_automute_hook = alc288_update_headset_jack_cb;
4930         }
4931 }
4932
4933 static void alc_fixup_auto_mute_via_amp(struct hda_codec *codec,
4934                                         const struct hda_fixup *fix, int action)
4935 {
4936         if (action == HDA_FIXUP_ACT_PRE_PROBE) {
4937                 struct alc_spec *spec = codec->spec;
4938                 spec->gen.auto_mute_via_amp = 1;
4939         }
4940 }
4941
4942 static void alc_no_shutup(struct hda_codec *codec)
4943 {
4944 }
4945
4946 static void alc_fixup_no_shutup(struct hda_codec *codec,
4947                                 const struct hda_fixup *fix, int action)
4948 {
4949         if (action == HDA_FIXUP_ACT_PRE_PROBE) {
4950                 struct alc_spec *spec = codec->spec;
4951                 spec->shutup = alc_no_shutup;
4952         }
4953 }
4954
4955 static void alc_fixup_disable_aamix(struct hda_codec *codec,
4956                                     const struct hda_fixup *fix, int action)
4957 {
4958         if (action == HDA_FIXUP_ACT_PRE_PROBE) {
4959                 struct alc_spec *spec = codec->spec;
4960                 /* Disable AA-loopback as it causes white noise */
4961                 spec->gen.mixer_nid = 0;
4962         }
4963 }
4964
4965 /* fixup for Thinkpad docks: add dock pins, avoid HP parser fixup */
4966 static void alc_fixup_tpt440_dock(struct hda_codec *codec,
4967                                   const struct hda_fixup *fix, int action)
4968 {
4969         static const struct hda_pintbl pincfgs[] = {
4970                 { 0x16, 0x21211010 }, /* dock headphone */
4971                 { 0x19, 0x21a11010 }, /* dock mic */
4972                 { }
4973         };
4974         struct alc_spec *spec = codec->spec;
4975
4976         if (action == HDA_FIXUP_ACT_PRE_PROBE) {
4977                 spec->reboot_notify = alc_d3_at_reboot; /* reduce noise */
4978                 spec->parse_flags = HDA_PINCFG_NO_HP_FIXUP;
4979                 codec->power_save_node = 0; /* avoid click noises */
4980                 snd_hda_apply_pincfgs(codec, pincfgs);
4981         }
4982 }
4983
4984 static void alc_fixup_tpt470_dock(struct hda_codec *codec,
4985                                   const struct hda_fixup *fix, int action)
4986 {
4987         static const struct hda_pintbl pincfgs[] = {
4988                 { 0x17, 0x21211010 }, /* dock headphone */
4989                 { 0x19, 0x21a11010 }, /* dock mic */
4990                 { }
4991         };
4992         /* Assure the speaker pin to be coupled with DAC NID 0x03; otherwise
4993          * the speaker output becomes too low by some reason on Thinkpads with
4994          * ALC298 codec
4995          */
4996         static hda_nid_t preferred_pairs[] = {
4997                 0x14, 0x03, 0x17, 0x02, 0x21, 0x02,
4998                 0
4999         };
5000         struct alc_spec *spec = codec->spec;
5001
5002         if (action == HDA_FIXUP_ACT_PRE_PROBE) {
5003                 spec->gen.preferred_dacs = preferred_pairs;
5004                 spec->parse_flags = HDA_PINCFG_NO_HP_FIXUP;
5005                 snd_hda_apply_pincfgs(codec, pincfgs);
5006         } else if (action == HDA_FIXUP_ACT_INIT) {
5007                 /* Enable DOCK device */
5008                 snd_hda_codec_write(codec, 0x17, 0,
5009                             AC_VERB_SET_CONFIG_DEFAULT_BYTES_3, 0);
5010                 /* Enable DOCK device */
5011                 snd_hda_codec_write(codec, 0x19, 0,
5012                             AC_VERB_SET_CONFIG_DEFAULT_BYTES_3, 0);
5013         }
5014 }
5015
5016 static void alc_shutup_dell_xps13(struct hda_codec *codec)
5017 {
5018         struct alc_spec *spec = codec->spec;
5019         int hp_pin = spec->gen.autocfg.hp_pins[0];
5020
5021         /* Prevent pop noises when headphones are plugged in */
5022         snd_hda_codec_write(codec, hp_pin, 0,
5023                             AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);
5024         msleep(20);
5025 }
5026
5027 static void alc_fixup_dell_xps13(struct hda_codec *codec,
5028                                 const struct hda_fixup *fix, int action)
5029 {
5030         struct alc_spec *spec = codec->spec;
5031         struct hda_input_mux *imux = &spec->gen.input_mux;
5032         int i;
5033
5034         switch (action) {
5035         case HDA_FIXUP_ACT_PRE_PROBE:
5036                 /* mic pin 0x19 must be initialized with Vref Hi-Z, otherwise
5037                  * it causes a click noise at start up
5038                  */
5039                 snd_hda_codec_set_pin_target(codec, 0x19, PIN_VREFHIZ);
5040                 spec->shutup = alc_shutup_dell_xps13;
5041                 break;
5042         case HDA_FIXUP_ACT_PROBE:
5043                 /* Make the internal mic the default input source. */
5044                 for (i = 0; i < imux->num_items; i++) {
5045                         if (spec->gen.imux_pins[i] == 0x12) {
5046                                 spec->gen.cur_mux[0] = i;
5047                                 break;
5048                         }
5049                 }
5050                 break;
5051         }
5052 }
5053
5054 static void alc_fixup_headset_mode_alc662(struct hda_codec *codec,
5055                                 const struct hda_fixup *fix, int action)
5056 {
5057         struct alc_spec *spec = codec->spec;
5058
5059         if (action == HDA_FIXUP_ACT_PRE_PROBE) {
5060                 spec->parse_flags |= HDA_PINCFG_HEADSET_MIC;
5061                 spec->gen.hp_mic = 1; /* Mic-in is same pin as headphone */
5062
5063                 /* Disable boost for mic-in permanently. (This code is only called
5064                    from quirks that guarantee that the headphone is at NID 0x1b.) */
5065                 snd_hda_codec_write(codec, 0x1b, 0, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000);
5066                 snd_hda_override_wcaps(codec, 0x1b, get_wcaps(codec, 0x1b) & ~AC_WCAP_IN_AMP);
5067         } else
5068                 alc_fixup_headset_mode(codec, fix, action);
5069 }
5070
5071 static void alc_fixup_headset_mode_alc668(struct hda_codec *codec,
5072                                 const struct hda_fixup *fix, int action)
5073 {
5074         if (action == HDA_FIXUP_ACT_PRE_PROBE) {
5075                 alc_write_coef_idx(codec, 0xc4, 0x8000);
5076                 alc_update_coef_idx(codec, 0xc2, ~0xfe, 0);
5077                 snd_hda_set_pin_ctl_cache(codec, 0x18, 0);
5078         }
5079         alc_fixup_headset_mode(codec, fix, action);
5080 }
5081
5082 /* Returns the nid of the external mic input pin, or 0 if it cannot be found. */
5083 static int find_ext_mic_pin(struct hda_codec *codec)
5084 {
5085         struct alc_spec *spec = codec->spec;
5086         struct auto_pin_cfg *cfg = &spec->gen.autocfg;
5087         hda_nid_t nid;
5088         unsigned int defcfg;
5089         int i;
5090
5091         for (i = 0; i < cfg->num_inputs; i++) {
5092                 if (cfg->inputs[i].type != AUTO_PIN_MIC)
5093                         continue;
5094                 nid = cfg->inputs[i].pin;
5095                 defcfg = snd_hda_codec_get_pincfg(codec, nid);
5096                 if (snd_hda_get_input_pin_attr(defcfg) == INPUT_PIN_ATTR_INT)
5097                         continue;
5098                 return nid;
5099         }
5100
5101         return 0;
5102 }
5103
5104 static void alc271_hp_gate_mic_jack(struct hda_codec *codec,
5105                                     const struct hda_fixup *fix,
5106                                     int action)
5107 {
5108         struct alc_spec *spec = codec->spec;
5109
5110         if (action == HDA_FIXUP_ACT_PROBE) {
5111                 int mic_pin = find_ext_mic_pin(codec);
5112                 int hp_pin = spec->gen.autocfg.hp_pins[0];
5113
5114                 if (snd_BUG_ON(!mic_pin || !hp_pin))
5115                         return;
5116                 snd_hda_jack_set_gating_jack(codec, mic_pin, hp_pin);
5117         }
5118 }
5119
5120 static void alc269_fixup_limit_int_mic_boost(struct hda_codec *codec,
5121                                              const struct hda_fixup *fix,
5122                                              int action)
5123 {
5124         struct alc_spec *spec = codec->spec;
5125         struct auto_pin_cfg *cfg = &spec->gen.autocfg;
5126         int i;
5127
5128         /* The mic boosts on level 2 and 3 are too noisy
5129            on the internal mic input.
5130            Therefore limit the boost to 0 or 1. */
5131
5132         if (action != HDA_FIXUP_ACT_PROBE)
5133                 return;
5134
5135         for (i = 0; i < cfg->num_inputs; i++) {
5136                 hda_nid_t nid = cfg->inputs[i].pin;
5137                 unsigned int defcfg;
5138                 if (cfg->inputs[i].type != AUTO_PIN_MIC)
5139                         continue;
5140                 defcfg = snd_hda_codec_get_pincfg(codec, nid);
5141                 if (snd_hda_get_input_pin_attr(defcfg) != INPUT_PIN_ATTR_INT)
5142                         continue;
5143
5144                 snd_hda_override_amp_caps(codec, nid, HDA_INPUT,
5145                                           (0x00 << AC_AMPCAP_OFFSET_SHIFT) |
5146                                           (0x01 << AC_AMPCAP_NUM_STEPS_SHIFT) |
5147                                           (0x2f << AC_AMPCAP_STEP_SIZE_SHIFT) |
5148                                           (0 << AC_AMPCAP_MUTE_SHIFT));
5149         }
5150 }
5151
5152 static void alc283_hp_automute_hook(struct hda_codec *codec,
5153                                     struct hda_jack_callback *jack)
5154 {
5155         struct alc_spec *spec = codec->spec;
5156         int vref;
5157
5158         msleep(200);
5159         snd_hda_gen_hp_automute(codec, jack);
5160
5161         vref = spec->gen.hp_jack_present ? PIN_VREF80 : 0;
5162
5163         msleep(600);
5164         snd_hda_codec_write(codec, 0x19, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
5165                             vref);
5166 }
5167
5168 static void alc283_fixup_chromebook(struct hda_codec *codec,
5169                                     const struct hda_fixup *fix, int action)
5170 {
5171         struct alc_spec *spec = codec->spec;
5172
5173         switch (action) {
5174         case HDA_FIXUP_ACT_PRE_PROBE:
5175                 snd_hda_override_wcaps(codec, 0x03, 0);
5176                 /* Disable AA-loopback as it causes white noise */
5177                 spec->gen.mixer_nid = 0;
5178                 break;
5179         case HDA_FIXUP_ACT_INIT:
5180                 /* MIC2-VREF control */
5181                 /* Set to manual mode */
5182                 alc_update_coef_idx(codec, 0x06, 0x000c, 0);
5183                 /* Enable Line1 input control by verb */
5184                 alc_update_coef_idx(codec, 0x1a, 0, 1 << 4);
5185                 break;
5186         }
5187 }
5188
5189 static void alc283_fixup_sense_combo_jack(struct hda_codec *codec,
5190                                     const struct hda_fixup *fix, int action)
5191 {
5192         struct alc_spec *spec = codec->spec;
5193
5194         switch (action) {
5195         case HDA_FIXUP_ACT_PRE_PROBE:
5196                 spec->gen.hp_automute_hook = alc283_hp_automute_hook;
5197                 break;
5198         case HDA_FIXUP_ACT_INIT:
5199                 /* MIC2-VREF control */
5200                 /* Set to manual mode */
5201                 alc_update_coef_idx(codec, 0x06, 0x000c, 0);
5202                 break;
5203         }
5204 }
5205
5206 /* mute tablet speaker pin (0x14) via dock plugging in addition */
5207 static void asus_tx300_automute(struct hda_codec *codec)
5208 {
5209         struct alc_spec *spec = codec->spec;
5210         snd_hda_gen_update_outputs(codec);
5211         if (snd_hda_jack_detect(codec, 0x1b))
5212                 spec->gen.mute_bits |= (1ULL << 0x14);
5213 }
5214
5215 static void alc282_fixup_asus_tx300(struct hda_codec *codec,
5216                                     const struct hda_fixup *fix, int action)
5217 {
5218         struct alc_spec *spec = codec->spec;
5219         static const struct hda_pintbl dock_pins[] = {
5220                 { 0x1b, 0x21114000 }, /* dock speaker pin */
5221                 {}
5222         };
5223
5224         switch (action) {
5225         case HDA_FIXUP_ACT_PRE_PROBE:
5226                 spec->init_amp = ALC_INIT_DEFAULT;
5227                 /* TX300 needs to set up GPIO2 for the speaker amp */
5228                 alc_setup_gpio(codec, 0x04);
5229                 snd_hda_apply_pincfgs(codec, dock_pins);
5230                 spec->gen.auto_mute_via_amp = 1;
5231                 spec->gen.automute_hook = asus_tx300_automute;
5232                 snd_hda_jack_detect_enable_callback(codec, 0x1b,
5233                                                     snd_hda_gen_hp_automute);
5234                 break;
5235         case HDA_FIXUP_ACT_PROBE:
5236                 spec->init_amp = ALC_INIT_DEFAULT;
5237                 break;
5238         case HDA_FIXUP_ACT_BUILD:
5239                 /* this is a bit tricky; give more sane names for the main
5240                  * (tablet) speaker and the dock speaker, respectively
5241                  */
5242                 rename_ctl(codec, "Speaker Playback Switch",
5243                            "Dock Speaker Playback Switch");
5244                 rename_ctl(codec, "Bass Speaker Playback Switch",
5245                            "Speaker Playback Switch");
5246                 break;
5247         }
5248 }
5249
5250 static void alc290_fixup_mono_speakers(struct hda_codec *codec,
5251                                        const struct hda_fixup *fix, int action)
5252 {
5253         if (action == HDA_FIXUP_ACT_PRE_PROBE) {
5254                 /* DAC node 0x03 is giving mono output. We therefore want to
5255                    make sure 0x14 (front speaker) and 0x15 (headphones) use the
5256                    stereo DAC, while leaving 0x17 (bass speaker) for node 0x03. */
5257                 hda_nid_t conn1[2] = { 0x0c };
5258                 snd_hda_override_conn_list(codec, 0x14, 1, conn1);
5259                 snd_hda_override_conn_list(codec, 0x15, 1, conn1);
5260         }
5261 }
5262
5263 static void alc298_fixup_speaker_volume(struct hda_codec *codec,
5264                                         const struct hda_fixup *fix, int action)
5265 {
5266         if (action == HDA_FIXUP_ACT_PRE_PROBE) {
5267                 /* The speaker is routed to the Node 0x06 by a mistake, as a result
5268                    we can't adjust the speaker's volume since this node does not has
5269                    Amp-out capability. we change the speaker's route to:
5270                    Node 0x02 (Audio Output) -> Node 0x0c (Audio Mixer) -> Node 0x17 (
5271                    Pin Complex), since Node 0x02 has Amp-out caps, we can adjust
5272                    speaker's volume now. */
5273
5274                 hda_nid_t conn1[1] = { 0x0c };
5275                 snd_hda_override_conn_list(codec, 0x17, 1, conn1);
5276         }
5277 }
5278
5279 /* disable DAC3 (0x06) selection on NID 0x17 as it has no volume amp control */
5280 static void alc295_fixup_disable_dac3(struct hda_codec *codec,
5281                                       const struct hda_fixup *fix, int action)
5282 {
5283         if (action == HDA_FIXUP_ACT_PRE_PROBE) {
5284                 hda_nid_t conn[2] = { 0x02, 0x03 };
5285                 snd_hda_override_conn_list(codec, 0x17, 2, conn);
5286         }
5287 }
5288
5289 /* Hook to update amp GPIO4 for automute */
5290 static void alc280_hp_gpio4_automute_hook(struct hda_codec *codec,
5291                                           struct hda_jack_callback *jack)
5292 {
5293         struct alc_spec *spec = codec->spec;
5294
5295         snd_hda_gen_hp_automute(codec, jack);
5296         /* mute_led_polarity is set to 0, so we pass inverted value here */
5297         alc_update_gpio_led(codec, 0x10, !spec->gen.hp_jack_present);
5298 }
5299
5300 /* Manage GPIOs for HP EliteBook Folio 9480m.
5301  *
5302  * GPIO4 is the headphone amplifier power control
5303  * GPIO3 is the audio output mute indicator LED
5304  */
5305
5306 static void alc280_fixup_hp_9480m(struct hda_codec *codec,
5307                                   const struct hda_fixup *fix,
5308                                   int action)
5309 {
5310         struct alc_spec *spec = codec->spec;
5311
5312         alc_fixup_hp_gpio_led(codec, action, 0x08, 0);
5313         if (action == HDA_FIXUP_ACT_PRE_PROBE) {
5314                 /* amp at GPIO4; toggled via alc280_hp_gpio4_automute_hook() */
5315                 spec->gpio_mask |= 0x10;
5316                 spec->gpio_dir |= 0x10;
5317                 spec->gen.hp_automute_hook = alc280_hp_gpio4_automute_hook;
5318         }
5319 }
5320
5321 static void alc275_fixup_gpio4_off(struct hda_codec *codec,
5322                                    const struct hda_fixup *fix,
5323                                    int action)
5324 {
5325         struct alc_spec *spec = codec->spec;
5326
5327         if (action == HDA_FIXUP_ACT_PRE_PROBE) {
5328                 spec->gpio_mask |= 0x04;
5329                 spec->gpio_dir |= 0x04;
5330                 /* set data bit low */
5331         }
5332 }
5333
5334 static void alc233_alc662_fixup_lenovo_dual_codecs(struct hda_codec *codec,
5335                                          const struct hda_fixup *fix,
5336                                          int action)
5337 {
5338         alc_fixup_dual_codecs(codec, fix, action);
5339         switch (action) {
5340         case HDA_FIXUP_ACT_PRE_PROBE:
5341                 /* override card longname to provide a unique UCM profile */
5342                 strcpy(codec->card->longname, "HDAudio-Lenovo-DualCodecs");
5343                 break;
5344         case HDA_FIXUP_ACT_BUILD:
5345                 /* rename Capture controls depending on the codec */
5346                 rename_ctl(codec, "Capture Volume",
5347                            codec->addr == 0 ?
5348                            "Rear-Panel Capture Volume" :
5349                            "Front-Panel Capture Volume");
5350                 rename_ctl(codec, "Capture Switch",
5351                            codec->addr == 0 ?
5352                            "Rear-Panel Capture Switch" :
5353                            "Front-Panel Capture Switch");
5354                 break;
5355         }
5356 }
5357
5358 /* Forcibly assign NID 0x03 to HP/LO while NID 0x02 to SPK for EQ */
5359 static void alc274_fixup_bind_dacs(struct hda_codec *codec,
5360                                     const struct hda_fixup *fix, int action)
5361 {
5362         struct alc_spec *spec = codec->spec;
5363         static hda_nid_t preferred_pairs[] = {
5364                 0x21, 0x03, 0x1b, 0x03, 0x16, 0x02,
5365                 0
5366         };
5367
5368         if (action != HDA_FIXUP_ACT_PRE_PROBE)
5369                 return;
5370
5371         spec->gen.preferred_dacs = preferred_pairs;
5372 }
5373
5374 /* The DAC of NID 0x3 will introduce click/pop noise on headphones, so invalidate it */
5375 static void alc285_fixup_invalidate_dacs(struct hda_codec *codec,
5376                               const struct hda_fixup *fix, int action)
5377 {
5378         if (action != HDA_FIXUP_ACT_PRE_PROBE)
5379                 return;
5380
5381         snd_hda_override_wcaps(codec, 0x03, 0);
5382 }
5383
5384 static const struct hda_jack_keymap alc_headset_btn_keymap[] = {
5385         { SND_JACK_BTN_0, KEY_PLAYPAUSE },
5386         { SND_JACK_BTN_1, KEY_VOICECOMMAND },
5387         { SND_JACK_BTN_2, KEY_VOLUMEUP },
5388         { SND_JACK_BTN_3, KEY_VOLUMEDOWN },
5389         {}
5390 };
5391
5392 static void alc_headset_btn_callback(struct hda_codec *codec,
5393                                      struct hda_jack_callback *jack)
5394 {
5395         int report = 0;
5396
5397         if (jack->unsol_res & (7 << 13))
5398                 report |= SND_JACK_BTN_0;
5399
5400         if (jack->unsol_res  & (1 << 16 | 3 << 8))
5401                 report |= SND_JACK_BTN_1;
5402
5403         /* Volume up key */
5404         if (jack->unsol_res & (7 << 23))
5405                 report |= SND_JACK_BTN_2;
5406
5407         /* Volume down key */
5408         if (jack->unsol_res & (7 << 10))
5409                 report |= SND_JACK_BTN_3;
5410
5411         jack->jack->button_state = report;
5412 }
5413
5414 static void alc_fixup_headset_jack(struct hda_codec *codec,
5415                                     const struct hda_fixup *fix, int action)
5416 {
5417
5418         switch (action) {
5419         case HDA_FIXUP_ACT_PRE_PROBE:
5420                 snd_hda_jack_detect_enable_callback(codec, 0x55,
5421                                                     alc_headset_btn_callback);
5422                 snd_hda_jack_add_kctl(codec, 0x55, "Headset Jack", false,
5423                                       SND_JACK_HEADSET, alc_headset_btn_keymap);
5424                 break;
5425         case HDA_FIXUP_ACT_INIT:
5426                 switch (codec->core.vendor_id) {
5427                 case 0x10ec0225:
5428                 case 0x10ec0295:
5429                 case 0x10ec0299:
5430                         alc_write_coef_idx(codec, 0x48, 0xd011);
5431                         alc_update_coef_idx(codec, 0x49, 0x007f, 0x0045);
5432                         alc_update_coef_idx(codec, 0x44, 0x007f << 8, 0x0045 << 8);
5433                         break;
5434                 case 0x10ec0236:
5435                 case 0x10ec0256:
5436                         alc_write_coef_idx(codec, 0x48, 0xd011);
5437                         alc_update_coef_idx(codec, 0x49, 0x007f, 0x0045);
5438                         break;
5439                 }
5440                 break;
5441         }
5442 }
5443
5444 static void alc_fixup_disable_mic_vref(struct hda_codec *codec,
5445                                   const struct hda_fixup *fix, int action)
5446 {
5447         if (action == HDA_FIXUP_ACT_PRE_PROBE)
5448                 snd_hda_codec_set_pin_target(codec, 0x19, PIN_VREFHIZ);
5449 }
5450
5451 /* for hda_fixup_thinkpad_acpi() */
5452 #include "thinkpad_helper.c"
5453
5454 static void alc_fixup_thinkpad_acpi(struct hda_codec *codec,
5455                                     const struct hda_fixup *fix, int action)
5456 {
5457         alc_fixup_no_shutup(codec, fix, action); /* reduce click noise */
5458         hda_fixup_thinkpad_acpi(codec, fix, action);
5459 }
5460
5461 /* for alc295_fixup_hp_top_speakers */
5462 #include "hp_x360_helper.c"
5463
5464 enum {
5465         ALC269_FIXUP_SONY_VAIO,
5466         ALC275_FIXUP_SONY_VAIO_GPIO2,
5467         ALC269_FIXUP_DELL_M101Z,
5468         ALC269_FIXUP_SKU_IGNORE,
5469         ALC269_FIXUP_ASUS_G73JW,
5470         ALC269_FIXUP_LENOVO_EAPD,
5471         ALC275_FIXUP_SONY_HWEQ,
5472         ALC275_FIXUP_SONY_DISABLE_AAMIX,
5473         ALC271_FIXUP_DMIC,
5474         ALC269_FIXUP_PCM_44K,
5475         ALC269_FIXUP_STEREO_DMIC,
5476         ALC269_FIXUP_HEADSET_MIC,
5477         ALC269_FIXUP_QUANTA_MUTE,
5478         ALC269_FIXUP_LIFEBOOK,
5479         ALC269_FIXUP_LIFEBOOK_EXTMIC,
5480         ALC269_FIXUP_LIFEBOOK_HP_PIN,
5481         ALC269_FIXUP_LIFEBOOK_NO_HP_TO_LINEOUT,
5482         ALC255_FIXUP_LIFEBOOK_U7x7_HEADSET_MIC,
5483         ALC269_FIXUP_AMIC,
5484         ALC269_FIXUP_DMIC,
5485         ALC269VB_FIXUP_AMIC,
5486         ALC269VB_FIXUP_DMIC,
5487         ALC269_FIXUP_HP_MUTE_LED,
5488         ALC269_FIXUP_HP_MUTE_LED_MIC1,
5489         ALC269_FIXUP_HP_MUTE_LED_MIC2,
5490         ALC269_FIXUP_HP_MUTE_LED_MIC3,
5491         ALC269_FIXUP_HP_GPIO_LED,
5492         ALC269_FIXUP_HP_GPIO_MIC1_LED,
5493         ALC269_FIXUP_HP_LINE1_MIC1_LED,
5494         ALC269_FIXUP_INV_DMIC,
5495         ALC269_FIXUP_LENOVO_DOCK,
5496         ALC269_FIXUP_NO_SHUTUP,
5497         ALC286_FIXUP_SONY_MIC_NO_PRESENCE,
5498         ALC269_FIXUP_PINCFG_NO_HP_TO_LINEOUT,
5499         ALC269_FIXUP_DELL1_MIC_NO_PRESENCE,
5500         ALC269_FIXUP_DELL2_MIC_NO_PRESENCE,
5501         ALC269_FIXUP_DELL3_MIC_NO_PRESENCE,
5502         ALC269_FIXUP_DELL4_MIC_NO_PRESENCE,
5503         ALC269_FIXUP_HEADSET_MODE,
5504         ALC269_FIXUP_HEADSET_MODE_NO_HP_MIC,
5505         ALC269_FIXUP_ASPIRE_HEADSET_MIC,
5506         ALC269_FIXUP_ASUS_X101_FUNC,
5507         ALC269_FIXUP_ASUS_X101_VERB,
5508         ALC269_FIXUP_ASUS_X101,
5509         ALC271_FIXUP_AMIC_MIC2,
5510         ALC271_FIXUP_HP_GATE_MIC_JACK,
5511         ALC271_FIXUP_HP_GATE_MIC_JACK_E1_572,
5512         ALC269_FIXUP_ACER_AC700,
5513         ALC269_FIXUP_LIMIT_INT_MIC_BOOST,
5514         ALC269VB_FIXUP_ASUS_ZENBOOK,
5515         ALC269VB_FIXUP_ASUS_ZENBOOK_UX31A,
5516         ALC269_FIXUP_LIMIT_INT_MIC_BOOST_MUTE_LED,
5517         ALC269VB_FIXUP_ORDISSIMO_EVE2,
5518         ALC283_FIXUP_CHROME_BOOK,
5519         ALC283_FIXUP_SENSE_COMBO_JACK,
5520         ALC282_FIXUP_ASUS_TX300,
5521         ALC283_FIXUP_INT_MIC,
5522         ALC290_FIXUP_MONO_SPEAKERS,
5523         ALC290_FIXUP_MONO_SPEAKERS_HSJACK,
5524         ALC290_FIXUP_SUBWOOFER,
5525         ALC290_FIXUP_SUBWOOFER_HSJACK,
5526         ALC269_FIXUP_THINKPAD_ACPI,
5527         ALC269_FIXUP_DMIC_THINKPAD_ACPI,
5528         ALC255_FIXUP_ACER_MIC_NO_PRESENCE,
5529         ALC255_FIXUP_ASUS_MIC_NO_PRESENCE,
5530         ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
5531         ALC255_FIXUP_DELL2_MIC_NO_PRESENCE,
5532         ALC255_FIXUP_HEADSET_MODE,
5533         ALC255_FIXUP_HEADSET_MODE_NO_HP_MIC,
5534         ALC293_FIXUP_DELL1_MIC_NO_PRESENCE,
5535         ALC292_FIXUP_TPT440_DOCK,
5536         ALC292_FIXUP_TPT440,
5537         ALC283_FIXUP_HEADSET_MIC,
5538         ALC255_FIXUP_MIC_MUTE_LED,
5539         ALC282_FIXUP_ASPIRE_V5_PINS,
5540         ALC280_FIXUP_HP_GPIO4,
5541         ALC286_FIXUP_HP_GPIO_LED,
5542         ALC280_FIXUP_HP_GPIO2_MIC_HOTKEY,
5543         ALC280_FIXUP_HP_DOCK_PINS,
5544         ALC269_FIXUP_HP_DOCK_GPIO_MIC1_LED,
5545         ALC280_FIXUP_HP_9480M,
5546         ALC288_FIXUP_DELL_HEADSET_MODE,
5547         ALC288_FIXUP_DELL1_MIC_NO_PRESENCE,
5548         ALC288_FIXUP_DELL_XPS_13,
5549         ALC288_FIXUP_DISABLE_AAMIX,
5550         ALC292_FIXUP_DELL_E7X,
5551         ALC292_FIXUP_DISABLE_AAMIX,
5552         ALC293_FIXUP_DISABLE_AAMIX_MULTIJACK,
5553         ALC298_FIXUP_DELL1_MIC_NO_PRESENCE,
5554         ALC298_FIXUP_DELL_AIO_MIC_NO_PRESENCE,
5555         ALC275_FIXUP_DELL_XPS,
5556         ALC256_FIXUP_DELL_XPS_13_HEADPHONE_NOISE,
5557         ALC293_FIXUP_LENOVO_SPK_NOISE,
5558         ALC233_FIXUP_LENOVO_LINE2_MIC_HOTKEY,
5559         ALC255_FIXUP_DELL_SPK_NOISE,
5560         ALC225_FIXUP_DISABLE_MIC_VREF,
5561         ALC225_FIXUP_DELL1_MIC_NO_PRESENCE,
5562         ALC295_FIXUP_DISABLE_DAC3,
5563         ALC280_FIXUP_HP_HEADSET_MIC,
5564         ALC221_FIXUP_HP_FRONT_MIC,
5565         ALC292_FIXUP_TPT460,
5566         ALC298_FIXUP_SPK_VOLUME,
5567         ALC256_FIXUP_DELL_INSPIRON_7559_SUBWOOFER,
5568         ALC269_FIXUP_ATIV_BOOK_8,
5569         ALC221_FIXUP_HP_MIC_NO_PRESENCE,
5570         ALC256_FIXUP_ASUS_HEADSET_MODE,
5571         ALC256_FIXUP_ASUS_MIC,
5572         ALC256_FIXUP_ASUS_AIO_GPIO2,
5573         ALC233_FIXUP_ASUS_MIC_NO_PRESENCE,
5574         ALC233_FIXUP_EAPD_COEF_AND_MIC_NO_PRESENCE,
5575         ALC233_FIXUP_LENOVO_MULTI_CODECS,
5576         ALC294_FIXUP_LENOVO_MIC_LOCATION,
5577         ALC225_FIXUP_DELL_WYSE_MIC_NO_PRESENCE,
5578         ALC700_FIXUP_INTEL_REFERENCE,
5579         ALC274_FIXUP_DELL_BIND_DACS,
5580         ALC274_FIXUP_DELL_AIO_LINEOUT_VERB,
5581         ALC298_FIXUP_TPT470_DOCK,
5582         ALC255_FIXUP_DUMMY_LINEOUT_VERB,
5583         ALC255_FIXUP_DELL_HEADSET_MIC,
5584         ALC256_FIXUP_HUAWEI_MBXP_PINS,
5585         ALC295_FIXUP_HP_X360,
5586         ALC221_FIXUP_HP_HEADSET_MIC,
5587         ALC285_FIXUP_LENOVO_HEADPHONE_NOISE,
5588         ALC295_FIXUP_HP_AUTO_MUTE,
5589         ALC286_FIXUP_ACER_AIO_MIC_NO_PRESENCE,
5590         ALC294_FIXUP_ASUS_MIC,
5591         ALC294_FIXUP_ASUS_HEADSET_MIC,
5592         ALC294_FIXUP_ASUS_SPK,
5593         ALC225_FIXUP_HEADSET_JACK,
5594 };
5595
5596 static const struct hda_fixup alc269_fixups[] = {
5597         [ALC269_FIXUP_SONY_VAIO] = {
5598                 .type = HDA_FIXUP_PINCTLS,
5599                 .v.pins = (const struct hda_pintbl[]) {
5600                         {0x19, PIN_VREFGRD},
5601                         {}
5602                 }
5603         },
5604         [ALC275_FIXUP_SONY_VAIO_GPIO2] = {
5605                 .type = HDA_FIXUP_FUNC,
5606                 .v.func = alc275_fixup_gpio4_off,
5607                 .chained = true,
5608                 .chain_id = ALC269_FIXUP_SONY_VAIO
5609         },
5610         [ALC269_FIXUP_DELL_M101Z] = {
5611                 .type = HDA_FIXUP_VERBS,
5612                 .v.verbs = (const struct hda_verb[]) {
5613                         /* Enables internal speaker */
5614                         {0x20, AC_VERB_SET_COEF_INDEX, 13},
5615                         {0x20, AC_VERB_SET_PROC_COEF, 0x4040},
5616                         {}
5617                 }
5618         },
5619         [ALC269_FIXUP_SKU_IGNORE] = {
5620                 .type = HDA_FIXUP_FUNC,
5621                 .v.func = alc_fixup_sku_ignore,
5622         },
5623         [ALC269_FIXUP_ASUS_G73JW] = {
5624                 .type = HDA_FIXUP_PINS,
5625                 .v.pins = (const struct hda_pintbl[]) {
5626                         { 0x17, 0x99130111 }, /* subwoofer */
5627                         { }
5628                 }
5629         },
5630         [ALC269_FIXUP_LENOVO_EAPD] = {
5631                 .type = HDA_FIXUP_VERBS,
5632                 .v.verbs = (const struct hda_verb[]) {
5633                         {0x14, AC_VERB_SET_EAPD_BTLENABLE, 0},
5634                         {}
5635                 }
5636         },
5637         [ALC275_FIXUP_SONY_HWEQ] = {
5638                 .type = HDA_FIXUP_FUNC,
5639                 .v.func = alc269_fixup_hweq,
5640                 .chained = true,
5641                 .chain_id = ALC275_FIXUP_SONY_VAIO_GPIO2
5642         },
5643         [ALC275_FIXUP_SONY_DISABLE_AAMIX] = {
5644                 .type = HDA_FIXUP_FUNC,
5645                 .v.func = alc_fixup_disable_aamix,
5646                 .chained = true,
5647                 .chain_id = ALC269_FIXUP_SONY_VAIO
5648         },
5649         [ALC271_FIXUP_DMIC] = {
5650                 .type = HDA_FIXUP_FUNC,
5651                 .v.func = alc271_fixup_dmic,
5652         },
5653         [ALC269_FIXUP_PCM_44K] = {
5654                 .type = HDA_FIXUP_FUNC,
5655                 .v.func = alc269_fixup_pcm_44k,
5656                 .chained = true,
5657                 .chain_id = ALC269_FIXUP_QUANTA_MUTE
5658         },
5659         [ALC269_FIXUP_STEREO_DMIC] = {
5660                 .type = HDA_FIXUP_FUNC,
5661                 .v.func = alc269_fixup_stereo_dmic,
5662         },
5663         [ALC269_FIXUP_HEADSET_MIC] = {
5664                 .type = HDA_FIXUP_FUNC,
5665                 .v.func = alc269_fixup_headset_mic,
5666         },
5667         [ALC269_FIXUP_QUANTA_MUTE] = {
5668                 .type = HDA_FIXUP_FUNC,
5669                 .v.func = alc269_fixup_quanta_mute,
5670         },
5671         [ALC269_FIXUP_LIFEBOOK] = {
5672                 .type = HDA_FIXUP_PINS,
5673                 .v.pins = (const struct hda_pintbl[]) {
5674                         { 0x1a, 0x2101103f }, /* dock line-out */
5675                         { 0x1b, 0x23a11040 }, /* dock mic-in */
5676                         { }
5677                 },
5678                 .chained = true,
5679                 .chain_id = ALC269_FIXUP_QUANTA_MUTE
5680         },
5681         [ALC269_FIXUP_LIFEBOOK_EXTMIC] = {
5682                 .type = HDA_FIXUP_PINS,
5683                 .v.pins = (const struct hda_pintbl[]) {
5684                         { 0x19, 0x01a1903c }, /* headset mic, with jack detect */
5685                         { }
5686                 },
5687         },
5688         [ALC269_FIXUP_LIFEBOOK_HP_PIN] = {
5689                 .type = HDA_FIXUP_PINS,
5690                 .v.pins = (const struct hda_pintbl[]) {
5691                         { 0x21, 0x0221102f }, /* HP out */
5692                         { }
5693                 },
5694         },
5695         [ALC269_FIXUP_LIFEBOOK_NO_HP_TO_LINEOUT] = {
5696                 .type = HDA_FIXUP_FUNC,
5697                 .v.func = alc269_fixup_pincfg_no_hp_to_lineout,
5698         },
5699         [ALC255_FIXUP_LIFEBOOK_U7x7_HEADSET_MIC] = {
5700                 .type = HDA_FIXUP_FUNC,
5701                 .v.func = alc269_fixup_pincfg_U7x7_headset_mic,
5702         },
5703         [ALC269_FIXUP_AMIC] = {
5704                 .type = HDA_FIXUP_PINS,
5705                 .v.pins = (const struct hda_pintbl[]) {
5706                         { 0x14, 0x99130110 }, /* speaker */
5707                         { 0x15, 0x0121401f }, /* HP out */
5708                         { 0x18, 0x01a19c20 }, /* mic */
5709                         { 0x19, 0x99a3092f }, /* int-mic */
5710                         { }
5711                 },
5712         },
5713         [ALC269_FIXUP_DMIC] = {
5714                 .type = HDA_FIXUP_PINS,
5715                 .v.pins = (const struct hda_pintbl[]) {
5716                         { 0x12, 0x99a3092f }, /* int-mic */
5717                         { 0x14, 0x99130110 }, /* speaker */
5718                         { 0x15, 0x0121401f }, /* HP out */
5719                         { 0x18, 0x01a19c20 }, /* mic */
5720                         { }
5721                 },
5722         },
5723         [ALC269VB_FIXUP_AMIC] = {
5724                 .type = HDA_FIXUP_PINS,
5725                 .v.pins = (const struct hda_pintbl[]) {
5726                         { 0x14, 0x99130110 }, /* speaker */
5727                         { 0x18, 0x01a19c20 }, /* mic */
5728                         { 0x19, 0x99a3092f }, /* int-mic */
5729                         { 0x21, 0x0121401f }, /* HP out */
5730                         { }
5731                 },
5732         },
5733         [ALC269VB_FIXUP_DMIC] = {
5734                 .type = HDA_FIXUP_PINS,
5735                 .v.pins = (const struct hda_pintbl[]) {
5736                         { 0x12, 0x99a3092f }, /* int-mic */
5737                         { 0x14, 0x99130110 }, /* speaker */
5738                         { 0x18, 0x01a19c20 }, /* mic */
5739                         { 0x21, 0x0121401f }, /* HP out */
5740                         { }
5741                 },
5742         },
5743         [ALC269_FIXUP_HP_MUTE_LED] = {
5744                 .type = HDA_FIXUP_FUNC,
5745                 .v.func = alc269_fixup_hp_mute_led,
5746         },
5747         [ALC269_FIXUP_HP_MUTE_LED_MIC1] = {
5748                 .type = HDA_FIXUP_FUNC,
5749                 .v.func = alc269_fixup_hp_mute_led_mic1,
5750         },
5751         [ALC269_FIXUP_HP_MUTE_LED_MIC2] = {
5752                 .type = HDA_FIXUP_FUNC,
5753                 .v.func = alc269_fixup_hp_mute_led_mic2,
5754         },
5755         [ALC269_FIXUP_HP_MUTE_LED_MIC3] = {
5756                 .type = HDA_FIXUP_FUNC,
5757                 .v.func = alc269_fixup_hp_mute_led_mic3,
5758                 .chained = true,
5759                 .chain_id = ALC295_FIXUP_HP_AUTO_MUTE
5760         },
5761         [ALC269_FIXUP_HP_GPIO_LED] = {
5762                 .type = HDA_FIXUP_FUNC,
5763                 .v.func = alc269_fixup_hp_gpio_led,
5764         },
5765         [ALC269_FIXUP_HP_GPIO_MIC1_LED] = {
5766                 .type = HDA_FIXUP_FUNC,
5767                 .v.func = alc269_fixup_hp_gpio_mic1_led,
5768         },
5769         [ALC269_FIXUP_HP_LINE1_MIC1_LED] = {
5770                 .type = HDA_FIXUP_FUNC,
5771                 .v.func = alc269_fixup_hp_line1_mic1_led,
5772         },
5773         [ALC269_FIXUP_INV_DMIC] = {
5774                 .type = HDA_FIXUP_FUNC,
5775                 .v.func = alc_fixup_inv_dmic,
5776         },
5777         [ALC269_FIXUP_NO_SHUTUP] = {
5778                 .type = HDA_FIXUP_FUNC,
5779                 .v.func = alc_fixup_no_shutup,
5780         },
5781         [ALC269_FIXUP_LENOVO_DOCK] = {
5782                 .type = HDA_FIXUP_PINS,
5783                 .v.pins = (const struct hda_pintbl[]) {
5784                         { 0x19, 0x23a11040 }, /* dock mic */
5785                         { 0x1b, 0x2121103f }, /* dock headphone */
5786                         { }
5787                 },
5788                 .chained = true,
5789                 .chain_id = ALC269_FIXUP_PINCFG_NO_HP_TO_LINEOUT
5790         },
5791         [ALC269_FIXUP_PINCFG_NO_HP_TO_LINEOUT] = {
5792                 .type = HDA_FIXUP_FUNC,
5793                 .v.func = alc269_fixup_pincfg_no_hp_to_lineout,
5794                 .chained = true,
5795                 .chain_id = ALC269_FIXUP_THINKPAD_ACPI,
5796         },
5797         [ALC269_FIXUP_DELL1_MIC_NO_PRESENCE] = {
5798                 .type = HDA_FIXUP_PINS,
5799                 .v.pins = (const struct hda_pintbl[]) {
5800                         { 0x19, 0x01a1913c }, /* use as headset mic, without its own jack detect */
5801                         { 0x1a, 0x01a1913d }, /* use as headphone mic, without its own jack detect */
5802                         { }
5803                 },
5804                 .chained = true,
5805                 .chain_id = ALC269_FIXUP_HEADSET_MODE
5806         },
5807         [ALC269_FIXUP_DELL2_MIC_NO_PRESENCE] = {
5808                 .type = HDA_FIXUP_PINS,
5809                 .v.pins = (const struct hda_pintbl[]) {
5810                         { 0x16, 0x21014020 }, /* dock line out */
5811                         { 0x19, 0x21a19030 }, /* dock mic */
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_DELL3_MIC_NO_PRESENCE] = {
5819                 .type = HDA_FIXUP_PINS,
5820                 .v.pins = (const struct hda_pintbl[]) {
5821                         { 0x1a, 0x01a1913c }, /* use as headset mic, without its own jack detect */
5822                         { }
5823                 },
5824                 .chained = true,
5825                 .chain_id = ALC269_FIXUP_HEADSET_MODE_NO_HP_MIC
5826         },
5827         [ALC269_FIXUP_DELL4_MIC_NO_PRESENCE] = {
5828                 .type = HDA_FIXUP_PINS,
5829                 .v.pins = (const struct hda_pintbl[]) {
5830                         { 0x19, 0x01a1913c }, /* use as headset mic, without its own jack detect */
5831                         { 0x1b, 0x01a1913d }, /* use as headphone mic, without its own jack detect */
5832                         { }
5833                 },
5834                 .chained = true,
5835                 .chain_id = ALC269_FIXUP_HEADSET_MODE
5836         },
5837         [ALC269_FIXUP_HEADSET_MODE] = {
5838                 .type = HDA_FIXUP_FUNC,
5839                 .v.func = alc_fixup_headset_mode,
5840                 .chained = true,
5841                 .chain_id = ALC255_FIXUP_MIC_MUTE_LED
5842         },
5843         [ALC269_FIXUP_HEADSET_MODE_NO_HP_MIC] = {
5844                 .type = HDA_FIXUP_FUNC,
5845                 .v.func = alc_fixup_headset_mode_no_hp_mic,
5846         },
5847         [ALC269_FIXUP_ASPIRE_HEADSET_MIC] = {
5848                 .type = HDA_FIXUP_PINS,
5849                 .v.pins = (const struct hda_pintbl[]) {
5850                         { 0x19, 0x01a1913c }, /* headset mic w/o jack detect */
5851                         { }
5852                 },
5853                 .chained = true,
5854                 .chain_id = ALC269_FIXUP_HEADSET_MODE,
5855         },
5856         [ALC286_FIXUP_SONY_MIC_NO_PRESENCE] = {
5857                 .type = HDA_FIXUP_PINS,
5858                 .v.pins = (const struct hda_pintbl[]) {
5859                         { 0x18, 0x01a1913c }, /* use as headset mic, without its own jack detect */
5860                         { }
5861                 },
5862                 .chained = true,
5863                 .chain_id = ALC269_FIXUP_HEADSET_MIC
5864         },
5865         [ALC256_FIXUP_HUAWEI_MBXP_PINS] = {
5866                 .type = HDA_FIXUP_PINS,
5867                 .v.pins = (const struct hda_pintbl[]) {
5868                         {0x12, 0x90a60130},
5869                         {0x13, 0x40000000},
5870                         {0x14, 0x90170110},
5871                         {0x18, 0x411111f0},
5872                         {0x19, 0x04a11040},
5873                         {0x1a, 0x411111f0},
5874                         {0x1b, 0x90170112},
5875                         {0x1d, 0x40759a05},
5876                         {0x1e, 0x411111f0},
5877                         {0x21, 0x04211020},
5878                         { }
5879                 },
5880                 .chained = true,
5881                 .chain_id = ALC255_FIXUP_MIC_MUTE_LED
5882         },
5883         [ALC269_FIXUP_ASUS_X101_FUNC] = {
5884                 .type = HDA_FIXUP_FUNC,
5885                 .v.func = alc269_fixup_x101_headset_mic,
5886         },
5887         [ALC269_FIXUP_ASUS_X101_VERB] = {
5888                 .type = HDA_FIXUP_VERBS,
5889                 .v.verbs = (const struct hda_verb[]) {
5890                         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
5891                         {0x20, AC_VERB_SET_COEF_INDEX, 0x08},
5892                         {0x20, AC_VERB_SET_PROC_COEF,  0x0310},
5893                         { }
5894                 },
5895                 .chained = true,
5896                 .chain_id = ALC269_FIXUP_ASUS_X101_FUNC
5897         },
5898         [ALC269_FIXUP_ASUS_X101] = {
5899                 .type = HDA_FIXUP_PINS,
5900                 .v.pins = (const struct hda_pintbl[]) {
5901                         { 0x18, 0x04a1182c }, /* Headset mic */
5902                         { }
5903                 },
5904                 .chained = true,
5905                 .chain_id = ALC269_FIXUP_ASUS_X101_VERB
5906         },
5907         [ALC271_FIXUP_AMIC_MIC2] = {
5908                 .type = HDA_FIXUP_PINS,
5909                 .v.pins = (const struct hda_pintbl[]) {
5910                         { 0x14, 0x99130110 }, /* speaker */
5911                         { 0x19, 0x01a19c20 }, /* mic */
5912                         { 0x1b, 0x99a7012f }, /* int-mic */
5913                         { 0x21, 0x0121401f }, /* HP out */
5914                         { }
5915                 },
5916         },
5917         [ALC271_FIXUP_HP_GATE_MIC_JACK] = {
5918                 .type = HDA_FIXUP_FUNC,
5919                 .v.func = alc271_hp_gate_mic_jack,
5920                 .chained = true,
5921                 .chain_id = ALC271_FIXUP_AMIC_MIC2,
5922         },
5923         [ALC271_FIXUP_HP_GATE_MIC_JACK_E1_572] = {
5924                 .type = HDA_FIXUP_FUNC,
5925                 .v.func = alc269_fixup_limit_int_mic_boost,
5926                 .chained = true,
5927                 .chain_id = ALC271_FIXUP_HP_GATE_MIC_JACK,
5928         },
5929         [ALC269_FIXUP_ACER_AC700] = {
5930                 .type = HDA_FIXUP_PINS,
5931                 .v.pins = (const struct hda_pintbl[]) {
5932                         { 0x12, 0x99a3092f }, /* int-mic */
5933                         { 0x14, 0x99130110 }, /* speaker */
5934                         { 0x18, 0x03a11c20 }, /* mic */
5935                         { 0x1e, 0x0346101e }, /* SPDIF1 */
5936                         { 0x21, 0x0321101f }, /* HP out */
5937                         { }
5938                 },
5939                 .chained = true,
5940                 .chain_id = ALC271_FIXUP_DMIC,
5941         },
5942         [ALC269_FIXUP_LIMIT_INT_MIC_BOOST] = {
5943                 .type = HDA_FIXUP_FUNC,
5944                 .v.func = alc269_fixup_limit_int_mic_boost,
5945                 .chained = true,
5946                 .chain_id = ALC269_FIXUP_THINKPAD_ACPI,
5947         },
5948         [ALC269VB_FIXUP_ASUS_ZENBOOK] = {
5949                 .type = HDA_FIXUP_FUNC,
5950                 .v.func = alc269_fixup_limit_int_mic_boost,
5951                 .chained = true,
5952                 .chain_id = ALC269VB_FIXUP_DMIC,
5953         },
5954         [ALC269VB_FIXUP_ASUS_ZENBOOK_UX31A] = {
5955                 .type = HDA_FIXUP_VERBS,
5956                 .v.verbs = (const struct hda_verb[]) {
5957                         /* class-D output amp +5dB */
5958                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x12 },
5959                         { 0x20, AC_VERB_SET_PROC_COEF, 0x2800 },
5960                         {}
5961                 },
5962                 .chained = true,
5963                 .chain_id = ALC269VB_FIXUP_ASUS_ZENBOOK,
5964         },
5965         [ALC269_FIXUP_LIMIT_INT_MIC_BOOST_MUTE_LED] = {
5966                 .type = HDA_FIXUP_FUNC,
5967                 .v.func = alc269_fixup_limit_int_mic_boost,
5968                 .chained = true,
5969                 .chain_id = ALC269_FIXUP_HP_MUTE_LED_MIC1,
5970         },
5971         [ALC269VB_FIXUP_ORDISSIMO_EVE2] = {
5972                 .type = HDA_FIXUP_PINS,
5973                 .v.pins = (const struct hda_pintbl[]) {
5974                         { 0x12, 0x99a3092f }, /* int-mic */
5975                         { 0x18, 0x03a11d20 }, /* mic */
5976                         { 0x19, 0x411111f0 }, /* Unused bogus pin */
5977                         { }
5978                 },
5979         },
5980         [ALC283_FIXUP_CHROME_BOOK] = {
5981                 .type = HDA_FIXUP_FUNC,
5982                 .v.func = alc283_fixup_chromebook,
5983         },
5984         [ALC283_FIXUP_SENSE_COMBO_JACK] = {
5985                 .type = HDA_FIXUP_FUNC,
5986                 .v.func = alc283_fixup_sense_combo_jack,
5987                 .chained = true,
5988                 .chain_id = ALC283_FIXUP_CHROME_BOOK,
5989         },
5990         [ALC282_FIXUP_ASUS_TX300] = {
5991                 .type = HDA_FIXUP_FUNC,
5992                 .v.func = alc282_fixup_asus_tx300,
5993         },
5994         [ALC283_FIXUP_INT_MIC] = {
5995                 .type = HDA_FIXUP_VERBS,
5996                 .v.verbs = (const struct hda_verb[]) {
5997                         {0x20, AC_VERB_SET_COEF_INDEX, 0x1a},
5998                         {0x20, AC_VERB_SET_PROC_COEF, 0x0011},
5999                         { }
6000                 },
6001                 .chained = true,
6002                 .chain_id = ALC269_FIXUP_LIMIT_INT_MIC_BOOST
6003         },
6004         [ALC290_FIXUP_SUBWOOFER_HSJACK] = {
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_HSJACK,
6012         },
6013         [ALC290_FIXUP_SUBWOOFER] = {
6014                 .type = HDA_FIXUP_PINS,
6015                 .v.pins = (const struct hda_pintbl[]) {
6016                         { 0x17, 0x90170112 }, /* subwoofer */
6017                         { }
6018                 },
6019                 .chained = true,
6020                 .chain_id = ALC290_FIXUP_MONO_SPEAKERS,
6021         },
6022         [ALC290_FIXUP_MONO_SPEAKERS] = {
6023                 .type = HDA_FIXUP_FUNC,
6024                 .v.func = alc290_fixup_mono_speakers,
6025         },
6026         [ALC290_FIXUP_MONO_SPEAKERS_HSJACK] = {
6027                 .type = HDA_FIXUP_FUNC,
6028                 .v.func = alc290_fixup_mono_speakers,
6029                 .chained = true,
6030                 .chain_id = ALC269_FIXUP_DELL3_MIC_NO_PRESENCE,
6031         },
6032         [ALC269_FIXUP_THINKPAD_ACPI] = {
6033                 .type = HDA_FIXUP_FUNC,
6034                 .v.func = alc_fixup_thinkpad_acpi,
6035                 .chained = true,
6036                 .chain_id = ALC269_FIXUP_SKU_IGNORE,
6037         },
6038         [ALC269_FIXUP_DMIC_THINKPAD_ACPI] = {
6039                 .type = HDA_FIXUP_FUNC,
6040                 .v.func = alc_fixup_inv_dmic,
6041                 .chained = true,
6042                 .chain_id = ALC269_FIXUP_THINKPAD_ACPI,
6043         },
6044         [ALC255_FIXUP_ACER_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_ASUS_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                         { }
6058                 },
6059                 .chained = true,
6060                 .chain_id = ALC255_FIXUP_HEADSET_MODE
6061         },
6062         [ALC255_FIXUP_DELL1_MIC_NO_PRESENCE] = {
6063                 .type = HDA_FIXUP_PINS,
6064                 .v.pins = (const struct hda_pintbl[]) {
6065                         { 0x19, 0x01a1913c }, /* use as headset mic, without its own jack detect */
6066                         { 0x1a, 0x01a1913d }, /* use as headphone mic, without its own jack detect */
6067                         { }
6068                 },
6069                 .chained = true,
6070                 .chain_id = ALC255_FIXUP_HEADSET_MODE
6071         },
6072         [ALC255_FIXUP_DELL2_MIC_NO_PRESENCE] = {
6073                 .type = HDA_FIXUP_PINS,
6074                 .v.pins = (const struct hda_pintbl[]) {
6075                         { 0x19, 0x01a1913c }, /* use as headset mic, without its own jack detect */
6076                         { }
6077                 },
6078                 .chained = true,
6079                 .chain_id = ALC255_FIXUP_HEADSET_MODE_NO_HP_MIC
6080         },
6081         [ALC255_FIXUP_HEADSET_MODE] = {
6082                 .type = HDA_FIXUP_FUNC,
6083                 .v.func = alc_fixup_headset_mode_alc255,
6084                 .chained = true,
6085                 .chain_id = ALC255_FIXUP_MIC_MUTE_LED
6086         },
6087         [ALC255_FIXUP_HEADSET_MODE_NO_HP_MIC] = {
6088                 .type = HDA_FIXUP_FUNC,
6089                 .v.func = alc_fixup_headset_mode_alc255_no_hp_mic,
6090         },
6091         [ALC293_FIXUP_DELL1_MIC_NO_PRESENCE] = {
6092                 .type = HDA_FIXUP_PINS,
6093                 .v.pins = (const struct hda_pintbl[]) {
6094                         { 0x18, 0x01a1913d }, /* use as headphone mic, without its own jack detect */
6095                         { 0x1a, 0x01a1913c }, /* use as headset mic, without its own jack detect */
6096                         { }
6097                 },
6098                 .chained = true,
6099                 .chain_id = ALC269_FIXUP_HEADSET_MODE
6100         },
6101         [ALC292_FIXUP_TPT440_DOCK] = {
6102                 .type = HDA_FIXUP_FUNC,
6103                 .v.func = alc_fixup_tpt440_dock,
6104                 .chained = true,
6105                 .chain_id = ALC269_FIXUP_LIMIT_INT_MIC_BOOST
6106         },
6107         [ALC292_FIXUP_TPT440] = {
6108                 .type = HDA_FIXUP_FUNC,
6109                 .v.func = alc_fixup_disable_aamix,
6110                 .chained = true,
6111                 .chain_id = ALC292_FIXUP_TPT440_DOCK,
6112         },
6113         [ALC283_FIXUP_HEADSET_MIC] = {
6114                 .type = HDA_FIXUP_PINS,
6115                 .v.pins = (const struct hda_pintbl[]) {
6116                         { 0x19, 0x04a110f0 },
6117                         { },
6118                 },
6119         },
6120         [ALC255_FIXUP_MIC_MUTE_LED] = {
6121                 .type = HDA_FIXUP_FUNC,
6122                 .v.func = snd_hda_gen_fixup_micmute_led,
6123         },
6124         [ALC282_FIXUP_ASPIRE_V5_PINS] = {
6125                 .type = HDA_FIXUP_PINS,
6126                 .v.pins = (const struct hda_pintbl[]) {
6127                         { 0x12, 0x90a60130 },
6128                         { 0x14, 0x90170110 },
6129                         { 0x17, 0x40000008 },
6130                         { 0x18, 0x411111f0 },
6131                         { 0x19, 0x01a1913c },
6132                         { 0x1a, 0x411111f0 },
6133                         { 0x1b, 0x411111f0 },
6134                         { 0x1d, 0x40f89b2d },
6135                         { 0x1e, 0x411111f0 },
6136                         { 0x21, 0x0321101f },
6137                         { },
6138                 },
6139         },
6140         [ALC280_FIXUP_HP_GPIO4] = {
6141                 .type = HDA_FIXUP_FUNC,
6142                 .v.func = alc280_fixup_hp_gpio4,
6143         },
6144         [ALC286_FIXUP_HP_GPIO_LED] = {
6145                 .type = HDA_FIXUP_FUNC,
6146                 .v.func = alc286_fixup_hp_gpio_led,
6147         },
6148         [ALC280_FIXUP_HP_GPIO2_MIC_HOTKEY] = {
6149                 .type = HDA_FIXUP_FUNC,
6150                 .v.func = alc280_fixup_hp_gpio2_mic_hotkey,
6151         },
6152         [ALC280_FIXUP_HP_DOCK_PINS] = {
6153                 .type = HDA_FIXUP_PINS,
6154                 .v.pins = (const struct hda_pintbl[]) {
6155                         { 0x1b, 0x21011020 }, /* line-out */
6156                         { 0x1a, 0x01a1903c }, /* headset mic */
6157                         { 0x18, 0x2181103f }, /* line-in */
6158                         { },
6159                 },
6160                 .chained = true,
6161                 .chain_id = ALC280_FIXUP_HP_GPIO4
6162         },
6163         [ALC269_FIXUP_HP_DOCK_GPIO_MIC1_LED] = {
6164                 .type = HDA_FIXUP_PINS,
6165                 .v.pins = (const struct hda_pintbl[]) {
6166                         { 0x1b, 0x21011020 }, /* line-out */
6167                         { 0x18, 0x2181103f }, /* line-in */
6168                         { },
6169                 },
6170                 .chained = true,
6171                 .chain_id = ALC269_FIXUP_HP_GPIO_MIC1_LED
6172         },
6173         [ALC280_FIXUP_HP_9480M] = {
6174                 .type = HDA_FIXUP_FUNC,
6175                 .v.func = alc280_fixup_hp_9480m,
6176         },
6177         [ALC288_FIXUP_DELL_HEADSET_MODE] = {
6178                 .type = HDA_FIXUP_FUNC,
6179                 .v.func = alc_fixup_headset_mode_dell_alc288,
6180                 .chained = true,
6181                 .chain_id = ALC255_FIXUP_MIC_MUTE_LED
6182         },
6183         [ALC288_FIXUP_DELL1_MIC_NO_PRESENCE] = {
6184                 .type = HDA_FIXUP_PINS,
6185                 .v.pins = (const struct hda_pintbl[]) {
6186                         { 0x18, 0x01a1913c }, /* use as headset mic, without its own jack detect */
6187                         { 0x1a, 0x01a1913d }, /* use as headphone mic, without its own jack detect */
6188                         { }
6189                 },
6190                 .chained = true,
6191                 .chain_id = ALC288_FIXUP_DELL_HEADSET_MODE
6192         },
6193         [ALC288_FIXUP_DISABLE_AAMIX] = {
6194                 .type = HDA_FIXUP_FUNC,
6195                 .v.func = alc_fixup_disable_aamix,
6196                 .chained = true,
6197                 .chain_id = ALC288_FIXUP_DELL1_MIC_NO_PRESENCE
6198         },
6199         [ALC288_FIXUP_DELL_XPS_13] = {
6200                 .type = HDA_FIXUP_FUNC,
6201                 .v.func = alc_fixup_dell_xps13,
6202                 .chained = true,
6203                 .chain_id = ALC288_FIXUP_DISABLE_AAMIX
6204         },
6205         [ALC292_FIXUP_DISABLE_AAMIX] = {
6206                 .type = HDA_FIXUP_FUNC,
6207                 .v.func = alc_fixup_disable_aamix,
6208                 .chained = true,
6209                 .chain_id = ALC269_FIXUP_DELL2_MIC_NO_PRESENCE
6210         },
6211         [ALC293_FIXUP_DISABLE_AAMIX_MULTIJACK] = {
6212                 .type = HDA_FIXUP_FUNC,
6213                 .v.func = alc_fixup_disable_aamix,
6214                 .chained = true,
6215                 .chain_id = ALC293_FIXUP_DELL1_MIC_NO_PRESENCE
6216         },
6217         [ALC292_FIXUP_DELL_E7X] = {
6218                 .type = HDA_FIXUP_FUNC,
6219                 .v.func = alc_fixup_dell_xps13,
6220                 .chained = true,
6221                 .chain_id = ALC292_FIXUP_DISABLE_AAMIX
6222         },
6223         [ALC298_FIXUP_DELL1_MIC_NO_PRESENCE] = {
6224                 .type = HDA_FIXUP_PINS,
6225                 .v.pins = (const struct hda_pintbl[]) {
6226                         { 0x18, 0x01a1913c }, /* use as headset mic, without its own jack detect */
6227                         { 0x1a, 0x01a1913d }, /* use as headphone mic, without its own jack detect */
6228                         { }
6229                 },
6230                 .chained = true,
6231                 .chain_id = ALC269_FIXUP_HEADSET_MODE
6232         },
6233         [ALC298_FIXUP_DELL_AIO_MIC_NO_PRESENCE] = {
6234                 .type = HDA_FIXUP_PINS,
6235                 .v.pins = (const struct hda_pintbl[]) {
6236                         { 0x18, 0x01a1913c }, /* use as headset mic, without its own jack detect */
6237                         { }
6238                 },
6239                 .chained = true,
6240                 .chain_id = ALC269_FIXUP_HEADSET_MODE
6241         },
6242         [ALC275_FIXUP_DELL_XPS] = {
6243                 .type = HDA_FIXUP_VERBS,
6244                 .v.verbs = (const struct hda_verb[]) {
6245                         /* Enables internal speaker */
6246                         {0x20, AC_VERB_SET_COEF_INDEX, 0x1f},
6247                         {0x20, AC_VERB_SET_PROC_COEF, 0x00c0},
6248                         {0x20, AC_VERB_SET_COEF_INDEX, 0x30},
6249                         {0x20, AC_VERB_SET_PROC_COEF, 0x00b1},
6250                         {}
6251                 }
6252         },
6253         [ALC256_FIXUP_DELL_XPS_13_HEADPHONE_NOISE] = {
6254                 .type = HDA_FIXUP_VERBS,
6255                 .v.verbs = (const struct hda_verb[]) {
6256                         /* Disable pass-through path for FRONT 14h */
6257                         {0x20, AC_VERB_SET_COEF_INDEX, 0x36},
6258                         {0x20, AC_VERB_SET_PROC_COEF, 0x1737},
6259                         {}
6260                 },
6261                 .chained = true,
6262                 .chain_id = ALC255_FIXUP_DELL1_MIC_NO_PRESENCE
6263         },
6264         [ALC293_FIXUP_LENOVO_SPK_NOISE] = {
6265                 .type = HDA_FIXUP_FUNC,
6266                 .v.func = alc_fixup_disable_aamix,
6267                 .chained = true,
6268                 .chain_id = ALC269_FIXUP_THINKPAD_ACPI
6269         },
6270         [ALC233_FIXUP_LENOVO_LINE2_MIC_HOTKEY] = {
6271                 .type = HDA_FIXUP_FUNC,
6272                 .v.func = alc233_fixup_lenovo_line2_mic_hotkey,
6273         },
6274         [ALC255_FIXUP_DELL_SPK_NOISE] = {
6275                 .type = HDA_FIXUP_FUNC,
6276                 .v.func = alc_fixup_disable_aamix,
6277                 .chained = true,
6278                 .chain_id = ALC255_FIXUP_DELL1_MIC_NO_PRESENCE
6279         },
6280         [ALC225_FIXUP_DISABLE_MIC_VREF] = {
6281                 .type = HDA_FIXUP_FUNC,
6282                 .v.func = alc_fixup_disable_mic_vref,
6283                 .chained = true,
6284                 .chain_id = ALC269_FIXUP_DELL1_MIC_NO_PRESENCE
6285         },
6286         [ALC225_FIXUP_DELL1_MIC_NO_PRESENCE] = {
6287                 .type = HDA_FIXUP_VERBS,
6288                 .v.verbs = (const struct hda_verb[]) {
6289                         /* Disable pass-through path for FRONT 14h */
6290                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x36 },
6291                         { 0x20, AC_VERB_SET_PROC_COEF, 0x57d7 },
6292                         {}
6293                 },
6294                 .chained = true,
6295                 .chain_id = ALC225_FIXUP_DISABLE_MIC_VREF
6296         },
6297         [ALC280_FIXUP_HP_HEADSET_MIC] = {
6298                 .type = HDA_FIXUP_FUNC,
6299                 .v.func = alc_fixup_disable_aamix,
6300                 .chained = true,
6301                 .chain_id = ALC269_FIXUP_HEADSET_MIC,
6302         },
6303         [ALC221_FIXUP_HP_FRONT_MIC] = {
6304                 .type = HDA_FIXUP_PINS,
6305                 .v.pins = (const struct hda_pintbl[]) {
6306                         { 0x19, 0x02a19020 }, /* Front Mic */
6307                         { }
6308                 },
6309         },
6310         [ALC292_FIXUP_TPT460] = {
6311                 .type = HDA_FIXUP_FUNC,
6312                 .v.func = alc_fixup_tpt440_dock,
6313                 .chained = true,
6314                 .chain_id = ALC293_FIXUP_LENOVO_SPK_NOISE,
6315         },
6316         [ALC298_FIXUP_SPK_VOLUME] = {
6317                 .type = HDA_FIXUP_FUNC,
6318                 .v.func = alc298_fixup_speaker_volume,
6319                 .chained = true,
6320                 .chain_id = ALC298_FIXUP_DELL_AIO_MIC_NO_PRESENCE,
6321         },
6322         [ALC295_FIXUP_DISABLE_DAC3] = {
6323                 .type = HDA_FIXUP_FUNC,
6324                 .v.func = alc295_fixup_disable_dac3,
6325         },
6326         [ALC256_FIXUP_DELL_INSPIRON_7559_SUBWOOFER] = {
6327                 .type = HDA_FIXUP_PINS,
6328                 .v.pins = (const struct hda_pintbl[]) {
6329                         { 0x1b, 0x90170151 },
6330                         { }
6331                 },
6332                 .chained = true,
6333                 .chain_id = ALC255_FIXUP_DELL1_MIC_NO_PRESENCE
6334         },
6335         [ALC269_FIXUP_ATIV_BOOK_8] = {
6336                 .type = HDA_FIXUP_FUNC,
6337                 .v.func = alc_fixup_auto_mute_via_amp,
6338                 .chained = true,
6339                 .chain_id = ALC269_FIXUP_NO_SHUTUP
6340         },
6341         [ALC221_FIXUP_HP_MIC_NO_PRESENCE] = {
6342                 .type = HDA_FIXUP_PINS,
6343                 .v.pins = (const struct hda_pintbl[]) {
6344                         { 0x18, 0x01a1913c }, /* use as headset mic, without its own jack detect */
6345                         { 0x1a, 0x01a1913d }, /* use as headphone mic, without its own jack detect */
6346                         { }
6347                 },
6348                 .chained = true,
6349                 .chain_id = ALC269_FIXUP_HEADSET_MODE
6350         },
6351         [ALC256_FIXUP_ASUS_HEADSET_MODE] = {
6352                 .type = HDA_FIXUP_FUNC,
6353                 .v.func = alc_fixup_headset_mode,
6354         },
6355         [ALC256_FIXUP_ASUS_MIC] = {
6356                 .type = HDA_FIXUP_PINS,
6357                 .v.pins = (const struct hda_pintbl[]) {
6358                         { 0x13, 0x90a60160 }, /* use as internal mic */
6359                         { 0x19, 0x04a11120 }, /* use as headset mic, without its own jack detect */
6360                         { }
6361                 },
6362                 .chained = true,
6363                 .chain_id = ALC256_FIXUP_ASUS_HEADSET_MODE
6364         },
6365         [ALC256_FIXUP_ASUS_AIO_GPIO2] = {
6366                 .type = HDA_FIXUP_FUNC,
6367                 /* Set up GPIO2 for the speaker amp */
6368                 .v.func = alc_fixup_gpio4,
6369         },
6370         [ALC233_FIXUP_ASUS_MIC_NO_PRESENCE] = {
6371                 .type = HDA_FIXUP_PINS,
6372                 .v.pins = (const struct hda_pintbl[]) {
6373                         { 0x19, 0x01a1913c }, /* use as headset mic, without its own jack detect */
6374                         { }
6375                 },
6376                 .chained = true,
6377                 .chain_id = ALC269_FIXUP_HEADSET_MIC
6378         },
6379         [ALC233_FIXUP_EAPD_COEF_AND_MIC_NO_PRESENCE] = {
6380                 .type = HDA_FIXUP_VERBS,
6381                 .v.verbs = (const struct hda_verb[]) {
6382                         /* Enables internal speaker */
6383                         {0x20, AC_VERB_SET_COEF_INDEX, 0x40},
6384                         {0x20, AC_VERB_SET_PROC_COEF, 0x8800},
6385                         {}
6386                 },
6387                 .chained = true,
6388                 .chain_id = ALC233_FIXUP_ASUS_MIC_NO_PRESENCE
6389         },
6390         [ALC233_FIXUP_LENOVO_MULTI_CODECS] = {
6391                 .type = HDA_FIXUP_FUNC,
6392                 .v.func = alc233_alc662_fixup_lenovo_dual_codecs,
6393         },
6394         [ALC294_FIXUP_LENOVO_MIC_LOCATION] = {
6395                 .type = HDA_FIXUP_PINS,
6396                 .v.pins = (const struct hda_pintbl[]) {
6397                         /* Change the mic location from front to right, otherwise there are
6398                            two front mics with the same name, pulseaudio can't handle them.
6399                            This is just a temporary workaround, after applying this fixup,
6400                            there will be one "Front Mic" and one "Mic" in this machine.
6401                          */
6402                         { 0x1a, 0x04a19040 },
6403                         { }
6404                 },
6405         },
6406         [ALC225_FIXUP_DELL_WYSE_MIC_NO_PRESENCE] = {
6407                 .type = HDA_FIXUP_PINS,
6408                 .v.pins = (const struct hda_pintbl[]) {
6409                         { 0x16, 0x0101102f }, /* Rear Headset HP */
6410                         { 0x19, 0x02a1913c }, /* use as Front headset mic, without its own jack detect */
6411                         { 0x1a, 0x01a19030 }, /* Rear Headset MIC */
6412                         { 0x1b, 0x02011020 },
6413                         { }
6414                 },
6415                 .chained = true,
6416                 .chain_id = ALC269_FIXUP_HEADSET_MODE_NO_HP_MIC
6417         },
6418         [ALC700_FIXUP_INTEL_REFERENCE] = {
6419                 .type = HDA_FIXUP_VERBS,
6420                 .v.verbs = (const struct hda_verb[]) {
6421                         /* Enables internal speaker */
6422                         {0x20, AC_VERB_SET_COEF_INDEX, 0x45},
6423                         {0x20, AC_VERB_SET_PROC_COEF, 0x5289},
6424                         {0x20, AC_VERB_SET_COEF_INDEX, 0x4A},
6425                         {0x20, AC_VERB_SET_PROC_COEF, 0x001b},
6426                         {0x58, AC_VERB_SET_COEF_INDEX, 0x00},
6427                         {0x58, AC_VERB_SET_PROC_COEF, 0x3888},
6428                         {0x20, AC_VERB_SET_COEF_INDEX, 0x6f},
6429                         {0x20, AC_VERB_SET_PROC_COEF, 0x2c0b},
6430                         {}
6431                 }
6432         },
6433         [ALC274_FIXUP_DELL_BIND_DACS] = {
6434                 .type = HDA_FIXUP_FUNC,
6435                 .v.func = alc274_fixup_bind_dacs,
6436                 .chained = true,
6437                 .chain_id = ALC269_FIXUP_DELL1_MIC_NO_PRESENCE
6438         },
6439         [ALC274_FIXUP_DELL_AIO_LINEOUT_VERB] = {
6440                 .type = HDA_FIXUP_PINS,
6441                 .v.pins = (const struct hda_pintbl[]) {
6442                         { 0x1b, 0x0401102f },
6443                         { }
6444                 },
6445                 .chained = true,
6446                 .chain_id = ALC274_FIXUP_DELL_BIND_DACS
6447         },
6448         [ALC298_FIXUP_TPT470_DOCK] = {
6449                 .type = HDA_FIXUP_FUNC,
6450                 .v.func = alc_fixup_tpt470_dock,
6451                 .chained = true,
6452                 .chain_id = ALC293_FIXUP_LENOVO_SPK_NOISE
6453         },
6454         [ALC255_FIXUP_DUMMY_LINEOUT_VERB] = {
6455                 .type = HDA_FIXUP_PINS,
6456                 .v.pins = (const struct hda_pintbl[]) {
6457                         { 0x14, 0x0201101f },
6458                         { }
6459                 },
6460                 .chained = true,
6461                 .chain_id = ALC255_FIXUP_DELL1_MIC_NO_PRESENCE
6462         },
6463         [ALC255_FIXUP_DELL_HEADSET_MIC] = {
6464                 .type = HDA_FIXUP_PINS,
6465                 .v.pins = (const struct hda_pintbl[]) {
6466                         { 0x19, 0x01a1913c }, /* use as headset mic, without its own jack detect */
6467                         { }
6468                 },
6469                 .chained = true,
6470                 .chain_id = ALC269_FIXUP_HEADSET_MIC
6471         },
6472         [ALC295_FIXUP_HP_X360] = {
6473                 .type = HDA_FIXUP_FUNC,
6474                 .v.func = alc295_fixup_hp_top_speakers,
6475                 .chained = true,
6476                 .chain_id = ALC269_FIXUP_HP_MUTE_LED_MIC3
6477         },
6478         [ALC221_FIXUP_HP_HEADSET_MIC] = {
6479                 .type = HDA_FIXUP_PINS,
6480                 .v.pins = (const struct hda_pintbl[]) {
6481                         { 0x19, 0x0181313f},
6482                         { }
6483                 },
6484                 .chained = true,
6485                 .chain_id = ALC269_FIXUP_HEADSET_MIC
6486         },
6487         [ALC285_FIXUP_LENOVO_HEADPHONE_NOISE] = {
6488                 .type = HDA_FIXUP_FUNC,
6489                 .v.func = alc285_fixup_invalidate_dacs,
6490                 .chained = true,
6491                 .chain_id = ALC269_FIXUP_THINKPAD_ACPI
6492         },
6493         [ALC295_FIXUP_HP_AUTO_MUTE] = {
6494                 .type = HDA_FIXUP_FUNC,
6495                 .v.func = alc_fixup_auto_mute_via_amp,
6496         },
6497         [ALC286_FIXUP_ACER_AIO_MIC_NO_PRESENCE] = {
6498                 .type = HDA_FIXUP_PINS,
6499                 .v.pins = (const struct hda_pintbl[]) {
6500                         { 0x18, 0x01a1913c }, /* use as headset mic, without its own jack detect */
6501                         { }
6502                 },
6503                 .chained = true,
6504                 .chain_id = ALC269_FIXUP_HEADSET_MIC
6505         },
6506         [ALC294_FIXUP_ASUS_MIC] = {
6507                 .type = HDA_FIXUP_PINS,
6508                 .v.pins = (const struct hda_pintbl[]) {
6509                         { 0x13, 0x90a60160 }, /* use as internal mic */
6510                         { 0x19, 0x04a11120 }, /* use as headset mic, without its own jack detect */
6511                         { }
6512                 },
6513                 .chained = true,
6514                 .chain_id = ALC269_FIXUP_HEADSET_MODE_NO_HP_MIC
6515         },
6516         [ALC294_FIXUP_ASUS_HEADSET_MIC] = {
6517                 .type = HDA_FIXUP_PINS,
6518                 .v.pins = (const struct hda_pintbl[]) {
6519                         { 0x19, 0x01a1103c }, /* use as headset mic */
6520                         { }
6521                 },
6522                 .chained = true,
6523                 .chain_id = ALC269_FIXUP_HEADSET_MODE_NO_HP_MIC
6524         },
6525         [ALC294_FIXUP_ASUS_SPK] = {
6526                 .type = HDA_FIXUP_VERBS,
6527                 .v.verbs = (const struct hda_verb[]) {
6528                         /* Set EAPD high */
6529                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x40 },
6530                         { 0x20, AC_VERB_SET_PROC_COEF, 0x8800 },
6531                         { }
6532                 },
6533                 .chained = true,
6534                 .chain_id = ALC294_FIXUP_ASUS_HEADSET_MIC
6535         },
6536         [ALC225_FIXUP_HEADSET_JACK] = {
6537                 .type = HDA_FIXUP_FUNC,
6538                 .v.func = alc_fixup_headset_jack,
6539         },
6540 };
6541
6542 static const struct snd_pci_quirk alc269_fixup_tbl[] = {
6543         SND_PCI_QUIRK(0x1025, 0x0283, "Acer TravelMate 8371", ALC269_FIXUP_INV_DMIC),
6544         SND_PCI_QUIRK(0x1025, 0x029b, "Acer 1810TZ", ALC269_FIXUP_INV_DMIC),
6545         SND_PCI_QUIRK(0x1025, 0x0349, "Acer AOD260", ALC269_FIXUP_INV_DMIC),
6546         SND_PCI_QUIRK(0x1025, 0x047c, "Acer AC700", ALC269_FIXUP_ACER_AC700),
6547         SND_PCI_QUIRK(0x1025, 0x072d, "Acer Aspire V5-571G", ALC269_FIXUP_ASPIRE_HEADSET_MIC),
6548         SND_PCI_QUIRK(0x1025, 0x080d, "Acer Aspire V5-122P", ALC269_FIXUP_ASPIRE_HEADSET_MIC),
6549         SND_PCI_QUIRK(0x1025, 0x0740, "Acer AO725", ALC271_FIXUP_HP_GATE_MIC_JACK),
6550         SND_PCI_QUIRK(0x1025, 0x0742, "Acer AO756", ALC271_FIXUP_HP_GATE_MIC_JACK),
6551         SND_PCI_QUIRK(0x1025, 0x0762, "Acer Aspire E1-472", ALC271_FIXUP_HP_GATE_MIC_JACK_E1_572),
6552         SND_PCI_QUIRK(0x1025, 0x0775, "Acer Aspire E1-572", ALC271_FIXUP_HP_GATE_MIC_JACK_E1_572),
6553         SND_PCI_QUIRK(0x1025, 0x079b, "Acer Aspire V5-573G", ALC282_FIXUP_ASPIRE_V5_PINS),
6554         SND_PCI_QUIRK(0x1025, 0x102b, "Acer Aspire C24-860", ALC286_FIXUP_ACER_AIO_MIC_NO_PRESENCE),
6555         SND_PCI_QUIRK(0x1025, 0x106d, "Acer Cloudbook 14", ALC283_FIXUP_CHROME_BOOK),
6556         SND_PCI_QUIRK(0x1025, 0x128f, "Acer Veriton Z6860G", ALC286_FIXUP_ACER_AIO_MIC_NO_PRESENCE),
6557         SND_PCI_QUIRK(0x1025, 0x1290, "Acer Veriton Z4860G", ALC286_FIXUP_ACER_AIO_MIC_NO_PRESENCE),
6558         SND_PCI_QUIRK(0x1025, 0x1291, "Acer Veriton Z4660G", ALC286_FIXUP_ACER_AIO_MIC_NO_PRESENCE),
6559         SND_PCI_QUIRK(0x1028, 0x0470, "Dell M101z", ALC269_FIXUP_DELL_M101Z),
6560         SND_PCI_QUIRK(0x1028, 0x054b, "Dell XPS one 2710", ALC275_FIXUP_DELL_XPS),
6561         SND_PCI_QUIRK(0x1028, 0x05bd, "Dell Latitude E6440", ALC292_FIXUP_DELL_E7X),
6562         SND_PCI_QUIRK(0x1028, 0x05be, "Dell Latitude E6540", ALC292_FIXUP_DELL_E7X),
6563         SND_PCI_QUIRK(0x1028, 0x05ca, "Dell Latitude E7240", ALC292_FIXUP_DELL_E7X),
6564         SND_PCI_QUIRK(0x1028, 0x05cb, "Dell Latitude E7440", ALC292_FIXUP_DELL_E7X),
6565         SND_PCI_QUIRK(0x1028, 0x05da, "Dell Vostro 5460", ALC290_FIXUP_SUBWOOFER),
6566         SND_PCI_QUIRK(0x1028, 0x05f4, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE),
6567         SND_PCI_QUIRK(0x1028, 0x05f5, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE),
6568         SND_PCI_QUIRK(0x1028, 0x05f6, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE),
6569         SND_PCI_QUIRK(0x1028, 0x0615, "Dell Vostro 5470", ALC290_FIXUP_SUBWOOFER_HSJACK),
6570         SND_PCI_QUIRK(0x1028, 0x0616, "Dell Vostro 5470", ALC290_FIXUP_SUBWOOFER_HSJACK),
6571         SND_PCI_QUIRK(0x1028, 0x062c, "Dell Latitude E5550", ALC292_FIXUP_DELL_E7X),
6572         SND_PCI_QUIRK(0x1028, 0x062e, "Dell Latitude E7450", ALC292_FIXUP_DELL_E7X),
6573         SND_PCI_QUIRK(0x1028, 0x0638, "Dell Inspiron 5439", ALC290_FIXUP_MONO_SPEAKERS_HSJACK),
6574         SND_PCI_QUIRK(0x1028, 0x064a, "Dell", ALC293_FIXUP_DELL1_MIC_NO_PRESENCE),
6575         SND_PCI_QUIRK(0x1028, 0x064b, "Dell", ALC293_FIXUP_DELL1_MIC_NO_PRESENCE),
6576         SND_PCI_QUIRK(0x1028, 0x0665, "Dell XPS 13", ALC288_FIXUP_DELL_XPS_13),
6577         SND_PCI_QUIRK(0x1028, 0x0669, "Dell Optiplex 9020m", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE),
6578         SND_PCI_QUIRK(0x1028, 0x069a, "Dell Vostro 5480", ALC290_FIXUP_SUBWOOFER_HSJACK),
6579         SND_PCI_QUIRK(0x1028, 0x06c7, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE),
6580         SND_PCI_QUIRK(0x1028, 0x06d9, "Dell", ALC293_FIXUP_DELL1_MIC_NO_PRESENCE),
6581         SND_PCI_QUIRK(0x1028, 0x06da, "Dell", ALC293_FIXUP_DELL1_MIC_NO_PRESENCE),
6582         SND_PCI_QUIRK(0x1028, 0x06db, "Dell", ALC293_FIXUP_DISABLE_AAMIX_MULTIJACK),
6583         SND_PCI_QUIRK(0x1028, 0x06dd, "Dell", ALC293_FIXUP_DISABLE_AAMIX_MULTIJACK),
6584         SND_PCI_QUIRK(0x1028, 0x06de, "Dell", ALC293_FIXUP_DISABLE_AAMIX_MULTIJACK),
6585         SND_PCI_QUIRK(0x1028, 0x06df, "Dell", ALC293_FIXUP_DISABLE_AAMIX_MULTIJACK),
6586         SND_PCI_QUIRK(0x1028, 0x06e0, "Dell", ALC293_FIXUP_DISABLE_AAMIX_MULTIJACK),
6587         SND_PCI_QUIRK(0x1028, 0x0704, "Dell XPS 13 9350", ALC256_FIXUP_DELL_XPS_13_HEADPHONE_NOISE),
6588         SND_PCI_QUIRK(0x1028, 0x0706, "Dell Inspiron 7559", ALC256_FIXUP_DELL_INSPIRON_7559_SUBWOOFER),
6589         SND_PCI_QUIRK(0x1028, 0x0725, "Dell Inspiron 3162", ALC255_FIXUP_DELL_SPK_NOISE),
6590         SND_PCI_QUIRK(0x1028, 0x075b, "Dell XPS 13 9360", ALC256_FIXUP_DELL_XPS_13_HEADPHONE_NOISE),
6591         SND_PCI_QUIRK(0x1028, 0x075c, "Dell XPS 27 7760", ALC298_FIXUP_SPK_VOLUME),
6592         SND_PCI_QUIRK(0x1028, 0x075d, "Dell AIO", ALC298_FIXUP_SPK_VOLUME),
6593         SND_PCI_QUIRK(0x1028, 0x07b0, "Dell Precision 7520", ALC295_FIXUP_DISABLE_DAC3),
6594         SND_PCI_QUIRK(0x1028, 0x0798, "Dell Inspiron 17 7000 Gaming", ALC256_FIXUP_DELL_INSPIRON_7559_SUBWOOFER),
6595         SND_PCI_QUIRK(0x1028, 0x080c, "Dell WYSE", ALC225_FIXUP_DELL_WYSE_MIC_NO_PRESENCE),
6596         SND_PCI_QUIRK(0x1028, 0x082a, "Dell XPS 13 9360", ALC256_FIXUP_DELL_XPS_13_HEADPHONE_NOISE),
6597         SND_PCI_QUIRK(0x1028, 0x084b, "Dell", ALC274_FIXUP_DELL_AIO_LINEOUT_VERB),
6598         SND_PCI_QUIRK(0x1028, 0x084e, "Dell", ALC274_FIXUP_DELL_AIO_LINEOUT_VERB),
6599         SND_PCI_QUIRK(0x1028, 0x0871, "Dell Precision 3630", ALC255_FIXUP_DELL_HEADSET_MIC),
6600         SND_PCI_QUIRK(0x1028, 0x0872, "Dell Precision 3630", ALC255_FIXUP_DELL_HEADSET_MIC),
6601         SND_PCI_QUIRK(0x1028, 0x0873, "Dell Precision 3930", ALC255_FIXUP_DUMMY_LINEOUT_VERB),
6602         SND_PCI_QUIRK(0x1028, 0x0935, "Dell", ALC274_FIXUP_DELL_AIO_LINEOUT_VERB),
6603         SND_PCI_QUIRK(0x1028, 0x164a, "Dell", ALC293_FIXUP_DELL1_MIC_NO_PRESENCE),
6604         SND_PCI_QUIRK(0x1028, 0x164b, "Dell", ALC293_FIXUP_DELL1_MIC_NO_PRESENCE),
6605         SND_PCI_QUIRK(0x103c, 0x1586, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC2),
6606         SND_PCI_QUIRK(0x103c, 0x18e6, "HP", ALC269_FIXUP_HP_GPIO_LED),
6607         SND_PCI_QUIRK(0x103c, 0x218b, "HP", ALC269_FIXUP_LIMIT_INT_MIC_BOOST_MUTE_LED),
6608         SND_PCI_QUIRK(0x103c, 0x225f, "HP", ALC280_FIXUP_HP_GPIO2_MIC_HOTKEY),
6609         /* ALC282 */
6610         SND_PCI_QUIRK(0x103c, 0x21f9, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
6611         SND_PCI_QUIRK(0x103c, 0x2210, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
6612         SND_PCI_QUIRK(0x103c, 0x2214, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
6613         SND_PCI_QUIRK(0x103c, 0x2236, "HP", ALC269_FIXUP_HP_LINE1_MIC1_LED),
6614         SND_PCI_QUIRK(0x103c, 0x2237, "HP", ALC269_FIXUP_HP_LINE1_MIC1_LED),
6615         SND_PCI_QUIRK(0x103c, 0x2238, "HP", ALC269_FIXUP_HP_LINE1_MIC1_LED),
6616         SND_PCI_QUIRK(0x103c, 0x2239, "HP", ALC269_FIXUP_HP_LINE1_MIC1_LED),
6617         SND_PCI_QUIRK(0x103c, 0x224b, "HP", ALC269_FIXUP_HP_LINE1_MIC1_LED),
6618         SND_PCI_QUIRK(0x103c, 0x2268, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
6619         SND_PCI_QUIRK(0x103c, 0x226a, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
6620         SND_PCI_QUIRK(0x103c, 0x226b, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
6621         SND_PCI_QUIRK(0x103c, 0x226e, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
6622         SND_PCI_QUIRK(0x103c, 0x2271, "HP", ALC286_FIXUP_HP_GPIO_LED),
6623         SND_PCI_QUIRK(0x103c, 0x2272, "HP", ALC280_FIXUP_HP_DOCK_PINS),
6624         SND_PCI_QUIRK(0x103c, 0x2273, "HP", ALC280_FIXUP_HP_DOCK_PINS),
6625         SND_PCI_QUIRK(0x103c, 0x229e, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
6626         SND_PCI_QUIRK(0x103c, 0x22b2, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
6627         SND_PCI_QUIRK(0x103c, 0x22b7, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
6628         SND_PCI_QUIRK(0x103c, 0x22bf, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
6629         SND_PCI_QUIRK(0x103c, 0x22cf, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
6630         SND_PCI_QUIRK(0x103c, 0x22db, "HP", ALC280_FIXUP_HP_9480M),
6631         SND_PCI_QUIRK(0x103c, 0x22dc, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),
6632         SND_PCI_QUIRK(0x103c, 0x22fb, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),
6633         /* ALC290 */
6634         SND_PCI_QUIRK(0x103c, 0x221b, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),
6635         SND_PCI_QUIRK(0x103c, 0x2221, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),
6636         SND_PCI_QUIRK(0x103c, 0x2225, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),
6637         SND_PCI_QUIRK(0x103c, 0x2253, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),
6638         SND_PCI_QUIRK(0x103c, 0x2254, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),
6639         SND_PCI_QUIRK(0x103c, 0x2255, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),
6640         SND_PCI_QUIRK(0x103c, 0x2256, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),
6641         SND_PCI_QUIRK(0x103c, 0x2257, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),
6642         SND_PCI_QUIRK(0x103c, 0x2259, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),
6643         SND_PCI_QUIRK(0x103c, 0x225a, "HP", ALC269_FIXUP_HP_DOCK_GPIO_MIC1_LED),
6644         SND_PCI_QUIRK(0x103c, 0x2260, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
6645         SND_PCI_QUIRK(0x103c, 0x2263, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
6646         SND_PCI_QUIRK(0x103c, 0x2264, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
6647         SND_PCI_QUIRK(0x103c, 0x2265, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
6648         SND_PCI_QUIRK(0x103c, 0x2272, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),
6649         SND_PCI_QUIRK(0x103c, 0x2273, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),
6650         SND_PCI_QUIRK(0x103c, 0x2278, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),
6651         SND_PCI_QUIRK(0x103c, 0x227f, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
6652         SND_PCI_QUIRK(0x103c, 0x2282, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
6653         SND_PCI_QUIRK(0x103c, 0x228b, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
6654         SND_PCI_QUIRK(0x103c, 0x228e, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
6655         SND_PCI_QUIRK(0x103c, 0x22c5, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
6656         SND_PCI_QUIRK(0x103c, 0x22c7, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
6657         SND_PCI_QUIRK(0x103c, 0x22c8, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
6658         SND_PCI_QUIRK(0x103c, 0x22c4, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
6659         SND_PCI_QUIRK(0x103c, 0x2334, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
6660         SND_PCI_QUIRK(0x103c, 0x2335, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
6661         SND_PCI_QUIRK(0x103c, 0x2336, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
6662         SND_PCI_QUIRK(0x103c, 0x2337, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
6663         SND_PCI_QUIRK(0x103c, 0x221c, "HP EliteBook 755 G2", ALC280_FIXUP_HP_HEADSET_MIC),
6664         SND_PCI_QUIRK(0x103c, 0x820d, "HP Pavilion 15", ALC269_FIXUP_HP_MUTE_LED_MIC3),
6665         SND_PCI_QUIRK(0x103c, 0x8256, "HP", ALC221_FIXUP_HP_FRONT_MIC),
6666         SND_PCI_QUIRK(0x103c, 0x827e, "HP x360", ALC295_FIXUP_HP_X360),
6667         SND_PCI_QUIRK(0x103c, 0x82bf, "HP", ALC221_FIXUP_HP_MIC_NO_PRESENCE),
6668         SND_PCI_QUIRK(0x103c, 0x82c0, "HP", ALC221_FIXUP_HP_MIC_NO_PRESENCE),
6669         SND_PCI_QUIRK(0x103c, 0x83b9, "HP Spectre x360", ALC269_FIXUP_HP_MUTE_LED_MIC3),
6670         SND_PCI_QUIRK(0x1043, 0x103e, "ASUS X540SA", ALC256_FIXUP_ASUS_MIC),
6671         SND_PCI_QUIRK(0x1043, 0x103f, "ASUS TX300", ALC282_FIXUP_ASUS_TX300),
6672         SND_PCI_QUIRK(0x1043, 0x106d, "Asus K53BE", ALC269_FIXUP_LIMIT_INT_MIC_BOOST),
6673         SND_PCI_QUIRK(0x1043, 0x10a1, "ASUS UX391UA", ALC294_FIXUP_ASUS_SPK),
6674         SND_PCI_QUIRK(0x1043, 0x10c0, "ASUS X540SA", ALC256_FIXUP_ASUS_MIC),
6675         SND_PCI_QUIRK(0x1043, 0x10d0, "ASUS X540LA/X540LJ", ALC255_FIXUP_ASUS_MIC_NO_PRESENCE),
6676         SND_PCI_QUIRK(0x1043, 0x115d, "Asus 1015E", ALC269_FIXUP_LIMIT_INT_MIC_BOOST),
6677         SND_PCI_QUIRK(0x1043, 0x11c0, "ASUS X556UR", ALC255_FIXUP_ASUS_MIC_NO_PRESENCE),
6678         SND_PCI_QUIRK(0x1043, 0x1290, "ASUS X441SA", ALC233_FIXUP_EAPD_COEF_AND_MIC_NO_PRESENCE),
6679         SND_PCI_QUIRK(0x1043, 0x12a0, "ASUS X441UV", ALC233_FIXUP_EAPD_COEF_AND_MIC_NO_PRESENCE),
6680         SND_PCI_QUIRK(0x1043, 0x12f0, "ASUS X541UV", ALC256_FIXUP_ASUS_MIC),
6681         SND_PCI_QUIRK(0x1043, 0x12e0, "ASUS X541SA", ALC256_FIXUP_ASUS_MIC),
6682         SND_PCI_QUIRK(0x1043, 0x13b0, "ASUS Z550SA", ALC256_FIXUP_ASUS_MIC),
6683         SND_PCI_QUIRK(0x1043, 0x1427, "Asus Zenbook UX31E", ALC269VB_FIXUP_ASUS_ZENBOOK),
6684         SND_PCI_QUIRK(0x1043, 0x14a1, "ASUS UX533FD", ALC294_FIXUP_ASUS_SPK),
6685         SND_PCI_QUIRK(0x1043, 0x1517, "Asus Zenbook UX31A", ALC269VB_FIXUP_ASUS_ZENBOOK_UX31A),
6686         SND_PCI_QUIRK(0x1043, 0x16e3, "ASUS UX50", ALC269_FIXUP_STEREO_DMIC),
6687         SND_PCI_QUIRK(0x1043, 0x1a13, "Asus G73Jw", ALC269_FIXUP_ASUS_G73JW),
6688         SND_PCI_QUIRK(0x1043, 0x1a30, "ASUS X705UD", ALC256_FIXUP_ASUS_MIC),
6689         SND_PCI_QUIRK(0x1043, 0x1b13, "Asus U41SV", ALC269_FIXUP_INV_DMIC),
6690         SND_PCI_QUIRK(0x1043, 0x1bbd, "ASUS Z550MA", ALC255_FIXUP_ASUS_MIC_NO_PRESENCE),
6691         SND_PCI_QUIRK(0x1043, 0x1c23, "Asus X55U", ALC269_FIXUP_LIMIT_INT_MIC_BOOST),
6692         SND_PCI_QUIRK(0x1043, 0x1ccd, "ASUS X555UB", ALC256_FIXUP_ASUS_MIC),
6693         SND_PCI_QUIRK(0x1043, 0x3030, "ASUS ZN270IE", ALC256_FIXUP_ASUS_AIO_GPIO2),
6694         SND_PCI_QUIRK(0x1043, 0x831a, "ASUS P901", ALC269_FIXUP_STEREO_DMIC),
6695         SND_PCI_QUIRK(0x1043, 0x834a, "ASUS S101", ALC269_FIXUP_STEREO_DMIC),
6696         SND_PCI_QUIRK(0x1043, 0x8398, "ASUS P1005", ALC269_FIXUP_STEREO_DMIC),
6697         SND_PCI_QUIRK(0x1043, 0x83ce, "ASUS P1005", ALC269_FIXUP_STEREO_DMIC),
6698         SND_PCI_QUIRK(0x1043, 0x8516, "ASUS X101CH", ALC269_FIXUP_ASUS_X101),
6699         SND_PCI_QUIRK(0x104d, 0x90b5, "Sony VAIO Pro 11", ALC286_FIXUP_SONY_MIC_NO_PRESENCE),
6700         SND_PCI_QUIRK(0x104d, 0x90b6, "Sony VAIO Pro 13", ALC286_FIXUP_SONY_MIC_NO_PRESENCE),
6701         SND_PCI_QUIRK(0x104d, 0x9073, "Sony VAIO", ALC275_FIXUP_SONY_VAIO_GPIO2),
6702         SND_PCI_QUIRK(0x104d, 0x907b, "Sony VAIO", ALC275_FIXUP_SONY_HWEQ),
6703         SND_PCI_QUIRK(0x104d, 0x9084, "Sony VAIO", ALC275_FIXUP_SONY_HWEQ),
6704         SND_PCI_QUIRK(0x104d, 0x9099, "Sony VAIO S13", ALC275_FIXUP_SONY_DISABLE_AAMIX),
6705         SND_PCI_QUIRK(0x10cf, 0x1475, "Lifebook", ALC269_FIXUP_LIFEBOOK),
6706         SND_PCI_QUIRK(0x10cf, 0x159f, "Lifebook E780", ALC269_FIXUP_LIFEBOOK_NO_HP_TO_LINEOUT),
6707         SND_PCI_QUIRK(0x10cf, 0x15dc, "Lifebook T731", ALC269_FIXUP_LIFEBOOK_HP_PIN),
6708         SND_PCI_QUIRK(0x10cf, 0x1757, "Lifebook E752", ALC269_FIXUP_LIFEBOOK_HP_PIN),
6709         SND_PCI_QUIRK(0x10cf, 0x1629, "Lifebook U7x7", ALC255_FIXUP_LIFEBOOK_U7x7_HEADSET_MIC),
6710         SND_PCI_QUIRK(0x10cf, 0x1845, "Lifebook U904", ALC269_FIXUP_LIFEBOOK_EXTMIC),
6711         SND_PCI_QUIRK(0x10ec, 0x10f2, "Intel Reference board", ALC700_FIXUP_INTEL_REFERENCE),
6712         SND_PCI_QUIRK(0x10f7, 0x8338, "Panasonic CF-SZ6", ALC269_FIXUP_HEADSET_MODE),
6713         SND_PCI_QUIRK(0x144d, 0xc109, "Samsung Ativ book 9 (NP900X3G)", ALC269_FIXUP_INV_DMIC),
6714         SND_PCI_QUIRK(0x144d, 0xc740, "Samsung Ativ book 8 (NP870Z5G)", ALC269_FIXUP_ATIV_BOOK_8),
6715         SND_PCI_QUIRK(0x1458, 0xfa53, "Gigabyte BXBT-2807", ALC283_FIXUP_HEADSET_MIC),
6716         SND_PCI_QUIRK(0x1462, 0xb120, "MSI Cubi MS-B120", ALC283_FIXUP_HEADSET_MIC),
6717         SND_PCI_QUIRK(0x1462, 0xb171, "Cubi N 8GL (MS-B171)", ALC283_FIXUP_HEADSET_MIC),
6718         SND_PCI_QUIRK(0x17aa, 0x1036, "Lenovo P520", ALC233_FIXUP_LENOVO_MULTI_CODECS),
6719         SND_PCI_QUIRK(0x17aa, 0x20f2, "Thinkpad SL410/510", ALC269_FIXUP_SKU_IGNORE),
6720         SND_PCI_QUIRK(0x17aa, 0x215e, "Thinkpad L512", ALC269_FIXUP_SKU_IGNORE),
6721         SND_PCI_QUIRK(0x17aa, 0x21b8, "Thinkpad Edge 14", ALC269_FIXUP_SKU_IGNORE),
6722         SND_PCI_QUIRK(0x17aa, 0x21ca, "Thinkpad L412", ALC269_FIXUP_SKU_IGNORE),
6723         SND_PCI_QUIRK(0x17aa, 0x21e9, "Thinkpad Edge 15", ALC269_FIXUP_SKU_IGNORE),
6724         SND_PCI_QUIRK(0x17aa, 0x21f6, "Thinkpad T530", ALC269_FIXUP_LENOVO_DOCK),
6725         SND_PCI_QUIRK(0x17aa, 0x21fa, "Thinkpad X230", ALC269_FIXUP_LENOVO_DOCK),
6726         SND_PCI_QUIRK(0x17aa, 0x21f3, "Thinkpad T430", ALC269_FIXUP_LENOVO_DOCK),
6727         SND_PCI_QUIRK(0x17aa, 0x21fb, "Thinkpad T430s", ALC269_FIXUP_LENOVO_DOCK),
6728         SND_PCI_QUIRK(0x17aa, 0x2203, "Thinkpad X230 Tablet", ALC269_FIXUP_LENOVO_DOCK),
6729         SND_PCI_QUIRK(0x17aa, 0x2208, "Thinkpad T431s", ALC269_FIXUP_LENOVO_DOCK),
6730         SND_PCI_QUIRK(0x17aa, 0x220c, "Thinkpad T440s", ALC292_FIXUP_TPT440),
6731         SND_PCI_QUIRK(0x17aa, 0x220e, "Thinkpad T440p", ALC292_FIXUP_TPT440_DOCK),
6732         SND_PCI_QUIRK(0x17aa, 0x2210, "Thinkpad T540p", ALC292_FIXUP_TPT440_DOCK),
6733         SND_PCI_QUIRK(0x17aa, 0x2211, "Thinkpad W541", ALC292_FIXUP_TPT440_DOCK),
6734         SND_PCI_QUIRK(0x17aa, 0x2212, "Thinkpad T440", ALC292_FIXUP_TPT440_DOCK),
6735         SND_PCI_QUIRK(0x17aa, 0x2214, "Thinkpad X240", ALC292_FIXUP_TPT440_DOCK),
6736         SND_PCI_QUIRK(0x17aa, 0x2215, "Thinkpad", ALC269_FIXUP_LIMIT_INT_MIC_BOOST),
6737         SND_PCI_QUIRK(0x17aa, 0x2218, "Thinkpad X1 Carbon 2nd", ALC292_FIXUP_TPT440_DOCK),
6738         SND_PCI_QUIRK(0x17aa, 0x2223, "ThinkPad T550", ALC292_FIXUP_TPT440_DOCK),
6739         SND_PCI_QUIRK(0x17aa, 0x2226, "ThinkPad X250", ALC292_FIXUP_TPT440_DOCK),
6740         SND_PCI_QUIRK(0x17aa, 0x222d, "Thinkpad", ALC298_FIXUP_TPT470_DOCK),
6741         SND_PCI_QUIRK(0x17aa, 0x222e, "Thinkpad", ALC298_FIXUP_TPT470_DOCK),
6742         SND_PCI_QUIRK(0x17aa, 0x2231, "Thinkpad T560", ALC292_FIXUP_TPT460),
6743         SND_PCI_QUIRK(0x17aa, 0x2233, "Thinkpad", ALC292_FIXUP_TPT460),
6744         SND_PCI_QUIRK(0x17aa, 0x2245, "Thinkpad T470", ALC298_FIXUP_TPT470_DOCK),
6745         SND_PCI_QUIRK(0x17aa, 0x2246, "Thinkpad", ALC298_FIXUP_TPT470_DOCK),
6746         SND_PCI_QUIRK(0x17aa, 0x2247, "Thinkpad", ALC298_FIXUP_TPT470_DOCK),
6747         SND_PCI_QUIRK(0x17aa, 0x2249, "Thinkpad", ALC292_FIXUP_TPT460),
6748         SND_PCI_QUIRK(0x17aa, 0x224b, "Thinkpad", ALC298_FIXUP_TPT470_DOCK),
6749         SND_PCI_QUIRK(0x17aa, 0x224c, "Thinkpad", ALC298_FIXUP_TPT470_DOCK),
6750         SND_PCI_QUIRK(0x17aa, 0x224d, "Thinkpad", ALC298_FIXUP_TPT470_DOCK),
6751         SND_PCI_QUIRK(0x17aa, 0x225d, "Thinkpad T480", ALC269_FIXUP_LIMIT_INT_MIC_BOOST),
6752         SND_PCI_QUIRK(0x17aa, 0x30bb, "ThinkCentre AIO", ALC233_FIXUP_LENOVO_LINE2_MIC_HOTKEY),
6753         SND_PCI_QUIRK(0x17aa, 0x30e2, "ThinkCentre AIO", ALC233_FIXUP_LENOVO_LINE2_MIC_HOTKEY),
6754         SND_PCI_QUIRK(0x17aa, 0x310c, "ThinkCentre Station", ALC294_FIXUP_LENOVO_MIC_LOCATION),
6755         SND_PCI_QUIRK(0x17aa, 0x312a, "ThinkCentre Station", ALC294_FIXUP_LENOVO_MIC_LOCATION),
6756         SND_PCI_QUIRK(0x17aa, 0x312f, "ThinkCentre Station", ALC294_FIXUP_LENOVO_MIC_LOCATION),
6757         SND_PCI_QUIRK(0x17aa, 0x313c, "ThinkCentre Station", ALC294_FIXUP_LENOVO_MIC_LOCATION),
6758         SND_PCI_QUIRK(0x17aa, 0x3902, "Lenovo E50-80", ALC269_FIXUP_DMIC_THINKPAD_ACPI),
6759         SND_PCI_QUIRK(0x17aa, 0x3977, "IdeaPad S210", ALC283_FIXUP_INT_MIC),
6760         SND_PCI_QUIRK(0x17aa, 0x3978, "IdeaPad Y410P", ALC269_FIXUP_NO_SHUTUP),
6761         SND_PCI_QUIRK(0x17aa, 0x5013, "Thinkpad", ALC269_FIXUP_LIMIT_INT_MIC_BOOST),
6762         SND_PCI_QUIRK(0x17aa, 0x501a, "Thinkpad", ALC283_FIXUP_INT_MIC),
6763         SND_PCI_QUIRK(0x17aa, 0x501e, "Thinkpad L440", ALC292_FIXUP_TPT440_DOCK),
6764         SND_PCI_QUIRK(0x17aa, 0x5026, "Thinkpad", ALC269_FIXUP_LIMIT_INT_MIC_BOOST),
6765         SND_PCI_QUIRK(0x17aa, 0x5034, "Thinkpad T450", ALC292_FIXUP_TPT440_DOCK),
6766         SND_PCI_QUIRK(0x17aa, 0x5036, "Thinkpad T450s", ALC292_FIXUP_TPT440_DOCK),
6767         SND_PCI_QUIRK(0x17aa, 0x503c, "Thinkpad L450", ALC292_FIXUP_TPT440_DOCK),
6768         SND_PCI_QUIRK(0x17aa, 0x504a, "ThinkPad X260", ALC292_FIXUP_TPT440_DOCK),
6769         SND_PCI_QUIRK(0x17aa, 0x504b, "Thinkpad", ALC293_FIXUP_LENOVO_SPK_NOISE),
6770         SND_PCI_QUIRK(0x17aa, 0x5050, "Thinkpad T560p", ALC292_FIXUP_TPT460),
6771         SND_PCI_QUIRK(0x17aa, 0x5051, "Thinkpad L460", ALC292_FIXUP_TPT460),
6772         SND_PCI_QUIRK(0x17aa, 0x5053, "Thinkpad T460", ALC292_FIXUP_TPT460),
6773         SND_PCI_QUIRK(0x17aa, 0x505d, "Thinkpad", ALC298_FIXUP_TPT470_DOCK),
6774         SND_PCI_QUIRK(0x17aa, 0x505f, "Thinkpad", ALC298_FIXUP_TPT470_DOCK),
6775         SND_PCI_QUIRK(0x17aa, 0x5062, "Thinkpad", ALC298_FIXUP_TPT470_DOCK),
6776         SND_PCI_QUIRK(0x17aa, 0x5109, "Thinkpad", ALC269_FIXUP_LIMIT_INT_MIC_BOOST),
6777         SND_PCI_QUIRK(0x17aa, 0x511e, "Thinkpad", ALC298_FIXUP_TPT470_DOCK),
6778         SND_PCI_QUIRK(0x17aa, 0x511f, "Thinkpad", ALC298_FIXUP_TPT470_DOCK),
6779         SND_PCI_QUIRK(0x17aa, 0x3bf8, "Quanta FL1", ALC269_FIXUP_PCM_44K),
6780         SND_PCI_QUIRK(0x17aa, 0x9e54, "LENOVO NB", ALC269_FIXUP_LENOVO_EAPD),
6781         SND_PCI_QUIRK(0x19e5, 0x3200, "Huawei MBX", ALC255_FIXUP_MIC_MUTE_LED),
6782         SND_PCI_QUIRK(0x19e5, 0x3201, "Huawei MBX", ALC255_FIXUP_MIC_MUTE_LED),
6783         SND_PCI_QUIRK(0x19e5, 0x3204, "Huawei MBXP", ALC256_FIXUP_HUAWEI_MBXP_PINS),
6784         SND_PCI_QUIRK(0x1b7d, 0xa831, "Ordissimo EVE2 ", ALC269VB_FIXUP_ORDISSIMO_EVE2), /* Also known as Malata PC-B1303 */
6785
6786 #if 0
6787         /* Below is a quirk table taken from the old code.
6788          * Basically the device should work as is without the fixup table.
6789          * If BIOS doesn't give a proper info, enable the corresponding
6790          * fixup entry.
6791          */
6792         SND_PCI_QUIRK(0x1043, 0x8330, "ASUS Eeepc P703 P900A",
6793                       ALC269_FIXUP_AMIC),
6794         SND_PCI_QUIRK(0x1043, 0x1013, "ASUS N61Da", ALC269_FIXUP_AMIC),
6795         SND_PCI_QUIRK(0x1043, 0x1143, "ASUS B53f", ALC269_FIXUP_AMIC),
6796         SND_PCI_QUIRK(0x1043, 0x1133, "ASUS UJ20ft", ALC269_FIXUP_AMIC),
6797         SND_PCI_QUIRK(0x1043, 0x1183, "ASUS K72DR", ALC269_FIXUP_AMIC),
6798         SND_PCI_QUIRK(0x1043, 0x11b3, "ASUS K52DR", ALC269_FIXUP_AMIC),
6799         SND_PCI_QUIRK(0x1043, 0x11e3, "ASUS U33Jc", ALC269_FIXUP_AMIC),
6800         SND_PCI_QUIRK(0x1043, 0x1273, "ASUS UL80Jt", ALC269_FIXUP_AMIC),
6801         SND_PCI_QUIRK(0x1043, 0x1283, "ASUS U53Jc", ALC269_FIXUP_AMIC),
6802         SND_PCI_QUIRK(0x1043, 0x12b3, "ASUS N82JV", ALC269_FIXUP_AMIC),
6803         SND_PCI_QUIRK(0x1043, 0x12d3, "ASUS N61Jv", ALC269_FIXUP_AMIC),
6804         SND_PCI_QUIRK(0x1043, 0x13a3, "ASUS UL30Vt", ALC269_FIXUP_AMIC),
6805         SND_PCI_QUIRK(0x1043, 0x1373, "ASUS G73JX", ALC269_FIXUP_AMIC),
6806         SND_PCI_QUIRK(0x1043, 0x1383, "ASUS UJ30Jc", ALC269_FIXUP_AMIC),
6807         SND_PCI_QUIRK(0x1043, 0x13d3, "ASUS N61JA", ALC269_FIXUP_AMIC),
6808         SND_PCI_QUIRK(0x1043, 0x1413, "ASUS UL50", ALC269_FIXUP_AMIC),
6809         SND_PCI_QUIRK(0x1043, 0x1443, "ASUS UL30", ALC269_FIXUP_AMIC),
6810         SND_PCI_QUIRK(0x1043, 0x1453, "ASUS M60Jv", ALC269_FIXUP_AMIC),
6811         SND_PCI_QUIRK(0x1043, 0x1483, "ASUS UL80", ALC269_FIXUP_AMIC),
6812         SND_PCI_QUIRK(0x1043, 0x14f3, "ASUS F83Vf", ALC269_FIXUP_AMIC),
6813         SND_PCI_QUIRK(0x1043, 0x14e3, "ASUS UL20", ALC269_FIXUP_AMIC),
6814         SND_PCI_QUIRK(0x1043, 0x1513, "ASUS UX30", ALC269_FIXUP_AMIC),
6815         SND_PCI_QUIRK(0x1043, 0x1593, "ASUS N51Vn", ALC269_FIXUP_AMIC),
6816         SND_PCI_QUIRK(0x1043, 0x15a3, "ASUS N60Jv", ALC269_FIXUP_AMIC),
6817         SND_PCI_QUIRK(0x1043, 0x15b3, "ASUS N60Dp", ALC269_FIXUP_AMIC),
6818         SND_PCI_QUIRK(0x1043, 0x15c3, "ASUS N70De", ALC269_FIXUP_AMIC),
6819         SND_PCI_QUIRK(0x1043, 0x15e3, "ASUS F83T", ALC269_FIXUP_AMIC),
6820         SND_PCI_QUIRK(0x1043, 0x1643, "ASUS M60J", ALC269_FIXUP_AMIC),
6821         SND_PCI_QUIRK(0x1043, 0x1653, "ASUS U50", ALC269_FIXUP_AMIC),
6822         SND_PCI_QUIRK(0x1043, 0x1693, "ASUS F50N", ALC269_FIXUP_AMIC),
6823         SND_PCI_QUIRK(0x1043, 0x16a3, "ASUS F5Q", ALC269_FIXUP_AMIC),
6824         SND_PCI_QUIRK(0x1043, 0x1723, "ASUS P80", ALC269_FIXUP_AMIC),
6825         SND_PCI_QUIRK(0x1043, 0x1743, "ASUS U80", ALC269_FIXUP_AMIC),
6826         SND_PCI_QUIRK(0x1043, 0x1773, "ASUS U20A", ALC269_FIXUP_AMIC),
6827         SND_PCI_QUIRK(0x1043, 0x1883, "ASUS F81Se", ALC269_FIXUP_AMIC),
6828         SND_PCI_QUIRK(0x152d, 0x1778, "Quanta ON1", ALC269_FIXUP_DMIC),
6829         SND_PCI_QUIRK(0x17aa, 0x3be9, "Quanta Wistron", ALC269_FIXUP_AMIC),
6830         SND_PCI_QUIRK(0x17aa, 0x3bf8, "Quanta FL1", ALC269_FIXUP_AMIC),
6831         SND_PCI_QUIRK(0x17ff, 0x059a, "Quanta EL3", ALC269_FIXUP_DMIC),
6832         SND_PCI_QUIRK(0x17ff, 0x059b, "Quanta JR1", ALC269_FIXUP_DMIC),
6833 #endif
6834         {}
6835 };
6836
6837 static const struct snd_pci_quirk alc269_fixup_vendor_tbl[] = {
6838         SND_PCI_QUIRK_VENDOR(0x1025, "Acer Aspire", ALC271_FIXUP_DMIC),
6839         SND_PCI_QUIRK_VENDOR(0x103c, "HP", ALC269_FIXUP_HP_MUTE_LED),
6840         SND_PCI_QUIRK_VENDOR(0x104d, "Sony VAIO", ALC269_FIXUP_SONY_VAIO),
6841         SND_PCI_QUIRK_VENDOR(0x17aa, "Thinkpad", ALC269_FIXUP_THINKPAD_ACPI),
6842         {}
6843 };
6844
6845 static const struct hda_model_fixup alc269_fixup_models[] = {
6846         {.id = ALC269_FIXUP_AMIC, .name = "laptop-amic"},
6847         {.id = ALC269_FIXUP_DMIC, .name = "laptop-dmic"},
6848         {.id = ALC269_FIXUP_STEREO_DMIC, .name = "alc269-dmic"},
6849         {.id = ALC271_FIXUP_DMIC, .name = "alc271-dmic"},
6850         {.id = ALC269_FIXUP_INV_DMIC, .name = "inv-dmic"},
6851         {.id = ALC269_FIXUP_HEADSET_MIC, .name = "headset-mic"},
6852         {.id = ALC269_FIXUP_HEADSET_MODE, .name = "headset-mode"},
6853         {.id = ALC269_FIXUP_HEADSET_MODE_NO_HP_MIC, .name = "headset-mode-no-hp-mic"},
6854         {.id = ALC269_FIXUP_LENOVO_DOCK, .name = "lenovo-dock"},
6855         {.id = ALC269_FIXUP_HP_GPIO_LED, .name = "hp-gpio-led"},
6856         {.id = ALC269_FIXUP_HP_DOCK_GPIO_MIC1_LED, .name = "hp-dock-gpio-mic1-led"},
6857         {.id = ALC269_FIXUP_DELL1_MIC_NO_PRESENCE, .name = "dell-headset-multi"},
6858         {.id = ALC269_FIXUP_DELL2_MIC_NO_PRESENCE, .name = "dell-headset-dock"},
6859         {.id = ALC269_FIXUP_DELL3_MIC_NO_PRESENCE, .name = "dell-headset3"},
6860         {.id = ALC269_FIXUP_DELL4_MIC_NO_PRESENCE, .name = "dell-headset4"},
6861         {.id = ALC283_FIXUP_CHROME_BOOK, .name = "alc283-dac-wcaps"},
6862         {.id = ALC283_FIXUP_SENSE_COMBO_JACK, .name = "alc283-sense-combo"},
6863         {.id = ALC292_FIXUP_TPT440_DOCK, .name = "tpt440-dock"},
6864         {.id = ALC292_FIXUP_TPT440, .name = "tpt440"},
6865         {.id = ALC292_FIXUP_TPT460, .name = "tpt460"},
6866         {.id = ALC298_FIXUP_TPT470_DOCK, .name = "tpt470-dock"},
6867         {.id = ALC233_FIXUP_LENOVO_MULTI_CODECS, .name = "dual-codecs"},
6868         {.id = ALC700_FIXUP_INTEL_REFERENCE, .name = "alc700-ref"},
6869         {.id = ALC269_FIXUP_SONY_VAIO, .name = "vaio"},
6870         {.id = ALC269_FIXUP_DELL_M101Z, .name = "dell-m101z"},
6871         {.id = ALC269_FIXUP_ASUS_G73JW, .name = "asus-g73jw"},
6872         {.id = ALC269_FIXUP_LENOVO_EAPD, .name = "lenovo-eapd"},
6873         {.id = ALC275_FIXUP_SONY_HWEQ, .name = "sony-hweq"},
6874         {.id = ALC269_FIXUP_PCM_44K, .name = "pcm44k"},
6875         {.id = ALC269_FIXUP_LIFEBOOK, .name = "lifebook"},
6876         {.id = ALC269_FIXUP_LIFEBOOK_EXTMIC, .name = "lifebook-extmic"},
6877         {.id = ALC269_FIXUP_LIFEBOOK_HP_PIN, .name = "lifebook-hp-pin"},
6878         {.id = ALC255_FIXUP_LIFEBOOK_U7x7_HEADSET_MIC, .name = "lifebook-u7x7"},
6879         {.id = ALC269VB_FIXUP_AMIC, .name = "alc269vb-amic"},
6880         {.id = ALC269VB_FIXUP_DMIC, .name = "alc269vb-dmic"},
6881         {.id = ALC269_FIXUP_HP_MUTE_LED_MIC1, .name = "hp-mute-led-mic1"},
6882         {.id = ALC269_FIXUP_HP_MUTE_LED_MIC2, .name = "hp-mute-led-mic2"},
6883         {.id = ALC269_FIXUP_HP_MUTE_LED_MIC3, .name = "hp-mute-led-mic3"},
6884         {.id = ALC269_FIXUP_HP_GPIO_MIC1_LED, .name = "hp-gpio-mic1"},
6885         {.id = ALC269_FIXUP_HP_LINE1_MIC1_LED, .name = "hp-line1-mic1"},
6886         {.id = ALC269_FIXUP_NO_SHUTUP, .name = "noshutup"},
6887         {.id = ALC286_FIXUP_SONY_MIC_NO_PRESENCE, .name = "sony-nomic"},
6888         {.id = ALC269_FIXUP_ASPIRE_HEADSET_MIC, .name = "aspire-headset-mic"},
6889         {.id = ALC269_FIXUP_ASUS_X101, .name = "asus-x101"},
6890         {.id = ALC271_FIXUP_HP_GATE_MIC_JACK, .name = "acer-ao7xx"},
6891         {.id = ALC271_FIXUP_HP_GATE_MIC_JACK_E1_572, .name = "acer-aspire-e1"},
6892         {.id = ALC269_FIXUP_ACER_AC700, .name = "acer-ac700"},
6893         {.id = ALC269_FIXUP_LIMIT_INT_MIC_BOOST, .name = "limit-mic-boost"},
6894         {.id = ALC269VB_FIXUP_ASUS_ZENBOOK, .name = "asus-zenbook"},
6895         {.id = ALC269VB_FIXUP_ASUS_ZENBOOK_UX31A, .name = "asus-zenbook-ux31a"},
6896         {.id = ALC269VB_FIXUP_ORDISSIMO_EVE2, .name = "ordissimo"},
6897         {.id = ALC282_FIXUP_ASUS_TX300, .name = "asus-tx300"},
6898         {.id = ALC283_FIXUP_INT_MIC, .name = "alc283-int-mic"},
6899         {.id = ALC290_FIXUP_MONO_SPEAKERS_HSJACK, .name = "mono-speakers"},
6900         {.id = ALC290_FIXUP_SUBWOOFER_HSJACK, .name = "alc290-subwoofer"},
6901         {.id = ALC269_FIXUP_THINKPAD_ACPI, .name = "thinkpad"},
6902         {.id = ALC269_FIXUP_DMIC_THINKPAD_ACPI, .name = "dmic-thinkpad"},
6903         {.id = ALC255_FIXUP_ACER_MIC_NO_PRESENCE, .name = "alc255-acer"},
6904         {.id = ALC255_FIXUP_ASUS_MIC_NO_PRESENCE, .name = "alc255-asus"},
6905         {.id = ALC255_FIXUP_DELL1_MIC_NO_PRESENCE, .name = "alc255-dell1"},
6906         {.id = ALC255_FIXUP_DELL2_MIC_NO_PRESENCE, .name = "alc255-dell2"},
6907         {.id = ALC293_FIXUP_DELL1_MIC_NO_PRESENCE, .name = "alc293-dell1"},
6908         {.id = ALC283_FIXUP_HEADSET_MIC, .name = "alc283-headset"},
6909         {.id = ALC255_FIXUP_MIC_MUTE_LED, .name = "alc255-dell-mute"},
6910         {.id = ALC282_FIXUP_ASPIRE_V5_PINS, .name = "aspire-v5"},
6911         {.id = ALC280_FIXUP_HP_GPIO4, .name = "hp-gpio4"},
6912         {.id = ALC286_FIXUP_HP_GPIO_LED, .name = "hp-gpio-led"},
6913         {.id = ALC280_FIXUP_HP_GPIO2_MIC_HOTKEY, .name = "hp-gpio2-hotkey"},
6914         {.id = ALC280_FIXUP_HP_DOCK_PINS, .name = "hp-dock-pins"},
6915         {.id = ALC269_FIXUP_HP_DOCK_GPIO_MIC1_LED, .name = "hp-dock-gpio-mic"},
6916         {.id = ALC280_FIXUP_HP_9480M, .name = "hp-9480m"},
6917         {.id = ALC288_FIXUP_DELL_HEADSET_MODE, .name = "alc288-dell-headset"},
6918         {.id = ALC288_FIXUP_DELL1_MIC_NO_PRESENCE, .name = "alc288-dell1"},
6919         {.id = ALC288_FIXUP_DELL_XPS_13, .name = "alc288-dell-xps13"},
6920         {.id = ALC292_FIXUP_DELL_E7X, .name = "dell-e7x"},
6921         {.id = ALC293_FIXUP_DISABLE_AAMIX_MULTIJACK, .name = "alc293-dell"},
6922         {.id = ALC298_FIXUP_DELL1_MIC_NO_PRESENCE, .name = "alc298-dell1"},
6923         {.id = ALC298_FIXUP_DELL_AIO_MIC_NO_PRESENCE, .name = "alc298-dell-aio"},
6924         {.id = ALC275_FIXUP_DELL_XPS, .name = "alc275-dell-xps"},
6925         {.id = ALC256_FIXUP_DELL_XPS_13_HEADPHONE_NOISE, .name = "alc256-dell-xps13"},
6926         {.id = ALC293_FIXUP_LENOVO_SPK_NOISE, .name = "lenovo-spk-noise"},
6927         {.id = ALC233_FIXUP_LENOVO_LINE2_MIC_HOTKEY, .name = "lenovo-hotkey"},
6928         {.id = ALC255_FIXUP_DELL_SPK_NOISE, .name = "dell-spk-noise"},
6929         {.id = ALC225_FIXUP_DELL1_MIC_NO_PRESENCE, .name = "alc225-dell1"},
6930         {.id = ALC295_FIXUP_DISABLE_DAC3, .name = "alc295-disable-dac3"},
6931         {.id = ALC280_FIXUP_HP_HEADSET_MIC, .name = "alc280-hp-headset"},
6932         {.id = ALC221_FIXUP_HP_FRONT_MIC, .name = "alc221-hp-mic"},
6933         {.id = ALC298_FIXUP_SPK_VOLUME, .name = "alc298-spk-volume"},
6934         {.id = ALC256_FIXUP_DELL_INSPIRON_7559_SUBWOOFER, .name = "dell-inspiron-7559"},
6935         {.id = ALC269_FIXUP_ATIV_BOOK_8, .name = "ativ-book"},
6936         {.id = ALC221_FIXUP_HP_MIC_NO_PRESENCE, .name = "alc221-hp-mic"},
6937         {.id = ALC256_FIXUP_ASUS_HEADSET_MODE, .name = "alc256-asus-headset"},
6938         {.id = ALC256_FIXUP_ASUS_MIC, .name = "alc256-asus-mic"},
6939         {.id = ALC256_FIXUP_ASUS_AIO_GPIO2, .name = "alc256-asus-aio"},
6940         {.id = ALC233_FIXUP_ASUS_MIC_NO_PRESENCE, .name = "alc233-asus"},
6941         {.id = ALC233_FIXUP_EAPD_COEF_AND_MIC_NO_PRESENCE, .name = "alc233-eapd"},
6942         {.id = ALC294_FIXUP_LENOVO_MIC_LOCATION, .name = "alc294-lenovo-mic"},
6943         {.id = ALC225_FIXUP_DELL_WYSE_MIC_NO_PRESENCE, .name = "alc225-wyse"},
6944         {.id = ALC274_FIXUP_DELL_AIO_LINEOUT_VERB, .name = "alc274-dell-aio"},
6945         {.id = ALC255_FIXUP_DUMMY_LINEOUT_VERB, .name = "alc255-dummy-lineout"},
6946         {.id = ALC255_FIXUP_DELL_HEADSET_MIC, .name = "alc255-dell-headset"},
6947         {.id = ALC295_FIXUP_HP_X360, .name = "alc295-hp-x360"},
6948         {.id = ALC225_FIXUP_HEADSET_JACK, .name = "alc-sense-combo"},
6949         {}
6950 };
6951 #define ALC225_STANDARD_PINS \
6952         {0x21, 0x04211020}
6953
6954 #define ALC256_STANDARD_PINS \
6955         {0x12, 0x90a60140}, \
6956         {0x14, 0x90170110}, \
6957         {0x21, 0x02211020}
6958
6959 #define ALC282_STANDARD_PINS \
6960         {0x14, 0x90170110}
6961
6962 #define ALC290_STANDARD_PINS \
6963         {0x12, 0x99a30130}
6964
6965 #define ALC292_STANDARD_PINS \
6966         {0x14, 0x90170110}, \
6967         {0x15, 0x0221401f}
6968
6969 #define ALC295_STANDARD_PINS \
6970         {0x12, 0xb7a60130}, \
6971         {0x14, 0x90170110}, \
6972         {0x21, 0x04211020}
6973
6974 #define ALC298_STANDARD_PINS \
6975         {0x12, 0x90a60130}, \
6976         {0x21, 0x03211020}
6977
6978 static const struct snd_hda_pin_quirk alc269_pin_fixup_tbl[] = {
6979         SND_HDA_PIN_QUIRK(0x10ec0221, 0x103c, "HP Workstation", ALC221_FIXUP_HP_HEADSET_MIC,
6980                 {0x14, 0x01014020},
6981                 {0x17, 0x90170110},
6982                 {0x18, 0x02a11030},
6983                 {0x19, 0x0181303F},
6984                 {0x21, 0x0221102f}),
6985         SND_HDA_PIN_QUIRK(0x10ec0255, 0x1025, "Acer", ALC255_FIXUP_ACER_MIC_NO_PRESENCE,
6986                 {0x12, 0x90a601c0},
6987                 {0x14, 0x90171120},
6988                 {0x21, 0x02211030}),
6989         SND_HDA_PIN_QUIRK(0x10ec0255, 0x1043, "ASUS", ALC255_FIXUP_ASUS_MIC_NO_PRESENCE,
6990                 {0x14, 0x90170110},
6991                 {0x1b, 0x90a70130},
6992                 {0x21, 0x03211020}),
6993         SND_HDA_PIN_QUIRK(0x10ec0255, 0x1043, "ASUS", ALC255_FIXUP_ASUS_MIC_NO_PRESENCE,
6994                 {0x1a, 0x90a70130},
6995                 {0x1b, 0x90170110},
6996                 {0x21, 0x03211020}),
6997         SND_HDA_PIN_QUIRK(0x10ec0225, 0x1028, "Dell", ALC225_FIXUP_DELL1_MIC_NO_PRESENCE,
6998                 ALC225_STANDARD_PINS,
6999                 {0x12, 0xb7a60130},
7000                 {0x14, 0x901701a0}),
7001         SND_HDA_PIN_QUIRK(0x10ec0225, 0x1028, "Dell", ALC225_FIXUP_DELL1_MIC_NO_PRESENCE,
7002                 ALC225_STANDARD_PINS,
7003                 {0x12, 0xb7a60130},
7004                 {0x14, 0x901701b0}),
7005         SND_HDA_PIN_QUIRK(0x10ec0225, 0x1028, "Dell", ALC225_FIXUP_DELL1_MIC_NO_PRESENCE,
7006                 ALC225_STANDARD_PINS,
7007                 {0x12, 0xb7a60150},
7008                 {0x14, 0x901701a0}),
7009         SND_HDA_PIN_QUIRK(0x10ec0225, 0x1028, "Dell", ALC225_FIXUP_DELL1_MIC_NO_PRESENCE,
7010                 ALC225_STANDARD_PINS,
7011                 {0x12, 0xb7a60150},
7012                 {0x14, 0x901701b0}),
7013         SND_HDA_PIN_QUIRK(0x10ec0225, 0x1028, "Dell", ALC225_FIXUP_DELL1_MIC_NO_PRESENCE,
7014                 ALC225_STANDARD_PINS,
7015                 {0x12, 0xb7a60130},
7016                 {0x1b, 0x90170110}),
7017         SND_HDA_PIN_QUIRK(0x10ec0233, 0x8086, "Intel NUC Skull Canyon", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE,
7018                 {0x1b, 0x01111010},
7019                 {0x1e, 0x01451130},
7020                 {0x21, 0x02211020}),
7021         SND_HDA_PIN_QUIRK(0x10ec0235, 0x17aa, "Lenovo", ALC233_FIXUP_LENOVO_LINE2_MIC_HOTKEY,
7022                 {0x12, 0x90a60140},
7023                 {0x14, 0x90170110},
7024                 {0x19, 0x02a11030},
7025                 {0x21, 0x02211020}),
7026         SND_HDA_PIN_QUIRK(0x10ec0235, 0x17aa, "Lenovo", ALC294_FIXUP_LENOVO_MIC_LOCATION,
7027                 {0x14, 0x90170110},
7028                 {0x19, 0x02a11030},
7029                 {0x1a, 0x02a11040},
7030                 {0x1b, 0x01014020},
7031                 {0x21, 0x0221101f}),
7032         SND_HDA_PIN_QUIRK(0x10ec0235, 0x17aa, "Lenovo", ALC294_FIXUP_LENOVO_MIC_LOCATION,
7033                 {0x14, 0x90170110},
7034                 {0x19, 0x02a11030},
7035                 {0x1a, 0x02a11040},
7036                 {0x1b, 0x01011020},
7037                 {0x21, 0x0221101f}),
7038         SND_HDA_PIN_QUIRK(0x10ec0235, 0x17aa, "Lenovo", ALC294_FIXUP_LENOVO_MIC_LOCATION,
7039                 {0x14, 0x90170110},
7040                 {0x19, 0x02a11020},
7041                 {0x1a, 0x02a11030},
7042                 {0x21, 0x0221101f}),
7043         SND_HDA_PIN_QUIRK(0x10ec0236, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
7044                 {0x12, 0x90a60140},
7045                 {0x14, 0x90170110},
7046                 {0x21, 0x02211020}),
7047         SND_HDA_PIN_QUIRK(0x10ec0236, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
7048                 {0x12, 0x90a60140},
7049                 {0x14, 0x90170150},
7050                 {0x21, 0x02211020}),
7051         SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL2_MIC_NO_PRESENCE,
7052                 {0x14, 0x90170110},
7053                 {0x21, 0x02211020}),
7054         SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
7055                 {0x14, 0x90170130},
7056                 {0x21, 0x02211040}),
7057         SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
7058                 {0x12, 0x90a60140},
7059                 {0x14, 0x90170110},
7060                 {0x21, 0x02211020}),
7061         SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
7062                 {0x12, 0x90a60160},
7063                 {0x14, 0x90170120},
7064                 {0x21, 0x02211030}),
7065         SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
7066                 {0x14, 0x90170110},
7067                 {0x1b, 0x02011020},
7068                 {0x21, 0x0221101f}),
7069         SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
7070                 {0x14, 0x90170110},
7071                 {0x1b, 0x01011020},
7072                 {0x21, 0x0221101f}),
7073         SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
7074                 {0x14, 0x90170130},
7075                 {0x1b, 0x01014020},
7076                 {0x21, 0x0221103f}),
7077         SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
7078                 {0x14, 0x90170130},
7079                 {0x1b, 0x01011020},
7080                 {0x21, 0x0221103f}),
7081         SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
7082                 {0x14, 0x90170130},
7083                 {0x1b, 0x02011020},
7084                 {0x21, 0x0221103f}),
7085         SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
7086                 {0x14, 0x90170150},
7087                 {0x1b, 0x02011020},
7088                 {0x21, 0x0221105f}),
7089         SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
7090                 {0x14, 0x90170110},
7091                 {0x1b, 0x01014020},
7092                 {0x21, 0x0221101f}),
7093         SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
7094                 {0x12, 0x90a60160},
7095                 {0x14, 0x90170120},
7096                 {0x17, 0x90170140},
7097                 {0x21, 0x0321102f}),
7098         SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
7099                 {0x12, 0x90a60160},
7100                 {0x14, 0x90170130},
7101                 {0x21, 0x02211040}),
7102         SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
7103                 {0x12, 0x90a60160},
7104                 {0x14, 0x90170140},
7105                 {0x21, 0x02211050}),
7106         SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
7107                 {0x12, 0x90a60170},
7108                 {0x14, 0x90170120},
7109                 {0x21, 0x02211030}),
7110         SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
7111                 {0x12, 0x90a60170},
7112                 {0x14, 0x90170130},
7113                 {0x21, 0x02211040}),
7114         SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
7115                 {0x12, 0x90a60170},
7116                 {0x14, 0x90171130},
7117                 {0x21, 0x02211040}),
7118         SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
7119                 {0x12, 0x90a60170},
7120                 {0x14, 0x90170140},
7121                 {0x21, 0x02211050}),
7122         SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell Inspiron 5548", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
7123                 {0x12, 0x90a60180},
7124                 {0x14, 0x90170130},
7125                 {0x21, 0x02211040}),
7126         SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell Inspiron 5565", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
7127                 {0x12, 0x90a60180},
7128                 {0x14, 0x90170120},
7129                 {0x21, 0x02211030}),
7130         SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
7131                 {0x1b, 0x01011020},
7132                 {0x21, 0x02211010}),
7133         SND_HDA_PIN_QUIRK(0x10ec0256, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
7134                 {0x12, 0x90a60130},
7135                 {0x14, 0x90170110},
7136                 {0x1b, 0x01011020},
7137                 {0x21, 0x0221101f}),
7138         SND_HDA_PIN_QUIRK(0x10ec0256, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
7139                 {0x12, 0x90a60160},
7140                 {0x14, 0x90170120},
7141                 {0x21, 0x02211030}),
7142         SND_HDA_PIN_QUIRK(0x10ec0256, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
7143                 {0x12, 0x90a60170},
7144                 {0x14, 0x90170120},
7145                 {0x21, 0x02211030}),
7146         SND_HDA_PIN_QUIRK(0x10ec0256, 0x1028, "Dell Inspiron 5468", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
7147                 {0x12, 0x90a60180},
7148                 {0x14, 0x90170120},
7149                 {0x21, 0x02211030}),
7150         SND_HDA_PIN_QUIRK(0x10ec0256, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
7151                 {0x12, 0xb7a60130},
7152                 {0x14, 0x90170110},
7153                 {0x21, 0x02211020}),
7154         SND_HDA_PIN_QUIRK(0x10ec0256, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
7155                 {0x12, 0x90a60130},
7156                 {0x14, 0x90170110},
7157                 {0x14, 0x01011020},
7158                 {0x21, 0x0221101f}),
7159         SND_HDA_PIN_QUIRK(0x10ec0256, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
7160                 ALC256_STANDARD_PINS),
7161         SND_HDA_PIN_QUIRK(0x10ec0256, 0x1043, "ASUS", ALC256_FIXUP_ASUS_MIC,
7162                 {0x14, 0x90170110},
7163                 {0x1b, 0x90a70130},
7164                 {0x21, 0x04211020}),
7165         SND_HDA_PIN_QUIRK(0x10ec0256, 0x1043, "ASUS", ALC256_FIXUP_ASUS_MIC,
7166                 {0x14, 0x90170110},
7167                 {0x1b, 0x90a70130},
7168                 {0x21, 0x03211020}),
7169         SND_HDA_PIN_QUIRK(0x10ec0274, 0x1028, "Dell", ALC274_FIXUP_DELL_AIO_LINEOUT_VERB,
7170                 {0x12, 0xb7a60130},
7171                 {0x13, 0xb8a61140},
7172                 {0x16, 0x90170110},
7173                 {0x21, 0x04211020}),
7174         SND_HDA_PIN_QUIRK(0x10ec0280, 0x103c, "HP", ALC280_FIXUP_HP_GPIO4,
7175                 {0x12, 0x90a60130},
7176                 {0x14, 0x90170110},
7177                 {0x15, 0x0421101f},
7178                 {0x1a, 0x04a11020}),
7179         SND_HDA_PIN_QUIRK(0x10ec0280, 0x103c, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED,
7180                 {0x12, 0x90a60140},
7181                 {0x14, 0x90170110},
7182                 {0x15, 0x0421101f},
7183                 {0x18, 0x02811030},
7184                 {0x1a, 0x04a1103f},
7185                 {0x1b, 0x02011020}),
7186         SND_HDA_PIN_QUIRK(0x10ec0282, 0x103c, "HP 15 Touchsmart", ALC269_FIXUP_HP_MUTE_LED_MIC1,
7187                 ALC282_STANDARD_PINS,
7188                 {0x12, 0x99a30130},
7189                 {0x19, 0x03a11020},
7190                 {0x21, 0x0321101f}),
7191         SND_HDA_PIN_QUIRK(0x10ec0282, 0x103c, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1,
7192                 ALC282_STANDARD_PINS,
7193                 {0x12, 0x99a30130},
7194                 {0x19, 0x03a11020},
7195                 {0x21, 0x03211040}),
7196         SND_HDA_PIN_QUIRK(0x10ec0282, 0x103c, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1,
7197                 ALC282_STANDARD_PINS,
7198                 {0x12, 0x99a30130},
7199                 {0x19, 0x03a11030},
7200                 {0x21, 0x03211020}),
7201         SND_HDA_PIN_QUIRK(0x10ec0282, 0x103c, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1,
7202                 ALC282_STANDARD_PINS,
7203                 {0x12, 0x99a30130},
7204                 {0x19, 0x04a11020},
7205                 {0x21, 0x0421101f}),
7206         SND_HDA_PIN_QUIRK(0x10ec0282, 0x103c, "HP", ALC269_FIXUP_HP_LINE1_MIC1_LED,
7207                 ALC282_STANDARD_PINS,
7208                 {0x12, 0x90a60140},
7209                 {0x19, 0x04a11030},
7210                 {0x21, 0x04211020}),
7211         SND_HDA_PIN_QUIRK(0x10ec0283, 0x1028, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE,
7212                 ALC282_STANDARD_PINS,
7213                 {0x12, 0x90a60130},
7214                 {0x21, 0x0321101f}),
7215         SND_HDA_PIN_QUIRK(0x10ec0283, 0x1028, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE,
7216                 {0x12, 0x90a60160},
7217                 {0x14, 0x90170120},
7218                 {0x21, 0x02211030}),
7219         SND_HDA_PIN_QUIRK(0x10ec0283, 0x1028, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE,
7220                 ALC282_STANDARD_PINS,
7221                 {0x12, 0x90a60130},
7222                 {0x19, 0x03a11020},
7223                 {0x21, 0x0321101f}),
7224         SND_HDA_PIN_QUIRK(0x10ec0285, 0x17aa, "Lenovo", ALC285_FIXUP_LENOVO_HEADPHONE_NOISE,
7225                 {0x12, 0x90a60130},
7226                 {0x14, 0x90170110},
7227                 {0x19, 0x04a11040},
7228                 {0x21, 0x04211020}),
7229         SND_HDA_PIN_QUIRK(0x10ec0286, 0x1025, "Acer", ALC286_FIXUP_ACER_AIO_MIC_NO_PRESENCE,
7230                 {0x12, 0x90a60130},
7231                 {0x17, 0x90170110},
7232                 {0x21, 0x02211020}),
7233         SND_HDA_PIN_QUIRK(0x10ec0288, 0x1028, "Dell", ALC288_FIXUP_DELL1_MIC_NO_PRESENCE,
7234                 {0x12, 0x90a60120},
7235                 {0x14, 0x90170110},
7236                 {0x21, 0x0321101f}),
7237         SND_HDA_PIN_QUIRK(0x10ec0289, 0x1028, "Dell", ALC269_FIXUP_DELL4_MIC_NO_PRESENCE,
7238                 {0x12, 0xb7a60130},
7239                 {0x14, 0x90170110},
7240                 {0x21, 0x04211020}),
7241         SND_HDA_PIN_QUIRK(0x10ec0290, 0x103c, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1,
7242                 ALC290_STANDARD_PINS,
7243                 {0x15, 0x04211040},
7244                 {0x18, 0x90170112},
7245                 {0x1a, 0x04a11020}),
7246         SND_HDA_PIN_QUIRK(0x10ec0290, 0x103c, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1,
7247                 ALC290_STANDARD_PINS,
7248                 {0x15, 0x04211040},
7249                 {0x18, 0x90170110},
7250                 {0x1a, 0x04a11020}),
7251         SND_HDA_PIN_QUIRK(0x10ec0290, 0x103c, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1,
7252                 ALC290_STANDARD_PINS,
7253                 {0x15, 0x0421101f},
7254                 {0x1a, 0x04a11020}),
7255         SND_HDA_PIN_QUIRK(0x10ec0290, 0x103c, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1,
7256                 ALC290_STANDARD_PINS,
7257                 {0x15, 0x04211020},
7258                 {0x1a, 0x04a11040}),
7259         SND_HDA_PIN_QUIRK(0x10ec0290, 0x103c, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1,
7260                 ALC290_STANDARD_PINS,
7261                 {0x14, 0x90170110},
7262                 {0x15, 0x04211020},
7263                 {0x1a, 0x04a11040}),
7264         SND_HDA_PIN_QUIRK(0x10ec0290, 0x103c, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1,
7265                 ALC290_STANDARD_PINS,
7266                 {0x14, 0x90170110},
7267                 {0x15, 0x04211020},
7268                 {0x1a, 0x04a11020}),
7269         SND_HDA_PIN_QUIRK(0x10ec0290, 0x103c, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1,
7270                 ALC290_STANDARD_PINS,
7271                 {0x14, 0x90170110},
7272                 {0x15, 0x0421101f},
7273                 {0x1a, 0x04a11020}),
7274         SND_HDA_PIN_QUIRK(0x10ec0292, 0x1028, "Dell", ALC269_FIXUP_DELL2_MIC_NO_PRESENCE,
7275                 ALC292_STANDARD_PINS,
7276                 {0x12, 0x90a60140},
7277                 {0x16, 0x01014020},
7278                 {0x19, 0x01a19030}),
7279         SND_HDA_PIN_QUIRK(0x10ec0292, 0x1028, "Dell", ALC269_FIXUP_DELL2_MIC_NO_PRESENCE,
7280                 ALC292_STANDARD_PINS,
7281                 {0x12, 0x90a60140},
7282                 {0x16, 0x01014020},
7283                 {0x18, 0x02a19031},
7284                 {0x19, 0x01a1903e}),
7285         SND_HDA_PIN_QUIRK(0x10ec0292, 0x1028, "Dell", ALC269_FIXUP_DELL3_MIC_NO_PRESENCE,
7286                 ALC292_STANDARD_PINS,
7287                 {0x12, 0x90a60140}),
7288         SND_HDA_PIN_QUIRK(0x10ec0293, 0x1028, "Dell", ALC293_FIXUP_DELL1_MIC_NO_PRESENCE,
7289                 ALC292_STANDARD_PINS,
7290                 {0x13, 0x90a60140},
7291                 {0x16, 0x21014020},
7292                 {0x19, 0x21a19030}),
7293         SND_HDA_PIN_QUIRK(0x10ec0293, 0x1028, "Dell", ALC293_FIXUP_DELL1_MIC_NO_PRESENCE,
7294                 ALC292_STANDARD_PINS,
7295                 {0x13, 0x90a60140}),
7296         SND_HDA_PIN_QUIRK(0x10ec0294, 0x1043, "ASUS", ALC294_FIXUP_ASUS_MIC,
7297                 {0x14, 0x90170110},
7298                 {0x1b, 0x90a70130},
7299                 {0x21, 0x04211020}),
7300         SND_HDA_PIN_QUIRK(0x10ec0294, 0x1043, "ASUS", ALC294_FIXUP_ASUS_SPK,
7301                 {0x12, 0x90a60130},
7302                 {0x17, 0x90170110},
7303                 {0x21, 0x04211020}),
7304         SND_HDA_PIN_QUIRK(0x10ec0295, 0x1028, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE,
7305                 ALC295_STANDARD_PINS,
7306                 {0x17, 0x21014020},
7307                 {0x18, 0x21a19030}),
7308         SND_HDA_PIN_QUIRK(0x10ec0295, 0x1028, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE,
7309                 ALC295_STANDARD_PINS,
7310                 {0x17, 0x21014040},
7311                 {0x18, 0x21a19050}),
7312         SND_HDA_PIN_QUIRK(0x10ec0295, 0x1028, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE,
7313                 ALC295_STANDARD_PINS),
7314         SND_HDA_PIN_QUIRK(0x10ec0298, 0x1028, "Dell", ALC298_FIXUP_DELL1_MIC_NO_PRESENCE,
7315                 ALC298_STANDARD_PINS,
7316                 {0x17, 0x90170110}),
7317         SND_HDA_PIN_QUIRK(0x10ec0298, 0x1028, "Dell", ALC298_FIXUP_DELL1_MIC_NO_PRESENCE,
7318                 ALC298_STANDARD_PINS,
7319                 {0x17, 0x90170140}),
7320         SND_HDA_PIN_QUIRK(0x10ec0298, 0x1028, "Dell", ALC298_FIXUP_DELL1_MIC_NO_PRESENCE,
7321                 ALC298_STANDARD_PINS,
7322                 {0x17, 0x90170150}),
7323         SND_HDA_PIN_QUIRK(0x10ec0298, 0x1028, "Dell", ALC298_FIXUP_SPK_VOLUME,
7324                 {0x12, 0xb7a60140},
7325                 {0x13, 0xb7a60150},
7326                 {0x17, 0x90170110},
7327                 {0x1a, 0x03011020},
7328                 {0x21, 0x03211030}),
7329         SND_HDA_PIN_QUIRK(0x10ec0299, 0x1028, "Dell", ALC269_FIXUP_DELL4_MIC_NO_PRESENCE,
7330                 ALC225_STANDARD_PINS,
7331                 {0x12, 0xb7a60130},
7332                 {0x17, 0x90170110}),
7333         {}
7334 };
7335
7336 static void alc269_fill_coef(struct hda_codec *codec)
7337 {
7338         struct alc_spec *spec = codec->spec;
7339         int val;
7340
7341         if (spec->codec_variant != ALC269_TYPE_ALC269VB)
7342                 return;
7343
7344         if ((alc_get_coef0(codec) & 0x00ff) < 0x015) {
7345                 alc_write_coef_idx(codec, 0xf, 0x960b);
7346                 alc_write_coef_idx(codec, 0xe, 0x8817);
7347         }
7348
7349         if ((alc_get_coef0(codec) & 0x00ff) == 0x016) {
7350                 alc_write_coef_idx(codec, 0xf, 0x960b);
7351                 alc_write_coef_idx(codec, 0xe, 0x8814);
7352         }
7353
7354         if ((alc_get_coef0(codec) & 0x00ff) == 0x017) {
7355                 /* Power up output pin */
7356                 alc_update_coef_idx(codec, 0x04, 0, 1<<11);
7357         }
7358
7359         if ((alc_get_coef0(codec) & 0x00ff) == 0x018) {
7360                 val = alc_read_coef_idx(codec, 0xd);
7361                 if (val != -1 && (val & 0x0c00) >> 10 != 0x1) {
7362                         /* Capless ramp up clock control */
7363                         alc_write_coef_idx(codec, 0xd, val | (1<<10));
7364                 }
7365                 val = alc_read_coef_idx(codec, 0x17);
7366                 if (val != -1 && (val & 0x01c0) >> 6 != 0x4) {
7367                         /* Class D power on reset */
7368                         alc_write_coef_idx(codec, 0x17, val | (1<<7));
7369                 }
7370         }
7371
7372         /* HP */
7373         alc_update_coef_idx(codec, 0x4, 0, 1<<11);
7374 }
7375
7376 static void alc294_hp_init(struct hda_codec *codec)
7377 {
7378         struct alc_spec *spec = codec->spec;
7379         hda_nid_t hp_pin = spec->gen.autocfg.hp_pins[0];
7380         int i, val;
7381
7382         if (!hp_pin)
7383                 return;
7384
7385         snd_hda_codec_write(codec, hp_pin, 0,
7386                             AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);
7387
7388         msleep(100);
7389
7390         snd_hda_codec_write(codec, hp_pin, 0,
7391                             AC_VERB_SET_PIN_WIDGET_CONTROL, 0x0);
7392
7393         alc_update_coef_idx(codec, 0x6f, 0x000f, 0);/* Set HP depop to manual mode */
7394         alc_update_coefex_idx(codec, 0x58, 0x00, 0x8000, 0x8000); /* HP depop procedure start */
7395
7396         /* Wait for depop procedure finish  */
7397         val = alc_read_coefex_idx(codec, 0x58, 0x01);
7398         for (i = 0; i < 20 && val & 0x0080; i++) {
7399                 msleep(50);
7400                 val = alc_read_coefex_idx(codec, 0x58, 0x01);
7401         }
7402         /* Set HP depop to auto mode */
7403         alc_update_coef_idx(codec, 0x6f, 0x000f, 0x000b);
7404         msleep(50);
7405 }
7406
7407 /*
7408  */
7409 static int patch_alc269(struct hda_codec *codec)
7410 {
7411         struct alc_spec *spec;
7412         int err;
7413
7414         err = alc_alloc_spec(codec, 0x0b);
7415         if (err < 0)
7416                 return err;
7417
7418         spec = codec->spec;
7419         spec->gen.shared_mic_vref_pin = 0x18;
7420         codec->power_save_node = 1;
7421
7422 #ifdef CONFIG_PM
7423         codec->patch_ops.suspend = alc269_suspend;
7424         codec->patch_ops.resume = alc269_resume;
7425 #endif
7426         spec->shutup = alc_default_shutup;
7427         spec->init_hook = alc_default_init;
7428
7429         switch (codec->core.vendor_id) {
7430         case 0x10ec0269:
7431                 spec->codec_variant = ALC269_TYPE_ALC269VA;
7432                 switch (alc_get_coef0(codec) & 0x00f0) {
7433                 case 0x0010:
7434                         if (codec->bus->pci &&
7435                             codec->bus->pci->subsystem_vendor == 0x1025 &&
7436                             spec->cdefine.platform_type == 1)
7437                                 err = alc_codec_rename(codec, "ALC271X");
7438                         spec->codec_variant = ALC269_TYPE_ALC269VB;
7439                         break;
7440                 case 0x0020:
7441                         if (codec->bus->pci &&
7442                             codec->bus->pci->subsystem_vendor == 0x17aa &&
7443                             codec->bus->pci->subsystem_device == 0x21f3)
7444                                 err = alc_codec_rename(codec, "ALC3202");
7445                         spec->codec_variant = ALC269_TYPE_ALC269VC;
7446                         break;
7447                 case 0x0030:
7448                         spec->codec_variant = ALC269_TYPE_ALC269VD;
7449                         break;
7450                 default:
7451                         alc_fix_pll_init(codec, 0x20, 0x04, 15);
7452                 }
7453                 if (err < 0)
7454                         goto error;
7455                 spec->shutup = alc269_shutup;
7456                 spec->init_hook = alc269_fill_coef;
7457                 alc269_fill_coef(codec);
7458                 break;
7459
7460         case 0x10ec0280:
7461         case 0x10ec0290:
7462                 spec->codec_variant = ALC269_TYPE_ALC280;
7463                 break;
7464         case 0x10ec0282:
7465                 spec->codec_variant = ALC269_TYPE_ALC282;
7466                 spec->shutup = alc282_shutup;
7467                 spec->init_hook = alc282_init;
7468                 break;
7469         case 0x10ec0233:
7470         case 0x10ec0283:
7471                 spec->codec_variant = ALC269_TYPE_ALC283;
7472                 spec->shutup = alc283_shutup;
7473                 spec->init_hook = alc283_init;
7474                 break;
7475         case 0x10ec0284:
7476         case 0x10ec0292:
7477                 spec->codec_variant = ALC269_TYPE_ALC284;
7478                 break;
7479         case 0x10ec0293:
7480                 spec->codec_variant = ALC269_TYPE_ALC293;
7481                 break;
7482         case 0x10ec0286:
7483         case 0x10ec0288:
7484                 spec->codec_variant = ALC269_TYPE_ALC286;
7485                 spec->shutup = alc286_shutup;
7486                 break;
7487         case 0x10ec0298:
7488                 spec->codec_variant = ALC269_TYPE_ALC298;
7489                 break;
7490         case 0x10ec0235:
7491         case 0x10ec0255:
7492                 spec->codec_variant = ALC269_TYPE_ALC255;
7493                 spec->shutup = alc256_shutup;
7494                 spec->init_hook = alc256_init;
7495                 break;
7496         case 0x10ec0236:
7497         case 0x10ec0256:
7498                 spec->codec_variant = ALC269_TYPE_ALC256;
7499                 spec->shutup = alc256_shutup;
7500                 spec->init_hook = alc256_init;
7501                 spec->gen.mixer_nid = 0; /* ALC256 does not have any loopback mixer path */
7502                 alc_update_coef_idx(codec, 0x36, 1 << 13, 1 << 5); /* Switch pcbeep path to Line in path*/
7503                 break;
7504         case 0x10ec0257:
7505                 spec->codec_variant = ALC269_TYPE_ALC257;
7506                 spec->shutup = alc256_shutup;
7507                 spec->init_hook = alc256_init;
7508                 spec->gen.mixer_nid = 0;
7509                 break;
7510         case 0x10ec0215:
7511         case 0x10ec0285:
7512         case 0x10ec0289:
7513                 spec->codec_variant = ALC269_TYPE_ALC215;
7514                 spec->shutup = alc225_shutup;
7515                 spec->init_hook = alc225_init;
7516                 spec->gen.mixer_nid = 0;
7517                 break;
7518         case 0x10ec0225:
7519         case 0x10ec0295:
7520         case 0x10ec0299:
7521                 spec->codec_variant = ALC269_TYPE_ALC225;
7522                 spec->shutup = alc225_shutup;
7523                 spec->init_hook = alc225_init;
7524                 spec->gen.mixer_nid = 0; /* no loopback on ALC225, ALC295 and ALC299 */
7525                 break;
7526         case 0x10ec0234:
7527         case 0x10ec0274:
7528         case 0x10ec0294:
7529                 spec->codec_variant = ALC269_TYPE_ALC294;
7530                 spec->gen.mixer_nid = 0; /* ALC2x4 does not have any loopback mixer path */
7531                 alc_update_coef_idx(codec, 0x6b, 0x0018, (1<<4) | (1<<3)); /* UAJ MIC Vref control by verb */
7532                 alc294_hp_init(codec);
7533                 break;
7534         case 0x10ec0300:
7535                 spec->codec_variant = ALC269_TYPE_ALC300;
7536                 spec->gen.mixer_nid = 0; /* no loopback on ALC300 */
7537                 break;
7538         case 0x10ec0700:
7539         case 0x10ec0701:
7540         case 0x10ec0703:
7541                 spec->codec_variant = ALC269_TYPE_ALC700;
7542                 spec->gen.mixer_nid = 0; /* ALC700 does not have any loopback mixer path */
7543                 alc_update_coef_idx(codec, 0x4a, 1 << 15, 0); /* Combo jack auto trigger control */
7544                 alc294_hp_init(codec);
7545                 break;
7546
7547         }
7548
7549         if (snd_hda_codec_read(codec, 0x51, 0, AC_VERB_PARAMETERS, 0) == 0x10ec5505) {
7550                 spec->has_alc5505_dsp = 1;
7551                 spec->init_hook = alc5505_dsp_init;
7552         }
7553
7554         snd_hda_pick_fixup(codec, alc269_fixup_models,
7555                        alc269_fixup_tbl, alc269_fixups);
7556         snd_hda_pick_pin_fixup(codec, alc269_pin_fixup_tbl, alc269_fixups);
7557         snd_hda_pick_fixup(codec, NULL, alc269_fixup_vendor_tbl,
7558                            alc269_fixups);
7559         snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE);
7560
7561         alc_auto_parse_customize_define(codec);
7562
7563         if (has_cdefine_beep(codec))
7564                 spec->gen.beep_nid = 0x01;
7565
7566         /* automatic parse from the BIOS config */
7567         err = alc269_parse_auto_config(codec);
7568         if (err < 0)
7569                 goto error;
7570
7571         if (!spec->gen.no_analog && spec->gen.beep_nid && spec->gen.mixer_nid) {
7572                 err = set_beep_amp(spec, spec->gen.mixer_nid, 0x04, HDA_INPUT);
7573                 if (err < 0)
7574                         goto error;
7575         }
7576
7577         snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE);
7578
7579         return 0;
7580
7581  error:
7582         alc_free(codec);
7583         return err;
7584 }
7585
7586 /*
7587  * ALC861
7588  */
7589
7590 static int alc861_parse_auto_config(struct hda_codec *codec)
7591 {
7592         static const hda_nid_t alc861_ignore[] = { 0x1d, 0 };
7593         static const hda_nid_t alc861_ssids[] = { 0x0e, 0x0f, 0x0b, 0 };
7594         return alc_parse_auto_config(codec, alc861_ignore, alc861_ssids);
7595 }
7596
7597 /* Pin config fixes */
7598 enum {
7599         ALC861_FIXUP_FSC_AMILO_PI1505,
7600         ALC861_FIXUP_AMP_VREF_0F,
7601         ALC861_FIXUP_NO_JACK_DETECT,
7602         ALC861_FIXUP_ASUS_A6RP,
7603         ALC660_FIXUP_ASUS_W7J,
7604 };
7605
7606 /* On some laptops, VREF of pin 0x0f is abused for controlling the main amp */
7607 static void alc861_fixup_asus_amp_vref_0f(struct hda_codec *codec,
7608                         const struct hda_fixup *fix, int action)
7609 {
7610         struct alc_spec *spec = codec->spec;
7611         unsigned int val;
7612
7613         if (action != HDA_FIXUP_ACT_INIT)
7614                 return;
7615         val = snd_hda_codec_get_pin_target(codec, 0x0f);
7616         if (!(val & (AC_PINCTL_IN_EN | AC_PINCTL_OUT_EN)))
7617                 val |= AC_PINCTL_IN_EN;
7618         val |= AC_PINCTL_VREF_50;
7619         snd_hda_set_pin_ctl(codec, 0x0f, val);
7620         spec->gen.keep_vref_in_automute = 1;
7621 }
7622
7623 /* suppress the jack-detection */
7624 static void alc_fixup_no_jack_detect(struct hda_codec *codec,
7625                                      const struct hda_fixup *fix, int action)
7626 {
7627         if (action == HDA_FIXUP_ACT_PRE_PROBE)
7628                 codec->no_jack_detect = 1;
7629 }
7630
7631 static const struct hda_fixup alc861_fixups[] = {
7632         [ALC861_FIXUP_FSC_AMILO_PI1505] = {
7633                 .type = HDA_FIXUP_PINS,
7634                 .v.pins = (const struct hda_pintbl[]) {
7635                         { 0x0b, 0x0221101f }, /* HP */
7636                         { 0x0f, 0x90170310 }, /* speaker */
7637                         { }
7638                 }
7639         },
7640         [ALC861_FIXUP_AMP_VREF_0F] = {
7641                 .type = HDA_FIXUP_FUNC,
7642                 .v.func = alc861_fixup_asus_amp_vref_0f,
7643         },
7644         [ALC861_FIXUP_NO_JACK_DETECT] = {
7645                 .type = HDA_FIXUP_FUNC,
7646                 .v.func = alc_fixup_no_jack_detect,
7647         },
7648         [ALC861_FIXUP_ASUS_A6RP] = {
7649                 .type = HDA_FIXUP_FUNC,
7650                 .v.func = alc861_fixup_asus_amp_vref_0f,
7651                 .chained = true,
7652                 .chain_id = ALC861_FIXUP_NO_JACK_DETECT,
7653         },
7654         [ALC660_FIXUP_ASUS_W7J] = {
7655                 .type = HDA_FIXUP_VERBS,
7656                 .v.verbs = (const struct hda_verb[]) {
7657                         /* ASUS W7J needs a magic pin setup on unused NID 0x10
7658                          * for enabling outputs
7659                          */
7660                         {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
7661                         { }
7662                 },
7663         }
7664 };
7665
7666 static const struct snd_pci_quirk alc861_fixup_tbl[] = {
7667         SND_PCI_QUIRK(0x1043, 0x1253, "ASUS W7J", ALC660_FIXUP_ASUS_W7J),
7668         SND_PCI_QUIRK(0x1043, 0x1263, "ASUS Z35HL", ALC660_FIXUP_ASUS_W7J),
7669         SND_PCI_QUIRK(0x1043, 0x1393, "ASUS A6Rp", ALC861_FIXUP_ASUS_A6RP),
7670         SND_PCI_QUIRK_VENDOR(0x1043, "ASUS laptop", ALC861_FIXUP_AMP_VREF_0F),
7671         SND_PCI_QUIRK(0x1462, 0x7254, "HP DX2200", ALC861_FIXUP_NO_JACK_DETECT),
7672         SND_PCI_QUIRK(0x1584, 0x2b01, "Haier W18", ALC861_FIXUP_AMP_VREF_0F),
7673         SND_PCI_QUIRK(0x1584, 0x0000, "Uniwill ECS M31EI", ALC861_FIXUP_AMP_VREF_0F),
7674         SND_PCI_QUIRK(0x1734, 0x10c7, "FSC Amilo Pi1505", ALC861_FIXUP_FSC_AMILO_PI1505),
7675         {}
7676 };
7677
7678 /*
7679  */
7680 static int patch_alc861(struct hda_codec *codec)
7681 {
7682         struct alc_spec *spec;
7683         int err;
7684
7685         err = alc_alloc_spec(codec, 0x15);
7686         if (err < 0)
7687                 return err;
7688
7689         spec = codec->spec;
7690         spec->gen.beep_nid = 0x23;
7691
7692 #ifdef CONFIG_PM
7693         spec->power_hook = alc_power_eapd;
7694 #endif
7695
7696         snd_hda_pick_fixup(codec, NULL, alc861_fixup_tbl, alc861_fixups);
7697         snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE);
7698
7699         /* automatic parse from the BIOS config */
7700         err = alc861_parse_auto_config(codec);
7701         if (err < 0)
7702                 goto error;
7703
7704         if (!spec->gen.no_analog) {
7705                 err = set_beep_amp(spec, 0x23, 0, HDA_OUTPUT);
7706                 if (err < 0)
7707                         goto error;
7708         }
7709
7710         snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE);
7711
7712         return 0;
7713
7714  error:
7715         alc_free(codec);
7716         return err;
7717 }
7718
7719 /*
7720  * ALC861-VD support
7721  *
7722  * Based on ALC882
7723  *
7724  * In addition, an independent DAC
7725  */
7726 static int alc861vd_parse_auto_config(struct hda_codec *codec)
7727 {
7728         static const hda_nid_t alc861vd_ignore[] = { 0x1d, 0 };
7729         static const hda_nid_t alc861vd_ssids[] = { 0x15, 0x1b, 0x14, 0 };
7730         return alc_parse_auto_config(codec, alc861vd_ignore, alc861vd_ssids);
7731 }
7732
7733 enum {
7734         ALC660VD_FIX_ASUS_GPIO1,
7735         ALC861VD_FIX_DALLAS,
7736 };
7737
7738 /* exclude VREF80 */
7739 static void alc861vd_fixup_dallas(struct hda_codec *codec,
7740                                   const struct hda_fixup *fix, int action)
7741 {
7742         if (action == HDA_FIXUP_ACT_PRE_PROBE) {
7743                 snd_hda_override_pin_caps(codec, 0x18, 0x00000734);
7744                 snd_hda_override_pin_caps(codec, 0x19, 0x0000073c);
7745         }
7746 }
7747
7748 /* reset GPIO1 */
7749 static void alc660vd_fixup_asus_gpio1(struct hda_codec *codec,
7750                                       const struct hda_fixup *fix, int action)
7751 {
7752         struct alc_spec *spec = codec->spec;
7753
7754         if (action == HDA_FIXUP_ACT_PRE_PROBE)
7755                 spec->gpio_mask |= 0x02;
7756         alc_fixup_gpio(codec, action, 0x01);
7757 }
7758
7759 static const struct hda_fixup alc861vd_fixups[] = {
7760         [ALC660VD_FIX_ASUS_GPIO1] = {
7761                 .type = HDA_FIXUP_FUNC,
7762                 .v.func = alc660vd_fixup_asus_gpio1,
7763         },
7764         [ALC861VD_FIX_DALLAS] = {
7765                 .type = HDA_FIXUP_FUNC,
7766                 .v.func = alc861vd_fixup_dallas,
7767         },
7768 };
7769
7770 static const struct snd_pci_quirk alc861vd_fixup_tbl[] = {
7771         SND_PCI_QUIRK(0x103c, 0x30bf, "HP TX1000", ALC861VD_FIX_DALLAS),
7772         SND_PCI_QUIRK(0x1043, 0x1339, "ASUS A7-K", ALC660VD_FIX_ASUS_GPIO1),
7773         SND_PCI_QUIRK(0x1179, 0xff31, "Toshiba L30-149", ALC861VD_FIX_DALLAS),
7774         {}
7775 };
7776
7777 /*
7778  */
7779 static int patch_alc861vd(struct hda_codec *codec)
7780 {
7781         struct alc_spec *spec;
7782         int err;
7783
7784         err = alc_alloc_spec(codec, 0x0b);
7785         if (err < 0)
7786                 return err;
7787
7788         spec = codec->spec;
7789         spec->gen.beep_nid = 0x23;
7790
7791         spec->shutup = alc_eapd_shutup;
7792
7793         snd_hda_pick_fixup(codec, NULL, alc861vd_fixup_tbl, alc861vd_fixups);
7794         snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE);
7795
7796         /* automatic parse from the BIOS config */
7797         err = alc861vd_parse_auto_config(codec);
7798         if (err < 0)
7799                 goto error;
7800
7801         if (!spec->gen.no_analog) {
7802                 err = set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
7803                 if (err < 0)
7804                         goto error;
7805         }
7806
7807         snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE);
7808
7809         return 0;
7810
7811  error:
7812         alc_free(codec);
7813         return err;
7814 }
7815
7816 /*
7817  * ALC662 support
7818  *
7819  * ALC662 is almost identical with ALC880 but has cleaner and more flexible
7820  * configuration.  Each pin widget can choose any input DACs and a mixer.
7821  * Each ADC is connected from a mixer of all inputs.  This makes possible
7822  * 6-channel independent captures.
7823  *
7824  * In addition, an independent DAC for the multi-playback (not used in this
7825  * driver yet).
7826  */
7827
7828 /*
7829  * BIOS auto configuration
7830  */
7831
7832 static int alc662_parse_auto_config(struct hda_codec *codec)
7833 {
7834         static const hda_nid_t alc662_ignore[] = { 0x1d, 0 };
7835         static const hda_nid_t alc663_ssids[] = { 0x15, 0x1b, 0x14, 0x21 };
7836         static const hda_nid_t alc662_ssids[] = { 0x15, 0x1b, 0x14, 0 };
7837         const hda_nid_t *ssids;
7838
7839         if (codec->core.vendor_id == 0x10ec0272 || codec->core.vendor_id == 0x10ec0663 ||
7840             codec->core.vendor_id == 0x10ec0665 || codec->core.vendor_id == 0x10ec0670 ||
7841             codec->core.vendor_id == 0x10ec0671)
7842                 ssids = alc663_ssids;
7843         else
7844                 ssids = alc662_ssids;
7845         return alc_parse_auto_config(codec, alc662_ignore, ssids);
7846 }
7847
7848 static void alc272_fixup_mario(struct hda_codec *codec,
7849                                const struct hda_fixup *fix, int action)
7850 {
7851         if (action != HDA_FIXUP_ACT_PRE_PROBE)
7852                 return;
7853         if (snd_hda_override_amp_caps(codec, 0x2, HDA_OUTPUT,
7854                                       (0x3b << AC_AMPCAP_OFFSET_SHIFT) |
7855                                       (0x3b << AC_AMPCAP_NUM_STEPS_SHIFT) |
7856                                       (0x03 << AC_AMPCAP_STEP_SIZE_SHIFT) |
7857                                       (0 << AC_AMPCAP_MUTE_SHIFT)))
7858                 codec_warn(codec, "failed to override amp caps for NID 0x2\n");
7859 }
7860
7861 static const struct snd_pcm_chmap_elem asus_pcm_2_1_chmaps[] = {
7862         { .channels = 2,
7863           .map = { SNDRV_CHMAP_FL, SNDRV_CHMAP_FR } },
7864         { .channels = 4,
7865           .map = { SNDRV_CHMAP_FL, SNDRV_CHMAP_FR,
7866                    SNDRV_CHMAP_NA, SNDRV_CHMAP_LFE } }, /* LFE only on right */
7867         { }
7868 };
7869
7870 /* override the 2.1 chmap */
7871 static void alc_fixup_bass_chmap(struct hda_codec *codec,
7872                                     const struct hda_fixup *fix, int action)
7873 {
7874         if (action == HDA_FIXUP_ACT_BUILD) {
7875                 struct alc_spec *spec = codec->spec;
7876                 spec->gen.pcm_rec[0]->stream[0].chmap = asus_pcm_2_1_chmaps;
7877         }
7878 }
7879
7880 /* avoid D3 for keeping GPIO up */
7881 static unsigned int gpio_led_power_filter(struct hda_codec *codec,
7882                                           hda_nid_t nid,
7883                                           unsigned int power_state)
7884 {
7885         struct alc_spec *spec = codec->spec;
7886         if (nid == codec->core.afg && power_state == AC_PWRST_D3 && spec->gpio_data)
7887                 return AC_PWRST_D0;
7888         return power_state;
7889 }
7890
7891 static void alc662_fixup_led_gpio1(struct hda_codec *codec,
7892                                    const struct hda_fixup *fix, int action)
7893 {
7894         struct alc_spec *spec = codec->spec;
7895
7896         alc_fixup_hp_gpio_led(codec, action, 0x01, 0);
7897         if (action == HDA_FIXUP_ACT_PRE_PROBE) {
7898                 spec->mute_led_polarity = 1;
7899                 codec->power_filter = gpio_led_power_filter;
7900         }
7901 }
7902
7903 static void alc662_usi_automute_hook(struct hda_codec *codec,
7904                                          struct hda_jack_callback *jack)
7905 {
7906         struct alc_spec *spec = codec->spec;
7907         int vref;
7908         msleep(200);
7909         snd_hda_gen_hp_automute(codec, jack);
7910
7911         vref = spec->gen.hp_jack_present ? PIN_VREF80 : 0;
7912         msleep(100);
7913         snd_hda_codec_write(codec, 0x19, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
7914                             vref);
7915 }
7916
7917 static void alc662_fixup_usi_headset_mic(struct hda_codec *codec,
7918                                      const struct hda_fixup *fix, int action)
7919 {
7920         struct alc_spec *spec = codec->spec;
7921         if (action == HDA_FIXUP_ACT_PRE_PROBE) {
7922                 spec->parse_flags |= HDA_PINCFG_HEADSET_MIC;
7923                 spec->gen.hp_automute_hook = alc662_usi_automute_hook;
7924         }
7925 }
7926
7927 static struct coef_fw alc668_coefs[] = {
7928         WRITE_COEF(0x01, 0xbebe), WRITE_COEF(0x02, 0xaaaa), WRITE_COEF(0x03,    0x0),
7929         WRITE_COEF(0x04, 0x0180), WRITE_COEF(0x06,    0x0), WRITE_COEF(0x07, 0x0f80),
7930         WRITE_COEF(0x08, 0x0031), WRITE_COEF(0x0a, 0x0060), WRITE_COEF(0x0b,    0x0),
7931         WRITE_COEF(0x0c, 0x7cf7), WRITE_COEF(0x0d, 0x1080), WRITE_COEF(0x0e, 0x7f7f),
7932         WRITE_COEF(0x0f, 0xcccc), WRITE_COEF(0x10, 0xddcc), WRITE_COEF(0x11, 0x0001),
7933         WRITE_COEF(0x13,    0x0), WRITE_COEF(0x14, 0x2aa0), WRITE_COEF(0x17, 0xa940),
7934         WRITE_COEF(0x19,    0x0), WRITE_COEF(0x1a,    0x0), WRITE_COEF(0x1b,    0x0),
7935         WRITE_COEF(0x1c,    0x0), WRITE_COEF(0x1d,    0x0), WRITE_COEF(0x1e, 0x7418),
7936         WRITE_COEF(0x1f, 0x0804), WRITE_COEF(0x20, 0x4200), WRITE_COEF(0x21, 0x0468),
7937         WRITE_COEF(0x22, 0x8ccc), WRITE_COEF(0x23, 0x0250), WRITE_COEF(0x24, 0x7418),
7938         WRITE_COEF(0x27,    0x0), WRITE_COEF(0x28, 0x8ccc), WRITE_COEF(0x2a, 0xff00),
7939         WRITE_COEF(0x2b, 0x8000), WRITE_COEF(0xa7, 0xff00), WRITE_COEF(0xa8, 0x8000),
7940         WRITE_COEF(0xaa, 0x2e17), WRITE_COEF(0xab, 0xa0c0), WRITE_COEF(0xac,    0x0),
7941         WRITE_COEF(0xad,    0x0), WRITE_COEF(0xae, 0x2ac6), WRITE_COEF(0xaf, 0xa480),
7942         WRITE_COEF(0xb0,    0x0), WRITE_COEF(0xb1,    0x0), WRITE_COEF(0xb2,    0x0),
7943         WRITE_COEF(0xb3,    0x0), WRITE_COEF(0xb4,    0x0), WRITE_COEF(0xb5, 0x1040),
7944         WRITE_COEF(0xb6, 0xd697), WRITE_COEF(0xb7, 0x902b), WRITE_COEF(0xb8, 0xd697),
7945         WRITE_COEF(0xb9, 0x902b), WRITE_COEF(0xba, 0xb8ba), WRITE_COEF(0xbb, 0xaaab),
7946         WRITE_COEF(0xbc, 0xaaaf), WRITE_COEF(0xbd, 0x6aaa), WRITE_COEF(0xbe, 0x1c02),
7947         WRITE_COEF(0xc0, 0x00ff), WRITE_COEF(0xc1, 0x0fa6),
7948         {}
7949 };
7950
7951 static void alc668_restore_default_value(struct hda_codec *codec)
7952 {
7953         alc_process_coef_fw(codec, alc668_coefs);
7954 }
7955
7956 enum {
7957         ALC662_FIXUP_ASPIRE,
7958         ALC662_FIXUP_LED_GPIO1,
7959         ALC662_FIXUP_IDEAPAD,
7960         ALC272_FIXUP_MARIO,
7961         ALC662_FIXUP_CZC_P10T,
7962         ALC662_FIXUP_SKU_IGNORE,
7963         ALC662_FIXUP_HP_RP5800,
7964         ALC662_FIXUP_ASUS_MODE1,
7965         ALC662_FIXUP_ASUS_MODE2,
7966         ALC662_FIXUP_ASUS_MODE3,
7967         ALC662_FIXUP_ASUS_MODE4,
7968         ALC662_FIXUP_ASUS_MODE5,
7969         ALC662_FIXUP_ASUS_MODE6,
7970         ALC662_FIXUP_ASUS_MODE7,
7971         ALC662_FIXUP_ASUS_MODE8,
7972         ALC662_FIXUP_NO_JACK_DETECT,
7973         ALC662_FIXUP_ZOTAC_Z68,
7974         ALC662_FIXUP_INV_DMIC,
7975         ALC662_FIXUP_DELL_MIC_NO_PRESENCE,
7976         ALC668_FIXUP_DELL_MIC_NO_PRESENCE,
7977         ALC662_FIXUP_HEADSET_MODE,
7978         ALC668_FIXUP_HEADSET_MODE,
7979         ALC662_FIXUP_BASS_MODE4_CHMAP,
7980         ALC662_FIXUP_BASS_16,
7981         ALC662_FIXUP_BASS_1A,
7982         ALC662_FIXUP_BASS_CHMAP,
7983         ALC668_FIXUP_AUTO_MUTE,
7984         ALC668_FIXUP_DELL_DISABLE_AAMIX,
7985         ALC668_FIXUP_DELL_XPS13,
7986         ALC662_FIXUP_ASUS_Nx50,
7987         ALC668_FIXUP_ASUS_Nx51_HEADSET_MODE,
7988         ALC668_FIXUP_ASUS_Nx51,
7989         ALC668_FIXUP_MIC_COEF,
7990         ALC668_FIXUP_ASUS_G751,
7991         ALC891_FIXUP_HEADSET_MODE,
7992         ALC891_FIXUP_DELL_MIC_NO_PRESENCE,
7993         ALC662_FIXUP_ACER_VERITON,
7994         ALC892_FIXUP_ASROCK_MOBO,
7995         ALC662_FIXUP_USI_FUNC,
7996         ALC662_FIXUP_USI_HEADSET_MODE,
7997         ALC662_FIXUP_LENOVO_MULTI_CODECS,
7998 };
7999
8000 static const struct hda_fixup alc662_fixups[] = {
8001         [ALC662_FIXUP_ASPIRE] = {
8002                 .type = HDA_FIXUP_PINS,
8003                 .v.pins = (const struct hda_pintbl[]) {
8004                         { 0x15, 0x99130112 }, /* subwoofer */
8005                         { }
8006                 }
8007         },
8008         [ALC662_FIXUP_LED_GPIO1] = {
8009                 .type = HDA_FIXUP_FUNC,
8010                 .v.func = alc662_fixup_led_gpio1,
8011         },
8012         [ALC662_FIXUP_IDEAPAD] = {
8013                 .type = HDA_FIXUP_PINS,
8014                 .v.pins = (const struct hda_pintbl[]) {
8015                         { 0x17, 0x99130112 }, /* subwoofer */
8016                         { }
8017                 },
8018                 .chained = true,
8019                 .chain_id = ALC662_FIXUP_LED_GPIO1,
8020         },
8021         [ALC272_FIXUP_MARIO] = {
8022                 .type = HDA_FIXUP_FUNC,
8023                 .v.func = alc272_fixup_mario,
8024         },
8025         [ALC662_FIXUP_CZC_P10T] = {
8026                 .type = HDA_FIXUP_VERBS,
8027                 .v.verbs = (const struct hda_verb[]) {
8028                         {0x14, AC_VERB_SET_EAPD_BTLENABLE, 0},
8029                         {}
8030                 }
8031         },
8032         [ALC662_FIXUP_SKU_IGNORE] = {
8033                 .type = HDA_FIXUP_FUNC,
8034                 .v.func = alc_fixup_sku_ignore,
8035         },
8036         [ALC662_FIXUP_HP_RP5800] = {
8037                 .type = HDA_FIXUP_PINS,
8038                 .v.pins = (const struct hda_pintbl[]) {
8039                         { 0x14, 0x0221201f }, /* HP out */
8040                         { }
8041                 },
8042                 .chained = true,
8043                 .chain_id = ALC662_FIXUP_SKU_IGNORE
8044         },
8045         [ALC662_FIXUP_ASUS_MODE1] = {
8046                 .type = HDA_FIXUP_PINS,
8047                 .v.pins = (const struct hda_pintbl[]) {
8048                         { 0x14, 0x99130110 }, /* speaker */
8049                         { 0x18, 0x01a19c20 }, /* mic */
8050                         { 0x19, 0x99a3092f }, /* int-mic */
8051                         { 0x21, 0x0121401f }, /* HP out */
8052                         { }
8053                 },
8054                 .chained = true,
8055                 .chain_id = ALC662_FIXUP_SKU_IGNORE
8056         },
8057         [ALC662_FIXUP_ASUS_MODE2] = {
8058                 .type = HDA_FIXUP_PINS,
8059                 .v.pins = (const struct hda_pintbl[]) {
8060                         { 0x14, 0x99130110 }, /* speaker */
8061                         { 0x18, 0x01a19820 }, /* mic */
8062                         { 0x19, 0x99a3092f }, /* int-mic */
8063                         { 0x1b, 0x0121401f }, /* HP out */
8064                         { }
8065                 },
8066                 .chained = true,
8067                 .chain_id = ALC662_FIXUP_SKU_IGNORE
8068         },
8069         [ALC662_FIXUP_ASUS_MODE3] = {
8070                 .type = HDA_FIXUP_PINS,
8071                 .v.pins = (const struct hda_pintbl[]) {
8072                         { 0x14, 0x99130110 }, /* speaker */
8073                         { 0x15, 0x0121441f }, /* HP */
8074                         { 0x18, 0x01a19840 }, /* mic */
8075                         { 0x19, 0x99a3094f }, /* int-mic */
8076                         { 0x21, 0x01211420 }, /* HP2 */
8077                         { }
8078                 },
8079                 .chained = true,
8080                 .chain_id = ALC662_FIXUP_SKU_IGNORE
8081         },
8082         [ALC662_FIXUP_ASUS_MODE4] = {
8083                 .type = HDA_FIXUP_PINS,
8084                 .v.pins = (const struct hda_pintbl[]) {
8085                         { 0x14, 0x99130110 }, /* speaker */
8086                         { 0x16, 0x99130111 }, /* speaker */
8087                         { 0x18, 0x01a19840 }, /* mic */
8088                         { 0x19, 0x99a3094f }, /* int-mic */
8089                         { 0x21, 0x0121441f }, /* HP */
8090                         { }
8091                 },
8092                 .chained = true,
8093                 .chain_id = ALC662_FIXUP_SKU_IGNORE
8094         },
8095         [ALC662_FIXUP_ASUS_MODE5] = {
8096                 .type = HDA_FIXUP_PINS,
8097                 .v.pins = (const struct hda_pintbl[]) {
8098                         { 0x14, 0x99130110 }, /* speaker */
8099                         { 0x15, 0x0121441f }, /* HP */
8100                         { 0x16, 0x99130111 }, /* speaker */
8101                         { 0x18, 0x01a19840 }, /* mic */
8102                         { 0x19, 0x99a3094f }, /* int-mic */
8103                         { }
8104                 },
8105                 .chained = true,
8106                 .chain_id = ALC662_FIXUP_SKU_IGNORE
8107         },
8108         [ALC662_FIXUP_ASUS_MODE6] = {
8109                 .type = HDA_FIXUP_PINS,
8110                 .v.pins = (const struct hda_pintbl[]) {
8111                         { 0x14, 0x99130110 }, /* speaker */
8112                         { 0x15, 0x01211420 }, /* HP2 */
8113                         { 0x18, 0x01a19840 }, /* mic */
8114                         { 0x19, 0x99a3094f }, /* int-mic */
8115                         { 0x1b, 0x0121441f }, /* HP */
8116                         { }
8117                 },
8118                 .chained = true,
8119                 .chain_id = ALC662_FIXUP_SKU_IGNORE
8120         },
8121         [ALC662_FIXUP_ASUS_MODE7] = {
8122                 .type = HDA_FIXUP_PINS,
8123                 .v.pins = (const struct hda_pintbl[]) {
8124                         { 0x14, 0x99130110 }, /* speaker */
8125                         { 0x17, 0x99130111 }, /* speaker */
8126                         { 0x18, 0x01a19840 }, /* mic */
8127                         { 0x19, 0x99a3094f }, /* int-mic */
8128                         { 0x1b, 0x01214020 }, /* HP */
8129                         { 0x21, 0x0121401f }, /* HP */
8130                         { }
8131                 },
8132                 .chained = true,
8133                 .chain_id = ALC662_FIXUP_SKU_IGNORE
8134         },
8135         [ALC662_FIXUP_ASUS_MODE8] = {
8136                 .type = HDA_FIXUP_PINS,
8137                 .v.pins = (const struct hda_pintbl[]) {
8138                         { 0x14, 0x99130110 }, /* speaker */
8139                         { 0x12, 0x99a30970 }, /* int-mic */
8140                         { 0x15, 0x01214020 }, /* HP */
8141                         { 0x17, 0x99130111 }, /* speaker */
8142                         { 0x18, 0x01a19840 }, /* mic */
8143                         { 0x21, 0x0121401f }, /* HP */
8144                         { }
8145                 },
8146                 .chained = true,
8147                 .chain_id = ALC662_FIXUP_SKU_IGNORE
8148         },
8149         [ALC662_FIXUP_NO_JACK_DETECT] = {
8150                 .type = HDA_FIXUP_FUNC,
8151                 .v.func = alc_fixup_no_jack_detect,
8152         },
8153         [ALC662_FIXUP_ZOTAC_Z68] = {
8154                 .type = HDA_FIXUP_PINS,
8155                 .v.pins = (const struct hda_pintbl[]) {
8156                         { 0x1b, 0x02214020 }, /* Front HP */
8157                         { }
8158                 }
8159         },
8160         [ALC662_FIXUP_INV_DMIC] = {
8161                 .type = HDA_FIXUP_FUNC,
8162                 .v.func = alc_fixup_inv_dmic,
8163         },
8164         [ALC668_FIXUP_DELL_XPS13] = {
8165                 .type = HDA_FIXUP_FUNC,
8166                 .v.func = alc_fixup_dell_xps13,
8167                 .chained = true,
8168                 .chain_id = ALC668_FIXUP_DELL_DISABLE_AAMIX
8169         },
8170         [ALC668_FIXUP_DELL_DISABLE_AAMIX] = {
8171                 .type = HDA_FIXUP_FUNC,
8172                 .v.func = alc_fixup_disable_aamix,
8173                 .chained = true,
8174                 .chain_id = ALC668_FIXUP_DELL_MIC_NO_PRESENCE
8175         },
8176         [ALC668_FIXUP_AUTO_MUTE] = {
8177                 .type = HDA_FIXUP_FUNC,
8178                 .v.func = alc_fixup_auto_mute_via_amp,
8179                 .chained = true,
8180                 .chain_id = ALC668_FIXUP_DELL_MIC_NO_PRESENCE
8181         },
8182         [ALC662_FIXUP_DELL_MIC_NO_PRESENCE] = {
8183                 .type = HDA_FIXUP_PINS,
8184                 .v.pins = (const struct hda_pintbl[]) {
8185                         { 0x19, 0x03a1113c }, /* use as headset mic, without its own jack detect */
8186                         /* headphone mic by setting pin control of 0x1b (headphone out) to in + vref_50 */
8187                         { }
8188                 },
8189                 .chained = true,
8190                 .chain_id = ALC662_FIXUP_HEADSET_MODE
8191         },
8192         [ALC662_FIXUP_HEADSET_MODE] = {
8193                 .type = HDA_FIXUP_FUNC,
8194                 .v.func = alc_fixup_headset_mode_alc662,
8195         },
8196         [ALC668_FIXUP_DELL_MIC_NO_PRESENCE] = {
8197                 .type = HDA_FIXUP_PINS,
8198                 .v.pins = (const struct hda_pintbl[]) {
8199                         { 0x19, 0x03a1913d }, /* use as headphone mic, without its own jack detect */
8200                         { 0x1b, 0x03a1113c }, /* use as headset mic, without its own jack detect */
8201                         { }
8202                 },
8203                 .chained = true,
8204                 .chain_id = ALC668_FIXUP_HEADSET_MODE
8205         },
8206         [ALC668_FIXUP_HEADSET_MODE] = {
8207                 .type = HDA_FIXUP_FUNC,
8208                 .v.func = alc_fixup_headset_mode_alc668,
8209         },
8210         [ALC662_FIXUP_BASS_MODE4_CHMAP] = {
8211                 .type = HDA_FIXUP_FUNC,
8212                 .v.func = alc_fixup_bass_chmap,
8213                 .chained = true,
8214                 .chain_id = ALC662_FIXUP_ASUS_MODE4
8215         },
8216         [ALC662_FIXUP_BASS_16] = {
8217                 .type = HDA_FIXUP_PINS,
8218                 .v.pins = (const struct hda_pintbl[]) {
8219                         {0x16, 0x80106111}, /* bass speaker */
8220                         {}
8221                 },
8222                 .chained = true,
8223                 .chain_id = ALC662_FIXUP_BASS_CHMAP,
8224         },
8225         [ALC662_FIXUP_BASS_1A] = {
8226                 .type = HDA_FIXUP_PINS,
8227                 .v.pins = (const struct hda_pintbl[]) {
8228                         {0x1a, 0x80106111}, /* bass speaker */
8229                         {}
8230                 },
8231                 .chained = true,
8232                 .chain_id = ALC662_FIXUP_BASS_CHMAP,
8233         },
8234         [ALC662_FIXUP_BASS_CHMAP] = {
8235                 .type = HDA_FIXUP_FUNC,
8236                 .v.func = alc_fixup_bass_chmap,
8237         },
8238         [ALC662_FIXUP_ASUS_Nx50] = {
8239                 .type = HDA_FIXUP_FUNC,
8240                 .v.func = alc_fixup_auto_mute_via_amp,
8241                 .chained = true,
8242                 .chain_id = ALC662_FIXUP_BASS_1A
8243         },
8244         [ALC668_FIXUP_ASUS_Nx51_HEADSET_MODE] = {
8245                 .type = HDA_FIXUP_FUNC,
8246                 .v.func = alc_fixup_headset_mode_alc668,
8247                 .chain_id = ALC662_FIXUP_BASS_CHMAP
8248         },
8249         [ALC668_FIXUP_ASUS_Nx51] = {
8250                 .type = HDA_FIXUP_PINS,
8251                 .v.pins = (const struct hda_pintbl[]) {
8252                         { 0x19, 0x03a1913d }, /* use as headphone mic, without its own jack detect */
8253                         { 0x1a, 0x90170151 }, /* bass speaker */
8254                         { 0x1b, 0x03a1113c }, /* use as headset mic, without its own jack detect */
8255                         {}
8256                 },
8257                 .chained = true,
8258                 .chain_id = ALC668_FIXUP_ASUS_Nx51_HEADSET_MODE,
8259         },
8260         [ALC668_FIXUP_MIC_COEF] = {
8261                 .type = HDA_FIXUP_VERBS,
8262                 .v.verbs = (const struct hda_verb[]) {
8263                         { 0x20, AC_VERB_SET_COEF_INDEX, 0xc3 },
8264                         { 0x20, AC_VERB_SET_PROC_COEF, 0x4000 },
8265                         {}
8266                 },
8267         },
8268         [ALC668_FIXUP_ASUS_G751] = {
8269                 .type = HDA_FIXUP_PINS,
8270                 .v.pins = (const struct hda_pintbl[]) {
8271                         { 0x16, 0x0421101f }, /* HP */
8272                         {}
8273                 },
8274                 .chained = true,
8275                 .chain_id = ALC668_FIXUP_MIC_COEF
8276         },
8277         [ALC891_FIXUP_HEADSET_MODE] = {
8278                 .type = HDA_FIXUP_FUNC,
8279                 .v.func = alc_fixup_headset_mode,
8280         },
8281         [ALC891_FIXUP_DELL_MIC_NO_PRESENCE] = {
8282                 .type = HDA_FIXUP_PINS,
8283                 .v.pins = (const struct hda_pintbl[]) {
8284                         { 0x19, 0x03a1913d }, /* use as headphone mic, without its own jack detect */
8285                         { 0x1b, 0x03a1113c }, /* use as headset mic, without its own jack detect */
8286                         { }
8287                 },
8288                 .chained = true,
8289                 .chain_id = ALC891_FIXUP_HEADSET_MODE
8290         },
8291         [ALC662_FIXUP_ACER_VERITON] = {
8292                 .type = HDA_FIXUP_PINS,
8293                 .v.pins = (const struct hda_pintbl[]) {
8294                         { 0x15, 0x50170120 }, /* no internal speaker */
8295                         { }
8296                 }
8297         },
8298         [ALC892_FIXUP_ASROCK_MOBO] = {
8299                 .type = HDA_FIXUP_PINS,
8300                 .v.pins = (const struct hda_pintbl[]) {
8301                         { 0x15, 0x40f000f0 }, /* disabled */
8302                         { 0x16, 0x40f000f0 }, /* disabled */
8303                         { }
8304                 }
8305         },
8306         [ALC662_FIXUP_USI_FUNC] = {
8307                 .type = HDA_FIXUP_FUNC,
8308                 .v.func = alc662_fixup_usi_headset_mic,
8309         },
8310         [ALC662_FIXUP_USI_HEADSET_MODE] = {
8311                 .type = HDA_FIXUP_PINS,
8312                 .v.pins = (const struct hda_pintbl[]) {
8313                         { 0x19, 0x02a1913c }, /* use as headset mic, without its own jack detect */
8314                         { 0x18, 0x01a1903d },
8315                         { }
8316                 },
8317                 .chained = true,
8318                 .chain_id = ALC662_FIXUP_USI_FUNC
8319         },
8320         [ALC662_FIXUP_LENOVO_MULTI_CODECS] = {
8321                 .type = HDA_FIXUP_FUNC,
8322                 .v.func = alc233_alc662_fixup_lenovo_dual_codecs,
8323         },
8324 };
8325
8326 static const struct snd_pci_quirk alc662_fixup_tbl[] = {
8327         SND_PCI_QUIRK(0x1019, 0x9087, "ECS", ALC662_FIXUP_ASUS_MODE2),
8328         SND_PCI_QUIRK(0x1025, 0x022f, "Acer Aspire One", ALC662_FIXUP_INV_DMIC),
8329         SND_PCI_QUIRK(0x1025, 0x0241, "Packard Bell DOTS", ALC662_FIXUP_INV_DMIC),
8330         SND_PCI_QUIRK(0x1025, 0x0308, "Acer Aspire 8942G", ALC662_FIXUP_ASPIRE),
8331         SND_PCI_QUIRK(0x1025, 0x031c, "Gateway NV79", ALC662_FIXUP_SKU_IGNORE),
8332         SND_PCI_QUIRK(0x1025, 0x0349, "eMachines eM250", ALC662_FIXUP_INV_DMIC),
8333         SND_PCI_QUIRK(0x1025, 0x034a, "Gateway LT27", ALC662_FIXUP_INV_DMIC),
8334         SND_PCI_QUIRK(0x1025, 0x038b, "Acer Aspire 8943G", ALC662_FIXUP_ASPIRE),
8335         SND_PCI_QUIRK(0x1028, 0x05d8, "Dell", ALC668_FIXUP_DELL_MIC_NO_PRESENCE),
8336         SND_PCI_QUIRK(0x1028, 0x05db, "Dell", ALC668_FIXUP_DELL_MIC_NO_PRESENCE),
8337         SND_PCI_QUIRK(0x1028, 0x05fe, "Dell XPS 15", ALC668_FIXUP_DELL_XPS13),
8338         SND_PCI_QUIRK(0x1028, 0x060a, "Dell XPS 13", ALC668_FIXUP_DELL_XPS13),
8339         SND_PCI_QUIRK(0x1028, 0x060d, "Dell M3800", ALC668_FIXUP_DELL_XPS13),
8340         SND_PCI_QUIRK(0x1028, 0x0625, "Dell", ALC668_FIXUP_DELL_MIC_NO_PRESENCE),
8341         SND_PCI_QUIRK(0x1028, 0x0626, "Dell", ALC668_FIXUP_DELL_MIC_NO_PRESENCE),
8342         SND_PCI_QUIRK(0x1028, 0x0696, "Dell", ALC668_FIXUP_DELL_MIC_NO_PRESENCE),
8343         SND_PCI_QUIRK(0x1028, 0x0698, "Dell", ALC668_FIXUP_DELL_MIC_NO_PRESENCE),
8344         SND_PCI_QUIRK(0x1028, 0x069f, "Dell", ALC668_FIXUP_DELL_MIC_NO_PRESENCE),
8345         SND_PCI_QUIRK(0x103c, 0x1632, "HP RP5800", ALC662_FIXUP_HP_RP5800),
8346         SND_PCI_QUIRK(0x1043, 0x1080, "Asus UX501VW", ALC668_FIXUP_HEADSET_MODE),
8347         SND_PCI_QUIRK(0x1043, 0x11cd, "Asus N550", ALC662_FIXUP_ASUS_Nx50),
8348         SND_PCI_QUIRK(0x1043, 0x13df, "Asus N550JX", ALC662_FIXUP_BASS_1A),
8349         SND_PCI_QUIRK(0x1043, 0x129d, "Asus N750", ALC662_FIXUP_ASUS_Nx50),
8350         SND_PCI_QUIRK(0x1043, 0x12ff, "ASUS G751", ALC668_FIXUP_ASUS_G751),
8351         SND_PCI_QUIRK(0x1043, 0x1477, "ASUS N56VZ", ALC662_FIXUP_BASS_MODE4_CHMAP),
8352         SND_PCI_QUIRK(0x1043, 0x15a7, "ASUS UX51VZH", ALC662_FIXUP_BASS_16),
8353         SND_PCI_QUIRK(0x1043, 0x177d, "ASUS N551", ALC668_FIXUP_ASUS_Nx51),
8354         SND_PCI_QUIRK(0x1043, 0x17bd, "ASUS N751", ALC668_FIXUP_ASUS_Nx51),
8355         SND_PCI_QUIRK(0x1043, 0x1963, "ASUS X71SL", ALC662_FIXUP_ASUS_MODE8),
8356         SND_PCI_QUIRK(0x1043, 0x1b73, "ASUS N55SF", ALC662_FIXUP_BASS_16),
8357         SND_PCI_QUIRK(0x1043, 0x1bf3, "ASUS N76VZ", ALC662_FIXUP_BASS_MODE4_CHMAP),
8358         SND_PCI_QUIRK(0x1043, 0x8469, "ASUS mobo", ALC662_FIXUP_NO_JACK_DETECT),
8359         SND_PCI_QUIRK(0x105b, 0x0cd6, "Foxconn", ALC662_FIXUP_ASUS_MODE2),
8360         SND_PCI_QUIRK(0x144d, 0xc051, "Samsung R720", ALC662_FIXUP_IDEAPAD),
8361         SND_PCI_QUIRK(0x14cd, 0x5003, "USI", ALC662_FIXUP_USI_HEADSET_MODE),
8362         SND_PCI_QUIRK(0x17aa, 0x1036, "Lenovo P520", ALC662_FIXUP_LENOVO_MULTI_CODECS),
8363         SND_PCI_QUIRK(0x17aa, 0x38af, "Lenovo Ideapad Y550P", ALC662_FIXUP_IDEAPAD),
8364         SND_PCI_QUIRK(0x17aa, 0x3a0d, "Lenovo Ideapad Y550", ALC662_FIXUP_IDEAPAD),
8365         SND_PCI_QUIRK(0x1849, 0x5892, "ASRock B150M", ALC892_FIXUP_ASROCK_MOBO),
8366         SND_PCI_QUIRK(0x19da, 0xa130, "Zotac Z68", ALC662_FIXUP_ZOTAC_Z68),
8367         SND_PCI_QUIRK(0x1b0a, 0x01b8, "ACER Veriton", ALC662_FIXUP_ACER_VERITON),
8368         SND_PCI_QUIRK(0x1b35, 0x2206, "CZC P10T", ALC662_FIXUP_CZC_P10T),
8369
8370 #if 0
8371         /* Below is a quirk table taken from the old code.
8372          * Basically the device should work as is without the fixup table.
8373          * If BIOS doesn't give a proper info, enable the corresponding
8374          * fixup entry.
8375          */
8376         SND_PCI_QUIRK(0x1043, 0x1000, "ASUS N50Vm", ALC662_FIXUP_ASUS_MODE1),
8377         SND_PCI_QUIRK(0x1043, 0x1092, "ASUS NB", ALC662_FIXUP_ASUS_MODE3),
8378         SND_PCI_QUIRK(0x1043, 0x1173, "ASUS K73Jn", ALC662_FIXUP_ASUS_MODE1),
8379         SND_PCI_QUIRK(0x1043, 0x11c3, "ASUS M70V", ALC662_FIXUP_ASUS_MODE3),
8380         SND_PCI_QUIRK(0x1043, 0x11d3, "ASUS NB", ALC662_FIXUP_ASUS_MODE1),
8381         SND_PCI_QUIRK(0x1043, 0x11f3, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),
8382         SND_PCI_QUIRK(0x1043, 0x1203, "ASUS NB", ALC662_FIXUP_ASUS_MODE1),
8383         SND_PCI_QUIRK(0x1043, 0x1303, "ASUS G60J", ALC662_FIXUP_ASUS_MODE1),
8384         SND_PCI_QUIRK(0x1043, 0x1333, "ASUS G60Jx", ALC662_FIXUP_ASUS_MODE1),
8385         SND_PCI_QUIRK(0x1043, 0x1339, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),
8386         SND_PCI_QUIRK(0x1043, 0x13e3, "ASUS N71JA", ALC662_FIXUP_ASUS_MODE7),
8387         SND_PCI_QUIRK(0x1043, 0x1463, "ASUS N71", ALC662_FIXUP_ASUS_MODE7),
8388         SND_PCI_QUIRK(0x1043, 0x14d3, "ASUS G72", ALC662_FIXUP_ASUS_MODE8),
8389         SND_PCI_QUIRK(0x1043, 0x1563, "ASUS N90", ALC662_FIXUP_ASUS_MODE3),
8390         SND_PCI_QUIRK(0x1043, 0x15d3, "ASUS N50SF F50SF", ALC662_FIXUP_ASUS_MODE1),
8391         SND_PCI_QUIRK(0x1043, 0x16c3, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),
8392         SND_PCI_QUIRK(0x1043, 0x16f3, "ASUS K40C K50C", ALC662_FIXUP_ASUS_MODE2),
8393         SND_PCI_QUIRK(0x1043, 0x1733, "ASUS N81De", ALC662_FIXUP_ASUS_MODE1),
8394         SND_PCI_QUIRK(0x1043, 0x1753, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),
8395         SND_PCI_QUIRK(0x1043, 0x1763, "ASUS NB", ALC662_FIXUP_ASUS_MODE6),
8396         SND_PCI_QUIRK(0x1043, 0x1765, "ASUS NB", ALC662_FIXUP_ASUS_MODE6),
8397         SND_PCI_QUIRK(0x1043, 0x1783, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),
8398         SND_PCI_QUIRK(0x1043, 0x1793, "ASUS F50GX", ALC662_FIXUP_ASUS_MODE1),
8399         SND_PCI_QUIRK(0x1043, 0x17b3, "ASUS F70SL", ALC662_FIXUP_ASUS_MODE3),
8400         SND_PCI_QUIRK(0x1043, 0x17f3, "ASUS X58LE", ALC662_FIXUP_ASUS_MODE2),
8401         SND_PCI_QUIRK(0x1043, 0x1813, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),
8402         SND_PCI_QUIRK(0x1043, 0x1823, "ASUS NB", ALC662_FIXUP_ASUS_MODE5),
8403         SND_PCI_QUIRK(0x1043, 0x1833, "ASUS NB", ALC662_FIXUP_ASUS_MODE6),
8404         SND_PCI_QUIRK(0x1043, 0x1843, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),
8405         SND_PCI_QUIRK(0x1043, 0x1853, "ASUS F50Z", ALC662_FIXUP_ASUS_MODE1),
8406         SND_PCI_QUIRK(0x1043, 0x1864, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),
8407         SND_PCI_QUIRK(0x1043, 0x1876, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),
8408         SND_PCI_QUIRK(0x1043, 0x1893, "ASUS M50Vm", ALC662_FIXUP_ASUS_MODE3),
8409         SND_PCI_QUIRK(0x1043, 0x1894, "ASUS X55", ALC662_FIXUP_ASUS_MODE3),
8410         SND_PCI_QUIRK(0x1043, 0x18b3, "ASUS N80Vc", ALC662_FIXUP_ASUS_MODE1),
8411         SND_PCI_QUIRK(0x1043, 0x18c3, "ASUS VX5", ALC662_FIXUP_ASUS_MODE1),
8412         SND_PCI_QUIRK(0x1043, 0x18d3, "ASUS N81Te", ALC662_FIXUP_ASUS_MODE1),
8413         SND_PCI_QUIRK(0x1043, 0x18f3, "ASUS N505Tp", ALC662_FIXUP_ASUS_MODE1),
8414         SND_PCI_QUIRK(0x1043, 0x1903, "ASUS F5GL", ALC662_FIXUP_ASUS_MODE1),
8415         SND_PCI_QUIRK(0x1043, 0x1913, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),
8416         SND_PCI_QUIRK(0x1043, 0x1933, "ASUS F80Q", ALC662_FIXUP_ASUS_MODE2),
8417         SND_PCI_QUIRK(0x1043, 0x1943, "ASUS Vx3V", ALC662_FIXUP_ASUS_MODE1),
8418         SND_PCI_QUIRK(0x1043, 0x1953, "ASUS NB", ALC662_FIXUP_ASUS_MODE1),
8419         SND_PCI_QUIRK(0x1043, 0x1963, "ASUS X71C", ALC662_FIXUP_ASUS_MODE3),
8420         SND_PCI_QUIRK(0x1043, 0x1983, "ASUS N5051A", ALC662_FIXUP_ASUS_MODE1),
8421         SND_PCI_QUIRK(0x1043, 0x1993, "ASUS N20", ALC662_FIXUP_ASUS_MODE1),
8422         SND_PCI_QUIRK(0x1043, 0x19b3, "ASUS F7Z", ALC662_FIXUP_ASUS_MODE1),
8423         SND_PCI_QUIRK(0x1043, 0x19c3, "ASUS F5Z/F6x", ALC662_FIXUP_ASUS_MODE2),
8424         SND_PCI_QUIRK(0x1043, 0x19e3, "ASUS NB", ALC662_FIXUP_ASUS_MODE1),
8425         SND_PCI_QUIRK(0x1043, 0x19f3, "ASUS NB", ALC662_FIXUP_ASUS_MODE4),
8426 #endif
8427         {}
8428 };
8429
8430 static const struct hda_model_fixup alc662_fixup_models[] = {
8431         {.id = ALC662_FIXUP_ASPIRE, .name = "aspire"},
8432         {.id = ALC662_FIXUP_IDEAPAD, .name = "ideapad"},
8433         {.id = ALC272_FIXUP_MARIO, .name = "mario"},
8434         {.id = ALC662_FIXUP_HP_RP5800, .name = "hp-rp5800"},
8435         {.id = ALC662_FIXUP_ASUS_MODE1, .name = "asus-mode1"},
8436         {.id = ALC662_FIXUP_ASUS_MODE2, .name = "asus-mode2"},
8437         {.id = ALC662_FIXUP_ASUS_MODE3, .name = "asus-mode3"},
8438         {.id = ALC662_FIXUP_ASUS_MODE4, .name = "asus-mode4"},
8439         {.id = ALC662_FIXUP_ASUS_MODE5, .name = "asus-mode5"},
8440         {.id = ALC662_FIXUP_ASUS_MODE6, .name = "asus-mode6"},
8441         {.id = ALC662_FIXUP_ASUS_MODE7, .name = "asus-mode7"},
8442         {.id = ALC662_FIXUP_ASUS_MODE8, .name = "asus-mode8"},
8443         {.id = ALC662_FIXUP_ZOTAC_Z68, .name = "zotac-z68"},
8444         {.id = ALC662_FIXUP_INV_DMIC, .name = "inv-dmic"},
8445         {.id = ALC662_FIXUP_DELL_MIC_NO_PRESENCE, .name = "alc662-headset-multi"},
8446         {.id = ALC668_FIXUP_DELL_MIC_NO_PRESENCE, .name = "dell-headset-multi"},
8447         {.id = ALC662_FIXUP_HEADSET_MODE, .name = "alc662-headset"},
8448         {.id = ALC668_FIXUP_HEADSET_MODE, .name = "alc668-headset"},
8449         {.id = ALC662_FIXUP_BASS_16, .name = "bass16"},
8450         {.id = ALC662_FIXUP_BASS_1A, .name = "bass1a"},
8451         {.id = ALC668_FIXUP_AUTO_MUTE, .name = "automute"},
8452         {.id = ALC668_FIXUP_DELL_XPS13, .name = "dell-xps13"},
8453         {.id = ALC662_FIXUP_ASUS_Nx50, .name = "asus-nx50"},
8454         {.id = ALC668_FIXUP_ASUS_Nx51, .name = "asus-nx51"},
8455         {.id = ALC668_FIXUP_ASUS_G751, .name = "asus-g751"},
8456         {.id = ALC891_FIXUP_HEADSET_MODE, .name = "alc891-headset"},
8457         {.id = ALC891_FIXUP_DELL_MIC_NO_PRESENCE, .name = "alc891-headset-multi"},
8458         {.id = ALC662_FIXUP_ACER_VERITON, .name = "acer-veriton"},
8459         {.id = ALC892_FIXUP_ASROCK_MOBO, .name = "asrock-mobo"},
8460         {.id = ALC662_FIXUP_USI_HEADSET_MODE, .name = "usi-headset"},
8461         {.id = ALC662_FIXUP_LENOVO_MULTI_CODECS, .name = "dual-codecs"},
8462         {}
8463 };
8464
8465 static const struct snd_hda_pin_quirk alc662_pin_fixup_tbl[] = {
8466         SND_HDA_PIN_QUIRK(0x10ec0867, 0x1028, "Dell", ALC891_FIXUP_DELL_MIC_NO_PRESENCE,
8467                 {0x17, 0x02211010},
8468                 {0x18, 0x01a19030},
8469                 {0x1a, 0x01813040},
8470                 {0x21, 0x01014020}),
8471         SND_HDA_PIN_QUIRK(0x10ec0662, 0x1028, "Dell", ALC662_FIXUP_DELL_MIC_NO_PRESENCE,
8472                 {0x14, 0x01014010},
8473                 {0x18, 0x01a19020},
8474                 {0x1a, 0x0181302f},
8475                 {0x1b, 0x0221401f}),
8476         SND_HDA_PIN_QUIRK(0x10ec0668, 0x1028, "Dell", ALC668_FIXUP_AUTO_MUTE,
8477                 {0x12, 0x99a30130},
8478                 {0x14, 0x90170110},
8479                 {0x15, 0x0321101f},
8480                 {0x16, 0x03011020}),
8481         SND_HDA_PIN_QUIRK(0x10ec0668, 0x1028, "Dell", ALC668_FIXUP_AUTO_MUTE,
8482                 {0x12, 0x99a30140},
8483                 {0x14, 0x90170110},
8484                 {0x15, 0x0321101f},
8485                 {0x16, 0x03011020}),
8486         SND_HDA_PIN_QUIRK(0x10ec0668, 0x1028, "Dell", ALC668_FIXUP_AUTO_MUTE,
8487                 {0x12, 0x99a30150},
8488                 {0x14, 0x90170110},
8489                 {0x15, 0x0321101f},
8490                 {0x16, 0x03011020}),
8491         SND_HDA_PIN_QUIRK(0x10ec0668, 0x1028, "Dell", ALC668_FIXUP_AUTO_MUTE,
8492                 {0x14, 0x90170110},
8493                 {0x15, 0x0321101f},
8494                 {0x16, 0x03011020}),
8495         SND_HDA_PIN_QUIRK(0x10ec0668, 0x1028, "Dell XPS 15", ALC668_FIXUP_AUTO_MUTE,
8496                 {0x12, 0x90a60130},
8497                 {0x14, 0x90170110},
8498                 {0x15, 0x0321101f}),
8499         {}
8500 };
8501
8502 /*
8503  */
8504 static int patch_alc662(struct hda_codec *codec)
8505 {
8506         struct alc_spec *spec;
8507         int err;
8508
8509         err = alc_alloc_spec(codec, 0x0b);
8510         if (err < 0)
8511                 return err;
8512
8513         spec = codec->spec;
8514
8515         spec->shutup = alc_eapd_shutup;
8516
8517         /* handle multiple HPs as is */
8518         spec->parse_flags = HDA_PINCFG_NO_HP_FIXUP;
8519
8520         alc_fix_pll_init(codec, 0x20, 0x04, 15);
8521
8522         switch (codec->core.vendor_id) {
8523         case 0x10ec0668:
8524                 spec->init_hook = alc668_restore_default_value;
8525                 break;
8526         }
8527
8528         snd_hda_pick_fixup(codec, alc662_fixup_models,
8529                        alc662_fixup_tbl, alc662_fixups);
8530         snd_hda_pick_pin_fixup(codec, alc662_pin_fixup_tbl, alc662_fixups);
8531         snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE);
8532
8533         alc_auto_parse_customize_define(codec);
8534
8535         if (has_cdefine_beep(codec))
8536                 spec->gen.beep_nid = 0x01;
8537
8538         if ((alc_get_coef0(codec) & (1 << 14)) &&
8539             codec->bus->pci && codec->bus->pci->subsystem_vendor == 0x1025 &&
8540             spec->cdefine.platform_type == 1) {
8541                 err = alc_codec_rename(codec, "ALC272X");
8542                 if (err < 0)
8543                         goto error;
8544         }
8545
8546         /* automatic parse from the BIOS config */
8547         err = alc662_parse_auto_config(codec);
8548         if (err < 0)
8549                 goto error;
8550
8551         if (!spec->gen.no_analog && spec->gen.beep_nid) {
8552                 switch (codec->core.vendor_id) {
8553                 case 0x10ec0662:
8554                         err = set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
8555                         break;
8556                 case 0x10ec0272:
8557                 case 0x10ec0663:
8558                 case 0x10ec0665:
8559                 case 0x10ec0668:
8560                         err = set_beep_amp(spec, 0x0b, 0x04, HDA_INPUT);
8561                         break;
8562                 case 0x10ec0273:
8563                         err = set_beep_amp(spec, 0x0b, 0x03, HDA_INPUT);
8564                         break;
8565                 }
8566                 if (err < 0)
8567                         goto error;
8568         }
8569
8570         snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE);
8571
8572         return 0;
8573
8574  error:
8575         alc_free(codec);
8576         return err;
8577 }
8578
8579 /*
8580  * ALC680 support
8581  */
8582
8583 static int alc680_parse_auto_config(struct hda_codec *codec)
8584 {
8585         return alc_parse_auto_config(codec, NULL, NULL);
8586 }
8587
8588 /*
8589  */
8590 static int patch_alc680(struct hda_codec *codec)
8591 {
8592         int err;
8593
8594         /* ALC680 has no aa-loopback mixer */
8595         err = alc_alloc_spec(codec, 0);
8596         if (err < 0)
8597                 return err;
8598
8599         /* automatic parse from the BIOS config */
8600         err = alc680_parse_auto_config(codec);
8601         if (err < 0) {
8602                 alc_free(codec);
8603                 return err;
8604         }
8605
8606         return 0;
8607 }
8608
8609 /*
8610  * patch entries
8611  */
8612 static const struct hda_device_id snd_hda_id_realtek[] = {
8613         HDA_CODEC_ENTRY(0x10ec0215, "ALC215", patch_alc269),
8614         HDA_CODEC_ENTRY(0x10ec0221, "ALC221", patch_alc269),
8615         HDA_CODEC_ENTRY(0x10ec0225, "ALC225", patch_alc269),
8616         HDA_CODEC_ENTRY(0x10ec0231, "ALC231", patch_alc269),
8617         HDA_CODEC_ENTRY(0x10ec0233, "ALC233", patch_alc269),
8618         HDA_CODEC_ENTRY(0x10ec0234, "ALC234", patch_alc269),
8619         HDA_CODEC_ENTRY(0x10ec0235, "ALC233", patch_alc269),
8620         HDA_CODEC_ENTRY(0x10ec0236, "ALC236", patch_alc269),
8621         HDA_CODEC_ENTRY(0x10ec0255, "ALC255", patch_alc269),
8622         HDA_CODEC_ENTRY(0x10ec0256, "ALC256", patch_alc269),
8623         HDA_CODEC_ENTRY(0x10ec0257, "ALC257", patch_alc269),
8624         HDA_CODEC_ENTRY(0x10ec0260, "ALC260", patch_alc260),
8625         HDA_CODEC_ENTRY(0x10ec0262, "ALC262", patch_alc262),
8626         HDA_CODEC_ENTRY(0x10ec0267, "ALC267", patch_alc268),
8627         HDA_CODEC_ENTRY(0x10ec0268, "ALC268", patch_alc268),
8628         HDA_CODEC_ENTRY(0x10ec0269, "ALC269", patch_alc269),
8629         HDA_CODEC_ENTRY(0x10ec0270, "ALC270", patch_alc269),
8630         HDA_CODEC_ENTRY(0x10ec0272, "ALC272", patch_alc662),
8631         HDA_CODEC_ENTRY(0x10ec0274, "ALC274", patch_alc269),
8632         HDA_CODEC_ENTRY(0x10ec0275, "ALC275", patch_alc269),
8633         HDA_CODEC_ENTRY(0x10ec0276, "ALC276", patch_alc269),
8634         HDA_CODEC_ENTRY(0x10ec0280, "ALC280", patch_alc269),
8635         HDA_CODEC_ENTRY(0x10ec0282, "ALC282", patch_alc269),
8636         HDA_CODEC_ENTRY(0x10ec0283, "ALC283", patch_alc269),
8637         HDA_CODEC_ENTRY(0x10ec0284, "ALC284", patch_alc269),
8638         HDA_CODEC_ENTRY(0x10ec0285, "ALC285", patch_alc269),
8639         HDA_CODEC_ENTRY(0x10ec0286, "ALC286", patch_alc269),
8640         HDA_CODEC_ENTRY(0x10ec0288, "ALC288", patch_alc269),
8641         HDA_CODEC_ENTRY(0x10ec0289, "ALC289", patch_alc269),
8642         HDA_CODEC_ENTRY(0x10ec0290, "ALC290", patch_alc269),
8643         HDA_CODEC_ENTRY(0x10ec0292, "ALC292", patch_alc269),
8644         HDA_CODEC_ENTRY(0x10ec0293, "ALC293", patch_alc269),
8645         HDA_CODEC_ENTRY(0x10ec0294, "ALC294", patch_alc269),
8646         HDA_CODEC_ENTRY(0x10ec0295, "ALC295", patch_alc269),
8647         HDA_CODEC_ENTRY(0x10ec0298, "ALC298", patch_alc269),
8648         HDA_CODEC_ENTRY(0x10ec0299, "ALC299", patch_alc269),
8649         HDA_CODEC_ENTRY(0x10ec0300, "ALC300", patch_alc269),
8650         HDA_CODEC_REV_ENTRY(0x10ec0861, 0x100340, "ALC660", patch_alc861),
8651         HDA_CODEC_ENTRY(0x10ec0660, "ALC660-VD", patch_alc861vd),
8652         HDA_CODEC_ENTRY(0x10ec0861, "ALC861", patch_alc861),
8653         HDA_CODEC_ENTRY(0x10ec0862, "ALC861-VD", patch_alc861vd),
8654         HDA_CODEC_REV_ENTRY(0x10ec0662, 0x100002, "ALC662 rev2", patch_alc882),
8655         HDA_CODEC_REV_ENTRY(0x10ec0662, 0x100101, "ALC662 rev1", patch_alc662),
8656         HDA_CODEC_REV_ENTRY(0x10ec0662, 0x100300, "ALC662 rev3", patch_alc662),
8657         HDA_CODEC_ENTRY(0x10ec0663, "ALC663", patch_alc662),
8658         HDA_CODEC_ENTRY(0x10ec0665, "ALC665", patch_alc662),
8659         HDA_CODEC_ENTRY(0x10ec0667, "ALC667", patch_alc662),
8660         HDA_CODEC_ENTRY(0x10ec0668, "ALC668", patch_alc662),
8661         HDA_CODEC_ENTRY(0x10ec0670, "ALC670", patch_alc662),
8662         HDA_CODEC_ENTRY(0x10ec0671, "ALC671", patch_alc662),
8663         HDA_CODEC_ENTRY(0x10ec0680, "ALC680", patch_alc680),
8664         HDA_CODEC_ENTRY(0x10ec0700, "ALC700", patch_alc269),
8665         HDA_CODEC_ENTRY(0x10ec0701, "ALC701", patch_alc269),
8666         HDA_CODEC_ENTRY(0x10ec0703, "ALC703", patch_alc269),
8667         HDA_CODEC_ENTRY(0x10ec0867, "ALC891", patch_alc662),
8668         HDA_CODEC_ENTRY(0x10ec0880, "ALC880", patch_alc880),
8669         HDA_CODEC_ENTRY(0x10ec0882, "ALC882", patch_alc882),
8670         HDA_CODEC_ENTRY(0x10ec0883, "ALC883", patch_alc882),
8671         HDA_CODEC_REV_ENTRY(0x10ec0885, 0x100101, "ALC889A", patch_alc882),
8672         HDA_CODEC_REV_ENTRY(0x10ec0885, 0x100103, "ALC889A", patch_alc882),
8673         HDA_CODEC_ENTRY(0x10ec0885, "ALC885", patch_alc882),
8674         HDA_CODEC_ENTRY(0x10ec0887, "ALC887", patch_alc882),
8675         HDA_CODEC_REV_ENTRY(0x10ec0888, 0x100101, "ALC1200", patch_alc882),
8676         HDA_CODEC_ENTRY(0x10ec0888, "ALC888", patch_alc882),
8677         HDA_CODEC_ENTRY(0x10ec0889, "ALC889", patch_alc882),
8678         HDA_CODEC_ENTRY(0x10ec0892, "ALC892", patch_alc662),
8679         HDA_CODEC_ENTRY(0x10ec0899, "ALC898", patch_alc882),
8680         HDA_CODEC_ENTRY(0x10ec0900, "ALC1150", patch_alc882),
8681         HDA_CODEC_ENTRY(0x10ec1168, "ALC1220", patch_alc882),
8682         HDA_CODEC_ENTRY(0x10ec1220, "ALC1220", patch_alc882),
8683         {} /* terminator */
8684 };
8685 MODULE_DEVICE_TABLE(hdaudio, snd_hda_id_realtek);
8686
8687 MODULE_LICENSE("GPL");
8688 MODULE_DESCRIPTION("Realtek HD-audio codec");
8689
8690 static struct hda_codec_driver realtek_driver = {
8691         .id = snd_hda_id_realtek,
8692 };
8693
8694 module_hda_codec_driver(realtek_driver);