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