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