sound/pci/hda/patch_realtek.c

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