sound/pci/hda/patch_realtek.c

   1 /*
   2  * Universal Interface for Intel High Definition Audio Codec
   3  *
   4  * HD audio interface patch for Realtek ALC codecs
   5  *
   6  * Copyright (c) 2004 Kailang Yang <kailang@realtek.com.tw>
   7  *                    PeiSen Hou <pshou@realtek.com.tw>
   8  *                    Takashi Iwai <tiwai@suse.de>
   9  *                    Jonathan Woithe <jwoithe@just42.net>
  10  *
  11  *  This driver is free software; you can redistribute it and/or modify
  12  *  it under the terms of the GNU General Public License as published by
  13  *  the Free Software Foundation; either version 2 of the License, or
  14  *  (at your option) any later version.
  15  *
  16  *  This driver is distributed in the hope that it will be useful,
  17  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  18  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  19  *  GNU General Public License for more details.
  20  *
  21  *  You should have received a copy of the GNU General Public License
  22  *  along with this program; if not, write to the Free Software
  23  *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  24  */
  25
  26 #include <linux/init.h>
  27 #include <linux/delay.h>
  28 #include <linux/slab.h>
  29 #include <linux/pci.h>
  30 #include <linux/dmi.h>
  31 #include <linux/module.h>
  32 #include <sound/core.h>
  33 #include <sound/jack.h>
  34 #include "hda_codec.h"
  35 #include "hda_local.h"
  36 #include "hda_auto_parser.h"
  37 #include "hda_jack.h"
  38 #include "hda_generic.h"
  39
  40 /* keep halting ALC5505 DSP, for power saving */
  41 #define HALT_REALTEK_ALC5505
  42
  43 /* unsol event tags */
  44 #define ALC_DCVOL_EVENT         0x08
  45
  46 /* for GPIO Poll */
  47 #define GPIO_MASK       0x03
  48
  49 /* extra amp-initialization sequence types */
  50 enum {
  51         ALC_INIT_NONE,
  52         ALC_INIT_DEFAULT,
  53         ALC_INIT_GPIO1,
  54         ALC_INIT_GPIO2,
  55         ALC_INIT_GPIO3,
  56 };
  57
  58 enum {
  59         ALC_HEADSET_MODE_UNKNOWN,
  60         ALC_HEADSET_MODE_UNPLUGGED,
  61         ALC_HEADSET_MODE_HEADSET,
  62         ALC_HEADSET_MODE_MIC,
  63         ALC_HEADSET_MODE_HEADPHONE,
  64 };
  65
  66 enum {
  67         ALC_HEADSET_TYPE_UNKNOWN,
  68         ALC_HEADSET_TYPE_CTIA,
  69         ALC_HEADSET_TYPE_OMTP,
  70 };
  71
  72 struct alc_customize_define {
  73         unsigned int  sku_cfg;
  74         unsigned char port_connectivity;
  75         unsigned char check_sum;
  76         unsigned char customization;
  77         unsigned char external_amp;
  78         unsigned int  enable_pcbeep:1;
  79         unsigned int  platform_type:1;
  80         unsigned int  swap:1;
  81         unsigned int  override:1;
  82         unsigned int  fixup:1; /* Means that this sku is set by driver, not read from hw */
  83 };
  84
  85 struct alc_spec {
  86         struct hda_gen_spec gen; /* must be at head */
  87
  88         /* codec parameterization */
  89         const struct snd_kcontrol_new *mixers[5];       /* mixer arrays */
  90         unsigned int num_mixers;
  91         unsigned int beep_amp;  /* beep amp value, set via set_beep_amp() */
  92
  93         struct alc_customize_define cdefine;
  94         unsigned int parse_flags; /* flag for snd_hda_parse_pin_defcfg() */
  95
  96         /* inverted dmic fix */
  97         unsigned int inv_dmic_fixup:1; /* has inverted digital-mic workaround */
  98         unsigned int inv_dmic_muted:1; /* R-ch of inv d-mic is muted? */
  99         hda_nid_t inv_dmic_pin;
 100
 101         /* mute LED for HP laptops, see alc269_fixup_mic_mute_hook() */
 102         int mute_led_polarity;
 103         hda_nid_t mute_led_nid;
 104
 105         unsigned int gpio_led; /* used for alc269_fixup_hp_gpio_led() */
 106
 107         hda_nid_t headset_mic_pin;
 108         hda_nid_t headphone_mic_pin;
 109         int current_headset_mode;
 110         int current_headset_type;
 111
 112         /* hooks */
 113         void (*init_hook)(struct hda_codec *codec);
 114 #ifdef CONFIG_PM
 115         void (*power_hook)(struct hda_codec *codec);
 116 #endif
 117         void (*shutup)(struct hda_codec *codec);
 118
 119         int init_amp;
 120         int codec_variant;      /* flag for other variants */
 121         unsigned int has_alc5505_dsp:1;
 122         unsigned int no_depop_delay:1;
 123
 124         /* for PLL fix */
 125         hda_nid_t pll_nid;
 126         unsigned int pll_coef_idx, pll_coef_bit;
 127         unsigned int coef0;
 128 };
 129
 130 /*
 131  * Append the given mixer and verb elements for the later use
 132  * The mixer array is referred in build_controls(), and init_verbs are
 133  * called in init().
 134  */
 135 static void add_mixer(struct alc_spec *spec, const struct snd_kcontrol_new *mix)
 136 {
 137         if (snd_BUG_ON(spec->num_mixers >= ARRAY_SIZE(spec->mixers)))
 138                 return;
 139         spec->mixers[spec->num_mixers++] = mix;
 140 }
 141
 142 /*
 143  * GPIO setup tables, used in initialization
 144  */
 145 /* Enable GPIO mask and set output */
 146 static const struct hda_verb alc_gpio1_init_verbs[] = {
 147         {0x01, AC_VERB_SET_GPIO_MASK, 0x01},
 148         {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x01},
 149         {0x01, AC_VERB_SET_GPIO_DATA, 0x01},
 150         { }
 151 };
 152
 153 static const struct hda_verb alc_gpio2_init_verbs[] = {
 154         {0x01, AC_VERB_SET_GPIO_MASK, 0x02},
 155         {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x02},
 156         {0x01, AC_VERB_SET_GPIO_DATA, 0x02},
 157         { }
 158 };
 159
 160 static const struct hda_verb alc_gpio3_init_verbs[] = {
 161         {0x01, AC_VERB_SET_GPIO_MASK, 0x03},
 162         {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x03},
 163         {0x01, AC_VERB_SET_GPIO_DATA, 0x03},
 164         { }
 165 };
 166
 167 /*
 168  * Fix hardware PLL issue
 169  * On some codecs, the analog PLL gating control must be off while
 170  * the default value is 1.
 171  */
 172 static void alc_fix_pll(struct hda_codec *codec)
 173 {
 174         struct alc_spec *spec = codec->spec;
 175         unsigned int val;
 176
 177         if (!spec->pll_nid)
 178                 return;
 179         snd_hda_codec_write(codec, spec->pll_nid, 0, AC_VERB_SET_COEF_INDEX,
 180                             spec->pll_coef_idx);
 181         val = snd_hda_codec_read(codec, spec->pll_nid, 0,
 182                                  AC_VERB_GET_PROC_COEF, 0);
 183         snd_hda_codec_write(codec, spec->pll_nid, 0, AC_VERB_SET_COEF_INDEX,
 184                             spec->pll_coef_idx);
 185         snd_hda_codec_write(codec, spec->pll_nid, 0, AC_VERB_SET_PROC_COEF,
 186                             val & ~(1 << spec->pll_coef_bit));
 187 }
 188
 189 static void alc_fix_pll_init(struct hda_codec *codec, hda_nid_t nid,
 190                              unsigned int coef_idx, unsigned int coef_bit)
 191 {
 192         struct alc_spec *spec = codec->spec;
 193         spec->pll_nid = nid;
 194         spec->pll_coef_idx = coef_idx;
 195         spec->pll_coef_bit = coef_bit;
 196         alc_fix_pll(codec);
 197 }
 198
 199 /* update the master volume per volume-knob's unsol event */
 200 static void alc_update_knob_master(struct hda_codec *codec, struct hda_jack_tbl *jack)
 201 {
 202         unsigned int val;
 203         struct snd_kcontrol *kctl;
 204         struct snd_ctl_elem_value *uctl;
 205
 206         kctl = snd_hda_find_mixer_ctl(codec, "Master Playback Volume");
 207         if (!kctl)
 208                 return;
 209         uctl = kzalloc(sizeof(*uctl), GFP_KERNEL);
 210         if (!uctl)
 211                 return;
 212         val = snd_hda_codec_read(codec, jack->nid, 0,
 213                                  AC_VERB_GET_VOLUME_KNOB_CONTROL, 0);
 214         val &= HDA_AMP_VOLMASK;
 215         uctl->value.integer.value[0] = val;
 216         uctl->value.integer.value[1] = val;
 217         kctl->put(kctl, uctl);
 218         kfree(uctl);
 219 }
 220
 221 static void alc880_unsol_event(struct hda_codec *codec, unsigned int res)
 222 {
 223         /* For some reason, the res given from ALC880 is broken.
 224            Here we adjust it properly. */
 225         snd_hda_jack_unsol_event(codec, res >> 2);
 226 }
 227
 228 /* additional initialization for ALC888 variants */
 229 static void alc888_coef_init(struct hda_codec *codec)
 230 {
 231         unsigned int tmp;
 232
 233         snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_COEF_INDEX, 0);
 234         tmp = snd_hda_codec_read(codec, 0x20, 0, AC_VERB_GET_PROC_COEF, 0);
 235         snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_COEF_INDEX, 7);
 236         if ((tmp & 0xf0) == 0x20)
 237                 /* alc888S-VC */
 238                 snd_hda_codec_read(codec, 0x20, 0,
 239                                    AC_VERB_SET_PROC_COEF, 0x830);
 240          else
 241                  /* alc888-VB */
 242                  snd_hda_codec_read(codec, 0x20, 0,
 243                                     AC_VERB_SET_PROC_COEF, 0x3030);
 244 }
 245
 246 /* additional initialization for ALC889 variants */
 247 static void alc889_coef_init(struct hda_codec *codec)
 248 {
 249         unsigned int tmp;
 250
 251         snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_COEF_INDEX, 7);
 252         tmp = snd_hda_codec_read(codec, 0x20, 0, AC_VERB_GET_PROC_COEF, 0);
 253         snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_COEF_INDEX, 7);
 254         snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_PROC_COEF, tmp|0x2010);
 255 }
 256
 257 /* turn on/off EAPD control (only if available) */
 258 static void set_eapd(struct hda_codec *codec, hda_nid_t nid, int on)
 259 {
 260         if (get_wcaps_type(get_wcaps(codec, nid)) != AC_WID_PIN)
 261                 return;
 262         if (snd_hda_query_pin_caps(codec, nid) & AC_PINCAP_EAPD)
 263                 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_EAPD_BTLENABLE,
 264                                     on ? 2 : 0);
 265 }
 266
 267 /* turn on/off EAPD controls of the codec */
 268 static void alc_auto_setup_eapd(struct hda_codec *codec, bool on)
 269 {
 270         /* We currently only handle front, HP */
 271         static hda_nid_t pins[] = {
 272                 0x0f, 0x10, 0x14, 0x15, 0
 273         };
 274         hda_nid_t *p;
 275         for (p = pins; *p; p++)
 276                 set_eapd(codec, *p, on);
 277 }
 278
 279 /* generic shutup callback;
 280  * just turning off EPAD and a little pause for avoiding pop-noise
 281  */
 282 static void alc_eapd_shutup(struct hda_codec *codec)
 283 {
 284         struct alc_spec *spec = codec->spec;
 285
 286         alc_auto_setup_eapd(codec, false);
 287         if (!spec->no_depop_delay)
 288                 msleep(200);
 289         snd_hda_shutup_pins(codec);
 290 }
 291
 292 /* generic EAPD initialization */
 293 static void alc_auto_init_amp(struct hda_codec *codec, int type)
 294 {
 295         unsigned int tmp;
 296
 297         alc_auto_setup_eapd(codec, true);
 298         switch (type) {
 299         case ALC_INIT_GPIO1:
 300                 snd_hda_sequence_write(codec, alc_gpio1_init_verbs);
 301                 break;
 302         case ALC_INIT_GPIO2:
 303                 snd_hda_sequence_write(codec, alc_gpio2_init_verbs);
 304                 break;
 305         case ALC_INIT_GPIO3:
 306                 snd_hda_sequence_write(codec, alc_gpio3_init_verbs);
 307                 break;
 308         case ALC_INIT_DEFAULT:
 309                 switch (codec->vendor_id) {
 310                 case 0x10ec0260:
 311                         snd_hda_codec_write(codec, 0x1a, 0,
 312                                             AC_VERB_SET_COEF_INDEX, 7);
 313                         tmp = snd_hda_codec_read(codec, 0x1a, 0,
 314                                                  AC_VERB_GET_PROC_COEF, 0);
 315                         snd_hda_codec_write(codec, 0x1a, 0,
 316                                             AC_VERB_SET_COEF_INDEX, 7);
 317                         snd_hda_codec_write(codec, 0x1a, 0,
 318                                             AC_VERB_SET_PROC_COEF,
 319                                             tmp | 0x2010);
 320                         break;
 321                 case 0x10ec0262:
 322                 case 0x10ec0880:
 323                 case 0x10ec0882:
 324                 case 0x10ec0883:
 325                 case 0x10ec0885:
 326                 case 0x10ec0887:
 327                 /*case 0x10ec0889:*/ /* this causes an SPDIF problem */
 328                         alc889_coef_init(codec);
 329                         break;
 330                 case 0x10ec0888:
 331                         alc888_coef_init(codec);
 332                         break;
 333 #if 0 /* XXX: This may cause the silent output on speaker on some machines */
 334                 case 0x10ec0267:
 335                 case 0x10ec0268:
 336                         snd_hda_codec_write(codec, 0x20, 0,
 337                                             AC_VERB_SET_COEF_INDEX, 7);
 338                         tmp = snd_hda_codec_read(codec, 0x20, 0,
 339                                                  AC_VERB_GET_PROC_COEF, 0);
 340                         snd_hda_codec_write(codec, 0x20, 0,
 341                                             AC_VERB_SET_COEF_INDEX, 7);
 342                         snd_hda_codec_write(codec, 0x20, 0,
 343                                             AC_VERB_SET_PROC_COEF,
 344                                             tmp | 0x3000);
 345                         break;
 346 #endif /* XXX */
 347                 }
 348                 break;
 349         }
 350 }
 351
 352
 353 /*
 354  * Realtek SSID verification
 355  */
 356
 357 /* Could be any non-zero and even value. When used as fixup, tells
 358  * the driver to ignore any present sku defines.
 359  */
 360 #define ALC_FIXUP_SKU_IGNORE (2)
 361
 362 static void alc_fixup_sku_ignore(struct hda_codec *codec,
 363                                  const struct hda_fixup *fix, int action)
 364 {
 365         struct alc_spec *spec = codec->spec;
 366         if (action == HDA_FIXUP_ACT_PRE_PROBE) {
 367                 spec->cdefine.fixup = 1;
 368                 spec->cdefine.sku_cfg = ALC_FIXUP_SKU_IGNORE;
 369         }
 370 }
 371
 372 static void alc_fixup_no_depop_delay(struct hda_codec *codec,
 373                                     const struct hda_fixup *fix, int action)
 374 {
 375         struct alc_spec *spec = codec->spec;
 376
 377         if (action == HDA_FIXUP_ACT_PROBE) {
 378                 spec->no_depop_delay = 1;
 379                 codec->depop_delay = 0;
 380         }
 381 }
 382
 383 static int alc_auto_parse_customize_define(struct hda_codec *codec)
 384 {
 385         unsigned int ass, tmp, i;
 386         unsigned nid = 0;
 387         struct alc_spec *spec = codec->spec;
 388
 389         spec->cdefine.enable_pcbeep = 1; /* assume always enabled */
 390
 391         if (spec->cdefine.fixup) {
 392                 ass = spec->cdefine.sku_cfg;
 393                 if (ass == ALC_FIXUP_SKU_IGNORE)
 394                         return -1;
 395                 goto do_sku;
 396         }
 397
 398         ass = codec->subsystem_id & 0xffff;
 399         if (ass != codec->bus->pci->subsystem_device && (ass & 1))
 400                 goto do_sku;
 401
 402         nid = 0x1d;
 403         if (codec->vendor_id == 0x10ec0260)
 404                 nid = 0x17;
 405         ass = snd_hda_codec_get_pincfg(codec, nid);
 406
 407         if (!(ass & 1)) {
 408                 printk(KERN_INFO "hda_codec: %s: SKU not ready 0x%08x\n",
 409                        codec->chip_name, ass);
 410                 return -1;
 411         }
 412
 413         /* check sum */
 414         tmp = 0;
 415         for (i = 1; i < 16; i++) {
 416                 if ((ass >> i) & 1)
 417                         tmp++;
 418         }
 419         if (((ass >> 16) & 0xf) != tmp)
 420                 return -1;
 421
 422         spec->cdefine.port_connectivity = ass >> 30;
 423         spec->cdefine.enable_pcbeep = (ass & 0x100000) >> 20;
 424         spec->cdefine.check_sum = (ass >> 16) & 0xf;
 425         spec->cdefine.customization = ass >> 8;
 426 do_sku:
 427         spec->cdefine.sku_cfg = ass;
 428         spec->cdefine.external_amp = (ass & 0x38) >> 3;
 429         spec->cdefine.platform_type = (ass & 0x4) >> 2;
 430         spec->cdefine.swap = (ass & 0x2) >> 1;
 431         spec->cdefine.override = ass & 0x1;
 432
 433         snd_printd("SKU: Nid=0x%x sku_cfg=0x%08x\n",
 434                    nid, spec->cdefine.sku_cfg);
 435         snd_printd("SKU: port_connectivity=0x%x\n",
 436                    spec->cdefine.port_connectivity);
 437         snd_printd("SKU: enable_pcbeep=0x%x\n", spec->cdefine.enable_pcbeep);
 438         snd_printd("SKU: check_sum=0x%08x\n", spec->cdefine.check_sum);
 439         snd_printd("SKU: customization=0x%08x\n", spec->cdefine.customization);
 440         snd_printd("SKU: external_amp=0x%x\n", spec->cdefine.external_amp);
 441         snd_printd("SKU: platform_type=0x%x\n", spec->cdefine.platform_type);
 442         snd_printd("SKU: swap=0x%x\n", spec->cdefine.swap);
 443         snd_printd("SKU: override=0x%x\n", spec->cdefine.override);
 444
 445         return 0;
 446 }
 447
 448 /* return the position of NID in the list, or -1 if not found */
 449 static int find_idx_in_nid_list(hda_nid_t nid, const hda_nid_t *list, int nums)
 450 {
 451         int i;
 452         for (i = 0; i < nums; i++)
 453                 if (list[i] == nid)
 454                         return i;
 455         return -1;
 456 }
 457 /* return true if the given NID is found in the list */
 458 static bool found_in_nid_list(hda_nid_t nid, const hda_nid_t *list, int nums)
 459 {
 460         return find_idx_in_nid_list(nid, list, nums) >= 0;
 461 }
 462
 463 /* check subsystem ID and set up device-specific initialization;
 464  * return 1 if initialized, 0 if invalid SSID
 465  */
 466 /* 32-bit subsystem ID for BIOS loading in HD Audio codec.
 467  *      31 ~ 16 :       Manufacture ID
 468  *      15 ~ 8  :       SKU ID
 469  *      7  ~ 0  :       Assembly ID
 470  *      port-A --> pin 39/41, port-E --> pin 14/15, port-D --> pin 35/36
 471  */
 472 static int alc_subsystem_id(struct hda_codec *codec,
 473                             hda_nid_t porta, hda_nid_t porte,
 474                             hda_nid_t portd, hda_nid_t porti)
 475 {
 476         unsigned int ass, tmp, i;
 477         unsigned nid;
 478         struct alc_spec *spec = codec->spec;
 479
 480         if (spec->cdefine.fixup) {
 481                 ass = spec->cdefine.sku_cfg;
 482                 if (ass == ALC_FIXUP_SKU_IGNORE)
 483                         return 0;
 484                 goto do_sku;
 485         }
 486
 487         ass = codec->subsystem_id & 0xffff;
 488         if ((ass != codec->bus->pci->subsystem_device) && (ass & 1))
 489                 goto do_sku;
 490
 491         /* invalid SSID, check the special NID pin defcfg instead */
 492         /*
 493          * 31~30        : port connectivity
 494          * 29~21        : reserve
 495          * 20           : PCBEEP input
 496          * 19~16        : Check sum (15:1)
 497          * 15~1         : Custom
 498          * 0            : override
 499         */
 500         nid = 0x1d;
 501         if (codec->vendor_id == 0x10ec0260)
 502                 nid = 0x17;
 503         ass = snd_hda_codec_get_pincfg(codec, nid);
 504         snd_printd("realtek: No valid SSID, "
 505                    "checking pincfg 0x%08x for NID 0x%x\n",
 506                    ass, nid);
 507         if (!(ass & 1))
 508                 return 0;
 509         if ((ass >> 30) != 1)   /* no physical connection */
 510                 return 0;
 511
 512         /* check sum */
 513         tmp = 0;
 514         for (i = 1; i < 16; i++) {
 515                 if ((ass >> i) & 1)
 516                         tmp++;
 517         }
 518         if (((ass >> 16) & 0xf) != tmp)
 519                 return 0;
 520 do_sku:
 521         snd_printd("realtek: Enabling init ASM_ID=0x%04x CODEC_ID=%08x\n",
 522                    ass & 0xffff, codec->vendor_id);
 523         /*
 524          * 0 : override
 525          * 1 :  Swap Jack
 526          * 2 : 0 --> Desktop, 1 --> Laptop
 527          * 3~5 : External Amplifier control
 528          * 7~6 : Reserved
 529         */
 530         tmp = (ass & 0x38) >> 3;        /* external Amp control */
 531         switch (tmp) {
 532         case 1:
 533                 spec->init_amp = ALC_INIT_GPIO1;
 534                 break;
 535         case 3:
 536                 spec->init_amp = ALC_INIT_GPIO2;
 537                 break;
 538         case 7:
 539                 spec->init_amp = ALC_INIT_GPIO3;
 540                 break;
 541         case 5:
 542         default:
 543                 spec->init_amp = ALC_INIT_DEFAULT;
 544                 break;
 545         }
 546
 547         /* is laptop or Desktop and enable the function "Mute internal speaker
 548          * when the external headphone out jack is plugged"
 549          */
 550         if (!(ass & 0x8000))
 551                 return 1;
 552         /*
 553          * 10~8 : Jack location
 554          * 12~11: Headphone out -> 00: PortA, 01: PortE, 02: PortD, 03: Resvered
 555          * 14~13: Resvered
 556          * 15   : 1 --> enable the function "Mute internal speaker
 557          *              when the external headphone out jack is plugged"
 558          */
 559         if (!spec->gen.autocfg.hp_pins[0] &&
 560             !(spec->gen.autocfg.line_out_pins[0] &&
 561               spec->gen.autocfg.line_out_type == AUTO_PIN_HP_OUT)) {
 562                 hda_nid_t nid;
 563                 tmp = (ass >> 11) & 0x3;        /* HP to chassis */
 564                 if (tmp == 0)
 565                         nid = porta;
 566                 else if (tmp == 1)
 567                         nid = porte;
 568                 else if (tmp == 2)
 569                         nid = portd;
 570                 else if (tmp == 3)
 571                         nid = porti;
 572                 if (found_in_nid_list(nid, spec->gen.autocfg.line_out_pins,
 573                                       spec->gen.autocfg.line_outs))
 574                         return 1;
 575                 spec->gen.autocfg.hp_pins[0] = nid;
 576         }
 577         return 1;
 578 }
 579
 580 /* Check the validity of ALC subsystem-id
 581  * ports contains an array of 4 pin NIDs for port-A, E, D and I */
 582 static void alc_ssid_check(struct hda_codec *codec, const hda_nid_t *ports)
 583 {
 584         if (!alc_subsystem_id(codec, ports[0], ports[1], ports[2], ports[3])) {
 585                 struct alc_spec *spec = codec->spec;
 586                 snd_printd("realtek: "
 587                            "Enable default setup for auto mode as fallback\n");
 588                 spec->init_amp = ALC_INIT_DEFAULT;
 589         }
 590 }
 591
 592 /*
 593  * COEF access helper functions
 594  */
 595
 596 static int alc_read_coefex_idx(struct hda_codec *codec,
 597                                         hda_nid_t nid,
 598                                         unsigned int coef_idx)
 599 {
 600         unsigned int val;
 601         snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_COEF_INDEX,
 602                                 coef_idx);
 603         val = snd_hda_codec_read(codec, nid, 0,
 604                                 AC_VERB_GET_PROC_COEF, 0);
 605         return val;
 606 }
 607
 608 #define alc_read_coef_idx(codec, coef_idx) \
 609         alc_read_coefex_idx(codec, 0x20, coef_idx)
 610
 611 static void alc_write_coefex_idx(struct hda_codec *codec, hda_nid_t nid,
 612                                                         unsigned int coef_idx,
 613                                                         unsigned int coef_val)
 614 {
 615         snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_COEF_INDEX,
 616                             coef_idx);
 617         snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_PROC_COEF,
 618                             coef_val);
 619 }
 620
 621 #define alc_write_coef_idx(codec, coef_idx, coef_val) \
 622         alc_write_coefex_idx(codec, 0x20, coef_idx, coef_val)
 623
 624 /* a special bypass for COEF 0; read the cached value at the second time */
 625 static unsigned int alc_get_coef0(struct hda_codec *codec)
 626 {
 627         struct alc_spec *spec = codec->spec;
 628         if (!spec->coef0)
 629                 spec->coef0 = alc_read_coef_idx(codec, 0);
 630         return spec->coef0;
 631 }
 632
 633 /*
 634  */
 635
 636 static hda_nid_t get_adc_nid(struct hda_codec *codec, int adc_idx, int imux_idx)
 637 {
 638         struct hda_gen_spec *spec = codec->spec;
 639         if (spec->dyn_adc_switch)
 640                 adc_idx = spec->dyn_adc_idx[imux_idx];
 641         return spec->adc_nids[adc_idx];
 642 }
 643
 644 static void alc_inv_dmic_sync_adc(struct hda_codec *codec, int adc_idx)
 645 {
 646         struct alc_spec *spec = codec->spec;
 647         struct hda_input_mux *imux = &spec->gen.input_mux;
 648         struct nid_path *path;
 649         hda_nid_t nid;
 650         int i, dir, parm;
 651         unsigned int val;
 652
 653         for (i = 0; i < imux->num_items; i++) {
 654                 if (spec->gen.imux_pins[i] == spec->inv_dmic_pin)
 655                         break;
 656         }
 657         if (i >= imux->num_items)
 658                 return;
 659
 660         path = snd_hda_get_nid_path(codec, spec->inv_dmic_pin,
 661                                     get_adc_nid(codec, adc_idx, i));
 662         val = path->ctls[NID_PATH_MUTE_CTL];
 663         if (!val)
 664                 return;
 665         nid = get_amp_nid_(val);
 666         dir = get_amp_direction_(val);
 667         parm = AC_AMP_SET_RIGHT |
 668                 (dir == HDA_OUTPUT ? AC_AMP_SET_OUTPUT : AC_AMP_SET_INPUT);
 669
 670         /* flush all cached amps at first */
 671         snd_hda_codec_flush_cache(codec);
 672
 673         /* we care only right channel */
 674         val = snd_hda_codec_amp_read(codec, nid, 1, dir, 0);
 675         if (val & 0x80) /* if already muted, we don't need to touch */
 676                 return;
 677         val |= 0x80;
 678         snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_AMP_GAIN_MUTE,
 679                             parm | val);
 680 }
 681
 682 /*
 683  * Inverted digital-mic handling
 684  *
 685  * First off, it's a bit tricky.  The "Inverted Internal Mic Capture Switch"
 686  * gives the additional mute only to the right channel of the digital mic
 687  * capture stream.  This is a workaround for avoiding the almost silence
 688  * by summing the stereo stream from some (known to be ForteMedia)
 689  * digital mic unit.
 690  *
 691  * The logic is to call alc_inv_dmic_sync() after each action (possibly)
 692  * modifying ADC amp.  When the mute flag is set, it mutes the R-channel
 693  * without caching so that the cache can still keep the original value.
 694  * The cached value is then restored when the flag is set off or any other
 695  * than d-mic is used as the current input source.
 696  */
 697 static void alc_inv_dmic_sync(struct hda_codec *codec, bool force)
 698 {
 699         struct alc_spec *spec = codec->spec;
 700         int src, nums;
 701
 702         if (!spec->inv_dmic_fixup)
 703                 return;
 704         if (!spec->inv_dmic_muted && !force)
 705                 return;
 706         nums = spec->gen.dyn_adc_switch ? 1 : spec->gen.num_adc_nids;
 707         for (src = 0; src < nums; src++) {
 708                 bool dmic_fixup = false;
 709
 710                 if (spec->inv_dmic_muted &&
 711                     spec->gen.imux_pins[spec->gen.cur_mux[src]] == spec->inv_dmic_pin)
 712                         dmic_fixup = true;
 713                 if (!dmic_fixup && !force)
 714                         continue;
 715                 alc_inv_dmic_sync_adc(codec, src);
 716         }
 717 }
 718
 719 static void alc_inv_dmic_hook(struct hda_codec *codec,
 720                              struct snd_ctl_elem_value *ucontrol)
 721 {
 722         alc_inv_dmic_sync(codec, false);
 723 }
 724
 725 static int alc_inv_dmic_sw_get(struct snd_kcontrol *kcontrol,
 726                                struct snd_ctl_elem_value *ucontrol)
 727 {
 728         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 729         struct alc_spec *spec = codec->spec;
 730
 731         ucontrol->value.integer.value[0] = !spec->inv_dmic_muted;
 732         return 0;
 733 }
 734
 735 static int alc_inv_dmic_sw_put(struct snd_kcontrol *kcontrol,
 736                                struct snd_ctl_elem_value *ucontrol)
 737 {
 738         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 739         struct alc_spec *spec = codec->spec;
 740         unsigned int val = !ucontrol->value.integer.value[0];
 741
 742         if (val == spec->inv_dmic_muted)
 743                 return 0;
 744         spec->inv_dmic_muted = val;
 745         alc_inv_dmic_sync(codec, true);
 746         return 0;
 747 }
 748
 749 static const struct snd_kcontrol_new alc_inv_dmic_sw = {
 750         .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
 751         .name = "Inverted Internal Mic Capture Switch",
 752         .info = snd_ctl_boolean_mono_info,
 753         .get = alc_inv_dmic_sw_get,
 754         .put = alc_inv_dmic_sw_put,
 755 };
 756
 757 static int alc_add_inv_dmic_mixer(struct hda_codec *codec, hda_nid_t nid)
 758 {
 759         struct alc_spec *spec = codec->spec;
 760
 761         if (!snd_hda_gen_add_kctl(&spec->gen, NULL, &alc_inv_dmic_sw))
 762                 return -ENOMEM;
 763         spec->inv_dmic_fixup = 1;
 764         spec->inv_dmic_muted = 0;
 765         spec->inv_dmic_pin = nid;
 766         spec->gen.cap_sync_hook = alc_inv_dmic_hook;
 767         return 0;
 768 }
 769
 770 /* typically the digital mic is put at node 0x12 */
 771 static void alc_fixup_inv_dmic_0x12(struct hda_codec *codec,
 772                                     const struct hda_fixup *fix, int action)
 773 {
 774         if (action == HDA_FIXUP_ACT_PROBE)
 775                 alc_add_inv_dmic_mixer(codec, 0x12);
 776 }
 777
 778
 779 #ifdef CONFIG_SND_HDA_INPUT_BEEP
 780 /* additional beep mixers; the actual parameters are overwritten at build */
 781 static const struct snd_kcontrol_new alc_beep_mixer[] = {
 782         HDA_CODEC_VOLUME("Beep Playback Volume", 0, 0, HDA_INPUT),
 783         HDA_CODEC_MUTE_BEEP("Beep Playback Switch", 0, 0, HDA_INPUT),
 784         { } /* end */
 785 };
 786 #endif
 787
 788 static int alc_build_controls(struct hda_codec *codec)
 789 {
 790         struct alc_spec *spec = codec->spec;
 791         int i, err;
 792
 793         err = snd_hda_gen_build_controls(codec);
 794         if (err < 0)
 795                 return err;
 796
 797         for (i = 0; i < spec->num_mixers; i++) {
 798                 err = snd_hda_add_new_ctls(codec, spec->mixers[i]);
 799                 if (err < 0)
 800                         return err;
 801         }
 802
 803 #ifdef CONFIG_SND_HDA_INPUT_BEEP
 804         /* create beep controls if needed */
 805         if (spec->beep_amp) {
 806                 const struct snd_kcontrol_new *knew;
 807                 for (knew = alc_beep_mixer; knew->name; knew++) {
 808                         struct snd_kcontrol *kctl;
 809                         kctl = snd_ctl_new1(knew, codec);
 810                         if (!kctl)
 811                                 return -ENOMEM;
 812                         kctl->private_value = spec->beep_amp;
 813                         err = snd_hda_ctl_add(codec, 0, kctl);
 814                         if (err < 0)
 815                                 return err;
 816                 }
 817         }
 818 #endif
 819
 820         snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_BUILD);
 821         return 0;
 822 }
 823
 824
 825 /*
 826  * Common callbacks
 827  */
 828
 829 static int alc_init(struct hda_codec *codec)
 830 {
 831         struct alc_spec *spec = codec->spec;
 832
 833         if (spec->init_hook)
 834                 spec->init_hook(codec);
 835
 836         alc_fix_pll(codec);
 837         alc_auto_init_amp(codec, spec->init_amp);
 838
 839         snd_hda_gen_init(codec);
 840
 841         snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_INIT);
 842
 843         return 0;
 844 }
 845
 846 static inline void alc_shutup(struct hda_codec *codec)
 847 {
 848         struct alc_spec *spec = codec->spec;
 849
 850         if (spec && spec->shutup)
 851                 spec->shutup(codec);
 852         else
 853                 snd_hda_shutup_pins(codec);
 854 }
 855
 856 static void alc_free(struct hda_codec *codec)
 857 {
 858         snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_FREE);
 859         snd_hda_gen_free(codec);
 860 }
 861
 862 #ifdef CONFIG_PM
 863 static void alc_power_eapd(struct hda_codec *codec)
 864 {
 865         alc_auto_setup_eapd(codec, false);
 866 }
 867
 868 static int alc_suspend(struct hda_codec *codec)
 869 {
 870         struct alc_spec *spec = codec->spec;
 871         alc_shutup(codec);
 872         if (spec && spec->power_hook)
 873                 spec->power_hook(codec);
 874         return 0;
 875 }
 876 #endif
 877
 878 #ifdef CONFIG_PM
 879 static int alc_resume(struct hda_codec *codec)
 880 {
 881         struct alc_spec *spec = codec->spec;
 882
 883         if (!spec->no_depop_delay)
 884                 msleep(150); /* to avoid pop noise */
 885         codec->patch_ops.init(codec);
 886         snd_hda_codec_resume_amp(codec);
 887         snd_hda_codec_resume_cache(codec);
 888         alc_inv_dmic_sync(codec, true);
 889         hda_call_check_power_status(codec, 0x01);
 890         return 0;
 891 }
 892 #endif
 893
 894 /*
 895  */
 896 static const struct hda_codec_ops alc_patch_ops = {
 897         .build_controls = alc_build_controls,
 898         .build_pcms = snd_hda_gen_build_pcms,
 899         .init = alc_init,
 900         .free = alc_free,
 901         .unsol_event = snd_hda_jack_unsol_event,
 902 #ifdef CONFIG_PM
 903         .resume = alc_resume,
 904         .suspend = alc_suspend,
 905         .check_power_status = snd_hda_gen_check_power_status,
 906 #endif
 907         .reboot_notify = alc_shutup,
 908 };
 909
 910
 911 /* replace the codec chip_name with the given string */
 912 static int alc_codec_rename(struct hda_codec *codec, const char *name)
 913 {
 914         kfree(codec->chip_name);
 915         codec->chip_name = kstrdup(name, GFP_KERNEL);
 916         if (!codec->chip_name) {
 917                 alc_free(codec);
 918                 return -ENOMEM;
 919         }
 920         return 0;
 921 }
 922
 923 /*
 924  * Rename codecs appropriately from COEF value or subvendor id
 925  */
 926 struct alc_codec_rename_table {
 927         unsigned int vendor_id;
 928         unsigned short coef_mask;
 929         unsigned short coef_bits;
 930         const char *name;
 931 };
 932
 933 struct alc_codec_rename_pci_table {
 934         unsigned int codec_vendor_id;
 935         unsigned short pci_subvendor;
 936         unsigned short pci_subdevice;
 937         const char *name;
 938 };
 939
 940 static struct alc_codec_rename_table rename_tbl[] = {
 941         { 0x10ec0269, 0xfff0, 0x3010, "ALC277" },
 942         { 0x10ec0269, 0xf0f0, 0x2010, "ALC259" },
 943         { 0x10ec0269, 0xf0f0, 0x3010, "ALC258" },
 944         { 0x10ec0269, 0x00f0, 0x0010, "ALC269VB" },
 945         { 0x10ec0269, 0xffff, 0xa023, "ALC259" },
 946         { 0x10ec0269, 0xffff, 0x6023, "ALC281X" },
 947         { 0x10ec0269, 0x00f0, 0x0020, "ALC269VC" },
 948         { 0x10ec0269, 0x00f0, 0x0030, "ALC269VD" },
 949         { 0x10ec0887, 0x00f0, 0x0030, "ALC887-VD" },
 950         { 0x10ec0888, 0x00f0, 0x0030, "ALC888-VD" },
 951         { 0x10ec0888, 0xf0f0, 0x3020, "ALC886" },
 952         { 0x10ec0899, 0x2000, 0x2000, "ALC899" },
 953         { 0x10ec0892, 0xffff, 0x8020, "ALC661" },
 954         { 0x10ec0892, 0xffff, 0x8011, "ALC661" },
 955         { 0x10ec0892, 0xffff, 0x4011, "ALC656" },
 956         { } /* terminator */
 957 };
 958
 959 static struct alc_codec_rename_pci_table rename_pci_tbl[] = {
 960         { 0x10ec0280, 0x1028, 0, "ALC3220" },
 961         { 0x10ec0282, 0x1028, 0, "ALC3221" },
 962         { 0x10ec0283, 0x1028, 0, "ALC3223" },
 963         { 0x10ec0292, 0x1028, 0, "ALC3226" },
 964         { 0x10ec0255, 0x1028, 0, "ALC3234" },
 965         { 0x10ec0668, 0x1028, 0, "ALC3661" },
 966         { } /* terminator */
 967 };
 968
 969 static int alc_codec_rename_from_preset(struct hda_codec *codec)
 970 {
 971         const struct alc_codec_rename_table *p;
 972         const struct alc_codec_rename_pci_table *q;
 973
 974         for (p = rename_tbl; p->vendor_id; p++) {
 975                 if (p->vendor_id != codec->vendor_id)
 976                         continue;
 977                 if ((alc_get_coef0(codec) & p->coef_mask) == p->coef_bits)
 978                         return alc_codec_rename(codec, p->name);
 979         }
 980
 981         for (q = rename_pci_tbl; q->codec_vendor_id; q++) {
 982                 if (q->codec_vendor_id != codec->vendor_id)
 983                         continue;
 984                 if (q->pci_subvendor != codec->bus->pci->subsystem_vendor)
 985                         continue;
 986                 if (!q->pci_subdevice ||
 987                     q->pci_subdevice == codec->bus->pci->subsystem_device)
 988                         return alc_codec_rename(codec, q->name);
 989         }
 990
 991         return 0;
 992 }
 993
 994
 995 /*
 996  * Digital-beep handlers
 997  */
 998 #ifdef CONFIG_SND_HDA_INPUT_BEEP
 999 #define set_beep_amp(spec, nid, idx, dir) \
1000         ((spec)->beep_amp = HDA_COMPOSE_AMP_VAL(nid, 3, idx, dir))
1001
1002 static const struct snd_pci_quirk beep_white_list[] = {
1003         SND_PCI_QUIRK(0x1043, 0x103c, "ASUS", 1),
1004         SND_PCI_QUIRK(0x1043, 0x829f, "ASUS", 1),
1005         SND_PCI_QUIRK(0x1043, 0x8376, "EeePC", 1),
1006         SND_PCI_QUIRK(0x1043, 0x83ce, "EeePC", 1),
1007         SND_PCI_QUIRK(0x1043, 0x831a, "EeePC", 1),
1008         SND_PCI_QUIRK(0x1043, 0x834a, "EeePC", 1),
1009         SND_PCI_QUIRK(0x1458, 0xa002, "GA-MA790X", 1),
1010         SND_PCI_QUIRK(0x8086, 0xd613, "Intel", 1),
1011         {}
1012 };
1013
1014 static inline int has_cdefine_beep(struct hda_codec *codec)
1015 {
1016         struct alc_spec *spec = codec->spec;
1017         const struct snd_pci_quirk *q;
1018         q = snd_pci_quirk_lookup(codec->bus->pci, beep_white_list);
1019         if (q)
1020                 return q->value;
1021         return spec->cdefine.enable_pcbeep;
1022 }
1023 #else
1024 #define set_beep_amp(spec, nid, idx, dir) /* NOP */
1025 #define has_cdefine_beep(codec)         0
1026 #endif
1027
1028 /* parse the BIOS configuration and set up the alc_spec */
1029 /* return 1 if successful, 0 if the proper config is not found,
1030  * or a negative error code
1031  */
1032 static int alc_parse_auto_config(struct hda_codec *codec,
1033                                  const hda_nid_t *ignore_nids,
1034                                  const hda_nid_t *ssid_nids)
1035 {
1036         struct alc_spec *spec = codec->spec;
1037         struct auto_pin_cfg *cfg = &spec->gen.autocfg;
1038         int err;
1039
1040         err = snd_hda_parse_pin_defcfg(codec, cfg, ignore_nids,
1041                                        spec->parse_flags);
1042         if (err < 0)
1043                 return err;
1044
1045         if (ssid_nids)
1046                 alc_ssid_check(codec, ssid_nids);
1047
1048         err = snd_hda_gen_parse_auto_config(codec, cfg);
1049         if (err < 0)
1050                 return err;
1051
1052         return 1;
1053 }
1054
1055 /* common preparation job for alc_spec */
1056 static int alc_alloc_spec(struct hda_codec *codec, hda_nid_t mixer_nid)
1057 {
1058         struct alc_spec *spec = kzalloc(sizeof(*spec), GFP_KERNEL);
1059         int err;
1060
1061         if (!spec)
1062                 return -ENOMEM;
1063         codec->spec = spec;
1064         snd_hda_gen_spec_init(&spec->gen);
1065         spec->gen.mixer_nid = mixer_nid;
1066         spec->gen.own_eapd_ctl = 1;
1067         codec->single_adc_amp = 1;
1068         /* FIXME: do we need this for all Realtek codec models? */
1069         codec->spdif_status_reset = 1;
1070
1071         err = alc_codec_rename_from_preset(codec);
1072         if (err < 0) {
1073                 kfree(spec);
1074                 return err;
1075         }
1076         return 0;
1077 }
1078
1079 static int alc880_parse_auto_config(struct hda_codec *codec)
1080 {
1081         static const hda_nid_t alc880_ignore[] = { 0x1d, 0 };
1082         static const hda_nid_t alc880_ssids[] = { 0x15, 0x1b, 0x14, 0 };
1083         return alc_parse_auto_config(codec, alc880_ignore, alc880_ssids);
1084 }
1085
1086 /*
1087  * ALC880 fix-ups
1088  */
1089 enum {
1090         ALC880_FIXUP_GPIO1,
1091         ALC880_FIXUP_GPIO2,
1092         ALC880_FIXUP_MEDION_RIM,
1093         ALC880_FIXUP_LG,
1094         ALC880_FIXUP_LG_LW25,
1095         ALC880_FIXUP_W810,
1096         ALC880_FIXUP_EAPD_COEF,
1097         ALC880_FIXUP_TCL_S700,
1098         ALC880_FIXUP_VOL_KNOB,
1099         ALC880_FIXUP_FUJITSU,
1100         ALC880_FIXUP_F1734,
1101         ALC880_FIXUP_UNIWILL,
1102         ALC880_FIXUP_UNIWILL_DIG,
1103         ALC880_FIXUP_Z71V,
1104         ALC880_FIXUP_ASUS_W5A,
1105         ALC880_FIXUP_3ST_BASE,
1106         ALC880_FIXUP_3ST,
1107         ALC880_FIXUP_3ST_DIG,
1108         ALC880_FIXUP_5ST_BASE,
1109         ALC880_FIXUP_5ST,
1110         ALC880_FIXUP_5ST_DIG,
1111         ALC880_FIXUP_6ST_BASE,
1112         ALC880_FIXUP_6ST,
1113         ALC880_FIXUP_6ST_DIG,
1114         ALC880_FIXUP_6ST_AUTOMUTE,
1115 };
1116
1117 /* enable the volume-knob widget support on NID 0x21 */
1118 static void alc880_fixup_vol_knob(struct hda_codec *codec,
1119                                   const struct hda_fixup *fix, int action)
1120 {
1121         if (action == HDA_FIXUP_ACT_PROBE)
1122                 snd_hda_jack_detect_enable_callback(codec, 0x21, ALC_DCVOL_EVENT, alc_update_knob_master);
1123 }
1124
1125 static const struct hda_fixup alc880_fixups[] = {
1126         [ALC880_FIXUP_GPIO1] = {
1127                 .type = HDA_FIXUP_VERBS,
1128                 .v.verbs = alc_gpio1_init_verbs,
1129         },
1130         [ALC880_FIXUP_GPIO2] = {
1131                 .type = HDA_FIXUP_VERBS,
1132                 .v.verbs = alc_gpio2_init_verbs,
1133         },
1134         [ALC880_FIXUP_MEDION_RIM] = {
1135                 .type = HDA_FIXUP_VERBS,
1136                 .v.verbs = (const struct hda_verb[]) {
1137                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x07 },
1138                         { 0x20, AC_VERB_SET_PROC_COEF,  0x3060 },
1139                         { }
1140                 },
1141                 .chained = true,
1142                 .chain_id = ALC880_FIXUP_GPIO2,
1143         },
1144         [ALC880_FIXUP_LG] = {
1145                 .type = HDA_FIXUP_PINS,
1146                 .v.pins = (const struct hda_pintbl[]) {
1147                         /* disable bogus unused pins */
1148                         { 0x16, 0x411111f0 },
1149                         { 0x18, 0x411111f0 },
1150                         { 0x1a, 0x411111f0 },
1151                         { }
1152                 }
1153         },
1154         [ALC880_FIXUP_LG_LW25] = {
1155                 .type = HDA_FIXUP_PINS,
1156                 .v.pins = (const struct hda_pintbl[]) {
1157                         { 0x1a, 0x0181344f }, /* line-in */
1158                         { 0x1b, 0x0321403f }, /* headphone */
1159                         { }
1160                 }
1161         },
1162         [ALC880_FIXUP_W810] = {
1163                 .type = HDA_FIXUP_PINS,
1164                 .v.pins = (const struct hda_pintbl[]) {
1165                         /* disable bogus unused pins */
1166                         { 0x17, 0x411111f0 },
1167                         { }
1168                 },
1169                 .chained = true,
1170                 .chain_id = ALC880_FIXUP_GPIO2,
1171         },
1172         [ALC880_FIXUP_EAPD_COEF] = {
1173                 .type = HDA_FIXUP_VERBS,
1174                 .v.verbs = (const struct hda_verb[]) {
1175                         /* change to EAPD mode */
1176                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x07 },
1177                         { 0x20, AC_VERB_SET_PROC_COEF,  0x3060 },
1178                         {}
1179                 },
1180         },
1181         [ALC880_FIXUP_TCL_S700] = {
1182                 .type = HDA_FIXUP_VERBS,
1183                 .v.verbs = (const struct hda_verb[]) {
1184                         /* change to EAPD mode */
1185                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x07 },
1186                         { 0x20, AC_VERB_SET_PROC_COEF,  0x3070 },
1187                         {}
1188                 },
1189                 .chained = true,
1190                 .chain_id = ALC880_FIXUP_GPIO2,
1191         },
1192         [ALC880_FIXUP_VOL_KNOB] = {
1193                 .type = HDA_FIXUP_FUNC,
1194                 .v.func = alc880_fixup_vol_knob,
1195         },
1196         [ALC880_FIXUP_FUJITSU] = {
1197                 /* override all pins as BIOS on old Amilo is broken */
1198                 .type = HDA_FIXUP_PINS,
1199                 .v.pins = (const struct hda_pintbl[]) {
1200                         { 0x14, 0x0121411f }, /* HP */
1201                         { 0x15, 0x99030120 }, /* speaker */
1202                         { 0x16, 0x99030130 }, /* bass speaker */
1203                         { 0x17, 0x411111f0 }, /* N/A */
1204                         { 0x18, 0x411111f0 }, /* N/A */
1205                         { 0x19, 0x01a19950 }, /* mic-in */
1206                         { 0x1a, 0x411111f0 }, /* N/A */
1207                         { 0x1b, 0x411111f0 }, /* N/A */
1208                         { 0x1c, 0x411111f0 }, /* N/A */
1209                         { 0x1d, 0x411111f0 }, /* N/A */
1210                         { 0x1e, 0x01454140 }, /* SPDIF out */
1211                         { }
1212                 },
1213                 .chained = true,
1214                 .chain_id = ALC880_FIXUP_VOL_KNOB,
1215         },
1216         [ALC880_FIXUP_F1734] = {
1217                 /* almost compatible with FUJITSU, but no bass and SPDIF */
1218                 .type = HDA_FIXUP_PINS,
1219                 .v.pins = (const struct hda_pintbl[]) {
1220                         { 0x14, 0x0121411f }, /* HP */
1221                         { 0x15, 0x99030120 }, /* speaker */
1222                         { 0x16, 0x411111f0 }, /* N/A */
1223                         { 0x17, 0x411111f0 }, /* N/A */
1224                         { 0x18, 0x411111f0 }, /* N/A */
1225                         { 0x19, 0x01a19950 }, /* mic-in */
1226                         { 0x1a, 0x411111f0 }, /* N/A */
1227                         { 0x1b, 0x411111f0 }, /* N/A */
1228                         { 0x1c, 0x411111f0 }, /* N/A */
1229                         { 0x1d, 0x411111f0 }, /* N/A */
1230                         { 0x1e, 0x411111f0 }, /* N/A */
1231                         { }
1232                 },
1233                 .chained = true,
1234                 .chain_id = ALC880_FIXUP_VOL_KNOB,
1235         },
1236         [ALC880_FIXUP_UNIWILL] = {
1237                 /* need to fix HP and speaker pins to be parsed correctly */
1238                 .type = HDA_FIXUP_PINS,
1239                 .v.pins = (const struct hda_pintbl[]) {
1240                         { 0x14, 0x0121411f }, /* HP */
1241                         { 0x15, 0x99030120 }, /* speaker */
1242                         { 0x16, 0x99030130 }, /* bass speaker */
1243                         { }
1244                 },
1245         },
1246         [ALC880_FIXUP_UNIWILL_DIG] = {
1247                 .type = HDA_FIXUP_PINS,
1248                 .v.pins = (const struct hda_pintbl[]) {
1249                         /* disable bogus unused pins */
1250                         { 0x17, 0x411111f0 },
1251                         { 0x19, 0x411111f0 },
1252                         { 0x1b, 0x411111f0 },
1253                         { 0x1f, 0x411111f0 },
1254                         { }
1255                 }
1256         },
1257         [ALC880_FIXUP_Z71V] = {
1258                 .type = HDA_FIXUP_PINS,
1259                 .v.pins = (const struct hda_pintbl[]) {
1260                         /* set up the whole pins as BIOS is utterly broken */
1261                         { 0x14, 0x99030120 }, /* speaker */
1262                         { 0x15, 0x0121411f }, /* HP */
1263                         { 0x16, 0x411111f0 }, /* N/A */
1264                         { 0x17, 0x411111f0 }, /* N/A */
1265                         { 0x18, 0x01a19950 }, /* mic-in */
1266                         { 0x19, 0x411111f0 }, /* N/A */
1267                         { 0x1a, 0x01813031 }, /* line-in */
1268                         { 0x1b, 0x411111f0 }, /* N/A */
1269                         { 0x1c, 0x411111f0 }, /* N/A */
1270                         { 0x1d, 0x411111f0 }, /* N/A */
1271                         { 0x1e, 0x0144111e }, /* SPDIF */
1272                         { }
1273                 }
1274         },
1275         [ALC880_FIXUP_ASUS_W5A] = {
1276                 .type = HDA_FIXUP_PINS,
1277                 .v.pins = (const struct hda_pintbl[]) {
1278                         /* set up the whole pins as BIOS is utterly broken */
1279                         { 0x14, 0x0121411f }, /* HP */
1280                         { 0x15, 0x411111f0 }, /* N/A */
1281                         { 0x16, 0x411111f0 }, /* N/A */
1282                         { 0x17, 0x411111f0 }, /* N/A */
1283                         { 0x18, 0x90a60160 }, /* mic */
1284                         { 0x19, 0x411111f0 }, /* N/A */
1285                         { 0x1a, 0x411111f0 }, /* N/A */
1286                         { 0x1b, 0x411111f0 }, /* N/A */
1287                         { 0x1c, 0x411111f0 }, /* N/A */
1288                         { 0x1d, 0x411111f0 }, /* N/A */
1289                         { 0x1e, 0xb743111e }, /* SPDIF out */
1290                         { }
1291                 },
1292                 .chained = true,
1293                 .chain_id = ALC880_FIXUP_GPIO1,
1294         },
1295         [ALC880_FIXUP_3ST_BASE] = {
1296                 .type = HDA_FIXUP_PINS,
1297                 .v.pins = (const struct hda_pintbl[]) {
1298                         { 0x14, 0x01014010 }, /* line-out */
1299                         { 0x15, 0x411111f0 }, /* N/A */
1300                         { 0x16, 0x411111f0 }, /* N/A */
1301                         { 0x17, 0x411111f0 }, /* N/A */
1302                         { 0x18, 0x01a19c30 }, /* mic-in */
1303                         { 0x19, 0x0121411f }, /* HP */
1304                         { 0x1a, 0x01813031 }, /* line-in */
1305                         { 0x1b, 0x02a19c40 }, /* front-mic */
1306                         { 0x1c, 0x411111f0 }, /* N/A */
1307                         { 0x1d, 0x411111f0 }, /* N/A */
1308                         /* 0x1e is filled in below */
1309                         { 0x1f, 0x411111f0 }, /* N/A */
1310                         { }
1311                 }
1312         },
1313         [ALC880_FIXUP_3ST] = {
1314                 .type = HDA_FIXUP_PINS,
1315                 .v.pins = (const struct hda_pintbl[]) {
1316                         { 0x1e, 0x411111f0 }, /* N/A */
1317                         { }
1318                 },
1319                 .chained = true,
1320                 .chain_id = ALC880_FIXUP_3ST_BASE,
1321         },
1322         [ALC880_FIXUP_3ST_DIG] = {
1323                 .type = HDA_FIXUP_PINS,
1324                 .v.pins = (const struct hda_pintbl[]) {
1325                         { 0x1e, 0x0144111e }, /* SPDIF */
1326                         { }
1327                 },
1328                 .chained = true,
1329                 .chain_id = ALC880_FIXUP_3ST_BASE,
1330         },
1331         [ALC880_FIXUP_5ST_BASE] = {
1332                 .type = HDA_FIXUP_PINS,
1333                 .v.pins = (const struct hda_pintbl[]) {
1334                         { 0x14, 0x01014010 }, /* front */
1335                         { 0x15, 0x411111f0 }, /* N/A */
1336                         { 0x16, 0x01011411 }, /* CLFE */
1337                         { 0x17, 0x01016412 }, /* surr */
1338                         { 0x18, 0x01a19c30 }, /* mic-in */
1339                         { 0x19, 0x0121411f }, /* HP */
1340                         { 0x1a, 0x01813031 }, /* line-in */
1341                         { 0x1b, 0x02a19c40 }, /* front-mic */
1342                         { 0x1c, 0x411111f0 }, /* N/A */
1343                         { 0x1d, 0x411111f0 }, /* N/A */
1344                         /* 0x1e is filled in below */
1345                         { 0x1f, 0x411111f0 }, /* N/A */
1346                         { }
1347                 }
1348         },
1349         [ALC880_FIXUP_5ST] = {
1350                 .type = HDA_FIXUP_PINS,
1351                 .v.pins = (const struct hda_pintbl[]) {
1352                         { 0x1e, 0x411111f0 }, /* N/A */
1353                         { }
1354                 },
1355                 .chained = true,
1356                 .chain_id = ALC880_FIXUP_5ST_BASE,
1357         },
1358         [ALC880_FIXUP_5ST_DIG] = {
1359                 .type = HDA_FIXUP_PINS,
1360                 .v.pins = (const struct hda_pintbl[]) {
1361                         { 0x1e, 0x0144111e }, /* SPDIF */
1362                         { }
1363                 },
1364                 .chained = true,
1365                 .chain_id = ALC880_FIXUP_5ST_BASE,
1366         },
1367         [ALC880_FIXUP_6ST_BASE] = {
1368                 .type = HDA_FIXUP_PINS,
1369                 .v.pins = (const struct hda_pintbl[]) {
1370                         { 0x14, 0x01014010 }, /* front */
1371                         { 0x15, 0x01016412 }, /* surr */
1372                         { 0x16, 0x01011411 }, /* CLFE */
1373                         { 0x17, 0x01012414 }, /* side */
1374                         { 0x18, 0x01a19c30 }, /* mic-in */
1375                         { 0x19, 0x02a19c40 }, /* front-mic */
1376                         { 0x1a, 0x01813031 }, /* line-in */
1377                         { 0x1b, 0x0121411f }, /* HP */
1378                         { 0x1c, 0x411111f0 }, /* N/A */
1379                         { 0x1d, 0x411111f0 }, /* N/A */
1380                         /* 0x1e is filled in below */
1381                         { 0x1f, 0x411111f0 }, /* N/A */
1382                         { }
1383                 }
1384         },
1385         [ALC880_FIXUP_6ST] = {
1386                 .type = HDA_FIXUP_PINS,
1387                 .v.pins = (const struct hda_pintbl[]) {
1388                         { 0x1e, 0x411111f0 }, /* N/A */
1389                         { }
1390                 },
1391                 .chained = true,
1392                 .chain_id = ALC880_FIXUP_6ST_BASE,
1393         },
1394         [ALC880_FIXUP_6ST_DIG] = {
1395                 .type = HDA_FIXUP_PINS,
1396                 .v.pins = (const struct hda_pintbl[]) {
1397                         { 0x1e, 0x0144111e }, /* SPDIF */
1398                         { }
1399                 },
1400                 .chained = true,
1401                 .chain_id = ALC880_FIXUP_6ST_BASE,
1402         },
1403         [ALC880_FIXUP_6ST_AUTOMUTE] = {
1404                 .type = HDA_FIXUP_PINS,
1405                 .v.pins = (const struct hda_pintbl[]) {
1406                         { 0x1b, 0x0121401f }, /* HP with jack detect */
1407                         { }
1408                 },
1409                 .chained_before = true,
1410                 .chain_id = ALC880_FIXUP_6ST_BASE,
1411         },
1412 };
1413
1414 static const struct snd_pci_quirk alc880_fixup_tbl[] = {
1415         SND_PCI_QUIRK(0x1019, 0x0f69, "Coeus G610P", ALC880_FIXUP_W810),
1416         SND_PCI_QUIRK(0x1043, 0x10c3, "ASUS W5A", ALC880_FIXUP_ASUS_W5A),
1417         SND_PCI_QUIRK(0x1043, 0x1964, "ASUS Z71V", ALC880_FIXUP_Z71V),
1418         SND_PCI_QUIRK_VENDOR(0x1043, "ASUS", ALC880_FIXUP_GPIO1),
1419         SND_PCI_QUIRK(0x1558, 0x5401, "Clevo GPIO2", ALC880_FIXUP_GPIO2),
1420         SND_PCI_QUIRK_VENDOR(0x1558, "Clevo", ALC880_FIXUP_EAPD_COEF),
1421         SND_PCI_QUIRK(0x1584, 0x9050, "Uniwill", ALC880_FIXUP_UNIWILL_DIG),
1422         SND_PCI_QUIRK(0x1584, 0x9054, "Uniwill", ALC880_FIXUP_F1734),
1423         SND_PCI_QUIRK(0x1584, 0x9070, "Uniwill", ALC880_FIXUP_UNIWILL),
1424         SND_PCI_QUIRK(0x1584, 0x9077, "Uniwill P53", ALC880_FIXUP_VOL_KNOB),
1425         SND_PCI_QUIRK(0x161f, 0x203d, "W810", ALC880_FIXUP_W810),
1426         SND_PCI_QUIRK(0x161f, 0x205d, "Medion Rim 2150", ALC880_FIXUP_MEDION_RIM),
1427         SND_PCI_QUIRK(0x1631, 0xe011, "PB 13201056", ALC880_FIXUP_6ST_AUTOMUTE),
1428         SND_PCI_QUIRK(0x1734, 0x107c, "FSC F1734", ALC880_FIXUP_F1734),
1429         SND_PCI_QUIRK(0x1734, 0x1094, "FSC Amilo M1451G", ALC880_FIXUP_FUJITSU),
1430         SND_PCI_QUIRK(0x1734, 0x10ac, "FSC AMILO Xi 1526", ALC880_FIXUP_F1734),
1431         SND_PCI_QUIRK(0x1734, 0x10b0, "FSC Amilo Pi1556", ALC880_FIXUP_FUJITSU),
1432         SND_PCI_QUIRK(0x1854, 0x003b, "LG", ALC880_FIXUP_LG),
1433         SND_PCI_QUIRK(0x1854, 0x005f, "LG P1 Express", ALC880_FIXUP_LG),
1434         SND_PCI_QUIRK(0x1854, 0x0068, "LG w1", ALC880_FIXUP_LG),
1435         SND_PCI_QUIRK(0x1854, 0x0077, "LG LW25", ALC880_FIXUP_LG_LW25),
1436         SND_PCI_QUIRK(0x19db, 0x4188, "TCL S700", ALC880_FIXUP_TCL_S700),
1437
1438         /* Below is the copied entries from alc880_quirks.c.
1439          * It's not quite sure whether BIOS sets the correct pin-config table
1440          * on these machines, thus they are kept to be compatible with
1441          * the old static quirks.  Once when it's confirmed to work without
1442          * these overrides, it'd be better to remove.
1443          */
1444         SND_PCI_QUIRK(0x1019, 0xa880, "ECS", ALC880_FIXUP_5ST_DIG),
1445         SND_PCI_QUIRK(0x1019, 0xa884, "Acer APFV", ALC880_FIXUP_6ST),
1446         SND_PCI_QUIRK(0x1025, 0x0070, "ULI", ALC880_FIXUP_3ST_DIG),
1447         SND_PCI_QUIRK(0x1025, 0x0077, "ULI", ALC880_FIXUP_6ST_DIG),
1448         SND_PCI_QUIRK(0x1025, 0x0078, "ULI", ALC880_FIXUP_6ST_DIG),
1449         SND_PCI_QUIRK(0x1025, 0x0087, "ULI", ALC880_FIXUP_6ST_DIG),
1450         SND_PCI_QUIRK(0x1025, 0xe309, "ULI", ALC880_FIXUP_3ST_DIG),
1451         SND_PCI_QUIRK(0x1025, 0xe310, "ULI", ALC880_FIXUP_3ST),
1452         SND_PCI_QUIRK(0x1039, 0x1234, NULL, ALC880_FIXUP_6ST_DIG),
1453         SND_PCI_QUIRK(0x104d, 0x81a0, "Sony", ALC880_FIXUP_3ST),
1454         SND_PCI_QUIRK(0x104d, 0x81d6, "Sony", ALC880_FIXUP_3ST),
1455         SND_PCI_QUIRK(0x107b, 0x3032, "Gateway", ALC880_FIXUP_5ST),
1456         SND_PCI_QUIRK(0x107b, 0x3033, "Gateway", ALC880_FIXUP_5ST),
1457         SND_PCI_QUIRK(0x107b, 0x4039, "Gateway", ALC880_FIXUP_5ST),
1458         SND_PCI_QUIRK(0x1297, 0xc790, "Shuttle ST20G5", ALC880_FIXUP_6ST_DIG),
1459         SND_PCI_QUIRK(0x1458, 0xa102, "Gigabyte K8", ALC880_FIXUP_6ST_DIG),
1460         SND_PCI_QUIRK(0x1462, 0x1150, "MSI", ALC880_FIXUP_6ST_DIG),
1461         SND_PCI_QUIRK(0x1509, 0x925d, "FIC P4M", ALC880_FIXUP_6ST_DIG),
1462         SND_PCI_QUIRK(0x1565, 0x8202, "Biostar", ALC880_FIXUP_5ST_DIG),
1463         SND_PCI_QUIRK(0x1695, 0x400d, "EPoX", ALC880_FIXUP_5ST_DIG),
1464         SND_PCI_QUIRK(0x1695, 0x4012, "EPox EP-5LDA", ALC880_FIXUP_5ST_DIG),
1465         SND_PCI_QUIRK(0x2668, 0x8086, NULL, ALC880_FIXUP_6ST_DIG), /* broken BIOS */
1466         SND_PCI_QUIRK(0x8086, 0x2668, NULL, ALC880_FIXUP_6ST_DIG),
1467         SND_PCI_QUIRK(0x8086, 0xa100, "Intel mobo", ALC880_FIXUP_5ST_DIG),
1468         SND_PCI_QUIRK(0x8086, 0xd400, "Intel mobo", ALC880_FIXUP_5ST_DIG),
1469         SND_PCI_QUIRK(0x8086, 0xd401, "Intel mobo", ALC880_FIXUP_5ST_DIG),
1470         SND_PCI_QUIRK(0x8086, 0xd402, "Intel mobo", ALC880_FIXUP_3ST_DIG),
1471         SND_PCI_QUIRK(0x8086, 0xe224, "Intel mobo", ALC880_FIXUP_5ST_DIG),
1472         SND_PCI_QUIRK(0x8086, 0xe305, "Intel mobo", ALC880_FIXUP_3ST_DIG),
1473         SND_PCI_QUIRK(0x8086, 0xe308, "Intel mobo", ALC880_FIXUP_3ST_DIG),
1474         SND_PCI_QUIRK(0x8086, 0xe400, "Intel mobo", ALC880_FIXUP_5ST_DIG),
1475         SND_PCI_QUIRK(0x8086, 0xe401, "Intel mobo", ALC880_FIXUP_5ST_DIG),
1476         SND_PCI_QUIRK(0x8086, 0xe402, "Intel mobo", ALC880_FIXUP_5ST_DIG),
1477         /* default Intel */
1478         SND_PCI_QUIRK_VENDOR(0x8086, "Intel mobo", ALC880_FIXUP_3ST),
1479         SND_PCI_QUIRK(0xa0a0, 0x0560, "AOpen i915GMm-HFS", ALC880_FIXUP_5ST_DIG),
1480         SND_PCI_QUIRK(0xe803, 0x1019, NULL, ALC880_FIXUP_6ST_DIG),
1481         {}
1482 };
1483
1484 static const struct hda_model_fixup alc880_fixup_models[] = {
1485         {.id = ALC880_FIXUP_3ST, .name = "3stack"},
1486         {.id = ALC880_FIXUP_3ST_DIG, .name = "3stack-digout"},
1487         {.id = ALC880_FIXUP_5ST, .name = "5stack"},
1488         {.id = ALC880_FIXUP_5ST_DIG, .name = "5stack-digout"},
1489         {.id = ALC880_FIXUP_6ST, .name = "6stack"},
1490         {.id = ALC880_FIXUP_6ST_DIG, .name = "6stack-digout"},
1491         {.id = ALC880_FIXUP_6ST_AUTOMUTE, .name = "6stack-automute"},
1492         {}
1493 };
1494
1495
1496 /*
1497  * OK, here we have finally the patch for ALC880
1498  */
1499 static int patch_alc880(struct hda_codec *codec)
1500 {
1501         struct alc_spec *spec;
1502         int err;
1503
1504         err = alc_alloc_spec(codec, 0x0b);
1505         if (err < 0)
1506                 return err;
1507
1508         spec = codec->spec;
1509         spec->gen.need_dac_fix = 1;
1510         spec->gen.beep_nid = 0x01;
1511
1512         snd_hda_pick_fixup(codec, alc880_fixup_models, alc880_fixup_tbl,
1513                        alc880_fixups);
1514         snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE);
1515
1516         /* automatic parse from the BIOS config */
1517         err = alc880_parse_auto_config(codec);
1518         if (err < 0)
1519                 goto error;
1520
1521         if (!spec->gen.no_analog)
1522                 set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
1523
1524         codec->patch_ops = alc_patch_ops;
1525         codec->patch_ops.unsol_event = alc880_unsol_event;
1526
1527
1528         snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE);
1529
1530         return 0;
1531
1532  error:
1533         alc_free(codec);
1534         return err;
1535 }
1536
1537
1538 /*
1539  * ALC260 support
1540  */
1541 static int alc260_parse_auto_config(struct hda_codec *codec)
1542 {
1543         static const hda_nid_t alc260_ignore[] = { 0x17, 0 };
1544         static const hda_nid_t alc260_ssids[] = { 0x10, 0x15, 0x0f, 0 };
1545         return alc_parse_auto_config(codec, alc260_ignore, alc260_ssids);
1546 }
1547
1548 /*
1549  * Pin config fixes
1550  */
1551 enum {
1552         ALC260_FIXUP_HP_DC5750,
1553         ALC260_FIXUP_HP_PIN_0F,
1554         ALC260_FIXUP_COEF,
1555         ALC260_FIXUP_GPIO1,
1556         ALC260_FIXUP_GPIO1_TOGGLE,
1557         ALC260_FIXUP_REPLACER,
1558         ALC260_FIXUP_HP_B1900,
1559         ALC260_FIXUP_KN1,
1560         ALC260_FIXUP_FSC_S7020,
1561         ALC260_FIXUP_FSC_S7020_JWSE,
1562         ALC260_FIXUP_VAIO_PINS,
1563 };
1564
1565 static void alc260_gpio1_automute(struct hda_codec *codec)
1566 {
1567         struct alc_spec *spec = codec->spec;
1568         snd_hda_codec_write(codec, 0x01, 0, AC_VERB_SET_GPIO_DATA,
1569                             spec->gen.hp_jack_present);
1570 }
1571
1572 static void alc260_fixup_gpio1_toggle(struct hda_codec *codec,
1573                                       const struct hda_fixup *fix, int action)
1574 {
1575         struct alc_spec *spec = codec->spec;
1576         if (action == HDA_FIXUP_ACT_PROBE) {
1577                 /* although the machine has only one output pin, we need to
1578                  * toggle GPIO1 according to the jack state
1579                  */
1580                 spec->gen.automute_hook = alc260_gpio1_automute;
1581                 spec->gen.detect_hp = 1;
1582                 spec->gen.automute_speaker = 1;
1583                 spec->gen.autocfg.hp_pins[0] = 0x0f; /* copy it for automute */
1584                 snd_hda_jack_detect_enable_callback(codec, 0x0f, HDA_GEN_HP_EVENT,
1585                                                     snd_hda_gen_hp_automute);
1586                 snd_hda_add_verbs(codec, alc_gpio1_init_verbs);
1587         }
1588 }
1589
1590 static void alc260_fixup_kn1(struct hda_codec *codec,
1591                              const struct hda_fixup *fix, int action)
1592 {
1593         struct alc_spec *spec = codec->spec;
1594         static const struct hda_pintbl pincfgs[] = {
1595                 { 0x0f, 0x02214000 }, /* HP/speaker */
1596                 { 0x12, 0x90a60160 }, /* int mic */
1597                 { 0x13, 0x02a19000 }, /* ext mic */
1598                 { 0x18, 0x01446000 }, /* SPDIF out */
1599                 /* disable bogus I/O pins */
1600                 { 0x10, 0x411111f0 },
1601                 { 0x11, 0x411111f0 },
1602                 { 0x14, 0x411111f0 },
1603                 { 0x15, 0x411111f0 },
1604                 { 0x16, 0x411111f0 },
1605                 { 0x17, 0x411111f0 },
1606                 { 0x19, 0x411111f0 },
1607                 { }
1608         };
1609
1610         switch (action) {
1611         case HDA_FIXUP_ACT_PRE_PROBE:
1612                 snd_hda_apply_pincfgs(codec, pincfgs);
1613                 break;
1614         case HDA_FIXUP_ACT_PROBE:
1615                 spec->init_amp = ALC_INIT_NONE;
1616                 break;
1617         }
1618 }
1619
1620 static void alc260_fixup_fsc_s7020(struct hda_codec *codec,
1621                                    const struct hda_fixup *fix, int action)
1622 {
1623         struct alc_spec *spec = codec->spec;
1624         if (action == HDA_FIXUP_ACT_PROBE)
1625                 spec->init_amp = ALC_INIT_NONE;
1626 }
1627
1628 static void alc260_fixup_fsc_s7020_jwse(struct hda_codec *codec,
1629                                    const struct hda_fixup *fix, int action)
1630 {
1631         struct alc_spec *spec = codec->spec;
1632         if (action == HDA_FIXUP_ACT_PRE_PROBE) {
1633                 spec->gen.add_jack_modes = 1;
1634                 spec->gen.hp_mic = 1;
1635         }
1636 }
1637
1638 static const struct hda_fixup alc260_fixups[] = {
1639         [ALC260_FIXUP_HP_DC5750] = {
1640                 .type = HDA_FIXUP_PINS,
1641                 .v.pins = (const struct hda_pintbl[]) {
1642                         { 0x11, 0x90130110 }, /* speaker */
1643                         { }
1644                 }
1645         },
1646         [ALC260_FIXUP_HP_PIN_0F] = {
1647                 .type = HDA_FIXUP_PINS,
1648                 .v.pins = (const struct hda_pintbl[]) {
1649                         { 0x0f, 0x01214000 }, /* HP */
1650                         { }
1651                 }
1652         },
1653         [ALC260_FIXUP_COEF] = {
1654                 .type = HDA_FIXUP_VERBS,
1655                 .v.verbs = (const struct hda_verb[]) {
1656                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x07 },
1657                         { 0x20, AC_VERB_SET_PROC_COEF,  0x3040 },
1658                         { }
1659                 },
1660                 .chained = true,
1661                 .chain_id = ALC260_FIXUP_HP_PIN_0F,
1662         },
1663         [ALC260_FIXUP_GPIO1] = {
1664                 .type = HDA_FIXUP_VERBS,
1665                 .v.verbs = alc_gpio1_init_verbs,
1666         },
1667         [ALC260_FIXUP_GPIO1_TOGGLE] = {
1668                 .type = HDA_FIXUP_FUNC,
1669                 .v.func = alc260_fixup_gpio1_toggle,
1670                 .chained = true,
1671                 .chain_id = ALC260_FIXUP_HP_PIN_0F,
1672         },
1673         [ALC260_FIXUP_REPLACER] = {
1674                 .type = HDA_FIXUP_VERBS,
1675                 .v.verbs = (const struct hda_verb[]) {
1676                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x07 },
1677                         { 0x20, AC_VERB_SET_PROC_COEF,  0x3050 },
1678                         { }
1679                 },
1680                 .chained = true,
1681                 .chain_id = ALC260_FIXUP_GPIO1_TOGGLE,
1682         },
1683         [ALC260_FIXUP_HP_B1900] = {
1684                 .type = HDA_FIXUP_FUNC,
1685                 .v.func = alc260_fixup_gpio1_toggle,
1686                 .chained = true,
1687                 .chain_id = ALC260_FIXUP_COEF,
1688         },
1689         [ALC260_FIXUP_KN1] = {
1690                 .type = HDA_FIXUP_FUNC,
1691                 .v.func = alc260_fixup_kn1,
1692         },
1693         [ALC260_FIXUP_FSC_S7020] = {
1694                 .type = HDA_FIXUP_FUNC,
1695                 .v.func = alc260_fixup_fsc_s7020,
1696         },
1697         [ALC260_FIXUP_FSC_S7020_JWSE] = {
1698                 .type = HDA_FIXUP_FUNC,
1699                 .v.func = alc260_fixup_fsc_s7020_jwse,
1700                 .chained = true,
1701                 .chain_id = ALC260_FIXUP_FSC_S7020,
1702         },
1703         [ALC260_FIXUP_VAIO_PINS] = {
1704                 .type = HDA_FIXUP_PINS,
1705                 .v.pins = (const struct hda_pintbl[]) {
1706                         /* Pin configs are missing completely on some VAIOs */
1707                         { 0x0f, 0x01211020 },
1708                         { 0x10, 0x0001003f },
1709                         { 0x11, 0x411111f0 },
1710                         { 0x12, 0x01a15930 },
1711                         { 0x13, 0x411111f0 },
1712                         { 0x14, 0x411111f0 },
1713                         { 0x15, 0x411111f0 },
1714                         { 0x16, 0x411111f0 },
1715                         { 0x17, 0x411111f0 },
1716                         { 0x18, 0x411111f0 },
1717                         { 0x19, 0x411111f0 },
1718                         { }
1719                 }
1720         },
1721 };
1722
1723 static const struct snd_pci_quirk alc260_fixup_tbl[] = {
1724         SND_PCI_QUIRK(0x1025, 0x007b, "Acer C20x", ALC260_FIXUP_GPIO1),
1725         SND_PCI_QUIRK(0x1025, 0x007f, "Acer Aspire 9500", ALC260_FIXUP_COEF),
1726         SND_PCI_QUIRK(0x1025, 0x008f, "Acer", ALC260_FIXUP_GPIO1),
1727         SND_PCI_QUIRK(0x103c, 0x280a, "HP dc5750", ALC260_FIXUP_HP_DC5750),
1728         SND_PCI_QUIRK(0x103c, 0x30ba, "HP Presario B1900", ALC260_FIXUP_HP_B1900),
1729         SND_PCI_QUIRK(0x104d, 0x81bb, "Sony VAIO", ALC260_FIXUP_VAIO_PINS),
1730         SND_PCI_QUIRK(0x104d, 0x81e2, "Sony VAIO TX", ALC260_FIXUP_HP_PIN_0F),
1731         SND_PCI_QUIRK(0x10cf, 0x1326, "FSC LifeBook S7020", ALC260_FIXUP_FSC_S7020),
1732         SND_PCI_QUIRK(0x1509, 0x4540, "Favorit 100XS", ALC260_FIXUP_GPIO1),
1733         SND_PCI_QUIRK(0x152d, 0x0729, "Quanta KN1", ALC260_FIXUP_KN1),
1734         SND_PCI_QUIRK(0x161f, 0x2057, "Replacer 672V", ALC260_FIXUP_REPLACER),
1735         SND_PCI_QUIRK(0x1631, 0xc017, "PB V7900", ALC260_FIXUP_COEF),
1736         {}
1737 };
1738
1739 static const struct hda_model_fixup alc260_fixup_models[] = {
1740         {.id = ALC260_FIXUP_GPIO1, .name = "gpio1"},
1741         {.id = ALC260_FIXUP_COEF, .name = "coef"},
1742         {.id = ALC260_FIXUP_FSC_S7020, .name = "fujitsu"},
1743         {.id = ALC260_FIXUP_FSC_S7020_JWSE, .name = "fujitsu-jwse"},
1744         {}
1745 };
1746
1747 /*
1748  */
1749 static int patch_alc260(struct hda_codec *codec)
1750 {
1751         struct alc_spec *spec;
1752         int err;
1753
1754         err = alc_alloc_spec(codec, 0x07);
1755         if (err < 0)
1756                 return err;
1757
1758         spec = codec->spec;
1759         /* as quite a few machines require HP amp for speaker outputs,
1760          * it's easier to enable it unconditionally; even if it's unneeded,
1761          * it's almost harmless.
1762          */
1763         spec->gen.prefer_hp_amp = 1;
1764         spec->gen.beep_nid = 0x01;
1765
1766         snd_hda_pick_fixup(codec, alc260_fixup_models, alc260_fixup_tbl,
1767                            alc260_fixups);
1768         snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE);
1769
1770         /* automatic parse from the BIOS config */
1771         err = alc260_parse_auto_config(codec);
1772         if (err < 0)
1773                 goto error;
1774
1775         if (!spec->gen.no_analog)
1776                 set_beep_amp(spec, 0x07, 0x05, HDA_INPUT);
1777
1778         codec->patch_ops = alc_patch_ops;
1779         spec->shutup = alc_eapd_shutup;
1780
1781         snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE);
1782
1783         return 0;
1784
1785  error:
1786         alc_free(codec);
1787         return err;
1788 }
1789
1790
1791 /*
1792  * ALC882/883/885/888/889 support
1793  *
1794  * ALC882 is almost identical with ALC880 but has cleaner and more flexible
1795  * configuration.  Each pin widget can choose any input DACs and a mixer.
1796  * Each ADC is connected from a mixer of all inputs.  This makes possible
1797  * 6-channel independent captures.
1798  *
1799  * In addition, an independent DAC for the multi-playback (not used in this
1800  * driver yet).
1801  */
1802
1803 /*
1804  * Pin config fixes
1805  */
1806 enum {
1807         ALC882_FIXUP_ABIT_AW9D_MAX,
1808         ALC882_FIXUP_LENOVO_Y530,
1809         ALC882_FIXUP_PB_M5210,
1810         ALC882_FIXUP_ACER_ASPIRE_7736,
1811         ALC882_FIXUP_ASUS_W90V,
1812         ALC889_FIXUP_CD,
1813         ALC889_FIXUP_VAIO_TT,
1814         ALC888_FIXUP_EEE1601,
1815         ALC882_FIXUP_EAPD,
1816         ALC883_FIXUP_EAPD,
1817         ALC883_FIXUP_ACER_EAPD,
1818         ALC882_FIXUP_GPIO1,
1819         ALC882_FIXUP_GPIO2,
1820         ALC882_FIXUP_GPIO3,
1821         ALC889_FIXUP_COEF,
1822         ALC882_FIXUP_ASUS_W2JC,
1823         ALC882_FIXUP_ACER_ASPIRE_4930G,
1824         ALC882_FIXUP_ACER_ASPIRE_8930G,
1825         ALC882_FIXUP_ASPIRE_8930G_VERBS,
1826         ALC885_FIXUP_MACPRO_GPIO,
1827         ALC889_FIXUP_DAC_ROUTE,
1828         ALC889_FIXUP_MBP_VREF,
1829         ALC889_FIXUP_IMAC91_VREF,
1830         ALC889_FIXUP_MBA21_VREF,
1831         ALC882_FIXUP_INV_DMIC,
1832         ALC882_FIXUP_NO_PRIMARY_HP,
1833         ALC887_FIXUP_ASUS_BASS,
1834         ALC887_FIXUP_BASS_CHMAP,
1835 };
1836
1837 static void alc889_fixup_coef(struct hda_codec *codec,
1838                               const struct hda_fixup *fix, int action)
1839 {
1840         if (action != HDA_FIXUP_ACT_INIT)
1841                 return;
1842         alc889_coef_init(codec);
1843 }
1844
1845 /* toggle speaker-output according to the hp-jack state */
1846 static void alc882_gpio_mute(struct hda_codec *codec, int pin, int muted)
1847 {
1848         unsigned int gpiostate, gpiomask, gpiodir;
1849
1850         gpiostate = snd_hda_codec_read(codec, codec->afg, 0,
1851                                        AC_VERB_GET_GPIO_DATA, 0);
1852
1853         if (!muted)
1854                 gpiostate |= (1 << pin);
1855         else
1856                 gpiostate &= ~(1 << pin);
1857
1858         gpiomask = snd_hda_codec_read(codec, codec->afg, 0,
1859                                       AC_VERB_GET_GPIO_MASK, 0);
1860         gpiomask |= (1 << pin);
1861
1862         gpiodir = snd_hda_codec_read(codec, codec->afg, 0,
1863                                      AC_VERB_GET_GPIO_DIRECTION, 0);
1864         gpiodir |= (1 << pin);
1865
1866
1867         snd_hda_codec_write(codec, codec->afg, 0,
1868                             AC_VERB_SET_GPIO_MASK, gpiomask);
1869         snd_hda_codec_write(codec, codec->afg, 0,
1870                             AC_VERB_SET_GPIO_DIRECTION, gpiodir);
1871
1872         msleep(1);
1873
1874         snd_hda_codec_write(codec, codec->afg, 0,
1875                             AC_VERB_SET_GPIO_DATA, gpiostate);
1876 }
1877
1878 /* set up GPIO at initialization */
1879 static void alc885_fixup_macpro_gpio(struct hda_codec *codec,
1880                                      const struct hda_fixup *fix, int action)
1881 {
1882         if (action != HDA_FIXUP_ACT_INIT)
1883                 return;
1884         alc882_gpio_mute(codec, 0, 0);
1885         alc882_gpio_mute(codec, 1, 0);
1886 }
1887
1888 /* Fix the connection of some pins for ALC889:
1889  * At least, Acer Aspire 5935 shows the connections to DAC3/4 don't
1890  * work correctly (bko#42740)
1891  */
1892 static void alc889_fixup_dac_route(struct hda_codec *codec,
1893                                    const struct hda_fixup *fix, int action)
1894 {
1895         if (action == HDA_FIXUP_ACT_PRE_PROBE) {
1896                 /* fake the connections during parsing the tree */
1897                 hda_nid_t conn1[2] = { 0x0c, 0x0d };
1898                 hda_nid_t conn2[2] = { 0x0e, 0x0f };
1899                 snd_hda_override_conn_list(codec, 0x14, 2, conn1);
1900                 snd_hda_override_conn_list(codec, 0x15, 2, conn1);
1901                 snd_hda_override_conn_list(codec, 0x18, 2, conn2);
1902                 snd_hda_override_conn_list(codec, 0x1a, 2, conn2);
1903         } else if (action == HDA_FIXUP_ACT_PROBE) {
1904                 /* restore the connections */
1905                 hda_nid_t conn[5] = { 0x0c, 0x0d, 0x0e, 0x0f, 0x26 };
1906                 snd_hda_override_conn_list(codec, 0x14, 5, conn);
1907                 snd_hda_override_conn_list(codec, 0x15, 5, conn);
1908                 snd_hda_override_conn_list(codec, 0x18, 5, conn);
1909                 snd_hda_override_conn_list(codec, 0x1a, 5, conn);
1910         }
1911 }
1912
1913 /* Set VREF on HP pin */
1914 static void alc889_fixup_mbp_vref(struct hda_codec *codec,
1915                                   const struct hda_fixup *fix, int action)
1916 {
1917         struct alc_spec *spec = codec->spec;
1918         static hda_nid_t nids[2] = { 0x14, 0x15 };
1919         int i;
1920
1921         if (action != HDA_FIXUP_ACT_INIT)
1922                 return;
1923         for (i = 0; i < ARRAY_SIZE(nids); i++) {
1924                 unsigned int val = snd_hda_codec_get_pincfg(codec, nids[i]);
1925                 if (get_defcfg_device(val) != AC_JACK_HP_OUT)
1926                         continue;
1927                 val = snd_hda_codec_get_pin_target(codec, nids[i]);
1928                 val |= AC_PINCTL_VREF_80;
1929                 snd_hda_set_pin_ctl(codec, nids[i], val);
1930                 spec->gen.keep_vref_in_automute = 1;
1931                 break;
1932         }
1933 }
1934
1935 static void alc889_fixup_mac_pins(struct hda_codec *codec,
1936                                   const hda_nid_t *nids, int num_nids)
1937 {
1938         struct alc_spec *spec = codec->spec;
1939         int i;
1940
1941         for (i = 0; i < num_nids; i++) {
1942                 unsigned int val;
1943                 val = snd_hda_codec_get_pin_target(codec, nids[i]);
1944                 val |= AC_PINCTL_VREF_50;
1945                 snd_hda_set_pin_ctl(codec, nids[i], val);
1946         }
1947         spec->gen.keep_vref_in_automute = 1;
1948 }
1949
1950 /* Set VREF on speaker pins on imac91 */
1951 static void alc889_fixup_imac91_vref(struct hda_codec *codec,
1952                                      const struct hda_fixup *fix, int action)
1953 {
1954         static hda_nid_t nids[2] = { 0x18, 0x1a };
1955
1956         if (action == HDA_FIXUP_ACT_INIT)
1957                 alc889_fixup_mac_pins(codec, nids, ARRAY_SIZE(nids));
1958 }
1959
1960 /* Set VREF on speaker pins on mba21 */
1961 static void alc889_fixup_mba21_vref(struct hda_codec *codec,
1962                                     const struct hda_fixup *fix, int action)
1963 {
1964         static hda_nid_t nids[2] = { 0x18, 0x19 };
1965
1966         if (action == HDA_FIXUP_ACT_INIT)
1967                 alc889_fixup_mac_pins(codec, nids, ARRAY_SIZE(nids));
1968 }
1969
1970 /* Don't take HP output as primary
1971  * Strangely, the speaker output doesn't work on Vaio Z and some Vaio
1972  * all-in-one desktop PCs (for example VGC-LN51JGB) through DAC 0x05
1973  */
1974 static void alc882_fixup_no_primary_hp(struct hda_codec *codec,
1975                                        const struct hda_fixup *fix, int action)
1976 {
1977         struct alc_spec *spec = codec->spec;
1978         if (action == HDA_FIXUP_ACT_PRE_PROBE) {
1979                 spec->gen.no_primary_hp = 1;
1980                 spec->gen.no_multi_io = 1;
1981         }
1982 }
1983
1984 static void alc_fixup_bass_chmap(struct hda_codec *codec,
1985                                  const struct hda_fixup *fix, int action);
1986
1987 static const struct hda_fixup alc882_fixups[] = {
1988         [ALC882_FIXUP_ABIT_AW9D_MAX] = {
1989                 .type = HDA_FIXUP_PINS,
1990                 .v.pins = (const struct hda_pintbl[]) {
1991                         { 0x15, 0x01080104 }, /* side */
1992                         { 0x16, 0x01011012 }, /* rear */
1993                         { 0x17, 0x01016011 }, /* clfe */
1994                         { }
1995                 }
1996         },
1997         [ALC882_FIXUP_LENOVO_Y530] = {
1998                 .type = HDA_FIXUP_PINS,
1999                 .v.pins = (const struct hda_pintbl[]) {
2000                         { 0x15, 0x99130112 }, /* rear int speakers */
2001                         { 0x16, 0x99130111 }, /* subwoofer */
2002                         { }
2003                 }
2004         },
2005         [ALC882_FIXUP_PB_M5210] = {
2006                 .type = HDA_FIXUP_PINCTLS,
2007                 .v.pins = (const struct hda_pintbl[]) {
2008                         { 0x19, PIN_VREF50 },
2009                         {}
2010                 }
2011         },
2012         [ALC882_FIXUP_ACER_ASPIRE_7736] = {
2013                 .type = HDA_FIXUP_FUNC,
2014                 .v.func = alc_fixup_sku_ignore,
2015         },
2016         [ALC882_FIXUP_ASUS_W90V] = {
2017                 .type = HDA_FIXUP_PINS,
2018                 .v.pins = (const struct hda_pintbl[]) {
2019                         { 0x16, 0x99130110 }, /* fix sequence for CLFE */
2020                         { }
2021                 }
2022         },
2023         [ALC889_FIXUP_CD] = {
2024                 .type = HDA_FIXUP_PINS,
2025                 .v.pins = (const struct hda_pintbl[]) {
2026                         { 0x1c, 0x993301f0 }, /* CD */
2027                         { }
2028                 }
2029         },
2030         [ALC889_FIXUP_VAIO_TT] = {
2031                 .type = HDA_FIXUP_PINS,
2032                 .v.pins = (const struct hda_pintbl[]) {
2033                         { 0x17, 0x90170111 }, /* hidden surround speaker */
2034                         { }
2035                 }
2036         },
2037         [ALC888_FIXUP_EEE1601] = {
2038                 .type = HDA_FIXUP_VERBS,
2039                 .v.verbs = (const struct hda_verb[]) {
2040                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x0b },
2041                         { 0x20, AC_VERB_SET_PROC_COEF,  0x0838 },
2042                         { }
2043                 }
2044         },
2045         [ALC882_FIXUP_EAPD] = {
2046                 .type = HDA_FIXUP_VERBS,
2047                 .v.verbs = (const struct hda_verb[]) {
2048                         /* change to EAPD mode */
2049                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x07 },
2050                         { 0x20, AC_VERB_SET_PROC_COEF, 0x3060 },
2051                         { }
2052                 }
2053         },
2054         [ALC883_FIXUP_EAPD] = {
2055                 .type = HDA_FIXUP_VERBS,
2056                 .v.verbs = (const struct hda_verb[]) {
2057                         /* change to EAPD mode */
2058                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x07 },
2059                         { 0x20, AC_VERB_SET_PROC_COEF, 0x3070 },
2060                         { }
2061                 }
2062         },
2063         [ALC883_FIXUP_ACER_EAPD] = {
2064                 .type = HDA_FIXUP_VERBS,
2065                 .v.verbs = (const struct hda_verb[]) {
2066                         /* eanable EAPD on Acer laptops */
2067                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x07 },
2068                         { 0x20, AC_VERB_SET_PROC_COEF, 0x3050 },
2069                         { }
2070                 }
2071         },
2072         [ALC882_FIXUP_GPIO1] = {
2073                 .type = HDA_FIXUP_VERBS,
2074                 .v.verbs = alc_gpio1_init_verbs,
2075         },
2076         [ALC882_FIXUP_GPIO2] = {
2077                 .type = HDA_FIXUP_VERBS,
2078                 .v.verbs = alc_gpio2_init_verbs,
2079         },
2080         [ALC882_FIXUP_GPIO3] = {
2081                 .type = HDA_FIXUP_VERBS,
2082                 .v.verbs = alc_gpio3_init_verbs,
2083         },
2084         [ALC882_FIXUP_ASUS_W2JC] = {
2085                 .type = HDA_FIXUP_VERBS,
2086                 .v.verbs = alc_gpio1_init_verbs,
2087                 .chained = true,
2088                 .chain_id = ALC882_FIXUP_EAPD,
2089         },
2090         [ALC889_FIXUP_COEF] = {
2091                 .type = HDA_FIXUP_FUNC,
2092                 .v.func = alc889_fixup_coef,
2093         },
2094         [ALC882_FIXUP_ACER_ASPIRE_4930G] = {
2095                 .type = HDA_FIXUP_PINS,
2096                 .v.pins = (const struct hda_pintbl[]) {
2097                         { 0x16, 0x99130111 }, /* CLFE speaker */
2098                         { 0x17, 0x99130112 }, /* surround speaker */
2099                         { }
2100                 },
2101                 .chained = true,
2102                 .chain_id = ALC882_FIXUP_GPIO1,
2103         },
2104         [ALC882_FIXUP_ACER_ASPIRE_8930G] = {
2105                 .type = HDA_FIXUP_PINS,
2106                 .v.pins = (const struct hda_pintbl[]) {
2107                         { 0x16, 0x99130111 }, /* CLFE speaker */
2108                         { 0x1b, 0x99130112 }, /* surround speaker */
2109                         { }
2110                 },
2111                 .chained = true,
2112                 .chain_id = ALC882_FIXUP_ASPIRE_8930G_VERBS,
2113         },
2114         [ALC882_FIXUP_ASPIRE_8930G_VERBS] = {
2115                 /* additional init verbs for Acer Aspire 8930G */
2116                 .type = HDA_FIXUP_VERBS,
2117                 .v.verbs = (const struct hda_verb[]) {
2118                         /* Enable all DACs */
2119                         /* DAC DISABLE/MUTE 1? */
2120                         /*  setting bits 1-5 disables DAC nids 0x02-0x06
2121                          *  apparently. Init=0x38 */
2122                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x03 },
2123                         { 0x20, AC_VERB_SET_PROC_COEF, 0x0000 },
2124                         /* DAC DISABLE/MUTE 2? */
2125                         /*  some bit here disables the other DACs.
2126                          *  Init=0x4900 */
2127                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x08 },
2128                         { 0x20, AC_VERB_SET_PROC_COEF, 0x0000 },
2129                         /* DMIC fix
2130                          * This laptop has a stereo digital microphone.
2131                          * The mics are only 1cm apart which makes the stereo
2132                          * useless. However, either the mic or the ALC889
2133                          * makes the signal become a difference/sum signal
2134                          * instead of standard stereo, which is annoying.
2135                          * So instead we flip this bit which makes the
2136                          * codec replicate the sum signal to both channels,
2137                          * turning it into a normal mono mic.
2138                          */
2139                         /* DMIC_CONTROL? Init value = 0x0001 */
2140                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x0b },
2141                         { 0x20, AC_VERB_SET_PROC_COEF, 0x0003 },
2142                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x07 },
2143                         { 0x20, AC_VERB_SET_PROC_COEF, 0x3050 },
2144                         { }
2145                 },
2146                 .chained = true,
2147                 .chain_id = ALC882_FIXUP_GPIO1,
2148         },
2149         [ALC885_FIXUP_MACPRO_GPIO] = {
2150                 .type = HDA_FIXUP_FUNC,
2151                 .v.func = alc885_fixup_macpro_gpio,
2152         },
2153         [ALC889_FIXUP_DAC_ROUTE] = {
2154                 .type = HDA_FIXUP_FUNC,
2155                 .v.func = alc889_fixup_dac_route,
2156         },
2157         [ALC889_FIXUP_MBP_VREF] = {
2158                 .type = HDA_FIXUP_FUNC,
2159                 .v.func = alc889_fixup_mbp_vref,
2160                 .chained = true,
2161                 .chain_id = ALC882_FIXUP_GPIO1,
2162         },
2163         [ALC889_FIXUP_IMAC91_VREF] = {
2164                 .type = HDA_FIXUP_FUNC,
2165                 .v.func = alc889_fixup_imac91_vref,
2166                 .chained = true,
2167                 .chain_id = ALC882_FIXUP_GPIO1,
2168         },
2169         [ALC889_FIXUP_MBA21_VREF] = {
2170                 .type = HDA_FIXUP_FUNC,
2171                 .v.func = alc889_fixup_mba21_vref,
2172                 .chained = true,
2173                 .chain_id = ALC889_FIXUP_MBP_VREF,
2174         },
2175         [ALC882_FIXUP_INV_DMIC] = {
2176                 .type = HDA_FIXUP_FUNC,
2177                 .v.func = alc_fixup_inv_dmic_0x12,
2178         },
2179         [ALC882_FIXUP_NO_PRIMARY_HP] = {
2180                 .type = HDA_FIXUP_FUNC,
2181                 .v.func = alc882_fixup_no_primary_hp,
2182         },
2183         [ALC887_FIXUP_ASUS_BASS] = {
2184                 .type = HDA_FIXUP_PINS,
2185                 .v.pins = (const struct hda_pintbl[]) {
2186                         {0x16, 0x99130130}, /* bass speaker */
2187                         {}
2188                 },
2189                 .chained = true,
2190                 .chain_id = ALC887_FIXUP_BASS_CHMAP,
2191         },
2192         [ALC887_FIXUP_BASS_CHMAP] = {
2193                 .type = HDA_FIXUP_FUNC,
2194                 .v.func = alc_fixup_bass_chmap,
2195         },
2196 };
2197
2198 static const struct snd_pci_quirk alc882_fixup_tbl[] = {
2199         SND_PCI_QUIRK(0x1025, 0x006c, "Acer Aspire 9810", ALC883_FIXUP_ACER_EAPD),
2200         SND_PCI_QUIRK(0x1025, 0x0090, "Acer Aspire", ALC883_FIXUP_ACER_EAPD),
2201         SND_PCI_QUIRK(0x1025, 0x010a, "Acer Ferrari 5000", ALC883_FIXUP_ACER_EAPD),
2202         SND_PCI_QUIRK(0x1025, 0x0110, "Acer Aspire", ALC883_FIXUP_ACER_EAPD),
2203         SND_PCI_QUIRK(0x1025, 0x0112, "Acer Aspire 9303", ALC883_FIXUP_ACER_EAPD),
2204         SND_PCI_QUIRK(0x1025, 0x0121, "Acer Aspire 5920G", ALC883_FIXUP_ACER_EAPD),
2205         SND_PCI_QUIRK(0x1025, 0x013e, "Acer Aspire 4930G",
2206                       ALC882_FIXUP_ACER_ASPIRE_4930G),
2207         SND_PCI_QUIRK(0x1025, 0x013f, "Acer Aspire 5930G",
2208                       ALC882_FIXUP_ACER_ASPIRE_4930G),
2209         SND_PCI_QUIRK(0x1025, 0x0145, "Acer Aspire 8930G",
2210                       ALC882_FIXUP_ACER_ASPIRE_8930G),
2211         SND_PCI_QUIRK(0x1025, 0x0146, "Acer Aspire 6935G",
2212                       ALC882_FIXUP_ACER_ASPIRE_8930G),
2213         SND_PCI_QUIRK(0x1025, 0x015e, "Acer Aspire 6930G",
2214                       ALC882_FIXUP_ACER_ASPIRE_4930G),
2215         SND_PCI_QUIRK(0x1025, 0x0166, "Acer Aspire 6530G",
2216                       ALC882_FIXUP_ACER_ASPIRE_4930G),
2217         SND_PCI_QUIRK(0x1025, 0x0142, "Acer Aspire 7730G",
2218                       ALC882_FIXUP_ACER_ASPIRE_4930G),
2219         SND_PCI_QUIRK(0x1025, 0x0155, "Packard-Bell M5120", ALC882_FIXUP_PB_M5210),
2220         SND_PCI_QUIRK(0x1025, 0x021e, "Acer Aspire 5739G",
2221                       ALC882_FIXUP_ACER_ASPIRE_4930G),
2222         SND_PCI_QUIRK(0x1025, 0x0259, "Acer Aspire 5935", ALC889_FIXUP_DAC_ROUTE),
2223         SND_PCI_QUIRK(0x1025, 0x026b, "Acer Aspire 8940G", ALC882_FIXUP_ACER_ASPIRE_8930G),
2224         SND_PCI_QUIRK(0x1025, 0x0296, "Acer Aspire 7736z", ALC882_FIXUP_ACER_ASPIRE_7736),
2225         SND_PCI_QUIRK(0x1043, 0x13c2, "Asus A7M", ALC882_FIXUP_EAPD),
2226         SND_PCI_QUIRK(0x1043, 0x1873, "ASUS W90V", ALC882_FIXUP_ASUS_W90V),
2227         SND_PCI_QUIRK(0x1043, 0x1971, "Asus W2JC", ALC882_FIXUP_ASUS_W2JC),
2228         SND_PCI_QUIRK(0x1043, 0x835f, "Asus Eee 1601", ALC888_FIXUP_EEE1601),
2229         SND_PCI_QUIRK(0x1043, 0x84bc, "ASUS ET2700", ALC887_FIXUP_ASUS_BASS),
2230         SND_PCI_QUIRK(0x104d, 0x9047, "Sony Vaio TT", ALC889_FIXUP_VAIO_TT),
2231         SND_PCI_QUIRK(0x104d, 0x905a, "Sony Vaio Z", ALC882_FIXUP_NO_PRIMARY_HP),
2232         SND_PCI_QUIRK(0x104d, 0x9043, "Sony Vaio VGC-LN51JGB", ALC882_FIXUP_NO_PRIMARY_HP),
2233
2234         /* All Apple entries are in codec SSIDs */
2235         SND_PCI_QUIRK(0x106b, 0x00a0, "MacBookPro 3,1", ALC889_FIXUP_MBP_VREF),
2236         SND_PCI_QUIRK(0x106b, 0x00a1, "Macbook", ALC889_FIXUP_MBP_VREF),
2237         SND_PCI_QUIRK(0x106b, 0x00a4, "MacbookPro 4,1", ALC889_FIXUP_MBP_VREF),
2238         SND_PCI_QUIRK(0x106b, 0x0c00, "Mac Pro", ALC885_FIXUP_MACPRO_GPIO),
2239         SND_PCI_QUIRK(0x106b, 0x1000, "iMac 24", ALC885_FIXUP_MACPRO_GPIO),
2240         SND_PCI_QUIRK(0x106b, 0x2800, "AppleTV", ALC885_FIXUP_MACPRO_GPIO),
2241         SND_PCI_QUIRK(0x106b, 0x2c00, "MacbookPro rev3", ALC889_FIXUP_MBP_VREF),
2242         SND_PCI_QUIRK(0x106b, 0x3000, "iMac", ALC889_FIXUP_MBP_VREF),
2243         SND_PCI_QUIRK(0x106b, 0x3200, "iMac 7,1 Aluminum", ALC882_FIXUP_EAPD),
2244         SND_PCI_QUIRK(0x106b, 0x3400, "MacBookAir 1,1", ALC889_FIXUP_MBP_VREF),
2245         SND_PCI_QUIRK(0x106b, 0x3500, "MacBookAir 2,1", ALC889_FIXUP_MBA21_VREF),
2246         SND_PCI_QUIRK(0x106b, 0x3600, "Macbook 3,1", ALC889_FIXUP_MBP_VREF),
2247         SND_PCI_QUIRK(0x106b, 0x3800, "MacbookPro 4,1", ALC889_FIXUP_MBP_VREF),
2248         SND_PCI_QUIRK(0x106b, 0x3e00, "iMac 24 Aluminum", ALC885_FIXUP_MACPRO_GPIO),
2249         SND_PCI_QUIRK(0x106b, 0x3f00, "Macbook 5,1", ALC889_FIXUP_IMAC91_VREF),
2250         SND_PCI_QUIRK(0x106b, 0x4000, "MacbookPro 5,1", ALC889_FIXUP_IMAC91_VREF),
2251         SND_PCI_QUIRK(0x106b, 0x4100, "Macmini 3,1", ALC889_FIXUP_IMAC91_VREF),
2252         SND_PCI_QUIRK(0x106b, 0x4200, "Mac Pro 5,1", ALC885_FIXUP_MACPRO_GPIO),
2253         SND_PCI_QUIRK(0x106b, 0x4300, "iMac 9,1", ALC889_FIXUP_IMAC91_VREF),
2254         SND_PCI_QUIRK(0x106b, 0x4600, "MacbookPro 5,2", ALC889_FIXUP_IMAC91_VREF),
2255         SND_PCI_QUIRK(0x106b, 0x4900, "iMac 9,1 Aluminum", ALC889_FIXUP_IMAC91_VREF),
2256         SND_PCI_QUIRK(0x106b, 0x4a00, "Macbook 5,2", ALC889_FIXUP_IMAC91_VREF),
2257
2258         SND_PCI_QUIRK(0x1071, 0x8258, "Evesham Voyaeger", ALC882_FIXUP_EAPD),
2259         SND_PCI_QUIRK(0x1462, 0x7350, "MSI-7350", ALC889_FIXUP_CD),
2260         SND_PCI_QUIRK_VENDOR(0x1462, "MSI", ALC882_FIXUP_GPIO3),
2261         SND_PCI_QUIRK(0x1458, 0xa002, "Gigabyte EP45-DS3", ALC889_FIXUP_CD),
2262         SND_PCI_QUIRK(0x147b, 0x107a, "Abit AW9D-MAX", ALC882_FIXUP_ABIT_AW9D_MAX),
2263         SND_PCI_QUIRK_VENDOR(0x1558, "Clevo laptop", ALC882_FIXUP_EAPD),
2264         SND_PCI_QUIRK(0x161f, 0x2054, "Medion laptop", ALC883_FIXUP_EAPD),
2265         SND_PCI_QUIRK(0x17aa, 0x3a0d, "Lenovo Y530", ALC882_FIXUP_LENOVO_Y530),
2266         SND_PCI_QUIRK(0x8086, 0x0022, "DX58SO", ALC889_FIXUP_COEF),
2267         {}
2268 };
2269
2270 static const struct hda_model_fixup alc882_fixup_models[] = {
2271         {.id = ALC882_FIXUP_ACER_ASPIRE_4930G, .name = "acer-aspire-4930g"},
2272         {.id = ALC882_FIXUP_ACER_ASPIRE_8930G, .name = "acer-aspire-8930g"},
2273         {.id = ALC883_FIXUP_ACER_EAPD, .name = "acer-aspire"},
2274         {.id = ALC882_FIXUP_INV_DMIC, .name = "inv-dmic"},
2275         {.id = ALC882_FIXUP_NO_PRIMARY_HP, .name = "no-primary-hp"},
2276         {}
2277 };
2278
2279 /*
2280  * BIOS auto configuration
2281  */
2282 /* almost identical with ALC880 parser... */
2283 static int alc882_parse_auto_config(struct hda_codec *codec)
2284 {
2285         static const hda_nid_t alc882_ignore[] = { 0x1d, 0 };
2286         static const hda_nid_t alc882_ssids[] = { 0x15, 0x1b, 0x14, 0 };
2287         return alc_parse_auto_config(codec, alc882_ignore, alc882_ssids);
2288 }
2289
2290 /*
2291  */
2292 static int patch_alc882(struct hda_codec *codec)
2293 {
2294         struct alc_spec *spec;
2295         int err;
2296
2297         err = alc_alloc_spec(codec, 0x0b);
2298         if (err < 0)
2299                 return err;
2300
2301         spec = codec->spec;
2302
2303         switch (codec->vendor_id) {
2304         case 0x10ec0882:
2305         case 0x10ec0885:
2306                 break;
2307         default:
2308                 /* ALC883 and variants */
2309                 alc_fix_pll_init(codec, 0x20, 0x0a, 10);
2310                 break;
2311         }
2312
2313         snd_hda_pick_fixup(codec, alc882_fixup_models, alc882_fixup_tbl,
2314                        alc882_fixups);
2315         snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE);
2316
2317         alc_auto_parse_customize_define(codec);
2318
2319         if (has_cdefine_beep(codec))
2320                 spec->gen.beep_nid = 0x01;
2321
2322         /* automatic parse from the BIOS config */
2323         err = alc882_parse_auto_config(codec);
2324         if (err < 0)
2325                 goto error;
2326
2327         if (!spec->gen.no_analog && spec->gen.beep_nid)
2328                 set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
2329
2330         codec->patch_ops = alc_patch_ops;
2331
2332         snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE);
2333
2334         return 0;
2335
2336  error:
2337         alc_free(codec);
2338         return err;
2339 }
2340
2341
2342 /*
2343  * ALC262 support
2344  */
2345 static int alc262_parse_auto_config(struct hda_codec *codec)
2346 {
2347         static const hda_nid_t alc262_ignore[] = { 0x1d, 0 };
2348         static const hda_nid_t alc262_ssids[] = { 0x15, 0x1b, 0x14, 0 };
2349         return alc_parse_auto_config(codec, alc262_ignore, alc262_ssids);
2350 }
2351
2352 /*
2353  * Pin config fixes
2354  */
2355 enum {
2356         ALC262_FIXUP_FSC_H270,
2357         ALC262_FIXUP_FSC_S7110,
2358         ALC262_FIXUP_HP_Z200,
2359         ALC262_FIXUP_TYAN,
2360         ALC262_FIXUP_LENOVO_3000,
2361         ALC262_FIXUP_BENQ,
2362         ALC262_FIXUP_BENQ_T31,
2363         ALC262_FIXUP_INV_DMIC,
2364         ALC262_FIXUP_INTEL_BAYLEYBAY,
2365 };
2366
2367 static const struct hda_fixup alc262_fixups[] = {
2368         [ALC262_FIXUP_FSC_H270] = {
2369                 .type = HDA_FIXUP_PINS,
2370                 .v.pins = (const struct hda_pintbl[]) {
2371                         { 0x14, 0x99130110 }, /* speaker */
2372                         { 0x15, 0x0221142f }, /* front HP */
2373                         { 0x1b, 0x0121141f }, /* rear HP */
2374                         { }
2375                 }
2376         },
2377         [ALC262_FIXUP_FSC_S7110] = {
2378                 .type = HDA_FIXUP_PINS,
2379                 .v.pins = (const struct hda_pintbl[]) {
2380                         { 0x15, 0x90170110 }, /* speaker */
2381                         { }
2382                 },
2383                 .chained = true,
2384                 .chain_id = ALC262_FIXUP_BENQ,
2385         },
2386         [ALC262_FIXUP_HP_Z200] = {
2387                 .type = HDA_FIXUP_PINS,
2388                 .v.pins = (const struct hda_pintbl[]) {
2389                         { 0x16, 0x99130120 }, /* internal speaker */
2390                         { }
2391                 }
2392         },
2393         [ALC262_FIXUP_TYAN] = {
2394                 .type = HDA_FIXUP_PINS,
2395                 .v.pins = (const struct hda_pintbl[]) {
2396                         { 0x14, 0x1993e1f0 }, /* int AUX */
2397                         { }
2398                 }
2399         },
2400         [ALC262_FIXUP_LENOVO_3000] = {
2401                 .type = HDA_FIXUP_PINCTLS,
2402                 .v.pins = (const struct hda_pintbl[]) {
2403                         { 0x19, PIN_VREF50 },
2404                         {}
2405                 },
2406                 .chained = true,
2407                 .chain_id = ALC262_FIXUP_BENQ,
2408         },
2409         [ALC262_FIXUP_BENQ] = {
2410                 .type = HDA_FIXUP_VERBS,
2411                 .v.verbs = (const struct hda_verb[]) {
2412                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x07 },
2413                         { 0x20, AC_VERB_SET_PROC_COEF, 0x3070 },
2414                         {}
2415                 }
2416         },
2417         [ALC262_FIXUP_BENQ_T31] = {
2418                 .type = HDA_FIXUP_VERBS,
2419                 .v.verbs = (const struct hda_verb[]) {
2420                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x07 },
2421                         { 0x20, AC_VERB_SET_PROC_COEF, 0x3050 },
2422                         {}
2423                 }
2424         },
2425         [ALC262_FIXUP_INV_DMIC] = {
2426                 .type = HDA_FIXUP_FUNC,
2427                 .v.func = alc_fixup_inv_dmic_0x12,
2428         },
2429         [ALC262_FIXUP_INTEL_BAYLEYBAY] = {
2430                 .type = HDA_FIXUP_FUNC,
2431                 .v.func = alc_fixup_no_depop_delay,
2432         },
2433 };
2434
2435 static const struct snd_pci_quirk alc262_fixup_tbl[] = {
2436         SND_PCI_QUIRK(0x103c, 0x170b, "HP Z200", ALC262_FIXUP_HP_Z200),
2437         SND_PCI_QUIRK(0x10cf, 0x1397, "Fujitsu Lifebook S7110", ALC262_FIXUP_FSC_S7110),
2438         SND_PCI_QUIRK(0x10cf, 0x142d, "Fujitsu Lifebook E8410", ALC262_FIXUP_BENQ),
2439         SND_PCI_QUIRK(0x10f1, 0x2915, "Tyan Thunder n6650W", ALC262_FIXUP_TYAN),
2440         SND_PCI_QUIRK(0x1734, 0x1147, "FSC Celsius H270", ALC262_FIXUP_FSC_H270),
2441         SND_PCI_QUIRK(0x17aa, 0x384e, "Lenovo 3000", ALC262_FIXUP_LENOVO_3000),
2442         SND_PCI_QUIRK(0x17ff, 0x0560, "Benq ED8", ALC262_FIXUP_BENQ),
2443         SND_PCI_QUIRK(0x17ff, 0x058d, "Benq T31-16", ALC262_FIXUP_BENQ_T31),
2444         SND_PCI_QUIRK(0x8086, 0x7270, "BayleyBay", ALC262_FIXUP_INTEL_BAYLEYBAY),
2445         {}
2446 };
2447
2448 static const struct hda_model_fixup alc262_fixup_models[] = {
2449         {.id = ALC262_FIXUP_INV_DMIC, .name = "inv-dmic"},
2450         {}
2451 };
2452
2453 /*
2454  */
2455 static int patch_alc262(struct hda_codec *codec)
2456 {
2457         struct alc_spec *spec;
2458         int err;
2459
2460         err = alc_alloc_spec(codec, 0x0b);
2461         if (err < 0)
2462                 return err;
2463
2464         spec = codec->spec;
2465         spec->gen.shared_mic_vref_pin = 0x18;
2466
2467 #if 0
2468         /* pshou 07/11/05  set a zero PCM sample to DAC when FIFO is
2469          * under-run
2470          */
2471         {
2472         int tmp;
2473         snd_hda_codec_write(codec, 0x1a, 0, AC_VERB_SET_COEF_INDEX, 7);
2474         tmp = snd_hda_codec_read(codec, 0x20, 0, AC_VERB_GET_PROC_COEF, 0);
2475         snd_hda_codec_write(codec, 0x1a, 0, AC_VERB_SET_COEF_INDEX, 7);
2476         snd_hda_codec_write(codec, 0x1a, 0, AC_VERB_SET_PROC_COEF, tmp | 0x80);
2477         }
2478 #endif
2479         alc_fix_pll_init(codec, 0x20, 0x0a, 10);
2480
2481         snd_hda_pick_fixup(codec, alc262_fixup_models, alc262_fixup_tbl,
2482                        alc262_fixups);
2483         snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE);
2484
2485         alc_auto_parse_customize_define(codec);
2486
2487         if (has_cdefine_beep(codec))
2488                 spec->gen.beep_nid = 0x01;
2489
2490         /* automatic parse from the BIOS config */
2491         err = alc262_parse_auto_config(codec);
2492         if (err < 0)
2493                 goto error;
2494
2495         if (!spec->gen.no_analog && spec->gen.beep_nid)
2496                 set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
2497
2498         codec->patch_ops = alc_patch_ops;
2499         spec->shutup = alc_eapd_shutup;
2500
2501         snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE);
2502
2503         return 0;
2504
2505  error:
2506         alc_free(codec);
2507         return err;
2508 }
2509
2510 /*
2511  *  ALC268
2512  */
2513 /* bind Beep switches of both NID 0x0f and 0x10 */
2514 static const struct hda_bind_ctls alc268_bind_beep_sw = {
2515         .ops = &snd_hda_bind_sw,
2516         .values = {
2517                 HDA_COMPOSE_AMP_VAL(0x0f, 3, 1, HDA_INPUT),
2518                 HDA_COMPOSE_AMP_VAL(0x10, 3, 1, HDA_INPUT),
2519                 0
2520         },
2521 };
2522
2523 static const struct snd_kcontrol_new alc268_beep_mixer[] = {
2524         HDA_CODEC_VOLUME("Beep Playback Volume", 0x1d, 0x0, HDA_INPUT),
2525         HDA_BIND_SW("Beep Playback Switch", &alc268_bind_beep_sw),
2526         { }
2527 };
2528
2529 /* set PCBEEP vol = 0, mute connections */
2530 static const struct hda_verb alc268_beep_init_verbs[] = {
2531         {0x1d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
2532         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
2533         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
2534         { }
2535 };
2536
2537 enum {
2538         ALC268_FIXUP_INV_DMIC,
2539         ALC268_FIXUP_HP_EAPD,
2540         ALC268_FIXUP_SPDIF,
2541 };
2542
2543 static const struct hda_fixup alc268_fixups[] = {
2544         [ALC268_FIXUP_INV_DMIC] = {
2545                 .type = HDA_FIXUP_FUNC,
2546                 .v.func = alc_fixup_inv_dmic_0x12,
2547         },
2548         [ALC268_FIXUP_HP_EAPD] = {
2549                 .type = HDA_FIXUP_VERBS,
2550                 .v.verbs = (const struct hda_verb[]) {
2551                         {0x15, AC_VERB_SET_EAPD_BTLENABLE, 0},
2552                         {}
2553                 }
2554         },
2555         [ALC268_FIXUP_SPDIF] = {
2556                 .type = HDA_FIXUP_PINS,
2557                 .v.pins = (const struct hda_pintbl[]) {
2558                         { 0x1e, 0x014b1180 }, /* enable SPDIF out */
2559                         {}
2560                 }
2561         },
2562 };
2563
2564 static const struct hda_model_fixup alc268_fixup_models[] = {
2565         {.id = ALC268_FIXUP_INV_DMIC, .name = "inv-dmic"},
2566         {.id = ALC268_FIXUP_HP_EAPD, .name = "hp-eapd"},
2567         {}
2568 };
2569
2570 static const struct snd_pci_quirk alc268_fixup_tbl[] = {
2571         SND_PCI_QUIRK(0x1025, 0x0139, "Acer TravelMate 6293", ALC268_FIXUP_SPDIF),
2572         SND_PCI_QUIRK(0x1025, 0x015b, "Acer AOA 150 (ZG5)", ALC268_FIXUP_INV_DMIC),
2573         /* below is codec SSID since multiple Toshiba laptops have the
2574          * same PCI SSID 1179:ff00
2575          */
2576         SND_PCI_QUIRK(0x1179, 0xff06, "Toshiba P200", ALC268_FIXUP_HP_EAPD),
2577         {}
2578 };
2579
2580 /*
2581  * BIOS auto configuration
2582  */
2583 static int alc268_parse_auto_config(struct hda_codec *codec)
2584 {
2585         static const hda_nid_t alc268_ssids[] = { 0x15, 0x1b, 0x14, 0 };
2586         return alc_parse_auto_config(codec, NULL, alc268_ssids);
2587 }
2588
2589 /*
2590  */
2591 static int patch_alc268(struct hda_codec *codec)
2592 {
2593         struct alc_spec *spec;
2594         int err;
2595
2596         /* ALC268 has no aa-loopback mixer */
2597         err = alc_alloc_spec(codec, 0);
2598         if (err < 0)
2599                 return err;
2600
2601         spec = codec->spec;
2602         spec->gen.beep_nid = 0x01;
2603
2604         snd_hda_pick_fixup(codec, alc268_fixup_models, alc268_fixup_tbl, alc268_fixups);
2605         snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE);
2606
2607         /* automatic parse from the BIOS config */
2608         err = alc268_parse_auto_config(codec);
2609         if (err < 0)
2610                 goto error;
2611
2612         if (err > 0 && !spec->gen.no_analog &&
2613             spec->gen.autocfg.speaker_pins[0] != 0x1d) {
2614                 add_mixer(spec, alc268_beep_mixer);
2615                 snd_hda_add_verbs(codec, alc268_beep_init_verbs);
2616                 if (!query_amp_caps(codec, 0x1d, HDA_INPUT))
2617                         /* override the amp caps for beep generator */
2618                         snd_hda_override_amp_caps(codec, 0x1d, HDA_INPUT,
2619                                           (0x0c << AC_AMPCAP_OFFSET_SHIFT) |
2620                                           (0x0c << AC_AMPCAP_NUM_STEPS_SHIFT) |
2621                                           (0x07 << AC_AMPCAP_STEP_SIZE_SHIFT) |
2622                                           (0 << AC_AMPCAP_MUTE_SHIFT));
2623         }
2624
2625         codec->patch_ops = alc_patch_ops;
2626         spec->shutup = alc_eapd_shutup;
2627
2628         snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE);
2629
2630         return 0;
2631
2632  error:
2633         alc_free(codec);
2634         return err;
2635 }
2636
2637 /*
2638  * ALC269
2639  */
2640
2641 static int playback_pcm_open(struct hda_pcm_stream *hinfo,
2642                              struct hda_codec *codec,
2643                              struct snd_pcm_substream *substream)
2644 {
2645         struct hda_gen_spec *spec = codec->spec;
2646         return snd_hda_multi_out_analog_open(codec, &spec->multiout, substream,
2647                                              hinfo);
2648 }
2649
2650 static int playback_pcm_prepare(struct hda_pcm_stream *hinfo,
2651                                 struct hda_codec *codec,
2652                                 unsigned int stream_tag,
2653                                 unsigned int format,
2654                                 struct snd_pcm_substream *substream)
2655 {
2656         struct hda_gen_spec *spec = codec->spec;
2657         return snd_hda_multi_out_analog_prepare(codec, &spec->multiout,
2658                                                 stream_tag, format, substream);
2659 }
2660
2661 static int playback_pcm_cleanup(struct hda_pcm_stream *hinfo,
2662                                 struct hda_codec *codec,
2663                                 struct snd_pcm_substream *substream)
2664 {
2665         struct hda_gen_spec *spec = codec->spec;
2666         return snd_hda_multi_out_analog_cleanup(codec, &spec->multiout);
2667 }
2668
2669 static const struct hda_pcm_stream alc269_44k_pcm_analog_playback = {
2670         .substreams = 1,
2671         .channels_min = 2,
2672         .channels_max = 8,
2673         .rates = SNDRV_PCM_RATE_44100, /* fixed rate */
2674         /* NID is set in alc_build_pcms */
2675         .ops = {
2676                 .open = playback_pcm_open,
2677                 .prepare = playback_pcm_prepare,
2678                 .cleanup = playback_pcm_cleanup
2679         },
2680 };
2681
2682 static const struct hda_pcm_stream alc269_44k_pcm_analog_capture = {
2683         .substreams = 1,
2684         .channels_min = 2,
2685         .channels_max = 2,
2686         .rates = SNDRV_PCM_RATE_44100, /* fixed rate */
2687         /* NID is set in alc_build_pcms */
2688 };
2689
2690 /* different alc269-variants */
2691 enum {
2692         ALC269_TYPE_ALC269VA,
2693         ALC269_TYPE_ALC269VB,
2694         ALC269_TYPE_ALC269VC,
2695         ALC269_TYPE_ALC269VD,
2696         ALC269_TYPE_ALC280,
2697         ALC269_TYPE_ALC282,
2698         ALC269_TYPE_ALC283,
2699         ALC269_TYPE_ALC284,
2700         ALC269_TYPE_ALC285,
2701         ALC269_TYPE_ALC286,
2702         ALC269_TYPE_ALC255,
2703 };
2704
2705 /*
2706  * BIOS auto configuration
2707  */
2708 static int alc269_parse_auto_config(struct hda_codec *codec)
2709 {
2710         static const hda_nid_t alc269_ignore[] = { 0x1d, 0 };
2711         static const hda_nid_t alc269_ssids[] = { 0, 0x1b, 0x14, 0x21 };
2712         static const hda_nid_t alc269va_ssids[] = { 0x15, 0x1b, 0x14, 0 };
2713         struct alc_spec *spec = codec->spec;
2714         const hda_nid_t *ssids;
2715
2716         switch (spec->codec_variant) {
2717         case ALC269_TYPE_ALC269VA:
2718         case ALC269_TYPE_ALC269VC:
2719         case ALC269_TYPE_ALC280:
2720         case ALC269_TYPE_ALC284:
2721         case ALC269_TYPE_ALC285:
2722                 ssids = alc269va_ssids;
2723                 break;
2724         case ALC269_TYPE_ALC269VB:
2725         case ALC269_TYPE_ALC269VD:
2726         case ALC269_TYPE_ALC282:
2727         case ALC269_TYPE_ALC283:
2728         case ALC269_TYPE_ALC286:
2729         case ALC269_TYPE_ALC255:
2730                 ssids = alc269_ssids;
2731                 break;
2732         default:
2733                 ssids = alc269_ssids;
2734                 break;
2735         }
2736
2737         return alc_parse_auto_config(codec, alc269_ignore, ssids);
2738 }
2739
2740 static void alc269vb_toggle_power_output(struct hda_codec *codec, int power_up)
2741 {
2742         int val = alc_read_coef_idx(codec, 0x04);
2743         if (power_up)
2744                 val |= 1 << 11;
2745         else
2746                 val &= ~(1 << 11);
2747         alc_write_coef_idx(codec, 0x04, val);
2748 }
2749
2750 static void alc269_shutup(struct hda_codec *codec)
2751 {
2752         struct alc_spec *spec = codec->spec;
2753
2754         if (spec->codec_variant == ALC269_TYPE_ALC269VB)
2755                 alc269vb_toggle_power_output(codec, 0);
2756         if (spec->codec_variant == ALC269_TYPE_ALC269VB &&
2757                         (alc_get_coef0(codec) & 0x00ff) == 0x018) {
2758                 msleep(150);
2759         }
2760         snd_hda_shutup_pins(codec);
2761 }
2762
2763 static void alc283_init(struct hda_codec *codec)
2764 {
2765         struct alc_spec *spec = codec->spec;
2766         hda_nid_t hp_pin = spec->gen.autocfg.hp_pins[0];
2767         bool hp_pin_sense;
2768         int val;
2769
2770         if (!hp_pin)
2771                 return;
2772         hp_pin_sense = snd_hda_jack_detect(codec, hp_pin);
2773
2774         /* Index 0x43 Direct Drive HP AMP LPM Control 1 */
2775         /* Headphone capless set to high power mode */
2776         alc_write_coef_idx(codec, 0x43, 0x9004);
2777
2778         snd_hda_codec_write(codec, hp_pin, 0,
2779                             AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);
2780
2781         if (hp_pin_sense)
2782                 msleep(85);
2783
2784         snd_hda_codec_write(codec, hp_pin, 0,
2785                             AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT);
2786
2787         if (hp_pin_sense)
2788                 msleep(85);
2789         /* Index 0x46 Combo jack auto switch control 2 */
2790         /* 3k pull low control for Headset jack. */
2791         val = alc_read_coef_idx(codec, 0x46);
2792         alc_write_coef_idx(codec, 0x46, val & ~(3 << 12));
2793         /* Headphone capless set to normal mode */
2794         alc_write_coef_idx(codec, 0x43, 0x9614);
2795 }
2796
2797 static void alc283_shutup(struct hda_codec *codec)
2798 {
2799         struct alc_spec *spec = codec->spec;
2800         hda_nid_t hp_pin = spec->gen.autocfg.hp_pins[0];
2801         bool hp_pin_sense;
2802         int val;
2803
2804         if (!hp_pin) {
2805                 alc269_shutup(codec);
2806                 return;
2807         }
2808
2809         hp_pin_sense = snd_hda_jack_detect(codec, hp_pin);
2810
2811         alc_write_coef_idx(codec, 0x43, 0x9004);
2812
2813         snd_hda_codec_write(codec, hp_pin, 0,
2814                             AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);
2815
2816         if (hp_pin_sense)
2817                 msleep(100);
2818
2819         snd_hda_codec_write(codec, hp_pin, 0,
2820                             AC_VERB_SET_PIN_WIDGET_CONTROL, 0x0);
2821
2822         val = alc_read_coef_idx(codec, 0x46);
2823         alc_write_coef_idx(codec, 0x46, val | (3 << 12));
2824
2825         if (hp_pin_sense)
2826                 msleep(100);
2827         snd_hda_shutup_pins(codec);
2828         alc_write_coef_idx(codec, 0x43, 0x9614);
2829 }
2830
2831 static void alc5505_coef_set(struct hda_codec *codec, unsigned int index_reg,
2832                              unsigned int val)
2833 {
2834         snd_hda_codec_write(codec, 0x51, 0, AC_VERB_SET_COEF_INDEX, index_reg >> 1);
2835         snd_hda_codec_write(codec, 0x51, 0, AC_VERB_SET_PROC_COEF, val & 0xffff); /* LSB */
2836         snd_hda_codec_write(codec, 0x51, 0, AC_VERB_SET_PROC_COEF, val >> 16); /* MSB */
2837 }
2838
2839 static int alc5505_coef_get(struct hda_codec *codec, unsigned int index_reg)
2840 {
2841         unsigned int val;
2842
2843         snd_hda_codec_write(codec, 0x51, 0, AC_VERB_SET_COEF_INDEX, index_reg >> 1);
2844         val = snd_hda_codec_read(codec, 0x51, 0, AC_VERB_GET_PROC_COEF, 0)
2845                 & 0xffff;
2846         val |= snd_hda_codec_read(codec, 0x51, 0, AC_VERB_GET_PROC_COEF, 0)
2847                 << 16;
2848         return val;
2849 }
2850
2851 static void alc5505_dsp_halt(struct hda_codec *codec)
2852 {
2853         unsigned int val;
2854
2855         alc5505_coef_set(codec, 0x3000, 0x000c); /* DSP CPU stop */
2856         alc5505_coef_set(codec, 0x880c, 0x0008); /* DDR enter self refresh */
2857         alc5505_coef_set(codec, 0x61c0, 0x11110080); /* Clock control for PLL and CPU */
2858         alc5505_coef_set(codec, 0x6230, 0xfc0d4011); /* Disable Input OP */
2859         alc5505_coef_set(codec, 0x61b4, 0x040a2b03); /* Stop PLL2 */
2860         alc5505_coef_set(codec, 0x61b0, 0x00005b17); /* Stop PLL1 */
2861         alc5505_coef_set(codec, 0x61b8, 0x04133303); /* Stop PLL3 */
2862         val = alc5505_coef_get(codec, 0x6220);
2863         alc5505_coef_set(codec, 0x6220, (val | 0x3000)); /* switch Ringbuffer clock to DBUS clock */
2864 }
2865
2866 static void alc5505_dsp_back_from_halt(struct hda_codec *codec)
2867 {
2868         alc5505_coef_set(codec, 0x61b8, 0x04133302);
2869         alc5505_coef_set(codec, 0x61b0, 0x00005b16);
2870         alc5505_coef_set(codec, 0x61b4, 0x040a2b02);
2871         alc5505_coef_set(codec, 0x6230, 0xf80d4011);
2872         alc5505_coef_set(codec, 0x6220, 0x2002010f);
2873         alc5505_coef_set(codec, 0x880c, 0x00000004);
2874 }
2875
2876 static void alc5505_dsp_init(struct hda_codec *codec)
2877 {
2878         unsigned int val;
2879
2880         alc5505_dsp_halt(codec);
2881         alc5505_dsp_back_from_halt(codec);
2882         alc5505_coef_set(codec, 0x61b0, 0x5b14); /* PLL1 control */
2883         alc5505_coef_set(codec, 0x61b0, 0x5b16);
2884         alc5505_coef_set(codec, 0x61b4, 0x04132b00); /* PLL2 control */
2885         alc5505_coef_set(codec, 0x61b4, 0x04132b02);
2886         alc5505_coef_set(codec, 0x61b8, 0x041f3300); /* PLL3 control*/
2887         alc5505_coef_set(codec, 0x61b8, 0x041f3302);
2888         snd_hda_codec_write(codec, 0x51, 0, AC_VERB_SET_CODEC_RESET, 0); /* Function reset */
2889         alc5505_coef_set(codec, 0x61b8, 0x041b3302);
2890         alc5505_coef_set(codec, 0x61b8, 0x04173302);
2891         alc5505_coef_set(codec, 0x61b8, 0x04163302);
2892         alc5505_coef_set(codec, 0x8800, 0x348b328b); /* DRAM control */
2893         alc5505_coef_set(codec, 0x8808, 0x00020022); /* DRAM control */
2894         alc5505_coef_set(codec, 0x8818, 0x00000400); /* DRAM control */
2895
2896         val = alc5505_coef_get(codec, 0x6200) >> 16; /* Read revision ID */
2897         if (val <= 3)
2898                 alc5505_coef_set(codec, 0x6220, 0x2002010f); /* I/O PAD Configuration */
2899         else
2900                 alc5505_coef_set(codec, 0x6220, 0x6002018f);
2901
2902         alc5505_coef_set(codec, 0x61ac, 0x055525f0); /**/
2903         alc5505_coef_set(codec, 0x61c0, 0x12230080); /* Clock control */
2904         alc5505_coef_set(codec, 0x61b4, 0x040e2b02); /* PLL2 control */
2905         alc5505_coef_set(codec, 0x61bc, 0x010234f8); /* OSC Control */
2906         alc5505_coef_set(codec, 0x880c, 0x00000004); /* DRAM Function control */
2907         alc5505_coef_set(codec, 0x880c, 0x00000003);
2908         alc5505_coef_set(codec, 0x880c, 0x00000010);
2909
2910 #ifdef HALT_REALTEK_ALC5505
2911         alc5505_dsp_halt(codec);
2912 #endif
2913 }
2914
2915 #ifdef HALT_REALTEK_ALC5505
2916 #define alc5505_dsp_suspend(codec)      /* NOP */
2917 #define alc5505_dsp_resume(codec)       /* NOP */
2918 #else
2919 #define alc5505_dsp_suspend(codec)      alc5505_dsp_halt(codec)
2920 #define alc5505_dsp_resume(codec)       alc5505_dsp_back_from_halt(codec)
2921 #endif
2922
2923 #ifdef CONFIG_PM
2924 static int alc269_suspend(struct hda_codec *codec)
2925 {
2926         struct alc_spec *spec = codec->spec;
2927
2928         if (spec->has_alc5505_dsp)
2929                 alc5505_dsp_suspend(codec);
2930         return alc_suspend(codec);
2931 }
2932
2933 static int alc269_resume(struct hda_codec *codec)
2934 {
2935         struct alc_spec *spec = codec->spec;
2936
2937         if (spec->codec_variant == ALC269_TYPE_ALC269VB)
2938                 alc269vb_toggle_power_output(codec, 0);
2939         if (spec->codec_variant == ALC269_TYPE_ALC269VB &&
2940                         (alc_get_coef0(codec) & 0x00ff) == 0x018) {
2941                 msleep(150);
2942         }
2943
2944         codec->patch_ops.init(codec);
2945
2946         if (spec->codec_variant == ALC269_TYPE_ALC269VB)
2947                 alc269vb_toggle_power_output(codec, 1);
2948         if (spec->codec_variant == ALC269_TYPE_ALC269VB &&
2949                         (alc_get_coef0(codec) & 0x00ff) == 0x017) {
2950                 msleep(200);
2951         }
2952
2953         snd_hda_codec_resume_amp(codec);
2954         snd_hda_codec_resume_cache(codec);
2955         alc_inv_dmic_sync(codec, true);
2956         hda_call_check_power_status(codec, 0x01);
2957         if (spec->has_alc5505_dsp)
2958                 alc5505_dsp_resume(codec);
2959
2960         return 0;
2961 }
2962 #endif /* CONFIG_PM */
2963
2964 static void alc269_fixup_pincfg_no_hp_to_lineout(struct hda_codec *codec,
2965                                                  const struct hda_fixup *fix, int action)
2966 {
2967         struct alc_spec *spec = codec->spec;
2968
2969         if (action == HDA_FIXUP_ACT_PRE_PROBE)
2970                 spec->parse_flags = HDA_PINCFG_NO_HP_FIXUP;
2971 }
2972
2973 static void alc269_fixup_hweq(struct hda_codec *codec,
2974                                const struct hda_fixup *fix, int action)
2975 {
2976         int coef;
2977
2978         if (action != HDA_FIXUP_ACT_INIT)
2979                 return;
2980         coef = alc_read_coef_idx(codec, 0x1e);
2981         alc_write_coef_idx(codec, 0x1e, coef | 0x80);
2982 }
2983
2984 static void alc269_fixup_headset_mic(struct hda_codec *codec,
2985                                        const struct hda_fixup *fix, int action)
2986 {
2987         struct alc_spec *spec = codec->spec;
2988
2989         if (action == HDA_FIXUP_ACT_PRE_PROBE)
2990                 spec->parse_flags |= HDA_PINCFG_HEADSET_MIC;
2991 }
2992
2993 static void alc271_fixup_dmic(struct hda_codec *codec,
2994                               const struct hda_fixup *fix, int action)
2995 {
2996         static const struct hda_verb verbs[] = {
2997                 {0x20, AC_VERB_SET_COEF_INDEX, 0x0d},
2998                 {0x20, AC_VERB_SET_PROC_COEF, 0x4000},
2999                 {}
3000         };
3001         unsigned int cfg;
3002
3003         if (strcmp(codec->chip_name, "ALC271X") &&
3004             strcmp(codec->chip_name, "ALC269VB"))
3005                 return;
3006         cfg = snd_hda_codec_get_pincfg(codec, 0x12);
3007         if (get_defcfg_connect(cfg) == AC_JACK_PORT_FIXED)
3008                 snd_hda_sequence_write(codec, verbs);
3009 }
3010
3011 static void alc269_fixup_pcm_44k(struct hda_codec *codec,
3012                                  const struct hda_fixup *fix, int action)
3013 {
3014         struct alc_spec *spec = codec->spec;
3015
3016         if (action != HDA_FIXUP_ACT_PROBE)
3017                 return;
3018
3019         /* Due to a hardware problem on Lenovo Ideadpad, we need to
3020          * fix the sample rate of analog I/O to 44.1kHz
3021          */
3022         spec->gen.stream_analog_playback = &alc269_44k_pcm_analog_playback;
3023         spec->gen.stream_analog_capture = &alc269_44k_pcm_analog_capture;
3024 }
3025
3026 static void alc269_fixup_stereo_dmic(struct hda_codec *codec,
3027                                      const struct hda_fixup *fix, int action)
3028 {
3029         int coef;
3030
3031         if (action != HDA_FIXUP_ACT_INIT)
3032                 return;
3033         /* The digital-mic unit sends PDM (differential signal) instead of
3034          * the standard PCM, thus you can't record a valid mono stream as is.
3035          * Below is a workaround specific to ALC269 to control the dmic
3036          * signal source as mono.
3037          */
3038         coef = alc_read_coef_idx(codec, 0x07);
3039         alc_write_coef_idx(codec, 0x07, coef | 0x80);
3040 }
3041
3042 static void alc269_quanta_automute(struct hda_codec *codec)
3043 {
3044         snd_hda_gen_update_outputs(codec);
3045
3046         snd_hda_codec_write(codec, 0x20, 0,
3047                         AC_VERB_SET_COEF_INDEX, 0x0c);
3048         snd_hda_codec_write(codec, 0x20, 0,
3049                         AC_VERB_SET_PROC_COEF, 0x680);
3050
3051         snd_hda_codec_write(codec, 0x20, 0,
3052                         AC_VERB_SET_COEF_INDEX, 0x0c);
3053         snd_hda_codec_write(codec, 0x20, 0,
3054                         AC_VERB_SET_PROC_COEF, 0x480);
3055 }
3056
3057 static void alc269_fixup_quanta_mute(struct hda_codec *codec,
3058                                      const struct hda_fixup *fix, int action)
3059 {
3060         struct alc_spec *spec = codec->spec;
3061         if (action != HDA_FIXUP_ACT_PROBE)
3062                 return;
3063         spec->gen.automute_hook = alc269_quanta_automute;
3064 }
3065
3066 static void alc269_x101_hp_automute_hook(struct hda_codec *codec,
3067                                          struct hda_jack_tbl *jack)
3068 {
3069         struct alc_spec *spec = codec->spec;
3070         int vref;
3071         msleep(200);
3072         snd_hda_gen_hp_automute(codec, jack);
3073
3074         vref = spec->gen.hp_jack_present ? PIN_VREF80 : 0;
3075         msleep(100);
3076         snd_hda_codec_write(codec, 0x18, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
3077                             vref);
3078         msleep(500);
3079         snd_hda_codec_write(codec, 0x18, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
3080                             vref);
3081 }
3082
3083 static void alc269_fixup_x101_headset_mic(struct hda_codec *codec,
3084                                      const struct hda_fixup *fix, int action)
3085 {
3086         struct alc_spec *spec = codec->spec;
3087         if (action == HDA_FIXUP_ACT_PRE_PROBE) {
3088                 spec->parse_flags |= HDA_PINCFG_HEADSET_MIC;
3089                 spec->gen.hp_automute_hook = alc269_x101_hp_automute_hook;
3090         }
3091 }
3092
3093
3094 /* update mute-LED according to the speaker mute state via mic VREF pin */
3095 static void alc269_fixup_mic_mute_hook(void *private_data, int enabled)
3096 {
3097         struct hda_codec *codec = private_data;
3098         struct alc_spec *spec = codec->spec;
3099         unsigned int pinval;
3100
3101         if (spec->mute_led_polarity)
3102                 enabled = !enabled;
3103         pinval = AC_PINCTL_IN_EN |
3104                 (enabled ? AC_PINCTL_VREF_HIZ : AC_PINCTL_VREF_80);
3105         if (spec->mute_led_nid)
3106                 snd_hda_set_pin_ctl_cache(codec, spec->mute_led_nid, pinval);
3107 }
3108
3109 /* Make sure the led works even in runtime suspend */
3110 static unsigned int led_power_filter(struct hda_codec *codec,
3111                                                   hda_nid_t nid,
3112                                                   unsigned int power_state)
3113 {
3114         struct alc_spec *spec = codec->spec;
3115
3116         if (power_state != AC_PWRST_D3 || nid != spec->mute_led_nid)
3117                 return power_state;
3118
3119         /* Set pin ctl again, it might have just been set to 0 */
3120         snd_hda_set_pin_ctl(codec, nid,
3121                             snd_hda_codec_get_pin_target(codec, nid));
3122
3123         return AC_PWRST_D0;
3124 }
3125
3126 static void alc269_fixup_hp_mute_led(struct hda_codec *codec,
3127                                      const struct hda_fixup *fix, int action)
3128 {
3129         struct alc_spec *spec = codec->spec;
3130         const struct dmi_device *dev = NULL;
3131
3132         if (action != HDA_FIXUP_ACT_PRE_PROBE)
3133                 return;
3134
3135         while ((dev = dmi_find_device(DMI_DEV_TYPE_OEM_STRING, NULL, dev))) {
3136                 int pol, pin;
3137                 if (sscanf(dev->name, "HP_Mute_LED_%d_%x", &pol, &pin) != 2)
3138                         continue;
3139                 if (pin < 0x0a || pin >= 0x10)
3140                         break;
3141                 spec->mute_led_polarity = pol;
3142                 spec->mute_led_nid = pin - 0x0a + 0x18;
3143                 spec->gen.vmaster_mute.hook = alc269_fixup_mic_mute_hook;
3144                 spec->gen.vmaster_mute_enum = 1;
3145                 codec->power_filter = led_power_filter;
3146                 snd_printd("Detected mute LED for %x:%d\n", spec->mute_led_nid,
3147                            spec->mute_led_polarity);
3148                 break;
3149         }
3150 }
3151
3152 static void alc269_fixup_hp_mute_led_mic1(struct hda_codec *codec,
3153                                 const struct hda_fixup *fix, int action)
3154 {
3155         struct alc_spec *spec = codec->spec;
3156         if (action == HDA_FIXUP_ACT_PRE_PROBE) {
3157                 spec->mute_led_polarity = 0;
3158                 spec->mute_led_nid = 0x18;
3159                 spec->gen.vmaster_mute.hook = alc269_fixup_mic_mute_hook;
3160                 spec->gen.vmaster_mute_enum = 1;
3161                 codec->power_filter = led_power_filter;
3162         }
3163 }
3164
3165 static void alc269_fixup_hp_mute_led_mic2(struct hda_codec *codec,
3166                                 const struct hda_fixup *fix, int action)
3167 {
3168         struct alc_spec *spec = codec->spec;
3169         if (action == HDA_FIXUP_ACT_PRE_PROBE) {
3170                 spec->mute_led_polarity = 0;
3171                 spec->mute_led_nid = 0x19;
3172                 spec->gen.vmaster_mute.hook = alc269_fixup_mic_mute_hook;
3173                 spec->gen.vmaster_mute_enum = 1;
3174                 codec->power_filter = led_power_filter;
3175         }
3176 }
3177
3178 /* turn on/off mute LED per vmaster hook */
3179 static void alc269_fixup_hp_gpio_mute_hook(void *private_data, int enabled)
3180 {
3181         struct hda_codec *codec = private_data;
3182         struct alc_spec *spec = codec->spec;
3183         unsigned int oldval = spec->gpio_led;
3184
3185         if (enabled)
3186                 spec->gpio_led &= ~0x08;
3187         else
3188                 spec->gpio_led |= 0x08;
3189         if (spec->gpio_led != oldval)
3190                 snd_hda_codec_write(codec, 0x01, 0, AC_VERB_SET_GPIO_DATA,
3191                                     spec->gpio_led);
3192 }
3193
3194 /* turn on/off mic-mute LED per capture hook */
3195 static void alc269_fixup_hp_gpio_mic_mute_hook(struct hda_codec *codec,
3196                                struct snd_ctl_elem_value *ucontrol)
3197 {
3198         struct alc_spec *spec = codec->spec;
3199         unsigned int oldval = spec->gpio_led;
3200
3201         if (!ucontrol)
3202                 return;
3203
3204         if (ucontrol->value.integer.value[0] ||
3205             ucontrol->value.integer.value[1])
3206                 spec->gpio_led &= ~0x10;
3207         else
3208                 spec->gpio_led |= 0x10;
3209         if (spec->gpio_led != oldval)
3210                 snd_hda_codec_write(codec, 0x01, 0, AC_VERB_SET_GPIO_DATA,
3211                                     spec->gpio_led);
3212 }
3213
3214 static void alc269_fixup_hp_gpio_led(struct hda_codec *codec,
3215                                 const struct hda_fixup *fix, int action)
3216 {
3217         struct alc_spec *spec = codec->spec;
3218         static const struct hda_verb gpio_init[] = {
3219                 { 0x01, AC_VERB_SET_GPIO_MASK, 0x18 },
3220                 { 0x01, AC_VERB_SET_GPIO_DIRECTION, 0x18 },
3221                 {}
3222         };
3223
3224         if (action == HDA_FIXUP_ACT_PRE_PROBE) {
3225                 spec->gen.vmaster_mute.hook = alc269_fixup_hp_gpio_mute_hook;
3226                 spec->gen.cap_sync_hook = alc269_fixup_hp_gpio_mic_mute_hook;
3227                 spec->gpio_led = 0;
3228                 snd_hda_add_verbs(codec, gpio_init);
3229         }
3230 }
3231
3232 static void alc_headset_mode_unplugged(struct hda_codec *codec)
3233 {
3234         int val;
3235
3236         switch (codec->vendor_id) {
3237         case 0x10ec0255:
3238                 /* LDO and MISC control */
3239                 alc_write_coef_idx(codec, 0x1b, 0x0c0b);
3240                 /* UAJ function set to menual mode */
3241                 alc_write_coef_idx(codec, 0x45, 0xd089);
3242                 /* Direct Drive HP Amp control(Set to verb control)*/
3243                 val = alc_read_coefex_idx(codec, 0x57, 0x05);
3244                 alc_write_coefex_idx(codec, 0x57, 0x05, val & ~(1<<14));
3245                 /* Set MIC2 Vref gate with HP */
3246                 alc_write_coef_idx(codec, 0x06, 0x6104);
3247                 /* Direct Drive HP Amp control */
3248                 alc_write_coefex_idx(codec, 0x57, 0x03, 0x8aa6);
3249                 break;
3250         case 0x10ec0283:
3251                 alc_write_coef_idx(codec, 0x1b, 0x0c0b);
3252                 alc_write_coef_idx(codec, 0x45, 0xc429);
3253                 val = alc_read_coef_idx(codec, 0x35);
3254                 alc_write_coef_idx(codec, 0x35, val & 0xbfff);
3255                 alc_write_coef_idx(codec, 0x06, 0x2104);
3256                 alc_write_coef_idx(codec, 0x1a, 0x0001);
3257                 alc_write_coef_idx(codec, 0x26, 0x0004);
3258                 alc_write_coef_idx(codec, 0x32, 0x42a3);
3259                 break;
3260         case 0x10ec0292:
3261                 alc_write_coef_idx(codec, 0x76, 0x000e);
3262                 alc_write_coef_idx(codec, 0x6c, 0x2400);
3263                 alc_write_coef_idx(codec, 0x18, 0x7308);
3264                 alc_write_coef_idx(codec, 0x6b, 0xc429);
3265                 break;
3266         case 0x10ec0668:
3267                 alc_write_coef_idx(codec, 0x15, 0x0d40);
3268                 alc_write_coef_idx(codec, 0xb7, 0x802b);
3269                 break;
3270         }
3271         snd_printdd("Headset jack set to unplugged mode.\n");
3272 }
3273
3274
3275 static void alc_headset_mode_mic_in(struct hda_codec *codec, hda_nid_t hp_pin,
3276                                     hda_nid_t mic_pin)
3277 {
3278         int val;
3279
3280         switch (codec->vendor_id) {
3281         case 0x10ec0255:
3282                 alc_write_coef_idx(codec, 0x45, 0xc489);
3283                 snd_hda_set_pin_ctl_cache(codec, hp_pin, 0);
3284                 alc_write_coefex_idx(codec, 0x57, 0x03, 0x8aa6);
3285                 /* Set MIC2 Vref gate to normal */
3286                 alc_write_coef_idx(codec, 0x06, 0x6100);
3287                 snd_hda_set_pin_ctl_cache(codec, mic_pin, PIN_VREF50);
3288                 break;
3289         case 0x10ec0283:
3290                 alc_write_coef_idx(codec, 0x45, 0xc429);
3291                 snd_hda_set_pin_ctl_cache(codec, hp_pin, 0);
3292                 val = alc_read_coef_idx(codec, 0x35);
3293                 alc_write_coef_idx(codec, 0x35, val | 1<<14);
3294                 alc_write_coef_idx(codec, 0x06, 0x2100);
3295                 alc_write_coef_idx(codec, 0x1a, 0x0021);
3296                 alc_write_coef_idx(codec, 0x26, 0x008c);
3297                 snd_hda_set_pin_ctl_cache(codec, mic_pin, PIN_VREF50);
3298                 break;
3299         case 0x10ec0292:
3300                 snd_hda_set_pin_ctl_cache(codec, hp_pin, 0);
3301                 alc_write_coef_idx(codec, 0x19, 0xa208);
3302                 alc_write_coef_idx(codec, 0x2e, 0xacf0);
3303                 break;
3304         case 0x10ec0668:
3305                 alc_write_coef_idx(codec, 0x11, 0x0001);
3306                 snd_hda_set_pin_ctl_cache(codec, hp_pin, 0);
3307                 alc_write_coef_idx(codec, 0xb7, 0x802b);
3308                 alc_write_coef_idx(codec, 0xb5, 0x1040);
3309                 val = alc_read_coef_idx(codec, 0xc3);
3310                 alc_write_coef_idx(codec, 0xc3, val | 1<<12);
3311                 snd_hda_set_pin_ctl_cache(codec, mic_pin, PIN_VREF50);
3312                 break;
3313         }
3314         snd_printdd("Headset jack set to mic-in mode.\n");
3315 }
3316
3317 static void alc_headset_mode_default(struct hda_codec *codec)
3318 {
3319         switch (codec->vendor_id) {
3320         case 0x10ec0255:
3321                 alc_write_coef_idx(codec, 0x45, 0xc089);
3322                 alc_write_coef_idx(codec, 0x45, 0xc489);
3323                 alc_write_coefex_idx(codec, 0x57, 0x03, 0x8ea6);
3324                 alc_write_coef_idx(codec, 0x49, 0x0049);
3325                 break;
3326         case 0x10ec0283:
3327                 alc_write_coef_idx(codec, 0x06, 0x2100);
3328                 alc_write_coef_idx(codec, 0x32, 0x4ea3);
3329                 break;
3330         case 0x10ec0292:
3331                 alc_write_coef_idx(codec, 0x76, 0x000e);
3332                 alc_write_coef_idx(codec, 0x6c, 0x2400);
3333                 alc_write_coef_idx(codec, 0x6b, 0xc429);
3334                 alc_write_coef_idx(codec, 0x18, 0x7308);
3335                 break;
3336         case 0x10ec0668:
3337                 alc_write_coef_idx(codec, 0x11, 0x0041);
3338                 alc_write_coef_idx(codec, 0x15, 0x0d40);
3339                 alc_write_coef_idx(codec, 0xb7, 0x802b);
3340                 break;
3341         }
3342         snd_printdd("Headset jack set to headphone (default) mode.\n");
3343 }
3344
3345 /* Iphone type */
3346 static void alc_headset_mode_ctia(struct hda_codec *codec)
3347 {
3348         switch (codec->vendor_id) {
3349         case 0x10ec0255:
3350                 /* Set to CTIA type */
3351                 alc_write_coef_idx(codec, 0x45, 0xd489);
3352                 alc_write_coef_idx(codec, 0x1b, 0x0c2b);
3353                 alc_write_coefex_idx(codec, 0x57, 0x03, 0x8ea6);
3354                 break;
3355         case 0x10ec0283:
3356                 alc_write_coef_idx(codec, 0x45, 0xd429);
3357                 alc_write_coef_idx(codec, 0x1b, 0x0c2b);
3358                 alc_write_coef_idx(codec, 0x32, 0x4ea3);
3359                 break;
3360         case 0x10ec0292:
3361                 alc_write_coef_idx(codec, 0x6b, 0xd429);
3362                 alc_write_coef_idx(codec, 0x76, 0x0008);
3363                 alc_write_coef_idx(codec, 0x18, 0x7388);
3364                 break;
3365         case 0x10ec0668:
3366                 alc_write_coef_idx(codec, 0x11, 0x0001);
3367                 alc_write_coef_idx(codec, 0x15, 0x0d60);
3368                 alc_write_coef_idx(codec, 0xc3, 0x0000);
3369                 break;
3370         }
3371         snd_printdd("Headset jack set to iPhone-style headset mode.\n");
3372 }
3373
3374 /* Nokia type */
3375 static void alc_headset_mode_omtp(struct hda_codec *codec)
3376 {
3377         switch (codec->vendor_id) {
3378         case 0x10ec0255:
3379                 /* Set to OMTP Type */
3380                 alc_write_coef_idx(codec, 0x45, 0xe489);
3381                 alc_write_coef_idx(codec, 0x1b, 0x0c2b);
3382                 alc_write_coefex_idx(codec, 0x57, 0x03, 0x8ea6);
3383                 break;
3384         case 0x10ec0283:
3385                 alc_write_coef_idx(codec, 0x45, 0xe429);
3386                 alc_write_coef_idx(codec, 0x1b, 0x0c2b);
3387                 alc_write_coef_idx(codec, 0x32, 0x4ea3);
3388                 break;
3389         case 0x10ec0292:
3390                 alc_write_coef_idx(codec, 0x6b, 0xe429);
3391                 alc_write_coef_idx(codec, 0x76, 0x0008);
3392                 alc_write_coef_idx(codec, 0x18, 0x7388);
3393                 break;
3394         case 0x10ec0668:
3395                 alc_write_coef_idx(codec, 0x11, 0x0001);
3396                 alc_write_coef_idx(codec, 0x15, 0x0d50);
3397                 alc_write_coef_idx(codec, 0xc3, 0x0000);
3398                 break;
3399         }
3400         snd_printdd("Headset jack set to Nokia-style headset mode.\n");
3401 }
3402
3403 static void alc_determine_headset_type(struct hda_codec *codec)
3404 {
3405         int val;
3406         bool is_ctia = false;
3407         struct alc_spec *spec = codec->spec;
3408
3409         switch (codec->vendor_id) {
3410         case 0x10ec0255:
3411                 /* combo jack auto switch control(Check type)*/
3412                 alc_write_coef_idx(codec, 0x45, 0xd089);
3413                 /* combo jack auto switch control(Vref conteol) */
3414                 alc_write_coef_idx(codec, 0x49, 0x0149);
3415                 msleep(300);
3416                 val = alc_read_coef_idx(codec, 0x46);
3417                 is_ctia = (val & 0x0070) == 0x0070;
3418                 break;
3419         case 0x10ec0283:
3420                 alc_write_coef_idx(codec, 0x45, 0xd029);
3421                 msleep(300);
3422                 val = alc_read_coef_idx(codec, 0x46);
3423                 is_ctia = (val & 0x0070) == 0x0070;
3424                 break;
3425         case 0x10ec0292:
3426                 alc_write_coef_idx(codec, 0x6b, 0xd429);
3427                 msleep(300);
3428                 val = alc_read_coef_idx(codec, 0x6c);
3429                 is_ctia = (val & 0x001c) == 0x001c;
3430                 break;
3431         case 0x10ec0668:
3432                 alc_write_coef_idx(codec, 0x11, 0x0001);
3433                 alc_write_coef_idx(codec, 0xb7, 0x802b);
3434                 alc_write_coef_idx(codec, 0x15, 0x0d60);
3435                 alc_write_coef_idx(codec, 0xc3, 0x0c00);
3436                 msleep(300);
3437                 val = alc_read_coef_idx(codec, 0xbe);
3438                 is_ctia = (val & 0x1c02) == 0x1c02;
3439                 break;
3440         }
3441
3442         snd_printdd("Headset jack detected iPhone-style headset: %s\n",
3443                     is_ctia ? "yes" : "no");
3444         spec->current_headset_type = is_ctia ? ALC_HEADSET_TYPE_CTIA : ALC_HEADSET_TYPE_OMTP;
3445 }
3446
3447 static void alc_update_headset_mode(struct hda_codec *codec)
3448 {
3449         struct alc_spec *spec = codec->spec;
3450
3451         hda_nid_t mux_pin = spec->gen.imux_pins[spec->gen.cur_mux[0]];
3452         hda_nid_t hp_pin = spec->gen.autocfg.hp_pins[0];
3453
3454         int new_headset_mode;
3455
3456         if (!snd_hda_jack_detect(codec, hp_pin))
3457                 new_headset_mode = ALC_HEADSET_MODE_UNPLUGGED;
3458         else if (mux_pin == spec->headset_mic_pin)
3459                 new_headset_mode = ALC_HEADSET_MODE_HEADSET;
3460         else if (mux_pin == spec->headphone_mic_pin)
3461                 new_headset_mode = ALC_HEADSET_MODE_MIC;
3462         else
3463                 new_headset_mode = ALC_HEADSET_MODE_HEADPHONE;
3464
3465         if (new_headset_mode == spec->current_headset_mode) {
3466                 snd_hda_gen_update_outputs(codec);
3467                 return;
3468         }
3469
3470         switch (new_headset_mode) {
3471         case ALC_HEADSET_MODE_UNPLUGGED:
3472                 alc_headset_mode_unplugged(codec);
3473                 spec->gen.hp_jack_present = false;
3474                 break;
3475         case ALC_HEADSET_MODE_HEADSET:
3476                 if (spec->current_headset_type == ALC_HEADSET_TYPE_UNKNOWN)
3477                         alc_determine_headset_type(codec);
3478                 if (spec->current_headset_type == ALC_HEADSET_TYPE_CTIA)
3479                         alc_headset_mode_ctia(codec);
3480                 else if (spec->current_headset_type == ALC_HEADSET_TYPE_OMTP)
3481                         alc_headset_mode_omtp(codec);
3482                 spec->gen.hp_jack_present = true;
3483                 break;
3484         case ALC_HEADSET_MODE_MIC:
3485                 alc_headset_mode_mic_in(codec, hp_pin, spec->headphone_mic_pin);
3486                 spec->gen.hp_jack_present = false;
3487                 break;
3488         case ALC_HEADSET_MODE_HEADPHONE:
3489                 alc_headset_mode_default(codec);
3490                 spec->gen.hp_jack_present = true;
3491                 break;
3492         }
3493         if (new_headset_mode != ALC_HEADSET_MODE_MIC) {
3494                 snd_hda_set_pin_ctl_cache(codec, hp_pin,
3495                                           AC_PINCTL_OUT_EN | AC_PINCTL_HP_EN);
3496                 if (spec->headphone_mic_pin)
3497                         snd_hda_set_pin_ctl_cache(codec, spec->headphone_mic_pin,
3498                                                   PIN_VREFHIZ);
3499         }
3500         spec->current_headset_mode = new_headset_mode;
3501
3502         snd_hda_gen_update_outputs(codec);
3503 }
3504
3505 static void alc_update_headset_mode_hook(struct hda_codec *codec,
3506                              struct snd_ctl_elem_value *ucontrol)
3507 {
3508         alc_update_headset_mode(codec);
3509 }
3510
3511 static void alc_update_headset_jack_cb(struct hda_codec *codec, struct hda_jack_tbl *jack)
3512 {
3513         struct alc_spec *spec = codec->spec;
3514         spec->current_headset_type = ALC_HEADSET_TYPE_UNKNOWN;
3515         snd_hda_gen_hp_automute(codec, jack);
3516 }
3517
3518 static void alc_probe_headset_mode(struct hda_codec *codec)
3519 {
3520         int i;
3521         struct alc_spec *spec = codec->spec;
3522         struct auto_pin_cfg *cfg = &spec->gen.autocfg;
3523
3524         /* Find mic pins */
3525         for (i = 0; i < cfg->num_inputs; i++) {
3526                 if (cfg->inputs[i].is_headset_mic && !spec->headset_mic_pin)
3527                         spec->headset_mic_pin = cfg->inputs[i].pin;
3528                 if (cfg->inputs[i].is_headphone_mic && !spec->headphone_mic_pin)
3529                         spec->headphone_mic_pin = cfg->inputs[i].pin;
3530         }
3531
3532         spec->gen.cap_sync_hook = alc_update_headset_mode_hook;
3533         spec->gen.automute_hook = alc_update_headset_mode;
3534         spec->gen.hp_automute_hook = alc_update_headset_jack_cb;
3535 }
3536
3537 static void alc_fixup_headset_mode(struct hda_codec *codec,
3538                                 const struct hda_fixup *fix, int action)
3539 {
3540         struct alc_spec *spec = codec->spec;
3541
3542         switch (action) {
3543         case HDA_FIXUP_ACT_PRE_PROBE:
3544                 spec->parse_flags |= HDA_PINCFG_HEADSET_MIC | HDA_PINCFG_HEADPHONE_MIC;
3545                 break;
3546         case HDA_FIXUP_ACT_PROBE:
3547                 alc_probe_headset_mode(codec);
3548                 break;
3549         case HDA_FIXUP_ACT_INIT:
3550                 spec->current_headset_mode = 0;
3551                 alc_update_headset_mode(codec);
3552                 break;
3553         }
3554 }
3555
3556 static void alc_fixup_headset_mode_no_hp_mic(struct hda_codec *codec,
3557                                 const struct hda_fixup *fix, int action)
3558 {
3559         if (action == HDA_FIXUP_ACT_PRE_PROBE) {
3560                 struct alc_spec *spec = codec->spec;
3561                 spec->parse_flags |= HDA_PINCFG_HEADSET_MIC;
3562         }
3563         else
3564                 alc_fixup_headset_mode(codec, fix, action);
3565 }
3566
3567 static void alc_fixup_headset_mode_alc255(struct hda_codec *codec,
3568                                 const struct hda_fixup *fix, int action)
3569 {
3570         if (action == HDA_FIXUP_ACT_PRE_PROBE) {
3571                 /* Set to iphone type */
3572                 alc_write_coef_idx(codec, 0x1b, 0x880b);
3573                 alc_write_coef_idx(codec, 0x45, 0xd089);
3574                 alc_write_coef_idx(codec, 0x1b, 0x080b);
3575                 alc_write_coef_idx(codec, 0x46, 0x0004);
3576                 alc_write_coef_idx(codec, 0x1b, 0x0c0b);
3577                 msleep(30);
3578         }
3579         alc_fixup_headset_mode(codec, fix, action);
3580 }
3581
3582 static void alc_fixup_headset_mode_alc668(struct hda_codec *codec,
3583                                 const struct hda_fixup *fix, int action)
3584 {
3585         if (action == HDA_FIXUP_ACT_PRE_PROBE) {
3586                 int val;
3587                 alc_write_coef_idx(codec, 0xc4, 0x8000);
3588                 val = alc_read_coef_idx(codec, 0xc2);
3589                 alc_write_coef_idx(codec, 0xc2, val & 0xfe);
3590                 snd_hda_set_pin_ctl_cache(codec, 0x18, 0);
3591         }
3592         alc_fixup_headset_mode(codec, fix, action);
3593 }
3594
3595 /* Returns the nid of the external mic input pin, or 0 if it cannot be found. */
3596 static int find_ext_mic_pin(struct hda_codec *codec)
3597 {
3598         struct alc_spec *spec = codec->spec;
3599         struct auto_pin_cfg *cfg = &spec->gen.autocfg;
3600         hda_nid_t nid;
3601         unsigned int defcfg;
3602         int i;
3603
3604         for (i = 0; i < cfg->num_inputs; i++) {
3605                 if (cfg->inputs[i].type != AUTO_PIN_MIC)
3606                         continue;
3607                 nid = cfg->inputs[i].pin;
3608                 defcfg = snd_hda_codec_get_pincfg(codec, nid);
3609                 if (snd_hda_get_input_pin_attr(defcfg) == INPUT_PIN_ATTR_INT)
3610                         continue;
3611                 return nid;
3612         }
3613
3614         return 0;
3615 }
3616
3617 static void alc271_hp_gate_mic_jack(struct hda_codec *codec,
3618                                     const struct hda_fixup *fix,
3619                                     int action)
3620 {
3621         struct alc_spec *spec = codec->spec;
3622
3623         if (action == HDA_FIXUP_ACT_PROBE) {
3624                 int mic_pin = find_ext_mic_pin(codec);
3625                 int hp_pin = spec->gen.autocfg.hp_pins[0];
3626
3627                 if (snd_BUG_ON(!mic_pin || !hp_pin))
3628                         return;
3629                 snd_hda_jack_set_gating_jack(codec, mic_pin, hp_pin);
3630         }
3631 }
3632
3633 static void alc269_fixup_limit_int_mic_boost(struct hda_codec *codec,
3634                                              const struct hda_fixup *fix,
3635                                              int action)
3636 {
3637         struct alc_spec *spec = codec->spec;
3638         struct auto_pin_cfg *cfg = &spec->gen.autocfg;
3639         int i;
3640
3641         /* The mic boosts on level 2 and 3 are too noisy
3642            on the internal mic input.
3643            Therefore limit the boost to 0 or 1. */
3644
3645         if (action != HDA_FIXUP_ACT_PROBE)
3646                 return;
3647
3648         for (i = 0; i < cfg->num_inputs; i++) {
3649                 hda_nid_t nid = cfg->inputs[i].pin;
3650                 unsigned int defcfg;
3651                 if (cfg->inputs[i].type != AUTO_PIN_MIC)
3652                         continue;
3653                 defcfg = snd_hda_codec_get_pincfg(codec, nid);
3654                 if (snd_hda_get_input_pin_attr(defcfg) != INPUT_PIN_ATTR_INT)
3655                         continue;
3656
3657                 snd_hda_override_amp_caps(codec, nid, HDA_INPUT,
3658                                           (0x00 << AC_AMPCAP_OFFSET_SHIFT) |
3659                                           (0x01 << AC_AMPCAP_NUM_STEPS_SHIFT) |
3660                                           (0x2f << AC_AMPCAP_STEP_SIZE_SHIFT) |
3661                                           (0 << AC_AMPCAP_MUTE_SHIFT));
3662         }
3663 }
3664
3665 static void alc283_hp_automute_hook(struct hda_codec *codec,
3666                                     struct hda_jack_tbl *jack)
3667 {
3668         struct alc_spec *spec = codec->spec;
3669         int vref;
3670
3671         msleep(200);
3672         snd_hda_gen_hp_automute(codec, jack);
3673
3674         vref = spec->gen.hp_jack_present ? PIN_VREF80 : 0;
3675
3676         msleep(600);
3677         snd_hda_codec_write(codec, 0x19, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
3678                             vref);
3679 }
3680
3681 static void alc283_fixup_chromebook(struct hda_codec *codec,
3682                                     const struct hda_fixup *fix, int action)
3683 {
3684         struct alc_spec *spec = codec->spec;
3685         int val;
3686
3687         switch (action) {
3688         case HDA_FIXUP_ACT_PRE_PROBE:
3689                 snd_hda_override_wcaps(codec, 0x03, 0);
3690                 /* Disable AA-loopback as it causes white noise */
3691                 spec->gen.mixer_nid = 0;
3692                 break;
3693         case HDA_FIXUP_ACT_INIT:
3694                 /* Enable Line1 input control by verb */
3695                 val = alc_read_coef_idx(codec, 0x1a);
3696                 alc_write_coef_idx(codec, 0x1a, val | (1 << 4));
3697                 break;
3698         }
3699 }
3700
3701 static void alc283_fixup_sense_combo_jack(struct hda_codec *codec,
3702                                     const struct hda_fixup *fix, int action)
3703 {
3704         struct alc_spec *spec = codec->spec;
3705         int val;
3706
3707         switch (action) {
3708         case HDA_FIXUP_ACT_PRE_PROBE:
3709                 spec->gen.hp_automute_hook = alc283_hp_automute_hook;
3710                 break;
3711         case HDA_FIXUP_ACT_INIT:
3712                 /* MIC2-VREF control */
3713                 /* Set to manual mode */
3714                 val = alc_read_coef_idx(codec, 0x06);
3715                 alc_write_coef_idx(codec, 0x06, val & ~0x000c);
3716                 break;
3717         }
3718 }
3719
3720 /* mute tablet speaker pin (0x14) via dock plugging in addition */
3721 static void asus_tx300_automute(struct hda_codec *codec)
3722 {
3723         struct alc_spec *spec = codec->spec;
3724         snd_hda_gen_update_outputs(codec);
3725         if (snd_hda_jack_detect(codec, 0x1b))
3726                 spec->gen.mute_bits |= (1ULL << 0x14);
3727 }
3728
3729 static void alc282_fixup_asus_tx300(struct hda_codec *codec,
3730                                     const struct hda_fixup *fix, int action)
3731 {
3732         struct alc_spec *spec = codec->spec;
3733         /* TX300 needs to set up GPIO2 for the speaker amp */
3734         static const struct hda_verb gpio2_verbs[] = {
3735                 { 0x01, AC_VERB_SET_GPIO_MASK, 0x04 },
3736                 { 0x01, AC_VERB_SET_GPIO_DIRECTION, 0x04 },
3737                 { 0x01, AC_VERB_SET_GPIO_DATA, 0x04 },
3738                 {}
3739         };
3740         static const struct hda_pintbl dock_pins[] = {
3741                 { 0x1b, 0x21114000 }, /* dock speaker pin */
3742                 {}
3743         };
3744         struct snd_kcontrol *kctl;
3745
3746         switch (action) {
3747         case HDA_FIXUP_ACT_PRE_PROBE:
3748                 snd_hda_add_verbs(codec, gpio2_verbs);
3749                 snd_hda_apply_pincfgs(codec, dock_pins);
3750                 spec->gen.auto_mute_via_amp = 1;
3751                 spec->gen.automute_hook = asus_tx300_automute;
3752                 snd_hda_jack_detect_enable_callback(codec, 0x1b,
3753                                                     HDA_GEN_HP_EVENT,
3754                                                     snd_hda_gen_hp_automute);
3755                 break;
3756         case HDA_FIXUP_ACT_BUILD:
3757                 /* this is a bit tricky; give more sane names for the main
3758                  * (tablet) speaker and the dock speaker, respectively
3759                  */
3760                 kctl = snd_hda_find_mixer_ctl(codec, "Speaker Playback Switch");
3761                 if (kctl)
3762                         strcpy(kctl->id.name, "Dock Speaker Playback Switch");
3763                 kctl = snd_hda_find_mixer_ctl(codec, "Bass Speaker Playback Switch");
3764                 if (kctl)
3765                         strcpy(kctl->id.name, "Speaker Playback Switch");
3766                 break;
3767         }
3768 }
3769
3770 static void alc290_fixup_mono_speakers(struct hda_codec *codec,
3771                                        const struct hda_fixup *fix, int action)
3772 {
3773         if (action == HDA_FIXUP_ACT_PRE_PROBE)
3774                 /* Remove DAC node 0x03, as it seems to be
3775                    giving mono output */
3776                 snd_hda_override_wcaps(codec, 0x03, 0);
3777 }
3778
3779 #if IS_ENABLED(CONFIG_THINKPAD_ACPI)
3780
3781 #include <linux/thinkpad_acpi.h>
3782 #include <linux/acpi.h>
3783
3784 static int (*led_set_func)(int, bool);
3785
3786 static acpi_status acpi_check_cb(acpi_handle handle, u32 lvl, void *context,
3787                                  void **rv)
3788 {
3789         bool *found = context;
3790         *found = true;
3791         return AE_OK;
3792 }
3793
3794 static bool is_thinkpad(struct hda_codec *codec)
3795 {
3796         bool found = false;
3797         if (codec->subsystem_id >> 16 != 0x17aa)
3798                 return false;
3799         if (ACPI_SUCCESS(acpi_get_devices("LEN0068", acpi_check_cb, &found, NULL)) && found)
3800                 return true;
3801         found = false;
3802         return ACPI_SUCCESS(acpi_get_devices("IBM0068", acpi_check_cb, &found, NULL)) && found;
3803 }
3804
3805 static void update_tpacpi_mute_led(void *private_data, int enabled)
3806 {
3807         if (led_set_func)
3808                 led_set_func(TPACPI_LED_MUTE, !enabled);
3809 }
3810
3811 static void update_tpacpi_micmute_led(struct hda_codec *codec,
3812                                       struct snd_ctl_elem_value *ucontrol)
3813 {
3814         if (!ucontrol || !led_set_func)
3815                 return;
3816         if (strcmp("Capture Switch", ucontrol->id.name) == 0 && ucontrol->id.index == 0) {
3817                 /* TODO: How do I verify if it's a mono or stereo here? */
3818                 bool val = ucontrol->value.integer.value[0] || ucontrol->value.integer.value[1];
3819                 led_set_func(TPACPI_LED_MICMUTE, !val);
3820         }
3821 }
3822
3823 static void alc_fixup_thinkpad_acpi(struct hda_codec *codec,
3824                                   const struct hda_fixup *fix, int action)
3825 {
3826         struct alc_spec *spec = codec->spec;
3827         bool removefunc = false;
3828
3829         if (action == HDA_FIXUP_ACT_PROBE) {
3830                 if (!is_thinkpad(codec))
3831                         return;
3832                 if (!led_set_func)
3833                         led_set_func = symbol_request(tpacpi_led_set);
3834                 if (!led_set_func) {
3835                         snd_printk(KERN_WARNING "Failed to find thinkpad-acpi symbol tpacpi_led_set\n");
3836                         return;
3837                 }
3838
3839                 removefunc = true;
3840                 if (led_set_func(TPACPI_LED_MUTE, false) >= 0) {
3841                         spec->gen.vmaster_mute.hook = update_tpacpi_mute_led;
3842                         removefunc = false;
3843                 }
3844                 if (led_set_func(TPACPI_LED_MICMUTE, false) >= 0) {
3845                         if (spec->gen.num_adc_nids > 1)
3846                                 snd_printdd("Skipping micmute LED control due to several ADCs");
3847                         else {
3848                                 spec->gen.cap_sync_hook = update_tpacpi_micmute_led;
3849                                 removefunc = false;
3850                         }
3851                 }
3852         }
3853
3854         if (led_set_func && (action == HDA_FIXUP_ACT_FREE || removefunc)) {
3855                 symbol_put(tpacpi_led_set);
3856                 led_set_func = NULL;
3857         }
3858 }
3859
3860 #else
3861
3862 static void alc_fixup_thinkpad_acpi(struct hda_codec *codec,
3863                                   const struct hda_fixup *fix, int action)
3864 {
3865 }
3866
3867 #endif
3868
3869 enum {
3870         ALC269_FIXUP_SONY_VAIO,
3871         ALC275_FIXUP_SONY_VAIO_GPIO2,
3872         ALC269_FIXUP_DELL_M101Z,
3873         ALC269_FIXUP_SKU_IGNORE,
3874         ALC269_FIXUP_ASUS_G73JW,
3875         ALC269_FIXUP_LENOVO_EAPD,
3876         ALC275_FIXUP_SONY_HWEQ,
3877         ALC271_FIXUP_DMIC,
3878         ALC269_FIXUP_PCM_44K,
3879         ALC269_FIXUP_STEREO_DMIC,
3880         ALC269_FIXUP_HEADSET_MIC,
3881         ALC269_FIXUP_QUANTA_MUTE,
3882         ALC269_FIXUP_LIFEBOOK,
3883         ALC269_FIXUP_AMIC,
3884         ALC269_FIXUP_DMIC,
3885         ALC269VB_FIXUP_AMIC,
3886         ALC269VB_FIXUP_DMIC,
3887         ALC269_FIXUP_HP_MUTE_LED,
3888         ALC269_FIXUP_HP_MUTE_LED_MIC1,
3889         ALC269_FIXUP_HP_MUTE_LED_MIC2,
3890         ALC269_FIXUP_HP_GPIO_LED,
3891         ALC269_FIXUP_INV_DMIC,
3892         ALC269_FIXUP_LENOVO_DOCK,
3893         ALC286_FIXUP_SONY_MIC_NO_PRESENCE,
3894         ALC269_FIXUP_PINCFG_NO_HP_TO_LINEOUT,
3895         ALC269_FIXUP_DELL1_MIC_NO_PRESENCE,
3896         ALC269_FIXUP_DELL2_MIC_NO_PRESENCE,
3897         ALC269_FIXUP_DELL3_MIC_NO_PRESENCE,
3898         ALC269_FIXUP_HEADSET_MODE,
3899         ALC269_FIXUP_HEADSET_MODE_NO_HP_MIC,
3900         ALC269_FIXUP_ASUS_X101_FUNC,
3901         ALC269_FIXUP_ASUS_X101_VERB,
3902         ALC269_FIXUP_ASUS_X101,
3903         ALC271_FIXUP_AMIC_MIC2,
3904         ALC271_FIXUP_HP_GATE_MIC_JACK,
3905         ALC271_FIXUP_HP_GATE_MIC_JACK_E1_572,
3906         ALC269_FIXUP_ACER_AC700,
3907         ALC269_FIXUP_LIMIT_INT_MIC_BOOST,
3908         ALC269VB_FIXUP_ASUS_ZENBOOK,
3909         ALC269_FIXUP_LIMIT_INT_MIC_BOOST_MUTE_LED,
3910         ALC269VB_FIXUP_ORDISSIMO_EVE2,
3911         ALC283_FIXUP_CHROME_BOOK,
3912         ALC283_FIXUP_SENSE_COMBO_JACK,
3913         ALC282_FIXUP_ASUS_TX300,
3914         ALC283_FIXUP_INT_MIC,
3915         ALC290_FIXUP_MONO_SPEAKERS,
3916         ALC269_FIXUP_THINKPAD_ACPI,
3917         ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
3918         ALC255_FIXUP_HEADSET_MODE,
3919 };
3920
3921 static const struct hda_fixup alc269_fixups[] = {
3922         [ALC269_FIXUP_SONY_VAIO] = {
3923                 .type = HDA_FIXUP_PINCTLS,
3924                 .v.pins = (const struct hda_pintbl[]) {
3925                         {0x19, PIN_VREFGRD},
3926                         {}
3927                 }
3928         },
3929         [ALC275_FIXUP_SONY_VAIO_GPIO2] = {
3930                 .type = HDA_FIXUP_VERBS,
3931                 .v.verbs = (const struct hda_verb[]) {
3932                         {0x01, AC_VERB_SET_GPIO_MASK, 0x04},
3933                         {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x04},
3934                         {0x01, AC_VERB_SET_GPIO_DATA, 0x00},
3935                         { }
3936                 },
3937                 .chained = true,
3938                 .chain_id = ALC269_FIXUP_SONY_VAIO
3939         },
3940         [ALC269_FIXUP_DELL_M101Z] = {
3941                 .type = HDA_FIXUP_VERBS,
3942                 .v.verbs = (const struct hda_verb[]) {
3943                         /* Enables internal speaker */
3944                         {0x20, AC_VERB_SET_COEF_INDEX, 13},
3945                         {0x20, AC_VERB_SET_PROC_COEF, 0x4040},
3946                         {}
3947                 }
3948         },
3949         [ALC269_FIXUP_SKU_IGNORE] = {
3950                 .type = HDA_FIXUP_FUNC,
3951                 .v.func = alc_fixup_sku_ignore,
3952         },
3953         [ALC269_FIXUP_ASUS_G73JW] = {
3954                 .type = HDA_FIXUP_PINS,
3955                 .v.pins = (const struct hda_pintbl[]) {
3956                         { 0x17, 0x99130111 }, /* subwoofer */
3957                         { }
3958                 }
3959         },
3960         [ALC269_FIXUP_LENOVO_EAPD] = {
3961                 .type = HDA_FIXUP_VERBS,
3962                 .v.verbs = (const struct hda_verb[]) {
3963                         {0x14, AC_VERB_SET_EAPD_BTLENABLE, 0},
3964                         {}
3965                 }
3966         },
3967         [ALC275_FIXUP_SONY_HWEQ] = {
3968                 .type = HDA_FIXUP_FUNC,
3969                 .v.func = alc269_fixup_hweq,
3970                 .chained = true,
3971                 .chain_id = ALC275_FIXUP_SONY_VAIO_GPIO2
3972         },
3973         [ALC271_FIXUP_DMIC] = {
3974                 .type = HDA_FIXUP_FUNC,
3975                 .v.func = alc271_fixup_dmic,
3976         },
3977         [ALC269_FIXUP_PCM_44K] = {
3978                 .type = HDA_FIXUP_FUNC,
3979                 .v.func = alc269_fixup_pcm_44k,
3980                 .chained = true,
3981                 .chain_id = ALC269_FIXUP_QUANTA_MUTE
3982         },
3983         [ALC269_FIXUP_STEREO_DMIC] = {
3984                 .type = HDA_FIXUP_FUNC,
3985                 .v.func = alc269_fixup_stereo_dmic,
3986         },
3987         [ALC269_FIXUP_HEADSET_MIC] = {
3988                 .type = HDA_FIXUP_FUNC,
3989                 .v.func = alc269_fixup_headset_mic,
3990         },
3991         [ALC269_FIXUP_QUANTA_MUTE] = {
3992                 .type = HDA_FIXUP_FUNC,
3993                 .v.func = alc269_fixup_quanta_mute,
3994         },
3995         [ALC269_FIXUP_LIFEBOOK] = {
3996                 .type = HDA_FIXUP_PINS,
3997                 .v.pins = (const struct hda_pintbl[]) {
3998                         { 0x1a, 0x2101103f }, /* dock line-out */
3999                         { 0x1b, 0x23a11040 }, /* dock mic-in */
4000                         { }
4001                 },
4002                 .chained = true,
4003                 .chain_id = ALC269_FIXUP_QUANTA_MUTE
4004         },
4005         [ALC269_FIXUP_AMIC] = {
4006                 .type = HDA_FIXUP_PINS,
4007                 .v.pins = (const struct hda_pintbl[]) {
4008                         { 0x14, 0x99130110 }, /* speaker */
4009                         { 0x15, 0x0121401f }, /* HP out */
4010                         { 0x18, 0x01a19c20 }, /* mic */
4011                         { 0x19, 0x99a3092f }, /* int-mic */
4012                         { }
4013                 },
4014         },
4015         [ALC269_FIXUP_DMIC] = {
4016                 .type = HDA_FIXUP_PINS,
4017                 .v.pins = (const struct hda_pintbl[]) {
4018                         { 0x12, 0x99a3092f }, /* int-mic */
4019                         { 0x14, 0x99130110 }, /* speaker */
4020                         { 0x15, 0x0121401f }, /* HP out */
4021                         { 0x18, 0x01a19c20 }, /* mic */
4022                         { }
4023                 },
4024         },
4025         [ALC269VB_FIXUP_AMIC] = {
4026                 .type = HDA_FIXUP_PINS,
4027                 .v.pins = (const struct hda_pintbl[]) {
4028                         { 0x14, 0x99130110 }, /* speaker */
4029                         { 0x18, 0x01a19c20 }, /* mic */
4030                         { 0x19, 0x99a3092f }, /* int-mic */
4031                         { 0x21, 0x0121401f }, /* HP out */
4032                         { }
4033                 },
4034         },
4035         [ALC269VB_FIXUP_DMIC] = {
4036                 .type = HDA_FIXUP_PINS,
4037                 .v.pins = (const struct hda_pintbl[]) {
4038                         { 0x12, 0x99a3092f }, /* int-mic */
4039                         { 0x14, 0x99130110 }, /* speaker */
4040                         { 0x18, 0x01a19c20 }, /* mic */
4041                         { 0x21, 0x0121401f }, /* HP out */
4042                         { }
4043                 },
4044         },
4045         [ALC269_FIXUP_HP_MUTE_LED] = {
4046                 .type = HDA_FIXUP_FUNC,
4047                 .v.func = alc269_fixup_hp_mute_led,
4048         },
4049         [ALC269_FIXUP_HP_MUTE_LED_MIC1] = {
4050                 .type = HDA_FIXUP_FUNC,
4051                 .v.func = alc269_fixup_hp_mute_led_mic1,
4052         },
4053         [ALC269_FIXUP_HP_MUTE_LED_MIC2] = {
4054                 .type = HDA_FIXUP_FUNC,
4055                 .v.func = alc269_fixup_hp_mute_led_mic2,
4056         },
4057         [ALC269_FIXUP_HP_GPIO_LED] = {
4058                 .type = HDA_FIXUP_FUNC,
4059                 .v.func = alc269_fixup_hp_gpio_led,
4060         },
4061         [ALC269_FIXUP_INV_DMIC] = {
4062                 .type = HDA_FIXUP_FUNC,
4063                 .v.func = alc_fixup_inv_dmic_0x12,
4064         },
4065         [ALC269_FIXUP_LENOVO_DOCK] = {
4066                 .type = HDA_FIXUP_PINS,
4067                 .v.pins = (const struct hda_pintbl[]) {
4068                         { 0x19, 0x23a11040 }, /* dock mic */
4069                         { 0x1b, 0x2121103f }, /* dock headphone */
4070                         { }
4071                 },
4072                 .chained = true,
4073                 .chain_id = ALC269_FIXUP_PINCFG_NO_HP_TO_LINEOUT
4074         },
4075         [ALC269_FIXUP_PINCFG_NO_HP_TO_LINEOUT] = {
4076                 .type = HDA_FIXUP_FUNC,
4077                 .v.func = alc269_fixup_pincfg_no_hp_to_lineout,
4078                 .chained = true,
4079                 .chain_id = ALC269_FIXUP_THINKPAD_ACPI,
4080         },
4081         [ALC269_FIXUP_DELL1_MIC_NO_PRESENCE] = {
4082                 .type = HDA_FIXUP_PINS,
4083                 .v.pins = (const struct hda_pintbl[]) {
4084                         { 0x19, 0x01a1913c }, /* use as headset mic, without its own jack detect */
4085                         { 0x1a, 0x01a1913d }, /* use as headphone mic, without its own jack detect */
4086                         { }
4087                 },
4088                 .chained = true,
4089                 .chain_id = ALC269_FIXUP_HEADSET_MODE
4090         },
4091         [ALC269_FIXUP_DELL2_MIC_NO_PRESENCE] = {
4092                 .type = HDA_FIXUP_PINS,
4093                 .v.pins = (const struct hda_pintbl[]) {
4094                         { 0x16, 0x21014020 }, /* dock line out */
4095                         { 0x19, 0x21a19030 }, /* dock mic */
4096                         { 0x1a, 0x01a1913c }, /* use as headset mic, without its own jack detect */
4097                         { }
4098                 },
4099                 .chained = true,
4100                 .chain_id = ALC269_FIXUP_HEADSET_MODE_NO_HP_MIC
4101         },
4102         [ALC269_FIXUP_DELL3_MIC_NO_PRESENCE] = {
4103                 .type = HDA_FIXUP_PINS,
4104                 .v.pins = (const struct hda_pintbl[]) {
4105                         { 0x1a, 0x01a1913c }, /* use as headset mic, without its own jack detect */
4106                         { }
4107                 },
4108                 .chained = true,
4109                 .chain_id = ALC269_FIXUP_HEADSET_MODE_NO_HP_MIC
4110         },
4111         [ALC269_FIXUP_HEADSET_MODE] = {
4112                 .type = HDA_FIXUP_FUNC,
4113                 .v.func = alc_fixup_headset_mode,
4114         },
4115         [ALC269_FIXUP_HEADSET_MODE_NO_HP_MIC] = {
4116                 .type = HDA_FIXUP_FUNC,
4117                 .v.func = alc_fixup_headset_mode_no_hp_mic,
4118         },
4119         [ALC286_FIXUP_SONY_MIC_NO_PRESENCE] = {
4120                 .type = HDA_FIXUP_PINS,
4121                 .v.pins = (const struct hda_pintbl[]) {
4122                         { 0x18, 0x01a1913c }, /* use as headset mic, without its own jack detect */
4123                         { }
4124                 },
4125                 .chained = true,
4126                 .chain_id = ALC269_FIXUP_HEADSET_MIC
4127         },
4128         [ALC269_FIXUP_ASUS_X101_FUNC] = {
4129                 .type = HDA_FIXUP_FUNC,
4130                 .v.func = alc269_fixup_x101_headset_mic,
4131         },
4132         [ALC269_FIXUP_ASUS_X101_VERB] = {
4133                 .type = HDA_FIXUP_VERBS,
4134                 .v.verbs = (const struct hda_verb[]) {
4135                         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
4136                         {0x20, AC_VERB_SET_COEF_INDEX, 0x08},
4137                         {0x20, AC_VERB_SET_PROC_COEF,  0x0310},
4138                         { }
4139                 },
4140                 .chained = true,
4141                 .chain_id = ALC269_FIXUP_ASUS_X101_FUNC
4142         },
4143         [ALC269_FIXUP_ASUS_X101] = {
4144                 .type = HDA_FIXUP_PINS,
4145                 .v.pins = (const struct hda_pintbl[]) {
4146                         { 0x18, 0x04a1182c }, /* Headset mic */
4147                         { }
4148                 },
4149                 .chained = true,
4150                 .chain_id = ALC269_FIXUP_ASUS_X101_VERB
4151         },
4152         [ALC271_FIXUP_AMIC_MIC2] = {
4153                 .type = HDA_FIXUP_PINS,
4154                 .v.pins = (const struct hda_pintbl[]) {
4155                         { 0x14, 0x99130110 }, /* speaker */
4156                         { 0x19, 0x01a19c20 }, /* mic */
4157                         { 0x1b, 0x99a7012f }, /* int-mic */
4158                         { 0x21, 0x0121401f }, /* HP out */
4159                         { }
4160                 },
4161         },
4162         [ALC271_FIXUP_HP_GATE_MIC_JACK] = {
4163                 .type = HDA_FIXUP_FUNC,
4164                 .v.func = alc271_hp_gate_mic_jack,
4165                 .chained = true,
4166                 .chain_id = ALC271_FIXUP_AMIC_MIC2,
4167         },
4168         [ALC271_FIXUP_HP_GATE_MIC_JACK_E1_572] = {
4169                 .type = HDA_FIXUP_FUNC,
4170                 .v.func = alc269_fixup_limit_int_mic_boost,
4171                 .chained = true,
4172                 .chain_id = ALC271_FIXUP_HP_GATE_MIC_JACK,
4173         },
4174         [ALC269_FIXUP_ACER_AC700] = {
4175                 .type = HDA_FIXUP_PINS,
4176                 .v.pins = (const struct hda_pintbl[]) {
4177                         { 0x12, 0x99a3092f }, /* int-mic */
4178                         { 0x14, 0x99130110 }, /* speaker */
4179                         { 0x18, 0x03a11c20 }, /* mic */
4180                         { 0x1e, 0x0346101e }, /* SPDIF1 */
4181                         { 0x21, 0x0321101f }, /* HP out */
4182                         { }
4183                 },
4184                 .chained = true,
4185                 .chain_id = ALC271_FIXUP_DMIC,
4186         },
4187         [ALC269_FIXUP_LIMIT_INT_MIC_BOOST] = {
4188                 .type = HDA_FIXUP_FUNC,
4189                 .v.func = alc269_fixup_limit_int_mic_boost,
4190                 .chained = true,
4191                 .chain_id = ALC269_FIXUP_THINKPAD_ACPI,
4192         },
4193         [ALC269VB_FIXUP_ASUS_ZENBOOK] = {
4194                 .type = HDA_FIXUP_FUNC,
4195                 .v.func = alc269_fixup_limit_int_mic_boost,
4196                 .chained = true,
4197                 .chain_id = ALC269VB_FIXUP_DMIC,
4198         },
4199         [ALC269_FIXUP_LIMIT_INT_MIC_BOOST_MUTE_LED] = {
4200                 .type = HDA_FIXUP_FUNC,
4201                 .v.func = alc269_fixup_limit_int_mic_boost,
4202                 .chained = true,
4203                 .chain_id = ALC269_FIXUP_HP_MUTE_LED_MIC1,
4204         },
4205         [ALC269VB_FIXUP_ORDISSIMO_EVE2] = {
4206                 .type = HDA_FIXUP_PINS,
4207                 .v.pins = (const struct hda_pintbl[]) {
4208                         { 0x12, 0x99a3092f }, /* int-mic */
4209                         { 0x18, 0x03a11d20 }, /* mic */
4210                         { 0x19, 0x411111f0 }, /* Unused bogus pin */
4211                         { }
4212                 },
4213         },
4214         [ALC283_FIXUP_CHROME_BOOK] = {
4215                 .type = HDA_FIXUP_FUNC,
4216                 .v.func = alc283_fixup_chromebook,
4217         },
4218         [ALC283_FIXUP_SENSE_COMBO_JACK] = {
4219                 .type = HDA_FIXUP_FUNC,
4220                 .v.func = alc283_fixup_sense_combo_jack,
4221                 .chained = true,
4222                 .chain_id = ALC283_FIXUP_CHROME_BOOK,
4223         },
4224         [ALC282_FIXUP_ASUS_TX300] = {
4225                 .type = HDA_FIXUP_FUNC,
4226                 .v.func = alc282_fixup_asus_tx300,
4227         },
4228         [ALC283_FIXUP_INT_MIC] = {
4229                 .type = HDA_FIXUP_VERBS,
4230                 .v.verbs = (const struct hda_verb[]) {
4231                         {0x20, AC_VERB_SET_COEF_INDEX, 0x1a},
4232                         {0x20, AC_VERB_SET_PROC_COEF, 0x0011},
4233                         { }
4234                 },
4235                 .chained = true,
4236                 .chain_id = ALC269_FIXUP_LIMIT_INT_MIC_BOOST
4237         },
4238         [ALC290_FIXUP_MONO_SPEAKERS] = {
4239                 .type = HDA_FIXUP_FUNC,
4240                 .v.func = alc290_fixup_mono_speakers,
4241                 .chained = true,
4242                 .chain_id = ALC269_FIXUP_DELL3_MIC_NO_PRESENCE,
4243         },
4244         [ALC269_FIXUP_THINKPAD_ACPI] = {
4245                 .type = HDA_FIXUP_FUNC,
4246                 .v.func = alc_fixup_thinkpad_acpi,
4247         },
4248         [ALC255_FIXUP_DELL1_MIC_NO_PRESENCE] = {
4249                 .type = HDA_FIXUP_PINS,
4250                 .v.pins = (const struct hda_pintbl[]) {
4251                         { 0x19, 0x01a1913c }, /* use as headset mic, without its own jack detect */
4252                         { 0x1a, 0x01a1913d }, /* use as headphone mic, without its own jack detect */
4253                         { }
4254                 },
4255                 .chained = true,
4256                 .chain_id = ALC255_FIXUP_HEADSET_MODE
4257         },
4258         [ALC255_FIXUP_HEADSET_MODE] = {
4259                 .type = HDA_FIXUP_FUNC,
4260                 .v.func = alc_fixup_headset_mode_alc255,
4261         },
4262 };
4263
4264 static const struct snd_pci_quirk alc269_fixup_tbl[] = {
4265         SND_PCI_QUIRK(0x1025, 0x029b, "Acer 1810TZ", ALC269_FIXUP_INV_DMIC),
4266         SND_PCI_QUIRK(0x1025, 0x0349, "Acer AOD260", ALC269_FIXUP_INV_DMIC),
4267         SND_PCI_QUIRK(0x1025, 0x047c, "Acer AC700", ALC269_FIXUP_ACER_AC700),
4268         SND_PCI_QUIRK(0x1025, 0x0740, "Acer AO725", ALC271_FIXUP_HP_GATE_MIC_JACK),
4269         SND_PCI_QUIRK(0x1025, 0x0742, "Acer AO756", ALC271_FIXUP_HP_GATE_MIC_JACK),
4270         SND_PCI_QUIRK_VENDOR(0x1025, "Acer Aspire", ALC271_FIXUP_DMIC),
4271         SND_PCI_QUIRK(0x1025, 0x0775, "Acer Aspire E1-572", ALC271_FIXUP_HP_GATE_MIC_JACK_E1_572),
4272         SND_PCI_QUIRK(0x1028, 0x0470, "Dell M101z", ALC269_FIXUP_DELL_M101Z),
4273         SND_PCI_QUIRK(0x1028, 0x05bd, "Dell", ALC269_FIXUP_DELL2_MIC_NO_PRESENCE),
4274         SND_PCI_QUIRK(0x1028, 0x05be, "Dell", ALC269_FIXUP_DELL2_MIC_NO_PRESENCE),
4275         SND_PCI_QUIRK(0x1028, 0x05c4, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE),
4276         SND_PCI_QUIRK(0x1028, 0x05c5, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE),
4277         SND_PCI_QUIRK(0x1028, 0x05c6, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE),
4278         SND_PCI_QUIRK(0x1028, 0x05c7, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE),
4279         SND_PCI_QUIRK(0x1028, 0x05c8, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE),
4280         SND_PCI_QUIRK(0x1028, 0x05c9, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE),
4281         SND_PCI_QUIRK(0x1028, 0x05ca, "Dell", ALC269_FIXUP_DELL2_MIC_NO_PRESENCE),
4282         SND_PCI_QUIRK(0x1028, 0x05cb, "Dell", ALC269_FIXUP_DELL2_MIC_NO_PRESENCE),
4283         SND_PCI_QUIRK(0x1028, 0x05cc, "Dell X5 Precision", ALC269_FIXUP_DELL2_MIC_NO_PRESENCE),
4284         SND_PCI_QUIRK(0x1028, 0x05cd, "Dell X5 Precision", ALC269_FIXUP_DELL2_MIC_NO_PRESENCE),
4285         SND_PCI_QUIRK(0x1028, 0x05de, "Dell", ALC269_FIXUP_DELL2_MIC_NO_PRESENCE),
4286         SND_PCI_QUIRK(0x1028, 0x05e0, "Dell", ALC269_FIXUP_DELL2_MIC_NO_PRESENCE),
4287         SND_PCI_QUIRK(0x1028, 0x05e9, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE),
4288         SND_PCI_QUIRK(0x1028, 0x05ea, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE),
4289         SND_PCI_QUIRK(0x1028, 0x05eb, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE),
4290         SND_PCI_QUIRK(0x1028, 0x05ec, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE),
4291         SND_PCI_QUIRK(0x1028, 0x05ed, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE),
4292         SND_PCI_QUIRK(0x1028, 0x05ee, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE),
4293         SND_PCI_QUIRK(0x1028, 0x05f3, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE),
4294         SND_PCI_QUIRK(0x1028, 0x05f4, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE),
4295         SND_PCI_QUIRK(0x1028, 0x05f5, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE),
4296         SND_PCI_QUIRK(0x1028, 0x05f6, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE),
4297         SND_PCI_QUIRK(0x1028, 0x05f8, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE),
4298         SND_PCI_QUIRK(0x1028, 0x05f9, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE),
4299         SND_PCI_QUIRK(0x1028, 0x05fb, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE),
4300         SND_PCI_QUIRK(0x1028, 0x0606, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE),
4301         SND_PCI_QUIRK(0x1028, 0x0608, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE),
4302         SND_PCI_QUIRK(0x1028, 0x0609, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE),
4303         SND_PCI_QUIRK(0x1028, 0x0610, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE),
4304         SND_PCI_QUIRK(0x1028, 0x0613, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE),
4305         SND_PCI_QUIRK(0x1028, 0x0614, "Dell Inspiron 3135", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE),
4306         SND_PCI_QUIRK(0x1028, 0x0616, "Dell Vostro 5470", ALC290_FIXUP_MONO_SPEAKERS),
4307         SND_PCI_QUIRK(0x1028, 0x061f, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE),
4308         SND_PCI_QUIRK(0x1028, 0x0629, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE),
4309         SND_PCI_QUIRK(0x1028, 0x0638, "Dell Inspiron 5439", ALC290_FIXUP_MONO_SPEAKERS),
4310         SND_PCI_QUIRK(0x1028, 0x063e, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE),
4311         SND_PCI_QUIRK(0x1028, 0x063f, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE),
4312         SND_PCI_QUIRK(0x1028, 0x15cc, "Dell X5 Precision", ALC269_FIXUP_DELL2_MIC_NO_PRESENCE),
4313         SND_PCI_QUIRK(0x1028, 0x15cd, "Dell X5 Precision", ALC269_FIXUP_DELL2_MIC_NO_PRESENCE),
4314         SND_PCI_QUIRK(0x103c, 0x1586, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC2),
4315         SND_PCI_QUIRK(0x103c, 0x18e6, "HP", ALC269_FIXUP_HP_GPIO_LED),
4316         SND_PCI_QUIRK(0x103c, 0x1973, "HP Pavilion", ALC269_FIXUP_HP_MUTE_LED_MIC1),
4317         SND_PCI_QUIRK(0x103c, 0x1983, "HP Pavilion", ALC269_FIXUP_HP_MUTE_LED_MIC1),
4318         SND_PCI_QUIRK(0x103c, 0x218b, "HP", ALC269_FIXUP_LIMIT_INT_MIC_BOOST_MUTE_LED),
4319         SND_PCI_QUIRK_VENDOR(0x103c, "HP", ALC269_FIXUP_HP_MUTE_LED),
4320         SND_PCI_QUIRK(0x1043, 0x103f, "ASUS TX300", ALC282_FIXUP_ASUS_TX300),
4321         SND_PCI_QUIRK(0x1043, 0x106d, "Asus K53BE", ALC269_FIXUP_LIMIT_INT_MIC_BOOST),
4322         SND_PCI_QUIRK(0x1043, 0x115d, "Asus 1015E", ALC269_FIXUP_LIMIT_INT_MIC_BOOST),
4323         SND_PCI_QUIRK(0x1043, 0x1427, "Asus Zenbook UX31E", ALC269VB_FIXUP_ASUS_ZENBOOK),
4324         SND_PCI_QUIRK(0x1043, 0x1517, "Asus Zenbook UX31A", ALC269VB_FIXUP_ASUS_ZENBOOK),
4325         SND_PCI_QUIRK(0x1043, 0x16e3, "ASUS UX50", ALC269_FIXUP_STEREO_DMIC),
4326         SND_PCI_QUIRK(0x1043, 0x1a13, "Asus G73Jw", ALC269_FIXUP_ASUS_G73JW),
4327         SND_PCI_QUIRK(0x1043, 0x1b13, "Asus U41SV", ALC269_FIXUP_INV_DMIC),
4328         SND_PCI_QUIRK(0x1043, 0x1c23, "Asus X55U", ALC269_FIXUP_LIMIT_INT_MIC_BOOST),
4329         SND_PCI_QUIRK(0x1043, 0x831a, "ASUS P901", ALC269_FIXUP_STEREO_DMIC),
4330         SND_PCI_QUIRK(0x1043, 0x834a, "ASUS S101", ALC269_FIXUP_STEREO_DMIC),
4331         SND_PCI_QUIRK(0x1043, 0x8398, "ASUS P1005", ALC269_FIXUP_STEREO_DMIC),
4332         SND_PCI_QUIRK(0x1043, 0x83ce, "ASUS P1005", ALC269_FIXUP_STEREO_DMIC),
4333         SND_PCI_QUIRK(0x1043, 0x8516, "ASUS X101CH", ALC269_FIXUP_ASUS_X101),
4334         SND_PCI_QUIRK(0x104d, 0x90b6, "Sony VAIO Pro 13", ALC286_FIXUP_SONY_MIC_NO_PRESENCE),
4335         SND_PCI_QUIRK(0x104d, 0x9073, "Sony VAIO", ALC275_FIXUP_SONY_VAIO_GPIO2),
4336         SND_PCI_QUIRK(0x104d, 0x907b, "Sony VAIO", ALC275_FIXUP_SONY_HWEQ),
4337         SND_PCI_QUIRK(0x104d, 0x9084, "Sony VAIO", ALC275_FIXUP_SONY_HWEQ),
4338         SND_PCI_QUIRK_VENDOR(0x104d, "Sony VAIO", ALC269_FIXUP_SONY_VAIO),
4339         SND_PCI_QUIRK(0x10cf, 0x1475, "Lifebook", ALC269_FIXUP_LIFEBOOK),
4340         SND_PCI_QUIRK(0x17aa, 0x20f2, "Thinkpad SL410/510", ALC269_FIXUP_SKU_IGNORE),
4341         SND_PCI_QUIRK(0x17aa, 0x215e, "Thinkpad L512", ALC269_FIXUP_SKU_IGNORE),
4342         SND_PCI_QUIRK(0x17aa, 0x21b8, "Thinkpad Edge 14", ALC269_FIXUP_SKU_IGNORE),
4343         SND_PCI_QUIRK(0x17aa, 0x21ca, "Thinkpad L412", ALC269_FIXUP_SKU_IGNORE),
4344         SND_PCI_QUIRK(0x17aa, 0x21e9, "Thinkpad Edge 15", ALC269_FIXUP_SKU_IGNORE),
4345         SND_PCI_QUIRK(0x17aa, 0x21f6, "Thinkpad T530", ALC269_FIXUP_LENOVO_DOCK),
4346         SND_PCI_QUIRK(0x17aa, 0x21fa, "Thinkpad X230", ALC269_FIXUP_LENOVO_DOCK),
4347         SND_PCI_QUIRK(0x17aa, 0x21f3, "Thinkpad T430", ALC269_FIXUP_LENOVO_DOCK),
4348         SND_PCI_QUIRK(0x17aa, 0x21fb, "Thinkpad T430s", ALC269_FIXUP_LENOVO_DOCK),
4349         SND_PCI_QUIRK(0x17aa, 0x2203, "Thinkpad X230 Tablet", ALC269_FIXUP_LENOVO_DOCK),
4350         SND_PCI_QUIRK(0x17aa, 0x2208, "Thinkpad T431s", ALC269_FIXUP_LENOVO_DOCK),
4351         SND_PCI_QUIRK(0x17aa, 0x220c, "Thinkpad", ALC269_FIXUP_LIMIT_INT_MIC_BOOST),
4352         SND_PCI_QUIRK(0x17aa, 0x2212, "Thinkpad", ALC269_FIXUP_LIMIT_INT_MIC_BOOST),
4353         SND_PCI_QUIRK(0x17aa, 0x2214, "Thinkpad", ALC269_FIXUP_LIMIT_INT_MIC_BOOST),
4354         SND_PCI_QUIRK(0x17aa, 0x2215, "Thinkpad", ALC269_FIXUP_LIMIT_INT_MIC_BOOST),
4355         SND_PCI_QUIRK(0x17aa, 0x5013, "Thinkpad", ALC269_FIXUP_LIMIT_INT_MIC_BOOST),
4356         SND_PCI_QUIRK(0x17aa, 0x501a, "Thinkpad", ALC283_FIXUP_INT_MIC),
4357         SND_PCI_QUIRK(0x17aa, 0x5026, "Thinkpad", ALC269_FIXUP_LIMIT_INT_MIC_BOOST),
4358         SND_PCI_QUIRK(0x17aa, 0x5109, "Thinkpad", ALC269_FIXUP_LIMIT_INT_MIC_BOOST),
4359         SND_PCI_QUIRK(0x17aa, 0x3bf8, "Quanta FL1", ALC269_FIXUP_PCM_44K),
4360         SND_PCI_QUIRK(0x17aa, 0x9e54, "LENOVO NB", ALC269_FIXUP_LENOVO_EAPD),
4361         SND_PCI_QUIRK_VENDOR(0x17aa, "Thinkpad", ALC269_FIXUP_THINKPAD_ACPI),
4362         SND_PCI_QUIRK(0x1b7d, 0xa831, "Ordissimo EVE2 ", ALC269VB_FIXUP_ORDISSIMO_EVE2), /* Also known as Malata PC-B1303 */
4363
4364 #if 0
4365         /* Below is a quirk table taken from the old code.
4366          * Basically the device should work as is without the fixup table.
4367          * If BIOS doesn't give a proper info, enable the corresponding
4368          * fixup entry.
4369          */
4370         SND_PCI_QUIRK(0x1043, 0x8330, "ASUS Eeepc P703 P900A",
4371                       ALC269_FIXUP_AMIC),
4372         SND_PCI_QUIRK(0x1043, 0x1013, "ASUS N61Da", ALC269_FIXUP_AMIC),
4373         SND_PCI_QUIRK(0x1043, 0x1143, "ASUS B53f", ALC269_FIXUP_AMIC),
4374         SND_PCI_QUIRK(0x1043, 0x1133, "ASUS UJ20ft", ALC269_FIXUP_AMIC),
4375         SND_PCI_QUIRK(0x1043, 0x1183, "ASUS K72DR", ALC269_FIXUP_AMIC),
4376         SND_PCI_QUIRK(0x1043, 0x11b3, "ASUS K52DR", ALC269_FIXUP_AMIC),
4377         SND_PCI_QUIRK(0x1043, 0x11e3, "ASUS U33Jc", ALC269_FIXUP_AMIC),
4378         SND_PCI_QUIRK(0x1043, 0x1273, "ASUS UL80Jt", ALC269_FIXUP_AMIC),
4379         SND_PCI_QUIRK(0x1043, 0x1283, "ASUS U53Jc", ALC269_FIXUP_AMIC),
4380         SND_PCI_QUIRK(0x1043, 0x12b3, "ASUS N82JV", ALC269_FIXUP_AMIC),
4381         SND_PCI_QUIRK(0x1043, 0x12d3, "ASUS N61Jv", ALC269_FIXUP_AMIC),
4382         SND_PCI_QUIRK(0x1043, 0x13a3, "ASUS UL30Vt", ALC269_FIXUP_AMIC),
4383         SND_PCI_QUIRK(0x1043, 0x1373, "ASUS G73JX", ALC269_FIXUP_AMIC),
4384         SND_PCI_QUIRK(0x1043, 0x1383, "ASUS UJ30Jc", ALC269_FIXUP_AMIC),
4385         SND_PCI_QUIRK(0x1043, 0x13d3, "ASUS N61JA", ALC269_FIXUP_AMIC),
4386         SND_PCI_QUIRK(0x1043, 0x1413, "ASUS UL50", ALC269_FIXUP_AMIC),
4387         SND_PCI_QUIRK(0x1043, 0x1443, "ASUS UL30", ALC269_FIXUP_AMIC),
4388         SND_PCI_QUIRK(0x1043, 0x1453, "ASUS M60Jv", ALC269_FIXUP_AMIC),
4389         SND_PCI_QUIRK(0x1043, 0x1483, "ASUS UL80", ALC269_FIXUP_AMIC),
4390         SND_PCI_QUIRK(0x1043, 0x14f3, "ASUS F83Vf", ALC269_FIXUP_AMIC),
4391         SND_PCI_QUIRK(0x1043, 0x14e3, "ASUS UL20", ALC269_FIXUP_AMIC),
4392         SND_PCI_QUIRK(0x1043, 0x1513, "ASUS UX30", ALC269_FIXUP_AMIC),
4393         SND_PCI_QUIRK(0x1043, 0x1593, "ASUS N51Vn", ALC269_FIXUP_AMIC),
4394         SND_PCI_QUIRK(0x1043, 0x15a3, "ASUS N60Jv", ALC269_FIXUP_AMIC),
4395         SND_PCI_QUIRK(0x1043, 0x15b3, "ASUS N60Dp", ALC269_FIXUP_AMIC),
4396         SND_PCI_QUIRK(0x1043, 0x15c3, "ASUS N70De", ALC269_FIXUP_AMIC),
4397         SND_PCI_QUIRK(0x1043, 0x15e3, "ASUS F83T", ALC269_FIXUP_AMIC),
4398         SND_PCI_QUIRK(0x1043, 0x1643, "ASUS M60J", ALC269_FIXUP_AMIC),
4399         SND_PCI_QUIRK(0x1043, 0x1653, "ASUS U50", ALC269_FIXUP_AMIC),
4400         SND_PCI_QUIRK(0x1043, 0x1693, "ASUS F50N", ALC269_FIXUP_AMIC),
4401         SND_PCI_QUIRK(0x1043, 0x16a3, "ASUS F5Q", ALC269_FIXUP_AMIC),
4402         SND_PCI_QUIRK(0x1043, 0x1723, "ASUS P80", ALC269_FIXUP_AMIC),
4403         SND_PCI_QUIRK(0x1043, 0x1743, "ASUS U80", ALC269_FIXUP_AMIC),
4404         SND_PCI_QUIRK(0x1043, 0x1773, "ASUS U20A", ALC269_FIXUP_AMIC),
4405         SND_PCI_QUIRK(0x1043, 0x1883, "ASUS F81Se", ALC269_FIXUP_AMIC),
4406         SND_PCI_QUIRK(0x152d, 0x1778, "Quanta ON1", ALC269_FIXUP_DMIC),
4407         SND_PCI_QUIRK(0x17aa, 0x3be9, "Quanta Wistron", ALC269_FIXUP_AMIC),
4408         SND_PCI_QUIRK(0x17aa, 0x3bf8, "Quanta FL1", ALC269_FIXUP_AMIC),
4409         SND_PCI_QUIRK(0x17ff, 0x059a, "Quanta EL3", ALC269_FIXUP_DMIC),
4410         SND_PCI_QUIRK(0x17ff, 0x059b, "Quanta JR1", ALC269_FIXUP_DMIC),
4411 #endif
4412         {}
4413 };
4414
4415 static const struct hda_model_fixup alc269_fixup_models[] = {
4416         {.id = ALC269_FIXUP_AMIC, .name = "laptop-amic"},
4417         {.id = ALC269_FIXUP_DMIC, .name = "laptop-dmic"},
4418         {.id = ALC269_FIXUP_STEREO_DMIC, .name = "alc269-dmic"},
4419         {.id = ALC271_FIXUP_DMIC, .name = "alc271-dmic"},
4420         {.id = ALC269_FIXUP_INV_DMIC, .name = "inv-dmic"},
4421         {.id = ALC269_FIXUP_HEADSET_MIC, .name = "headset-mic"},
4422         {.id = ALC269_FIXUP_LENOVO_DOCK, .name = "lenovo-dock"},
4423         {.id = ALC269_FIXUP_HP_GPIO_LED, .name = "hp-gpio-led"},
4424         {.id = ALC269_FIXUP_DELL1_MIC_NO_PRESENCE, .name = "dell-headset-multi"},
4425         {.id = ALC269_FIXUP_DELL2_MIC_NO_PRESENCE, .name = "dell-headset-dock"},
4426         {.id = ALC283_FIXUP_CHROME_BOOK, .name = "alc283-chrome"},
4427         {.id = ALC283_FIXUP_SENSE_COMBO_JACK, .name = "alc283-sense-combo"},
4428         {}
4429 };
4430
4431
4432 static void alc269_fill_coef(struct hda_codec *codec)
4433 {
4434         struct alc_spec *spec = codec->spec;
4435         int val;
4436
4437         if (spec->codec_variant != ALC269_TYPE_ALC269VB)
4438                 return;
4439
4440         if ((alc_get_coef0(codec) & 0x00ff) < 0x015) {
4441                 alc_write_coef_idx(codec, 0xf, 0x960b);
4442                 alc_write_coef_idx(codec, 0xe, 0x8817);
4443         }
4444
4445         if ((alc_get_coef0(codec) & 0x00ff) == 0x016) {
4446                 alc_write_coef_idx(codec, 0xf, 0x960b);
4447                 alc_write_coef_idx(codec, 0xe, 0x8814);
4448         }
4449
4450         if ((alc_get_coef0(codec) & 0x00ff) == 0x017) {
4451                 val = alc_read_coef_idx(codec, 0x04);
4452                 /* Power up output pin */
4453                 alc_write_coef_idx(codec, 0x04, val | (1<<11));
4454         }
4455
4456         if ((alc_get_coef0(codec) & 0x00ff) == 0x018) {
4457                 val = alc_read_coef_idx(codec, 0xd);
4458                 if ((val & 0x0c00) >> 10 != 0x1) {
4459                         /* Capless ramp up clock control */
4460                         alc_write_coef_idx(codec, 0xd, val | (1<<10));
4461                 }
4462                 val = alc_read_coef_idx(codec, 0x17);
4463                 if ((val & 0x01c0) >> 6 != 0x4) {
4464                         /* Class D power on reset */
4465                         alc_write_coef_idx(codec, 0x17, val | (1<<7));
4466                 }
4467         }
4468
4469         val = alc_read_coef_idx(codec, 0xd); /* Class D */
4470         alc_write_coef_idx(codec, 0xd, val | (1<<14));
4471
4472         val = alc_read_coef_idx(codec, 0x4); /* HP */
4473         alc_write_coef_idx(codec, 0x4, val | (1<<11));
4474 }
4475
4476 /*
4477  */
4478 static int patch_alc269(struct hda_codec *codec)
4479 {
4480         struct alc_spec *spec;
4481         int err;
4482
4483         err = alc_alloc_spec(codec, 0x0b);
4484         if (err < 0)
4485                 return err;
4486
4487         spec = codec->spec;
4488         spec->gen.shared_mic_vref_pin = 0x18;
4489
4490         snd_hda_pick_fixup(codec, alc269_fixup_models,
4491                        alc269_fixup_tbl, alc269_fixups);
4492         snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE);
4493
4494         alc_auto_parse_customize_define(codec);
4495
4496         if (has_cdefine_beep(codec))
4497                 spec->gen.beep_nid = 0x01;
4498
4499         switch (codec->vendor_id) {
4500         case 0x10ec0269:
4501                 spec->codec_variant = ALC269_TYPE_ALC269VA;
4502                 switch (alc_get_coef0(codec) & 0x00f0) {
4503                 case 0x0010:
4504                         if (codec->bus->pci->subsystem_vendor == 0x1025 &&
4505                             spec->cdefine.platform_type == 1)
4506                                 err = alc_codec_rename(codec, "ALC271X");
4507                         spec->codec_variant = ALC269_TYPE_ALC269VB;
4508                         break;
4509                 case 0x0020:
4510                         if (codec->bus->pci->subsystem_vendor == 0x17aa &&
4511                             codec->bus->pci->subsystem_device == 0x21f3)
4512                                 err = alc_codec_rename(codec, "ALC3202");
4513                         spec->codec_variant = ALC269_TYPE_ALC269VC;
4514                         break;
4515                 case 0x0030:
4516                         spec->codec_variant = ALC269_TYPE_ALC269VD;
4517                         break;
4518                 default:
4519                         alc_fix_pll_init(codec, 0x20, 0x04, 15);
4520                 }
4521                 if (err < 0)
4522                         goto error;
4523                 spec->init_hook = alc269_fill_coef;
4524                 alc269_fill_coef(codec);
4525                 break;
4526
4527         case 0x10ec0280:
4528         case 0x10ec0290:
4529                 spec->codec_variant = ALC269_TYPE_ALC280;
4530                 break;
4531         case 0x10ec0282:
4532                 spec->codec_variant = ALC269_TYPE_ALC282;
4533                 break;
4534         case 0x10ec0233:
4535         case 0x10ec0283:
4536                 spec->codec_variant = ALC269_TYPE_ALC283;
4537                 spec->shutup = alc283_shutup;
4538                 spec->init_hook = alc283_init;
4539                 break;
4540         case 0x10ec0284:
4541         case 0x10ec0292:
4542                 spec->codec_variant = ALC269_TYPE_ALC284;
4543                 break;
4544         case 0x10ec0285:
4545         case 0x10ec0293:
4546                 spec->codec_variant = ALC269_TYPE_ALC285;
4547                 break;
4548         case 0x10ec0286:
4549                 spec->codec_variant = ALC269_TYPE_ALC286;
4550                 break;
4551         case 0x10ec0255:
4552                 spec->codec_variant = ALC269_TYPE_ALC255;
4553                 break;
4554         }
4555
4556         if (snd_hda_codec_read(codec, 0x51, 0, AC_VERB_PARAMETERS, 0) == 0x10ec5505) {
4557                 spec->has_alc5505_dsp = 1;
4558                 spec->init_hook = alc5505_dsp_init;
4559         }
4560
4561         /* automatic parse from the BIOS config */
4562         err = alc269_parse_auto_config(codec);
4563         if (err < 0)
4564                 goto error;
4565
4566         if (!spec->gen.no_analog && spec->gen.beep_nid)
4567                 set_beep_amp(spec, 0x0b, 0x04, HDA_INPUT);
4568
4569         codec->patch_ops = alc_patch_ops;
4570 #ifdef CONFIG_PM
4571         codec->patch_ops.suspend = alc269_suspend;
4572         codec->patch_ops.resume = alc269_resume;
4573 #endif
4574         if (!spec->shutup)
4575                 spec->shutup = alc269_shutup;
4576
4577         snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE);
4578
4579         return 0;
4580
4581  error:
4582         alc_free(codec);
4583         return err;
4584 }
4585
4586 /*
4587  * ALC861
4588  */
4589
4590 static int alc861_parse_auto_config(struct hda_codec *codec)
4591 {
4592         static const hda_nid_t alc861_ignore[] = { 0x1d, 0 };
4593         static const hda_nid_t alc861_ssids[] = { 0x0e, 0x0f, 0x0b, 0 };
4594         return alc_parse_auto_config(codec, alc861_ignore, alc861_ssids);
4595 }
4596
4597 /* Pin config fixes */
4598 enum {
4599         ALC861_FIXUP_FSC_AMILO_PI1505,
4600         ALC861_FIXUP_AMP_VREF_0F,
4601         ALC861_FIXUP_NO_JACK_DETECT,
4602         ALC861_FIXUP_ASUS_A6RP,
4603         ALC660_FIXUP_ASUS_W7J,
4604 };
4605
4606 /* On some laptops, VREF of pin 0x0f is abused for controlling the main amp */
4607 static void alc861_fixup_asus_amp_vref_0f(struct hda_codec *codec,
4608                         const struct hda_fixup *fix, int action)
4609 {
4610         struct alc_spec *spec = codec->spec;
4611         unsigned int val;
4612
4613         if (action != HDA_FIXUP_ACT_INIT)
4614                 return;
4615         val = snd_hda_codec_get_pin_target(codec, 0x0f);
4616         if (!(val & (AC_PINCTL_IN_EN | AC_PINCTL_OUT_EN)))
4617                 val |= AC_PINCTL_IN_EN;
4618         val |= AC_PINCTL_VREF_50;
4619         snd_hda_set_pin_ctl(codec, 0x0f, val);
4620         spec->gen.keep_vref_in_automute = 1;
4621 }
4622
4623 /* suppress the jack-detection */
4624 static void alc_fixup_no_jack_detect(struct hda_codec *codec,
4625                                      const struct hda_fixup *fix, int action)
4626 {
4627         if (action == HDA_FIXUP_ACT_PRE_PROBE)
4628                 codec->no_jack_detect = 1;
4629 }
4630
4631 static const struct hda_fixup alc861_fixups[] = {
4632         [ALC861_FIXUP_FSC_AMILO_PI1505] = {
4633                 .type = HDA_FIXUP_PINS,
4634                 .v.pins = (const struct hda_pintbl[]) {
4635                         { 0x0b, 0x0221101f }, /* HP */
4636                         { 0x0f, 0x90170310 }, /* speaker */
4637                         { }
4638                 }
4639         },
4640         [ALC861_FIXUP_AMP_VREF_0F] = {
4641                 .type = HDA_FIXUP_FUNC,
4642                 .v.func = alc861_fixup_asus_amp_vref_0f,
4643         },
4644         [ALC861_FIXUP_NO_JACK_DETECT] = {
4645                 .type = HDA_FIXUP_FUNC,
4646                 .v.func = alc_fixup_no_jack_detect,
4647         },
4648         [ALC861_FIXUP_ASUS_A6RP] = {
4649                 .type = HDA_FIXUP_FUNC,
4650                 .v.func = alc861_fixup_asus_amp_vref_0f,
4651                 .chained = true,
4652                 .chain_id = ALC861_FIXUP_NO_JACK_DETECT,
4653         },
4654         [ALC660_FIXUP_ASUS_W7J] = {
4655                 .type = HDA_FIXUP_VERBS,
4656                 .v.verbs = (const struct hda_verb[]) {
4657                         /* ASUS W7J needs a magic pin setup on unused NID 0x10
4658                          * for enabling outputs
4659                          */
4660                         {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
4661                         { }
4662                 },
4663         }
4664 };
4665
4666 static const struct snd_pci_quirk alc861_fixup_tbl[] = {
4667         SND_PCI_QUIRK(0x1043, 0x1253, "ASUS W7J", ALC660_FIXUP_ASUS_W7J),
4668         SND_PCI_QUIRK(0x1043, 0x1263, "ASUS Z35HL", ALC660_FIXUP_ASUS_W7J),
4669         SND_PCI_QUIRK(0x1043, 0x1393, "ASUS A6Rp", ALC861_FIXUP_ASUS_A6RP),
4670         SND_PCI_QUIRK_VENDOR(0x1043, "ASUS laptop", ALC861_FIXUP_AMP_VREF_0F),
4671         SND_PCI_QUIRK(0x1462, 0x7254, "HP DX2200", ALC861_FIXUP_NO_JACK_DETECT),
4672         SND_PCI_QUIRK(0x1584, 0x2b01, "Haier W18", ALC861_FIXUP_AMP_VREF_0F),
4673         SND_PCI_QUIRK(0x1584, 0x0000, "Uniwill ECS M31EI", ALC861_FIXUP_AMP_VREF_0F),
4674         SND_PCI_QUIRK(0x1734, 0x10c7, "FSC Amilo Pi1505", ALC861_FIXUP_FSC_AMILO_PI1505),
4675         {}
4676 };
4677
4678 /*
4679  */
4680 static int patch_alc861(struct hda_codec *codec)
4681 {
4682         struct alc_spec *spec;
4683         int err;
4684
4685         err = alc_alloc_spec(codec, 0x15);
4686         if (err < 0)
4687                 return err;
4688
4689         spec = codec->spec;
4690         spec->gen.beep_nid = 0x23;
4691
4692         snd_hda_pick_fixup(codec, NULL, alc861_fixup_tbl, alc861_fixups);
4693         snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE);
4694
4695         /* automatic parse from the BIOS config */
4696         err = alc861_parse_auto_config(codec);
4697         if (err < 0)
4698                 goto error;
4699
4700         if (!spec->gen.no_analog)
4701                 set_beep_amp(spec, 0x23, 0, HDA_OUTPUT);
4702
4703         codec->patch_ops = alc_patch_ops;
4704 #ifdef CONFIG_PM
4705         spec->power_hook = alc_power_eapd;
4706 #endif
4707
4708         snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE);
4709
4710         return 0;
4711
4712  error:
4713         alc_free(codec);
4714         return err;
4715 }
4716
4717 /*
4718  * ALC861-VD support
4719  *
4720  * Based on ALC882
4721  *
4722  * In addition, an independent DAC
4723  */
4724 static int alc861vd_parse_auto_config(struct hda_codec *codec)
4725 {
4726         static const hda_nid_t alc861vd_ignore[] = { 0x1d, 0 };
4727         static const hda_nid_t alc861vd_ssids[] = { 0x15, 0x1b, 0x14, 0 };
4728         return alc_parse_auto_config(codec, alc861vd_ignore, alc861vd_ssids);
4729 }
4730
4731 enum {
4732         ALC660VD_FIX_ASUS_GPIO1,
4733         ALC861VD_FIX_DALLAS,
4734 };
4735
4736 /* exclude VREF80 */
4737 static void alc861vd_fixup_dallas(struct hda_codec *codec,
4738                                   const struct hda_fixup *fix, int action)
4739 {
4740         if (action == HDA_FIXUP_ACT_PRE_PROBE) {
4741                 snd_hda_override_pin_caps(codec, 0x18, 0x00000734);
4742                 snd_hda_override_pin_caps(codec, 0x19, 0x0000073c);
4743         }
4744 }
4745
4746 static const struct hda_fixup alc861vd_fixups[] = {
4747         [ALC660VD_FIX_ASUS_GPIO1] = {
4748                 .type = HDA_FIXUP_VERBS,
4749                 .v.verbs = (const struct hda_verb[]) {
4750                         /* reset GPIO1 */
4751                         {0x01, AC_VERB_SET_GPIO_MASK, 0x03},
4752                         {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x01},
4753                         {0x01, AC_VERB_SET_GPIO_DATA, 0x01},
4754                         { }
4755                 }
4756         },
4757         [ALC861VD_FIX_DALLAS] = {
4758                 .type = HDA_FIXUP_FUNC,
4759                 .v.func = alc861vd_fixup_dallas,
4760         },
4761 };
4762
4763 static const struct snd_pci_quirk alc861vd_fixup_tbl[] = {
4764         SND_PCI_QUIRK(0x103c, 0x30bf, "HP TX1000", ALC861VD_FIX_DALLAS),
4765         SND_PCI_QUIRK(0x1043, 0x1339, "ASUS A7-K", ALC660VD_FIX_ASUS_GPIO1),
4766         SND_PCI_QUIRK(0x1179, 0xff31, "Toshiba L30-149", ALC861VD_FIX_DALLAS),
4767         {}
4768 };
4769
4770 /*
4771  */
4772 static int patch_alc861vd(struct hda_codec *codec)
4773 {
4774         struct alc_spec *spec;
4775         int err;
4776
4777         err = alc_alloc_spec(codec, 0x0b);
4778         if (err < 0)
4779                 return err;
4780
4781         spec = codec->spec;
4782         spec->gen.beep_nid = 0x23;
4783
4784         snd_hda_pick_fixup(codec, NULL, alc861vd_fixup_tbl, alc861vd_fixups);
4785         snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE);
4786
4787         /* automatic parse from the BIOS config */
4788         err = alc861vd_parse_auto_config(codec);
4789         if (err < 0)
4790                 goto error;
4791
4792         if (!spec->gen.no_analog)
4793                 set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
4794
4795         codec->patch_ops = alc_patch_ops;
4796
4797         spec->shutup = alc_eapd_shutup;
4798
4799         snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE);
4800
4801         return 0;
4802
4803  error:
4804         alc_free(codec);
4805         return err;
4806 }
4807
4808 /*
4809  * ALC662 support
4810  *
4811  * ALC662 is almost identical with ALC880 but has cleaner and more flexible
4812  * configuration.  Each pin widget can choose any input DACs and a mixer.
4813  * Each ADC is connected from a mixer of all inputs.  This makes possible
4814  * 6-channel independent captures.
4815  *
4816  * In addition, an independent DAC for the multi-playback (not used in this
4817  * driver yet).
4818  */
4819
4820 /*
4821  * BIOS auto configuration
4822  */
4823
4824 static int alc662_parse_auto_config(struct hda_codec *codec)
4825 {
4826         static const hda_nid_t alc662_ignore[] = { 0x1d, 0 };
4827         static const hda_nid_t alc663_ssids[] = { 0x15, 0x1b, 0x14, 0x21 };
4828         static const hda_nid_t alc662_ssids[] = { 0x15, 0x1b, 0x14, 0 };
4829         const hda_nid_t *ssids;
4830
4831         if (codec->vendor_id == 0x10ec0272 || codec->vendor_id == 0x10ec0663 ||
4832             codec->vendor_id == 0x10ec0665 || codec->vendor_id == 0x10ec0670 ||
4833             codec->vendor_id == 0x10ec0671)
4834                 ssids = alc663_ssids;
4835         else
4836                 ssids = alc662_ssids;
4837         return alc_parse_auto_config(codec, alc662_ignore, ssids);
4838 }
4839
4840 static void alc272_fixup_mario(struct hda_codec *codec,
4841                                const struct hda_fixup *fix, int action)
4842 {
4843         if (action != HDA_FIXUP_ACT_PRE_PROBE)
4844                 return;
4845         if (snd_hda_override_amp_caps(codec, 0x2, HDA_OUTPUT,
4846                                       (0x3b << AC_AMPCAP_OFFSET_SHIFT) |
4847                                       (0x3b << AC_AMPCAP_NUM_STEPS_SHIFT) |
4848                                       (0x03 << AC_AMPCAP_STEP_SIZE_SHIFT) |
4849                                       (0 << AC_AMPCAP_MUTE_SHIFT)))
4850                 printk(KERN_WARNING
4851                        "hda_codec: failed to override amp caps for NID 0x2\n");
4852 }
4853
4854 static const struct snd_pcm_chmap_elem asus_pcm_2_1_chmaps[] = {
4855         { .channels = 2,
4856           .map = { SNDRV_CHMAP_FL, SNDRV_CHMAP_FR } },
4857         { .channels = 4,
4858           .map = { SNDRV_CHMAP_FL, SNDRV_CHMAP_FR,
4859                    SNDRV_CHMAP_NA, SNDRV_CHMAP_LFE } }, /* LFE only on right */
4860         { }
4861 };
4862
4863 /* override the 2.1 chmap */
4864 static void alc_fixup_bass_chmap(struct hda_codec *codec,
4865                                     const struct hda_fixup *fix, int action)
4866 {
4867         if (action == HDA_FIXUP_ACT_BUILD) {
4868                 struct alc_spec *spec = codec->spec;
4869                 spec->gen.pcm_rec[0].stream[0].chmap = asus_pcm_2_1_chmaps;
4870         }
4871 }
4872
4873 enum {
4874         ALC662_FIXUP_ASPIRE,
4875         ALC662_FIXUP_IDEAPAD,
4876         ALC272_FIXUP_MARIO,
4877         ALC662_FIXUP_CZC_P10T,
4878         ALC662_FIXUP_SKU_IGNORE,
4879         ALC662_FIXUP_HP_RP5800,
4880         ALC662_FIXUP_ASUS_MODE1,
4881         ALC662_FIXUP_ASUS_MODE2,
4882         ALC662_FIXUP_ASUS_MODE3,
4883         ALC662_FIXUP_ASUS_MODE4,
4884         ALC662_FIXUP_ASUS_MODE5,
4885         ALC662_FIXUP_ASUS_MODE6,
4886         ALC662_FIXUP_ASUS_MODE7,
4887         ALC662_FIXUP_ASUS_MODE8,
4888         ALC662_FIXUP_NO_JACK_DETECT,
4889         ALC662_FIXUP_ZOTAC_Z68,
4890         ALC662_FIXUP_INV_DMIC,
4891         ALC668_FIXUP_DELL_MIC_NO_PRESENCE,
4892         ALC668_FIXUP_HEADSET_MODE,
4893         ALC662_FIXUP_BASS_CHMAP,
4894         ALC662_FIXUP_BASS_1A,
4895         ALC662_FIXUP_BASS_1A_CHMAP,
4896 };
4897
4898 static const struct hda_fixup alc662_fixups[] = {
4899         [ALC662_FIXUP_ASPIRE] = {
4900                 .type = HDA_FIXUP_PINS,
4901                 .v.pins = (const struct hda_pintbl[]) {
4902                         { 0x15, 0x99130112 }, /* subwoofer */
4903                         { }
4904                 }
4905         },
4906         [ALC662_FIXUP_IDEAPAD] = {
4907                 .type = HDA_FIXUP_PINS,
4908                 .v.pins = (const struct hda_pintbl[]) {
4909                         { 0x17, 0x99130112 }, /* subwoofer */
4910                         { }
4911                 }
4912         },
4913         [ALC272_FIXUP_MARIO] = {
4914                 .type = HDA_FIXUP_FUNC,
4915                 .v.func = alc272_fixup_mario,
4916         },
4917         [ALC662_FIXUP_CZC_P10T] = {
4918                 .type = HDA_FIXUP_VERBS,
4919                 .v.verbs = (const struct hda_verb[]) {
4920                         {0x14, AC_VERB_SET_EAPD_BTLENABLE, 0},
4921                         {}
4922                 }
4923         },
4924         [ALC662_FIXUP_SKU_IGNORE] = {
4925                 .type = HDA_FIXUP_FUNC,
4926                 .v.func = alc_fixup_sku_ignore,
4927         },
4928         [ALC662_FIXUP_HP_RP5800] = {
4929                 .type = HDA_FIXUP_PINS,
4930                 .v.pins = (const struct hda_pintbl[]) {
4931                         { 0x14, 0x0221201f }, /* HP out */
4932                         { }
4933                 },
4934                 .chained = true,
4935                 .chain_id = ALC662_FIXUP_SKU_IGNORE
4936         },
4937         [ALC662_FIXUP_ASUS_MODE1] = {
4938                 .type = HDA_FIXUP_PINS,
4939                 .v.pins = (const struct hda_pintbl[]) {
4940                         { 0x14, 0x99130110 }, /* speaker */
4941                         { 0x18, 0x01a19c20 }, /* mic */
4942                         { 0x19, 0x99a3092f }, /* int-mic */
4943                         { 0x21, 0x0121401f }, /* HP out */
4944                         { }
4945                 },
4946                 .chained = true,
4947                 .chain_id = ALC662_FIXUP_SKU_IGNORE
4948         },
4949         [ALC662_FIXUP_ASUS_MODE2] = {
4950                 .type = HDA_FIXUP_PINS,
4951                 .v.pins = (const struct hda_pintbl[]) {
4952                         { 0x14, 0x99130110 }, /* speaker */
4953                         { 0x18, 0x01a19820 }, /* mic */
4954                         { 0x19, 0x99a3092f }, /* int-mic */
4955                         { 0x1b, 0x0121401f }, /* HP out */
4956                         { }
4957                 },
4958                 .chained = true,
4959                 .chain_id = ALC662_FIXUP_SKU_IGNORE
4960         },
4961         [ALC662_FIXUP_ASUS_MODE3] = {
4962                 .type = HDA_FIXUP_PINS,
4963                 .v.pins = (const struct hda_pintbl[]) {
4964                         { 0x14, 0x99130110 }, /* speaker */
4965                         { 0x15, 0x0121441f }, /* HP */
4966                         { 0x18, 0x01a19840 }, /* mic */
4967                         { 0x19, 0x99a3094f }, /* int-mic */
4968                         { 0x21, 0x01211420 }, /* HP2 */
4969                         { }
4970                 },
4971                 .chained = true,
4972                 .chain_id = ALC662_FIXUP_SKU_IGNORE
4973         },
4974         [ALC662_FIXUP_ASUS_MODE4] = {
4975                 .type = HDA_FIXUP_PINS,
4976                 .v.pins = (const struct hda_pintbl[]) {
4977                         { 0x14, 0x99130110 }, /* speaker */
4978                         { 0x16, 0x99130111 }, /* speaker */
4979                         { 0x18, 0x01a19840 }, /* mic */
4980                         { 0x19, 0x99a3094f }, /* int-mic */
4981                         { 0x21, 0x0121441f }, /* HP */
4982                         { }
4983                 },
4984                 .chained = true,
4985                 .chain_id = ALC662_FIXUP_SKU_IGNORE
4986         },
4987         [ALC662_FIXUP_ASUS_MODE5] = {
4988                 .type = HDA_FIXUP_PINS,
4989                 .v.pins = (const struct hda_pintbl[]) {
4990                         { 0x14, 0x99130110 }, /* speaker */
4991                         { 0x15, 0x0121441f }, /* HP */
4992                         { 0x16, 0x99130111 }, /* speaker */
4993                         { 0x18, 0x01a19840 }, /* mic */
4994                         { 0x19, 0x99a3094f }, /* int-mic */
4995                         { }
4996                 },
4997                 .chained = true,
4998                 .chain_id = ALC662_FIXUP_SKU_IGNORE
4999         },
5000         [ALC662_FIXUP_ASUS_MODE6] = {
5001                 .type = HDA_FIXUP_PINS,
5002                 .v.pins = (const struct hda_pintbl[]) {
5003                         { 0x14, 0x99130110 }, /* speaker */
5004                         { 0x15, 0x01211420 }, /* HP2 */
5005                         { 0x18, 0x01a19840 }, /* mic */
5006                         { 0x19, 0x99a3094f }, /* int-mic */
5007                         { 0x1b, 0x0121441f }, /* HP */
5008                         { }
5009                 },
5010                 .chained = true,
5011                 .chain_id = ALC662_FIXUP_SKU_IGNORE
5012         },
5013         [ALC662_FIXUP_ASUS_MODE7] = {
5014                 .type = HDA_FIXUP_PINS,
5015                 .v.pins = (const struct hda_pintbl[]) {
5016                         { 0x14, 0x99130110 }, /* speaker */
5017                         { 0x17, 0x99130111 }, /* speaker */
5018                         { 0x18, 0x01a19840 }, /* mic */
5019                         { 0x19, 0x99a3094f }, /* int-mic */
5020                         { 0x1b, 0x01214020 }, /* HP */
5021                         { 0x21, 0x0121401f }, /* HP */
5022                         { }
5023                 },
5024                 .chained = true,
5025                 .chain_id = ALC662_FIXUP_SKU_IGNORE
5026         },
5027         [ALC662_FIXUP_ASUS_MODE8] = {
5028                 .type = HDA_FIXUP_PINS,
5029                 .v.pins = (const struct hda_pintbl[]) {
5030                         { 0x14, 0x99130110 }, /* speaker */
5031                         { 0x12, 0x99a30970 }, /* int-mic */
5032                         { 0x15, 0x01214020 }, /* HP */
5033                         { 0x17, 0x99130111 }, /* speaker */
5034                         { 0x18, 0x01a19840 }, /* mic */
5035                         { 0x21, 0x0121401f }, /* HP */
5036                         { }
5037                 },
5038                 .chained = true,
5039                 .chain_id = ALC662_FIXUP_SKU_IGNORE
5040         },
5041         [ALC662_FIXUP_NO_JACK_DETECT] = {
5042                 .type = HDA_FIXUP_FUNC,
5043                 .v.func = alc_fixup_no_jack_detect,
5044         },
5045         [ALC662_FIXUP_ZOTAC_Z68] = {
5046                 .type = HDA_FIXUP_PINS,
5047                 .v.pins = (const struct hda_pintbl[]) {
5048                         { 0x1b, 0x02214020 }, /* Front HP */
5049                         { }
5050                 }
5051         },
5052         [ALC662_FIXUP_INV_DMIC] = {
5053                 .type = HDA_FIXUP_FUNC,
5054                 .v.func = alc_fixup_inv_dmic_0x12,
5055         },
5056         [ALC668_FIXUP_DELL_MIC_NO_PRESENCE] = {
5057                 .type = HDA_FIXUP_PINS,
5058                 .v.pins = (const struct hda_pintbl[]) {
5059                         { 0x19, 0x03a1913d }, /* use as headphone mic, without its own jack detect */
5060                         { 0x1b, 0x03a1113c }, /* use as headset mic, without its own jack detect */
5061                         { }
5062                 },
5063                 .chained = true,
5064                 .chain_id = ALC668_FIXUP_HEADSET_MODE
5065         },
5066         [ALC668_FIXUP_HEADSET_MODE] = {
5067                 .type = HDA_FIXUP_FUNC,
5068                 .v.func = alc_fixup_headset_mode_alc668,
5069         },
5070         [ALC662_FIXUP_BASS_CHMAP] = {
5071                 .type = HDA_FIXUP_FUNC,
5072                 .v.func = alc_fixup_bass_chmap,
5073                 .chained = true,
5074                 .chain_id = ALC662_FIXUP_ASUS_MODE4
5075         },
5076         [ALC662_FIXUP_BASS_1A] = {
5077                 .type = HDA_FIXUP_PINS,
5078                 .v.pins = (const struct hda_pintbl[]) {
5079                         {0x1a, 0x80106111}, /* bass speaker */
5080                         {}
5081                 },
5082         },
5083         [ALC662_FIXUP_BASS_1A_CHMAP] = {
5084                 .type = HDA_FIXUP_FUNC,
5085                 .v.func = alc_fixup_bass_chmap,
5086                 .chained = true,
5087                 .chain_id = ALC662_FIXUP_BASS_1A,
5088         },
5089 };
5090
5091 static const struct snd_pci_quirk alc662_fixup_tbl[] = {
5092         SND_PCI_QUIRK(0x1019, 0x9087, "ECS", ALC662_FIXUP_ASUS_MODE2),
5093         SND_PCI_QUIRK(0x1025, 0x022f, "Acer Aspire One", ALC662_FIXUP_INV_DMIC),
5094         SND_PCI_QUIRK(0x1025, 0x0308, "Acer Aspire 8942G", ALC662_FIXUP_ASPIRE),
5095         SND_PCI_QUIRK(0x1025, 0x031c, "Gateway NV79", ALC662_FIXUP_SKU_IGNORE),
5096         SND_PCI_QUIRK(0x1025, 0x0349, "eMachines eM250", ALC662_FIXUP_INV_DMIC),
5097         SND_PCI_QUIRK(0x1025, 0x034a, "Gateway LT27", ALC662_FIXUP_INV_DMIC),
5098         SND_PCI_QUIRK(0x1025, 0x038b, "Acer Aspire 8943G", ALC662_FIXUP_ASPIRE),
5099         SND_PCI_QUIRK(0x1028, 0x05d8, "Dell", ALC668_FIXUP_DELL_MIC_NO_PRESENCE),
5100         SND_PCI_QUIRK(0x1028, 0x05db, "Dell", ALC668_FIXUP_DELL_MIC_NO_PRESENCE),
5101         SND_PCI_QUIRK(0x1028, 0x0623, "Dell", ALC668_FIXUP_DELL_MIC_NO_PRESENCE),
5102         SND_PCI_QUIRK(0x1028, 0x0624, "Dell", ALC668_FIXUP_DELL_MIC_NO_PRESENCE),
5103         SND_PCI_QUIRK(0x1028, 0x0625, "Dell", ALC668_FIXUP_DELL_MIC_NO_PRESENCE),
5104         SND_PCI_QUIRK(0x1028, 0x0626, "Dell", ALC668_FIXUP_DELL_MIC_NO_PRESENCE),
5105         SND_PCI_QUIRK(0x1028, 0x0628, "Dell", ALC668_FIXUP_DELL_MIC_NO_PRESENCE),
5106         SND_PCI_QUIRK(0x103c, 0x1632, "HP RP5800", ALC662_FIXUP_HP_RP5800),
5107         SND_PCI_QUIRK(0x1043, 0x11cd, "Asus N550", ALC662_FIXUP_BASS_1A_CHMAP),
5108         SND_PCI_QUIRK(0x1043, 0x1477, "ASUS N56VZ", ALC662_FIXUP_BASS_CHMAP),
5109         SND_PCI_QUIRK(0x1043, 0x1bf3, "ASUS N76VZ", ALC662_FIXUP_BASS_CHMAP),
5110         SND_PCI_QUIRK(0x1043, 0x8469, "ASUS mobo", ALC662_FIXUP_NO_JACK_DETECT),
5111         SND_PCI_QUIRK(0x105b, 0x0cd6, "Foxconn", ALC662_FIXUP_ASUS_MODE2),
5112         SND_PCI_QUIRK(0x144d, 0xc051, "Samsung R720", ALC662_FIXUP_IDEAPAD),
5113         SND_PCI_QUIRK(0x17aa, 0x38af, "Lenovo Ideapad Y550P", ALC662_FIXUP_IDEAPAD),
5114         SND_PCI_QUIRK(0x17aa, 0x3a0d, "Lenovo Ideapad Y550", ALC662_FIXUP_IDEAPAD),
5115         SND_PCI_QUIRK(0x19da, 0xa130, "Zotac Z68", ALC662_FIXUP_ZOTAC_Z68),
5116         SND_PCI_QUIRK(0x1b35, 0x2206, "CZC P10T", ALC662_FIXUP_CZC_P10T),
5117
5118 #if 0
5119         /* Below is a quirk table taken from the old code.
5120          * Basically the device should work as is without the fixup table.
5121          * If BIOS doesn't give a proper info, enable the corresponding
5122          * fixup entry.
5123          */
5124         SND_PCI_QUIRK(0x1043, 0x1000, "ASUS N50Vm", ALC662_FIXUP_ASUS_MODE1),
5125         SND_PCI_QUIRK(0x1043, 0x1092, "ASUS NB", ALC662_FIXUP_ASUS_MODE3),
5126         SND_PCI_QUIRK(0x1043, 0x1173, "ASUS K73Jn", ALC662_FIXUP_ASUS_MODE1),
5127         SND_PCI_QUIRK(0x1043, 0x11c3, "ASUS M70V", ALC662_FIXUP_ASUS_MODE3),
5128         SND_PCI_QUIRK(0x1043, 0x11d3, "ASUS NB", ALC662_FIXUP_ASUS_MODE1),
5129         SND_PCI_QUIRK(0x1043, 0x11f3, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),
5130         SND_PCI_QUIRK(0x1043, 0x1203, "ASUS NB", ALC662_FIXUP_ASUS_MODE1),
5131         SND_PCI_QUIRK(0x1043, 0x1303, "ASUS G60J", ALC662_FIXUP_ASUS_MODE1),
5132         SND_PCI_QUIRK(0x1043, 0x1333, "ASUS G60Jx", ALC662_FIXUP_ASUS_MODE1),
5133         SND_PCI_QUIRK(0x1043, 0x1339, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),
5134         SND_PCI_QUIRK(0x1043, 0x13e3, "ASUS N71JA", ALC662_FIXUP_ASUS_MODE7),
5135         SND_PCI_QUIRK(0x1043, 0x1463, "ASUS N71", ALC662_FIXUP_ASUS_MODE7),
5136         SND_PCI_QUIRK(0x1043, 0x14d3, "ASUS G72", ALC662_FIXUP_ASUS_MODE8),
5137         SND_PCI_QUIRK(0x1043, 0x1563, "ASUS N90", ALC662_FIXUP_ASUS_MODE3),
5138         SND_PCI_QUIRK(0x1043, 0x15d3, "ASUS N50SF F50SF", ALC662_FIXUP_ASUS_MODE1),
5139         SND_PCI_QUIRK(0x1043, 0x16c3, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),
5140         SND_PCI_QUIRK(0x1043, 0x16f3, "ASUS K40C K50C", ALC662_FIXUP_ASUS_MODE2),
5141         SND_PCI_QUIRK(0x1043, 0x1733, "ASUS N81De", ALC662_FIXUP_ASUS_MODE1),
5142         SND_PCI_QUIRK(0x1043, 0x1753, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),
5143         SND_PCI_QUIRK(0x1043, 0x1763, "ASUS NB", ALC662_FIXUP_ASUS_MODE6),
5144         SND_PCI_QUIRK(0x1043, 0x1765, "ASUS NB", ALC662_FIXUP_ASUS_MODE6),
5145         SND_PCI_QUIRK(0x1043, 0x1783, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),
5146         SND_PCI_QUIRK(0x1043, 0x1793, "ASUS F50GX", ALC662_FIXUP_ASUS_MODE1),
5147         SND_PCI_QUIRK(0x1043, 0x17b3, "ASUS F70SL", ALC662_FIXUP_ASUS_MODE3),
5148         SND_PCI_QUIRK(0x1043, 0x17f3, "ASUS X58LE", ALC662_FIXUP_ASUS_MODE2),
5149         SND_PCI_QUIRK(0x1043, 0x1813, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),
5150         SND_PCI_QUIRK(0x1043, 0x1823, "ASUS NB", ALC662_FIXUP_ASUS_MODE5),
5151         SND_PCI_QUIRK(0x1043, 0x1833, "ASUS NB", ALC662_FIXUP_ASUS_MODE6),
5152         SND_PCI_QUIRK(0x1043, 0x1843, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),
5153         SND_PCI_QUIRK(0x1043, 0x1853, "ASUS F50Z", ALC662_FIXUP_ASUS_MODE1),
5154         SND_PCI_QUIRK(0x1043, 0x1864, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),
5155         SND_PCI_QUIRK(0x1043, 0x1876, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),
5156         SND_PCI_QUIRK(0x1043, 0x1893, "ASUS M50Vm", ALC662_FIXUP_ASUS_MODE3),
5157         SND_PCI_QUIRK(0x1043, 0x1894, "ASUS X55", ALC662_FIXUP_ASUS_MODE3),
5158         SND_PCI_QUIRK(0x1043, 0x18b3, "ASUS N80Vc", ALC662_FIXUP_ASUS_MODE1),
5159         SND_PCI_QUIRK(0x1043, 0x18c3, "ASUS VX5", ALC662_FIXUP_ASUS_MODE1),
5160         SND_PCI_QUIRK(0x1043, 0x18d3, "ASUS N81Te", ALC662_FIXUP_ASUS_MODE1),
5161         SND_PCI_QUIRK(0x1043, 0x18f3, "ASUS N505Tp", ALC662_FIXUP_ASUS_MODE1),
5162         SND_PCI_QUIRK(0x1043, 0x1903, "ASUS F5GL", ALC662_FIXUP_ASUS_MODE1),
5163         SND_PCI_QUIRK(0x1043, 0x1913, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),
5164         SND_PCI_QUIRK(0x1043, 0x1933, "ASUS F80Q", ALC662_FIXUP_ASUS_MODE2),
5165         SND_PCI_QUIRK(0x1043, 0x1943, "ASUS Vx3V", ALC662_FIXUP_ASUS_MODE1),
5166         SND_PCI_QUIRK(0x1043, 0x1953, "ASUS NB", ALC662_FIXUP_ASUS_MODE1),
5167         SND_PCI_QUIRK(0x1043, 0x1963, "ASUS X71C", ALC662_FIXUP_ASUS_MODE3),
5168         SND_PCI_QUIRK(0x1043, 0x1983, "ASUS N5051A", ALC662_FIXUP_ASUS_MODE1),
5169         SND_PCI_QUIRK(0x1043, 0x1993, "ASUS N20", ALC662_FIXUP_ASUS_MODE1),
5170         SND_PCI_QUIRK(0x1043, 0x19b3, "ASUS F7Z", ALC662_FIXUP_ASUS_MODE1),
5171         SND_PCI_QUIRK(0x1043, 0x19c3, "ASUS F5Z/F6x", ALC662_FIXUP_ASUS_MODE2),
5172         SND_PCI_QUIRK(0x1043, 0x19e3, "ASUS NB", ALC662_FIXUP_ASUS_MODE1),
5173         SND_PCI_QUIRK(0x1043, 0x19f3, "ASUS NB", ALC662_FIXUP_ASUS_MODE4),
5174 #endif
5175         {}
5176 };
5177
5178 static const struct hda_model_fixup alc662_fixup_models[] = {
5179         {.id = ALC272_FIXUP_MARIO, .name = "mario"},
5180         {.id = ALC662_FIXUP_ASUS_MODE1, .name = "asus-mode1"},
5181         {.id = ALC662_FIXUP_ASUS_MODE2, .name = "asus-mode2"},
5182         {.id = ALC662_FIXUP_ASUS_MODE3, .name = "asus-mode3"},
5183         {.id = ALC662_FIXUP_ASUS_MODE4, .name = "asus-mode4"},
5184         {.id = ALC662_FIXUP_ASUS_MODE5, .name = "asus-mode5"},
5185         {.id = ALC662_FIXUP_ASUS_MODE6, .name = "asus-mode6"},
5186         {.id = ALC662_FIXUP_ASUS_MODE7, .name = "asus-mode7"},
5187         {.id = ALC662_FIXUP_ASUS_MODE8, .name = "asus-mode8"},
5188         {.id = ALC662_FIXUP_INV_DMIC, .name = "inv-dmic"},
5189         {.id = ALC668_FIXUP_DELL_MIC_NO_PRESENCE, .name = "dell-headset-multi"},
5190         {}
5191 };
5192
5193 static void alc662_fill_coef(struct hda_codec *codec)
5194 {
5195         int val, coef;
5196
5197         coef = alc_get_coef0(codec);
5198
5199         switch (codec->vendor_id) {
5200         case 0x10ec0662:
5201                 if ((coef & 0x00f0) == 0x0030) {
5202                         val = alc_read_coef_idx(codec, 0x4); /* EAPD Ctrl */
5203                         alc_write_coef_idx(codec, 0x4, val & ~(1<<10));
5204                 }
5205                 break;
5206         case 0x10ec0272:
5207         case 0x10ec0273:
5208         case 0x10ec0663:
5209         case 0x10ec0665:
5210         case 0x10ec0670:
5211         case 0x10ec0671:
5212         case 0x10ec0672:
5213                 val = alc_read_coef_idx(codec, 0xd); /* EAPD Ctrl */
5214                 alc_write_coef_idx(codec, 0xd, val | (1<<14));
5215                 break;
5216         }
5217 }
5218
5219 /*
5220  */
5221 static int patch_alc662(struct hda_codec *codec)
5222 {
5223         struct alc_spec *spec;
5224         int err;
5225
5226         err = alc_alloc_spec(codec, 0x0b);
5227         if (err < 0)
5228                 return err;
5229
5230         spec = codec->spec;
5231
5232         /* handle multiple HPs as is */
5233         spec->parse_flags = HDA_PINCFG_NO_HP_FIXUP;
5234
5235         alc_fix_pll_init(codec, 0x20, 0x04, 15);
5236
5237         spec->init_hook = alc662_fill_coef;
5238         alc662_fill_coef(codec);
5239
5240         snd_hda_pick_fixup(codec, alc662_fixup_models,
5241                        alc662_fixup_tbl, alc662_fixups);
5242         snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE);
5243
5244         alc_auto_parse_customize_define(codec);
5245
5246         if (has_cdefine_beep(codec))
5247                 spec->gen.beep_nid = 0x01;
5248
5249         if ((alc_get_coef0(codec) & (1 << 14)) &&
5250             codec->bus->pci->subsystem_vendor == 0x1025 &&
5251             spec->cdefine.platform_type == 1) {
5252                 err = alc_codec_rename(codec, "ALC272X");
5253                 if (err < 0)
5254                         goto error;
5255         }
5256
5257         /* automatic parse from the BIOS config */
5258         err = alc662_parse_auto_config(codec);
5259         if (err < 0)
5260                 goto error;
5261
5262         if (!spec->gen.no_analog && spec->gen.beep_nid) {
5263                 switch (codec->vendor_id) {
5264                 case 0x10ec0662:
5265                         set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
5266                         break;
5267                 case 0x10ec0272:
5268                 case 0x10ec0663:
5269                 case 0x10ec0665:
5270                 case 0x10ec0668:
5271                         set_beep_amp(spec, 0x0b, 0x04, HDA_INPUT);
5272                         break;
5273                 case 0x10ec0273:
5274                         set_beep_amp(spec, 0x0b, 0x03, HDA_INPUT);
5275                         break;
5276                 }
5277         }
5278
5279         codec->patch_ops = alc_patch_ops;
5280         spec->shutup = alc_eapd_shutup;
5281
5282         snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE);
5283
5284         return 0;
5285
5286  error:
5287         alc_free(codec);
5288         return err;
5289 }
5290
5291 /*
5292  * ALC680 support
5293  */
5294
5295 static int alc680_parse_auto_config(struct hda_codec *codec)
5296 {
5297         return alc_parse_auto_config(codec, NULL, NULL);
5298 }
5299
5300 /*
5301  */
5302 static int patch_alc680(struct hda_codec *codec)
5303 {
5304         int err;
5305
5306         /* ALC680 has no aa-loopback mixer */
5307         err = alc_alloc_spec(codec, 0);
5308         if (err < 0)
5309                 return err;
5310
5311         /* automatic parse from the BIOS config */
5312         err = alc680_parse_auto_config(codec);
5313         if (err < 0) {
5314                 alc_free(codec);
5315                 return err;
5316         }
5317
5318         codec->patch_ops = alc_patch_ops;
5319
5320         return 0;
5321 }
5322
5323 /*
5324  * patch entries
5325  */
5326 static const struct hda_codec_preset snd_hda_preset_realtek[] = {
5327         { .id = 0x10ec0221, .name = "ALC221", .patch = patch_alc269 },
5328         { .id = 0x10ec0231, .name = "ALC231", .patch = patch_alc269 },
5329         { .id = 0x10ec0233, .name = "ALC233", .patch = patch_alc269 },
5330         { .id = 0x10ec0255, .name = "ALC255", .patch = patch_alc269 },
5331         { .id = 0x10ec0260, .name = "ALC260", .patch = patch_alc260 },
5332         { .id = 0x10ec0262, .name = "ALC262", .patch = patch_alc262 },
5333         { .id = 0x10ec0267, .name = "ALC267", .patch = patch_alc268 },
5334         { .id = 0x10ec0268, .name = "ALC268", .patch = patch_alc268 },
5335         { .id = 0x10ec0269, .name = "ALC269", .patch = patch_alc269 },
5336         { .id = 0x10ec0270, .name = "ALC270", .patch = patch_alc269 },
5337         { .id = 0x10ec0272, .name = "ALC272", .patch = patch_alc662 },
5338         { .id = 0x10ec0275, .name = "ALC275", .patch = patch_alc269 },
5339         { .id = 0x10ec0276, .name = "ALC276", .patch = patch_alc269 },
5340         { .id = 0x10ec0280, .name = "ALC280", .patch = patch_alc269 },
5341         { .id = 0x10ec0282, .name = "ALC282", .patch = patch_alc269 },
5342         { .id = 0x10ec0283, .name = "ALC283", .patch = patch_alc269 },
5343         { .id = 0x10ec0284, .name = "ALC284", .patch = patch_alc269 },
5344         { .id = 0x10ec0285, .name = "ALC285", .patch = patch_alc269 },
5345         { .id = 0x10ec0286, .name = "ALC286", .patch = patch_alc269 },
5346         { .id = 0x10ec0290, .name = "ALC290", .patch = patch_alc269 },
5347         { .id = 0x10ec0292, .name = "ALC292", .patch = patch_alc269 },
5348         { .id = 0x10ec0293, .name = "ALC293", .patch = patch_alc269 },
5349         { .id = 0x10ec0861, .rev = 0x100340, .name = "ALC660",
5350           .patch = patch_alc861 },
5351         { .id = 0x10ec0660, .name = "ALC660-VD", .patch = patch_alc861vd },
5352         { .id = 0x10ec0861, .name = "ALC861", .patch = patch_alc861 },
5353         { .id = 0x10ec0862, .name = "ALC861-VD", .patch = patch_alc861vd },
5354         { .id = 0x10ec0662, .rev = 0x100002, .name = "ALC662 rev2",
5355           .patch = patch_alc882 },
5356         { .id = 0x10ec0662, .rev = 0x100101, .name = "ALC662 rev1",
5357           .patch = patch_alc662 },
5358         { .id = 0x10ec0662, .rev = 0x100300, .name = "ALC662 rev3",
5359           .patch = patch_alc662 },
5360         { .id = 0x10ec0663, .name = "ALC663", .patch = patch_alc662 },
5361         { .id = 0x10ec0665, .name = "ALC665", .patch = patch_alc662 },
5362         { .id = 0x10ec0668, .name = "ALC668", .patch = patch_alc662 },
5363         { .id = 0x10ec0670, .name = "ALC670", .patch = patch_alc662 },
5364         { .id = 0x10ec0671, .name = "ALC671", .patch = patch_alc662 },
5365         { .id = 0x10ec0680, .name = "ALC680", .patch = patch_alc680 },
5366         { .id = 0x10ec0880, .name = "ALC880", .patch = patch_alc880 },
5367         { .id = 0x10ec0882, .name = "ALC882", .patch = patch_alc882 },
5368         { .id = 0x10ec0883, .name = "ALC883", .patch = patch_alc882 },
5369         { .id = 0x10ec0885, .rev = 0x100101, .name = "ALC889A",
5370           .patch = patch_alc882 },
5371         { .id = 0x10ec0885, .rev = 0x100103, .name = "ALC889A",
5372           .patch = patch_alc882 },
5373         { .id = 0x10ec0885, .name = "ALC885", .patch = patch_alc882 },
5374         { .id = 0x10ec0887, .name = "ALC887", .patch = patch_alc882 },
5375         { .id = 0x10ec0888, .rev = 0x100101, .name = "ALC1200",
5376           .patch = patch_alc882 },
5377         { .id = 0x10ec0888, .name = "ALC888", .patch = patch_alc882 },
5378         { .id = 0x10ec0889, .name = "ALC889", .patch = patch_alc882 },
5379         { .id = 0x10ec0892, .name = "ALC892", .patch = patch_alc662 },
5380         { .id = 0x10ec0899, .name = "ALC898", .patch = patch_alc882 },
5381         { .id = 0x10ec0900, .name = "ALC1150", .patch = patch_alc882 },
5382         {} /* terminator */
5383 };
5384
5385 MODULE_ALIAS("snd-hda-codec-id:10ec*");
5386
5387 MODULE_LICENSE("GPL");
5388 MODULE_DESCRIPTION("Realtek HD-audio codec");
5389
5390 static struct hda_codec_preset_list realtek_list = {
5391         .preset = snd_hda_preset_realtek,
5392         .owner = THIS_MODULE,
5393 };
5394
5395 static int __init patch_realtek_init(void)
5396 {
5397         return snd_hda_add_codec_preset(&realtek_list);
5398 }
5399
5400 static void __exit patch_realtek_exit(void)
5401 {
5402         snd_hda_delete_codec_preset(&realtek_list);
5403 }
5404
5405 module_init(patch_realtek_init)
5406 module_exit(patch_realtek_exit)