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