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