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