sound/pci/hda/patch_realtek.c

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