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