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