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