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