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, 0x1228, "MSI-GP63", ALC1220_FIXUP_CLEVO_P950),
2465         SND_PCI_QUIRK(0x1462, 0x1275, "MSI-GL63", ALC1220_FIXUP_CLEVO_P950),
2466         SND_PCI_QUIRK(0x1462, 0x1276, "MSI-GL73", ALC1220_FIXUP_CLEVO_P950),
2467         SND_PCI_QUIRK(0x1462, 0x1293, "MSI-GP65", ALC1220_FIXUP_CLEVO_P950),
2468         SND_PCI_QUIRK(0x1462, 0x7350, "MSI-7350", ALC889_FIXUP_CD),
2469         SND_PCI_QUIRK(0x1462, 0xda57, "MSI Z270-Gaming", ALC1220_FIXUP_GB_DUAL_CODECS),
2470         SND_PCI_QUIRK_VENDOR(0x1462, "MSI", ALC882_FIXUP_GPIO3),
2471         SND_PCI_QUIRK(0x147b, 0x107a, "Abit AW9D-MAX", ALC882_FIXUP_ABIT_AW9D_MAX),
2472         SND_PCI_QUIRK(0x1558, 0x9501, "Clevo P950HR", ALC1220_FIXUP_CLEVO_P950),
2473         SND_PCI_QUIRK(0x1558, 0x95e1, "Clevo P95xER", ALC1220_FIXUP_CLEVO_P950),
2474         SND_PCI_QUIRK(0x1558, 0x95e2, "Clevo P950ER", ALC1220_FIXUP_CLEVO_P950),
2475         SND_PCI_QUIRK(0x1558, 0x96e1, "Clevo P960[ER][CDFN]-K", ALC1220_FIXUP_CLEVO_P950),
2476         SND_PCI_QUIRK(0x1558, 0x97e1, "Clevo P970[ER][CDFN]", ALC1220_FIXUP_CLEVO_P950),
2477         SND_PCI_QUIRK(0x1558, 0x65d1, "Clevo PB51[ER][CDF]", ALC1220_FIXUP_CLEVO_PB51ED_PINS),
2478         SND_PCI_QUIRK(0x1558, 0x67d1, "Clevo PB71[ER][CDF]", ALC1220_FIXUP_CLEVO_PB51ED_PINS),
2479         SND_PCI_QUIRK(0x1558, 0x50d3, "Clevo PC50[ER][CDF]", ALC1220_FIXUP_CLEVO_PB51ED_PINS),
2480         SND_PCI_QUIRK(0x1558, 0x70d1, "Clevo PC70[ER][CDF]", ALC1220_FIXUP_CLEVO_PB51ED_PINS),
2481         SND_PCI_QUIRK(0x1558, 0x7714, "Clevo X170", ALC1220_FIXUP_CLEVO_PB51ED_PINS),
2482         SND_PCI_QUIRK_VENDOR(0x1558, "Clevo laptop", ALC882_FIXUP_EAPD),
2483         SND_PCI_QUIRK(0x161f, 0x2054, "Medion laptop", ALC883_FIXUP_EAPD),
2484         SND_PCI_QUIRK(0x17aa, 0x3a0d, "Lenovo Y530", ALC882_FIXUP_LENOVO_Y530),
2485         SND_PCI_QUIRK(0x8086, 0x0022, "DX58SO", ALC889_FIXUP_COEF),
2486         {}
2487 };
2488
2489 static const struct hda_model_fixup alc882_fixup_models[] = {
2490         {.id = ALC882_FIXUP_ABIT_AW9D_MAX, .name = "abit-aw9d"},
2491         {.id = ALC882_FIXUP_LENOVO_Y530, .name = "lenovo-y530"},
2492         {.id = ALC882_FIXUP_ACER_ASPIRE_7736, .name = "acer-aspire-7736"},
2493         {.id = ALC882_FIXUP_ASUS_W90V, .name = "asus-w90v"},
2494         {.id = ALC889_FIXUP_CD, .name = "cd"},
2495         {.id = ALC889_FIXUP_FRONT_HP_NO_PRESENCE, .name = "no-front-hp"},
2496         {.id = ALC889_FIXUP_VAIO_TT, .name = "vaio-tt"},
2497         {.id = ALC888_FIXUP_EEE1601, .name = "eee1601"},
2498         {.id = ALC882_FIXUP_EAPD, .name = "alc882-eapd"},
2499         {.id = ALC883_FIXUP_EAPD, .name = "alc883-eapd"},
2500         {.id = ALC882_FIXUP_GPIO1, .name = "gpio1"},
2501         {.id = ALC882_FIXUP_GPIO2, .name = "gpio2"},
2502         {.id = ALC882_FIXUP_GPIO3, .name = "gpio3"},
2503         {.id = ALC889_FIXUP_COEF, .name = "alc889-coef"},
2504         {.id = ALC882_FIXUP_ASUS_W2JC, .name = "asus-w2jc"},
2505         {.id = ALC882_FIXUP_ACER_ASPIRE_4930G, .name = "acer-aspire-4930g"},
2506         {.id = ALC882_FIXUP_ACER_ASPIRE_8930G, .name = "acer-aspire-8930g"},
2507         {.id = ALC883_FIXUP_ACER_EAPD, .name = "acer-aspire"},
2508         {.id = ALC885_FIXUP_MACPRO_GPIO, .name = "macpro-gpio"},
2509         {.id = ALC889_FIXUP_DAC_ROUTE, .name = "dac-route"},
2510         {.id = ALC889_FIXUP_MBP_VREF, .name = "mbp-vref"},
2511         {.id = ALC889_FIXUP_IMAC91_VREF, .name = "imac91-vref"},
2512         {.id = ALC889_FIXUP_MBA11_VREF, .name = "mba11-vref"},
2513         {.id = ALC889_FIXUP_MBA21_VREF, .name = "mba21-vref"},
2514         {.id = ALC889_FIXUP_MP11_VREF, .name = "mp11-vref"},
2515         {.id = ALC889_FIXUP_MP41_VREF, .name = "mp41-vref"},
2516         {.id = ALC882_FIXUP_INV_DMIC, .name = "inv-dmic"},
2517         {.id = ALC882_FIXUP_NO_PRIMARY_HP, .name = "no-primary-hp"},
2518         {.id = ALC887_FIXUP_ASUS_BASS, .name = "asus-bass"},
2519         {.id = ALC1220_FIXUP_GB_DUAL_CODECS, .name = "dual-codecs"},
2520         {.id = ALC1220_FIXUP_CLEVO_P950, .name = "clevo-p950"},
2521         {}
2522 };
2523
2524 /*
2525  * BIOS auto configuration
2526  */
2527 /* almost identical with ALC880 parser... */
2528 static int alc882_parse_auto_config(struct hda_codec *codec)
2529 {
2530         static const hda_nid_t alc882_ignore[] = { 0x1d, 0 };
2531         static const hda_nid_t alc882_ssids[] = { 0x15, 0x1b, 0x14, 0 };
2532         return alc_parse_auto_config(codec, alc882_ignore, alc882_ssids);
2533 }
2534
2535 /*
2536  */
2537 static int patch_alc882(struct hda_codec *codec)
2538 {
2539         struct alc_spec *spec;
2540         int err;
2541
2542         err = alc_alloc_spec(codec, 0x0b);
2543         if (err < 0)
2544                 return err;
2545
2546         spec = codec->spec;
2547
2548         switch (codec->core.vendor_id) {
2549         case 0x10ec0882:
2550         case 0x10ec0885:
2551         case 0x10ec0900:
2552         case 0x10ec0b00:
2553         case 0x10ec1220:
2554                 break;
2555         default:
2556                 /* ALC883 and variants */
2557                 alc_fix_pll_init(codec, 0x20, 0x0a, 10);
2558                 break;
2559         }
2560
2561         alc_pre_init(codec);
2562
2563         snd_hda_pick_fixup(codec, alc882_fixup_models, alc882_fixup_tbl,
2564                        alc882_fixups);
2565         snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE);
2566
2567         alc_auto_parse_customize_define(codec);
2568
2569         if (has_cdefine_beep(codec))
2570                 spec->gen.beep_nid = 0x01;
2571
2572         /* automatic parse from the BIOS config */
2573         err = alc882_parse_auto_config(codec);
2574         if (err < 0)
2575                 goto error;
2576
2577         if (!spec->gen.no_analog && spec->gen.beep_nid) {
2578                 err = set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
2579                 if (err < 0)
2580                         goto error;
2581         }
2582
2583         snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE);
2584
2585         return 0;
2586
2587  error:
2588         alc_free(codec);
2589         return err;
2590 }
2591
2592
2593 /*
2594  * ALC262 support
2595  */
2596 static int alc262_parse_auto_config(struct hda_codec *codec)
2597 {
2598         static const hda_nid_t alc262_ignore[] = { 0x1d, 0 };
2599         static const hda_nid_t alc262_ssids[] = { 0x15, 0x1b, 0x14, 0 };
2600         return alc_parse_auto_config(codec, alc262_ignore, alc262_ssids);
2601 }
2602
2603 /*
2604  * Pin config fixes
2605  */
2606 enum {
2607         ALC262_FIXUP_FSC_H270,
2608         ALC262_FIXUP_FSC_S7110,
2609         ALC262_FIXUP_HP_Z200,
2610         ALC262_FIXUP_TYAN,
2611         ALC262_FIXUP_LENOVO_3000,
2612         ALC262_FIXUP_BENQ,
2613         ALC262_FIXUP_BENQ_T31,
2614         ALC262_FIXUP_INV_DMIC,
2615         ALC262_FIXUP_INTEL_BAYLEYBAY,
2616 };
2617
2618 static const struct hda_fixup alc262_fixups[] = {
2619         [ALC262_FIXUP_FSC_H270] = {
2620                 .type = HDA_FIXUP_PINS,
2621                 .v.pins = (const struct hda_pintbl[]) {
2622                         { 0x14, 0x99130110 }, /* speaker */
2623                         { 0x15, 0x0221142f }, /* front HP */
2624                         { 0x1b, 0x0121141f }, /* rear HP */
2625                         { }
2626                 }
2627         },
2628         [ALC262_FIXUP_FSC_S7110] = {
2629                 .type = HDA_FIXUP_PINS,
2630                 .v.pins = (const struct hda_pintbl[]) {
2631                         { 0x15, 0x90170110 }, /* speaker */
2632                         { }
2633                 },
2634                 .chained = true,
2635                 .chain_id = ALC262_FIXUP_BENQ,
2636         },
2637         [ALC262_FIXUP_HP_Z200] = {
2638                 .type = HDA_FIXUP_PINS,
2639                 .v.pins = (const struct hda_pintbl[]) {
2640                         { 0x16, 0x99130120 }, /* internal speaker */
2641                         { }
2642                 }
2643         },
2644         [ALC262_FIXUP_TYAN] = {
2645                 .type = HDA_FIXUP_PINS,
2646                 .v.pins = (const struct hda_pintbl[]) {
2647                         { 0x14, 0x1993e1f0 }, /* int AUX */
2648                         { }
2649                 }
2650         },
2651         [ALC262_FIXUP_LENOVO_3000] = {
2652                 .type = HDA_FIXUP_PINCTLS,
2653                 .v.pins = (const struct hda_pintbl[]) {
2654                         { 0x19, PIN_VREF50 },
2655                         {}
2656                 },
2657                 .chained = true,
2658                 .chain_id = ALC262_FIXUP_BENQ,
2659         },
2660         [ALC262_FIXUP_BENQ] = {
2661                 .type = HDA_FIXUP_VERBS,
2662                 .v.verbs = (const struct hda_verb[]) {
2663                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x07 },
2664                         { 0x20, AC_VERB_SET_PROC_COEF, 0x3070 },
2665                         {}
2666                 }
2667         },
2668         [ALC262_FIXUP_BENQ_T31] = {
2669                 .type = HDA_FIXUP_VERBS,
2670                 .v.verbs = (const struct hda_verb[]) {
2671                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x07 },
2672                         { 0x20, AC_VERB_SET_PROC_COEF, 0x3050 },
2673                         {}
2674                 }
2675         },
2676         [ALC262_FIXUP_INV_DMIC] = {
2677                 .type = HDA_FIXUP_FUNC,
2678                 .v.func = alc_fixup_inv_dmic,
2679         },
2680         [ALC262_FIXUP_INTEL_BAYLEYBAY] = {
2681                 .type = HDA_FIXUP_FUNC,
2682                 .v.func = alc_fixup_no_depop_delay,
2683         },
2684 };
2685
2686 static const struct snd_pci_quirk alc262_fixup_tbl[] = {
2687         SND_PCI_QUIRK(0x103c, 0x170b, "HP Z200", ALC262_FIXUP_HP_Z200),
2688         SND_PCI_QUIRK(0x10cf, 0x1397, "Fujitsu Lifebook S7110", ALC262_FIXUP_FSC_S7110),
2689         SND_PCI_QUIRK(0x10cf, 0x142d, "Fujitsu Lifebook E8410", ALC262_FIXUP_BENQ),
2690         SND_PCI_QUIRK(0x10f1, 0x2915, "Tyan Thunder n6650W", ALC262_FIXUP_TYAN),
2691         SND_PCI_QUIRK(0x1734, 0x1141, "FSC ESPRIMO U9210", ALC262_FIXUP_FSC_H270),
2692         SND_PCI_QUIRK(0x1734, 0x1147, "FSC Celsius H270", ALC262_FIXUP_FSC_H270),
2693         SND_PCI_QUIRK(0x17aa, 0x384e, "Lenovo 3000", ALC262_FIXUP_LENOVO_3000),
2694         SND_PCI_QUIRK(0x17ff, 0x0560, "Benq ED8", ALC262_FIXUP_BENQ),
2695         SND_PCI_QUIRK(0x17ff, 0x058d, "Benq T31-16", ALC262_FIXUP_BENQ_T31),
2696         SND_PCI_QUIRK(0x8086, 0x7270, "BayleyBay", ALC262_FIXUP_INTEL_BAYLEYBAY),
2697         {}
2698 };
2699
2700 static const struct hda_model_fixup alc262_fixup_models[] = {
2701         {.id = ALC262_FIXUP_INV_DMIC, .name = "inv-dmic"},
2702         {.id = ALC262_FIXUP_FSC_H270, .name = "fsc-h270"},
2703         {.id = ALC262_FIXUP_FSC_S7110, .name = "fsc-s7110"},
2704         {.id = ALC262_FIXUP_HP_Z200, .name = "hp-z200"},
2705         {.id = ALC262_FIXUP_TYAN, .name = "tyan"},
2706         {.id = ALC262_FIXUP_LENOVO_3000, .name = "lenovo-3000"},
2707         {.id = ALC262_FIXUP_BENQ, .name = "benq"},
2708         {.id = ALC262_FIXUP_BENQ_T31, .name = "benq-t31"},
2709         {.id = ALC262_FIXUP_INTEL_BAYLEYBAY, .name = "bayleybay"},
2710         {}
2711 };
2712
2713 /*
2714  */
2715 static int patch_alc262(struct hda_codec *codec)
2716 {
2717         struct alc_spec *spec;
2718         int err;
2719
2720         err = alc_alloc_spec(codec, 0x0b);
2721         if (err < 0)
2722                 return err;
2723
2724         spec = codec->spec;
2725         spec->gen.shared_mic_vref_pin = 0x18;
2726
2727         spec->shutup = alc_eapd_shutup;
2728
2729 #if 0
2730         /* pshou 07/11/05  set a zero PCM sample to DAC when FIFO is
2731          * under-run
2732          */
2733         alc_update_coefex_idx(codec, 0x1a, 7, 0, 0x80);
2734 #endif
2735         alc_fix_pll_init(codec, 0x20, 0x0a, 10);
2736
2737         alc_pre_init(codec);
2738
2739         snd_hda_pick_fixup(codec, alc262_fixup_models, alc262_fixup_tbl,
2740                        alc262_fixups);
2741         snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE);
2742
2743         alc_auto_parse_customize_define(codec);
2744
2745         if (has_cdefine_beep(codec))
2746                 spec->gen.beep_nid = 0x01;
2747
2748         /* automatic parse from the BIOS config */
2749         err = alc262_parse_auto_config(codec);
2750         if (err < 0)
2751                 goto error;
2752
2753         if (!spec->gen.no_analog && spec->gen.beep_nid) {
2754                 err = set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
2755                 if (err < 0)
2756                         goto error;
2757         }
2758
2759         snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE);
2760
2761         return 0;
2762
2763  error:
2764         alc_free(codec);
2765         return err;
2766 }
2767
2768 /*
2769  *  ALC268
2770  */
2771 /* bind Beep switches of both NID 0x0f and 0x10 */
2772 static int alc268_beep_switch_put(struct snd_kcontrol *kcontrol,
2773                                   struct snd_ctl_elem_value *ucontrol)
2774 {
2775         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2776         unsigned long pval;
2777         int err;
2778
2779         mutex_lock(&codec->control_mutex);
2780         pval = kcontrol->private_value;
2781         kcontrol->private_value = (pval & ~0xff) | 0x0f;
2782         err = snd_hda_mixer_amp_switch_put(kcontrol, ucontrol);
2783         if (err >= 0) {
2784                 kcontrol->private_value = (pval & ~0xff) | 0x10;
2785                 err = snd_hda_mixer_amp_switch_put(kcontrol, ucontrol);
2786         }
2787         kcontrol->private_value = pval;
2788         mutex_unlock(&codec->control_mutex);
2789         return err;
2790 }
2791
2792 static const struct snd_kcontrol_new alc268_beep_mixer[] = {
2793         HDA_CODEC_VOLUME("Beep Playback Volume", 0x1d, 0x0, HDA_INPUT),
2794         {
2795                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2796                 .name = "Beep Playback Switch",
2797                 .subdevice = HDA_SUBDEV_AMP_FLAG,
2798                 .info = snd_hda_mixer_amp_switch_info,
2799                 .get = snd_hda_mixer_amp_switch_get,
2800                 .put = alc268_beep_switch_put,
2801                 .private_value = HDA_COMPOSE_AMP_VAL(0x0f, 3, 1, HDA_INPUT)
2802         },
2803 };
2804
2805 /* set PCBEEP vol = 0, mute connections */
2806 static const struct hda_verb alc268_beep_init_verbs[] = {
2807         {0x1d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
2808         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
2809         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
2810         { }
2811 };
2812
2813 enum {
2814         ALC268_FIXUP_INV_DMIC,
2815         ALC268_FIXUP_HP_EAPD,
2816         ALC268_FIXUP_SPDIF,
2817 };
2818
2819 static const struct hda_fixup alc268_fixups[] = {
2820         [ALC268_FIXUP_INV_DMIC] = {
2821                 .type = HDA_FIXUP_FUNC,
2822                 .v.func = alc_fixup_inv_dmic,
2823         },
2824         [ALC268_FIXUP_HP_EAPD] = {
2825                 .type = HDA_FIXUP_VERBS,
2826                 .v.verbs = (const struct hda_verb[]) {
2827                         {0x15, AC_VERB_SET_EAPD_BTLENABLE, 0},
2828                         {}
2829                 }
2830         },
2831         [ALC268_FIXUP_SPDIF] = {
2832                 .type = HDA_FIXUP_PINS,
2833                 .v.pins = (const struct hda_pintbl[]) {
2834                         { 0x1e, 0x014b1180 }, /* enable SPDIF out */
2835                         {}
2836                 }
2837         },
2838 };
2839
2840 static const struct hda_model_fixup alc268_fixup_models[] = {
2841         {.id = ALC268_FIXUP_INV_DMIC, .name = "inv-dmic"},
2842         {.id = ALC268_FIXUP_HP_EAPD, .name = "hp-eapd"},
2843         {.id = ALC268_FIXUP_SPDIF, .name = "spdif"},
2844         {}
2845 };
2846
2847 static const struct snd_pci_quirk alc268_fixup_tbl[] = {
2848         SND_PCI_QUIRK(0x1025, 0x0139, "Acer TravelMate 6293", ALC268_FIXUP_SPDIF),
2849         SND_PCI_QUIRK(0x1025, 0x015b, "Acer AOA 150 (ZG5)", ALC268_FIXUP_INV_DMIC),
2850         /* below is codec SSID since multiple Toshiba laptops have the
2851          * same PCI SSID 1179:ff00
2852          */
2853         SND_PCI_QUIRK(0x1179, 0xff06, "Toshiba P200", ALC268_FIXUP_HP_EAPD),
2854         {}
2855 };
2856
2857 /*
2858  * BIOS auto configuration
2859  */
2860 static int alc268_parse_auto_config(struct hda_codec *codec)
2861 {
2862         static const hda_nid_t alc268_ssids[] = { 0x15, 0x1b, 0x14, 0 };
2863         return alc_parse_auto_config(codec, NULL, alc268_ssids);
2864 }
2865
2866 /*
2867  */
2868 static int patch_alc268(struct hda_codec *codec)
2869 {
2870         struct alc_spec *spec;
2871         int i, err;
2872
2873         /* ALC268 has no aa-loopback mixer */
2874         err = alc_alloc_spec(codec, 0);
2875         if (err < 0)
2876                 return err;
2877
2878         spec = codec->spec;
2879         if (has_cdefine_beep(codec))
2880                 spec->gen.beep_nid = 0x01;
2881
2882         spec->shutup = alc_eapd_shutup;
2883
2884         alc_pre_init(codec);
2885
2886         snd_hda_pick_fixup(codec, alc268_fixup_models, alc268_fixup_tbl, alc268_fixups);
2887         snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE);
2888
2889         /* automatic parse from the BIOS config */
2890         err = alc268_parse_auto_config(codec);
2891         if (err < 0)
2892                 goto error;
2893
2894         if (err > 0 && !spec->gen.no_analog &&
2895             spec->gen.autocfg.speaker_pins[0] != 0x1d) {
2896                 for (i = 0; i < ARRAY_SIZE(alc268_beep_mixer); i++) {
2897                         if (!snd_hda_gen_add_kctl(&spec->gen, NULL,
2898                                                   &alc268_beep_mixer[i])) {
2899                                 err = -ENOMEM;
2900                                 goto error;
2901                         }
2902                 }
2903                 snd_hda_add_verbs(codec, alc268_beep_init_verbs);
2904                 if (!query_amp_caps(codec, 0x1d, HDA_INPUT))
2905                         /* override the amp caps for beep generator */
2906                         snd_hda_override_amp_caps(codec, 0x1d, HDA_INPUT,
2907                                           (0x0c << AC_AMPCAP_OFFSET_SHIFT) |
2908                                           (0x0c << AC_AMPCAP_NUM_STEPS_SHIFT) |
2909                                           (0x07 << AC_AMPCAP_STEP_SIZE_SHIFT) |
2910                                           (0 << AC_AMPCAP_MUTE_SHIFT));
2911         }
2912
2913         snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE);
2914
2915         return 0;
2916
2917  error:
2918         alc_free(codec);
2919         return err;
2920 }
2921
2922 /*
2923  * ALC269
2924  */
2925
2926 static const struct hda_pcm_stream alc269_44k_pcm_analog_playback = {
2927         .rates = SNDRV_PCM_RATE_44100, /* fixed rate */
2928 };
2929
2930 static const struct hda_pcm_stream alc269_44k_pcm_analog_capture = {
2931         .rates = SNDRV_PCM_RATE_44100, /* fixed rate */
2932 };
2933
2934 /* different alc269-variants */
2935 enum {
2936         ALC269_TYPE_ALC269VA,
2937         ALC269_TYPE_ALC269VB,
2938         ALC269_TYPE_ALC269VC,
2939         ALC269_TYPE_ALC269VD,
2940         ALC269_TYPE_ALC280,
2941         ALC269_TYPE_ALC282,
2942         ALC269_TYPE_ALC283,
2943         ALC269_TYPE_ALC284,
2944         ALC269_TYPE_ALC293,
2945         ALC269_TYPE_ALC286,
2946         ALC269_TYPE_ALC298,
2947         ALC269_TYPE_ALC255,
2948         ALC269_TYPE_ALC256,
2949         ALC269_TYPE_ALC257,
2950         ALC269_TYPE_ALC215,
2951         ALC269_TYPE_ALC225,
2952         ALC269_TYPE_ALC294,
2953         ALC269_TYPE_ALC300,
2954         ALC269_TYPE_ALC623,
2955         ALC269_TYPE_ALC700,
2956 };
2957
2958 /*
2959  * BIOS auto configuration
2960  */
2961 static int alc269_parse_auto_config(struct hda_codec *codec)
2962 {
2963         static const hda_nid_t alc269_ignore[] = { 0x1d, 0 };
2964         static const hda_nid_t alc269_ssids[] = { 0, 0x1b, 0x14, 0x21 };
2965         static const hda_nid_t alc269va_ssids[] = { 0x15, 0x1b, 0x14, 0 };
2966         struct alc_spec *spec = codec->spec;
2967         const hda_nid_t *ssids;
2968
2969         switch (spec->codec_variant) {
2970         case ALC269_TYPE_ALC269VA:
2971         case ALC269_TYPE_ALC269VC:
2972         case ALC269_TYPE_ALC280:
2973         case ALC269_TYPE_ALC284:
2974         case ALC269_TYPE_ALC293:
2975                 ssids = alc269va_ssids;
2976                 break;
2977         case ALC269_TYPE_ALC269VB:
2978         case ALC269_TYPE_ALC269VD:
2979         case ALC269_TYPE_ALC282:
2980         case ALC269_TYPE_ALC283:
2981         case ALC269_TYPE_ALC286:
2982         case ALC269_TYPE_ALC298:
2983         case ALC269_TYPE_ALC255:
2984         case ALC269_TYPE_ALC256:
2985         case ALC269_TYPE_ALC257:
2986         case ALC269_TYPE_ALC215:
2987         case ALC269_TYPE_ALC225:
2988         case ALC269_TYPE_ALC294:
2989         case ALC269_TYPE_ALC300:
2990         case ALC269_TYPE_ALC623:
2991         case ALC269_TYPE_ALC700:
2992                 ssids = alc269_ssids;
2993                 break;
2994         default:
2995                 ssids = alc269_ssids;
2996                 break;
2997         }
2998
2999         return alc_parse_auto_config(codec, alc269_ignore, ssids);
3000 }
3001
3002 static const struct hda_jack_keymap alc_headset_btn_keymap[] = {
3003         { SND_JACK_BTN_0, KEY_PLAYPAUSE },
3004         { SND_JACK_BTN_1, KEY_VOICECOMMAND },
3005         { SND_JACK_BTN_2, KEY_VOLUMEUP },
3006         { SND_JACK_BTN_3, KEY_VOLUMEDOWN },
3007         {}
3008 };
3009
3010 static void alc_headset_btn_callback(struct hda_codec *codec,
3011                                      struct hda_jack_callback *jack)
3012 {
3013         int report = 0;
3014
3015         if (jack->unsol_res & (7 << 13))
3016                 report |= SND_JACK_BTN_0;
3017
3018         if (jack->unsol_res  & (1 << 16 | 3 << 8))
3019                 report |= SND_JACK_BTN_1;
3020
3021         /* Volume up key */
3022         if (jack->unsol_res & (7 << 23))
3023                 report |= SND_JACK_BTN_2;
3024
3025         /* Volume down key */
3026         if (jack->unsol_res & (7 << 10))
3027                 report |= SND_JACK_BTN_3;
3028
3029         jack->jack->button_state = report;
3030 }
3031
3032 static void alc_disable_headset_jack_key(struct hda_codec *codec)
3033 {
3034         struct alc_spec *spec = codec->spec;
3035
3036         if (!spec->has_hs_key)
3037                 return;
3038
3039         switch (codec->core.vendor_id) {
3040         case 0x10ec0215:
3041         case 0x10ec0225:
3042         case 0x10ec0285:
3043         case 0x10ec0295:
3044         case 0x10ec0289:
3045         case 0x10ec0299:
3046                 alc_write_coef_idx(codec, 0x48, 0x0);
3047                 alc_update_coef_idx(codec, 0x49, 0x0045, 0x0);
3048                 alc_update_coef_idx(codec, 0x44, 0x0045 << 8, 0x0);
3049                 break;
3050         case 0x10ec0236:
3051         case 0x10ec0256:
3052                 alc_write_coef_idx(codec, 0x48, 0x0);
3053                 alc_update_coef_idx(codec, 0x49, 0x0045, 0x0);
3054                 break;
3055         }
3056 }
3057
3058 static void alc_enable_headset_jack_key(struct hda_codec *codec)
3059 {
3060         struct alc_spec *spec = codec->spec;
3061
3062         if (!spec->has_hs_key)
3063                 return;
3064
3065         switch (codec->core.vendor_id) {
3066         case 0x10ec0215:
3067         case 0x10ec0225:
3068         case 0x10ec0285:
3069         case 0x10ec0295:
3070         case 0x10ec0289:
3071         case 0x10ec0299:
3072                 alc_write_coef_idx(codec, 0x48, 0xd011);
3073                 alc_update_coef_idx(codec, 0x49, 0x007f, 0x0045);
3074                 alc_update_coef_idx(codec, 0x44, 0x007f << 8, 0x0045 << 8);
3075                 break;
3076         case 0x10ec0236:
3077         case 0x10ec0256:
3078                 alc_write_coef_idx(codec, 0x48, 0xd011);
3079                 alc_update_coef_idx(codec, 0x49, 0x007f, 0x0045);
3080                 break;
3081         }
3082 }
3083
3084 static void alc_fixup_headset_jack(struct hda_codec *codec,
3085                                     const struct hda_fixup *fix, int action)
3086 {
3087         struct alc_spec *spec = codec->spec;
3088
3089         switch (action) {
3090         case HDA_FIXUP_ACT_PRE_PROBE:
3091                 spec->has_hs_key = 1;
3092                 snd_hda_jack_detect_enable_callback(codec, 0x55,
3093                                                     alc_headset_btn_callback);
3094                 snd_hda_jack_add_kctl(codec, 0x55, "Headset Jack", false,
3095                                       SND_JACK_HEADSET, alc_headset_btn_keymap);
3096                 break;
3097         case HDA_FIXUP_ACT_INIT:
3098                 alc_enable_headset_jack_key(codec);
3099                 break;
3100         }
3101 }
3102
3103 static void alc269vb_toggle_power_output(struct hda_codec *codec, int power_up)
3104 {
3105         alc_update_coef_idx(codec, 0x04, 1 << 11, power_up ? (1 << 11) : 0);
3106 }
3107
3108 static void alc269_shutup(struct hda_codec *codec)
3109 {
3110         struct alc_spec *spec = codec->spec;
3111
3112         if (spec->codec_variant == ALC269_TYPE_ALC269VB)
3113                 alc269vb_toggle_power_output(codec, 0);
3114         if (spec->codec_variant == ALC269_TYPE_ALC269VB &&
3115                         (alc_get_coef0(codec) & 0x00ff) == 0x018) {
3116                 msleep(150);
3117         }
3118         alc_shutup_pins(codec);
3119 }
3120
3121 static const struct coef_fw alc282_coefs[] = {
3122         WRITE_COEF(0x03, 0x0002), /* Power Down Control */
3123         UPDATE_COEF(0x05, 0xff3f, 0x0700), /* FIFO and filter clock */
3124         WRITE_COEF(0x07, 0x0200), /* DMIC control */
3125         UPDATE_COEF(0x06, 0x00f0, 0), /* Analog clock */
3126         UPDATE_COEF(0x08, 0xfffc, 0x0c2c), /* JD */
3127         WRITE_COEF(0x0a, 0xcccc), /* JD offset1 */
3128         WRITE_COEF(0x0b, 0xcccc), /* JD offset2 */
3129         WRITE_COEF(0x0e, 0x6e00), /* LDO1/2/3, DAC/ADC */
3130         UPDATE_COEF(0x0f, 0xf800, 0x1000), /* JD */
3131         UPDATE_COEF(0x10, 0xfc00, 0x0c00), /* Capless */
3132         WRITE_COEF(0x6f, 0x0), /* Class D test 4 */
3133         UPDATE_COEF(0x0c, 0xfe00, 0), /* IO power down directly */
3134         WRITE_COEF(0x34, 0xa0c0), /* ANC */
3135         UPDATE_COEF(0x16, 0x0008, 0), /* AGC MUX */
3136         UPDATE_COEF(0x1d, 0x00e0, 0), /* DAC simple content protection */
3137         UPDATE_COEF(0x1f, 0x00e0, 0), /* ADC simple content protection */
3138         WRITE_COEF(0x21, 0x8804), /* DAC ADC Zero Detection */
3139         WRITE_COEF(0x63, 0x2902), /* PLL */
3140         WRITE_COEF(0x68, 0xa080), /* capless control 2 */
3141         WRITE_COEF(0x69, 0x3400), /* capless control 3 */
3142         WRITE_COEF(0x6a, 0x2f3e), /* capless control 4 */
3143         WRITE_COEF(0x6b, 0x0), /* capless control 5 */
3144         UPDATE_COEF(0x6d, 0x0fff, 0x0900), /* class D test 2 */
3145         WRITE_COEF(0x6e, 0x110a), /* class D test 3 */
3146         UPDATE_COEF(0x70, 0x00f8, 0x00d8), /* class D test 5 */
3147         WRITE_COEF(0x71, 0x0014), /* class D test 6 */
3148         WRITE_COEF(0x72, 0xc2ba), /* classD OCP */
3149         UPDATE_COEF(0x77, 0x0f80, 0), /* classD pure DC test */
3150         WRITE_COEF(0x6c, 0xfc06), /* Class D amp control */
3151         {}
3152 };
3153
3154 static void alc282_restore_default_value(struct hda_codec *codec)
3155 {
3156         alc_process_coef_fw(codec, alc282_coefs);
3157 }
3158
3159 static void alc282_init(struct hda_codec *codec)
3160 {
3161         struct alc_spec *spec = codec->spec;
3162         hda_nid_t hp_pin = alc_get_hp_pin(spec);
3163         bool hp_pin_sense;
3164         int coef78;
3165
3166         alc282_restore_default_value(codec);
3167
3168         if (!hp_pin)
3169                 return;
3170         hp_pin_sense = snd_hda_jack_detect(codec, hp_pin);
3171         coef78 = alc_read_coef_idx(codec, 0x78);
3172
3173         /* Index 0x78 Direct Drive HP AMP LPM Control 1 */
3174         /* Headphone capless set to high power mode */
3175         alc_write_coef_idx(codec, 0x78, 0x9004);
3176
3177         if (hp_pin_sense)
3178                 msleep(2);
3179
3180         snd_hda_codec_write(codec, hp_pin, 0,
3181                             AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);
3182
3183         if (hp_pin_sense)
3184                 msleep(85);
3185
3186         snd_hda_codec_write(codec, hp_pin, 0,
3187                             AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT);
3188
3189         if (hp_pin_sense)
3190                 msleep(100);
3191
3192         /* Headphone capless set to normal mode */
3193         alc_write_coef_idx(codec, 0x78, coef78);
3194 }
3195
3196 static void alc282_shutup(struct hda_codec *codec)
3197 {
3198         struct alc_spec *spec = codec->spec;
3199         hda_nid_t hp_pin = alc_get_hp_pin(spec);
3200         bool hp_pin_sense;
3201         int coef78;
3202
3203         if (!hp_pin) {
3204                 alc269_shutup(codec);
3205                 return;
3206         }
3207
3208         hp_pin_sense = snd_hda_jack_detect(codec, hp_pin);
3209         coef78 = alc_read_coef_idx(codec, 0x78);
3210         alc_write_coef_idx(codec, 0x78, 0x9004);
3211
3212         if (hp_pin_sense)
3213                 msleep(2);
3214
3215         snd_hda_codec_write(codec, hp_pin, 0,
3216                             AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);
3217
3218         if (hp_pin_sense)
3219                 msleep(85);
3220
3221         if (!spec->no_shutup_pins)
3222                 snd_hda_codec_write(codec, hp_pin, 0,
3223                                     AC_VERB_SET_PIN_WIDGET_CONTROL, 0x0);
3224
3225         if (hp_pin_sense)
3226                 msleep(100);
3227
3228         alc_auto_setup_eapd(codec, false);
3229         alc_shutup_pins(codec);
3230         alc_write_coef_idx(codec, 0x78, coef78);
3231 }
3232
3233 static const struct coef_fw alc283_coefs[] = {
3234         WRITE_COEF(0x03, 0x0002), /* Power Down Control */
3235         UPDATE_COEF(0x05, 0xff3f, 0x0700), /* FIFO and filter clock */
3236         WRITE_COEF(0x07, 0x0200), /* DMIC control */
3237         UPDATE_COEF(0x06, 0x00f0, 0), /* Analog clock */
3238         UPDATE_COEF(0x08, 0xfffc, 0x0c2c), /* JD */
3239         WRITE_COEF(0x0a, 0xcccc), /* JD offset1 */
3240         WRITE_COEF(0x0b, 0xcccc), /* JD offset2 */
3241         WRITE_COEF(0x0e, 0x6fc0), /* LDO1/2/3, DAC/ADC */
3242         UPDATE_COEF(0x0f, 0xf800, 0x1000), /* JD */
3243         UPDATE_COEF(0x10, 0xfc00, 0x0c00), /* Capless */
3244         WRITE_COEF(0x3a, 0x0), /* Class D test 4 */
3245         UPDATE_COEF(0x0c, 0xfe00, 0x0), /* IO power down directly */
3246         WRITE_COEF(0x22, 0xa0c0), /* ANC */
3247         UPDATE_COEFEX(0x53, 0x01, 0x000f, 0x0008), /* AGC MUX */
3248         UPDATE_COEF(0x1d, 0x00e0, 0), /* DAC simple content protection */
3249         UPDATE_COEF(0x1f, 0x00e0, 0), /* ADC simple content protection */
3250         WRITE_COEF(0x21, 0x8804), /* DAC ADC Zero Detection */
3251         WRITE_COEF(0x2e, 0x2902), /* PLL */
3252         WRITE_COEF(0x33, 0xa080), /* capless control 2 */
3253         WRITE_COEF(0x34, 0x3400), /* capless control 3 */
3254         WRITE_COEF(0x35, 0x2f3e), /* capless control 4 */
3255         WRITE_COEF(0x36, 0x0), /* capless control 5 */
3256         UPDATE_COEF(0x38, 0x0fff, 0x0900), /* class D test 2 */
3257         WRITE_COEF(0x39, 0x110a), /* class D test 3 */
3258         UPDATE_COEF(0x3b, 0x00f8, 0x00d8), /* class D test 5 */
3259         WRITE_COEF(0x3c, 0x0014), /* class D test 6 */
3260         WRITE_COEF(0x3d, 0xc2ba), /* classD OCP */
3261         UPDATE_COEF(0x42, 0x0f80, 0x0), /* classD pure DC test */
3262         WRITE_COEF(0x49, 0x0), /* test mode */
3263         UPDATE_COEF(0x40, 0xf800, 0x9800), /* Class D DC enable */
3264         UPDATE_COEF(0x42, 0xf000, 0x2000), /* DC offset */
3265         WRITE_COEF(0x37, 0xfc06), /* Class D amp control */
3266         UPDATE_COEF(0x1b, 0x8000, 0), /* HP JD control */
3267         {}
3268 };
3269
3270 static void alc283_restore_default_value(struct hda_codec *codec)
3271 {
3272         alc_process_coef_fw(codec, alc283_coefs);
3273 }
3274
3275 static void alc283_init(struct hda_codec *codec)
3276 {
3277         struct alc_spec *spec = codec->spec;
3278         hda_nid_t hp_pin = alc_get_hp_pin(spec);
3279         bool hp_pin_sense;
3280
3281         alc283_restore_default_value(codec);
3282
3283         if (!hp_pin)
3284                 return;
3285
3286         msleep(30);
3287         hp_pin_sense = snd_hda_jack_detect(codec, hp_pin);
3288
3289         /* Index 0x43 Direct Drive HP AMP LPM Control 1 */
3290         /* Headphone capless set to high power mode */
3291         alc_write_coef_idx(codec, 0x43, 0x9004);
3292
3293         snd_hda_codec_write(codec, hp_pin, 0,
3294                             AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);
3295
3296         if (hp_pin_sense)
3297                 msleep(85);
3298
3299         snd_hda_codec_write(codec, hp_pin, 0,
3300                             AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT);
3301
3302         if (hp_pin_sense)
3303                 msleep(85);
3304         /* Index 0x46 Combo jack auto switch control 2 */
3305         /* 3k pull low control for Headset jack. */
3306         alc_update_coef_idx(codec, 0x46, 3 << 12, 0);
3307         /* Headphone capless set to normal mode */
3308         alc_write_coef_idx(codec, 0x43, 0x9614);
3309 }
3310
3311 static void alc283_shutup(struct hda_codec *codec)
3312 {
3313         struct alc_spec *spec = codec->spec;
3314         hda_nid_t hp_pin = alc_get_hp_pin(spec);
3315         bool hp_pin_sense;
3316
3317         if (!hp_pin) {
3318                 alc269_shutup(codec);
3319                 return;
3320         }
3321
3322         hp_pin_sense = snd_hda_jack_detect(codec, hp_pin);
3323
3324         alc_write_coef_idx(codec, 0x43, 0x9004);
3325
3326         /*depop hp during suspend*/
3327         alc_write_coef_idx(codec, 0x06, 0x2100);
3328
3329         snd_hda_codec_write(codec, hp_pin, 0,
3330                             AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);
3331
3332         if (hp_pin_sense)
3333                 msleep(100);
3334
3335         if (!spec->no_shutup_pins)
3336                 snd_hda_codec_write(codec, hp_pin, 0,
3337                                     AC_VERB_SET_PIN_WIDGET_CONTROL, 0x0);
3338
3339         alc_update_coef_idx(codec, 0x46, 0, 3 << 12);
3340
3341         if (hp_pin_sense)
3342                 msleep(100);
3343         alc_auto_setup_eapd(codec, false);
3344         alc_shutup_pins(codec);
3345         alc_write_coef_idx(codec, 0x43, 0x9614);
3346 }
3347
3348 static void alc256_init(struct hda_codec *codec)
3349 {
3350         struct alc_spec *spec = codec->spec;
3351         hda_nid_t hp_pin = alc_get_hp_pin(spec);
3352         bool hp_pin_sense;
3353
3354         if (!hp_pin)
3355                 hp_pin = 0x21;
3356
3357         msleep(30);
3358
3359         hp_pin_sense = snd_hda_jack_detect(codec, hp_pin);
3360
3361         if (hp_pin_sense)
3362                 msleep(2);
3363
3364         alc_update_coefex_idx(codec, 0x57, 0x04, 0x0007, 0x1); /* Low power */
3365         if (spec->ultra_low_power) {
3366                 alc_update_coef_idx(codec, 0x03, 1<<1, 1<<1);
3367                 alc_update_coef_idx(codec, 0x08, 3<<2, 3<<2);
3368                 alc_update_coef_idx(codec, 0x08, 7<<4, 0);
3369                 alc_update_coef_idx(codec, 0x3b, 1<<15, 0);
3370                 alc_update_coef_idx(codec, 0x0e, 7<<6, 7<<6);
3371                 msleep(30);
3372         }
3373
3374         snd_hda_codec_write(codec, hp_pin, 0,
3375                             AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);
3376
3377         if (hp_pin_sense || spec->ultra_low_power)
3378                 msleep(85);
3379
3380         snd_hda_codec_write(codec, hp_pin, 0,
3381                             AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT);
3382
3383         if (hp_pin_sense || spec->ultra_low_power)
3384                 msleep(100);
3385
3386         alc_update_coef_idx(codec, 0x46, 3 << 12, 0);
3387         alc_update_coefex_idx(codec, 0x57, 0x04, 0x0007, 0x4); /* Hight power */
3388         alc_update_coefex_idx(codec, 0x53, 0x02, 0x8000, 1 << 15); /* Clear bit */
3389         alc_update_coefex_idx(codec, 0x53, 0x02, 0x8000, 0 << 15);
3390         /*
3391          * Expose headphone mic (or possibly Line In on some machines) instead
3392          * of PC Beep on 1Ah, and disable 1Ah loopback for all outputs. See
3393          * Documentation/sound/hd-audio/realtek-pc-beep.rst for details of
3394          * this register.
3395          */
3396         alc_write_coef_idx(codec, 0x36, 0x5757);
3397 }
3398
3399 static void alc256_shutup(struct hda_codec *codec)
3400 {
3401         struct alc_spec *spec = codec->spec;
3402         hda_nid_t hp_pin = alc_get_hp_pin(spec);
3403         bool hp_pin_sense;
3404
3405         if (!hp_pin)
3406                 hp_pin = 0x21;
3407
3408         hp_pin_sense = snd_hda_jack_detect(codec, hp_pin);
3409
3410         if (hp_pin_sense)
3411                 msleep(2);
3412
3413         snd_hda_codec_write(codec, hp_pin, 0,
3414                             AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);
3415
3416         if (hp_pin_sense || spec->ultra_low_power)
3417                 msleep(85);
3418
3419         /* 3k pull low control for Headset jack. */
3420         /* NOTE: call this before clearing the pin, otherwise codec stalls */
3421         alc_update_coef_idx(codec, 0x46, 0, 3 << 12);
3422
3423         if (!spec->no_shutup_pins)
3424                 snd_hda_codec_write(codec, hp_pin, 0,
3425                                     AC_VERB_SET_PIN_WIDGET_CONTROL, 0x0);
3426
3427         if (hp_pin_sense || spec->ultra_low_power)
3428                 msleep(100);
3429
3430         alc_auto_setup_eapd(codec, false);
3431         alc_shutup_pins(codec);
3432         if (spec->ultra_low_power) {
3433                 msleep(50);
3434                 alc_update_coef_idx(codec, 0x03, 1<<1, 0);
3435                 alc_update_coef_idx(codec, 0x08, 7<<4, 7<<4);
3436                 alc_update_coef_idx(codec, 0x08, 3<<2, 0);
3437                 alc_update_coef_idx(codec, 0x3b, 1<<15, 1<<15);
3438                 alc_update_coef_idx(codec, 0x0e, 7<<6, 0);
3439                 msleep(30);
3440         }
3441 }
3442
3443 static void alc225_init(struct hda_codec *codec)
3444 {
3445         struct alc_spec *spec = codec->spec;
3446         hda_nid_t hp_pin = alc_get_hp_pin(spec);
3447         bool hp1_pin_sense, hp2_pin_sense;
3448
3449         if (!hp_pin)
3450                 hp_pin = 0x21;
3451         msleep(30);
3452
3453         hp1_pin_sense = snd_hda_jack_detect(codec, hp_pin);
3454         hp2_pin_sense = snd_hda_jack_detect(codec, 0x16);
3455
3456         if (hp1_pin_sense || hp2_pin_sense)
3457                 msleep(2);
3458
3459         alc_update_coefex_idx(codec, 0x57, 0x04, 0x0007, 0x1); /* Low power */
3460         if (spec->ultra_low_power) {
3461                 alc_update_coef_idx(codec, 0x08, 0x0f << 2, 3<<2);
3462                 alc_update_coef_idx(codec, 0x0e, 7<<6, 7<<6);
3463                 alc_update_coef_idx(codec, 0x33, 1<<11, 0);
3464                 msleep(30);
3465         }
3466
3467         if (hp1_pin_sense || spec->ultra_low_power)
3468                 snd_hda_codec_write(codec, hp_pin, 0,
3469                             AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);
3470         if (hp2_pin_sense)
3471                 snd_hda_codec_write(codec, 0x16, 0,
3472                             AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);
3473
3474         if (hp1_pin_sense || hp2_pin_sense || spec->ultra_low_power)
3475                 msleep(85);
3476
3477         if (hp1_pin_sense || spec->ultra_low_power)
3478                 snd_hda_codec_write(codec, hp_pin, 0,
3479                             AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT);
3480         if (hp2_pin_sense)
3481                 snd_hda_codec_write(codec, 0x16, 0,
3482                             AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT);
3483
3484         if (hp1_pin_sense || hp2_pin_sense || spec->ultra_low_power)
3485                 msleep(100);
3486
3487         alc_update_coef_idx(codec, 0x4a, 3 << 10, 0);
3488         alc_update_coefex_idx(codec, 0x57, 0x04, 0x0007, 0x4); /* Hight power */
3489 }
3490
3491 static void alc225_shutup(struct hda_codec *codec)
3492 {
3493         struct alc_spec *spec = codec->spec;
3494         hda_nid_t hp_pin = alc_get_hp_pin(spec);
3495         bool hp1_pin_sense, hp2_pin_sense;
3496
3497         if (!hp_pin)
3498                 hp_pin = 0x21;
3499
3500         alc_disable_headset_jack_key(codec);
3501         /* 3k pull low control for Headset jack. */
3502         alc_update_coef_idx(codec, 0x4a, 0, 3 << 10);
3503
3504         hp1_pin_sense = snd_hda_jack_detect(codec, hp_pin);
3505         hp2_pin_sense = snd_hda_jack_detect(codec, 0x16);
3506
3507         if (hp1_pin_sense || hp2_pin_sense)
3508                 msleep(2);
3509
3510         if (hp1_pin_sense || spec->ultra_low_power)
3511                 snd_hda_codec_write(codec, hp_pin, 0,
3512                             AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);
3513         if (hp2_pin_sense)
3514                 snd_hda_codec_write(codec, 0x16, 0,
3515                             AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);
3516
3517         if (hp1_pin_sense || hp2_pin_sense || spec->ultra_low_power)
3518                 msleep(85);
3519
3520         if (hp1_pin_sense || spec->ultra_low_power)
3521                 snd_hda_codec_write(codec, hp_pin, 0,
3522                             AC_VERB_SET_PIN_WIDGET_CONTROL, 0x0);
3523         if (hp2_pin_sense)
3524                 snd_hda_codec_write(codec, 0x16, 0,
3525                             AC_VERB_SET_PIN_WIDGET_CONTROL, 0x0);
3526
3527         if (hp1_pin_sense || hp2_pin_sense || spec->ultra_low_power)
3528                 msleep(100);
3529
3530         alc_auto_setup_eapd(codec, false);
3531         alc_shutup_pins(codec);
3532         if (spec->ultra_low_power) {
3533                 msleep(50);
3534                 alc_update_coef_idx(codec, 0x08, 0x0f << 2, 0x0c << 2);
3535                 alc_update_coef_idx(codec, 0x0e, 7<<6, 0);
3536                 alc_update_coef_idx(codec, 0x33, 1<<11, 1<<11);
3537                 alc_update_coef_idx(codec, 0x4a, 3<<4, 2<<4);
3538                 msleep(30);
3539         }
3540
3541         alc_update_coef_idx(codec, 0x4a, 3 << 10, 0);
3542         alc_enable_headset_jack_key(codec);
3543 }
3544
3545 static void alc_default_init(struct hda_codec *codec)
3546 {
3547         struct alc_spec *spec = codec->spec;
3548         hda_nid_t hp_pin = alc_get_hp_pin(spec);
3549         bool hp_pin_sense;
3550
3551         if (!hp_pin)
3552                 return;
3553
3554         msleep(30);
3555
3556         hp_pin_sense = snd_hda_jack_detect(codec, hp_pin);
3557
3558         if (hp_pin_sense)
3559                 msleep(2);
3560
3561         snd_hda_codec_write(codec, hp_pin, 0,
3562                             AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);
3563
3564         if (hp_pin_sense)
3565                 msleep(85);
3566
3567         snd_hda_codec_write(codec, hp_pin, 0,
3568                             AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT);
3569
3570         if (hp_pin_sense)
3571                 msleep(100);
3572 }
3573
3574 static void alc_default_shutup(struct hda_codec *codec)
3575 {
3576         struct alc_spec *spec = codec->spec;
3577         hda_nid_t hp_pin = alc_get_hp_pin(spec);
3578         bool hp_pin_sense;
3579
3580         if (!hp_pin) {
3581                 alc269_shutup(codec);
3582                 return;
3583         }
3584
3585         hp_pin_sense = snd_hda_jack_detect(codec, hp_pin);
3586
3587         if (hp_pin_sense)
3588                 msleep(2);
3589
3590         snd_hda_codec_write(codec, hp_pin, 0,
3591                             AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);
3592
3593         if (hp_pin_sense)
3594                 msleep(85);
3595
3596         if (!spec->no_shutup_pins)
3597                 snd_hda_codec_write(codec, hp_pin, 0,
3598                                     AC_VERB_SET_PIN_WIDGET_CONTROL, 0x0);
3599
3600         if (hp_pin_sense)
3601                 msleep(100);
3602
3603         alc_auto_setup_eapd(codec, false);
3604         alc_shutup_pins(codec);
3605 }
3606
3607 static void alc294_hp_init(struct hda_codec *codec)
3608 {
3609         struct alc_spec *spec = codec->spec;
3610         hda_nid_t hp_pin = alc_get_hp_pin(spec);
3611         int i, val;
3612
3613         if (!hp_pin)
3614                 return;
3615
3616         snd_hda_codec_write(codec, hp_pin, 0,
3617                             AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);
3618
3619         msleep(100);
3620
3621         if (!spec->no_shutup_pins)
3622                 snd_hda_codec_write(codec, hp_pin, 0,
3623                                     AC_VERB_SET_PIN_WIDGET_CONTROL, 0x0);
3624
3625         alc_update_coef_idx(codec, 0x6f, 0x000f, 0);/* Set HP depop to manual mode */
3626         alc_update_coefex_idx(codec, 0x58, 0x00, 0x8000, 0x8000); /* HP depop procedure start */
3627
3628         /* Wait for depop procedure finish  */
3629         val = alc_read_coefex_idx(codec, 0x58, 0x01);
3630         for (i = 0; i < 20 && val & 0x0080; i++) {
3631                 msleep(50);
3632                 val = alc_read_coefex_idx(codec, 0x58, 0x01);
3633         }
3634         /* Set HP depop to auto mode */
3635         alc_update_coef_idx(codec, 0x6f, 0x000f, 0x000b);
3636         msleep(50);
3637 }
3638
3639 static void alc294_init(struct hda_codec *codec)
3640 {
3641         struct alc_spec *spec = codec->spec;
3642
3643         /* required only at boot or S4 resume time */
3644         if (!spec->done_hp_init ||
3645             codec->core.dev.power.power_state.event == PM_EVENT_RESTORE) {
3646                 alc294_hp_init(codec);
3647                 spec->done_hp_init = true;
3648         }
3649         alc_default_init(codec);
3650 }
3651
3652 static void alc5505_coef_set(struct hda_codec *codec, unsigned int index_reg,
3653                              unsigned int val)
3654 {
3655         snd_hda_codec_write(codec, 0x51, 0, AC_VERB_SET_COEF_INDEX, index_reg >> 1);
3656         snd_hda_codec_write(codec, 0x51, 0, AC_VERB_SET_PROC_COEF, val & 0xffff); /* LSB */
3657         snd_hda_codec_write(codec, 0x51, 0, AC_VERB_SET_PROC_COEF, val >> 16); /* MSB */
3658 }
3659
3660 static int alc5505_coef_get(struct hda_codec *codec, unsigned int index_reg)
3661 {
3662         unsigned int val;
3663
3664         snd_hda_codec_write(codec, 0x51, 0, AC_VERB_SET_COEF_INDEX, index_reg >> 1);
3665         val = snd_hda_codec_read(codec, 0x51, 0, AC_VERB_GET_PROC_COEF, 0)
3666                 & 0xffff;
3667         val |= snd_hda_codec_read(codec, 0x51, 0, AC_VERB_GET_PROC_COEF, 0)
3668                 << 16;
3669         return val;
3670 }
3671
3672 static void alc5505_dsp_halt(struct hda_codec *codec)
3673 {
3674         unsigned int val;
3675
3676         alc5505_coef_set(codec, 0x3000, 0x000c); /* DSP CPU stop */
3677         alc5505_coef_set(codec, 0x880c, 0x0008); /* DDR enter self refresh */
3678         alc5505_coef_set(codec, 0x61c0, 0x11110080); /* Clock control for PLL and CPU */
3679         alc5505_coef_set(codec, 0x6230, 0xfc0d4011); /* Disable Input OP */
3680         alc5505_coef_set(codec, 0x61b4, 0x040a2b03); /* Stop PLL2 */
3681         alc5505_coef_set(codec, 0x61b0, 0x00005b17); /* Stop PLL1 */
3682         alc5505_coef_set(codec, 0x61b8, 0x04133303); /* Stop PLL3 */
3683         val = alc5505_coef_get(codec, 0x6220);
3684         alc5505_coef_set(codec, 0x6220, (val | 0x3000)); /* switch Ringbuffer clock to DBUS clock */
3685 }
3686
3687 static void alc5505_dsp_back_from_halt(struct hda_codec *codec)
3688 {
3689         alc5505_coef_set(codec, 0x61b8, 0x04133302);
3690         alc5505_coef_set(codec, 0x61b0, 0x00005b16);
3691         alc5505_coef_set(codec, 0x61b4, 0x040a2b02);
3692         alc5505_coef_set(codec, 0x6230, 0xf80d4011);
3693         alc5505_coef_set(codec, 0x6220, 0x2002010f);
3694         alc5505_coef_set(codec, 0x880c, 0x00000004);
3695 }
3696
3697 static void alc5505_dsp_init(struct hda_codec *codec)
3698 {
3699         unsigned int val;
3700
3701         alc5505_dsp_halt(codec);
3702         alc5505_dsp_back_from_halt(codec);
3703         alc5505_coef_set(codec, 0x61b0, 0x5b14); /* PLL1 control */
3704         alc5505_coef_set(codec, 0x61b0, 0x5b16);
3705         alc5505_coef_set(codec, 0x61b4, 0x04132b00); /* PLL2 control */
3706         alc5505_coef_set(codec, 0x61b4, 0x04132b02);
3707         alc5505_coef_set(codec, 0x61b8, 0x041f3300); /* PLL3 control*/
3708         alc5505_coef_set(codec, 0x61b8, 0x041f3302);
3709         snd_hda_codec_write(codec, 0x51, 0, AC_VERB_SET_CODEC_RESET, 0); /* Function reset */
3710         alc5505_coef_set(codec, 0x61b8, 0x041b3302);
3711         alc5505_coef_set(codec, 0x61b8, 0x04173302);
3712         alc5505_coef_set(codec, 0x61b8, 0x04163302);
3713         alc5505_coef_set(codec, 0x8800, 0x348b328b); /* DRAM control */
3714         alc5505_coef_set(codec, 0x8808, 0x00020022); /* DRAM control */
3715         alc5505_coef_set(codec, 0x8818, 0x00000400); /* DRAM control */
3716
3717         val = alc5505_coef_get(codec, 0x6200) >> 16; /* Read revision ID */
3718         if (val <= 3)
3719                 alc5505_coef_set(codec, 0x6220, 0x2002010f); /* I/O PAD Configuration */
3720         else
3721                 alc5505_coef_set(codec, 0x6220, 0x6002018f);
3722
3723         alc5505_coef_set(codec, 0x61ac, 0x055525f0); /**/
3724         alc5505_coef_set(codec, 0x61c0, 0x12230080); /* Clock control */
3725         alc5505_coef_set(codec, 0x61b4, 0x040e2b02); /* PLL2 control */
3726         alc5505_coef_set(codec, 0x61bc, 0x010234f8); /* OSC Control */
3727         alc5505_coef_set(codec, 0x880c, 0x00000004); /* DRAM Function control */
3728         alc5505_coef_set(codec, 0x880c, 0x00000003);
3729         alc5505_coef_set(codec, 0x880c, 0x00000010);
3730
3731 #ifdef HALT_REALTEK_ALC5505
3732         alc5505_dsp_halt(codec);
3733 #endif
3734 }
3735
3736 #ifdef HALT_REALTEK_ALC5505
3737 #define alc5505_dsp_suspend(codec)      do { } while (0) /* NOP */
3738 #define alc5505_dsp_resume(codec)       do { } while (0) /* NOP */
3739 #else
3740 #define alc5505_dsp_suspend(codec)      alc5505_dsp_halt(codec)
3741 #define alc5505_dsp_resume(codec)       alc5505_dsp_back_from_halt(codec)
3742 #endif
3743
3744 #ifdef CONFIG_PM
3745 static int alc269_suspend(struct hda_codec *codec)
3746 {
3747         struct alc_spec *spec = codec->spec;
3748
3749         if (spec->has_alc5505_dsp)
3750                 alc5505_dsp_suspend(codec);
3751         return alc_suspend(codec);
3752 }
3753
3754 static int alc269_resume(struct hda_codec *codec)
3755 {
3756         struct alc_spec *spec = codec->spec;
3757
3758         if (spec->codec_variant == ALC269_TYPE_ALC269VB)
3759                 alc269vb_toggle_power_output(codec, 0);
3760         if (spec->codec_variant == ALC269_TYPE_ALC269VB &&
3761                         (alc_get_coef0(codec) & 0x00ff) == 0x018) {
3762                 msleep(150);
3763         }
3764
3765         codec->patch_ops.init(codec);
3766
3767         if (spec->codec_variant == ALC269_TYPE_ALC269VB)
3768                 alc269vb_toggle_power_output(codec, 1);
3769         if (spec->codec_variant == ALC269_TYPE_ALC269VB &&
3770                         (alc_get_coef0(codec) & 0x00ff) == 0x017) {
3771                 msleep(200);
3772         }
3773
3774         snd_hda_regmap_sync(codec);
3775         hda_call_check_power_status(codec, 0x01);
3776
3777         /* on some machine, the BIOS will clear the codec gpio data when enter
3778          * suspend, and won't restore the data after resume, so we restore it
3779          * in the driver.
3780          */
3781         if (spec->gpio_data)
3782                 alc_write_gpio_data(codec);
3783
3784         if (spec->has_alc5505_dsp)
3785                 alc5505_dsp_resume(codec);
3786
3787         return 0;
3788 }
3789 #endif /* CONFIG_PM */
3790
3791 static void alc269_fixup_pincfg_no_hp_to_lineout(struct hda_codec *codec,
3792                                                  const struct hda_fixup *fix, int action)
3793 {
3794         struct alc_spec *spec = codec->spec;
3795
3796         if (action == HDA_FIXUP_ACT_PRE_PROBE)
3797                 spec->parse_flags = HDA_PINCFG_NO_HP_FIXUP;
3798 }
3799
3800 static void alc269_fixup_pincfg_U7x7_headset_mic(struct hda_codec *codec,
3801                                                  const struct hda_fixup *fix,
3802                                                  int action)
3803 {
3804         unsigned int cfg_headphone = snd_hda_codec_get_pincfg(codec, 0x21);
3805         unsigned int cfg_headset_mic = snd_hda_codec_get_pincfg(codec, 0x19);
3806
3807         if (cfg_headphone && cfg_headset_mic == 0x411111f0)
3808                 snd_hda_codec_set_pincfg(codec, 0x19,
3809                         (cfg_headphone & ~AC_DEFCFG_DEVICE) |
3810                         (AC_JACK_MIC_IN << AC_DEFCFG_DEVICE_SHIFT));
3811 }
3812
3813 static void alc269_fixup_hweq(struct hda_codec *codec,
3814                                const struct hda_fixup *fix, int action)
3815 {
3816         if (action == HDA_FIXUP_ACT_INIT)
3817                 alc_update_coef_idx(codec, 0x1e, 0, 0x80);
3818 }
3819
3820 static void alc269_fixup_headset_mic(struct hda_codec *codec,
3821                                        const struct hda_fixup *fix, int action)
3822 {
3823         struct alc_spec *spec = codec->spec;
3824
3825         if (action == HDA_FIXUP_ACT_PRE_PROBE)
3826                 spec->parse_flags |= HDA_PINCFG_HEADSET_MIC;
3827 }
3828
3829 static void alc271_fixup_dmic(struct hda_codec *codec,
3830                               const struct hda_fixup *fix, int action)
3831 {
3832         static const struct hda_verb verbs[] = {
3833                 {0x20, AC_VERB_SET_COEF_INDEX, 0x0d},
3834                 {0x20, AC_VERB_SET_PROC_COEF, 0x4000},
3835                 {}
3836         };
3837         unsigned int cfg;
3838
3839         if (strcmp(codec->core.chip_name, "ALC271X") &&
3840             strcmp(codec->core.chip_name, "ALC269VB"))
3841                 return;
3842         cfg = snd_hda_codec_get_pincfg(codec, 0x12);
3843         if (get_defcfg_connect(cfg) == AC_JACK_PORT_FIXED)
3844                 snd_hda_sequence_write(codec, verbs);
3845 }
3846
3847 static void alc269_fixup_pcm_44k(struct hda_codec *codec,
3848                                  const struct hda_fixup *fix, int action)
3849 {
3850         struct alc_spec *spec = codec->spec;
3851
3852         if (action != HDA_FIXUP_ACT_PROBE)
3853                 return;
3854
3855         /* Due to a hardware problem on Lenovo Ideadpad, we need to
3856          * fix the sample rate of analog I/O to 44.1kHz
3857          */
3858         spec->gen.stream_analog_playback = &alc269_44k_pcm_analog_playback;
3859         spec->gen.stream_analog_capture = &alc269_44k_pcm_analog_capture;
3860 }
3861
3862 static void alc269_fixup_stereo_dmic(struct hda_codec *codec,
3863                                      const struct hda_fixup *fix, int action)
3864 {
3865         /* The digital-mic unit sends PDM (differential signal) instead of
3866          * the standard PCM, thus you can't record a valid mono stream as is.
3867          * Below is a workaround specific to ALC269 to control the dmic
3868          * signal source as mono.
3869          */
3870         if (action == HDA_FIXUP_ACT_INIT)
3871                 alc_update_coef_idx(codec, 0x07, 0, 0x80);
3872 }
3873
3874 static void alc269_quanta_automute(struct hda_codec *codec)
3875 {
3876         snd_hda_gen_update_outputs(codec);
3877
3878         alc_write_coef_idx(codec, 0x0c, 0x680);
3879         alc_write_coef_idx(codec, 0x0c, 0x480);
3880 }
3881
3882 static void alc269_fixup_quanta_mute(struct hda_codec *codec,
3883                                      const struct hda_fixup *fix, int action)
3884 {
3885         struct alc_spec *spec = codec->spec;
3886         if (action != HDA_FIXUP_ACT_PROBE)
3887                 return;
3888         spec->gen.automute_hook = alc269_quanta_automute;
3889 }
3890
3891 static void alc269_x101_hp_automute_hook(struct hda_codec *codec,
3892                                          struct hda_jack_callback *jack)
3893 {
3894         struct alc_spec *spec = codec->spec;
3895         int vref;
3896         msleep(200);
3897         snd_hda_gen_hp_automute(codec, jack);
3898
3899         vref = spec->gen.hp_jack_present ? PIN_VREF80 : 0;
3900         msleep(100);
3901         snd_hda_codec_write(codec, 0x18, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
3902                             vref);
3903         msleep(500);
3904         snd_hda_codec_write(codec, 0x18, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
3905                             vref);
3906 }
3907
3908 /*
3909  * Magic sequence to make Huawei Matebook X right speaker working (bko#197801)
3910  */
3911 struct hda_alc298_mbxinit {
3912         unsigned char value_0x23;
3913         unsigned char value_0x25;
3914 };
3915
3916 static void alc298_huawei_mbx_stereo_seq(struct hda_codec *codec,
3917                                          const struct hda_alc298_mbxinit *initval,
3918                                          bool first)
3919 {
3920         snd_hda_codec_write(codec, 0x06, 0, AC_VERB_SET_DIGI_CONVERT_3, 0x0);
3921         alc_write_coef_idx(codec, 0x26, 0xb000);
3922
3923         if (first)
3924                 snd_hda_codec_write(codec, 0x21, 0, AC_VERB_GET_PIN_SENSE, 0x0);
3925
3926         snd_hda_codec_write(codec, 0x6, 0, AC_VERB_SET_DIGI_CONVERT_3, 0x80);
3927         alc_write_coef_idx(codec, 0x26, 0xf000);
3928         alc_write_coef_idx(codec, 0x23, initval->value_0x23);
3929
3930         if (initval->value_0x23 != 0x1e)
3931                 alc_write_coef_idx(codec, 0x25, initval->value_0x25);
3932
3933         snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_COEF_INDEX, 0x26);
3934         snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_PROC_COEF, 0xb010);
3935 }
3936
3937 static void alc298_fixup_huawei_mbx_stereo(struct hda_codec *codec,
3938                                            const struct hda_fixup *fix,
3939                                            int action)
3940 {
3941         /* Initialization magic */
3942         static const struct hda_alc298_mbxinit dac_init[] = {
3943                 {0x0c, 0x00}, {0x0d, 0x00}, {0x0e, 0x00}, {0x0f, 0x00},
3944                 {0x10, 0x00}, {0x1a, 0x40}, {0x1b, 0x82}, {0x1c, 0x00},
3945                 {0x1d, 0x00}, {0x1e, 0x00}, {0x1f, 0x00},
3946                 {0x20, 0xc2}, {0x21, 0xc8}, {0x22, 0x26}, {0x23, 0x24},
3947                 {0x27, 0xff}, {0x28, 0xff}, {0x29, 0xff}, {0x2a, 0x8f},
3948                 {0x2b, 0x02}, {0x2c, 0x48}, {0x2d, 0x34}, {0x2e, 0x00},
3949                 {0x2f, 0x00},
3950                 {0x30, 0x00}, {0x31, 0x00}, {0x32, 0x00}, {0x33, 0x00},
3951                 {0x34, 0x00}, {0x35, 0x01}, {0x36, 0x93}, {0x37, 0x0c},
3952                 {0x38, 0x00}, {0x39, 0x00}, {0x3a, 0xf8}, {0x38, 0x80},
3953                 {}
3954         };
3955         const struct hda_alc298_mbxinit *seq;
3956
3957         if (action != HDA_FIXUP_ACT_INIT)
3958                 return;
3959
3960         /* Start */
3961         snd_hda_codec_write(codec, 0x06, 0, AC_VERB_SET_DIGI_CONVERT_3, 0x00);
3962         snd_hda_codec_write(codec, 0x06, 0, AC_VERB_SET_DIGI_CONVERT_3, 0x80);
3963         alc_write_coef_idx(codec, 0x26, 0xf000);
3964         alc_write_coef_idx(codec, 0x22, 0x31);
3965         alc_write_coef_idx(codec, 0x23, 0x0b);
3966         alc_write_coef_idx(codec, 0x25, 0x00);
3967         snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_COEF_INDEX, 0x26);
3968         snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_PROC_COEF, 0xb010);
3969
3970         for (seq = dac_init; seq->value_0x23; seq++)
3971                 alc298_huawei_mbx_stereo_seq(codec, seq, seq == dac_init);
3972 }
3973
3974 static void alc269_fixup_x101_headset_mic(struct hda_codec *codec,
3975                                      const struct hda_fixup *fix, int action)
3976 {
3977         struct alc_spec *spec = codec->spec;
3978         if (action == HDA_FIXUP_ACT_PRE_PROBE) {
3979                 spec->parse_flags |= HDA_PINCFG_HEADSET_MIC;
3980                 spec->gen.hp_automute_hook = alc269_x101_hp_automute_hook;
3981         }
3982 }
3983
3984
3985 /* update mute-LED according to the speaker mute state via mic VREF pin */
3986 static void alc269_fixup_mic_mute_hook(void *private_data, int enabled)
3987 {
3988         struct hda_codec *codec = private_data;
3989         struct alc_spec *spec = codec->spec;
3990         unsigned int pinval;
3991
3992         if (spec->mute_led_polarity)
3993                 enabled = !enabled;
3994         pinval = snd_hda_codec_get_pin_target(codec, spec->mute_led_nid);
3995         pinval &= ~AC_PINCTL_VREFEN;
3996         pinval |= enabled ? AC_PINCTL_VREF_HIZ : AC_PINCTL_VREF_80;
3997         if (spec->mute_led_nid) {
3998                 /* temporarily power up/down for setting VREF */
3999                 snd_hda_power_up_pm(codec);
4000                 snd_hda_set_pin_ctl_cache(codec, spec->mute_led_nid, pinval);
4001                 snd_hda_power_down_pm(codec);
4002         }
4003 }
4004
4005 /* Make sure the led works even in runtime suspend */
4006 static unsigned int led_power_filter(struct hda_codec *codec,
4007                                                   hda_nid_t nid,
4008                                                   unsigned int power_state)
4009 {
4010         struct alc_spec *spec = codec->spec;
4011
4012         if (power_state != AC_PWRST_D3 || nid == 0 ||
4013             (nid != spec->mute_led_nid && nid != spec->cap_mute_led_nid))
4014                 return power_state;
4015
4016         /* Set pin ctl again, it might have just been set to 0 */
4017         snd_hda_set_pin_ctl(codec, nid,
4018                             snd_hda_codec_get_pin_target(codec, nid));
4019
4020         return snd_hda_gen_path_power_filter(codec, nid, power_state);
4021 }
4022
4023 static void alc269_fixup_hp_mute_led(struct hda_codec *codec,
4024                                      const struct hda_fixup *fix, int action)
4025 {
4026         struct alc_spec *spec = codec->spec;
4027         const struct dmi_device *dev = NULL;
4028
4029         if (action != HDA_FIXUP_ACT_PRE_PROBE)
4030                 return;
4031
4032         while ((dev = dmi_find_device(DMI_DEV_TYPE_OEM_STRING, NULL, dev))) {
4033                 int pol, pin;
4034                 if (sscanf(dev->name, "HP_Mute_LED_%d_%x", &pol, &pin) != 2)
4035                         continue;
4036                 if (pin < 0x0a || pin >= 0x10)
4037                         break;
4038                 spec->mute_led_polarity = pol;
4039                 spec->mute_led_nid = pin - 0x0a + 0x18;
4040                 spec->gen.vmaster_mute.hook = alc269_fixup_mic_mute_hook;
4041                 spec->gen.vmaster_mute_enum = 1;
4042                 codec->power_filter = led_power_filter;
4043                 codec_dbg(codec,
4044                           "Detected mute LED for %x:%d\n", spec->mute_led_nid,
4045                            spec->mute_led_polarity);
4046                 break;
4047         }
4048 }
4049
4050 static void alc269_fixup_hp_mute_led_micx(struct hda_codec *codec,
4051                                           const struct hda_fixup *fix,
4052                                           int action, hda_nid_t pin)
4053 {
4054         struct alc_spec *spec = codec->spec;
4055
4056         if (action == HDA_FIXUP_ACT_PRE_PROBE) {
4057                 spec->mute_led_polarity = 0;
4058                 spec->mute_led_nid = pin;
4059                 spec->gen.vmaster_mute.hook = alc269_fixup_mic_mute_hook;
4060                 spec->gen.vmaster_mute_enum = 1;
4061                 codec->power_filter = led_power_filter;
4062         }
4063 }
4064
4065 static void alc269_fixup_hp_mute_led_mic1(struct hda_codec *codec,
4066                                 const struct hda_fixup *fix, int action)
4067 {
4068         alc269_fixup_hp_mute_led_micx(codec, fix, action, 0x18);
4069 }
4070
4071 static void alc269_fixup_hp_mute_led_mic2(struct hda_codec *codec,
4072                                 const struct hda_fixup *fix, int action)
4073 {
4074         alc269_fixup_hp_mute_led_micx(codec, fix, action, 0x19);
4075 }
4076
4077 static void alc269_fixup_hp_mute_led_mic3(struct hda_codec *codec,
4078                                 const struct hda_fixup *fix, int action)
4079 {
4080         alc269_fixup_hp_mute_led_micx(codec, fix, action, 0x1b);
4081 }
4082
4083 /* update LED status via GPIO */
4084 static void alc_update_gpio_led(struct hda_codec *codec, unsigned int mask,
4085                                 int polarity, bool enabled)
4086 {
4087         if (polarity)
4088                 enabled = !enabled;
4089         alc_update_gpio_data(codec, mask, !enabled); /* muted -> LED on */
4090 }
4091
4092 /* turn on/off mute LED via GPIO per vmaster hook */
4093 static void alc_fixup_gpio_mute_hook(void *private_data, int enabled)
4094 {
4095         struct hda_codec *codec = private_data;
4096         struct alc_spec *spec = codec->spec;
4097
4098         alc_update_gpio_led(codec, spec->gpio_mute_led_mask,
4099                             spec->mute_led_polarity, enabled);
4100 }
4101
4102 /* turn on/off mic-mute LED via GPIO per capture hook */
4103 static int micmute_led_set(struct led_classdev *led_cdev,
4104                            enum led_brightness brightness)
4105 {
4106         struct hda_codec *codec = dev_to_hda_codec(led_cdev->dev->parent);
4107         struct alc_spec *spec = codec->spec;
4108
4109         alc_update_gpio_led(codec, spec->gpio_mic_led_mask,
4110                             spec->micmute_led_polarity, !!brightness);
4111         return 0;
4112 }
4113
4114 /* setup mute and mic-mute GPIO bits, add hooks appropriately */
4115 static void alc_fixup_hp_gpio_led(struct hda_codec *codec,
4116                                   int action,
4117                                   unsigned int mute_mask,
4118                                   unsigned int micmute_mask)
4119 {
4120         struct alc_spec *spec = codec->spec;
4121
4122         alc_fixup_gpio(codec, action, mute_mask | micmute_mask);
4123
4124         if (action != HDA_FIXUP_ACT_PRE_PROBE)
4125                 return;
4126         if (mute_mask) {
4127                 spec->gpio_mute_led_mask = mute_mask;
4128                 spec->gen.vmaster_mute.hook = alc_fixup_gpio_mute_hook;
4129         }
4130         if (micmute_mask) {
4131                 spec->gpio_mic_led_mask = micmute_mask;
4132                 snd_hda_gen_add_micmute_led_cdev(codec, micmute_led_set);
4133         }
4134 }
4135
4136 static void alc269_fixup_hp_gpio_led(struct hda_codec *codec,
4137                                 const struct hda_fixup *fix, int action)
4138 {
4139         alc_fixup_hp_gpio_led(codec, action, 0x08, 0x10);
4140 }
4141
4142 static void alc285_fixup_hp_gpio_led(struct hda_codec *codec,
4143                                 const struct hda_fixup *fix, int action)
4144 {
4145         struct alc_spec *spec = codec->spec;
4146
4147         spec->micmute_led_polarity = 1;
4148
4149         alc_fixup_hp_gpio_led(codec, action, 0x04, 0x01);
4150 }
4151
4152 static void alc286_fixup_hp_gpio_led(struct hda_codec *codec,
4153                                 const struct hda_fixup *fix, int action)
4154 {
4155         alc_fixup_hp_gpio_led(codec, action, 0x02, 0x20);
4156 }
4157
4158 /* turn on/off mic-mute LED per capture hook */
4159 static void alc_cap_micmute_update(struct hda_codec *codec)
4160 {
4161         struct alc_spec *spec = codec->spec;
4162         unsigned int pinval;
4163
4164         if (!spec->cap_mute_led_nid)
4165                 return;
4166         pinval = snd_hda_codec_get_pin_target(codec, spec->cap_mute_led_nid);
4167         pinval &= ~AC_PINCTL_VREFEN;
4168         if (spec->gen.micmute_led.led_value)
4169                 pinval |= AC_PINCTL_VREF_80;
4170         else
4171                 pinval |= AC_PINCTL_VREF_HIZ;
4172         snd_hda_set_pin_ctl_cache(codec, spec->cap_mute_led_nid, pinval);
4173 }
4174
4175 static void alc269_fixup_hp_gpio_mic1_led(struct hda_codec *codec,
4176                                 const struct hda_fixup *fix, int action)
4177 {
4178         struct alc_spec *spec = codec->spec;
4179
4180         alc_fixup_hp_gpio_led(codec, action, 0x08, 0);
4181         if (action == HDA_FIXUP_ACT_PRE_PROBE) {
4182                 /* Like hp_gpio_mic1_led, but also needs GPIO4 low to
4183                  * enable headphone amp
4184                  */
4185                 spec->gpio_mask |= 0x10;
4186                 spec->gpio_dir |= 0x10;
4187                 spec->cap_mute_led_nid = 0x18;
4188                 snd_hda_gen_add_micmute_led(codec, alc_cap_micmute_update);
4189                 codec->power_filter = led_power_filter;
4190         }
4191 }
4192
4193 static void alc280_fixup_hp_gpio4(struct hda_codec *codec,
4194                                    const struct hda_fixup *fix, int action)
4195 {
4196         struct alc_spec *spec = codec->spec;
4197
4198         alc_fixup_hp_gpio_led(codec, action, 0x08, 0);
4199         if (action == HDA_FIXUP_ACT_PRE_PROBE) {
4200                 spec->cap_mute_led_nid = 0x18;
4201                 snd_hda_gen_add_micmute_led(codec, alc_cap_micmute_update);
4202                 codec->power_filter = led_power_filter;
4203         }
4204 }
4205
4206 /* update mute-LED according to the speaker mute state via COEF bit */
4207 static void alc_fixup_mute_led_coefbit_hook(void *private_data, int enabled)
4208 {
4209         struct hda_codec *codec = private_data;
4210         struct alc_spec *spec = codec->spec;
4211
4212         if (spec->mute_led_polarity)
4213                 enabled = !enabled;
4214
4215         /* temporarily power up/down for setting COEF bit */
4216         enabled ? alc_update_coef_idx(codec, spec->mute_led_coef_idx,
4217                 spec->mute_led_coefbit_mask, spec->mute_led_coefbit_off) :
4218                   alc_update_coef_idx(codec, spec->mute_led_coef_idx,
4219                 spec->mute_led_coefbit_mask, spec->mute_led_coefbit_on);
4220 }
4221
4222 static void alc285_fixup_hp_mute_led_coefbit(struct hda_codec *codec,
4223                                           const struct hda_fixup *fix,
4224                                           int action)
4225 {
4226         struct alc_spec *spec = codec->spec;
4227
4228         if (action == HDA_FIXUP_ACT_PRE_PROBE) {
4229                 spec->mute_led_polarity = 0;
4230                 spec->mute_led_coef_idx = 0x0b;
4231                 spec->mute_led_coefbit_mask = 1<<3;
4232                 spec->mute_led_coefbit_on = 1<<3;
4233                 spec->mute_led_coefbit_off = 0;
4234                 spec->gen.vmaster_mute.hook = alc_fixup_mute_led_coefbit_hook;
4235                 spec->gen.vmaster_mute_enum = 1;
4236         }
4237 }
4238
4239 static void alc236_fixup_hp_mute_led_coefbit(struct hda_codec *codec,
4240                                           const struct hda_fixup *fix,
4241                                           int action)
4242 {
4243         struct alc_spec *spec = codec->spec;
4244
4245         if (action == HDA_FIXUP_ACT_PRE_PROBE) {
4246                 spec->mute_led_polarity = 0;
4247                 spec->mute_led_coef_idx = 0x34;
4248                 spec->mute_led_coefbit_mask = 1<<5;
4249                 spec->mute_led_coefbit_on = 0;
4250                 spec->mute_led_coefbit_off = 1<<5;
4251                 spec->gen.vmaster_mute.hook = alc_fixup_mute_led_coefbit_hook;
4252                 spec->gen.vmaster_mute_enum = 1;
4253         }
4254 }
4255
4256 /* turn on/off mic-mute LED per capture hook by coef bit */
4257 static void alc_hp_cap_micmute_update(struct hda_codec *codec)
4258 {
4259         struct alc_spec *spec = codec->spec;
4260
4261         if (spec->gen.micmute_led.led_value)
4262                 alc_update_coef_idx(codec, spec->mic_led_coef_idx,
4263                         spec->mic_led_coefbit_mask, spec->mic_led_coefbit_on);
4264         else
4265                 alc_update_coef_idx(codec, spec->mic_led_coef_idx,
4266                         spec->mic_led_coefbit_mask, spec->mic_led_coefbit_off);
4267 }
4268
4269 static void alc285_fixup_hp_coef_micmute_led(struct hda_codec *codec,
4270                                 const struct hda_fixup *fix, int action)
4271 {
4272         struct alc_spec *spec = codec->spec;
4273
4274         if (action == HDA_FIXUP_ACT_PRE_PROBE) {
4275                 spec->mic_led_coef_idx = 0x19;
4276                 spec->mic_led_coefbit_mask = 1<<13;
4277                 spec->mic_led_coefbit_on = 1<<13;
4278                 spec->mic_led_coefbit_off = 0;
4279                 snd_hda_gen_add_micmute_led(codec, alc_hp_cap_micmute_update);
4280         }
4281 }
4282
4283 static void alc236_fixup_hp_coef_micmute_led(struct hda_codec *codec,
4284                                 const struct hda_fixup *fix, int action)
4285 {
4286         struct alc_spec *spec = codec->spec;
4287
4288         if (action == HDA_FIXUP_ACT_PRE_PROBE) {
4289                 spec->mic_led_coef_idx = 0x35;
4290                 spec->mic_led_coefbit_mask = 3<<2;
4291                 spec->mic_led_coefbit_on = 2<<2;
4292                 spec->mic_led_coefbit_off = 1<<2;
4293                 snd_hda_gen_add_micmute_led(codec, alc_hp_cap_micmute_update);
4294         }
4295 }
4296
4297 static void alc285_fixup_hp_mute_led(struct hda_codec *codec,
4298                                 const struct hda_fixup *fix, int action)
4299 {
4300         alc285_fixup_hp_mute_led_coefbit(codec, fix, action);
4301         alc285_fixup_hp_coef_micmute_led(codec, fix, action);
4302 }
4303
4304 static void alc236_fixup_hp_mute_led(struct hda_codec *codec,
4305                                 const struct hda_fixup *fix, int action)
4306 {
4307         alc236_fixup_hp_mute_led_coefbit(codec, fix, action);
4308         alc236_fixup_hp_coef_micmute_led(codec, fix, action);
4309 }
4310
4311 #if IS_REACHABLE(CONFIG_INPUT)
4312 static void gpio2_mic_hotkey_event(struct hda_codec *codec,
4313                                    struct hda_jack_callback *event)
4314 {
4315         struct alc_spec *spec = codec->spec;
4316
4317         /* GPIO2 just toggles on a keypress/keyrelease cycle. Therefore
4318            send both key on and key off event for every interrupt. */
4319         input_report_key(spec->kb_dev, spec->alc_mute_keycode_map[ALC_KEY_MICMUTE_INDEX], 1);
4320         input_sync(spec->kb_dev);
4321         input_report_key(spec->kb_dev, spec->alc_mute_keycode_map[ALC_KEY_MICMUTE_INDEX], 0);
4322         input_sync(spec->kb_dev);
4323 }
4324
4325 static int alc_register_micmute_input_device(struct hda_codec *codec)
4326 {
4327         struct alc_spec *spec = codec->spec;
4328         int i;
4329
4330         spec->kb_dev = input_allocate_device();
4331         if (!spec->kb_dev) {
4332                 codec_err(codec, "Out of memory (input_allocate_device)\n");
4333                 return -ENOMEM;
4334         }
4335
4336         spec->alc_mute_keycode_map[ALC_KEY_MICMUTE_INDEX] = KEY_MICMUTE;
4337
4338         spec->kb_dev->name = "Microphone Mute Button";
4339         spec->kb_dev->evbit[0] = BIT_MASK(EV_KEY);
4340         spec->kb_dev->keycodesize = sizeof(spec->alc_mute_keycode_map[0]);
4341         spec->kb_dev->keycodemax = ARRAY_SIZE(spec->alc_mute_keycode_map);
4342         spec->kb_dev->keycode = spec->alc_mute_keycode_map;
4343         for (i = 0; i < ARRAY_SIZE(spec->alc_mute_keycode_map); i++)
4344                 set_bit(spec->alc_mute_keycode_map[i], spec->kb_dev->keybit);
4345
4346         if (input_register_device(spec->kb_dev)) {
4347                 codec_err(codec, "input_register_device failed\n");
4348                 input_free_device(spec->kb_dev);
4349                 spec->kb_dev = NULL;
4350                 return -ENOMEM;
4351         }
4352
4353         return 0;
4354 }
4355
4356 /* GPIO1 = set according to SKU external amp
4357  * GPIO2 = mic mute hotkey
4358  * GPIO3 = mute LED
4359  * GPIO4 = mic mute LED
4360  */
4361 static void alc280_fixup_hp_gpio2_mic_hotkey(struct hda_codec *codec,
4362                                              const struct hda_fixup *fix, int action)
4363 {
4364         struct alc_spec *spec = codec->spec;
4365
4366         alc_fixup_hp_gpio_led(codec, action, 0x08, 0x10);
4367         if (action == HDA_FIXUP_ACT_PRE_PROBE) {
4368                 spec->init_amp = ALC_INIT_DEFAULT;
4369                 if (alc_register_micmute_input_device(codec) != 0)
4370                         return;
4371
4372                 spec->gpio_mask |= 0x06;
4373                 spec->gpio_dir |= 0x02;
4374                 spec->gpio_data |= 0x02;
4375                 snd_hda_codec_write_cache(codec, codec->core.afg, 0,
4376                                           AC_VERB_SET_GPIO_UNSOLICITED_RSP_MASK, 0x04);
4377                 snd_hda_jack_detect_enable_callback(codec, codec->core.afg,
4378                                                     gpio2_mic_hotkey_event);
4379                 return;
4380         }
4381
4382         if (!spec->kb_dev)
4383                 return;
4384
4385         switch (action) {
4386         case HDA_FIXUP_ACT_FREE:
4387                 input_unregister_device(spec->kb_dev);
4388                 spec->kb_dev = NULL;
4389         }
4390 }
4391
4392 /* Line2 = mic mute hotkey
4393  * GPIO2 = mic mute LED
4394  */
4395 static void alc233_fixup_lenovo_line2_mic_hotkey(struct hda_codec *codec,
4396                                              const struct hda_fixup *fix, int action)
4397 {
4398         struct alc_spec *spec = codec->spec;
4399
4400         alc_fixup_hp_gpio_led(codec, action, 0, 0x04);
4401         if (action == HDA_FIXUP_ACT_PRE_PROBE) {
4402                 spec->init_amp = ALC_INIT_DEFAULT;
4403                 if (alc_register_micmute_input_device(codec) != 0)
4404                         return;
4405
4406                 snd_hda_jack_detect_enable_callback(codec, 0x1b,
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 #else /* INPUT */
4421 #define alc280_fixup_hp_gpio2_mic_hotkey        NULL
4422 #define alc233_fixup_lenovo_line2_mic_hotkey    NULL
4423 #endif /* INPUT */
4424
4425 static void alc269_fixup_hp_line1_mic1_led(struct hda_codec *codec,
4426                                 const struct hda_fixup *fix, int action)
4427 {
4428         struct alc_spec *spec = codec->spec;
4429
4430         alc269_fixup_hp_mute_led_micx(codec, fix, action, 0x1a);
4431         if (action == HDA_FIXUP_ACT_PRE_PROBE) {
4432                 spec->cap_mute_led_nid = 0x18;
4433                 snd_hda_gen_add_micmute_led(codec, alc_cap_micmute_update);
4434         }
4435 }
4436
4437 static const struct coef_fw alc225_pre_hsmode[] = {
4438         UPDATE_COEF(0x4a, 1<<8, 0),
4439         UPDATE_COEFEX(0x57, 0x05, 1<<14, 0),
4440         UPDATE_COEF(0x63, 3<<14, 3<<14),
4441         UPDATE_COEF(0x4a, 3<<4, 2<<4),
4442         UPDATE_COEF(0x4a, 3<<10, 3<<10),
4443         UPDATE_COEF(0x45, 0x3f<<10, 0x34<<10),
4444         UPDATE_COEF(0x4a, 3<<10, 0),
4445         {}
4446 };
4447
4448 static void alc_headset_mode_unplugged(struct hda_codec *codec)
4449 {
4450         static const struct coef_fw coef0255[] = {
4451                 WRITE_COEF(0x1b, 0x0c0b), /* LDO and MISC control */
4452                 WRITE_COEF(0x45, 0xd089), /* UAJ function set to menual mode */
4453                 UPDATE_COEFEX(0x57, 0x05, 1<<14, 0), /* Direct Drive HP Amp control(Set to verb control)*/
4454                 WRITE_COEF(0x06, 0x6104), /* Set MIC2 Vref gate with HP */
4455                 WRITE_COEFEX(0x57, 0x03, 0x8aa6), /* Direct Drive HP Amp control */
4456                 {}
4457         };
4458         static const struct coef_fw coef0256[] = {
4459                 WRITE_COEF(0x1b, 0x0c4b), /* LDO and MISC control */
4460                 WRITE_COEF(0x45, 0xd089), /* UAJ function set to menual mode */
4461                 WRITE_COEF(0x06, 0x6104), /* Set MIC2 Vref gate with HP */
4462                 WRITE_COEFEX(0x57, 0x03, 0x09a3), /* Direct Drive HP Amp control */
4463                 UPDATE_COEFEX(0x57, 0x05, 1<<14, 0), /* Direct Drive HP Amp control(Set to verb control)*/
4464                 {}
4465         };
4466         static const struct coef_fw coef0233[] = {
4467                 WRITE_COEF(0x1b, 0x0c0b),
4468                 WRITE_COEF(0x45, 0xc429),
4469                 UPDATE_COEF(0x35, 0x4000, 0),
4470                 WRITE_COEF(0x06, 0x2104),
4471                 WRITE_COEF(0x1a, 0x0001),
4472                 WRITE_COEF(0x26, 0x0004),
4473                 WRITE_COEF(0x32, 0x42a3),
4474                 {}
4475         };
4476         static const struct coef_fw coef0288[] = {
4477                 UPDATE_COEF(0x4f, 0xfcc0, 0xc400),
4478                 UPDATE_COEF(0x50, 0x2000, 0x2000),
4479                 UPDATE_COEF(0x56, 0x0006, 0x0006),
4480                 UPDATE_COEF(0x66, 0x0008, 0),
4481                 UPDATE_COEF(0x67, 0x2000, 0),
4482                 {}
4483         };
4484         static const struct coef_fw coef0298[] = {
4485                 UPDATE_COEF(0x19, 0x1300, 0x0300),
4486                 {}
4487         };
4488         static const struct coef_fw coef0292[] = {
4489                 WRITE_COEF(0x76, 0x000e),
4490                 WRITE_COEF(0x6c, 0x2400),
4491                 WRITE_COEF(0x18, 0x7308),
4492                 WRITE_COEF(0x6b, 0xc429),
4493                 {}
4494         };
4495         static const struct coef_fw coef0293[] = {
4496                 UPDATE_COEF(0x10, 7<<8, 6<<8), /* SET Line1 JD to 0 */
4497                 UPDATE_COEFEX(0x57, 0x05, 1<<15|1<<13, 0x0), /* SET charge pump by verb */
4498                 UPDATE_COEFEX(0x57, 0x03, 1<<10, 1<<10), /* SET EN_OSW to 1 */
4499                 UPDATE_COEF(0x1a, 1<<3, 1<<3), /* Combo JD gating with LINE1-VREFO */
4500                 WRITE_COEF(0x45, 0xc429), /* Set to TRS type */
4501                 UPDATE_COEF(0x4a, 0x000f, 0x000e), /* Combo Jack auto detect */
4502                 {}
4503         };
4504         static const struct coef_fw coef0668[] = {
4505                 WRITE_COEF(0x15, 0x0d40),
4506                 WRITE_COEF(0xb7, 0x802b),
4507                 {}
4508         };
4509         static const struct coef_fw coef0225[] = {
4510                 UPDATE_COEF(0x63, 3<<14, 0),
4511                 {}
4512         };
4513         static const struct coef_fw coef0274[] = {
4514                 UPDATE_COEF(0x4a, 0x0100, 0),
4515                 UPDATE_COEFEX(0x57, 0x05, 0x4000, 0),
4516                 UPDATE_COEF(0x6b, 0xf000, 0x5000),
4517                 UPDATE_COEF(0x4a, 0x0010, 0),
4518                 UPDATE_COEF(0x4a, 0x0c00, 0x0c00),
4519                 WRITE_COEF(0x45, 0x5289),
4520                 UPDATE_COEF(0x4a, 0x0c00, 0),
4521                 {}
4522         };
4523
4524         switch (codec->core.vendor_id) {
4525         case 0x10ec0255:
4526                 alc_process_coef_fw(codec, coef0255);
4527                 break;
4528         case 0x10ec0236:
4529         case 0x10ec0256:
4530                 alc_process_coef_fw(codec, coef0256);
4531                 break;
4532         case 0x10ec0234:
4533         case 0x10ec0274:
4534         case 0x10ec0294:
4535                 alc_process_coef_fw(codec, coef0274);
4536                 break;
4537         case 0x10ec0233:
4538         case 0x10ec0283:
4539                 alc_process_coef_fw(codec, coef0233);
4540                 break;
4541         case 0x10ec0286:
4542         case 0x10ec0288:
4543                 alc_process_coef_fw(codec, coef0288);
4544                 break;
4545         case 0x10ec0298:
4546                 alc_process_coef_fw(codec, coef0298);
4547                 alc_process_coef_fw(codec, coef0288);
4548                 break;
4549         case 0x10ec0292:
4550                 alc_process_coef_fw(codec, coef0292);
4551                 break;
4552         case 0x10ec0293:
4553                 alc_process_coef_fw(codec, coef0293);
4554                 break;
4555         case 0x10ec0668:
4556                 alc_process_coef_fw(codec, coef0668);
4557                 break;
4558         case 0x10ec0215:
4559         case 0x10ec0225:
4560         case 0x10ec0285:
4561         case 0x10ec0295:
4562         case 0x10ec0289:
4563         case 0x10ec0299:
4564                 alc_process_coef_fw(codec, alc225_pre_hsmode);
4565                 alc_process_coef_fw(codec, coef0225);
4566                 break;
4567         case 0x10ec0867:
4568                 alc_update_coefex_idx(codec, 0x57, 0x5, 1<<14, 0);
4569                 break;
4570         }
4571         codec_dbg(codec, "Headset jack set to unplugged mode.\n");
4572 }
4573
4574
4575 static void alc_headset_mode_mic_in(struct hda_codec *codec, hda_nid_t hp_pin,
4576                                     hda_nid_t mic_pin)
4577 {
4578         static const struct coef_fw coef0255[] = {
4579                 WRITE_COEFEX(0x57, 0x03, 0x8aa6),
4580                 WRITE_COEF(0x06, 0x6100), /* Set MIC2 Vref gate to normal */
4581                 {}
4582         };
4583         static const struct coef_fw coef0256[] = {
4584                 UPDATE_COEFEX(0x57, 0x05, 1<<14, 1<<14), /* Direct Drive HP Amp control(Set to verb control)*/
4585                 WRITE_COEFEX(0x57, 0x03, 0x09a3),
4586                 WRITE_COEF(0x06, 0x6100), /* Set MIC2 Vref gate to normal */
4587                 {}
4588         };
4589         static const struct coef_fw coef0233[] = {
4590                 UPDATE_COEF(0x35, 0, 1<<14),
4591                 WRITE_COEF(0x06, 0x2100),
4592                 WRITE_COEF(0x1a, 0x0021),
4593                 WRITE_COEF(0x26, 0x008c),
4594                 {}
4595         };
4596         static const struct coef_fw coef0288[] = {
4597                 UPDATE_COEF(0x4f, 0x00c0, 0),
4598                 UPDATE_COEF(0x50, 0x2000, 0),
4599                 UPDATE_COEF(0x56, 0x0006, 0),
4600                 UPDATE_COEF(0x4f, 0xfcc0, 0xc400),
4601                 UPDATE_COEF(0x66, 0x0008, 0x0008),
4602                 UPDATE_COEF(0x67, 0x2000, 0x2000),
4603                 {}
4604         };
4605         static const struct coef_fw coef0292[] = {
4606                 WRITE_COEF(0x19, 0xa208),
4607                 WRITE_COEF(0x2e, 0xacf0),
4608                 {}
4609         };
4610         static const struct coef_fw coef0293[] = {
4611                 UPDATE_COEFEX(0x57, 0x05, 0, 1<<15|1<<13), /* SET charge pump by verb */
4612                 UPDATE_COEFEX(0x57, 0x03, 1<<10, 0), /* SET EN_OSW to 0 */
4613                 UPDATE_COEF(0x1a, 1<<3, 0), /* Combo JD gating without LINE1-VREFO */
4614                 {}
4615         };
4616         static const struct coef_fw coef0688[] = {
4617                 WRITE_COEF(0xb7, 0x802b),
4618                 WRITE_COEF(0xb5, 0x1040),
4619                 UPDATE_COEF(0xc3, 0, 1<<12),
4620                 {}
4621         };
4622         static const struct coef_fw coef0225[] = {
4623                 UPDATE_COEFEX(0x57, 0x05, 1<<14, 1<<14),
4624                 UPDATE_COEF(0x4a, 3<<4, 2<<4),
4625                 UPDATE_COEF(0x63, 3<<14, 0),
4626                 {}
4627         };
4628         static const struct coef_fw coef0274[] = {
4629                 UPDATE_COEFEX(0x57, 0x05, 0x4000, 0x4000),
4630                 UPDATE_COEF(0x4a, 0x0010, 0),
4631                 UPDATE_COEF(0x6b, 0xf000, 0),
4632                 {}
4633         };
4634
4635         switch (codec->core.vendor_id) {
4636         case 0x10ec0255:
4637                 alc_write_coef_idx(codec, 0x45, 0xc489);
4638                 snd_hda_set_pin_ctl_cache(codec, hp_pin, 0);
4639                 alc_process_coef_fw(codec, coef0255);
4640                 snd_hda_set_pin_ctl_cache(codec, mic_pin, PIN_VREF50);
4641                 break;
4642         case 0x10ec0236:
4643         case 0x10ec0256:
4644                 alc_write_coef_idx(codec, 0x45, 0xc489);
4645                 snd_hda_set_pin_ctl_cache(codec, hp_pin, 0);
4646                 alc_process_coef_fw(codec, coef0256);
4647                 snd_hda_set_pin_ctl_cache(codec, mic_pin, PIN_VREF50);
4648                 break;
4649         case 0x10ec0234:
4650         case 0x10ec0274:
4651         case 0x10ec0294:
4652                 alc_write_coef_idx(codec, 0x45, 0x4689);
4653                 snd_hda_set_pin_ctl_cache(codec, hp_pin, 0);
4654                 alc_process_coef_fw(codec, coef0274);
4655                 snd_hda_set_pin_ctl_cache(codec, mic_pin, PIN_VREF50);
4656                 break;
4657         case 0x10ec0233:
4658         case 0x10ec0283:
4659                 alc_write_coef_idx(codec, 0x45, 0xc429);
4660                 snd_hda_set_pin_ctl_cache(codec, hp_pin, 0);
4661                 alc_process_coef_fw(codec, coef0233);
4662                 snd_hda_set_pin_ctl_cache(codec, mic_pin, PIN_VREF50);
4663                 break;
4664         case 0x10ec0286:
4665         case 0x10ec0288:
4666         case 0x10ec0298:
4667                 snd_hda_set_pin_ctl_cache(codec, hp_pin, 0);
4668                 alc_process_coef_fw(codec, coef0288);
4669                 snd_hda_set_pin_ctl_cache(codec, mic_pin, PIN_VREF50);
4670                 break;
4671         case 0x10ec0292:
4672                 snd_hda_set_pin_ctl_cache(codec, hp_pin, 0);
4673                 alc_process_coef_fw(codec, coef0292);
4674                 break;
4675         case 0x10ec0293:
4676                 /* Set to TRS mode */
4677                 alc_write_coef_idx(codec, 0x45, 0xc429);
4678                 snd_hda_set_pin_ctl_cache(codec, hp_pin, 0);
4679                 alc_process_coef_fw(codec, coef0293);
4680                 snd_hda_set_pin_ctl_cache(codec, mic_pin, PIN_VREF50);
4681                 break;
4682         case 0x10ec0867:
4683                 alc_update_coefex_idx(codec, 0x57, 0x5, 0, 1<<14);
4684                 /* fallthru */
4685         case 0x10ec0221:
4686         case 0x10ec0662:
4687                 snd_hda_set_pin_ctl_cache(codec, hp_pin, 0);
4688                 snd_hda_set_pin_ctl_cache(codec, mic_pin, PIN_VREF50);
4689                 break;
4690         case 0x10ec0668:
4691                 alc_write_coef_idx(codec, 0x11, 0x0001);
4692                 snd_hda_set_pin_ctl_cache(codec, hp_pin, 0);
4693                 alc_process_coef_fw(codec, coef0688);
4694                 snd_hda_set_pin_ctl_cache(codec, mic_pin, PIN_VREF50);
4695                 break;
4696         case 0x10ec0215:
4697         case 0x10ec0225:
4698         case 0x10ec0285:
4699         case 0x10ec0295:
4700         case 0x10ec0289:
4701         case 0x10ec0299:
4702                 alc_process_coef_fw(codec, alc225_pre_hsmode);
4703                 alc_update_coef_idx(codec, 0x45, 0x3f<<10, 0x31<<10);
4704                 snd_hda_set_pin_ctl_cache(codec, hp_pin, 0);
4705                 alc_process_coef_fw(codec, coef0225);
4706                 snd_hda_set_pin_ctl_cache(codec, mic_pin, PIN_VREF50);
4707                 break;
4708         }
4709         codec_dbg(codec, "Headset jack set to mic-in mode.\n");
4710 }
4711
4712 static void alc_headset_mode_default(struct hda_codec *codec)
4713 {
4714         static const struct coef_fw coef0225[] = {
4715                 UPDATE_COEF(0x45, 0x3f<<10, 0x30<<10),
4716                 UPDATE_COEF(0x45, 0x3f<<10, 0x31<<10),
4717                 UPDATE_COEF(0x49, 3<<8, 0<<8),
4718                 UPDATE_COEF(0x4a, 3<<4, 3<<4),
4719                 UPDATE_COEF(0x63, 3<<14, 0),
4720                 UPDATE_COEF(0x67, 0xf000, 0x3000),
4721                 {}
4722         };
4723         static const struct coef_fw coef0255[] = {
4724                 WRITE_COEF(0x45, 0xc089),
4725                 WRITE_COEF(0x45, 0xc489),
4726                 WRITE_COEFEX(0x57, 0x03, 0x8ea6),
4727                 WRITE_COEF(0x49, 0x0049),
4728                 {}
4729         };
4730         static const struct coef_fw coef0256[] = {
4731                 WRITE_COEF(0x45, 0xc489),
4732                 WRITE_COEFEX(0x57, 0x03, 0x0da3),
4733                 WRITE_COEF(0x49, 0x0049),
4734                 UPDATE_COEFEX(0x57, 0x05, 1<<14, 0), /* Direct Drive HP Amp control(Set to verb control)*/
4735                 WRITE_COEF(0x06, 0x6100),
4736                 {}
4737         };
4738         static const struct coef_fw coef0233[] = {
4739                 WRITE_COEF(0x06, 0x2100),
4740                 WRITE_COEF(0x32, 0x4ea3),
4741                 {}
4742         };
4743         static const struct coef_fw coef0288[] = {
4744                 UPDATE_COEF(0x4f, 0xfcc0, 0xc400), /* Set to TRS type */
4745                 UPDATE_COEF(0x50, 0x2000, 0x2000),
4746                 UPDATE_COEF(0x56, 0x0006, 0x0006),
4747                 UPDATE_COEF(0x66, 0x0008, 0),
4748                 UPDATE_COEF(0x67, 0x2000, 0),
4749                 {}
4750         };
4751         static const struct coef_fw coef0292[] = {
4752                 WRITE_COEF(0x76, 0x000e),
4753                 WRITE_COEF(0x6c, 0x2400),
4754                 WRITE_COEF(0x6b, 0xc429),
4755                 WRITE_COEF(0x18, 0x7308),
4756                 {}
4757         };
4758         static const struct coef_fw coef0293[] = {
4759                 UPDATE_COEF(0x4a, 0x000f, 0x000e), /* Combo Jack auto detect */
4760                 WRITE_COEF(0x45, 0xC429), /* Set to TRS type */
4761                 UPDATE_COEF(0x1a, 1<<3, 0), /* Combo JD gating without LINE1-VREFO */
4762                 {}
4763         };
4764         static const struct coef_fw coef0688[] = {
4765                 WRITE_COEF(0x11, 0x0041),
4766                 WRITE_COEF(0x15, 0x0d40),
4767                 WRITE_COEF(0xb7, 0x802b),
4768                 {}
4769         };
4770         static const struct coef_fw coef0274[] = {
4771                 WRITE_COEF(0x45, 0x4289),
4772                 UPDATE_COEF(0x4a, 0x0010, 0x0010),
4773                 UPDATE_COEF(0x6b, 0x0f00, 0),
4774                 UPDATE_COEF(0x49, 0x0300, 0x0300),
4775                 {}
4776         };
4777
4778         switch (codec->core.vendor_id) {
4779         case 0x10ec0215:
4780         case 0x10ec0225:
4781         case 0x10ec0285:
4782         case 0x10ec0295:
4783         case 0x10ec0289:
4784         case 0x10ec0299:
4785                 alc_process_coef_fw(codec, alc225_pre_hsmode);
4786                 alc_process_coef_fw(codec, coef0225);
4787                 break;
4788         case 0x10ec0255:
4789                 alc_process_coef_fw(codec, coef0255);
4790                 break;
4791         case 0x10ec0236:
4792         case 0x10ec0256:
4793                 alc_write_coef_idx(codec, 0x1b, 0x0e4b);
4794                 alc_write_coef_idx(codec, 0x45, 0xc089);
4795                 msleep(50);
4796                 alc_process_coef_fw(codec, coef0256);
4797                 break;
4798         case 0x10ec0234:
4799         case 0x10ec0274:
4800         case 0x10ec0294:
4801                 alc_process_coef_fw(codec, coef0274);
4802                 break;
4803         case 0x10ec0233:
4804         case 0x10ec0283:
4805                 alc_process_coef_fw(codec, coef0233);
4806                 break;
4807         case 0x10ec0286:
4808         case 0x10ec0288:
4809         case 0x10ec0298:
4810                 alc_process_coef_fw(codec, coef0288);
4811                 break;
4812         case 0x10ec0292:
4813                 alc_process_coef_fw(codec, coef0292);
4814                 break;
4815         case 0x10ec0293:
4816                 alc_process_coef_fw(codec, coef0293);
4817                 break;
4818         case 0x10ec0668:
4819                 alc_process_coef_fw(codec, coef0688);
4820                 break;
4821         case 0x10ec0867:
4822                 alc_update_coefex_idx(codec, 0x57, 0x5, 1<<14, 0);
4823                 break;
4824         }
4825         codec_dbg(codec, "Headset jack set to headphone (default) mode.\n");
4826 }
4827
4828 /* Iphone type */
4829 static void alc_headset_mode_ctia(struct hda_codec *codec)
4830 {
4831         int val;
4832
4833         static const struct coef_fw coef0255[] = {
4834                 WRITE_COEF(0x45, 0xd489), /* Set to CTIA type */
4835                 WRITE_COEF(0x1b, 0x0c2b),
4836                 WRITE_COEFEX(0x57, 0x03, 0x8ea6),
4837                 {}
4838         };
4839         static const struct coef_fw coef0256[] = {
4840                 WRITE_COEF(0x45, 0xd489), /* Set to CTIA type */
4841                 WRITE_COEF(0x1b, 0x0e6b),
4842                 {}
4843         };
4844         static const struct coef_fw coef0233[] = {
4845                 WRITE_COEF(0x45, 0xd429),
4846                 WRITE_COEF(0x1b, 0x0c2b),
4847                 WRITE_COEF(0x32, 0x4ea3),
4848                 {}
4849         };
4850         static const struct coef_fw coef0288[] = {
4851                 UPDATE_COEF(0x50, 0x2000, 0x2000),
4852                 UPDATE_COEF(0x56, 0x0006, 0x0006),
4853                 UPDATE_COEF(0x66, 0x0008, 0),
4854                 UPDATE_COEF(0x67, 0x2000, 0),
4855                 {}
4856         };
4857         static const struct coef_fw coef0292[] = {
4858                 WRITE_COEF(0x6b, 0xd429),
4859                 WRITE_COEF(0x76, 0x0008),
4860                 WRITE_COEF(0x18, 0x7388),
4861                 {}
4862         };
4863         static const struct coef_fw coef0293[] = {
4864                 WRITE_COEF(0x45, 0xd429), /* Set to ctia type */
4865                 UPDATE_COEF(0x10, 7<<8, 7<<8), /* SET Line1 JD to 1 */
4866                 {}
4867         };
4868         static const struct coef_fw coef0688[] = {
4869                 WRITE_COEF(0x11, 0x0001),
4870                 WRITE_COEF(0x15, 0x0d60),
4871                 WRITE_COEF(0xc3, 0x0000),
4872                 {}
4873         };
4874         static const struct coef_fw coef0225_1[] = {
4875                 UPDATE_COEF(0x45, 0x3f<<10, 0x35<<10),
4876                 UPDATE_COEF(0x63, 3<<14, 2<<14),
4877                 {}
4878         };
4879         static const struct coef_fw coef0225_2[] = {
4880                 UPDATE_COEF(0x45, 0x3f<<10, 0x35<<10),
4881                 UPDATE_COEF(0x63, 3<<14, 1<<14),
4882                 {}
4883         };
4884
4885         switch (codec->core.vendor_id) {
4886         case 0x10ec0255:
4887                 alc_process_coef_fw(codec, coef0255);
4888                 break;
4889         case 0x10ec0236:
4890         case 0x10ec0256:
4891                 alc_process_coef_fw(codec, coef0256);
4892                 break;
4893         case 0x10ec0234:
4894         case 0x10ec0274:
4895         case 0x10ec0294:
4896                 alc_write_coef_idx(codec, 0x45, 0xd689);
4897                 break;
4898         case 0x10ec0233:
4899         case 0x10ec0283:
4900                 alc_process_coef_fw(codec, coef0233);
4901                 break;
4902         case 0x10ec0298:
4903                 val = alc_read_coef_idx(codec, 0x50);
4904                 if (val & (1 << 12)) {
4905                         alc_update_coef_idx(codec, 0x8e, 0x0070, 0x0020);
4906                         alc_update_coef_idx(codec, 0x4f, 0xfcc0, 0xd400);
4907                         msleep(300);
4908                 } else {
4909                         alc_update_coef_idx(codec, 0x8e, 0x0070, 0x0010);
4910                         alc_update_coef_idx(codec, 0x4f, 0xfcc0, 0xd400);
4911                         msleep(300);
4912                 }
4913                 break;
4914         case 0x10ec0286:
4915         case 0x10ec0288:
4916                 alc_update_coef_idx(codec, 0x4f, 0xfcc0, 0xd400);
4917                 msleep(300);
4918                 alc_process_coef_fw(codec, coef0288);
4919                 break;
4920         case 0x10ec0292:
4921                 alc_process_coef_fw(codec, coef0292);
4922                 break;
4923         case 0x10ec0293:
4924                 alc_process_coef_fw(codec, coef0293);
4925                 break;
4926         case 0x10ec0668:
4927                 alc_process_coef_fw(codec, coef0688);
4928                 break;
4929         case 0x10ec0215:
4930         case 0x10ec0225:
4931         case 0x10ec0285:
4932         case 0x10ec0295:
4933         case 0x10ec0289:
4934         case 0x10ec0299:
4935                 val = alc_read_coef_idx(codec, 0x45);
4936                 if (val & (1 << 9))
4937                         alc_process_coef_fw(codec, coef0225_2);
4938                 else
4939                         alc_process_coef_fw(codec, coef0225_1);
4940                 break;
4941         case 0x10ec0867:
4942                 alc_update_coefex_idx(codec, 0x57, 0x5, 1<<14, 0);
4943                 break;
4944         }
4945         codec_dbg(codec, "Headset jack set to iPhone-style headset mode.\n");
4946 }
4947
4948 /* Nokia type */
4949 static void alc_headset_mode_omtp(struct hda_codec *codec)
4950 {
4951         static const struct coef_fw coef0255[] = {
4952                 WRITE_COEF(0x45, 0xe489), /* Set to OMTP Type */
4953                 WRITE_COEF(0x1b, 0x0c2b),
4954                 WRITE_COEFEX(0x57, 0x03, 0x8ea6),
4955                 {}
4956         };
4957         static const struct coef_fw coef0256[] = {
4958                 WRITE_COEF(0x45, 0xe489), /* Set to OMTP Type */
4959                 WRITE_COEF(0x1b, 0x0e6b),
4960                 {}
4961         };
4962         static const struct coef_fw coef0233[] = {
4963                 WRITE_COEF(0x45, 0xe429),
4964                 WRITE_COEF(0x1b, 0x0c2b),
4965                 WRITE_COEF(0x32, 0x4ea3),
4966                 {}
4967         };
4968         static const struct coef_fw coef0288[] = {
4969                 UPDATE_COEF(0x50, 0x2000, 0x2000),
4970                 UPDATE_COEF(0x56, 0x0006, 0x0006),
4971                 UPDATE_COEF(0x66, 0x0008, 0),
4972                 UPDATE_COEF(0x67, 0x2000, 0),
4973                 {}
4974         };
4975         static const struct coef_fw coef0292[] = {
4976                 WRITE_COEF(0x6b, 0xe429),
4977                 WRITE_COEF(0x76, 0x0008),
4978                 WRITE_COEF(0x18, 0x7388),
4979                 {}
4980         };
4981         static const struct coef_fw coef0293[] = {
4982                 WRITE_COEF(0x45, 0xe429), /* Set to omtp type */
4983                 UPDATE_COEF(0x10, 7<<8, 7<<8), /* SET Line1 JD to 1 */
4984                 {}
4985         };
4986         static const struct coef_fw coef0688[] = {
4987                 WRITE_COEF(0x11, 0x0001),
4988                 WRITE_COEF(0x15, 0x0d50),
4989                 WRITE_COEF(0xc3, 0x0000),
4990                 {}
4991         };
4992         static const struct coef_fw coef0225[] = {
4993                 UPDATE_COEF(0x45, 0x3f<<10, 0x39<<10),
4994                 UPDATE_COEF(0x63, 3<<14, 2<<14),
4995                 {}
4996         };
4997
4998         switch (codec->core.vendor_id) {
4999         case 0x10ec0255:
5000                 alc_process_coef_fw(codec, coef0255);
5001                 break;
5002         case 0x10ec0236:
5003         case 0x10ec0256:
5004                 alc_process_coef_fw(codec, coef0256);
5005                 break;
5006         case 0x10ec0234:
5007         case 0x10ec0274:
5008         case 0x10ec0294:
5009                 alc_write_coef_idx(codec, 0x45, 0xe689);
5010                 break;
5011         case 0x10ec0233:
5012         case 0x10ec0283:
5013                 alc_process_coef_fw(codec, coef0233);
5014                 break;
5015         case 0x10ec0298:
5016                 alc_update_coef_idx(codec, 0x8e, 0x0070, 0x0010);/* Headset output enable */
5017                 alc_update_coef_idx(codec, 0x4f, 0xfcc0, 0xe400);
5018                 msleep(300);
5019                 break;
5020         case 0x10ec0286:
5021         case 0x10ec0288:
5022                 alc_update_coef_idx(codec, 0x4f, 0xfcc0, 0xe400);
5023                 msleep(300);
5024                 alc_process_coef_fw(codec, coef0288);
5025                 break;
5026         case 0x10ec0292:
5027                 alc_process_coef_fw(codec, coef0292);
5028                 break;
5029         case 0x10ec0293:
5030                 alc_process_coef_fw(codec, coef0293);
5031                 break;
5032         case 0x10ec0668:
5033                 alc_process_coef_fw(codec, coef0688);
5034                 break;
5035         case 0x10ec0215:
5036         case 0x10ec0225:
5037         case 0x10ec0285:
5038         case 0x10ec0295:
5039         case 0x10ec0289:
5040         case 0x10ec0299:
5041                 alc_process_coef_fw(codec, coef0225);
5042                 break;
5043         }
5044         codec_dbg(codec, "Headset jack set to Nokia-style headset mode.\n");
5045 }
5046
5047 static void alc_determine_headset_type(struct hda_codec *codec)
5048 {
5049         int val;
5050         bool is_ctia = false;
5051         struct alc_spec *spec = codec->spec;
5052         static const struct coef_fw coef0255[] = {
5053                 WRITE_COEF(0x45, 0xd089), /* combo jack auto switch control(Check type)*/
5054                 WRITE_COEF(0x49, 0x0149), /* combo jack auto switch control(Vref
5055  conteol) */
5056                 {}
5057         };
5058         static const struct coef_fw coef0288[] = {
5059                 UPDATE_COEF(0x4f, 0xfcc0, 0xd400), /* Check Type */
5060                 {}
5061         };
5062         static const struct coef_fw coef0298[] = {
5063                 UPDATE_COEF(0x50, 0x2000, 0x2000),
5064                 UPDATE_COEF(0x56, 0x0006, 0x0006),
5065                 UPDATE_COEF(0x66, 0x0008, 0),
5066                 UPDATE_COEF(0x67, 0x2000, 0),
5067                 UPDATE_COEF(0x19, 0x1300, 0x1300),
5068                 {}
5069         };
5070         static const struct coef_fw coef0293[] = {
5071                 UPDATE_COEF(0x4a, 0x000f, 0x0008), /* Combo Jack auto detect */
5072                 WRITE_COEF(0x45, 0xD429), /* Set to ctia type */
5073                 {}
5074         };
5075         static const struct coef_fw coef0688[] = {
5076                 WRITE_COEF(0x11, 0x0001),
5077                 WRITE_COEF(0xb7, 0x802b),
5078                 WRITE_COEF(0x15, 0x0d60),
5079                 WRITE_COEF(0xc3, 0x0c00),
5080                 {}
5081         };
5082         static const struct coef_fw coef0274[] = {
5083                 UPDATE_COEF(0x4a, 0x0010, 0),
5084                 UPDATE_COEF(0x4a, 0x8000, 0),
5085                 WRITE_COEF(0x45, 0xd289),
5086                 UPDATE_COEF(0x49, 0x0300, 0x0300),
5087                 {}
5088         };
5089
5090         switch (codec->core.vendor_id) {
5091         case 0x10ec0255:
5092                 alc_process_coef_fw(codec, coef0255);
5093                 msleep(300);
5094                 val = alc_read_coef_idx(codec, 0x46);
5095                 is_ctia = (val & 0x0070) == 0x0070;
5096                 break;
5097         case 0x10ec0236:
5098         case 0x10ec0256:
5099                 alc_write_coef_idx(codec, 0x1b, 0x0e4b);
5100                 alc_write_coef_idx(codec, 0x06, 0x6104);
5101                 alc_write_coefex_idx(codec, 0x57, 0x3, 0x09a3);
5102
5103                 snd_hda_codec_write(codec, 0x21, 0,
5104                             AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);
5105                 msleep(80);
5106                 snd_hda_codec_write(codec, 0x21, 0,
5107                             AC_VERB_SET_PIN_WIDGET_CONTROL, 0x0);
5108
5109                 alc_process_coef_fw(codec, coef0255);
5110                 msleep(300);
5111                 val = alc_read_coef_idx(codec, 0x46);
5112                 is_ctia = (val & 0x0070) == 0x0070;
5113
5114                 alc_write_coefex_idx(codec, 0x57, 0x3, 0x0da3);
5115                 alc_update_coefex_idx(codec, 0x57, 0x5, 1<<14, 0);
5116
5117                 snd_hda_codec_write(codec, 0x21, 0,
5118                             AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT);
5119                 msleep(80);
5120                 snd_hda_codec_write(codec, 0x21, 0,
5121                             AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE);
5122                 break;
5123         case 0x10ec0234:
5124         case 0x10ec0274:
5125         case 0x10ec0294:
5126                 alc_process_coef_fw(codec, coef0274);
5127                 msleep(80);
5128                 val = alc_read_coef_idx(codec, 0x46);
5129                 is_ctia = (val & 0x00f0) == 0x00f0;
5130                 break;
5131         case 0x10ec0233:
5132         case 0x10ec0283:
5133                 alc_write_coef_idx(codec, 0x45, 0xd029);
5134                 msleep(300);
5135                 val = alc_read_coef_idx(codec, 0x46);
5136                 is_ctia = (val & 0x0070) == 0x0070;
5137                 break;
5138         case 0x10ec0298:
5139                 snd_hda_codec_write(codec, 0x21, 0,
5140                             AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);
5141                 msleep(100);
5142                 snd_hda_codec_write(codec, 0x21, 0,
5143                             AC_VERB_SET_PIN_WIDGET_CONTROL, 0x0);
5144                 msleep(200);
5145
5146                 val = alc_read_coef_idx(codec, 0x50);
5147                 if (val & (1 << 12)) {
5148                         alc_update_coef_idx(codec, 0x8e, 0x0070, 0x0020);
5149                         alc_process_coef_fw(codec, coef0288);
5150                         msleep(350);
5151                         val = alc_read_coef_idx(codec, 0x50);
5152                         is_ctia = (val & 0x0070) == 0x0070;
5153                 } else {
5154                         alc_update_coef_idx(codec, 0x8e, 0x0070, 0x0010);
5155                         alc_process_coef_fw(codec, coef0288);
5156                         msleep(350);
5157                         val = alc_read_coef_idx(codec, 0x50);
5158                         is_ctia = (val & 0x0070) == 0x0070;
5159                 }
5160                 alc_process_coef_fw(codec, coef0298);
5161                 snd_hda_codec_write(codec, 0x21, 0,
5162                             AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP);
5163                 msleep(75);
5164                 snd_hda_codec_write(codec, 0x21, 0,
5165                             AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE);
5166                 break;
5167         case 0x10ec0286:
5168         case 0x10ec0288:
5169                 alc_process_coef_fw(codec, coef0288);
5170                 msleep(350);
5171                 val = alc_read_coef_idx(codec, 0x50);
5172                 is_ctia = (val & 0x0070) == 0x0070;
5173                 break;
5174         case 0x10ec0292:
5175                 alc_write_coef_idx(codec, 0x6b, 0xd429);
5176                 msleep(300);
5177                 val = alc_read_coef_idx(codec, 0x6c);
5178                 is_ctia = (val & 0x001c) == 0x001c;
5179                 break;
5180         case 0x10ec0293:
5181                 alc_process_coef_fw(codec, coef0293);
5182                 msleep(300);
5183                 val = alc_read_coef_idx(codec, 0x46);
5184                 is_ctia = (val & 0x0070) == 0x0070;
5185                 break;
5186         case 0x10ec0668:
5187                 alc_process_coef_fw(codec, coef0688);
5188                 msleep(300);
5189                 val = alc_read_coef_idx(codec, 0xbe);
5190                 is_ctia = (val & 0x1c02) == 0x1c02;
5191                 break;
5192         case 0x10ec0215:
5193         case 0x10ec0225:
5194         case 0x10ec0285:
5195         case 0x10ec0295:
5196         case 0x10ec0289:
5197         case 0x10ec0299:
5198                 snd_hda_codec_write(codec, 0x21, 0,
5199                             AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);
5200                 msleep(80);
5201                 snd_hda_codec_write(codec, 0x21, 0,
5202                             AC_VERB_SET_PIN_WIDGET_CONTROL, 0x0);
5203
5204                 alc_process_coef_fw(codec, alc225_pre_hsmode);
5205                 alc_update_coef_idx(codec, 0x67, 0xf000, 0x1000);
5206                 val = alc_read_coef_idx(codec, 0x45);
5207                 if (val & (1 << 9)) {
5208                         alc_update_coef_idx(codec, 0x45, 0x3f<<10, 0x34<<10);
5209                         alc_update_coef_idx(codec, 0x49, 3<<8, 2<<8);
5210                         msleep(800);
5211                         val = alc_read_coef_idx(codec, 0x46);
5212                         is_ctia = (val & 0x00f0) == 0x00f0;
5213                 } else {
5214                         alc_update_coef_idx(codec, 0x45, 0x3f<<10, 0x34<<10);
5215                         alc_update_coef_idx(codec, 0x49, 3<<8, 1<<8);
5216                         msleep(800);
5217                         val = alc_read_coef_idx(codec, 0x46);
5218                         is_ctia = (val & 0x00f0) == 0x00f0;
5219                 }
5220                 alc_update_coef_idx(codec, 0x4a, 7<<6, 7<<6);
5221                 alc_update_coef_idx(codec, 0x4a, 3<<4, 3<<4);
5222                 alc_update_coef_idx(codec, 0x67, 0xf000, 0x3000);
5223
5224                 snd_hda_codec_write(codec, 0x21, 0,
5225                             AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT);
5226                 msleep(80);
5227                 snd_hda_codec_write(codec, 0x21, 0,
5228                             AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE);
5229                 break;
5230         case 0x10ec0867:
5231                 is_ctia = true;
5232                 break;
5233         }
5234
5235         codec_dbg(codec, "Headset jack detected iPhone-style headset: %s\n",
5236                     is_ctia ? "yes" : "no");
5237         spec->current_headset_type = is_ctia ? ALC_HEADSET_TYPE_CTIA : ALC_HEADSET_TYPE_OMTP;
5238 }
5239
5240 static void alc_update_headset_mode(struct hda_codec *codec)
5241 {
5242         struct alc_spec *spec = codec->spec;
5243
5244         hda_nid_t mux_pin = spec->gen.imux_pins[spec->gen.cur_mux[0]];
5245         hda_nid_t hp_pin = alc_get_hp_pin(spec);
5246
5247         int new_headset_mode;
5248
5249         if (!snd_hda_jack_detect(codec, hp_pin))
5250                 new_headset_mode = ALC_HEADSET_MODE_UNPLUGGED;
5251         else if (mux_pin == spec->headset_mic_pin)
5252                 new_headset_mode = ALC_HEADSET_MODE_HEADSET;
5253         else if (mux_pin == spec->headphone_mic_pin)
5254                 new_headset_mode = ALC_HEADSET_MODE_MIC;
5255         else
5256                 new_headset_mode = ALC_HEADSET_MODE_HEADPHONE;
5257
5258         if (new_headset_mode == spec->current_headset_mode) {
5259                 snd_hda_gen_update_outputs(codec);
5260                 return;
5261         }
5262
5263         switch (new_headset_mode) {
5264         case ALC_HEADSET_MODE_UNPLUGGED:
5265                 alc_headset_mode_unplugged(codec);
5266                 spec->current_headset_mode = ALC_HEADSET_MODE_UNKNOWN;
5267                 spec->current_headset_type = ALC_HEADSET_TYPE_UNKNOWN;
5268                 spec->gen.hp_jack_present = false;
5269                 break;
5270         case ALC_HEADSET_MODE_HEADSET:
5271                 if (spec->current_headset_type == ALC_HEADSET_TYPE_UNKNOWN)
5272                         alc_determine_headset_type(codec);
5273                 if (spec->current_headset_type == ALC_HEADSET_TYPE_CTIA)
5274                         alc_headset_mode_ctia(codec);
5275                 else if (spec->current_headset_type == ALC_HEADSET_TYPE_OMTP)
5276                         alc_headset_mode_omtp(codec);
5277                 spec->gen.hp_jack_present = true;
5278                 break;
5279         case ALC_HEADSET_MODE_MIC:
5280                 alc_headset_mode_mic_in(codec, hp_pin, spec->headphone_mic_pin);
5281                 spec->gen.hp_jack_present = false;
5282                 break;
5283         case ALC_HEADSET_MODE_HEADPHONE:
5284                 alc_headset_mode_default(codec);
5285                 spec->gen.hp_jack_present = true;
5286                 break;
5287         }
5288         if (new_headset_mode != ALC_HEADSET_MODE_MIC) {
5289                 snd_hda_set_pin_ctl_cache(codec, hp_pin,
5290                                           AC_PINCTL_OUT_EN | AC_PINCTL_HP_EN);
5291                 if (spec->headphone_mic_pin && spec->headphone_mic_pin != hp_pin)
5292                         snd_hda_set_pin_ctl_cache(codec, spec->headphone_mic_pin,
5293                                                   PIN_VREFHIZ);
5294         }
5295         spec->current_headset_mode = new_headset_mode;
5296
5297         snd_hda_gen_update_outputs(codec);
5298 }
5299
5300 static void alc_update_headset_mode_hook(struct hda_codec *codec,
5301                                          struct snd_kcontrol *kcontrol,
5302                                          struct snd_ctl_elem_value *ucontrol)
5303 {
5304         alc_update_headset_mode(codec);
5305 }
5306
5307 static void alc_update_headset_jack_cb(struct hda_codec *codec,
5308                                        struct hda_jack_callback *jack)
5309 {
5310         snd_hda_gen_hp_automute(codec, jack);
5311 }
5312
5313 static void alc_probe_headset_mode(struct hda_codec *codec)
5314 {
5315         int i;
5316         struct alc_spec *spec = codec->spec;
5317         struct auto_pin_cfg *cfg = &spec->gen.autocfg;
5318
5319         /* Find mic pins */
5320         for (i = 0; i < cfg->num_inputs; i++) {
5321                 if (cfg->inputs[i].is_headset_mic && !spec->headset_mic_pin)
5322                         spec->headset_mic_pin = cfg->inputs[i].pin;
5323                 if (cfg->inputs[i].is_headphone_mic && !spec->headphone_mic_pin)
5324                         spec->headphone_mic_pin = cfg->inputs[i].pin;
5325         }
5326
5327         WARN_ON(spec->gen.cap_sync_hook);
5328         spec->gen.cap_sync_hook = alc_update_headset_mode_hook;
5329         spec->gen.automute_hook = alc_update_headset_mode;
5330         spec->gen.hp_automute_hook = alc_update_headset_jack_cb;
5331 }
5332
5333 static void alc_fixup_headset_mode(struct hda_codec *codec,
5334                                 const struct hda_fixup *fix, int action)
5335 {
5336         struct alc_spec *spec = codec->spec;
5337
5338         switch (action) {
5339         case HDA_FIXUP_ACT_PRE_PROBE:
5340                 spec->parse_flags |= HDA_PINCFG_HEADSET_MIC | HDA_PINCFG_HEADPHONE_MIC;
5341                 break;
5342         case HDA_FIXUP_ACT_PROBE:
5343                 alc_probe_headset_mode(codec);
5344                 break;
5345         case HDA_FIXUP_ACT_INIT:
5346                 if (is_s3_resume(codec) || is_s4_resume(codec)) {
5347                         spec->current_headset_mode = ALC_HEADSET_MODE_UNKNOWN;
5348                         spec->current_headset_type = ALC_HEADSET_TYPE_UNKNOWN;
5349                 }
5350                 alc_update_headset_mode(codec);
5351                 break;
5352         }
5353 }
5354
5355 static void alc_fixup_headset_mode_no_hp_mic(struct hda_codec *codec,
5356                                 const struct hda_fixup *fix, int action)
5357 {
5358         if (action == HDA_FIXUP_ACT_PRE_PROBE) {
5359                 struct alc_spec *spec = codec->spec;
5360                 spec->parse_flags |= HDA_PINCFG_HEADSET_MIC;
5361         }
5362         else
5363                 alc_fixup_headset_mode(codec, fix, action);
5364 }
5365
5366 static void alc255_set_default_jack_type(struct hda_codec *codec)
5367 {
5368         /* Set to iphone type */
5369         static const struct coef_fw alc255fw[] = {
5370                 WRITE_COEF(0x1b, 0x880b),
5371                 WRITE_COEF(0x45, 0xd089),
5372                 WRITE_COEF(0x1b, 0x080b),
5373                 WRITE_COEF(0x46, 0x0004),
5374                 WRITE_COEF(0x1b, 0x0c0b),
5375                 {}
5376         };
5377         static const struct coef_fw alc256fw[] = {
5378                 WRITE_COEF(0x1b, 0x884b),
5379                 WRITE_COEF(0x45, 0xd089),
5380                 WRITE_COEF(0x1b, 0x084b),
5381                 WRITE_COEF(0x46, 0x0004),
5382                 WRITE_COEF(0x1b, 0x0c4b),
5383                 {}
5384         };
5385         switch (codec->core.vendor_id) {
5386         case 0x10ec0255:
5387                 alc_process_coef_fw(codec, alc255fw);
5388                 break;
5389         case 0x10ec0236:
5390         case 0x10ec0256:
5391                 alc_process_coef_fw(codec, alc256fw);
5392                 break;
5393         }
5394         msleep(30);
5395 }
5396
5397 static void alc_fixup_headset_mode_alc255(struct hda_codec *codec,
5398                                 const struct hda_fixup *fix, int action)
5399 {
5400         if (action == HDA_FIXUP_ACT_PRE_PROBE) {
5401                 alc255_set_default_jack_type(codec);
5402         }
5403         alc_fixup_headset_mode(codec, fix, action);
5404 }
5405
5406 static void alc_fixup_headset_mode_alc255_no_hp_mic(struct hda_codec *codec,
5407                                 const struct hda_fixup *fix, int action)
5408 {
5409         if (action == HDA_FIXUP_ACT_PRE_PROBE) {
5410                 struct alc_spec *spec = codec->spec;
5411                 spec->parse_flags |= HDA_PINCFG_HEADSET_MIC;
5412                 alc255_set_default_jack_type(codec);
5413         }
5414         else
5415                 alc_fixup_headset_mode(codec, fix, action);
5416 }
5417
5418 static void alc288_update_headset_jack_cb(struct hda_codec *codec,
5419                                        struct hda_jack_callback *jack)
5420 {
5421         struct alc_spec *spec = codec->spec;
5422
5423         alc_update_headset_jack_cb(codec, jack);
5424         /* Headset Mic enable or disable, only for Dell Dino */
5425         alc_update_gpio_data(codec, 0x40, spec->gen.hp_jack_present);
5426 }
5427
5428 static void alc_fixup_headset_mode_dell_alc288(struct hda_codec *codec,
5429                                 const struct hda_fixup *fix, int action)
5430 {
5431         alc_fixup_headset_mode(codec, fix, action);
5432         if (action == HDA_FIXUP_ACT_PROBE) {
5433                 struct alc_spec *spec = codec->spec;
5434                 /* toggled via hp_automute_hook */
5435                 spec->gpio_mask |= 0x40;
5436                 spec->gpio_dir |= 0x40;
5437                 spec->gen.hp_automute_hook = alc288_update_headset_jack_cb;
5438         }
5439 }
5440
5441 static void alc_fixup_auto_mute_via_amp(struct hda_codec *codec,
5442                                         const struct hda_fixup *fix, int action)
5443 {
5444         if (action == HDA_FIXUP_ACT_PRE_PROBE) {
5445                 struct alc_spec *spec = codec->spec;
5446                 spec->gen.auto_mute_via_amp = 1;
5447         }
5448 }
5449
5450 static void alc_fixup_no_shutup(struct hda_codec *codec,
5451                                 const struct hda_fixup *fix, int action)
5452 {
5453         if (action == HDA_FIXUP_ACT_PRE_PROBE) {
5454                 struct alc_spec *spec = codec->spec;
5455                 spec->no_shutup_pins = 1;
5456         }
5457 }
5458
5459 static void alc_fixup_disable_aamix(struct hda_codec *codec,
5460                                     const struct hda_fixup *fix, int action)
5461 {
5462         if (action == HDA_FIXUP_ACT_PRE_PROBE) {
5463                 struct alc_spec *spec = codec->spec;
5464                 /* Disable AA-loopback as it causes white noise */
5465                 spec->gen.mixer_nid = 0;
5466         }
5467 }
5468
5469 /* fixup for Thinkpad docks: add dock pins, avoid HP parser fixup */
5470 static void alc_fixup_tpt440_dock(struct hda_codec *codec,
5471                                   const struct hda_fixup *fix, int action)
5472 {
5473         static const struct hda_pintbl pincfgs[] = {
5474                 { 0x16, 0x21211010 }, /* dock headphone */
5475                 { 0x19, 0x21a11010 }, /* dock mic */
5476                 { }
5477         };
5478         struct alc_spec *spec = codec->spec;
5479
5480         if (action == HDA_FIXUP_ACT_PRE_PROBE) {
5481                 spec->reboot_notify = snd_hda_gen_reboot_notify; /* reduce noise */
5482                 spec->parse_flags = HDA_PINCFG_NO_HP_FIXUP;
5483                 codec->power_save_node = 0; /* avoid click noises */
5484                 snd_hda_apply_pincfgs(codec, pincfgs);
5485         }
5486 }
5487
5488 static void alc_fixup_tpt470_dock(struct hda_codec *codec,
5489                                   const struct hda_fixup *fix, int action)
5490 {
5491         static const struct hda_pintbl pincfgs[] = {
5492                 { 0x17, 0x21211010 }, /* dock headphone */
5493                 { 0x19, 0x21a11010 }, /* dock mic */
5494                 { }
5495         };
5496         struct alc_spec *spec = codec->spec;
5497
5498         if (action == HDA_FIXUP_ACT_PRE_PROBE) {
5499                 spec->parse_flags = HDA_PINCFG_NO_HP_FIXUP;
5500                 snd_hda_apply_pincfgs(codec, pincfgs);
5501         } else if (action == HDA_FIXUP_ACT_INIT) {
5502                 /* Enable DOCK device */
5503                 snd_hda_codec_write(codec, 0x17, 0,
5504                             AC_VERB_SET_CONFIG_DEFAULT_BYTES_3, 0);
5505                 /* Enable DOCK device */
5506                 snd_hda_codec_write(codec, 0x19, 0,
5507                             AC_VERB_SET_CONFIG_DEFAULT_BYTES_3, 0);
5508         }
5509 }
5510
5511 static void alc_fixup_tpt470_dacs(struct hda_codec *codec,
5512                                   const struct hda_fixup *fix, int action)
5513 {
5514         /* Assure the speaker pin to be coupled with DAC NID 0x03; otherwise
5515          * the speaker output becomes too low by some reason on Thinkpads with
5516          * ALC298 codec
5517          */
5518         static const hda_nid_t preferred_pairs[] = {
5519                 0x14, 0x03, 0x17, 0x02, 0x21, 0x02,
5520                 0
5521         };
5522         struct alc_spec *spec = codec->spec;
5523
5524         if (action == HDA_FIXUP_ACT_PRE_PROBE)
5525                 spec->gen.preferred_dacs = preferred_pairs;
5526 }
5527
5528 static void alc_shutup_dell_xps13(struct hda_codec *codec)
5529 {
5530         struct alc_spec *spec = codec->spec;
5531         int hp_pin = alc_get_hp_pin(spec);
5532
5533         /* Prevent pop noises when headphones are plugged in */
5534         snd_hda_codec_write(codec, hp_pin, 0,
5535                             AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);
5536         msleep(20);
5537 }
5538
5539 static void alc_fixup_dell_xps13(struct hda_codec *codec,
5540                                 const struct hda_fixup *fix, int action)
5541 {
5542         struct alc_spec *spec = codec->spec;
5543         struct hda_input_mux *imux = &spec->gen.input_mux;
5544         int i;
5545
5546         switch (action) {
5547         case HDA_FIXUP_ACT_PRE_PROBE:
5548                 /* mic pin 0x19 must be initialized with Vref Hi-Z, otherwise
5549                  * it causes a click noise at start up
5550                  */
5551                 snd_hda_codec_set_pin_target(codec, 0x19, PIN_VREFHIZ);
5552                 spec->shutup = alc_shutup_dell_xps13;
5553                 break;
5554         case HDA_FIXUP_ACT_PROBE:
5555                 /* Make the internal mic the default input source. */
5556                 for (i = 0; i < imux->num_items; i++) {
5557                         if (spec->gen.imux_pins[i] == 0x12) {
5558                                 spec->gen.cur_mux[0] = i;
5559                                 break;
5560                         }
5561                 }
5562                 break;
5563         }
5564 }
5565
5566 static void alc_fixup_headset_mode_alc662(struct hda_codec *codec,
5567                                 const struct hda_fixup *fix, int action)
5568 {
5569         struct alc_spec *spec = codec->spec;
5570
5571         if (action == HDA_FIXUP_ACT_PRE_PROBE) {
5572                 spec->parse_flags |= HDA_PINCFG_HEADSET_MIC;
5573                 spec->gen.hp_mic = 1; /* Mic-in is same pin as headphone */
5574
5575                 /* Disable boost for mic-in permanently. (This code is only called
5576                    from quirks that guarantee that the headphone is at NID 0x1b.) */
5577                 snd_hda_codec_write(codec, 0x1b, 0, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000);
5578                 snd_hda_override_wcaps(codec, 0x1b, get_wcaps(codec, 0x1b) & ~AC_WCAP_IN_AMP);
5579         } else
5580                 alc_fixup_headset_mode(codec, fix, action);
5581 }
5582
5583 static void alc_fixup_headset_mode_alc668(struct hda_codec *codec,
5584                                 const struct hda_fixup *fix, int action)
5585 {
5586         if (action == HDA_FIXUP_ACT_PRE_PROBE) {
5587                 alc_write_coef_idx(codec, 0xc4, 0x8000);
5588                 alc_update_coef_idx(codec, 0xc2, ~0xfe, 0);
5589                 snd_hda_set_pin_ctl_cache(codec, 0x18, 0);
5590         }
5591         alc_fixup_headset_mode(codec, fix, action);
5592 }
5593
5594 /* Returns the nid of the external mic input pin, or 0 if it cannot be found. */
5595 static int find_ext_mic_pin(struct hda_codec *codec)
5596 {
5597         struct alc_spec *spec = codec->spec;
5598         struct auto_pin_cfg *cfg = &spec->gen.autocfg;
5599         hda_nid_t nid;
5600         unsigned int defcfg;
5601         int i;
5602
5603         for (i = 0; i < cfg->num_inputs; i++) {
5604                 if (cfg->inputs[i].type != AUTO_PIN_MIC)
5605                         continue;
5606                 nid = cfg->inputs[i].pin;
5607                 defcfg = snd_hda_codec_get_pincfg(codec, nid);
5608                 if (snd_hda_get_input_pin_attr(defcfg) == INPUT_PIN_ATTR_INT)
5609                         continue;
5610                 return nid;
5611         }
5612
5613         return 0;
5614 }
5615
5616 static void alc271_hp_gate_mic_jack(struct hda_codec *codec,
5617                                     const struct hda_fixup *fix,
5618                                     int action)
5619 {
5620         struct alc_spec *spec = codec->spec;
5621
5622         if (action == HDA_FIXUP_ACT_PROBE) {
5623                 int mic_pin = find_ext_mic_pin(codec);
5624                 int hp_pin = alc_get_hp_pin(spec);
5625
5626                 if (snd_BUG_ON(!mic_pin || !hp_pin))
5627                         return;
5628                 snd_hda_jack_set_gating_jack(codec, mic_pin, hp_pin);
5629         }
5630 }
5631
5632 static void alc269_fixup_limit_int_mic_boost(struct hda_codec *codec,
5633                                              const struct hda_fixup *fix,
5634                                              int action)
5635 {
5636         struct alc_spec *spec = codec->spec;
5637         struct auto_pin_cfg *cfg = &spec->gen.autocfg;
5638         int i;
5639
5640         /* The mic boosts on level 2 and 3 are too noisy
5641            on the internal mic input.
5642            Therefore limit the boost to 0 or 1. */
5643
5644         if (action != HDA_FIXUP_ACT_PROBE)
5645                 return;
5646
5647         for (i = 0; i < cfg->num_inputs; i++) {
5648                 hda_nid_t nid = cfg->inputs[i].pin;
5649                 unsigned int defcfg;
5650                 if (cfg->inputs[i].type != AUTO_PIN_MIC)
5651                         continue;
5652                 defcfg = snd_hda_codec_get_pincfg(codec, nid);
5653                 if (snd_hda_get_input_pin_attr(defcfg) != INPUT_PIN_ATTR_INT)
5654                         continue;
5655
5656                 snd_hda_override_amp_caps(codec, nid, HDA_INPUT,
5657                                           (0x00 << AC_AMPCAP_OFFSET_SHIFT) |
5658                                           (0x01 << AC_AMPCAP_NUM_STEPS_SHIFT) |
5659                                           (0x2f << AC_AMPCAP_STEP_SIZE_SHIFT) |
5660                                           (0 << AC_AMPCAP_MUTE_SHIFT));
5661         }
5662 }
5663
5664 static void alc283_hp_automute_hook(struct hda_codec *codec,
5665                                     struct hda_jack_callback *jack)
5666 {
5667         struct alc_spec *spec = codec->spec;
5668         int vref;
5669
5670         msleep(200);
5671         snd_hda_gen_hp_automute(codec, jack);
5672
5673         vref = spec->gen.hp_jack_present ? PIN_VREF80 : 0;
5674
5675         msleep(600);
5676         snd_hda_codec_write(codec, 0x19, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
5677                             vref);
5678 }
5679
5680 static void alc283_fixup_chromebook(struct hda_codec *codec,
5681                                     const struct hda_fixup *fix, int action)
5682 {
5683         struct alc_spec *spec = codec->spec;
5684
5685         switch (action) {
5686         case HDA_FIXUP_ACT_PRE_PROBE:
5687                 snd_hda_override_wcaps(codec, 0x03, 0);
5688                 /* Disable AA-loopback as it causes white noise */
5689                 spec->gen.mixer_nid = 0;
5690                 break;
5691         case HDA_FIXUP_ACT_INIT:
5692                 /* MIC2-VREF control */
5693                 /* Set to manual mode */
5694                 alc_update_coef_idx(codec, 0x06, 0x000c, 0);
5695                 /* Enable Line1 input control by verb */
5696                 alc_update_coef_idx(codec, 0x1a, 0, 1 << 4);
5697                 break;
5698         }
5699 }
5700
5701 static void alc283_fixup_sense_combo_jack(struct hda_codec *codec,
5702                                     const struct hda_fixup *fix, int action)
5703 {
5704         struct alc_spec *spec = codec->spec;
5705
5706         switch (action) {
5707         case HDA_FIXUP_ACT_PRE_PROBE:
5708                 spec->gen.hp_automute_hook = alc283_hp_automute_hook;
5709                 break;
5710         case HDA_FIXUP_ACT_INIT:
5711                 /* MIC2-VREF control */
5712                 /* Set to manual mode */
5713                 alc_update_coef_idx(codec, 0x06, 0x000c, 0);
5714                 break;
5715         }
5716 }
5717
5718 /* mute tablet speaker pin (0x14) via dock plugging in addition */
5719 static void asus_tx300_automute(struct hda_codec *codec)
5720 {
5721         struct alc_spec *spec = codec->spec;
5722         snd_hda_gen_update_outputs(codec);
5723         if (snd_hda_jack_detect(codec, 0x1b))
5724                 spec->gen.mute_bits |= (1ULL << 0x14);
5725 }
5726
5727 static void alc282_fixup_asus_tx300(struct hda_codec *codec,
5728                                     const struct hda_fixup *fix, int action)
5729 {
5730         struct alc_spec *spec = codec->spec;
5731         static const struct hda_pintbl dock_pins[] = {
5732                 { 0x1b, 0x21114000 }, /* dock speaker pin */
5733                 {}
5734         };
5735
5736         switch (action) {
5737         case HDA_FIXUP_ACT_PRE_PROBE:
5738                 spec->init_amp = ALC_INIT_DEFAULT;
5739                 /* TX300 needs to set up GPIO2 for the speaker amp */
5740                 alc_setup_gpio(codec, 0x04);
5741                 snd_hda_apply_pincfgs(codec, dock_pins);
5742                 spec->gen.auto_mute_via_amp = 1;
5743                 spec->gen.automute_hook = asus_tx300_automute;
5744                 snd_hda_jack_detect_enable_callback(codec, 0x1b,
5745                                                     snd_hda_gen_hp_automute);
5746                 break;
5747         case HDA_FIXUP_ACT_PROBE:
5748                 spec->init_amp = ALC_INIT_DEFAULT;
5749                 break;
5750         case HDA_FIXUP_ACT_BUILD:
5751                 /* this is a bit tricky; give more sane names for the main
5752                  * (tablet) speaker and the dock speaker, respectively
5753                  */
5754                 rename_ctl(codec, "Speaker Playback Switch",
5755                            "Dock Speaker Playback Switch");
5756                 rename_ctl(codec, "Bass Speaker Playback Switch",
5757                            "Speaker Playback Switch");
5758                 break;
5759         }
5760 }
5761
5762 static void alc290_fixup_mono_speakers(struct hda_codec *codec,
5763                                        const struct hda_fixup *fix, int action)
5764 {
5765         if (action == HDA_FIXUP_ACT_PRE_PROBE) {
5766                 /* DAC node 0x03 is giving mono output. We therefore want to
5767                    make sure 0x14 (front speaker) and 0x15 (headphones) use the
5768                    stereo DAC, while leaving 0x17 (bass speaker) for node 0x03. */
5769                 static const hda_nid_t conn1[] = { 0x0c };
5770                 snd_hda_override_conn_list(codec, 0x14, ARRAY_SIZE(conn1), conn1);
5771                 snd_hda_override_conn_list(codec, 0x15, ARRAY_SIZE(conn1), conn1);
5772         }
5773 }
5774
5775 static void alc298_fixup_speaker_volume(struct hda_codec *codec,
5776                                         const struct hda_fixup *fix, int action)
5777 {
5778         if (action == HDA_FIXUP_ACT_PRE_PROBE) {
5779                 /* The speaker is routed to the Node 0x06 by a mistake, as a result
5780                    we can't adjust the speaker's volume since this node does not has
5781                    Amp-out capability. we change the speaker's route to:
5782                    Node 0x02 (Audio Output) -> Node 0x0c (Audio Mixer) -> Node 0x17 (
5783                    Pin Complex), since Node 0x02 has Amp-out caps, we can adjust
5784                    speaker's volume now. */
5785
5786                 static const hda_nid_t conn1[] = { 0x0c };
5787                 snd_hda_override_conn_list(codec, 0x17, ARRAY_SIZE(conn1), conn1);
5788         }
5789 }
5790
5791 /* disable DAC3 (0x06) selection on NID 0x17 as it has no volume amp control */
5792 static void alc295_fixup_disable_dac3(struct hda_codec *codec,
5793                                       const struct hda_fixup *fix, int action)
5794 {
5795         if (action == HDA_FIXUP_ACT_PRE_PROBE) {
5796                 static const hda_nid_t conn[] = { 0x02, 0x03 };
5797                 snd_hda_override_conn_list(codec, 0x17, ARRAY_SIZE(conn), conn);
5798         }
5799 }
5800
5801 /* force NID 0x17 (Bass Speaker) to DAC1 to share it with the main speaker */
5802 static void alc285_fixup_speaker2_to_dac1(struct hda_codec *codec,
5803                                           const struct hda_fixup *fix, int action)
5804 {
5805         if (action == HDA_FIXUP_ACT_PRE_PROBE) {
5806                 static const hda_nid_t conn[] = { 0x02 };
5807                 snd_hda_override_conn_list(codec, 0x17, ARRAY_SIZE(conn), conn);
5808         }
5809 }
5810
5811 /* Hook to update amp GPIO4 for automute */
5812 static void alc280_hp_gpio4_automute_hook(struct hda_codec *codec,
5813                                           struct hda_jack_callback *jack)
5814 {
5815         struct alc_spec *spec = codec->spec;
5816
5817         snd_hda_gen_hp_automute(codec, jack);
5818         /* mute_led_polarity is set to 0, so we pass inverted value here */
5819         alc_update_gpio_led(codec, 0x10, spec->mute_led_polarity,
5820                             !spec->gen.hp_jack_present);
5821 }
5822
5823 /* Manage GPIOs for HP EliteBook Folio 9480m.
5824  *
5825  * GPIO4 is the headphone amplifier power control
5826  * GPIO3 is the audio output mute indicator LED
5827  */
5828
5829 static void alc280_fixup_hp_9480m(struct hda_codec *codec,
5830                                   const struct hda_fixup *fix,
5831                                   int action)
5832 {
5833         struct alc_spec *spec = codec->spec;
5834
5835         alc_fixup_hp_gpio_led(codec, action, 0x08, 0);
5836         if (action == HDA_FIXUP_ACT_PRE_PROBE) {
5837                 /* amp at GPIO4; toggled via alc280_hp_gpio4_automute_hook() */
5838                 spec->gpio_mask |= 0x10;
5839                 spec->gpio_dir |= 0x10;
5840                 spec->gen.hp_automute_hook = alc280_hp_gpio4_automute_hook;
5841         }
5842 }
5843
5844 static void alc275_fixup_gpio4_off(struct hda_codec *codec,
5845                                    const struct hda_fixup *fix,
5846                                    int action)
5847 {
5848         struct alc_spec *spec = codec->spec;
5849
5850         if (action == HDA_FIXUP_ACT_PRE_PROBE) {
5851                 spec->gpio_mask |= 0x04;
5852                 spec->gpio_dir |= 0x04;
5853                 /* set data bit low */
5854         }
5855 }
5856
5857 static void alc233_alc662_fixup_lenovo_dual_codecs(struct hda_codec *codec,
5858                                          const struct hda_fixup *fix,
5859                                          int action)
5860 {
5861         alc_fixup_dual_codecs(codec, fix, action);
5862         switch (action) {
5863         case HDA_FIXUP_ACT_PRE_PROBE:
5864                 /* override card longname to provide a unique UCM profile */
5865                 strcpy(codec->card->longname, "HDAudio-Lenovo-DualCodecs");
5866                 break;
5867         case HDA_FIXUP_ACT_BUILD:
5868                 /* rename Capture controls depending on the codec */
5869                 rename_ctl(codec, "Capture Volume",
5870                            codec->addr == 0 ?
5871                            "Rear-Panel Capture Volume" :
5872                            "Front-Panel Capture Volume");
5873                 rename_ctl(codec, "Capture Switch",
5874                            codec->addr == 0 ?
5875                            "Rear-Panel Capture Switch" :
5876                            "Front-Panel Capture Switch");
5877                 break;
5878         }
5879 }
5880
5881 static void alc225_fixup_s3_pop_noise(struct hda_codec *codec,
5882                                       const struct hda_fixup *fix, int action)
5883 {
5884         if (action != HDA_FIXUP_ACT_PRE_PROBE)
5885                 return;
5886
5887         codec->power_save_node = 1;
5888 }
5889
5890 /* Forcibly assign NID 0x03 to HP/LO while NID 0x02 to SPK for EQ */
5891 static void alc274_fixup_bind_dacs(struct hda_codec *codec,
5892                                     const struct hda_fixup *fix, int action)
5893 {
5894         struct alc_spec *spec = codec->spec;
5895         static const hda_nid_t preferred_pairs[] = {
5896                 0x21, 0x03, 0x1b, 0x03, 0x16, 0x02,
5897                 0
5898         };
5899
5900         if (action != HDA_FIXUP_ACT_PRE_PROBE)
5901                 return;
5902
5903         spec->gen.preferred_dacs = preferred_pairs;
5904         spec->gen.auto_mute_via_amp = 1;
5905         codec->power_save_node = 0;
5906 }
5907
5908 /* The DAC of NID 0x3 will introduce click/pop noise on headphones, so invalidate it */
5909 static void alc285_fixup_invalidate_dacs(struct hda_codec *codec,
5910                               const struct hda_fixup *fix, int action)
5911 {
5912         if (action != HDA_FIXUP_ACT_PRE_PROBE)
5913                 return;
5914
5915         snd_hda_override_wcaps(codec, 0x03, 0);
5916 }
5917
5918 static void alc295_fixup_chromebook(struct hda_codec *codec,
5919                                     const struct hda_fixup *fix, int action)
5920 {
5921         struct alc_spec *spec = codec->spec;
5922
5923         switch (action) {
5924         case HDA_FIXUP_ACT_PRE_PROBE:
5925                 spec->ultra_low_power = true;
5926                 break;
5927         case HDA_FIXUP_ACT_INIT:
5928                 switch (codec->core.vendor_id) {
5929                 case 0x10ec0295:
5930                         alc_update_coef_idx(codec, 0x4a, 0x8000, 1 << 15); /* Reset HP JD */
5931                         alc_update_coef_idx(codec, 0x4a, 0x8000, 0 << 15);
5932                         break;
5933                 case 0x10ec0236:
5934                         alc_update_coef_idx(codec, 0x1b, 0x8000, 1 << 15); /* Reset HP JD */
5935                         alc_update_coef_idx(codec, 0x1b, 0x8000, 0 << 15);
5936                         break;
5937                 }
5938                 break;
5939         }
5940 }
5941
5942 static void alc_fixup_disable_mic_vref(struct hda_codec *codec,
5943                                   const struct hda_fixup *fix, int action)
5944 {
5945         if (action == HDA_FIXUP_ACT_PRE_PROBE)
5946                 snd_hda_codec_set_pin_target(codec, 0x19, PIN_VREFHIZ);
5947 }
5948
5949 /* for hda_fixup_thinkpad_acpi() */
5950 #include "thinkpad_helper.c"
5951
5952 static void alc_fixup_thinkpad_acpi(struct hda_codec *codec,
5953                                     const struct hda_fixup *fix, int action)
5954 {
5955         alc_fixup_no_shutup(codec, fix, action); /* reduce click noise */
5956         hda_fixup_thinkpad_acpi(codec, fix, action);
5957 }
5958
5959 /* for alc295_fixup_hp_top_speakers */
5960 #include "hp_x360_helper.c"
5961
5962 enum {
5963         ALC269_FIXUP_SONY_VAIO,
5964         ALC275_FIXUP_SONY_VAIO_GPIO2,
5965         ALC269_FIXUP_DELL_M101Z,
5966         ALC269_FIXUP_SKU_IGNORE,
5967         ALC269_FIXUP_ASUS_G73JW,
5968         ALC269_FIXUP_LENOVO_EAPD,
5969         ALC275_FIXUP_SONY_HWEQ,
5970         ALC275_FIXUP_SONY_DISABLE_AAMIX,
5971         ALC271_FIXUP_DMIC,
5972         ALC269_FIXUP_PCM_44K,
5973         ALC269_FIXUP_STEREO_DMIC,
5974         ALC269_FIXUP_HEADSET_MIC,
5975         ALC269_FIXUP_QUANTA_MUTE,
5976         ALC269_FIXUP_LIFEBOOK,
5977         ALC269_FIXUP_LIFEBOOK_EXTMIC,
5978         ALC269_FIXUP_LIFEBOOK_HP_PIN,
5979         ALC269_FIXUP_LIFEBOOK_NO_HP_TO_LINEOUT,
5980         ALC255_FIXUP_LIFEBOOK_U7x7_HEADSET_MIC,
5981         ALC269_FIXUP_AMIC,
5982         ALC269_FIXUP_DMIC,
5983         ALC269VB_FIXUP_AMIC,
5984         ALC269VB_FIXUP_DMIC,
5985         ALC269_FIXUP_HP_MUTE_LED,
5986         ALC269_FIXUP_HP_MUTE_LED_MIC1,
5987         ALC269_FIXUP_HP_MUTE_LED_MIC2,
5988         ALC269_FIXUP_HP_MUTE_LED_MIC3,
5989         ALC269_FIXUP_HP_GPIO_LED,
5990         ALC269_FIXUP_HP_GPIO_MIC1_LED,
5991         ALC269_FIXUP_HP_LINE1_MIC1_LED,
5992         ALC269_FIXUP_INV_DMIC,
5993         ALC269_FIXUP_LENOVO_DOCK,
5994         ALC269_FIXUP_LENOVO_DOCK_LIMIT_BOOST,
5995         ALC269_FIXUP_NO_SHUTUP,
5996         ALC286_FIXUP_SONY_MIC_NO_PRESENCE,
5997         ALC269_FIXUP_PINCFG_NO_HP_TO_LINEOUT,
5998         ALC269_FIXUP_DELL1_MIC_NO_PRESENCE,
5999         ALC269_FIXUP_DELL2_MIC_NO_PRESENCE,
6000         ALC269_FIXUP_DELL3_MIC_NO_PRESENCE,
6001         ALC269_FIXUP_DELL4_MIC_NO_PRESENCE,
6002         ALC269_FIXUP_HEADSET_MODE,
6003         ALC269_FIXUP_HEADSET_MODE_NO_HP_MIC,
6004         ALC269_FIXUP_ASPIRE_HEADSET_MIC,
6005         ALC269_FIXUP_ASUS_X101_FUNC,
6006         ALC269_FIXUP_ASUS_X101_VERB,
6007         ALC269_FIXUP_ASUS_X101,
6008         ALC271_FIXUP_AMIC_MIC2,
6009         ALC271_FIXUP_HP_GATE_MIC_JACK,
6010         ALC271_FIXUP_HP_GATE_MIC_JACK_E1_572,
6011         ALC269_FIXUP_ACER_AC700,
6012         ALC269_FIXUP_LIMIT_INT_MIC_BOOST,
6013         ALC269VB_FIXUP_ASUS_ZENBOOK,
6014         ALC269VB_FIXUP_ASUS_ZENBOOK_UX31A,
6015         ALC269_FIXUP_LIMIT_INT_MIC_BOOST_MUTE_LED,
6016         ALC269VB_FIXUP_ORDISSIMO_EVE2,
6017         ALC283_FIXUP_CHROME_BOOK,
6018         ALC283_FIXUP_SENSE_COMBO_JACK,
6019         ALC282_FIXUP_ASUS_TX300,
6020         ALC283_FIXUP_INT_MIC,
6021         ALC290_FIXUP_MONO_SPEAKERS,
6022         ALC290_FIXUP_MONO_SPEAKERS_HSJACK,
6023         ALC290_FIXUP_SUBWOOFER,
6024         ALC290_FIXUP_SUBWOOFER_HSJACK,
6025         ALC269_FIXUP_THINKPAD_ACPI,
6026         ALC269_FIXUP_DMIC_THINKPAD_ACPI,
6027         ALC255_FIXUP_ACER_MIC_NO_PRESENCE,
6028         ALC255_FIXUP_ASUS_MIC_NO_PRESENCE,
6029         ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
6030         ALC255_FIXUP_DELL2_MIC_NO_PRESENCE,
6031         ALC255_FIXUP_HEADSET_MODE,
6032         ALC255_FIXUP_HEADSET_MODE_NO_HP_MIC,
6033         ALC293_FIXUP_DELL1_MIC_NO_PRESENCE,
6034         ALC292_FIXUP_TPT440_DOCK,
6035         ALC292_FIXUP_TPT440,
6036         ALC283_FIXUP_HEADSET_MIC,
6037         ALC255_FIXUP_MIC_MUTE_LED,
6038         ALC282_FIXUP_ASPIRE_V5_PINS,
6039         ALC280_FIXUP_HP_GPIO4,
6040         ALC286_FIXUP_HP_GPIO_LED,
6041         ALC280_FIXUP_HP_GPIO2_MIC_HOTKEY,
6042         ALC280_FIXUP_HP_DOCK_PINS,
6043         ALC269_FIXUP_HP_DOCK_GPIO_MIC1_LED,
6044         ALC280_FIXUP_HP_9480M,
6045         ALC288_FIXUP_DELL_HEADSET_MODE,
6046         ALC288_FIXUP_DELL1_MIC_NO_PRESENCE,
6047         ALC288_FIXUP_DELL_XPS_13,
6048         ALC288_FIXUP_DISABLE_AAMIX,
6049         ALC292_FIXUP_DELL_E7X_AAMIX,
6050         ALC292_FIXUP_DELL_E7X,
6051         ALC292_FIXUP_DISABLE_AAMIX,
6052         ALC293_FIXUP_DISABLE_AAMIX_MULTIJACK,
6053         ALC298_FIXUP_ALIENWARE_MIC_NO_PRESENCE,
6054         ALC298_FIXUP_DELL1_MIC_NO_PRESENCE,
6055         ALC298_FIXUP_DELL_AIO_MIC_NO_PRESENCE,
6056         ALC275_FIXUP_DELL_XPS,
6057         ALC293_FIXUP_LENOVO_SPK_NOISE,
6058         ALC233_FIXUP_LENOVO_LINE2_MIC_HOTKEY,
6059         ALC255_FIXUP_DELL_SPK_NOISE,
6060         ALC225_FIXUP_DISABLE_MIC_VREF,
6061         ALC225_FIXUP_DELL1_MIC_NO_PRESENCE,
6062         ALC295_FIXUP_DISABLE_DAC3,
6063         ALC285_FIXUP_SPEAKER2_TO_DAC1,
6064         ALC280_FIXUP_HP_HEADSET_MIC,
6065         ALC221_FIXUP_HP_FRONT_MIC,
6066         ALC292_FIXUP_TPT460,
6067         ALC298_FIXUP_SPK_VOLUME,
6068         ALC256_FIXUP_DELL_INSPIRON_7559_SUBWOOFER,
6069         ALC269_FIXUP_ATIV_BOOK_8,
6070         ALC221_FIXUP_HP_MIC_NO_PRESENCE,
6071         ALC256_FIXUP_ASUS_HEADSET_MODE,
6072         ALC256_FIXUP_ASUS_MIC,
6073         ALC256_FIXUP_ASUS_AIO_GPIO2,
6074         ALC233_FIXUP_ASUS_MIC_NO_PRESENCE,
6075         ALC233_FIXUP_EAPD_COEF_AND_MIC_NO_PRESENCE,
6076         ALC233_FIXUP_LENOVO_MULTI_CODECS,
6077         ALC233_FIXUP_ACER_HEADSET_MIC,
6078         ALC294_FIXUP_LENOVO_MIC_LOCATION,
6079         ALC225_FIXUP_DELL_WYSE_MIC_NO_PRESENCE,
6080         ALC225_FIXUP_S3_POP_NOISE,
6081         ALC700_FIXUP_INTEL_REFERENCE,
6082         ALC274_FIXUP_DELL_BIND_DACS,
6083         ALC274_FIXUP_DELL_AIO_LINEOUT_VERB,
6084         ALC298_FIXUP_TPT470_DOCK_FIX,
6085         ALC298_FIXUP_TPT470_DOCK,
6086         ALC255_FIXUP_DUMMY_LINEOUT_VERB,
6087         ALC255_FIXUP_DELL_HEADSET_MIC,
6088         ALC256_FIXUP_HUAWEI_MACH_WX9_PINS,
6089         ALC298_FIXUP_HUAWEI_MBX_STEREO,
6090         ALC295_FIXUP_HP_X360,
6091         ALC221_FIXUP_HP_HEADSET_MIC,
6092         ALC285_FIXUP_LENOVO_HEADPHONE_NOISE,
6093         ALC295_FIXUP_HP_AUTO_MUTE,
6094         ALC286_FIXUP_ACER_AIO_MIC_NO_PRESENCE,
6095         ALC294_FIXUP_ASUS_MIC,
6096         ALC294_FIXUP_ASUS_HEADSET_MIC,
6097         ALC294_FIXUP_ASUS_SPK,
6098         ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE,
6099         ALC285_FIXUP_LENOVO_PC_BEEP_IN_NOISE,
6100         ALC255_FIXUP_ACER_HEADSET_MIC,
6101         ALC295_FIXUP_CHROME_BOOK,
6102         ALC225_FIXUP_HEADSET_JACK,
6103         ALC225_FIXUP_DELL_WYSE_AIO_MIC_NO_PRESENCE,
6104         ALC225_FIXUP_WYSE_AUTO_MUTE,
6105         ALC225_FIXUP_WYSE_DISABLE_MIC_VREF,
6106         ALC286_FIXUP_ACER_AIO_HEADSET_MIC,
6107         ALC256_FIXUP_ASUS_HEADSET_MIC,
6108         ALC256_FIXUP_ASUS_MIC_NO_PRESENCE,
6109         ALC299_FIXUP_PREDATOR_SPK,
6110         ALC256_FIXUP_MEDION_HEADSET_NO_PRESENCE,
6111         ALC289_FIXUP_DELL_SPK2,
6112         ALC289_FIXUP_DUAL_SPK,
6113         ALC294_FIXUP_SPK2_TO_DAC1,
6114         ALC294_FIXUP_ASUS_DUAL_SPK,
6115         ALC285_FIXUP_THINKPAD_HEADSET_JACK,
6116         ALC294_FIXUP_ASUS_HPE,
6117         ALC294_FIXUP_ASUS_COEF_1B,
6118         ALC285_FIXUP_HP_GPIO_LED,
6119         ALC285_FIXUP_HP_MUTE_LED,
6120         ALC236_FIXUP_HP_MUTE_LED,
6121         ALC298_FIXUP_SAMSUNG_HEADPHONE_VERY_QUIET,
6122         ALC295_FIXUP_ASUS_MIC_NO_PRESENCE,
6123 };
6124
6125 static const struct hda_fixup alc269_fixups[] = {
6126         [ALC269_FIXUP_SONY_VAIO] = {
6127                 .type = HDA_FIXUP_PINCTLS,
6128                 .v.pins = (const struct hda_pintbl[]) {
6129                         {0x19, PIN_VREFGRD},
6130                         {}
6131                 }
6132         },
6133         [ALC275_FIXUP_SONY_VAIO_GPIO2] = {
6134                 .type = HDA_FIXUP_FUNC,
6135                 .v.func = alc275_fixup_gpio4_off,
6136                 .chained = true,
6137                 .chain_id = ALC269_FIXUP_SONY_VAIO
6138         },
6139         [ALC269_FIXUP_DELL_M101Z] = {
6140                 .type = HDA_FIXUP_VERBS,
6141                 .v.verbs = (const struct hda_verb[]) {
6142                         /* Enables internal speaker */
6143                         {0x20, AC_VERB_SET_COEF_INDEX, 13},
6144                         {0x20, AC_VERB_SET_PROC_COEF, 0x4040},
6145                         {}
6146                 }
6147         },
6148         [ALC269_FIXUP_SKU_IGNORE] = {
6149                 .type = HDA_FIXUP_FUNC,
6150                 .v.func = alc_fixup_sku_ignore,
6151         },
6152         [ALC269_FIXUP_ASUS_G73JW] = {
6153                 .type = HDA_FIXUP_PINS,
6154                 .v.pins = (const struct hda_pintbl[]) {
6155                         { 0x17, 0x99130111 }, /* subwoofer */
6156                         { }
6157                 }
6158         },
6159         [ALC269_FIXUP_LENOVO_EAPD] = {
6160                 .type = HDA_FIXUP_VERBS,
6161                 .v.verbs = (const struct hda_verb[]) {
6162                         {0x14, AC_VERB_SET_EAPD_BTLENABLE, 0},
6163                         {}
6164                 }
6165         },
6166         [ALC275_FIXUP_SONY_HWEQ] = {
6167                 .type = HDA_FIXUP_FUNC,
6168                 .v.func = alc269_fixup_hweq,
6169                 .chained = true,
6170                 .chain_id = ALC275_FIXUP_SONY_VAIO_GPIO2
6171         },
6172         [ALC275_FIXUP_SONY_DISABLE_AAMIX] = {
6173                 .type = HDA_FIXUP_FUNC,
6174                 .v.func = alc_fixup_disable_aamix,
6175                 .chained = true,
6176                 .chain_id = ALC269_FIXUP_SONY_VAIO
6177         },
6178         [ALC271_FIXUP_DMIC] = {
6179                 .type = HDA_FIXUP_FUNC,
6180                 .v.func = alc271_fixup_dmic,
6181         },
6182         [ALC269_FIXUP_PCM_44K] = {
6183                 .type = HDA_FIXUP_FUNC,
6184                 .v.func = alc269_fixup_pcm_44k,
6185                 .chained = true,
6186                 .chain_id = ALC269_FIXUP_QUANTA_MUTE
6187         },
6188         [ALC269_FIXUP_STEREO_DMIC] = {
6189                 .type = HDA_FIXUP_FUNC,
6190                 .v.func = alc269_fixup_stereo_dmic,
6191         },
6192         [ALC269_FIXUP_HEADSET_MIC] = {
6193                 .type = HDA_FIXUP_FUNC,
6194                 .v.func = alc269_fixup_headset_mic,
6195         },
6196         [ALC269_FIXUP_QUANTA_MUTE] = {
6197                 .type = HDA_FIXUP_FUNC,
6198                 .v.func = alc269_fixup_quanta_mute,
6199         },
6200         [ALC269_FIXUP_LIFEBOOK] = {
6201                 .type = HDA_FIXUP_PINS,
6202                 .v.pins = (const struct hda_pintbl[]) {
6203                         { 0x1a, 0x2101103f }, /* dock line-out */
6204                         { 0x1b, 0x23a11040 }, /* dock mic-in */
6205                         { }
6206                 },
6207                 .chained = true,
6208                 .chain_id = ALC269_FIXUP_QUANTA_MUTE
6209         },
6210         [ALC269_FIXUP_LIFEBOOK_EXTMIC] = {
6211                 .type = HDA_FIXUP_PINS,
6212                 .v.pins = (const struct hda_pintbl[]) {
6213                         { 0x19, 0x01a1903c }, /* headset mic, with jack detect */
6214                         { }
6215                 },
6216         },
6217         [ALC269_FIXUP_LIFEBOOK_HP_PIN] = {
6218                 .type = HDA_FIXUP_PINS,
6219                 .v.pins = (const struct hda_pintbl[]) {
6220                         { 0x21, 0x0221102f }, /* HP out */
6221                         { }
6222                 },
6223         },
6224         [ALC269_FIXUP_LIFEBOOK_NO_HP_TO_LINEOUT] = {
6225                 .type = HDA_FIXUP_FUNC,
6226                 .v.func = alc269_fixup_pincfg_no_hp_to_lineout,
6227         },
6228         [ALC255_FIXUP_LIFEBOOK_U7x7_HEADSET_MIC] = {
6229                 .type = HDA_FIXUP_FUNC,
6230                 .v.func = alc269_fixup_pincfg_U7x7_headset_mic,
6231         },
6232         [ALC269_FIXUP_AMIC] = {
6233                 .type = HDA_FIXUP_PINS,
6234                 .v.pins = (const struct hda_pintbl[]) {
6235                         { 0x14, 0x99130110 }, /* speaker */
6236                         { 0x15, 0x0121401f }, /* HP out */
6237                         { 0x18, 0x01a19c20 }, /* mic */
6238                         { 0x19, 0x99a3092f }, /* int-mic */
6239                         { }
6240                 },
6241         },
6242         [ALC269_FIXUP_DMIC] = {
6243                 .type = HDA_FIXUP_PINS,
6244                 .v.pins = (const struct hda_pintbl[]) {
6245                         { 0x12, 0x99a3092f }, /* int-mic */
6246                         { 0x14, 0x99130110 }, /* speaker */
6247                         { 0x15, 0x0121401f }, /* HP out */
6248                         { 0x18, 0x01a19c20 }, /* mic */
6249                         { }
6250                 },
6251         },
6252         [ALC269VB_FIXUP_AMIC] = {
6253                 .type = HDA_FIXUP_PINS,
6254                 .v.pins = (const struct hda_pintbl[]) {
6255                         { 0x14, 0x99130110 }, /* speaker */
6256                         { 0x18, 0x01a19c20 }, /* mic */
6257                         { 0x19, 0x99a3092f }, /* int-mic */
6258                         { 0x21, 0x0121401f }, /* HP out */
6259                         { }
6260                 },
6261         },
6262         [ALC269VB_FIXUP_DMIC] = {
6263                 .type = HDA_FIXUP_PINS,
6264                 .v.pins = (const struct hda_pintbl[]) {
6265                         { 0x12, 0x99a3092f }, /* int-mic */
6266                         { 0x14, 0x99130110 }, /* speaker */
6267                         { 0x18, 0x01a19c20 }, /* mic */
6268                         { 0x21, 0x0121401f }, /* HP out */
6269                         { }
6270                 },
6271         },
6272         [ALC269_FIXUP_HP_MUTE_LED] = {
6273                 .type = HDA_FIXUP_FUNC,
6274                 .v.func = alc269_fixup_hp_mute_led,
6275         },
6276         [ALC269_FIXUP_HP_MUTE_LED_MIC1] = {
6277                 .type = HDA_FIXUP_FUNC,
6278                 .v.func = alc269_fixup_hp_mute_led_mic1,
6279         },
6280         [ALC269_FIXUP_HP_MUTE_LED_MIC2] = {
6281                 .type = HDA_FIXUP_FUNC,
6282                 .v.func = alc269_fixup_hp_mute_led_mic2,
6283         },
6284         [ALC269_FIXUP_HP_MUTE_LED_MIC3] = {
6285                 .type = HDA_FIXUP_FUNC,
6286                 .v.func = alc269_fixup_hp_mute_led_mic3,
6287                 .chained = true,
6288                 .chain_id = ALC295_FIXUP_HP_AUTO_MUTE
6289         },
6290         [ALC269_FIXUP_HP_GPIO_LED] = {
6291                 .type = HDA_FIXUP_FUNC,
6292                 .v.func = alc269_fixup_hp_gpio_led,
6293         },
6294         [ALC269_FIXUP_HP_GPIO_MIC1_LED] = {
6295                 .type = HDA_FIXUP_FUNC,
6296                 .v.func = alc269_fixup_hp_gpio_mic1_led,
6297         },
6298         [ALC269_FIXUP_HP_LINE1_MIC1_LED] = {
6299                 .type = HDA_FIXUP_FUNC,
6300                 .v.func = alc269_fixup_hp_line1_mic1_led,
6301         },
6302         [ALC269_FIXUP_INV_DMIC] = {
6303                 .type = HDA_FIXUP_FUNC,
6304                 .v.func = alc_fixup_inv_dmic,
6305         },
6306         [ALC269_FIXUP_NO_SHUTUP] = {
6307                 .type = HDA_FIXUP_FUNC,
6308                 .v.func = alc_fixup_no_shutup,
6309         },
6310         [ALC269_FIXUP_LENOVO_DOCK] = {
6311                 .type = HDA_FIXUP_PINS,
6312                 .v.pins = (const struct hda_pintbl[]) {
6313                         { 0x19, 0x23a11040 }, /* dock mic */
6314                         { 0x1b, 0x2121103f }, /* dock headphone */
6315                         { }
6316                 },
6317                 .chained = true,
6318                 .chain_id = ALC269_FIXUP_PINCFG_NO_HP_TO_LINEOUT
6319         },
6320         [ALC269_FIXUP_LENOVO_DOCK_LIMIT_BOOST] = {
6321                 .type = HDA_FIXUP_FUNC,
6322                 .v.func = alc269_fixup_limit_int_mic_boost,
6323                 .chained = true,
6324                 .chain_id = ALC269_FIXUP_LENOVO_DOCK,
6325         },
6326         [ALC269_FIXUP_PINCFG_NO_HP_TO_LINEOUT] = {
6327                 .type = HDA_FIXUP_FUNC,
6328                 .v.func = alc269_fixup_pincfg_no_hp_to_lineout,
6329                 .chained = true,
6330                 .chain_id = ALC269_FIXUP_THINKPAD_ACPI,
6331         },
6332         [ALC269_FIXUP_DELL1_MIC_NO_PRESENCE] = {
6333                 .type = HDA_FIXUP_PINS,
6334                 .v.pins = (const struct hda_pintbl[]) {
6335                         { 0x19, 0x01a1913c }, /* use as headset mic, without its own jack detect */
6336                         { 0x1a, 0x01a1913d }, /* use as headphone mic, without its own jack detect */
6337                         { }
6338                 },
6339                 .chained = true,
6340                 .chain_id = ALC269_FIXUP_HEADSET_MODE
6341         },
6342         [ALC269_FIXUP_DELL2_MIC_NO_PRESENCE] = {
6343                 .type = HDA_FIXUP_PINS,
6344                 .v.pins = (const struct hda_pintbl[]) {
6345                         { 0x16, 0x21014020 }, /* dock line out */
6346                         { 0x19, 0x21a19030 }, /* dock mic */
6347                         { 0x1a, 0x01a1913c }, /* use as headset mic, without its own jack detect */
6348                         { }
6349                 },
6350                 .chained = true,
6351                 .chain_id = ALC269_FIXUP_HEADSET_MODE_NO_HP_MIC
6352         },
6353         [ALC269_FIXUP_DELL3_MIC_NO_PRESENCE] = {
6354                 .type = HDA_FIXUP_PINS,
6355                 .v.pins = (const struct hda_pintbl[]) {
6356                         { 0x1a, 0x01a1913c }, /* use as headset mic, without its own jack detect */
6357                         { }
6358                 },
6359                 .chained = true,
6360                 .chain_id = ALC269_FIXUP_HEADSET_MODE_NO_HP_MIC
6361         },
6362         [ALC269_FIXUP_DELL4_MIC_NO_PRESENCE] = {
6363                 .type = HDA_FIXUP_PINS,
6364                 .v.pins = (const struct hda_pintbl[]) {
6365                         { 0x19, 0x01a1913c }, /* use as headset mic, without its own jack detect */
6366                         { 0x1b, 0x01a1913d }, /* use as headphone mic, without its own jack detect */
6367                         { }
6368                 },
6369                 .chained = true,
6370                 .chain_id = ALC269_FIXUP_HEADSET_MODE
6371         },
6372         [ALC269_FIXUP_HEADSET_MODE] = {
6373                 .type = HDA_FIXUP_FUNC,
6374                 .v.func = alc_fixup_headset_mode,
6375                 .chained = true,
6376                 .chain_id = ALC255_FIXUP_MIC_MUTE_LED
6377         },
6378         [ALC269_FIXUP_HEADSET_MODE_NO_HP_MIC] = {
6379                 .type = HDA_FIXUP_FUNC,
6380                 .v.func = alc_fixup_headset_mode_no_hp_mic,
6381         },
6382         [ALC269_FIXUP_ASPIRE_HEADSET_MIC] = {
6383                 .type = HDA_FIXUP_PINS,
6384                 .v.pins = (const struct hda_pintbl[]) {
6385                         { 0x19, 0x01a1913c }, /* headset mic w/o jack detect */
6386                         { }
6387                 },
6388                 .chained = true,
6389                 .chain_id = ALC269_FIXUP_HEADSET_MODE,
6390         },
6391         [ALC286_FIXUP_SONY_MIC_NO_PRESENCE] = {
6392                 .type = HDA_FIXUP_PINS,
6393                 .v.pins = (const struct hda_pintbl[]) {
6394                         { 0x18, 0x01a1913c }, /* use as headset mic, without its own jack detect */
6395                         { }
6396                 },
6397                 .chained = true,
6398                 .chain_id = ALC269_FIXUP_HEADSET_MIC
6399         },
6400         [ALC256_FIXUP_HUAWEI_MACH_WX9_PINS] = {
6401                 .type = HDA_FIXUP_PINS,
6402                 .v.pins = (const struct hda_pintbl[]) {
6403                         {0x12, 0x90a60130},
6404                         {0x13, 0x40000000},
6405                         {0x14, 0x90170110},
6406                         {0x18, 0x411111f0},
6407                         {0x19, 0x04a11040},
6408                         {0x1a, 0x411111f0},
6409                         {0x1b, 0x90170112},
6410                         {0x1d, 0x40759a05},
6411                         {0x1e, 0x411111f0},
6412                         {0x21, 0x04211020},
6413                         { }
6414                 },
6415                 .chained = true,
6416                 .chain_id = ALC255_FIXUP_MIC_MUTE_LED
6417         },
6418         [ALC298_FIXUP_HUAWEI_MBX_STEREO] = {
6419                 .type = HDA_FIXUP_FUNC,
6420                 .v.func = alc298_fixup_huawei_mbx_stereo,
6421                 .chained = true,
6422                 .chain_id = ALC255_FIXUP_MIC_MUTE_LED
6423         },
6424         [ALC269_FIXUP_ASUS_X101_FUNC] = {
6425                 .type = HDA_FIXUP_FUNC,
6426                 .v.func = alc269_fixup_x101_headset_mic,
6427         },
6428         [ALC269_FIXUP_ASUS_X101_VERB] = {
6429                 .type = HDA_FIXUP_VERBS,
6430                 .v.verbs = (const struct hda_verb[]) {
6431                         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
6432                         {0x20, AC_VERB_SET_COEF_INDEX, 0x08},
6433                         {0x20, AC_VERB_SET_PROC_COEF,  0x0310},
6434                         { }
6435                 },
6436                 .chained = true,
6437                 .chain_id = ALC269_FIXUP_ASUS_X101_FUNC
6438         },
6439         [ALC269_FIXUP_ASUS_X101] = {
6440                 .type = HDA_FIXUP_PINS,
6441                 .v.pins = (const struct hda_pintbl[]) {
6442                         { 0x18, 0x04a1182c }, /* Headset mic */
6443                         { }
6444                 },
6445                 .chained = true,
6446                 .chain_id = ALC269_FIXUP_ASUS_X101_VERB
6447         },
6448         [ALC271_FIXUP_AMIC_MIC2] = {
6449                 .type = HDA_FIXUP_PINS,
6450                 .v.pins = (const struct hda_pintbl[]) {
6451                         { 0x14, 0x99130110 }, /* speaker */
6452                         { 0x19, 0x01a19c20 }, /* mic */
6453                         { 0x1b, 0x99a7012f }, /* int-mic */
6454                         { 0x21, 0x0121401f }, /* HP out */
6455                         { }
6456                 },
6457         },
6458         [ALC271_FIXUP_HP_GATE_MIC_JACK] = {
6459                 .type = HDA_FIXUP_FUNC,
6460                 .v.func = alc271_hp_gate_mic_jack,
6461                 .chained = true,
6462                 .chain_id = ALC271_FIXUP_AMIC_MIC2,
6463         },
6464         [ALC271_FIXUP_HP_GATE_MIC_JACK_E1_572] = {
6465                 .type = HDA_FIXUP_FUNC,
6466                 .v.func = alc269_fixup_limit_int_mic_boost,
6467                 .chained = true,
6468                 .chain_id = ALC271_FIXUP_HP_GATE_MIC_JACK,
6469         },
6470         [ALC269_FIXUP_ACER_AC700] = {
6471                 .type = HDA_FIXUP_PINS,
6472                 .v.pins = (const struct hda_pintbl[]) {
6473                         { 0x12, 0x99a3092f }, /* int-mic */
6474                         { 0x14, 0x99130110 }, /* speaker */
6475                         { 0x18, 0x03a11c20 }, /* mic */
6476                         { 0x1e, 0x0346101e }, /* SPDIF1 */
6477                         { 0x21, 0x0321101f }, /* HP out */
6478                         { }
6479                 },
6480                 .chained = true,
6481                 .chain_id = ALC271_FIXUP_DMIC,
6482         },
6483         [ALC269_FIXUP_LIMIT_INT_MIC_BOOST] = {
6484                 .type = HDA_FIXUP_FUNC,
6485                 .v.func = alc269_fixup_limit_int_mic_boost,
6486                 .chained = true,
6487                 .chain_id = ALC269_FIXUP_THINKPAD_ACPI,
6488         },
6489         [ALC269VB_FIXUP_ASUS_ZENBOOK] = {
6490                 .type = HDA_FIXUP_FUNC,
6491                 .v.func = alc269_fixup_limit_int_mic_boost,
6492                 .chained = true,
6493                 .chain_id = ALC269VB_FIXUP_DMIC,
6494         },
6495         [ALC269VB_FIXUP_ASUS_ZENBOOK_UX31A] = {
6496                 .type = HDA_FIXUP_VERBS,
6497                 .v.verbs = (const struct hda_verb[]) {
6498                         /* class-D output amp +5dB */
6499                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x12 },
6500                         { 0x20, AC_VERB_SET_PROC_COEF, 0x2800 },
6501                         {}
6502                 },
6503                 .chained = true,
6504                 .chain_id = ALC269VB_FIXUP_ASUS_ZENBOOK,
6505         },
6506         [ALC269_FIXUP_LIMIT_INT_MIC_BOOST_MUTE_LED] = {
6507                 .type = HDA_FIXUP_FUNC,
6508                 .v.func = alc269_fixup_limit_int_mic_boost,
6509                 .chained = true,
6510                 .chain_id = ALC269_FIXUP_HP_MUTE_LED_MIC1,
6511         },
6512         [ALC269VB_FIXUP_ORDISSIMO_EVE2] = {
6513                 .type = HDA_FIXUP_PINS,
6514                 .v.pins = (const struct hda_pintbl[]) {
6515                         { 0x12, 0x99a3092f }, /* int-mic */
6516                         { 0x18, 0x03a11d20 }, /* mic */
6517                         { 0x19, 0x411111f0 }, /* Unused bogus pin */
6518                         { }
6519                 },
6520         },
6521         [ALC283_FIXUP_CHROME_BOOK] = {
6522                 .type = HDA_FIXUP_FUNC,
6523                 .v.func = alc283_fixup_chromebook,
6524         },
6525         [ALC283_FIXUP_SENSE_COMBO_JACK] = {
6526                 .type = HDA_FIXUP_FUNC,
6527                 .v.func = alc283_fixup_sense_combo_jack,
6528                 .chained = true,
6529                 .chain_id = ALC283_FIXUP_CHROME_BOOK,
6530         },
6531         [ALC282_FIXUP_ASUS_TX300] = {
6532                 .type = HDA_FIXUP_FUNC,
6533                 .v.func = alc282_fixup_asus_tx300,
6534         },
6535         [ALC283_FIXUP_INT_MIC] = {
6536                 .type = HDA_FIXUP_VERBS,
6537                 .v.verbs = (const struct hda_verb[]) {
6538                         {0x20, AC_VERB_SET_COEF_INDEX, 0x1a},
6539                         {0x20, AC_VERB_SET_PROC_COEF, 0x0011},
6540                         { }
6541                 },
6542                 .chained = true,
6543                 .chain_id = ALC269_FIXUP_LIMIT_INT_MIC_BOOST
6544         },
6545         [ALC290_FIXUP_SUBWOOFER_HSJACK] = {
6546                 .type = HDA_FIXUP_PINS,
6547                 .v.pins = (const struct hda_pintbl[]) {
6548                         { 0x17, 0x90170112 }, /* subwoofer */
6549                         { }
6550                 },
6551                 .chained = true,
6552                 .chain_id = ALC290_FIXUP_MONO_SPEAKERS_HSJACK,
6553         },
6554         [ALC290_FIXUP_SUBWOOFER] = {
6555                 .type = HDA_FIXUP_PINS,
6556                 .v.pins = (const struct hda_pintbl[]) {
6557                         { 0x17, 0x90170112 }, /* subwoofer */
6558                         { }
6559                 },
6560                 .chained = true,
6561                 .chain_id = ALC290_FIXUP_MONO_SPEAKERS,
6562         },
6563         [ALC290_FIXUP_MONO_SPEAKERS] = {
6564                 .type = HDA_FIXUP_FUNC,
6565                 .v.func = alc290_fixup_mono_speakers,
6566         },
6567         [ALC290_FIXUP_MONO_SPEAKERS_HSJACK] = {
6568                 .type = HDA_FIXUP_FUNC,
6569                 .v.func = alc290_fixup_mono_speakers,
6570                 .chained = true,
6571                 .chain_id = ALC269_FIXUP_DELL3_MIC_NO_PRESENCE,
6572         },
6573         [ALC269_FIXUP_THINKPAD_ACPI] = {
6574                 .type = HDA_FIXUP_FUNC,
6575                 .v.func = alc_fixup_thinkpad_acpi,
6576                 .chained = true,
6577                 .chain_id = ALC269_FIXUP_SKU_IGNORE,
6578         },
6579         [ALC269_FIXUP_DMIC_THINKPAD_ACPI] = {
6580                 .type = HDA_FIXUP_FUNC,
6581                 .v.func = alc_fixup_inv_dmic,
6582                 .chained = true,
6583                 .chain_id = ALC269_FIXUP_THINKPAD_ACPI,
6584         },
6585         [ALC255_FIXUP_ACER_MIC_NO_PRESENCE] = {
6586                 .type = HDA_FIXUP_PINS,
6587                 .v.pins = (const struct hda_pintbl[]) {
6588                         { 0x19, 0x01a1913c }, /* use as headset mic, without its own jack detect */
6589                         { }
6590                 },
6591                 .chained = true,
6592                 .chain_id = ALC255_FIXUP_HEADSET_MODE
6593         },
6594         [ALC255_FIXUP_ASUS_MIC_NO_PRESENCE] = {
6595                 .type = HDA_FIXUP_PINS,
6596                 .v.pins = (const struct hda_pintbl[]) {
6597                         { 0x19, 0x01a1913c }, /* use as headset mic, without its own jack detect */
6598                         { }
6599                 },
6600                 .chained = true,
6601                 .chain_id = ALC255_FIXUP_HEADSET_MODE
6602         },
6603         [ALC255_FIXUP_DELL1_MIC_NO_PRESENCE] = {
6604                 .type = HDA_FIXUP_PINS,
6605                 .v.pins = (const struct hda_pintbl[]) {
6606                         { 0x19, 0x01a1913c }, /* use as headset mic, without its own jack detect */
6607                         { 0x1a, 0x01a1913d }, /* use as headphone mic, without its own jack detect */
6608                         { }
6609                 },
6610                 .chained = true,
6611                 .chain_id = ALC255_FIXUP_HEADSET_MODE
6612         },
6613         [ALC255_FIXUP_DELL2_MIC_NO_PRESENCE] = {
6614                 .type = HDA_FIXUP_PINS,
6615                 .v.pins = (const struct hda_pintbl[]) {
6616                         { 0x19, 0x01a1913c }, /* use as headset mic, without its own jack detect */
6617                         { }
6618                 },
6619                 .chained = true,
6620                 .chain_id = ALC255_FIXUP_HEADSET_MODE_NO_HP_MIC
6621         },
6622         [ALC255_FIXUP_HEADSET_MODE] = {
6623                 .type = HDA_FIXUP_FUNC,
6624                 .v.func = alc_fixup_headset_mode_alc255,
6625                 .chained = true,
6626                 .chain_id = ALC255_FIXUP_MIC_MUTE_LED
6627         },
6628         [ALC255_FIXUP_HEADSET_MODE_NO_HP_MIC] = {
6629                 .type = HDA_FIXUP_FUNC,
6630                 .v.func = alc_fixup_headset_mode_alc255_no_hp_mic,
6631         },
6632         [ALC293_FIXUP_DELL1_MIC_NO_PRESENCE] = {
6633                 .type = HDA_FIXUP_PINS,
6634                 .v.pins = (const struct hda_pintbl[]) {
6635                         { 0x18, 0x01a1913d }, /* use as headphone mic, without its own jack detect */
6636                         { 0x1a, 0x01a1913c }, /* use as headset mic, without its own jack detect */
6637                         { }
6638                 },
6639                 .chained = true,
6640                 .chain_id = ALC269_FIXUP_HEADSET_MODE
6641         },
6642         [ALC292_FIXUP_TPT440_DOCK] = {
6643                 .type = HDA_FIXUP_FUNC,
6644                 .v.func = alc_fixup_tpt440_dock,
6645                 .chained = true,
6646                 .chain_id = ALC269_FIXUP_LIMIT_INT_MIC_BOOST
6647         },
6648         [ALC292_FIXUP_TPT440] = {
6649                 .type = HDA_FIXUP_FUNC,
6650                 .v.func = alc_fixup_disable_aamix,
6651                 .chained = true,
6652                 .chain_id = ALC292_FIXUP_TPT440_DOCK,
6653         },
6654         [ALC283_FIXUP_HEADSET_MIC] = {
6655                 .type = HDA_FIXUP_PINS,
6656                 .v.pins = (const struct hda_pintbl[]) {
6657                         { 0x19, 0x04a110f0 },
6658                         { },
6659                 },
6660         },
6661         [ALC255_FIXUP_MIC_MUTE_LED] = {
6662                 .type = HDA_FIXUP_FUNC,
6663                 .v.func = snd_hda_gen_fixup_micmute_led,
6664         },
6665         [ALC282_FIXUP_ASPIRE_V5_PINS] = {
6666                 .type = HDA_FIXUP_PINS,
6667                 .v.pins = (const struct hda_pintbl[]) {
6668                         { 0x12, 0x90a60130 },
6669                         { 0x14, 0x90170110 },
6670                         { 0x17, 0x40000008 },
6671                         { 0x18, 0x411111f0 },
6672                         { 0x19, 0x01a1913c },
6673                         { 0x1a, 0x411111f0 },
6674                         { 0x1b, 0x411111f0 },
6675                         { 0x1d, 0x40f89b2d },
6676                         { 0x1e, 0x411111f0 },
6677                         { 0x21, 0x0321101f },
6678                         { },
6679                 },
6680         },
6681         [ALC280_FIXUP_HP_GPIO4] = {
6682                 .type = HDA_FIXUP_FUNC,
6683                 .v.func = alc280_fixup_hp_gpio4,
6684         },
6685         [ALC286_FIXUP_HP_GPIO_LED] = {
6686                 .type = HDA_FIXUP_FUNC,
6687                 .v.func = alc286_fixup_hp_gpio_led,
6688         },
6689         [ALC280_FIXUP_HP_GPIO2_MIC_HOTKEY] = {
6690                 .type = HDA_FIXUP_FUNC,
6691                 .v.func = alc280_fixup_hp_gpio2_mic_hotkey,
6692         },
6693         [ALC280_FIXUP_HP_DOCK_PINS] = {
6694                 .type = HDA_FIXUP_PINS,
6695                 .v.pins = (const struct hda_pintbl[]) {
6696                         { 0x1b, 0x21011020 }, /* line-out */
6697                         { 0x1a, 0x01a1903c }, /* headset mic */
6698                         { 0x18, 0x2181103f }, /* line-in */
6699                         { },
6700                 },
6701                 .chained = true,
6702                 .chain_id = ALC280_FIXUP_HP_GPIO4
6703         },
6704         [ALC269_FIXUP_HP_DOCK_GPIO_MIC1_LED] = {
6705                 .type = HDA_FIXUP_PINS,
6706                 .v.pins = (const struct hda_pintbl[]) {
6707                         { 0x1b, 0x21011020 }, /* line-out */
6708                         { 0x18, 0x2181103f }, /* line-in */
6709                         { },
6710                 },
6711                 .chained = true,
6712                 .chain_id = ALC269_FIXUP_HP_GPIO_MIC1_LED
6713         },
6714         [ALC280_FIXUP_HP_9480M] = {
6715                 .type = HDA_FIXUP_FUNC,
6716                 .v.func = alc280_fixup_hp_9480m,
6717         },
6718         [ALC288_FIXUP_DELL_HEADSET_MODE] = {
6719                 .type = HDA_FIXUP_FUNC,
6720                 .v.func = alc_fixup_headset_mode_dell_alc288,
6721                 .chained = true,
6722                 .chain_id = ALC255_FIXUP_MIC_MUTE_LED
6723         },
6724         [ALC288_FIXUP_DELL1_MIC_NO_PRESENCE] = {
6725                 .type = HDA_FIXUP_PINS,
6726                 .v.pins = (const struct hda_pintbl[]) {
6727                         { 0x18, 0x01a1913c }, /* use as headset mic, without its own jack detect */
6728                         { 0x1a, 0x01a1913d }, /* use as headphone mic, without its own jack detect */
6729                         { }
6730                 },
6731                 .chained = true,
6732                 .chain_id = ALC288_FIXUP_DELL_HEADSET_MODE
6733         },
6734         [ALC288_FIXUP_DISABLE_AAMIX] = {
6735                 .type = HDA_FIXUP_FUNC,
6736                 .v.func = alc_fixup_disable_aamix,
6737                 .chained = true,
6738                 .chain_id = ALC288_FIXUP_DELL1_MIC_NO_PRESENCE
6739         },
6740         [ALC288_FIXUP_DELL_XPS_13] = {
6741                 .type = HDA_FIXUP_FUNC,
6742                 .v.func = alc_fixup_dell_xps13,
6743                 .chained = true,
6744                 .chain_id = ALC288_FIXUP_DISABLE_AAMIX
6745         },
6746         [ALC292_FIXUP_DISABLE_AAMIX] = {
6747                 .type = HDA_FIXUP_FUNC,
6748                 .v.func = alc_fixup_disable_aamix,
6749                 .chained = true,
6750                 .chain_id = ALC269_FIXUP_DELL2_MIC_NO_PRESENCE
6751         },
6752         [ALC293_FIXUP_DISABLE_AAMIX_MULTIJACK] = {
6753                 .type = HDA_FIXUP_FUNC,
6754                 .v.func = alc_fixup_disable_aamix,
6755                 .chained = true,
6756                 .chain_id = ALC293_FIXUP_DELL1_MIC_NO_PRESENCE
6757         },
6758         [ALC292_FIXUP_DELL_E7X_AAMIX] = {
6759                 .type = HDA_FIXUP_FUNC,
6760                 .v.func = alc_fixup_dell_xps13,
6761                 .chained = true,
6762                 .chain_id = ALC292_FIXUP_DISABLE_AAMIX
6763         },
6764         [ALC292_FIXUP_DELL_E7X] = {
6765                 .type = HDA_FIXUP_FUNC,
6766                 .v.func = snd_hda_gen_fixup_micmute_led,
6767                 /* micmute fixup must be applied at last */
6768                 .chained_before = true,
6769                 .chain_id = ALC292_FIXUP_DELL_E7X_AAMIX,
6770         },
6771         [ALC298_FIXUP_ALIENWARE_MIC_NO_PRESENCE] = {
6772                 .type = HDA_FIXUP_PINS,
6773                 .v.pins = (const struct hda_pintbl[]) {
6774                         { 0x18, 0x01a1913c }, /* headset mic w/o jack detect */
6775                         { }
6776                 },
6777                 .chained_before = true,
6778                 .chain_id = ALC269_FIXUP_HEADSET_MODE,
6779         },
6780         [ALC298_FIXUP_DELL1_MIC_NO_PRESENCE] = {
6781                 .type = HDA_FIXUP_PINS,
6782                 .v.pins = (const struct hda_pintbl[]) {
6783                         { 0x18, 0x01a1913c }, /* use as headset mic, without its own jack detect */
6784                         { 0x1a, 0x01a1913d }, /* use as headphone mic, without its own jack detect */
6785                         { }
6786                 },
6787                 .chained = true,
6788                 .chain_id = ALC269_FIXUP_HEADSET_MODE
6789         },
6790         [ALC298_FIXUP_DELL_AIO_MIC_NO_PRESENCE] = {
6791                 .type = HDA_FIXUP_PINS,
6792                 .v.pins = (const struct hda_pintbl[]) {
6793                         { 0x18, 0x01a1913c }, /* use as headset mic, without its own jack detect */
6794                         { }
6795                 },
6796                 .chained = true,
6797                 .chain_id = ALC269_FIXUP_HEADSET_MODE
6798         },
6799         [ALC275_FIXUP_DELL_XPS] = {
6800                 .type = HDA_FIXUP_VERBS,
6801                 .v.verbs = (const struct hda_verb[]) {
6802                         /* Enables internal speaker */
6803                         {0x20, AC_VERB_SET_COEF_INDEX, 0x1f},
6804                         {0x20, AC_VERB_SET_PROC_COEF, 0x00c0},
6805                         {0x20, AC_VERB_SET_COEF_INDEX, 0x30},
6806                         {0x20, AC_VERB_SET_PROC_COEF, 0x00b1},
6807                         {}
6808                 }
6809         },
6810         [ALC293_FIXUP_LENOVO_SPK_NOISE] = {
6811                 .type = HDA_FIXUP_FUNC,
6812                 .v.func = alc_fixup_disable_aamix,
6813                 .chained = true,
6814                 .chain_id = ALC269_FIXUP_THINKPAD_ACPI
6815         },
6816         [ALC233_FIXUP_LENOVO_LINE2_MIC_HOTKEY] = {
6817                 .type = HDA_FIXUP_FUNC,
6818                 .v.func = alc233_fixup_lenovo_line2_mic_hotkey,
6819         },
6820         [ALC255_FIXUP_DELL_SPK_NOISE] = {
6821                 .type = HDA_FIXUP_FUNC,
6822                 .v.func = alc_fixup_disable_aamix,
6823                 .chained = true,
6824                 .chain_id = ALC255_FIXUP_DELL1_MIC_NO_PRESENCE
6825         },
6826         [ALC225_FIXUP_DISABLE_MIC_VREF] = {
6827                 .type = HDA_FIXUP_FUNC,
6828                 .v.func = alc_fixup_disable_mic_vref,
6829                 .chained = true,
6830                 .chain_id = ALC269_FIXUP_DELL1_MIC_NO_PRESENCE
6831         },
6832         [ALC225_FIXUP_DELL1_MIC_NO_PRESENCE] = {
6833                 .type = HDA_FIXUP_VERBS,
6834                 .v.verbs = (const struct hda_verb[]) {
6835                         /* Disable pass-through path for FRONT 14h */
6836                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x36 },
6837                         { 0x20, AC_VERB_SET_PROC_COEF, 0x57d7 },
6838                         {}
6839                 },
6840                 .chained = true,
6841                 .chain_id = ALC225_FIXUP_DISABLE_MIC_VREF
6842         },
6843         [ALC280_FIXUP_HP_HEADSET_MIC] = {
6844                 .type = HDA_FIXUP_FUNC,
6845                 .v.func = alc_fixup_disable_aamix,
6846                 .chained = true,
6847                 .chain_id = ALC269_FIXUP_HEADSET_MIC,
6848         },
6849         [ALC221_FIXUP_HP_FRONT_MIC] = {
6850                 .type = HDA_FIXUP_PINS,
6851                 .v.pins = (const struct hda_pintbl[]) {
6852                         { 0x19, 0x02a19020 }, /* Front Mic */
6853                         { }
6854                 },
6855         },
6856         [ALC292_FIXUP_TPT460] = {
6857                 .type = HDA_FIXUP_FUNC,
6858                 .v.func = alc_fixup_tpt440_dock,
6859                 .chained = true,
6860                 .chain_id = ALC293_FIXUP_LENOVO_SPK_NOISE,
6861         },
6862         [ALC298_FIXUP_SPK_VOLUME] = {
6863                 .type = HDA_FIXUP_FUNC,
6864                 .v.func = alc298_fixup_speaker_volume,
6865                 .chained = true,
6866                 .chain_id = ALC298_FIXUP_DELL_AIO_MIC_NO_PRESENCE,
6867         },
6868         [ALC295_FIXUP_DISABLE_DAC3] = {
6869                 .type = HDA_FIXUP_FUNC,
6870                 .v.func = alc295_fixup_disable_dac3,
6871         },
6872         [ALC285_FIXUP_SPEAKER2_TO_DAC1] = {
6873                 .type = HDA_FIXUP_FUNC,
6874                 .v.func = alc285_fixup_speaker2_to_dac1,
6875                 .chained = true,
6876                 .chain_id = ALC269_FIXUP_THINKPAD_ACPI
6877         },
6878         [ALC256_FIXUP_DELL_INSPIRON_7559_SUBWOOFER] = {
6879                 .type = HDA_FIXUP_PINS,
6880                 .v.pins = (const struct hda_pintbl[]) {
6881                         { 0x1b, 0x90170151 },
6882                         { }
6883                 },
6884                 .chained = true,
6885                 .chain_id = ALC255_FIXUP_DELL1_MIC_NO_PRESENCE
6886         },
6887         [ALC269_FIXUP_ATIV_BOOK_8] = {
6888                 .type = HDA_FIXUP_FUNC,
6889                 .v.func = alc_fixup_auto_mute_via_amp,
6890                 .chained = true,
6891                 .chain_id = ALC269_FIXUP_NO_SHUTUP
6892         },
6893         [ALC221_FIXUP_HP_MIC_NO_PRESENCE] = {
6894                 .type = HDA_FIXUP_PINS,
6895                 .v.pins = (const struct hda_pintbl[]) {
6896                         { 0x18, 0x01a1913c }, /* use as headset mic, without its own jack detect */
6897                         { 0x1a, 0x01a1913d }, /* use as headphone mic, without its own jack detect */
6898                         { }
6899                 },
6900                 .chained = true,
6901                 .chain_id = ALC269_FIXUP_HEADSET_MODE
6902         },
6903         [ALC256_FIXUP_ASUS_HEADSET_MODE] = {
6904                 .type = HDA_FIXUP_FUNC,
6905                 .v.func = alc_fixup_headset_mode,
6906         },
6907         [ALC256_FIXUP_ASUS_MIC] = {
6908                 .type = HDA_FIXUP_PINS,
6909                 .v.pins = (const struct hda_pintbl[]) {
6910                         { 0x13, 0x90a60160 }, /* use as internal mic */
6911                         { 0x19, 0x04a11120 }, /* use as headset mic, without its own jack detect */
6912                         { }
6913                 },
6914                 .chained = true,
6915                 .chain_id = ALC256_FIXUP_ASUS_HEADSET_MODE
6916         },
6917         [ALC256_FIXUP_ASUS_AIO_GPIO2] = {
6918                 .type = HDA_FIXUP_FUNC,
6919                 /* Set up GPIO2 for the speaker amp */
6920                 .v.func = alc_fixup_gpio4,
6921         },
6922         [ALC233_FIXUP_ASUS_MIC_NO_PRESENCE] = {
6923                 .type = HDA_FIXUP_PINS,
6924                 .v.pins = (const struct hda_pintbl[]) {
6925                         { 0x19, 0x01a1913c }, /* use as headset mic, without its own jack detect */
6926                         { }
6927                 },
6928                 .chained = true,
6929                 .chain_id = ALC269_FIXUP_HEADSET_MIC
6930         },
6931         [ALC233_FIXUP_EAPD_COEF_AND_MIC_NO_PRESENCE] = {
6932                 .type = HDA_FIXUP_VERBS,
6933                 .v.verbs = (const struct hda_verb[]) {
6934                         /* Enables internal speaker */
6935                         {0x20, AC_VERB_SET_COEF_INDEX, 0x40},
6936                         {0x20, AC_VERB_SET_PROC_COEF, 0x8800},
6937                         {}
6938                 },
6939                 .chained = true,
6940                 .chain_id = ALC233_FIXUP_ASUS_MIC_NO_PRESENCE
6941         },
6942         [ALC233_FIXUP_LENOVO_MULTI_CODECS] = {
6943                 .type = HDA_FIXUP_FUNC,
6944                 .v.func = alc233_alc662_fixup_lenovo_dual_codecs,
6945         },
6946         [ALC233_FIXUP_ACER_HEADSET_MIC] = {
6947                 .type = HDA_FIXUP_VERBS,
6948                 .v.verbs = (const struct hda_verb[]) {
6949                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x45 },
6950                         { 0x20, AC_VERB_SET_PROC_COEF, 0x5089 },
6951                         { }
6952                 },
6953                 .chained = true,
6954                 .chain_id = ALC233_FIXUP_ASUS_MIC_NO_PRESENCE
6955         },
6956         [ALC294_FIXUP_LENOVO_MIC_LOCATION] = {
6957                 .type = HDA_FIXUP_PINS,
6958                 .v.pins = (const struct hda_pintbl[]) {
6959                         /* Change the mic location from front to right, otherwise there are
6960                            two front mics with the same name, pulseaudio can't handle them.
6961                            This is just a temporary workaround, after applying this fixup,
6962                            there will be one "Front Mic" and one "Mic" in this machine.
6963                          */
6964                         { 0x1a, 0x04a19040 },
6965                         { }
6966                 },
6967         },
6968         [ALC225_FIXUP_DELL_WYSE_MIC_NO_PRESENCE] = {
6969                 .type = HDA_FIXUP_PINS,
6970                 .v.pins = (const struct hda_pintbl[]) {
6971                         { 0x16, 0x0101102f }, /* Rear Headset HP */
6972                         { 0x19, 0x02a1913c }, /* use as Front headset mic, without its own jack detect */
6973                         { 0x1a, 0x01a19030 }, /* Rear Headset MIC */
6974                         { 0x1b, 0x02011020 },
6975                         { }
6976                 },
6977                 .chained = true,
6978                 .chain_id = ALC225_FIXUP_S3_POP_NOISE
6979         },
6980         [ALC225_FIXUP_S3_POP_NOISE] = {
6981                 .type = HDA_FIXUP_FUNC,
6982                 .v.func = alc225_fixup_s3_pop_noise,
6983                 .chained = true,
6984                 .chain_id = ALC269_FIXUP_HEADSET_MODE_NO_HP_MIC
6985         },
6986         [ALC700_FIXUP_INTEL_REFERENCE] = {
6987                 .type = HDA_FIXUP_VERBS,
6988                 .v.verbs = (const struct hda_verb[]) {
6989                         /* Enables internal speaker */
6990                         {0x20, AC_VERB_SET_COEF_INDEX, 0x45},
6991                         {0x20, AC_VERB_SET_PROC_COEF, 0x5289},
6992                         {0x20, AC_VERB_SET_COEF_INDEX, 0x4A},
6993                         {0x20, AC_VERB_SET_PROC_COEF, 0x001b},
6994                         {0x58, AC_VERB_SET_COEF_INDEX, 0x00},
6995                         {0x58, AC_VERB_SET_PROC_COEF, 0x3888},
6996                         {0x20, AC_VERB_SET_COEF_INDEX, 0x6f},
6997                         {0x20, AC_VERB_SET_PROC_COEF, 0x2c0b},
6998                         {}
6999                 }
7000         },
7001         [ALC274_FIXUP_DELL_BIND_DACS] = {
7002                 .type = HDA_FIXUP_FUNC,
7003                 .v.func = alc274_fixup_bind_dacs,
7004                 .chained = true,
7005                 .chain_id = ALC269_FIXUP_DELL1_MIC_NO_PRESENCE
7006         },
7007         [ALC274_FIXUP_DELL_AIO_LINEOUT_VERB] = {
7008                 .type = HDA_FIXUP_PINS,
7009                 .v.pins = (const struct hda_pintbl[]) {
7010                         { 0x1b, 0x0401102f },
7011                         { }
7012                 },
7013                 .chained = true,
7014                 .chain_id = ALC274_FIXUP_DELL_BIND_DACS
7015         },
7016         [ALC298_FIXUP_TPT470_DOCK_FIX] = {
7017                 .type = HDA_FIXUP_FUNC,
7018                 .v.func = alc_fixup_tpt470_dock,
7019                 .chained = true,
7020                 .chain_id = ALC293_FIXUP_LENOVO_SPK_NOISE
7021         },
7022         [ALC298_FIXUP_TPT470_DOCK] = {
7023                 .type = HDA_FIXUP_FUNC,
7024                 .v.func = alc_fixup_tpt470_dacs,
7025                 .chained = true,
7026                 .chain_id = ALC298_FIXUP_TPT470_DOCK_FIX
7027         },
7028         [ALC255_FIXUP_DUMMY_LINEOUT_VERB] = {
7029                 .type = HDA_FIXUP_PINS,
7030                 .v.pins = (const struct hda_pintbl[]) {
7031                         { 0x14, 0x0201101f },
7032                         { }
7033                 },
7034                 .chained = true,
7035                 .chain_id = ALC255_FIXUP_DELL1_MIC_NO_PRESENCE
7036         },
7037         [ALC255_FIXUP_DELL_HEADSET_MIC] = {
7038                 .type = HDA_FIXUP_PINS,
7039                 .v.pins = (const struct hda_pintbl[]) {
7040                         { 0x19, 0x01a1913c }, /* use as headset mic, without its own jack detect */
7041                         { }
7042                 },
7043                 .chained = true,
7044                 .chain_id = ALC269_FIXUP_HEADSET_MIC
7045         },
7046         [ALC295_FIXUP_HP_X360] = {
7047                 .type = HDA_FIXUP_FUNC,
7048                 .v.func = alc295_fixup_hp_top_speakers,
7049                 .chained = true,
7050                 .chain_id = ALC269_FIXUP_HP_MUTE_LED_MIC3
7051         },
7052         [ALC221_FIXUP_HP_HEADSET_MIC] = {
7053                 .type = HDA_FIXUP_PINS,
7054                 .v.pins = (const struct hda_pintbl[]) {
7055                         { 0x19, 0x0181313f},
7056                         { }
7057                 },
7058                 .chained = true,
7059                 .chain_id = ALC269_FIXUP_HEADSET_MIC
7060         },
7061         [ALC285_FIXUP_LENOVO_HEADPHONE_NOISE] = {
7062                 .type = HDA_FIXUP_FUNC,
7063                 .v.func = alc285_fixup_invalidate_dacs,
7064                 .chained = true,
7065                 .chain_id = ALC269_FIXUP_THINKPAD_ACPI
7066         },
7067         [ALC295_FIXUP_HP_AUTO_MUTE] = {
7068                 .type = HDA_FIXUP_FUNC,
7069                 .v.func = alc_fixup_auto_mute_via_amp,
7070         },
7071         [ALC286_FIXUP_ACER_AIO_MIC_NO_PRESENCE] = {
7072                 .type = HDA_FIXUP_PINS,
7073                 .v.pins = (const struct hda_pintbl[]) {
7074                         { 0x18, 0x01a1913c }, /* use as headset mic, without its own jack detect */
7075                         { }
7076                 },
7077                 .chained = true,
7078                 .chain_id = ALC269_FIXUP_HEADSET_MIC
7079         },
7080         [ALC294_FIXUP_ASUS_MIC] = {
7081                 .type = HDA_FIXUP_PINS,
7082                 .v.pins = (const struct hda_pintbl[]) {
7083                         { 0x13, 0x90a60160 }, /* use as internal mic */
7084                         { 0x19, 0x04a11120 }, /* use as headset mic, without its own jack detect */
7085                         { }
7086                 },
7087                 .chained = true,
7088                 .chain_id = ALC269_FIXUP_HEADSET_MODE_NO_HP_MIC
7089         },
7090         [ALC294_FIXUP_ASUS_HEADSET_MIC] = {
7091                 .type = HDA_FIXUP_PINS,
7092                 .v.pins = (const struct hda_pintbl[]) {
7093                         { 0x19, 0x01a1103c }, /* use as headset mic */
7094                         { }
7095                 },
7096                 .chained = true,
7097                 .chain_id = ALC269_FIXUP_HEADSET_MODE_NO_HP_MIC
7098         },
7099         [ALC294_FIXUP_ASUS_SPK] = {
7100                 .type = HDA_FIXUP_VERBS,
7101                 .v.verbs = (const struct hda_verb[]) {
7102                         /* Set EAPD high */
7103                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x40 },
7104                         { 0x20, AC_VERB_SET_PROC_COEF, 0x8800 },
7105                         { }
7106                 },
7107                 .chained = true,
7108                 .chain_id = ALC294_FIXUP_ASUS_HEADSET_MIC
7109         },
7110         [ALC295_FIXUP_CHROME_BOOK] = {
7111                 .type = HDA_FIXUP_FUNC,
7112                 .v.func = alc295_fixup_chromebook,
7113                 .chained = true,
7114                 .chain_id = ALC225_FIXUP_HEADSET_JACK
7115         },
7116         [ALC225_FIXUP_HEADSET_JACK] = {
7117                 .type = HDA_FIXUP_FUNC,
7118                 .v.func = alc_fixup_headset_jack,
7119         },
7120         [ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE] = {
7121                 .type = HDA_FIXUP_PINS,
7122                 .v.pins = (const struct hda_pintbl[]) {
7123                         { 0x1a, 0x01a1913c }, /* use as headset mic, without its own jack detect */
7124                         { }
7125                 },
7126                 .chained = true,
7127                 .chain_id = ALC269_FIXUP_HEADSET_MODE_NO_HP_MIC
7128         },
7129         [ALC285_FIXUP_LENOVO_PC_BEEP_IN_NOISE] = {
7130                 .type = HDA_FIXUP_VERBS,
7131                 .v.verbs = (const struct hda_verb[]) {
7132                         /* Disable PCBEEP-IN passthrough */
7133                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x36 },
7134                         { 0x20, AC_VERB_SET_PROC_COEF, 0x57d7 },
7135                         { }
7136                 },
7137                 .chained = true,
7138                 .chain_id = ALC285_FIXUP_LENOVO_HEADPHONE_NOISE
7139         },
7140         [ALC255_FIXUP_ACER_HEADSET_MIC] = {
7141                 .type = HDA_FIXUP_PINS,
7142                 .v.pins = (const struct hda_pintbl[]) {
7143                         { 0x19, 0x03a11130 },
7144                         { 0x1a, 0x90a60140 }, /* use as internal mic */
7145                         { }
7146                 },
7147                 .chained = true,
7148                 .chain_id = ALC255_FIXUP_HEADSET_MODE_NO_HP_MIC
7149         },
7150         [ALC225_FIXUP_DELL_WYSE_AIO_MIC_NO_PRESENCE] = {
7151                 .type = HDA_FIXUP_PINS,
7152                 .v.pins = (const struct hda_pintbl[]) {
7153                         { 0x16, 0x01011020 }, /* Rear Line out */
7154                         { 0x19, 0x01a1913c }, /* use as Front headset mic, without its own jack detect */
7155                         { }
7156                 },
7157                 .chained = true,
7158                 .chain_id = ALC225_FIXUP_WYSE_AUTO_MUTE
7159         },
7160         [ALC225_FIXUP_WYSE_AUTO_MUTE] = {
7161                 .type = HDA_FIXUP_FUNC,
7162                 .v.func = alc_fixup_auto_mute_via_amp,
7163                 .chained = true,
7164                 .chain_id = ALC225_FIXUP_WYSE_DISABLE_MIC_VREF
7165         },
7166         [ALC225_FIXUP_WYSE_DISABLE_MIC_VREF] = {
7167                 .type = HDA_FIXUP_FUNC,
7168                 .v.func = alc_fixup_disable_mic_vref,
7169                 .chained = true,
7170                 .chain_id = ALC269_FIXUP_HEADSET_MODE_NO_HP_MIC
7171         },
7172         [ALC286_FIXUP_ACER_AIO_HEADSET_MIC] = {
7173                 .type = HDA_FIXUP_VERBS,
7174                 .v.verbs = (const struct hda_verb[]) {
7175                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x4f },
7176                         { 0x20, AC_VERB_SET_PROC_COEF, 0x5029 },
7177                         { }
7178                 },
7179                 .chained = true,
7180                 .chain_id = ALC286_FIXUP_ACER_AIO_MIC_NO_PRESENCE
7181         },
7182         [ALC256_FIXUP_ASUS_HEADSET_MIC] = {
7183                 .type = HDA_FIXUP_PINS,
7184                 .v.pins = (const struct hda_pintbl[]) {
7185                         { 0x19, 0x03a11020 }, /* headset mic with jack detect */
7186                         { }
7187                 },
7188                 .chained = true,
7189                 .chain_id = ALC256_FIXUP_ASUS_HEADSET_MODE
7190         },
7191         [ALC256_FIXUP_ASUS_MIC_NO_PRESENCE] = {
7192                 .type = HDA_FIXUP_PINS,
7193                 .v.pins = (const struct hda_pintbl[]) {
7194                         { 0x19, 0x04a11120 }, /* use as headset mic, without its own jack detect */
7195                         { }
7196                 },
7197                 .chained = true,
7198                 .chain_id = ALC256_FIXUP_ASUS_HEADSET_MODE
7199         },
7200         [ALC299_FIXUP_PREDATOR_SPK] = {
7201                 .type = HDA_FIXUP_PINS,
7202                 .v.pins = (const struct hda_pintbl[]) {
7203                         { 0x21, 0x90170150 }, /* use as headset mic, without its own jack detect */
7204                         { }
7205                 }
7206         },
7207         [ALC256_FIXUP_MEDION_HEADSET_NO_PRESENCE] = {
7208                 .type = HDA_FIXUP_PINS,
7209                 .v.pins = (const struct hda_pintbl[]) {
7210                         { 0x19, 0x04a11040 },
7211                         { 0x21, 0x04211020 },
7212                         { }
7213                 },
7214                 .chained = true,
7215                 .chain_id = ALC256_FIXUP_ASUS_HEADSET_MODE
7216         },
7217         [ALC289_FIXUP_DELL_SPK2] = {
7218                 .type = HDA_FIXUP_PINS,
7219                 .v.pins = (const struct hda_pintbl[]) {
7220                         { 0x17, 0x90170130 }, /* bass spk */
7221                         { }
7222                 },
7223                 .chained = true,
7224                 .chain_id = ALC269_FIXUP_DELL4_MIC_NO_PRESENCE
7225         },
7226         [ALC289_FIXUP_DUAL_SPK] = {
7227                 .type = HDA_FIXUP_FUNC,
7228                 .v.func = alc285_fixup_speaker2_to_dac1,
7229                 .chained = true,
7230                 .chain_id = ALC289_FIXUP_DELL_SPK2
7231         },
7232         [ALC294_FIXUP_SPK2_TO_DAC1] = {
7233                 .type = HDA_FIXUP_FUNC,
7234                 .v.func = alc285_fixup_speaker2_to_dac1,
7235                 .chained = true,
7236                 .chain_id = ALC294_FIXUP_ASUS_HEADSET_MIC
7237         },
7238         [ALC294_FIXUP_ASUS_DUAL_SPK] = {
7239                 .type = HDA_FIXUP_FUNC,
7240                 /* The GPIO must be pulled to initialize the AMP */
7241                 .v.func = alc_fixup_gpio4,
7242                 .chained = true,
7243                 .chain_id = ALC294_FIXUP_SPK2_TO_DAC1
7244         },
7245         [ALC285_FIXUP_THINKPAD_HEADSET_JACK] = {
7246                 .type = HDA_FIXUP_FUNC,
7247                 .v.func = alc_fixup_headset_jack,
7248                 .chained = true,
7249                 .chain_id = ALC285_FIXUP_SPEAKER2_TO_DAC1
7250         },
7251         [ALC294_FIXUP_ASUS_HPE] = {
7252                 .type = HDA_FIXUP_VERBS,
7253                 .v.verbs = (const struct hda_verb[]) {
7254                         /* Set EAPD high */
7255                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x0f },
7256                         { 0x20, AC_VERB_SET_PROC_COEF, 0x7774 },
7257                         { }
7258                 },
7259                 .chained = true,
7260                 .chain_id = ALC294_FIXUP_ASUS_HEADSET_MIC
7261         },
7262         [ALC294_FIXUP_ASUS_COEF_1B] = {
7263                 .type = HDA_FIXUP_VERBS,
7264                 .v.verbs = (const struct hda_verb[]) {
7265                         /* Set bit 10 to correct noisy output after reboot from
7266                          * Windows 10 (due to pop noise reduction?)
7267                          */
7268                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x1b },
7269                         { 0x20, AC_VERB_SET_PROC_COEF, 0x4e4b },
7270                         { }
7271                 },
7272         },
7273         [ALC285_FIXUP_HP_GPIO_LED] = {
7274                 .type = HDA_FIXUP_FUNC,
7275                 .v.func = alc285_fixup_hp_gpio_led,
7276         },
7277         [ALC285_FIXUP_HP_MUTE_LED] = {
7278                 .type = HDA_FIXUP_FUNC,
7279                 .v.func = alc285_fixup_hp_mute_led,
7280         },
7281         [ALC236_FIXUP_HP_MUTE_LED] = {
7282                 .type = HDA_FIXUP_FUNC,
7283                 .v.func = alc236_fixup_hp_mute_led,
7284         },
7285         [ALC298_FIXUP_SAMSUNG_HEADPHONE_VERY_QUIET] = {
7286                 .type = HDA_FIXUP_VERBS,
7287                 .v.verbs = (const struct hda_verb[]) {
7288                         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc5 },
7289                         { }
7290                 },
7291         },
7292         [ALC295_FIXUP_ASUS_MIC_NO_PRESENCE] = {
7293                 .type = HDA_FIXUP_PINS,
7294                 .v.pins = (const struct hda_pintbl[]) {
7295                         { 0x19, 0x01a1913c }, /* use as headset mic, without its own jack detect */
7296                         { }
7297                 },
7298                 .chained = true,
7299                 .chain_id = ALC269_FIXUP_HEADSET_MODE
7300         },
7301 };
7302
7303 static const struct snd_pci_quirk alc269_fixup_tbl[] = {
7304         SND_PCI_QUIRK(0x1025, 0x0283, "Acer TravelMate 8371", ALC269_FIXUP_INV_DMIC),
7305         SND_PCI_QUIRK(0x1025, 0x029b, "Acer 1810TZ", ALC269_FIXUP_INV_DMIC),
7306         SND_PCI_QUIRK(0x1025, 0x0349, "Acer AOD260", ALC269_FIXUP_INV_DMIC),
7307         SND_PCI_QUIRK(0x1025, 0x047c, "Acer AC700", ALC269_FIXUP_ACER_AC700),
7308         SND_PCI_QUIRK(0x1025, 0x072d, "Acer Aspire V5-571G", ALC269_FIXUP_ASPIRE_HEADSET_MIC),
7309         SND_PCI_QUIRK(0x1025, 0x080d, "Acer Aspire V5-122P", ALC269_FIXUP_ASPIRE_HEADSET_MIC),
7310         SND_PCI_QUIRK(0x1025, 0x0740, "Acer AO725", ALC271_FIXUP_HP_GATE_MIC_JACK),
7311         SND_PCI_QUIRK(0x1025, 0x0742, "Acer AO756", ALC271_FIXUP_HP_GATE_MIC_JACK),
7312         SND_PCI_QUIRK(0x1025, 0x0762, "Acer Aspire E1-472", ALC271_FIXUP_HP_GATE_MIC_JACK_E1_572),
7313         SND_PCI_QUIRK(0x1025, 0x0775, "Acer Aspire E1-572", ALC271_FIXUP_HP_GATE_MIC_JACK_E1_572),
7314         SND_PCI_QUIRK(0x1025, 0x079b, "Acer Aspire V5-573G", ALC282_FIXUP_ASPIRE_V5_PINS),
7315         SND_PCI_QUIRK(0x1025, 0x102b, "Acer Aspire C24-860", ALC286_FIXUP_ACER_AIO_MIC_NO_PRESENCE),
7316         SND_PCI_QUIRK(0x1025, 0x106d, "Acer Cloudbook 14", ALC283_FIXUP_CHROME_BOOK),
7317         SND_PCI_QUIRK(0x1025, 0x1099, "Acer Aspire E5-523G", ALC255_FIXUP_ACER_MIC_NO_PRESENCE),
7318         SND_PCI_QUIRK(0x1025, 0x110e, "Acer Aspire ES1-432", ALC255_FIXUP_ACER_MIC_NO_PRESENCE),
7319         SND_PCI_QUIRK(0x1025, 0x1246, "Acer Predator Helios 500", ALC299_FIXUP_PREDATOR_SPK),
7320         SND_PCI_QUIRK(0x1025, 0x128f, "Acer Veriton Z6860G", ALC286_FIXUP_ACER_AIO_HEADSET_MIC),
7321         SND_PCI_QUIRK(0x1025, 0x1290, "Acer Veriton Z4860G", ALC286_FIXUP_ACER_AIO_HEADSET_MIC),
7322         SND_PCI_QUIRK(0x1025, 0x1291, "Acer Veriton Z4660G", ALC286_FIXUP_ACER_AIO_HEADSET_MIC),
7323         SND_PCI_QUIRK(0x1025, 0x1308, "Acer Aspire Z24-890", ALC286_FIXUP_ACER_AIO_HEADSET_MIC),
7324         SND_PCI_QUIRK(0x1025, 0x132a, "Acer TravelMate B114-21", ALC233_FIXUP_ACER_HEADSET_MIC),
7325         SND_PCI_QUIRK(0x1025, 0x1330, "Acer TravelMate X514-51T", ALC255_FIXUP_ACER_HEADSET_MIC),
7326         SND_PCI_QUIRK(0x1028, 0x0470, "Dell M101z", ALC269_FIXUP_DELL_M101Z),
7327         SND_PCI_QUIRK(0x1028, 0x054b, "Dell XPS one 2710", ALC275_FIXUP_DELL_XPS),
7328         SND_PCI_QUIRK(0x1028, 0x05bd, "Dell Latitude E6440", ALC292_FIXUP_DELL_E7X),
7329         SND_PCI_QUIRK(0x1028, 0x05be, "Dell Latitude E6540", ALC292_FIXUP_DELL_E7X),
7330         SND_PCI_QUIRK(0x1028, 0x05ca, "Dell Latitude E7240", ALC292_FIXUP_DELL_E7X),
7331         SND_PCI_QUIRK(0x1028, 0x05cb, "Dell Latitude E7440", ALC292_FIXUP_DELL_E7X),
7332         SND_PCI_QUIRK(0x1028, 0x05da, "Dell Vostro 5460", ALC290_FIXUP_SUBWOOFER),
7333         SND_PCI_QUIRK(0x1028, 0x05f4, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE),
7334         SND_PCI_QUIRK(0x1028, 0x05f5, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE),
7335         SND_PCI_QUIRK(0x1028, 0x05f6, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE),
7336         SND_PCI_QUIRK(0x1028, 0x0615, "Dell Vostro 5470", ALC290_FIXUP_SUBWOOFER_HSJACK),
7337         SND_PCI_QUIRK(0x1028, 0x0616, "Dell Vostro 5470", ALC290_FIXUP_SUBWOOFER_HSJACK),
7338         SND_PCI_QUIRK(0x1028, 0x062c, "Dell Latitude E5550", ALC292_FIXUP_DELL_E7X),
7339         SND_PCI_QUIRK(0x1028, 0x062e, "Dell Latitude E7450", ALC292_FIXUP_DELL_E7X),
7340         SND_PCI_QUIRK(0x1028, 0x0638, "Dell Inspiron 5439", ALC290_FIXUP_MONO_SPEAKERS_HSJACK),
7341         SND_PCI_QUIRK(0x1028, 0x064a, "Dell", ALC293_FIXUP_DELL1_MIC_NO_PRESENCE),
7342         SND_PCI_QUIRK(0x1028, 0x064b, "Dell", ALC293_FIXUP_DELL1_MIC_NO_PRESENCE),
7343         SND_PCI_QUIRK(0x1028, 0x0665, "Dell XPS 13", ALC288_FIXUP_DELL_XPS_13),
7344         SND_PCI_QUIRK(0x1028, 0x0669, "Dell Optiplex 9020m", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE),
7345         SND_PCI_QUIRK(0x1028, 0x069a, "Dell Vostro 5480", ALC290_FIXUP_SUBWOOFER_HSJACK),
7346         SND_PCI_QUIRK(0x1028, 0x06c7, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE),
7347         SND_PCI_QUIRK(0x1028, 0x06d9, "Dell", ALC293_FIXUP_DELL1_MIC_NO_PRESENCE),
7348         SND_PCI_QUIRK(0x1028, 0x06da, "Dell", ALC293_FIXUP_DELL1_MIC_NO_PRESENCE),
7349         SND_PCI_QUIRK(0x1028, 0x06db, "Dell", ALC293_FIXUP_DISABLE_AAMIX_MULTIJACK),
7350         SND_PCI_QUIRK(0x1028, 0x06dd, "Dell", ALC293_FIXUP_DISABLE_AAMIX_MULTIJACK),
7351         SND_PCI_QUIRK(0x1028, 0x06de, "Dell", ALC293_FIXUP_DISABLE_AAMIX_MULTIJACK),
7352         SND_PCI_QUIRK(0x1028, 0x06df, "Dell", ALC293_FIXUP_DISABLE_AAMIX_MULTIJACK),
7353         SND_PCI_QUIRK(0x1028, 0x06e0, "Dell", ALC293_FIXUP_DISABLE_AAMIX_MULTIJACK),
7354         SND_PCI_QUIRK(0x1028, 0x0706, "Dell Inspiron 7559", ALC256_FIXUP_DELL_INSPIRON_7559_SUBWOOFER),
7355         SND_PCI_QUIRK(0x1028, 0x0725, "Dell Inspiron 3162", ALC255_FIXUP_DELL_SPK_NOISE),
7356         SND_PCI_QUIRK(0x1028, 0x0738, "Dell Precision 5820", ALC269_FIXUP_NO_SHUTUP),
7357         SND_PCI_QUIRK(0x1028, 0x075c, "Dell XPS 27 7760", ALC298_FIXUP_SPK_VOLUME),
7358         SND_PCI_QUIRK(0x1028, 0x075d, "Dell AIO", ALC298_FIXUP_SPK_VOLUME),
7359         SND_PCI_QUIRK(0x1028, 0x07b0, "Dell Precision 7520", ALC295_FIXUP_DISABLE_DAC3),
7360         SND_PCI_QUIRK(0x1028, 0x0798, "Dell Inspiron 17 7000 Gaming", ALC256_FIXUP_DELL_INSPIRON_7559_SUBWOOFER),
7361         SND_PCI_QUIRK(0x1028, 0x080c, "Dell WYSE", ALC225_FIXUP_DELL_WYSE_MIC_NO_PRESENCE),
7362         SND_PCI_QUIRK(0x1028, 0x084b, "Dell", ALC274_FIXUP_DELL_AIO_LINEOUT_VERB),
7363         SND_PCI_QUIRK(0x1028, 0x084e, "Dell", ALC274_FIXUP_DELL_AIO_LINEOUT_VERB),
7364         SND_PCI_QUIRK(0x1028, 0x0871, "Dell Precision 3630", ALC255_FIXUP_DELL_HEADSET_MIC),
7365         SND_PCI_QUIRK(0x1028, 0x0872, "Dell Precision 3630", ALC255_FIXUP_DELL_HEADSET_MIC),
7366         SND_PCI_QUIRK(0x1028, 0x0873, "Dell Precision 3930", ALC255_FIXUP_DUMMY_LINEOUT_VERB),
7367         SND_PCI_QUIRK(0x1028, 0x08ad, "Dell WYSE AIO", ALC225_FIXUP_DELL_WYSE_AIO_MIC_NO_PRESENCE),
7368         SND_PCI_QUIRK(0x1028, 0x08ae, "Dell WYSE NB", ALC225_FIXUP_DELL1_MIC_NO_PRESENCE),
7369         SND_PCI_QUIRK(0x1028, 0x0935, "Dell", ALC274_FIXUP_DELL_AIO_LINEOUT_VERB),
7370         SND_PCI_QUIRK(0x1028, 0x097e, "Dell Precision", ALC289_FIXUP_DUAL_SPK),
7371         SND_PCI_QUIRK(0x1028, 0x097d, "Dell Precision", ALC289_FIXUP_DUAL_SPK),
7372         SND_PCI_QUIRK(0x1028, 0x098d, "Dell Precision", ALC233_FIXUP_ASUS_MIC_NO_PRESENCE),
7373         SND_PCI_QUIRK(0x1028, 0x09bf, "Dell Precision", ALC233_FIXUP_ASUS_MIC_NO_PRESENCE),
7374         SND_PCI_QUIRK(0x1028, 0x164a, "Dell", ALC293_FIXUP_DELL1_MIC_NO_PRESENCE),
7375         SND_PCI_QUIRK(0x1028, 0x164b, "Dell", ALC293_FIXUP_DELL1_MIC_NO_PRESENCE),
7376         SND_PCI_QUIRK(0x103c, 0x1586, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC2),
7377         SND_PCI_QUIRK(0x103c, 0x18e6, "HP", ALC269_FIXUP_HP_GPIO_LED),
7378         SND_PCI_QUIRK(0x103c, 0x218b, "HP", ALC269_FIXUP_LIMIT_INT_MIC_BOOST_MUTE_LED),
7379         SND_PCI_QUIRK(0x103c, 0x225f, "HP", ALC280_FIXUP_HP_GPIO2_MIC_HOTKEY),
7380         /* ALC282 */
7381         SND_PCI_QUIRK(0x103c, 0x21f9, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
7382         SND_PCI_QUIRK(0x103c, 0x2210, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
7383         SND_PCI_QUIRK(0x103c, 0x2214, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
7384         SND_PCI_QUIRK(0x103c, 0x2236, "HP", ALC269_FIXUP_HP_LINE1_MIC1_LED),
7385         SND_PCI_QUIRK(0x103c, 0x2237, "HP", ALC269_FIXUP_HP_LINE1_MIC1_LED),
7386         SND_PCI_QUIRK(0x103c, 0x2238, "HP", ALC269_FIXUP_HP_LINE1_MIC1_LED),
7387         SND_PCI_QUIRK(0x103c, 0x2239, "HP", ALC269_FIXUP_HP_LINE1_MIC1_LED),
7388         SND_PCI_QUIRK(0x103c, 0x224b, "HP", ALC269_FIXUP_HP_LINE1_MIC1_LED),
7389         SND_PCI_QUIRK(0x103c, 0x2268, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
7390         SND_PCI_QUIRK(0x103c, 0x226a, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
7391         SND_PCI_QUIRK(0x103c, 0x226b, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
7392         SND_PCI_QUIRK(0x103c, 0x226e, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
7393         SND_PCI_QUIRK(0x103c, 0x2271, "HP", ALC286_FIXUP_HP_GPIO_LED),
7394         SND_PCI_QUIRK(0x103c, 0x2272, "HP", ALC280_FIXUP_HP_DOCK_PINS),
7395         SND_PCI_QUIRK(0x103c, 0x2273, "HP", ALC280_FIXUP_HP_DOCK_PINS),
7396         SND_PCI_QUIRK(0x103c, 0x229e, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
7397         SND_PCI_QUIRK(0x103c, 0x22b2, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
7398         SND_PCI_QUIRK(0x103c, 0x22b7, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
7399         SND_PCI_QUIRK(0x103c, 0x22bf, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
7400         SND_PCI_QUIRK(0x103c, 0x22cf, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
7401         SND_PCI_QUIRK(0x103c, 0x22db, "HP", ALC280_FIXUP_HP_9480M),
7402         SND_PCI_QUIRK(0x103c, 0x22dc, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),
7403         SND_PCI_QUIRK(0x103c, 0x22fb, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),
7404         /* ALC290 */
7405         SND_PCI_QUIRK(0x103c, 0x221b, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),
7406         SND_PCI_QUIRK(0x103c, 0x2221, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),
7407         SND_PCI_QUIRK(0x103c, 0x2225, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),
7408         SND_PCI_QUIRK(0x103c, 0x2253, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),
7409         SND_PCI_QUIRK(0x103c, 0x2254, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),
7410         SND_PCI_QUIRK(0x103c, 0x2255, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),
7411         SND_PCI_QUIRK(0x103c, 0x2256, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),
7412         SND_PCI_QUIRK(0x103c, 0x2257, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),
7413         SND_PCI_QUIRK(0x103c, 0x2259, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),
7414         SND_PCI_QUIRK(0x103c, 0x225a, "HP", ALC269_FIXUP_HP_DOCK_GPIO_MIC1_LED),
7415         SND_PCI_QUIRK(0x103c, 0x2260, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
7416         SND_PCI_QUIRK(0x103c, 0x2263, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
7417         SND_PCI_QUIRK(0x103c, 0x2264, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
7418         SND_PCI_QUIRK(0x103c, 0x2265, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
7419         SND_PCI_QUIRK(0x103c, 0x2272, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),
7420         SND_PCI_QUIRK(0x103c, 0x2273, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),
7421         SND_PCI_QUIRK(0x103c, 0x2278, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),
7422         SND_PCI_QUIRK(0x103c, 0x227f, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
7423         SND_PCI_QUIRK(0x103c, 0x2282, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
7424         SND_PCI_QUIRK(0x103c, 0x228b, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
7425         SND_PCI_QUIRK(0x103c, 0x228e, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
7426         SND_PCI_QUIRK(0x103c, 0x22c5, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
7427         SND_PCI_QUIRK(0x103c, 0x22c7, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
7428         SND_PCI_QUIRK(0x103c, 0x22c8, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
7429         SND_PCI_QUIRK(0x103c, 0x22c4, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
7430         SND_PCI_QUIRK(0x103c, 0x2334, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
7431         SND_PCI_QUIRK(0x103c, 0x2335, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
7432         SND_PCI_QUIRK(0x103c, 0x2336, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
7433         SND_PCI_QUIRK(0x103c, 0x2337, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
7434         SND_PCI_QUIRK(0x103c, 0x221c, "HP EliteBook 755 G2", ALC280_FIXUP_HP_HEADSET_MIC),
7435         SND_PCI_QUIRK(0x103c, 0x802e, "HP Z240 SFF", ALC221_FIXUP_HP_MIC_NO_PRESENCE),
7436         SND_PCI_QUIRK(0x103c, 0x802f, "HP Z240", ALC221_FIXUP_HP_MIC_NO_PRESENCE),
7437         SND_PCI_QUIRK(0x103c, 0x820d, "HP Pavilion 15", ALC269_FIXUP_HP_MUTE_LED_MIC3),
7438         SND_PCI_QUIRK(0x103c, 0x8256, "HP", ALC221_FIXUP_HP_FRONT_MIC),
7439         SND_PCI_QUIRK(0x103c, 0x827e, "HP x360", ALC295_FIXUP_HP_X360),
7440         SND_PCI_QUIRK(0x103c, 0x82bf, "HP G3 mini", ALC221_FIXUP_HP_MIC_NO_PRESENCE),
7441         SND_PCI_QUIRK(0x103c, 0x82c0, "HP G3 mini premium", ALC221_FIXUP_HP_MIC_NO_PRESENCE),
7442         SND_PCI_QUIRK(0x103c, 0x83b9, "HP Spectre x360", ALC269_FIXUP_HP_MUTE_LED_MIC3),
7443         SND_PCI_QUIRK(0x103c, 0x8497, "HP Envy x360", ALC269_FIXUP_HP_MUTE_LED_MIC3),
7444         SND_PCI_QUIRK(0x103c, 0x84e7, "HP Pavilion 15", ALC269_FIXUP_HP_MUTE_LED_MIC3),
7445         SND_PCI_QUIRK(0x103c, 0x8736, "HP", ALC285_FIXUP_HP_GPIO_LED),
7446         SND_PCI_QUIRK(0x103c, 0x877a, "HP", ALC285_FIXUP_HP_MUTE_LED),
7447         SND_PCI_QUIRK(0x103c, 0x877d, "HP", ALC236_FIXUP_HP_MUTE_LED),
7448         SND_PCI_QUIRK(0x1043, 0x103e, "ASUS X540SA", ALC256_FIXUP_ASUS_MIC),
7449         SND_PCI_QUIRK(0x1043, 0x103f, "ASUS TX300", ALC282_FIXUP_ASUS_TX300),
7450         SND_PCI_QUIRK(0x1043, 0x106d, "Asus K53BE", ALC269_FIXUP_LIMIT_INT_MIC_BOOST),
7451         SND_PCI_QUIRK(0x1043, 0x10a1, "ASUS UX391UA", ALC294_FIXUP_ASUS_SPK),
7452         SND_PCI_QUIRK(0x1043, 0x10c0, "ASUS X540SA", ALC256_FIXUP_ASUS_MIC),
7453         SND_PCI_QUIRK(0x1043, 0x10d0, "ASUS X540LA/X540LJ", ALC255_FIXUP_ASUS_MIC_NO_PRESENCE),
7454         SND_PCI_QUIRK(0x1043, 0x115d, "Asus 1015E", ALC269_FIXUP_LIMIT_INT_MIC_BOOST),
7455         SND_PCI_QUIRK(0x1043, 0x11c0, "ASUS X556UR", ALC255_FIXUP_ASUS_MIC_NO_PRESENCE),
7456         SND_PCI_QUIRK(0x1043, 0x1290, "ASUS X441SA", ALC233_FIXUP_EAPD_COEF_AND_MIC_NO_PRESENCE),
7457         SND_PCI_QUIRK(0x1043, 0x12a0, "ASUS X441UV", ALC233_FIXUP_EAPD_COEF_AND_MIC_NO_PRESENCE),
7458         SND_PCI_QUIRK(0x1043, 0x12f0, "ASUS X541UV", ALC256_FIXUP_ASUS_MIC),
7459         SND_PCI_QUIRK(0x1043, 0x12e0, "ASUS X541SA", ALC256_FIXUP_ASUS_MIC),
7460         SND_PCI_QUIRK(0x1043, 0x13b0, "ASUS Z550SA", ALC256_FIXUP_ASUS_MIC),
7461         SND_PCI_QUIRK(0x1043, 0x1427, "Asus Zenbook UX31E", ALC269VB_FIXUP_ASUS_ZENBOOK),
7462         SND_PCI_QUIRK(0x1043, 0x1517, "Asus Zenbook UX31A", ALC269VB_FIXUP_ASUS_ZENBOOK_UX31A),
7463         SND_PCI_QUIRK(0x1043, 0x16e3, "ASUS UX50", ALC269_FIXUP_STEREO_DMIC),
7464         SND_PCI_QUIRK(0x1043, 0x17d1, "ASUS UX431FL", ALC294_FIXUP_ASUS_DUAL_SPK),
7465         SND_PCI_QUIRK(0x1043, 0x18b1, "Asus MJ401TA", ALC256_FIXUP_ASUS_HEADSET_MIC),
7466         SND_PCI_QUIRK(0x1043, 0x18f1, "Asus FX505DT", ALC256_FIXUP_ASUS_HEADSET_MIC),
7467         SND_PCI_QUIRK(0x1043, 0x19ce, "ASUS B9450FA", ALC294_FIXUP_ASUS_HPE),
7468         SND_PCI_QUIRK(0x1043, 0x19e1, "ASUS UX581LV", ALC295_FIXUP_ASUS_MIC_NO_PRESENCE),
7469         SND_PCI_QUIRK(0x1043, 0x1a13, "Asus G73Jw", ALC269_FIXUP_ASUS_G73JW),
7470         SND_PCI_QUIRK(0x1043, 0x1a30, "ASUS X705UD", ALC256_FIXUP_ASUS_MIC),
7471         SND_PCI_QUIRK(0x1043, 0x1b11, "ASUS UX431DA", ALC294_FIXUP_ASUS_COEF_1B),
7472         SND_PCI_QUIRK(0x1043, 0x1b13, "Asus U41SV", ALC269_FIXUP_INV_DMIC),
7473         SND_PCI_QUIRK(0x1043, 0x1bbd, "ASUS Z550MA", ALC255_FIXUP_ASUS_MIC_NO_PRESENCE),
7474         SND_PCI_QUIRK(0x1043, 0x1c23, "Asus X55U", ALC269_FIXUP_LIMIT_INT_MIC_BOOST),
7475         SND_PCI_QUIRK(0x1043, 0x1ccd, "ASUS X555UB", ALC256_FIXUP_ASUS_MIC),
7476         SND_PCI_QUIRK(0x1043, 0x3030, "ASUS ZN270IE", ALC256_FIXUP_ASUS_AIO_GPIO2),
7477         SND_PCI_QUIRK(0x1043, 0x831a, "ASUS P901", ALC269_FIXUP_STEREO_DMIC),
7478         SND_PCI_QUIRK(0x1043, 0x834a, "ASUS S101", ALC269_FIXUP_STEREO_DMIC),
7479         SND_PCI_QUIRK(0x1043, 0x8398, "ASUS P1005", ALC269_FIXUP_STEREO_DMIC),
7480         SND_PCI_QUIRK(0x1043, 0x83ce, "ASUS P1005", ALC269_FIXUP_STEREO_DMIC),
7481         SND_PCI_QUIRK(0x1043, 0x8516, "ASUS X101CH", ALC269_FIXUP_ASUS_X101),
7482         SND_PCI_QUIRK(0x104d, 0x90b5, "Sony VAIO Pro 11", ALC286_FIXUP_SONY_MIC_NO_PRESENCE),
7483         SND_PCI_QUIRK(0x104d, 0x90b6, "Sony VAIO Pro 13", ALC286_FIXUP_SONY_MIC_NO_PRESENCE),
7484         SND_PCI_QUIRK(0x104d, 0x9073, "Sony VAIO", ALC275_FIXUP_SONY_VAIO_GPIO2),
7485         SND_PCI_QUIRK(0x104d, 0x907b, "Sony VAIO", ALC275_FIXUP_SONY_HWEQ),
7486         SND_PCI_QUIRK(0x104d, 0x9084, "Sony VAIO", ALC275_FIXUP_SONY_HWEQ),
7487         SND_PCI_QUIRK(0x104d, 0x9099, "Sony VAIO S13", ALC275_FIXUP_SONY_DISABLE_AAMIX),
7488         SND_PCI_QUIRK(0x10cf, 0x1475, "Lifebook", ALC269_FIXUP_LIFEBOOK),
7489         SND_PCI_QUIRK(0x10cf, 0x159f, "Lifebook E780", ALC269_FIXUP_LIFEBOOK_NO_HP_TO_LINEOUT),
7490         SND_PCI_QUIRK(0x10cf, 0x15dc, "Lifebook T731", ALC269_FIXUP_LIFEBOOK_HP_PIN),
7491         SND_PCI_QUIRK(0x10cf, 0x1757, "Lifebook E752", ALC269_FIXUP_LIFEBOOK_HP_PIN),
7492         SND_PCI_QUIRK(0x10cf, 0x1629, "Lifebook U7x7", ALC255_FIXUP_LIFEBOOK_U7x7_HEADSET_MIC),
7493         SND_PCI_QUIRK(0x10cf, 0x1845, "Lifebook U904", ALC269_FIXUP_LIFEBOOK_EXTMIC),
7494         SND_PCI_QUIRK(0x10ec, 0x10f2, "Intel Reference board", ALC700_FIXUP_INTEL_REFERENCE),
7495         SND_PCI_QUIRK(0x10f7, 0x8338, "Panasonic CF-SZ6", ALC269_FIXUP_HEADSET_MODE),
7496         SND_PCI_QUIRK(0x144d, 0xc109, "Samsung Ativ book 9 (NP900X3G)", ALC269_FIXUP_INV_DMIC),
7497         SND_PCI_QUIRK(0x144d, 0xc169, "Samsung Notebook 9 Pen (NP930SBE-K01US)", ALC298_FIXUP_SAMSUNG_HEADPHONE_VERY_QUIET),
7498         SND_PCI_QUIRK(0x144d, 0xc176, "Samsung Notebook 9 Pro (NP930MBE-K04US)", ALC298_FIXUP_SAMSUNG_HEADPHONE_VERY_QUIET),
7499         SND_PCI_QUIRK(0x144d, 0xc740, "Samsung Ativ book 8 (NP870Z5G)", ALC269_FIXUP_ATIV_BOOK_8),
7500         SND_PCI_QUIRK(0x1458, 0xfa53, "Gigabyte BXBT-2807", ALC283_FIXUP_HEADSET_MIC),
7501         SND_PCI_QUIRK(0x1462, 0xb120, "MSI Cubi MS-B120", ALC283_FIXUP_HEADSET_MIC),
7502         SND_PCI_QUIRK(0x1462, 0xb171, "Cubi N 8GL (MS-B171)", ALC283_FIXUP_HEADSET_MIC),
7503         SND_PCI_QUIRK(0x1558, 0x1325, "System76 Darter Pro (darp5)", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
7504         SND_PCI_QUIRK(0x1558, 0x8550, "System76 Gazelle (gaze14)", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
7505         SND_PCI_QUIRK(0x1558, 0x8551, "System76 Gazelle (gaze14)", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
7506         SND_PCI_QUIRK(0x1558, 0x8560, "System76 Gazelle (gaze14)", ALC269_FIXUP_HEADSET_MIC),
7507         SND_PCI_QUIRK(0x1558, 0x8561, "System76 Gazelle (gaze14)", ALC269_FIXUP_HEADSET_MIC),
7508         SND_PCI_QUIRK(0x17aa, 0x1036, "Lenovo P520", ALC233_FIXUP_LENOVO_MULTI_CODECS),
7509         SND_PCI_QUIRK(0x17aa, 0x1048, "ThinkCentre Station", ALC283_FIXUP_HEADSET_MIC),
7510         SND_PCI_QUIRK(0x17aa, 0x20f2, "Thinkpad SL410/510", ALC269_FIXUP_SKU_IGNORE),
7511         SND_PCI_QUIRK(0x17aa, 0x215e, "Thinkpad L512", ALC269_FIXUP_SKU_IGNORE),
7512         SND_PCI_QUIRK(0x17aa, 0x21b8, "Thinkpad Edge 14", ALC269_FIXUP_SKU_IGNORE),
7513         SND_PCI_QUIRK(0x17aa, 0x21ca, "Thinkpad L412", ALC269_FIXUP_SKU_IGNORE),
7514         SND_PCI_QUIRK(0x17aa, 0x21e9, "Thinkpad Edge 15", ALC269_FIXUP_SKU_IGNORE),
7515         SND_PCI_QUIRK(0x17aa, 0x21f6, "Thinkpad T530", ALC269_FIXUP_LENOVO_DOCK_LIMIT_BOOST),
7516         SND_PCI_QUIRK(0x17aa, 0x21fa, "Thinkpad X230", ALC269_FIXUP_LENOVO_DOCK),
7517         SND_PCI_QUIRK(0x17aa, 0x21f3, "Thinkpad T430", ALC269_FIXUP_LENOVO_DOCK),
7518         SND_PCI_QUIRK(0x17aa, 0x21fb, "Thinkpad T430s", ALC269_FIXUP_LENOVO_DOCK),
7519         SND_PCI_QUIRK(0x17aa, 0x2203, "Thinkpad X230 Tablet", ALC269_FIXUP_LENOVO_DOCK),
7520         SND_PCI_QUIRK(0x17aa, 0x2208, "Thinkpad T431s", ALC269_FIXUP_LENOVO_DOCK),
7521         SND_PCI_QUIRK(0x17aa, 0x220c, "Thinkpad T440s", ALC292_FIXUP_TPT440),
7522         SND_PCI_QUIRK(0x17aa, 0x220e, "Thinkpad T440p", ALC292_FIXUP_TPT440_DOCK),
7523         SND_PCI_QUIRK(0x17aa, 0x2210, "Thinkpad T540p", ALC292_FIXUP_TPT440_DOCK),
7524         SND_PCI_QUIRK(0x17aa, 0x2211, "Thinkpad W541", ALC292_FIXUP_TPT440_DOCK),
7525         SND_PCI_QUIRK(0x17aa, 0x2212, "Thinkpad T440", ALC292_FIXUP_TPT440_DOCK),
7526         SND_PCI_QUIRK(0x17aa, 0x2214, "Thinkpad X240", ALC292_FIXUP_TPT440_DOCK),
7527         SND_PCI_QUIRK(0x17aa, 0x2215, "Thinkpad", ALC269_FIXUP_LIMIT_INT_MIC_BOOST),
7528         SND_PCI_QUIRK(0x17aa, 0x2218, "Thinkpad X1 Carbon 2nd", ALC292_FIXUP_TPT440_DOCK),
7529         SND_PCI_QUIRK(0x17aa, 0x2223, "ThinkPad T550", ALC292_FIXUP_TPT440_DOCK),
7530         SND_PCI_QUIRK(0x17aa, 0x2226, "ThinkPad X250", ALC292_FIXUP_TPT440_DOCK),
7531         SND_PCI_QUIRK(0x17aa, 0x222d, "Thinkpad", ALC298_FIXUP_TPT470_DOCK),
7532         SND_PCI_QUIRK(0x17aa, 0x222e, "Thinkpad", ALC298_FIXUP_TPT470_DOCK),
7533         SND_PCI_QUIRK(0x17aa, 0x2231, "Thinkpad T560", ALC292_FIXUP_TPT460),
7534         SND_PCI_QUIRK(0x17aa, 0x2233, "Thinkpad", ALC292_FIXUP_TPT460),
7535         SND_PCI_QUIRK(0x17aa, 0x2245, "Thinkpad T470", ALC298_FIXUP_TPT470_DOCK),
7536         SND_PCI_QUIRK(0x17aa, 0x2246, "Thinkpad", ALC298_FIXUP_TPT470_DOCK),
7537         SND_PCI_QUIRK(0x17aa, 0x2247, "Thinkpad", ALC298_FIXUP_TPT470_DOCK),
7538         SND_PCI_QUIRK(0x17aa, 0x2249, "Thinkpad", ALC292_FIXUP_TPT460),
7539         SND_PCI_QUIRK(0x17aa, 0x224b, "Thinkpad", ALC298_FIXUP_TPT470_DOCK),
7540         SND_PCI_QUIRK(0x17aa, 0x224c, "Thinkpad", ALC298_FIXUP_TPT470_DOCK),
7541         SND_PCI_QUIRK(0x17aa, 0x224d, "Thinkpad", ALC298_FIXUP_TPT470_DOCK),
7542         SND_PCI_QUIRK(0x17aa, 0x225d, "Thinkpad T480", ALC269_FIXUP_LIMIT_INT_MIC_BOOST),
7543         SND_PCI_QUIRK(0x17aa, 0x2292, "Thinkpad X1 Yoga 7th", ALC285_FIXUP_THINKPAD_HEADSET_JACK),
7544         SND_PCI_QUIRK(0x17aa, 0x2293, "Thinkpad X1 Carbon 7th", ALC285_FIXUP_THINKPAD_HEADSET_JACK),
7545         SND_PCI_QUIRK(0x17aa, 0x22be, "Thinkpad X1 Carbon 8th", ALC285_FIXUP_THINKPAD_HEADSET_JACK),
7546         SND_PCI_QUIRK(0x17aa, 0x30bb, "ThinkCentre AIO", ALC233_FIXUP_LENOVO_LINE2_MIC_HOTKEY),
7547         SND_PCI_QUIRK(0x17aa, 0x30e2, "ThinkCentre AIO", ALC233_FIXUP_LENOVO_LINE2_MIC_HOTKEY),
7548         SND_PCI_QUIRK(0x17aa, 0x310c, "ThinkCentre Station", ALC294_FIXUP_LENOVO_MIC_LOCATION),
7549         SND_PCI_QUIRK(0x17aa, 0x3111, "ThinkCentre Station", ALC294_FIXUP_LENOVO_MIC_LOCATION),
7550         SND_PCI_QUIRK(0x17aa, 0x312a, "ThinkCentre Station", ALC294_FIXUP_LENOVO_MIC_LOCATION),
7551         SND_PCI_QUIRK(0x17aa, 0x312f, "ThinkCentre Station", ALC294_FIXUP_LENOVO_MIC_LOCATION),
7552         SND_PCI_QUIRK(0x17aa, 0x313c, "ThinkCentre Station", ALC294_FIXUP_LENOVO_MIC_LOCATION),
7553         SND_PCI_QUIRK(0x17aa, 0x3151, "ThinkCentre Station", ALC283_FIXUP_HEADSET_MIC),
7554         SND_PCI_QUIRK(0x17aa, 0x3176, "ThinkCentre Station", ALC283_FIXUP_HEADSET_MIC),
7555         SND_PCI_QUIRK(0x17aa, 0x3178, "ThinkCentre Station", ALC283_FIXUP_HEADSET_MIC),
7556         SND_PCI_QUIRK(0x17aa, 0x3902, "Lenovo E50-80", ALC269_FIXUP_DMIC_THINKPAD_ACPI),
7557         SND_PCI_QUIRK(0x17aa, 0x3977, "IdeaPad S210", ALC283_FIXUP_INT_MIC),
7558         SND_PCI_QUIRK(0x17aa, 0x3978, "Lenovo B50-70", ALC269_FIXUP_DMIC_THINKPAD_ACPI),
7559         SND_PCI_QUIRK(0x17aa, 0x5013, "Thinkpad", ALC269_FIXUP_LIMIT_INT_MIC_BOOST),
7560         SND_PCI_QUIRK(0x17aa, 0x501a, "Thinkpad", ALC283_FIXUP_INT_MIC),
7561         SND_PCI_QUIRK(0x17aa, 0x501e, "Thinkpad L440", ALC292_FIXUP_TPT440_DOCK),
7562         SND_PCI_QUIRK(0x17aa, 0x5026, "Thinkpad", ALC269_FIXUP_LIMIT_INT_MIC_BOOST),
7563         SND_PCI_QUIRK(0x17aa, 0x5034, "Thinkpad T450", ALC292_FIXUP_TPT440_DOCK),
7564         SND_PCI_QUIRK(0x17aa, 0x5036, "Thinkpad T450s", ALC292_FIXUP_TPT440_DOCK),
7565         SND_PCI_QUIRK(0x17aa, 0x503c, "Thinkpad L450", ALC292_FIXUP_TPT440_DOCK),
7566         SND_PCI_QUIRK(0x17aa, 0x504a, "ThinkPad X260", ALC292_FIXUP_TPT440_DOCK),
7567         SND_PCI_QUIRK(0x17aa, 0x504b, "Thinkpad", ALC293_FIXUP_LENOVO_SPK_NOISE),
7568         SND_PCI_QUIRK(0x17aa, 0x5050, "Thinkpad T560p", ALC292_FIXUP_TPT460),
7569         SND_PCI_QUIRK(0x17aa, 0x5051, "Thinkpad L460", ALC292_FIXUP_TPT460),
7570         SND_PCI_QUIRK(0x17aa, 0x5053, "Thinkpad T460", ALC292_FIXUP_TPT460),
7571         SND_PCI_QUIRK(0x17aa, 0x505d, "Thinkpad", ALC298_FIXUP_TPT470_DOCK),
7572         SND_PCI_QUIRK(0x17aa, 0x505f, "Thinkpad", ALC298_FIXUP_TPT470_DOCK),
7573         SND_PCI_QUIRK(0x17aa, 0x5062, "Thinkpad", ALC298_FIXUP_TPT470_DOCK),
7574         SND_PCI_QUIRK(0x17aa, 0x5109, "Thinkpad", ALC269_FIXUP_LIMIT_INT_MIC_BOOST),
7575         SND_PCI_QUIRK(0x17aa, 0x511e, "Thinkpad", ALC298_FIXUP_TPT470_DOCK),
7576         SND_PCI_QUIRK(0x17aa, 0x511f, "Thinkpad", ALC298_FIXUP_TPT470_DOCK),
7577         SND_PCI_QUIRK(0x17aa, 0x3bf8, "Quanta FL1", ALC269_FIXUP_PCM_44K),
7578         SND_PCI_QUIRK(0x17aa, 0x9e54, "LENOVO NB", ALC269_FIXUP_LENOVO_EAPD),
7579         SND_PCI_QUIRK(0x19e5, 0x3204, "Huawei MACH-WX9", ALC256_FIXUP_HUAWEI_MACH_WX9_PINS),
7580         SND_PCI_QUIRK(0x1b7d, 0xa831, "Ordissimo EVE2 ", ALC269VB_FIXUP_ORDISSIMO_EVE2), /* Also known as Malata PC-B1303 */
7581         SND_PCI_QUIRK(0x1d72, 0x1901, "RedmiBook 14", ALC256_FIXUP_ASUS_HEADSET_MIC),
7582         SND_PCI_QUIRK(0x10ec, 0x118c, "Medion EE4254 MD62100", ALC256_FIXUP_MEDION_HEADSET_NO_PRESENCE),
7583
7584 #if 0
7585         /* Below is a quirk table taken from the old code.
7586          * Basically the device should work as is without the fixup table.
7587          * If BIOS doesn't give a proper info, enable the corresponding
7588          * fixup entry.
7589          */
7590         SND_PCI_QUIRK(0x1043, 0x8330, "ASUS Eeepc P703 P900A",
7591                       ALC269_FIXUP_AMIC),
7592         SND_PCI_QUIRK(0x1043, 0x1013, "ASUS N61Da", ALC269_FIXUP_AMIC),
7593         SND_PCI_QUIRK(0x1043, 0x1143, "ASUS B53f", ALC269_FIXUP_AMIC),
7594         SND_PCI_QUIRK(0x1043, 0x1133, "ASUS UJ20ft", ALC269_FIXUP_AMIC),
7595         SND_PCI_QUIRK(0x1043, 0x1183, "ASUS K72DR", ALC269_FIXUP_AMIC),
7596         SND_PCI_QUIRK(0x1043, 0x11b3, "ASUS K52DR", ALC269_FIXUP_AMIC),
7597         SND_PCI_QUIRK(0x1043, 0x11e3, "ASUS U33Jc", ALC269_FIXUP_AMIC),
7598         SND_PCI_QUIRK(0x1043, 0x1273, "ASUS UL80Jt", ALC269_FIXUP_AMIC),
7599         SND_PCI_QUIRK(0x1043, 0x1283, "ASUS U53Jc", ALC269_FIXUP_AMIC),
7600         SND_PCI_QUIRK(0x1043, 0x12b3, "ASUS N82JV", ALC269_FIXUP_AMIC),
7601         SND_PCI_QUIRK(0x1043, 0x12d3, "ASUS N61Jv", ALC269_FIXUP_AMIC),
7602         SND_PCI_QUIRK(0x1043, 0x13a3, "ASUS UL30Vt", ALC269_FIXUP_AMIC),
7603         SND_PCI_QUIRK(0x1043, 0x1373, "ASUS G73JX", ALC269_FIXUP_AMIC),
7604         SND_PCI_QUIRK(0x1043, 0x1383, "ASUS UJ30Jc", ALC269_FIXUP_AMIC),
7605         SND_PCI_QUIRK(0x1043, 0x13d3, "ASUS N61JA", ALC269_FIXUP_AMIC),
7606         SND_PCI_QUIRK(0x1043, 0x1413, "ASUS UL50", ALC269_FIXUP_AMIC),
7607         SND_PCI_QUIRK(0x1043, 0x1443, "ASUS UL30", ALC269_FIXUP_AMIC),
7608         SND_PCI_QUIRK(0x1043, 0x1453, "ASUS M60Jv", ALC269_FIXUP_AMIC),
7609         SND_PCI_QUIRK(0x1043, 0x1483, "ASUS UL80", ALC269_FIXUP_AMIC),
7610         SND_PCI_QUIRK(0x1043, 0x14f3, "ASUS F83Vf", ALC269_FIXUP_AMIC),
7611         SND_PCI_QUIRK(0x1043, 0x14e3, "ASUS UL20", ALC269_FIXUP_AMIC),
7612         SND_PCI_QUIRK(0x1043, 0x1513, "ASUS UX30", ALC269_FIXUP_AMIC),
7613         SND_PCI_QUIRK(0x1043, 0x1593, "ASUS N51Vn", ALC269_FIXUP_AMIC),
7614         SND_PCI_QUIRK(0x1043, 0x15a3, "ASUS N60Jv", ALC269_FIXUP_AMIC),
7615         SND_PCI_QUIRK(0x1043, 0x15b3, "ASUS N60Dp", ALC269_FIXUP_AMIC),
7616         SND_PCI_QUIRK(0x1043, 0x15c3, "ASUS N70De", ALC269_FIXUP_AMIC),
7617         SND_PCI_QUIRK(0x1043, 0x15e3, "ASUS F83T", ALC269_FIXUP_AMIC),
7618         SND_PCI_QUIRK(0x1043, 0x1643, "ASUS M60J", ALC269_FIXUP_AMIC),
7619         SND_PCI_QUIRK(0x1043, 0x1653, "ASUS U50", ALC269_FIXUP_AMIC),
7620         SND_PCI_QUIRK(0x1043, 0x1693, "ASUS F50N", ALC269_FIXUP_AMIC),
7621         SND_PCI_QUIRK(0x1043, 0x16a3, "ASUS F5Q", ALC269_FIXUP_AMIC),
7622         SND_PCI_QUIRK(0x1043, 0x1723, "ASUS P80", ALC269_FIXUP_AMIC),
7623         SND_PCI_QUIRK(0x1043, 0x1743, "ASUS U80", ALC269_FIXUP_AMIC),
7624         SND_PCI_QUIRK(0x1043, 0x1773, "ASUS U20A", ALC269_FIXUP_AMIC),
7625         SND_PCI_QUIRK(0x1043, 0x1883, "ASUS F81Se", ALC269_FIXUP_AMIC),
7626         SND_PCI_QUIRK(0x152d, 0x1778, "Quanta ON1", ALC269_FIXUP_DMIC),
7627         SND_PCI_QUIRK(0x17aa, 0x3be9, "Quanta Wistron", ALC269_FIXUP_AMIC),
7628         SND_PCI_QUIRK(0x17aa, 0x3bf8, "Quanta FL1", ALC269_FIXUP_AMIC),
7629         SND_PCI_QUIRK(0x17ff, 0x059a, "Quanta EL3", ALC269_FIXUP_DMIC),
7630         SND_PCI_QUIRK(0x17ff, 0x059b, "Quanta JR1", ALC269_FIXUP_DMIC),
7631 #endif
7632         {}
7633 };
7634
7635 static const struct snd_pci_quirk alc269_fixup_vendor_tbl[] = {
7636         SND_PCI_QUIRK_VENDOR(0x1025, "Acer Aspire", ALC271_FIXUP_DMIC),
7637         SND_PCI_QUIRK_VENDOR(0x103c, "HP", ALC269_FIXUP_HP_MUTE_LED),
7638         SND_PCI_QUIRK_VENDOR(0x104d, "Sony VAIO", ALC269_FIXUP_SONY_VAIO),
7639         SND_PCI_QUIRK_VENDOR(0x17aa, "Thinkpad", ALC269_FIXUP_THINKPAD_ACPI),
7640         SND_PCI_QUIRK_VENDOR(0x19e5, "Huawei Matebook", ALC255_FIXUP_MIC_MUTE_LED),
7641         {}
7642 };
7643
7644 static const struct hda_model_fixup alc269_fixup_models[] = {
7645         {.id = ALC269_FIXUP_AMIC, .name = "laptop-amic"},
7646         {.id = ALC269_FIXUP_DMIC, .name = "laptop-dmic"},
7647         {.id = ALC269_FIXUP_STEREO_DMIC, .name = "alc269-dmic"},
7648         {.id = ALC271_FIXUP_DMIC, .name = "alc271-dmic"},
7649         {.id = ALC269_FIXUP_INV_DMIC, .name = "inv-dmic"},
7650         {.id = ALC269_FIXUP_HEADSET_MIC, .name = "headset-mic"},
7651         {.id = ALC269_FIXUP_HEADSET_MODE, .name = "headset-mode"},
7652         {.id = ALC269_FIXUP_HEADSET_MODE_NO_HP_MIC, .name = "headset-mode-no-hp-mic"},
7653         {.id = ALC269_FIXUP_LENOVO_DOCK, .name = "lenovo-dock"},
7654         {.id = ALC269_FIXUP_LENOVO_DOCK_LIMIT_BOOST, .name = "lenovo-dock-limit-boost"},
7655         {.id = ALC269_FIXUP_HP_GPIO_LED, .name = "hp-gpio-led"},
7656         {.id = ALC269_FIXUP_HP_DOCK_GPIO_MIC1_LED, .name = "hp-dock-gpio-mic1-led"},
7657         {.id = ALC269_FIXUP_DELL1_MIC_NO_PRESENCE, .name = "dell-headset-multi"},
7658         {.id = ALC269_FIXUP_DELL2_MIC_NO_PRESENCE, .name = "dell-headset-dock"},
7659         {.id = ALC269_FIXUP_DELL3_MIC_NO_PRESENCE, .name = "dell-headset3"},
7660         {.id = ALC269_FIXUP_DELL4_MIC_NO_PRESENCE, .name = "dell-headset4"},
7661         {.id = ALC283_FIXUP_CHROME_BOOK, .name = "alc283-dac-wcaps"},
7662         {.id = ALC283_FIXUP_SENSE_COMBO_JACK, .name = "alc283-sense-combo"},
7663         {.id = ALC292_FIXUP_TPT440_DOCK, .name = "tpt440-dock"},
7664         {.id = ALC292_FIXUP_TPT440, .name = "tpt440"},
7665         {.id = ALC292_FIXUP_TPT460, .name = "tpt460"},
7666         {.id = ALC298_FIXUP_TPT470_DOCK_FIX, .name = "tpt470-dock-fix"},
7667         {.id = ALC298_FIXUP_TPT470_DOCK, .name = "tpt470-dock"},
7668         {.id = ALC233_FIXUP_LENOVO_MULTI_CODECS, .name = "dual-codecs"},
7669         {.id = ALC700_FIXUP_INTEL_REFERENCE, .name = "alc700-ref"},
7670         {.id = ALC269_FIXUP_SONY_VAIO, .name = "vaio"},
7671         {.id = ALC269_FIXUP_DELL_M101Z, .name = "dell-m101z"},
7672         {.id = ALC269_FIXUP_ASUS_G73JW, .name = "asus-g73jw"},
7673         {.id = ALC269_FIXUP_LENOVO_EAPD, .name = "lenovo-eapd"},
7674         {.id = ALC275_FIXUP_SONY_HWEQ, .name = "sony-hweq"},
7675         {.id = ALC269_FIXUP_PCM_44K, .name = "pcm44k"},
7676         {.id = ALC269_FIXUP_LIFEBOOK, .name = "lifebook"},
7677         {.id = ALC269_FIXUP_LIFEBOOK_EXTMIC, .name = "lifebook-extmic"},
7678         {.id = ALC269_FIXUP_LIFEBOOK_HP_PIN, .name = "lifebook-hp-pin"},
7679         {.id = ALC255_FIXUP_LIFEBOOK_U7x7_HEADSET_MIC, .name = "lifebook-u7x7"},
7680         {.id = ALC269VB_FIXUP_AMIC, .name = "alc269vb-amic"},
7681         {.id = ALC269VB_FIXUP_DMIC, .name = "alc269vb-dmic"},
7682         {.id = ALC269_FIXUP_HP_MUTE_LED_MIC1, .name = "hp-mute-led-mic1"},
7683         {.id = ALC269_FIXUP_HP_MUTE_LED_MIC2, .name = "hp-mute-led-mic2"},
7684         {.id = ALC269_FIXUP_HP_MUTE_LED_MIC3, .name = "hp-mute-led-mic3"},
7685         {.id = ALC269_FIXUP_HP_GPIO_MIC1_LED, .name = "hp-gpio-mic1"},
7686         {.id = ALC269_FIXUP_HP_LINE1_MIC1_LED, .name = "hp-line1-mic1"},
7687         {.id = ALC269_FIXUP_NO_SHUTUP, .name = "noshutup"},
7688         {.id = ALC286_FIXUP_SONY_MIC_NO_PRESENCE, .name = "sony-nomic"},
7689         {.id = ALC269_FIXUP_ASPIRE_HEADSET_MIC, .name = "aspire-headset-mic"},
7690         {.id = ALC269_FIXUP_ASUS_X101, .name = "asus-x101"},
7691         {.id = ALC271_FIXUP_HP_GATE_MIC_JACK, .name = "acer-ao7xx"},
7692         {.id = ALC271_FIXUP_HP_GATE_MIC_JACK_E1_572, .name = "acer-aspire-e1"},
7693         {.id = ALC269_FIXUP_ACER_AC700, .name = "acer-ac700"},
7694         {.id = ALC269_FIXUP_LIMIT_INT_MIC_BOOST, .name = "limit-mic-boost"},
7695         {.id = ALC269VB_FIXUP_ASUS_ZENBOOK, .name = "asus-zenbook"},
7696         {.id = ALC269VB_FIXUP_ASUS_ZENBOOK_UX31A, .name = "asus-zenbook-ux31a"},
7697         {.id = ALC269VB_FIXUP_ORDISSIMO_EVE2, .name = "ordissimo"},
7698         {.id = ALC282_FIXUP_ASUS_TX300, .name = "asus-tx300"},
7699         {.id = ALC283_FIXUP_INT_MIC, .name = "alc283-int-mic"},
7700         {.id = ALC290_FIXUP_MONO_SPEAKERS_HSJACK, .name = "mono-speakers"},
7701         {.id = ALC290_FIXUP_SUBWOOFER_HSJACK, .name = "alc290-subwoofer"},
7702         {.id = ALC269_FIXUP_THINKPAD_ACPI, .name = "thinkpad"},
7703         {.id = ALC269_FIXUP_DMIC_THINKPAD_ACPI, .name = "dmic-thinkpad"},
7704         {.id = ALC255_FIXUP_ACER_MIC_NO_PRESENCE, .name = "alc255-acer"},
7705         {.id = ALC255_FIXUP_ASUS_MIC_NO_PRESENCE, .name = "alc255-asus"},
7706         {.id = ALC255_FIXUP_DELL1_MIC_NO_PRESENCE, .name = "alc255-dell1"},
7707         {.id = ALC255_FIXUP_DELL2_MIC_NO_PRESENCE, .name = "alc255-dell2"},
7708         {.id = ALC293_FIXUP_DELL1_MIC_NO_PRESENCE, .name = "alc293-dell1"},
7709         {.id = ALC283_FIXUP_HEADSET_MIC, .name = "alc283-headset"},
7710         {.id = ALC255_FIXUP_MIC_MUTE_LED, .name = "alc255-dell-mute"},
7711         {.id = ALC282_FIXUP_ASPIRE_V5_PINS, .name = "aspire-v5"},
7712         {.id = ALC280_FIXUP_HP_GPIO4, .name = "hp-gpio4"},
7713         {.id = ALC286_FIXUP_HP_GPIO_LED, .name = "hp-gpio-led"},
7714         {.id = ALC280_FIXUP_HP_GPIO2_MIC_HOTKEY, .name = "hp-gpio2-hotkey"},
7715         {.id = ALC280_FIXUP_HP_DOCK_PINS, .name = "hp-dock-pins"},
7716         {.id = ALC269_FIXUP_HP_DOCK_GPIO_MIC1_LED, .name = "hp-dock-gpio-mic"},
7717         {.id = ALC280_FIXUP_HP_9480M, .name = "hp-9480m"},
7718         {.id = ALC288_FIXUP_DELL_HEADSET_MODE, .name = "alc288-dell-headset"},
7719         {.id = ALC288_FIXUP_DELL1_MIC_NO_PRESENCE, .name = "alc288-dell1"},
7720         {.id = ALC288_FIXUP_DELL_XPS_13, .name = "alc288-dell-xps13"},
7721         {.id = ALC292_FIXUP_DELL_E7X, .name = "dell-e7x"},
7722         {.id = ALC293_FIXUP_DISABLE_AAMIX_MULTIJACK, .name = "alc293-dell"},
7723         {.id = ALC298_FIXUP_DELL1_MIC_NO_PRESENCE, .name = "alc298-dell1"},
7724         {.id = ALC298_FIXUP_DELL_AIO_MIC_NO_PRESENCE, .name = "alc298-dell-aio"},
7725         {.id = ALC275_FIXUP_DELL_XPS, .name = "alc275-dell-xps"},
7726         {.id = ALC293_FIXUP_LENOVO_SPK_NOISE, .name = "lenovo-spk-noise"},
7727         {.id = ALC233_FIXUP_LENOVO_LINE2_MIC_HOTKEY, .name = "lenovo-hotkey"},
7728         {.id = ALC255_FIXUP_DELL_SPK_NOISE, .name = "dell-spk-noise"},
7729         {.id = ALC225_FIXUP_DELL1_MIC_NO_PRESENCE, .name = "alc225-dell1"},
7730         {.id = ALC295_FIXUP_DISABLE_DAC3, .name = "alc295-disable-dac3"},
7731         {.id = ALC285_FIXUP_SPEAKER2_TO_DAC1, .name = "alc285-speaker2-to-dac1"},
7732         {.id = ALC280_FIXUP_HP_HEADSET_MIC, .name = "alc280-hp-headset"},
7733         {.id = ALC221_FIXUP_HP_FRONT_MIC, .name = "alc221-hp-mic"},
7734         {.id = ALC298_FIXUP_SPK_VOLUME, .name = "alc298-spk-volume"},
7735         {.id = ALC256_FIXUP_DELL_INSPIRON_7559_SUBWOOFER, .name = "dell-inspiron-7559"},
7736         {.id = ALC269_FIXUP_ATIV_BOOK_8, .name = "ativ-book"},
7737         {.id = ALC221_FIXUP_HP_MIC_NO_PRESENCE, .name = "alc221-hp-mic"},
7738         {.id = ALC256_FIXUP_ASUS_HEADSET_MODE, .name = "alc256-asus-headset"},
7739         {.id = ALC256_FIXUP_ASUS_MIC, .name = "alc256-asus-mic"},
7740         {.id = ALC256_FIXUP_ASUS_AIO_GPIO2, .name = "alc256-asus-aio"},
7741         {.id = ALC233_FIXUP_ASUS_MIC_NO_PRESENCE, .name = "alc233-asus"},
7742         {.id = ALC233_FIXUP_EAPD_COEF_AND_MIC_NO_PRESENCE, .name = "alc233-eapd"},
7743         {.id = ALC294_FIXUP_LENOVO_MIC_LOCATION, .name = "alc294-lenovo-mic"},
7744         {.id = ALC225_FIXUP_DELL_WYSE_MIC_NO_PRESENCE, .name = "alc225-wyse"},
7745         {.id = ALC274_FIXUP_DELL_AIO_LINEOUT_VERB, .name = "alc274-dell-aio"},
7746         {.id = ALC255_FIXUP_DUMMY_LINEOUT_VERB, .name = "alc255-dummy-lineout"},
7747         {.id = ALC255_FIXUP_DELL_HEADSET_MIC, .name = "alc255-dell-headset"},
7748         {.id = ALC295_FIXUP_HP_X360, .name = "alc295-hp-x360"},
7749         {.id = ALC225_FIXUP_HEADSET_JACK, .name = "alc-headset-jack"},
7750         {.id = ALC295_FIXUP_CHROME_BOOK, .name = "alc-chrome-book"},
7751         {.id = ALC299_FIXUP_PREDATOR_SPK, .name = "predator-spk"},
7752         {.id = ALC298_FIXUP_HUAWEI_MBX_STEREO, .name = "huawei-mbx-stereo"},
7753         {.id = ALC256_FIXUP_MEDION_HEADSET_NO_PRESENCE, .name = "alc256-medion-headset"},
7754         {}
7755 };
7756 #define ALC225_STANDARD_PINS \
7757         {0x21, 0x04211020}
7758
7759 #define ALC256_STANDARD_PINS \
7760         {0x12, 0x90a60140}, \
7761         {0x14, 0x90170110}, \
7762         {0x21, 0x02211020}
7763
7764 #define ALC282_STANDARD_PINS \
7765         {0x14, 0x90170110}
7766
7767 #define ALC290_STANDARD_PINS \
7768         {0x12, 0x99a30130}
7769
7770 #define ALC292_STANDARD_PINS \
7771         {0x14, 0x90170110}, \
7772         {0x15, 0x0221401f}
7773
7774 #define ALC295_STANDARD_PINS \
7775         {0x12, 0xb7a60130}, \
7776         {0x14, 0x90170110}, \
7777         {0x21, 0x04211020}
7778
7779 #define ALC298_STANDARD_PINS \
7780         {0x12, 0x90a60130}, \
7781         {0x21, 0x03211020}
7782
7783 static const struct snd_hda_pin_quirk alc269_pin_fixup_tbl[] = {
7784         SND_HDA_PIN_QUIRK(0x10ec0221, 0x103c, "HP Workstation", ALC221_FIXUP_HP_HEADSET_MIC,
7785                 {0x14, 0x01014020},
7786                 {0x17, 0x90170110},
7787                 {0x18, 0x02a11030},
7788                 {0x19, 0x0181303F},
7789                 {0x21, 0x0221102f}),
7790         SND_HDA_PIN_QUIRK(0x10ec0255, 0x1025, "Acer", ALC255_FIXUP_ACER_MIC_NO_PRESENCE,
7791                 {0x12, 0x90a601c0},
7792                 {0x14, 0x90171120},
7793                 {0x21, 0x02211030}),
7794         SND_HDA_PIN_QUIRK(0x10ec0255, 0x1043, "ASUS", ALC255_FIXUP_ASUS_MIC_NO_PRESENCE,
7795                 {0x14, 0x90170110},
7796                 {0x1b, 0x90a70130},
7797                 {0x21, 0x03211020}),
7798         SND_HDA_PIN_QUIRK(0x10ec0255, 0x1043, "ASUS", ALC255_FIXUP_ASUS_MIC_NO_PRESENCE,
7799                 {0x1a, 0x90a70130},
7800                 {0x1b, 0x90170110},
7801                 {0x21, 0x03211020}),
7802         SND_HDA_PIN_QUIRK(0x10ec0225, 0x1028, "Dell", ALC225_FIXUP_DELL1_MIC_NO_PRESENCE,
7803                 ALC225_STANDARD_PINS,
7804                 {0x12, 0xb7a60130},
7805                 {0x14, 0x901701a0}),
7806         SND_HDA_PIN_QUIRK(0x10ec0225, 0x1028, "Dell", ALC225_FIXUP_DELL1_MIC_NO_PRESENCE,
7807                 ALC225_STANDARD_PINS,
7808                 {0x12, 0xb7a60130},
7809                 {0x14, 0x901701b0}),
7810         SND_HDA_PIN_QUIRK(0x10ec0225, 0x1028, "Dell", ALC225_FIXUP_DELL1_MIC_NO_PRESENCE,
7811                 ALC225_STANDARD_PINS,
7812                 {0x12, 0xb7a60150},
7813                 {0x14, 0x901701a0}),
7814         SND_HDA_PIN_QUIRK(0x10ec0225, 0x1028, "Dell", ALC225_FIXUP_DELL1_MIC_NO_PRESENCE,
7815                 ALC225_STANDARD_PINS,
7816                 {0x12, 0xb7a60150},
7817                 {0x14, 0x901701b0}),
7818         SND_HDA_PIN_QUIRK(0x10ec0225, 0x1028, "Dell", ALC225_FIXUP_DELL1_MIC_NO_PRESENCE,
7819                 ALC225_STANDARD_PINS,
7820                 {0x12, 0xb7a60130},
7821                 {0x1b, 0x90170110}),
7822         SND_HDA_PIN_QUIRK(0x10ec0233, 0x8086, "Intel NUC Skull Canyon", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE,
7823                 {0x1b, 0x01111010},
7824                 {0x1e, 0x01451130},
7825                 {0x21, 0x02211020}),
7826         SND_HDA_PIN_QUIRK(0x10ec0235, 0x17aa, "Lenovo", ALC233_FIXUP_LENOVO_LINE2_MIC_HOTKEY,
7827                 {0x12, 0x90a60140},
7828                 {0x14, 0x90170110},
7829                 {0x19, 0x02a11030},
7830                 {0x21, 0x02211020}),
7831         SND_HDA_PIN_QUIRK(0x10ec0235, 0x17aa, "Lenovo", ALC294_FIXUP_LENOVO_MIC_LOCATION,
7832                 {0x14, 0x90170110},
7833                 {0x19, 0x02a11030},
7834                 {0x1a, 0x02a11040},
7835                 {0x1b, 0x01014020},
7836                 {0x21, 0x0221101f}),
7837         SND_HDA_PIN_QUIRK(0x10ec0235, 0x17aa, "Lenovo", ALC294_FIXUP_LENOVO_MIC_LOCATION,
7838                 {0x14, 0x90170110},
7839                 {0x19, 0x02a11030},
7840                 {0x1a, 0x02a11040},
7841                 {0x1b, 0x01011020},
7842                 {0x21, 0x0221101f}),
7843         SND_HDA_PIN_QUIRK(0x10ec0235, 0x17aa, "Lenovo", ALC294_FIXUP_LENOVO_MIC_LOCATION,
7844                 {0x14, 0x90170110},
7845                 {0x19, 0x02a11020},
7846                 {0x1a, 0x02a11030},
7847                 {0x21, 0x0221101f}),
7848         SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL2_MIC_NO_PRESENCE,
7849                 {0x14, 0x90170110},
7850                 {0x21, 0x02211020}),
7851         SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
7852                 {0x14, 0x90170130},
7853                 {0x21, 0x02211040}),
7854         SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
7855                 {0x12, 0x90a60140},
7856                 {0x14, 0x90170110},
7857                 {0x21, 0x02211020}),
7858         SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
7859                 {0x12, 0x90a60160},
7860                 {0x14, 0x90170120},
7861                 {0x21, 0x02211030}),
7862         SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
7863                 {0x14, 0x90170110},
7864                 {0x1b, 0x02011020},
7865                 {0x21, 0x0221101f}),
7866         SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
7867                 {0x14, 0x90170110},
7868                 {0x1b, 0x01011020},
7869                 {0x21, 0x0221101f}),
7870         SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
7871                 {0x14, 0x90170130},
7872                 {0x1b, 0x01014020},
7873                 {0x21, 0x0221103f}),
7874         SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
7875                 {0x14, 0x90170130},
7876                 {0x1b, 0x01011020},
7877                 {0x21, 0x0221103f}),
7878         SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
7879                 {0x14, 0x90170130},
7880                 {0x1b, 0x02011020},
7881                 {0x21, 0x0221103f}),
7882         SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
7883                 {0x14, 0x90170150},
7884                 {0x1b, 0x02011020},
7885                 {0x21, 0x0221105f}),
7886         SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
7887                 {0x14, 0x90170110},
7888                 {0x1b, 0x01014020},
7889                 {0x21, 0x0221101f}),
7890         SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
7891                 {0x12, 0x90a60160},
7892                 {0x14, 0x90170120},
7893                 {0x17, 0x90170140},
7894                 {0x21, 0x0321102f}),
7895         SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
7896                 {0x12, 0x90a60160},
7897                 {0x14, 0x90170130},
7898                 {0x21, 0x02211040}),
7899         SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
7900                 {0x12, 0x90a60160},
7901                 {0x14, 0x90170140},
7902                 {0x21, 0x02211050}),
7903         SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
7904                 {0x12, 0x90a60170},
7905                 {0x14, 0x90170120},
7906                 {0x21, 0x02211030}),
7907         SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
7908                 {0x12, 0x90a60170},
7909                 {0x14, 0x90170130},
7910                 {0x21, 0x02211040}),
7911         SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
7912                 {0x12, 0x90a60170},
7913                 {0x14, 0x90171130},
7914                 {0x21, 0x02211040}),
7915         SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
7916                 {0x12, 0x90a60170},
7917                 {0x14, 0x90170140},
7918                 {0x21, 0x02211050}),
7919         SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell Inspiron 5548", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
7920                 {0x12, 0x90a60180},
7921                 {0x14, 0x90170130},
7922                 {0x21, 0x02211040}),
7923         SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell Inspiron 5565", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
7924                 {0x12, 0x90a60180},
7925                 {0x14, 0x90170120},
7926                 {0x21, 0x02211030}),
7927         SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
7928                 {0x1b, 0x01011020},
7929                 {0x21, 0x02211010}),
7930         SND_HDA_PIN_QUIRK(0x10ec0256, 0x1043, "ASUS", ALC256_FIXUP_ASUS_MIC,
7931                 {0x14, 0x90170110},
7932                 {0x1b, 0x90a70130},
7933                 {0x21, 0x04211020}),
7934         SND_HDA_PIN_QUIRK(0x10ec0256, 0x1043, "ASUS", ALC256_FIXUP_ASUS_MIC,
7935                 {0x14, 0x90170110},
7936                 {0x1b, 0x90a70130},
7937                 {0x21, 0x03211020}),
7938         SND_HDA_PIN_QUIRK(0x10ec0256, 0x1043, "ASUS", ALC256_FIXUP_ASUS_MIC_NO_PRESENCE,
7939                 {0x12, 0x90a60130},
7940                 {0x14, 0x90170110},
7941                 {0x21, 0x03211020}),
7942         SND_HDA_PIN_QUIRK(0x10ec0256, 0x1043, "ASUS", ALC256_FIXUP_ASUS_MIC_NO_PRESENCE,
7943                 {0x12, 0x90a60130},
7944                 {0x14, 0x90170110},
7945                 {0x21, 0x04211020}),
7946         SND_HDA_PIN_QUIRK(0x10ec0256, 0x1043, "ASUS", ALC256_FIXUP_ASUS_MIC_NO_PRESENCE,
7947                 {0x1a, 0x90a70130},
7948                 {0x1b, 0x90170110},
7949                 {0x21, 0x03211020}),
7950         SND_HDA_PIN_QUIRK(0x10ec0280, 0x103c, "HP", ALC280_FIXUP_HP_GPIO4,
7951                 {0x12, 0x90a60130},
7952                 {0x14, 0x90170110},
7953                 {0x15, 0x0421101f},
7954                 {0x1a, 0x04a11020}),
7955         SND_HDA_PIN_QUIRK(0x10ec0280, 0x103c, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED,
7956                 {0x12, 0x90a60140},
7957                 {0x14, 0x90170110},
7958                 {0x15, 0x0421101f},
7959                 {0x18, 0x02811030},
7960                 {0x1a, 0x04a1103f},
7961                 {0x1b, 0x02011020}),
7962         SND_HDA_PIN_QUIRK(0x10ec0282, 0x103c, "HP 15 Touchsmart", ALC269_FIXUP_HP_MUTE_LED_MIC1,
7963                 ALC282_STANDARD_PINS,
7964                 {0x12, 0x99a30130},
7965                 {0x19, 0x03a11020},
7966                 {0x21, 0x0321101f}),
7967         SND_HDA_PIN_QUIRK(0x10ec0282, 0x103c, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1,
7968                 ALC282_STANDARD_PINS,
7969                 {0x12, 0x99a30130},
7970                 {0x19, 0x03a11020},
7971                 {0x21, 0x03211040}),
7972         SND_HDA_PIN_QUIRK(0x10ec0282, 0x103c, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1,
7973                 ALC282_STANDARD_PINS,
7974                 {0x12, 0x99a30130},
7975                 {0x19, 0x03a11030},
7976                 {0x21, 0x03211020}),
7977         SND_HDA_PIN_QUIRK(0x10ec0282, 0x103c, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1,
7978                 ALC282_STANDARD_PINS,
7979                 {0x12, 0x99a30130},
7980                 {0x19, 0x04a11020},
7981                 {0x21, 0x0421101f}),
7982         SND_HDA_PIN_QUIRK(0x10ec0282, 0x103c, "HP", ALC269_FIXUP_HP_LINE1_MIC1_LED,
7983                 ALC282_STANDARD_PINS,
7984                 {0x12, 0x90a60140},
7985                 {0x19, 0x04a11030},
7986                 {0x21, 0x04211020}),
7987         SND_HDA_PIN_QUIRK(0x10ec0283, 0x1028, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE,
7988                 ALC282_STANDARD_PINS,
7989                 {0x12, 0x90a60130},
7990                 {0x21, 0x0321101f}),
7991         SND_HDA_PIN_QUIRK(0x10ec0283, 0x1028, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE,
7992                 {0x12, 0x90a60160},
7993                 {0x14, 0x90170120},
7994                 {0x21, 0x02211030}),
7995         SND_HDA_PIN_QUIRK(0x10ec0283, 0x1028, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE,
7996                 ALC282_STANDARD_PINS,
7997                 {0x12, 0x90a60130},
7998                 {0x19, 0x03a11020},
7999                 {0x21, 0x0321101f}),
8000         SND_HDA_PIN_QUIRK(0x10ec0285, 0x17aa, "Lenovo", ALC285_FIXUP_LENOVO_PC_BEEP_IN_NOISE,
8001                 {0x12, 0x90a60130},
8002                 {0x14, 0x90170110},
8003                 {0x19, 0x04a11040},
8004                 {0x21, 0x04211020}),
8005         SND_HDA_PIN_QUIRK(0x10ec0286, 0x1025, "Acer", ALC286_FIXUP_ACER_AIO_MIC_NO_PRESENCE,
8006                 {0x12, 0x90a60130},
8007                 {0x17, 0x90170110},
8008                 {0x21, 0x02211020}),
8009         SND_HDA_PIN_QUIRK(0x10ec0288, 0x1028, "Dell", ALC288_FIXUP_DELL1_MIC_NO_PRESENCE,
8010                 {0x12, 0x90a60120},
8011                 {0x14, 0x90170110},
8012                 {0x21, 0x0321101f}),
8013         SND_HDA_PIN_QUIRK(0x10ec0290, 0x103c, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1,
8014                 ALC290_STANDARD_PINS,
8015                 {0x15, 0x04211040},
8016                 {0x18, 0x90170112},
8017                 {0x1a, 0x04a11020}),
8018         SND_HDA_PIN_QUIRK(0x10ec0290, 0x103c, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1,
8019                 ALC290_STANDARD_PINS,
8020                 {0x15, 0x04211040},
8021                 {0x18, 0x90170110},
8022                 {0x1a, 0x04a11020}),
8023         SND_HDA_PIN_QUIRK(0x10ec0290, 0x103c, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1,
8024                 ALC290_STANDARD_PINS,
8025                 {0x15, 0x0421101f},
8026                 {0x1a, 0x04a11020}),
8027         SND_HDA_PIN_QUIRK(0x10ec0290, 0x103c, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1,
8028                 ALC290_STANDARD_PINS,
8029                 {0x15, 0x04211020},
8030                 {0x1a, 0x04a11040}),
8031         SND_HDA_PIN_QUIRK(0x10ec0290, 0x103c, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1,
8032                 ALC290_STANDARD_PINS,
8033                 {0x14, 0x90170110},
8034                 {0x15, 0x04211020},
8035                 {0x1a, 0x04a11040}),
8036         SND_HDA_PIN_QUIRK(0x10ec0290, 0x103c, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1,
8037                 ALC290_STANDARD_PINS,
8038                 {0x14, 0x90170110},
8039                 {0x15, 0x04211020},
8040                 {0x1a, 0x04a11020}),
8041         SND_HDA_PIN_QUIRK(0x10ec0290, 0x103c, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1,
8042                 ALC290_STANDARD_PINS,
8043                 {0x14, 0x90170110},
8044                 {0x15, 0x0421101f},
8045                 {0x1a, 0x04a11020}),
8046         SND_HDA_PIN_QUIRK(0x10ec0292, 0x1028, "Dell", ALC269_FIXUP_DELL2_MIC_NO_PRESENCE,
8047                 ALC292_STANDARD_PINS,
8048                 {0x12, 0x90a60140},
8049                 {0x16, 0x01014020},
8050                 {0x19, 0x01a19030}),
8051         SND_HDA_PIN_QUIRK(0x10ec0292, 0x1028, "Dell", ALC269_FIXUP_DELL2_MIC_NO_PRESENCE,
8052                 ALC292_STANDARD_PINS,
8053                 {0x12, 0x90a60140},
8054                 {0x16, 0x01014020},
8055                 {0x18, 0x02a19031},
8056                 {0x19, 0x01a1903e}),
8057         SND_HDA_PIN_QUIRK(0x10ec0292, 0x1028, "Dell", ALC269_FIXUP_DELL3_MIC_NO_PRESENCE,
8058                 ALC292_STANDARD_PINS,
8059                 {0x12, 0x90a60140}),
8060         SND_HDA_PIN_QUIRK(0x10ec0293, 0x1028, "Dell", ALC293_FIXUP_DELL1_MIC_NO_PRESENCE,
8061                 ALC292_STANDARD_PINS,
8062                 {0x13, 0x90a60140},
8063                 {0x16, 0x21014020},
8064                 {0x19, 0x21a19030}),
8065         SND_HDA_PIN_QUIRK(0x10ec0293, 0x1028, "Dell", ALC293_FIXUP_DELL1_MIC_NO_PRESENCE,
8066                 ALC292_STANDARD_PINS,
8067                 {0x13, 0x90a60140}),
8068         SND_HDA_PIN_QUIRK(0x10ec0294, 0x1043, "ASUS", ALC294_FIXUP_ASUS_MIC,
8069                 {0x14, 0x90170110},
8070                 {0x1b, 0x90a70130},
8071                 {0x21, 0x04211020}),
8072         SND_HDA_PIN_QUIRK(0x10ec0294, 0x1043, "ASUS", ALC294_FIXUP_ASUS_SPK,
8073                 {0x12, 0x90a60130},
8074                 {0x17, 0x90170110},
8075                 {0x21, 0x03211020}),
8076         SND_HDA_PIN_QUIRK(0x10ec0294, 0x1043, "ASUS", ALC294_FIXUP_ASUS_SPK,
8077                 {0x12, 0x90a60130},
8078                 {0x17, 0x90170110},
8079                 {0x21, 0x04211020}),
8080         SND_HDA_PIN_QUIRK(0x10ec0295, 0x1043, "ASUS", ALC294_FIXUP_ASUS_SPK,
8081                 {0x12, 0x90a60130},
8082                 {0x17, 0x90170110},
8083                 {0x21, 0x03211020}),
8084         SND_HDA_PIN_QUIRK(0x10ec0295, 0x1043, "ASUS", ALC295_FIXUP_ASUS_MIC_NO_PRESENCE,
8085                 {0x12, 0x90a60120},
8086                 {0x17, 0x90170110},
8087                 {0x21, 0x04211030}),
8088         SND_HDA_PIN_QUIRK(0x10ec0295, 0x1043, "ASUS", ALC295_FIXUP_ASUS_MIC_NO_PRESENCE,
8089                 {0x12, 0x90a60130},
8090                 {0x17, 0x90170110},
8091                 {0x21, 0x03211020}),
8092         SND_HDA_PIN_QUIRK(0x10ec0295, 0x1043, "ASUS", ALC295_FIXUP_ASUS_MIC_NO_PRESENCE,
8093                 {0x12, 0x90a60130},
8094                 {0x17, 0x90170110},
8095                 {0x21, 0x03211020}),
8096         SND_HDA_PIN_QUIRK(0x10ec0295, 0x1028, "Dell", ALC269_FIXUP_DELL4_MIC_NO_PRESENCE,
8097                 {0x14, 0x90170110},
8098                 {0x21, 0x04211020}),
8099         SND_HDA_PIN_QUIRK(0x10ec0295, 0x1028, "Dell", ALC269_FIXUP_DELL4_MIC_NO_PRESENCE,
8100                 {0x14, 0x90170110},
8101                 {0x21, 0x04211030}),
8102         SND_HDA_PIN_QUIRK(0x10ec0295, 0x1028, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE,
8103                 ALC295_STANDARD_PINS,
8104                 {0x17, 0x21014020},
8105                 {0x18, 0x21a19030}),
8106         SND_HDA_PIN_QUIRK(0x10ec0295, 0x1028, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE,
8107                 ALC295_STANDARD_PINS,
8108                 {0x17, 0x21014040},
8109                 {0x18, 0x21a19050}),
8110         SND_HDA_PIN_QUIRK(0x10ec0295, 0x1028, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE,
8111                 ALC295_STANDARD_PINS),
8112         SND_HDA_PIN_QUIRK(0x10ec0298, 0x1028, "Dell", ALC298_FIXUP_DELL1_MIC_NO_PRESENCE,
8113                 ALC298_STANDARD_PINS,
8114                 {0x17, 0x90170110}),
8115         SND_HDA_PIN_QUIRK(0x10ec0298, 0x1028, "Dell", ALC298_FIXUP_DELL1_MIC_NO_PRESENCE,
8116                 ALC298_STANDARD_PINS,
8117                 {0x17, 0x90170140}),
8118         SND_HDA_PIN_QUIRK(0x10ec0298, 0x1028, "Dell", ALC298_FIXUP_DELL1_MIC_NO_PRESENCE,
8119                 ALC298_STANDARD_PINS,
8120                 {0x17, 0x90170150}),
8121         SND_HDA_PIN_QUIRK(0x10ec0298, 0x1028, "Dell", ALC298_FIXUP_SPK_VOLUME,
8122                 {0x12, 0xb7a60140},
8123                 {0x13, 0xb7a60150},
8124                 {0x17, 0x90170110},
8125                 {0x1a, 0x03011020},
8126                 {0x21, 0x03211030}),
8127         SND_HDA_PIN_QUIRK(0x10ec0298, 0x1028, "Dell", ALC298_FIXUP_ALIENWARE_MIC_NO_PRESENCE,
8128                 {0x12, 0xb7a60140},
8129                 {0x17, 0x90170110},
8130                 {0x1a, 0x03a11030},
8131                 {0x21, 0x03211020}),
8132         SND_HDA_PIN_QUIRK(0x10ec0299, 0x1028, "Dell", ALC269_FIXUP_DELL4_MIC_NO_PRESENCE,
8133                 ALC225_STANDARD_PINS,
8134                 {0x12, 0xb7a60130},
8135                 {0x17, 0x90170110}),
8136         SND_HDA_PIN_QUIRK(0x10ec0623, 0x17aa, "Lenovo", ALC283_FIXUP_HEADSET_MIC,
8137                 {0x14, 0x01014010},
8138                 {0x17, 0x90170120},
8139                 {0x18, 0x02a11030},
8140                 {0x19, 0x02a1103f},
8141                 {0x21, 0x0221101f}),
8142         {}
8143 };
8144
8145 /* This is the fallback pin_fixup_tbl for alc269 family, to make the tbl match
8146  * more machines, don't need to match all valid pins, just need to match
8147  * all the pins defined in the tbl. Just because of this reason, it is possible
8148  * that a single machine matches multiple tbls, so there is one limitation:
8149  *   at most one tbl is allowed to define for the same vendor and same codec
8150  */
8151 static const struct snd_hda_pin_quirk alc269_fallback_pin_fixup_tbl[] = {
8152         SND_HDA_PIN_QUIRK(0x10ec0289, 0x1028, "Dell", ALC269_FIXUP_DELL4_MIC_NO_PRESENCE,
8153                 {0x19, 0x40000000},
8154                 {0x1b, 0x40000000}),
8155         SND_HDA_PIN_QUIRK(0x10ec0256, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
8156                 {0x19, 0x40000000},
8157                 {0x1a, 0x40000000}),
8158         SND_HDA_PIN_QUIRK(0x10ec0236, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
8159                 {0x19, 0x40000000},
8160                 {0x1a, 0x40000000}),
8161         SND_HDA_PIN_QUIRK(0x10ec0274, 0x1028, "Dell", ALC274_FIXUP_DELL_AIO_LINEOUT_VERB,
8162                 {0x19, 0x40000000},
8163                 {0x1a, 0x40000000}),
8164         {}
8165 };
8166
8167 static void alc269_fill_coef(struct hda_codec *codec)
8168 {
8169         struct alc_spec *spec = codec->spec;
8170         int val;
8171
8172         if (spec->codec_variant != ALC269_TYPE_ALC269VB)
8173                 return;
8174
8175         if ((alc_get_coef0(codec) & 0x00ff) < 0x015) {
8176                 alc_write_coef_idx(codec, 0xf, 0x960b);
8177                 alc_write_coef_idx(codec, 0xe, 0x8817);
8178         }
8179
8180         if ((alc_get_coef0(codec) & 0x00ff) == 0x016) {
8181                 alc_write_coef_idx(codec, 0xf, 0x960b);
8182                 alc_write_coef_idx(codec, 0xe, 0x8814);
8183         }
8184
8185         if ((alc_get_coef0(codec) & 0x00ff) == 0x017) {
8186                 /* Power up output pin */
8187                 alc_update_coef_idx(codec, 0x04, 0, 1<<11);
8188         }
8189
8190         if ((alc_get_coef0(codec) & 0x00ff) == 0x018) {
8191                 val = alc_read_coef_idx(codec, 0xd);
8192                 if (val != -1 && (val & 0x0c00) >> 10 != 0x1) {
8193                         /* Capless ramp up clock control */
8194                         alc_write_coef_idx(codec, 0xd, val | (1<<10));
8195                 }
8196                 val = alc_read_coef_idx(codec, 0x17);
8197                 if (val != -1 && (val & 0x01c0) >> 6 != 0x4) {
8198                         /* Class D power on reset */
8199                         alc_write_coef_idx(codec, 0x17, val | (1<<7));
8200                 }
8201         }
8202
8203         /* HP */
8204         alc_update_coef_idx(codec, 0x4, 0, 1<<11);
8205 }
8206
8207 /*
8208  */
8209 static int patch_alc269(struct hda_codec *codec)
8210 {
8211         struct alc_spec *spec;
8212         int err;
8213
8214         err = alc_alloc_spec(codec, 0x0b);
8215         if (err < 0)
8216                 return err;
8217
8218         spec = codec->spec;
8219         spec->gen.shared_mic_vref_pin = 0x18;
8220         codec->power_save_node = 0;
8221
8222 #ifdef CONFIG_PM
8223         codec->patch_ops.suspend = alc269_suspend;
8224         codec->patch_ops.resume = alc269_resume;
8225 #endif
8226         spec->shutup = alc_default_shutup;
8227         spec->init_hook = alc_default_init;
8228
8229         switch (codec->core.vendor_id) {
8230         case 0x10ec0269:
8231                 spec->codec_variant = ALC269_TYPE_ALC269VA;
8232                 switch (alc_get_coef0(codec) & 0x00f0) {
8233                 case 0x0010:
8234                         if (codec->bus->pci &&
8235                             codec->bus->pci->subsystem_vendor == 0x1025 &&
8236                             spec->cdefine.platform_type == 1)
8237                                 err = alc_codec_rename(codec, "ALC271X");
8238                         spec->codec_variant = ALC269_TYPE_ALC269VB;
8239                         break;
8240                 case 0x0020:
8241                         if (codec->bus->pci &&
8242                             codec->bus->pci->subsystem_vendor == 0x17aa &&
8243                             codec->bus->pci->subsystem_device == 0x21f3)
8244                                 err = alc_codec_rename(codec, "ALC3202");
8245                         spec->codec_variant = ALC269_TYPE_ALC269VC;
8246                         break;
8247                 case 0x0030:
8248                         spec->codec_variant = ALC269_TYPE_ALC269VD;
8249                         break;
8250                 default:
8251                         alc_fix_pll_init(codec, 0x20, 0x04, 15);
8252                 }
8253                 if (err < 0)
8254                         goto error;
8255                 spec->shutup = alc269_shutup;
8256                 spec->init_hook = alc269_fill_coef;
8257                 alc269_fill_coef(codec);
8258                 break;
8259
8260         case 0x10ec0280:
8261         case 0x10ec0290:
8262                 spec->codec_variant = ALC269_TYPE_ALC280;
8263                 break;
8264         case 0x10ec0282:
8265                 spec->codec_variant = ALC269_TYPE_ALC282;
8266                 spec->shutup = alc282_shutup;
8267                 spec->init_hook = alc282_init;
8268                 break;
8269         case 0x10ec0233:
8270         case 0x10ec0283:
8271                 spec->codec_variant = ALC269_TYPE_ALC283;
8272                 spec->shutup = alc283_shutup;
8273                 spec->init_hook = alc283_init;
8274                 break;
8275         case 0x10ec0284:
8276         case 0x10ec0292:
8277                 spec->codec_variant = ALC269_TYPE_ALC284;
8278                 break;
8279         case 0x10ec0293:
8280                 spec->codec_variant = ALC269_TYPE_ALC293;
8281                 break;
8282         case 0x10ec0286:
8283         case 0x10ec0288:
8284                 spec->codec_variant = ALC269_TYPE_ALC286;
8285                 break;
8286         case 0x10ec0298:
8287                 spec->codec_variant = ALC269_TYPE_ALC298;
8288                 break;
8289         case 0x10ec0235:
8290         case 0x10ec0255:
8291                 spec->codec_variant = ALC269_TYPE_ALC255;
8292                 spec->shutup = alc256_shutup;
8293                 spec->init_hook = alc256_init;
8294                 break;
8295         case 0x10ec0236:
8296         case 0x10ec0256:
8297                 spec->codec_variant = ALC269_TYPE_ALC256;
8298                 spec->shutup = alc256_shutup;
8299                 spec->init_hook = alc256_init;
8300                 spec->gen.mixer_nid = 0; /* ALC256 does not have any loopback mixer path */
8301                 break;
8302         case 0x10ec0257:
8303                 spec->codec_variant = ALC269_TYPE_ALC257;
8304                 spec->shutup = alc256_shutup;
8305                 spec->init_hook = alc256_init;
8306                 spec->gen.mixer_nid = 0;
8307                 break;
8308         case 0x10ec0215:
8309         case 0x10ec0245:
8310         case 0x10ec0285:
8311         case 0x10ec0287:
8312         case 0x10ec0289:
8313                 spec->codec_variant = ALC269_TYPE_ALC215;
8314                 spec->shutup = alc225_shutup;
8315                 spec->init_hook = alc225_init;
8316                 spec->gen.mixer_nid = 0;
8317                 break;
8318         case 0x10ec0225:
8319         case 0x10ec0295:
8320         case 0x10ec0299:
8321                 spec->codec_variant = ALC269_TYPE_ALC225;
8322                 spec->shutup = alc225_shutup;
8323                 spec->init_hook = alc225_init;
8324                 spec->gen.mixer_nid = 0; /* no loopback on ALC225, ALC295 and ALC299 */
8325                 break;
8326         case 0x10ec0234:
8327         case 0x10ec0274:
8328         case 0x10ec0294:
8329                 spec->codec_variant = ALC269_TYPE_ALC294;
8330                 spec->gen.mixer_nid = 0; /* ALC2x4 does not have any loopback mixer path */
8331                 alc_update_coef_idx(codec, 0x6b, 0x0018, (1<<4) | (1<<3)); /* UAJ MIC Vref control by verb */
8332                 spec->init_hook = alc294_init;
8333                 break;
8334         case 0x10ec0300:
8335                 spec->codec_variant = ALC269_TYPE_ALC300;
8336                 spec->gen.mixer_nid = 0; /* no loopback on ALC300 */
8337                 break;
8338         case 0x10ec0623:
8339                 spec->codec_variant = ALC269_TYPE_ALC623;
8340                 break;
8341         case 0x10ec0700:
8342         case 0x10ec0701:
8343         case 0x10ec0703:
8344         case 0x10ec0711:
8345                 spec->codec_variant = ALC269_TYPE_ALC700;
8346                 spec->gen.mixer_nid = 0; /* ALC700 does not have any loopback mixer path */
8347                 alc_update_coef_idx(codec, 0x4a, 1 << 15, 0); /* Combo jack auto trigger control */
8348                 spec->init_hook = alc294_init;
8349                 break;
8350
8351         }
8352
8353         if (snd_hda_codec_read(codec, 0x51, 0, AC_VERB_PARAMETERS, 0) == 0x10ec5505) {
8354                 spec->has_alc5505_dsp = 1;
8355                 spec->init_hook = alc5505_dsp_init;
8356         }
8357
8358         alc_pre_init(codec);
8359
8360         snd_hda_pick_fixup(codec, alc269_fixup_models,
8361                        alc269_fixup_tbl, alc269_fixups);
8362         snd_hda_pick_pin_fixup(codec, alc269_pin_fixup_tbl, alc269_fixups, true);
8363         snd_hda_pick_pin_fixup(codec, alc269_fallback_pin_fixup_tbl, alc269_fixups, false);
8364         snd_hda_pick_fixup(codec, NULL, alc269_fixup_vendor_tbl,
8365                            alc269_fixups);
8366         snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE);
8367
8368         alc_auto_parse_customize_define(codec);
8369
8370         if (has_cdefine_beep(codec))
8371                 spec->gen.beep_nid = 0x01;
8372
8373         /* automatic parse from the BIOS config */
8374         err = alc269_parse_auto_config(codec);
8375         if (err < 0)
8376                 goto error;
8377
8378         if (!spec->gen.no_analog && spec->gen.beep_nid && spec->gen.mixer_nid) {
8379                 err = set_beep_amp(spec, spec->gen.mixer_nid, 0x04, HDA_INPUT);
8380                 if (err < 0)
8381                         goto error;
8382         }
8383
8384         snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE);
8385
8386         return 0;
8387
8388  error:
8389         alc_free(codec);
8390         return err;
8391 }
8392
8393 /*
8394  * ALC861
8395  */
8396
8397 static int alc861_parse_auto_config(struct hda_codec *codec)
8398 {
8399         static const hda_nid_t alc861_ignore[] = { 0x1d, 0 };
8400         static const hda_nid_t alc861_ssids[] = { 0x0e, 0x0f, 0x0b, 0 };
8401         return alc_parse_auto_config(codec, alc861_ignore, alc861_ssids);
8402 }
8403
8404 /* Pin config fixes */
8405 enum {
8406         ALC861_FIXUP_FSC_AMILO_PI1505,
8407         ALC861_FIXUP_AMP_VREF_0F,
8408         ALC861_FIXUP_NO_JACK_DETECT,
8409         ALC861_FIXUP_ASUS_A6RP,
8410         ALC660_FIXUP_ASUS_W7J,
8411 };
8412
8413 /* On some laptops, VREF of pin 0x0f is abused for controlling the main amp */
8414 static void alc861_fixup_asus_amp_vref_0f(struct hda_codec *codec,
8415                         const struct hda_fixup *fix, int action)
8416 {
8417         struct alc_spec *spec = codec->spec;
8418         unsigned int val;
8419
8420         if (action != HDA_FIXUP_ACT_INIT)
8421                 return;
8422         val = snd_hda_codec_get_pin_target(codec, 0x0f);
8423         if (!(val & (AC_PINCTL_IN_EN | AC_PINCTL_OUT_EN)))
8424                 val |= AC_PINCTL_IN_EN;
8425         val |= AC_PINCTL_VREF_50;
8426         snd_hda_set_pin_ctl(codec, 0x0f, val);
8427         spec->gen.keep_vref_in_automute = 1;
8428 }
8429
8430 /* suppress the jack-detection */
8431 static void alc_fixup_no_jack_detect(struct hda_codec *codec,
8432                                      const struct hda_fixup *fix, int action)
8433 {
8434         if (action == HDA_FIXUP_ACT_PRE_PROBE)
8435                 codec->no_jack_detect = 1;
8436 }
8437
8438 static const struct hda_fixup alc861_fixups[] = {
8439         [ALC861_FIXUP_FSC_AMILO_PI1505] = {
8440                 .type = HDA_FIXUP_PINS,
8441                 .v.pins = (const struct hda_pintbl[]) {
8442                         { 0x0b, 0x0221101f }, /* HP */
8443                         { 0x0f, 0x90170310 }, /* speaker */
8444                         { }
8445                 }
8446         },
8447         [ALC861_FIXUP_AMP_VREF_0F] = {
8448                 .type = HDA_FIXUP_FUNC,
8449                 .v.func = alc861_fixup_asus_amp_vref_0f,
8450         },
8451         [ALC861_FIXUP_NO_JACK_DETECT] = {
8452                 .type = HDA_FIXUP_FUNC,
8453                 .v.func = alc_fixup_no_jack_detect,
8454         },
8455         [ALC861_FIXUP_ASUS_A6RP] = {
8456                 .type = HDA_FIXUP_FUNC,
8457                 .v.func = alc861_fixup_asus_amp_vref_0f,
8458                 .chained = true,
8459                 .chain_id = ALC861_FIXUP_NO_JACK_DETECT,
8460         },
8461         [ALC660_FIXUP_ASUS_W7J] = {
8462                 .type = HDA_FIXUP_VERBS,
8463                 .v.verbs = (const struct hda_verb[]) {
8464                         /* ASUS W7J needs a magic pin setup on unused NID 0x10
8465                          * for enabling outputs
8466                          */
8467                         {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
8468                         { }
8469                 },
8470         }
8471 };
8472
8473 static const struct snd_pci_quirk alc861_fixup_tbl[] = {
8474         SND_PCI_QUIRK(0x1043, 0x1253, "ASUS W7J", ALC660_FIXUP_ASUS_W7J),
8475         SND_PCI_QUIRK(0x1043, 0x1263, "ASUS Z35HL", ALC660_FIXUP_ASUS_W7J),
8476         SND_PCI_QUIRK(0x1043, 0x1393, "ASUS A6Rp", ALC861_FIXUP_ASUS_A6RP),
8477         SND_PCI_QUIRK_VENDOR(0x1043, "ASUS laptop", ALC861_FIXUP_AMP_VREF_0F),
8478         SND_PCI_QUIRK(0x1462, 0x7254, "HP DX2200", ALC861_FIXUP_NO_JACK_DETECT),
8479         SND_PCI_QUIRK(0x1584, 0x2b01, "Haier W18", ALC861_FIXUP_AMP_VREF_0F),
8480         SND_PCI_QUIRK(0x1584, 0x0000, "Uniwill ECS M31EI", ALC861_FIXUP_AMP_VREF_0F),
8481         SND_PCI_QUIRK(0x1734, 0x10c7, "FSC Amilo Pi1505", ALC861_FIXUP_FSC_AMILO_PI1505),
8482         {}
8483 };
8484
8485 /*
8486  */
8487 static int patch_alc861(struct hda_codec *codec)
8488 {
8489         struct alc_spec *spec;
8490         int err;
8491
8492         err = alc_alloc_spec(codec, 0x15);
8493         if (err < 0)
8494                 return err;
8495
8496         spec = codec->spec;
8497         if (has_cdefine_beep(codec))
8498                 spec->gen.beep_nid = 0x23;
8499
8500 #ifdef CONFIG_PM
8501         spec->power_hook = alc_power_eapd;
8502 #endif
8503
8504         alc_pre_init(codec);
8505
8506         snd_hda_pick_fixup(codec, NULL, alc861_fixup_tbl, alc861_fixups);
8507         snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE);
8508
8509         /* automatic parse from the BIOS config */
8510         err = alc861_parse_auto_config(codec);
8511         if (err < 0)
8512                 goto error;
8513
8514         if (!spec->gen.no_analog) {
8515                 err = set_beep_amp(spec, 0x23, 0, HDA_OUTPUT);
8516                 if (err < 0)
8517                         goto error;
8518         }
8519
8520         snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE);
8521
8522         return 0;
8523
8524  error:
8525         alc_free(codec);
8526         return err;
8527 }
8528
8529 /*
8530  * ALC861-VD support
8531  *
8532  * Based on ALC882
8533  *
8534  * In addition, an independent DAC
8535  */
8536 static int alc861vd_parse_auto_config(struct hda_codec *codec)
8537 {
8538         static const hda_nid_t alc861vd_ignore[] = { 0x1d, 0 };
8539         static const hda_nid_t alc861vd_ssids[] = { 0x15, 0x1b, 0x14, 0 };
8540         return alc_parse_auto_config(codec, alc861vd_ignore, alc861vd_ssids);
8541 }
8542
8543 enum {
8544         ALC660VD_FIX_ASUS_GPIO1,
8545         ALC861VD_FIX_DALLAS,
8546 };
8547
8548 /* exclude VREF80 */
8549 static void alc861vd_fixup_dallas(struct hda_codec *codec,
8550                                   const struct hda_fixup *fix, int action)
8551 {
8552         if (action == HDA_FIXUP_ACT_PRE_PROBE) {
8553                 snd_hda_override_pin_caps(codec, 0x18, 0x00000734);
8554                 snd_hda_override_pin_caps(codec, 0x19, 0x0000073c);
8555         }
8556 }
8557
8558 /* reset GPIO1 */
8559 static void alc660vd_fixup_asus_gpio1(struct hda_codec *codec,
8560                                       const struct hda_fixup *fix, int action)
8561 {
8562         struct alc_spec *spec = codec->spec;
8563
8564         if (action == HDA_FIXUP_ACT_PRE_PROBE)
8565                 spec->gpio_mask |= 0x02;
8566         alc_fixup_gpio(codec, action, 0x01);
8567 }
8568
8569 static const struct hda_fixup alc861vd_fixups[] = {
8570         [ALC660VD_FIX_ASUS_GPIO1] = {
8571                 .type = HDA_FIXUP_FUNC,
8572                 .v.func = alc660vd_fixup_asus_gpio1,
8573         },
8574         [ALC861VD_FIX_DALLAS] = {
8575                 .type = HDA_FIXUP_FUNC,
8576                 .v.func = alc861vd_fixup_dallas,
8577         },
8578 };
8579
8580 static const struct snd_pci_quirk alc861vd_fixup_tbl[] = {
8581         SND_PCI_QUIRK(0x103c, 0x30bf, "HP TX1000", ALC861VD_FIX_DALLAS),
8582         SND_PCI_QUIRK(0x1043, 0x1339, "ASUS A7-K", ALC660VD_FIX_ASUS_GPIO1),
8583         SND_PCI_QUIRK(0x1179, 0xff31, "Toshiba L30-149", ALC861VD_FIX_DALLAS),
8584         {}
8585 };
8586
8587 /*
8588  */
8589 static int patch_alc861vd(struct hda_codec *codec)
8590 {
8591         struct alc_spec *spec;
8592         int err;
8593
8594         err = alc_alloc_spec(codec, 0x0b);
8595         if (err < 0)
8596                 return err;
8597
8598         spec = codec->spec;
8599         if (has_cdefine_beep(codec))
8600                 spec->gen.beep_nid = 0x23;
8601
8602         spec->shutup = alc_eapd_shutup;
8603
8604         alc_pre_init(codec);
8605
8606         snd_hda_pick_fixup(codec, NULL, alc861vd_fixup_tbl, alc861vd_fixups);
8607         snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE);
8608
8609         /* automatic parse from the BIOS config */
8610         err = alc861vd_parse_auto_config(codec);
8611         if (err < 0)
8612                 goto error;
8613
8614         if (!spec->gen.no_analog) {
8615                 err = set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
8616                 if (err < 0)
8617                         goto error;
8618         }
8619
8620         snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE);
8621
8622         return 0;
8623
8624  error:
8625         alc_free(codec);
8626         return err;
8627 }
8628
8629 /*
8630  * ALC662 support
8631  *
8632  * ALC662 is almost identical with ALC880 but has cleaner and more flexible
8633  * configuration.  Each pin widget can choose any input DACs and a mixer.
8634  * Each ADC is connected from a mixer of all inputs.  This makes possible
8635  * 6-channel independent captures.
8636  *
8637  * In addition, an independent DAC for the multi-playback (not used in this
8638  * driver yet).
8639  */
8640
8641 /*
8642  * BIOS auto configuration
8643  */
8644
8645 static int alc662_parse_auto_config(struct hda_codec *codec)
8646 {
8647         static const hda_nid_t alc662_ignore[] = { 0x1d, 0 };
8648         static const hda_nid_t alc663_ssids[] = { 0x15, 0x1b, 0x14, 0x21 };
8649         static const hda_nid_t alc662_ssids[] = { 0x15, 0x1b, 0x14, 0 };
8650         const hda_nid_t *ssids;
8651
8652         if (codec->core.vendor_id == 0x10ec0272 || codec->core.vendor_id == 0x10ec0663 ||
8653             codec->core.vendor_id == 0x10ec0665 || codec->core.vendor_id == 0x10ec0670 ||
8654             codec->core.vendor_id == 0x10ec0671)
8655                 ssids = alc663_ssids;
8656         else
8657                 ssids = alc662_ssids;
8658         return alc_parse_auto_config(codec, alc662_ignore, ssids);
8659 }
8660
8661 static void alc272_fixup_mario(struct hda_codec *codec,
8662                                const struct hda_fixup *fix, int action)
8663 {
8664         if (action != HDA_FIXUP_ACT_PRE_PROBE)
8665                 return;
8666         if (snd_hda_override_amp_caps(codec, 0x2, HDA_OUTPUT,
8667                                       (0x3b << AC_AMPCAP_OFFSET_SHIFT) |
8668                                       (0x3b << AC_AMPCAP_NUM_STEPS_SHIFT) |
8669                                       (0x03 << AC_AMPCAP_STEP_SIZE_SHIFT) |
8670                                       (0 << AC_AMPCAP_MUTE_SHIFT)))
8671                 codec_warn(codec, "failed to override amp caps for NID 0x2\n");
8672 }
8673
8674 static const struct snd_pcm_chmap_elem asus_pcm_2_1_chmaps[] = {
8675         { .channels = 2,
8676           .map = { SNDRV_CHMAP_FL, SNDRV_CHMAP_FR } },
8677         { .channels = 4,
8678           .map = { SNDRV_CHMAP_FL, SNDRV_CHMAP_FR,
8679                    SNDRV_CHMAP_NA, SNDRV_CHMAP_LFE } }, /* LFE only on right */
8680         { }
8681 };
8682
8683 /* override the 2.1 chmap */
8684 static void alc_fixup_bass_chmap(struct hda_codec *codec,
8685                                     const struct hda_fixup *fix, int action)
8686 {
8687         if (action == HDA_FIXUP_ACT_BUILD) {
8688                 struct alc_spec *spec = codec->spec;
8689                 spec->gen.pcm_rec[0]->stream[0].chmap = asus_pcm_2_1_chmaps;
8690         }
8691 }
8692
8693 /* avoid D3 for keeping GPIO up */
8694 static unsigned int gpio_led_power_filter(struct hda_codec *codec,
8695                                           hda_nid_t nid,
8696                                           unsigned int power_state)
8697 {
8698         struct alc_spec *spec = codec->spec;
8699         if (nid == codec->core.afg && power_state == AC_PWRST_D3 && spec->gpio_data)
8700                 return AC_PWRST_D0;
8701         return power_state;
8702 }
8703
8704 static void alc662_fixup_led_gpio1(struct hda_codec *codec,
8705                                    const struct hda_fixup *fix, int action)
8706 {
8707         struct alc_spec *spec = codec->spec;
8708
8709         alc_fixup_hp_gpio_led(codec, action, 0x01, 0);
8710         if (action == HDA_FIXUP_ACT_PRE_PROBE) {
8711                 spec->mute_led_polarity = 1;
8712                 codec->power_filter = gpio_led_power_filter;
8713         }
8714 }
8715
8716 static void alc662_usi_automute_hook(struct hda_codec *codec,
8717                                          struct hda_jack_callback *jack)
8718 {
8719         struct alc_spec *spec = codec->spec;
8720         int vref;
8721         msleep(200);
8722         snd_hda_gen_hp_automute(codec, jack);
8723
8724         vref = spec->gen.hp_jack_present ? PIN_VREF80 : 0;
8725         msleep(100);
8726         snd_hda_codec_write(codec, 0x19, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
8727                             vref);
8728 }
8729
8730 static void alc662_fixup_usi_headset_mic(struct hda_codec *codec,
8731                                      const struct hda_fixup *fix, int action)
8732 {
8733         struct alc_spec *spec = codec->spec;
8734         if (action == HDA_FIXUP_ACT_PRE_PROBE) {
8735                 spec->parse_flags |= HDA_PINCFG_HEADSET_MIC;
8736                 spec->gen.hp_automute_hook = alc662_usi_automute_hook;
8737         }
8738 }
8739
8740 static void alc662_aspire_ethos_mute_speakers(struct hda_codec *codec,
8741                                         struct hda_jack_callback *cb)
8742 {
8743         /* surround speakers at 0x1b already get muted automatically when
8744          * headphones are plugged in, but we have to mute/unmute the remaining
8745          * channels manually:
8746          * 0x15 - front left/front right
8747          * 0x18 - front center/ LFE
8748          */
8749         if (snd_hda_jack_detect_state(codec, 0x1b) == HDA_JACK_PRESENT) {
8750                 snd_hda_set_pin_ctl_cache(codec, 0x15, 0);
8751                 snd_hda_set_pin_ctl_cache(codec, 0x18, 0);
8752         } else {
8753                 snd_hda_set_pin_ctl_cache(codec, 0x15, PIN_OUT);
8754                 snd_hda_set_pin_ctl_cache(codec, 0x18, PIN_OUT);
8755         }
8756 }
8757
8758 static void alc662_fixup_aspire_ethos_hp(struct hda_codec *codec,
8759                                         const struct hda_fixup *fix, int action)
8760 {
8761     /* Pin 0x1b: shared headphones jack and surround speakers */
8762         if (!is_jack_detectable(codec, 0x1b))
8763                 return;
8764
8765         switch (action) {
8766         case HDA_FIXUP_ACT_PRE_PROBE:
8767                 snd_hda_jack_detect_enable_callback(codec, 0x1b,
8768                                 alc662_aspire_ethos_mute_speakers);
8769                 /* subwoofer needs an extra GPIO setting to become audible */
8770                 alc_setup_gpio(codec, 0x02);
8771                 break;
8772         case HDA_FIXUP_ACT_INIT:
8773                 /* Make sure to start in a correct state, i.e. if
8774                  * headphones have been plugged in before powering up the system
8775                  */
8776                 alc662_aspire_ethos_mute_speakers(codec, NULL);
8777                 break;
8778         }
8779 }
8780
8781 static void alc671_fixup_hp_headset_mic2(struct hda_codec *codec,
8782                                              const struct hda_fixup *fix, int action)
8783 {
8784         struct alc_spec *spec = codec->spec;
8785
8786         static const struct hda_pintbl pincfgs[] = {
8787                 { 0x19, 0x02a11040 }, /* use as headset mic, with its own jack detect */
8788                 { 0x1b, 0x0181304f },
8789                 { }
8790         };
8791
8792         switch (action) {
8793         case HDA_FIXUP_ACT_PRE_PROBE:
8794                 spec->gen.mixer_nid = 0;
8795                 spec->parse_flags |= HDA_PINCFG_HEADSET_MIC;
8796                 snd_hda_apply_pincfgs(codec, pincfgs);
8797                 break;
8798         case HDA_FIXUP_ACT_INIT:
8799                 alc_write_coef_idx(codec, 0x19, 0xa054);
8800                 break;
8801         }
8802 }
8803
8804 static const struct coef_fw alc668_coefs[] = {
8805         WRITE_COEF(0x01, 0xbebe), WRITE_COEF(0x02, 0xaaaa), WRITE_COEF(0x03,    0x0),
8806         WRITE_COEF(0x04, 0x0180), WRITE_COEF(0x06,    0x0), WRITE_COEF(0x07, 0x0f80),
8807         WRITE_COEF(0x08, 0x0031), WRITE_COEF(0x0a, 0x0060), WRITE_COEF(0x0b,    0x0),
8808         WRITE_COEF(0x0c, 0x7cf7), WRITE_COEF(0x0d, 0x1080), WRITE_COEF(0x0e, 0x7f7f),
8809         WRITE_COEF(0x0f, 0xcccc), WRITE_COEF(0x10, 0xddcc), WRITE_COEF(0x11, 0x0001),
8810         WRITE_COEF(0x13,    0x0), WRITE_COEF(0x14, 0x2aa0), WRITE_COEF(0x17, 0xa940),
8811         WRITE_COEF(0x19,    0x0), WRITE_COEF(0x1a,    0x0), WRITE_COEF(0x1b,    0x0),
8812         WRITE_COEF(0x1c,    0x0), WRITE_COEF(0x1d,    0x0), WRITE_COEF(0x1e, 0x7418),
8813         WRITE_COEF(0x1f, 0x0804), WRITE_COEF(0x20, 0x4200), WRITE_COEF(0x21, 0x0468),
8814         WRITE_COEF(0x22, 0x8ccc), WRITE_COEF(0x23, 0x0250), WRITE_COEF(0x24, 0x7418),
8815         WRITE_COEF(0x27,    0x0), WRITE_COEF(0x28, 0x8ccc), WRITE_COEF(0x2a, 0xff00),
8816         WRITE_COEF(0x2b, 0x8000), WRITE_COEF(0xa7, 0xff00), WRITE_COEF(0xa8, 0x8000),
8817         WRITE_COEF(0xaa, 0x2e17), WRITE_COEF(0xab, 0xa0c0), WRITE_COEF(0xac,    0x0),
8818         WRITE_COEF(0xad,    0x0), WRITE_COEF(0xae, 0x2ac6), WRITE_COEF(0xaf, 0xa480),
8819         WRITE_COEF(0xb0,    0x0), WRITE_COEF(0xb1,    0x0), WRITE_COEF(0xb2,    0x0),
8820         WRITE_COEF(0xb3,    0x0), WRITE_COEF(0xb4,    0x0), WRITE_COEF(0xb5, 0x1040),
8821         WRITE_COEF(0xb6, 0xd697), WRITE_COEF(0xb7, 0x902b), WRITE_COEF(0xb8, 0xd697),
8822         WRITE_COEF(0xb9, 0x902b), WRITE_COEF(0xba, 0xb8ba), WRITE_COEF(0xbb, 0xaaab),
8823         WRITE_COEF(0xbc, 0xaaaf), WRITE_COEF(0xbd, 0x6aaa), WRITE_COEF(0xbe, 0x1c02),
8824         WRITE_COEF(0xc0, 0x00ff), WRITE_COEF(0xc1, 0x0fa6),
8825         {}
8826 };
8827
8828 static void alc668_restore_default_value(struct hda_codec *codec)
8829 {
8830         alc_process_coef_fw(codec, alc668_coefs);
8831 }
8832
8833 enum {
8834         ALC662_FIXUP_ASPIRE,
8835         ALC662_FIXUP_LED_GPIO1,
8836         ALC662_FIXUP_IDEAPAD,
8837         ALC272_FIXUP_MARIO,
8838         ALC662_FIXUP_CZC_P10T,
8839         ALC662_FIXUP_SKU_IGNORE,
8840         ALC662_FIXUP_HP_RP5800,
8841         ALC662_FIXUP_ASUS_MODE1,
8842         ALC662_FIXUP_ASUS_MODE2,
8843         ALC662_FIXUP_ASUS_MODE3,
8844         ALC662_FIXUP_ASUS_MODE4,
8845         ALC662_FIXUP_ASUS_MODE5,
8846         ALC662_FIXUP_ASUS_MODE6,
8847         ALC662_FIXUP_ASUS_MODE7,
8848         ALC662_FIXUP_ASUS_MODE8,
8849         ALC662_FIXUP_NO_JACK_DETECT,
8850         ALC662_FIXUP_ZOTAC_Z68,
8851         ALC662_FIXUP_INV_DMIC,
8852         ALC662_FIXUP_DELL_MIC_NO_PRESENCE,
8853         ALC668_FIXUP_DELL_MIC_NO_PRESENCE,
8854         ALC662_FIXUP_HEADSET_MODE,
8855         ALC668_FIXUP_HEADSET_MODE,
8856         ALC662_FIXUP_BASS_MODE4_CHMAP,
8857         ALC662_FIXUP_BASS_16,
8858         ALC662_FIXUP_BASS_1A,
8859         ALC662_FIXUP_BASS_CHMAP,
8860         ALC668_FIXUP_AUTO_MUTE,
8861         ALC668_FIXUP_DELL_DISABLE_AAMIX,
8862         ALC668_FIXUP_DELL_XPS13,
8863         ALC662_FIXUP_ASUS_Nx50,
8864         ALC668_FIXUP_ASUS_Nx51_HEADSET_MODE,
8865         ALC668_FIXUP_ASUS_Nx51,
8866         ALC668_FIXUP_MIC_COEF,
8867         ALC668_FIXUP_ASUS_G751,
8868         ALC891_FIXUP_HEADSET_MODE,
8869         ALC891_FIXUP_DELL_MIC_NO_PRESENCE,
8870         ALC662_FIXUP_ACER_VERITON,
8871         ALC892_FIXUP_ASROCK_MOBO,
8872         ALC662_FIXUP_USI_FUNC,
8873         ALC662_FIXUP_USI_HEADSET_MODE,
8874         ALC662_FIXUP_LENOVO_MULTI_CODECS,
8875         ALC669_FIXUP_ACER_ASPIRE_ETHOS,
8876         ALC669_FIXUP_ACER_ASPIRE_ETHOS_HEADSET,
8877         ALC671_FIXUP_HP_HEADSET_MIC2,
8878         ALC662_FIXUP_ACER_X2660G_HEADSET_MODE,
8879         ALC662_FIXUP_ACER_NITRO_HEADSET_MODE,
8880 };
8881
8882 static const struct hda_fixup alc662_fixups[] = {
8883         [ALC662_FIXUP_ASPIRE] = {
8884                 .type = HDA_FIXUP_PINS,
8885                 .v.pins = (const struct hda_pintbl[]) {
8886                         { 0x15, 0x99130112 }, /* subwoofer */
8887                         { }
8888                 }
8889         },
8890         [ALC662_FIXUP_LED_GPIO1] = {
8891                 .type = HDA_FIXUP_FUNC,
8892                 .v.func = alc662_fixup_led_gpio1,
8893         },
8894         [ALC662_FIXUP_IDEAPAD] = {
8895                 .type = HDA_FIXUP_PINS,
8896                 .v.pins = (const struct hda_pintbl[]) {
8897                         { 0x17, 0x99130112 }, /* subwoofer */
8898                         { }
8899                 },
8900                 .chained = true,
8901                 .chain_id = ALC662_FIXUP_LED_GPIO1,
8902         },
8903         [ALC272_FIXUP_MARIO] = {
8904                 .type = HDA_FIXUP_FUNC,
8905                 .v.func = alc272_fixup_mario,
8906         },
8907         [ALC662_FIXUP_CZC_P10T] = {
8908                 .type = HDA_FIXUP_VERBS,
8909                 .v.verbs = (const struct hda_verb[]) {
8910                         {0x14, AC_VERB_SET_EAPD_BTLENABLE, 0},
8911                         {}
8912                 }
8913         },
8914         [ALC662_FIXUP_SKU_IGNORE] = {
8915                 .type = HDA_FIXUP_FUNC,
8916                 .v.func = alc_fixup_sku_ignore,
8917         },
8918         [ALC662_FIXUP_HP_RP5800] = {
8919                 .type = HDA_FIXUP_PINS,
8920                 .v.pins = (const struct hda_pintbl[]) {
8921                         { 0x14, 0x0221201f }, /* HP out */
8922                         { }
8923                 },
8924                 .chained = true,
8925                 .chain_id = ALC662_FIXUP_SKU_IGNORE
8926         },
8927         [ALC662_FIXUP_ASUS_MODE1] = {
8928                 .type = HDA_FIXUP_PINS,
8929                 .v.pins = (const struct hda_pintbl[]) {
8930                         { 0x14, 0x99130110 }, /* speaker */
8931                         { 0x18, 0x01a19c20 }, /* mic */
8932                         { 0x19, 0x99a3092f }, /* int-mic */
8933                         { 0x21, 0x0121401f }, /* HP out */
8934                         { }
8935                 },
8936                 .chained = true,
8937                 .chain_id = ALC662_FIXUP_SKU_IGNORE
8938         },
8939         [ALC662_FIXUP_ASUS_MODE2] = {
8940                 .type = HDA_FIXUP_PINS,
8941                 .v.pins = (const struct hda_pintbl[]) {
8942                         { 0x14, 0x99130110 }, /* speaker */
8943                         { 0x18, 0x01a19820 }, /* mic */
8944                         { 0x19, 0x99a3092f }, /* int-mic */
8945                         { 0x1b, 0x0121401f }, /* HP out */
8946                         { }
8947                 },
8948                 .chained = true,
8949                 .chain_id = ALC662_FIXUP_SKU_IGNORE
8950         },
8951         [ALC662_FIXUP_ASUS_MODE3] = {
8952                 .type = HDA_FIXUP_PINS,
8953                 .v.pins = (const struct hda_pintbl[]) {
8954                         { 0x14, 0x99130110 }, /* speaker */
8955                         { 0x15, 0x0121441f }, /* HP */
8956                         { 0x18, 0x01a19840 }, /* mic */
8957                         { 0x19, 0x99a3094f }, /* int-mic */
8958                         { 0x21, 0x01211420 }, /* HP2 */
8959                         { }
8960                 },
8961                 .chained = true,
8962                 .chain_id = ALC662_FIXUP_SKU_IGNORE
8963         },
8964         [ALC662_FIXUP_ASUS_MODE4] = {
8965                 .type = HDA_FIXUP_PINS,
8966                 .v.pins = (const struct hda_pintbl[]) {
8967                         { 0x14, 0x99130110 }, /* speaker */
8968                         { 0x16, 0x99130111 }, /* speaker */
8969                         { 0x18, 0x01a19840 }, /* mic */
8970                         { 0x19, 0x99a3094f }, /* int-mic */
8971                         { 0x21, 0x0121441f }, /* HP */
8972                         { }
8973                 },
8974                 .chained = true,
8975                 .chain_id = ALC662_FIXUP_SKU_IGNORE
8976         },
8977         [ALC662_FIXUP_ASUS_MODE5] = {
8978                 .type = HDA_FIXUP_PINS,
8979                 .v.pins = (const struct hda_pintbl[]) {
8980                         { 0x14, 0x99130110 }, /* speaker */
8981                         { 0x15, 0x0121441f }, /* HP */
8982                         { 0x16, 0x99130111 }, /* speaker */
8983                         { 0x18, 0x01a19840 }, /* mic */
8984                         { 0x19, 0x99a3094f }, /* int-mic */
8985                         { }
8986                 },
8987                 .chained = true,
8988                 .chain_id = ALC662_FIXUP_SKU_IGNORE
8989         },
8990         [ALC662_FIXUP_ASUS_MODE6] = {
8991                 .type = HDA_FIXUP_PINS,
8992                 .v.pins = (const struct hda_pintbl[]) {
8993                         { 0x14, 0x99130110 }, /* speaker */
8994                         { 0x15, 0x01211420 }, /* HP2 */
8995                         { 0x18, 0x01a19840 }, /* mic */
8996                         { 0x19, 0x99a3094f }, /* int-mic */
8997                         { 0x1b, 0x0121441f }, /* HP */
8998                         { }
8999                 },
9000                 .chained = true,
9001                 .chain_id = ALC662_FIXUP_SKU_IGNORE
9002         },
9003         [ALC662_FIXUP_ASUS_MODE7] = {
9004                 .type = HDA_FIXUP_PINS,
9005                 .v.pins = (const struct hda_pintbl[]) {
9006                         { 0x14, 0x99130110 }, /* speaker */
9007                         { 0x17, 0x99130111 }, /* speaker */
9008                         { 0x18, 0x01a19840 }, /* mic */
9009                         { 0x19, 0x99a3094f }, /* int-mic */
9010                         { 0x1b, 0x01214020 }, /* HP */
9011                         { 0x21, 0x0121401f }, /* HP */
9012                         { }
9013                 },
9014                 .chained = true,
9015                 .chain_id = ALC662_FIXUP_SKU_IGNORE
9016         },
9017         [ALC662_FIXUP_ASUS_MODE8] = {
9018                 .type = HDA_FIXUP_PINS,
9019                 .v.pins = (const struct hda_pintbl[]) {
9020                         { 0x14, 0x99130110 }, /* speaker */
9021                         { 0x12, 0x99a30970 }, /* int-mic */
9022                         { 0x15, 0x01214020 }, /* HP */
9023                         { 0x17, 0x99130111 }, /* speaker */
9024                         { 0x18, 0x01a19840 }, /* mic */
9025                         { 0x21, 0x0121401f }, /* HP */
9026                         { }
9027                 },
9028                 .chained = true,
9029                 .chain_id = ALC662_FIXUP_SKU_IGNORE
9030         },
9031         [ALC662_FIXUP_NO_JACK_DETECT] = {
9032                 .type = HDA_FIXUP_FUNC,
9033                 .v.func = alc_fixup_no_jack_detect,
9034         },
9035         [ALC662_FIXUP_ZOTAC_Z68] = {
9036                 .type = HDA_FIXUP_PINS,
9037                 .v.pins = (const struct hda_pintbl[]) {
9038                         { 0x1b, 0x02214020 }, /* Front HP */
9039                         { }
9040                 }
9041         },
9042         [ALC662_FIXUP_INV_DMIC] = {
9043                 .type = HDA_FIXUP_FUNC,
9044                 .v.func = alc_fixup_inv_dmic,
9045         },
9046         [ALC668_FIXUP_DELL_XPS13] = {
9047                 .type = HDA_FIXUP_FUNC,
9048                 .v.func = alc_fixup_dell_xps13,
9049                 .chained = true,
9050                 .chain_id = ALC668_FIXUP_DELL_DISABLE_AAMIX
9051         },
9052         [ALC668_FIXUP_DELL_DISABLE_AAMIX] = {
9053                 .type = HDA_FIXUP_FUNC,
9054                 .v.func = alc_fixup_disable_aamix,
9055                 .chained = true,
9056                 .chain_id = ALC668_FIXUP_DELL_MIC_NO_PRESENCE
9057         },
9058         [ALC668_FIXUP_AUTO_MUTE] = {
9059                 .type = HDA_FIXUP_FUNC,
9060                 .v.func = alc_fixup_auto_mute_via_amp,
9061                 .chained = true,
9062                 .chain_id = ALC668_FIXUP_DELL_MIC_NO_PRESENCE
9063         },
9064         [ALC662_FIXUP_DELL_MIC_NO_PRESENCE] = {
9065                 .type = HDA_FIXUP_PINS,
9066                 .v.pins = (const struct hda_pintbl[]) {
9067                         { 0x19, 0x03a1113c }, /* use as headset mic, without its own jack detect */
9068                         /* headphone mic by setting pin control of 0x1b (headphone out) to in + vref_50 */
9069                         { }
9070                 },
9071                 .chained = true,
9072                 .chain_id = ALC662_FIXUP_HEADSET_MODE
9073         },
9074         [ALC662_FIXUP_HEADSET_MODE] = {
9075                 .type = HDA_FIXUP_FUNC,
9076                 .v.func = alc_fixup_headset_mode_alc662,
9077         },
9078         [ALC668_FIXUP_DELL_MIC_NO_PRESENCE] = {
9079                 .type = HDA_FIXUP_PINS,
9080                 .v.pins = (const struct hda_pintbl[]) {
9081                         { 0x19, 0x03a1913d }, /* use as headphone mic, without its own jack detect */
9082                         { 0x1b, 0x03a1113c }, /* use as headset mic, without its own jack detect */
9083                         { }
9084                 },
9085                 .chained = true,
9086                 .chain_id = ALC668_FIXUP_HEADSET_MODE
9087         },
9088         [ALC668_FIXUP_HEADSET_MODE] = {
9089                 .type = HDA_FIXUP_FUNC,
9090                 .v.func = alc_fixup_headset_mode_alc668,
9091         },
9092         [ALC662_FIXUP_BASS_MODE4_CHMAP] = {
9093                 .type = HDA_FIXUP_FUNC,
9094                 .v.func = alc_fixup_bass_chmap,
9095                 .chained = true,
9096                 .chain_id = ALC662_FIXUP_ASUS_MODE4
9097         },
9098         [ALC662_FIXUP_BASS_16] = {
9099                 .type = HDA_FIXUP_PINS,
9100                 .v.pins = (const struct hda_pintbl[]) {
9101                         {0x16, 0x80106111}, /* bass speaker */
9102                         {}
9103                 },
9104                 .chained = true,
9105                 .chain_id = ALC662_FIXUP_BASS_CHMAP,
9106         },
9107         [ALC662_FIXUP_BASS_1A] = {
9108                 .type = HDA_FIXUP_PINS,
9109                 .v.pins = (const struct hda_pintbl[]) {
9110                         {0x1a, 0x80106111}, /* bass speaker */
9111                         {}
9112                 },
9113                 .chained = true,
9114                 .chain_id = ALC662_FIXUP_BASS_CHMAP,
9115         },
9116         [ALC662_FIXUP_BASS_CHMAP] = {
9117                 .type = HDA_FIXUP_FUNC,
9118                 .v.func = alc_fixup_bass_chmap,
9119         },
9120         [ALC662_FIXUP_ASUS_Nx50] = {
9121                 .type = HDA_FIXUP_FUNC,
9122                 .v.func = alc_fixup_auto_mute_via_amp,
9123                 .chained = true,
9124                 .chain_id = ALC662_FIXUP_BASS_1A
9125         },
9126         [ALC668_FIXUP_ASUS_Nx51_HEADSET_MODE] = {
9127                 .type = HDA_FIXUP_FUNC,
9128                 .v.func = alc_fixup_headset_mode_alc668,
9129                 .chain_id = ALC662_FIXUP_BASS_CHMAP
9130         },
9131         [ALC668_FIXUP_ASUS_Nx51] = {
9132                 .type = HDA_FIXUP_PINS,
9133                 .v.pins = (const struct hda_pintbl[]) {
9134                         { 0x19, 0x03a1913d }, /* use as headphone mic, without its own jack detect */
9135                         { 0x1a, 0x90170151 }, /* bass speaker */
9136                         { 0x1b, 0x03a1113c }, /* use as headset mic, without its own jack detect */
9137                         {}
9138                 },
9139                 .chained = true,
9140                 .chain_id = ALC668_FIXUP_ASUS_Nx51_HEADSET_MODE,
9141         },
9142         [ALC668_FIXUP_MIC_COEF] = {
9143                 .type = HDA_FIXUP_VERBS,
9144                 .v.verbs = (const struct hda_verb[]) {
9145                         { 0x20, AC_VERB_SET_COEF_INDEX, 0xc3 },
9146                         { 0x20, AC_VERB_SET_PROC_COEF, 0x4000 },
9147                         {}
9148                 },
9149         },
9150         [ALC668_FIXUP_ASUS_G751] = {
9151                 .type = HDA_FIXUP_PINS,
9152                 .v.pins = (const struct hda_pintbl[]) {
9153                         { 0x16, 0x0421101f }, /* HP */
9154                         {}
9155                 },
9156                 .chained = true,
9157                 .chain_id = ALC668_FIXUP_MIC_COEF
9158         },
9159         [ALC891_FIXUP_HEADSET_MODE] = {
9160                 .type = HDA_FIXUP_FUNC,
9161                 .v.func = alc_fixup_headset_mode,
9162         },
9163         [ALC891_FIXUP_DELL_MIC_NO_PRESENCE] = {
9164                 .type = HDA_FIXUP_PINS,
9165                 .v.pins = (const struct hda_pintbl[]) {
9166                         { 0x19, 0x03a1913d }, /* use as headphone mic, without its own jack detect */
9167                         { 0x1b, 0x03a1113c }, /* use as headset mic, without its own jack detect */
9168                         { }
9169                 },
9170                 .chained = true,
9171                 .chain_id = ALC891_FIXUP_HEADSET_MODE
9172         },
9173         [ALC662_FIXUP_ACER_VERITON] = {
9174                 .type = HDA_FIXUP_PINS,
9175                 .v.pins = (const struct hda_pintbl[]) {
9176                         { 0x15, 0x50170120 }, /* no internal speaker */
9177                         { }
9178                 }
9179         },
9180         [ALC892_FIXUP_ASROCK_MOBO] = {
9181                 .type = HDA_FIXUP_PINS,
9182                 .v.pins = (const struct hda_pintbl[]) {
9183                         { 0x15, 0x40f000f0 }, /* disabled */
9184                         { 0x16, 0x40f000f0 }, /* disabled */
9185                         { }
9186                 }
9187         },
9188         [ALC662_FIXUP_USI_FUNC] = {
9189                 .type = HDA_FIXUP_FUNC,
9190                 .v.func = alc662_fixup_usi_headset_mic,
9191         },
9192         [ALC662_FIXUP_USI_HEADSET_MODE] = {
9193                 .type = HDA_FIXUP_PINS,
9194                 .v.pins = (const struct hda_pintbl[]) {
9195                         { 0x19, 0x02a1913c }, /* use as headset mic, without its own jack detect */
9196                         { 0x18, 0x01a1903d },
9197                         { }
9198                 },
9199                 .chained = true,
9200                 .chain_id = ALC662_FIXUP_USI_FUNC
9201         },
9202         [ALC662_FIXUP_LENOVO_MULTI_CODECS] = {
9203                 .type = HDA_FIXUP_FUNC,
9204                 .v.func = alc233_alc662_fixup_lenovo_dual_codecs,
9205         },
9206         [ALC669_FIXUP_ACER_ASPIRE_ETHOS_HEADSET] = {
9207                 .type = HDA_FIXUP_FUNC,
9208                 .v.func = alc662_fixup_aspire_ethos_hp,
9209         },
9210         [ALC669_FIXUP_ACER_ASPIRE_ETHOS] = {
9211                 .type = HDA_FIXUP_PINS,
9212                 .v.pins = (const struct hda_pintbl[]) {
9213                         { 0x15, 0x92130110 }, /* front speakers */
9214                         { 0x18, 0x99130111 }, /* center/subwoofer */
9215                         { 0x1b, 0x11130012 }, /* surround plus jack for HP */
9216                         { }
9217                 },
9218                 .chained = true,
9219                 .chain_id = ALC669_FIXUP_ACER_ASPIRE_ETHOS_HEADSET
9220         },
9221         [ALC671_FIXUP_HP_HEADSET_MIC2] = {
9222                 .type = HDA_FIXUP_FUNC,
9223                 .v.func = alc671_fixup_hp_headset_mic2,
9224         },
9225         [ALC662_FIXUP_ACER_X2660G_HEADSET_MODE] = {
9226                 .type = HDA_FIXUP_PINS,
9227                 .v.pins = (const struct hda_pintbl[]) {
9228                         { 0x1a, 0x02a1113c }, /* use as headset mic, without its own jack detect */
9229                         { }
9230                 },
9231                 .chained = true,
9232                 .chain_id = ALC662_FIXUP_USI_FUNC
9233         },
9234         [ALC662_FIXUP_ACER_NITRO_HEADSET_MODE] = {
9235                 .type = HDA_FIXUP_PINS,
9236                 .v.pins = (const struct hda_pintbl[]) {
9237                         { 0x1a, 0x01a11140 }, /* use as headset mic, without its own jack detect */
9238                         { 0x1b, 0x0221144f },
9239                         { }
9240                 },
9241                 .chained = true,
9242                 .chain_id = ALC662_FIXUP_USI_FUNC
9243         },
9244 };
9245
9246 static const struct snd_pci_quirk alc662_fixup_tbl[] = {
9247         SND_PCI_QUIRK(0x1019, 0x9087, "ECS", ALC662_FIXUP_ASUS_MODE2),
9248         SND_PCI_QUIRK(0x1025, 0x022f, "Acer Aspire One", ALC662_FIXUP_INV_DMIC),
9249         SND_PCI_QUIRK(0x1025, 0x0241, "Packard Bell DOTS", ALC662_FIXUP_INV_DMIC),
9250         SND_PCI_QUIRK(0x1025, 0x0308, "Acer Aspire 8942G", ALC662_FIXUP_ASPIRE),
9251         SND_PCI_QUIRK(0x1025, 0x031c, "Gateway NV79", ALC662_FIXUP_SKU_IGNORE),
9252         SND_PCI_QUIRK(0x1025, 0x0349, "eMachines eM250", ALC662_FIXUP_INV_DMIC),
9253         SND_PCI_QUIRK(0x1025, 0x034a, "Gateway LT27", ALC662_FIXUP_INV_DMIC),
9254         SND_PCI_QUIRK(0x1025, 0x038b, "Acer Aspire 8943G", ALC662_FIXUP_ASPIRE),
9255         SND_PCI_QUIRK(0x1025, 0x123c, "Acer Nitro N50-600", ALC662_FIXUP_ACER_NITRO_HEADSET_MODE),
9256         SND_PCI_QUIRK(0x1025, 0x124e, "Acer 2660G", ALC662_FIXUP_ACER_X2660G_HEADSET_MODE),
9257         SND_PCI_QUIRK(0x1028, 0x05d8, "Dell", ALC668_FIXUP_DELL_MIC_NO_PRESENCE),
9258         SND_PCI_QUIRK(0x1028, 0x05db, "Dell", ALC668_FIXUP_DELL_MIC_NO_PRESENCE),
9259         SND_PCI_QUIRK(0x1028, 0x05fe, "Dell XPS 15", ALC668_FIXUP_DELL_XPS13),
9260         SND_PCI_QUIRK(0x1028, 0x060a, "Dell XPS 13", ALC668_FIXUP_DELL_XPS13),
9261         SND_PCI_QUIRK(0x1028, 0x060d, "Dell M3800", ALC668_FIXUP_DELL_XPS13),
9262         SND_PCI_QUIRK(0x1028, 0x0625, "Dell", ALC668_FIXUP_DELL_MIC_NO_PRESENCE),
9263         SND_PCI_QUIRK(0x1028, 0x0626, "Dell", ALC668_FIXUP_DELL_MIC_NO_PRESENCE),
9264         SND_PCI_QUIRK(0x1028, 0x0696, "Dell", ALC668_FIXUP_DELL_MIC_NO_PRESENCE),
9265         SND_PCI_QUIRK(0x1028, 0x0698, "Dell", ALC668_FIXUP_DELL_MIC_NO_PRESENCE),
9266         SND_PCI_QUIRK(0x1028, 0x069f, "Dell", ALC668_FIXUP_DELL_MIC_NO_PRESENCE),
9267         SND_PCI_QUIRK(0x103c, 0x1632, "HP RP5800", ALC662_FIXUP_HP_RP5800),
9268         SND_PCI_QUIRK(0x1043, 0x1080, "Asus UX501VW", ALC668_FIXUP_HEADSET_MODE),
9269         SND_PCI_QUIRK(0x1043, 0x11cd, "Asus N550", ALC662_FIXUP_ASUS_Nx50),
9270         SND_PCI_QUIRK(0x1043, 0x13df, "Asus N550JX", ALC662_FIXUP_BASS_1A),
9271         SND_PCI_QUIRK(0x1043, 0x129d, "Asus N750", ALC662_FIXUP_ASUS_Nx50),
9272         SND_PCI_QUIRK(0x1043, 0x12ff, "ASUS G751", ALC668_FIXUP_ASUS_G751),
9273         SND_PCI_QUIRK(0x1043, 0x1477, "ASUS N56VZ", ALC662_FIXUP_BASS_MODE4_CHMAP),
9274         SND_PCI_QUIRK(0x1043, 0x15a7, "ASUS UX51VZH", ALC662_FIXUP_BASS_16),
9275         SND_PCI_QUIRK(0x1043, 0x177d, "ASUS N551", ALC668_FIXUP_ASUS_Nx51),
9276         SND_PCI_QUIRK(0x1043, 0x17bd, "ASUS N751", ALC668_FIXUP_ASUS_Nx51),
9277         SND_PCI_QUIRK(0x1043, 0x1963, "ASUS X71SL", ALC662_FIXUP_ASUS_MODE8),
9278         SND_PCI_QUIRK(0x1043, 0x1b73, "ASUS N55SF", ALC662_FIXUP_BASS_16),
9279         SND_PCI_QUIRK(0x1043, 0x1bf3, "ASUS N76VZ", ALC662_FIXUP_BASS_MODE4_CHMAP),
9280         SND_PCI_QUIRK(0x1043, 0x8469, "ASUS mobo", ALC662_FIXUP_NO_JACK_DETECT),
9281         SND_PCI_QUIRK(0x105b, 0x0cd6, "Foxconn", ALC662_FIXUP_ASUS_MODE2),
9282         SND_PCI_QUIRK(0x144d, 0xc051, "Samsung R720", ALC662_FIXUP_IDEAPAD),
9283         SND_PCI_QUIRK(0x14cd, 0x5003, "USI", ALC662_FIXUP_USI_HEADSET_MODE),
9284         SND_PCI_QUIRK(0x17aa, 0x1036, "Lenovo P520", ALC662_FIXUP_LENOVO_MULTI_CODECS),
9285         SND_PCI_QUIRK(0x17aa, 0x38af, "Lenovo Ideapad Y550P", ALC662_FIXUP_IDEAPAD),
9286         SND_PCI_QUIRK(0x17aa, 0x3a0d, "Lenovo Ideapad Y550", ALC662_FIXUP_IDEAPAD),
9287         SND_PCI_QUIRK(0x1849, 0x5892, "ASRock B150M", ALC892_FIXUP_ASROCK_MOBO),
9288         SND_PCI_QUIRK(0x19da, 0xa130, "Zotac Z68", ALC662_FIXUP_ZOTAC_Z68),
9289         SND_PCI_QUIRK(0x1b0a, 0x01b8, "ACER Veriton", ALC662_FIXUP_ACER_VERITON),
9290         SND_PCI_QUIRK(0x1b35, 0x2206, "CZC P10T", ALC662_FIXUP_CZC_P10T),
9291         SND_PCI_QUIRK(0x1025, 0x0566, "Acer Aspire Ethos 8951G", ALC669_FIXUP_ACER_ASPIRE_ETHOS),
9292
9293 #if 0
9294         /* Below is a quirk table taken from the old code.
9295          * Basically the device should work as is without the fixup table.
9296          * If BIOS doesn't give a proper info, enable the corresponding
9297          * fixup entry.
9298          */
9299         SND_PCI_QUIRK(0x1043, 0x1000, "ASUS N50Vm", ALC662_FIXUP_ASUS_MODE1),
9300         SND_PCI_QUIRK(0x1043, 0x1092, "ASUS NB", ALC662_FIXUP_ASUS_MODE3),
9301         SND_PCI_QUIRK(0x1043, 0x1173, "ASUS K73Jn", ALC662_FIXUP_ASUS_MODE1),
9302         SND_PCI_QUIRK(0x1043, 0x11c3, "ASUS M70V", ALC662_FIXUP_ASUS_MODE3),
9303         SND_PCI_QUIRK(0x1043, 0x11d3, "ASUS NB", ALC662_FIXUP_ASUS_MODE1),
9304         SND_PCI_QUIRK(0x1043, 0x11f3, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),
9305         SND_PCI_QUIRK(0x1043, 0x1203, "ASUS NB", ALC662_FIXUP_ASUS_MODE1),
9306         SND_PCI_QUIRK(0x1043, 0x1303, "ASUS G60J", ALC662_FIXUP_ASUS_MODE1),
9307         SND_PCI_QUIRK(0x1043, 0x1333, "ASUS G60Jx", ALC662_FIXUP_ASUS_MODE1),
9308         SND_PCI_QUIRK(0x1043, 0x1339, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),
9309         SND_PCI_QUIRK(0x1043, 0x13e3, "ASUS N71JA", ALC662_FIXUP_ASUS_MODE7),
9310         SND_PCI_QUIRK(0x1043, 0x1463, "ASUS N71", ALC662_FIXUP_ASUS_MODE7),
9311         SND_PCI_QUIRK(0x1043, 0x14d3, "ASUS G72", ALC662_FIXUP_ASUS_MODE8),
9312         SND_PCI_QUIRK(0x1043, 0x1563, "ASUS N90", ALC662_FIXUP_ASUS_MODE3),
9313         SND_PCI_QUIRK(0x1043, 0x15d3, "ASUS N50SF F50SF", ALC662_FIXUP_ASUS_MODE1),
9314         SND_PCI_QUIRK(0x1043, 0x16c3, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),
9315         SND_PCI_QUIRK(0x1043, 0x16f3, "ASUS K40C K50C", ALC662_FIXUP_ASUS_MODE2),
9316         SND_PCI_QUIRK(0x1043, 0x1733, "ASUS N81De", ALC662_FIXUP_ASUS_MODE1),
9317         SND_PCI_QUIRK(0x1043, 0x1753, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),
9318         SND_PCI_QUIRK(0x1043, 0x1763, "ASUS NB", ALC662_FIXUP_ASUS_MODE6),
9319         SND_PCI_QUIRK(0x1043, 0x1765, "ASUS NB", ALC662_FIXUP_ASUS_MODE6),
9320         SND_PCI_QUIRK(0x1043, 0x1783, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),
9321         SND_PCI_QUIRK(0x1043, 0x1793, "ASUS F50GX", ALC662_FIXUP_ASUS_MODE1),
9322         SND_PCI_QUIRK(0x1043, 0x17b3, "ASUS F70SL", ALC662_FIXUP_ASUS_MODE3),
9323         SND_PCI_QUIRK(0x1043, 0x17f3, "ASUS X58LE", ALC662_FIXUP_ASUS_MODE2),
9324         SND_PCI_QUIRK(0x1043, 0x1813, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),
9325         SND_PCI_QUIRK(0x1043, 0x1823, "ASUS NB", ALC662_FIXUP_ASUS_MODE5),
9326         SND_PCI_QUIRK(0x1043, 0x1833, "ASUS NB", ALC662_FIXUP_ASUS_MODE6),
9327         SND_PCI_QUIRK(0x1043, 0x1843, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),
9328         SND_PCI_QUIRK(0x1043, 0x1853, "ASUS F50Z", ALC662_FIXUP_ASUS_MODE1),
9329         SND_PCI_QUIRK(0x1043, 0x1864, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),
9330         SND_PCI_QUIRK(0x1043, 0x1876, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),
9331         SND_PCI_QUIRK(0x1043, 0x1893, "ASUS M50Vm", ALC662_FIXUP_ASUS_MODE3),
9332         SND_PCI_QUIRK(0x1043, 0x1894, "ASUS X55", ALC662_FIXUP_ASUS_MODE3),
9333         SND_PCI_QUIRK(0x1043, 0x18b3, "ASUS N80Vc", ALC662_FIXUP_ASUS_MODE1),
9334         SND_PCI_QUIRK(0x1043, 0x18c3, "ASUS VX5", ALC662_FIXUP_ASUS_MODE1),
9335         SND_PCI_QUIRK(0x1043, 0x18d3, "ASUS N81Te", ALC662_FIXUP_ASUS_MODE1),
9336         SND_PCI_QUIRK(0x1043, 0x18f3, "ASUS N505Tp", ALC662_FIXUP_ASUS_MODE1),
9337         SND_PCI_QUIRK(0x1043, 0x1903, "ASUS F5GL", ALC662_FIXUP_ASUS_MODE1),
9338         SND_PCI_QUIRK(0x1043, 0x1913, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),
9339         SND_PCI_QUIRK(0x1043, 0x1933, "ASUS F80Q", ALC662_FIXUP_ASUS_MODE2),
9340         SND_PCI_QUIRK(0x1043, 0x1943, "ASUS Vx3V", ALC662_FIXUP_ASUS_MODE1),
9341         SND_PCI_QUIRK(0x1043, 0x1953, "ASUS NB", ALC662_FIXUP_ASUS_MODE1),
9342         SND_PCI_QUIRK(0x1043, 0x1963, "ASUS X71C", ALC662_FIXUP_ASUS_MODE3),
9343         SND_PCI_QUIRK(0x1043, 0x1983, "ASUS N5051A", ALC662_FIXUP_ASUS_MODE1),
9344         SND_PCI_QUIRK(0x1043, 0x1993, "ASUS N20", ALC662_FIXUP_ASUS_MODE1),
9345         SND_PCI_QUIRK(0x1043, 0x19b3, "ASUS F7Z", ALC662_FIXUP_ASUS_MODE1),
9346         SND_PCI_QUIRK(0x1043, 0x19c3, "ASUS F5Z/F6x", ALC662_FIXUP_ASUS_MODE2),
9347         SND_PCI_QUIRK(0x1043, 0x19e3, "ASUS NB", ALC662_FIXUP_ASUS_MODE1),
9348         SND_PCI_QUIRK(0x1043, 0x19f3, "ASUS NB", ALC662_FIXUP_ASUS_MODE4),
9349 #endif
9350         {}
9351 };
9352
9353 static const struct hda_model_fixup alc662_fixup_models[] = {
9354         {.id = ALC662_FIXUP_ASPIRE, .name = "aspire"},
9355         {.id = ALC662_FIXUP_IDEAPAD, .name = "ideapad"},
9356         {.id = ALC272_FIXUP_MARIO, .name = "mario"},
9357         {.id = ALC662_FIXUP_HP_RP5800, .name = "hp-rp5800"},
9358         {.id = ALC662_FIXUP_ASUS_MODE1, .name = "asus-mode1"},
9359         {.id = ALC662_FIXUP_ASUS_MODE2, .name = "asus-mode2"},
9360         {.id = ALC662_FIXUP_ASUS_MODE3, .name = "asus-mode3"},
9361         {.id = ALC662_FIXUP_ASUS_MODE4, .name = "asus-mode4"},
9362         {.id = ALC662_FIXUP_ASUS_MODE5, .name = "asus-mode5"},
9363         {.id = ALC662_FIXUP_ASUS_MODE6, .name = "asus-mode6"},
9364         {.id = ALC662_FIXUP_ASUS_MODE7, .name = "asus-mode7"},
9365         {.id = ALC662_FIXUP_ASUS_MODE8, .name = "asus-mode8"},
9366         {.id = ALC662_FIXUP_ZOTAC_Z68, .name = "zotac-z68"},
9367         {.id = ALC662_FIXUP_INV_DMIC, .name = "inv-dmic"},
9368         {.id = ALC662_FIXUP_DELL_MIC_NO_PRESENCE, .name = "alc662-headset-multi"},
9369         {.id = ALC668_FIXUP_DELL_MIC_NO_PRESENCE, .name = "dell-headset-multi"},
9370         {.id = ALC662_FIXUP_HEADSET_MODE, .name = "alc662-headset"},
9371         {.id = ALC668_FIXUP_HEADSET_MODE, .name = "alc668-headset"},
9372         {.id = ALC662_FIXUP_BASS_16, .name = "bass16"},
9373         {.id = ALC662_FIXUP_BASS_1A, .name = "bass1a"},
9374         {.id = ALC668_FIXUP_AUTO_MUTE, .name = "automute"},
9375         {.id = ALC668_FIXUP_DELL_XPS13, .name = "dell-xps13"},
9376         {.id = ALC662_FIXUP_ASUS_Nx50, .name = "asus-nx50"},
9377         {.id = ALC668_FIXUP_ASUS_Nx51, .name = "asus-nx51"},
9378         {.id = ALC668_FIXUP_ASUS_G751, .name = "asus-g751"},
9379         {.id = ALC891_FIXUP_HEADSET_MODE, .name = "alc891-headset"},
9380         {.id = ALC891_FIXUP_DELL_MIC_NO_PRESENCE, .name = "alc891-headset-multi"},
9381         {.id = ALC662_FIXUP_ACER_VERITON, .name = "acer-veriton"},
9382         {.id = ALC892_FIXUP_ASROCK_MOBO, .name = "asrock-mobo"},
9383         {.id = ALC662_FIXUP_USI_HEADSET_MODE, .name = "usi-headset"},
9384         {.id = ALC662_FIXUP_LENOVO_MULTI_CODECS, .name = "dual-codecs"},
9385         {.id = ALC669_FIXUP_ACER_ASPIRE_ETHOS, .name = "aspire-ethos"},
9386         {}
9387 };
9388
9389 static const struct snd_hda_pin_quirk alc662_pin_fixup_tbl[] = {
9390         SND_HDA_PIN_QUIRK(0x10ec0867, 0x1028, "Dell", ALC891_FIXUP_DELL_MIC_NO_PRESENCE,
9391                 {0x17, 0x02211010},
9392                 {0x18, 0x01a19030},
9393                 {0x1a, 0x01813040},
9394                 {0x21, 0x01014020}),
9395         SND_HDA_PIN_QUIRK(0x10ec0867, 0x1028, "Dell", ALC891_FIXUP_DELL_MIC_NO_PRESENCE,
9396                 {0x16, 0x01813030},
9397                 {0x17, 0x02211010},
9398                 {0x18, 0x01a19040},
9399                 {0x21, 0x01014020}),
9400         SND_HDA_PIN_QUIRK(0x10ec0662, 0x1028, "Dell", ALC662_FIXUP_DELL_MIC_NO_PRESENCE,
9401                 {0x14, 0x01014010},
9402                 {0x18, 0x01a19020},
9403                 {0x1a, 0x0181302f},
9404                 {0x1b, 0x0221401f}),
9405         SND_HDA_PIN_QUIRK(0x10ec0668, 0x1028, "Dell", ALC668_FIXUP_AUTO_MUTE,
9406                 {0x12, 0x99a30130},
9407                 {0x14, 0x90170110},
9408                 {0x15, 0x0321101f},
9409                 {0x16, 0x03011020}),
9410         SND_HDA_PIN_QUIRK(0x10ec0668, 0x1028, "Dell", ALC668_FIXUP_AUTO_MUTE,
9411                 {0x12, 0x99a30140},
9412                 {0x14, 0x90170110},
9413                 {0x15, 0x0321101f},
9414                 {0x16, 0x03011020}),
9415         SND_HDA_PIN_QUIRK(0x10ec0668, 0x1028, "Dell", ALC668_FIXUP_AUTO_MUTE,
9416                 {0x12, 0x99a30150},
9417                 {0x14, 0x90170110},
9418                 {0x15, 0x0321101f},
9419                 {0x16, 0x03011020}),
9420         SND_HDA_PIN_QUIRK(0x10ec0668, 0x1028, "Dell", ALC668_FIXUP_AUTO_MUTE,
9421                 {0x14, 0x90170110},
9422                 {0x15, 0x0321101f},
9423                 {0x16, 0x03011020}),
9424         SND_HDA_PIN_QUIRK(0x10ec0668, 0x1028, "Dell XPS 15", ALC668_FIXUP_AUTO_MUTE,
9425                 {0x12, 0x90a60130},
9426                 {0x14, 0x90170110},
9427                 {0x15, 0x0321101f}),
9428         SND_HDA_PIN_QUIRK(0x10ec0671, 0x103c, "HP cPC", ALC671_FIXUP_HP_HEADSET_MIC2,
9429                 {0x14, 0x01014010},
9430                 {0x17, 0x90170150},
9431                 {0x19, 0x02a11060},
9432                 {0x1b, 0x01813030},
9433                 {0x21, 0x02211020}),
9434         SND_HDA_PIN_QUIRK(0x10ec0671, 0x103c, "HP cPC", ALC671_FIXUP_HP_HEADSET_MIC2,
9435                 {0x14, 0x01014010},
9436                 {0x18, 0x01a19040},
9437                 {0x1b, 0x01813030},
9438                 {0x21, 0x02211020}),
9439         SND_HDA_PIN_QUIRK(0x10ec0671, 0x103c, "HP cPC", ALC671_FIXUP_HP_HEADSET_MIC2,
9440                 {0x14, 0x01014020},
9441                 {0x17, 0x90170110},
9442                 {0x18, 0x01a19050},
9443                 {0x1b, 0x01813040},
9444                 {0x21, 0x02211030}),
9445         {}
9446 };
9447
9448 /*
9449  */
9450 static int patch_alc662(struct hda_codec *codec)
9451 {
9452         struct alc_spec *spec;
9453         int err;
9454
9455         err = alc_alloc_spec(codec, 0x0b);
9456         if (err < 0)
9457                 return err;
9458
9459         spec = codec->spec;
9460
9461         spec->shutup = alc_eapd_shutup;
9462
9463         /* handle multiple HPs as is */
9464         spec->parse_flags = HDA_PINCFG_NO_HP_FIXUP;
9465
9466         alc_fix_pll_init(codec, 0x20, 0x04, 15);
9467
9468         switch (codec->core.vendor_id) {
9469         case 0x10ec0668:
9470                 spec->init_hook = alc668_restore_default_value;
9471                 break;
9472         }
9473
9474         alc_pre_init(codec);
9475
9476         snd_hda_pick_fixup(codec, alc662_fixup_models,
9477                        alc662_fixup_tbl, alc662_fixups);
9478         snd_hda_pick_pin_fixup(codec, alc662_pin_fixup_tbl, alc662_fixups, true);
9479         snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE);
9480
9481         alc_auto_parse_customize_define(codec);
9482
9483         if (has_cdefine_beep(codec))
9484                 spec->gen.beep_nid = 0x01;
9485
9486         if ((alc_get_coef0(codec) & (1 << 14)) &&
9487             codec->bus->pci && codec->bus->pci->subsystem_vendor == 0x1025 &&
9488             spec->cdefine.platform_type == 1) {
9489                 err = alc_codec_rename(codec, "ALC272X");
9490                 if (err < 0)
9491                         goto error;
9492         }
9493
9494         /* automatic parse from the BIOS config */
9495         err = alc662_parse_auto_config(codec);
9496         if (err < 0)
9497                 goto error;
9498
9499         if (!spec->gen.no_analog && spec->gen.beep_nid) {
9500                 switch (codec->core.vendor_id) {
9501                 case 0x10ec0662:
9502                         err = set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
9503                         break;
9504                 case 0x10ec0272:
9505                 case 0x10ec0663:
9506                 case 0x10ec0665:
9507                 case 0x10ec0668:
9508                         err = set_beep_amp(spec, 0x0b, 0x04, HDA_INPUT);
9509                         break;
9510                 case 0x10ec0273:
9511                         err = set_beep_amp(spec, 0x0b, 0x03, HDA_INPUT);
9512                         break;
9513                 }
9514                 if (err < 0)
9515                         goto error;
9516         }
9517
9518         snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE);
9519
9520         return 0;
9521
9522  error:
9523         alc_free(codec);
9524         return err;
9525 }
9526
9527 /*
9528  * ALC680 support
9529  */
9530
9531 static int alc680_parse_auto_config(struct hda_codec *codec)
9532 {
9533         return alc_parse_auto_config(codec, NULL, NULL);
9534 }
9535
9536 /*
9537  */
9538 static int patch_alc680(struct hda_codec *codec)
9539 {
9540         int err;
9541
9542         /* ALC680 has no aa-loopback mixer */
9543         err = alc_alloc_spec(codec, 0);
9544         if (err < 0)
9545                 return err;
9546
9547         /* automatic parse from the BIOS config */
9548         err = alc680_parse_auto_config(codec);
9549         if (err < 0) {
9550                 alc_free(codec);
9551                 return err;
9552         }
9553
9554         return 0;
9555 }
9556
9557 /*
9558  * patch entries
9559  */
9560 static const struct hda_device_id snd_hda_id_realtek[] = {
9561         HDA_CODEC_ENTRY(0x10ec0215, "ALC215", patch_alc269),
9562         HDA_CODEC_ENTRY(0x10ec0221, "ALC221", patch_alc269),
9563         HDA_CODEC_ENTRY(0x10ec0222, "ALC222", patch_alc269),
9564         HDA_CODEC_ENTRY(0x10ec0225, "ALC225", patch_alc269),
9565         HDA_CODEC_ENTRY(0x10ec0231, "ALC231", patch_alc269),
9566         HDA_CODEC_ENTRY(0x10ec0233, "ALC233", patch_alc269),
9567         HDA_CODEC_ENTRY(0x10ec0234, "ALC234", patch_alc269),
9568         HDA_CODEC_ENTRY(0x10ec0235, "ALC233", patch_alc269),
9569         HDA_CODEC_ENTRY(0x10ec0236, "ALC236", patch_alc269),
9570         HDA_CODEC_ENTRY(0x10ec0245, "ALC245", patch_alc269),
9571         HDA_CODEC_ENTRY(0x10ec0255, "ALC255", patch_alc269),
9572         HDA_CODEC_ENTRY(0x10ec0256, "ALC256", patch_alc269),
9573         HDA_CODEC_ENTRY(0x10ec0257, "ALC257", patch_alc269),
9574         HDA_CODEC_ENTRY(0x10ec0260, "ALC260", patch_alc260),
9575         HDA_CODEC_ENTRY(0x10ec0262, "ALC262", patch_alc262),
9576         HDA_CODEC_ENTRY(0x10ec0267, "ALC267", patch_alc268),
9577         HDA_CODEC_ENTRY(0x10ec0268, "ALC268", patch_alc268),
9578         HDA_CODEC_ENTRY(0x10ec0269, "ALC269", patch_alc269),
9579         HDA_CODEC_ENTRY(0x10ec0270, "ALC270", patch_alc269),
9580         HDA_CODEC_ENTRY(0x10ec0272, "ALC272", patch_alc662),
9581         HDA_CODEC_ENTRY(0x10ec0274, "ALC274", patch_alc269),
9582         HDA_CODEC_ENTRY(0x10ec0275, "ALC275", patch_alc269),
9583         HDA_CODEC_ENTRY(0x10ec0276, "ALC276", patch_alc269),
9584         HDA_CODEC_ENTRY(0x10ec0280, "ALC280", patch_alc269),
9585         HDA_CODEC_ENTRY(0x10ec0282, "ALC282", patch_alc269),
9586         HDA_CODEC_ENTRY(0x10ec0283, "ALC283", patch_alc269),
9587         HDA_CODEC_ENTRY(0x10ec0284, "ALC284", patch_alc269),
9588         HDA_CODEC_ENTRY(0x10ec0285, "ALC285", patch_alc269),
9589         HDA_CODEC_ENTRY(0x10ec0286, "ALC286", patch_alc269),
9590         HDA_CODEC_ENTRY(0x10ec0287, "ALC287", patch_alc269),
9591         HDA_CODEC_ENTRY(0x10ec0288, "ALC288", patch_alc269),
9592         HDA_CODEC_ENTRY(0x10ec0289, "ALC289", patch_alc269),
9593         HDA_CODEC_ENTRY(0x10ec0290, "ALC290", patch_alc269),
9594         HDA_CODEC_ENTRY(0x10ec0292, "ALC292", patch_alc269),
9595         HDA_CODEC_ENTRY(0x10ec0293, "ALC293", patch_alc269),
9596         HDA_CODEC_ENTRY(0x10ec0294, "ALC294", patch_alc269),
9597         HDA_CODEC_ENTRY(0x10ec0295, "ALC295", patch_alc269),
9598         HDA_CODEC_ENTRY(0x10ec0298, "ALC298", patch_alc269),
9599         HDA_CODEC_ENTRY(0x10ec0299, "ALC299", patch_alc269),
9600         HDA_CODEC_ENTRY(0x10ec0300, "ALC300", patch_alc269),
9601         HDA_CODEC_ENTRY(0x10ec0623, "ALC623", patch_alc269),
9602         HDA_CODEC_REV_ENTRY(0x10ec0861, 0x100340, "ALC660", patch_alc861),
9603         HDA_CODEC_ENTRY(0x10ec0660, "ALC660-VD", patch_alc861vd),
9604         HDA_CODEC_ENTRY(0x10ec0861, "ALC861", patch_alc861),
9605         HDA_CODEC_ENTRY(0x10ec0862, "ALC861-VD", patch_alc861vd),
9606         HDA_CODEC_REV_ENTRY(0x10ec0662, 0x100002, "ALC662 rev2", patch_alc882),
9607         HDA_CODEC_REV_ENTRY(0x10ec0662, 0x100101, "ALC662 rev1", patch_alc662),
9608         HDA_CODEC_REV_ENTRY(0x10ec0662, 0x100300, "ALC662 rev3", patch_alc662),
9609         HDA_CODEC_ENTRY(0x10ec0663, "ALC663", patch_alc662),
9610         HDA_CODEC_ENTRY(0x10ec0665, "ALC665", patch_alc662),
9611         HDA_CODEC_ENTRY(0x10ec0667, "ALC667", patch_alc662),
9612         HDA_CODEC_ENTRY(0x10ec0668, "ALC668", patch_alc662),
9613         HDA_CODEC_ENTRY(0x10ec0670, "ALC670", patch_alc662),
9614         HDA_CODEC_ENTRY(0x10ec0671, "ALC671", patch_alc662),
9615         HDA_CODEC_ENTRY(0x10ec0680, "ALC680", patch_alc680),
9616         HDA_CODEC_ENTRY(0x10ec0700, "ALC700", patch_alc269),
9617         HDA_CODEC_ENTRY(0x10ec0701, "ALC701", patch_alc269),
9618         HDA_CODEC_ENTRY(0x10ec0703, "ALC703", patch_alc269),
9619         HDA_CODEC_ENTRY(0x10ec0711, "ALC711", patch_alc269),
9620         HDA_CODEC_ENTRY(0x10ec0867, "ALC891", patch_alc662),
9621         HDA_CODEC_ENTRY(0x10ec0880, "ALC880", patch_alc880),
9622         HDA_CODEC_ENTRY(0x10ec0882, "ALC882", patch_alc882),
9623         HDA_CODEC_ENTRY(0x10ec0883, "ALC883", patch_alc882),
9624         HDA_CODEC_REV_ENTRY(0x10ec0885, 0x100101, "ALC889A", patch_alc882),
9625         HDA_CODEC_REV_ENTRY(0x10ec0885, 0x100103, "ALC889A", patch_alc882),
9626         HDA_CODEC_ENTRY(0x10ec0885, "ALC885", patch_alc882),
9627         HDA_CODEC_ENTRY(0x10ec0887, "ALC887", patch_alc882),
9628         HDA_CODEC_REV_ENTRY(0x10ec0888, 0x100101, "ALC1200", patch_alc882),
9629         HDA_CODEC_ENTRY(0x10ec0888, "ALC888", patch_alc882),
9630         HDA_CODEC_ENTRY(0x10ec0889, "ALC889", patch_alc882),
9631         HDA_CODEC_ENTRY(0x10ec0892, "ALC892", patch_alc662),
9632         HDA_CODEC_ENTRY(0x10ec0899, "ALC898", patch_alc882),
9633         HDA_CODEC_ENTRY(0x10ec0900, "ALC1150", patch_alc882),
9634         HDA_CODEC_ENTRY(0x10ec0b00, "ALCS1200A", patch_alc882),
9635         HDA_CODEC_ENTRY(0x10ec1168, "ALC1220", patch_alc882),
9636         HDA_CODEC_ENTRY(0x10ec1220, "ALC1220", patch_alc882),
9637         {} /* terminator */
9638 };
9639 MODULE_DEVICE_TABLE(hdaudio, snd_hda_id_realtek);
9640
9641 MODULE_LICENSE("GPL");
9642 MODULE_DESCRIPTION("Realtek HD-audio codec");
9643
9644 static struct hda_codec_driver realtek_driver = {
9645         .id = snd_hda_id_realtek,
9646 };
9647
9648 module_hda_codec_driver(realtek_driver);