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