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