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