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