sound/pci/hda/patch_realtek.c

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