~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/sound/pci/hda/patch_realtek.c

Version: ~ [ linux-4.20-rc6 ] ~ [ linux-4.19.8 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.87 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.144 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.166 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.128 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.61 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ linux-3.10.108 ] ~ [ linux-3.9.11 ] ~ [ linux-3.8.13 ] ~ [ linux-3.7.10 ] ~ [ linux-3.6.11 ] ~ [ linux-3.5.7 ] ~ [ linux-3.4.113 ] ~ [ linux-3.3.8 ] ~ [ linux-3.2.102 ] ~ [ linux-3.1.10 ] ~ [ linux-3.0.101 ] ~ [ linux-2.6.39.4 ] ~ [ linux-2.6.38.8 ] ~ [ linux-2.6.37.6 ] ~ [ linux-2.6.36.4 ] ~ [ linux-2.6.35.14 ] ~ [ linux-2.6.34.15 ] ~ [ linux-2.6.33.20 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.31.14 ] ~ [ linux-2.6.30.10 ] ~ [ linux-2.6.29.6 ] ~ [ linux-2.6.28.10 ] ~ [ linux-2.6.27.62 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

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