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