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