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 };
1791
1792 static void alc889_fixup_coef(struct hda_codec *codec,
1793                               const struct hda_fixup *fix, int action)
1794 {
1795         if (action != HDA_FIXUP_ACT_INIT)
1796                 return;
1797         alc_update_coef_idx(codec, 7, 0, 0x2030);
1798 }
1799
1800 /* toggle speaker-output according to the hp-jack state */
1801 static void alc882_gpio_mute(struct hda_codec *codec, int pin, int muted)
1802 {
1803         unsigned int gpiostate, gpiomask, gpiodir;
1804
1805         gpiostate = snd_hda_codec_read(codec, codec->core.afg, 0,
1806                                        AC_VERB_GET_GPIO_DATA, 0);
1807
1808         if (!muted)
1809                 gpiostate |= (1 << pin);
1810         else
1811                 gpiostate &= ~(1 << pin);
1812
1813         gpiomask = snd_hda_codec_read(codec, codec->core.afg, 0,
1814                                       AC_VERB_GET_GPIO_MASK, 0);
1815         gpiomask |= (1 << pin);
1816
1817         gpiodir = snd_hda_codec_read(codec, codec->core.afg, 0,
1818                                      AC_VERB_GET_GPIO_DIRECTION, 0);
1819         gpiodir |= (1 << pin);
1820
1821
1822         snd_hda_codec_write(codec, codec->core.afg, 0,
1823                             AC_VERB_SET_GPIO_MASK, gpiomask);
1824         snd_hda_codec_write(codec, codec->core.afg, 0,
1825                             AC_VERB_SET_GPIO_DIRECTION, gpiodir);
1826
1827         msleep(1);
1828
1829         snd_hda_codec_write(codec, codec->core.afg, 0,
1830                             AC_VERB_SET_GPIO_DATA, gpiostate);
1831 }
1832
1833 /* set up GPIO at initialization */
1834 static void alc885_fixup_macpro_gpio(struct hda_codec *codec,
1835                                      const struct hda_fixup *fix, int action)
1836 {
1837         if (action != HDA_FIXUP_ACT_INIT)
1838                 return;
1839         alc882_gpio_mute(codec, 0, 0);
1840         alc882_gpio_mute(codec, 1, 0);
1841 }
1842
1843 /* Fix the connection of some pins for ALC889:
1844  * At least, Acer Aspire 5935 shows the connections to DAC3/4 don't
1845  * work correctly (bko#42740)
1846  */
1847 static void alc889_fixup_dac_route(struct hda_codec *codec,
1848                                    const struct hda_fixup *fix, int action)
1849 {
1850         if (action == HDA_FIXUP_ACT_PRE_PROBE) {
1851                 /* fake the connections during parsing the tree */
1852                 hda_nid_t conn1[2] = { 0x0c, 0x0d };
1853                 hda_nid_t conn2[2] = { 0x0e, 0x0f };
1854                 snd_hda_override_conn_list(codec, 0x14, 2, conn1);
1855                 snd_hda_override_conn_list(codec, 0x15, 2, conn1);
1856                 snd_hda_override_conn_list(codec, 0x18, 2, conn2);
1857                 snd_hda_override_conn_list(codec, 0x1a, 2, conn2);
1858         } else if (action == HDA_FIXUP_ACT_PROBE) {
1859                 /* restore the connections */
1860                 hda_nid_t conn[5] = { 0x0c, 0x0d, 0x0e, 0x0f, 0x26 };
1861                 snd_hda_override_conn_list(codec, 0x14, 5, conn);
1862                 snd_hda_override_conn_list(codec, 0x15, 5, conn);
1863                 snd_hda_override_conn_list(codec, 0x18, 5, conn);
1864                 snd_hda_override_conn_list(codec, 0x1a, 5, conn);
1865         }
1866 }
1867
1868 /* Set VREF on HP pin */
1869 static void alc889_fixup_mbp_vref(struct hda_codec *codec,
1870                                   const struct hda_fixup *fix, int action)
1871 {
1872         struct alc_spec *spec = codec->spec;
1873         static hda_nid_t nids[3] = { 0x14, 0x15, 0x19 };
1874         int i;
1875
1876         if (action != HDA_FIXUP_ACT_INIT)
1877                 return;
1878         for (i = 0; i < ARRAY_SIZE(nids); i++) {
1879                 unsigned int val = snd_hda_codec_get_pincfg(codec, nids[i]);
1880                 if (get_defcfg_device(val) != AC_JACK_HP_OUT)
1881                         continue;
1882                 val = snd_hda_codec_get_pin_target(codec, nids[i]);
1883                 val |= AC_PINCTL_VREF_80;
1884                 snd_hda_set_pin_ctl(codec, nids[i], val);
1885                 spec->gen.keep_vref_in_automute = 1;
1886                 break;
1887         }
1888 }
1889
1890 static void alc889_fixup_mac_pins(struct hda_codec *codec,
1891                                   const hda_nid_t *nids, int num_nids)
1892 {
1893         struct alc_spec *spec = codec->spec;
1894         int i;
1895
1896         for (i = 0; i < num_nids; i++) {
1897                 unsigned int val;
1898                 val = snd_hda_codec_get_pin_target(codec, nids[i]);
1899                 val |= AC_PINCTL_VREF_50;
1900                 snd_hda_set_pin_ctl(codec, nids[i], val);
1901         }
1902         spec->gen.keep_vref_in_automute = 1;
1903 }
1904
1905 /* Set VREF on speaker pins on imac91 */
1906 static void alc889_fixup_imac91_vref(struct hda_codec *codec,
1907                                      const struct hda_fixup *fix, int action)
1908 {
1909         static hda_nid_t nids[2] = { 0x18, 0x1a };
1910
1911         if (action == HDA_FIXUP_ACT_INIT)
1912                 alc889_fixup_mac_pins(codec, nids, ARRAY_SIZE(nids));
1913 }
1914
1915 /* Set VREF on speaker pins on mba11 */
1916 static void alc889_fixup_mba11_vref(struct hda_codec *codec,
1917                                     const struct hda_fixup *fix, int action)
1918 {
1919         static hda_nid_t nids[1] = { 0x18 };
1920
1921         if (action == HDA_FIXUP_ACT_INIT)
1922                 alc889_fixup_mac_pins(codec, nids, ARRAY_SIZE(nids));
1923 }
1924
1925 /* Set VREF on speaker pins on mba21 */
1926 static void alc889_fixup_mba21_vref(struct hda_codec *codec,
1927                                     const struct hda_fixup *fix, int action)
1928 {
1929         static hda_nid_t nids[2] = { 0x18, 0x19 };
1930
1931         if (action == HDA_FIXUP_ACT_INIT)
1932                 alc889_fixup_mac_pins(codec, nids, ARRAY_SIZE(nids));
1933 }
1934
1935 /* Don't take HP output as primary
1936  * Strangely, the speaker output doesn't work on Vaio Z and some Vaio
1937  * all-in-one desktop PCs (for example VGC-LN51JGB) through DAC 0x05
1938  */
1939 static void alc882_fixup_no_primary_hp(struct hda_codec *codec,
1940                                        const struct hda_fixup *fix, int action)
1941 {
1942         struct alc_spec *spec = codec->spec;
1943         if (action == HDA_FIXUP_ACT_PRE_PROBE) {
1944                 spec->gen.no_primary_hp = 1;
1945                 spec->gen.no_multi_io = 1;
1946         }
1947 }
1948
1949 static void alc_fixup_bass_chmap(struct hda_codec *codec,
1950                                  const struct hda_fixup *fix, int action);
1951
1952 static const struct hda_fixup alc882_fixups[] = {
1953         [ALC882_FIXUP_ABIT_AW9D_MAX] = {
1954                 .type = HDA_FIXUP_PINS,
1955                 .v.pins = (const struct hda_pintbl[]) {
1956                         { 0x15, 0x01080104 }, /* side */
1957                         { 0x16, 0x01011012 }, /* rear */
1958                         { 0x17, 0x01016011 }, /* clfe */
1959                         { }
1960                 }
1961         },
1962         [ALC882_FIXUP_LENOVO_Y530] = {
1963                 .type = HDA_FIXUP_PINS,
1964                 .v.pins = (const struct hda_pintbl[]) {
1965                         { 0x15, 0x99130112 }, /* rear int speakers */
1966                         { 0x16, 0x99130111 }, /* subwoofer */
1967                         { }
1968                 }
1969         },
1970         [ALC882_FIXUP_PB_M5210] = {
1971                 .type = HDA_FIXUP_PINCTLS,
1972                 .v.pins = (const struct hda_pintbl[]) {
1973                         { 0x19, PIN_VREF50 },
1974                         {}
1975                 }
1976         },
1977         [ALC882_FIXUP_ACER_ASPIRE_7736] = {
1978                 .type = HDA_FIXUP_FUNC,
1979                 .v.func = alc_fixup_sku_ignore,
1980         },
1981         [ALC882_FIXUP_ASUS_W90V] = {
1982                 .type = HDA_FIXUP_PINS,
1983                 .v.pins = (const struct hda_pintbl[]) {
1984                         { 0x16, 0x99130110 }, /* fix sequence for CLFE */
1985                         { }
1986                 }
1987         },
1988         [ALC889_FIXUP_CD] = {
1989                 .type = HDA_FIXUP_PINS,
1990                 .v.pins = (const struct hda_pintbl[]) {
1991                         { 0x1c, 0x993301f0 }, /* CD */
1992                         { }
1993                 }
1994         },
1995         [ALC889_FIXUP_FRONT_HP_NO_PRESENCE] = {
1996                 .type = HDA_FIXUP_PINS,
1997                 .v.pins = (const struct hda_pintbl[]) {
1998                         { 0x1b, 0x02214120 }, /* Front HP jack is flaky, disable jack detect */
1999                         { }
2000                 },
2001                 .chained = true,
2002                 .chain_id = ALC889_FIXUP_CD,
2003         },
2004         [ALC889_FIXUP_VAIO_TT] = {
2005                 .type = HDA_FIXUP_PINS,
2006                 .v.pins = (const struct hda_pintbl[]) {
2007                         { 0x17, 0x90170111 }, /* hidden surround speaker */
2008                         { }
2009                 }
2010         },
2011         [ALC888_FIXUP_EEE1601] = {
2012                 .type = HDA_FIXUP_VERBS,
2013                 .v.verbs = (const struct hda_verb[]) {
2014                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x0b },
2015                         { 0x20, AC_VERB_SET_PROC_COEF,  0x0838 },
2016                         { }
2017                 }
2018         },
2019         [ALC882_FIXUP_EAPD] = {
2020                 .type = HDA_FIXUP_VERBS,
2021                 .v.verbs = (const struct hda_verb[]) {
2022                         /* change to EAPD mode */
2023                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x07 },
2024                         { 0x20, AC_VERB_SET_PROC_COEF, 0x3060 },
2025                         { }
2026                 }
2027         },
2028         [ALC883_FIXUP_EAPD] = {
2029                 .type = HDA_FIXUP_VERBS,
2030                 .v.verbs = (const struct hda_verb[]) {
2031                         /* change to EAPD mode */
2032                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x07 },
2033                         { 0x20, AC_VERB_SET_PROC_COEF, 0x3070 },
2034                         { }
2035                 }
2036         },
2037         [ALC883_FIXUP_ACER_EAPD] = {
2038                 .type = HDA_FIXUP_VERBS,
2039                 .v.verbs = (const struct hda_verb[]) {
2040                         /* eanable EAPD on Acer laptops */
2041                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x07 },
2042                         { 0x20, AC_VERB_SET_PROC_COEF, 0x3050 },
2043                         { }
2044                 }
2045         },
2046         [ALC882_FIXUP_GPIO1] = {
2047                 .type = HDA_FIXUP_VERBS,
2048                 .v.verbs = alc_gpio1_init_verbs,
2049         },
2050         [ALC882_FIXUP_GPIO2] = {
2051                 .type = HDA_FIXUP_VERBS,
2052                 .v.verbs = alc_gpio2_init_verbs,
2053         },
2054         [ALC882_FIXUP_GPIO3] = {
2055                 .type = HDA_FIXUP_VERBS,
2056                 .v.verbs = alc_gpio3_init_verbs,
2057         },
2058         [ALC882_FIXUP_ASUS_W2JC] = {
2059                 .type = HDA_FIXUP_VERBS,
2060                 .v.verbs = alc_gpio1_init_verbs,
2061                 .chained = true,
2062                 .chain_id = ALC882_FIXUP_EAPD,
2063         },
2064         [ALC889_FIXUP_COEF] = {
2065                 .type = HDA_FIXUP_FUNC,
2066                 .v.func = alc889_fixup_coef,
2067         },
2068         [ALC882_FIXUP_ACER_ASPIRE_4930G] = {
2069                 .type = HDA_FIXUP_PINS,
2070                 .v.pins = (const struct hda_pintbl[]) {
2071                         { 0x16, 0x99130111 }, /* CLFE speaker */
2072                         { 0x17, 0x99130112 }, /* surround speaker */
2073                         { }
2074                 },
2075                 .chained = true,
2076                 .chain_id = ALC882_FIXUP_GPIO1,
2077         },
2078         [ALC882_FIXUP_ACER_ASPIRE_8930G] = {
2079                 .type = HDA_FIXUP_PINS,
2080                 .v.pins = (const struct hda_pintbl[]) {
2081                         { 0x16, 0x99130111 }, /* CLFE speaker */
2082                         { 0x1b, 0x99130112 }, /* surround speaker */
2083                         { }
2084                 },
2085                 .chained = true,
2086                 .chain_id = ALC882_FIXUP_ASPIRE_8930G_VERBS,
2087         },
2088         [ALC882_FIXUP_ASPIRE_8930G_VERBS] = {
2089                 /* additional init verbs for Acer Aspire 8930G */
2090                 .type = HDA_FIXUP_VERBS,
2091                 .v.verbs = (const struct hda_verb[]) {
2092                         /* Enable all DACs */
2093                         /* DAC DISABLE/MUTE 1? */
2094                         /*  setting bits 1-5 disables DAC nids 0x02-0x06
2095                          *  apparently. Init=0x38 */
2096                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x03 },
2097                         { 0x20, AC_VERB_SET_PROC_COEF, 0x0000 },
2098                         /* DAC DISABLE/MUTE 2? */
2099                         /*  some bit here disables the other DACs.
2100                          *  Init=0x4900 */
2101                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x08 },
2102                         { 0x20, AC_VERB_SET_PROC_COEF, 0x0000 },
2103                         /* DMIC fix
2104                          * This laptop has a stereo digital microphone.
2105                          * The mics are only 1cm apart which makes the stereo
2106                          * useless. However, either the mic or the ALC889
2107                          * makes the signal become a difference/sum signal
2108                          * instead of standard stereo, which is annoying.
2109                          * So instead we flip this bit which makes the
2110                          * codec replicate the sum signal to both channels,
2111                          * turning it into a normal mono mic.
2112                          */
2113                         /* DMIC_CONTROL? Init value = 0x0001 */
2114                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x0b },
2115                         { 0x20, AC_VERB_SET_PROC_COEF, 0x0003 },
2116                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x07 },
2117                         { 0x20, AC_VERB_SET_PROC_COEF, 0x3050 },
2118                         { }
2119                 },
2120                 .chained = true,
2121                 .chain_id = ALC882_FIXUP_GPIO1,
2122         },
2123         [ALC885_FIXUP_MACPRO_GPIO] = {
2124                 .type = HDA_FIXUP_FUNC,
2125                 .v.func = alc885_fixup_macpro_gpio,
2126         },
2127         [ALC889_FIXUP_DAC_ROUTE] = {
2128                 .type = HDA_FIXUP_FUNC,
2129                 .v.func = alc889_fixup_dac_route,
2130         },
2131         [ALC889_FIXUP_MBP_VREF] = {
2132                 .type = HDA_FIXUP_FUNC,
2133                 .v.func = alc889_fixup_mbp_vref,
2134                 .chained = true,
2135                 .chain_id = ALC882_FIXUP_GPIO1,
2136         },
2137         [ALC889_FIXUP_IMAC91_VREF] = {
2138                 .type = HDA_FIXUP_FUNC,
2139                 .v.func = alc889_fixup_imac91_vref,
2140                 .chained = true,
2141                 .chain_id = ALC882_FIXUP_GPIO1,
2142         },
2143         [ALC889_FIXUP_MBA11_VREF] = {
2144                 .type = HDA_FIXUP_FUNC,
2145                 .v.func = alc889_fixup_mba11_vref,
2146                 .chained = true,
2147                 .chain_id = ALC889_FIXUP_MBP_VREF,
2148         },
2149         [ALC889_FIXUP_MBA21_VREF] = {
2150                 .type = HDA_FIXUP_FUNC,
2151                 .v.func = alc889_fixup_mba21_vref,
2152                 .chained = true,
2153                 .chain_id = ALC889_FIXUP_MBP_VREF,
2154         },
2155         [ALC889_FIXUP_MP11_VREF] = {
2156                 .type = HDA_FIXUP_FUNC,
2157                 .v.func = alc889_fixup_mba11_vref,
2158                 .chained = true,
2159                 .chain_id = ALC885_FIXUP_MACPRO_GPIO,
2160         },
2161         [ALC889_FIXUP_MP41_VREF] = {
2162                 .type = HDA_FIXUP_FUNC,
2163                 .v.func = alc889_fixup_mbp_vref,
2164                 .chained = true,
2165                 .chain_id = ALC885_FIXUP_MACPRO_GPIO,
2166         },
2167         [ALC882_FIXUP_INV_DMIC] = {
2168                 .type = HDA_FIXUP_FUNC,
2169                 .v.func = alc_fixup_inv_dmic,
2170         },
2171         [ALC882_FIXUP_NO_PRIMARY_HP] = {
2172                 .type = HDA_FIXUP_FUNC,
2173                 .v.func = alc882_fixup_no_primary_hp,
2174         },
2175         [ALC887_FIXUP_ASUS_BASS] = {
2176                 .type = HDA_FIXUP_PINS,
2177                 .v.pins = (const struct hda_pintbl[]) {
2178                         {0x16, 0x99130130}, /* bass speaker */
2179                         {}
2180                 },
2181                 .chained = true,
2182                 .chain_id = ALC887_FIXUP_BASS_CHMAP,
2183         },
2184         [ALC887_FIXUP_BASS_CHMAP] = {
2185                 .type = HDA_FIXUP_FUNC,
2186                 .v.func = alc_fixup_bass_chmap,
2187         },
2188 };
2189
2190 static const struct snd_pci_quirk alc882_fixup_tbl[] = {
2191         SND_PCI_QUIRK(0x1025, 0x006c, "Acer Aspire 9810", ALC883_FIXUP_ACER_EAPD),
2192         SND_PCI_QUIRK(0x1025, 0x0090, "Acer Aspire", ALC883_FIXUP_ACER_EAPD),
2193         SND_PCI_QUIRK(0x1025, 0x0107, "Acer Aspire", ALC883_FIXUP_ACER_EAPD),
2194         SND_PCI_QUIRK(0x1025, 0x010a, "Acer Ferrari 5000", ALC883_FIXUP_ACER_EAPD),
2195         SND_PCI_QUIRK(0x1025, 0x0110, "Acer Aspire", ALC883_FIXUP_ACER_EAPD),
2196         SND_PCI_QUIRK(0x1025, 0x0112, "Acer Aspire 9303", ALC883_FIXUP_ACER_EAPD),
2197         SND_PCI_QUIRK(0x1025, 0x0121, "Acer Aspire 5920G", ALC883_FIXUP_ACER_EAPD),
2198         SND_PCI_QUIRK(0x1025, 0x013e, "Acer Aspire 4930G",
2199                       ALC882_FIXUP_ACER_ASPIRE_4930G),
2200         SND_PCI_QUIRK(0x1025, 0x013f, "Acer Aspire 5930G",
2201                       ALC882_FIXUP_ACER_ASPIRE_4930G),
2202         SND_PCI_QUIRK(0x1025, 0x0145, "Acer Aspire 8930G",
2203                       ALC882_FIXUP_ACER_ASPIRE_8930G),
2204         SND_PCI_QUIRK(0x1025, 0x0146, "Acer Aspire 6935G",
2205                       ALC882_FIXUP_ACER_ASPIRE_8930G),
2206         SND_PCI_QUIRK(0x1025, 0x015e, "Acer Aspire 6930G",
2207                       ALC882_FIXUP_ACER_ASPIRE_4930G),
2208         SND_PCI_QUIRK(0x1025, 0x0166, "Acer Aspire 6530G",
2209                       ALC882_FIXUP_ACER_ASPIRE_4930G),
2210         SND_PCI_QUIRK(0x1025, 0x0142, "Acer Aspire 7730G",
2211                       ALC882_FIXUP_ACER_ASPIRE_4930G),
2212         SND_PCI_QUIRK(0x1025, 0x0155, "Packard-Bell M5120", ALC882_FIXUP_PB_M5210),
2213         SND_PCI_QUIRK(0x1025, 0x021e, "Acer Aspire 5739G",
2214                       ALC882_FIXUP_ACER_ASPIRE_4930G),
2215         SND_PCI_QUIRK(0x1025, 0x0259, "Acer Aspire 5935", ALC889_FIXUP_DAC_ROUTE),
2216         SND_PCI_QUIRK(0x1025, 0x026b, "Acer Aspire 8940G", ALC882_FIXUP_ACER_ASPIRE_8930G),
2217         SND_PCI_QUIRK(0x1025, 0x0296, "Acer Aspire 7736z", ALC882_FIXUP_ACER_ASPIRE_7736),
2218         SND_PCI_QUIRK(0x1043, 0x13c2, "Asus A7M", ALC882_FIXUP_EAPD),
2219         SND_PCI_QUIRK(0x1043, 0x1873, "ASUS W90V", ALC882_FIXUP_ASUS_W90V),
2220         SND_PCI_QUIRK(0x1043, 0x1971, "Asus W2JC", ALC882_FIXUP_ASUS_W2JC),
2221         SND_PCI_QUIRK(0x1043, 0x835f, "Asus Eee 1601", ALC888_FIXUP_EEE1601),
2222         SND_PCI_QUIRK(0x1043, 0x84bc, "ASUS ET2700", ALC887_FIXUP_ASUS_BASS),
2223         SND_PCI_QUIRK(0x104d, 0x9047, "Sony Vaio TT", ALC889_FIXUP_VAIO_TT),
2224         SND_PCI_QUIRK(0x104d, 0x905a, "Sony Vaio Z", ALC882_FIXUP_NO_PRIMARY_HP),
2225         SND_PCI_QUIRK(0x104d, 0x9043, "Sony Vaio VGC-LN51JGB", ALC882_FIXUP_NO_PRIMARY_HP),
2226
2227         /* All Apple entries are in codec SSIDs */
2228         SND_PCI_QUIRK(0x106b, 0x00a0, "MacBookPro 3,1", ALC889_FIXUP_MBP_VREF),
2229         SND_PCI_QUIRK(0x106b, 0x00a1, "Macbook", ALC889_FIXUP_MBP_VREF),
2230         SND_PCI_QUIRK(0x106b, 0x00a4, "MacbookPro 4,1", ALC889_FIXUP_MBP_VREF),
2231         SND_PCI_QUIRK(0x106b, 0x0c00, "Mac Pro", ALC889_FIXUP_MP11_VREF),
2232         SND_PCI_QUIRK(0x106b, 0x1000, "iMac 24", ALC885_FIXUP_MACPRO_GPIO),
2233         SND_PCI_QUIRK(0x106b, 0x2800, "AppleTV", ALC885_FIXUP_MACPRO_GPIO),
2234         SND_PCI_QUIRK(0x106b, 0x2c00, "MacbookPro rev3", ALC889_FIXUP_MBP_VREF),
2235         SND_PCI_QUIRK(0x106b, 0x3000, "iMac", ALC889_FIXUP_MBP_VREF),
2236         SND_PCI_QUIRK(0x106b, 0x3200, "iMac 7,1 Aluminum", ALC882_FIXUP_EAPD),
2237         SND_PCI_QUIRK(0x106b, 0x3400, "MacBookAir 1,1", ALC889_FIXUP_MBA11_VREF),
2238         SND_PCI_QUIRK(0x106b, 0x3500, "MacBookAir 2,1", ALC889_FIXUP_MBA21_VREF),
2239         SND_PCI_QUIRK(0x106b, 0x3600, "Macbook 3,1", ALC889_FIXUP_MBP_VREF),
2240         SND_PCI_QUIRK(0x106b, 0x3800, "MacbookPro 4,1", ALC889_FIXUP_MBP_VREF),
2241         SND_PCI_QUIRK(0x106b, 0x3e00, "iMac 24 Aluminum", ALC885_FIXUP_MACPRO_GPIO),
2242         SND_PCI_QUIRK(0x106b, 0x3f00, "Macbook 5,1", ALC889_FIXUP_IMAC91_VREF),
2243         SND_PCI_QUIRK(0x106b, 0x4000, "MacbookPro 5,1", ALC889_FIXUP_IMAC91_VREF),
2244         SND_PCI_QUIRK(0x106b, 0x4100, "Macmini 3,1", ALC889_FIXUP_IMAC91_VREF),
2245         SND_PCI_QUIRK(0x106b, 0x4200, "Mac Pro 4,1/5,1", ALC889_FIXUP_MP41_VREF),
2246         SND_PCI_QUIRK(0x106b, 0x4300, "iMac 9,1", ALC889_FIXUP_IMAC91_VREF),
2247         SND_PCI_QUIRK(0x106b, 0x4600, "MacbookPro 5,2", ALC889_FIXUP_IMAC91_VREF),
2248         SND_PCI_QUIRK(0x106b, 0x4900, "iMac 9,1 Aluminum", ALC889_FIXUP_IMAC91_VREF),
2249         SND_PCI_QUIRK(0x106b, 0x4a00, "Macbook 5,2", ALC889_FIXUP_MBA11_VREF),
2250
2251         SND_PCI_QUIRK(0x1071, 0x8258, "Evesham Voyaeger", ALC882_FIXUP_EAPD),
2252         SND_PCI_QUIRK(0x1462, 0x7350, "MSI-7350", ALC889_FIXUP_CD),
2253         SND_PCI_QUIRK_VENDOR(0x1462, "MSI", ALC882_FIXUP_GPIO3),
2254         SND_PCI_QUIRK(0x1458, 0xa002, "Gigabyte EP45-DS3/Z87X-UD3H", ALC889_FIXUP_FRONT_HP_NO_PRESENCE),
2255         SND_PCI_QUIRK(0x147b, 0x107a, "Abit AW9D-MAX", ALC882_FIXUP_ABIT_AW9D_MAX),
2256         SND_PCI_QUIRK_VENDOR(0x1558, "Clevo laptop", ALC882_FIXUP_EAPD),
2257         SND_PCI_QUIRK(0x161f, 0x2054, "Medion laptop", ALC883_FIXUP_EAPD),
2258         SND_PCI_QUIRK(0x17aa, 0x3a0d, "Lenovo Y530", ALC882_FIXUP_LENOVO_Y530),
2259         SND_PCI_QUIRK(0x8086, 0x0022, "DX58SO", ALC889_FIXUP_COEF),
2260         {}
2261 };
2262
2263 static const struct hda_model_fixup alc882_fixup_models[] = {
2264         {.id = ALC882_FIXUP_ACER_ASPIRE_4930G, .name = "acer-aspire-4930g"},
2265         {.id = ALC882_FIXUP_ACER_ASPIRE_8930G, .name = "acer-aspire-8930g"},
2266         {.id = ALC883_FIXUP_ACER_EAPD, .name = "acer-aspire"},
2267         {.id = ALC882_FIXUP_INV_DMIC, .name = "inv-dmic"},
2268         {.id = ALC882_FIXUP_NO_PRIMARY_HP, .name = "no-primary-hp"},
2269         {}
2270 };
2271
2272 /*
2273  * BIOS auto configuration
2274  */
2275 /* almost identical with ALC880 parser... */
2276 static int alc882_parse_auto_config(struct hda_codec *codec)
2277 {
2278         static const hda_nid_t alc882_ignore[] = { 0x1d, 0 };
2279         static const hda_nid_t alc882_ssids[] = { 0x15, 0x1b, 0x14, 0 };
2280         return alc_parse_auto_config(codec, alc882_ignore, alc882_ssids);
2281 }
2282
2283 /*
2284  */
2285 static int patch_alc882(struct hda_codec *codec)
2286 {
2287         struct alc_spec *spec;
2288         int err;
2289
2290         err = alc_alloc_spec(codec, 0x0b);
2291         if (err < 0)
2292                 return err;
2293
2294         spec = codec->spec;
2295
2296         switch (codec->core.vendor_id) {
2297         case 0x10ec0882:
2298         case 0x10ec0885:
2299         case 0x10ec0900:
2300                 break;
2301         default:
2302                 /* ALC883 and variants */
2303                 alc_fix_pll_init(codec, 0x20, 0x0a, 10);
2304                 break;
2305         }
2306
2307         snd_hda_pick_fixup(codec, alc882_fixup_models, alc882_fixup_tbl,
2308                        alc882_fixups);
2309         snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE);
2310
2311         alc_auto_parse_customize_define(codec);
2312
2313         if (has_cdefine_beep(codec))
2314                 spec->gen.beep_nid = 0x01;
2315
2316         /* automatic parse from the BIOS config */
2317         err = alc882_parse_auto_config(codec);
2318         if (err < 0)
2319                 goto error;
2320
2321         if (!spec->gen.no_analog && spec->gen.beep_nid)
2322                 set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
2323
2324         snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE);
2325
2326         return 0;
2327
2328  error:
2329         alc_free(codec);
2330         return err;
2331 }
2332
2333
2334 /*
2335  * ALC262 support
2336  */
2337 static int alc262_parse_auto_config(struct hda_codec *codec)
2338 {
2339         static const hda_nid_t alc262_ignore[] = { 0x1d, 0 };
2340         static const hda_nid_t alc262_ssids[] = { 0x15, 0x1b, 0x14, 0 };
2341         return alc_parse_auto_config(codec, alc262_ignore, alc262_ssids);
2342 }
2343
2344 /*
2345  * Pin config fixes
2346  */
2347 enum {
2348         ALC262_FIXUP_FSC_H270,
2349         ALC262_FIXUP_FSC_S7110,
2350         ALC262_FIXUP_HP_Z200,
2351         ALC262_FIXUP_TYAN,
2352         ALC262_FIXUP_LENOVO_3000,
2353         ALC262_FIXUP_BENQ,
2354         ALC262_FIXUP_BENQ_T31,
2355         ALC262_FIXUP_INV_DMIC,
2356         ALC262_FIXUP_INTEL_BAYLEYBAY,
2357 };
2358
2359 static const struct hda_fixup alc262_fixups[] = {
2360         [ALC262_FIXUP_FSC_H270] = {
2361                 .type = HDA_FIXUP_PINS,
2362                 .v.pins = (const struct hda_pintbl[]) {
2363                         { 0x14, 0x99130110 }, /* speaker */
2364                         { 0x15, 0x0221142f }, /* front HP */
2365                         { 0x1b, 0x0121141f }, /* rear HP */
2366                         { }
2367                 }
2368         },
2369         [ALC262_FIXUP_FSC_S7110] = {
2370                 .type = HDA_FIXUP_PINS,
2371                 .v.pins = (const struct hda_pintbl[]) {
2372                         { 0x15, 0x90170110 }, /* speaker */
2373                         { }
2374                 },
2375                 .chained = true,
2376                 .chain_id = ALC262_FIXUP_BENQ,
2377         },
2378         [ALC262_FIXUP_HP_Z200] = {
2379                 .type = HDA_FIXUP_PINS,
2380                 .v.pins = (const struct hda_pintbl[]) {
2381                         { 0x16, 0x99130120 }, /* internal speaker */
2382                         { }
2383                 }
2384         },
2385         [ALC262_FIXUP_TYAN] = {
2386                 .type = HDA_FIXUP_PINS,
2387                 .v.pins = (const struct hda_pintbl[]) {
2388                         { 0x14, 0x1993e1f0 }, /* int AUX */
2389                         { }
2390                 }
2391         },
2392         [ALC262_FIXUP_LENOVO_3000] = {
2393                 .type = HDA_FIXUP_PINCTLS,
2394                 .v.pins = (const struct hda_pintbl[]) {
2395                         { 0x19, PIN_VREF50 },
2396                         {}
2397                 },
2398                 .chained = true,
2399                 .chain_id = ALC262_FIXUP_BENQ,
2400         },
2401         [ALC262_FIXUP_BENQ] = {
2402                 .type = HDA_FIXUP_VERBS,
2403                 .v.verbs = (const struct hda_verb[]) {
2404                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x07 },
2405                         { 0x20, AC_VERB_SET_PROC_COEF, 0x3070 },
2406                         {}
2407                 }
2408         },
2409         [ALC262_FIXUP_BENQ_T31] = {
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, 0x3050 },
2414                         {}
2415                 }
2416         },
2417         [ALC262_FIXUP_INV_DMIC] = {
2418                 .type = HDA_FIXUP_FUNC,
2419                 .v.func = alc_fixup_inv_dmic,
2420         },
2421         [ALC262_FIXUP_INTEL_BAYLEYBAY] = {
2422                 .type = HDA_FIXUP_FUNC,
2423                 .v.func = alc_fixup_no_depop_delay,
2424         },
2425 };
2426
2427 static const struct snd_pci_quirk alc262_fixup_tbl[] = {
2428         SND_PCI_QUIRK(0x103c, 0x170b, "HP Z200", ALC262_FIXUP_HP_Z200),
2429         SND_PCI_QUIRK(0x10cf, 0x1397, "Fujitsu Lifebook S7110", ALC262_FIXUP_FSC_S7110),
2430         SND_PCI_QUIRK(0x10cf, 0x142d, "Fujitsu Lifebook E8410", ALC262_FIXUP_BENQ),
2431         SND_PCI_QUIRK(0x10f1, 0x2915, "Tyan Thunder n6650W", ALC262_FIXUP_TYAN),
2432         SND_PCI_QUIRK(0x1734, 0x1147, "FSC Celsius H270", ALC262_FIXUP_FSC_H270),
2433         SND_PCI_QUIRK(0x17aa, 0x384e, "Lenovo 3000", ALC262_FIXUP_LENOVO_3000),
2434         SND_PCI_QUIRK(0x17ff, 0x0560, "Benq ED8", ALC262_FIXUP_BENQ),
2435         SND_PCI_QUIRK(0x17ff, 0x058d, "Benq T31-16", ALC262_FIXUP_BENQ_T31),
2436         SND_PCI_QUIRK(0x8086, 0x7270, "BayleyBay", ALC262_FIXUP_INTEL_BAYLEYBAY),
2437         {}
2438 };
2439
2440 static const struct hda_model_fixup alc262_fixup_models[] = {
2441         {.id = ALC262_FIXUP_INV_DMIC, .name = "inv-dmic"},
2442         {}
2443 };
2444
2445 /*
2446  */
2447 static int patch_alc262(struct hda_codec *codec)
2448 {
2449         struct alc_spec *spec;
2450         int err;
2451
2452         err = alc_alloc_spec(codec, 0x0b);
2453         if (err < 0)
2454                 return err;
2455
2456         spec = codec->spec;
2457         spec->gen.shared_mic_vref_pin = 0x18;
2458
2459         spec->shutup = alc_eapd_shutup;
2460
2461 #if 0
2462         /* pshou 07/11/05  set a zero PCM sample to DAC when FIFO is
2463          * under-run
2464          */
2465         alc_update_coefex_idx(codec, 0x1a, 7, 0, 0x80);
2466 #endif
2467         alc_fix_pll_init(codec, 0x20, 0x0a, 10);
2468
2469         snd_hda_pick_fixup(codec, alc262_fixup_models, alc262_fixup_tbl,
2470                        alc262_fixups);
2471         snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE);
2472
2473         alc_auto_parse_customize_define(codec);
2474
2475         if (has_cdefine_beep(codec))
2476                 spec->gen.beep_nid = 0x01;
2477
2478         /* automatic parse from the BIOS config */
2479         err = alc262_parse_auto_config(codec);
2480         if (err < 0)
2481                 goto error;
2482
2483         if (!spec->gen.no_analog && spec->gen.beep_nid)
2484                 set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
2485
2486         snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE);
2487
2488         return 0;
2489
2490  error:
2491         alc_free(codec);
2492         return err;
2493 }
2494
2495 /*
2496  *  ALC268
2497  */
2498 /* bind Beep switches of both NID 0x0f and 0x10 */
2499 static const struct hda_bind_ctls alc268_bind_beep_sw = {
2500         .ops = &snd_hda_bind_sw,
2501         .values = {
2502                 HDA_COMPOSE_AMP_VAL(0x0f, 3, 1, HDA_INPUT),
2503                 HDA_COMPOSE_AMP_VAL(0x10, 3, 1, HDA_INPUT),
2504                 0
2505         },
2506 };
2507
2508 static const struct snd_kcontrol_new alc268_beep_mixer[] = {
2509         HDA_CODEC_VOLUME("Beep Playback Volume", 0x1d, 0x0, HDA_INPUT),
2510         HDA_BIND_SW("Beep Playback Switch", &alc268_bind_beep_sw),
2511         { }
2512 };
2513
2514 /* set PCBEEP vol = 0, mute connections */
2515 static const struct hda_verb alc268_beep_init_verbs[] = {
2516         {0x1d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
2517         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
2518         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
2519         { }
2520 };
2521
2522 enum {
2523         ALC268_FIXUP_INV_DMIC,
2524         ALC268_FIXUP_HP_EAPD,
2525         ALC268_FIXUP_SPDIF,
2526 };
2527
2528 static const struct hda_fixup alc268_fixups[] = {
2529         [ALC268_FIXUP_INV_DMIC] = {
2530                 .type = HDA_FIXUP_FUNC,
2531                 .v.func = alc_fixup_inv_dmic,
2532         },
2533         [ALC268_FIXUP_HP_EAPD] = {
2534                 .type = HDA_FIXUP_VERBS,
2535                 .v.verbs = (const struct hda_verb[]) {
2536                         {0x15, AC_VERB_SET_EAPD_BTLENABLE, 0},
2537                         {}
2538                 }
2539         },
2540         [ALC268_FIXUP_SPDIF] = {
2541                 .type = HDA_FIXUP_PINS,
2542                 .v.pins = (const struct hda_pintbl[]) {
2543                         { 0x1e, 0x014b1180 }, /* enable SPDIF out */
2544                         {}
2545                 }
2546         },
2547 };
2548
2549 static const struct hda_model_fixup alc268_fixup_models[] = {
2550         {.id = ALC268_FIXUP_INV_DMIC, .name = "inv-dmic"},
2551         {.id = ALC268_FIXUP_HP_EAPD, .name = "hp-eapd"},
2552         {}
2553 };
2554
2555 static const struct snd_pci_quirk alc268_fixup_tbl[] = {
2556         SND_PCI_QUIRK(0x1025, 0x0139, "Acer TravelMate 6293", ALC268_FIXUP_SPDIF),
2557         SND_PCI_QUIRK(0x1025, 0x015b, "Acer AOA 150 (ZG5)", ALC268_FIXUP_INV_DMIC),
2558         /* below is codec SSID since multiple Toshiba laptops have the
2559          * same PCI SSID 1179:ff00
2560          */
2561         SND_PCI_QUIRK(0x1179, 0xff06, "Toshiba P200", ALC268_FIXUP_HP_EAPD),
2562         {}
2563 };
2564
2565 /*
2566  * BIOS auto configuration
2567  */
2568 static int alc268_parse_auto_config(struct hda_codec *codec)
2569 {
2570         static const hda_nid_t alc268_ssids[] = { 0x15, 0x1b, 0x14, 0 };
2571         return alc_parse_auto_config(codec, NULL, alc268_ssids);
2572 }
2573
2574 /*
2575  */
2576 static int patch_alc268(struct hda_codec *codec)
2577 {
2578         struct alc_spec *spec;
2579         int err;
2580
2581         /* ALC268 has no aa-loopback mixer */
2582         err = alc_alloc_spec(codec, 0);
2583         if (err < 0)
2584                 return err;
2585
2586         spec = codec->spec;
2587         spec->gen.beep_nid = 0x01;
2588
2589         spec->shutup = alc_eapd_shutup;
2590
2591         snd_hda_pick_fixup(codec, alc268_fixup_models, alc268_fixup_tbl, alc268_fixups);
2592         snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE);
2593
2594         /* automatic parse from the BIOS config */
2595         err = alc268_parse_auto_config(codec);
2596         if (err < 0)
2597                 goto error;
2598
2599         if (err > 0 && !spec->gen.no_analog &&
2600             spec->gen.autocfg.speaker_pins[0] != 0x1d) {
2601                 add_mixer(spec, alc268_beep_mixer);
2602                 snd_hda_add_verbs(codec, alc268_beep_init_verbs);
2603                 if (!query_amp_caps(codec, 0x1d, HDA_INPUT))
2604                         /* override the amp caps for beep generator */
2605                         snd_hda_override_amp_caps(codec, 0x1d, HDA_INPUT,
2606                                           (0x0c << AC_AMPCAP_OFFSET_SHIFT) |
2607                                           (0x0c << AC_AMPCAP_NUM_STEPS_SHIFT) |
2608                                           (0x07 << AC_AMPCAP_STEP_SIZE_SHIFT) |
2609                                           (0 << AC_AMPCAP_MUTE_SHIFT));
2610         }
2611
2612         snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE);
2613
2614         return 0;
2615
2616  error:
2617         alc_free(codec);
2618         return err;
2619 }
2620
2621 /*
2622  * ALC269
2623  */
2624
2625 static const struct hda_pcm_stream alc269_44k_pcm_analog_playback = {
2626         .rates = SNDRV_PCM_RATE_44100, /* fixed rate */
2627 };
2628
2629 static const struct hda_pcm_stream alc269_44k_pcm_analog_capture = {
2630         .rates = SNDRV_PCM_RATE_44100, /* fixed rate */
2631 };
2632
2633 /* different alc269-variants */
2634 enum {
2635         ALC269_TYPE_ALC269VA,
2636         ALC269_TYPE_ALC269VB,
2637         ALC269_TYPE_ALC269VC,
2638         ALC269_TYPE_ALC269VD,
2639         ALC269_TYPE_ALC280,
2640         ALC269_TYPE_ALC282,
2641         ALC269_TYPE_ALC283,
2642         ALC269_TYPE_ALC284,
2643         ALC269_TYPE_ALC285,
2644         ALC269_TYPE_ALC286,
2645         ALC269_TYPE_ALC298,
2646         ALC269_TYPE_ALC255,
2647         ALC269_TYPE_ALC256,
2648         ALC269_TYPE_ALC225,
2649 };
2650
2651 /*
2652  * BIOS auto configuration
2653  */
2654 static int alc269_parse_auto_config(struct hda_codec *codec)
2655 {
2656         static const hda_nid_t alc269_ignore[] = { 0x1d, 0 };
2657         static const hda_nid_t alc269_ssids[] = { 0, 0x1b, 0x14, 0x21 };
2658         static const hda_nid_t alc269va_ssids[] = { 0x15, 0x1b, 0x14, 0 };
2659         struct alc_spec *spec = codec->spec;
2660         const hda_nid_t *ssids;
2661
2662         switch (spec->codec_variant) {
2663         case ALC269_TYPE_ALC269VA:
2664         case ALC269_TYPE_ALC269VC:
2665         case ALC269_TYPE_ALC280:
2666         case ALC269_TYPE_ALC284:
2667         case ALC269_TYPE_ALC285:
2668                 ssids = alc269va_ssids;
2669                 break;
2670         case ALC269_TYPE_ALC269VB:
2671         case ALC269_TYPE_ALC269VD:
2672         case ALC269_TYPE_ALC282:
2673         case ALC269_TYPE_ALC283:
2674         case ALC269_TYPE_ALC286:
2675         case ALC269_TYPE_ALC298:
2676         case ALC269_TYPE_ALC255:
2677         case ALC269_TYPE_ALC256:
2678         case ALC269_TYPE_ALC225:
2679                 ssids = alc269_ssids;
2680                 break;
2681         default:
2682                 ssids = alc269_ssids;
2683                 break;
2684         }
2685
2686         return alc_parse_auto_config(codec, alc269_ignore, ssids);
2687 }
2688
2689 static int find_ext_mic_pin(struct hda_codec *codec);
2690
2691 static void alc286_shutup(struct hda_codec *codec)
2692 {
2693         int i;
2694         int mic_pin = find_ext_mic_pin(codec);
2695         /* don't shut up pins when unloading the driver; otherwise it breaks
2696          * the default pin setup at the next load of the driver
2697          */
2698         if (codec->bus->shutdown)
2699                 return;
2700         for (i = 0; i < codec->init_pins.used; i++) {
2701                 struct hda_pincfg *pin = snd_array_elem(&codec->init_pins, i);
2702                 /* use read here for syncing after issuing each verb */
2703                 if (pin->nid != mic_pin)
2704                         snd_hda_codec_read(codec, pin->nid, 0,
2705                                         AC_VERB_SET_PIN_WIDGET_CONTROL, 0);
2706         }
2707         codec->pins_shutup = 1;
2708 }
2709
2710 static void alc269vb_toggle_power_output(struct hda_codec *codec, int power_up)
2711 {
2712         alc_update_coef_idx(codec, 0x04, 1 << 11, power_up ? (1 << 11) : 0);
2713 }
2714
2715 static void alc269_shutup(struct hda_codec *codec)
2716 {
2717         struct alc_spec *spec = codec->spec;
2718
2719         if (spec->codec_variant == ALC269_TYPE_ALC269VB)
2720                 alc269vb_toggle_power_output(codec, 0);
2721         if (spec->codec_variant == ALC269_TYPE_ALC269VB &&
2722                         (alc_get_coef0(codec) & 0x00ff) == 0x018) {
2723                 msleep(150);
2724         }
2725         snd_hda_shutup_pins(codec);
2726 }
2727
2728 static struct coef_fw alc282_coefs[] = {
2729         WRITE_COEF(0x03, 0x0002), /* Power Down Control */
2730         UPDATE_COEF(0x05, 0xff3f, 0x0700), /* FIFO and filter clock */
2731         WRITE_COEF(0x07, 0x0200), /* DMIC control */
2732         UPDATE_COEF(0x06, 0x00f0, 0), /* Analog clock */
2733         UPDATE_COEF(0x08, 0xfffc, 0x0c2c), /* JD */
2734         WRITE_COEF(0x0a, 0xcccc), /* JD offset1 */
2735         WRITE_COEF(0x0b, 0xcccc), /* JD offset2 */
2736         WRITE_COEF(0x0e, 0x6e00), /* LDO1/2/3, DAC/ADC */
2737         UPDATE_COEF(0x0f, 0xf800, 0x1000), /* JD */
2738         UPDATE_COEF(0x10, 0xfc00, 0x0c00), /* Capless */
2739         WRITE_COEF(0x6f, 0x0), /* Class D test 4 */
2740         UPDATE_COEF(0x0c, 0xfe00, 0), /* IO power down directly */
2741         WRITE_COEF(0x34, 0xa0c0), /* ANC */
2742         UPDATE_COEF(0x16, 0x0008, 0), /* AGC MUX */
2743         UPDATE_COEF(0x1d, 0x00e0, 0), /* DAC simple content protection */
2744         UPDATE_COEF(0x1f, 0x00e0, 0), /* ADC simple content protection */
2745         WRITE_COEF(0x21, 0x8804), /* DAC ADC Zero Detection */
2746         WRITE_COEF(0x63, 0x2902), /* PLL */
2747         WRITE_COEF(0x68, 0xa080), /* capless control 2 */
2748         WRITE_COEF(0x69, 0x3400), /* capless control 3 */
2749         WRITE_COEF(0x6a, 0x2f3e), /* capless control 4 */
2750         WRITE_COEF(0x6b, 0x0), /* capless control 5 */
2751         UPDATE_COEF(0x6d, 0x0fff, 0x0900), /* class D test 2 */
2752         WRITE_COEF(0x6e, 0x110a), /* class D test 3 */
2753         UPDATE_COEF(0x70, 0x00f8, 0x00d8), /* class D test 5 */
2754         WRITE_COEF(0x71, 0x0014), /* class D test 6 */
2755         WRITE_COEF(0x72, 0xc2ba), /* classD OCP */
2756         UPDATE_COEF(0x77, 0x0f80, 0), /* classD pure DC test */
2757         WRITE_COEF(0x6c, 0xfc06), /* Class D amp control */
2758         {}
2759 };
2760
2761 static void alc282_restore_default_value(struct hda_codec *codec)
2762 {
2763         alc_process_coef_fw(codec, alc282_coefs);
2764 }
2765
2766 static void alc282_init(struct hda_codec *codec)
2767 {
2768         struct alc_spec *spec = codec->spec;
2769         hda_nid_t hp_pin = spec->gen.autocfg.hp_pins[0];
2770         bool hp_pin_sense;
2771         int coef78;
2772
2773         alc282_restore_default_value(codec);
2774
2775         if (!hp_pin)
2776                 return;
2777         hp_pin_sense = snd_hda_jack_detect(codec, hp_pin);
2778         coef78 = alc_read_coef_idx(codec, 0x78);
2779
2780         /* Index 0x78 Direct Drive HP AMP LPM Control 1 */
2781         /* Headphone capless set to high power mode */
2782         alc_write_coef_idx(codec, 0x78, 0x9004);
2783
2784         if (hp_pin_sense)
2785                 msleep(2);
2786
2787         snd_hda_codec_write(codec, hp_pin, 0,
2788                             AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);
2789
2790         if (hp_pin_sense)
2791                 msleep(85);
2792
2793         snd_hda_codec_write(codec, hp_pin, 0,
2794                             AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT);
2795
2796         if (hp_pin_sense)
2797                 msleep(100);
2798
2799         /* Headphone capless set to normal mode */
2800         alc_write_coef_idx(codec, 0x78, coef78);
2801 }
2802
2803 static void alc282_shutup(struct hda_codec *codec)
2804 {
2805         struct alc_spec *spec = codec->spec;
2806         hda_nid_t hp_pin = spec->gen.autocfg.hp_pins[0];
2807         bool hp_pin_sense;
2808         int coef78;
2809
2810         if (!hp_pin) {
2811                 alc269_shutup(codec);
2812                 return;
2813         }
2814
2815         hp_pin_sense = snd_hda_jack_detect(codec, hp_pin);
2816         coef78 = alc_read_coef_idx(codec, 0x78);
2817         alc_write_coef_idx(codec, 0x78, 0x9004);
2818
2819         if (hp_pin_sense)
2820                 msleep(2);
2821
2822         snd_hda_codec_write(codec, hp_pin, 0,
2823                             AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);
2824
2825         if (hp_pin_sense)
2826                 msleep(85);
2827
2828         snd_hda_codec_write(codec, hp_pin, 0,
2829                             AC_VERB_SET_PIN_WIDGET_CONTROL, 0x0);
2830
2831         if (hp_pin_sense)
2832                 msleep(100);
2833
2834         alc_auto_setup_eapd(codec, false);
2835         snd_hda_shutup_pins(codec);
2836         alc_write_coef_idx(codec, 0x78, coef78);
2837 }
2838
2839 static struct coef_fw alc283_coefs[] = {
2840         WRITE_COEF(0x03, 0x0002), /* Power Down Control */
2841         UPDATE_COEF(0x05, 0xff3f, 0x0700), /* FIFO and filter clock */
2842         WRITE_COEF(0x07, 0x0200), /* DMIC control */
2843         UPDATE_COEF(0x06, 0x00f0, 0), /* Analog clock */
2844         UPDATE_COEF(0x08, 0xfffc, 0x0c2c), /* JD */
2845         WRITE_COEF(0x0a, 0xcccc), /* JD offset1 */
2846         WRITE_COEF(0x0b, 0xcccc), /* JD offset2 */
2847         WRITE_COEF(0x0e, 0x6fc0), /* LDO1/2/3, DAC/ADC */
2848         UPDATE_COEF(0x0f, 0xf800, 0x1000), /* JD */
2849         UPDATE_COEF(0x10, 0xfc00, 0x0c00), /* Capless */
2850         WRITE_COEF(0x3a, 0x0), /* Class D test 4 */
2851         UPDATE_COEF(0x0c, 0xfe00, 0x0), /* IO power down directly */
2852         WRITE_COEF(0x22, 0xa0c0), /* ANC */
2853         UPDATE_COEFEX(0x53, 0x01, 0x000f, 0x0008), /* AGC MUX */
2854         UPDATE_COEF(0x1d, 0x00e0, 0), /* DAC simple content protection */
2855         UPDATE_COEF(0x1f, 0x00e0, 0), /* ADC simple content protection */
2856         WRITE_COEF(0x21, 0x8804), /* DAC ADC Zero Detection */
2857         WRITE_COEF(0x2e, 0x2902), /* PLL */
2858         WRITE_COEF(0x33, 0xa080), /* capless control 2 */
2859         WRITE_COEF(0x34, 0x3400), /* capless control 3 */
2860         WRITE_COEF(0x35, 0x2f3e), /* capless control 4 */
2861         WRITE_COEF(0x36, 0x0), /* capless control 5 */
2862         UPDATE_COEF(0x38, 0x0fff, 0x0900), /* class D test 2 */
2863         WRITE_COEF(0x39, 0x110a), /* class D test 3 */
2864         UPDATE_COEF(0x3b, 0x00f8, 0x00d8), /* class D test 5 */
2865         WRITE_COEF(0x3c, 0x0014), /* class D test 6 */
2866         WRITE_COEF(0x3d, 0xc2ba), /* classD OCP */
2867         UPDATE_COEF(0x42, 0x0f80, 0x0), /* classD pure DC test */
2868         WRITE_COEF(0x49, 0x0), /* test mode */
2869         UPDATE_COEF(0x40, 0xf800, 0x9800), /* Class D DC enable */
2870         UPDATE_COEF(0x42, 0xf000, 0x2000), /* DC offset */
2871         WRITE_COEF(0x37, 0xfc06), /* Class D amp control */
2872         UPDATE_COEF(0x1b, 0x8000, 0), /* HP JD control */
2873         {}
2874 };
2875
2876 static void alc283_restore_default_value(struct hda_codec *codec)
2877 {
2878         alc_process_coef_fw(codec, alc283_coefs);
2879 }
2880
2881 static void alc283_init(struct hda_codec *codec)
2882 {
2883         struct alc_spec *spec = codec->spec;
2884         hda_nid_t hp_pin = spec->gen.autocfg.hp_pins[0];
2885         bool hp_pin_sense;
2886
2887         if (!spec->gen.autocfg.hp_outs) {
2888                 if (spec->gen.autocfg.line_out_type == AC_JACK_HP_OUT)
2889                         hp_pin = spec->gen.autocfg.line_out_pins[0];
2890         }
2891
2892         alc283_restore_default_value(codec);
2893
2894         if (!hp_pin)
2895                 return;
2896
2897         msleep(30);
2898         hp_pin_sense = snd_hda_jack_detect(codec, hp_pin);
2899
2900         /* Index 0x43 Direct Drive HP AMP LPM Control 1 */
2901         /* Headphone capless set to high power mode */
2902         alc_write_coef_idx(codec, 0x43, 0x9004);
2903
2904         snd_hda_codec_write(codec, hp_pin, 0,
2905                             AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);
2906
2907         if (hp_pin_sense)
2908                 msleep(85);
2909
2910         snd_hda_codec_write(codec, hp_pin, 0,
2911                             AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT);
2912
2913         if (hp_pin_sense)
2914                 msleep(85);
2915         /* Index 0x46 Combo jack auto switch control 2 */
2916         /* 3k pull low control for Headset jack. */
2917         alc_update_coef_idx(codec, 0x46, 3 << 12, 0);
2918         /* Headphone capless set to normal mode */
2919         alc_write_coef_idx(codec, 0x43, 0x9614);
2920 }
2921
2922 static void alc283_shutup(struct hda_codec *codec)
2923 {
2924         struct alc_spec *spec = codec->spec;
2925         hda_nid_t hp_pin = spec->gen.autocfg.hp_pins[0];
2926         bool hp_pin_sense;
2927
2928         if (!spec->gen.autocfg.hp_outs) {
2929                 if (spec->gen.autocfg.line_out_type == AC_JACK_HP_OUT)
2930                         hp_pin = spec->gen.autocfg.line_out_pins[0];
2931         }
2932
2933         if (!hp_pin) {
2934                 alc269_shutup(codec);
2935                 return;
2936         }
2937
2938         hp_pin_sense = snd_hda_jack_detect(codec, hp_pin);
2939
2940         alc_write_coef_idx(codec, 0x43, 0x9004);
2941
2942         /*depop hp during suspend*/
2943         alc_write_coef_idx(codec, 0x06, 0x2100);
2944
2945         snd_hda_codec_write(codec, hp_pin, 0,
2946                             AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);
2947
2948         if (hp_pin_sense)
2949                 msleep(100);
2950
2951         snd_hda_codec_write(codec, hp_pin, 0,
2952                             AC_VERB_SET_PIN_WIDGET_CONTROL, 0x0);
2953
2954         alc_update_coef_idx(codec, 0x46, 0, 3 << 12);
2955
2956         if (hp_pin_sense)
2957                 msleep(100);
2958         alc_auto_setup_eapd(codec, false);
2959         snd_hda_shutup_pins(codec);
2960         alc_write_coef_idx(codec, 0x43, 0x9614);
2961 }
2962
2963 static void alc5505_coef_set(struct hda_codec *codec, unsigned int index_reg,
2964                              unsigned int val)
2965 {
2966         snd_hda_codec_write(codec, 0x51, 0, AC_VERB_SET_COEF_INDEX, index_reg >> 1);
2967         snd_hda_codec_write(codec, 0x51, 0, AC_VERB_SET_PROC_COEF, val & 0xffff); /* LSB */
2968         snd_hda_codec_write(codec, 0x51, 0, AC_VERB_SET_PROC_COEF, val >> 16); /* MSB */
2969 }
2970
2971 static int alc5505_coef_get(struct hda_codec *codec, unsigned int index_reg)
2972 {
2973         unsigned int val;
2974
2975         snd_hda_codec_write(codec, 0x51, 0, AC_VERB_SET_COEF_INDEX, index_reg >> 1);
2976         val = snd_hda_codec_read(codec, 0x51, 0, AC_VERB_GET_PROC_COEF, 0)
2977                 & 0xffff;
2978         val |= snd_hda_codec_read(codec, 0x51, 0, AC_VERB_GET_PROC_COEF, 0)
2979                 << 16;
2980         return val;
2981 }
2982
2983 static void alc5505_dsp_halt(struct hda_codec *codec)
2984 {
2985         unsigned int val;
2986
2987         alc5505_coef_set(codec, 0x3000, 0x000c); /* DSP CPU stop */
2988         alc5505_coef_set(codec, 0x880c, 0x0008); /* DDR enter self refresh */
2989         alc5505_coef_set(codec, 0x61c0, 0x11110080); /* Clock control for PLL and CPU */
2990         alc5505_coef_set(codec, 0x6230, 0xfc0d4011); /* Disable Input OP */
2991         alc5505_coef_set(codec, 0x61b4, 0x040a2b03); /* Stop PLL2 */
2992         alc5505_coef_set(codec, 0x61b0, 0x00005b17); /* Stop PLL1 */
2993         alc5505_coef_set(codec, 0x61b8, 0x04133303); /* Stop PLL3 */
2994         val = alc5505_coef_get(codec, 0x6220);
2995         alc5505_coef_set(codec, 0x6220, (val | 0x3000)); /* switch Ringbuffer clock to DBUS clock */
2996 }
2997
2998 static void alc5505_dsp_back_from_halt(struct hda_codec *codec)
2999 {
3000         alc5505_coef_set(codec, 0x61b8, 0x04133302);
3001         alc5505_coef_set(codec, 0x61b0, 0x00005b16);
3002         alc5505_coef_set(codec, 0x61b4, 0x040a2b02);
3003         alc5505_coef_set(codec, 0x6230, 0xf80d4011);
3004         alc5505_coef_set(codec, 0x6220, 0x2002010f);
3005         alc5505_coef_set(codec, 0x880c, 0x00000004);
3006 }
3007
3008 static void alc5505_dsp_init(struct hda_codec *codec)
3009 {
3010         unsigned int val;
3011
3012         alc5505_dsp_halt(codec);
3013         alc5505_dsp_back_from_halt(codec);
3014         alc5505_coef_set(codec, 0x61b0, 0x5b14); /* PLL1 control */
3015         alc5505_coef_set(codec, 0x61b0, 0x5b16);
3016         alc5505_coef_set(codec, 0x61b4, 0x04132b00); /* PLL2 control */
3017         alc5505_coef_set(codec, 0x61b4, 0x04132b02);
3018         alc5505_coef_set(codec, 0x61b8, 0x041f3300); /* PLL3 control*/
3019         alc5505_coef_set(codec, 0x61b8, 0x041f3302);
3020         snd_hda_codec_write(codec, 0x51, 0, AC_VERB_SET_CODEC_RESET, 0); /* Function reset */
3021         alc5505_coef_set(codec, 0x61b8, 0x041b3302);
3022         alc5505_coef_set(codec, 0x61b8, 0x04173302);
3023         alc5505_coef_set(codec, 0x61b8, 0x04163302);
3024         alc5505_coef_set(codec, 0x8800, 0x348b328b); /* DRAM control */
3025         alc5505_coef_set(codec, 0x8808, 0x00020022); /* DRAM control */
3026         alc5505_coef_set(codec, 0x8818, 0x00000400); /* DRAM control */
3027
3028         val = alc5505_coef_get(codec, 0x6200) >> 16; /* Read revision ID */
3029         if (val <= 3)
3030                 alc5505_coef_set(codec, 0x6220, 0x2002010f); /* I/O PAD Configuration */
3031         else
3032                 alc5505_coef_set(codec, 0x6220, 0x6002018f);
3033
3034         alc5505_coef_set(codec, 0x61ac, 0x055525f0); /**/
3035         alc5505_coef_set(codec, 0x61c0, 0x12230080); /* Clock control */
3036         alc5505_coef_set(codec, 0x61b4, 0x040e2b02); /* PLL2 control */
3037         alc5505_coef_set(codec, 0x61bc, 0x010234f8); /* OSC Control */
3038         alc5505_coef_set(codec, 0x880c, 0x00000004); /* DRAM Function control */
3039         alc5505_coef_set(codec, 0x880c, 0x00000003);
3040         alc5505_coef_set(codec, 0x880c, 0x00000010);
3041
3042 #ifdef HALT_REALTEK_ALC5505
3043         alc5505_dsp_halt(codec);
3044 #endif
3045 }
3046
3047 #ifdef HALT_REALTEK_ALC5505
3048 #define alc5505_dsp_suspend(codec)      /* NOP */
3049 #define alc5505_dsp_resume(codec)       /* NOP */
3050 #else
3051 #define alc5505_dsp_suspend(codec)      alc5505_dsp_halt(codec)
3052 #define alc5505_dsp_resume(codec)       alc5505_dsp_back_from_halt(codec)
3053 #endif
3054
3055 #ifdef CONFIG_PM
3056 static int alc269_suspend(struct hda_codec *codec)
3057 {
3058         struct alc_spec *spec = codec->spec;
3059
3060         if (spec->has_alc5505_dsp)
3061                 alc5505_dsp_suspend(codec);
3062         return alc_suspend(codec);
3063 }
3064
3065 static int alc269_resume(struct hda_codec *codec)
3066 {
3067         struct alc_spec *spec = codec->spec;
3068
3069         if (spec->codec_variant == ALC269_TYPE_ALC269VB)
3070                 alc269vb_toggle_power_output(codec, 0);
3071         if (spec->codec_variant == ALC269_TYPE_ALC269VB &&
3072                         (alc_get_coef0(codec) & 0x00ff) == 0x018) {
3073                 msleep(150);
3074         }
3075
3076         codec->patch_ops.init(codec);
3077
3078         if (spec->codec_variant == ALC269_TYPE_ALC269VB)
3079                 alc269vb_toggle_power_output(codec, 1);
3080         if (spec->codec_variant == ALC269_TYPE_ALC269VB &&
3081                         (alc_get_coef0(codec) & 0x00ff) == 0x017) {
3082                 msleep(200);
3083         }
3084
3085         regcache_sync(codec->core.regmap);
3086         hda_call_check_power_status(codec, 0x01);
3087
3088         /* on some machine, the BIOS will clear the codec gpio data when enter
3089          * suspend, and won't restore the data after resume, so we restore it
3090          * in the driver.
3091          */
3092         if (spec->gpio_led)
3093                 snd_hda_codec_write(codec, codec->core.afg, 0, AC_VERB_SET_GPIO_DATA,
3094                             spec->gpio_led);
3095
3096         if (spec->has_alc5505_dsp)
3097                 alc5505_dsp_resume(codec);
3098
3099         return 0;
3100 }
3101 #endif /* CONFIG_PM */
3102
3103 static void alc269_fixup_pincfg_no_hp_to_lineout(struct hda_codec *codec,
3104                                                  const struct hda_fixup *fix, int action)
3105 {
3106         struct alc_spec *spec = codec->spec;
3107
3108         if (action == HDA_FIXUP_ACT_PRE_PROBE)
3109                 spec->parse_flags = HDA_PINCFG_NO_HP_FIXUP;
3110 }
3111
3112 static void alc269_fixup_hweq(struct hda_codec *codec,
3113                                const struct hda_fixup *fix, int action)
3114 {
3115         if (action == HDA_FIXUP_ACT_INIT)
3116                 alc_update_coef_idx(codec, 0x1e, 0, 0x80);
3117 }
3118
3119 static void alc269_fixup_headset_mic(struct hda_codec *codec,
3120                                        const struct hda_fixup *fix, int action)
3121 {
3122         struct alc_spec *spec = codec->spec;
3123
3124         if (action == HDA_FIXUP_ACT_PRE_PROBE)
3125                 spec->parse_flags |= HDA_PINCFG_HEADSET_MIC;
3126 }
3127
3128 static void alc271_fixup_dmic(struct hda_codec *codec,
3129                               const struct hda_fixup *fix, int action)
3130 {
3131         static const struct hda_verb verbs[] = {
3132                 {0x20, AC_VERB_SET_COEF_INDEX, 0x0d},
3133                 {0x20, AC_VERB_SET_PROC_COEF, 0x4000},
3134                 {}
3135         };
3136         unsigned int cfg;
3137
3138         if (strcmp(codec->core.chip_name, "ALC271X") &&
3139             strcmp(codec->core.chip_name, "ALC269VB"))
3140                 return;
3141         cfg = snd_hda_codec_get_pincfg(codec, 0x12);
3142         if (get_defcfg_connect(cfg) == AC_JACK_PORT_FIXED)
3143                 snd_hda_sequence_write(codec, verbs);
3144 }
3145
3146 static void alc269_fixup_pcm_44k(struct hda_codec *codec,
3147                                  const struct hda_fixup *fix, int action)
3148 {
3149         struct alc_spec *spec = codec->spec;
3150
3151         if (action != HDA_FIXUP_ACT_PROBE)
3152                 return;
3153
3154         /* Due to a hardware problem on Lenovo Ideadpad, we need to
3155          * fix the sample rate of analog I/O to 44.1kHz
3156          */
3157         spec->gen.stream_analog_playback = &alc269_44k_pcm_analog_playback;
3158         spec->gen.stream_analog_capture = &alc269_44k_pcm_analog_capture;
3159 }
3160
3161 static void alc269_fixup_stereo_dmic(struct hda_codec *codec,
3162                                      const struct hda_fixup *fix, int action)
3163 {
3164         /* The digital-mic unit sends PDM (differential signal) instead of
3165          * the standard PCM, thus you can't record a valid mono stream as is.
3166          * Below is a workaround specific to ALC269 to control the dmic
3167          * signal source as mono.
3168          */
3169         if (action == HDA_FIXUP_ACT_INIT)
3170                 alc_update_coef_idx(codec, 0x07, 0, 0x80);
3171 }
3172
3173 static void alc269_quanta_automute(struct hda_codec *codec)
3174 {
3175         snd_hda_gen_update_outputs(codec);
3176
3177         alc_write_coef_idx(codec, 0x0c, 0x680);
3178         alc_write_coef_idx(codec, 0x0c, 0x480);
3179 }
3180
3181 static void alc269_fixup_quanta_mute(struct hda_codec *codec,
3182                                      const struct hda_fixup *fix, int action)
3183 {
3184         struct alc_spec *spec = codec->spec;
3185         if (action != HDA_FIXUP_ACT_PROBE)
3186                 return;
3187         spec->gen.automute_hook = alc269_quanta_automute;
3188 }
3189
3190 static void alc269_x101_hp_automute_hook(struct hda_codec *codec,
3191                                          struct hda_jack_callback *jack)
3192 {
3193         struct alc_spec *spec = codec->spec;
3194         int vref;
3195         msleep(200);
3196         snd_hda_gen_hp_automute(codec, jack);
3197
3198         vref = spec->gen.hp_jack_present ? PIN_VREF80 : 0;
3199         msleep(100);
3200         snd_hda_codec_write(codec, 0x18, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
3201                             vref);
3202         msleep(500);
3203         snd_hda_codec_write(codec, 0x18, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
3204                             vref);
3205 }
3206
3207 static void alc269_fixup_x101_headset_mic(struct hda_codec *codec,
3208                                      const struct hda_fixup *fix, int action)
3209 {
3210         struct alc_spec *spec = codec->spec;
3211         if (action == HDA_FIXUP_ACT_PRE_PROBE) {
3212                 spec->parse_flags |= HDA_PINCFG_HEADSET_MIC;
3213                 spec->gen.hp_automute_hook = alc269_x101_hp_automute_hook;
3214         }
3215 }
3216
3217
3218 /* update mute-LED according to the speaker mute state via mic VREF pin */
3219 static void alc269_fixup_mic_mute_hook(void *private_data, int enabled)
3220 {
3221         struct hda_codec *codec = private_data;
3222         struct alc_spec *spec = codec->spec;
3223         unsigned int pinval;
3224
3225         if (spec->mute_led_polarity)
3226                 enabled = !enabled;
3227         pinval = snd_hda_codec_get_pin_target(codec, spec->mute_led_nid);
3228         pinval &= ~AC_PINCTL_VREFEN;
3229         pinval |= enabled ? AC_PINCTL_VREF_HIZ : AC_PINCTL_VREF_80;
3230         if (spec->mute_led_nid)
3231                 snd_hda_set_pin_ctl_cache(codec, spec->mute_led_nid, pinval);
3232 }
3233
3234 /* Make sure the led works even in runtime suspend */
3235 static unsigned int led_power_filter(struct hda_codec *codec,
3236                                                   hda_nid_t nid,
3237                                                   unsigned int power_state)
3238 {
3239         struct alc_spec *spec = codec->spec;
3240
3241         if (power_state != AC_PWRST_D3 || nid == 0 ||
3242             (nid != spec->mute_led_nid && nid != spec->cap_mute_led_nid))
3243                 return power_state;
3244
3245         /* Set pin ctl again, it might have just been set to 0 */
3246         snd_hda_set_pin_ctl(codec, nid,
3247                             snd_hda_codec_get_pin_target(codec, nid));
3248
3249         return snd_hda_gen_path_power_filter(codec, nid, power_state);
3250 }
3251
3252 static void alc269_fixup_hp_mute_led(struct hda_codec *codec,
3253                                      const struct hda_fixup *fix, int action)
3254 {
3255         struct alc_spec *spec = codec->spec;
3256         const struct dmi_device *dev = NULL;
3257
3258         if (action != HDA_FIXUP_ACT_PRE_PROBE)
3259                 return;
3260
3261         while ((dev = dmi_find_device(DMI_DEV_TYPE_OEM_STRING, NULL, dev))) {
3262                 int pol, pin;
3263                 if (sscanf(dev->name, "HP_Mute_LED_%d_%x", &pol, &pin) != 2)
3264                         continue;
3265                 if (pin < 0x0a || pin >= 0x10)
3266                         break;
3267                 spec->mute_led_polarity = pol;
3268                 spec->mute_led_nid = pin - 0x0a + 0x18;
3269                 spec->gen.vmaster_mute.hook = alc269_fixup_mic_mute_hook;
3270                 spec->gen.vmaster_mute_enum = 1;
3271                 codec->power_filter = led_power_filter;
3272                 codec_dbg(codec,
3273                           "Detected mute LED for %x:%d\n", spec->mute_led_nid,
3274                            spec->mute_led_polarity);
3275                 break;
3276         }
3277 }
3278
3279 static void alc269_fixup_hp_mute_led_mic1(struct hda_codec *codec,
3280                                 const struct hda_fixup *fix, int action)
3281 {
3282         struct alc_spec *spec = codec->spec;
3283         if (action == HDA_FIXUP_ACT_PRE_PROBE) {
3284                 spec->mute_led_polarity = 0;
3285                 spec->mute_led_nid = 0x18;
3286                 spec->gen.vmaster_mute.hook = alc269_fixup_mic_mute_hook;
3287                 spec->gen.vmaster_mute_enum = 1;
3288                 codec->power_filter = led_power_filter;
3289         }
3290 }
3291
3292 static void alc269_fixup_hp_mute_led_mic2(struct hda_codec *codec,
3293                                 const struct hda_fixup *fix, int action)
3294 {
3295         struct alc_spec *spec = codec->spec;
3296         if (action == HDA_FIXUP_ACT_PRE_PROBE) {
3297                 spec->mute_led_polarity = 0;
3298                 spec->mute_led_nid = 0x19;
3299                 spec->gen.vmaster_mute.hook = alc269_fixup_mic_mute_hook;
3300                 spec->gen.vmaster_mute_enum = 1;
3301                 codec->power_filter = led_power_filter;
3302         }
3303 }
3304
3305 /* update LED status via GPIO */
3306 static void alc_update_gpio_led(struct hda_codec *codec, unsigned int mask,
3307                                 bool enabled)
3308 {
3309         struct alc_spec *spec = codec->spec;
3310         unsigned int oldval = spec->gpio_led;
3311
3312         if (spec->mute_led_polarity)
3313                 enabled = !enabled;
3314
3315         if (enabled)
3316                 spec->gpio_led &= ~mask;
3317         else
3318                 spec->gpio_led |= mask;
3319         if (spec->gpio_led != oldval)
3320                 snd_hda_codec_write(codec, 0x01, 0, AC_VERB_SET_GPIO_DATA,
3321                                     spec->gpio_led);
3322 }
3323
3324 /* turn on/off mute LED via GPIO per vmaster hook */
3325 static void alc_fixup_gpio_mute_hook(void *private_data, int enabled)
3326 {
3327         struct hda_codec *codec = private_data;
3328         struct alc_spec *spec = codec->spec;
3329
3330         alc_update_gpio_led(codec, spec->gpio_mute_led_mask, enabled);
3331 }
3332
3333 /* turn on/off mic-mute LED via GPIO per capture hook */
3334 static void alc_fixup_gpio_mic_mute_hook(struct hda_codec *codec,
3335                                          struct snd_kcontrol *kcontrol,
3336                                          struct snd_ctl_elem_value *ucontrol)
3337 {
3338         struct alc_spec *spec = codec->spec;
3339
3340         if (ucontrol)
3341                 alc_update_gpio_led(codec, spec->gpio_mic_led_mask,
3342                                     ucontrol->value.integer.value[0] ||
3343                                     ucontrol->value.integer.value[1]);
3344 }
3345
3346 static void alc269_fixup_hp_gpio_led(struct hda_codec *codec,
3347                                 const struct hda_fixup *fix, int action)
3348 {
3349         struct alc_spec *spec = codec->spec;
3350         static const struct hda_verb gpio_init[] = {
3351                 { 0x01, AC_VERB_SET_GPIO_MASK, 0x18 },
3352                 { 0x01, AC_VERB_SET_GPIO_DIRECTION, 0x18 },
3353                 {}
3354         };
3355
3356         if (action == HDA_FIXUP_ACT_PRE_PROBE) {
3357                 spec->gen.vmaster_mute.hook = alc_fixup_gpio_mute_hook;
3358                 spec->gen.cap_sync_hook = alc_fixup_gpio_mic_mute_hook;
3359                 spec->gpio_led = 0;
3360                 spec->mute_led_polarity = 0;
3361                 spec->gpio_mute_led_mask = 0x08;
3362                 spec->gpio_mic_led_mask = 0x10;
3363                 snd_hda_add_verbs(codec, gpio_init);
3364         }
3365 }
3366
3367 static void alc286_fixup_hp_gpio_led(struct hda_codec *codec,
3368                                 const struct hda_fixup *fix, int action)
3369 {
3370         struct alc_spec *spec = codec->spec;
3371         static const struct hda_verb gpio_init[] = {
3372                 { 0x01, AC_VERB_SET_GPIO_MASK, 0x22 },
3373                 { 0x01, AC_VERB_SET_GPIO_DIRECTION, 0x22 },
3374                 {}
3375         };
3376
3377         if (action == HDA_FIXUP_ACT_PRE_PROBE) {
3378                 spec->gen.vmaster_mute.hook = alc_fixup_gpio_mute_hook;
3379                 spec->gen.cap_sync_hook = alc_fixup_gpio_mic_mute_hook;
3380                 spec->gpio_led = 0;
3381                 spec->mute_led_polarity = 0;
3382                 spec->gpio_mute_led_mask = 0x02;
3383                 spec->gpio_mic_led_mask = 0x20;
3384                 snd_hda_add_verbs(codec, gpio_init);
3385         }
3386 }
3387
3388 /* turn on/off mic-mute LED per capture hook */
3389 static void alc269_fixup_hp_cap_mic_mute_hook(struct hda_codec *codec,
3390                                                struct snd_kcontrol *kcontrol,
3391                                                struct snd_ctl_elem_value *ucontrol)
3392 {
3393         struct alc_spec *spec = codec->spec;
3394         unsigned int pinval, enable, disable;
3395
3396         pinval = snd_hda_codec_get_pin_target(codec, spec->cap_mute_led_nid);
3397         pinval &= ~AC_PINCTL_VREFEN;
3398         enable  = pinval | AC_PINCTL_VREF_80;
3399         disable = pinval | AC_PINCTL_VREF_HIZ;
3400
3401         if (!ucontrol)
3402                 return;
3403
3404         if (ucontrol->value.integer.value[0] ||
3405             ucontrol->value.integer.value[1])
3406                 pinval = disable;
3407         else
3408                 pinval = enable;
3409
3410         if (spec->cap_mute_led_nid)
3411                 snd_hda_set_pin_ctl_cache(codec, spec->cap_mute_led_nid, pinval);
3412 }
3413
3414 static void alc269_fixup_hp_gpio_mic1_led(struct hda_codec *codec,
3415                                 const struct hda_fixup *fix, int action)
3416 {
3417         struct alc_spec *spec = codec->spec;
3418         static const struct hda_verb gpio_init[] = {
3419                 { 0x01, AC_VERB_SET_GPIO_MASK, 0x08 },
3420                 { 0x01, AC_VERB_SET_GPIO_DIRECTION, 0x08 },
3421                 {}
3422         };
3423
3424         if (action == HDA_FIXUP_ACT_PRE_PROBE) {
3425                 spec->gen.vmaster_mute.hook = alc_fixup_gpio_mute_hook;
3426                 spec->gen.cap_sync_hook = alc269_fixup_hp_cap_mic_mute_hook;
3427                 spec->gpio_led = 0;
3428                 spec->mute_led_polarity = 0;
3429                 spec->gpio_mute_led_mask = 0x08;
3430                 spec->cap_mute_led_nid = 0x18;
3431                 snd_hda_add_verbs(codec, gpio_init);
3432                 codec->power_filter = led_power_filter;
3433         }
3434 }
3435
3436 static void alc280_fixup_hp_gpio4(struct hda_codec *codec,
3437                                    const struct hda_fixup *fix, int action)
3438 {
3439         /* Like hp_gpio_mic1_led, but also needs GPIO4 low to enable headphone amp */
3440         struct alc_spec *spec = codec->spec;
3441         static const struct hda_verb gpio_init[] = {
3442                 { 0x01, AC_VERB_SET_GPIO_MASK, 0x18 },
3443                 { 0x01, AC_VERB_SET_GPIO_DIRECTION, 0x18 },
3444                 {}
3445         };
3446
3447         if (action == HDA_FIXUP_ACT_PRE_PROBE) {
3448                 spec->gen.vmaster_mute.hook = alc_fixup_gpio_mute_hook;
3449                 spec->gen.cap_sync_hook = alc269_fixup_hp_cap_mic_mute_hook;
3450                 spec->gpio_led = 0;
3451                 spec->mute_led_polarity = 0;
3452                 spec->gpio_mute_led_mask = 0x08;
3453                 spec->cap_mute_led_nid = 0x18;
3454                 snd_hda_add_verbs(codec, gpio_init);
3455                 codec->power_filter = led_power_filter;
3456         }
3457 }
3458
3459 static void gpio2_mic_hotkey_event(struct hda_codec *codec,
3460                                    struct hda_jack_callback *event)
3461 {
3462         struct alc_spec *spec = codec->spec;
3463
3464         /* GPIO2 just toggles on a keypress/keyrelease cycle. Therefore
3465            send both key on and key off event for every interrupt. */
3466         input_report_key(spec->kb_dev, spec->alc_mute_keycode_map[ALC_KEY_MICMUTE_INDEX], 1);
3467         input_sync(spec->kb_dev);
3468         input_report_key(spec->kb_dev, spec->alc_mute_keycode_map[ALC_KEY_MICMUTE_INDEX], 0);
3469         input_sync(spec->kb_dev);
3470 }
3471
3472 static int alc_register_micmute_input_device(struct hda_codec *codec)
3473 {
3474         struct alc_spec *spec = codec->spec;
3475         int i;
3476
3477         spec->kb_dev = input_allocate_device();
3478         if (!spec->kb_dev) {
3479                 codec_err(codec, "Out of memory (input_allocate_device)\n");
3480                 return -ENOMEM;
3481         }
3482
3483         spec->alc_mute_keycode_map[ALC_KEY_MICMUTE_INDEX] = KEY_MICMUTE;
3484
3485         spec->kb_dev->name = "Microphone Mute Button";
3486         spec->kb_dev->evbit[0] = BIT_MASK(EV_KEY);
3487         spec->kb_dev->keycodesize = sizeof(spec->alc_mute_keycode_map[0]);
3488         spec->kb_dev->keycodemax = ARRAY_SIZE(spec->alc_mute_keycode_map);
3489         spec->kb_dev->keycode = spec->alc_mute_keycode_map;
3490         for (i = 0; i < ARRAY_SIZE(spec->alc_mute_keycode_map); i++)
3491                 set_bit(spec->alc_mute_keycode_map[i], spec->kb_dev->keybit);
3492
3493         if (input_register_device(spec->kb_dev)) {
3494                 codec_err(codec, "input_register_device failed\n");
3495                 input_free_device(spec->kb_dev);
3496                 spec->kb_dev = NULL;
3497                 return -ENOMEM;
3498         }
3499
3500         return 0;
3501 }
3502
3503 static void alc280_fixup_hp_gpio2_mic_hotkey(struct hda_codec *codec,
3504                                              const struct hda_fixup *fix, int action)
3505 {
3506         /* GPIO1 = set according to SKU external amp
3507            GPIO2 = mic mute hotkey
3508            GPIO3 = mute LED
3509            GPIO4 = mic mute LED */
3510         static const struct hda_verb gpio_init[] = {
3511                 { 0x01, AC_VERB_SET_GPIO_MASK, 0x1e },
3512                 { 0x01, AC_VERB_SET_GPIO_DIRECTION, 0x1a },
3513                 { 0x01, AC_VERB_SET_GPIO_DATA, 0x02 },
3514                 {}
3515         };
3516
3517         struct alc_spec *spec = codec->spec;
3518
3519         if (action == HDA_FIXUP_ACT_PRE_PROBE) {
3520                 if (alc_register_micmute_input_device(codec) != 0)
3521                         return;
3522
3523                 snd_hda_add_verbs(codec, gpio_init);
3524                 snd_hda_codec_write_cache(codec, codec->core.afg, 0,
3525                                           AC_VERB_SET_GPIO_UNSOLICITED_RSP_MASK, 0x04);
3526                 snd_hda_jack_detect_enable_callback(codec, codec->core.afg,
3527                                                     gpio2_mic_hotkey_event);
3528
3529                 spec->gen.vmaster_mute.hook = alc_fixup_gpio_mute_hook;
3530                 spec->gen.cap_sync_hook = alc_fixup_gpio_mic_mute_hook;
3531                 spec->gpio_led = 0;
3532                 spec->mute_led_polarity = 0;
3533                 spec->gpio_mute_led_mask = 0x08;
3534                 spec->gpio_mic_led_mask = 0x10;
3535                 return;
3536         }
3537
3538         if (!spec->kb_dev)
3539                 return;
3540
3541         switch (action) {
3542         case HDA_FIXUP_ACT_PROBE:
3543                 spec->init_amp = ALC_INIT_DEFAULT;
3544                 break;
3545         case HDA_FIXUP_ACT_FREE:
3546                 input_unregister_device(spec->kb_dev);
3547                 spec->kb_dev = NULL;
3548         }
3549 }
3550
3551 static void alc233_fixup_lenovo_line2_mic_hotkey(struct hda_codec *codec,
3552                                              const struct hda_fixup *fix, int action)
3553 {
3554         /* Line2 = mic mute hotkey
3555            GPIO2 = mic mute LED */
3556         static const struct hda_verb gpio_init[] = {
3557                 { 0x01, AC_VERB_SET_GPIO_MASK, 0x04 },
3558                 { 0x01, AC_VERB_SET_GPIO_DIRECTION, 0x04 },
3559                 {}
3560         };
3561
3562         struct alc_spec *spec = codec->spec;
3563
3564         if (action == HDA_FIXUP_ACT_PRE_PROBE) {
3565                 if (alc_register_micmute_input_device(codec) != 0)
3566                         return;
3567
3568                 snd_hda_add_verbs(codec, gpio_init);
3569                 snd_hda_jack_detect_enable_callback(codec, 0x1b,
3570                                                     gpio2_mic_hotkey_event);
3571
3572                 spec->gen.cap_sync_hook = alc_fixup_gpio_mic_mute_hook;
3573                 spec->gpio_led = 0;
3574                 spec->mute_led_polarity = 0;
3575                 spec->gpio_mic_led_mask = 0x04;
3576                 return;
3577         }
3578
3579         if (!spec->kb_dev)
3580                 return;
3581
3582         switch (action) {
3583         case HDA_FIXUP_ACT_PROBE:
3584                 spec->init_amp = ALC_INIT_DEFAULT;
3585                 break;
3586         case HDA_FIXUP_ACT_FREE:
3587                 input_unregister_device(spec->kb_dev);
3588                 spec->kb_dev = NULL;
3589         }
3590 }
3591
3592 static void alc269_fixup_hp_line1_mic1_led(struct hda_codec *codec,
3593                                 const struct hda_fixup *fix, int action)
3594 {
3595         struct alc_spec *spec = codec->spec;
3596
3597         if (action == HDA_FIXUP_ACT_PRE_PROBE) {
3598                 spec->gen.vmaster_mute.hook = alc269_fixup_mic_mute_hook;
3599                 spec->gen.cap_sync_hook = alc269_fixup_hp_cap_mic_mute_hook;
3600                 spec->mute_led_polarity = 0;
3601                 spec->mute_led_nid = 0x1a;
3602                 spec->cap_mute_led_nid = 0x18;
3603                 spec->gen.vmaster_mute_enum = 1;
3604                 codec->power_filter = led_power_filter;
3605         }
3606 }
3607
3608 static void alc_headset_mode_unplugged(struct hda_codec *codec)
3609 {
3610         static struct coef_fw coef0255[] = {
3611                 WRITE_COEF(0x1b, 0x0c0b), /* LDO and MISC control */
3612                 WRITE_COEF(0x45, 0xd089), /* UAJ function set to menual mode */
3613                 UPDATE_COEFEX(0x57, 0x05, 1<<14, 0), /* Direct Drive HP Amp control(Set to verb control)*/
3614                 WRITE_COEF(0x06, 0x6104), /* Set MIC2 Vref gate with HP */
3615                 WRITE_COEFEX(0x57, 0x03, 0x8aa6), /* Direct Drive HP Amp control */
3616                 {}
3617         };
3618         static struct coef_fw coef0233[] = {
3619                 WRITE_COEF(0x1b, 0x0c0b),
3620                 WRITE_COEF(0x45, 0xc429),
3621                 UPDATE_COEF(0x35, 0x4000, 0),
3622                 WRITE_COEF(0x06, 0x2104),
3623                 WRITE_COEF(0x1a, 0x0001),
3624                 WRITE_COEF(0x26, 0x0004),
3625                 WRITE_COEF(0x32, 0x42a3),
3626                 {}
3627         };
3628         static struct coef_fw coef0288[] = {
3629                 UPDATE_COEF(0x4f, 0xfcc0, 0xc400),
3630                 UPDATE_COEF(0x50, 0x2000, 0x2000),
3631                 UPDATE_COEF(0x56, 0x0006, 0x0006),
3632                 UPDATE_COEF(0x66, 0x0008, 0),
3633                 UPDATE_COEF(0x67, 0x2000, 0),
3634                 {}
3635         };
3636         static struct coef_fw coef0292[] = {
3637                 WRITE_COEF(0x76, 0x000e),
3638                 WRITE_COEF(0x6c, 0x2400),
3639                 WRITE_COEF(0x18, 0x7308),
3640                 WRITE_COEF(0x6b, 0xc429),
3641                 {}
3642         };
3643         static struct coef_fw coef0293[] = {
3644                 UPDATE_COEF(0x10, 7<<8, 6<<8), /* SET Line1 JD to 0 */
3645                 UPDATE_COEFEX(0x57, 0x05, 1<<15|1<<13, 0x0), /* SET charge pump by verb */
3646                 UPDATE_COEFEX(0x57, 0x03, 1<<10, 1<<10), /* SET EN_OSW to 1 */
3647                 UPDATE_COEF(0x1a, 1<<3, 1<<3), /* Combo JD gating with LINE1-VREFO */
3648                 WRITE_COEF(0x45, 0xc429), /* Set to TRS type */
3649                 UPDATE_COEF(0x4a, 0x000f, 0x000e), /* Combo Jack auto detect */
3650                 {}
3651         };
3652         static struct coef_fw coef0668[] = {
3653                 WRITE_COEF(0x15, 0x0d40),
3654                 WRITE_COEF(0xb7, 0x802b),
3655                 {}
3656         };
3657         static struct coef_fw coef0225[] = {
3658                 UPDATE_COEF(0x4a, 1<<8, 0),
3659                 UPDATE_COEFEX(0x57, 0x05, 1<<14, 0),
3660                 UPDATE_COEF(0x63, 3<<14, 3<<14),
3661                 UPDATE_COEF(0x4a, 3<<4, 2<<4),
3662                 UPDATE_COEF(0x4a, 3<<10, 3<<10),
3663                 UPDATE_COEF(0x45, 0x3f<<10, 0x34<<10),
3664                 UPDATE_COEF(0x4a, 3<<10, 0),
3665                 {}
3666         };
3667
3668         switch (codec->core.vendor_id) {
3669         case 0x10ec0255:
3670         case 0x10ec0256:
3671                 alc_process_coef_fw(codec, coef0255);
3672                 break;
3673         case 0x10ec0233:
3674         case 0x10ec0283:
3675                 alc_process_coef_fw(codec, coef0233);
3676                 break;
3677         case 0x10ec0286:
3678         case 0x10ec0288:
3679         case 0x10ec0298:
3680                 alc_process_coef_fw(codec, coef0288);
3681                 break;
3682         case 0x10ec0292:
3683                 alc_process_coef_fw(codec, coef0292);
3684                 break;
3685         case 0x10ec0293:
3686                 alc_process_coef_fw(codec, coef0293);
3687                 break;
3688         case 0x10ec0668:
3689                 alc_process_coef_fw(codec, coef0668);
3690                 break;
3691         case 0x10ec0225:
3692                 alc_process_coef_fw(codec, coef0225);
3693                 break;
3694         }
3695         codec_dbg(codec, "Headset jack set to unplugged mode.\n");
3696 }
3697
3698
3699 static void alc_headset_mode_mic_in(struct hda_codec *codec, hda_nid_t hp_pin,
3700                                     hda_nid_t mic_pin)
3701 {
3702         static struct coef_fw coef0255[] = {
3703                 WRITE_COEFEX(0x57, 0x03, 0x8aa6),
3704                 WRITE_COEF(0x06, 0x6100), /* Set MIC2 Vref gate to normal */
3705                 {}
3706         };
3707         static struct coef_fw coef0233[] = {
3708                 UPDATE_COEF(0x35, 0, 1<<14),
3709                 WRITE_COEF(0x06, 0x2100),
3710                 WRITE_COEF(0x1a, 0x0021),
3711                 WRITE_COEF(0x26, 0x008c),
3712                 {}
3713         };
3714         static struct coef_fw coef0288[] = {
3715                 UPDATE_COEF(0x50, 0x2000, 0),
3716                 UPDATE_COEF(0x56, 0x0006, 0),
3717                 UPDATE_COEF(0x4f, 0xfcc0, 0xc400),
3718                 UPDATE_COEF(0x66, 0x0008, 0x0008),
3719                 UPDATE_COEF(0x67, 0x2000, 0x2000),
3720                 {}
3721         };
3722         static struct coef_fw coef0292[] = {
3723                 WRITE_COEF(0x19, 0xa208),
3724                 WRITE_COEF(0x2e, 0xacf0),
3725                 {}
3726         };
3727         static struct coef_fw coef0293[] = {
3728                 UPDATE_COEFEX(0x57, 0x05, 0, 1<<15|1<<13), /* SET charge pump by verb */
3729                 UPDATE_COEFEX(0x57, 0x03, 1<<10, 0), /* SET EN_OSW to 0 */
3730                 UPDATE_COEF(0x1a, 1<<3, 0), /* Combo JD gating without LINE1-VREFO */
3731                 {}
3732         };
3733         static struct coef_fw coef0688[] = {
3734                 WRITE_COEF(0xb7, 0x802b),
3735                 WRITE_COEF(0xb5, 0x1040),
3736                 UPDATE_COEF(0xc3, 0, 1<<12),
3737                 {}
3738         };
3739         static struct coef_fw coef0225[] = {
3740                 UPDATE_COEFEX(0x57, 0x05, 1<<14, 1<<14),
3741                 UPDATE_COEF(0x4a, 3<<4, 2<<4),
3742                 UPDATE_COEF(0x63, 3<<14, 0),
3743                 {}
3744         };
3745
3746
3747         switch (codec->core.vendor_id) {
3748         case 0x10ec0255:
3749         case 0x10ec0256:
3750                 alc_write_coef_idx(codec, 0x45, 0xc489);
3751                 snd_hda_set_pin_ctl_cache(codec, hp_pin, 0);
3752                 alc_process_coef_fw(codec, coef0255);
3753                 snd_hda_set_pin_ctl_cache(codec, mic_pin, PIN_VREF50);
3754                 break;
3755         case 0x10ec0233:
3756         case 0x10ec0283:
3757                 alc_write_coef_idx(codec, 0x45, 0xc429);
3758                 snd_hda_set_pin_ctl_cache(codec, hp_pin, 0);
3759                 alc_process_coef_fw(codec, coef0233);
3760                 snd_hda_set_pin_ctl_cache(codec, mic_pin, PIN_VREF50);
3761                 break;
3762         case 0x10ec0286:
3763         case 0x10ec0288:
3764         case 0x10ec0298:
3765                 alc_update_coef_idx(codec, 0x4f, 0x000c, 0);
3766                 snd_hda_set_pin_ctl_cache(codec, hp_pin, 0);
3767                 alc_process_coef_fw(codec, coef0288);
3768                 snd_hda_set_pin_ctl_cache(codec, mic_pin, PIN_VREF50);
3769                 break;
3770         case 0x10ec0292:
3771                 snd_hda_set_pin_ctl_cache(codec, hp_pin, 0);
3772                 alc_process_coef_fw(codec, coef0292);
3773                 break;
3774         case 0x10ec0293:
3775                 /* Set to TRS mode */
3776                 alc_write_coef_idx(codec, 0x45, 0xc429);
3777                 snd_hda_set_pin_ctl_cache(codec, hp_pin, 0);
3778                 alc_process_coef_fw(codec, coef0293);
3779                 snd_hda_set_pin_ctl_cache(codec, mic_pin, PIN_VREF50);
3780                 break;
3781         case 0x10ec0662:
3782                 snd_hda_set_pin_ctl_cache(codec, hp_pin, 0);
3783                 snd_hda_set_pin_ctl_cache(codec, mic_pin, PIN_VREF50);
3784                 break;
3785         case 0x10ec0668:
3786                 alc_write_coef_idx(codec, 0x11, 0x0001);
3787                 snd_hda_set_pin_ctl_cache(codec, hp_pin, 0);
3788                 alc_process_coef_fw(codec, coef0688);
3789                 snd_hda_set_pin_ctl_cache(codec, mic_pin, PIN_VREF50);
3790                 break;
3791         case 0x10ec0225:
3792                 alc_update_coef_idx(codec, 0x45, 0x3f<<10, 0x31<<10);
3793                 snd_hda_set_pin_ctl_cache(codec, hp_pin, 0);
3794                 alc_process_coef_fw(codec, coef0225);
3795                 snd_hda_set_pin_ctl_cache(codec, mic_pin, PIN_VREF50);
3796                 break;
3797         }
3798         codec_dbg(codec, "Headset jack set to mic-in mode.\n");
3799 }
3800
3801 static void alc_headset_mode_default(struct hda_codec *codec)
3802 {
3803         static struct coef_fw coef0255[] = {
3804                 WRITE_COEF(0x45, 0xc089),
3805                 WRITE_COEF(0x45, 0xc489),
3806                 WRITE_COEFEX(0x57, 0x03, 0x8ea6),
3807                 WRITE_COEF(0x49, 0x0049),
3808                 {}
3809         };
3810         static struct coef_fw coef0233[] = {
3811                 WRITE_COEF(0x06, 0x2100),
3812                 WRITE_COEF(0x32, 0x4ea3),
3813                 {}
3814         };
3815         static struct coef_fw coef0288[] = {
3816                 UPDATE_COEF(0x4f, 0xfcc0, 0xc400), /* Set to TRS type */
3817                 UPDATE_COEF(0x50, 0x2000, 0x2000),
3818                 UPDATE_COEF(0x56, 0x0006, 0x0006),
3819                 UPDATE_COEF(0x66, 0x0008, 0),
3820                 UPDATE_COEF(0x67, 0x2000, 0),
3821                 {}
3822         };
3823         static struct coef_fw coef0292[] = {
3824                 WRITE_COEF(0x76, 0x000e),
3825                 WRITE_COEF(0x6c, 0x2400),
3826                 WRITE_COEF(0x6b, 0xc429),
3827                 WRITE_COEF(0x18, 0x7308),
3828                 {}
3829         };
3830         static struct coef_fw coef0293[] = {
3831                 UPDATE_COEF(0x4a, 0x000f, 0x000e), /* Combo Jack auto detect */
3832                 WRITE_COEF(0x45, 0xC429), /* Set to TRS type */
3833                 UPDATE_COEF(0x1a, 1<<3, 0), /* Combo JD gating without LINE1-VREFO */
3834                 {}
3835         };
3836         static struct coef_fw coef0688[] = {
3837                 WRITE_COEF(0x11, 0x0041),
3838                 WRITE_COEF(0x15, 0x0d40),
3839                 WRITE_COEF(0xb7, 0x802b),
3840                 {}
3841         };
3842
3843         switch (codec->core.vendor_id) {
3844         case 0x10ec0255:
3845         case 0x10ec0256:
3846                 alc_process_coef_fw(codec, coef0255);
3847                 break;
3848         case 0x10ec0233:
3849         case 0x10ec0283:
3850                 alc_process_coef_fw(codec, coef0233);
3851                 break;
3852         case 0x10ec0286:
3853         case 0x10ec0288:
3854         case 0x10ec0298:
3855                 alc_process_coef_fw(codec, coef0288);
3856                 break;
3857         case 0x10ec0292:
3858                 alc_process_coef_fw(codec, coef0292);
3859                 break;
3860         case 0x10ec0293:
3861                 alc_process_coef_fw(codec, coef0293);
3862                 break;
3863         case 0x10ec0668:
3864                 alc_process_coef_fw(codec, coef0688);
3865                 break;
3866         }
3867         codec_dbg(codec, "Headset jack set to headphone (default) mode.\n");
3868 }
3869
3870 /* Iphone type */
3871 static void alc_headset_mode_ctia(struct hda_codec *codec)
3872 {
3873         static struct coef_fw coef0255[] = {
3874                 WRITE_COEF(0x45, 0xd489), /* Set to CTIA type */
3875                 WRITE_COEF(0x1b, 0x0c2b),
3876                 WRITE_COEFEX(0x57, 0x03, 0x8ea6),
3877                 {}
3878         };
3879         static struct coef_fw coef0233[] = {
3880                 WRITE_COEF(0x45, 0xd429),
3881                 WRITE_COEF(0x1b, 0x0c2b),
3882                 WRITE_COEF(0x32, 0x4ea3),
3883                 {}
3884         };
3885         static struct coef_fw coef0288[] = {
3886                 UPDATE_COEF(0x50, 0x2000, 0x2000),
3887                 UPDATE_COEF(0x56, 0x0006, 0x0006),
3888                 UPDATE_COEF(0x66, 0x0008, 0),
3889                 UPDATE_COEF(0x67, 0x2000, 0),
3890                 {}
3891         };
3892         static struct coef_fw coef0292[] = {
3893                 WRITE_COEF(0x6b, 0xd429),
3894                 WRITE_COEF(0x76, 0x0008),
3895                 WRITE_COEF(0x18, 0x7388),
3896                 {}
3897         };
3898         static struct coef_fw coef0293[] = {
3899                 WRITE_COEF(0x45, 0xd429), /* Set to ctia type */
3900                 UPDATE_COEF(0x10, 7<<8, 7<<8), /* SET Line1 JD to 1 */
3901                 {}
3902         };
3903         static struct coef_fw coef0688[] = {
3904                 WRITE_COEF(0x11, 0x0001),
3905                 WRITE_COEF(0x15, 0x0d60),
3906                 WRITE_COEF(0xc3, 0x0000),
3907                 {}
3908         };
3909         static struct coef_fw coef0225[] = {
3910                 UPDATE_COEF(0x45, 0x3f<<10, 0x35<<10),
3911                 UPDATE_COEF(0x49, 1<<8, 1<<8),
3912                 UPDATE_COEF(0x4a, 7<<6, 7<<6),
3913                 UPDATE_COEF(0x4a, 3<<4, 3<<4),
3914                 {}
3915         };
3916
3917         switch (codec->core.vendor_id) {
3918         case 0x10ec0255:
3919         case 0x10ec0256:
3920                 alc_process_coef_fw(codec, coef0255);
3921                 break;
3922         case 0x10ec0233:
3923         case 0x10ec0283:
3924                 alc_process_coef_fw(codec, coef0233);
3925                 break;
3926         case 0x10ec0298:
3927                 alc_update_coef_idx(codec, 0x8e, 0x0070, 0x0020);/* Headset output enable */
3928                 /* ALC298 jack type setting is the same with ALC286/ALC288 */
3929         case 0x10ec0286:
3930         case 0x10ec0288:
3931                 alc_update_coef_idx(codec, 0x4f, 0xfcc0, 0xd400);
3932                 msleep(300);
3933                 alc_process_coef_fw(codec, coef0288);
3934                 break;
3935         case 0x10ec0292:
3936                 alc_process_coef_fw(codec, coef0292);
3937                 break;
3938         case 0x10ec0293:
3939                 alc_process_coef_fw(codec, coef0293);
3940                 break;
3941         case 0x10ec0668:
3942                 alc_process_coef_fw(codec, coef0688);
3943                 break;
3944         case 0x10ec0225:
3945                 alc_process_coef_fw(codec, coef0225);
3946                 break;
3947         }
3948         codec_dbg(codec, "Headset jack set to iPhone-style headset mode.\n");
3949 }
3950
3951 /* Nokia type */
3952 static void alc_headset_mode_omtp(struct hda_codec *codec)
3953 {
3954         static struct coef_fw coef0255[] = {
3955                 WRITE_COEF(0x45, 0xe489), /* Set to OMTP Type */
3956                 WRITE_COEF(0x1b, 0x0c2b),
3957                 WRITE_COEFEX(0x57, 0x03, 0x8ea6),
3958                 {}
3959         };
3960         static struct coef_fw coef0233[] = {
3961                 WRITE_COEF(0x45, 0xe429),
3962                 WRITE_COEF(0x1b, 0x0c2b),
3963                 WRITE_COEF(0x32, 0x4ea3),
3964                 {}
3965         };
3966         static struct coef_fw coef0288[] = {
3967                 UPDATE_COEF(0x50, 0x2000, 0x2000),
3968                 UPDATE_COEF(0x56, 0x0006, 0x0006),
3969                 UPDATE_COEF(0x66, 0x0008, 0),
3970                 UPDATE_COEF(0x67, 0x2000, 0),
3971                 {}
3972         };
3973         static struct coef_fw coef0292[] = {
3974                 WRITE_COEF(0x6b, 0xe429),
3975                 WRITE_COEF(0x76, 0x0008),
3976                 WRITE_COEF(0x18, 0x7388),
3977                 {}
3978         };
3979         static struct coef_fw coef0293[] = {
3980                 WRITE_COEF(0x45, 0xe429), /* Set to omtp type */
3981                 UPDATE_COEF(0x10, 7<<8, 7<<8), /* SET Line1 JD to 1 */
3982                 {}
3983         };
3984         static struct coef_fw coef0688[] = {
3985                 WRITE_COEF(0x11, 0x0001),
3986                 WRITE_COEF(0x15, 0x0d50),
3987                 WRITE_COEF(0xc3, 0x0000),
3988                 {}
3989         };
3990         static struct coef_fw coef0225[] = {
3991                 UPDATE_COEF(0x45, 0x3f<<10, 0x39<<10),
3992                 UPDATE_COEF(0x49, 1<<8, 1<<8),
3993                 UPDATE_COEF(0x4a, 7<<6, 7<<6),
3994                 UPDATE_COEF(0x4a, 3<<4, 3<<4),
3995                 {}
3996         };
3997
3998         switch (codec->core.vendor_id) {
3999         case 0x10ec0255:
4000         case 0x10ec0256:
4001                 alc_process_coef_fw(codec, coef0255);
4002                 break;
4003         case 0x10ec0233:
4004         case 0x10ec0283:
4005                 alc_process_coef_fw(codec, coef0233);
4006                 break;
4007         case 0x10ec0298:
4008                 alc_update_coef_idx(codec, 0x8e, 0x0070, 0x0010);/* Headset output enable */
4009                 /* ALC298 jack type setting is the same with ALC286/ALC288 */
4010         case 0x10ec0286:
4011         case 0x10ec0288:
4012                 alc_update_coef_idx(codec, 0x4f, 0xfcc0, 0xe400);
4013                 msleep(300);
4014                 alc_process_coef_fw(codec, coef0288);
4015                 break;
4016         case 0x10ec0292:
4017                 alc_process_coef_fw(codec, coef0292);
4018                 break;
4019         case 0x10ec0293:
4020                 alc_process_coef_fw(codec, coef0293);
4021                 break;
4022         case 0x10ec0668:
4023                 alc_process_coef_fw(codec, coef0688);
4024                 break;
4025         case 0x10ec0225:
4026                 alc_process_coef_fw(codec, coef0225);
4027                 break;
4028         }
4029         codec_dbg(codec, "Headset jack set to Nokia-style headset mode.\n");
4030 }
4031
4032 static void alc_determine_headset_type(struct hda_codec *codec)
4033 {
4034         int val;
4035         bool is_ctia = false;
4036         struct alc_spec *spec = codec->spec;
4037         static struct coef_fw coef0255[] = {
4038                 WRITE_COEF(0x45, 0xd089), /* combo jack auto switch control(Check type)*/
4039                 WRITE_COEF(0x49, 0x0149), /* combo jack auto switch control(Vref
4040  conteol) */
4041                 {}
4042         };
4043         static struct coef_fw coef0288[] = {
4044                 UPDATE_COEF(0x4f, 0xfcc0, 0xd400), /* Check Type */
4045                 {}
4046         };
4047         static struct coef_fw coef0293[] = {
4048                 UPDATE_COEF(0x4a, 0x000f, 0x0008), /* Combo Jack auto detect */
4049                 WRITE_COEF(0x45, 0xD429), /* Set to ctia type */
4050                 {}
4051         };
4052         static struct coef_fw coef0688[] = {
4053                 WRITE_COEF(0x11, 0x0001),
4054                 WRITE_COEF(0xb7, 0x802b),
4055                 WRITE_COEF(0x15, 0x0d60),
4056                 WRITE_COEF(0xc3, 0x0c00),
4057                 {}
4058         };
4059         static struct coef_fw coef0225[] = {
4060                 UPDATE_COEF(0x45, 0x3f<<10, 0x34<<10),
4061                 UPDATE_COEF(0x49, 1<<8, 1<<8),
4062                 {}
4063         };
4064
4065         switch (codec->core.vendor_id) {
4066         case 0x10ec0255:
4067         case 0x10ec0256:
4068                 alc_process_coef_fw(codec, coef0255);
4069                 msleep(300);
4070                 val = alc_read_coef_idx(codec, 0x46);
4071                 is_ctia = (val & 0x0070) == 0x0070;
4072                 break;
4073         case 0x10ec0233:
4074         case 0x10ec0283:
4075                 alc_write_coef_idx(codec, 0x45, 0xd029);
4076                 msleep(300);
4077                 val = alc_read_coef_idx(codec, 0x46);
4078                 is_ctia = (val & 0x0070) == 0x0070;
4079                 break;
4080         case 0x10ec0298:
4081                 alc_update_coef_idx(codec, 0x8e, 0x0070, 0x0020); /* Headset output enable */
4082                 /* ALC298 check jack type is the same with ALC286/ALC288 */
4083         case 0x10ec0286:
4084         case 0x10ec0288:
4085                 alc_process_coef_fw(codec, coef0288);
4086                 msleep(350);
4087                 val = alc_read_coef_idx(codec, 0x50);
4088                 is_ctia = (val & 0x0070) == 0x0070;
4089                 break;
4090         case 0x10ec0292:
4091                 alc_write_coef_idx(codec, 0x6b, 0xd429);
4092                 msleep(300);
4093                 val = alc_read_coef_idx(codec, 0x6c);
4094                 is_ctia = (val & 0x001c) == 0x001c;
4095                 break;
4096         case 0x10ec0293:
4097                 alc_process_coef_fw(codec, coef0293);
4098                 msleep(300);
4099                 val = alc_read_coef_idx(codec, 0x46);
4100                 is_ctia = (val & 0x0070) == 0x0070;
4101                 break;
4102         case 0x10ec0668:
4103                 alc_process_coef_fw(codec, coef0688);
4104                 msleep(300);
4105                 val = alc_read_coef_idx(codec, 0xbe);
4106                 is_ctia = (val & 0x1c02) == 0x1c02;
4107                 break;
4108         case 0x10ec0225:
4109                 alc_process_coef_fw(codec, coef0225);
4110                 msleep(800);
4111                 val = alc_read_coef_idx(codec, 0x46);
4112                 is_ctia = (val & 0x00f0) == 0x00f0;
4113                 break;
4114         }
4115
4116         codec_dbg(codec, "Headset jack detected iPhone-style headset: %s\n",
4117                     is_ctia ? "yes" : "no");
4118         spec->current_headset_type = is_ctia ? ALC_HEADSET_TYPE_CTIA : ALC_HEADSET_TYPE_OMTP;
4119 }
4120
4121 static void alc_update_headset_mode(struct hda_codec *codec)
4122 {
4123         struct alc_spec *spec = codec->spec;
4124
4125         hda_nid_t mux_pin = spec->gen.imux_pins[spec->gen.cur_mux[0]];
4126         hda_nid_t hp_pin = spec->gen.autocfg.hp_pins[0];
4127
4128         int new_headset_mode;
4129
4130         if (!snd_hda_jack_detect(codec, hp_pin))
4131                 new_headset_mode = ALC_HEADSET_MODE_UNPLUGGED;
4132         else if (mux_pin == spec->headset_mic_pin)
4133                 new_headset_mode = ALC_HEADSET_MODE_HEADSET;
4134         else if (mux_pin == spec->headphone_mic_pin)
4135                 new_headset_mode = ALC_HEADSET_MODE_MIC;
4136         else
4137                 new_headset_mode = ALC_HEADSET_MODE_HEADPHONE;
4138
4139         if (new_headset_mode == spec->current_headset_mode) {
4140                 snd_hda_gen_update_outputs(codec);
4141                 return;
4142         }
4143
4144         switch (new_headset_mode) {
4145         case ALC_HEADSET_MODE_UNPLUGGED:
4146                 alc_headset_mode_unplugged(codec);
4147                 spec->gen.hp_jack_present = false;
4148                 break;
4149         case ALC_HEADSET_MODE_HEADSET:
4150                 if (spec->current_headset_type == ALC_HEADSET_TYPE_UNKNOWN)
4151                         alc_determine_headset_type(codec);
4152                 if (spec->current_headset_type == ALC_HEADSET_TYPE_CTIA)
4153                         alc_headset_mode_ctia(codec);
4154                 else if (spec->current_headset_type == ALC_HEADSET_TYPE_OMTP)
4155                         alc_headset_mode_omtp(codec);
4156                 spec->gen.hp_jack_present = true;
4157                 break;
4158         case ALC_HEADSET_MODE_MIC:
4159                 alc_headset_mode_mic_in(codec, hp_pin, spec->headphone_mic_pin);
4160                 spec->gen.hp_jack_present = false;
4161                 break;
4162         case ALC_HEADSET_MODE_HEADPHONE:
4163                 alc_headset_mode_default(codec);
4164                 spec->gen.hp_jack_present = true;
4165                 break;
4166         }
4167         if (new_headset_mode != ALC_HEADSET_MODE_MIC) {
4168                 snd_hda_set_pin_ctl_cache(codec, hp_pin,
4169                                           AC_PINCTL_OUT_EN | AC_PINCTL_HP_EN);
4170                 if (spec->headphone_mic_pin && spec->headphone_mic_pin != hp_pin)
4171                         snd_hda_set_pin_ctl_cache(codec, spec->headphone_mic_pin,
4172                                                   PIN_VREFHIZ);
4173         }
4174         spec->current_headset_mode = new_headset_mode;
4175
4176         snd_hda_gen_update_outputs(codec);
4177 }
4178
4179 static void alc_update_headset_mode_hook(struct hda_codec *codec,
4180                                          struct snd_kcontrol *kcontrol,
4181                                          struct snd_ctl_elem_value *ucontrol)
4182 {
4183         alc_update_headset_mode(codec);
4184 }
4185
4186 static void alc_update_headset_jack_cb(struct hda_codec *codec,
4187                                        struct hda_jack_callback *jack)
4188 {
4189         struct alc_spec *spec = codec->spec;
4190         spec->current_headset_type = ALC_HEADSET_TYPE_UNKNOWN;
4191         snd_hda_gen_hp_automute(codec, jack);
4192 }
4193
4194 static void alc_probe_headset_mode(struct hda_codec *codec)
4195 {
4196         int i;
4197         struct alc_spec *spec = codec->spec;
4198         struct auto_pin_cfg *cfg = &spec->gen.autocfg;
4199
4200         /* Find mic pins */
4201         for (i = 0; i < cfg->num_inputs; i++) {
4202                 if (cfg->inputs[i].is_headset_mic && !spec->headset_mic_pin)
4203                         spec->headset_mic_pin = cfg->inputs[i].pin;
4204                 if (cfg->inputs[i].is_headphone_mic && !spec->headphone_mic_pin)
4205                         spec->headphone_mic_pin = cfg->inputs[i].pin;
4206         }
4207
4208         spec->gen.cap_sync_hook = alc_update_headset_mode_hook;
4209         spec->gen.automute_hook = alc_update_headset_mode;
4210         spec->gen.hp_automute_hook = alc_update_headset_jack_cb;
4211 }
4212
4213 static void alc_fixup_headset_mode(struct hda_codec *codec,
4214                                 const struct hda_fixup *fix, int action)
4215 {
4216         struct alc_spec *spec = codec->spec;
4217
4218         switch (action) {
4219         case HDA_FIXUP_ACT_PRE_PROBE:
4220                 spec->parse_flags |= HDA_PINCFG_HEADSET_MIC | HDA_PINCFG_HEADPHONE_MIC;
4221                 break;
4222         case HDA_FIXUP_ACT_PROBE:
4223                 alc_probe_headset_mode(codec);
4224                 break;
4225         case HDA_FIXUP_ACT_INIT:
4226                 spec->current_headset_mode = 0;
4227                 alc_update_headset_mode(codec);
4228                 break;
4229         }
4230 }
4231
4232 static void alc_fixup_headset_mode_no_hp_mic(struct hda_codec *codec,
4233                                 const struct hda_fixup *fix, int action)
4234 {
4235         if (action == HDA_FIXUP_ACT_PRE_PROBE) {
4236                 struct alc_spec *spec = codec->spec;
4237                 spec->parse_flags |= HDA_PINCFG_HEADSET_MIC;
4238         }
4239         else
4240                 alc_fixup_headset_mode(codec, fix, action);
4241 }
4242
4243 static void alc255_set_default_jack_type(struct hda_codec *codec)
4244 {
4245         /* Set to iphone type */
4246         static struct coef_fw fw[] = {
4247                 WRITE_COEF(0x1b, 0x880b),
4248                 WRITE_COEF(0x45, 0xd089),
4249                 WRITE_COEF(0x1b, 0x080b),
4250                 WRITE_COEF(0x46, 0x0004),
4251                 WRITE_COEF(0x1b, 0x0c0b),
4252                 {}
4253         };
4254         alc_process_coef_fw(codec, fw);
4255         msleep(30);
4256 }
4257
4258 static void alc_fixup_headset_mode_alc255(struct hda_codec *codec,
4259                                 const struct hda_fixup *fix, int action)
4260 {
4261         if (action == HDA_FIXUP_ACT_PRE_PROBE) {
4262                 alc255_set_default_jack_type(codec);
4263         }
4264         alc_fixup_headset_mode(codec, fix, action);
4265 }
4266
4267 static void alc_fixup_headset_mode_alc255_no_hp_mic(struct hda_codec *codec,
4268                                 const struct hda_fixup *fix, int action)
4269 {
4270         if (action == HDA_FIXUP_ACT_PRE_PROBE) {
4271                 struct alc_spec *spec = codec->spec;
4272                 spec->parse_flags |= HDA_PINCFG_HEADSET_MIC;
4273                 alc255_set_default_jack_type(codec);
4274         }
4275         else
4276                 alc_fixup_headset_mode(codec, fix, action);
4277 }
4278
4279 static void alc288_update_headset_jack_cb(struct hda_codec *codec,
4280                                        struct hda_jack_callback *jack)
4281 {
4282         struct alc_spec *spec = codec->spec;
4283         int present;
4284
4285         alc_update_headset_jack_cb(codec, jack);
4286         /* Headset Mic enable or disable, only for Dell Dino */
4287         present = spec->gen.hp_jack_present ? 0x40 : 0;
4288         snd_hda_codec_write(codec, 0x01, 0, AC_VERB_SET_GPIO_DATA,
4289                                 present);
4290 }
4291
4292 static void alc_fixup_headset_mode_dell_alc288(struct hda_codec *codec,
4293                                 const struct hda_fixup *fix, int action)
4294 {
4295         alc_fixup_headset_mode(codec, fix, action);
4296         if (action == HDA_FIXUP_ACT_PROBE) {
4297                 struct alc_spec *spec = codec->spec;
4298                 spec->gen.hp_automute_hook = alc288_update_headset_jack_cb;
4299         }
4300 }
4301
4302 static void alc_fixup_auto_mute_via_amp(struct hda_codec *codec,
4303                                         const struct hda_fixup *fix, int action)
4304 {
4305         if (action == HDA_FIXUP_ACT_PRE_PROBE) {
4306                 struct alc_spec *spec = codec->spec;
4307                 spec->gen.auto_mute_via_amp = 1;
4308         }
4309 }
4310
4311 static void alc_no_shutup(struct hda_codec *codec)
4312 {
4313 }
4314
4315 static void alc_fixup_no_shutup(struct hda_codec *codec,
4316                                 const struct hda_fixup *fix, int action)
4317 {
4318         if (action == HDA_FIXUP_ACT_PRE_PROBE) {
4319                 struct alc_spec *spec = codec->spec;
4320                 spec->shutup = alc_no_shutup;
4321         }
4322 }
4323
4324 static void alc_fixup_disable_aamix(struct hda_codec *codec,
4325                                     const struct hda_fixup *fix, int action)
4326 {
4327         if (action == HDA_FIXUP_ACT_PRE_PROBE) {
4328                 struct alc_spec *spec = codec->spec;
4329                 /* Disable AA-loopback as it causes white noise */
4330                 spec->gen.mixer_nid = 0;
4331         }
4332 }
4333
4334 /* fixup for Thinkpad docks: add dock pins, avoid HP parser fixup */
4335 static void alc_fixup_tpt440_dock(struct hda_codec *codec,
4336                                   const struct hda_fixup *fix, int action)
4337 {
4338         static const struct hda_pintbl pincfgs[] = {
4339                 { 0x16, 0x21211010 }, /* dock headphone */
4340                 { 0x19, 0x21a11010 }, /* dock mic */
4341                 { }
4342         };
4343         struct alc_spec *spec = codec->spec;
4344
4345         if (action == HDA_FIXUP_ACT_PRE_PROBE) {
4346                 spec->shutup = alc_no_shutup; /* reduce click noise */
4347                 spec->reboot_notify = alc_d3_at_reboot; /* reduce noise */
4348                 spec->parse_flags = HDA_PINCFG_NO_HP_FIXUP;
4349                 codec->power_save_node = 0; /* avoid click noises */
4350                 snd_hda_apply_pincfgs(codec, pincfgs);
4351         }
4352 }
4353
4354 static void alc_shutup_dell_xps13(struct hda_codec *codec)
4355 {
4356         struct alc_spec *spec = codec->spec;
4357         int hp_pin = spec->gen.autocfg.hp_pins[0];
4358
4359         /* Prevent pop noises when headphones are plugged in */
4360         snd_hda_codec_write(codec, hp_pin, 0,
4361                             AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);
4362         msleep(20);
4363 }
4364
4365 static void alc_fixup_dell_xps13(struct hda_codec *codec,
4366                                 const struct hda_fixup *fix, int action)
4367 {
4368         struct alc_spec *spec = codec->spec;
4369         struct hda_input_mux *imux = &spec->gen.input_mux;
4370         int i;
4371
4372         switch (action) {
4373         case HDA_FIXUP_ACT_PRE_PROBE:
4374                 /* mic pin 0x19 must be initialized with Vref Hi-Z, otherwise
4375                  * it causes a click noise at start up
4376                  */
4377                 snd_hda_codec_set_pin_target(codec, 0x19, PIN_VREFHIZ);
4378                 break;
4379         case HDA_FIXUP_ACT_PROBE:
4380                 spec->shutup = alc_shutup_dell_xps13;
4381
4382                 /* Make the internal mic the default input source. */
4383                 for (i = 0; i < imux->num_items; i++) {
4384                         if (spec->gen.imux_pins[i] == 0x12) {
4385                                 spec->gen.cur_mux[0] = i;
4386                                 break;
4387                         }
4388                 }
4389                 break;
4390         }
4391 }
4392
4393 static void alc_fixup_headset_mode_alc662(struct hda_codec *codec,
4394                                 const struct hda_fixup *fix, int action)
4395 {
4396         struct alc_spec *spec = codec->spec;
4397
4398         if (action == HDA_FIXUP_ACT_PRE_PROBE) {
4399                 spec->parse_flags |= HDA_PINCFG_HEADSET_MIC;
4400                 spec->gen.hp_mic = 1; /* Mic-in is same pin as headphone */
4401
4402                 /* Disable boost for mic-in permanently. (This code is only called
4403                    from quirks that guarantee that the headphone is at NID 0x1b.) */
4404                 snd_hda_codec_write(codec, 0x1b, 0, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000);
4405                 snd_hda_override_wcaps(codec, 0x1b, get_wcaps(codec, 0x1b) & ~AC_WCAP_IN_AMP);
4406         } else
4407                 alc_fixup_headset_mode(codec, fix, action);
4408 }
4409
4410 static void alc_fixup_headset_mode_alc668(struct hda_codec *codec,
4411                                 const struct hda_fixup *fix, int action)
4412 {
4413         if (action == HDA_FIXUP_ACT_PRE_PROBE) {
4414                 alc_write_coef_idx(codec, 0xc4, 0x8000);
4415                 alc_update_coef_idx(codec, 0xc2, ~0xfe, 0);
4416                 snd_hda_set_pin_ctl_cache(codec, 0x18, 0);
4417         }
4418         alc_fixup_headset_mode(codec, fix, action);
4419 }
4420
4421 /* Returns the nid of the external mic input pin, or 0 if it cannot be found. */
4422 static int find_ext_mic_pin(struct hda_codec *codec)
4423 {
4424         struct alc_spec *spec = codec->spec;
4425         struct auto_pin_cfg *cfg = &spec->gen.autocfg;
4426         hda_nid_t nid;
4427         unsigned int defcfg;
4428         int i;
4429
4430         for (i = 0; i < cfg->num_inputs; i++) {
4431                 if (cfg->inputs[i].type != AUTO_PIN_MIC)
4432                         continue;
4433                 nid = cfg->inputs[i].pin;
4434                 defcfg = snd_hda_codec_get_pincfg(codec, nid);
4435                 if (snd_hda_get_input_pin_attr(defcfg) == INPUT_PIN_ATTR_INT)
4436                         continue;
4437                 return nid;
4438         }
4439
4440         return 0;
4441 }
4442
4443 static void alc271_hp_gate_mic_jack(struct hda_codec *codec,
4444                                     const struct hda_fixup *fix,
4445                                     int action)
4446 {
4447         struct alc_spec *spec = codec->spec;
4448
4449         if (action == HDA_FIXUP_ACT_PROBE) {
4450                 int mic_pin = find_ext_mic_pin(codec);
4451                 int hp_pin = spec->gen.autocfg.hp_pins[0];
4452
4453                 if (snd_BUG_ON(!mic_pin || !hp_pin))
4454                         return;
4455                 snd_hda_jack_set_gating_jack(codec, mic_pin, hp_pin);
4456         }
4457 }
4458
4459 static void alc269_fixup_limit_int_mic_boost(struct hda_codec *codec,
4460                                              const struct hda_fixup *fix,
4461                                              int action)
4462 {
4463         struct alc_spec *spec = codec->spec;
4464         struct auto_pin_cfg *cfg = &spec->gen.autocfg;
4465         int i;
4466
4467         /* The mic boosts on level 2 and 3 are too noisy
4468            on the internal mic input.
4469            Therefore limit the boost to 0 or 1. */
4470
4471         if (action != HDA_FIXUP_ACT_PROBE)
4472                 return;
4473
4474         for (i = 0; i < cfg->num_inputs; i++) {
4475                 hda_nid_t nid = cfg->inputs[i].pin;
4476                 unsigned int defcfg;
4477                 if (cfg->inputs[i].type != AUTO_PIN_MIC)
4478                         continue;
4479                 defcfg = snd_hda_codec_get_pincfg(codec, nid);
4480                 if (snd_hda_get_input_pin_attr(defcfg) != INPUT_PIN_ATTR_INT)
4481                         continue;
4482
4483                 snd_hda_override_amp_caps(codec, nid, HDA_INPUT,
4484                                           (0x00 << AC_AMPCAP_OFFSET_SHIFT) |
4485                                           (0x01 << AC_AMPCAP_NUM_STEPS_SHIFT) |
4486                                           (0x2f << AC_AMPCAP_STEP_SIZE_SHIFT) |
4487                                           (0 << AC_AMPCAP_MUTE_SHIFT));
4488         }
4489 }
4490
4491 static void alc283_hp_automute_hook(struct hda_codec *codec,
4492                                     struct hda_jack_callback *jack)
4493 {
4494         struct alc_spec *spec = codec->spec;
4495         int vref;
4496
4497         msleep(200);
4498         snd_hda_gen_hp_automute(codec, jack);
4499
4500         vref = spec->gen.hp_jack_present ? PIN_VREF80 : 0;
4501
4502         msleep(600);
4503         snd_hda_codec_write(codec, 0x19, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
4504                             vref);
4505 }
4506
4507 static void alc283_fixup_chromebook(struct hda_codec *codec,
4508                                     const struct hda_fixup *fix, int action)
4509 {
4510         struct alc_spec *spec = codec->spec;
4511
4512         switch (action) {
4513         case HDA_FIXUP_ACT_PRE_PROBE:
4514                 snd_hda_override_wcaps(codec, 0x03, 0);
4515                 /* Disable AA-loopback as it causes white noise */
4516                 spec->gen.mixer_nid = 0;
4517                 break;
4518         case HDA_FIXUP_ACT_INIT:
4519                 /* MIC2-VREF control */
4520                 /* Set to manual mode */
4521                 alc_update_coef_idx(codec, 0x06, 0x000c, 0);
4522                 /* Enable Line1 input control by verb */
4523                 alc_update_coef_idx(codec, 0x1a, 0, 1 << 4);
4524                 break;
4525         }
4526 }
4527
4528 static void alc283_fixup_sense_combo_jack(struct hda_codec *codec,
4529                                     const struct hda_fixup *fix, int action)
4530 {
4531         struct alc_spec *spec = codec->spec;
4532
4533         switch (action) {
4534         case HDA_FIXUP_ACT_PRE_PROBE:
4535                 spec->gen.hp_automute_hook = alc283_hp_automute_hook;
4536                 break;
4537         case HDA_FIXUP_ACT_INIT:
4538                 /* MIC2-VREF control */
4539                 /* Set to manual mode */
4540                 alc_update_coef_idx(codec, 0x06, 0x000c, 0);
4541                 break;
4542         }
4543 }
4544
4545 /* mute tablet speaker pin (0x14) via dock plugging in addition */
4546 static void asus_tx300_automute(struct hda_codec *codec)
4547 {
4548         struct alc_spec *spec = codec->spec;
4549         snd_hda_gen_update_outputs(codec);
4550         if (snd_hda_jack_detect(codec, 0x1b))
4551                 spec->gen.mute_bits |= (1ULL << 0x14);
4552 }
4553
4554 static void alc282_fixup_asus_tx300(struct hda_codec *codec,
4555                                     const struct hda_fixup *fix, int action)
4556 {
4557         struct alc_spec *spec = codec->spec;
4558         /* TX300 needs to set up GPIO2 for the speaker amp */
4559         static const struct hda_verb gpio2_verbs[] = {
4560                 { 0x01, AC_VERB_SET_GPIO_MASK, 0x04 },
4561                 { 0x01, AC_VERB_SET_GPIO_DIRECTION, 0x04 },
4562                 { 0x01, AC_VERB_SET_GPIO_DATA, 0x04 },
4563                 {}
4564         };
4565         static const struct hda_pintbl dock_pins[] = {
4566                 { 0x1b, 0x21114000 }, /* dock speaker pin */
4567                 {}
4568         };
4569         struct snd_kcontrol *kctl;
4570
4571         switch (action) {
4572         case HDA_FIXUP_ACT_PRE_PROBE:
4573                 snd_hda_add_verbs(codec, gpio2_verbs);
4574                 snd_hda_apply_pincfgs(codec, dock_pins);
4575                 spec->gen.auto_mute_via_amp = 1;
4576                 spec->gen.automute_hook = asus_tx300_automute;
4577                 snd_hda_jack_detect_enable_callback(codec, 0x1b,
4578                                                     snd_hda_gen_hp_automute);
4579                 break;
4580         case HDA_FIXUP_ACT_BUILD:
4581                 /* this is a bit tricky; give more sane names for the main
4582                  * (tablet) speaker and the dock speaker, respectively
4583                  */
4584                 kctl = snd_hda_find_mixer_ctl(codec, "Speaker Playback Switch");
4585                 if (kctl)
4586                         strcpy(kctl->id.name, "Dock Speaker Playback Switch");
4587                 kctl = snd_hda_find_mixer_ctl(codec, "Bass Speaker Playback Switch");
4588                 if (kctl)
4589                         strcpy(kctl->id.name, "Speaker Playback Switch");
4590                 break;
4591         }
4592 }
4593
4594 static void alc290_fixup_mono_speakers(struct hda_codec *codec,
4595                                        const struct hda_fixup *fix, int action)
4596 {
4597         if (action == HDA_FIXUP_ACT_PRE_PROBE) {
4598                 /* DAC node 0x03 is giving mono output. We therefore want to
4599                    make sure 0x14 (front speaker) and 0x15 (headphones) use the
4600                    stereo DAC, while leaving 0x17 (bass speaker) for node 0x03. */
4601                 hda_nid_t conn1[2] = { 0x0c };
4602                 snd_hda_override_conn_list(codec, 0x14, 1, conn1);
4603                 snd_hda_override_conn_list(codec, 0x15, 1, conn1);
4604         }
4605 }
4606
4607 /* Hook to update amp GPIO4 for automute */
4608 static void alc280_hp_gpio4_automute_hook(struct hda_codec *codec,
4609                                           struct hda_jack_callback *jack)
4610 {
4611         struct alc_spec *spec = codec->spec;
4612
4613         snd_hda_gen_hp_automute(codec, jack);
4614         /* mute_led_polarity is set to 0, so we pass inverted value here */
4615         alc_update_gpio_led(codec, 0x10, !spec->gen.hp_jack_present);
4616 }
4617
4618 /* Manage GPIOs for HP EliteBook Folio 9480m.
4619  *
4620  * GPIO4 is the headphone amplifier power control
4621  * GPIO3 is the audio output mute indicator LED
4622  */
4623
4624 static void alc280_fixup_hp_9480m(struct hda_codec *codec,
4625                                   const struct hda_fixup *fix,
4626                                   int action)
4627 {
4628         struct alc_spec *spec = codec->spec;
4629         static const struct hda_verb gpio_init[] = {
4630                 { 0x01, AC_VERB_SET_GPIO_MASK, 0x18 },
4631                 { 0x01, AC_VERB_SET_GPIO_DIRECTION, 0x18 },
4632                 {}
4633         };
4634
4635         if (action == HDA_FIXUP_ACT_PRE_PROBE) {
4636                 /* Set the hooks to turn the headphone amp on/off
4637                  * as needed
4638                  */
4639                 spec->gen.vmaster_mute.hook = alc_fixup_gpio_mute_hook;
4640                 spec->gen.hp_automute_hook = alc280_hp_gpio4_automute_hook;
4641
4642                 /* The GPIOs are currently off */
4643                 spec->gpio_led = 0;
4644
4645                 /* GPIO3 is connected to the output mute LED,
4646                  * high is on, low is off
4647                  */
4648                 spec->mute_led_polarity = 0;
4649                 spec->gpio_mute_led_mask = 0x08;
4650
4651                 /* Initialize GPIO configuration */
4652                 snd_hda_add_verbs(codec, gpio_init);
4653         }
4654 }
4655
4656 /* for hda_fixup_thinkpad_acpi() */
4657 #include "thinkpad_helper.c"
4658
4659 /* for dell wmi mic mute led */
4660 #include "dell_wmi_helper.c"
4661
4662 enum {
4663         ALC269_FIXUP_SONY_VAIO,
4664         ALC275_FIXUP_SONY_VAIO_GPIO2,
4665         ALC269_FIXUP_DELL_M101Z,
4666         ALC269_FIXUP_SKU_IGNORE,
4667         ALC269_FIXUP_ASUS_G73JW,
4668         ALC269_FIXUP_LENOVO_EAPD,
4669         ALC275_FIXUP_SONY_HWEQ,
4670         ALC275_FIXUP_SONY_DISABLE_AAMIX,
4671         ALC271_FIXUP_DMIC,
4672         ALC269_FIXUP_PCM_44K,
4673         ALC269_FIXUP_STEREO_DMIC,
4674         ALC269_FIXUP_HEADSET_MIC,
4675         ALC269_FIXUP_QUANTA_MUTE,
4676         ALC269_FIXUP_LIFEBOOK,
4677         ALC269_FIXUP_LIFEBOOK_EXTMIC,
4678         ALC269_FIXUP_LIFEBOOK_HP_PIN,
4679         ALC269_FIXUP_LIFEBOOK_NO_HP_TO_LINEOUT,
4680         ALC269_FIXUP_AMIC,
4681         ALC269_FIXUP_DMIC,
4682         ALC269VB_FIXUP_AMIC,
4683         ALC269VB_FIXUP_DMIC,
4684         ALC269_FIXUP_HP_MUTE_LED,
4685         ALC269_FIXUP_HP_MUTE_LED_MIC1,
4686         ALC269_FIXUP_HP_MUTE_LED_MIC2,
4687         ALC269_FIXUP_HP_GPIO_LED,
4688         ALC269_FIXUP_HP_GPIO_MIC1_LED,
4689         ALC269_FIXUP_HP_LINE1_MIC1_LED,
4690         ALC269_FIXUP_INV_DMIC,
4691         ALC269_FIXUP_LENOVO_DOCK,
4692         ALC269_FIXUP_NO_SHUTUP,
4693         ALC286_FIXUP_SONY_MIC_NO_PRESENCE,
4694         ALC269_FIXUP_PINCFG_NO_HP_TO_LINEOUT,
4695         ALC269_FIXUP_DELL1_MIC_NO_PRESENCE,
4696         ALC269_FIXUP_DELL2_MIC_NO_PRESENCE,
4697         ALC269_FIXUP_DELL3_MIC_NO_PRESENCE,
4698         ALC269_FIXUP_HEADSET_MODE,
4699         ALC269_FIXUP_HEADSET_MODE_NO_HP_MIC,
4700         ALC269_FIXUP_ASPIRE_HEADSET_MIC,
4701         ALC269_FIXUP_ASUS_X101_FUNC,
4702         ALC269_FIXUP_ASUS_X101_VERB,
4703         ALC269_FIXUP_ASUS_X101,
4704         ALC271_FIXUP_AMIC_MIC2,
4705         ALC271_FIXUP_HP_GATE_MIC_JACK,
4706         ALC271_FIXUP_HP_GATE_MIC_JACK_E1_572,
4707         ALC269_FIXUP_ACER_AC700,
4708         ALC269_FIXUP_LIMIT_INT_MIC_BOOST,
4709         ALC269VB_FIXUP_ASUS_ZENBOOK,
4710         ALC269VB_FIXUP_ASUS_ZENBOOK_UX31A,
4711         ALC269_FIXUP_LIMIT_INT_MIC_BOOST_MUTE_LED,
4712         ALC269VB_FIXUP_ORDISSIMO_EVE2,
4713         ALC283_FIXUP_CHROME_BOOK,
4714         ALC283_FIXUP_SENSE_COMBO_JACK,
4715         ALC282_FIXUP_ASUS_TX300,
4716         ALC283_FIXUP_INT_MIC,
4717         ALC290_FIXUP_MONO_SPEAKERS,
4718         ALC290_FIXUP_MONO_SPEAKERS_HSJACK,
4719         ALC290_FIXUP_SUBWOOFER,
4720         ALC290_FIXUP_SUBWOOFER_HSJACK,
4721         ALC269_FIXUP_THINKPAD_ACPI,
4722         ALC269_FIXUP_DMIC_THINKPAD_ACPI,
4723         ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
4724         ALC255_FIXUP_DELL2_MIC_NO_PRESENCE,
4725         ALC255_FIXUP_HEADSET_MODE,
4726         ALC255_FIXUP_HEADSET_MODE_NO_HP_MIC,
4727         ALC293_FIXUP_DELL1_MIC_NO_PRESENCE,
4728         ALC292_FIXUP_TPT440_DOCK,
4729         ALC292_FIXUP_TPT440,
4730         ALC283_FIXUP_BXBT2807_MIC,
4731         ALC255_FIXUP_DELL_WMI_MIC_MUTE_LED,
4732         ALC282_FIXUP_ASPIRE_V5_PINS,
4733         ALC280_FIXUP_HP_GPIO4,
4734         ALC286_FIXUP_HP_GPIO_LED,
4735         ALC280_FIXUP_HP_GPIO2_MIC_HOTKEY,
4736         ALC280_FIXUP_HP_DOCK_PINS,
4737         ALC280_FIXUP_HP_9480M,
4738         ALC288_FIXUP_DELL_HEADSET_MODE,
4739         ALC288_FIXUP_DELL1_MIC_NO_PRESENCE,
4740         ALC288_FIXUP_DELL_XPS_13_GPIO6,
4741         ALC288_FIXUP_DELL_XPS_13,
4742         ALC288_FIXUP_DISABLE_AAMIX,
4743         ALC292_FIXUP_DELL_E7X,
4744         ALC292_FIXUP_DISABLE_AAMIX,
4745         ALC293_FIXUP_DISABLE_AAMIX_MULTIJACK,
4746         ALC298_FIXUP_DELL1_MIC_NO_PRESENCE,
4747         ALC275_FIXUP_DELL_XPS,
4748         ALC256_FIXUP_DELL_XPS_13_HEADPHONE_NOISE,
4749         ALC293_FIXUP_LENOVO_SPK_NOISE,
4750         ALC233_FIXUP_LENOVO_LINE2_MIC_HOTKEY,
4751 };
4752
4753 static const struct hda_fixup alc269_fixups[] = {
4754         [ALC269_FIXUP_SONY_VAIO] = {
4755                 .type = HDA_FIXUP_PINCTLS,
4756                 .v.pins = (const struct hda_pintbl[]) {
4757                         {0x19, PIN_VREFGRD},
4758                         {}
4759                 }
4760         },
4761         [ALC275_FIXUP_SONY_VAIO_GPIO2] = {
4762                 .type = HDA_FIXUP_VERBS,
4763                 .v.verbs = (const struct hda_verb[]) {
4764                         {0x01, AC_VERB_SET_GPIO_MASK, 0x04},
4765                         {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x04},
4766                         {0x01, AC_VERB_SET_GPIO_DATA, 0x00},
4767                         { }
4768                 },
4769                 .chained = true,
4770                 .chain_id = ALC269_FIXUP_SONY_VAIO
4771         },
4772         [ALC269_FIXUP_DELL_M101Z] = {
4773                 .type = HDA_FIXUP_VERBS,
4774                 .v.verbs = (const struct hda_verb[]) {
4775                         /* Enables internal speaker */
4776                         {0x20, AC_VERB_SET_COEF_INDEX, 13},
4777                         {0x20, AC_VERB_SET_PROC_COEF, 0x4040},
4778                         {}
4779                 }
4780         },
4781         [ALC269_FIXUP_SKU_IGNORE] = {
4782                 .type = HDA_FIXUP_FUNC,
4783                 .v.func = alc_fixup_sku_ignore,
4784         },
4785         [ALC269_FIXUP_ASUS_G73JW] = {
4786                 .type = HDA_FIXUP_PINS,
4787                 .v.pins = (const struct hda_pintbl[]) {
4788                         { 0x17, 0x99130111 }, /* subwoofer */
4789                         { }
4790                 }
4791         },
4792         [ALC269_FIXUP_LENOVO_EAPD] = {
4793                 .type = HDA_FIXUP_VERBS,
4794                 .v.verbs = (const struct hda_verb[]) {
4795                         {0x14, AC_VERB_SET_EAPD_BTLENABLE, 0},
4796                         {}
4797                 }
4798         },
4799         [ALC275_FIXUP_SONY_HWEQ] = {
4800                 .type = HDA_FIXUP_FUNC,
4801                 .v.func = alc269_fixup_hweq,
4802                 .chained = true,
4803                 .chain_id = ALC275_FIXUP_SONY_VAIO_GPIO2
4804         },
4805         [ALC275_FIXUP_SONY_DISABLE_AAMIX] = {
4806                 .type = HDA_FIXUP_FUNC,
4807                 .v.func = alc_fixup_disable_aamix,
4808                 .chained = true,
4809                 .chain_id = ALC269_FIXUP_SONY_VAIO
4810         },
4811         [ALC271_FIXUP_DMIC] = {
4812                 .type = HDA_FIXUP_FUNC,
4813                 .v.func = alc271_fixup_dmic,
4814         },
4815         [ALC269_FIXUP_PCM_44K] = {
4816                 .type = HDA_FIXUP_FUNC,
4817                 .v.func = alc269_fixup_pcm_44k,
4818                 .chained = true,
4819                 .chain_id = ALC269_FIXUP_QUANTA_MUTE
4820         },
4821         [ALC269_FIXUP_STEREO_DMIC] = {
4822                 .type = HDA_FIXUP_FUNC,
4823                 .v.func = alc269_fixup_stereo_dmic,
4824         },
4825         [ALC269_FIXUP_HEADSET_MIC] = {
4826                 .type = HDA_FIXUP_FUNC,
4827                 .v.func = alc269_fixup_headset_mic,
4828         },
4829         [ALC269_FIXUP_QUANTA_MUTE] = {
4830                 .type = HDA_FIXUP_FUNC,
4831                 .v.func = alc269_fixup_quanta_mute,
4832         },
4833         [ALC269_FIXUP_LIFEBOOK] = {
4834                 .type = HDA_FIXUP_PINS,
4835                 .v.pins = (const struct hda_pintbl[]) {
4836                         { 0x1a, 0x2101103f }, /* dock line-out */
4837                         { 0x1b, 0x23a11040 }, /* dock mic-in */
4838                         { }
4839                 },
4840                 .chained = true,
4841                 .chain_id = ALC269_FIXUP_QUANTA_MUTE
4842         },
4843         [ALC269_FIXUP_LIFEBOOK_EXTMIC] = {
4844                 .type = HDA_FIXUP_PINS,
4845                 .v.pins = (const struct hda_pintbl[]) {
4846                         { 0x19, 0x01a1903c }, /* headset mic, with jack detect */
4847                         { }
4848                 },
4849         },
4850         [ALC269_FIXUP_LIFEBOOK_HP_PIN] = {
4851                 .type = HDA_FIXUP_PINS,
4852                 .v.pins = (const struct hda_pintbl[]) {
4853                         { 0x21, 0x0221102f }, /* HP out */
4854                         { }
4855                 },
4856         },
4857         [ALC269_FIXUP_LIFEBOOK_NO_HP_TO_LINEOUT] = {
4858                 .type = HDA_FIXUP_FUNC,
4859                 .v.func = alc269_fixup_pincfg_no_hp_to_lineout,
4860         },
4861         [ALC269_FIXUP_AMIC] = {
4862                 .type = HDA_FIXUP_PINS,
4863                 .v.pins = (const struct hda_pintbl[]) {
4864                         { 0x14, 0x99130110 }, /* speaker */
4865                         { 0x15, 0x0121401f }, /* HP out */
4866                         { 0x18, 0x01a19c20 }, /* mic */
4867                         { 0x19, 0x99a3092f }, /* int-mic */
4868                         { }
4869                 },
4870         },
4871         [ALC269_FIXUP_DMIC] = {
4872                 .type = HDA_FIXUP_PINS,
4873                 .v.pins = (const struct hda_pintbl[]) {
4874                         { 0x12, 0x99a3092f }, /* int-mic */
4875                         { 0x14, 0x99130110 }, /* speaker */
4876                         { 0x15, 0x0121401f }, /* HP out */
4877                         { 0x18, 0x01a19c20 }, /* mic */
4878                         { }
4879                 },
4880         },
4881         [ALC269VB_FIXUP_AMIC] = {
4882                 .type = HDA_FIXUP_PINS,
4883                 .v.pins = (const struct hda_pintbl[]) {
4884                         { 0x14, 0x99130110 }, /* speaker */
4885                         { 0x18, 0x01a19c20 }, /* mic */
4886                         { 0x19, 0x99a3092f }, /* int-mic */
4887                         { 0x21, 0x0121401f }, /* HP out */
4888                         { }
4889                 },
4890         },
4891         [ALC269VB_FIXUP_DMIC] = {
4892                 .type = HDA_FIXUP_PINS,
4893                 .v.pins = (const struct hda_pintbl[]) {
4894                         { 0x12, 0x99a3092f }, /* int-mic */
4895                         { 0x14, 0x99130110 }, /* speaker */
4896                         { 0x18, 0x01a19c20 }, /* mic */
4897                         { 0x21, 0x0121401f }, /* HP out */
4898                         { }
4899                 },
4900         },
4901         [ALC269_FIXUP_HP_MUTE_LED] = {
4902                 .type = HDA_FIXUP_FUNC,
4903                 .v.func = alc269_fixup_hp_mute_led,
4904         },
4905         [ALC269_FIXUP_HP_MUTE_LED_MIC1] = {
4906                 .type = HDA_FIXUP_FUNC,
4907                 .v.func = alc269_fixup_hp_mute_led_mic1,
4908         },
4909         [ALC269_FIXUP_HP_MUTE_LED_MIC2] = {
4910                 .type = HDA_FIXUP_FUNC,
4911                 .v.func = alc269_fixup_hp_mute_led_mic2,
4912         },
4913         [ALC269_FIXUP_HP_GPIO_LED] = {
4914                 .type = HDA_FIXUP_FUNC,
4915                 .v.func = alc269_fixup_hp_gpio_led,
4916         },
4917         [ALC269_FIXUP_HP_GPIO_MIC1_LED] = {
4918                 .type = HDA_FIXUP_FUNC,
4919                 .v.func = alc269_fixup_hp_gpio_mic1_led,
4920         },
4921         [ALC269_FIXUP_HP_LINE1_MIC1_LED] = {
4922                 .type = HDA_FIXUP_FUNC,
4923                 .v.func = alc269_fixup_hp_line1_mic1_led,
4924         },
4925         [ALC269_FIXUP_INV_DMIC] = {
4926                 .type = HDA_FIXUP_FUNC,
4927                 .v.func = alc_fixup_inv_dmic,
4928         },
4929         [ALC269_FIXUP_NO_SHUTUP] = {
4930                 .type = HDA_FIXUP_FUNC,
4931                 .v.func = alc_fixup_no_shutup,
4932         },
4933         [ALC269_FIXUP_LENOVO_DOCK] = {
4934                 .type = HDA_FIXUP_PINS,
4935                 .v.pins = (const struct hda_pintbl[]) {
4936                         { 0x19, 0x23a11040 }, /* dock mic */
4937                         { 0x1b, 0x2121103f }, /* dock headphone */
4938                         { }
4939                 },
4940                 .chained = true,
4941                 .chain_id = ALC269_FIXUP_PINCFG_NO_HP_TO_LINEOUT
4942         },
4943         [ALC269_FIXUP_PINCFG_NO_HP_TO_LINEOUT] = {
4944                 .type = HDA_FIXUP_FUNC,
4945                 .v.func = alc269_fixup_pincfg_no_hp_to_lineout,
4946                 .chained = true,
4947                 .chain_id = ALC269_FIXUP_THINKPAD_ACPI,
4948         },
4949         [ALC269_FIXUP_DELL1_MIC_NO_PRESENCE] = {
4950                 .type = HDA_FIXUP_PINS,
4951                 .v.pins = (const struct hda_pintbl[]) {
4952                         { 0x19, 0x01a1913c }, /* use as headset mic, without its own jack detect */
4953                         { 0x1a, 0x01a1913d }, /* use as headphone mic, without its own jack detect */
4954                         { }
4955                 },
4956                 .chained = true,
4957                 .chain_id = ALC269_FIXUP_HEADSET_MODE
4958         },
4959         [ALC269_FIXUP_DELL2_MIC_NO_PRESENCE] = {
4960                 .type = HDA_FIXUP_PINS,
4961                 .v.pins = (const struct hda_pintbl[]) {
4962                         { 0x16, 0x21014020 }, /* dock line out */
4963                         { 0x19, 0x21a19030 }, /* dock mic */
4964                         { 0x1a, 0x01a1913c }, /* use as headset mic, without its own jack detect */
4965                         { }
4966                 },
4967                 .chained = true,
4968                 .chain_id = ALC269_FIXUP_HEADSET_MODE_NO_HP_MIC
4969         },
4970         [ALC269_FIXUP_DELL3_MIC_NO_PRESENCE] = {
4971                 .type = HDA_FIXUP_PINS,
4972                 .v.pins = (const struct hda_pintbl[]) {
4973                         { 0x1a, 0x01a1913c }, /* use as headset mic, without its own jack detect */
4974                         { }
4975                 },
4976                 .chained = true,
4977                 .chain_id = ALC269_FIXUP_HEADSET_MODE_NO_HP_MIC
4978         },
4979         [ALC269_FIXUP_HEADSET_MODE] = {
4980                 .type = HDA_FIXUP_FUNC,
4981                 .v.func = alc_fixup_headset_mode,
4982                 .chained = true,
4983                 .chain_id = ALC255_FIXUP_DELL_WMI_MIC_MUTE_LED
4984         },
4985         [ALC269_FIXUP_HEADSET_MODE_NO_HP_MIC] = {
4986                 .type = HDA_FIXUP_FUNC,
4987                 .v.func = alc_fixup_headset_mode_no_hp_mic,
4988         },
4989         [ALC269_FIXUP_ASPIRE_HEADSET_MIC] = {
4990                 .type = HDA_FIXUP_PINS,
4991                 .v.pins = (const struct hda_pintbl[]) {
4992                         { 0x19, 0x01a1913c }, /* headset mic w/o jack detect */
4993                         { }
4994                 },
4995                 .chained = true,
4996                 .chain_id = ALC269_FIXUP_HEADSET_MODE,
4997         },
4998         [ALC286_FIXUP_SONY_MIC_NO_PRESENCE] = {
4999                 .type = HDA_FIXUP_PINS,
5000                 .v.pins = (const struct hda_pintbl[]) {
5001                         { 0x18, 0x01a1913c }, /* use as headset mic, without its own jack detect */
5002                         { }
5003                 },
5004                 .chained = true,
5005                 .chain_id = ALC269_FIXUP_HEADSET_MIC
5006         },
5007         [ALC269_FIXUP_ASUS_X101_FUNC] = {
5008                 .type = HDA_FIXUP_FUNC,
5009                 .v.func = alc269_fixup_x101_headset_mic,
5010         },
5011         [ALC269_FIXUP_ASUS_X101_VERB] = {
5012                 .type = HDA_FIXUP_VERBS,
5013                 .v.verbs = (const struct hda_verb[]) {
5014                         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
5015                         {0x20, AC_VERB_SET_COEF_INDEX, 0x08},
5016                         {0x20, AC_VERB_SET_PROC_COEF,  0x0310},
5017                         { }
5018                 },
5019                 .chained = true,
5020                 .chain_id = ALC269_FIXUP_ASUS_X101_FUNC
5021         },
5022         [ALC269_FIXUP_ASUS_X101] = {
5023                 .type = HDA_FIXUP_PINS,
5024                 .v.pins = (const struct hda_pintbl[]) {
5025                         { 0x18, 0x04a1182c }, /* Headset mic */
5026                         { }
5027                 },
5028                 .chained = true,
5029                 .chain_id = ALC269_FIXUP_ASUS_X101_VERB
5030         },
5031         [ALC271_FIXUP_AMIC_MIC2] = {
5032                 .type = HDA_FIXUP_PINS,
5033                 .v.pins = (const struct hda_pintbl[]) {
5034                         { 0x14, 0x99130110 }, /* speaker */
5035                         { 0x19, 0x01a19c20 }, /* mic */
5036                         { 0x1b, 0x99a7012f }, /* int-mic */
5037                         { 0x21, 0x0121401f }, /* HP out */
5038                         { }
5039                 },
5040         },
5041         [ALC271_FIXUP_HP_GATE_MIC_JACK] = {
5042                 .type = HDA_FIXUP_FUNC,
5043                 .v.func = alc271_hp_gate_mic_jack,
5044                 .chained = true,
5045                 .chain_id = ALC271_FIXUP_AMIC_MIC2,
5046         },
5047         [ALC271_FIXUP_HP_GATE_MIC_JACK_E1_572] = {
5048                 .type = HDA_FIXUP_FUNC,
5049                 .v.func = alc269_fixup_limit_int_mic_boost,
5050                 .chained = true,
5051                 .chain_id = ALC271_FIXUP_HP_GATE_MIC_JACK,
5052         },
5053         [ALC269_FIXUP_ACER_AC700] = {
5054                 .type = HDA_FIXUP_PINS,
5055                 .v.pins = (const struct hda_pintbl[]) {
5056                         { 0x12, 0x99a3092f }, /* int-mic */
5057                         { 0x14, 0x99130110 }, /* speaker */
5058                         { 0x18, 0x03a11c20 }, /* mic */
5059                         { 0x1e, 0x0346101e }, /* SPDIF1 */
5060                         { 0x21, 0x0321101f }, /* HP out */
5061                         { }
5062                 },
5063                 .chained = true,
5064                 .chain_id = ALC271_FIXUP_DMIC,
5065         },
5066         [ALC269_FIXUP_LIMIT_INT_MIC_BOOST] = {
5067                 .type = HDA_FIXUP_FUNC,
5068                 .v.func = alc269_fixup_limit_int_mic_boost,
5069                 .chained = true,
5070                 .chain_id = ALC269_FIXUP_THINKPAD_ACPI,
5071         },
5072         [ALC269VB_FIXUP_ASUS_ZENBOOK] = {
5073                 .type = HDA_FIXUP_FUNC,
5074                 .v.func = alc269_fixup_limit_int_mic_boost,
5075                 .chained = true,
5076                 .chain_id = ALC269VB_FIXUP_DMIC,
5077         },
5078         [ALC269VB_FIXUP_ASUS_ZENBOOK_UX31A] = {
5079                 .type = HDA_FIXUP_VERBS,
5080                 .v.verbs = (const struct hda_verb[]) {
5081                         /* class-D output amp +5dB */
5082                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x12 },
5083                         { 0x20, AC_VERB_SET_PROC_COEF, 0x2800 },
5084                         {}
5085                 },
5086                 .chained = true,
5087                 .chain_id = ALC269VB_FIXUP_ASUS_ZENBOOK,
5088         },
5089         [ALC269_FIXUP_LIMIT_INT_MIC_BOOST_MUTE_LED] = {
5090                 .type = HDA_FIXUP_FUNC,
5091                 .v.func = alc269_fixup_limit_int_mic_boost,
5092                 .chained = true,
5093                 .chain_id = ALC269_FIXUP_HP_MUTE_LED_MIC1,
5094         },
5095         [ALC269VB_FIXUP_ORDISSIMO_EVE2] = {
5096                 .type = HDA_FIXUP_PINS,
5097                 .v.pins = (const struct hda_pintbl[]) {
5098                         { 0x12, 0x99a3092f }, /* int-mic */
5099                         { 0x18, 0x03a11d20 }, /* mic */
5100                         { 0x19, 0x411111f0 }, /* Unused bogus pin */
5101                         { }
5102                 },
5103         },
5104         [ALC283_FIXUP_CHROME_BOOK] = {
5105                 .type = HDA_FIXUP_FUNC,
5106                 .v.func = alc283_fixup_chromebook,
5107         },
5108         [ALC283_FIXUP_SENSE_COMBO_JACK] = {
5109                 .type = HDA_FIXUP_FUNC,
5110                 .v.func = alc283_fixup_sense_combo_jack,
5111                 .chained = true,
5112                 .chain_id = ALC283_FIXUP_CHROME_BOOK,
5113         },
5114         [ALC282_FIXUP_ASUS_TX300] = {
5115                 .type = HDA_FIXUP_FUNC,
5116                 .v.func = alc282_fixup_asus_tx300,
5117         },
5118         [ALC283_FIXUP_INT_MIC] = {
5119                 .type = HDA_FIXUP_VERBS,
5120                 .v.verbs = (const struct hda_verb[]) {
5121                         {0x20, AC_VERB_SET_COEF_INDEX, 0x1a},
5122                         {0x20, AC_VERB_SET_PROC_COEF, 0x0011},
5123                         { }
5124                 },
5125                 .chained = true,
5126                 .chain_id = ALC269_FIXUP_LIMIT_INT_MIC_BOOST
5127         },
5128         [ALC290_FIXUP_SUBWOOFER_HSJACK] = {
5129                 .type = HDA_FIXUP_PINS,
5130                 .v.pins = (const struct hda_pintbl[]) {
5131                         { 0x17, 0x90170112 }, /* subwoofer */
5132                         { }
5133                 },
5134                 .chained = true,
5135                 .chain_id = ALC290_FIXUP_MONO_SPEAKERS_HSJACK,
5136         },
5137         [ALC290_FIXUP_SUBWOOFER] = {
5138                 .type = HDA_FIXUP_PINS,
5139                 .v.pins = (const struct hda_pintbl[]) {
5140                         { 0x17, 0x90170112 }, /* subwoofer */
5141                         { }
5142                 },
5143                 .chained = true,
5144                 .chain_id = ALC290_FIXUP_MONO_SPEAKERS,
5145         },
5146         [ALC290_FIXUP_MONO_SPEAKERS] = {
5147                 .type = HDA_FIXUP_FUNC,
5148                 .v.func = alc290_fixup_mono_speakers,
5149         },
5150         [ALC290_FIXUP_MONO_SPEAKERS_HSJACK] = {
5151                 .type = HDA_FIXUP_FUNC,
5152                 .v.func = alc290_fixup_mono_speakers,
5153                 .chained = true,
5154                 .chain_id = ALC269_FIXUP_DELL3_MIC_NO_PRESENCE,
5155         },
5156         [ALC269_FIXUP_THINKPAD_ACPI] = {
5157                 .type = HDA_FIXUP_FUNC,
5158                 .v.func = hda_fixup_thinkpad_acpi,
5159         },
5160         [ALC269_FIXUP_DMIC_THINKPAD_ACPI] = {
5161                 .type = HDA_FIXUP_FUNC,
5162                 .v.func = alc_fixup_inv_dmic,
5163                 .chained = true,
5164                 .chain_id = ALC269_FIXUP_THINKPAD_ACPI,
5165         },
5166         [ALC255_FIXUP_DELL1_MIC_NO_PRESENCE] = {
5167                 .type = HDA_FIXUP_PINS,
5168                 .v.pins = (const struct hda_pintbl[]) {
5169                         { 0x19, 0x01a1913c }, /* use as headset mic, without its own jack detect */
5170                         { 0x1a, 0x01a1913d }, /* use as headphone mic, without its own jack detect */
5171                         { }
5172                 },
5173                 .chained = true,
5174                 .chain_id = ALC255_FIXUP_HEADSET_MODE
5175         },
5176         [ALC255_FIXUP_DELL2_MIC_NO_PRESENCE] = {
5177                 .type = HDA_FIXUP_PINS,
5178                 .v.pins = (const struct hda_pintbl[]) {
5179                         { 0x19, 0x01a1913c }, /* use as headset mic, without its own jack detect */
5180                         { }
5181                 },
5182                 .chained = true,
5183                 .chain_id = ALC255_FIXUP_HEADSET_MODE_NO_HP_MIC
5184         },
5185         [ALC255_FIXUP_HEADSET_MODE] = {
5186                 .type = HDA_FIXUP_FUNC,
5187                 .v.func = alc_fixup_headset_mode_alc255,
5188                 .chained = true,
5189                 .chain_id = ALC255_FIXUP_DELL_WMI_MIC_MUTE_LED
5190         },
5191         [ALC255_FIXUP_HEADSET_MODE_NO_HP_MIC] = {
5192                 .type = HDA_FIXUP_FUNC,
5193                 .v.func = alc_fixup_headset_mode_alc255_no_hp_mic,
5194         },
5195         [ALC293_FIXUP_DELL1_MIC_NO_PRESENCE] = {
5196                 .type = HDA_FIXUP_PINS,
5197                 .v.pins = (const struct hda_pintbl[]) {
5198                         { 0x18, 0x01a1913d }, /* use as headphone mic, without its own jack detect */
5199                         { 0x1a, 0x01a1913c }, /* use as headset mic, without its own jack detect */
5200                         { }
5201                 },
5202                 .chained = true,
5203                 .chain_id = ALC269_FIXUP_HEADSET_MODE
5204         },
5205         [ALC292_FIXUP_TPT440_DOCK] = {
5206                 .type = HDA_FIXUP_FUNC,
5207                 .v.func = alc_fixup_tpt440_dock,
5208                 .chained = true,
5209                 .chain_id = ALC269_FIXUP_LIMIT_INT_MIC_BOOST
5210         },
5211         [ALC292_FIXUP_TPT440] = {
5212                 .type = HDA_FIXUP_FUNC,
5213                 .v.func = alc_fixup_disable_aamix,
5214                 .chained = true,
5215                 .chain_id = ALC292_FIXUP_TPT440_DOCK,
5216         },
5217         [ALC283_FIXUP_BXBT2807_MIC] = {
5218                 .type = HDA_FIXUP_PINS,
5219                 .v.pins = (const struct hda_pintbl[]) {
5220                         { 0x19, 0x04a110f0 },
5221                         { },
5222                 },
5223         },
5224         [ALC255_FIXUP_DELL_WMI_MIC_MUTE_LED] = {
5225                 .type = HDA_FIXUP_FUNC,
5226                 .v.func = alc_fixup_dell_wmi,
5227         },
5228         [ALC282_FIXUP_ASPIRE_V5_PINS] = {
5229                 .type = HDA_FIXUP_PINS,
5230                 .v.pins = (const struct hda_pintbl[]) {
5231                         { 0x12, 0x90a60130 },
5232                         { 0x14, 0x90170110 },
5233                         { 0x17, 0x40000008 },
5234                         { 0x18, 0x411111f0 },
5235                         { 0x19, 0x01a1913c },
5236                         { 0x1a, 0x411111f0 },
5237                         { 0x1b, 0x411111f0 },
5238                         { 0x1d, 0x40f89b2d },
5239                         { 0x1e, 0x411111f0 },
5240                         { 0x21, 0x0321101f },
5241                         { },
5242                 },
5243         },
5244         [ALC280_FIXUP_HP_GPIO4] = {
5245                 .type = HDA_FIXUP_FUNC,
5246                 .v.func = alc280_fixup_hp_gpio4,
5247         },
5248         [ALC286_FIXUP_HP_GPIO_LED] = {
5249                 .type = HDA_FIXUP_FUNC,
5250                 .v.func = alc286_fixup_hp_gpio_led,
5251         },
5252         [ALC280_FIXUP_HP_GPIO2_MIC_HOTKEY] = {
5253                 .type = HDA_FIXUP_FUNC,
5254                 .v.func = alc280_fixup_hp_gpio2_mic_hotkey,
5255         },
5256         [ALC280_FIXUP_HP_DOCK_PINS] = {
5257                 .type = HDA_FIXUP_PINS,
5258                 .v.pins = (const struct hda_pintbl[]) {
5259                         { 0x1b, 0x21011020 }, /* line-out */
5260                         { 0x1a, 0x01a1903c }, /* headset mic */
5261                         { 0x18, 0x2181103f }, /* line-in */
5262                         { },
5263                 },
5264                 .chained = true,
5265                 .chain_id = ALC280_FIXUP_HP_GPIO4
5266         },
5267         [ALC280_FIXUP_HP_9480M] = {
5268                 .type = HDA_FIXUP_FUNC,
5269                 .v.func = alc280_fixup_hp_9480m,
5270         },
5271         [ALC288_FIXUP_DELL_HEADSET_MODE] = {
5272                 .type = HDA_FIXUP_FUNC,
5273                 .v.func = alc_fixup_headset_mode_dell_alc288,
5274                 .chained = true,
5275                 .chain_id = ALC255_FIXUP_DELL_WMI_MIC_MUTE_LED
5276         },
5277         [ALC288_FIXUP_DELL1_MIC_NO_PRESENCE] = {
5278                 .type = HDA_FIXUP_PINS,
5279                 .v.pins = (const struct hda_pintbl[]) {
5280                         { 0x18, 0x01a1913c }, /* use as headset mic, without its own jack detect */
5281                         { 0x1a, 0x01a1913d }, /* use as headphone mic, without its own jack detect */
5282                         { }
5283                 },
5284                 .chained = true,
5285                 .chain_id = ALC288_FIXUP_DELL_HEADSET_MODE
5286         },
5287         [ALC288_FIXUP_DELL_XPS_13_GPIO6] = {
5288                 .type = HDA_FIXUP_VERBS,
5289                 .v.verbs = (const struct hda_verb[]) {
5290                         {0x01, AC_VERB_SET_GPIO_MASK, 0x40},
5291                         {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x40},
5292                         {0x01, AC_VERB_SET_GPIO_DATA, 0x00},
5293                         { }
5294                 },
5295                 .chained = true,
5296                 .chain_id = ALC288_FIXUP_DELL1_MIC_NO_PRESENCE
5297         },
5298         [ALC288_FIXUP_DISABLE_AAMIX] = {
5299                 .type = HDA_FIXUP_FUNC,
5300                 .v.func = alc_fixup_disable_aamix,
5301                 .chained = true,
5302                 .chain_id = ALC288_FIXUP_DELL_XPS_13_GPIO6
5303         },
5304         [ALC288_FIXUP_DELL_XPS_13] = {
5305                 .type = HDA_FIXUP_FUNC,
5306                 .v.func = alc_fixup_dell_xps13,
5307                 .chained = true,
5308                 .chain_id = ALC288_FIXUP_DISABLE_AAMIX
5309         },
5310         [ALC292_FIXUP_DISABLE_AAMIX] = {
5311                 .type = HDA_FIXUP_FUNC,
5312                 .v.func = alc_fixup_disable_aamix,
5313                 .chained = true,
5314                 .chain_id = ALC269_FIXUP_DELL2_MIC_NO_PRESENCE
5315         },
5316         [ALC293_FIXUP_DISABLE_AAMIX_MULTIJACK] = {
5317                 .type = HDA_FIXUP_FUNC,
5318                 .v.func = alc_fixup_disable_aamix,
5319                 .chained = true,
5320                 .chain_id = ALC293_FIXUP_DELL1_MIC_NO_PRESENCE
5321         },
5322         [ALC292_FIXUP_DELL_E7X] = {
5323                 .type = HDA_FIXUP_FUNC,
5324                 .v.func = alc_fixup_dell_xps13,
5325                 .chained = true,
5326                 .chain_id = ALC292_FIXUP_DISABLE_AAMIX
5327         },
5328         [ALC298_FIXUP_DELL1_MIC_NO_PRESENCE] = {
5329                 .type = HDA_FIXUP_PINS,
5330                 .v.pins = (const struct hda_pintbl[]) {
5331                         { 0x18, 0x01a1913c }, /* use as headset mic, without its own jack detect */
5332                         { 0x1a, 0x01a1913d }, /* use as headphone mic, without its own jack detect */
5333                         { }
5334                 },
5335                 .chained = true,
5336                 .chain_id = ALC269_FIXUP_HEADSET_MODE
5337         },
5338         [ALC275_FIXUP_DELL_XPS] = {
5339                 .type = HDA_FIXUP_VERBS,
5340                 .v.verbs = (const struct hda_verb[]) {
5341                         /* Enables internal speaker */
5342                         {0x20, AC_VERB_SET_COEF_INDEX, 0x1f},
5343                         {0x20, AC_VERB_SET_PROC_COEF, 0x00c0},
5344                         {0x20, AC_VERB_SET_COEF_INDEX, 0x30},
5345                         {0x20, AC_VERB_SET_PROC_COEF, 0x00b1},
5346                         {}
5347                 }
5348         },
5349         [ALC256_FIXUP_DELL_XPS_13_HEADPHONE_NOISE] = {
5350                 .type = HDA_FIXUP_VERBS,
5351                 .v.verbs = (const struct hda_verb[]) {
5352                         /* Disable pass-through path for FRONT 14h */
5353                         {0x20, AC_VERB_SET_COEF_INDEX, 0x36},
5354                         {0x20, AC_VERB_SET_PROC_COEF, 0x1737},
5355                         {}
5356                 },
5357                 .chained = true,
5358                 .chain_id = ALC255_FIXUP_DELL1_MIC_NO_PRESENCE
5359         },
5360         [ALC293_FIXUP_LENOVO_SPK_NOISE] = {
5361                 .type = HDA_FIXUP_FUNC,
5362                 .v.func = alc_fixup_disable_aamix,
5363                 .chained = true,
5364                 .chain_id = ALC269_FIXUP_THINKPAD_ACPI
5365         },
5366         [ALC233_FIXUP_LENOVO_LINE2_MIC_HOTKEY] = {
5367                 .type = HDA_FIXUP_FUNC,
5368                 .v.func = alc233_fixup_lenovo_line2_mic_hotkey,
5369         },
5370 };
5371
5372 static const struct snd_pci_quirk alc269_fixup_tbl[] = {
5373         SND_PCI_QUIRK(0x1025, 0x0283, "Acer TravelMate 8371", ALC269_FIXUP_INV_DMIC),
5374         SND_PCI_QUIRK(0x1025, 0x029b, "Acer 1810TZ", ALC269_FIXUP_INV_DMIC),
5375         SND_PCI_QUIRK(0x1025, 0x0349, "Acer AOD260", ALC269_FIXUP_INV_DMIC),
5376         SND_PCI_QUIRK(0x1025, 0x047c, "Acer AC700", ALC269_FIXUP_ACER_AC700),
5377         SND_PCI_QUIRK(0x1025, 0x072d, "Acer Aspire V5-571G", ALC269_FIXUP_ASPIRE_HEADSET_MIC),
5378         SND_PCI_QUIRK(0x1025, 0x080d, "Acer Aspire V5-122P", ALC269_FIXUP_ASPIRE_HEADSET_MIC),
5379         SND_PCI_QUIRK(0x1025, 0x0740, "Acer AO725", ALC271_FIXUP_HP_GATE_MIC_JACK),
5380         SND_PCI_QUIRK(0x1025, 0x0742, "Acer AO756", ALC271_FIXUP_HP_GATE_MIC_JACK),
5381         SND_PCI_QUIRK(0x1025, 0x0775, "Acer Aspire E1-572", ALC271_FIXUP_HP_GATE_MIC_JACK_E1_572),
5382         SND_PCI_QUIRK(0x1025, 0x079b, "Acer Aspire V5-573G", ALC282_FIXUP_ASPIRE_V5_PINS),
5383         SND_PCI_QUIRK(0x1025, 0x106d, "Acer Cloudbook 14", ALC283_FIXUP_CHROME_BOOK),
5384         SND_PCI_QUIRK(0x1028, 0x0470, "Dell M101z", ALC269_FIXUP_DELL_M101Z),
5385         SND_PCI_QUIRK(0x1028, 0x054b, "Dell XPS one 2710", ALC275_FIXUP_DELL_XPS),
5386         SND_PCI_QUIRK(0x1028, 0x05bd, "Dell Latitude E6440", ALC292_FIXUP_DELL_E7X),
5387         SND_PCI_QUIRK(0x1028, 0x05be, "Dell Latitude E6540", ALC292_FIXUP_DELL_E7X),
5388         SND_PCI_QUIRK(0x1028, 0x05ca, "Dell Latitude E7240", ALC292_FIXUP_DELL_E7X),
5389         SND_PCI_QUIRK(0x1028, 0x05cb, "Dell Latitude E7440", ALC292_FIXUP_DELL_E7X),
5390         SND_PCI_QUIRK(0x1028, 0x05da, "Dell Vostro 5460", ALC290_FIXUP_SUBWOOFER),
5391         SND_PCI_QUIRK(0x1028, 0x05f4, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE),
5392         SND_PCI_QUIRK(0x1028, 0x05f5, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE),
5393         SND_PCI_QUIRK(0x1028, 0x05f6, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE),
5394         SND_PCI_QUIRK(0x1028, 0x0615, "Dell Vostro 5470", ALC290_FIXUP_SUBWOOFER_HSJACK),
5395         SND_PCI_QUIRK(0x1028, 0x0616, "Dell Vostro 5470", ALC290_FIXUP_SUBWOOFER_HSJACK),
5396         SND_PCI_QUIRK(0x1028, 0x062c, "Dell Latitude E5550", ALC292_FIXUP_DELL_E7X),
5397         SND_PCI_QUIRK(0x1028, 0x062e, "Dell Latitude E7450", ALC292_FIXUP_DELL_E7X),
5398         SND_PCI_QUIRK(0x1028, 0x0638, "Dell Inspiron 5439", ALC290_FIXUP_MONO_SPEAKERS_HSJACK),
5399         SND_PCI_QUIRK(0x1028, 0x064a, "Dell", ALC293_FIXUP_DELL1_MIC_NO_PRESENCE),
5400         SND_PCI_QUIRK(0x1028, 0x064b, "Dell", ALC293_FIXUP_DELL1_MIC_NO_PRESENCE),
5401         SND_PCI_QUIRK(0x1028, 0x0665, "Dell XPS 13", ALC288_FIXUP_DELL_XPS_13),
5402         SND_PCI_QUIRK(0x1028, 0x069a, "Dell Vostro 5480", ALC290_FIXUP_SUBWOOFER_HSJACK),
5403         SND_PCI_QUIRK(0x1028, 0x06c7, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE),
5404         SND_PCI_QUIRK(0x1028, 0x06d9, "Dell", ALC293_FIXUP_DELL1_MIC_NO_PRESENCE),
5405         SND_PCI_QUIRK(0x1028, 0x06da, "Dell", ALC293_FIXUP_DELL1_MIC_NO_PRESENCE),
5406         SND_PCI_QUIRK(0x1028, 0x06db, "Dell", ALC293_FIXUP_DISABLE_AAMIX_MULTIJACK),
5407         SND_PCI_QUIRK(0x1028, 0x06dd, "Dell", ALC293_FIXUP_DISABLE_AAMIX_MULTIJACK),
5408         SND_PCI_QUIRK(0x1028, 0x06de, "Dell", ALC293_FIXUP_DISABLE_AAMIX_MULTIJACK),
5409         SND_PCI_QUIRK(0x1028, 0x06df, "Dell", ALC293_FIXUP_DISABLE_AAMIX_MULTIJACK),
5410         SND_PCI_QUIRK(0x1028, 0x06e0, "Dell", ALC293_FIXUP_DISABLE_AAMIX_MULTIJACK),
5411         SND_PCI_QUIRK(0x1028, 0x0704, "Dell XPS 13", ALC256_FIXUP_DELL_XPS_13_HEADPHONE_NOISE),
5412         SND_PCI_QUIRK(0x1028, 0x164a, "Dell", ALC293_FIXUP_DELL1_MIC_NO_PRESENCE),
5413         SND_PCI_QUIRK(0x1028, 0x164b, "Dell", ALC293_FIXUP_DELL1_MIC_NO_PRESENCE),
5414         SND_PCI_QUIRK(0x103c, 0x1586, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC2),
5415         SND_PCI_QUIRK(0x103c, 0x18e6, "HP", ALC269_FIXUP_HP_GPIO_LED),
5416         SND_PCI_QUIRK(0x103c, 0x218b, "HP", ALC269_FIXUP_LIMIT_INT_MIC_BOOST_MUTE_LED),
5417         SND_PCI_QUIRK(0x103c, 0x225f, "HP", ALC280_FIXUP_HP_GPIO2_MIC_HOTKEY),
5418         /* ALC282 */
5419         SND_PCI_QUIRK(0x103c, 0x21f9, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
5420         SND_PCI_QUIRK(0x103c, 0x2210, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
5421         SND_PCI_QUIRK(0x103c, 0x2214, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
5422         SND_PCI_QUIRK(0x103c, 0x2236, "HP", ALC269_FIXUP_HP_LINE1_MIC1_LED),
5423         SND_PCI_QUIRK(0x103c, 0x2237, "HP", ALC269_FIXUP_HP_LINE1_MIC1_LED),
5424         SND_PCI_QUIRK(0x103c, 0x2238, "HP", ALC269_FIXUP_HP_LINE1_MIC1_LED),
5425         SND_PCI_QUIRK(0x103c, 0x2239, "HP", ALC269_FIXUP_HP_LINE1_MIC1_LED),
5426         SND_PCI_QUIRK(0x103c, 0x224b, "HP", ALC269_FIXUP_HP_LINE1_MIC1_LED),
5427         SND_PCI_QUIRK(0x103c, 0x2268, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
5428         SND_PCI_QUIRK(0x103c, 0x226a, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
5429         SND_PCI_QUIRK(0x103c, 0x226b, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
5430         SND_PCI_QUIRK(0x103c, 0x226e, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
5431         SND_PCI_QUIRK(0x103c, 0x2271, "HP", ALC286_FIXUP_HP_GPIO_LED),
5432         SND_PCI_QUIRK(0x103c, 0x2272, "HP", ALC280_FIXUP_HP_DOCK_PINS),
5433         SND_PCI_QUIRK(0x103c, 0x2273, "HP", ALC280_FIXUP_HP_DOCK_PINS),
5434         SND_PCI_QUIRK(0x103c, 0x229e, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
5435         SND_PCI_QUIRK(0x103c, 0x22b2, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
5436         SND_PCI_QUIRK(0x103c, 0x22b7, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
5437         SND_PCI_QUIRK(0x103c, 0x22bf, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
5438         SND_PCI_QUIRK(0x103c, 0x22cf, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
5439         SND_PCI_QUIRK(0x103c, 0x22db, "HP", ALC280_FIXUP_HP_9480M),
5440         SND_PCI_QUIRK(0x103c, 0x22dc, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),
5441         SND_PCI_QUIRK(0x103c, 0x22fb, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),
5442         /* ALC290 */
5443         SND_PCI_QUIRK(0x103c, 0x221b, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),
5444         SND_PCI_QUIRK(0x103c, 0x2221, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),
5445         SND_PCI_QUIRK(0x103c, 0x2225, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),
5446         SND_PCI_QUIRK(0x103c, 0x2253, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),
5447         SND_PCI_QUIRK(0x103c, 0x2254, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),
5448         SND_PCI_QUIRK(0x103c, 0x2255, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),
5449         SND_PCI_QUIRK(0x103c, 0x2256, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),
5450         SND_PCI_QUIRK(0x103c, 0x2257, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),
5451         SND_PCI_QUIRK(0x103c, 0x2259, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),
5452         SND_PCI_QUIRK(0x103c, 0x225a, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),
5453         SND_PCI_QUIRK(0x103c, 0x2260, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
5454         SND_PCI_QUIRK(0x103c, 0x2263, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
5455         SND_PCI_QUIRK(0x103c, 0x2264, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
5456         SND_PCI_QUIRK(0x103c, 0x2265, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
5457         SND_PCI_QUIRK(0x103c, 0x2272, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),
5458         SND_PCI_QUIRK(0x103c, 0x2273, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),
5459         SND_PCI_QUIRK(0x103c, 0x2278, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),
5460         SND_PCI_QUIRK(0x103c, 0x227f, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
5461         SND_PCI_QUIRK(0x103c, 0x2282, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
5462         SND_PCI_QUIRK(0x103c, 0x228b, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
5463         SND_PCI_QUIRK(0x103c, 0x228e, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
5464         SND_PCI_QUIRK(0x103c, 0x22c5, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
5465         SND_PCI_QUIRK(0x103c, 0x22c7, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
5466         SND_PCI_QUIRK(0x103c, 0x22c8, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
5467         SND_PCI_QUIRK(0x103c, 0x22c4, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
5468         SND_PCI_QUIRK(0x103c, 0x2334, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
5469         SND_PCI_QUIRK(0x103c, 0x2335, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
5470         SND_PCI_QUIRK(0x103c, 0x2336, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
5471         SND_PCI_QUIRK(0x103c, 0x2337, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
5472         SND_PCI_QUIRK(0x1043, 0x103f, "ASUS TX300", ALC282_FIXUP_ASUS_TX300),
5473         SND_PCI_QUIRK(0x1043, 0x106d, "Asus K53BE", ALC269_FIXUP_LIMIT_INT_MIC_BOOST),
5474         SND_PCI_QUIRK(0x1043, 0x115d, "Asus 1015E", ALC269_FIXUP_LIMIT_INT_MIC_BOOST),
5475         SND_PCI_QUIRK(0x1043, 0x1427, "Asus Zenbook UX31E", ALC269VB_FIXUP_ASUS_ZENBOOK),
5476         SND_PCI_QUIRK(0x1043, 0x1517, "Asus Zenbook UX31A", ALC269VB_FIXUP_ASUS_ZENBOOK_UX31A),
5477         SND_PCI_QUIRK(0x1043, 0x16e3, "ASUS UX50", ALC269_FIXUP_STEREO_DMIC),
5478         SND_PCI_QUIRK(0x1043, 0x1a13, "Asus G73Jw", ALC269_FIXUP_ASUS_G73JW),
5479         SND_PCI_QUIRK(0x1043, 0x1b13, "Asus U41SV", ALC269_FIXUP_INV_DMIC),
5480         SND_PCI_QUIRK(0x1043, 0x1c23, "Asus X55U", ALC269_FIXUP_LIMIT_INT_MIC_BOOST),
5481         SND_PCI_QUIRK(0x1043, 0x831a, "ASUS P901", ALC269_FIXUP_STEREO_DMIC),
5482         SND_PCI_QUIRK(0x1043, 0x834a, "ASUS S101", ALC269_FIXUP_STEREO_DMIC),
5483         SND_PCI_QUIRK(0x1043, 0x8398, "ASUS P1005", ALC269_FIXUP_STEREO_DMIC),
5484         SND_PCI_QUIRK(0x1043, 0x83ce, "ASUS P1005", ALC269_FIXUP_STEREO_DMIC),
5485         SND_PCI_QUIRK(0x1043, 0x8516, "ASUS X101CH", ALC269_FIXUP_ASUS_X101),
5486         SND_PCI_QUIRK(0x104d, 0x90b5, "Sony VAIO Pro 11", ALC286_FIXUP_SONY_MIC_NO_PRESENCE),
5487         SND_PCI_QUIRK(0x104d, 0x90b6, "Sony VAIO Pro 13", ALC286_FIXUP_SONY_MIC_NO_PRESENCE),
5488         SND_PCI_QUIRK(0x104d, 0x9073, "Sony VAIO", ALC275_FIXUP_SONY_VAIO_GPIO2),
5489         SND_PCI_QUIRK(0x104d, 0x907b, "Sony VAIO", ALC275_FIXUP_SONY_HWEQ),
5490         SND_PCI_QUIRK(0x104d, 0x9084, "Sony VAIO", ALC275_FIXUP_SONY_HWEQ),
5491         SND_PCI_QUIRK(0x104d, 0x9099, "Sony VAIO S13", ALC275_FIXUP_SONY_DISABLE_AAMIX),
5492         SND_PCI_QUIRK(0x10cf, 0x1475, "Lifebook", ALC269_FIXUP_LIFEBOOK),
5493         SND_PCI_QUIRK(0x10cf, 0x159f, "Lifebook E780", ALC269_FIXUP_LIFEBOOK_NO_HP_TO_LINEOUT),
5494         SND_PCI_QUIRK(0x10cf, 0x15dc, "Lifebook T731", ALC269_FIXUP_LIFEBOOK_HP_PIN),
5495         SND_PCI_QUIRK(0x10cf, 0x1757, "Lifebook E752", ALC269_FIXUP_LIFEBOOK_HP_PIN),
5496         SND_PCI_QUIRK(0x10cf, 0x1845, "Lifebook U904", ALC269_FIXUP_LIFEBOOK_EXTMIC),
5497         SND_PCI_QUIRK(0x144d, 0xc109, "Samsung Ativ book 9 (NP900X3G)", ALC269_FIXUP_INV_DMIC),
5498         SND_PCI_QUIRK(0x1458, 0xfa53, "Gigabyte BXBT-2807", ALC283_FIXUP_BXBT2807_MIC),
5499         SND_PCI_QUIRK(0x17aa, 0x20f2, "Thinkpad SL410/510", ALC269_FIXUP_SKU_IGNORE),
5500         SND_PCI_QUIRK(0x17aa, 0x215e, "Thinkpad L512", ALC269_FIXUP_SKU_IGNORE),
5501         SND_PCI_QUIRK(0x17aa, 0x21b8, "Thinkpad Edge 14", ALC269_FIXUP_SKU_IGNORE),
5502         SND_PCI_QUIRK(0x17aa, 0x21ca, "Thinkpad L412", ALC269_FIXUP_SKU_IGNORE),
5503         SND_PCI_QUIRK(0x17aa, 0x21e9, "Thinkpad Edge 15", ALC269_FIXUP_SKU_IGNORE),
5504         SND_PCI_QUIRK(0x17aa, 0x21f6, "Thinkpad T530", ALC269_FIXUP_LENOVO_DOCK),
5505         SND_PCI_QUIRK(0x17aa, 0x21fa, "Thinkpad X230", ALC269_FIXUP_LENOVO_DOCK),
5506         SND_PCI_QUIRK(0x17aa, 0x21f3, "Thinkpad T430", ALC269_FIXUP_LENOVO_DOCK),
5507         SND_PCI_QUIRK(0x17aa, 0x21fb, "Thinkpad T430s", ALC269_FIXUP_LENOVO_DOCK),
5508         SND_PCI_QUIRK(0x17aa, 0x2203, "Thinkpad X230 Tablet", ALC269_FIXUP_LENOVO_DOCK),
5509         SND_PCI_QUIRK(0x17aa, 0x2208, "Thinkpad T431s", ALC269_FIXUP_LENOVO_DOCK),
5510         SND_PCI_QUIRK(0x17aa, 0x220c, "Thinkpad T440s", ALC292_FIXUP_TPT440),
5511         SND_PCI_QUIRK(0x17aa, 0x220e, "Thinkpad T440p", ALC292_FIXUP_TPT440_DOCK),
5512         SND_PCI_QUIRK(0x17aa, 0x2210, "Thinkpad T540p", ALC292_FIXUP_TPT440_DOCK),
5513         SND_PCI_QUIRK(0x17aa, 0x2211, "Thinkpad W541", ALC292_FIXUP_TPT440_DOCK),
5514         SND_PCI_QUIRK(0x17aa, 0x2212, "Thinkpad T440", ALC292_FIXUP_TPT440_DOCK),
5515         SND_PCI_QUIRK(0x17aa, 0x2214, "Thinkpad X240", ALC292_FIXUP_TPT440_DOCK),
5516         SND_PCI_QUIRK(0x17aa, 0x2215, "Thinkpad", ALC269_FIXUP_LIMIT_INT_MIC_BOOST),
5517         SND_PCI_QUIRK(0x17aa, 0x2218, "Thinkpad X1 Carbon 2nd", ALC292_FIXUP_TPT440_DOCK),
5518         SND_PCI_QUIRK(0x17aa, 0x2223, "ThinkPad T550", ALC292_FIXUP_TPT440_DOCK),
5519         SND_PCI_QUIRK(0x17aa, 0x2226, "ThinkPad X250", ALC292_FIXUP_TPT440_DOCK),
5520         SND_PCI_QUIRK(0x17aa, 0x2233, "Thinkpad", ALC293_FIXUP_LENOVO_SPK_NOISE),
5521         SND_PCI_QUIRK(0x17aa, 0x30bb, "ThinkCentre AIO", ALC233_FIXUP_LENOVO_LINE2_MIC_HOTKEY),
5522         SND_PCI_QUIRK(0x17aa, 0x3902, "Lenovo E50-80", ALC269_FIXUP_DMIC_THINKPAD_ACPI),
5523         SND_PCI_QUIRK(0x17aa, 0x3977, "IdeaPad S210", ALC283_FIXUP_INT_MIC),
5524         SND_PCI_QUIRK(0x17aa, 0x3978, "IdeaPad Y410P", ALC269_FIXUP_NO_SHUTUP),
5525         SND_PCI_QUIRK(0x17aa, 0x5013, "Thinkpad", ALC269_FIXUP_LIMIT_INT_MIC_BOOST),
5526         SND_PCI_QUIRK(0x17aa, 0x501a, "Thinkpad", ALC283_FIXUP_INT_MIC),
5527         SND_PCI_QUIRK(0x17aa, 0x501e, "Thinkpad L440", ALC292_FIXUP_TPT440_DOCK),
5528         SND_PCI_QUIRK(0x17aa, 0x5026, "Thinkpad", ALC269_FIXUP_LIMIT_INT_MIC_BOOST),
5529         SND_PCI_QUIRK(0x17aa, 0x5034, "Thinkpad T450", ALC292_FIXUP_TPT440_DOCK),
5530         SND_PCI_QUIRK(0x17aa, 0x5036, "Thinkpad T450s", ALC292_FIXUP_TPT440_DOCK),
5531         SND_PCI_QUIRK(0x17aa, 0x503c, "Thinkpad L450", ALC292_FIXUP_TPT440_DOCK),
5532         SND_PCI_QUIRK(0x17aa, 0x504b, "Thinkpad", ALC293_FIXUP_LENOVO_SPK_NOISE),
5533         SND_PCI_QUIRK(0x17aa, 0x5109, "Thinkpad", ALC269_FIXUP_LIMIT_INT_MIC_BOOST),
5534         SND_PCI_QUIRK(0x17aa, 0x3bf8, "Quanta FL1", ALC269_FIXUP_PCM_44K),
5535         SND_PCI_QUIRK(0x17aa, 0x9e54, "LENOVO NB", ALC269_FIXUP_LENOVO_EAPD),
5536         SND_PCI_QUIRK(0x1b7d, 0xa831, "Ordissimo EVE2 ", ALC269VB_FIXUP_ORDISSIMO_EVE2), /* Also known as Malata PC-B1303 */
5537
5538 #if 0
5539         /* Below is a quirk table taken from the old code.
5540          * Basically the device should work as is without the fixup table.
5541          * If BIOS doesn't give a proper info, enable the corresponding
5542          * fixup entry.
5543          */
5544         SND_PCI_QUIRK(0x1043, 0x8330, "ASUS Eeepc P703 P900A",
5545                       ALC269_FIXUP_AMIC),
5546         SND_PCI_QUIRK(0x1043, 0x1013, "ASUS N61Da", ALC269_FIXUP_AMIC),
5547         SND_PCI_QUIRK(0x1043, 0x1143, "ASUS B53f", ALC269_FIXUP_AMIC),
5548         SND_PCI_QUIRK(0x1043, 0x1133, "ASUS UJ20ft", ALC269_FIXUP_AMIC),
5549         SND_PCI_QUIRK(0x1043, 0x1183, "ASUS K72DR", ALC269_FIXUP_AMIC),
5550         SND_PCI_QUIRK(0x1043, 0x11b3, "ASUS K52DR", ALC269_FIXUP_AMIC),
5551         SND_PCI_QUIRK(0x1043, 0x11e3, "ASUS U33Jc", ALC269_FIXUP_AMIC),
5552         SND_PCI_QUIRK(0x1043, 0x1273, "ASUS UL80Jt", ALC269_FIXUP_AMIC),
5553         SND_PCI_QUIRK(0x1043, 0x1283, "ASUS U53Jc", ALC269_FIXUP_AMIC),
5554         SND_PCI_QUIRK(0x1043, 0x12b3, "ASUS N82JV", ALC269_FIXUP_AMIC),
5555         SND_PCI_QUIRK(0x1043, 0x12d3, "ASUS N61Jv", ALC269_FIXUP_AMIC),
5556         SND_PCI_QUIRK(0x1043, 0x13a3, "ASUS UL30Vt", ALC269_FIXUP_AMIC),
5557         SND_PCI_QUIRK(0x1043, 0x1373, "ASUS G73JX", ALC269_FIXUP_AMIC),
5558         SND_PCI_QUIRK(0x1043, 0x1383, "ASUS UJ30Jc", ALC269_FIXUP_AMIC),
5559         SND_PCI_QUIRK(0x1043, 0x13d3, "ASUS N61JA", ALC269_FIXUP_AMIC),
5560         SND_PCI_QUIRK(0x1043, 0x1413, "ASUS UL50", ALC269_FIXUP_AMIC),
5561         SND_PCI_QUIRK(0x1043, 0x1443, "ASUS UL30", ALC269_FIXUP_AMIC),
5562         SND_PCI_QUIRK(0x1043, 0x1453, "ASUS M60Jv", ALC269_FIXUP_AMIC),
5563         SND_PCI_QUIRK(0x1043, 0x1483, "ASUS UL80", ALC269_FIXUP_AMIC),
5564         SND_PCI_QUIRK(0x1043, 0x14f3, "ASUS F83Vf", ALC269_FIXUP_AMIC),
5565         SND_PCI_QUIRK(0x1043, 0x14e3, "ASUS UL20", ALC269_FIXUP_AMIC),
5566         SND_PCI_QUIRK(0x1043, 0x1513, "ASUS UX30", ALC269_FIXUP_AMIC),
5567         SND_PCI_QUIRK(0x1043, 0x1593, "ASUS N51Vn", ALC269_FIXUP_AMIC),
5568         SND_PCI_QUIRK(0x1043, 0x15a3, "ASUS N60Jv", ALC269_FIXUP_AMIC),
5569         SND_PCI_QUIRK(0x1043, 0x15b3, "ASUS N60Dp", ALC269_FIXUP_AMIC),
5570         SND_PCI_QUIRK(0x1043, 0x15c3, "ASUS N70De", ALC269_FIXUP_AMIC),
5571         SND_PCI_QUIRK(0x1043, 0x15e3, "ASUS F83T", ALC269_FIXUP_AMIC),
5572         SND_PCI_QUIRK(0x1043, 0x1643, "ASUS M60J", ALC269_FIXUP_AMIC),
5573         SND_PCI_QUIRK(0x1043, 0x1653, "ASUS U50", ALC269_FIXUP_AMIC),
5574         SND_PCI_QUIRK(0x1043, 0x1693, "ASUS F50N", ALC269_FIXUP_AMIC),
5575         SND_PCI_QUIRK(0x1043, 0x16a3, "ASUS F5Q", ALC269_FIXUP_AMIC),
5576         SND_PCI_QUIRK(0x1043, 0x1723, "ASUS P80", ALC269_FIXUP_AMIC),
5577         SND_PCI_QUIRK(0x1043, 0x1743, "ASUS U80", ALC269_FIXUP_AMIC),
5578         SND_PCI_QUIRK(0x1043, 0x1773, "ASUS U20A", ALC269_FIXUP_AMIC),
5579         SND_PCI_QUIRK(0x1043, 0x1883, "ASUS F81Se", ALC269_FIXUP_AMIC),
5580         SND_PCI_QUIRK(0x152d, 0x1778, "Quanta ON1", ALC269_FIXUP_DMIC),
5581         SND_PCI_QUIRK(0x17aa, 0x3be9, "Quanta Wistron", ALC269_FIXUP_AMIC),
5582         SND_PCI_QUIRK(0x17aa, 0x3bf8, "Quanta FL1", ALC269_FIXUP_AMIC),
5583         SND_PCI_QUIRK(0x17ff, 0x059a, "Quanta EL3", ALC269_FIXUP_DMIC),
5584         SND_PCI_QUIRK(0x17ff, 0x059b, "Quanta JR1", ALC269_FIXUP_DMIC),
5585 #endif
5586         {}
5587 };
5588
5589 static const struct snd_pci_quirk alc269_fixup_vendor_tbl[] = {
5590         SND_PCI_QUIRK_VENDOR(0x1025, "Acer Aspire", ALC271_FIXUP_DMIC),
5591         SND_PCI_QUIRK_VENDOR(0x103c, "HP", ALC269_FIXUP_HP_MUTE_LED),
5592         SND_PCI_QUIRK_VENDOR(0x104d, "Sony VAIO", ALC269_FIXUP_SONY_VAIO),
5593         SND_PCI_QUIRK_VENDOR(0x17aa, "Thinkpad", ALC269_FIXUP_THINKPAD_ACPI),
5594         {}
5595 };
5596
5597 static const struct hda_model_fixup alc269_fixup_models[] = {
5598         {.id = ALC269_FIXUP_AMIC, .name = "laptop-amic"},
5599         {.id = ALC269_FIXUP_DMIC, .name = "laptop-dmic"},
5600         {.id = ALC269_FIXUP_STEREO_DMIC, .name = "alc269-dmic"},
5601         {.id = ALC271_FIXUP_DMIC, .name = "alc271-dmic"},
5602         {.id = ALC269_FIXUP_INV_DMIC, .name = "inv-dmic"},
5603         {.id = ALC269_FIXUP_HEADSET_MIC, .name = "headset-mic"},
5604         {.id = ALC269_FIXUP_HEADSET_MODE, .name = "headset-mode"},
5605         {.id = ALC269_FIXUP_HEADSET_MODE_NO_HP_MIC, .name = "headset-mode-no-hp-mic"},
5606         {.id = ALC269_FIXUP_LENOVO_DOCK, .name = "lenovo-dock"},
5607         {.id = ALC269_FIXUP_HP_GPIO_LED, .name = "hp-gpio-led"},
5608         {.id = ALC269_FIXUP_DELL1_MIC_NO_PRESENCE, .name = "dell-headset-multi"},
5609         {.id = ALC269_FIXUP_DELL2_MIC_NO_PRESENCE, .name = "dell-headset-dock"},
5610         {.id = ALC283_FIXUP_CHROME_BOOK, .name = "alc283-dac-wcaps"},
5611         {.id = ALC283_FIXUP_SENSE_COMBO_JACK, .name = "alc283-sense-combo"},
5612         {.id = ALC292_FIXUP_TPT440_DOCK, .name = "tpt440-dock"},
5613         {.id = ALC292_FIXUP_TPT440, .name = "tpt440"},
5614         {}
5615 };
5616 #define ALC225_STANDARD_PINS \
5617         {0x12, 0xb7a60130}, \
5618         {0x21, 0x04211020}
5619
5620 #define ALC256_STANDARD_PINS \
5621         {0x12, 0x90a60140}, \
5622         {0x14, 0x90170110}, \
5623         {0x21, 0x02211020}
5624
5625 #define ALC282_STANDARD_PINS \
5626         {0x14, 0x90170110}
5627
5628 #define ALC290_STANDARD_PINS \
5629         {0x12, 0x99a30130}
5630
5631 #define ALC292_STANDARD_PINS \
5632         {0x14, 0x90170110}, \
5633         {0x15, 0x0221401f}
5634
5635 #define ALC298_STANDARD_PINS \
5636         {0x12, 0x90a60130}, \
5637         {0x21, 0x03211020}
5638
5639 static const struct snd_hda_pin_quirk alc269_pin_fixup_tbl[] = {
5640         SND_HDA_PIN_QUIRK(0x10ec0225, 0x1028, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE,
5641                 ALC225_STANDARD_PINS,
5642                 {0x14, 0x901701a0}),
5643         SND_HDA_PIN_QUIRK(0x10ec0225, 0x1028, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE,
5644                 ALC225_STANDARD_PINS,
5645                 {0x14, 0x901701b0}),
5646         SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL2_MIC_NO_PRESENCE,
5647                 {0x14, 0x90170110},
5648                 {0x21, 0x02211020}),
5649         SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
5650                 {0x12, 0x90a60140},
5651                 {0x14, 0x90170110},
5652                 {0x21, 0x02211020}),
5653         SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
5654                 {0x12, 0x90a60160},
5655                 {0x14, 0x90170120},
5656                 {0x21, 0x02211030}),
5657         SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
5658                 {0x14, 0x90170130},
5659                 {0x1b, 0x01014020},
5660                 {0x21, 0x0221103f}),
5661         SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
5662                 {0x14, 0x90170150},
5663                 {0x1b, 0x02011020},
5664                 {0x21, 0x0221105f}),
5665         SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
5666                 {0x14, 0x90170110},
5667                 {0x1b, 0x01014020},
5668                 {0x21, 0x0221101f}),
5669         SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
5670                 {0x12, 0x90a60160},
5671                 {0x14, 0x90170120},
5672                 {0x17, 0x90170140},
5673                 {0x21, 0x0321102f}),
5674         SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
5675                 {0x12, 0x90a60160},
5676                 {0x14, 0x90170130},
5677                 {0x21, 0x02211040}),
5678         SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
5679                 {0x12, 0x90a60160},
5680                 {0x14, 0x90170140},
5681                 {0x21, 0x02211050}),
5682         SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
5683                 {0x12, 0x90a60170},
5684                 {0x14, 0x90170120},
5685                 {0x21, 0x02211030}),
5686         SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
5687                 {0x12, 0x90a60170},
5688                 {0x14, 0x90170130},
5689                 {0x21, 0x02211040}),
5690         SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
5691                 {0x12, 0x90a60170},
5692                 {0x14, 0x90171130},
5693                 {0x21, 0x02211040}),
5694         SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
5695                 {0x12, 0x90a60170},
5696                 {0x14, 0x90170140},
5697                 {0x21, 0x02211050}),
5698         SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell Inspiron 5548", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
5699                 {0x12, 0x90a60180},
5700                 {0x14, 0x90170130},
5701                 {0x21, 0x02211040}),
5702         SND_HDA_PIN_QUIRK(0x10ec0256, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
5703                 {0x12, 0x90a60160},
5704                 {0x14, 0x90170120},
5705                 {0x21, 0x02211030}),
5706         SND_HDA_PIN_QUIRK(0x10ec0256, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
5707                 ALC256_STANDARD_PINS),
5708         SND_HDA_PIN_QUIRK(0x10ec0280, 0x103c, "HP", ALC280_FIXUP_HP_GPIO4,
5709                 {0x12, 0x90a60130},
5710                 {0x14, 0x90170110},
5711                 {0x15, 0x0421101f},
5712                 {0x1a, 0x04a11020}),
5713         SND_HDA_PIN_QUIRK(0x10ec0280, 0x103c, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED,
5714                 {0x12, 0x90a60140},
5715                 {0x14, 0x90170110},
5716                 {0x15, 0x0421101f},
5717                 {0x18, 0x02811030},
5718                 {0x1a, 0x04a1103f},
5719                 {0x1b, 0x02011020}),
5720         SND_HDA_PIN_QUIRK(0x10ec0282, 0x103c, "HP 15 Touchsmart", ALC269_FIXUP_HP_MUTE_LED_MIC1,
5721                 ALC282_STANDARD_PINS,
5722                 {0x12, 0x99a30130},
5723                 {0x19, 0x03a11020},
5724                 {0x21, 0x0321101f}),
5725         SND_HDA_PIN_QUIRK(0x10ec0282, 0x103c, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1,
5726                 ALC282_STANDARD_PINS,
5727                 {0x12, 0x99a30130},
5728                 {0x19, 0x03a11020},
5729                 {0x21, 0x03211040}),
5730         SND_HDA_PIN_QUIRK(0x10ec0282, 0x103c, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1,
5731                 ALC282_STANDARD_PINS,
5732                 {0x12, 0x99a30130},
5733                 {0x19, 0x03a11030},
5734                 {0x21, 0x03211020}),
5735         SND_HDA_PIN_QUIRK(0x10ec0282, 0x103c, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1,
5736                 ALC282_STANDARD_PINS,
5737                 {0x12, 0x99a30130},
5738                 {0x19, 0x04a11020},
5739                 {0x21, 0x0421101f}),
5740         SND_HDA_PIN_QUIRK(0x10ec0282, 0x103c, "HP", ALC269_FIXUP_HP_LINE1_MIC1_LED,
5741                 ALC282_STANDARD_PINS,
5742                 {0x12, 0x90a60140},
5743                 {0x19, 0x04a11030},
5744                 {0x21, 0x04211020}),
5745         SND_HDA_PIN_QUIRK(0x10ec0283, 0x1028, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE,
5746                 ALC282_STANDARD_PINS,
5747                 {0x12, 0x90a60130},
5748                 {0x21, 0x0321101f}),
5749         SND_HDA_PIN_QUIRK(0x10ec0283, 0x1028, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE,
5750                 {0x12, 0x90a60160},
5751                 {0x14, 0x90170120},
5752                 {0x21, 0x02211030}),
5753         SND_HDA_PIN_QUIRK(0x10ec0283, 0x1028, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE,
5754                 ALC282_STANDARD_PINS,
5755                 {0x12, 0x90a60130},
5756                 {0x19, 0x03a11020},
5757                 {0x21, 0x0321101f}),
5758         SND_HDA_PIN_QUIRK(0x10ec0288, 0x1028, "Dell", ALC288_FIXUP_DELL_XPS_13_GPIO6,
5759                 {0x12, 0x90a60120},
5760                 {0x14, 0x90170110},
5761                 {0x21, 0x0321101f}),
5762         SND_HDA_PIN_QUIRK(0x10ec0290, 0x103c, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1,
5763                 ALC290_STANDARD_PINS,
5764                 {0x15, 0x04211040},
5765                 {0x18, 0x90170112},
5766                 {0x1a, 0x04a11020}),
5767         SND_HDA_PIN_QUIRK(0x10ec0290, 0x103c, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1,
5768                 ALC290_STANDARD_PINS,
5769                 {0x15, 0x04211040},
5770                 {0x18, 0x90170110},
5771                 {0x1a, 0x04a11020}),
5772         SND_HDA_PIN_QUIRK(0x10ec0290, 0x103c, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1,
5773                 ALC290_STANDARD_PINS,
5774                 {0x15, 0x0421101f},
5775                 {0x1a, 0x04a11020}),
5776         SND_HDA_PIN_QUIRK(0x10ec0290, 0x103c, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1,
5777                 ALC290_STANDARD_PINS,
5778                 {0x15, 0x04211020},
5779                 {0x1a, 0x04a11040}),
5780         SND_HDA_PIN_QUIRK(0x10ec0290, 0x103c, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1,
5781                 ALC290_STANDARD_PINS,
5782                 {0x14, 0x90170110},
5783                 {0x15, 0x04211020},
5784                 {0x1a, 0x04a11040}),
5785         SND_HDA_PIN_QUIRK(0x10ec0290, 0x103c, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1,
5786                 ALC290_STANDARD_PINS,
5787                 {0x14, 0x90170110},
5788                 {0x15, 0x04211020},
5789                 {0x1a, 0x04a11020}),
5790         SND_HDA_PIN_QUIRK(0x10ec0290, 0x103c, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1,
5791                 ALC290_STANDARD_PINS,
5792                 {0x14, 0x90170110},
5793                 {0x15, 0x0421101f},
5794                 {0x1a, 0x04a11020}),
5795         SND_HDA_PIN_QUIRK(0x10ec0292, 0x1028, "Dell", ALC269_FIXUP_DELL2_MIC_NO_PRESENCE,
5796                 ALC292_STANDARD_PINS,
5797                 {0x12, 0x90a60140},
5798                 {0x16, 0x01014020},
5799                 {0x19, 0x01a19030}),
5800         SND_HDA_PIN_QUIRK(0x10ec0292, 0x1028, "Dell", ALC269_FIXUP_DELL2_MIC_NO_PRESENCE,
5801                 ALC292_STANDARD_PINS,
5802                 {0x12, 0x90a60140},
5803                 {0x16, 0x01014020},
5804                 {0x18, 0x02a19031},
5805                 {0x19, 0x01a1903e}),
5806         SND_HDA_PIN_QUIRK(0x10ec0292, 0x1028, "Dell", ALC269_FIXUP_DELL3_MIC_NO_PRESENCE,
5807                 ALC292_STANDARD_PINS,
5808                 {0x12, 0x90a60140}),
5809         SND_HDA_PIN_QUIRK(0x10ec0293, 0x1028, "Dell", ALC293_FIXUP_DELL1_MIC_NO_PRESENCE,
5810                 ALC292_STANDARD_PINS,
5811                 {0x13, 0x90a60140},
5812                 {0x16, 0x21014020},
5813                 {0x19, 0x21a19030}),
5814         SND_HDA_PIN_QUIRK(0x10ec0293, 0x1028, "Dell", ALC293_FIXUP_DELL1_MIC_NO_PRESENCE,
5815                 ALC292_STANDARD_PINS,
5816                 {0x13, 0x90a60140}),
5817         SND_HDA_PIN_QUIRK(0x10ec0298, 0x1028, "Dell", ALC298_FIXUP_DELL1_MIC_NO_PRESENCE,
5818                 ALC298_STANDARD_PINS,
5819                 {0x17, 0x90170110}),
5820         SND_HDA_PIN_QUIRK(0x10ec0298, 0x1028, "Dell", ALC298_FIXUP_DELL1_MIC_NO_PRESENCE,
5821                 ALC298_STANDARD_PINS,
5822                 {0x17, 0x90170140}),
5823         SND_HDA_PIN_QUIRK(0x10ec0298, 0x1028, "Dell", ALC298_FIXUP_DELL1_MIC_NO_PRESENCE,
5824                 ALC298_STANDARD_PINS,
5825                 {0x17, 0x90170150}),
5826         {}
5827 };
5828
5829 static void alc269_fill_coef(struct hda_codec *codec)
5830 {
5831         struct alc_spec *spec = codec->spec;
5832         int val;
5833
5834         if (spec->codec_variant != ALC269_TYPE_ALC269VB)
5835                 return;
5836
5837         if ((alc_get_coef0(codec) & 0x00ff) < 0x015) {
5838                 alc_write_coef_idx(codec, 0xf, 0x960b);
5839                 alc_write_coef_idx(codec, 0xe, 0x8817);
5840         }
5841
5842         if ((alc_get_coef0(codec) & 0x00ff) == 0x016) {
5843                 alc_write_coef_idx(codec, 0xf, 0x960b);
5844                 alc_write_coef_idx(codec, 0xe, 0x8814);
5845         }
5846
5847         if ((alc_get_coef0(codec) & 0x00ff) == 0x017) {
5848                 /* Power up output pin */
5849                 alc_update_coef_idx(codec, 0x04, 0, 1<<11);
5850         }
5851
5852         if ((alc_get_coef0(codec) & 0x00ff) == 0x018) {
5853                 val = alc_read_coef_idx(codec, 0xd);
5854                 if (val != -1 && (val & 0x0c00) >> 10 != 0x1) {
5855                         /* Capless ramp up clock control */
5856                         alc_write_coef_idx(codec, 0xd, val | (1<<10));
5857                 }
5858                 val = alc_read_coef_idx(codec, 0x17);
5859                 if (val != -1 && (val & 0x01c0) >> 6 != 0x4) {
5860                         /* Class D power on reset */
5861                         alc_write_coef_idx(codec, 0x17, val | (1<<7));
5862                 }
5863         }
5864
5865         /* HP */
5866         alc_update_coef_idx(codec, 0x4, 0, 1<<11);
5867 }
5868
5869 /*
5870  */
5871 static int patch_alc269(struct hda_codec *codec)
5872 {
5873         struct alc_spec *spec;
5874         int err;
5875
5876         err = alc_alloc_spec(codec, 0x0b);
5877         if (err < 0)
5878                 return err;
5879
5880         spec = codec->spec;
5881         spec->gen.shared_mic_vref_pin = 0x18;
5882         codec->power_save_node = 1;
5883
5884 #ifdef CONFIG_PM
5885         codec->patch_ops.suspend = alc269_suspend;
5886         codec->patch_ops.resume = alc269_resume;
5887 #endif
5888         spec->shutup = alc269_shutup;
5889
5890         snd_hda_pick_fixup(codec, alc269_fixup_models,
5891                        alc269_fixup_tbl, alc269_fixups);
5892         snd_hda_pick_pin_fixup(codec, alc269_pin_fixup_tbl, alc269_fixups);
5893         snd_hda_pick_fixup(codec, NULL, alc269_fixup_vendor_tbl,
5894                            alc269_fixups);
5895         snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE);
5896
5897         alc_auto_parse_customize_define(codec);
5898
5899         if (has_cdefine_beep(codec))
5900                 spec->gen.beep_nid = 0x01;
5901
5902         switch (codec->core.vendor_id) {
5903         case 0x10ec0269:
5904                 spec->codec_variant = ALC269_TYPE_ALC269VA;
5905                 switch (alc_get_coef0(codec) & 0x00f0) {
5906                 case 0x0010:
5907                         if (codec->bus->pci &&
5908                             codec->bus->pci->subsystem_vendor == 0x1025 &&
5909                             spec->cdefine.platform_type == 1)
5910                                 err = alc_codec_rename(codec, "ALC271X");
5911                         spec->codec_variant = ALC269_TYPE_ALC269VB;
5912                         break;
5913                 case 0x0020:
5914                         if (codec->bus->pci &&
5915                             codec->bus->pci->subsystem_vendor == 0x17aa &&
5916                             codec->bus->pci->subsystem_device == 0x21f3)
5917                                 err = alc_codec_rename(codec, "ALC3202");
5918                         spec->codec_variant = ALC269_TYPE_ALC269VC;
5919                         break;
5920                 case 0x0030:
5921                         spec->codec_variant = ALC269_TYPE_ALC269VD;
5922                         break;
5923                 default:
5924                         alc_fix_pll_init(codec, 0x20, 0x04, 15);
5925                 }
5926                 if (err < 0)
5927                         goto error;
5928                 spec->init_hook = alc269_fill_coef;
5929                 alc269_fill_coef(codec);
5930                 break;
5931
5932         case 0x10ec0280:
5933         case 0x10ec0290:
5934                 spec->codec_variant = ALC269_TYPE_ALC280;
5935                 break;
5936         case 0x10ec0282:
5937                 spec->codec_variant = ALC269_TYPE_ALC282;
5938                 spec->shutup = alc282_shutup;
5939                 spec->init_hook = alc282_init;
5940                 break;
5941         case 0x10ec0233:
5942         case 0x10ec0283:
5943                 spec->codec_variant = ALC269_TYPE_ALC283;
5944                 spec->shutup = alc283_shutup;
5945                 spec->init_hook = alc283_init;
5946                 break;
5947         case 0x10ec0284:
5948         case 0x10ec0292:
5949                 spec->codec_variant = ALC269_TYPE_ALC284;
5950                 break;
5951         case 0x10ec0285:
5952         case 0x10ec0293:
5953                 spec->codec_variant = ALC269_TYPE_ALC285;
5954                 break;
5955         case 0x10ec0286:
5956         case 0x10ec0288:
5957                 spec->codec_variant = ALC269_TYPE_ALC286;
5958                 spec->shutup = alc286_shutup;
5959                 break;
5960         case 0x10ec0298:
5961                 spec->codec_variant = ALC269_TYPE_ALC298;
5962                 break;
5963         case 0x10ec0255:
5964                 spec->codec_variant = ALC269_TYPE_ALC255;
5965                 break;
5966         case 0x10ec0256:
5967                 spec->codec_variant = ALC269_TYPE_ALC256;
5968                 spec->gen.mixer_nid = 0; /* ALC256 does not have any loopback mixer path */
5969                 alc_update_coef_idx(codec, 0x36, 1 << 13, 1 << 5); /* Switch pcbeep path to Line in path*/
5970                 break;
5971         case 0x10ec0225:
5972                 spec->codec_variant = ALC269_TYPE_ALC225;
5973                 break;
5974         }
5975
5976         if (snd_hda_codec_read(codec, 0x51, 0, AC_VERB_PARAMETERS, 0) == 0x10ec5505) {
5977                 spec->has_alc5505_dsp = 1;
5978                 spec->init_hook = alc5505_dsp_init;
5979         }
5980
5981         /* automatic parse from the BIOS config */
5982         err = alc269_parse_auto_config(codec);
5983         if (err < 0)
5984                 goto error;
5985
5986         if (!spec->gen.no_analog && spec->gen.beep_nid && spec->gen.mixer_nid)
5987                 set_beep_amp(spec, spec->gen.mixer_nid, 0x04, HDA_INPUT);
5988
5989         snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE);
5990
5991         return 0;
5992
5993  error:
5994         alc_free(codec);
5995         return err;
5996 }
5997
5998 /*
5999  * ALC861
6000  */
6001
6002 static int alc861_parse_auto_config(struct hda_codec *codec)
6003 {
6004         static const hda_nid_t alc861_ignore[] = { 0x1d, 0 };
6005         static const hda_nid_t alc861_ssids[] = { 0x0e, 0x0f, 0x0b, 0 };
6006         return alc_parse_auto_config(codec, alc861_ignore, alc861_ssids);
6007 }
6008
6009 /* Pin config fixes */
6010 enum {
6011         ALC861_FIXUP_FSC_AMILO_PI1505,
6012         ALC861_FIXUP_AMP_VREF_0F,
6013         ALC861_FIXUP_NO_JACK_DETECT,
6014         ALC861_FIXUP_ASUS_A6RP,
6015         ALC660_FIXUP_ASUS_W7J,
6016 };
6017
6018 /* On some laptops, VREF of pin 0x0f is abused for controlling the main amp */
6019 static void alc861_fixup_asus_amp_vref_0f(struct hda_codec *codec,
6020                         const struct hda_fixup *fix, int action)
6021 {
6022         struct alc_spec *spec = codec->spec;
6023         unsigned int val;
6024
6025         if (action != HDA_FIXUP_ACT_INIT)
6026                 return;
6027         val = snd_hda_codec_get_pin_target(codec, 0x0f);
6028         if (!(val & (AC_PINCTL_IN_EN | AC_PINCTL_OUT_EN)))
6029                 val |= AC_PINCTL_IN_EN;
6030         val |= AC_PINCTL_VREF_50;
6031         snd_hda_set_pin_ctl(codec, 0x0f, val);
6032         spec->gen.keep_vref_in_automute = 1;
6033 }
6034
6035 /* suppress the jack-detection */
6036 static void alc_fixup_no_jack_detect(struct hda_codec *codec,
6037                                      const struct hda_fixup *fix, int action)
6038 {
6039         if (action == HDA_FIXUP_ACT_PRE_PROBE)
6040                 codec->no_jack_detect = 1;
6041 }
6042
6043 static const struct hda_fixup alc861_fixups[] = {
6044         [ALC861_FIXUP_FSC_AMILO_PI1505] = {
6045                 .type = HDA_FIXUP_PINS,
6046                 .v.pins = (const struct hda_pintbl[]) {
6047                         { 0x0b, 0x0221101f }, /* HP */
6048                         { 0x0f, 0x90170310 }, /* speaker */
6049                         { }
6050                 }
6051         },
6052         [ALC861_FIXUP_AMP_VREF_0F] = {
6053                 .type = HDA_FIXUP_FUNC,
6054                 .v.func = alc861_fixup_asus_amp_vref_0f,
6055         },
6056         [ALC861_FIXUP_NO_JACK_DETECT] = {
6057                 .type = HDA_FIXUP_FUNC,
6058                 .v.func = alc_fixup_no_jack_detect,
6059         },
6060         [ALC861_FIXUP_ASUS_A6RP] = {
6061                 .type = HDA_FIXUP_FUNC,
6062                 .v.func = alc861_fixup_asus_amp_vref_0f,
6063                 .chained = true,
6064                 .chain_id = ALC861_FIXUP_NO_JACK_DETECT,
6065         },
6066         [ALC660_FIXUP_ASUS_W7J] = {
6067                 .type = HDA_FIXUP_VERBS,
6068                 .v.verbs = (const struct hda_verb[]) {
6069                         /* ASUS W7J needs a magic pin setup on unused NID 0x10
6070                          * for enabling outputs
6071                          */
6072                         {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
6073                         { }
6074                 },
6075         }
6076 };
6077
6078 static const struct snd_pci_quirk alc861_fixup_tbl[] = {
6079         SND_PCI_QUIRK(0x1043, 0x1253, "ASUS W7J", ALC660_FIXUP_ASUS_W7J),
6080         SND_PCI_QUIRK(0x1043, 0x1263, "ASUS Z35HL", ALC660_FIXUP_ASUS_W7J),
6081         SND_PCI_QUIRK(0x1043, 0x1393, "ASUS A6Rp", ALC861_FIXUP_ASUS_A6RP),
6082         SND_PCI_QUIRK_VENDOR(0x1043, "ASUS laptop", ALC861_FIXUP_AMP_VREF_0F),
6083         SND_PCI_QUIRK(0x1462, 0x7254, "HP DX2200", ALC861_FIXUP_NO_JACK_DETECT),
6084         SND_PCI_QUIRK(0x1584, 0x2b01, "Haier W18", ALC861_FIXUP_AMP_VREF_0F),
6085         SND_PCI_QUIRK(0x1584, 0x0000, "Uniwill ECS M31EI", ALC861_FIXUP_AMP_VREF_0F),
6086         SND_PCI_QUIRK(0x1734, 0x10c7, "FSC Amilo Pi1505", ALC861_FIXUP_FSC_AMILO_PI1505),
6087         {}
6088 };
6089
6090 /*
6091  */
6092 static int patch_alc861(struct hda_codec *codec)
6093 {
6094         struct alc_spec *spec;
6095         int err;
6096
6097         err = alc_alloc_spec(codec, 0x15);
6098         if (err < 0)
6099                 return err;
6100
6101         spec = codec->spec;
6102         spec->gen.beep_nid = 0x23;
6103
6104 #ifdef CONFIG_PM
6105         spec->power_hook = alc_power_eapd;
6106 #endif
6107
6108         snd_hda_pick_fixup(codec, NULL, alc861_fixup_tbl, alc861_fixups);
6109         snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE);
6110
6111         /* automatic parse from the BIOS config */
6112         err = alc861_parse_auto_config(codec);
6113         if (err < 0)
6114                 goto error;
6115
6116         if (!spec->gen.no_analog)
6117                 set_beep_amp(spec, 0x23, 0, HDA_OUTPUT);
6118
6119         snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE);
6120
6121         return 0;
6122
6123  error:
6124         alc_free(codec);
6125         return err;
6126 }
6127
6128 /*
6129  * ALC861-VD support
6130  *
6131  * Based on ALC882
6132  *
6133  * In addition, an independent DAC
6134  */
6135 static int alc861vd_parse_auto_config(struct hda_codec *codec)
6136 {
6137         static const hda_nid_t alc861vd_ignore[] = { 0x1d, 0 };
6138         static const hda_nid_t alc861vd_ssids[] = { 0x15, 0x1b, 0x14, 0 };
6139         return alc_parse_auto_config(codec, alc861vd_ignore, alc861vd_ssids);
6140 }
6141
6142 enum {
6143         ALC660VD_FIX_ASUS_GPIO1,
6144         ALC861VD_FIX_DALLAS,
6145 };
6146
6147 /* exclude VREF80 */
6148 static void alc861vd_fixup_dallas(struct hda_codec *codec,
6149                                   const struct hda_fixup *fix, int action)
6150 {
6151         if (action == HDA_FIXUP_ACT_PRE_PROBE) {
6152                 snd_hda_override_pin_caps(codec, 0x18, 0x00000734);
6153                 snd_hda_override_pin_caps(codec, 0x19, 0x0000073c);
6154         }
6155 }
6156
6157 static const struct hda_fixup alc861vd_fixups[] = {
6158         [ALC660VD_FIX_ASUS_GPIO1] = {
6159                 .type = HDA_FIXUP_VERBS,
6160                 .v.verbs = (const struct hda_verb[]) {
6161                         /* reset GPIO1 */
6162                         {0x01, AC_VERB_SET_GPIO_MASK, 0x03},
6163                         {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x01},
6164                         {0x01, AC_VERB_SET_GPIO_DATA, 0x01},
6165                         { }
6166                 }
6167         },
6168         [ALC861VD_FIX_DALLAS] = {
6169                 .type = HDA_FIXUP_FUNC,
6170                 .v.func = alc861vd_fixup_dallas,
6171         },
6172 };
6173
6174 static const struct snd_pci_quirk alc861vd_fixup_tbl[] = {
6175         SND_PCI_QUIRK(0x103c, 0x30bf, "HP TX1000", ALC861VD_FIX_DALLAS),
6176         SND_PCI_QUIRK(0x1043, 0x1339, "ASUS A7-K", ALC660VD_FIX_ASUS_GPIO1),
6177         SND_PCI_QUIRK(0x1179, 0xff31, "Toshiba L30-149", ALC861VD_FIX_DALLAS),
6178         {}
6179 };
6180
6181 /*
6182  */
6183 static int patch_alc861vd(struct hda_codec *codec)
6184 {
6185         struct alc_spec *spec;
6186         int err;
6187
6188         err = alc_alloc_spec(codec, 0x0b);
6189         if (err < 0)
6190                 return err;
6191
6192         spec = codec->spec;
6193         spec->gen.beep_nid = 0x23;
6194
6195         spec->shutup = alc_eapd_shutup;
6196
6197         snd_hda_pick_fixup(codec, NULL, alc861vd_fixup_tbl, alc861vd_fixups);
6198         snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE);
6199
6200         /* automatic parse from the BIOS config */
6201         err = alc861vd_parse_auto_config(codec);
6202         if (err < 0)
6203                 goto error;
6204
6205         if (!spec->gen.no_analog)
6206                 set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
6207
6208         snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE);
6209
6210         return 0;
6211
6212  error:
6213         alc_free(codec);
6214         return err;
6215 }
6216
6217 /*
6218  * ALC662 support
6219  *
6220  * ALC662 is almost identical with ALC880 but has cleaner and more flexible
6221  * configuration.  Each pin widget can choose any input DACs and a mixer.
6222  * Each ADC is connected from a mixer of all inputs.  This makes possible
6223  * 6-channel independent captures.
6224  *
6225  * In addition, an independent DAC for the multi-playback (not used in this
6226  * driver yet).
6227  */
6228
6229 /*
6230  * BIOS auto configuration
6231  */
6232
6233 static int alc662_parse_auto_config(struct hda_codec *codec)
6234 {
6235         static const hda_nid_t alc662_ignore[] = { 0x1d, 0 };
6236         static const hda_nid_t alc663_ssids[] = { 0x15, 0x1b, 0x14, 0x21 };
6237         static const hda_nid_t alc662_ssids[] = { 0x15, 0x1b, 0x14, 0 };
6238         const hda_nid_t *ssids;
6239
6240         if (codec->core.vendor_id == 0x10ec0272 || codec->core.vendor_id == 0x10ec0663 ||
6241             codec->core.vendor_id == 0x10ec0665 || codec->core.vendor_id == 0x10ec0670 ||
6242             codec->core.vendor_id == 0x10ec0671)
6243                 ssids = alc663_ssids;
6244         else
6245                 ssids = alc662_ssids;
6246         return alc_parse_auto_config(codec, alc662_ignore, ssids);
6247 }
6248
6249 static void alc272_fixup_mario(struct hda_codec *codec,
6250                                const struct hda_fixup *fix, int action)
6251 {
6252         if (action != HDA_FIXUP_ACT_PRE_PROBE)
6253                 return;
6254         if (snd_hda_override_amp_caps(codec, 0x2, HDA_OUTPUT,
6255                                       (0x3b << AC_AMPCAP_OFFSET_SHIFT) |
6256                                       (0x3b << AC_AMPCAP_NUM_STEPS_SHIFT) |
6257                                       (0x03 << AC_AMPCAP_STEP_SIZE_SHIFT) |
6258                                       (0 << AC_AMPCAP_MUTE_SHIFT)))
6259                 codec_warn(codec, "failed to override amp caps for NID 0x2\n");
6260 }
6261
6262 static const struct snd_pcm_chmap_elem asus_pcm_2_1_chmaps[] = {
6263         { .channels = 2,
6264           .map = { SNDRV_CHMAP_FL, SNDRV_CHMAP_FR } },
6265         { .channels = 4,
6266           .map = { SNDRV_CHMAP_FL, SNDRV_CHMAP_FR,
6267                    SNDRV_CHMAP_NA, SNDRV_CHMAP_LFE } }, /* LFE only on right */
6268         { }
6269 };
6270
6271 /* override the 2.1 chmap */
6272 static void alc_fixup_bass_chmap(struct hda_codec *codec,
6273                                     const struct hda_fixup *fix, int action)
6274 {
6275         if (action == HDA_FIXUP_ACT_BUILD) {
6276                 struct alc_spec *spec = codec->spec;
6277                 spec->gen.pcm_rec[0]->stream[0].chmap = asus_pcm_2_1_chmaps;
6278         }
6279 }
6280
6281 /* avoid D3 for keeping GPIO up */
6282 static unsigned int gpio_led_power_filter(struct hda_codec *codec,
6283                                           hda_nid_t nid,
6284                                           unsigned int power_state)
6285 {
6286         struct alc_spec *spec = codec->spec;
6287         if (nid == codec->core.afg && power_state == AC_PWRST_D3 && spec->gpio_led)
6288                 return AC_PWRST_D0;
6289         return power_state;
6290 }
6291
6292 static void alc662_fixup_led_gpio1(struct hda_codec *codec,
6293                                    const struct hda_fixup *fix, int action)
6294 {
6295         struct alc_spec *spec = codec->spec;
6296         static const struct hda_verb gpio_init[] = {
6297                 { 0x01, AC_VERB_SET_GPIO_MASK, 0x01 },
6298                 { 0x01, AC_VERB_SET_GPIO_DIRECTION, 0x01 },
6299                 {}
6300         };
6301
6302         if (action == HDA_FIXUP_ACT_PRE_PROBE) {
6303                 spec->gen.vmaster_mute.hook = alc_fixup_gpio_mute_hook;
6304                 spec->gpio_led = 0;
6305                 spec->mute_led_polarity = 1;
6306                 spec->gpio_mute_led_mask = 0x01;
6307                 snd_hda_add_verbs(codec, gpio_init);
6308                 codec->power_filter = gpio_led_power_filter;
6309         }
6310 }
6311
6312 static struct coef_fw alc668_coefs[] = {
6313         WRITE_COEF(0x01, 0xbebe), WRITE_COEF(0x02, 0xaaaa), WRITE_COEF(0x03,    0x0),
6314         WRITE_COEF(0x04, 0x0180), WRITE_COEF(0x06,    0x0), WRITE_COEF(0x07, 0x0f80),
6315         WRITE_COEF(0x08, 0x0031), WRITE_COEF(0x0a, 0x0060), WRITE_COEF(0x0b,    0x0),
6316         WRITE_COEF(0x0c, 0x7cf7), WRITE_COEF(0x0d, 0x1080), WRITE_COEF(0x0e, 0x7f7f),
6317         WRITE_COEF(0x0f, 0xcccc), WRITE_COEF(0x10, 0xddcc), WRITE_COEF(0x11, 0x0001),
6318         WRITE_COEF(0x13,    0x0), WRITE_COEF(0x14, 0x2aa0), WRITE_COEF(0x17, 0xa940),
6319         WRITE_COEF(0x19,    0x0), WRITE_COEF(0x1a,    0x0), WRITE_COEF(0x1b,    0x0),
6320         WRITE_COEF(0x1c,    0x0), WRITE_COEF(0x1d,    0x0), WRITE_COEF(0x1e, 0x7418),
6321         WRITE_COEF(0x1f, 0x0804), WRITE_COEF(0x20, 0x4200), WRITE_COEF(0x21, 0x0468),
6322         WRITE_COEF(0x22, 0x8ccc), WRITE_COEF(0x23, 0x0250), WRITE_COEF(0x24, 0x7418),
6323         WRITE_COEF(0x27,    0x0), WRITE_COEF(0x28, 0x8ccc), WRITE_COEF(0x2a, 0xff00),
6324         WRITE_COEF(0x2b, 0x8000), WRITE_COEF(0xa7, 0xff00), WRITE_COEF(0xa8, 0x8000),
6325         WRITE_COEF(0xaa, 0x2e17), WRITE_COEF(0xab, 0xa0c0), WRITE_COEF(0xac,    0x0),
6326         WRITE_COEF(0xad,    0x0), WRITE_COEF(0xae, 0x2ac6), WRITE_COEF(0xaf, 0xa480),
6327         WRITE_COEF(0xb0,    0x0), WRITE_COEF(0xb1,    0x0), WRITE_COEF(0xb2,    0x0),
6328         WRITE_COEF(0xb3,    0x0), WRITE_COEF(0xb4,    0x0), WRITE_COEF(0xb5, 0x1040),
6329         WRITE_COEF(0xb6, 0xd697), WRITE_COEF(0xb7, 0x902b), WRITE_COEF(0xb8, 0xd697),
6330         WRITE_COEF(0xb9, 0x902b), WRITE_COEF(0xba, 0xb8ba), WRITE_COEF(0xbb, 0xaaab),
6331         WRITE_COEF(0xbc, 0xaaaf), WRITE_COEF(0xbd, 0x6aaa), WRITE_COEF(0xbe, 0x1c02),
6332         WRITE_COEF(0xc0, 0x00ff), WRITE_COEF(0xc1, 0x0fa6),
6333         {}
6334 };
6335
6336 static void alc668_restore_default_value(struct hda_codec *codec)
6337 {
6338         alc_process_coef_fw(codec, alc668_coefs);
6339 }
6340
6341 enum {
6342         ALC662_FIXUP_ASPIRE,
6343         ALC662_FIXUP_LED_GPIO1,
6344         ALC662_FIXUP_IDEAPAD,
6345         ALC272_FIXUP_MARIO,
6346         ALC662_FIXUP_CZC_P10T,
6347         ALC662_FIXUP_SKU_IGNORE,
6348         ALC662_FIXUP_HP_RP5800,
6349         ALC662_FIXUP_ASUS_MODE1,
6350         ALC662_FIXUP_ASUS_MODE2,
6351         ALC662_FIXUP_ASUS_MODE3,
6352         ALC662_FIXUP_ASUS_MODE4,
6353         ALC662_FIXUP_ASUS_MODE5,
6354         ALC662_FIXUP_ASUS_MODE6,
6355         ALC662_FIXUP_ASUS_MODE7,
6356         ALC662_FIXUP_ASUS_MODE8,
6357         ALC662_FIXUP_NO_JACK_DETECT,
6358         ALC662_FIXUP_ZOTAC_Z68,
6359         ALC662_FIXUP_INV_DMIC,
6360         ALC662_FIXUP_DELL_MIC_NO_PRESENCE,
6361         ALC668_FIXUP_DELL_MIC_NO_PRESENCE,
6362         ALC662_FIXUP_HEADSET_MODE,
6363         ALC668_FIXUP_HEADSET_MODE,
6364         ALC662_FIXUP_BASS_MODE4_CHMAP,
6365         ALC662_FIXUP_BASS_16,
6366         ALC662_FIXUP_BASS_1A,
6367         ALC662_FIXUP_BASS_CHMAP,
6368         ALC668_FIXUP_AUTO_MUTE,
6369         ALC668_FIXUP_DELL_DISABLE_AAMIX,
6370         ALC668_FIXUP_DELL_XPS13,
6371 };
6372
6373 static const struct hda_fixup alc662_fixups[] = {
6374         [ALC662_FIXUP_ASPIRE] = {
6375                 .type = HDA_FIXUP_PINS,
6376                 .v.pins = (const struct hda_pintbl[]) {
6377                         { 0x15, 0x99130112 }, /* subwoofer */
6378                         { }
6379                 }
6380         },
6381         [ALC662_FIXUP_LED_GPIO1] = {
6382                 .type = HDA_FIXUP_FUNC,
6383                 .v.func = alc662_fixup_led_gpio1,
6384         },
6385         [ALC662_FIXUP_IDEAPAD] = {
6386                 .type = HDA_FIXUP_PINS,
6387                 .v.pins = (const struct hda_pintbl[]) {
6388                         { 0x17, 0x99130112 }, /* subwoofer */
6389                         { }
6390                 },
6391                 .chained = true,
6392                 .chain_id = ALC662_FIXUP_LED_GPIO1,
6393         },
6394         [ALC272_FIXUP_MARIO] = {
6395                 .type = HDA_FIXUP_FUNC,
6396                 .v.func = alc272_fixup_mario,
6397         },
6398         [ALC662_FIXUP_CZC_P10T] = {
6399                 .type = HDA_FIXUP_VERBS,
6400                 .v.verbs = (const struct hda_verb[]) {
6401                         {0x14, AC_VERB_SET_EAPD_BTLENABLE, 0},
6402                         {}
6403                 }
6404         },
6405         [ALC662_FIXUP_SKU_IGNORE] = {
6406                 .type = HDA_FIXUP_FUNC,
6407                 .v.func = alc_fixup_sku_ignore,
6408         },
6409         [ALC662_FIXUP_HP_RP5800] = {
6410                 .type = HDA_FIXUP_PINS,
6411                 .v.pins = (const struct hda_pintbl[]) {
6412                         { 0x14, 0x0221201f }, /* HP out */
6413                         { }
6414                 },
6415                 .chained = true,
6416                 .chain_id = ALC662_FIXUP_SKU_IGNORE
6417         },
6418         [ALC662_FIXUP_ASUS_MODE1] = {
6419                 .type = HDA_FIXUP_PINS,
6420                 .v.pins = (const struct hda_pintbl[]) {
6421                         { 0x14, 0x99130110 }, /* speaker */
6422                         { 0x18, 0x01a19c20 }, /* mic */
6423                         { 0x19, 0x99a3092f }, /* int-mic */
6424                         { 0x21, 0x0121401f }, /* HP out */
6425                         { }
6426                 },
6427                 .chained = true,
6428                 .chain_id = ALC662_FIXUP_SKU_IGNORE
6429         },
6430         [ALC662_FIXUP_ASUS_MODE2] = {
6431                 .type = HDA_FIXUP_PINS,
6432                 .v.pins = (const struct hda_pintbl[]) {
6433                         { 0x14, 0x99130110 }, /* speaker */
6434                         { 0x18, 0x01a19820 }, /* mic */
6435                         { 0x19, 0x99a3092f }, /* int-mic */
6436                         { 0x1b, 0x0121401f }, /* HP out */
6437                         { }
6438                 },
6439                 .chained = true,
6440                 .chain_id = ALC662_FIXUP_SKU_IGNORE
6441         },
6442         [ALC662_FIXUP_ASUS_MODE3] = {
6443                 .type = HDA_FIXUP_PINS,
6444                 .v.pins = (const struct hda_pintbl[]) {
6445                         { 0x14, 0x99130110 }, /* speaker */
6446                         { 0x15, 0x0121441f }, /* HP */
6447                         { 0x18, 0x01a19840 }, /* mic */
6448                         { 0x19, 0x99a3094f }, /* int-mic */
6449                         { 0x21, 0x01211420 }, /* HP2 */
6450                         { }
6451                 },
6452                 .chained = true,
6453                 .chain_id = ALC662_FIXUP_SKU_IGNORE
6454         },
6455         [ALC662_FIXUP_ASUS_MODE4] = {
6456                 .type = HDA_FIXUP_PINS,
6457                 .v.pins = (const struct hda_pintbl[]) {
6458                         { 0x14, 0x99130110 }, /* speaker */
6459                         { 0x16, 0x99130111 }, /* speaker */
6460                         { 0x18, 0x01a19840 }, /* mic */
6461                         { 0x19, 0x99a3094f }, /* int-mic */
6462                         { 0x21, 0x0121441f }, /* HP */
6463                         { }
6464                 },
6465                 .chained = true,
6466                 .chain_id = ALC662_FIXUP_SKU_IGNORE
6467         },
6468         [ALC662_FIXUP_ASUS_MODE5] = {
6469                 .type = HDA_FIXUP_PINS,
6470                 .v.pins = (const struct hda_pintbl[]) {
6471                         { 0x14, 0x99130110 }, /* speaker */
6472                         { 0x15, 0x0121441f }, /* HP */
6473                         { 0x16, 0x99130111 }, /* speaker */
6474                         { 0x18, 0x01a19840 }, /* mic */
6475                         { 0x19, 0x99a3094f }, /* int-mic */
6476                         { }
6477                 },
6478                 .chained = true,
6479                 .chain_id = ALC662_FIXUP_SKU_IGNORE
6480         },
6481         [ALC662_FIXUP_ASUS_MODE6] = {
6482                 .type = HDA_FIXUP_PINS,
6483                 .v.pins = (const struct hda_pintbl[]) {
6484                         { 0x14, 0x99130110 }, /* speaker */
6485                         { 0x15, 0x01211420 }, /* HP2 */
6486                         { 0x18, 0x01a19840 }, /* mic */
6487                         { 0x19, 0x99a3094f }, /* int-mic */
6488                         { 0x1b, 0x0121441f }, /* HP */
6489                         { }
6490                 },
6491                 .chained = true,
6492                 .chain_id = ALC662_FIXUP_SKU_IGNORE
6493         },
6494         [ALC662_FIXUP_ASUS_MODE7] = {
6495                 .type = HDA_FIXUP_PINS,
6496                 .v.pins = (const struct hda_pintbl[]) {
6497                         { 0x14, 0x99130110 }, /* speaker */
6498                         { 0x17, 0x99130111 }, /* speaker */
6499                         { 0x18, 0x01a19840 }, /* mic */
6500                         { 0x19, 0x99a3094f }, /* int-mic */
6501                         { 0x1b, 0x01214020 }, /* HP */
6502                         { 0x21, 0x0121401f }, /* HP */
6503                         { }
6504                 },
6505                 .chained = true,
6506                 .chain_id = ALC662_FIXUP_SKU_IGNORE
6507         },
6508         [ALC662_FIXUP_ASUS_MODE8] = {
6509                 .type = HDA_FIXUP_PINS,
6510                 .v.pins = (const struct hda_pintbl[]) {
6511                         { 0x14, 0x99130110 }, /* speaker */
6512                         { 0x12, 0x99a30970 }, /* int-mic */
6513                         { 0x15, 0x01214020 }, /* HP */
6514                         { 0x17, 0x99130111 }, /* speaker */
6515                         { 0x18, 0x01a19840 }, /* mic */
6516                         { 0x21, 0x0121401f }, /* HP */
6517                         { }
6518                 },
6519                 .chained = true,
6520                 .chain_id = ALC662_FIXUP_SKU_IGNORE
6521         },
6522         [ALC662_FIXUP_NO_JACK_DETECT] = {
6523                 .type = HDA_FIXUP_FUNC,
6524                 .v.func = alc_fixup_no_jack_detect,
6525         },
6526         [ALC662_FIXUP_ZOTAC_Z68] = {
6527                 .type = HDA_FIXUP_PINS,
6528                 .v.pins = (const struct hda_pintbl[]) {
6529                         { 0x1b, 0x02214020 }, /* Front HP */
6530                         { }
6531                 }
6532         },
6533         [ALC662_FIXUP_INV_DMIC] = {
6534                 .type = HDA_FIXUP_FUNC,
6535                 .v.func = alc_fixup_inv_dmic,
6536         },
6537         [ALC668_FIXUP_DELL_XPS13] = {
6538                 .type = HDA_FIXUP_FUNC,
6539                 .v.func = alc_fixup_dell_xps13,
6540                 .chained = true,
6541                 .chain_id = ALC668_FIXUP_DELL_DISABLE_AAMIX
6542         },
6543         [ALC668_FIXUP_DELL_DISABLE_AAMIX] = {
6544                 .type = HDA_FIXUP_FUNC,
6545                 .v.func = alc_fixup_disable_aamix,
6546                 .chained = true,
6547                 .chain_id = ALC668_FIXUP_DELL_MIC_NO_PRESENCE
6548         },
6549         [ALC668_FIXUP_AUTO_MUTE] = {
6550                 .type = HDA_FIXUP_FUNC,
6551                 .v.func = alc_fixup_auto_mute_via_amp,
6552                 .chained = true,
6553                 .chain_id = ALC668_FIXUP_DELL_MIC_NO_PRESENCE
6554         },
6555         [ALC662_FIXUP_DELL_MIC_NO_PRESENCE] = {
6556                 .type = HDA_FIXUP_PINS,
6557                 .v.pins = (const struct hda_pintbl[]) {
6558                         { 0x19, 0x03a1113c }, /* use as headset mic, without its own jack detect */
6559                         /* headphone mic by setting pin control of 0x1b (headphone out) to in + vref_50 */
6560                         { }
6561                 },
6562                 .chained = true,
6563                 .chain_id = ALC662_FIXUP_HEADSET_MODE
6564         },
6565         [ALC662_FIXUP_HEADSET_MODE] = {
6566                 .type = HDA_FIXUP_FUNC,
6567                 .v.func = alc_fixup_headset_mode_alc662,
6568         },
6569         [ALC668_FIXUP_DELL_MIC_NO_PRESENCE] = {
6570                 .type = HDA_FIXUP_PINS,
6571                 .v.pins = (const struct hda_pintbl[]) {
6572                         { 0x19, 0x03a1913d }, /* use as headphone mic, without its own jack detect */
6573                         { 0x1b, 0x03a1113c }, /* use as headset mic, without its own jack detect */
6574                         { }
6575                 },
6576                 .chained = true,
6577                 .chain_id = ALC668_FIXUP_HEADSET_MODE
6578         },
6579         [ALC668_FIXUP_HEADSET_MODE] = {
6580                 .type = HDA_FIXUP_FUNC,
6581                 .v.func = alc_fixup_headset_mode_alc668,
6582         },
6583         [ALC662_FIXUP_BASS_MODE4_CHMAP] = {
6584                 .type = HDA_FIXUP_FUNC,
6585                 .v.func = alc_fixup_bass_chmap,
6586                 .chained = true,
6587                 .chain_id = ALC662_FIXUP_ASUS_MODE4
6588         },
6589         [ALC662_FIXUP_BASS_16] = {
6590                 .type = HDA_FIXUP_PINS,
6591                 .v.pins = (const struct hda_pintbl[]) {
6592                         {0x16, 0x80106111}, /* bass speaker */
6593                         {}
6594                 },
6595                 .chained = true,
6596                 .chain_id = ALC662_FIXUP_BASS_CHMAP,
6597         },
6598         [ALC662_FIXUP_BASS_1A] = {
6599                 .type = HDA_FIXUP_PINS,
6600                 .v.pins = (const struct hda_pintbl[]) {
6601                         {0x1a, 0x80106111}, /* bass speaker */
6602                         {}
6603                 },
6604                 .chained = true,
6605                 .chain_id = ALC662_FIXUP_BASS_CHMAP,
6606         },
6607         [ALC662_FIXUP_BASS_CHMAP] = {
6608                 .type = HDA_FIXUP_FUNC,
6609                 .v.func = alc_fixup_bass_chmap,
6610         },
6611 };
6612
6613 static const struct snd_pci_quirk alc662_fixup_tbl[] = {
6614         SND_PCI_QUIRK(0x1019, 0x9087, "ECS", ALC662_FIXUP_ASUS_MODE2),
6615         SND_PCI_QUIRK(0x1025, 0x022f, "Acer Aspire One", ALC662_FIXUP_INV_DMIC),
6616         SND_PCI_QUIRK(0x1025, 0x0241, "Packard Bell DOTS", ALC662_FIXUP_INV_DMIC),
6617         SND_PCI_QUIRK(0x1025, 0x0308, "Acer Aspire 8942G", ALC662_FIXUP_ASPIRE),
6618         SND_PCI_QUIRK(0x1025, 0x031c, "Gateway NV79", ALC662_FIXUP_SKU_IGNORE),
6619         SND_PCI_QUIRK(0x1025, 0x0349, "eMachines eM250", ALC662_FIXUP_INV_DMIC),
6620         SND_PCI_QUIRK(0x1025, 0x034a, "Gateway LT27", ALC662_FIXUP_INV_DMIC),
6621         SND_PCI_QUIRK(0x1025, 0x038b, "Acer Aspire 8943G", ALC662_FIXUP_ASPIRE),
6622         SND_PCI_QUIRK(0x1028, 0x05d8, "Dell", ALC668_FIXUP_DELL_MIC_NO_PRESENCE),
6623         SND_PCI_QUIRK(0x1028, 0x05db, "Dell", ALC668_FIXUP_DELL_MIC_NO_PRESENCE),
6624         SND_PCI_QUIRK(0x1028, 0x05fe, "Dell XPS 15", ALC668_FIXUP_DELL_XPS13),
6625         SND_PCI_QUIRK(0x1028, 0x060a, "Dell XPS 13", ALC668_FIXUP_DELL_XPS13),
6626         SND_PCI_QUIRK(0x1028, 0x060d, "Dell M3800", ALC668_FIXUP_DELL_XPS13),
6627         SND_PCI_QUIRK(0x1028, 0x0625, "Dell", ALC668_FIXUP_DELL_MIC_NO_PRESENCE),
6628         SND_PCI_QUIRK(0x1028, 0x0626, "Dell", ALC668_FIXUP_DELL_MIC_NO_PRESENCE),
6629         SND_PCI_QUIRK(0x1028, 0x0696, "Dell", ALC668_FIXUP_DELL_MIC_NO_PRESENCE),
6630         SND_PCI_QUIRK(0x1028, 0x0698, "Dell", ALC668_FIXUP_DELL_MIC_NO_PRESENCE),
6631         SND_PCI_QUIRK(0x1028, 0x069f, "Dell", ALC668_FIXUP_DELL_MIC_NO_PRESENCE),
6632         SND_PCI_QUIRK(0x103c, 0x1632, "HP RP5800", ALC662_FIXUP_HP_RP5800),
6633         SND_PCI_QUIRK(0x1043, 0x11cd, "Asus N550", ALC662_FIXUP_BASS_1A),
6634         SND_PCI_QUIRK(0x1043, 0x13df, "Asus N550JX", ALC662_FIXUP_BASS_1A),
6635         SND_PCI_QUIRK(0x1043, 0x1477, "ASUS N56VZ", ALC662_FIXUP_BASS_MODE4_CHMAP),
6636         SND_PCI_QUIRK(0x1043, 0x15a7, "ASUS UX51VZH", ALC662_FIXUP_BASS_16),
6637         SND_PCI_QUIRK(0x1043, 0x1b73, "ASUS N55SF", ALC662_FIXUP_BASS_16),
6638         SND_PCI_QUIRK(0x1043, 0x1bf3, "ASUS N76VZ", ALC662_FIXUP_BASS_MODE4_CHMAP),
6639         SND_PCI_QUIRK(0x1043, 0x8469, "ASUS mobo", ALC662_FIXUP_NO_JACK_DETECT),
6640         SND_PCI_QUIRK(0x105b, 0x0cd6, "Foxconn", ALC662_FIXUP_ASUS_MODE2),
6641         SND_PCI_QUIRK(0x144d, 0xc051, "Samsung R720", ALC662_FIXUP_IDEAPAD),
6642         SND_PCI_QUIRK(0x17aa, 0x38af, "Lenovo Ideapad Y550P", ALC662_FIXUP_IDEAPAD),
6643         SND_PCI_QUIRK(0x17aa, 0x3a0d, "Lenovo Ideapad Y550", ALC662_FIXUP_IDEAPAD),
6644         SND_PCI_QUIRK(0x19da, 0xa130, "Zotac Z68", ALC662_FIXUP_ZOTAC_Z68),
6645         SND_PCI_QUIRK(0x1b35, 0x2206, "CZC P10T", ALC662_FIXUP_CZC_P10T),
6646
6647 #if 0
6648         /* Below is a quirk table taken from the old code.
6649          * Basically the device should work as is without the fixup table.
6650          * If BIOS doesn't give a proper info, enable the corresponding
6651          * fixup entry.
6652          */
6653         SND_PCI_QUIRK(0x1043, 0x1000, "ASUS N50Vm", ALC662_FIXUP_ASUS_MODE1),
6654         SND_PCI_QUIRK(0x1043, 0x1092, "ASUS NB", ALC662_FIXUP_ASUS_MODE3),
6655         SND_PCI_QUIRK(0x1043, 0x1173, "ASUS K73Jn", ALC662_FIXUP_ASUS_MODE1),
6656         SND_PCI_QUIRK(0x1043, 0x11c3, "ASUS M70V", ALC662_FIXUP_ASUS_MODE3),
6657         SND_PCI_QUIRK(0x1043, 0x11d3, "ASUS NB", ALC662_FIXUP_ASUS_MODE1),
6658         SND_PCI_QUIRK(0x1043, 0x11f3, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),
6659         SND_PCI_QUIRK(0x1043, 0x1203, "ASUS NB", ALC662_FIXUP_ASUS_MODE1),
6660         SND_PCI_QUIRK(0x1043, 0x1303, "ASUS G60J", ALC662_FIXUP_ASUS_MODE1),
6661         SND_PCI_QUIRK(0x1043, 0x1333, "ASUS G60Jx", ALC662_FIXUP_ASUS_MODE1),
6662         SND_PCI_QUIRK(0x1043, 0x1339, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),
6663         SND_PCI_QUIRK(0x1043, 0x13e3, "ASUS N71JA", ALC662_FIXUP_ASUS_MODE7),
6664         SND_PCI_QUIRK(0x1043, 0x1463, "ASUS N71", ALC662_FIXUP_ASUS_MODE7),
6665         SND_PCI_QUIRK(0x1043, 0x14d3, "ASUS G72", ALC662_FIXUP_ASUS_MODE8),
6666         SND_PCI_QUIRK(0x1043, 0x1563, "ASUS N90", ALC662_FIXUP_ASUS_MODE3),
6667         SND_PCI_QUIRK(0x1043, 0x15d3, "ASUS N50SF F50SF", ALC662_FIXUP_ASUS_MODE1),
6668         SND_PCI_QUIRK(0x1043, 0x16c3, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),
6669         SND_PCI_QUIRK(0x1043, 0x16f3, "ASUS K40C K50C", ALC662_FIXUP_ASUS_MODE2),
6670         SND_PCI_QUIRK(0x1043, 0x1733, "ASUS N81De", ALC662_FIXUP_ASUS_MODE1),
6671         SND_PCI_QUIRK(0x1043, 0x1753, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),
6672         SND_PCI_QUIRK(0x1043, 0x1763, "ASUS NB", ALC662_FIXUP_ASUS_MODE6),
6673         SND_PCI_QUIRK(0x1043, 0x1765, "ASUS NB", ALC662_FIXUP_ASUS_MODE6),
6674         SND_PCI_QUIRK(0x1043, 0x1783, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),
6675         SND_PCI_QUIRK(0x1043, 0x1793, "ASUS F50GX", ALC662_FIXUP_ASUS_MODE1),
6676         SND_PCI_QUIRK(0x1043, 0x17b3, "ASUS F70SL", ALC662_FIXUP_ASUS_MODE3),
6677         SND_PCI_QUIRK(0x1043, 0x17f3, "ASUS X58LE", ALC662_FIXUP_ASUS_MODE2),
6678         SND_PCI_QUIRK(0x1043, 0x1813, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),
6679         SND_PCI_QUIRK(0x1043, 0x1823, "ASUS NB", ALC662_FIXUP_ASUS_MODE5),
6680         SND_PCI_QUIRK(0x1043, 0x1833, "ASUS NB", ALC662_FIXUP_ASUS_MODE6),
6681         SND_PCI_QUIRK(0x1043, 0x1843, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),
6682         SND_PCI_QUIRK(0x1043, 0x1853, "ASUS F50Z", ALC662_FIXUP_ASUS_MODE1),
6683         SND_PCI_QUIRK(0x1043, 0x1864, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),
6684         SND_PCI_QUIRK(0x1043, 0x1876, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),
6685         SND_PCI_QUIRK(0x1043, 0x1893, "ASUS M50Vm", ALC662_FIXUP_ASUS_MODE3),
6686         SND_PCI_QUIRK(0x1043, 0x1894, "ASUS X55", ALC662_FIXUP_ASUS_MODE3),
6687         SND_PCI_QUIRK(0x1043, 0x18b3, "ASUS N80Vc", ALC662_FIXUP_ASUS_MODE1),
6688         SND_PCI_QUIRK(0x1043, 0x18c3, "ASUS VX5", ALC662_FIXUP_ASUS_MODE1),
6689         SND_PCI_QUIRK(0x1043, 0x18d3, "ASUS N81Te", ALC662_FIXUP_ASUS_MODE1),
6690         SND_PCI_QUIRK(0x1043, 0x18f3, "ASUS N505Tp", ALC662_FIXUP_ASUS_MODE1),
6691         SND_PCI_QUIRK(0x1043, 0x1903, "ASUS F5GL", ALC662_FIXUP_ASUS_MODE1),
6692         SND_PCI_QUIRK(0x1043, 0x1913, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),
6693         SND_PCI_QUIRK(0x1043, 0x1933, "ASUS F80Q", ALC662_FIXUP_ASUS_MODE2),
6694         SND_PCI_QUIRK(0x1043, 0x1943, "ASUS Vx3V", ALC662_FIXUP_ASUS_MODE1),
6695         SND_PCI_QUIRK(0x1043, 0x1953, "ASUS NB", ALC662_FIXUP_ASUS_MODE1),
6696         SND_PCI_QUIRK(0x1043, 0x1963, "ASUS X71C", ALC662_FIXUP_ASUS_MODE3),
6697         SND_PCI_QUIRK(0x1043, 0x1983, "ASUS N5051A", ALC662_FIXUP_ASUS_MODE1),
6698         SND_PCI_QUIRK(0x1043, 0x1993, "ASUS N20", ALC662_FIXUP_ASUS_MODE1),
6699         SND_PCI_QUIRK(0x1043, 0x19b3, "ASUS F7Z", ALC662_FIXUP_ASUS_MODE1),
6700         SND_PCI_QUIRK(0x1043, 0x19c3, "ASUS F5Z/F6x", ALC662_FIXUP_ASUS_MODE2),
6701         SND_PCI_QUIRK(0x1043, 0x19e3, "ASUS NB", ALC662_FIXUP_ASUS_MODE1),
6702         SND_PCI_QUIRK(0x1043, 0x19f3, "ASUS NB", ALC662_FIXUP_ASUS_MODE4),
6703 #endif
6704         {}
6705 };
6706
6707 static const struct hda_model_fixup alc662_fixup_models[] = {
6708         {.id = ALC272_FIXUP_MARIO, .name = "mario"},
6709         {.id = ALC662_FIXUP_ASUS_MODE1, .name = "asus-mode1"},
6710         {.id = ALC662_FIXUP_ASUS_MODE2, .name = "asus-mode2"},
6711         {.id = ALC662_FIXUP_ASUS_MODE3, .name = "asus-mode3"},
6712         {.id = ALC662_FIXUP_ASUS_MODE4, .name = "asus-mode4"},
6713         {.id = ALC662_FIXUP_ASUS_MODE5, .name = "asus-mode5"},
6714         {.id = ALC662_FIXUP_ASUS_MODE6, .name = "asus-mode6"},
6715         {.id = ALC662_FIXUP_ASUS_MODE7, .name = "asus-mode7"},
6716         {.id = ALC662_FIXUP_ASUS_MODE8, .name = "asus-mode8"},
6717         {.id = ALC662_FIXUP_INV_DMIC, .name = "inv-dmic"},
6718         {.id = ALC668_FIXUP_DELL_MIC_NO_PRESENCE, .name = "dell-headset-multi"},
6719         {}
6720 };
6721
6722 static const struct snd_hda_pin_quirk alc662_pin_fixup_tbl[] = {
6723         SND_HDA_PIN_QUIRK(0x10ec0662, 0x1028, "Dell", ALC662_FIXUP_DELL_MIC_NO_PRESENCE,
6724                 {0x14, 0x01014010},
6725                 {0x18, 0x01a19020},
6726                 {0x1a, 0x0181302f},
6727                 {0x1b, 0x0221401f}),
6728         SND_HDA_PIN_QUIRK(0x10ec0668, 0x1028, "Dell", ALC668_FIXUP_AUTO_MUTE,
6729                 {0x12, 0x99a30130},
6730                 {0x14, 0x90170110},
6731                 {0x15, 0x0321101f},
6732                 {0x16, 0x03011020}),
6733         SND_HDA_PIN_QUIRK(0x10ec0668, 0x1028, "Dell", ALC668_FIXUP_AUTO_MUTE,
6734                 {0x12, 0x99a30140},
6735                 {0x14, 0x90170110},
6736                 {0x15, 0x0321101f},
6737                 {0x16, 0x03011020}),
6738         SND_HDA_PIN_QUIRK(0x10ec0668, 0x1028, "Dell", ALC668_FIXUP_AUTO_MUTE,
6739                 {0x12, 0x99a30150},
6740                 {0x14, 0x90170110},
6741                 {0x15, 0x0321101f},
6742                 {0x16, 0x03011020}),
6743         SND_HDA_PIN_QUIRK(0x10ec0668, 0x1028, "Dell", ALC668_FIXUP_AUTO_MUTE,
6744                 {0x14, 0x90170110},
6745                 {0x15, 0x0321101f},
6746                 {0x16, 0x03011020}),
6747         SND_HDA_PIN_QUIRK(0x10ec0668, 0x1028, "Dell XPS 15", ALC668_FIXUP_AUTO_MUTE,
6748                 {0x12, 0x90a60130},
6749                 {0x14, 0x90170110},
6750                 {0x15, 0x0321101f}),
6751         {}
6752 };
6753
6754 /*
6755  */
6756 static int patch_alc662(struct hda_codec *codec)
6757 {
6758         struct alc_spec *spec;
6759         int err;
6760
6761         err = alc_alloc_spec(codec, 0x0b);
6762         if (err < 0)
6763                 return err;
6764
6765         spec = codec->spec;
6766
6767         spec->shutup = alc_eapd_shutup;
6768
6769         /* handle multiple HPs as is */
6770         spec->parse_flags = HDA_PINCFG_NO_HP_FIXUP;
6771
6772         alc_fix_pll_init(codec, 0x20, 0x04, 15);
6773
6774         switch (codec->core.vendor_id) {
6775         case 0x10ec0668:
6776                 spec->init_hook = alc668_restore_default_value;
6777                 break;
6778         }
6779
6780         snd_hda_pick_fixup(codec, alc662_fixup_models,
6781                        alc662_fixup_tbl, alc662_fixups);
6782         snd_hda_pick_pin_fixup(codec, alc662_pin_fixup_tbl, alc662_fixups);
6783         snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE);
6784
6785         alc_auto_parse_customize_define(codec);
6786
6787         if (has_cdefine_beep(codec))
6788                 spec->gen.beep_nid = 0x01;
6789
6790         if ((alc_get_coef0(codec) & (1 << 14)) &&
6791             codec->bus->pci && codec->bus->pci->subsystem_vendor == 0x1025 &&
6792             spec->cdefine.platform_type == 1) {
6793                 err = alc_codec_rename(codec, "ALC272X");
6794                 if (err < 0)
6795                         goto error;
6796         }
6797
6798         /* automatic parse from the BIOS config */
6799         err = alc662_parse_auto_config(codec);
6800         if (err < 0)
6801                 goto error;
6802
6803         if (!spec->gen.no_analog && spec->gen.beep_nid) {
6804                 switch (codec->core.vendor_id) {
6805                 case 0x10ec0662:
6806                         set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
6807                         break;
6808                 case 0x10ec0272:
6809                 case 0x10ec0663:
6810                 case 0x10ec0665:
6811                 case 0x10ec0668:
6812                         set_beep_amp(spec, 0x0b, 0x04, HDA_INPUT);
6813                         break;
6814                 case 0x10ec0273:
6815                         set_beep_amp(spec, 0x0b, 0x03, HDA_INPUT);
6816                         break;
6817                 }
6818         }
6819
6820         snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE);
6821
6822         return 0;
6823
6824  error:
6825         alc_free(codec);
6826         return err;
6827 }
6828
6829 /*
6830  * ALC680 support
6831  */
6832
6833 static int alc680_parse_auto_config(struct hda_codec *codec)
6834 {
6835         return alc_parse_auto_config(codec, NULL, NULL);
6836 }
6837
6838 /*
6839  */
6840 static int patch_alc680(struct hda_codec *codec)
6841 {
6842         int err;
6843
6844         /* ALC680 has no aa-loopback mixer */
6845         err = alc_alloc_spec(codec, 0);
6846         if (err < 0)
6847                 return err;
6848
6849         /* automatic parse from the BIOS config */
6850         err = alc680_parse_auto_config(codec);
6851         if (err < 0) {
6852                 alc_free(codec);
6853                 return err;
6854         }
6855
6856         return 0;
6857 }
6858
6859 /*
6860  * patch entries
6861  */
6862 static const struct hda_device_id snd_hda_id_realtek[] = {
6863         HDA_CODEC_ENTRY(0x10ec0221, "ALC221", patch_alc269),
6864         HDA_CODEC_ENTRY(0x10ec0225, "ALC225", patch_alc269),
6865         HDA_CODEC_ENTRY(0x10ec0231, "ALC231", patch_alc269),
6866         HDA_CODEC_ENTRY(0x10ec0233, "ALC233", patch_alc269),
6867         HDA_CODEC_ENTRY(0x10ec0235, "ALC233", patch_alc269),
6868         HDA_CODEC_ENTRY(0x10ec0255, "ALC255", patch_alc269),
6869         HDA_CODEC_ENTRY(0x10ec0256, "ALC256", patch_alc269),
6870         HDA_CODEC_ENTRY(0x10ec0260, "ALC260", patch_alc260),
6871         HDA_CODEC_ENTRY(0x10ec0262, "ALC262", patch_alc262),
6872         HDA_CODEC_ENTRY(0x10ec0267, "ALC267", patch_alc268),
6873         HDA_CODEC_ENTRY(0x10ec0268, "ALC268", patch_alc268),
6874         HDA_CODEC_ENTRY(0x10ec0269, "ALC269", patch_alc269),
6875         HDA_CODEC_ENTRY(0x10ec0270, "ALC270", patch_alc269),
6876         HDA_CODEC_ENTRY(0x10ec0272, "ALC272", patch_alc662),
6877         HDA_CODEC_ENTRY(0x10ec0275, "ALC275", patch_alc269),
6878         HDA_CODEC_ENTRY(0x10ec0276, "ALC276", patch_alc269),
6879         HDA_CODEC_ENTRY(0x10ec0280, "ALC280", patch_alc269),
6880         HDA_CODEC_ENTRY(0x10ec0282, "ALC282", patch_alc269),
6881         HDA_CODEC_ENTRY(0x10ec0283, "ALC283", patch_alc269),
6882         HDA_CODEC_ENTRY(0x10ec0284, "ALC284", patch_alc269),
6883         HDA_CODEC_ENTRY(0x10ec0285, "ALC285", patch_alc269),
6884         HDA_CODEC_ENTRY(0x10ec0286, "ALC286", patch_alc269),
6885         HDA_CODEC_ENTRY(0x10ec0288, "ALC288", patch_alc269),
6886         HDA_CODEC_ENTRY(0x10ec0290, "ALC290", patch_alc269),
6887         HDA_CODEC_ENTRY(0x10ec0292, "ALC292", patch_alc269),
6888         HDA_CODEC_ENTRY(0x10ec0293, "ALC293", patch_alc269),
6889         HDA_CODEC_ENTRY(0x10ec0298, "ALC298", patch_alc269),
6890         HDA_CODEC_REV_ENTRY(0x10ec0861, 0x100340, "ALC660", patch_alc861),
6891         HDA_CODEC_ENTRY(0x10ec0660, "ALC660-VD", patch_alc861vd),
6892         HDA_CODEC_ENTRY(0x10ec0861, "ALC861", patch_alc861),
6893         HDA_CODEC_ENTRY(0x10ec0862, "ALC861-VD", patch_alc861vd),
6894         HDA_CODEC_REV_ENTRY(0x10ec0662, 0x100002, "ALC662 rev2", patch_alc882),
6895         HDA_CODEC_REV_ENTRY(0x10ec0662, 0x100101, "ALC662 rev1", patch_alc662),
6896         HDA_CODEC_REV_ENTRY(0x10ec0662, 0x100300, "ALC662 rev3", patch_alc662),
6897         HDA_CODEC_ENTRY(0x10ec0663, "ALC663", patch_alc662),
6898         HDA_CODEC_ENTRY(0x10ec0665, "ALC665", patch_alc662),
6899         HDA_CODEC_ENTRY(0x10ec0667, "ALC667", patch_alc662),
6900         HDA_CODEC_ENTRY(0x10ec0668, "ALC668", patch_alc662),
6901         HDA_CODEC_ENTRY(0x10ec0670, "ALC670", patch_alc662),
6902         HDA_CODEC_ENTRY(0x10ec0671, "ALC671", patch_alc662),
6903         HDA_CODEC_ENTRY(0x10ec0680, "ALC680", patch_alc680),
6904         HDA_CODEC_ENTRY(0x10ec0867, "ALC891", patch_alc882),
6905         HDA_CODEC_ENTRY(0x10ec0880, "ALC880", patch_alc880),
6906         HDA_CODEC_ENTRY(0x10ec0882, "ALC882", patch_alc882),
6907         HDA_CODEC_ENTRY(0x10ec0883, "ALC883", patch_alc882),
6908         HDA_CODEC_REV_ENTRY(0x10ec0885, 0x100101, "ALC889A", patch_alc882),
6909         HDA_CODEC_REV_ENTRY(0x10ec0885, 0x100103, "ALC889A", patch_alc882),
6910         HDA_CODEC_ENTRY(0x10ec0885, "ALC885", patch_alc882),
6911         HDA_CODEC_ENTRY(0x10ec0887, "ALC887", patch_alc882),
6912         HDA_CODEC_REV_ENTRY(0x10ec0888, 0x100101, "ALC1200", patch_alc882),
6913         HDA_CODEC_ENTRY(0x10ec0888, "ALC888", patch_alc882),
6914         HDA_CODEC_ENTRY(0x10ec0889, "ALC889", patch_alc882),
6915         HDA_CODEC_ENTRY(0x10ec0892, "ALC892", patch_alc662),
6916         HDA_CODEC_ENTRY(0x10ec0899, "ALC898", patch_alc882),
6917         HDA_CODEC_ENTRY(0x10ec0900, "ALC1150", patch_alc882),
6918         {} /* terminator */
6919 };
6920 MODULE_DEVICE_TABLE(hdaudio, snd_hda_id_realtek);
6921
6922 MODULE_LICENSE("GPL");
6923 MODULE_DESCRIPTION("Realtek HD-audio codec");
6924
6925 static struct hda_codec_driver realtek_driver = {
6926         .id = snd_hda_id_realtek,
6927 };
6928
6929 module_hda_codec_driver(realtek_driver);