sound/pci/hda/patch_realtek.c

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