sound/pci/hda/patch_realtek.c

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