xref: /linux/sound/pci/hda/patch_realtek.c (revision 93d4e8bb3f137e8037a65ea96f175f81c25c50e5)
1 // SPDX-License-Identifier: GPL-2.0-or-later
2 /*
3  * Universal Interface for Intel High Definition Audio Codec
4  *
5  * HD audio interface patch for Realtek ALC codecs
6  *
7  * Copyright (c) 2004 Kailang Yang <kailang@realtek.com.tw>
8  *                    PeiSen Hou <pshou@realtek.com.tw>
9  *                    Takashi Iwai <tiwai@suse.de>
10  *                    Jonathan Woithe <jwoithe@just42.net>
11  */
12 
13 #include <linux/acpi.h>
14 #include <linux/init.h>
15 #include <linux/delay.h>
16 #include <linux/slab.h>
17 #include <linux/pci.h>
18 #include <linux/dmi.h>
19 #include <linux/module.h>
20 #include <linux/input.h>
21 #include <linux/leds.h>
22 #include <linux/ctype.h>
23 #include <sound/core.h>
24 #include <sound/jack.h>
25 #include <sound/hda_codec.h>
26 #include "hda_local.h"
27 #include "hda_auto_parser.h"
28 #include "hda_jack.h"
29 #include "hda_generic.h"
30 #include "hda_component.h"
31 
32 /* keep halting ALC5505 DSP, for power saving */
33 #define HALT_REALTEK_ALC5505
34 
35 /* extra amp-initialization sequence types */
36 enum {
37 	ALC_INIT_UNDEFINED,
38 	ALC_INIT_NONE,
39 	ALC_INIT_DEFAULT,
40 };
41 
42 enum {
43 	ALC_HEADSET_MODE_UNKNOWN,
44 	ALC_HEADSET_MODE_UNPLUGGED,
45 	ALC_HEADSET_MODE_HEADSET,
46 	ALC_HEADSET_MODE_MIC,
47 	ALC_HEADSET_MODE_HEADPHONE,
48 };
49 
50 enum {
51 	ALC_HEADSET_TYPE_UNKNOWN,
52 	ALC_HEADSET_TYPE_CTIA,
53 	ALC_HEADSET_TYPE_OMTP,
54 };
55 
56 enum {
57 	ALC_KEY_MICMUTE_INDEX,
58 };
59 
60 struct alc_customize_define {
61 	unsigned int  sku_cfg;
62 	unsigned char port_connectivity;
63 	unsigned char check_sum;
64 	unsigned char customization;
65 	unsigned char external_amp;
66 	unsigned int  enable_pcbeep:1;
67 	unsigned int  platform_type:1;
68 	unsigned int  swap:1;
69 	unsigned int  override:1;
70 	unsigned int  fixup:1; /* Means that this sku is set by driver, not read from hw */
71 };
72 
73 struct alc_coef_led {
74 	unsigned int idx;
75 	unsigned int mask;
76 	unsigned int on;
77 	unsigned int off;
78 };
79 
80 struct alc_spec {
81 	struct hda_gen_spec gen; /* must be at head */
82 
83 	/* codec parameterization */
84 	struct alc_customize_define cdefine;
85 	unsigned int parse_flags; /* flag for snd_hda_parse_pin_defcfg() */
86 
87 	/* GPIO bits */
88 	unsigned int gpio_mask;
89 	unsigned int gpio_dir;
90 	unsigned int gpio_data;
91 	bool gpio_write_delay;	/* add a delay before writing gpio_data */
92 
93 	/* mute LED for HP laptops, see vref_mute_led_set() */
94 	int mute_led_polarity;
95 	int micmute_led_polarity;
96 	hda_nid_t mute_led_nid;
97 	hda_nid_t cap_mute_led_nid;
98 
99 	unsigned int gpio_mute_led_mask;
100 	unsigned int gpio_mic_led_mask;
101 	struct alc_coef_led mute_led_coef;
102 	struct alc_coef_led mic_led_coef;
103 	struct mutex coef_mutex;
104 
105 	hda_nid_t headset_mic_pin;
106 	hda_nid_t headphone_mic_pin;
107 	int current_headset_mode;
108 	int current_headset_type;
109 
110 	/* hooks */
111 	void (*init_hook)(struct hda_codec *codec);
112 	void (*power_hook)(struct hda_codec *codec);
113 	void (*shutup)(struct hda_codec *codec);
114 
115 	int init_amp;
116 	int codec_variant;	/* flag for other variants */
117 	unsigned int has_alc5505_dsp:1;
118 	unsigned int no_depop_delay:1;
119 	unsigned int done_hp_init:1;
120 	unsigned int no_shutup_pins:1;
121 	unsigned int ultra_low_power:1;
122 	unsigned int has_hs_key:1;
123 	unsigned int no_internal_mic_pin:1;
124 	unsigned int en_3kpull_low:1;
125 
126 	/* for PLL fix */
127 	hda_nid_t pll_nid;
128 	unsigned int pll_coef_idx, pll_coef_bit;
129 	unsigned int coef0;
130 	struct input_dev *kb_dev;
131 	u8 alc_mute_keycode_map[1];
132 
133 	/* component binding */
134 	struct hda_component comps[HDA_MAX_COMPONENTS];
135 };
136 
137 /*
138  * COEF access helper functions
139  */
140 
141 static void coef_mutex_lock(struct hda_codec *codec)
142 {
143 	struct alc_spec *spec = codec->spec;
144 
145 	snd_hda_power_up_pm(codec);
146 	mutex_lock(&spec->coef_mutex);
147 }
148 
149 static void coef_mutex_unlock(struct hda_codec *codec)
150 {
151 	struct alc_spec *spec = codec->spec;
152 
153 	mutex_unlock(&spec->coef_mutex);
154 	snd_hda_power_down_pm(codec);
155 }
156 
157 static int __alc_read_coefex_idx(struct hda_codec *codec, hda_nid_t nid,
158 				 unsigned int coef_idx)
159 {
160 	unsigned int val;
161 
162 	snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_COEF_INDEX, coef_idx);
163 	val = snd_hda_codec_read(codec, nid, 0, AC_VERB_GET_PROC_COEF, 0);
164 	return val;
165 }
166 
167 static int alc_read_coefex_idx(struct hda_codec *codec, hda_nid_t nid,
168 			       unsigned int coef_idx)
169 {
170 	unsigned int val;
171 
172 	coef_mutex_lock(codec);
173 	val = __alc_read_coefex_idx(codec, nid, coef_idx);
174 	coef_mutex_unlock(codec);
175 	return val;
176 }
177 
178 #define alc_read_coef_idx(codec, coef_idx) \
179 	alc_read_coefex_idx(codec, 0x20, coef_idx)
180 
181 static void __alc_write_coefex_idx(struct hda_codec *codec, hda_nid_t nid,
182 				   unsigned int coef_idx, unsigned int coef_val)
183 {
184 	snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_COEF_INDEX, coef_idx);
185 	snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_PROC_COEF, coef_val);
186 }
187 
188 static void alc_write_coefex_idx(struct hda_codec *codec, hda_nid_t nid,
189 				 unsigned int coef_idx, unsigned int coef_val)
190 {
191 	coef_mutex_lock(codec);
192 	__alc_write_coefex_idx(codec, nid, coef_idx, coef_val);
193 	coef_mutex_unlock(codec);
194 }
195 
196 #define alc_write_coef_idx(codec, coef_idx, coef_val) \
197 	alc_write_coefex_idx(codec, 0x20, coef_idx, coef_val)
198 
199 static void __alc_update_coefex_idx(struct hda_codec *codec, hda_nid_t nid,
200 				    unsigned int coef_idx, unsigned int mask,
201 				    unsigned int bits_set)
202 {
203 	unsigned int val = __alc_read_coefex_idx(codec, nid, coef_idx);
204 
205 	if (val != -1)
206 		__alc_write_coefex_idx(codec, nid, coef_idx,
207 				       (val & ~mask) | bits_set);
208 }
209 
210 static void alc_update_coefex_idx(struct hda_codec *codec, hda_nid_t nid,
211 				  unsigned int coef_idx, unsigned int mask,
212 				  unsigned int bits_set)
213 {
214 	coef_mutex_lock(codec);
215 	__alc_update_coefex_idx(codec, nid, coef_idx, mask, bits_set);
216 	coef_mutex_unlock(codec);
217 }
218 
219 #define alc_update_coef_idx(codec, coef_idx, mask, bits_set)	\
220 	alc_update_coefex_idx(codec, 0x20, coef_idx, mask, bits_set)
221 
222 /* a special bypass for COEF 0; read the cached value at the second time */
223 static unsigned int alc_get_coef0(struct hda_codec *codec)
224 {
225 	struct alc_spec *spec = codec->spec;
226 
227 	if (!spec->coef0)
228 		spec->coef0 = alc_read_coef_idx(codec, 0);
229 	return spec->coef0;
230 }
231 
232 /* coef writes/updates batch */
233 struct coef_fw {
234 	unsigned char nid;
235 	unsigned char idx;
236 	unsigned short mask;
237 	unsigned short val;
238 };
239 
240 #define UPDATE_COEFEX(_nid, _idx, _mask, _val) \
241 	{ .nid = (_nid), .idx = (_idx), .mask = (_mask), .val = (_val) }
242 #define WRITE_COEFEX(_nid, _idx, _val) UPDATE_COEFEX(_nid, _idx, -1, _val)
243 #define WRITE_COEF(_idx, _val) WRITE_COEFEX(0x20, _idx, _val)
244 #define UPDATE_COEF(_idx, _mask, _val) UPDATE_COEFEX(0x20, _idx, _mask, _val)
245 
246 static void alc_process_coef_fw(struct hda_codec *codec,
247 				const struct coef_fw *fw)
248 {
249 	coef_mutex_lock(codec);
250 	for (; fw->nid; fw++) {
251 		if (fw->mask == (unsigned short)-1)
252 			__alc_write_coefex_idx(codec, fw->nid, fw->idx, fw->val);
253 		else
254 			__alc_update_coefex_idx(codec, fw->nid, fw->idx,
255 						fw->mask, fw->val);
256 	}
257 	coef_mutex_unlock(codec);
258 }
259 
260 /*
261  * GPIO setup tables, used in initialization
262  */
263 
264 /* Enable GPIO mask and set output */
265 static void alc_setup_gpio(struct hda_codec *codec, unsigned int mask)
266 {
267 	struct alc_spec *spec = codec->spec;
268 
269 	spec->gpio_mask |= mask;
270 	spec->gpio_dir |= mask;
271 	spec->gpio_data |= mask;
272 }
273 
274 static void alc_write_gpio_data(struct hda_codec *codec)
275 {
276 	struct alc_spec *spec = codec->spec;
277 
278 	snd_hda_codec_write(codec, 0x01, 0, AC_VERB_SET_GPIO_DATA,
279 			    spec->gpio_data);
280 }
281 
282 static void alc_update_gpio_data(struct hda_codec *codec, unsigned int mask,
283 				 bool on)
284 {
285 	struct alc_spec *spec = codec->spec;
286 	unsigned int oldval = spec->gpio_data;
287 
288 	if (on)
289 		spec->gpio_data |= mask;
290 	else
291 		spec->gpio_data &= ~mask;
292 	if (oldval != spec->gpio_data)
293 		alc_write_gpio_data(codec);
294 }
295 
296 static void alc_write_gpio(struct hda_codec *codec)
297 {
298 	struct alc_spec *spec = codec->spec;
299 
300 	if (!spec->gpio_mask)
301 		return;
302 
303 	snd_hda_codec_write(codec, codec->core.afg, 0,
304 			    AC_VERB_SET_GPIO_MASK, spec->gpio_mask);
305 	snd_hda_codec_write(codec, codec->core.afg, 0,
306 			    AC_VERB_SET_GPIO_DIRECTION, spec->gpio_dir);
307 	if (spec->gpio_write_delay)
308 		msleep(1);
309 	alc_write_gpio_data(codec);
310 }
311 
312 static void alc_fixup_gpio(struct hda_codec *codec, int action,
313 			   unsigned int mask)
314 {
315 	if (action == HDA_FIXUP_ACT_PRE_PROBE)
316 		alc_setup_gpio(codec, mask);
317 }
318 
319 static void alc_fixup_gpio1(struct hda_codec *codec,
320 			    const struct hda_fixup *fix, int action)
321 {
322 	alc_fixup_gpio(codec, action, 0x01);
323 }
324 
325 static void alc_fixup_gpio2(struct hda_codec *codec,
326 			    const struct hda_fixup *fix, int action)
327 {
328 	alc_fixup_gpio(codec, action, 0x02);
329 }
330 
331 static void alc_fixup_gpio3(struct hda_codec *codec,
332 			    const struct hda_fixup *fix, int action)
333 {
334 	alc_fixup_gpio(codec, action, 0x03);
335 }
336 
337 static void alc_fixup_gpio4(struct hda_codec *codec,
338 			    const struct hda_fixup *fix, int action)
339 {
340 	alc_fixup_gpio(codec, action, 0x04);
341 }
342 
343 static void alc_fixup_micmute_led(struct hda_codec *codec,
344 				  const struct hda_fixup *fix, int action)
345 {
346 	if (action == HDA_FIXUP_ACT_PRE_PROBE)
347 		snd_hda_gen_add_micmute_led_cdev(codec, NULL);
348 }
349 
350 /*
351  * Fix hardware PLL issue
352  * On some codecs, the analog PLL gating control must be off while
353  * the default value is 1.
354  */
355 static void alc_fix_pll(struct hda_codec *codec)
356 {
357 	struct alc_spec *spec = codec->spec;
358 
359 	if (spec->pll_nid)
360 		alc_update_coefex_idx(codec, spec->pll_nid, spec->pll_coef_idx,
361 				      1 << spec->pll_coef_bit, 0);
362 }
363 
364 static void alc_fix_pll_init(struct hda_codec *codec, hda_nid_t nid,
365 			     unsigned int coef_idx, unsigned int coef_bit)
366 {
367 	struct alc_spec *spec = codec->spec;
368 	spec->pll_nid = nid;
369 	spec->pll_coef_idx = coef_idx;
370 	spec->pll_coef_bit = coef_bit;
371 	alc_fix_pll(codec);
372 }
373 
374 /* update the master volume per volume-knob's unsol event */
375 static void alc_update_knob_master(struct hda_codec *codec,
376 				   struct hda_jack_callback *jack)
377 {
378 	unsigned int val;
379 	struct snd_kcontrol *kctl;
380 	struct snd_ctl_elem_value *uctl;
381 
382 	kctl = snd_hda_find_mixer_ctl(codec, "Master Playback Volume");
383 	if (!kctl)
384 		return;
385 	uctl = kzalloc(sizeof(*uctl), GFP_KERNEL);
386 	if (!uctl)
387 		return;
388 	val = snd_hda_codec_read(codec, jack->nid, 0,
389 				 AC_VERB_GET_VOLUME_KNOB_CONTROL, 0);
390 	val &= HDA_AMP_VOLMASK;
391 	uctl->value.integer.value[0] = val;
392 	uctl->value.integer.value[1] = val;
393 	kctl->put(kctl, uctl);
394 	kfree(uctl);
395 }
396 
397 static void alc880_unsol_event(struct hda_codec *codec, unsigned int res)
398 {
399 	/* For some reason, the res given from ALC880 is broken.
400 	   Here we adjust it properly. */
401 	snd_hda_jack_unsol_event(codec, res >> 2);
402 }
403 
404 /* Change EAPD to verb control */
405 static void alc_fill_eapd_coef(struct hda_codec *codec)
406 {
407 	int coef;
408 
409 	coef = alc_get_coef0(codec);
410 
411 	switch (codec->core.vendor_id) {
412 	case 0x10ec0262:
413 		alc_update_coef_idx(codec, 0x7, 0, 1<<5);
414 		break;
415 	case 0x10ec0267:
416 	case 0x10ec0268:
417 		alc_update_coef_idx(codec, 0x7, 0, 1<<13);
418 		break;
419 	case 0x10ec0269:
420 		if ((coef & 0x00f0) == 0x0010)
421 			alc_update_coef_idx(codec, 0xd, 0, 1<<14);
422 		if ((coef & 0x00f0) == 0x0020)
423 			alc_update_coef_idx(codec, 0x4, 1<<15, 0);
424 		if ((coef & 0x00f0) == 0x0030)
425 			alc_update_coef_idx(codec, 0x10, 1<<9, 0);
426 		break;
427 	case 0x10ec0280:
428 	case 0x10ec0284:
429 	case 0x10ec0290:
430 	case 0x10ec0292:
431 		alc_update_coef_idx(codec, 0x4, 1<<15, 0);
432 		break;
433 	case 0x10ec0225:
434 	case 0x10ec0295:
435 	case 0x10ec0299:
436 		alc_update_coef_idx(codec, 0x67, 0xf000, 0x3000);
437 		fallthrough;
438 	case 0x10ec0215:
439 	case 0x10ec0285:
440 	case 0x10ec0289:
441 		alc_update_coef_idx(codec, 0x36, 1<<13, 0);
442 		fallthrough;
443 	case 0x10ec0230:
444 	case 0x10ec0233:
445 	case 0x10ec0235:
446 	case 0x10ec0236:
447 	case 0x10ec0245:
448 	case 0x10ec0255:
449 	case 0x10ec0256:
450 	case 0x19e58326:
451 	case 0x10ec0257:
452 	case 0x10ec0282:
453 	case 0x10ec0283:
454 	case 0x10ec0286:
455 	case 0x10ec0288:
456 	case 0x10ec0298:
457 	case 0x10ec0300:
458 		alc_update_coef_idx(codec, 0x10, 1<<9, 0);
459 		break;
460 	case 0x10ec0275:
461 		alc_update_coef_idx(codec, 0xe, 0, 1<<0);
462 		break;
463 	case 0x10ec0287:
464 		alc_update_coef_idx(codec, 0x10, 1<<9, 0);
465 		alc_write_coef_idx(codec, 0x8, 0x4ab7);
466 		break;
467 	case 0x10ec0293:
468 		alc_update_coef_idx(codec, 0xa, 1<<13, 0);
469 		break;
470 	case 0x10ec0234:
471 	case 0x10ec0274:
472 	case 0x10ec0294:
473 	case 0x10ec0700:
474 	case 0x10ec0701:
475 	case 0x10ec0703:
476 	case 0x10ec0711:
477 		alc_update_coef_idx(codec, 0x10, 1<<15, 0);
478 		break;
479 	case 0x10ec0662:
480 		if ((coef & 0x00f0) == 0x0030)
481 			alc_update_coef_idx(codec, 0x4, 1<<10, 0); /* EAPD Ctrl */
482 		break;
483 	case 0x10ec0272:
484 	case 0x10ec0273:
485 	case 0x10ec0663:
486 	case 0x10ec0665:
487 	case 0x10ec0670:
488 	case 0x10ec0671:
489 	case 0x10ec0672:
490 		alc_update_coef_idx(codec, 0xd, 0, 1<<14); /* EAPD Ctrl */
491 		break;
492 	case 0x10ec0222:
493 	case 0x10ec0623:
494 		alc_update_coef_idx(codec, 0x19, 1<<13, 0);
495 		break;
496 	case 0x10ec0668:
497 		alc_update_coef_idx(codec, 0x7, 3<<13, 0);
498 		break;
499 	case 0x10ec0867:
500 		alc_update_coef_idx(codec, 0x4, 1<<10, 0);
501 		break;
502 	case 0x10ec0888:
503 		if ((coef & 0x00f0) == 0x0020 || (coef & 0x00f0) == 0x0030)
504 			alc_update_coef_idx(codec, 0x7, 1<<5, 0);
505 		break;
506 	case 0x10ec0892:
507 	case 0x10ec0897:
508 		alc_update_coef_idx(codec, 0x7, 1<<5, 0);
509 		break;
510 	case 0x10ec0899:
511 	case 0x10ec0900:
512 	case 0x10ec0b00:
513 	case 0x10ec1168:
514 	case 0x10ec1220:
515 		alc_update_coef_idx(codec, 0x7, 1<<1, 0);
516 		break;
517 	}
518 }
519 
520 /* additional initialization for ALC888 variants */
521 static void alc888_coef_init(struct hda_codec *codec)
522 {
523 	switch (alc_get_coef0(codec) & 0x00f0) {
524 	/* alc888-VA */
525 	case 0x00:
526 	/* alc888-VB */
527 	case 0x10:
528 		alc_update_coef_idx(codec, 7, 0, 0x2030); /* Turn EAPD to High */
529 		break;
530 	}
531 }
532 
533 /* turn on/off EAPD control (only if available) */
534 static void set_eapd(struct hda_codec *codec, hda_nid_t nid, int on)
535 {
536 	if (get_wcaps_type(get_wcaps(codec, nid)) != AC_WID_PIN)
537 		return;
538 	if (snd_hda_query_pin_caps(codec, nid) & AC_PINCAP_EAPD)
539 		snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_EAPD_BTLENABLE,
540 				    on ? 2 : 0);
541 }
542 
543 /* turn on/off EAPD controls of the codec */
544 static void alc_auto_setup_eapd(struct hda_codec *codec, bool on)
545 {
546 	/* We currently only handle front, HP */
547 	static const hda_nid_t pins[] = {
548 		0x0f, 0x10, 0x14, 0x15, 0x17, 0
549 	};
550 	const hda_nid_t *p;
551 	for (p = pins; *p; p++)
552 		set_eapd(codec, *p, on);
553 }
554 
555 static int find_ext_mic_pin(struct hda_codec *codec);
556 
557 static void alc_headset_mic_no_shutup(struct hda_codec *codec)
558 {
559 	const struct hda_pincfg *pin;
560 	int mic_pin = find_ext_mic_pin(codec);
561 	int i;
562 
563 	/* don't shut up pins when unloading the driver; otherwise it breaks
564 	 * the default pin setup at the next load of the driver
565 	 */
566 	if (codec->bus->shutdown)
567 		return;
568 
569 	snd_array_for_each(&codec->init_pins, i, pin) {
570 		/* use read here for syncing after issuing each verb */
571 		if (pin->nid != mic_pin)
572 			snd_hda_codec_read(codec, pin->nid, 0,
573 					AC_VERB_SET_PIN_WIDGET_CONTROL, 0);
574 	}
575 
576 	codec->pins_shutup = 1;
577 }
578 
579 static void alc_shutup_pins(struct hda_codec *codec)
580 {
581 	struct alc_spec *spec = codec->spec;
582 
583 	switch (codec->core.vendor_id) {
584 	case 0x10ec0236:
585 	case 0x10ec0256:
586 	case 0x19e58326:
587 	case 0x10ec0283:
588 	case 0x10ec0286:
589 	case 0x10ec0288:
590 	case 0x10ec0298:
591 		alc_headset_mic_no_shutup(codec);
592 		break;
593 	default:
594 		if (!spec->no_shutup_pins)
595 			snd_hda_shutup_pins(codec);
596 		break;
597 	}
598 }
599 
600 /* generic shutup callback;
601  * just turning off EAPD and a little pause for avoiding pop-noise
602  */
603 static void alc_eapd_shutup(struct hda_codec *codec)
604 {
605 	struct alc_spec *spec = codec->spec;
606 
607 	alc_auto_setup_eapd(codec, false);
608 	if (!spec->no_depop_delay)
609 		msleep(200);
610 	alc_shutup_pins(codec);
611 }
612 
613 /* generic EAPD initialization */
614 static void alc_auto_init_amp(struct hda_codec *codec, int type)
615 {
616 	alc_auto_setup_eapd(codec, true);
617 	alc_write_gpio(codec);
618 	switch (type) {
619 	case ALC_INIT_DEFAULT:
620 		switch (codec->core.vendor_id) {
621 		case 0x10ec0260:
622 			alc_update_coefex_idx(codec, 0x1a, 7, 0, 0x2010);
623 			break;
624 		case 0x10ec0880:
625 		case 0x10ec0882:
626 		case 0x10ec0883:
627 		case 0x10ec0885:
628 			alc_update_coef_idx(codec, 7, 0, 0x2030);
629 			break;
630 		case 0x10ec0888:
631 			alc888_coef_init(codec);
632 			break;
633 		}
634 		break;
635 	}
636 }
637 
638 /* get a primary headphone pin if available */
639 static hda_nid_t alc_get_hp_pin(struct alc_spec *spec)
640 {
641 	if (spec->gen.autocfg.hp_pins[0])
642 		return spec->gen.autocfg.hp_pins[0];
643 	if (spec->gen.autocfg.line_out_type == AC_JACK_HP_OUT)
644 		return spec->gen.autocfg.line_out_pins[0];
645 	return 0;
646 }
647 
648 /*
649  * Realtek SSID verification
650  */
651 
652 /* Could be any non-zero and even value. When used as fixup, tells
653  * the driver to ignore any present sku defines.
654  */
655 #define ALC_FIXUP_SKU_IGNORE (2)
656 
657 static void alc_fixup_sku_ignore(struct hda_codec *codec,
658 				 const struct hda_fixup *fix, int action)
659 {
660 	struct alc_spec *spec = codec->spec;
661 	if (action == HDA_FIXUP_ACT_PRE_PROBE) {
662 		spec->cdefine.fixup = 1;
663 		spec->cdefine.sku_cfg = ALC_FIXUP_SKU_IGNORE;
664 	}
665 }
666 
667 static void alc_fixup_no_depop_delay(struct hda_codec *codec,
668 				    const struct hda_fixup *fix, int action)
669 {
670 	struct alc_spec *spec = codec->spec;
671 
672 	if (action == HDA_FIXUP_ACT_PROBE) {
673 		spec->no_depop_delay = 1;
674 		codec->depop_delay = 0;
675 	}
676 }
677 
678 static int alc_auto_parse_customize_define(struct hda_codec *codec)
679 {
680 	unsigned int ass, tmp, i;
681 	unsigned nid = 0;
682 	struct alc_spec *spec = codec->spec;
683 
684 	spec->cdefine.enable_pcbeep = 1; /* assume always enabled */
685 
686 	if (spec->cdefine.fixup) {
687 		ass = spec->cdefine.sku_cfg;
688 		if (ass == ALC_FIXUP_SKU_IGNORE)
689 			return -1;
690 		goto do_sku;
691 	}
692 
693 	if (!codec->bus->pci)
694 		return -1;
695 	ass = codec->core.subsystem_id & 0xffff;
696 	if (ass != codec->bus->pci->subsystem_device && (ass & 1))
697 		goto do_sku;
698 
699 	nid = 0x1d;
700 	if (codec->core.vendor_id == 0x10ec0260)
701 		nid = 0x17;
702 	ass = snd_hda_codec_get_pincfg(codec, nid);
703 
704 	if (!(ass & 1)) {
705 		codec_info(codec, "%s: SKU not ready 0x%08x\n",
706 			   codec->core.chip_name, ass);
707 		return -1;
708 	}
709 
710 	/* check sum */
711 	tmp = 0;
712 	for (i = 1; i < 16; i++) {
713 		if ((ass >> i) & 1)
714 			tmp++;
715 	}
716 	if (((ass >> 16) & 0xf) != tmp)
717 		return -1;
718 
719 	spec->cdefine.port_connectivity = ass >> 30;
720 	spec->cdefine.enable_pcbeep = (ass & 0x100000) >> 20;
721 	spec->cdefine.check_sum = (ass >> 16) & 0xf;
722 	spec->cdefine.customization = ass >> 8;
723 do_sku:
724 	spec->cdefine.sku_cfg = ass;
725 	spec->cdefine.external_amp = (ass & 0x38) >> 3;
726 	spec->cdefine.platform_type = (ass & 0x4) >> 2;
727 	spec->cdefine.swap = (ass & 0x2) >> 1;
728 	spec->cdefine.override = ass & 0x1;
729 
730 	codec_dbg(codec, "SKU: Nid=0x%x sku_cfg=0x%08x\n",
731 		   nid, spec->cdefine.sku_cfg);
732 	codec_dbg(codec, "SKU: port_connectivity=0x%x\n",
733 		   spec->cdefine.port_connectivity);
734 	codec_dbg(codec, "SKU: enable_pcbeep=0x%x\n", spec->cdefine.enable_pcbeep);
735 	codec_dbg(codec, "SKU: check_sum=0x%08x\n", spec->cdefine.check_sum);
736 	codec_dbg(codec, "SKU: customization=0x%08x\n", spec->cdefine.customization);
737 	codec_dbg(codec, "SKU: external_amp=0x%x\n", spec->cdefine.external_amp);
738 	codec_dbg(codec, "SKU: platform_type=0x%x\n", spec->cdefine.platform_type);
739 	codec_dbg(codec, "SKU: swap=0x%x\n", spec->cdefine.swap);
740 	codec_dbg(codec, "SKU: override=0x%x\n", spec->cdefine.override);
741 
742 	return 0;
743 }
744 
745 /* return the position of NID in the list, or -1 if not found */
746 static int find_idx_in_nid_list(hda_nid_t nid, const hda_nid_t *list, int nums)
747 {
748 	int i;
749 	for (i = 0; i < nums; i++)
750 		if (list[i] == nid)
751 			return i;
752 	return -1;
753 }
754 /* return true if the given NID is found in the list */
755 static bool found_in_nid_list(hda_nid_t nid, const hda_nid_t *list, int nums)
756 {
757 	return find_idx_in_nid_list(nid, list, nums) >= 0;
758 }
759 
760 /* check subsystem ID and set up device-specific initialization;
761  * return 1 if initialized, 0 if invalid SSID
762  */
763 /* 32-bit subsystem ID for BIOS loading in HD Audio codec.
764  *	31 ~ 16 :	Manufacture ID
765  *	15 ~ 8	:	SKU ID
766  *	7  ~ 0	:	Assembly ID
767  *	port-A --> pin 39/41, port-E --> pin 14/15, port-D --> pin 35/36
768  */
769 static int alc_subsystem_id(struct hda_codec *codec, const hda_nid_t *ports)
770 {
771 	unsigned int ass, tmp, i;
772 	unsigned nid;
773 	struct alc_spec *spec = codec->spec;
774 
775 	if (spec->cdefine.fixup) {
776 		ass = spec->cdefine.sku_cfg;
777 		if (ass == ALC_FIXUP_SKU_IGNORE)
778 			return 0;
779 		goto do_sku;
780 	}
781 
782 	ass = codec->core.subsystem_id & 0xffff;
783 	if (codec->bus->pci &&
784 	    ass != codec->bus->pci->subsystem_device && (ass & 1))
785 		goto do_sku;
786 
787 	/* invalid SSID, check the special NID pin defcfg instead */
788 	/*
789 	 * 31~30	: port connectivity
790 	 * 29~21	: reserve
791 	 * 20		: PCBEEP input
792 	 * 19~16	: Check sum (15:1)
793 	 * 15~1		: Custom
794 	 * 0		: override
795 	*/
796 	nid = 0x1d;
797 	if (codec->core.vendor_id == 0x10ec0260)
798 		nid = 0x17;
799 	ass = snd_hda_codec_get_pincfg(codec, nid);
800 	codec_dbg(codec,
801 		  "realtek: No valid SSID, checking pincfg 0x%08x for NID 0x%x\n",
802 		   ass, nid);
803 	if (!(ass & 1))
804 		return 0;
805 	if ((ass >> 30) != 1)	/* no physical connection */
806 		return 0;
807 
808 	/* check sum */
809 	tmp = 0;
810 	for (i = 1; i < 16; i++) {
811 		if ((ass >> i) & 1)
812 			tmp++;
813 	}
814 	if (((ass >> 16) & 0xf) != tmp)
815 		return 0;
816 do_sku:
817 	codec_dbg(codec, "realtek: Enabling init ASM_ID=0x%04x CODEC_ID=%08x\n",
818 		   ass & 0xffff, codec->core.vendor_id);
819 	/*
820 	 * 0 : override
821 	 * 1 :	Swap Jack
822 	 * 2 : 0 --> Desktop, 1 --> Laptop
823 	 * 3~5 : External Amplifier control
824 	 * 7~6 : Reserved
825 	*/
826 	tmp = (ass & 0x38) >> 3;	/* external Amp control */
827 	if (spec->init_amp == ALC_INIT_UNDEFINED) {
828 		switch (tmp) {
829 		case 1:
830 			alc_setup_gpio(codec, 0x01);
831 			break;
832 		case 3:
833 			alc_setup_gpio(codec, 0x02);
834 			break;
835 		case 7:
836 			alc_setup_gpio(codec, 0x04);
837 			break;
838 		case 5:
839 		default:
840 			spec->init_amp = ALC_INIT_DEFAULT;
841 			break;
842 		}
843 	}
844 
845 	/* is laptop or Desktop and enable the function "Mute internal speaker
846 	 * when the external headphone out jack is plugged"
847 	 */
848 	if (!(ass & 0x8000))
849 		return 1;
850 	/*
851 	 * 10~8 : Jack location
852 	 * 12~11: Headphone out -> 00: PortA, 01: PortE, 02: PortD, 03: Resvered
853 	 * 14~13: Resvered
854 	 * 15   : 1 --> enable the function "Mute internal speaker
855 	 *	        when the external headphone out jack is plugged"
856 	 */
857 	if (!alc_get_hp_pin(spec)) {
858 		hda_nid_t nid;
859 		tmp = (ass >> 11) & 0x3;	/* HP to chassis */
860 		nid = ports[tmp];
861 		if (found_in_nid_list(nid, spec->gen.autocfg.line_out_pins,
862 				      spec->gen.autocfg.line_outs))
863 			return 1;
864 		spec->gen.autocfg.hp_pins[0] = nid;
865 	}
866 	return 1;
867 }
868 
869 /* Check the validity of ALC subsystem-id
870  * ports contains an array of 4 pin NIDs for port-A, E, D and I */
871 static void alc_ssid_check(struct hda_codec *codec, const hda_nid_t *ports)
872 {
873 	if (!alc_subsystem_id(codec, ports)) {
874 		struct alc_spec *spec = codec->spec;
875 		if (spec->init_amp == ALC_INIT_UNDEFINED) {
876 			codec_dbg(codec,
877 				  "realtek: Enable default setup for auto mode as fallback\n");
878 			spec->init_amp = ALC_INIT_DEFAULT;
879 		}
880 	}
881 }
882 
883 /*
884  */
885 
886 static void alc_fixup_inv_dmic(struct hda_codec *codec,
887 			       const struct hda_fixup *fix, int action)
888 {
889 	struct alc_spec *spec = codec->spec;
890 
891 	spec->gen.inv_dmic_split = 1;
892 }
893 
894 
895 static int alc_build_controls(struct hda_codec *codec)
896 {
897 	int err;
898 
899 	err = snd_hda_gen_build_controls(codec);
900 	if (err < 0)
901 		return err;
902 
903 	snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_BUILD);
904 	return 0;
905 }
906 
907 
908 /*
909  * Common callbacks
910  */
911 
912 static void alc_pre_init(struct hda_codec *codec)
913 {
914 	alc_fill_eapd_coef(codec);
915 }
916 
917 #define is_s3_resume(codec) \
918 	((codec)->core.dev.power.power_state.event == PM_EVENT_RESUME)
919 #define is_s4_resume(codec) \
920 	((codec)->core.dev.power.power_state.event == PM_EVENT_RESTORE)
921 #define is_s4_suspend(codec) \
922 	((codec)->core.dev.power.power_state.event == PM_EVENT_FREEZE)
923 
924 static int alc_init(struct hda_codec *codec)
925 {
926 	struct alc_spec *spec = codec->spec;
927 
928 	/* hibernation resume needs the full chip initialization */
929 	if (is_s4_resume(codec))
930 		alc_pre_init(codec);
931 
932 	if (spec->init_hook)
933 		spec->init_hook(codec);
934 
935 	spec->gen.skip_verbs = 1; /* applied in below */
936 	snd_hda_gen_init(codec);
937 	alc_fix_pll(codec);
938 	alc_auto_init_amp(codec, spec->init_amp);
939 	snd_hda_apply_verbs(codec); /* apply verbs here after own init */
940 
941 	snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_INIT);
942 
943 	return 0;
944 }
945 
946 #define alc_free	snd_hda_gen_free
947 
948 static inline void alc_shutup(struct hda_codec *codec)
949 {
950 	struct alc_spec *spec = codec->spec;
951 
952 	if (!snd_hda_get_bool_hint(codec, "shutup"))
953 		return; /* disabled explicitly by hints */
954 
955 	if (spec && spec->shutup)
956 		spec->shutup(codec);
957 	else
958 		alc_shutup_pins(codec);
959 }
960 
961 static void alc_power_eapd(struct hda_codec *codec)
962 {
963 	alc_auto_setup_eapd(codec, false);
964 }
965 
966 static int alc_suspend(struct hda_codec *codec)
967 {
968 	struct alc_spec *spec = codec->spec;
969 	alc_shutup(codec);
970 	if (spec && spec->power_hook)
971 		spec->power_hook(codec);
972 	return 0;
973 }
974 
975 static int alc_resume(struct hda_codec *codec)
976 {
977 	struct alc_spec *spec = codec->spec;
978 
979 	if (!spec->no_depop_delay)
980 		msleep(150); /* to avoid pop noise */
981 	codec->patch_ops.init(codec);
982 	snd_hda_regmap_sync(codec);
983 	hda_call_check_power_status(codec, 0x01);
984 	return 0;
985 }
986 
987 /*
988  */
989 static const struct hda_codec_ops alc_patch_ops = {
990 	.build_controls = alc_build_controls,
991 	.build_pcms = snd_hda_gen_build_pcms,
992 	.init = alc_init,
993 	.free = alc_free,
994 	.unsol_event = snd_hda_jack_unsol_event,
995 	.resume = alc_resume,
996 	.suspend = alc_suspend,
997 	.check_power_status = snd_hda_gen_check_power_status,
998 };
999 
1000 
1001 #define alc_codec_rename(codec, name) snd_hda_codec_set_name(codec, name)
1002 
1003 /*
1004  * Rename codecs appropriately from COEF value or subvendor id
1005  */
1006 struct alc_codec_rename_table {
1007 	unsigned int vendor_id;
1008 	unsigned short coef_mask;
1009 	unsigned short coef_bits;
1010 	const char *name;
1011 };
1012 
1013 struct alc_codec_rename_pci_table {
1014 	unsigned int codec_vendor_id;
1015 	unsigned short pci_subvendor;
1016 	unsigned short pci_subdevice;
1017 	const char *name;
1018 };
1019 
1020 static const struct alc_codec_rename_table rename_tbl[] = {
1021 	{ 0x10ec0221, 0xf00f, 0x1003, "ALC231" },
1022 	{ 0x10ec0269, 0xfff0, 0x3010, "ALC277" },
1023 	{ 0x10ec0269, 0xf0f0, 0x2010, "ALC259" },
1024 	{ 0x10ec0269, 0xf0f0, 0x3010, "ALC258" },
1025 	{ 0x10ec0269, 0x00f0, 0x0010, "ALC269VB" },
1026 	{ 0x10ec0269, 0xffff, 0xa023, "ALC259" },
1027 	{ 0x10ec0269, 0xffff, 0x6023, "ALC281X" },
1028 	{ 0x10ec0269, 0x00f0, 0x0020, "ALC269VC" },
1029 	{ 0x10ec0269, 0x00f0, 0x0030, "ALC269VD" },
1030 	{ 0x10ec0662, 0xffff, 0x4020, "ALC656" },
1031 	{ 0x10ec0887, 0x00f0, 0x0030, "ALC887-VD" },
1032 	{ 0x10ec0888, 0x00f0, 0x0030, "ALC888-VD" },
1033 	{ 0x10ec0888, 0xf0f0, 0x3020, "ALC886" },
1034 	{ 0x10ec0899, 0x2000, 0x2000, "ALC899" },
1035 	{ 0x10ec0892, 0xffff, 0x8020, "ALC661" },
1036 	{ 0x10ec0892, 0xffff, 0x8011, "ALC661" },
1037 	{ 0x10ec0892, 0xffff, 0x4011, "ALC656" },
1038 	{ } /* terminator */
1039 };
1040 
1041 static const struct alc_codec_rename_pci_table rename_pci_tbl[] = {
1042 	{ 0x10ec0280, 0x1028, 0, "ALC3220" },
1043 	{ 0x10ec0282, 0x1028, 0, "ALC3221" },
1044 	{ 0x10ec0283, 0x1028, 0, "ALC3223" },
1045 	{ 0x10ec0288, 0x1028, 0, "ALC3263" },
1046 	{ 0x10ec0292, 0x1028, 0, "ALC3226" },
1047 	{ 0x10ec0293, 0x1028, 0, "ALC3235" },
1048 	{ 0x10ec0255, 0x1028, 0, "ALC3234" },
1049 	{ 0x10ec0668, 0x1028, 0, "ALC3661" },
1050 	{ 0x10ec0275, 0x1028, 0, "ALC3260" },
1051 	{ 0x10ec0899, 0x1028, 0, "ALC3861" },
1052 	{ 0x10ec0298, 0x1028, 0, "ALC3266" },
1053 	{ 0x10ec0236, 0x1028, 0, "ALC3204" },
1054 	{ 0x10ec0256, 0x1028, 0, "ALC3246" },
1055 	{ 0x10ec0225, 0x1028, 0, "ALC3253" },
1056 	{ 0x10ec0295, 0x1028, 0, "ALC3254" },
1057 	{ 0x10ec0299, 0x1028, 0, "ALC3271" },
1058 	{ 0x10ec0670, 0x1025, 0, "ALC669X" },
1059 	{ 0x10ec0676, 0x1025, 0, "ALC679X" },
1060 	{ 0x10ec0282, 0x1043, 0, "ALC3229" },
1061 	{ 0x10ec0233, 0x1043, 0, "ALC3236" },
1062 	{ 0x10ec0280, 0x103c, 0, "ALC3228" },
1063 	{ 0x10ec0282, 0x103c, 0, "ALC3227" },
1064 	{ 0x10ec0286, 0x103c, 0, "ALC3242" },
1065 	{ 0x10ec0290, 0x103c, 0, "ALC3241" },
1066 	{ 0x10ec0668, 0x103c, 0, "ALC3662" },
1067 	{ 0x10ec0283, 0x17aa, 0, "ALC3239" },
1068 	{ 0x10ec0292, 0x17aa, 0, "ALC3232" },
1069 	{ } /* terminator */
1070 };
1071 
1072 static int alc_codec_rename_from_preset(struct hda_codec *codec)
1073 {
1074 	const struct alc_codec_rename_table *p;
1075 	const struct alc_codec_rename_pci_table *q;
1076 
1077 	for (p = rename_tbl; p->vendor_id; p++) {
1078 		if (p->vendor_id != codec->core.vendor_id)
1079 			continue;
1080 		if ((alc_get_coef0(codec) & p->coef_mask) == p->coef_bits)
1081 			return alc_codec_rename(codec, p->name);
1082 	}
1083 
1084 	if (!codec->bus->pci)
1085 		return 0;
1086 	for (q = rename_pci_tbl; q->codec_vendor_id; q++) {
1087 		if (q->codec_vendor_id != codec->core.vendor_id)
1088 			continue;
1089 		if (q->pci_subvendor != codec->bus->pci->subsystem_vendor)
1090 			continue;
1091 		if (!q->pci_subdevice ||
1092 		    q->pci_subdevice == codec->bus->pci->subsystem_device)
1093 			return alc_codec_rename(codec, q->name);
1094 	}
1095 
1096 	return 0;
1097 }
1098 
1099 
1100 /*
1101  * Digital-beep handlers
1102  */
1103 #ifdef CONFIG_SND_HDA_INPUT_BEEP
1104 
1105 /* additional beep mixers; private_value will be overwritten */
1106 static const struct snd_kcontrol_new alc_beep_mixer[] = {
1107 	HDA_CODEC_VOLUME("Beep Playback Volume", 0, 0, HDA_INPUT),
1108 	HDA_CODEC_MUTE_BEEP("Beep Playback Switch", 0, 0, HDA_INPUT),
1109 };
1110 
1111 /* set up and create beep controls */
1112 static int set_beep_amp(struct alc_spec *spec, hda_nid_t nid,
1113 			int idx, int dir)
1114 {
1115 	struct snd_kcontrol_new *knew;
1116 	unsigned int beep_amp = HDA_COMPOSE_AMP_VAL(nid, 3, idx, dir);
1117 	int i;
1118 
1119 	for (i = 0; i < ARRAY_SIZE(alc_beep_mixer); i++) {
1120 		knew = snd_hda_gen_add_kctl(&spec->gen, NULL,
1121 					    &alc_beep_mixer[i]);
1122 		if (!knew)
1123 			return -ENOMEM;
1124 		knew->private_value = beep_amp;
1125 	}
1126 	return 0;
1127 }
1128 
1129 static const struct snd_pci_quirk beep_allow_list[] = {
1130 	SND_PCI_QUIRK(0x1043, 0x103c, "ASUS", 1),
1131 	SND_PCI_QUIRK(0x1043, 0x115d, "ASUS", 1),
1132 	SND_PCI_QUIRK(0x1043, 0x829f, "ASUS", 1),
1133 	SND_PCI_QUIRK(0x1043, 0x8376, "EeePC", 1),
1134 	SND_PCI_QUIRK(0x1043, 0x83ce, "EeePC", 1),
1135 	SND_PCI_QUIRK(0x1043, 0x831a, "EeePC", 1),
1136 	SND_PCI_QUIRK(0x1043, 0x834a, "EeePC", 1),
1137 	SND_PCI_QUIRK(0x1458, 0xa002, "GA-MA790X", 1),
1138 	SND_PCI_QUIRK(0x8086, 0xd613, "Intel", 1),
1139 	/* denylist -- no beep available */
1140 	SND_PCI_QUIRK(0x17aa, 0x309e, "Lenovo ThinkCentre M73", 0),
1141 	SND_PCI_QUIRK(0x17aa, 0x30a3, "Lenovo ThinkCentre M93", 0),
1142 	{}
1143 };
1144 
1145 static inline int has_cdefine_beep(struct hda_codec *codec)
1146 {
1147 	struct alc_spec *spec = codec->spec;
1148 	const struct snd_pci_quirk *q;
1149 	q = snd_pci_quirk_lookup(codec->bus->pci, beep_allow_list);
1150 	if (q)
1151 		return q->value;
1152 	return spec->cdefine.enable_pcbeep;
1153 }
1154 #else
1155 #define set_beep_amp(spec, nid, idx, dir)	0
1156 #define has_cdefine_beep(codec)		0
1157 #endif
1158 
1159 /* parse the BIOS configuration and set up the alc_spec */
1160 /* return 1 if successful, 0 if the proper config is not found,
1161  * or a negative error code
1162  */
1163 static int alc_parse_auto_config(struct hda_codec *codec,
1164 				 const hda_nid_t *ignore_nids,
1165 				 const hda_nid_t *ssid_nids)
1166 {
1167 	struct alc_spec *spec = codec->spec;
1168 	struct auto_pin_cfg *cfg = &spec->gen.autocfg;
1169 	int err;
1170 
1171 	err = snd_hda_parse_pin_defcfg(codec, cfg, ignore_nids,
1172 				       spec->parse_flags);
1173 	if (err < 0)
1174 		return err;
1175 
1176 	if (ssid_nids)
1177 		alc_ssid_check(codec, ssid_nids);
1178 
1179 	err = snd_hda_gen_parse_auto_config(codec, cfg);
1180 	if (err < 0)
1181 		return err;
1182 
1183 	return 1;
1184 }
1185 
1186 /* common preparation job for alc_spec */
1187 static int alc_alloc_spec(struct hda_codec *codec, hda_nid_t mixer_nid)
1188 {
1189 	struct alc_spec *spec = kzalloc(sizeof(*spec), GFP_KERNEL);
1190 	int err;
1191 
1192 	if (!spec)
1193 		return -ENOMEM;
1194 	codec->spec = spec;
1195 	snd_hda_gen_spec_init(&spec->gen);
1196 	spec->gen.mixer_nid = mixer_nid;
1197 	spec->gen.own_eapd_ctl = 1;
1198 	codec->single_adc_amp = 1;
1199 	/* FIXME: do we need this for all Realtek codec models? */
1200 	codec->spdif_status_reset = 1;
1201 	codec->forced_resume = 1;
1202 	codec->patch_ops = alc_patch_ops;
1203 	mutex_init(&spec->coef_mutex);
1204 
1205 	err = alc_codec_rename_from_preset(codec);
1206 	if (err < 0) {
1207 		kfree(spec);
1208 		return err;
1209 	}
1210 	return 0;
1211 }
1212 
1213 static int alc880_parse_auto_config(struct hda_codec *codec)
1214 {
1215 	static const hda_nid_t alc880_ignore[] = { 0x1d, 0 };
1216 	static const hda_nid_t alc880_ssids[] = { 0x15, 0x1b, 0x14, 0 };
1217 	return alc_parse_auto_config(codec, alc880_ignore, alc880_ssids);
1218 }
1219 
1220 /*
1221  * ALC880 fix-ups
1222  */
1223 enum {
1224 	ALC880_FIXUP_GPIO1,
1225 	ALC880_FIXUP_GPIO2,
1226 	ALC880_FIXUP_MEDION_RIM,
1227 	ALC880_FIXUP_LG,
1228 	ALC880_FIXUP_LG_LW25,
1229 	ALC880_FIXUP_W810,
1230 	ALC880_FIXUP_EAPD_COEF,
1231 	ALC880_FIXUP_TCL_S700,
1232 	ALC880_FIXUP_VOL_KNOB,
1233 	ALC880_FIXUP_FUJITSU,
1234 	ALC880_FIXUP_F1734,
1235 	ALC880_FIXUP_UNIWILL,
1236 	ALC880_FIXUP_UNIWILL_DIG,
1237 	ALC880_FIXUP_Z71V,
1238 	ALC880_FIXUP_ASUS_W5A,
1239 	ALC880_FIXUP_3ST_BASE,
1240 	ALC880_FIXUP_3ST,
1241 	ALC880_FIXUP_3ST_DIG,
1242 	ALC880_FIXUP_5ST_BASE,
1243 	ALC880_FIXUP_5ST,
1244 	ALC880_FIXUP_5ST_DIG,
1245 	ALC880_FIXUP_6ST_BASE,
1246 	ALC880_FIXUP_6ST,
1247 	ALC880_FIXUP_6ST_DIG,
1248 	ALC880_FIXUP_6ST_AUTOMUTE,
1249 };
1250 
1251 /* enable the volume-knob widget support on NID 0x21 */
1252 static void alc880_fixup_vol_knob(struct hda_codec *codec,
1253 				  const struct hda_fixup *fix, int action)
1254 {
1255 	if (action == HDA_FIXUP_ACT_PROBE)
1256 		snd_hda_jack_detect_enable_callback(codec, 0x21,
1257 						    alc_update_knob_master);
1258 }
1259 
1260 static const struct hda_fixup alc880_fixups[] = {
1261 	[ALC880_FIXUP_GPIO1] = {
1262 		.type = HDA_FIXUP_FUNC,
1263 		.v.func = alc_fixup_gpio1,
1264 	},
1265 	[ALC880_FIXUP_GPIO2] = {
1266 		.type = HDA_FIXUP_FUNC,
1267 		.v.func = alc_fixup_gpio2,
1268 	},
1269 	[ALC880_FIXUP_MEDION_RIM] = {
1270 		.type = HDA_FIXUP_VERBS,
1271 		.v.verbs = (const struct hda_verb[]) {
1272 			{ 0x20, AC_VERB_SET_COEF_INDEX, 0x07 },
1273 			{ 0x20, AC_VERB_SET_PROC_COEF,  0x3060 },
1274 			{ }
1275 		},
1276 		.chained = true,
1277 		.chain_id = ALC880_FIXUP_GPIO2,
1278 	},
1279 	[ALC880_FIXUP_LG] = {
1280 		.type = HDA_FIXUP_PINS,
1281 		.v.pins = (const struct hda_pintbl[]) {
1282 			/* disable bogus unused pins */
1283 			{ 0x16, 0x411111f0 },
1284 			{ 0x18, 0x411111f0 },
1285 			{ 0x1a, 0x411111f0 },
1286 			{ }
1287 		}
1288 	},
1289 	[ALC880_FIXUP_LG_LW25] = {
1290 		.type = HDA_FIXUP_PINS,
1291 		.v.pins = (const struct hda_pintbl[]) {
1292 			{ 0x1a, 0x0181344f }, /* line-in */
1293 			{ 0x1b, 0x0321403f }, /* headphone */
1294 			{ }
1295 		}
1296 	},
1297 	[ALC880_FIXUP_W810] = {
1298 		.type = HDA_FIXUP_PINS,
1299 		.v.pins = (const struct hda_pintbl[]) {
1300 			/* disable bogus unused pins */
1301 			{ 0x17, 0x411111f0 },
1302 			{ }
1303 		},
1304 		.chained = true,
1305 		.chain_id = ALC880_FIXUP_GPIO2,
1306 	},
1307 	[ALC880_FIXUP_EAPD_COEF] = {
1308 		.type = HDA_FIXUP_VERBS,
1309 		.v.verbs = (const struct hda_verb[]) {
1310 			/* change to EAPD mode */
1311 			{ 0x20, AC_VERB_SET_COEF_INDEX, 0x07 },
1312 			{ 0x20, AC_VERB_SET_PROC_COEF,  0x3060 },
1313 			{}
1314 		},
1315 	},
1316 	[ALC880_FIXUP_TCL_S700] = {
1317 		.type = HDA_FIXUP_VERBS,
1318 		.v.verbs = (const struct hda_verb[]) {
1319 			/* change to EAPD mode */
1320 			{ 0x20, AC_VERB_SET_COEF_INDEX, 0x07 },
1321 			{ 0x20, AC_VERB_SET_PROC_COEF,  0x3070 },
1322 			{}
1323 		},
1324 		.chained = true,
1325 		.chain_id = ALC880_FIXUP_GPIO2,
1326 	},
1327 	[ALC880_FIXUP_VOL_KNOB] = {
1328 		.type = HDA_FIXUP_FUNC,
1329 		.v.func = alc880_fixup_vol_knob,
1330 	},
1331 	[ALC880_FIXUP_FUJITSU] = {
1332 		/* override all pins as BIOS on old Amilo is broken */
1333 		.type = HDA_FIXUP_PINS,
1334 		.v.pins = (const struct hda_pintbl[]) {
1335 			{ 0x14, 0x0121401f }, /* HP */
1336 			{ 0x15, 0x99030120 }, /* speaker */
1337 			{ 0x16, 0x99030130 }, /* bass speaker */
1338 			{ 0x17, 0x411111f0 }, /* N/A */
1339 			{ 0x18, 0x411111f0 }, /* N/A */
1340 			{ 0x19, 0x01a19950 }, /* mic-in */
1341 			{ 0x1a, 0x411111f0 }, /* N/A */
1342 			{ 0x1b, 0x411111f0 }, /* N/A */
1343 			{ 0x1c, 0x411111f0 }, /* N/A */
1344 			{ 0x1d, 0x411111f0 }, /* N/A */
1345 			{ 0x1e, 0x01454140 }, /* SPDIF out */
1346 			{ }
1347 		},
1348 		.chained = true,
1349 		.chain_id = ALC880_FIXUP_VOL_KNOB,
1350 	},
1351 	[ALC880_FIXUP_F1734] = {
1352 		/* almost compatible with FUJITSU, but no bass and SPDIF */
1353 		.type = HDA_FIXUP_PINS,
1354 		.v.pins = (const struct hda_pintbl[]) {
1355 			{ 0x14, 0x0121401f }, /* HP */
1356 			{ 0x15, 0x99030120 }, /* speaker */
1357 			{ 0x16, 0x411111f0 }, /* N/A */
1358 			{ 0x17, 0x411111f0 }, /* N/A */
1359 			{ 0x18, 0x411111f0 }, /* N/A */
1360 			{ 0x19, 0x01a19950 }, /* mic-in */
1361 			{ 0x1a, 0x411111f0 }, /* N/A */
1362 			{ 0x1b, 0x411111f0 }, /* N/A */
1363 			{ 0x1c, 0x411111f0 }, /* N/A */
1364 			{ 0x1d, 0x411111f0 }, /* N/A */
1365 			{ 0x1e, 0x411111f0 }, /* N/A */
1366 			{ }
1367 		},
1368 		.chained = true,
1369 		.chain_id = ALC880_FIXUP_VOL_KNOB,
1370 	},
1371 	[ALC880_FIXUP_UNIWILL] = {
1372 		/* need to fix HP and speaker pins to be parsed correctly */
1373 		.type = HDA_FIXUP_PINS,
1374 		.v.pins = (const struct hda_pintbl[]) {
1375 			{ 0x14, 0x0121411f }, /* HP */
1376 			{ 0x15, 0x99030120 }, /* speaker */
1377 			{ 0x16, 0x99030130 }, /* bass speaker */
1378 			{ }
1379 		},
1380 	},
1381 	[ALC880_FIXUP_UNIWILL_DIG] = {
1382 		.type = HDA_FIXUP_PINS,
1383 		.v.pins = (const struct hda_pintbl[]) {
1384 			/* disable bogus unused pins */
1385 			{ 0x17, 0x411111f0 },
1386 			{ 0x19, 0x411111f0 },
1387 			{ 0x1b, 0x411111f0 },
1388 			{ 0x1f, 0x411111f0 },
1389 			{ }
1390 		}
1391 	},
1392 	[ALC880_FIXUP_Z71V] = {
1393 		.type = HDA_FIXUP_PINS,
1394 		.v.pins = (const struct hda_pintbl[]) {
1395 			/* set up the whole pins as BIOS is utterly broken */
1396 			{ 0x14, 0x99030120 }, /* speaker */
1397 			{ 0x15, 0x0121411f }, /* HP */
1398 			{ 0x16, 0x411111f0 }, /* N/A */
1399 			{ 0x17, 0x411111f0 }, /* N/A */
1400 			{ 0x18, 0x01a19950 }, /* mic-in */
1401 			{ 0x19, 0x411111f0 }, /* N/A */
1402 			{ 0x1a, 0x01813031 }, /* line-in */
1403 			{ 0x1b, 0x411111f0 }, /* N/A */
1404 			{ 0x1c, 0x411111f0 }, /* N/A */
1405 			{ 0x1d, 0x411111f0 }, /* N/A */
1406 			{ 0x1e, 0x0144111e }, /* SPDIF */
1407 			{ }
1408 		}
1409 	},
1410 	[ALC880_FIXUP_ASUS_W5A] = {
1411 		.type = HDA_FIXUP_PINS,
1412 		.v.pins = (const struct hda_pintbl[]) {
1413 			/* set up the whole pins as BIOS is utterly broken */
1414 			{ 0x14, 0x0121411f }, /* HP */
1415 			{ 0x15, 0x411111f0 }, /* N/A */
1416 			{ 0x16, 0x411111f0 }, /* N/A */
1417 			{ 0x17, 0x411111f0 }, /* N/A */
1418 			{ 0x18, 0x90a60160 }, /* mic */
1419 			{ 0x19, 0x411111f0 }, /* N/A */
1420 			{ 0x1a, 0x411111f0 }, /* N/A */
1421 			{ 0x1b, 0x411111f0 }, /* N/A */
1422 			{ 0x1c, 0x411111f0 }, /* N/A */
1423 			{ 0x1d, 0x411111f0 }, /* N/A */
1424 			{ 0x1e, 0xb743111e }, /* SPDIF out */
1425 			{ }
1426 		},
1427 		.chained = true,
1428 		.chain_id = ALC880_FIXUP_GPIO1,
1429 	},
1430 	[ALC880_FIXUP_3ST_BASE] = {
1431 		.type = HDA_FIXUP_PINS,
1432 		.v.pins = (const struct hda_pintbl[]) {
1433 			{ 0x14, 0x01014010 }, /* line-out */
1434 			{ 0x15, 0x411111f0 }, /* N/A */
1435 			{ 0x16, 0x411111f0 }, /* N/A */
1436 			{ 0x17, 0x411111f0 }, /* N/A */
1437 			{ 0x18, 0x01a19c30 }, /* mic-in */
1438 			{ 0x19, 0x0121411f }, /* HP */
1439 			{ 0x1a, 0x01813031 }, /* line-in */
1440 			{ 0x1b, 0x02a19c40 }, /* front-mic */
1441 			{ 0x1c, 0x411111f0 }, /* N/A */
1442 			{ 0x1d, 0x411111f0 }, /* N/A */
1443 			/* 0x1e is filled in below */
1444 			{ 0x1f, 0x411111f0 }, /* N/A */
1445 			{ }
1446 		}
1447 	},
1448 	[ALC880_FIXUP_3ST] = {
1449 		.type = HDA_FIXUP_PINS,
1450 		.v.pins = (const struct hda_pintbl[]) {
1451 			{ 0x1e, 0x411111f0 }, /* N/A */
1452 			{ }
1453 		},
1454 		.chained = true,
1455 		.chain_id = ALC880_FIXUP_3ST_BASE,
1456 	},
1457 	[ALC880_FIXUP_3ST_DIG] = {
1458 		.type = HDA_FIXUP_PINS,
1459 		.v.pins = (const struct hda_pintbl[]) {
1460 			{ 0x1e, 0x0144111e }, /* SPDIF */
1461 			{ }
1462 		},
1463 		.chained = true,
1464 		.chain_id = ALC880_FIXUP_3ST_BASE,
1465 	},
1466 	[ALC880_FIXUP_5ST_BASE] = {
1467 		.type = HDA_FIXUP_PINS,
1468 		.v.pins = (const struct hda_pintbl[]) {
1469 			{ 0x14, 0x01014010 }, /* front */
1470 			{ 0x15, 0x411111f0 }, /* N/A */
1471 			{ 0x16, 0x01011411 }, /* CLFE */
1472 			{ 0x17, 0x01016412 }, /* surr */
1473 			{ 0x18, 0x01a19c30 }, /* mic-in */
1474 			{ 0x19, 0x0121411f }, /* HP */
1475 			{ 0x1a, 0x01813031 }, /* line-in */
1476 			{ 0x1b, 0x02a19c40 }, /* front-mic */
1477 			{ 0x1c, 0x411111f0 }, /* N/A */
1478 			{ 0x1d, 0x411111f0 }, /* N/A */
1479 			/* 0x1e is filled in below */
1480 			{ 0x1f, 0x411111f0 }, /* N/A */
1481 			{ }
1482 		}
1483 	},
1484 	[ALC880_FIXUP_5ST] = {
1485 		.type = HDA_FIXUP_PINS,
1486 		.v.pins = (const struct hda_pintbl[]) {
1487 			{ 0x1e, 0x411111f0 }, /* N/A */
1488 			{ }
1489 		},
1490 		.chained = true,
1491 		.chain_id = ALC880_FIXUP_5ST_BASE,
1492 	},
1493 	[ALC880_FIXUP_5ST_DIG] = {
1494 		.type = HDA_FIXUP_PINS,
1495 		.v.pins = (const struct hda_pintbl[]) {
1496 			{ 0x1e, 0x0144111e }, /* SPDIF */
1497 			{ }
1498 		},
1499 		.chained = true,
1500 		.chain_id = ALC880_FIXUP_5ST_BASE,
1501 	},
1502 	[ALC880_FIXUP_6ST_BASE] = {
1503 		.type = HDA_FIXUP_PINS,
1504 		.v.pins = (const struct hda_pintbl[]) {
1505 			{ 0x14, 0x01014010 }, /* front */
1506 			{ 0x15, 0x01016412 }, /* surr */
1507 			{ 0x16, 0x01011411 }, /* CLFE */
1508 			{ 0x17, 0x01012414 }, /* side */
1509 			{ 0x18, 0x01a19c30 }, /* mic-in */
1510 			{ 0x19, 0x02a19c40 }, /* front-mic */
1511 			{ 0x1a, 0x01813031 }, /* line-in */
1512 			{ 0x1b, 0x0121411f }, /* HP */
1513 			{ 0x1c, 0x411111f0 }, /* N/A */
1514 			{ 0x1d, 0x411111f0 }, /* N/A */
1515 			/* 0x1e is filled in below */
1516 			{ 0x1f, 0x411111f0 }, /* N/A */
1517 			{ }
1518 		}
1519 	},
1520 	[ALC880_FIXUP_6ST] = {
1521 		.type = HDA_FIXUP_PINS,
1522 		.v.pins = (const struct hda_pintbl[]) {
1523 			{ 0x1e, 0x411111f0 }, /* N/A */
1524 			{ }
1525 		},
1526 		.chained = true,
1527 		.chain_id = ALC880_FIXUP_6ST_BASE,
1528 	},
1529 	[ALC880_FIXUP_6ST_DIG] = {
1530 		.type = HDA_FIXUP_PINS,
1531 		.v.pins = (const struct hda_pintbl[]) {
1532 			{ 0x1e, 0x0144111e }, /* SPDIF */
1533 			{ }
1534 		},
1535 		.chained = true,
1536 		.chain_id = ALC880_FIXUP_6ST_BASE,
1537 	},
1538 	[ALC880_FIXUP_6ST_AUTOMUTE] = {
1539 		.type = HDA_FIXUP_PINS,
1540 		.v.pins = (const struct hda_pintbl[]) {
1541 			{ 0x1b, 0x0121401f }, /* HP with jack detect */
1542 			{ }
1543 		},
1544 		.chained_before = true,
1545 		.chain_id = ALC880_FIXUP_6ST_BASE,
1546 	},
1547 };
1548 
1549 static const struct snd_pci_quirk alc880_fixup_tbl[] = {
1550 	SND_PCI_QUIRK(0x1019, 0x0f69, "Coeus G610P", ALC880_FIXUP_W810),
1551 	SND_PCI_QUIRK(0x1043, 0x10c3, "ASUS W5A", ALC880_FIXUP_ASUS_W5A),
1552 	SND_PCI_QUIRK(0x1043, 0x1964, "ASUS Z71V", ALC880_FIXUP_Z71V),
1553 	SND_PCI_QUIRK_VENDOR(0x1043, "ASUS", ALC880_FIXUP_GPIO1),
1554 	SND_PCI_QUIRK(0x147b, 0x1045, "ABit AA8XE", ALC880_FIXUP_6ST_AUTOMUTE),
1555 	SND_PCI_QUIRK(0x1558, 0x5401, "Clevo GPIO2", ALC880_FIXUP_GPIO2),
1556 	SND_PCI_QUIRK_VENDOR(0x1558, "Clevo", ALC880_FIXUP_EAPD_COEF),
1557 	SND_PCI_QUIRK(0x1584, 0x9050, "Uniwill", ALC880_FIXUP_UNIWILL_DIG),
1558 	SND_PCI_QUIRK(0x1584, 0x9054, "Uniwill", ALC880_FIXUP_F1734),
1559 	SND_PCI_QUIRK(0x1584, 0x9070, "Uniwill", ALC880_FIXUP_UNIWILL),
1560 	SND_PCI_QUIRK(0x1584, 0x9077, "Uniwill P53", ALC880_FIXUP_VOL_KNOB),
1561 	SND_PCI_QUIRK(0x161f, 0x203d, "W810", ALC880_FIXUP_W810),
1562 	SND_PCI_QUIRK(0x161f, 0x205d, "Medion Rim 2150", ALC880_FIXUP_MEDION_RIM),
1563 	SND_PCI_QUIRK(0x1631, 0xe011, "PB 13201056", ALC880_FIXUP_6ST_AUTOMUTE),
1564 	SND_PCI_QUIRK(0x1734, 0x107c, "FSC Amilo M1437", ALC880_FIXUP_FUJITSU),
1565 	SND_PCI_QUIRK(0x1734, 0x1094, "FSC Amilo M1451G", ALC880_FIXUP_FUJITSU),
1566 	SND_PCI_QUIRK(0x1734, 0x10ac, "FSC AMILO Xi 1526", ALC880_FIXUP_F1734),
1567 	SND_PCI_QUIRK(0x1734, 0x10b0, "FSC Amilo Pi1556", ALC880_FIXUP_FUJITSU),
1568 	SND_PCI_QUIRK(0x1854, 0x003b, "LG", ALC880_FIXUP_LG),
1569 	SND_PCI_QUIRK(0x1854, 0x005f, "LG P1 Express", ALC880_FIXUP_LG),
1570 	SND_PCI_QUIRK(0x1854, 0x0068, "LG w1", ALC880_FIXUP_LG),
1571 	SND_PCI_QUIRK(0x1854, 0x0077, "LG LW25", ALC880_FIXUP_LG_LW25),
1572 	SND_PCI_QUIRK(0x19db, 0x4188, "TCL S700", ALC880_FIXUP_TCL_S700),
1573 
1574 	/* Below is the copied entries from alc880_quirks.c.
1575 	 * It's not quite sure whether BIOS sets the correct pin-config table
1576 	 * on these machines, thus they are kept to be compatible with
1577 	 * the old static quirks.  Once when it's confirmed to work without
1578 	 * these overrides, it'd be better to remove.
1579 	 */
1580 	SND_PCI_QUIRK(0x1019, 0xa880, "ECS", ALC880_FIXUP_5ST_DIG),
1581 	SND_PCI_QUIRK(0x1019, 0xa884, "Acer APFV", ALC880_FIXUP_6ST),
1582 	SND_PCI_QUIRK(0x1025, 0x0070, "ULI", ALC880_FIXUP_3ST_DIG),
1583 	SND_PCI_QUIRK(0x1025, 0x0077, "ULI", ALC880_FIXUP_6ST_DIG),
1584 	SND_PCI_QUIRK(0x1025, 0x0078, "ULI", ALC880_FIXUP_6ST_DIG),
1585 	SND_PCI_QUIRK(0x1025, 0x0087, "ULI", ALC880_FIXUP_6ST_DIG),
1586 	SND_PCI_QUIRK(0x1025, 0xe309, "ULI", ALC880_FIXUP_3ST_DIG),
1587 	SND_PCI_QUIRK(0x1025, 0xe310, "ULI", ALC880_FIXUP_3ST),
1588 	SND_PCI_QUIRK(0x1039, 0x1234, NULL, ALC880_FIXUP_6ST_DIG),
1589 	SND_PCI_QUIRK(0x104d, 0x81a0, "Sony", ALC880_FIXUP_3ST),
1590 	SND_PCI_QUIRK(0x104d, 0x81d6, "Sony", ALC880_FIXUP_3ST),
1591 	SND_PCI_QUIRK(0x107b, 0x3032, "Gateway", ALC880_FIXUP_5ST),
1592 	SND_PCI_QUIRK(0x107b, 0x3033, "Gateway", ALC880_FIXUP_5ST),
1593 	SND_PCI_QUIRK(0x107b, 0x4039, "Gateway", ALC880_FIXUP_5ST),
1594 	SND_PCI_QUIRK(0x1297, 0xc790, "Shuttle ST20G5", ALC880_FIXUP_6ST_DIG),
1595 	SND_PCI_QUIRK(0x1458, 0xa102, "Gigabyte K8", ALC880_FIXUP_6ST_DIG),
1596 	SND_PCI_QUIRK(0x1462, 0x1150, "MSI", ALC880_FIXUP_6ST_DIG),
1597 	SND_PCI_QUIRK(0x1509, 0x925d, "FIC P4M", ALC880_FIXUP_6ST_DIG),
1598 	SND_PCI_QUIRK(0x1565, 0x8202, "Biostar", ALC880_FIXUP_5ST_DIG),
1599 	SND_PCI_QUIRK(0x1695, 0x400d, "EPoX", ALC880_FIXUP_5ST_DIG),
1600 	SND_PCI_QUIRK(0x1695, 0x4012, "EPox EP-5LDA", ALC880_FIXUP_5ST_DIG),
1601 	SND_PCI_QUIRK(0x2668, 0x8086, NULL, ALC880_FIXUP_6ST_DIG), /* broken BIOS */
1602 	SND_PCI_QUIRK(0x8086, 0x2668, NULL, ALC880_FIXUP_6ST_DIG),
1603 	SND_PCI_QUIRK(0x8086, 0xa100, "Intel mobo", ALC880_FIXUP_5ST_DIG),
1604 	SND_PCI_QUIRK(0x8086, 0xd400, "Intel mobo", ALC880_FIXUP_5ST_DIG),
1605 	SND_PCI_QUIRK(0x8086, 0xd401, "Intel mobo", ALC880_FIXUP_5ST_DIG),
1606 	SND_PCI_QUIRK(0x8086, 0xd402, "Intel mobo", ALC880_FIXUP_3ST_DIG),
1607 	SND_PCI_QUIRK(0x8086, 0xe224, "Intel mobo", ALC880_FIXUP_5ST_DIG),
1608 	SND_PCI_QUIRK(0x8086, 0xe305, "Intel mobo", ALC880_FIXUP_3ST_DIG),
1609 	SND_PCI_QUIRK(0x8086, 0xe308, "Intel mobo", ALC880_FIXUP_3ST_DIG),
1610 	SND_PCI_QUIRK(0x8086, 0xe400, "Intel mobo", ALC880_FIXUP_5ST_DIG),
1611 	SND_PCI_QUIRK(0x8086, 0xe401, "Intel mobo", ALC880_FIXUP_5ST_DIG),
1612 	SND_PCI_QUIRK(0x8086, 0xe402, "Intel mobo", ALC880_FIXUP_5ST_DIG),
1613 	/* default Intel */
1614 	SND_PCI_QUIRK_VENDOR(0x8086, "Intel mobo", ALC880_FIXUP_3ST),
1615 	SND_PCI_QUIRK(0xa0a0, 0x0560, "AOpen i915GMm-HFS", ALC880_FIXUP_5ST_DIG),
1616 	SND_PCI_QUIRK(0xe803, 0x1019, NULL, ALC880_FIXUP_6ST_DIG),
1617 	{}
1618 };
1619 
1620 static const struct hda_model_fixup alc880_fixup_models[] = {
1621 	{.id = ALC880_FIXUP_3ST, .name = "3stack"},
1622 	{.id = ALC880_FIXUP_3ST_DIG, .name = "3stack-digout"},
1623 	{.id = ALC880_FIXUP_5ST, .name = "5stack"},
1624 	{.id = ALC880_FIXUP_5ST_DIG, .name = "5stack-digout"},
1625 	{.id = ALC880_FIXUP_6ST, .name = "6stack"},
1626 	{.id = ALC880_FIXUP_6ST_DIG, .name = "6stack-digout"},
1627 	{.id = ALC880_FIXUP_6ST_AUTOMUTE, .name = "6stack-automute"},
1628 	{}
1629 };
1630 
1631 
1632 /*
1633  * OK, here we have finally the patch for ALC880
1634  */
1635 static int patch_alc880(struct hda_codec *codec)
1636 {
1637 	struct alc_spec *spec;
1638 	int err;
1639 
1640 	err = alc_alloc_spec(codec, 0x0b);
1641 	if (err < 0)
1642 		return err;
1643 
1644 	spec = codec->spec;
1645 	spec->gen.need_dac_fix = 1;
1646 	spec->gen.beep_nid = 0x01;
1647 
1648 	codec->patch_ops.unsol_event = alc880_unsol_event;
1649 
1650 	alc_pre_init(codec);
1651 
1652 	snd_hda_pick_fixup(codec, alc880_fixup_models, alc880_fixup_tbl,
1653 		       alc880_fixups);
1654 	snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE);
1655 
1656 	/* automatic parse from the BIOS config */
1657 	err = alc880_parse_auto_config(codec);
1658 	if (err < 0)
1659 		goto error;
1660 
1661 	if (!spec->gen.no_analog) {
1662 		err = set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
1663 		if (err < 0)
1664 			goto error;
1665 	}
1666 
1667 	snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE);
1668 
1669 	return 0;
1670 
1671  error:
1672 	alc_free(codec);
1673 	return err;
1674 }
1675 
1676 
1677 /*
1678  * ALC260 support
1679  */
1680 static int alc260_parse_auto_config(struct hda_codec *codec)
1681 {
1682 	static const hda_nid_t alc260_ignore[] = { 0x17, 0 };
1683 	static const hda_nid_t alc260_ssids[] = { 0x10, 0x15, 0x0f, 0 };
1684 	return alc_parse_auto_config(codec, alc260_ignore, alc260_ssids);
1685 }
1686 
1687 /*
1688  * Pin config fixes
1689  */
1690 enum {
1691 	ALC260_FIXUP_HP_DC5750,
1692 	ALC260_FIXUP_HP_PIN_0F,
1693 	ALC260_FIXUP_COEF,
1694 	ALC260_FIXUP_GPIO1,
1695 	ALC260_FIXUP_GPIO1_TOGGLE,
1696 	ALC260_FIXUP_REPLACER,
1697 	ALC260_FIXUP_HP_B1900,
1698 	ALC260_FIXUP_KN1,
1699 	ALC260_FIXUP_FSC_S7020,
1700 	ALC260_FIXUP_FSC_S7020_JWSE,
1701 	ALC260_FIXUP_VAIO_PINS,
1702 };
1703 
1704 static void alc260_gpio1_automute(struct hda_codec *codec)
1705 {
1706 	struct alc_spec *spec = codec->spec;
1707 
1708 	alc_update_gpio_data(codec, 0x01, spec->gen.hp_jack_present);
1709 }
1710 
1711 static void alc260_fixup_gpio1_toggle(struct hda_codec *codec,
1712 				      const struct hda_fixup *fix, int action)
1713 {
1714 	struct alc_spec *spec = codec->spec;
1715 	if (action == HDA_FIXUP_ACT_PROBE) {
1716 		/* although the machine has only one output pin, we need to
1717 		 * toggle GPIO1 according to the jack state
1718 		 */
1719 		spec->gen.automute_hook = alc260_gpio1_automute;
1720 		spec->gen.detect_hp = 1;
1721 		spec->gen.automute_speaker = 1;
1722 		spec->gen.autocfg.hp_pins[0] = 0x0f; /* copy it for automute */
1723 		snd_hda_jack_detect_enable_callback(codec, 0x0f,
1724 						    snd_hda_gen_hp_automute);
1725 		alc_setup_gpio(codec, 0x01);
1726 	}
1727 }
1728 
1729 static void alc260_fixup_kn1(struct hda_codec *codec,
1730 			     const struct hda_fixup *fix, int action)
1731 {
1732 	struct alc_spec *spec = codec->spec;
1733 	static const struct hda_pintbl pincfgs[] = {
1734 		{ 0x0f, 0x02214000 }, /* HP/speaker */
1735 		{ 0x12, 0x90a60160 }, /* int mic */
1736 		{ 0x13, 0x02a19000 }, /* ext mic */
1737 		{ 0x18, 0x01446000 }, /* SPDIF out */
1738 		/* disable bogus I/O pins */
1739 		{ 0x10, 0x411111f0 },
1740 		{ 0x11, 0x411111f0 },
1741 		{ 0x14, 0x411111f0 },
1742 		{ 0x15, 0x411111f0 },
1743 		{ 0x16, 0x411111f0 },
1744 		{ 0x17, 0x411111f0 },
1745 		{ 0x19, 0x411111f0 },
1746 		{ }
1747 	};
1748 
1749 	switch (action) {
1750 	case HDA_FIXUP_ACT_PRE_PROBE:
1751 		snd_hda_apply_pincfgs(codec, pincfgs);
1752 		spec->init_amp = ALC_INIT_NONE;
1753 		break;
1754 	}
1755 }
1756 
1757 static void alc260_fixup_fsc_s7020(struct hda_codec *codec,
1758 				   const struct hda_fixup *fix, int action)
1759 {
1760 	struct alc_spec *spec = codec->spec;
1761 	if (action == HDA_FIXUP_ACT_PRE_PROBE)
1762 		spec->init_amp = ALC_INIT_NONE;
1763 }
1764 
1765 static void alc260_fixup_fsc_s7020_jwse(struct hda_codec *codec,
1766 				   const struct hda_fixup *fix, int action)
1767 {
1768 	struct alc_spec *spec = codec->spec;
1769 	if (action == HDA_FIXUP_ACT_PRE_PROBE) {
1770 		spec->gen.add_jack_modes = 1;
1771 		spec->gen.hp_mic = 1;
1772 	}
1773 }
1774 
1775 static const struct hda_fixup alc260_fixups[] = {
1776 	[ALC260_FIXUP_HP_DC5750] = {
1777 		.type = HDA_FIXUP_PINS,
1778 		.v.pins = (const struct hda_pintbl[]) {
1779 			{ 0x11, 0x90130110 }, /* speaker */
1780 			{ }
1781 		}
1782 	},
1783 	[ALC260_FIXUP_HP_PIN_0F] = {
1784 		.type = HDA_FIXUP_PINS,
1785 		.v.pins = (const struct hda_pintbl[]) {
1786 			{ 0x0f, 0x01214000 }, /* HP */
1787 			{ }
1788 		}
1789 	},
1790 	[ALC260_FIXUP_COEF] = {
1791 		.type = HDA_FIXUP_VERBS,
1792 		.v.verbs = (const struct hda_verb[]) {
1793 			{ 0x1a, AC_VERB_SET_COEF_INDEX, 0x07 },
1794 			{ 0x1a, AC_VERB_SET_PROC_COEF,  0x3040 },
1795 			{ }
1796 		},
1797 	},
1798 	[ALC260_FIXUP_GPIO1] = {
1799 		.type = HDA_FIXUP_FUNC,
1800 		.v.func = alc_fixup_gpio1,
1801 	},
1802 	[ALC260_FIXUP_GPIO1_TOGGLE] = {
1803 		.type = HDA_FIXUP_FUNC,
1804 		.v.func = alc260_fixup_gpio1_toggle,
1805 		.chained = true,
1806 		.chain_id = ALC260_FIXUP_HP_PIN_0F,
1807 	},
1808 	[ALC260_FIXUP_REPLACER] = {
1809 		.type = HDA_FIXUP_VERBS,
1810 		.v.verbs = (const struct hda_verb[]) {
1811 			{ 0x1a, AC_VERB_SET_COEF_INDEX, 0x07 },
1812 			{ 0x1a, AC_VERB_SET_PROC_COEF,  0x3050 },
1813 			{ }
1814 		},
1815 		.chained = true,
1816 		.chain_id = ALC260_FIXUP_GPIO1_TOGGLE,
1817 	},
1818 	[ALC260_FIXUP_HP_B1900] = {
1819 		.type = HDA_FIXUP_FUNC,
1820 		.v.func = alc260_fixup_gpio1_toggle,
1821 		.chained = true,
1822 		.chain_id = ALC260_FIXUP_COEF,
1823 	},
1824 	[ALC260_FIXUP_KN1] = {
1825 		.type = HDA_FIXUP_FUNC,
1826 		.v.func = alc260_fixup_kn1,
1827 	},
1828 	[ALC260_FIXUP_FSC_S7020] = {
1829 		.type = HDA_FIXUP_FUNC,
1830 		.v.func = alc260_fixup_fsc_s7020,
1831 	},
1832 	[ALC260_FIXUP_FSC_S7020_JWSE] = {
1833 		.type = HDA_FIXUP_FUNC,
1834 		.v.func = alc260_fixup_fsc_s7020_jwse,
1835 		.chained = true,
1836 		.chain_id = ALC260_FIXUP_FSC_S7020,
1837 	},
1838 	[ALC260_FIXUP_VAIO_PINS] = {
1839 		.type = HDA_FIXUP_PINS,
1840 		.v.pins = (const struct hda_pintbl[]) {
1841 			/* Pin configs are missing completely on some VAIOs */
1842 			{ 0x0f, 0x01211020 },
1843 			{ 0x10, 0x0001003f },
1844 			{ 0x11, 0x411111f0 },
1845 			{ 0x12, 0x01a15930 },
1846 			{ 0x13, 0x411111f0 },
1847 			{ 0x14, 0x411111f0 },
1848 			{ 0x15, 0x411111f0 },
1849 			{ 0x16, 0x411111f0 },
1850 			{ 0x17, 0x411111f0 },
1851 			{ 0x18, 0x411111f0 },
1852 			{ 0x19, 0x411111f0 },
1853 			{ }
1854 		}
1855 	},
1856 };
1857 
1858 static const struct snd_pci_quirk alc260_fixup_tbl[] = {
1859 	SND_PCI_QUIRK(0x1025, 0x007b, "Acer C20x", ALC260_FIXUP_GPIO1),
1860 	SND_PCI_QUIRK(0x1025, 0x007f, "Acer Aspire 9500", ALC260_FIXUP_COEF),
1861 	SND_PCI_QUIRK(0x1025, 0x008f, "Acer", ALC260_FIXUP_GPIO1),
1862 	SND_PCI_QUIRK(0x103c, 0x280a, "HP dc5750", ALC260_FIXUP_HP_DC5750),
1863 	SND_PCI_QUIRK(0x103c, 0x30ba, "HP Presario B1900", ALC260_FIXUP_HP_B1900),
1864 	SND_PCI_QUIRK(0x104d, 0x81bb, "Sony VAIO", ALC260_FIXUP_VAIO_PINS),
1865 	SND_PCI_QUIRK(0x104d, 0x81e2, "Sony VAIO TX", ALC260_FIXUP_HP_PIN_0F),
1866 	SND_PCI_QUIRK(0x10cf, 0x1326, "FSC LifeBook S7020", ALC260_FIXUP_FSC_S7020),
1867 	SND_PCI_QUIRK(0x1509, 0x4540, "Favorit 100XS", ALC260_FIXUP_GPIO1),
1868 	SND_PCI_QUIRK(0x152d, 0x0729, "Quanta KN1", ALC260_FIXUP_KN1),
1869 	SND_PCI_QUIRK(0x161f, 0x2057, "Replacer 672V", ALC260_FIXUP_REPLACER),
1870 	SND_PCI_QUIRK(0x1631, 0xc017, "PB V7900", ALC260_FIXUP_COEF),
1871 	{}
1872 };
1873 
1874 static const struct hda_model_fixup alc260_fixup_models[] = {
1875 	{.id = ALC260_FIXUP_GPIO1, .name = "gpio1"},
1876 	{.id = ALC260_FIXUP_COEF, .name = "coef"},
1877 	{.id = ALC260_FIXUP_FSC_S7020, .name = "fujitsu"},
1878 	{.id = ALC260_FIXUP_FSC_S7020_JWSE, .name = "fujitsu-jwse"},
1879 	{}
1880 };
1881 
1882 /*
1883  */
1884 static int patch_alc260(struct hda_codec *codec)
1885 {
1886 	struct alc_spec *spec;
1887 	int err;
1888 
1889 	err = alc_alloc_spec(codec, 0x07);
1890 	if (err < 0)
1891 		return err;
1892 
1893 	spec = codec->spec;
1894 	/* as quite a few machines require HP amp for speaker outputs,
1895 	 * it's easier to enable it unconditionally; even if it's unneeded,
1896 	 * it's almost harmless.
1897 	 */
1898 	spec->gen.prefer_hp_amp = 1;
1899 	spec->gen.beep_nid = 0x01;
1900 
1901 	spec->shutup = alc_eapd_shutup;
1902 
1903 	alc_pre_init(codec);
1904 
1905 	snd_hda_pick_fixup(codec, alc260_fixup_models, alc260_fixup_tbl,
1906 			   alc260_fixups);
1907 	snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE);
1908 
1909 	/* automatic parse from the BIOS config */
1910 	err = alc260_parse_auto_config(codec);
1911 	if (err < 0)
1912 		goto error;
1913 
1914 	if (!spec->gen.no_analog) {
1915 		err = set_beep_amp(spec, 0x07, 0x05, HDA_INPUT);
1916 		if (err < 0)
1917 			goto error;
1918 	}
1919 
1920 	snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE);
1921 
1922 	return 0;
1923 
1924  error:
1925 	alc_free(codec);
1926 	return err;
1927 }
1928 
1929 
1930 /*
1931  * ALC882/883/885/888/889 support
1932  *
1933  * ALC882 is almost identical with ALC880 but has cleaner and more flexible
1934  * configuration.  Each pin widget can choose any input DACs and a mixer.
1935  * Each ADC is connected from a mixer of all inputs.  This makes possible
1936  * 6-channel independent captures.
1937  *
1938  * In addition, an independent DAC for the multi-playback (not used in this
1939  * driver yet).
1940  */
1941 
1942 /*
1943  * Pin config fixes
1944  */
1945 enum {
1946 	ALC882_FIXUP_ABIT_AW9D_MAX,
1947 	ALC882_FIXUP_LENOVO_Y530,
1948 	ALC882_FIXUP_PB_M5210,
1949 	ALC882_FIXUP_ACER_ASPIRE_7736,
1950 	ALC882_FIXUP_ASUS_W90V,
1951 	ALC889_FIXUP_CD,
1952 	ALC889_FIXUP_FRONT_HP_NO_PRESENCE,
1953 	ALC889_FIXUP_VAIO_TT,
1954 	ALC888_FIXUP_EEE1601,
1955 	ALC886_FIXUP_EAPD,
1956 	ALC882_FIXUP_EAPD,
1957 	ALC883_FIXUP_EAPD,
1958 	ALC883_FIXUP_ACER_EAPD,
1959 	ALC882_FIXUP_GPIO1,
1960 	ALC882_FIXUP_GPIO2,
1961 	ALC882_FIXUP_GPIO3,
1962 	ALC889_FIXUP_COEF,
1963 	ALC882_FIXUP_ASUS_W2JC,
1964 	ALC882_FIXUP_ACER_ASPIRE_4930G,
1965 	ALC882_FIXUP_ACER_ASPIRE_8930G,
1966 	ALC882_FIXUP_ASPIRE_8930G_VERBS,
1967 	ALC885_FIXUP_MACPRO_GPIO,
1968 	ALC889_FIXUP_DAC_ROUTE,
1969 	ALC889_FIXUP_MBP_VREF,
1970 	ALC889_FIXUP_IMAC91_VREF,
1971 	ALC889_FIXUP_MBA11_VREF,
1972 	ALC889_FIXUP_MBA21_VREF,
1973 	ALC889_FIXUP_MP11_VREF,
1974 	ALC889_FIXUP_MP41_VREF,
1975 	ALC882_FIXUP_INV_DMIC,
1976 	ALC882_FIXUP_NO_PRIMARY_HP,
1977 	ALC887_FIXUP_ASUS_BASS,
1978 	ALC887_FIXUP_BASS_CHMAP,
1979 	ALC1220_FIXUP_GB_DUAL_CODECS,
1980 	ALC1220_FIXUP_GB_X570,
1981 	ALC1220_FIXUP_CLEVO_P950,
1982 	ALC1220_FIXUP_CLEVO_PB51ED,
1983 	ALC1220_FIXUP_CLEVO_PB51ED_PINS,
1984 	ALC887_FIXUP_ASUS_AUDIO,
1985 	ALC887_FIXUP_ASUS_HMIC,
1986 	ALCS1200A_FIXUP_MIC_VREF,
1987 	ALC888VD_FIXUP_MIC_100VREF,
1988 };
1989 
1990 static void alc889_fixup_coef(struct hda_codec *codec,
1991 			      const struct hda_fixup *fix, int action)
1992 {
1993 	if (action != HDA_FIXUP_ACT_INIT)
1994 		return;
1995 	alc_update_coef_idx(codec, 7, 0, 0x2030);
1996 }
1997 
1998 /* set up GPIO at initialization */
1999 static void alc885_fixup_macpro_gpio(struct hda_codec *codec,
2000 				     const struct hda_fixup *fix, int action)
2001 {
2002 	struct alc_spec *spec = codec->spec;
2003 
2004 	spec->gpio_write_delay = true;
2005 	alc_fixup_gpio3(codec, fix, action);
2006 }
2007 
2008 /* Fix the connection of some pins for ALC889:
2009  * At least, Acer Aspire 5935 shows the connections to DAC3/4 don't
2010  * work correctly (bko#42740)
2011  */
2012 static void alc889_fixup_dac_route(struct hda_codec *codec,
2013 				   const struct hda_fixup *fix, int action)
2014 {
2015 	if (action == HDA_FIXUP_ACT_PRE_PROBE) {
2016 		/* fake the connections during parsing the tree */
2017 		static const hda_nid_t conn1[] = { 0x0c, 0x0d };
2018 		static const hda_nid_t conn2[] = { 0x0e, 0x0f };
2019 		snd_hda_override_conn_list(codec, 0x14, ARRAY_SIZE(conn1), conn1);
2020 		snd_hda_override_conn_list(codec, 0x15, ARRAY_SIZE(conn1), conn1);
2021 		snd_hda_override_conn_list(codec, 0x18, ARRAY_SIZE(conn2), conn2);
2022 		snd_hda_override_conn_list(codec, 0x1a, ARRAY_SIZE(conn2), conn2);
2023 	} else if (action == HDA_FIXUP_ACT_PROBE) {
2024 		/* restore the connections */
2025 		static const hda_nid_t conn[] = { 0x0c, 0x0d, 0x0e, 0x0f, 0x26 };
2026 		snd_hda_override_conn_list(codec, 0x14, ARRAY_SIZE(conn), conn);
2027 		snd_hda_override_conn_list(codec, 0x15, ARRAY_SIZE(conn), conn);
2028 		snd_hda_override_conn_list(codec, 0x18, ARRAY_SIZE(conn), conn);
2029 		snd_hda_override_conn_list(codec, 0x1a, ARRAY_SIZE(conn), conn);
2030 	}
2031 }
2032 
2033 /* Set VREF on HP pin */
2034 static void alc889_fixup_mbp_vref(struct hda_codec *codec,
2035 				  const struct hda_fixup *fix, int action)
2036 {
2037 	static const hda_nid_t nids[] = { 0x14, 0x15, 0x19 };
2038 	struct alc_spec *spec = codec->spec;
2039 	int i;
2040 
2041 	if (action != HDA_FIXUP_ACT_INIT)
2042 		return;
2043 	for (i = 0; i < ARRAY_SIZE(nids); i++) {
2044 		unsigned int val = snd_hda_codec_get_pincfg(codec, nids[i]);
2045 		if (get_defcfg_device(val) != AC_JACK_HP_OUT)
2046 			continue;
2047 		val = snd_hda_codec_get_pin_target(codec, nids[i]);
2048 		val |= AC_PINCTL_VREF_80;
2049 		snd_hda_set_pin_ctl(codec, nids[i], val);
2050 		spec->gen.keep_vref_in_automute = 1;
2051 		break;
2052 	}
2053 }
2054 
2055 static void alc889_fixup_mac_pins(struct hda_codec *codec,
2056 				  const hda_nid_t *nids, int num_nids)
2057 {
2058 	struct alc_spec *spec = codec->spec;
2059 	int i;
2060 
2061 	for (i = 0; i < num_nids; i++) {
2062 		unsigned int val;
2063 		val = snd_hda_codec_get_pin_target(codec, nids[i]);
2064 		val |= AC_PINCTL_VREF_50;
2065 		snd_hda_set_pin_ctl(codec, nids[i], val);
2066 	}
2067 	spec->gen.keep_vref_in_automute = 1;
2068 }
2069 
2070 /* Set VREF on speaker pins on imac91 */
2071 static void alc889_fixup_imac91_vref(struct hda_codec *codec,
2072 				     const struct hda_fixup *fix, int action)
2073 {
2074 	static const hda_nid_t nids[] = { 0x18, 0x1a };
2075 
2076 	if (action == HDA_FIXUP_ACT_INIT)
2077 		alc889_fixup_mac_pins(codec, nids, ARRAY_SIZE(nids));
2078 }
2079 
2080 /* Set VREF on speaker pins on mba11 */
2081 static void alc889_fixup_mba11_vref(struct hda_codec *codec,
2082 				    const struct hda_fixup *fix, int action)
2083 {
2084 	static const hda_nid_t nids[] = { 0x18 };
2085 
2086 	if (action == HDA_FIXUP_ACT_INIT)
2087 		alc889_fixup_mac_pins(codec, nids, ARRAY_SIZE(nids));
2088 }
2089 
2090 /* Set VREF on speaker pins on mba21 */
2091 static void alc889_fixup_mba21_vref(struct hda_codec *codec,
2092 				    const struct hda_fixup *fix, int action)
2093 {
2094 	static const hda_nid_t nids[] = { 0x18, 0x19 };
2095 
2096 	if (action == HDA_FIXUP_ACT_INIT)
2097 		alc889_fixup_mac_pins(codec, nids, ARRAY_SIZE(nids));
2098 }
2099 
2100 /* Don't take HP output as primary
2101  * Strangely, the speaker output doesn't work on Vaio Z and some Vaio
2102  * all-in-one desktop PCs (for example VGC-LN51JGB) through DAC 0x05
2103  */
2104 static void alc882_fixup_no_primary_hp(struct hda_codec *codec,
2105 				       const struct hda_fixup *fix, int action)
2106 {
2107 	struct alc_spec *spec = codec->spec;
2108 	if (action == HDA_FIXUP_ACT_PRE_PROBE) {
2109 		spec->gen.no_primary_hp = 1;
2110 		spec->gen.no_multi_io = 1;
2111 	}
2112 }
2113 
2114 static void alc_fixup_bass_chmap(struct hda_codec *codec,
2115 				 const struct hda_fixup *fix, int action);
2116 
2117 /* For dual-codec configuration, we need to disable some features to avoid
2118  * conflicts of kctls and PCM streams
2119  */
2120 static void alc_fixup_dual_codecs(struct hda_codec *codec,
2121 				  const struct hda_fixup *fix, int action)
2122 {
2123 	struct alc_spec *spec = codec->spec;
2124 
2125 	if (action != HDA_FIXUP_ACT_PRE_PROBE)
2126 		return;
2127 	/* disable vmaster */
2128 	spec->gen.suppress_vmaster = 1;
2129 	/* auto-mute and auto-mic switch don't work with multiple codecs */
2130 	spec->gen.suppress_auto_mute = 1;
2131 	spec->gen.suppress_auto_mic = 1;
2132 	/* disable aamix as well */
2133 	spec->gen.mixer_nid = 0;
2134 	/* add location prefix to avoid conflicts */
2135 	codec->force_pin_prefix = 1;
2136 }
2137 
2138 static void rename_ctl(struct hda_codec *codec, const char *oldname,
2139 		       const char *newname)
2140 {
2141 	struct snd_kcontrol *kctl;
2142 
2143 	kctl = snd_hda_find_mixer_ctl(codec, oldname);
2144 	if (kctl)
2145 		snd_ctl_rename(codec->card, kctl, newname);
2146 }
2147 
2148 static void alc1220_fixup_gb_dual_codecs(struct hda_codec *codec,
2149 					 const struct hda_fixup *fix,
2150 					 int action)
2151 {
2152 	alc_fixup_dual_codecs(codec, fix, action);
2153 	switch (action) {
2154 	case HDA_FIXUP_ACT_PRE_PROBE:
2155 		/* override card longname to provide a unique UCM profile */
2156 		strcpy(codec->card->longname, "HDAudio-Gigabyte-ALC1220DualCodecs");
2157 		break;
2158 	case HDA_FIXUP_ACT_BUILD:
2159 		/* rename Capture controls depending on the codec */
2160 		rename_ctl(codec, "Capture Volume",
2161 			   codec->addr == 0 ?
2162 			   "Rear-Panel Capture Volume" :
2163 			   "Front-Panel Capture Volume");
2164 		rename_ctl(codec, "Capture Switch",
2165 			   codec->addr == 0 ?
2166 			   "Rear-Panel Capture Switch" :
2167 			   "Front-Panel Capture Switch");
2168 		break;
2169 	}
2170 }
2171 
2172 static void alc1220_fixup_gb_x570(struct hda_codec *codec,
2173 				     const struct hda_fixup *fix,
2174 				     int action)
2175 {
2176 	static const hda_nid_t conn1[] = { 0x0c };
2177 	static const struct coef_fw gb_x570_coefs[] = {
2178 		WRITE_COEF(0x07, 0x03c0),
2179 		WRITE_COEF(0x1a, 0x01c1),
2180 		WRITE_COEF(0x1b, 0x0202),
2181 		WRITE_COEF(0x43, 0x3005),
2182 		{}
2183 	};
2184 
2185 	switch (action) {
2186 	case HDA_FIXUP_ACT_PRE_PROBE:
2187 		snd_hda_override_conn_list(codec, 0x14, ARRAY_SIZE(conn1), conn1);
2188 		snd_hda_override_conn_list(codec, 0x1b, ARRAY_SIZE(conn1), conn1);
2189 		break;
2190 	case HDA_FIXUP_ACT_INIT:
2191 		alc_process_coef_fw(codec, gb_x570_coefs);
2192 		break;
2193 	}
2194 }
2195 
2196 static void alc1220_fixup_clevo_p950(struct hda_codec *codec,
2197 				     const struct hda_fixup *fix,
2198 				     int action)
2199 {
2200 	static const hda_nid_t conn1[] = { 0x0c };
2201 
2202 	if (action != HDA_FIXUP_ACT_PRE_PROBE)
2203 		return;
2204 
2205 	alc_update_coef_idx(codec, 0x7, 0, 0x3c3);
2206 	/* We therefore want to make sure 0x14 (front headphone) and
2207 	 * 0x1b (speakers) use the stereo DAC 0x02
2208 	 */
2209 	snd_hda_override_conn_list(codec, 0x14, ARRAY_SIZE(conn1), conn1);
2210 	snd_hda_override_conn_list(codec, 0x1b, ARRAY_SIZE(conn1), conn1);
2211 }
2212 
2213 static void alc_fixup_headset_mode_no_hp_mic(struct hda_codec *codec,
2214 				const struct hda_fixup *fix, int action);
2215 
2216 static void alc1220_fixup_clevo_pb51ed(struct hda_codec *codec,
2217 				     const struct hda_fixup *fix,
2218 				     int action)
2219 {
2220 	alc1220_fixup_clevo_p950(codec, fix, action);
2221 	alc_fixup_headset_mode_no_hp_mic(codec, fix, action);
2222 }
2223 
2224 static void alc887_asus_hp_automute_hook(struct hda_codec *codec,
2225 					 struct hda_jack_callback *jack)
2226 {
2227 	struct alc_spec *spec = codec->spec;
2228 	unsigned int vref;
2229 
2230 	snd_hda_gen_hp_automute(codec, jack);
2231 
2232 	if (spec->gen.hp_jack_present)
2233 		vref = AC_PINCTL_VREF_80;
2234 	else
2235 		vref = AC_PINCTL_VREF_HIZ;
2236 	snd_hda_set_pin_ctl(codec, 0x19, PIN_HP | vref);
2237 }
2238 
2239 static void alc887_fixup_asus_jack(struct hda_codec *codec,
2240 				     const struct hda_fixup *fix, int action)
2241 {
2242 	struct alc_spec *spec = codec->spec;
2243 	if (action != HDA_FIXUP_ACT_PROBE)
2244 		return;
2245 	snd_hda_set_pin_ctl_cache(codec, 0x1b, PIN_HP);
2246 	spec->gen.hp_automute_hook = alc887_asus_hp_automute_hook;
2247 }
2248 
2249 static const struct hda_fixup alc882_fixups[] = {
2250 	[ALC882_FIXUP_ABIT_AW9D_MAX] = {
2251 		.type = HDA_FIXUP_PINS,
2252 		.v.pins = (const struct hda_pintbl[]) {
2253 			{ 0x15, 0x01080104 }, /* side */
2254 			{ 0x16, 0x01011012 }, /* rear */
2255 			{ 0x17, 0x01016011 }, /* clfe */
2256 			{ }
2257 		}
2258 	},
2259 	[ALC882_FIXUP_LENOVO_Y530] = {
2260 		.type = HDA_FIXUP_PINS,
2261 		.v.pins = (const struct hda_pintbl[]) {
2262 			{ 0x15, 0x99130112 }, /* rear int speakers */
2263 			{ 0x16, 0x99130111 }, /* subwoofer */
2264 			{ }
2265 		}
2266 	},
2267 	[ALC882_FIXUP_PB_M5210] = {
2268 		.type = HDA_FIXUP_PINCTLS,
2269 		.v.pins = (const struct hda_pintbl[]) {
2270 			{ 0x19, PIN_VREF50 },
2271 			{}
2272 		}
2273 	},
2274 	[ALC882_FIXUP_ACER_ASPIRE_7736] = {
2275 		.type = HDA_FIXUP_FUNC,
2276 		.v.func = alc_fixup_sku_ignore,
2277 	},
2278 	[ALC882_FIXUP_ASUS_W90V] = {
2279 		.type = HDA_FIXUP_PINS,
2280 		.v.pins = (const struct hda_pintbl[]) {
2281 			{ 0x16, 0x99130110 }, /* fix sequence for CLFE */
2282 			{ }
2283 		}
2284 	},
2285 	[ALC889_FIXUP_CD] = {
2286 		.type = HDA_FIXUP_PINS,
2287 		.v.pins = (const struct hda_pintbl[]) {
2288 			{ 0x1c, 0x993301f0 }, /* CD */
2289 			{ }
2290 		}
2291 	},
2292 	[ALC889_FIXUP_FRONT_HP_NO_PRESENCE] = {
2293 		.type = HDA_FIXUP_PINS,
2294 		.v.pins = (const struct hda_pintbl[]) {
2295 			{ 0x1b, 0x02214120 }, /* Front HP jack is flaky, disable jack detect */
2296 			{ }
2297 		},
2298 		.chained = true,
2299 		.chain_id = ALC889_FIXUP_CD,
2300 	},
2301 	[ALC889_FIXUP_VAIO_TT] = {
2302 		.type = HDA_FIXUP_PINS,
2303 		.v.pins = (const struct hda_pintbl[]) {
2304 			{ 0x17, 0x90170111 }, /* hidden surround speaker */
2305 			{ }
2306 		}
2307 	},
2308 	[ALC888_FIXUP_EEE1601] = {
2309 		.type = HDA_FIXUP_VERBS,
2310 		.v.verbs = (const struct hda_verb[]) {
2311 			{ 0x20, AC_VERB_SET_COEF_INDEX, 0x0b },
2312 			{ 0x20, AC_VERB_SET_PROC_COEF,  0x0838 },
2313 			{ }
2314 		}
2315 	},
2316 	[ALC886_FIXUP_EAPD] = {
2317 		.type = HDA_FIXUP_VERBS,
2318 		.v.verbs = (const struct hda_verb[]) {
2319 			/* change to EAPD mode */
2320 			{ 0x20, AC_VERB_SET_COEF_INDEX, 0x07 },
2321 			{ 0x20, AC_VERB_SET_PROC_COEF, 0x0068 },
2322 			{ }
2323 		}
2324 	},
2325 	[ALC882_FIXUP_EAPD] = {
2326 		.type = HDA_FIXUP_VERBS,
2327 		.v.verbs = (const struct hda_verb[]) {
2328 			/* change to EAPD mode */
2329 			{ 0x20, AC_VERB_SET_COEF_INDEX, 0x07 },
2330 			{ 0x20, AC_VERB_SET_PROC_COEF, 0x3060 },
2331 			{ }
2332 		}
2333 	},
2334 	[ALC883_FIXUP_EAPD] = {
2335 		.type = HDA_FIXUP_VERBS,
2336 		.v.verbs = (const struct hda_verb[]) {
2337 			/* change to EAPD mode */
2338 			{ 0x20, AC_VERB_SET_COEF_INDEX, 0x07 },
2339 			{ 0x20, AC_VERB_SET_PROC_COEF, 0x3070 },
2340 			{ }
2341 		}
2342 	},
2343 	[ALC883_FIXUP_ACER_EAPD] = {
2344 		.type = HDA_FIXUP_VERBS,
2345 		.v.verbs = (const struct hda_verb[]) {
2346 			/* eanable EAPD on Acer laptops */
2347 			{ 0x20, AC_VERB_SET_COEF_INDEX, 0x07 },
2348 			{ 0x20, AC_VERB_SET_PROC_COEF, 0x3050 },
2349 			{ }
2350 		}
2351 	},
2352 	[ALC882_FIXUP_GPIO1] = {
2353 		.type = HDA_FIXUP_FUNC,
2354 		.v.func = alc_fixup_gpio1,
2355 	},
2356 	[ALC882_FIXUP_GPIO2] = {
2357 		.type = HDA_FIXUP_FUNC,
2358 		.v.func = alc_fixup_gpio2,
2359 	},
2360 	[ALC882_FIXUP_GPIO3] = {
2361 		.type = HDA_FIXUP_FUNC,
2362 		.v.func = alc_fixup_gpio3,
2363 	},
2364 	[ALC882_FIXUP_ASUS_W2JC] = {
2365 		.type = HDA_FIXUP_FUNC,
2366 		.v.func = alc_fixup_gpio1,
2367 		.chained = true,
2368 		.chain_id = ALC882_FIXUP_EAPD,
2369 	},
2370 	[ALC889_FIXUP_COEF] = {
2371 		.type = HDA_FIXUP_FUNC,
2372 		.v.func = alc889_fixup_coef,
2373 	},
2374 	[ALC882_FIXUP_ACER_ASPIRE_4930G] = {
2375 		.type = HDA_FIXUP_PINS,
2376 		.v.pins = (const struct hda_pintbl[]) {
2377 			{ 0x16, 0x99130111 }, /* CLFE speaker */
2378 			{ 0x17, 0x99130112 }, /* surround speaker */
2379 			{ }
2380 		},
2381 		.chained = true,
2382 		.chain_id = ALC882_FIXUP_GPIO1,
2383 	},
2384 	[ALC882_FIXUP_ACER_ASPIRE_8930G] = {
2385 		.type = HDA_FIXUP_PINS,
2386 		.v.pins = (const struct hda_pintbl[]) {
2387 			{ 0x16, 0x99130111 }, /* CLFE speaker */
2388 			{ 0x1b, 0x99130112 }, /* surround speaker */
2389 			{ }
2390 		},
2391 		.chained = true,
2392 		.chain_id = ALC882_FIXUP_ASPIRE_8930G_VERBS,
2393 	},
2394 	[ALC882_FIXUP_ASPIRE_8930G_VERBS] = {
2395 		/* additional init verbs for Acer Aspire 8930G */
2396 		.type = HDA_FIXUP_VERBS,
2397 		.v.verbs = (const struct hda_verb[]) {
2398 			/* Enable all DACs */
2399 			/* DAC DISABLE/MUTE 1? */
2400 			/*  setting bits 1-5 disables DAC nids 0x02-0x06
2401 			 *  apparently. Init=0x38 */
2402 			{ 0x20, AC_VERB_SET_COEF_INDEX, 0x03 },
2403 			{ 0x20, AC_VERB_SET_PROC_COEF, 0x0000 },
2404 			/* DAC DISABLE/MUTE 2? */
2405 			/*  some bit here disables the other DACs.
2406 			 *  Init=0x4900 */
2407 			{ 0x20, AC_VERB_SET_COEF_INDEX, 0x08 },
2408 			{ 0x20, AC_VERB_SET_PROC_COEF, 0x0000 },
2409 			/* DMIC fix
2410 			 * This laptop has a stereo digital microphone.
2411 			 * The mics are only 1cm apart which makes the stereo
2412 			 * useless. However, either the mic or the ALC889
2413 			 * makes the signal become a difference/sum signal
2414 			 * instead of standard stereo, which is annoying.
2415 			 * So instead we flip this bit which makes the
2416 			 * codec replicate the sum signal to both channels,
2417 			 * turning it into a normal mono mic.
2418 			 */
2419 			/* DMIC_CONTROL? Init value = 0x0001 */
2420 			{ 0x20, AC_VERB_SET_COEF_INDEX, 0x0b },
2421 			{ 0x20, AC_VERB_SET_PROC_COEF, 0x0003 },
2422 			{ 0x20, AC_VERB_SET_COEF_INDEX, 0x07 },
2423 			{ 0x20, AC_VERB_SET_PROC_COEF, 0x3050 },
2424 			{ }
2425 		},
2426 		.chained = true,
2427 		.chain_id = ALC882_FIXUP_GPIO1,
2428 	},
2429 	[ALC885_FIXUP_MACPRO_GPIO] = {
2430 		.type = HDA_FIXUP_FUNC,
2431 		.v.func = alc885_fixup_macpro_gpio,
2432 	},
2433 	[ALC889_FIXUP_DAC_ROUTE] = {
2434 		.type = HDA_FIXUP_FUNC,
2435 		.v.func = alc889_fixup_dac_route,
2436 	},
2437 	[ALC889_FIXUP_MBP_VREF] = {
2438 		.type = HDA_FIXUP_FUNC,
2439 		.v.func = alc889_fixup_mbp_vref,
2440 		.chained = true,
2441 		.chain_id = ALC882_FIXUP_GPIO1,
2442 	},
2443 	[ALC889_FIXUP_IMAC91_VREF] = {
2444 		.type = HDA_FIXUP_FUNC,
2445 		.v.func = alc889_fixup_imac91_vref,
2446 		.chained = true,
2447 		.chain_id = ALC882_FIXUP_GPIO1,
2448 	},
2449 	[ALC889_FIXUP_MBA11_VREF] = {
2450 		.type = HDA_FIXUP_FUNC,
2451 		.v.func = alc889_fixup_mba11_vref,
2452 		.chained = true,
2453 		.chain_id = ALC889_FIXUP_MBP_VREF,
2454 	},
2455 	[ALC889_FIXUP_MBA21_VREF] = {
2456 		.type = HDA_FIXUP_FUNC,
2457 		.v.func = alc889_fixup_mba21_vref,
2458 		.chained = true,
2459 		.chain_id = ALC889_FIXUP_MBP_VREF,
2460 	},
2461 	[ALC889_FIXUP_MP11_VREF] = {
2462 		.type = HDA_FIXUP_FUNC,
2463 		.v.func = alc889_fixup_mba11_vref,
2464 		.chained = true,
2465 		.chain_id = ALC885_FIXUP_MACPRO_GPIO,
2466 	},
2467 	[ALC889_FIXUP_MP41_VREF] = {
2468 		.type = HDA_FIXUP_FUNC,
2469 		.v.func = alc889_fixup_mbp_vref,
2470 		.chained = true,
2471 		.chain_id = ALC885_FIXUP_MACPRO_GPIO,
2472 	},
2473 	[ALC882_FIXUP_INV_DMIC] = {
2474 		.type = HDA_FIXUP_FUNC,
2475 		.v.func = alc_fixup_inv_dmic,
2476 	},
2477 	[ALC882_FIXUP_NO_PRIMARY_HP] = {
2478 		.type = HDA_FIXUP_FUNC,
2479 		.v.func = alc882_fixup_no_primary_hp,
2480 	},
2481 	[ALC887_FIXUP_ASUS_BASS] = {
2482 		.type = HDA_FIXUP_PINS,
2483 		.v.pins = (const struct hda_pintbl[]) {
2484 			{0x16, 0x99130130}, /* bass speaker */
2485 			{}
2486 		},
2487 		.chained = true,
2488 		.chain_id = ALC887_FIXUP_BASS_CHMAP,
2489 	},
2490 	[ALC887_FIXUP_BASS_CHMAP] = {
2491 		.type = HDA_FIXUP_FUNC,
2492 		.v.func = alc_fixup_bass_chmap,
2493 	},
2494 	[ALC1220_FIXUP_GB_DUAL_CODECS] = {
2495 		.type = HDA_FIXUP_FUNC,
2496 		.v.func = alc1220_fixup_gb_dual_codecs,
2497 	},
2498 	[ALC1220_FIXUP_GB_X570] = {
2499 		.type = HDA_FIXUP_FUNC,
2500 		.v.func = alc1220_fixup_gb_x570,
2501 	},
2502 	[ALC1220_FIXUP_CLEVO_P950] = {
2503 		.type = HDA_FIXUP_FUNC,
2504 		.v.func = alc1220_fixup_clevo_p950,
2505 	},
2506 	[ALC1220_FIXUP_CLEVO_PB51ED] = {
2507 		.type = HDA_FIXUP_FUNC,
2508 		.v.func = alc1220_fixup_clevo_pb51ed,
2509 	},
2510 	[ALC1220_FIXUP_CLEVO_PB51ED_PINS] = {
2511 		.type = HDA_FIXUP_PINS,
2512 		.v.pins = (const struct hda_pintbl[]) {
2513 			{ 0x19, 0x01a1913c }, /* use as headset mic, without its own jack detect */
2514 			{}
2515 		},
2516 		.chained = true,
2517 		.chain_id = ALC1220_FIXUP_CLEVO_PB51ED,
2518 	},
2519 	[ALC887_FIXUP_ASUS_AUDIO] = {
2520 		.type = HDA_FIXUP_PINS,
2521 		.v.pins = (const struct hda_pintbl[]) {
2522 			{ 0x15, 0x02a14150 }, /* use as headset mic, without its own jack detect */
2523 			{ 0x19, 0x22219420 },
2524 			{}
2525 		},
2526 	},
2527 	[ALC887_FIXUP_ASUS_HMIC] = {
2528 		.type = HDA_FIXUP_FUNC,
2529 		.v.func = alc887_fixup_asus_jack,
2530 		.chained = true,
2531 		.chain_id = ALC887_FIXUP_ASUS_AUDIO,
2532 	},
2533 	[ALCS1200A_FIXUP_MIC_VREF] = {
2534 		.type = HDA_FIXUP_PINCTLS,
2535 		.v.pins = (const struct hda_pintbl[]) {
2536 			{ 0x18, PIN_VREF50 }, /* rear mic */
2537 			{ 0x19, PIN_VREF50 }, /* front mic */
2538 			{}
2539 		}
2540 	},
2541 	[ALC888VD_FIXUP_MIC_100VREF] = {
2542 		.type = HDA_FIXUP_PINCTLS,
2543 		.v.pins = (const struct hda_pintbl[]) {
2544 			{ 0x18, PIN_VREF100 }, /* headset mic */
2545 			{}
2546 		}
2547 	},
2548 };
2549 
2550 static const struct snd_pci_quirk alc882_fixup_tbl[] = {
2551 	SND_PCI_QUIRK(0x1025, 0x006c, "Acer Aspire 9810", ALC883_FIXUP_ACER_EAPD),
2552 	SND_PCI_QUIRK(0x1025, 0x0090, "Acer Aspire", ALC883_FIXUP_ACER_EAPD),
2553 	SND_PCI_QUIRK(0x1025, 0x0107, "Acer Aspire", ALC883_FIXUP_ACER_EAPD),
2554 	SND_PCI_QUIRK(0x1025, 0x010a, "Acer Ferrari 5000", ALC883_FIXUP_ACER_EAPD),
2555 	SND_PCI_QUIRK(0x1025, 0x0110, "Acer Aspire", ALC883_FIXUP_ACER_EAPD),
2556 	SND_PCI_QUIRK(0x1025, 0x0112, "Acer Aspire 9303", ALC883_FIXUP_ACER_EAPD),
2557 	SND_PCI_QUIRK(0x1025, 0x0121, "Acer Aspire 5920G", ALC883_FIXUP_ACER_EAPD),
2558 	SND_PCI_QUIRK(0x1025, 0x013e, "Acer Aspire 4930G",
2559 		      ALC882_FIXUP_ACER_ASPIRE_4930G),
2560 	SND_PCI_QUIRK(0x1025, 0x013f, "Acer Aspire 5930G",
2561 		      ALC882_FIXUP_ACER_ASPIRE_4930G),
2562 	SND_PCI_QUIRK(0x1025, 0x0145, "Acer Aspire 8930G",
2563 		      ALC882_FIXUP_ACER_ASPIRE_8930G),
2564 	SND_PCI_QUIRK(0x1025, 0x0146, "Acer Aspire 6935G",
2565 		      ALC882_FIXUP_ACER_ASPIRE_8930G),
2566 	SND_PCI_QUIRK(0x1025, 0x0142, "Acer Aspire 7730G",
2567 		      ALC882_FIXUP_ACER_ASPIRE_4930G),
2568 	SND_PCI_QUIRK(0x1025, 0x0155, "Packard-Bell M5120", ALC882_FIXUP_PB_M5210),
2569 	SND_PCI_QUIRK(0x1025, 0x015e, "Acer Aspire 6930G",
2570 		      ALC882_FIXUP_ACER_ASPIRE_4930G),
2571 	SND_PCI_QUIRK(0x1025, 0x0166, "Acer Aspire 6530G",
2572 		      ALC882_FIXUP_ACER_ASPIRE_4930G),
2573 	SND_PCI_QUIRK(0x1025, 0x021e, "Acer Aspire 5739G",
2574 		      ALC882_FIXUP_ACER_ASPIRE_4930G),
2575 	SND_PCI_QUIRK(0x1025, 0x0259, "Acer Aspire 5935", ALC889_FIXUP_DAC_ROUTE),
2576 	SND_PCI_QUIRK(0x1025, 0x026b, "Acer Aspire 8940G", ALC882_FIXUP_ACER_ASPIRE_8930G),
2577 	SND_PCI_QUIRK(0x1025, 0x0296, "Acer Aspire 7736z", ALC882_FIXUP_ACER_ASPIRE_7736),
2578 	SND_PCI_QUIRK(0x1043, 0x13c2, "Asus A7M", ALC882_FIXUP_EAPD),
2579 	SND_PCI_QUIRK(0x1043, 0x1873, "ASUS W90V", ALC882_FIXUP_ASUS_W90V),
2580 	SND_PCI_QUIRK(0x1043, 0x1971, "Asus W2JC", ALC882_FIXUP_ASUS_W2JC),
2581 	SND_PCI_QUIRK(0x1043, 0x2390, "Asus D700SA", ALC887_FIXUP_ASUS_HMIC),
2582 	SND_PCI_QUIRK(0x1043, 0x835f, "Asus Eee 1601", ALC888_FIXUP_EEE1601),
2583 	SND_PCI_QUIRK(0x1043, 0x84bc, "ASUS ET2700", ALC887_FIXUP_ASUS_BASS),
2584 	SND_PCI_QUIRK(0x1043, 0x8691, "ASUS ROG Ranger VIII", ALC882_FIXUP_GPIO3),
2585 	SND_PCI_QUIRK(0x1043, 0x8797, "ASUS TUF B550M-PLUS", ALCS1200A_FIXUP_MIC_VREF),
2586 	SND_PCI_QUIRK(0x104d, 0x9043, "Sony Vaio VGC-LN51JGB", ALC882_FIXUP_NO_PRIMARY_HP),
2587 	SND_PCI_QUIRK(0x104d, 0x9044, "Sony VAIO AiO", ALC882_FIXUP_NO_PRIMARY_HP),
2588 	SND_PCI_QUIRK(0x104d, 0x9047, "Sony Vaio TT", ALC889_FIXUP_VAIO_TT),
2589 	SND_PCI_QUIRK(0x104d, 0x905a, "Sony Vaio Z", ALC882_FIXUP_NO_PRIMARY_HP),
2590 	SND_PCI_QUIRK(0x104d, 0x9060, "Sony Vaio VPCL14M1R", ALC882_FIXUP_NO_PRIMARY_HP),
2591 
2592 	/* All Apple entries are in codec SSIDs */
2593 	SND_PCI_QUIRK(0x106b, 0x00a0, "MacBookPro 3,1", ALC889_FIXUP_MBP_VREF),
2594 	SND_PCI_QUIRK(0x106b, 0x00a1, "Macbook", ALC889_FIXUP_MBP_VREF),
2595 	SND_PCI_QUIRK(0x106b, 0x00a4, "MacbookPro 4,1", ALC889_FIXUP_MBP_VREF),
2596 	SND_PCI_QUIRK(0x106b, 0x0c00, "Mac Pro", ALC889_FIXUP_MP11_VREF),
2597 	SND_PCI_QUIRK(0x106b, 0x1000, "iMac 24", ALC885_FIXUP_MACPRO_GPIO),
2598 	SND_PCI_QUIRK(0x106b, 0x2800, "AppleTV", ALC885_FIXUP_MACPRO_GPIO),
2599 	SND_PCI_QUIRK(0x106b, 0x2c00, "MacbookPro rev3", ALC889_FIXUP_MBP_VREF),
2600 	SND_PCI_QUIRK(0x106b, 0x3000, "iMac", ALC889_FIXUP_MBP_VREF),
2601 	SND_PCI_QUIRK(0x106b, 0x3200, "iMac 7,1 Aluminum", ALC882_FIXUP_EAPD),
2602 	SND_PCI_QUIRK(0x106b, 0x3400, "MacBookAir 1,1", ALC889_FIXUP_MBA11_VREF),
2603 	SND_PCI_QUIRK(0x106b, 0x3500, "MacBookAir 2,1", ALC889_FIXUP_MBA21_VREF),
2604 	SND_PCI_QUIRK(0x106b, 0x3600, "Macbook 3,1", ALC889_FIXUP_MBP_VREF),
2605 	SND_PCI_QUIRK(0x106b, 0x3800, "MacbookPro 4,1", ALC889_FIXUP_MBP_VREF),
2606 	SND_PCI_QUIRK(0x106b, 0x3e00, "iMac 24 Aluminum", ALC885_FIXUP_MACPRO_GPIO),
2607 	SND_PCI_QUIRK(0x106b, 0x3f00, "Macbook 5,1", ALC889_FIXUP_IMAC91_VREF),
2608 	SND_PCI_QUIRK(0x106b, 0x4000, "MacbookPro 5,1", ALC889_FIXUP_IMAC91_VREF),
2609 	SND_PCI_QUIRK(0x106b, 0x4100, "Macmini 3,1", ALC889_FIXUP_IMAC91_VREF),
2610 	SND_PCI_QUIRK(0x106b, 0x4200, "Mac Pro 4,1/5,1", ALC889_FIXUP_MP41_VREF),
2611 	SND_PCI_QUIRK(0x106b, 0x4300, "iMac 9,1", ALC889_FIXUP_IMAC91_VREF),
2612 	SND_PCI_QUIRK(0x106b, 0x4600, "MacbookPro 5,2", ALC889_FIXUP_IMAC91_VREF),
2613 	SND_PCI_QUIRK(0x106b, 0x4900, "iMac 9,1 Aluminum", ALC889_FIXUP_IMAC91_VREF),
2614 	SND_PCI_QUIRK(0x106b, 0x4a00, "Macbook 5,2", ALC889_FIXUP_MBA11_VREF),
2615 
2616 	SND_PCI_QUIRK(0x1071, 0x8258, "Evesham Voyaeger", ALC882_FIXUP_EAPD),
2617 	SND_PCI_QUIRK(0x10ec, 0x12d8, "iBase Elo Touch", ALC888VD_FIXUP_MIC_100VREF),
2618 	SND_PCI_QUIRK(0x13fe, 0x1009, "Advantech MIT-W101", ALC886_FIXUP_EAPD),
2619 	SND_PCI_QUIRK(0x1458, 0xa002, "Gigabyte EP45-DS3/Z87X-UD3H", ALC889_FIXUP_FRONT_HP_NO_PRESENCE),
2620 	SND_PCI_QUIRK(0x1458, 0xa0b8, "Gigabyte AZ370-Gaming", ALC1220_FIXUP_GB_DUAL_CODECS),
2621 	SND_PCI_QUIRK(0x1458, 0xa0cd, "Gigabyte X570 Aorus Master", ALC1220_FIXUP_GB_X570),
2622 	SND_PCI_QUIRK(0x1458, 0xa0ce, "Gigabyte X570 Aorus Xtreme", ALC1220_FIXUP_GB_X570),
2623 	SND_PCI_QUIRK(0x1458, 0xa0d5, "Gigabyte X570S Aorus Master", ALC1220_FIXUP_GB_X570),
2624 	SND_PCI_QUIRK(0x1462, 0x11f7, "MSI-GE63", ALC1220_FIXUP_CLEVO_P950),
2625 	SND_PCI_QUIRK(0x1462, 0x1228, "MSI-GP63", ALC1220_FIXUP_CLEVO_P950),
2626 	SND_PCI_QUIRK(0x1462, 0x1229, "MSI-GP73", ALC1220_FIXUP_CLEVO_P950),
2627 	SND_PCI_QUIRK(0x1462, 0x1275, "MSI-GL63", ALC1220_FIXUP_CLEVO_P950),
2628 	SND_PCI_QUIRK(0x1462, 0x1276, "MSI-GL73", ALC1220_FIXUP_CLEVO_P950),
2629 	SND_PCI_QUIRK(0x1462, 0x1293, "MSI-GP65", ALC1220_FIXUP_CLEVO_P950),
2630 	SND_PCI_QUIRK(0x1462, 0x7350, "MSI-7350", ALC889_FIXUP_CD),
2631 	SND_PCI_QUIRK(0x1462, 0xcc34, "MSI Godlike X570", ALC1220_FIXUP_GB_DUAL_CODECS),
2632 	SND_PCI_QUIRK(0x1462, 0xda57, "MSI Z270-Gaming", ALC1220_FIXUP_GB_DUAL_CODECS),
2633 	SND_PCI_QUIRK_VENDOR(0x1462, "MSI", ALC882_FIXUP_GPIO3),
2634 	SND_PCI_QUIRK(0x147b, 0x107a, "Abit AW9D-MAX", ALC882_FIXUP_ABIT_AW9D_MAX),
2635 	SND_PCI_QUIRK(0x1558, 0x3702, "Clevo X370SN[VW]", ALC1220_FIXUP_CLEVO_PB51ED_PINS),
2636 	SND_PCI_QUIRK(0x1558, 0x50d3, "Clevo PC50[ER][CDF]", ALC1220_FIXUP_CLEVO_PB51ED_PINS),
2637 	SND_PCI_QUIRK(0x1558, 0x65d1, "Clevo PB51[ER][CDF]", ALC1220_FIXUP_CLEVO_PB51ED_PINS),
2638 	SND_PCI_QUIRK(0x1558, 0x65d2, "Clevo PB51R[CDF]", ALC1220_FIXUP_CLEVO_PB51ED_PINS),
2639 	SND_PCI_QUIRK(0x1558, 0x65e1, "Clevo PB51[ED][DF]", ALC1220_FIXUP_CLEVO_PB51ED_PINS),
2640 	SND_PCI_QUIRK(0x1558, 0x65e5, "Clevo PC50D[PRS](?:-D|-G)?", ALC1220_FIXUP_CLEVO_PB51ED_PINS),
2641 	SND_PCI_QUIRK(0x1558, 0x65f1, "Clevo PC50HS", ALC1220_FIXUP_CLEVO_PB51ED_PINS),
2642 	SND_PCI_QUIRK(0x1558, 0x65f5, "Clevo PD50PN[NRT]", ALC1220_FIXUP_CLEVO_PB51ED_PINS),
2643 	SND_PCI_QUIRK(0x1558, 0x66a2, "Clevo PE60RNE", ALC1220_FIXUP_CLEVO_PB51ED_PINS),
2644 	SND_PCI_QUIRK(0x1558, 0x66a6, "Clevo PE60SN[CDE]-[GS]", ALC1220_FIXUP_CLEVO_PB51ED_PINS),
2645 	SND_PCI_QUIRK(0x1558, 0x67d1, "Clevo PB71[ER][CDF]", ALC1220_FIXUP_CLEVO_PB51ED_PINS),
2646 	SND_PCI_QUIRK(0x1558, 0x67e1, "Clevo PB71[DE][CDF]", ALC1220_FIXUP_CLEVO_PB51ED_PINS),
2647 	SND_PCI_QUIRK(0x1558, 0x67e5, "Clevo PC70D[PRS](?:-D|-G)?", ALC1220_FIXUP_CLEVO_PB51ED_PINS),
2648 	SND_PCI_QUIRK(0x1558, 0x67f1, "Clevo PC70H[PRS]", ALC1220_FIXUP_CLEVO_PB51ED_PINS),
2649 	SND_PCI_QUIRK(0x1558, 0x67f5, "Clevo PD70PN[NRT]", ALC1220_FIXUP_CLEVO_PB51ED_PINS),
2650 	SND_PCI_QUIRK(0x1558, 0x70d1, "Clevo PC70[ER][CDF]", ALC1220_FIXUP_CLEVO_PB51ED_PINS),
2651 	SND_PCI_QUIRK(0x1558, 0x7714, "Clevo X170SM", ALC1220_FIXUP_CLEVO_PB51ED_PINS),
2652 	SND_PCI_QUIRK(0x1558, 0x7715, "Clevo X170KM-G", ALC1220_FIXUP_CLEVO_PB51ED),
2653 	SND_PCI_QUIRK(0x1558, 0x9501, "Clevo P950HR", ALC1220_FIXUP_CLEVO_P950),
2654 	SND_PCI_QUIRK(0x1558, 0x9506, "Clevo P955HQ", ALC1220_FIXUP_CLEVO_P950),
2655 	SND_PCI_QUIRK(0x1558, 0x950a, "Clevo P955H[PR]", ALC1220_FIXUP_CLEVO_P950),
2656 	SND_PCI_QUIRK(0x1558, 0x95e1, "Clevo P95xER", ALC1220_FIXUP_CLEVO_P950),
2657 	SND_PCI_QUIRK(0x1558, 0x95e2, "Clevo P950ER", ALC1220_FIXUP_CLEVO_P950),
2658 	SND_PCI_QUIRK(0x1558, 0x95e3, "Clevo P955[ER]T", ALC1220_FIXUP_CLEVO_P950),
2659 	SND_PCI_QUIRK(0x1558, 0x95e4, "Clevo P955ER", ALC1220_FIXUP_CLEVO_P950),
2660 	SND_PCI_QUIRK(0x1558, 0x95e5, "Clevo P955EE6", ALC1220_FIXUP_CLEVO_P950),
2661 	SND_PCI_QUIRK(0x1558, 0x95e6, "Clevo P950R[CDF]", ALC1220_FIXUP_CLEVO_P950),
2662 	SND_PCI_QUIRK(0x1558, 0x96e1, "Clevo P960[ER][CDFN]-K", ALC1220_FIXUP_CLEVO_P950),
2663 	SND_PCI_QUIRK(0x1558, 0x97e1, "Clevo P970[ER][CDFN]", ALC1220_FIXUP_CLEVO_P950),
2664 	SND_PCI_QUIRK(0x1558, 0x97e2, "Clevo P970RC-M", ALC1220_FIXUP_CLEVO_P950),
2665 	SND_PCI_QUIRK(0x1558, 0xd502, "Clevo PD50SNE", ALC1220_FIXUP_CLEVO_PB51ED_PINS),
2666 	SND_PCI_QUIRK_VENDOR(0x1558, "Clevo laptop", ALC882_FIXUP_EAPD),
2667 	SND_PCI_QUIRK(0x161f, 0x2054, "Medion laptop", ALC883_FIXUP_EAPD),
2668 	SND_PCI_QUIRK(0x17aa, 0x3a0d, "Lenovo Y530", ALC882_FIXUP_LENOVO_Y530),
2669 	SND_PCI_QUIRK(0x8086, 0x0022, "DX58SO", ALC889_FIXUP_COEF),
2670 	{}
2671 };
2672 
2673 static const struct hda_model_fixup alc882_fixup_models[] = {
2674 	{.id = ALC882_FIXUP_ABIT_AW9D_MAX, .name = "abit-aw9d"},
2675 	{.id = ALC882_FIXUP_LENOVO_Y530, .name = "lenovo-y530"},
2676 	{.id = ALC882_FIXUP_ACER_ASPIRE_7736, .name = "acer-aspire-7736"},
2677 	{.id = ALC882_FIXUP_ASUS_W90V, .name = "asus-w90v"},
2678 	{.id = ALC889_FIXUP_CD, .name = "cd"},
2679 	{.id = ALC889_FIXUP_FRONT_HP_NO_PRESENCE, .name = "no-front-hp"},
2680 	{.id = ALC889_FIXUP_VAIO_TT, .name = "vaio-tt"},
2681 	{.id = ALC888_FIXUP_EEE1601, .name = "eee1601"},
2682 	{.id = ALC882_FIXUP_EAPD, .name = "alc882-eapd"},
2683 	{.id = ALC883_FIXUP_EAPD, .name = "alc883-eapd"},
2684 	{.id = ALC882_FIXUP_GPIO1, .name = "gpio1"},
2685 	{.id = ALC882_FIXUP_GPIO2, .name = "gpio2"},
2686 	{.id = ALC882_FIXUP_GPIO3, .name = "gpio3"},
2687 	{.id = ALC889_FIXUP_COEF, .name = "alc889-coef"},
2688 	{.id = ALC882_FIXUP_ASUS_W2JC, .name = "asus-w2jc"},
2689 	{.id = ALC882_FIXUP_ACER_ASPIRE_4930G, .name = "acer-aspire-4930g"},
2690 	{.id = ALC882_FIXUP_ACER_ASPIRE_8930G, .name = "acer-aspire-8930g"},
2691 	{.id = ALC883_FIXUP_ACER_EAPD, .name = "acer-aspire"},
2692 	{.id = ALC885_FIXUP_MACPRO_GPIO, .name = "macpro-gpio"},
2693 	{.id = ALC889_FIXUP_DAC_ROUTE, .name = "dac-route"},
2694 	{.id = ALC889_FIXUP_MBP_VREF, .name = "mbp-vref"},
2695 	{.id = ALC889_FIXUP_IMAC91_VREF, .name = "imac91-vref"},
2696 	{.id = ALC889_FIXUP_MBA11_VREF, .name = "mba11-vref"},
2697 	{.id = ALC889_FIXUP_MBA21_VREF, .name = "mba21-vref"},
2698 	{.id = ALC889_FIXUP_MP11_VREF, .name = "mp11-vref"},
2699 	{.id = ALC889_FIXUP_MP41_VREF, .name = "mp41-vref"},
2700 	{.id = ALC882_FIXUP_INV_DMIC, .name = "inv-dmic"},
2701 	{.id = ALC882_FIXUP_NO_PRIMARY_HP, .name = "no-primary-hp"},
2702 	{.id = ALC887_FIXUP_ASUS_BASS, .name = "asus-bass"},
2703 	{.id = ALC1220_FIXUP_GB_DUAL_CODECS, .name = "dual-codecs"},
2704 	{.id = ALC1220_FIXUP_GB_X570, .name = "gb-x570"},
2705 	{.id = ALC1220_FIXUP_CLEVO_P950, .name = "clevo-p950"},
2706 	{}
2707 };
2708 
2709 static const struct snd_hda_pin_quirk alc882_pin_fixup_tbl[] = {
2710 	SND_HDA_PIN_QUIRK(0x10ec1220, 0x1043, "ASUS", ALC1220_FIXUP_CLEVO_P950,
2711 		{0x14, 0x01014010},
2712 		{0x15, 0x01011012},
2713 		{0x16, 0x01016011},
2714 		{0x18, 0x01a19040},
2715 		{0x19, 0x02a19050},
2716 		{0x1a, 0x0181304f},
2717 		{0x1b, 0x0221401f},
2718 		{0x1e, 0x01456130}),
2719 	SND_HDA_PIN_QUIRK(0x10ec1220, 0x1462, "MS-7C35", ALC1220_FIXUP_CLEVO_P950,
2720 		{0x14, 0x01015010},
2721 		{0x15, 0x01011012},
2722 		{0x16, 0x01011011},
2723 		{0x18, 0x01a11040},
2724 		{0x19, 0x02a19050},
2725 		{0x1a, 0x0181104f},
2726 		{0x1b, 0x0221401f},
2727 		{0x1e, 0x01451130}),
2728 	{}
2729 };
2730 
2731 /*
2732  * BIOS auto configuration
2733  */
2734 /* almost identical with ALC880 parser... */
2735 static int alc882_parse_auto_config(struct hda_codec *codec)
2736 {
2737 	static const hda_nid_t alc882_ignore[] = { 0x1d, 0 };
2738 	static const hda_nid_t alc882_ssids[] = { 0x15, 0x1b, 0x14, 0 };
2739 	return alc_parse_auto_config(codec, alc882_ignore, alc882_ssids);
2740 }
2741 
2742 /*
2743  */
2744 static int patch_alc882(struct hda_codec *codec)
2745 {
2746 	struct alc_spec *spec;
2747 	int err;
2748 
2749 	err = alc_alloc_spec(codec, 0x0b);
2750 	if (err < 0)
2751 		return err;
2752 
2753 	spec = codec->spec;
2754 
2755 	switch (codec->core.vendor_id) {
2756 	case 0x10ec0882:
2757 	case 0x10ec0885:
2758 	case 0x10ec0900:
2759 	case 0x10ec0b00:
2760 	case 0x10ec1220:
2761 		break;
2762 	default:
2763 		/* ALC883 and variants */
2764 		alc_fix_pll_init(codec, 0x20, 0x0a, 10);
2765 		break;
2766 	}
2767 
2768 	alc_pre_init(codec);
2769 
2770 	snd_hda_pick_fixup(codec, alc882_fixup_models, alc882_fixup_tbl,
2771 		       alc882_fixups);
2772 	snd_hda_pick_pin_fixup(codec, alc882_pin_fixup_tbl, alc882_fixups, true);
2773 	snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE);
2774 
2775 	alc_auto_parse_customize_define(codec);
2776 
2777 	if (has_cdefine_beep(codec))
2778 		spec->gen.beep_nid = 0x01;
2779 
2780 	/* automatic parse from the BIOS config */
2781 	err = alc882_parse_auto_config(codec);
2782 	if (err < 0)
2783 		goto error;
2784 
2785 	if (!spec->gen.no_analog && spec->gen.beep_nid) {
2786 		err = set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
2787 		if (err < 0)
2788 			goto error;
2789 	}
2790 
2791 	snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE);
2792 
2793 	return 0;
2794 
2795  error:
2796 	alc_free(codec);
2797 	return err;
2798 }
2799 
2800 
2801 /*
2802  * ALC262 support
2803  */
2804 static int alc262_parse_auto_config(struct hda_codec *codec)
2805 {
2806 	static const hda_nid_t alc262_ignore[] = { 0x1d, 0 };
2807 	static const hda_nid_t alc262_ssids[] = { 0x15, 0x1b, 0x14, 0 };
2808 	return alc_parse_auto_config(codec, alc262_ignore, alc262_ssids);
2809 }
2810 
2811 /*
2812  * Pin config fixes
2813  */
2814 enum {
2815 	ALC262_FIXUP_FSC_H270,
2816 	ALC262_FIXUP_FSC_S7110,
2817 	ALC262_FIXUP_HP_Z200,
2818 	ALC262_FIXUP_TYAN,
2819 	ALC262_FIXUP_LENOVO_3000,
2820 	ALC262_FIXUP_BENQ,
2821 	ALC262_FIXUP_BENQ_T31,
2822 	ALC262_FIXUP_INV_DMIC,
2823 	ALC262_FIXUP_INTEL_BAYLEYBAY,
2824 };
2825 
2826 static const struct hda_fixup alc262_fixups[] = {
2827 	[ALC262_FIXUP_FSC_H270] = {
2828 		.type = HDA_FIXUP_PINS,
2829 		.v.pins = (const struct hda_pintbl[]) {
2830 			{ 0x14, 0x99130110 }, /* speaker */
2831 			{ 0x15, 0x0221142f }, /* front HP */
2832 			{ 0x1b, 0x0121141f }, /* rear HP */
2833 			{ }
2834 		}
2835 	},
2836 	[ALC262_FIXUP_FSC_S7110] = {
2837 		.type = HDA_FIXUP_PINS,
2838 		.v.pins = (const struct hda_pintbl[]) {
2839 			{ 0x15, 0x90170110 }, /* speaker */
2840 			{ }
2841 		},
2842 		.chained = true,
2843 		.chain_id = ALC262_FIXUP_BENQ,
2844 	},
2845 	[ALC262_FIXUP_HP_Z200] = {
2846 		.type = HDA_FIXUP_PINS,
2847 		.v.pins = (const struct hda_pintbl[]) {
2848 			{ 0x16, 0x99130120 }, /* internal speaker */
2849 			{ }
2850 		}
2851 	},
2852 	[ALC262_FIXUP_TYAN] = {
2853 		.type = HDA_FIXUP_PINS,
2854 		.v.pins = (const struct hda_pintbl[]) {
2855 			{ 0x14, 0x1993e1f0 }, /* int AUX */
2856 			{ }
2857 		}
2858 	},
2859 	[ALC262_FIXUP_LENOVO_3000] = {
2860 		.type = HDA_FIXUP_PINCTLS,
2861 		.v.pins = (const struct hda_pintbl[]) {
2862 			{ 0x19, PIN_VREF50 },
2863 			{}
2864 		},
2865 		.chained = true,
2866 		.chain_id = ALC262_FIXUP_BENQ,
2867 	},
2868 	[ALC262_FIXUP_BENQ] = {
2869 		.type = HDA_FIXUP_VERBS,
2870 		.v.verbs = (const struct hda_verb[]) {
2871 			{ 0x20, AC_VERB_SET_COEF_INDEX, 0x07 },
2872 			{ 0x20, AC_VERB_SET_PROC_COEF, 0x3070 },
2873 			{}
2874 		}
2875 	},
2876 	[ALC262_FIXUP_BENQ_T31] = {
2877 		.type = HDA_FIXUP_VERBS,
2878 		.v.verbs = (const struct hda_verb[]) {
2879 			{ 0x20, AC_VERB_SET_COEF_INDEX, 0x07 },
2880 			{ 0x20, AC_VERB_SET_PROC_COEF, 0x3050 },
2881 			{}
2882 		}
2883 	},
2884 	[ALC262_FIXUP_INV_DMIC] = {
2885 		.type = HDA_FIXUP_FUNC,
2886 		.v.func = alc_fixup_inv_dmic,
2887 	},
2888 	[ALC262_FIXUP_INTEL_BAYLEYBAY] = {
2889 		.type = HDA_FIXUP_FUNC,
2890 		.v.func = alc_fixup_no_depop_delay,
2891 	},
2892 };
2893 
2894 static const struct snd_pci_quirk alc262_fixup_tbl[] = {
2895 	SND_PCI_QUIRK(0x103c, 0x170b, "HP Z200", ALC262_FIXUP_HP_Z200),
2896 	SND_PCI_QUIRK(0x10cf, 0x1397, "Fujitsu Lifebook S7110", ALC262_FIXUP_FSC_S7110),
2897 	SND_PCI_QUIRK(0x10cf, 0x142d, "Fujitsu Lifebook E8410", ALC262_FIXUP_BENQ),
2898 	SND_PCI_QUIRK(0x10f1, 0x2915, "Tyan Thunder n6650W", ALC262_FIXUP_TYAN),
2899 	SND_PCI_QUIRK(0x1734, 0x1141, "FSC ESPRIMO U9210", ALC262_FIXUP_FSC_H270),
2900 	SND_PCI_QUIRK(0x1734, 0x1147, "FSC Celsius H270", ALC262_FIXUP_FSC_H270),
2901 	SND_PCI_QUIRK(0x17aa, 0x384e, "Lenovo 3000", ALC262_FIXUP_LENOVO_3000),
2902 	SND_PCI_QUIRK(0x17ff, 0x0560, "Benq ED8", ALC262_FIXUP_BENQ),
2903 	SND_PCI_QUIRK(0x17ff, 0x058d, "Benq T31-16", ALC262_FIXUP_BENQ_T31),
2904 	SND_PCI_QUIRK(0x8086, 0x7270, "BayleyBay", ALC262_FIXUP_INTEL_BAYLEYBAY),
2905 	{}
2906 };
2907 
2908 static const struct hda_model_fixup alc262_fixup_models[] = {
2909 	{.id = ALC262_FIXUP_INV_DMIC, .name = "inv-dmic"},
2910 	{.id = ALC262_FIXUP_FSC_H270, .name = "fsc-h270"},
2911 	{.id = ALC262_FIXUP_FSC_S7110, .name = "fsc-s7110"},
2912 	{.id = ALC262_FIXUP_HP_Z200, .name = "hp-z200"},
2913 	{.id = ALC262_FIXUP_TYAN, .name = "tyan"},
2914 	{.id = ALC262_FIXUP_LENOVO_3000, .name = "lenovo-3000"},
2915 	{.id = ALC262_FIXUP_BENQ, .name = "benq"},
2916 	{.id = ALC262_FIXUP_BENQ_T31, .name = "benq-t31"},
2917 	{.id = ALC262_FIXUP_INTEL_BAYLEYBAY, .name = "bayleybay"},
2918 	{}
2919 };
2920 
2921 /*
2922  */
2923 static int patch_alc262(struct hda_codec *codec)
2924 {
2925 	struct alc_spec *spec;
2926 	int err;
2927 
2928 	err = alc_alloc_spec(codec, 0x0b);
2929 	if (err < 0)
2930 		return err;
2931 
2932 	spec = codec->spec;
2933 	spec->gen.shared_mic_vref_pin = 0x18;
2934 
2935 	spec->shutup = alc_eapd_shutup;
2936 
2937 #if 0
2938 	/* pshou 07/11/05  set a zero PCM sample to DAC when FIFO is
2939 	 * under-run
2940 	 */
2941 	alc_update_coefex_idx(codec, 0x1a, 7, 0, 0x80);
2942 #endif
2943 	alc_fix_pll_init(codec, 0x20, 0x0a, 10);
2944 
2945 	alc_pre_init(codec);
2946 
2947 	snd_hda_pick_fixup(codec, alc262_fixup_models, alc262_fixup_tbl,
2948 		       alc262_fixups);
2949 	snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE);
2950 
2951 	alc_auto_parse_customize_define(codec);
2952 
2953 	if (has_cdefine_beep(codec))
2954 		spec->gen.beep_nid = 0x01;
2955 
2956 	/* automatic parse from the BIOS config */
2957 	err = alc262_parse_auto_config(codec);
2958 	if (err < 0)
2959 		goto error;
2960 
2961 	if (!spec->gen.no_analog && spec->gen.beep_nid) {
2962 		err = set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
2963 		if (err < 0)
2964 			goto error;
2965 	}
2966 
2967 	snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE);
2968 
2969 	return 0;
2970 
2971  error:
2972 	alc_free(codec);
2973 	return err;
2974 }
2975 
2976 /*
2977  *  ALC268
2978  */
2979 /* bind Beep switches of both NID 0x0f and 0x10 */
2980 static int alc268_beep_switch_put(struct snd_kcontrol *kcontrol,
2981 				  struct snd_ctl_elem_value *ucontrol)
2982 {
2983 	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2984 	unsigned long pval;
2985 	int err;
2986 
2987 	mutex_lock(&codec->control_mutex);
2988 	pval = kcontrol->private_value;
2989 	kcontrol->private_value = (pval & ~0xff) | 0x0f;
2990 	err = snd_hda_mixer_amp_switch_put(kcontrol, ucontrol);
2991 	if (err >= 0) {
2992 		kcontrol->private_value = (pval & ~0xff) | 0x10;
2993 		err = snd_hda_mixer_amp_switch_put(kcontrol, ucontrol);
2994 	}
2995 	kcontrol->private_value = pval;
2996 	mutex_unlock(&codec->control_mutex);
2997 	return err;
2998 }
2999 
3000 static const struct snd_kcontrol_new alc268_beep_mixer[] = {
3001 	HDA_CODEC_VOLUME("Beep Playback Volume", 0x1d, 0x0, HDA_INPUT),
3002 	{
3003 		.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3004 		.name = "Beep Playback Switch",
3005 		.subdevice = HDA_SUBDEV_AMP_FLAG,
3006 		.info = snd_hda_mixer_amp_switch_info,
3007 		.get = snd_hda_mixer_amp_switch_get,
3008 		.put = alc268_beep_switch_put,
3009 		.private_value = HDA_COMPOSE_AMP_VAL(0x0f, 3, 1, HDA_INPUT)
3010 	},
3011 };
3012 
3013 /* set PCBEEP vol = 0, mute connections */
3014 static const struct hda_verb alc268_beep_init_verbs[] = {
3015 	{0x1d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
3016 	{0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
3017 	{0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
3018 	{ }
3019 };
3020 
3021 enum {
3022 	ALC268_FIXUP_INV_DMIC,
3023 	ALC268_FIXUP_HP_EAPD,
3024 	ALC268_FIXUP_SPDIF,
3025 };
3026 
3027 static const struct hda_fixup alc268_fixups[] = {
3028 	[ALC268_FIXUP_INV_DMIC] = {
3029 		.type = HDA_FIXUP_FUNC,
3030 		.v.func = alc_fixup_inv_dmic,
3031 	},
3032 	[ALC268_FIXUP_HP_EAPD] = {
3033 		.type = HDA_FIXUP_VERBS,
3034 		.v.verbs = (const struct hda_verb[]) {
3035 			{0x15, AC_VERB_SET_EAPD_BTLENABLE, 0},
3036 			{}
3037 		}
3038 	},
3039 	[ALC268_FIXUP_SPDIF] = {
3040 		.type = HDA_FIXUP_PINS,
3041 		.v.pins = (const struct hda_pintbl[]) {
3042 			{ 0x1e, 0x014b1180 }, /* enable SPDIF out */
3043 			{}
3044 		}
3045 	},
3046 };
3047 
3048 static const struct hda_model_fixup alc268_fixup_models[] = {
3049 	{.id = ALC268_FIXUP_INV_DMIC, .name = "inv-dmic"},
3050 	{.id = ALC268_FIXUP_HP_EAPD, .name = "hp-eapd"},
3051 	{.id = ALC268_FIXUP_SPDIF, .name = "spdif"},
3052 	{}
3053 };
3054 
3055 static const struct snd_pci_quirk alc268_fixup_tbl[] = {
3056 	SND_PCI_QUIRK(0x1025, 0x0139, "Acer TravelMate 6293", ALC268_FIXUP_SPDIF),
3057 	SND_PCI_QUIRK(0x1025, 0x015b, "Acer AOA 150 (ZG5)", ALC268_FIXUP_INV_DMIC),
3058 	/* below is codec SSID since multiple Toshiba laptops have the
3059 	 * same PCI SSID 1179:ff00
3060 	 */
3061 	SND_PCI_QUIRK(0x1179, 0xff06, "Toshiba P200", ALC268_FIXUP_HP_EAPD),
3062 	{}
3063 };
3064 
3065 /*
3066  * BIOS auto configuration
3067  */
3068 static int alc268_parse_auto_config(struct hda_codec *codec)
3069 {
3070 	static const hda_nid_t alc268_ssids[] = { 0x15, 0x1b, 0x14, 0 };
3071 	return alc_parse_auto_config(codec, NULL, alc268_ssids);
3072 }
3073 
3074 /*
3075  */
3076 static int patch_alc268(struct hda_codec *codec)
3077 {
3078 	struct alc_spec *spec;
3079 	int i, err;
3080 
3081 	/* ALC268 has no aa-loopback mixer */
3082 	err = alc_alloc_spec(codec, 0);
3083 	if (err < 0)
3084 		return err;
3085 
3086 	spec = codec->spec;
3087 	if (has_cdefine_beep(codec))
3088 		spec->gen.beep_nid = 0x01;
3089 
3090 	spec->shutup = alc_eapd_shutup;
3091 
3092 	alc_pre_init(codec);
3093 
3094 	snd_hda_pick_fixup(codec, alc268_fixup_models, alc268_fixup_tbl, alc268_fixups);
3095 	snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE);
3096 
3097 	/* automatic parse from the BIOS config */
3098 	err = alc268_parse_auto_config(codec);
3099 	if (err < 0)
3100 		goto error;
3101 
3102 	if (err > 0 && !spec->gen.no_analog &&
3103 	    spec->gen.autocfg.speaker_pins[0] != 0x1d) {
3104 		for (i = 0; i < ARRAY_SIZE(alc268_beep_mixer); i++) {
3105 			if (!snd_hda_gen_add_kctl(&spec->gen, NULL,
3106 						  &alc268_beep_mixer[i])) {
3107 				err = -ENOMEM;
3108 				goto error;
3109 			}
3110 		}
3111 		snd_hda_add_verbs(codec, alc268_beep_init_verbs);
3112 		if (!query_amp_caps(codec, 0x1d, HDA_INPUT))
3113 			/* override the amp caps for beep generator */
3114 			snd_hda_override_amp_caps(codec, 0x1d, HDA_INPUT,
3115 					  (0x0c << AC_AMPCAP_OFFSET_SHIFT) |
3116 					  (0x0c << AC_AMPCAP_NUM_STEPS_SHIFT) |
3117 					  (0x07 << AC_AMPCAP_STEP_SIZE_SHIFT) |
3118 					  (0 << AC_AMPCAP_MUTE_SHIFT));
3119 	}
3120 
3121 	snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE);
3122 
3123 	return 0;
3124 
3125  error:
3126 	alc_free(codec);
3127 	return err;
3128 }
3129 
3130 /*
3131  * ALC269
3132  */
3133 
3134 static const struct hda_pcm_stream alc269_44k_pcm_analog_playback = {
3135 	.rates = SNDRV_PCM_RATE_44100, /* fixed rate */
3136 };
3137 
3138 static const struct hda_pcm_stream alc269_44k_pcm_analog_capture = {
3139 	.rates = SNDRV_PCM_RATE_44100, /* fixed rate */
3140 };
3141 
3142 /* different alc269-variants */
3143 enum {
3144 	ALC269_TYPE_ALC269VA,
3145 	ALC269_TYPE_ALC269VB,
3146 	ALC269_TYPE_ALC269VC,
3147 	ALC269_TYPE_ALC269VD,
3148 	ALC269_TYPE_ALC280,
3149 	ALC269_TYPE_ALC282,
3150 	ALC269_TYPE_ALC283,
3151 	ALC269_TYPE_ALC284,
3152 	ALC269_TYPE_ALC293,
3153 	ALC269_TYPE_ALC286,
3154 	ALC269_TYPE_ALC298,
3155 	ALC269_TYPE_ALC255,
3156 	ALC269_TYPE_ALC256,
3157 	ALC269_TYPE_ALC257,
3158 	ALC269_TYPE_ALC215,
3159 	ALC269_TYPE_ALC225,
3160 	ALC269_TYPE_ALC245,
3161 	ALC269_TYPE_ALC287,
3162 	ALC269_TYPE_ALC294,
3163 	ALC269_TYPE_ALC300,
3164 	ALC269_TYPE_ALC623,
3165 	ALC269_TYPE_ALC700,
3166 };
3167 
3168 /*
3169  * BIOS auto configuration
3170  */
3171 static int alc269_parse_auto_config(struct hda_codec *codec)
3172 {
3173 	static const hda_nid_t alc269_ignore[] = { 0x1d, 0 };
3174 	static const hda_nid_t alc269_ssids[] = { 0, 0x1b, 0x14, 0x21 };
3175 	static const hda_nid_t alc269va_ssids[] = { 0x15, 0x1b, 0x14, 0 };
3176 	struct alc_spec *spec = codec->spec;
3177 	const hda_nid_t *ssids;
3178 
3179 	switch (spec->codec_variant) {
3180 	case ALC269_TYPE_ALC269VA:
3181 	case ALC269_TYPE_ALC269VC:
3182 	case ALC269_TYPE_ALC280:
3183 	case ALC269_TYPE_ALC284:
3184 	case ALC269_TYPE_ALC293:
3185 		ssids = alc269va_ssids;
3186 		break;
3187 	case ALC269_TYPE_ALC269VB:
3188 	case ALC269_TYPE_ALC269VD:
3189 	case ALC269_TYPE_ALC282:
3190 	case ALC269_TYPE_ALC283:
3191 	case ALC269_TYPE_ALC286:
3192 	case ALC269_TYPE_ALC298:
3193 	case ALC269_TYPE_ALC255:
3194 	case ALC269_TYPE_ALC256:
3195 	case ALC269_TYPE_ALC257:
3196 	case ALC269_TYPE_ALC215:
3197 	case ALC269_TYPE_ALC225:
3198 	case ALC269_TYPE_ALC245:
3199 	case ALC269_TYPE_ALC287:
3200 	case ALC269_TYPE_ALC294:
3201 	case ALC269_TYPE_ALC300:
3202 	case ALC269_TYPE_ALC623:
3203 	case ALC269_TYPE_ALC700:
3204 		ssids = alc269_ssids;
3205 		break;
3206 	default:
3207 		ssids = alc269_ssids;
3208 		break;
3209 	}
3210 
3211 	return alc_parse_auto_config(codec, alc269_ignore, ssids);
3212 }
3213 
3214 static const struct hda_jack_keymap alc_headset_btn_keymap[] = {
3215 	{ SND_JACK_BTN_0, KEY_PLAYPAUSE },
3216 	{ SND_JACK_BTN_1, KEY_VOICECOMMAND },
3217 	{ SND_JACK_BTN_2, KEY_VOLUMEUP },
3218 	{ SND_JACK_BTN_3, KEY_VOLUMEDOWN },
3219 	{}
3220 };
3221 
3222 static void alc_headset_btn_callback(struct hda_codec *codec,
3223 				     struct hda_jack_callback *jack)
3224 {
3225 	int report = 0;
3226 
3227 	if (jack->unsol_res & (7 << 13))
3228 		report |= SND_JACK_BTN_0;
3229 
3230 	if (jack->unsol_res  & (1 << 16 | 3 << 8))
3231 		report |= SND_JACK_BTN_1;
3232 
3233 	/* Volume up key */
3234 	if (jack->unsol_res & (7 << 23))
3235 		report |= SND_JACK_BTN_2;
3236 
3237 	/* Volume down key */
3238 	if (jack->unsol_res & (7 << 10))
3239 		report |= SND_JACK_BTN_3;
3240 
3241 	snd_hda_jack_set_button_state(codec, jack->nid, report);
3242 }
3243 
3244 static void alc_disable_headset_jack_key(struct hda_codec *codec)
3245 {
3246 	struct alc_spec *spec = codec->spec;
3247 
3248 	if (!spec->has_hs_key)
3249 		return;
3250 
3251 	switch (codec->core.vendor_id) {
3252 	case 0x10ec0215:
3253 	case 0x10ec0225:
3254 	case 0x10ec0285:
3255 	case 0x10ec0287:
3256 	case 0x10ec0295:
3257 	case 0x10ec0289:
3258 	case 0x10ec0299:
3259 		alc_write_coef_idx(codec, 0x48, 0x0);
3260 		alc_update_coef_idx(codec, 0x49, 0x0045, 0x0);
3261 		alc_update_coef_idx(codec, 0x44, 0x0045 << 8, 0x0);
3262 		break;
3263 	case 0x10ec0230:
3264 	case 0x10ec0236:
3265 	case 0x10ec0256:
3266 	case 0x10ec0257:
3267 	case 0x19e58326:
3268 		alc_write_coef_idx(codec, 0x48, 0x0);
3269 		alc_update_coef_idx(codec, 0x49, 0x0045, 0x0);
3270 		break;
3271 	}
3272 }
3273 
3274 static void alc_enable_headset_jack_key(struct hda_codec *codec)
3275 {
3276 	struct alc_spec *spec = codec->spec;
3277 
3278 	if (!spec->has_hs_key)
3279 		return;
3280 
3281 	switch (codec->core.vendor_id) {
3282 	case 0x10ec0215:
3283 	case 0x10ec0225:
3284 	case 0x10ec0285:
3285 	case 0x10ec0287:
3286 	case 0x10ec0295:
3287 	case 0x10ec0289:
3288 	case 0x10ec0299:
3289 		alc_write_coef_idx(codec, 0x48, 0xd011);
3290 		alc_update_coef_idx(codec, 0x49, 0x007f, 0x0045);
3291 		alc_update_coef_idx(codec, 0x44, 0x007f << 8, 0x0045 << 8);
3292 		break;
3293 	case 0x10ec0230:
3294 	case 0x10ec0236:
3295 	case 0x10ec0256:
3296 	case 0x10ec0257:
3297 	case 0x19e58326:
3298 		alc_write_coef_idx(codec, 0x48, 0xd011);
3299 		alc_update_coef_idx(codec, 0x49, 0x007f, 0x0045);
3300 		break;
3301 	}
3302 }
3303 
3304 static void alc_fixup_headset_jack(struct hda_codec *codec,
3305 				    const struct hda_fixup *fix, int action)
3306 {
3307 	struct alc_spec *spec = codec->spec;
3308 	hda_nid_t hp_pin;
3309 
3310 	switch (action) {
3311 	case HDA_FIXUP_ACT_PRE_PROBE:
3312 		spec->has_hs_key = 1;
3313 		snd_hda_jack_detect_enable_callback(codec, 0x55,
3314 						    alc_headset_btn_callback);
3315 		break;
3316 	case HDA_FIXUP_ACT_BUILD:
3317 		hp_pin = alc_get_hp_pin(spec);
3318 		if (!hp_pin || snd_hda_jack_bind_keymap(codec, 0x55,
3319 							alc_headset_btn_keymap,
3320 							hp_pin))
3321 			snd_hda_jack_add_kctl(codec, 0x55, "Headset Jack",
3322 					      false, SND_JACK_HEADSET,
3323 					      alc_headset_btn_keymap);
3324 
3325 		alc_enable_headset_jack_key(codec);
3326 		break;
3327 	}
3328 }
3329 
3330 static void alc269vb_toggle_power_output(struct hda_codec *codec, int power_up)
3331 {
3332 	alc_update_coef_idx(codec, 0x04, 1 << 11, power_up ? (1 << 11) : 0);
3333 }
3334 
3335 static void alc269_shutup(struct hda_codec *codec)
3336 {
3337 	struct alc_spec *spec = codec->spec;
3338 
3339 	if (spec->codec_variant == ALC269_TYPE_ALC269VB)
3340 		alc269vb_toggle_power_output(codec, 0);
3341 	if (spec->codec_variant == ALC269_TYPE_ALC269VB &&
3342 			(alc_get_coef0(codec) & 0x00ff) == 0x018) {
3343 		msleep(150);
3344 	}
3345 	alc_shutup_pins(codec);
3346 }
3347 
3348 static const struct coef_fw alc282_coefs[] = {
3349 	WRITE_COEF(0x03, 0x0002), /* Power Down Control */
3350 	UPDATE_COEF(0x05, 0xff3f, 0x0700), /* FIFO and filter clock */
3351 	WRITE_COEF(0x07, 0x0200), /* DMIC control */
3352 	UPDATE_COEF(0x06, 0x00f0, 0), /* Analog clock */
3353 	UPDATE_COEF(0x08, 0xfffc, 0x0c2c), /* JD */
3354 	WRITE_COEF(0x0a, 0xcccc), /* JD offset1 */
3355 	WRITE_COEF(0x0b, 0xcccc), /* JD offset2 */
3356 	WRITE_COEF(0x0e, 0x6e00), /* LDO1/2/3, DAC/ADC */
3357 	UPDATE_COEF(0x0f, 0xf800, 0x1000), /* JD */
3358 	UPDATE_COEF(0x10, 0xfc00, 0x0c00), /* Capless */
3359 	WRITE_COEF(0x6f, 0x0), /* Class D test 4 */
3360 	UPDATE_COEF(0x0c, 0xfe00, 0), /* IO power down directly */
3361 	WRITE_COEF(0x34, 0xa0c0), /* ANC */
3362 	UPDATE_COEF(0x16, 0x0008, 0), /* AGC MUX */
3363 	UPDATE_COEF(0x1d, 0x00e0, 0), /* DAC simple content protection */
3364 	UPDATE_COEF(0x1f, 0x00e0, 0), /* ADC simple content protection */
3365 	WRITE_COEF(0x21, 0x8804), /* DAC ADC Zero Detection */
3366 	WRITE_COEF(0x63, 0x2902), /* PLL */
3367 	WRITE_COEF(0x68, 0xa080), /* capless control 2 */
3368 	WRITE_COEF(0x69, 0x3400), /* capless control 3 */
3369 	WRITE_COEF(0x6a, 0x2f3e), /* capless control 4 */
3370 	WRITE_COEF(0x6b, 0x0), /* capless control 5 */
3371 	UPDATE_COEF(0x6d, 0x0fff, 0x0900), /* class D test 2 */
3372 	WRITE_COEF(0x6e, 0x110a), /* class D test 3 */
3373 	UPDATE_COEF(0x70, 0x00f8, 0x00d8), /* class D test 5 */
3374 	WRITE_COEF(0x71, 0x0014), /* class D test 6 */
3375 	WRITE_COEF(0x72, 0xc2ba), /* classD OCP */
3376 	UPDATE_COEF(0x77, 0x0f80, 0), /* classD pure DC test */
3377 	WRITE_COEF(0x6c, 0xfc06), /* Class D amp control */
3378 	{}
3379 };
3380 
3381 static void alc282_restore_default_value(struct hda_codec *codec)
3382 {
3383 	alc_process_coef_fw(codec, alc282_coefs);
3384 }
3385 
3386 static void alc282_init(struct hda_codec *codec)
3387 {
3388 	struct alc_spec *spec = codec->spec;
3389 	hda_nid_t hp_pin = alc_get_hp_pin(spec);
3390 	bool hp_pin_sense;
3391 	int coef78;
3392 
3393 	alc282_restore_default_value(codec);
3394 
3395 	if (!hp_pin)
3396 		return;
3397 	hp_pin_sense = snd_hda_jack_detect(codec, hp_pin);
3398 	coef78 = alc_read_coef_idx(codec, 0x78);
3399 
3400 	/* Index 0x78 Direct Drive HP AMP LPM Control 1 */
3401 	/* Headphone capless set to high power mode */
3402 	alc_write_coef_idx(codec, 0x78, 0x9004);
3403 
3404 	if (hp_pin_sense)
3405 		msleep(2);
3406 
3407 	snd_hda_codec_write(codec, hp_pin, 0,
3408 			    AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);
3409 
3410 	if (hp_pin_sense)
3411 		msleep(85);
3412 
3413 	snd_hda_codec_write(codec, hp_pin, 0,
3414 			    AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT);
3415 
3416 	if (hp_pin_sense)
3417 		msleep(100);
3418 
3419 	/* Headphone capless set to normal mode */
3420 	alc_write_coef_idx(codec, 0x78, coef78);
3421 }
3422 
3423 static void alc282_shutup(struct hda_codec *codec)
3424 {
3425 	struct alc_spec *spec = codec->spec;
3426 	hda_nid_t hp_pin = alc_get_hp_pin(spec);
3427 	bool hp_pin_sense;
3428 	int coef78;
3429 
3430 	if (!hp_pin) {
3431 		alc269_shutup(codec);
3432 		return;
3433 	}
3434 
3435 	hp_pin_sense = snd_hda_jack_detect(codec, hp_pin);
3436 	coef78 = alc_read_coef_idx(codec, 0x78);
3437 	alc_write_coef_idx(codec, 0x78, 0x9004);
3438 
3439 	if (hp_pin_sense)
3440 		msleep(2);
3441 
3442 	snd_hda_codec_write(codec, hp_pin, 0,
3443 			    AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);
3444 
3445 	if (hp_pin_sense)
3446 		msleep(85);
3447 
3448 	if (!spec->no_shutup_pins)
3449 		snd_hda_codec_write(codec, hp_pin, 0,
3450 				    AC_VERB_SET_PIN_WIDGET_CONTROL, 0x0);
3451 
3452 	if (hp_pin_sense)
3453 		msleep(100);
3454 
3455 	alc_auto_setup_eapd(codec, false);
3456 	alc_shutup_pins(codec);
3457 	alc_write_coef_idx(codec, 0x78, coef78);
3458 }
3459 
3460 static const struct coef_fw alc283_coefs[] = {
3461 	WRITE_COEF(0x03, 0x0002), /* Power Down Control */
3462 	UPDATE_COEF(0x05, 0xff3f, 0x0700), /* FIFO and filter clock */
3463 	WRITE_COEF(0x07, 0x0200), /* DMIC control */
3464 	UPDATE_COEF(0x06, 0x00f0, 0), /* Analog clock */
3465 	UPDATE_COEF(0x08, 0xfffc, 0x0c2c), /* JD */
3466 	WRITE_COEF(0x0a, 0xcccc), /* JD offset1 */
3467 	WRITE_COEF(0x0b, 0xcccc), /* JD offset2 */
3468 	WRITE_COEF(0x0e, 0x6fc0), /* LDO1/2/3, DAC/ADC */
3469 	UPDATE_COEF(0x0f, 0xf800, 0x1000), /* JD */
3470 	UPDATE_COEF(0x10, 0xfc00, 0x0c00), /* Capless */
3471 	WRITE_COEF(0x3a, 0x0), /* Class D test 4 */
3472 	UPDATE_COEF(0x0c, 0xfe00, 0x0), /* IO power down directly */
3473 	WRITE_COEF(0x22, 0xa0c0), /* ANC */
3474 	UPDATE_COEFEX(0x53, 0x01, 0x000f, 0x0008), /* AGC MUX */
3475 	UPDATE_COEF(0x1d, 0x00e0, 0), /* DAC simple content protection */
3476 	UPDATE_COEF(0x1f, 0x00e0, 0), /* ADC simple content protection */
3477 	WRITE_COEF(0x21, 0x8804), /* DAC ADC Zero Detection */
3478 	WRITE_COEF(0x2e, 0x2902), /* PLL */
3479 	WRITE_COEF(0x33, 0xa080), /* capless control 2 */
3480 	WRITE_COEF(0x34, 0x3400), /* capless control 3 */
3481 	WRITE_COEF(0x35, 0x2f3e), /* capless control 4 */
3482 	WRITE_COEF(0x36, 0x0), /* capless control 5 */
3483 	UPDATE_COEF(0x38, 0x0fff, 0x0900), /* class D test 2 */
3484 	WRITE_COEF(0x39, 0x110a), /* class D test 3 */
3485 	UPDATE_COEF(0x3b, 0x00f8, 0x00d8), /* class D test 5 */
3486 	WRITE_COEF(0x3c, 0x0014), /* class D test 6 */
3487 	WRITE_COEF(0x3d, 0xc2ba), /* classD OCP */
3488 	UPDATE_COEF(0x42, 0x0f80, 0x0), /* classD pure DC test */
3489 	WRITE_COEF(0x49, 0x0), /* test mode */
3490 	UPDATE_COEF(0x40, 0xf800, 0x9800), /* Class D DC enable */
3491 	UPDATE_COEF(0x42, 0xf000, 0x2000), /* DC offset */
3492 	WRITE_COEF(0x37, 0xfc06), /* Class D amp control */
3493 	UPDATE_COEF(0x1b, 0x8000, 0), /* HP JD control */
3494 	{}
3495 };
3496 
3497 static void alc283_restore_default_value(struct hda_codec *codec)
3498 {
3499 	alc_process_coef_fw(codec, alc283_coefs);
3500 }
3501 
3502 static void alc283_init(struct hda_codec *codec)
3503 {
3504 	struct alc_spec *spec = codec->spec;
3505 	hda_nid_t hp_pin = alc_get_hp_pin(spec);
3506 	bool hp_pin_sense;
3507 
3508 	alc283_restore_default_value(codec);
3509 
3510 	if (!hp_pin)
3511 		return;
3512 
3513 	msleep(30);
3514 	hp_pin_sense = snd_hda_jack_detect(codec, hp_pin);
3515 
3516 	/* Index 0x43 Direct Drive HP AMP LPM Control 1 */
3517 	/* Headphone capless set to high power mode */
3518 	alc_write_coef_idx(codec, 0x43, 0x9004);
3519 
3520 	snd_hda_codec_write(codec, hp_pin, 0,
3521 			    AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);
3522 
3523 	if (hp_pin_sense)
3524 		msleep(85);
3525 
3526 	snd_hda_codec_write(codec, hp_pin, 0,
3527 			    AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT);
3528 
3529 	if (hp_pin_sense)
3530 		msleep(85);
3531 	/* Index 0x46 Combo jack auto switch control 2 */
3532 	/* 3k pull low control for Headset jack. */
3533 	alc_update_coef_idx(codec, 0x46, 3 << 12, 0);
3534 	/* Headphone capless set to normal mode */
3535 	alc_write_coef_idx(codec, 0x43, 0x9614);
3536 }
3537 
3538 static void alc283_shutup(struct hda_codec *codec)
3539 {
3540 	struct alc_spec *spec = codec->spec;
3541 	hda_nid_t hp_pin = alc_get_hp_pin(spec);
3542 	bool hp_pin_sense;
3543 
3544 	if (!hp_pin) {
3545 		alc269_shutup(codec);
3546 		return;
3547 	}
3548 
3549 	hp_pin_sense = snd_hda_jack_detect(codec, hp_pin);
3550 
3551 	alc_write_coef_idx(codec, 0x43, 0x9004);
3552 
3553 	/*depop hp during suspend*/
3554 	alc_write_coef_idx(codec, 0x06, 0x2100);
3555 
3556 	snd_hda_codec_write(codec, hp_pin, 0,
3557 			    AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);
3558 
3559 	if (hp_pin_sense)
3560 		msleep(100);
3561 
3562 	if (!spec->no_shutup_pins)
3563 		snd_hda_codec_write(codec, hp_pin, 0,
3564 				    AC_VERB_SET_PIN_WIDGET_CONTROL, 0x0);
3565 
3566 	alc_update_coef_idx(codec, 0x46, 0, 3 << 12);
3567 
3568 	if (hp_pin_sense)
3569 		msleep(100);
3570 	alc_auto_setup_eapd(codec, false);
3571 	alc_shutup_pins(codec);
3572 	alc_write_coef_idx(codec, 0x43, 0x9614);
3573 }
3574 
3575 static void alc256_init(struct hda_codec *codec)
3576 {
3577 	struct alc_spec *spec = codec->spec;
3578 	hda_nid_t hp_pin = alc_get_hp_pin(spec);
3579 	bool hp_pin_sense;
3580 
3581 	if (spec->ultra_low_power) {
3582 		alc_update_coef_idx(codec, 0x03, 1<<1, 1<<1);
3583 		alc_update_coef_idx(codec, 0x08, 3<<2, 3<<2);
3584 		alc_update_coef_idx(codec, 0x08, 7<<4, 0);
3585 		alc_update_coef_idx(codec, 0x3b, 1<<15, 0);
3586 		alc_update_coef_idx(codec, 0x0e, 7<<6, 7<<6);
3587 		msleep(30);
3588 	}
3589 
3590 	if (!hp_pin)
3591 		hp_pin = 0x21;
3592 
3593 	msleep(30);
3594 
3595 	hp_pin_sense = snd_hda_jack_detect(codec, hp_pin);
3596 
3597 	if (hp_pin_sense)
3598 		msleep(2);
3599 
3600 	alc_update_coefex_idx(codec, 0x57, 0x04, 0x0007, 0x1); /* Low power */
3601 
3602 	snd_hda_codec_write(codec, hp_pin, 0,
3603 			    AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);
3604 
3605 	if (hp_pin_sense || spec->ultra_low_power)
3606 		msleep(85);
3607 
3608 	snd_hda_codec_write(codec, hp_pin, 0,
3609 			    AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT);
3610 
3611 	if (hp_pin_sense || spec->ultra_low_power)
3612 		msleep(100);
3613 
3614 	alc_update_coef_idx(codec, 0x46, 3 << 12, 0);
3615 	alc_update_coefex_idx(codec, 0x57, 0x04, 0x0007, 0x4); /* Hight power */
3616 	alc_update_coefex_idx(codec, 0x53, 0x02, 0x8000, 1 << 15); /* Clear bit */
3617 	alc_update_coefex_idx(codec, 0x53, 0x02, 0x8000, 0 << 15);
3618 	/*
3619 	 * Expose headphone mic (or possibly Line In on some machines) instead
3620 	 * of PC Beep on 1Ah, and disable 1Ah loopback for all outputs. See
3621 	 * Documentation/sound/hd-audio/realtek-pc-beep.rst for details of
3622 	 * this register.
3623 	 */
3624 	alc_write_coef_idx(codec, 0x36, 0x5757);
3625 }
3626 
3627 static void alc256_shutup(struct hda_codec *codec)
3628 {
3629 	struct alc_spec *spec = codec->spec;
3630 	hda_nid_t hp_pin = alc_get_hp_pin(spec);
3631 	bool hp_pin_sense;
3632 
3633 	if (!hp_pin)
3634 		hp_pin = 0x21;
3635 
3636 	alc_update_coefex_idx(codec, 0x57, 0x04, 0x0007, 0x1); /* Low power */
3637 	hp_pin_sense = snd_hda_jack_detect(codec, hp_pin);
3638 
3639 	if (hp_pin_sense)
3640 		msleep(2);
3641 
3642 	snd_hda_codec_write(codec, hp_pin, 0,
3643 			    AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);
3644 
3645 	if (hp_pin_sense || spec->ultra_low_power)
3646 		msleep(85);
3647 
3648 	/* 3k pull low control for Headset jack. */
3649 	/* NOTE: call this before clearing the pin, otherwise codec stalls */
3650 	/* If disable 3k pulldown control for alc257, the Mic detection will not work correctly
3651 	 * when booting with headset plugged. So skip setting it for the codec alc257
3652 	 */
3653 	if (spec->en_3kpull_low)
3654 		alc_update_coef_idx(codec, 0x46, 0, 3 << 12);
3655 
3656 	if (!spec->no_shutup_pins)
3657 		snd_hda_codec_write(codec, hp_pin, 0,
3658 				    AC_VERB_SET_PIN_WIDGET_CONTROL, 0x0);
3659 
3660 	if (hp_pin_sense || spec->ultra_low_power)
3661 		msleep(100);
3662 
3663 	alc_auto_setup_eapd(codec, false);
3664 	alc_shutup_pins(codec);
3665 	if (spec->ultra_low_power) {
3666 		msleep(50);
3667 		alc_update_coef_idx(codec, 0x03, 1<<1, 0);
3668 		alc_update_coef_idx(codec, 0x08, 7<<4, 7<<4);
3669 		alc_update_coef_idx(codec, 0x08, 3<<2, 0);
3670 		alc_update_coef_idx(codec, 0x3b, 1<<15, 1<<15);
3671 		alc_update_coef_idx(codec, 0x0e, 7<<6, 0);
3672 		msleep(30);
3673 	}
3674 }
3675 
3676 static void alc285_hp_init(struct hda_codec *codec)
3677 {
3678 	struct alc_spec *spec = codec->spec;
3679 	hda_nid_t hp_pin = alc_get_hp_pin(spec);
3680 	int i, val;
3681 	int coef38, coef0d, coef36;
3682 
3683 	alc_write_coefex_idx(codec, 0x58, 0x00, 0x1888); /* write default value */
3684 	alc_update_coef_idx(codec, 0x4a, 1<<15, 1<<15); /* Reset HP JD */
3685 	coef38 = alc_read_coef_idx(codec, 0x38); /* Amp control */
3686 	coef0d = alc_read_coef_idx(codec, 0x0d); /* Digital Misc control */
3687 	coef36 = alc_read_coef_idx(codec, 0x36); /* Passthrough Control */
3688 	alc_update_coef_idx(codec, 0x38, 1<<4, 0x0);
3689 	alc_update_coef_idx(codec, 0x0d, 0x110, 0x0);
3690 
3691 	alc_update_coef_idx(codec, 0x67, 0xf000, 0x3000);
3692 
3693 	if (hp_pin)
3694 		snd_hda_codec_write(codec, hp_pin, 0,
3695 			    AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);
3696 
3697 	msleep(130);
3698 	alc_update_coef_idx(codec, 0x36, 1<<14, 1<<14);
3699 	alc_update_coef_idx(codec, 0x36, 1<<13, 0x0);
3700 
3701 	if (hp_pin)
3702 		snd_hda_codec_write(codec, hp_pin, 0,
3703 			    AC_VERB_SET_PIN_WIDGET_CONTROL, 0x0);
3704 	msleep(10);
3705 	alc_write_coef_idx(codec, 0x67, 0x0); /* Set HP depop to manual mode */
3706 	alc_write_coefex_idx(codec, 0x58, 0x00, 0x7880);
3707 	alc_write_coefex_idx(codec, 0x58, 0x0f, 0xf049);
3708 	alc_update_coefex_idx(codec, 0x58, 0x03, 0x00f0, 0x00c0);
3709 
3710 	alc_write_coefex_idx(codec, 0x58, 0x00, 0xf888); /* HP depop procedure start */
3711 	val = alc_read_coefex_idx(codec, 0x58, 0x00);
3712 	for (i = 0; i < 20 && val & 0x8000; i++) {
3713 		msleep(50);
3714 		val = alc_read_coefex_idx(codec, 0x58, 0x00);
3715 	} /* Wait for depop procedure finish  */
3716 
3717 	alc_write_coefex_idx(codec, 0x58, 0x00, val); /* write back the result */
3718 	alc_update_coef_idx(codec, 0x38, 1<<4, coef38);
3719 	alc_update_coef_idx(codec, 0x0d, 0x110, coef0d);
3720 	alc_update_coef_idx(codec, 0x36, 3<<13, coef36);
3721 
3722 	msleep(50);
3723 	alc_update_coef_idx(codec, 0x4a, 1<<15, 0);
3724 }
3725 
3726 static void alc225_init(struct hda_codec *codec)
3727 {
3728 	struct alc_spec *spec = codec->spec;
3729 	hda_nid_t hp_pin = alc_get_hp_pin(spec);
3730 	bool hp1_pin_sense, hp2_pin_sense;
3731 
3732 	if (spec->ultra_low_power) {
3733 		alc_update_coef_idx(codec, 0x08, 0x0f << 2, 3<<2);
3734 		alc_update_coef_idx(codec, 0x0e, 7<<6, 7<<6);
3735 		alc_update_coef_idx(codec, 0x33, 1<<11, 0);
3736 		msleep(30);
3737 	}
3738 
3739 	if (spec->codec_variant != ALC269_TYPE_ALC287 &&
3740 		spec->codec_variant != ALC269_TYPE_ALC245)
3741 		/* required only at boot or S3 and S4 resume time */
3742 		if (!spec->done_hp_init ||
3743 			is_s3_resume(codec) ||
3744 			is_s4_resume(codec)) {
3745 			alc285_hp_init(codec);
3746 			spec->done_hp_init = true;
3747 		}
3748 
3749 	if (!hp_pin)
3750 		hp_pin = 0x21;
3751 	msleep(30);
3752 
3753 	hp1_pin_sense = snd_hda_jack_detect(codec, hp_pin);
3754 	hp2_pin_sense = snd_hda_jack_detect(codec, 0x16);
3755 
3756 	if (hp1_pin_sense || hp2_pin_sense)
3757 		msleep(2);
3758 
3759 	alc_update_coefex_idx(codec, 0x57, 0x04, 0x0007, 0x1); /* Low power */
3760 
3761 	if (hp1_pin_sense || spec->ultra_low_power)
3762 		snd_hda_codec_write(codec, hp_pin, 0,
3763 			    AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);
3764 	if (hp2_pin_sense)
3765 		snd_hda_codec_write(codec, 0x16, 0,
3766 			    AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);
3767 
3768 	if (hp1_pin_sense || hp2_pin_sense || spec->ultra_low_power)
3769 		msleep(85);
3770 
3771 	if (hp1_pin_sense || spec->ultra_low_power)
3772 		snd_hda_codec_write(codec, hp_pin, 0,
3773 			    AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT);
3774 	if (hp2_pin_sense)
3775 		snd_hda_codec_write(codec, 0x16, 0,
3776 			    AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT);
3777 
3778 	if (hp1_pin_sense || hp2_pin_sense || spec->ultra_low_power)
3779 		msleep(100);
3780 
3781 	alc_update_coef_idx(codec, 0x4a, 3 << 10, 0);
3782 	alc_update_coefex_idx(codec, 0x57, 0x04, 0x0007, 0x4); /* Hight power */
3783 }
3784 
3785 static void alc225_shutup(struct hda_codec *codec)
3786 {
3787 	struct alc_spec *spec = codec->spec;
3788 	hda_nid_t hp_pin = alc_get_hp_pin(spec);
3789 	bool hp1_pin_sense, hp2_pin_sense;
3790 
3791 	if (!hp_pin)
3792 		hp_pin = 0x21;
3793 
3794 	alc_disable_headset_jack_key(codec);
3795 	/* 3k pull low control for Headset jack. */
3796 	alc_update_coef_idx(codec, 0x4a, 0, 3 << 10);
3797 
3798 	hp1_pin_sense = snd_hda_jack_detect(codec, hp_pin);
3799 	hp2_pin_sense = snd_hda_jack_detect(codec, 0x16);
3800 
3801 	if (hp1_pin_sense || hp2_pin_sense)
3802 		msleep(2);
3803 
3804 	if (hp1_pin_sense || spec->ultra_low_power)
3805 		snd_hda_codec_write(codec, hp_pin, 0,
3806 			    AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);
3807 	if (hp2_pin_sense)
3808 		snd_hda_codec_write(codec, 0x16, 0,
3809 			    AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);
3810 
3811 	if (hp1_pin_sense || hp2_pin_sense || spec->ultra_low_power)
3812 		msleep(85);
3813 
3814 	if (hp1_pin_sense || spec->ultra_low_power)
3815 		snd_hda_codec_write(codec, hp_pin, 0,
3816 			    AC_VERB_SET_PIN_WIDGET_CONTROL, 0x0);
3817 	if (hp2_pin_sense)
3818 		snd_hda_codec_write(codec, 0x16, 0,
3819 			    AC_VERB_SET_PIN_WIDGET_CONTROL, 0x0);
3820 
3821 	if (hp1_pin_sense || hp2_pin_sense || spec->ultra_low_power)
3822 		msleep(100);
3823 
3824 	alc_auto_setup_eapd(codec, false);
3825 	alc_shutup_pins(codec);
3826 	if (spec->ultra_low_power) {
3827 		msleep(50);
3828 		alc_update_coef_idx(codec, 0x08, 0x0f << 2, 0x0c << 2);
3829 		alc_update_coef_idx(codec, 0x0e, 7<<6, 0);
3830 		alc_update_coef_idx(codec, 0x33, 1<<11, 1<<11);
3831 		alc_update_coef_idx(codec, 0x4a, 3<<4, 2<<4);
3832 		msleep(30);
3833 	}
3834 
3835 	alc_update_coef_idx(codec, 0x4a, 3 << 10, 0);
3836 	alc_enable_headset_jack_key(codec);
3837 }
3838 
3839 static void alc_default_init(struct hda_codec *codec)
3840 {
3841 	struct alc_spec *spec = codec->spec;
3842 	hda_nid_t hp_pin = alc_get_hp_pin(spec);
3843 	bool hp_pin_sense;
3844 
3845 	if (!hp_pin)
3846 		return;
3847 
3848 	msleep(30);
3849 
3850 	hp_pin_sense = snd_hda_jack_detect(codec, hp_pin);
3851 
3852 	if (hp_pin_sense)
3853 		msleep(2);
3854 
3855 	snd_hda_codec_write(codec, hp_pin, 0,
3856 			    AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);
3857 
3858 	if (hp_pin_sense)
3859 		msleep(85);
3860 
3861 	snd_hda_codec_write(codec, hp_pin, 0,
3862 			    AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT);
3863 
3864 	if (hp_pin_sense)
3865 		msleep(100);
3866 }
3867 
3868 static void alc_default_shutup(struct hda_codec *codec)
3869 {
3870 	struct alc_spec *spec = codec->spec;
3871 	hda_nid_t hp_pin = alc_get_hp_pin(spec);
3872 	bool hp_pin_sense;
3873 
3874 	if (!hp_pin) {
3875 		alc269_shutup(codec);
3876 		return;
3877 	}
3878 
3879 	hp_pin_sense = snd_hda_jack_detect(codec, hp_pin);
3880 
3881 	if (hp_pin_sense)
3882 		msleep(2);
3883 
3884 	snd_hda_codec_write(codec, hp_pin, 0,
3885 			    AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);
3886 
3887 	if (hp_pin_sense)
3888 		msleep(85);
3889 
3890 	if (!spec->no_shutup_pins)
3891 		snd_hda_codec_write(codec, hp_pin, 0,
3892 				    AC_VERB_SET_PIN_WIDGET_CONTROL, 0x0);
3893 
3894 	if (hp_pin_sense)
3895 		msleep(100);
3896 
3897 	alc_auto_setup_eapd(codec, false);
3898 	alc_shutup_pins(codec);
3899 }
3900 
3901 static void alc294_hp_init(struct hda_codec *codec)
3902 {
3903 	struct alc_spec *spec = codec->spec;
3904 	hda_nid_t hp_pin = alc_get_hp_pin(spec);
3905 	int i, val;
3906 
3907 	if (!hp_pin)
3908 		return;
3909 
3910 	snd_hda_codec_write(codec, hp_pin, 0,
3911 			    AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);
3912 
3913 	msleep(100);
3914 
3915 	if (!spec->no_shutup_pins)
3916 		snd_hda_codec_write(codec, hp_pin, 0,
3917 				    AC_VERB_SET_PIN_WIDGET_CONTROL, 0x0);
3918 
3919 	alc_update_coef_idx(codec, 0x6f, 0x000f, 0);/* Set HP depop to manual mode */
3920 	alc_update_coefex_idx(codec, 0x58, 0x00, 0x8000, 0x8000); /* HP depop procedure start */
3921 
3922 	/* Wait for depop procedure finish  */
3923 	val = alc_read_coefex_idx(codec, 0x58, 0x01);
3924 	for (i = 0; i < 20 && val & 0x0080; i++) {
3925 		msleep(50);
3926 		val = alc_read_coefex_idx(codec, 0x58, 0x01);
3927 	}
3928 	/* Set HP depop to auto mode */
3929 	alc_update_coef_idx(codec, 0x6f, 0x000f, 0x000b);
3930 	msleep(50);
3931 }
3932 
3933 static void alc294_init(struct hda_codec *codec)
3934 {
3935 	struct alc_spec *spec = codec->spec;
3936 
3937 	/* required only at boot or S4 resume time */
3938 	if (!spec->done_hp_init ||
3939 	    codec->core.dev.power.power_state.event == PM_EVENT_RESTORE) {
3940 		alc294_hp_init(codec);
3941 		spec->done_hp_init = true;
3942 	}
3943 	alc_default_init(codec);
3944 }
3945 
3946 static void alc5505_coef_set(struct hda_codec *codec, unsigned int index_reg,
3947 			     unsigned int val)
3948 {
3949 	snd_hda_codec_write(codec, 0x51, 0, AC_VERB_SET_COEF_INDEX, index_reg >> 1);
3950 	snd_hda_codec_write(codec, 0x51, 0, AC_VERB_SET_PROC_COEF, val & 0xffff); /* LSB */
3951 	snd_hda_codec_write(codec, 0x51, 0, AC_VERB_SET_PROC_COEF, val >> 16); /* MSB */
3952 }
3953 
3954 static int alc5505_coef_get(struct hda_codec *codec, unsigned int index_reg)
3955 {
3956 	unsigned int val;
3957 
3958 	snd_hda_codec_write(codec, 0x51, 0, AC_VERB_SET_COEF_INDEX, index_reg >> 1);
3959 	val = snd_hda_codec_read(codec, 0x51, 0, AC_VERB_GET_PROC_COEF, 0)
3960 		& 0xffff;
3961 	val |= snd_hda_codec_read(codec, 0x51, 0, AC_VERB_GET_PROC_COEF, 0)
3962 		<< 16;
3963 	return val;
3964 }
3965 
3966 static void alc5505_dsp_halt(struct hda_codec *codec)
3967 {
3968 	unsigned int val;
3969 
3970 	alc5505_coef_set(codec, 0x3000, 0x000c); /* DSP CPU stop */
3971 	alc5505_coef_set(codec, 0x880c, 0x0008); /* DDR enter self refresh */
3972 	alc5505_coef_set(codec, 0x61c0, 0x11110080); /* Clock control for PLL and CPU */
3973 	alc5505_coef_set(codec, 0x6230, 0xfc0d4011); /* Disable Input OP */
3974 	alc5505_coef_set(codec, 0x61b4, 0x040a2b03); /* Stop PLL2 */
3975 	alc5505_coef_set(codec, 0x61b0, 0x00005b17); /* Stop PLL1 */
3976 	alc5505_coef_set(codec, 0x61b8, 0x04133303); /* Stop PLL3 */
3977 	val = alc5505_coef_get(codec, 0x6220);
3978 	alc5505_coef_set(codec, 0x6220, (val | 0x3000)); /* switch Ringbuffer clock to DBUS clock */
3979 }
3980 
3981 static void alc5505_dsp_back_from_halt(struct hda_codec *codec)
3982 {
3983 	alc5505_coef_set(codec, 0x61b8, 0x04133302);
3984 	alc5505_coef_set(codec, 0x61b0, 0x00005b16);
3985 	alc5505_coef_set(codec, 0x61b4, 0x040a2b02);
3986 	alc5505_coef_set(codec, 0x6230, 0xf80d4011);
3987 	alc5505_coef_set(codec, 0x6220, 0x2002010f);
3988 	alc5505_coef_set(codec, 0x880c, 0x00000004);
3989 }
3990 
3991 static void alc5505_dsp_init(struct hda_codec *codec)
3992 {
3993 	unsigned int val;
3994 
3995 	alc5505_dsp_halt(codec);
3996 	alc5505_dsp_back_from_halt(codec);
3997 	alc5505_coef_set(codec, 0x61b0, 0x5b14); /* PLL1 control */
3998 	alc5505_coef_set(codec, 0x61b0, 0x5b16);
3999 	alc5505_coef_set(codec, 0x61b4, 0x04132b00); /* PLL2 control */
4000 	alc5505_coef_set(codec, 0x61b4, 0x04132b02);
4001 	alc5505_coef_set(codec, 0x61b8, 0x041f3300); /* PLL3 control*/
4002 	alc5505_coef_set(codec, 0x61b8, 0x041f3302);
4003 	snd_hda_codec_write(codec, 0x51, 0, AC_VERB_SET_CODEC_RESET, 0); /* Function reset */
4004 	alc5505_coef_set(codec, 0x61b8, 0x041b3302);
4005 	alc5505_coef_set(codec, 0x61b8, 0x04173302);
4006 	alc5505_coef_set(codec, 0x61b8, 0x04163302);
4007 	alc5505_coef_set(codec, 0x8800, 0x348b328b); /* DRAM control */
4008 	alc5505_coef_set(codec, 0x8808, 0x00020022); /* DRAM control */
4009 	alc5505_coef_set(codec, 0x8818, 0x00000400); /* DRAM control */
4010 
4011 	val = alc5505_coef_get(codec, 0x6200) >> 16; /* Read revision ID */
4012 	if (val <= 3)
4013 		alc5505_coef_set(codec, 0x6220, 0x2002010f); /* I/O PAD Configuration */
4014 	else
4015 		alc5505_coef_set(codec, 0x6220, 0x6002018f);
4016 
4017 	alc5505_coef_set(codec, 0x61ac, 0x055525f0); /**/
4018 	alc5505_coef_set(codec, 0x61c0, 0x12230080); /* Clock control */
4019 	alc5505_coef_set(codec, 0x61b4, 0x040e2b02); /* PLL2 control */
4020 	alc5505_coef_set(codec, 0x61bc, 0x010234f8); /* OSC Control */
4021 	alc5505_coef_set(codec, 0x880c, 0x00000004); /* DRAM Function control */
4022 	alc5505_coef_set(codec, 0x880c, 0x00000003);
4023 	alc5505_coef_set(codec, 0x880c, 0x00000010);
4024 
4025 #ifdef HALT_REALTEK_ALC5505
4026 	alc5505_dsp_halt(codec);
4027 #endif
4028 }
4029 
4030 #ifdef HALT_REALTEK_ALC5505
4031 #define alc5505_dsp_suspend(codec)	do { } while (0) /* NOP */
4032 #define alc5505_dsp_resume(codec)	do { } while (0) /* NOP */
4033 #else
4034 #define alc5505_dsp_suspend(codec)	alc5505_dsp_halt(codec)
4035 #define alc5505_dsp_resume(codec)	alc5505_dsp_back_from_halt(codec)
4036 #endif
4037 
4038 static int alc269_suspend(struct hda_codec *codec)
4039 {
4040 	struct alc_spec *spec = codec->spec;
4041 
4042 	if (spec->has_alc5505_dsp)
4043 		alc5505_dsp_suspend(codec);
4044 
4045 	return alc_suspend(codec);
4046 }
4047 
4048 static int alc269_resume(struct hda_codec *codec)
4049 {
4050 	struct alc_spec *spec = codec->spec;
4051 
4052 	if (spec->codec_variant == ALC269_TYPE_ALC269VB)
4053 		alc269vb_toggle_power_output(codec, 0);
4054 	if (spec->codec_variant == ALC269_TYPE_ALC269VB &&
4055 			(alc_get_coef0(codec) & 0x00ff) == 0x018) {
4056 		msleep(150);
4057 	}
4058 
4059 	codec->patch_ops.init(codec);
4060 
4061 	if (spec->codec_variant == ALC269_TYPE_ALC269VB)
4062 		alc269vb_toggle_power_output(codec, 1);
4063 	if (spec->codec_variant == ALC269_TYPE_ALC269VB &&
4064 			(alc_get_coef0(codec) & 0x00ff) == 0x017) {
4065 		msleep(200);
4066 	}
4067 
4068 	snd_hda_regmap_sync(codec);
4069 	hda_call_check_power_status(codec, 0x01);
4070 
4071 	/* on some machine, the BIOS will clear the codec gpio data when enter
4072 	 * suspend, and won't restore the data after resume, so we restore it
4073 	 * in the driver.
4074 	 */
4075 	if (spec->gpio_data)
4076 		alc_write_gpio_data(codec);
4077 
4078 	if (spec->has_alc5505_dsp)
4079 		alc5505_dsp_resume(codec);
4080 
4081 	return 0;
4082 }
4083 
4084 static void alc269_fixup_pincfg_no_hp_to_lineout(struct hda_codec *codec,
4085 						 const struct hda_fixup *fix, int action)
4086 {
4087 	struct alc_spec *spec = codec->spec;
4088 
4089 	if (action == HDA_FIXUP_ACT_PRE_PROBE)
4090 		spec->parse_flags = HDA_PINCFG_NO_HP_FIXUP;
4091 }
4092 
4093 static void alc269_fixup_pincfg_U7x7_headset_mic(struct hda_codec *codec,
4094 						 const struct hda_fixup *fix,
4095 						 int action)
4096 {
4097 	unsigned int cfg_headphone = snd_hda_codec_get_pincfg(codec, 0x21);
4098 	unsigned int cfg_headset_mic = snd_hda_codec_get_pincfg(codec, 0x19);
4099 
4100 	if (cfg_headphone && cfg_headset_mic == 0x411111f0)
4101 		snd_hda_codec_set_pincfg(codec, 0x19,
4102 			(cfg_headphone & ~AC_DEFCFG_DEVICE) |
4103 			(AC_JACK_MIC_IN << AC_DEFCFG_DEVICE_SHIFT));
4104 }
4105 
4106 static void alc269_fixup_hweq(struct hda_codec *codec,
4107 			       const struct hda_fixup *fix, int action)
4108 {
4109 	if (action == HDA_FIXUP_ACT_INIT)
4110 		alc_update_coef_idx(codec, 0x1e, 0, 0x80);
4111 }
4112 
4113 static void alc269_fixup_headset_mic(struct hda_codec *codec,
4114 				       const struct hda_fixup *fix, int action)
4115 {
4116 	struct alc_spec *spec = codec->spec;
4117 
4118 	if (action == HDA_FIXUP_ACT_PRE_PROBE)
4119 		spec->parse_flags |= HDA_PINCFG_HEADSET_MIC;
4120 }
4121 
4122 static void alc271_fixup_dmic(struct hda_codec *codec,
4123 			      const struct hda_fixup *fix, int action)
4124 {
4125 	static const struct hda_verb verbs[] = {
4126 		{0x20, AC_VERB_SET_COEF_INDEX, 0x0d},
4127 		{0x20, AC_VERB_SET_PROC_COEF, 0x4000},
4128 		{}
4129 	};
4130 	unsigned int cfg;
4131 
4132 	if (strcmp(codec->core.chip_name, "ALC271X") &&
4133 	    strcmp(codec->core.chip_name, "ALC269VB"))
4134 		return;
4135 	cfg = snd_hda_codec_get_pincfg(codec, 0x12);
4136 	if (get_defcfg_connect(cfg) == AC_JACK_PORT_FIXED)
4137 		snd_hda_sequence_write(codec, verbs);
4138 }
4139 
4140 /* Fix the speaker amp after resume, etc */
4141 static void alc269vb_fixup_aspire_e1_coef(struct hda_codec *codec,
4142 					  const struct hda_fixup *fix,
4143 					  int action)
4144 {
4145 	if (action == HDA_FIXUP_ACT_INIT)
4146 		alc_update_coef_idx(codec, 0x0d, 0x6000, 0x6000);
4147 }
4148 
4149 static void alc269_fixup_pcm_44k(struct hda_codec *codec,
4150 				 const struct hda_fixup *fix, int action)
4151 {
4152 	struct alc_spec *spec = codec->spec;
4153 
4154 	if (action != HDA_FIXUP_ACT_PROBE)
4155 		return;
4156 
4157 	/* Due to a hardware problem on Lenovo Ideadpad, we need to
4158 	 * fix the sample rate of analog I/O to 44.1kHz
4159 	 */
4160 	spec->gen.stream_analog_playback = &alc269_44k_pcm_analog_playback;
4161 	spec->gen.stream_analog_capture = &alc269_44k_pcm_analog_capture;
4162 }
4163 
4164 static void alc269_fixup_stereo_dmic(struct hda_codec *codec,
4165 				     const struct hda_fixup *fix, int action)
4166 {
4167 	/* The digital-mic unit sends PDM (differential signal) instead of
4168 	 * the standard PCM, thus you can't record a valid mono stream as is.
4169 	 * Below is a workaround specific to ALC269 to control the dmic
4170 	 * signal source as mono.
4171 	 */
4172 	if (action == HDA_FIXUP_ACT_INIT)
4173 		alc_update_coef_idx(codec, 0x07, 0, 0x80);
4174 }
4175 
4176 static void alc269_quanta_automute(struct hda_codec *codec)
4177 {
4178 	snd_hda_gen_update_outputs(codec);
4179 
4180 	alc_write_coef_idx(codec, 0x0c, 0x680);
4181 	alc_write_coef_idx(codec, 0x0c, 0x480);
4182 }
4183 
4184 static void alc269_fixup_quanta_mute(struct hda_codec *codec,
4185 				     const struct hda_fixup *fix, int action)
4186 {
4187 	struct alc_spec *spec = codec->spec;
4188 	if (action != HDA_FIXUP_ACT_PROBE)
4189 		return;
4190 	spec->gen.automute_hook = alc269_quanta_automute;
4191 }
4192 
4193 static void alc269_x101_hp_automute_hook(struct hda_codec *codec,
4194 					 struct hda_jack_callback *jack)
4195 {
4196 	struct alc_spec *spec = codec->spec;
4197 	int vref;
4198 	msleep(200);
4199 	snd_hda_gen_hp_automute(codec, jack);
4200 
4201 	vref = spec->gen.hp_jack_present ? PIN_VREF80 : 0;
4202 	msleep(100);
4203 	snd_hda_codec_write(codec, 0x18, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
4204 			    vref);
4205 	msleep(500);
4206 	snd_hda_codec_write(codec, 0x18, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
4207 			    vref);
4208 }
4209 
4210 /*
4211  * Magic sequence to make Huawei Matebook X right speaker working (bko#197801)
4212  */
4213 struct hda_alc298_mbxinit {
4214 	unsigned char value_0x23;
4215 	unsigned char value_0x25;
4216 };
4217 
4218 static void alc298_huawei_mbx_stereo_seq(struct hda_codec *codec,
4219 					 const struct hda_alc298_mbxinit *initval,
4220 					 bool first)
4221 {
4222 	snd_hda_codec_write(codec, 0x06, 0, AC_VERB_SET_DIGI_CONVERT_3, 0x0);
4223 	alc_write_coef_idx(codec, 0x26, 0xb000);
4224 
4225 	if (first)
4226 		snd_hda_codec_write(codec, 0x21, 0, AC_VERB_GET_PIN_SENSE, 0x0);
4227 
4228 	snd_hda_codec_write(codec, 0x6, 0, AC_VERB_SET_DIGI_CONVERT_3, 0x80);
4229 	alc_write_coef_idx(codec, 0x26, 0xf000);
4230 	alc_write_coef_idx(codec, 0x23, initval->value_0x23);
4231 
4232 	if (initval->value_0x23 != 0x1e)
4233 		alc_write_coef_idx(codec, 0x25, initval->value_0x25);
4234 
4235 	snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_COEF_INDEX, 0x26);
4236 	snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_PROC_COEF, 0xb010);
4237 }
4238 
4239 static void alc298_fixup_huawei_mbx_stereo(struct hda_codec *codec,
4240 					   const struct hda_fixup *fix,
4241 					   int action)
4242 {
4243 	/* Initialization magic */
4244 	static const struct hda_alc298_mbxinit dac_init[] = {
4245 		{0x0c, 0x00}, {0x0d, 0x00}, {0x0e, 0x00}, {0x0f, 0x00},
4246 		{0x10, 0x00}, {0x1a, 0x40}, {0x1b, 0x82}, {0x1c, 0x00},
4247 		{0x1d, 0x00}, {0x1e, 0x00}, {0x1f, 0x00},
4248 		{0x20, 0xc2}, {0x21, 0xc8}, {0x22, 0x26}, {0x23, 0x24},
4249 		{0x27, 0xff}, {0x28, 0xff}, {0x29, 0xff}, {0x2a, 0x8f},
4250 		{0x2b, 0x02}, {0x2c, 0x48}, {0x2d, 0x34}, {0x2e, 0x00},
4251 		{0x2f, 0x00},
4252 		{0x30, 0x00}, {0x31, 0x00}, {0x32, 0x00}, {0x33, 0x00},
4253 		{0x34, 0x00}, {0x35, 0x01}, {0x36, 0x93}, {0x37, 0x0c},
4254 		{0x38, 0x00}, {0x39, 0x00}, {0x3a, 0xf8}, {0x38, 0x80},
4255 		{}
4256 	};
4257 	const struct hda_alc298_mbxinit *seq;
4258 
4259 	if (action != HDA_FIXUP_ACT_INIT)
4260 		return;
4261 
4262 	/* Start */
4263 	snd_hda_codec_write(codec, 0x06, 0, AC_VERB_SET_DIGI_CONVERT_3, 0x00);
4264 	snd_hda_codec_write(codec, 0x06, 0, AC_VERB_SET_DIGI_CONVERT_3, 0x80);
4265 	alc_write_coef_idx(codec, 0x26, 0xf000);
4266 	alc_write_coef_idx(codec, 0x22, 0x31);
4267 	alc_write_coef_idx(codec, 0x23, 0x0b);
4268 	alc_write_coef_idx(codec, 0x25, 0x00);
4269 	snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_COEF_INDEX, 0x26);
4270 	snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_PROC_COEF, 0xb010);
4271 
4272 	for (seq = dac_init; seq->value_0x23; seq++)
4273 		alc298_huawei_mbx_stereo_seq(codec, seq, seq == dac_init);
4274 }
4275 
4276 static void alc269_fixup_x101_headset_mic(struct hda_codec *codec,
4277 				     const struct hda_fixup *fix, int action)
4278 {
4279 	struct alc_spec *spec = codec->spec;
4280 	if (action == HDA_FIXUP_ACT_PRE_PROBE) {
4281 		spec->parse_flags |= HDA_PINCFG_HEADSET_MIC;
4282 		spec->gen.hp_automute_hook = alc269_x101_hp_automute_hook;
4283 	}
4284 }
4285 
4286 static void alc_update_vref_led(struct hda_codec *codec, hda_nid_t pin,
4287 				bool polarity, bool on)
4288 {
4289 	unsigned int pinval;
4290 
4291 	if (!pin)
4292 		return;
4293 	if (polarity)
4294 		on = !on;
4295 	pinval = snd_hda_codec_get_pin_target(codec, pin);
4296 	pinval &= ~AC_PINCTL_VREFEN;
4297 	pinval |= on ? AC_PINCTL_VREF_80 : AC_PINCTL_VREF_HIZ;
4298 	/* temporarily power up/down for setting VREF */
4299 	snd_hda_power_up_pm(codec);
4300 	snd_hda_set_pin_ctl_cache(codec, pin, pinval);
4301 	snd_hda_power_down_pm(codec);
4302 }
4303 
4304 /* update mute-LED according to the speaker mute state via mic VREF pin */
4305 static int vref_mute_led_set(struct led_classdev *led_cdev,
4306 			     enum led_brightness brightness)
4307 {
4308 	struct hda_codec *codec = dev_to_hda_codec(led_cdev->dev->parent);
4309 	struct alc_spec *spec = codec->spec;
4310 
4311 	alc_update_vref_led(codec, spec->mute_led_nid,
4312 			    spec->mute_led_polarity, brightness);
4313 	return 0;
4314 }
4315 
4316 /* Make sure the led works even in runtime suspend */
4317 static unsigned int led_power_filter(struct hda_codec *codec,
4318 						  hda_nid_t nid,
4319 						  unsigned int power_state)
4320 {
4321 	struct alc_spec *spec = codec->spec;
4322 
4323 	if (power_state != AC_PWRST_D3 || nid == 0 ||
4324 	    (nid != spec->mute_led_nid && nid != spec->cap_mute_led_nid))
4325 		return power_state;
4326 
4327 	/* Set pin ctl again, it might have just been set to 0 */
4328 	snd_hda_set_pin_ctl(codec, nid,
4329 			    snd_hda_codec_get_pin_target(codec, nid));
4330 
4331 	return snd_hda_gen_path_power_filter(codec, nid, power_state);
4332 }
4333 
4334 static void alc269_fixup_hp_mute_led(struct hda_codec *codec,
4335 				     const struct hda_fixup *fix, int action)
4336 {
4337 	struct alc_spec *spec = codec->spec;
4338 	const struct dmi_device *dev = NULL;
4339 
4340 	if (action != HDA_FIXUP_ACT_PRE_PROBE)
4341 		return;
4342 
4343 	while ((dev = dmi_find_device(DMI_DEV_TYPE_OEM_STRING, NULL, dev))) {
4344 		int pol, pin;
4345 		if (sscanf(dev->name, "HP_Mute_LED_%d_%x", &pol, &pin) != 2)
4346 			continue;
4347 		if (pin < 0x0a || pin >= 0x10)
4348 			break;
4349 		spec->mute_led_polarity = pol;
4350 		spec->mute_led_nid = pin - 0x0a + 0x18;
4351 		snd_hda_gen_add_mute_led_cdev(codec, vref_mute_led_set);
4352 		codec->power_filter = led_power_filter;
4353 		codec_dbg(codec,
4354 			  "Detected mute LED for %x:%d\n", spec->mute_led_nid,
4355 			   spec->mute_led_polarity);
4356 		break;
4357 	}
4358 }
4359 
4360 static void alc269_fixup_hp_mute_led_micx(struct hda_codec *codec,
4361 					  const struct hda_fixup *fix,
4362 					  int action, hda_nid_t pin)
4363 {
4364 	struct alc_spec *spec = codec->spec;
4365 
4366 	if (action == HDA_FIXUP_ACT_PRE_PROBE) {
4367 		spec->mute_led_polarity = 0;
4368 		spec->mute_led_nid = pin;
4369 		snd_hda_gen_add_mute_led_cdev(codec, vref_mute_led_set);
4370 		codec->power_filter = led_power_filter;
4371 	}
4372 }
4373 
4374 static void alc269_fixup_hp_mute_led_mic1(struct hda_codec *codec,
4375 				const struct hda_fixup *fix, int action)
4376 {
4377 	alc269_fixup_hp_mute_led_micx(codec, fix, action, 0x18);
4378 }
4379 
4380 static void alc269_fixup_hp_mute_led_mic2(struct hda_codec *codec,
4381 				const struct hda_fixup *fix, int action)
4382 {
4383 	alc269_fixup_hp_mute_led_micx(codec, fix, action, 0x19);
4384 }
4385 
4386 static void alc269_fixup_hp_mute_led_mic3(struct hda_codec *codec,
4387 				const struct hda_fixup *fix, int action)
4388 {
4389 	alc269_fixup_hp_mute_led_micx(codec, fix, action, 0x1b);
4390 }
4391 
4392 /* update LED status via GPIO */
4393 static void alc_update_gpio_led(struct hda_codec *codec, unsigned int mask,
4394 				int polarity, bool enabled)
4395 {
4396 	if (polarity)
4397 		enabled = !enabled;
4398 	alc_update_gpio_data(codec, mask, !enabled); /* muted -> LED on */
4399 }
4400 
4401 /* turn on/off mute LED via GPIO per vmaster hook */
4402 static int gpio_mute_led_set(struct led_classdev *led_cdev,
4403 			     enum led_brightness brightness)
4404 {
4405 	struct hda_codec *codec = dev_to_hda_codec(led_cdev->dev->parent);
4406 	struct alc_spec *spec = codec->spec;
4407 
4408 	alc_update_gpio_led(codec, spec->gpio_mute_led_mask,
4409 			    spec->mute_led_polarity, !brightness);
4410 	return 0;
4411 }
4412 
4413 /* turn on/off mic-mute LED via GPIO per capture hook */
4414 static int micmute_led_set(struct led_classdev *led_cdev,
4415 			   enum led_brightness brightness)
4416 {
4417 	struct hda_codec *codec = dev_to_hda_codec(led_cdev->dev->parent);
4418 	struct alc_spec *spec = codec->spec;
4419 
4420 	alc_update_gpio_led(codec, spec->gpio_mic_led_mask,
4421 			    spec->micmute_led_polarity, !brightness);
4422 	return 0;
4423 }
4424 
4425 /* setup mute and mic-mute GPIO bits, add hooks appropriately */
4426 static void alc_fixup_hp_gpio_led(struct hda_codec *codec,
4427 				  int action,
4428 				  unsigned int mute_mask,
4429 				  unsigned int micmute_mask)
4430 {
4431 	struct alc_spec *spec = codec->spec;
4432 
4433 	alc_fixup_gpio(codec, action, mute_mask | micmute_mask);
4434 
4435 	if (action != HDA_FIXUP_ACT_PRE_PROBE)
4436 		return;
4437 	if (mute_mask) {
4438 		spec->gpio_mute_led_mask = mute_mask;
4439 		snd_hda_gen_add_mute_led_cdev(codec, gpio_mute_led_set);
4440 	}
4441 	if (micmute_mask) {
4442 		spec->gpio_mic_led_mask = micmute_mask;
4443 		snd_hda_gen_add_micmute_led_cdev(codec, micmute_led_set);
4444 	}
4445 }
4446 
4447 static void alc236_fixup_hp_gpio_led(struct hda_codec *codec,
4448 				const struct hda_fixup *fix, int action)
4449 {
4450 	alc_fixup_hp_gpio_led(codec, action, 0x02, 0x01);
4451 }
4452 
4453 static void alc269_fixup_hp_gpio_led(struct hda_codec *codec,
4454 				const struct hda_fixup *fix, int action)
4455 {
4456 	alc_fixup_hp_gpio_led(codec, action, 0x08, 0x10);
4457 }
4458 
4459 static void alc285_fixup_hp_gpio_led(struct hda_codec *codec,
4460 				const struct hda_fixup *fix, int action)
4461 {
4462 	alc_fixup_hp_gpio_led(codec, action, 0x04, 0x01);
4463 }
4464 
4465 static void alc286_fixup_hp_gpio_led(struct hda_codec *codec,
4466 				const struct hda_fixup *fix, int action)
4467 {
4468 	alc_fixup_hp_gpio_led(codec, action, 0x02, 0x20);
4469 }
4470 
4471 static void alc287_fixup_hp_gpio_led(struct hda_codec *codec,
4472 				const struct hda_fixup *fix, int action)
4473 {
4474 	alc_fixup_hp_gpio_led(codec, action, 0x10, 0);
4475 }
4476 
4477 static void alc245_fixup_hp_gpio_led(struct hda_codec *codec,
4478 				const struct hda_fixup *fix, int action)
4479 {
4480 	struct alc_spec *spec = codec->spec;
4481 
4482 	if (action == HDA_FIXUP_ACT_PRE_PROBE)
4483 		spec->micmute_led_polarity = 1;
4484 	alc_fixup_hp_gpio_led(codec, action, 0, 0x04);
4485 }
4486 
4487 /* turn on/off mic-mute LED per capture hook via VREF change */
4488 static int vref_micmute_led_set(struct led_classdev *led_cdev,
4489 				enum led_brightness brightness)
4490 {
4491 	struct hda_codec *codec = dev_to_hda_codec(led_cdev->dev->parent);
4492 	struct alc_spec *spec = codec->spec;
4493 
4494 	alc_update_vref_led(codec, spec->cap_mute_led_nid,
4495 			    spec->micmute_led_polarity, brightness);
4496 	return 0;
4497 }
4498 
4499 static void alc269_fixup_hp_gpio_mic1_led(struct hda_codec *codec,
4500 				const struct hda_fixup *fix, int action)
4501 {
4502 	struct alc_spec *spec = codec->spec;
4503 
4504 	alc_fixup_hp_gpio_led(codec, action, 0x08, 0);
4505 	if (action == HDA_FIXUP_ACT_PRE_PROBE) {
4506 		/* Like hp_gpio_mic1_led, but also needs GPIO4 low to
4507 		 * enable headphone amp
4508 		 */
4509 		spec->gpio_mask |= 0x10;
4510 		spec->gpio_dir |= 0x10;
4511 		spec->cap_mute_led_nid = 0x18;
4512 		snd_hda_gen_add_micmute_led_cdev(codec, vref_micmute_led_set);
4513 		codec->power_filter = led_power_filter;
4514 	}
4515 }
4516 
4517 static void alc280_fixup_hp_gpio4(struct hda_codec *codec,
4518 				   const struct hda_fixup *fix, int action)
4519 {
4520 	struct alc_spec *spec = codec->spec;
4521 
4522 	alc_fixup_hp_gpio_led(codec, action, 0x08, 0);
4523 	if (action == HDA_FIXUP_ACT_PRE_PROBE) {
4524 		spec->cap_mute_led_nid = 0x18;
4525 		snd_hda_gen_add_micmute_led_cdev(codec, vref_micmute_led_set);
4526 		codec->power_filter = led_power_filter;
4527 	}
4528 }
4529 
4530 /* HP Spectre x360 14 model needs a unique workaround for enabling the amp;
4531  * it needs to toggle the GPIO0 once on and off at each time (bko#210633)
4532  */
4533 static void alc245_fixup_hp_x360_amp(struct hda_codec *codec,
4534 				     const struct hda_fixup *fix, int action)
4535 {
4536 	struct alc_spec *spec = codec->spec;
4537 
4538 	switch (action) {
4539 	case HDA_FIXUP_ACT_PRE_PROBE:
4540 		spec->gpio_mask |= 0x01;
4541 		spec->gpio_dir |= 0x01;
4542 		break;
4543 	case HDA_FIXUP_ACT_INIT:
4544 		/* need to toggle GPIO to enable the amp */
4545 		alc_update_gpio_data(codec, 0x01, true);
4546 		msleep(100);
4547 		alc_update_gpio_data(codec, 0x01, false);
4548 		break;
4549 	}
4550 }
4551 
4552 /* toggle GPIO2 at each time stream is started; we use PREPARE state instead */
4553 static void alc274_hp_envy_pcm_hook(struct hda_pcm_stream *hinfo,
4554 				    struct hda_codec *codec,
4555 				    struct snd_pcm_substream *substream,
4556 				    int action)
4557 {
4558 	switch (action) {
4559 	case HDA_GEN_PCM_ACT_PREPARE:
4560 		alc_update_gpio_data(codec, 0x04, true);
4561 		break;
4562 	case HDA_GEN_PCM_ACT_CLEANUP:
4563 		alc_update_gpio_data(codec, 0x04, false);
4564 		break;
4565 	}
4566 }
4567 
4568 static void alc274_fixup_hp_envy_gpio(struct hda_codec *codec,
4569 				      const struct hda_fixup *fix,
4570 				      int action)
4571 {
4572 	struct alc_spec *spec = codec->spec;
4573 
4574 	if (action == HDA_FIXUP_ACT_PROBE) {
4575 		spec->gpio_mask |= 0x04;
4576 		spec->gpio_dir |= 0x04;
4577 		spec->gen.pcm_playback_hook = alc274_hp_envy_pcm_hook;
4578 	}
4579 }
4580 
4581 static void alc_update_coef_led(struct hda_codec *codec,
4582 				struct alc_coef_led *led,
4583 				bool polarity, bool on)
4584 {
4585 	if (polarity)
4586 		on = !on;
4587 	/* temporarily power up/down for setting COEF bit */
4588 	alc_update_coef_idx(codec, led->idx, led->mask,
4589 			    on ? led->on : led->off);
4590 }
4591 
4592 /* update mute-LED according to the speaker mute state via COEF bit */
4593 static int coef_mute_led_set(struct led_classdev *led_cdev,
4594 			     enum led_brightness brightness)
4595 {
4596 	struct hda_codec *codec = dev_to_hda_codec(led_cdev->dev->parent);
4597 	struct alc_spec *spec = codec->spec;
4598 
4599 	alc_update_coef_led(codec, &spec->mute_led_coef,
4600 			    spec->mute_led_polarity, brightness);
4601 	return 0;
4602 }
4603 
4604 static void alc285_fixup_hp_mute_led_coefbit(struct hda_codec *codec,
4605 					  const struct hda_fixup *fix,
4606 					  int action)
4607 {
4608 	struct alc_spec *spec = codec->spec;
4609 
4610 	if (action == HDA_FIXUP_ACT_PRE_PROBE) {
4611 		spec->mute_led_polarity = 0;
4612 		spec->mute_led_coef.idx = 0x0b;
4613 		spec->mute_led_coef.mask = 1 << 3;
4614 		spec->mute_led_coef.on = 1 << 3;
4615 		spec->mute_led_coef.off = 0;
4616 		snd_hda_gen_add_mute_led_cdev(codec, coef_mute_led_set);
4617 	}
4618 }
4619 
4620 static void alc236_fixup_hp_mute_led_coefbit(struct hda_codec *codec,
4621 					  const struct hda_fixup *fix,
4622 					  int action)
4623 {
4624 	struct alc_spec *spec = codec->spec;
4625 
4626 	if (action == HDA_FIXUP_ACT_PRE_PROBE) {
4627 		spec->mute_led_polarity = 0;
4628 		spec->mute_led_coef.idx = 0x34;
4629 		spec->mute_led_coef.mask = 1 << 5;
4630 		spec->mute_led_coef.on = 0;
4631 		spec->mute_led_coef.off = 1 << 5;
4632 		snd_hda_gen_add_mute_led_cdev(codec, coef_mute_led_set);
4633 	}
4634 }
4635 
4636 static void alc236_fixup_hp_mute_led_coefbit2(struct hda_codec *codec,
4637 					  const struct hda_fixup *fix, int action)
4638 {
4639 	struct alc_spec *spec = codec->spec;
4640 
4641 	if (action == HDA_FIXUP_ACT_PRE_PROBE) {
4642 		spec->mute_led_polarity = 0;
4643 		spec->mute_led_coef.idx = 0x07;
4644 		spec->mute_led_coef.mask = 1;
4645 		spec->mute_led_coef.on = 1;
4646 		spec->mute_led_coef.off = 0;
4647 		snd_hda_gen_add_mute_led_cdev(codec, coef_mute_led_set);
4648 	}
4649 }
4650 
4651 static void alc245_fixup_hp_mute_led_coefbit(struct hda_codec *codec,
4652 					  const struct hda_fixup *fix,
4653 					  int action)
4654 {
4655 	struct alc_spec *spec = codec->spec;
4656 
4657 	if (action == HDA_FIXUP_ACT_PRE_PROBE) {
4658 		spec->mute_led_polarity = 0;
4659 		spec->mute_led_coef.idx = 0x0b;
4660 		spec->mute_led_coef.mask = 3 << 2;
4661 		spec->mute_led_coef.on = 2 << 2;
4662 		spec->mute_led_coef.off = 1 << 2;
4663 		snd_hda_gen_add_mute_led_cdev(codec, coef_mute_led_set);
4664 	}
4665 }
4666 
4667 /* turn on/off mic-mute LED per capture hook by coef bit */
4668 static int coef_micmute_led_set(struct led_classdev *led_cdev,
4669 				enum led_brightness brightness)
4670 {
4671 	struct hda_codec *codec = dev_to_hda_codec(led_cdev->dev->parent);
4672 	struct alc_spec *spec = codec->spec;
4673 
4674 	alc_update_coef_led(codec, &spec->mic_led_coef,
4675 			    spec->micmute_led_polarity, brightness);
4676 	return 0;
4677 }
4678 
4679 static void alc285_fixup_hp_coef_micmute_led(struct hda_codec *codec,
4680 				const struct hda_fixup *fix, int action)
4681 {
4682 	struct alc_spec *spec = codec->spec;
4683 
4684 	if (action == HDA_FIXUP_ACT_PRE_PROBE) {
4685 		spec->mic_led_coef.idx = 0x19;
4686 		spec->mic_led_coef.mask = 1 << 13;
4687 		spec->mic_led_coef.on = 1 << 13;
4688 		spec->mic_led_coef.off = 0;
4689 		snd_hda_gen_add_micmute_led_cdev(codec, coef_micmute_led_set);
4690 	}
4691 }
4692 
4693 static void alc285_fixup_hp_gpio_micmute_led(struct hda_codec *codec,
4694 				const struct hda_fixup *fix, int action)
4695 {
4696 	struct alc_spec *spec = codec->spec;
4697 
4698 	if (action == HDA_FIXUP_ACT_PRE_PROBE)
4699 		spec->micmute_led_polarity = 1;
4700 	alc_fixup_hp_gpio_led(codec, action, 0, 0x04);
4701 }
4702 
4703 static void alc236_fixup_hp_coef_micmute_led(struct hda_codec *codec,
4704 				const struct hda_fixup *fix, int action)
4705 {
4706 	struct alc_spec *spec = codec->spec;
4707 
4708 	if (action == HDA_FIXUP_ACT_PRE_PROBE) {
4709 		spec->mic_led_coef.idx = 0x35;
4710 		spec->mic_led_coef.mask = 3 << 2;
4711 		spec->mic_led_coef.on = 2 << 2;
4712 		spec->mic_led_coef.off = 1 << 2;
4713 		snd_hda_gen_add_micmute_led_cdev(codec, coef_micmute_led_set);
4714 	}
4715 }
4716 
4717 static void alc285_fixup_hp_mute_led(struct hda_codec *codec,
4718 				const struct hda_fixup *fix, int action)
4719 {
4720 	alc285_fixup_hp_mute_led_coefbit(codec, fix, action);
4721 	alc285_fixup_hp_coef_micmute_led(codec, fix, action);
4722 }
4723 
4724 static void alc285_fixup_hp_spectre_x360_mute_led(struct hda_codec *codec,
4725 				const struct hda_fixup *fix, int action)
4726 {
4727 	alc285_fixup_hp_mute_led_coefbit(codec, fix, action);
4728 	alc285_fixup_hp_gpio_micmute_led(codec, fix, action);
4729 }
4730 
4731 static void alc236_fixup_hp_mute_led(struct hda_codec *codec,
4732 				const struct hda_fixup *fix, int action)
4733 {
4734 	alc236_fixup_hp_mute_led_coefbit(codec, fix, action);
4735 	alc236_fixup_hp_coef_micmute_led(codec, fix, action);
4736 }
4737 
4738 static void alc236_fixup_hp_micmute_led_vref(struct hda_codec *codec,
4739 				const struct hda_fixup *fix, int action)
4740 {
4741 	struct alc_spec *spec = codec->spec;
4742 
4743 	if (action == HDA_FIXUP_ACT_PRE_PROBE) {
4744 		spec->cap_mute_led_nid = 0x1a;
4745 		snd_hda_gen_add_micmute_led_cdev(codec, vref_micmute_led_set);
4746 		codec->power_filter = led_power_filter;
4747 	}
4748 }
4749 
4750 static void alc236_fixup_hp_mute_led_micmute_vref(struct hda_codec *codec,
4751 				const struct hda_fixup *fix, int action)
4752 {
4753 	alc236_fixup_hp_mute_led_coefbit(codec, fix, action);
4754 	alc236_fixup_hp_micmute_led_vref(codec, fix, action);
4755 }
4756 
4757 static inline void alc298_samsung_write_coef_pack(struct hda_codec *codec,
4758 						  const unsigned short coefs[2])
4759 {
4760 	alc_write_coef_idx(codec, 0x23, coefs[0]);
4761 	alc_write_coef_idx(codec, 0x25, coefs[1]);
4762 	alc_write_coef_idx(codec, 0x26, 0xb011);
4763 }
4764 
4765 struct alc298_samsung_amp_desc {
4766 	unsigned char nid;
4767 	unsigned short init_seq[2][2];
4768 };
4769 
4770 static void alc298_fixup_samsung_amp(struct hda_codec *codec,
4771 				     const struct hda_fixup *fix, int action)
4772 {
4773 	int i, j;
4774 	static const unsigned short init_seq[][2] = {
4775 		{ 0x19, 0x00 }, { 0x20, 0xc0 }, { 0x22, 0x44 }, { 0x23, 0x08 },
4776 		{ 0x24, 0x85 }, { 0x25, 0x41 }, { 0x35, 0x40 }, { 0x36, 0x01 },
4777 		{ 0x38, 0x81 }, { 0x3a, 0x03 }, { 0x3b, 0x81 }, { 0x40, 0x3e },
4778 		{ 0x41, 0x07 }, { 0x400, 0x1 }
4779 	};
4780 	static const struct alc298_samsung_amp_desc amps[] = {
4781 		{ 0x3a, { { 0x18, 0x1 }, { 0x26, 0x0 } } },
4782 		{ 0x39, { { 0x18, 0x2 }, { 0x26, 0x1 } } }
4783 	};
4784 
4785 	if (action != HDA_FIXUP_ACT_INIT)
4786 		return;
4787 
4788 	for (i = 0; i < ARRAY_SIZE(amps); i++) {
4789 		alc_write_coef_idx(codec, 0x22, amps[i].nid);
4790 
4791 		for (j = 0; j < ARRAY_SIZE(amps[i].init_seq); j++)
4792 			alc298_samsung_write_coef_pack(codec, amps[i].init_seq[j]);
4793 
4794 		for (j = 0; j < ARRAY_SIZE(init_seq); j++)
4795 			alc298_samsung_write_coef_pack(codec, init_seq[j]);
4796 	}
4797 }
4798 
4799 #if IS_REACHABLE(CONFIG_INPUT)
4800 static void gpio2_mic_hotkey_event(struct hda_codec *codec,
4801 				   struct hda_jack_callback *event)
4802 {
4803 	struct alc_spec *spec = codec->spec;
4804 
4805 	/* GPIO2 just toggles on a keypress/keyrelease cycle. Therefore
4806 	   send both key on and key off event for every interrupt. */
4807 	input_report_key(spec->kb_dev, spec->alc_mute_keycode_map[ALC_KEY_MICMUTE_INDEX], 1);
4808 	input_sync(spec->kb_dev);
4809 	input_report_key(spec->kb_dev, spec->alc_mute_keycode_map[ALC_KEY_MICMUTE_INDEX], 0);
4810 	input_sync(spec->kb_dev);
4811 }
4812 
4813 static int alc_register_micmute_input_device(struct hda_codec *codec)
4814 {
4815 	struct alc_spec *spec = codec->spec;
4816 	int i;
4817 
4818 	spec->kb_dev = input_allocate_device();
4819 	if (!spec->kb_dev) {
4820 		codec_err(codec, "Out of memory (input_allocate_device)\n");
4821 		return -ENOMEM;
4822 	}
4823 
4824 	spec->alc_mute_keycode_map[ALC_KEY_MICMUTE_INDEX] = KEY_MICMUTE;
4825 
4826 	spec->kb_dev->name = "Microphone Mute Button";
4827 	spec->kb_dev->evbit[0] = BIT_MASK(EV_KEY);
4828 	spec->kb_dev->keycodesize = sizeof(spec->alc_mute_keycode_map[0]);
4829 	spec->kb_dev->keycodemax = ARRAY_SIZE(spec->alc_mute_keycode_map);
4830 	spec->kb_dev->keycode = spec->alc_mute_keycode_map;
4831 	for (i = 0; i < ARRAY_SIZE(spec->alc_mute_keycode_map); i++)
4832 		set_bit(spec->alc_mute_keycode_map[i], spec->kb_dev->keybit);
4833 
4834 	if (input_register_device(spec->kb_dev)) {
4835 		codec_err(codec, "input_register_device failed\n");
4836 		input_free_device(spec->kb_dev);
4837 		spec->kb_dev = NULL;
4838 		return -ENOMEM;
4839 	}
4840 
4841 	return 0;
4842 }
4843 
4844 /* GPIO1 = set according to SKU external amp
4845  * GPIO2 = mic mute hotkey
4846  * GPIO3 = mute LED
4847  * GPIO4 = mic mute LED
4848  */
4849 static void alc280_fixup_hp_gpio2_mic_hotkey(struct hda_codec *codec,
4850 					     const struct hda_fixup *fix, int action)
4851 {
4852 	struct alc_spec *spec = codec->spec;
4853 
4854 	alc_fixup_hp_gpio_led(codec, action, 0x08, 0x10);
4855 	if (action == HDA_FIXUP_ACT_PRE_PROBE) {
4856 		spec->init_amp = ALC_INIT_DEFAULT;
4857 		if (alc_register_micmute_input_device(codec) != 0)
4858 			return;
4859 
4860 		spec->gpio_mask |= 0x06;
4861 		spec->gpio_dir |= 0x02;
4862 		spec->gpio_data |= 0x02;
4863 		snd_hda_codec_write_cache(codec, codec->core.afg, 0,
4864 					  AC_VERB_SET_GPIO_UNSOLICITED_RSP_MASK, 0x04);
4865 		snd_hda_jack_detect_enable_callback(codec, codec->core.afg,
4866 						    gpio2_mic_hotkey_event);
4867 		return;
4868 	}
4869 
4870 	if (!spec->kb_dev)
4871 		return;
4872 
4873 	switch (action) {
4874 	case HDA_FIXUP_ACT_FREE:
4875 		input_unregister_device(spec->kb_dev);
4876 		spec->kb_dev = NULL;
4877 	}
4878 }
4879 
4880 /* Line2 = mic mute hotkey
4881  * GPIO2 = mic mute LED
4882  */
4883 static void alc233_fixup_lenovo_line2_mic_hotkey(struct hda_codec *codec,
4884 					     const struct hda_fixup *fix, int action)
4885 {
4886 	struct alc_spec *spec = codec->spec;
4887 
4888 	alc_fixup_hp_gpio_led(codec, action, 0, 0x04);
4889 	if (action == HDA_FIXUP_ACT_PRE_PROBE) {
4890 		spec->init_amp = ALC_INIT_DEFAULT;
4891 		if (alc_register_micmute_input_device(codec) != 0)
4892 			return;
4893 
4894 		snd_hda_jack_detect_enable_callback(codec, 0x1b,
4895 						    gpio2_mic_hotkey_event);
4896 		return;
4897 	}
4898 
4899 	if (!spec->kb_dev)
4900 		return;
4901 
4902 	switch (action) {
4903 	case HDA_FIXUP_ACT_FREE:
4904 		input_unregister_device(spec->kb_dev);
4905 		spec->kb_dev = NULL;
4906 	}
4907 }
4908 #else /* INPUT */
4909 #define alc280_fixup_hp_gpio2_mic_hotkey	NULL
4910 #define alc233_fixup_lenovo_line2_mic_hotkey	NULL
4911 #endif /* INPUT */
4912 
4913 static void alc269_fixup_hp_line1_mic1_led(struct hda_codec *codec,
4914 				const struct hda_fixup *fix, int action)
4915 {
4916 	struct alc_spec *spec = codec->spec;
4917 
4918 	alc269_fixup_hp_mute_led_micx(codec, fix, action, 0x1a);
4919 	if (action == HDA_FIXUP_ACT_PRE_PROBE) {
4920 		spec->cap_mute_led_nid = 0x18;
4921 		snd_hda_gen_add_micmute_led_cdev(codec, vref_micmute_led_set);
4922 	}
4923 }
4924 
4925 static const struct coef_fw alc225_pre_hsmode[] = {
4926 	UPDATE_COEF(0x4a, 1<<8, 0),
4927 	UPDATE_COEFEX(0x57, 0x05, 1<<14, 0),
4928 	UPDATE_COEF(0x63, 3<<14, 3<<14),
4929 	UPDATE_COEF(0x4a, 3<<4, 2<<4),
4930 	UPDATE_COEF(0x4a, 3<<10, 3<<10),
4931 	UPDATE_COEF(0x45, 0x3f<<10, 0x34<<10),
4932 	UPDATE_COEF(0x4a, 3<<10, 0),
4933 	{}
4934 };
4935 
4936 static void alc_headset_mode_unplugged(struct hda_codec *codec)
4937 {
4938 	struct alc_spec *spec = codec->spec;
4939 	static const struct coef_fw coef0255[] = {
4940 		WRITE_COEF(0x1b, 0x0c0b), /* LDO and MISC control */
4941 		WRITE_COEF(0x45, 0xd089), /* UAJ function set to menual mode */
4942 		UPDATE_COEFEX(0x57, 0x05, 1<<14, 0), /* Direct Drive HP Amp control(Set to verb control)*/
4943 		WRITE_COEF(0x06, 0x6104), /* Set MIC2 Vref gate with HP */
4944 		WRITE_COEFEX(0x57, 0x03, 0x8aa6), /* Direct Drive HP Amp control */
4945 		{}
4946 	};
4947 	static const struct coef_fw coef0256[] = {
4948 		WRITE_COEF(0x1b, 0x0c4b), /* LDO and MISC control */
4949 		WRITE_COEF(0x45, 0xd089), /* UAJ function set to menual mode */
4950 		WRITE_COEF(0x06, 0x6104), /* Set MIC2 Vref gate with HP */
4951 		WRITE_COEFEX(0x57, 0x03, 0x09a3), /* Direct Drive HP Amp control */
4952 		UPDATE_COEFEX(0x57, 0x05, 1<<14, 0), /* Direct Drive HP Amp control(Set to verb control)*/
4953 		{}
4954 	};
4955 	static const struct coef_fw coef0233[] = {
4956 		WRITE_COEF(0x1b, 0x0c0b),
4957 		WRITE_COEF(0x45, 0xc429),
4958 		UPDATE_COEF(0x35, 0x4000, 0),
4959 		WRITE_COEF(0x06, 0x2104),
4960 		WRITE_COEF(0x1a, 0x0001),
4961 		WRITE_COEF(0x26, 0x0004),
4962 		WRITE_COEF(0x32, 0x42a3),
4963 		{}
4964 	};
4965 	static const struct coef_fw coef0288[] = {
4966 		UPDATE_COEF(0x4f, 0xfcc0, 0xc400),
4967 		UPDATE_COEF(0x50, 0x2000, 0x2000),
4968 		UPDATE_COEF(0x56, 0x0006, 0x0006),
4969 		UPDATE_COEF(0x66, 0x0008, 0),
4970 		UPDATE_COEF(0x67, 0x2000, 0),
4971 		{}
4972 	};
4973 	static const struct coef_fw coef0298[] = {
4974 		UPDATE_COEF(0x19, 0x1300, 0x0300),
4975 		{}
4976 	};
4977 	static const struct coef_fw coef0292[] = {
4978 		WRITE_COEF(0x76, 0x000e),
4979 		WRITE_COEF(0x6c, 0x2400),
4980 		WRITE_COEF(0x18, 0x7308),
4981 		WRITE_COEF(0x6b, 0xc429),
4982 		{}
4983 	};
4984 	static const struct coef_fw coef0293[] = {
4985 		UPDATE_COEF(0x10, 7<<8, 6<<8), /* SET Line1 JD to 0 */
4986 		UPDATE_COEFEX(0x57, 0x05, 1<<15|1<<13, 0x0), /* SET charge pump by verb */
4987 		UPDATE_COEFEX(0x57, 0x03, 1<<10, 1<<10), /* SET EN_OSW to 1 */
4988 		UPDATE_COEF(0x1a, 1<<3, 1<<3), /* Combo JD gating with LINE1-VREFO */
4989 		WRITE_COEF(0x45, 0xc429), /* Set to TRS type */
4990 		UPDATE_COEF(0x4a, 0x000f, 0x000e), /* Combo Jack auto detect */
4991 		{}
4992 	};
4993 	static const struct coef_fw coef0668[] = {
4994 		WRITE_COEF(0x15, 0x0d40),
4995 		WRITE_COEF(0xb7, 0x802b),
4996 		{}
4997 	};
4998 	static const struct coef_fw coef0225[] = {
4999 		UPDATE_COEF(0x63, 3<<14, 0),
5000 		{}
5001 	};
5002 	static const struct coef_fw coef0274[] = {
5003 		UPDATE_COEF(0x4a, 0x0100, 0),
5004 		UPDATE_COEFEX(0x57, 0x05, 0x4000, 0),
5005 		UPDATE_COEF(0x6b, 0xf000, 0x5000),
5006 		UPDATE_COEF(0x4a, 0x0010, 0),
5007 		UPDATE_COEF(0x4a, 0x0c00, 0x0c00),
5008 		WRITE_COEF(0x45, 0x5289),
5009 		UPDATE_COEF(0x4a, 0x0c00, 0),
5010 		{}
5011 	};
5012 
5013 	if (spec->no_internal_mic_pin) {
5014 		alc_update_coef_idx(codec, 0x45, 0xf<<12 | 1<<10, 5<<12);
5015 		return;
5016 	}
5017 
5018 	switch (codec->core.vendor_id) {
5019 	case 0x10ec0255:
5020 		alc_process_coef_fw(codec, coef0255);
5021 		break;
5022 	case 0x10ec0230:
5023 	case 0x10ec0236:
5024 	case 0x10ec0256:
5025 	case 0x19e58326:
5026 		alc_process_coef_fw(codec, coef0256);
5027 		break;
5028 	case 0x10ec0234:
5029 	case 0x10ec0274:
5030 	case 0x10ec0294:
5031 		alc_process_coef_fw(codec, coef0274);
5032 		break;
5033 	case 0x10ec0233:
5034 	case 0x10ec0283:
5035 		alc_process_coef_fw(codec, coef0233);
5036 		break;
5037 	case 0x10ec0286:
5038 	case 0x10ec0288:
5039 		alc_process_coef_fw(codec, coef0288);
5040 		break;
5041 	case 0x10ec0298:
5042 		alc_process_coef_fw(codec, coef0298);
5043 		alc_process_coef_fw(codec, coef0288);
5044 		break;
5045 	case 0x10ec0292:
5046 		alc_process_coef_fw(codec, coef0292);
5047 		break;
5048 	case 0x10ec0293:
5049 		alc_process_coef_fw(codec, coef0293);
5050 		break;
5051 	case 0x10ec0668:
5052 		alc_process_coef_fw(codec, coef0668);
5053 		break;
5054 	case 0x10ec0215:
5055 	case 0x10ec0225:
5056 	case 0x10ec0285:
5057 	case 0x10ec0295:
5058 	case 0x10ec0289:
5059 	case 0x10ec0299:
5060 		alc_process_coef_fw(codec, alc225_pre_hsmode);
5061 		alc_process_coef_fw(codec, coef0225);
5062 		break;
5063 	case 0x10ec0867:
5064 		alc_update_coefex_idx(codec, 0x57, 0x5, 1<<14, 0);
5065 		break;
5066 	}
5067 	codec_dbg(codec, "Headset jack set to unplugged mode.\n");
5068 }
5069 
5070 
5071 static void alc_headset_mode_mic_in(struct hda_codec *codec, hda_nid_t hp_pin,
5072 				    hda_nid_t mic_pin)
5073 {
5074 	static const struct coef_fw coef0255[] = {
5075 		WRITE_COEFEX(0x57, 0x03, 0x8aa6),
5076 		WRITE_COEF(0x06, 0x6100), /* Set MIC2 Vref gate to normal */
5077 		{}
5078 	};
5079 	static const struct coef_fw coef0256[] = {
5080 		UPDATE_COEFEX(0x57, 0x05, 1<<14, 1<<14), /* Direct Drive HP Amp control(Set to verb control)*/
5081 		WRITE_COEFEX(0x57, 0x03, 0x09a3),
5082 		WRITE_COEF(0x06, 0x6100), /* Set MIC2 Vref gate to normal */
5083 		{}
5084 	};
5085 	static const struct coef_fw coef0233[] = {
5086 		UPDATE_COEF(0x35, 0, 1<<14),
5087 		WRITE_COEF(0x06, 0x2100),
5088 		WRITE_COEF(0x1a, 0x0021),
5089 		WRITE_COEF(0x26, 0x008c),
5090 		{}
5091 	};
5092 	static const struct coef_fw coef0288[] = {
5093 		UPDATE_COEF(0x4f, 0x00c0, 0),
5094 		UPDATE_COEF(0x50, 0x2000, 0),
5095 		UPDATE_COEF(0x56, 0x0006, 0),
5096 		UPDATE_COEF(0x4f, 0xfcc0, 0xc400),
5097 		UPDATE_COEF(0x66, 0x0008, 0x0008),
5098 		UPDATE_COEF(0x67, 0x2000, 0x2000),
5099 		{}
5100 	};
5101 	static const struct coef_fw coef0292[] = {
5102 		WRITE_COEF(0x19, 0xa208),
5103 		WRITE_COEF(0x2e, 0xacf0),
5104 		{}
5105 	};
5106 	static const struct coef_fw coef0293[] = {
5107 		UPDATE_COEFEX(0x57, 0x05, 0, 1<<15|1<<13), /* SET charge pump by verb */
5108 		UPDATE_COEFEX(0x57, 0x03, 1<<10, 0), /* SET EN_OSW to 0 */
5109 		UPDATE_COEF(0x1a, 1<<3, 0), /* Combo JD gating without LINE1-VREFO */
5110 		{}
5111 	};
5112 	static const struct coef_fw coef0688[] = {
5113 		WRITE_COEF(0xb7, 0x802b),
5114 		WRITE_COEF(0xb5, 0x1040),
5115 		UPDATE_COEF(0xc3, 0, 1<<12),
5116 		{}
5117 	};
5118 	static const struct coef_fw coef0225[] = {
5119 		UPDATE_COEFEX(0x57, 0x05, 1<<14, 1<<14),
5120 		UPDATE_COEF(0x4a, 3<<4, 2<<4),
5121 		UPDATE_COEF(0x63, 3<<14, 0),
5122 		{}
5123 	};
5124 	static const struct coef_fw coef0274[] = {
5125 		UPDATE_COEFEX(0x57, 0x05, 0x4000, 0x4000),
5126 		UPDATE_COEF(0x4a, 0x0010, 0),
5127 		UPDATE_COEF(0x6b, 0xf000, 0),
5128 		{}
5129 	};
5130 
5131 	switch (codec->core.vendor_id) {
5132 	case 0x10ec0255:
5133 		alc_write_coef_idx(codec, 0x45, 0xc489);
5134 		snd_hda_set_pin_ctl_cache(codec, hp_pin, 0);
5135 		alc_process_coef_fw(codec, coef0255);
5136 		snd_hda_set_pin_ctl_cache(codec, mic_pin, PIN_VREF50);
5137 		break;
5138 	case 0x10ec0230:
5139 	case 0x10ec0236:
5140 	case 0x10ec0256:
5141 	case 0x19e58326:
5142 		alc_write_coef_idx(codec, 0x45, 0xc489);
5143 		snd_hda_set_pin_ctl_cache(codec, hp_pin, 0);
5144 		alc_process_coef_fw(codec, coef0256);
5145 		snd_hda_set_pin_ctl_cache(codec, mic_pin, PIN_VREF50);
5146 		break;
5147 	case 0x10ec0234:
5148 	case 0x10ec0274:
5149 	case 0x10ec0294:
5150 		alc_write_coef_idx(codec, 0x45, 0x4689);
5151 		snd_hda_set_pin_ctl_cache(codec, hp_pin, 0);
5152 		alc_process_coef_fw(codec, coef0274);
5153 		snd_hda_set_pin_ctl_cache(codec, mic_pin, PIN_VREF50);
5154 		break;
5155 	case 0x10ec0233:
5156 	case 0x10ec0283:
5157 		alc_write_coef_idx(codec, 0x45, 0xc429);
5158 		snd_hda_set_pin_ctl_cache(codec, hp_pin, 0);
5159 		alc_process_coef_fw(codec, coef0233);
5160 		snd_hda_set_pin_ctl_cache(codec, mic_pin, PIN_VREF50);
5161 		break;
5162 	case 0x10ec0286:
5163 	case 0x10ec0288:
5164 	case 0x10ec0298:
5165 		snd_hda_set_pin_ctl_cache(codec, hp_pin, 0);
5166 		alc_process_coef_fw(codec, coef0288);
5167 		snd_hda_set_pin_ctl_cache(codec, mic_pin, PIN_VREF50);
5168 		break;
5169 	case 0x10ec0292:
5170 		snd_hda_set_pin_ctl_cache(codec, hp_pin, 0);
5171 		alc_process_coef_fw(codec, coef0292);
5172 		break;
5173 	case 0x10ec0293:
5174 		/* Set to TRS mode */
5175 		alc_write_coef_idx(codec, 0x45, 0xc429);
5176 		snd_hda_set_pin_ctl_cache(codec, hp_pin, 0);
5177 		alc_process_coef_fw(codec, coef0293);
5178 		snd_hda_set_pin_ctl_cache(codec, mic_pin, PIN_VREF50);
5179 		break;
5180 	case 0x10ec0867:
5181 		alc_update_coefex_idx(codec, 0x57, 0x5, 0, 1<<14);
5182 		fallthrough;
5183 	case 0x10ec0221:
5184 	case 0x10ec0662:
5185 		snd_hda_set_pin_ctl_cache(codec, hp_pin, 0);
5186 		snd_hda_set_pin_ctl_cache(codec, mic_pin, PIN_VREF50);
5187 		break;
5188 	case 0x10ec0668:
5189 		alc_write_coef_idx(codec, 0x11, 0x0001);
5190 		snd_hda_set_pin_ctl_cache(codec, hp_pin, 0);
5191 		alc_process_coef_fw(codec, coef0688);
5192 		snd_hda_set_pin_ctl_cache(codec, mic_pin, PIN_VREF50);
5193 		break;
5194 	case 0x10ec0215:
5195 	case 0x10ec0225:
5196 	case 0x10ec0285:
5197 	case 0x10ec0295:
5198 	case 0x10ec0289:
5199 	case 0x10ec0299:
5200 		alc_process_coef_fw(codec, alc225_pre_hsmode);
5201 		alc_update_coef_idx(codec, 0x45, 0x3f<<10, 0x31<<10);
5202 		snd_hda_set_pin_ctl_cache(codec, hp_pin, 0);
5203 		alc_process_coef_fw(codec, coef0225);
5204 		snd_hda_set_pin_ctl_cache(codec, mic_pin, PIN_VREF50);
5205 		break;
5206 	}
5207 	codec_dbg(codec, "Headset jack set to mic-in mode.\n");
5208 }
5209 
5210 static void alc_headset_mode_default(struct hda_codec *codec)
5211 {
5212 	static const struct coef_fw coef0225[] = {
5213 		UPDATE_COEF(0x45, 0x3f<<10, 0x30<<10),
5214 		UPDATE_COEF(0x45, 0x3f<<10, 0x31<<10),
5215 		UPDATE_COEF(0x49, 3<<8, 0<<8),
5216 		UPDATE_COEF(0x4a, 3<<4, 3<<4),
5217 		UPDATE_COEF(0x63, 3<<14, 0),
5218 		UPDATE_COEF(0x67, 0xf000, 0x3000),
5219 		{}
5220 	};
5221 	static const struct coef_fw coef0255[] = {
5222 		WRITE_COEF(0x45, 0xc089),
5223 		WRITE_COEF(0x45, 0xc489),
5224 		WRITE_COEFEX(0x57, 0x03, 0x8ea6),
5225 		WRITE_COEF(0x49, 0x0049),
5226 		{}
5227 	};
5228 	static const struct coef_fw coef0256[] = {
5229 		WRITE_COEF(0x45, 0xc489),
5230 		WRITE_COEFEX(0x57, 0x03, 0x0da3),
5231 		WRITE_COEF(0x49, 0x0049),
5232 		UPDATE_COEFEX(0x57, 0x05, 1<<14, 0), /* Direct Drive HP Amp control(Set to verb control)*/
5233 		WRITE_COEF(0x06, 0x6100),
5234 		{}
5235 	};
5236 	static const struct coef_fw coef0233[] = {
5237 		WRITE_COEF(0x06, 0x2100),
5238 		WRITE_COEF(0x32, 0x4ea3),
5239 		{}
5240 	};
5241 	static const struct coef_fw coef0288[] = {
5242 		UPDATE_COEF(0x4f, 0xfcc0, 0xc400), /* Set to TRS type */
5243 		UPDATE_COEF(0x50, 0x2000, 0x2000),
5244 		UPDATE_COEF(0x56, 0x0006, 0x0006),
5245 		UPDATE_COEF(0x66, 0x0008, 0),
5246 		UPDATE_COEF(0x67, 0x2000, 0),
5247 		{}
5248 	};
5249 	static const struct coef_fw coef0292[] = {
5250 		WRITE_COEF(0x76, 0x000e),
5251 		WRITE_COEF(0x6c, 0x2400),
5252 		WRITE_COEF(0x6b, 0xc429),
5253 		WRITE_COEF(0x18, 0x7308),
5254 		{}
5255 	};
5256 	static const struct coef_fw coef0293[] = {
5257 		UPDATE_COEF(0x4a, 0x000f, 0x000e), /* Combo Jack auto detect */
5258 		WRITE_COEF(0x45, 0xC429), /* Set to TRS type */
5259 		UPDATE_COEF(0x1a, 1<<3, 0), /* Combo JD gating without LINE1-VREFO */
5260 		{}
5261 	};
5262 	static const struct coef_fw coef0688[] = {
5263 		WRITE_COEF(0x11, 0x0041),
5264 		WRITE_COEF(0x15, 0x0d40),
5265 		WRITE_COEF(0xb7, 0x802b),
5266 		{}
5267 	};
5268 	static const struct coef_fw coef0274[] = {
5269 		WRITE_COEF(0x45, 0x4289),
5270 		UPDATE_COEF(0x4a, 0x0010, 0x0010),
5271 		UPDATE_COEF(0x6b, 0x0f00, 0),
5272 		UPDATE_COEF(0x49, 0x0300, 0x0300),
5273 		{}
5274 	};
5275 
5276 	switch (codec->core.vendor_id) {
5277 	case 0x10ec0215:
5278 	case 0x10ec0225:
5279 	case 0x10ec0285:
5280 	case 0x10ec0295:
5281 	case 0x10ec0289:
5282 	case 0x10ec0299:
5283 		alc_process_coef_fw(codec, alc225_pre_hsmode);
5284 		alc_process_coef_fw(codec, coef0225);
5285 		break;
5286 	case 0x10ec0255:
5287 		alc_process_coef_fw(codec, coef0255);
5288 		break;
5289 	case 0x10ec0230:
5290 	case 0x10ec0236:
5291 	case 0x10ec0256:
5292 	case 0x19e58326:
5293 		alc_write_coef_idx(codec, 0x1b, 0x0e4b);
5294 		alc_write_coef_idx(codec, 0x45, 0xc089);
5295 		msleep(50);
5296 		alc_process_coef_fw(codec, coef0256);
5297 		break;
5298 	case 0x10ec0234:
5299 	case 0x10ec0274:
5300 	case 0x10ec0294:
5301 		alc_process_coef_fw(codec, coef0274);
5302 		break;
5303 	case 0x10ec0233:
5304 	case 0x10ec0283:
5305 		alc_process_coef_fw(codec, coef0233);
5306 		break;
5307 	case 0x10ec0286:
5308 	case 0x10ec0288:
5309 	case 0x10ec0298:
5310 		alc_process_coef_fw(codec, coef0288);
5311 		break;
5312 	case 0x10ec0292:
5313 		alc_process_coef_fw(codec, coef0292);
5314 		break;
5315 	case 0x10ec0293:
5316 		alc_process_coef_fw(codec, coef0293);
5317 		break;
5318 	case 0x10ec0668:
5319 		alc_process_coef_fw(codec, coef0688);
5320 		break;
5321 	case 0x10ec0867:
5322 		alc_update_coefex_idx(codec, 0x57, 0x5, 1<<14, 0);
5323 		break;
5324 	}
5325 	codec_dbg(codec, "Headset jack set to headphone (default) mode.\n");
5326 }
5327 
5328 /* Iphone type */
5329 static void alc_headset_mode_ctia(struct hda_codec *codec)
5330 {
5331 	int val;
5332 
5333 	static const struct coef_fw coef0255[] = {
5334 		WRITE_COEF(0x45, 0xd489), /* Set to CTIA type */
5335 		WRITE_COEF(0x1b, 0x0c2b),
5336 		WRITE_COEFEX(0x57, 0x03, 0x8ea6),
5337 		{}
5338 	};
5339 	static const struct coef_fw coef0256[] = {
5340 		WRITE_COEF(0x45, 0xd489), /* Set to CTIA type */
5341 		WRITE_COEF(0x1b, 0x0e6b),
5342 		{}
5343 	};
5344 	static const struct coef_fw coef0233[] = {
5345 		WRITE_COEF(0x45, 0xd429),
5346 		WRITE_COEF(0x1b, 0x0c2b),
5347 		WRITE_COEF(0x32, 0x4ea3),
5348 		{}
5349 	};
5350 	static const struct coef_fw coef0288[] = {
5351 		UPDATE_COEF(0x50, 0x2000, 0x2000),
5352 		UPDATE_COEF(0x56, 0x0006, 0x0006),
5353 		UPDATE_COEF(0x66, 0x0008, 0),
5354 		UPDATE_COEF(0x67, 0x2000, 0),
5355 		{}
5356 	};
5357 	static const struct coef_fw coef0292[] = {
5358 		WRITE_COEF(0x6b, 0xd429),
5359 		WRITE_COEF(0x76, 0x0008),
5360 		WRITE_COEF(0x18, 0x7388),
5361 		{}
5362 	};
5363 	static const struct coef_fw coef0293[] = {
5364 		WRITE_COEF(0x45, 0xd429), /* Set to ctia type */
5365 		UPDATE_COEF(0x10, 7<<8, 7<<8), /* SET Line1 JD to 1 */
5366 		{}
5367 	};
5368 	static const struct coef_fw coef0688[] = {
5369 		WRITE_COEF(0x11, 0x0001),
5370 		WRITE_COEF(0x15, 0x0d60),
5371 		WRITE_COEF(0xc3, 0x0000),
5372 		{}
5373 	};
5374 	static const struct coef_fw coef0225_1[] = {
5375 		UPDATE_COEF(0x45, 0x3f<<10, 0x35<<10),
5376 		UPDATE_COEF(0x63, 3<<14, 2<<14),
5377 		{}
5378 	};
5379 	static const struct coef_fw coef0225_2[] = {
5380 		UPDATE_COEF(0x45, 0x3f<<10, 0x35<<10),
5381 		UPDATE_COEF(0x63, 3<<14, 1<<14),
5382 		{}
5383 	};
5384 
5385 	switch (codec->core.vendor_id) {
5386 	case 0x10ec0255:
5387 		alc_process_coef_fw(codec, coef0255);
5388 		break;
5389 	case 0x10ec0230:
5390 	case 0x10ec0236:
5391 	case 0x10ec0256:
5392 	case 0x19e58326:
5393 		alc_process_coef_fw(codec, coef0256);
5394 		break;
5395 	case 0x10ec0234:
5396 	case 0x10ec0274:
5397 	case 0x10ec0294:
5398 		alc_write_coef_idx(codec, 0x45, 0xd689);
5399 		break;
5400 	case 0x10ec0233:
5401 	case 0x10ec0283:
5402 		alc_process_coef_fw(codec, coef0233);
5403 		break;
5404 	case 0x10ec0298:
5405 		val = alc_read_coef_idx(codec, 0x50);
5406 		if (val & (1 << 12)) {
5407 			alc_update_coef_idx(codec, 0x8e, 0x0070, 0x0020);
5408 			alc_update_coef_idx(codec, 0x4f, 0xfcc0, 0xd400);
5409 			msleep(300);
5410 		} else {
5411 			alc_update_coef_idx(codec, 0x8e, 0x0070, 0x0010);
5412 			alc_update_coef_idx(codec, 0x4f, 0xfcc0, 0xd400);
5413 			msleep(300);
5414 		}
5415 		break;
5416 	case 0x10ec0286:
5417 	case 0x10ec0288:
5418 		alc_update_coef_idx(codec, 0x4f, 0xfcc0, 0xd400);
5419 		msleep(300);
5420 		alc_process_coef_fw(codec, coef0288);
5421 		break;
5422 	case 0x10ec0292:
5423 		alc_process_coef_fw(codec, coef0292);
5424 		break;
5425 	case 0x10ec0293:
5426 		alc_process_coef_fw(codec, coef0293);
5427 		break;
5428 	case 0x10ec0668:
5429 		alc_process_coef_fw(codec, coef0688);
5430 		break;
5431 	case 0x10ec0215:
5432 	case 0x10ec0225:
5433 	case 0x10ec0285:
5434 	case 0x10ec0295:
5435 	case 0x10ec0289:
5436 	case 0x10ec0299:
5437 		val = alc_read_coef_idx(codec, 0x45);
5438 		if (val & (1 << 9))
5439 			alc_process_coef_fw(codec, coef0225_2);
5440 		else
5441 			alc_process_coef_fw(codec, coef0225_1);
5442 		break;
5443 	case 0x10ec0867:
5444 		alc_update_coefex_idx(codec, 0x57, 0x5, 1<<14, 0);
5445 		break;
5446 	}
5447 	codec_dbg(codec, "Headset jack set to iPhone-style headset mode.\n");
5448 }
5449 
5450 /* Nokia type */
5451 static void alc_headset_mode_omtp(struct hda_codec *codec)
5452 {
5453 	static const struct coef_fw coef0255[] = {
5454 		WRITE_COEF(0x45, 0xe489), /* Set to OMTP Type */
5455 		WRITE_COEF(0x1b, 0x0c2b),
5456 		WRITE_COEFEX(0x57, 0x03, 0x8ea6),
5457 		{}
5458 	};
5459 	static const struct coef_fw coef0256[] = {
5460 		WRITE_COEF(0x45, 0xe489), /* Set to OMTP Type */
5461 		WRITE_COEF(0x1b, 0x0e6b),
5462 		{}
5463 	};
5464 	static const struct coef_fw coef0233[] = {
5465 		WRITE_COEF(0x45, 0xe429),
5466 		WRITE_COEF(0x1b, 0x0c2b),
5467 		WRITE_COEF(0x32, 0x4ea3),
5468 		{}
5469 	};
5470 	static const struct coef_fw coef0288[] = {
5471 		UPDATE_COEF(0x50, 0x2000, 0x2000),
5472 		UPDATE_COEF(0x56, 0x0006, 0x0006),
5473 		UPDATE_COEF(0x66, 0x0008, 0),
5474 		UPDATE_COEF(0x67, 0x2000, 0),
5475 		{}
5476 	};
5477 	static const struct coef_fw coef0292[] = {
5478 		WRITE_COEF(0x6b, 0xe429),
5479 		WRITE_COEF(0x76, 0x0008),
5480 		WRITE_COEF(0x18, 0x7388),
5481 		{}
5482 	};
5483 	static const struct coef_fw coef0293[] = {
5484 		WRITE_COEF(0x45, 0xe429), /* Set to omtp type */
5485 		UPDATE_COEF(0x10, 7<<8, 7<<8), /* SET Line1 JD to 1 */
5486 		{}
5487 	};
5488 	static const struct coef_fw coef0688[] = {
5489 		WRITE_COEF(0x11, 0x0001),
5490 		WRITE_COEF(0x15, 0x0d50),
5491 		WRITE_COEF(0xc3, 0x0000),
5492 		{}
5493 	};
5494 	static const struct coef_fw coef0225[] = {
5495 		UPDATE_COEF(0x45, 0x3f<<10, 0x39<<10),
5496 		UPDATE_COEF(0x63, 3<<14, 2<<14),
5497 		{}
5498 	};
5499 
5500 	switch (codec->core.vendor_id) {
5501 	case 0x10ec0255:
5502 		alc_process_coef_fw(codec, coef0255);
5503 		break;
5504 	case 0x10ec0230:
5505 	case 0x10ec0236:
5506 	case 0x10ec0256:
5507 	case 0x19e58326:
5508 		alc_process_coef_fw(codec, coef0256);
5509 		break;
5510 	case 0x10ec0234:
5511 	case 0x10ec0274:
5512 	case 0x10ec0294:
5513 		alc_write_coef_idx(codec, 0x45, 0xe689);
5514 		break;
5515 	case 0x10ec0233:
5516 	case 0x10ec0283:
5517 		alc_process_coef_fw(codec, coef0233);
5518 		break;
5519 	case 0x10ec0298:
5520 		alc_update_coef_idx(codec, 0x8e, 0x0070, 0x0010);/* Headset output enable */
5521 		alc_update_coef_idx(codec, 0x4f, 0xfcc0, 0xe400);
5522 		msleep(300);
5523 		break;
5524 	case 0x10ec0286:
5525 	case 0x10ec0288:
5526 		alc_update_coef_idx(codec, 0x4f, 0xfcc0, 0xe400);
5527 		msleep(300);
5528 		alc_process_coef_fw(codec, coef0288);
5529 		break;
5530 	case 0x10ec0292:
5531 		alc_process_coef_fw(codec, coef0292);
5532 		break;
5533 	case 0x10ec0293:
5534 		alc_process_coef_fw(codec, coef0293);
5535 		break;
5536 	case 0x10ec0668:
5537 		alc_process_coef_fw(codec, coef0688);
5538 		break;
5539 	case 0x10ec0215:
5540 	case 0x10ec0225:
5541 	case 0x10ec0285:
5542 	case 0x10ec0295:
5543 	case 0x10ec0289:
5544 	case 0x10ec0299:
5545 		alc_process_coef_fw(codec, coef0225);
5546 		break;
5547 	}
5548 	codec_dbg(codec, "Headset jack set to Nokia-style headset mode.\n");
5549 }
5550 
5551 static void alc_determine_headset_type(struct hda_codec *codec)
5552 {
5553 	int val;
5554 	bool is_ctia = false;
5555 	struct alc_spec *spec = codec->spec;
5556 	static const struct coef_fw coef0255[] = {
5557 		WRITE_COEF(0x45, 0xd089), /* combo jack auto switch control(Check type)*/
5558 		WRITE_COEF(0x49, 0x0149), /* combo jack auto switch control(Vref
5559  conteol) */
5560 		{}
5561 	};
5562 	static const struct coef_fw coef0288[] = {
5563 		UPDATE_COEF(0x4f, 0xfcc0, 0xd400), /* Check Type */
5564 		{}
5565 	};
5566 	static const struct coef_fw coef0298[] = {
5567 		UPDATE_COEF(0x50, 0x2000, 0x2000),
5568 		UPDATE_COEF(0x56, 0x0006, 0x0006),
5569 		UPDATE_COEF(0x66, 0x0008, 0),
5570 		UPDATE_COEF(0x67, 0x2000, 0),
5571 		UPDATE_COEF(0x19, 0x1300, 0x1300),
5572 		{}
5573 	};
5574 	static const struct coef_fw coef0293[] = {
5575 		UPDATE_COEF(0x4a, 0x000f, 0x0008), /* Combo Jack auto detect */
5576 		WRITE_COEF(0x45, 0xD429), /* Set to ctia type */
5577 		{}
5578 	};
5579 	static const struct coef_fw coef0688[] = {
5580 		WRITE_COEF(0x11, 0x0001),
5581 		WRITE_COEF(0xb7, 0x802b),
5582 		WRITE_COEF(0x15, 0x0d60),
5583 		WRITE_COEF(0xc3, 0x0c00),
5584 		{}
5585 	};
5586 	static const struct coef_fw coef0274[] = {
5587 		UPDATE_COEF(0x4a, 0x0010, 0),
5588 		UPDATE_COEF(0x4a, 0x8000, 0),
5589 		WRITE_COEF(0x45, 0xd289),
5590 		UPDATE_COEF(0x49, 0x0300, 0x0300),
5591 		{}
5592 	};
5593 
5594 	if (spec->no_internal_mic_pin) {
5595 		alc_update_coef_idx(codec, 0x45, 0xf<<12 | 1<<10, 5<<12);
5596 		return;
5597 	}
5598 
5599 	switch (codec->core.vendor_id) {
5600 	case 0x10ec0255:
5601 		alc_process_coef_fw(codec, coef0255);
5602 		msleep(300);
5603 		val = alc_read_coef_idx(codec, 0x46);
5604 		is_ctia = (val & 0x0070) == 0x0070;
5605 		break;
5606 	case 0x10ec0230:
5607 	case 0x10ec0236:
5608 	case 0x10ec0256:
5609 	case 0x19e58326:
5610 		alc_write_coef_idx(codec, 0x1b, 0x0e4b);
5611 		alc_write_coef_idx(codec, 0x06, 0x6104);
5612 		alc_write_coefex_idx(codec, 0x57, 0x3, 0x09a3);
5613 
5614 		snd_hda_codec_write(codec, 0x21, 0,
5615 			    AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);
5616 		msleep(80);
5617 		snd_hda_codec_write(codec, 0x21, 0,
5618 			    AC_VERB_SET_PIN_WIDGET_CONTROL, 0x0);
5619 
5620 		alc_process_coef_fw(codec, coef0255);
5621 		msleep(300);
5622 		val = alc_read_coef_idx(codec, 0x46);
5623 		is_ctia = (val & 0x0070) == 0x0070;
5624 
5625 		alc_write_coefex_idx(codec, 0x57, 0x3, 0x0da3);
5626 		alc_update_coefex_idx(codec, 0x57, 0x5, 1<<14, 0);
5627 
5628 		snd_hda_codec_write(codec, 0x21, 0,
5629 			    AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT);
5630 		msleep(80);
5631 		snd_hda_codec_write(codec, 0x21, 0,
5632 			    AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE);
5633 		break;
5634 	case 0x10ec0234:
5635 	case 0x10ec0274:
5636 	case 0x10ec0294:
5637 		alc_process_coef_fw(codec, coef0274);
5638 		msleep(850);
5639 		val = alc_read_coef_idx(codec, 0x46);
5640 		is_ctia = (val & 0x00f0) == 0x00f0;
5641 		break;
5642 	case 0x10ec0233:
5643 	case 0x10ec0283:
5644 		alc_write_coef_idx(codec, 0x45, 0xd029);
5645 		msleep(300);
5646 		val = alc_read_coef_idx(codec, 0x46);
5647 		is_ctia = (val & 0x0070) == 0x0070;
5648 		break;
5649 	case 0x10ec0298:
5650 		snd_hda_codec_write(codec, 0x21, 0,
5651 			    AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);
5652 		msleep(100);
5653 		snd_hda_codec_write(codec, 0x21, 0,
5654 			    AC_VERB_SET_PIN_WIDGET_CONTROL, 0x0);
5655 		msleep(200);
5656 
5657 		val = alc_read_coef_idx(codec, 0x50);
5658 		if (val & (1 << 12)) {
5659 			alc_update_coef_idx(codec, 0x8e, 0x0070, 0x0020);
5660 			alc_process_coef_fw(codec, coef0288);
5661 			msleep(350);
5662 			val = alc_read_coef_idx(codec, 0x50);
5663 			is_ctia = (val & 0x0070) == 0x0070;
5664 		} else {
5665 			alc_update_coef_idx(codec, 0x8e, 0x0070, 0x0010);
5666 			alc_process_coef_fw(codec, coef0288);
5667 			msleep(350);
5668 			val = alc_read_coef_idx(codec, 0x50);
5669 			is_ctia = (val & 0x0070) == 0x0070;
5670 		}
5671 		alc_process_coef_fw(codec, coef0298);
5672 		snd_hda_codec_write(codec, 0x21, 0,
5673 			    AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP);
5674 		msleep(75);
5675 		snd_hda_codec_write(codec, 0x21, 0,
5676 			    AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE);
5677 		break;
5678 	case 0x10ec0286:
5679 	case 0x10ec0288:
5680 		alc_process_coef_fw(codec, coef0288);
5681 		msleep(350);
5682 		val = alc_read_coef_idx(codec, 0x50);
5683 		is_ctia = (val & 0x0070) == 0x0070;
5684 		break;
5685 	case 0x10ec0292:
5686 		alc_write_coef_idx(codec, 0x6b, 0xd429);
5687 		msleep(300);
5688 		val = alc_read_coef_idx(codec, 0x6c);
5689 		is_ctia = (val & 0x001c) == 0x001c;
5690 		break;
5691 	case 0x10ec0293:
5692 		alc_process_coef_fw(codec, coef0293);
5693 		msleep(300);
5694 		val = alc_read_coef_idx(codec, 0x46);
5695 		is_ctia = (val & 0x0070) == 0x0070;
5696 		break;
5697 	case 0x10ec0668:
5698 		alc_process_coef_fw(codec, coef0688);
5699 		msleep(300);
5700 		val = alc_read_coef_idx(codec, 0xbe);
5701 		is_ctia = (val & 0x1c02) == 0x1c02;
5702 		break;
5703 	case 0x10ec0215:
5704 	case 0x10ec0225:
5705 	case 0x10ec0285:
5706 	case 0x10ec0295:
5707 	case 0x10ec0289:
5708 	case 0x10ec0299:
5709 		snd_hda_codec_write(codec, 0x21, 0,
5710 			    AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);
5711 		msleep(80);
5712 		snd_hda_codec_write(codec, 0x21, 0,
5713 			    AC_VERB_SET_PIN_WIDGET_CONTROL, 0x0);
5714 
5715 		alc_process_coef_fw(codec, alc225_pre_hsmode);
5716 		alc_update_coef_idx(codec, 0x67, 0xf000, 0x1000);
5717 		val = alc_read_coef_idx(codec, 0x45);
5718 		if (val & (1 << 9)) {
5719 			alc_update_coef_idx(codec, 0x45, 0x3f<<10, 0x34<<10);
5720 			alc_update_coef_idx(codec, 0x49, 3<<8, 2<<8);
5721 			msleep(800);
5722 			val = alc_read_coef_idx(codec, 0x46);
5723 			is_ctia = (val & 0x00f0) == 0x00f0;
5724 		} else {
5725 			alc_update_coef_idx(codec, 0x45, 0x3f<<10, 0x34<<10);
5726 			alc_update_coef_idx(codec, 0x49, 3<<8, 1<<8);
5727 			msleep(800);
5728 			val = alc_read_coef_idx(codec, 0x46);
5729 			is_ctia = (val & 0x00f0) == 0x00f0;
5730 		}
5731 		alc_update_coef_idx(codec, 0x4a, 7<<6, 7<<6);
5732 		alc_update_coef_idx(codec, 0x4a, 3<<4, 3<<4);
5733 		alc_update_coef_idx(codec, 0x67, 0xf000, 0x3000);
5734 
5735 		snd_hda_codec_write(codec, 0x21, 0,
5736 			    AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT);
5737 		msleep(80);
5738 		snd_hda_codec_write(codec, 0x21, 0,
5739 			    AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE);
5740 		break;
5741 	case 0x10ec0867:
5742 		is_ctia = true;
5743 		break;
5744 	}
5745 
5746 	codec_dbg(codec, "Headset jack detected iPhone-style headset: %s\n",
5747 		    is_ctia ? "yes" : "no");
5748 	spec->current_headset_type = is_ctia ? ALC_HEADSET_TYPE_CTIA : ALC_HEADSET_TYPE_OMTP;
5749 }
5750 
5751 static void alc_update_headset_mode(struct hda_codec *codec)
5752 {
5753 	struct alc_spec *spec = codec->spec;
5754 
5755 	hda_nid_t mux_pin = spec->gen.imux_pins[spec->gen.cur_mux[0]];
5756 	hda_nid_t hp_pin = alc_get_hp_pin(spec);
5757 
5758 	int new_headset_mode;
5759 
5760 	if (!snd_hda_jack_detect(codec, hp_pin))
5761 		new_headset_mode = ALC_HEADSET_MODE_UNPLUGGED;
5762 	else if (mux_pin == spec->headset_mic_pin)
5763 		new_headset_mode = ALC_HEADSET_MODE_HEADSET;
5764 	else if (mux_pin == spec->headphone_mic_pin)
5765 		new_headset_mode = ALC_HEADSET_MODE_MIC;
5766 	else
5767 		new_headset_mode = ALC_HEADSET_MODE_HEADPHONE;
5768 
5769 	if (new_headset_mode == spec->current_headset_mode) {
5770 		snd_hda_gen_update_outputs(codec);
5771 		return;
5772 	}
5773 
5774 	switch (new_headset_mode) {
5775 	case ALC_HEADSET_MODE_UNPLUGGED:
5776 		alc_headset_mode_unplugged(codec);
5777 		spec->current_headset_mode = ALC_HEADSET_MODE_UNKNOWN;
5778 		spec->current_headset_type = ALC_HEADSET_TYPE_UNKNOWN;
5779 		spec->gen.hp_jack_present = false;
5780 		break;
5781 	case ALC_HEADSET_MODE_HEADSET:
5782 		if (spec->current_headset_type == ALC_HEADSET_TYPE_UNKNOWN)
5783 			alc_determine_headset_type(codec);
5784 		if (spec->current_headset_type == ALC_HEADSET_TYPE_CTIA)
5785 			alc_headset_mode_ctia(codec);
5786 		else if (spec->current_headset_type == ALC_HEADSET_TYPE_OMTP)
5787 			alc_headset_mode_omtp(codec);
5788 		spec->gen.hp_jack_present = true;
5789 		break;
5790 	case ALC_HEADSET_MODE_MIC:
5791 		alc_headset_mode_mic_in(codec, hp_pin, spec->headphone_mic_pin);
5792 		spec->gen.hp_jack_present = false;
5793 		break;
5794 	case ALC_HEADSET_MODE_HEADPHONE:
5795 		alc_headset_mode_default(codec);
5796 		spec->gen.hp_jack_present = true;
5797 		break;
5798 	}
5799 	if (new_headset_mode != ALC_HEADSET_MODE_MIC) {
5800 		snd_hda_set_pin_ctl_cache(codec, hp_pin,
5801 					  AC_PINCTL_OUT_EN | AC_PINCTL_HP_EN);
5802 		if (spec->headphone_mic_pin && spec->headphone_mic_pin != hp_pin)
5803 			snd_hda_set_pin_ctl_cache(codec, spec->headphone_mic_pin,
5804 						  PIN_VREFHIZ);
5805 	}
5806 	spec->current_headset_mode = new_headset_mode;
5807 
5808 	snd_hda_gen_update_outputs(codec);
5809 }
5810 
5811 static void alc_update_headset_mode_hook(struct hda_codec *codec,
5812 					 struct snd_kcontrol *kcontrol,
5813 					 struct snd_ctl_elem_value *ucontrol)
5814 {
5815 	alc_update_headset_mode(codec);
5816 }
5817 
5818 static void alc_update_headset_jack_cb(struct hda_codec *codec,
5819 				       struct hda_jack_callback *jack)
5820 {
5821 	snd_hda_gen_hp_automute(codec, jack);
5822 	alc_update_headset_mode(codec);
5823 }
5824 
5825 static void alc_probe_headset_mode(struct hda_codec *codec)
5826 {
5827 	int i;
5828 	struct alc_spec *spec = codec->spec;
5829 	struct auto_pin_cfg *cfg = &spec->gen.autocfg;
5830 
5831 	/* Find mic pins */
5832 	for (i = 0; i < cfg->num_inputs; i++) {
5833 		if (cfg->inputs[i].is_headset_mic && !spec->headset_mic_pin)
5834 			spec->headset_mic_pin = cfg->inputs[i].pin;
5835 		if (cfg->inputs[i].is_headphone_mic && !spec->headphone_mic_pin)
5836 			spec->headphone_mic_pin = cfg->inputs[i].pin;
5837 	}
5838 
5839 	WARN_ON(spec->gen.cap_sync_hook);
5840 	spec->gen.cap_sync_hook = alc_update_headset_mode_hook;
5841 	spec->gen.automute_hook = alc_update_headset_mode;
5842 	spec->gen.hp_automute_hook = alc_update_headset_jack_cb;
5843 }
5844 
5845 static void alc_fixup_headset_mode(struct hda_codec *codec,
5846 				const struct hda_fixup *fix, int action)
5847 {
5848 	struct alc_spec *spec = codec->spec;
5849 
5850 	switch (action) {
5851 	case HDA_FIXUP_ACT_PRE_PROBE:
5852 		spec->parse_flags |= HDA_PINCFG_HEADSET_MIC | HDA_PINCFG_HEADPHONE_MIC;
5853 		break;
5854 	case HDA_FIXUP_ACT_PROBE:
5855 		alc_probe_headset_mode(codec);
5856 		break;
5857 	case HDA_FIXUP_ACT_INIT:
5858 		if (is_s3_resume(codec) || is_s4_resume(codec)) {
5859 			spec->current_headset_mode = ALC_HEADSET_MODE_UNKNOWN;
5860 			spec->current_headset_type = ALC_HEADSET_TYPE_UNKNOWN;
5861 		}
5862 		alc_update_headset_mode(codec);
5863 		break;
5864 	}
5865 }
5866 
5867 static void alc_fixup_headset_mode_no_hp_mic(struct hda_codec *codec,
5868 				const struct hda_fixup *fix, int action)
5869 {
5870 	if (action == HDA_FIXUP_ACT_PRE_PROBE) {
5871 		struct alc_spec *spec = codec->spec;
5872 		spec->parse_flags |= HDA_PINCFG_HEADSET_MIC;
5873 	}
5874 	else
5875 		alc_fixup_headset_mode(codec, fix, action);
5876 }
5877 
5878 static void alc255_set_default_jack_type(struct hda_codec *codec)
5879 {
5880 	/* Set to iphone type */
5881 	static const struct coef_fw alc255fw[] = {
5882 		WRITE_COEF(0x1b, 0x880b),
5883 		WRITE_COEF(0x45, 0xd089),
5884 		WRITE_COEF(0x1b, 0x080b),
5885 		WRITE_COEF(0x46, 0x0004),
5886 		WRITE_COEF(0x1b, 0x0c0b),
5887 		{}
5888 	};
5889 	static const struct coef_fw alc256fw[] = {
5890 		WRITE_COEF(0x1b, 0x884b),
5891 		WRITE_COEF(0x45, 0xd089),
5892 		WRITE_COEF(0x1b, 0x084b),
5893 		WRITE_COEF(0x46, 0x0004),
5894 		WRITE_COEF(0x1b, 0x0c4b),
5895 		{}
5896 	};
5897 	switch (codec->core.vendor_id) {
5898 	case 0x10ec0255:
5899 		alc_process_coef_fw(codec, alc255fw);
5900 		break;
5901 	case 0x10ec0230:
5902 	case 0x10ec0236:
5903 	case 0x10ec0256:
5904 	case 0x19e58326:
5905 		alc_process_coef_fw(codec, alc256fw);
5906 		break;
5907 	}
5908 	msleep(30);
5909 }
5910 
5911 static void alc_fixup_headset_mode_alc255(struct hda_codec *codec,
5912 				const struct hda_fixup *fix, int action)
5913 {
5914 	if (action == HDA_FIXUP_ACT_PRE_PROBE) {
5915 		alc255_set_default_jack_type(codec);
5916 	}
5917 	alc_fixup_headset_mode(codec, fix, action);
5918 }
5919 
5920 static void alc_fixup_headset_mode_alc255_no_hp_mic(struct hda_codec *codec,
5921 				const struct hda_fixup *fix, int action)
5922 {
5923 	if (action == HDA_FIXUP_ACT_PRE_PROBE) {
5924 		struct alc_spec *spec = codec->spec;
5925 		spec->parse_flags |= HDA_PINCFG_HEADSET_MIC;
5926 		alc255_set_default_jack_type(codec);
5927 	}
5928 	else
5929 		alc_fixup_headset_mode(codec, fix, action);
5930 }
5931 
5932 static void alc288_update_headset_jack_cb(struct hda_codec *codec,
5933 				       struct hda_jack_callback *jack)
5934 {
5935 	struct alc_spec *spec = codec->spec;
5936 
5937 	alc_update_headset_jack_cb(codec, jack);
5938 	/* Headset Mic enable or disable, only for Dell Dino */
5939 	alc_update_gpio_data(codec, 0x40, spec->gen.hp_jack_present);
5940 }
5941 
5942 static void alc_fixup_headset_mode_dell_alc288(struct hda_codec *codec,
5943 				const struct hda_fixup *fix, int action)
5944 {
5945 	alc_fixup_headset_mode(codec, fix, action);
5946 	if (action == HDA_FIXUP_ACT_PROBE) {
5947 		struct alc_spec *spec = codec->spec;
5948 		/* toggled via hp_automute_hook */
5949 		spec->gpio_mask |= 0x40;
5950 		spec->gpio_dir |= 0x40;
5951 		spec->gen.hp_automute_hook = alc288_update_headset_jack_cb;
5952 	}
5953 }
5954 
5955 static void alc_fixup_auto_mute_via_amp(struct hda_codec *codec,
5956 					const struct hda_fixup *fix, int action)
5957 {
5958 	if (action == HDA_FIXUP_ACT_PRE_PROBE) {
5959 		struct alc_spec *spec = codec->spec;
5960 		spec->gen.auto_mute_via_amp = 1;
5961 	}
5962 }
5963 
5964 static void alc_fixup_no_shutup(struct hda_codec *codec,
5965 				const struct hda_fixup *fix, int action)
5966 {
5967 	if (action == HDA_FIXUP_ACT_PRE_PROBE) {
5968 		struct alc_spec *spec = codec->spec;
5969 		spec->no_shutup_pins = 1;
5970 	}
5971 }
5972 
5973 static void alc_fixup_disable_aamix(struct hda_codec *codec,
5974 				    const struct hda_fixup *fix, int action)
5975 {
5976 	if (action == HDA_FIXUP_ACT_PRE_PROBE) {
5977 		struct alc_spec *spec = codec->spec;
5978 		/* Disable AA-loopback as it causes white noise */
5979 		spec->gen.mixer_nid = 0;
5980 	}
5981 }
5982 
5983 /* fixup for Thinkpad docks: add dock pins, avoid HP parser fixup */
5984 static void alc_fixup_tpt440_dock(struct hda_codec *codec,
5985 				  const struct hda_fixup *fix, int action)
5986 {
5987 	static const struct hda_pintbl pincfgs[] = {
5988 		{ 0x16, 0x21211010 }, /* dock headphone */
5989 		{ 0x19, 0x21a11010 }, /* dock mic */
5990 		{ }
5991 	};
5992 	struct alc_spec *spec = codec->spec;
5993 
5994 	if (action == HDA_FIXUP_ACT_PRE_PROBE) {
5995 		spec->parse_flags = HDA_PINCFG_NO_HP_FIXUP;
5996 		codec->power_save_node = 0; /* avoid click noises */
5997 		snd_hda_apply_pincfgs(codec, pincfgs);
5998 	}
5999 }
6000 
6001 static void alc_fixup_tpt470_dock(struct hda_codec *codec,
6002 				  const struct hda_fixup *fix, int action)
6003 {
6004 	static const struct hda_pintbl pincfgs[] = {
6005 		{ 0x17, 0x21211010 }, /* dock headphone */
6006 		{ 0x19, 0x21a11010 }, /* dock mic */
6007 		{ }
6008 	};
6009 	struct alc_spec *spec = codec->spec;
6010 
6011 	if (action == HDA_FIXUP_ACT_PRE_PROBE) {
6012 		spec->parse_flags = HDA_PINCFG_NO_HP_FIXUP;
6013 		snd_hda_apply_pincfgs(codec, pincfgs);
6014 	} else if (action == HDA_FIXUP_ACT_INIT) {
6015 		/* Enable DOCK device */
6016 		snd_hda_codec_write(codec, 0x17, 0,
6017 			    AC_VERB_SET_CONFIG_DEFAULT_BYTES_3, 0);
6018 		/* Enable DOCK device */
6019 		snd_hda_codec_write(codec, 0x19, 0,
6020 			    AC_VERB_SET_CONFIG_DEFAULT_BYTES_3, 0);
6021 	}
6022 }
6023 
6024 static void alc_fixup_tpt470_dacs(struct hda_codec *codec,
6025 				  const struct hda_fixup *fix, int action)
6026 {
6027 	/* Assure the speaker pin to be coupled with DAC NID 0x03; otherwise
6028 	 * the speaker output becomes too low by some reason on Thinkpads with
6029 	 * ALC298 codec
6030 	 */
6031 	static const hda_nid_t preferred_pairs[] = {
6032 		0x14, 0x03, 0x17, 0x02, 0x21, 0x02,
6033 		0
6034 	};
6035 	struct alc_spec *spec = codec->spec;
6036 
6037 	if (action == HDA_FIXUP_ACT_PRE_PROBE)
6038 		spec->gen.preferred_dacs = preferred_pairs;
6039 }
6040 
6041 static void alc295_fixup_asus_dacs(struct hda_codec *codec,
6042 				   const struct hda_fixup *fix, int action)
6043 {
6044 	static const hda_nid_t preferred_pairs[] = {
6045 		0x17, 0x02, 0x21, 0x03, 0
6046 	};
6047 	struct alc_spec *spec = codec->spec;
6048 
6049 	if (action == HDA_FIXUP_ACT_PRE_PROBE)
6050 		spec->gen.preferred_dacs = preferred_pairs;
6051 }
6052 
6053 static void alc_shutup_dell_xps13(struct hda_codec *codec)
6054 {
6055 	struct alc_spec *spec = codec->spec;
6056 	int hp_pin = alc_get_hp_pin(spec);
6057 
6058 	/* Prevent pop noises when headphones are plugged in */
6059 	snd_hda_codec_write(codec, hp_pin, 0,
6060 			    AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);
6061 	msleep(20);
6062 }
6063 
6064 static void alc_fixup_dell_xps13(struct hda_codec *codec,
6065 				const struct hda_fixup *fix, int action)
6066 {
6067 	struct alc_spec *spec = codec->spec;
6068 	struct hda_input_mux *imux = &spec->gen.input_mux;
6069 	int i;
6070 
6071 	switch (action) {
6072 	case HDA_FIXUP_ACT_PRE_PROBE:
6073 		/* mic pin 0x19 must be initialized with Vref Hi-Z, otherwise
6074 		 * it causes a click noise at start up
6075 		 */
6076 		snd_hda_codec_set_pin_target(codec, 0x19, PIN_VREFHIZ);
6077 		spec->shutup = alc_shutup_dell_xps13;
6078 		break;
6079 	case HDA_FIXUP_ACT_PROBE:
6080 		/* Make the internal mic the default input source. */
6081 		for (i = 0; i < imux->num_items; i++) {
6082 			if (spec->gen.imux_pins[i] == 0x12) {
6083 				spec->gen.cur_mux[0] = i;
6084 				break;
6085 			}
6086 		}
6087 		break;
6088 	}
6089 }
6090 
6091 static void alc_fixup_headset_mode_alc662(struct hda_codec *codec,
6092 				const struct hda_fixup *fix, int action)
6093 {
6094 	struct alc_spec *spec = codec->spec;
6095 
6096 	if (action == HDA_FIXUP_ACT_PRE_PROBE) {
6097 		spec->parse_flags |= HDA_PINCFG_HEADSET_MIC;
6098 		spec->gen.hp_mic = 1; /* Mic-in is same pin as headphone */
6099 
6100 		/* Disable boost for mic-in permanently. (This code is only called
6101 		   from quirks that guarantee that the headphone is at NID 0x1b.) */
6102 		snd_hda_codec_write(codec, 0x1b, 0, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000);
6103 		snd_hda_override_wcaps(codec, 0x1b, get_wcaps(codec, 0x1b) & ~AC_WCAP_IN_AMP);
6104 	} else
6105 		alc_fixup_headset_mode(codec, fix, action);
6106 }
6107 
6108 static void alc_fixup_headset_mode_alc668(struct hda_codec *codec,
6109 				const struct hda_fixup *fix, int action)
6110 {
6111 	if (action == HDA_FIXUP_ACT_PRE_PROBE) {
6112 		alc_write_coef_idx(codec, 0xc4, 0x8000);
6113 		alc_update_coef_idx(codec, 0xc2, ~0xfe, 0);
6114 		snd_hda_set_pin_ctl_cache(codec, 0x18, 0);
6115 	}
6116 	alc_fixup_headset_mode(codec, fix, action);
6117 }
6118 
6119 /* Returns the nid of the external mic input pin, or 0 if it cannot be found. */
6120 static int find_ext_mic_pin(struct hda_codec *codec)
6121 {
6122 	struct alc_spec *spec = codec->spec;
6123 	struct auto_pin_cfg *cfg = &spec->gen.autocfg;
6124 	hda_nid_t nid;
6125 	unsigned int defcfg;
6126 	int i;
6127 
6128 	for (i = 0; i < cfg->num_inputs; i++) {
6129 		if (cfg->inputs[i].type != AUTO_PIN_MIC)
6130 			continue;
6131 		nid = cfg->inputs[i].pin;
6132 		defcfg = snd_hda_codec_get_pincfg(codec, nid);
6133 		if (snd_hda_get_input_pin_attr(defcfg) == INPUT_PIN_ATTR_INT)
6134 			continue;
6135 		return nid;
6136 	}
6137 
6138 	return 0;
6139 }
6140 
6141 static void alc271_hp_gate_mic_jack(struct hda_codec *codec,
6142 				    const struct hda_fixup *fix,
6143 				    int action)
6144 {
6145 	struct alc_spec *spec = codec->spec;
6146 
6147 	if (action == HDA_FIXUP_ACT_PROBE) {
6148 		int mic_pin = find_ext_mic_pin(codec);
6149 		int hp_pin = alc_get_hp_pin(spec);
6150 
6151 		if (snd_BUG_ON(!mic_pin || !hp_pin))
6152 			return;
6153 		snd_hda_jack_set_gating_jack(codec, mic_pin, hp_pin);
6154 	}
6155 }
6156 
6157 static void alc269_fixup_limit_int_mic_boost(struct hda_codec *codec,
6158 					     const struct hda_fixup *fix,
6159 					     int action)
6160 {
6161 	struct alc_spec *spec = codec->spec;
6162 	struct auto_pin_cfg *cfg = &spec->gen.autocfg;
6163 	int i;
6164 
6165 	/* The mic boosts on level 2 and 3 are too noisy
6166 	   on the internal mic input.
6167 	   Therefore limit the boost to 0 or 1. */
6168 
6169 	if (action != HDA_FIXUP_ACT_PROBE)
6170 		return;
6171 
6172 	for (i = 0; i < cfg->num_inputs; i++) {
6173 		hda_nid_t nid = cfg->inputs[i].pin;
6174 		unsigned int defcfg;
6175 		if (cfg->inputs[i].type != AUTO_PIN_MIC)
6176 			continue;
6177 		defcfg = snd_hda_codec_get_pincfg(codec, nid);
6178 		if (snd_hda_get_input_pin_attr(defcfg) != INPUT_PIN_ATTR_INT)
6179 			continue;
6180 
6181 		snd_hda_override_amp_caps(codec, nid, HDA_INPUT,
6182 					  (0x00 << AC_AMPCAP_OFFSET_SHIFT) |
6183 					  (0x01 << AC_AMPCAP_NUM_STEPS_SHIFT) |
6184 					  (0x2f << AC_AMPCAP_STEP_SIZE_SHIFT) |
6185 					  (0 << AC_AMPCAP_MUTE_SHIFT));
6186 	}
6187 }
6188 
6189 static void alc283_hp_automute_hook(struct hda_codec *codec,
6190 				    struct hda_jack_callback *jack)
6191 {
6192 	struct alc_spec *spec = codec->spec;
6193 	int vref;
6194 
6195 	msleep(200);
6196 	snd_hda_gen_hp_automute(codec, jack);
6197 
6198 	vref = spec->gen.hp_jack_present ? PIN_VREF80 : 0;
6199 
6200 	msleep(600);
6201 	snd_hda_codec_write(codec, 0x19, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
6202 			    vref);
6203 }
6204 
6205 static void alc283_fixup_chromebook(struct hda_codec *codec,
6206 				    const struct hda_fixup *fix, int action)
6207 {
6208 	struct alc_spec *spec = codec->spec;
6209 
6210 	switch (action) {
6211 	case HDA_FIXUP_ACT_PRE_PROBE:
6212 		snd_hda_override_wcaps(codec, 0x03, 0);
6213 		/* Disable AA-loopback as it causes white noise */
6214 		spec->gen.mixer_nid = 0;
6215 		break;
6216 	case HDA_FIXUP_ACT_INIT:
6217 		/* MIC2-VREF control */
6218 		/* Set to manual mode */
6219 		alc_update_coef_idx(codec, 0x06, 0x000c, 0);
6220 		/* Enable Line1 input control by verb */
6221 		alc_update_coef_idx(codec, 0x1a, 0, 1 << 4);
6222 		break;
6223 	}
6224 }
6225 
6226 static void alc283_fixup_sense_combo_jack(struct hda_codec *codec,
6227 				    const struct hda_fixup *fix, int action)
6228 {
6229 	struct alc_spec *spec = codec->spec;
6230 
6231 	switch (action) {
6232 	case HDA_FIXUP_ACT_PRE_PROBE:
6233 		spec->gen.hp_automute_hook = alc283_hp_automute_hook;
6234 		break;
6235 	case HDA_FIXUP_ACT_INIT:
6236 		/* MIC2-VREF control */
6237 		/* Set to manual mode */
6238 		alc_update_coef_idx(codec, 0x06, 0x000c, 0);
6239 		break;
6240 	}
6241 }
6242 
6243 /* mute tablet speaker pin (0x14) via dock plugging in addition */
6244 static void asus_tx300_automute(struct hda_codec *codec)
6245 {
6246 	struct alc_spec *spec = codec->spec;
6247 	snd_hda_gen_update_outputs(codec);
6248 	if (snd_hda_jack_detect(codec, 0x1b))
6249 		spec->gen.mute_bits |= (1ULL << 0x14);
6250 }
6251 
6252 static void alc282_fixup_asus_tx300(struct hda_codec *codec,
6253 				    const struct hda_fixup *fix, int action)
6254 {
6255 	struct alc_spec *spec = codec->spec;
6256 	static const struct hda_pintbl dock_pins[] = {
6257 		{ 0x1b, 0x21114000 }, /* dock speaker pin */
6258 		{}
6259 	};
6260 
6261 	switch (action) {
6262 	case HDA_FIXUP_ACT_PRE_PROBE:
6263 		spec->init_amp = ALC_INIT_DEFAULT;
6264 		/* TX300 needs to set up GPIO2 for the speaker amp */
6265 		alc_setup_gpio(codec, 0x04);
6266 		snd_hda_apply_pincfgs(codec, dock_pins);
6267 		spec->gen.auto_mute_via_amp = 1;
6268 		spec->gen.automute_hook = asus_tx300_automute;
6269 		snd_hda_jack_detect_enable_callback(codec, 0x1b,
6270 						    snd_hda_gen_hp_automute);
6271 		break;
6272 	case HDA_FIXUP_ACT_PROBE:
6273 		spec->init_amp = ALC_INIT_DEFAULT;
6274 		break;
6275 	case HDA_FIXUP_ACT_BUILD:
6276 		/* this is a bit tricky; give more sane names for the main
6277 		 * (tablet) speaker and the dock speaker, respectively
6278 		 */
6279 		rename_ctl(codec, "Speaker Playback Switch",
6280 			   "Dock Speaker Playback Switch");
6281 		rename_ctl(codec, "Bass Speaker Playback Switch",
6282 			   "Speaker Playback Switch");
6283 		break;
6284 	}
6285 }
6286 
6287 static void alc290_fixup_mono_speakers(struct hda_codec *codec,
6288 				       const struct hda_fixup *fix, int action)
6289 {
6290 	if (action == HDA_FIXUP_ACT_PRE_PROBE) {
6291 		/* DAC node 0x03 is giving mono output. We therefore want to
6292 		   make sure 0x14 (front speaker) and 0x15 (headphones) use the
6293 		   stereo DAC, while leaving 0x17 (bass speaker) for node 0x03. */
6294 		static const hda_nid_t conn1[] = { 0x0c };
6295 		snd_hda_override_conn_list(codec, 0x14, ARRAY_SIZE(conn1), conn1);
6296 		snd_hda_override_conn_list(codec, 0x15, ARRAY_SIZE(conn1), conn1);
6297 	}
6298 }
6299 
6300 static void alc298_fixup_speaker_volume(struct hda_codec *codec,
6301 					const struct hda_fixup *fix, int action)
6302 {
6303 	if (action == HDA_FIXUP_ACT_PRE_PROBE) {
6304 		/* The speaker is routed to the Node 0x06 by a mistake, as a result
6305 		   we can't adjust the speaker's volume since this node does not has
6306 		   Amp-out capability. we change the speaker's route to:
6307 		   Node 0x02 (Audio Output) -> Node 0x0c (Audio Mixer) -> Node 0x17 (
6308 		   Pin Complex), since Node 0x02 has Amp-out caps, we can adjust
6309 		   speaker's volume now. */
6310 
6311 		static const hda_nid_t conn1[] = { 0x0c };
6312 		snd_hda_override_conn_list(codec, 0x17, ARRAY_SIZE(conn1), conn1);
6313 	}
6314 }
6315 
6316 /* disable DAC3 (0x06) selection on NID 0x17 as it has no volume amp control */
6317 static void alc295_fixup_disable_dac3(struct hda_codec *codec,
6318 				      const struct hda_fixup *fix, int action)
6319 {
6320 	if (action == HDA_FIXUP_ACT_PRE_PROBE) {
6321 		static const hda_nid_t conn[] = { 0x02, 0x03 };
6322 		snd_hda_override_conn_list(codec, 0x17, ARRAY_SIZE(conn), conn);
6323 	}
6324 }
6325 
6326 /* force NID 0x17 (Bass Speaker) to DAC1 to share it with the main speaker */
6327 static void alc285_fixup_speaker2_to_dac1(struct hda_codec *codec,
6328 					  const struct hda_fixup *fix, int action)
6329 {
6330 	if (action == HDA_FIXUP_ACT_PRE_PROBE) {
6331 		static const hda_nid_t conn[] = { 0x02 };
6332 		snd_hda_override_conn_list(codec, 0x17, ARRAY_SIZE(conn), conn);
6333 	}
6334 }
6335 
6336 /* Hook to update amp GPIO4 for automute */
6337 static void alc280_hp_gpio4_automute_hook(struct hda_codec *codec,
6338 					  struct hda_jack_callback *jack)
6339 {
6340 	struct alc_spec *spec = codec->spec;
6341 
6342 	snd_hda_gen_hp_automute(codec, jack);
6343 	/* mute_led_polarity is set to 0, so we pass inverted value here */
6344 	alc_update_gpio_led(codec, 0x10, spec->mute_led_polarity,
6345 			    !spec->gen.hp_jack_present);
6346 }
6347 
6348 /* Manage GPIOs for HP EliteBook Folio 9480m.
6349  *
6350  * GPIO4 is the headphone amplifier power control
6351  * GPIO3 is the audio output mute indicator LED
6352  */
6353 
6354 static void alc280_fixup_hp_9480m(struct hda_codec *codec,
6355 				  const struct hda_fixup *fix,
6356 				  int action)
6357 {
6358 	struct alc_spec *spec = codec->spec;
6359 
6360 	alc_fixup_hp_gpio_led(codec, action, 0x08, 0);
6361 	if (action == HDA_FIXUP_ACT_PRE_PROBE) {
6362 		/* amp at GPIO4; toggled via alc280_hp_gpio4_automute_hook() */
6363 		spec->gpio_mask |= 0x10;
6364 		spec->gpio_dir |= 0x10;
6365 		spec->gen.hp_automute_hook = alc280_hp_gpio4_automute_hook;
6366 	}
6367 }
6368 
6369 static void alc275_fixup_gpio4_off(struct hda_codec *codec,
6370 				   const struct hda_fixup *fix,
6371 				   int action)
6372 {
6373 	struct alc_spec *spec = codec->spec;
6374 
6375 	if (action == HDA_FIXUP_ACT_PRE_PROBE) {
6376 		spec->gpio_mask |= 0x04;
6377 		spec->gpio_dir |= 0x04;
6378 		/* set data bit low */
6379 	}
6380 }
6381 
6382 /* Quirk for Thinkpad X1 7th and 8th Gen
6383  * The following fixed routing needed
6384  * DAC1 (NID 0x02) -> Speaker (NID 0x14); some eq applied secretly
6385  * DAC2 (NID 0x03) -> Bass (NID 0x17) & Headphone (NID 0x21); sharing a DAC
6386  * DAC3 (NID 0x06) -> Unused, due to the lack of volume amp
6387  */
6388 static void alc285_fixup_thinkpad_x1_gen7(struct hda_codec *codec,
6389 					  const struct hda_fixup *fix, int action)
6390 {
6391 	static const hda_nid_t conn[] = { 0x02, 0x03 }; /* exclude 0x06 */
6392 	static const hda_nid_t preferred_pairs[] = {
6393 		0x14, 0x02, 0x17, 0x03, 0x21, 0x03, 0
6394 	};
6395 	struct alc_spec *spec = codec->spec;
6396 
6397 	switch (action) {
6398 	case HDA_FIXUP_ACT_PRE_PROBE:
6399 		snd_hda_override_conn_list(codec, 0x17, ARRAY_SIZE(conn), conn);
6400 		spec->gen.preferred_dacs = preferred_pairs;
6401 		break;
6402 	case HDA_FIXUP_ACT_BUILD:
6403 		/* The generic parser creates somewhat unintuitive volume ctls
6404 		 * with the fixed routing above, and the shared DAC2 may be
6405 		 * confusing for PA.
6406 		 * Rename those to unique names so that PA doesn't touch them
6407 		 * and use only Master volume.
6408 		 */
6409 		rename_ctl(codec, "Front Playback Volume", "DAC1 Playback Volume");
6410 		rename_ctl(codec, "Bass Speaker Playback Volume", "DAC2 Playback Volume");
6411 		break;
6412 	}
6413 }
6414 
6415 static void alc233_alc662_fixup_lenovo_dual_codecs(struct hda_codec *codec,
6416 					 const struct hda_fixup *fix,
6417 					 int action)
6418 {
6419 	alc_fixup_dual_codecs(codec, fix, action);
6420 	switch (action) {
6421 	case HDA_FIXUP_ACT_PRE_PROBE:
6422 		/* override card longname to provide a unique UCM profile */
6423 		strcpy(codec->card->longname, "HDAudio-Lenovo-DualCodecs");
6424 		break;
6425 	case HDA_FIXUP_ACT_BUILD:
6426 		/* rename Capture controls depending on the codec */
6427 		rename_ctl(codec, "Capture Volume",
6428 			   codec->addr == 0 ?
6429 			   "Rear-Panel Capture Volume" :
6430 			   "Front-Panel Capture Volume");
6431 		rename_ctl(codec, "Capture Switch",
6432 			   codec->addr == 0 ?
6433 			   "Rear-Panel Capture Switch" :
6434 			   "Front-Panel Capture Switch");
6435 		break;
6436 	}
6437 }
6438 
6439 static void alc225_fixup_s3_pop_noise(struct hda_codec *codec,
6440 				      const struct hda_fixup *fix, int action)
6441 {
6442 	if (action != HDA_FIXUP_ACT_PRE_PROBE)
6443 		return;
6444 
6445 	codec->power_save_node = 1;
6446 }
6447 
6448 /* Forcibly assign NID 0x03 to HP/LO while NID 0x02 to SPK for EQ */
6449 static void alc274_fixup_bind_dacs(struct hda_codec *codec,
6450 				    const struct hda_fixup *fix, int action)
6451 {
6452 	struct alc_spec *spec = codec->spec;
6453 	static const hda_nid_t preferred_pairs[] = {
6454 		0x21, 0x03, 0x1b, 0x03, 0x16, 0x02,
6455 		0
6456 	};
6457 
6458 	if (action != HDA_FIXUP_ACT_PRE_PROBE)
6459 		return;
6460 
6461 	spec->gen.preferred_dacs = preferred_pairs;
6462 	spec->gen.auto_mute_via_amp = 1;
6463 	codec->power_save_node = 0;
6464 }
6465 
6466 /* avoid DAC 0x06 for bass speaker 0x17; it has no volume control */
6467 static void alc289_fixup_asus_ga401(struct hda_codec *codec,
6468 				    const struct hda_fixup *fix, int action)
6469 {
6470 	static const hda_nid_t preferred_pairs[] = {
6471 		0x14, 0x02, 0x17, 0x02, 0x21, 0x03, 0
6472 	};
6473 	struct alc_spec *spec = codec->spec;
6474 
6475 	if (action == HDA_FIXUP_ACT_PRE_PROBE) {
6476 		spec->gen.preferred_dacs = preferred_pairs;
6477 		spec->gen.obey_preferred_dacs = 1;
6478 	}
6479 }
6480 
6481 /* The DAC of NID 0x3 will introduce click/pop noise on headphones, so invalidate it */
6482 static void alc285_fixup_invalidate_dacs(struct hda_codec *codec,
6483 			      const struct hda_fixup *fix, int action)
6484 {
6485 	if (action != HDA_FIXUP_ACT_PRE_PROBE)
6486 		return;
6487 
6488 	snd_hda_override_wcaps(codec, 0x03, 0);
6489 }
6490 
6491 static void alc_combo_jack_hp_jd_restart(struct hda_codec *codec)
6492 {
6493 	switch (codec->core.vendor_id) {
6494 	case 0x10ec0274:
6495 	case 0x10ec0294:
6496 	case 0x10ec0225:
6497 	case 0x10ec0295:
6498 	case 0x10ec0299:
6499 		alc_update_coef_idx(codec, 0x4a, 0x8000, 1 << 15); /* Reset HP JD */
6500 		alc_update_coef_idx(codec, 0x4a, 0x8000, 0 << 15);
6501 		break;
6502 	case 0x10ec0230:
6503 	case 0x10ec0235:
6504 	case 0x10ec0236:
6505 	case 0x10ec0255:
6506 	case 0x10ec0256:
6507 	case 0x10ec0257:
6508 	case 0x19e58326:
6509 		alc_update_coef_idx(codec, 0x1b, 0x8000, 1 << 15); /* Reset HP JD */
6510 		alc_update_coef_idx(codec, 0x1b, 0x8000, 0 << 15);
6511 		break;
6512 	}
6513 }
6514 
6515 static void alc295_fixup_chromebook(struct hda_codec *codec,
6516 				    const struct hda_fixup *fix, int action)
6517 {
6518 	struct alc_spec *spec = codec->spec;
6519 
6520 	switch (action) {
6521 	case HDA_FIXUP_ACT_PRE_PROBE:
6522 		spec->ultra_low_power = true;
6523 		break;
6524 	case HDA_FIXUP_ACT_INIT:
6525 		alc_combo_jack_hp_jd_restart(codec);
6526 		break;
6527 	}
6528 }
6529 
6530 static void alc256_fixup_chromebook(struct hda_codec *codec,
6531 				    const struct hda_fixup *fix, int action)
6532 {
6533 	struct alc_spec *spec = codec->spec;
6534 
6535 	switch (action) {
6536 	case HDA_FIXUP_ACT_PRE_PROBE:
6537 		spec->gen.suppress_auto_mute = 1;
6538 		spec->gen.suppress_auto_mic = 1;
6539 		spec->en_3kpull_low = false;
6540 		break;
6541 	}
6542 }
6543 
6544 static void alc_fixup_disable_mic_vref(struct hda_codec *codec,
6545 				  const struct hda_fixup *fix, int action)
6546 {
6547 	if (action == HDA_FIXUP_ACT_PRE_PROBE)
6548 		snd_hda_codec_set_pin_target(codec, 0x19, PIN_VREFHIZ);
6549 }
6550 
6551 
6552 static void alc294_gx502_toggle_output(struct hda_codec *codec,
6553 					struct hda_jack_callback *cb)
6554 {
6555 	/* The Windows driver sets the codec up in a very different way where
6556 	 * it appears to leave 0x10 = 0x8a20 set. For Linux we need to toggle it
6557 	 */
6558 	if (snd_hda_jack_detect_state(codec, 0x21) == HDA_JACK_PRESENT)
6559 		alc_write_coef_idx(codec, 0x10, 0x8a20);
6560 	else
6561 		alc_write_coef_idx(codec, 0x10, 0x0a20);
6562 }
6563 
6564 static void alc294_fixup_gx502_hp(struct hda_codec *codec,
6565 					const struct hda_fixup *fix, int action)
6566 {
6567 	/* Pin 0x21: headphones/headset mic */
6568 	if (!is_jack_detectable(codec, 0x21))
6569 		return;
6570 
6571 	switch (action) {
6572 	case HDA_FIXUP_ACT_PRE_PROBE:
6573 		snd_hda_jack_detect_enable_callback(codec, 0x21,
6574 				alc294_gx502_toggle_output);
6575 		break;
6576 	case HDA_FIXUP_ACT_INIT:
6577 		/* Make sure to start in a correct state, i.e. if
6578 		 * headphones have been plugged in before powering up the system
6579 		 */
6580 		alc294_gx502_toggle_output(codec, NULL);
6581 		break;
6582 	}
6583 }
6584 
6585 static void alc294_gu502_toggle_output(struct hda_codec *codec,
6586 				       struct hda_jack_callback *cb)
6587 {
6588 	/* Windows sets 0x10 to 0x8420 for Node 0x20 which is
6589 	 * responsible from changes between speakers and headphones
6590 	 */
6591 	if (snd_hda_jack_detect_state(codec, 0x21) == HDA_JACK_PRESENT)
6592 		alc_write_coef_idx(codec, 0x10, 0x8420);
6593 	else
6594 		alc_write_coef_idx(codec, 0x10, 0x0a20);
6595 }
6596 
6597 static void alc294_fixup_gu502_hp(struct hda_codec *codec,
6598 				  const struct hda_fixup *fix, int action)
6599 {
6600 	if (!is_jack_detectable(codec, 0x21))
6601 		return;
6602 
6603 	switch (action) {
6604 	case HDA_FIXUP_ACT_PRE_PROBE:
6605 		snd_hda_jack_detect_enable_callback(codec, 0x21,
6606 				alc294_gu502_toggle_output);
6607 		break;
6608 	case HDA_FIXUP_ACT_INIT:
6609 		alc294_gu502_toggle_output(codec, NULL);
6610 		break;
6611 	}
6612 }
6613 
6614 static void  alc285_fixup_hp_gpio_amp_init(struct hda_codec *codec,
6615 			      const struct hda_fixup *fix, int action)
6616 {
6617 	if (action != HDA_FIXUP_ACT_INIT)
6618 		return;
6619 
6620 	msleep(100);
6621 	alc_write_coef_idx(codec, 0x65, 0x0);
6622 }
6623 
6624 static void alc274_fixup_hp_headset_mic(struct hda_codec *codec,
6625 				    const struct hda_fixup *fix, int action)
6626 {
6627 	switch (action) {
6628 	case HDA_FIXUP_ACT_INIT:
6629 		alc_combo_jack_hp_jd_restart(codec);
6630 		break;
6631 	}
6632 }
6633 
6634 static void alc_fixup_no_int_mic(struct hda_codec *codec,
6635 				    const struct hda_fixup *fix, int action)
6636 {
6637 	struct alc_spec *spec = codec->spec;
6638 
6639 	switch (action) {
6640 	case HDA_FIXUP_ACT_PRE_PROBE:
6641 		/* Mic RING SLEEVE swap for combo jack */
6642 		alc_update_coef_idx(codec, 0x45, 0xf<<12 | 1<<10, 5<<12);
6643 		spec->no_internal_mic_pin = true;
6644 		break;
6645 	case HDA_FIXUP_ACT_INIT:
6646 		alc_combo_jack_hp_jd_restart(codec);
6647 		break;
6648 	}
6649 }
6650 
6651 /* GPIO1 = amplifier on/off
6652  * GPIO3 = mic mute LED
6653  */
6654 static void alc285_fixup_hp_spectre_x360_eb1(struct hda_codec *codec,
6655 					  const struct hda_fixup *fix, int action)
6656 {
6657 	static const hda_nid_t conn[] = { 0x02 };
6658 
6659 	struct alc_spec *spec = codec->spec;
6660 	static const struct hda_pintbl pincfgs[] = {
6661 		{ 0x14, 0x90170110 },  /* front/high speakers */
6662 		{ 0x17, 0x90170130 },  /* back/bass speakers */
6663 		{ }
6664 	};
6665 
6666 	//enable micmute led
6667 	alc_fixup_hp_gpio_led(codec, action, 0x00, 0x04);
6668 
6669 	switch (action) {
6670 	case HDA_FIXUP_ACT_PRE_PROBE:
6671 		spec->micmute_led_polarity = 1;
6672 		/* needed for amp of back speakers */
6673 		spec->gpio_mask |= 0x01;
6674 		spec->gpio_dir |= 0x01;
6675 		snd_hda_apply_pincfgs(codec, pincfgs);
6676 		/* share DAC to have unified volume control */
6677 		snd_hda_override_conn_list(codec, 0x14, ARRAY_SIZE(conn), conn);
6678 		snd_hda_override_conn_list(codec, 0x17, ARRAY_SIZE(conn), conn);
6679 		break;
6680 	case HDA_FIXUP_ACT_INIT:
6681 		/* need to toggle GPIO to enable the amp of back speakers */
6682 		alc_update_gpio_data(codec, 0x01, true);
6683 		msleep(100);
6684 		alc_update_gpio_data(codec, 0x01, false);
6685 		break;
6686 	}
6687 }
6688 
6689 static void alc285_fixup_hp_spectre_x360(struct hda_codec *codec,
6690 					  const struct hda_fixup *fix, int action)
6691 {
6692 	static const hda_nid_t conn[] = { 0x02 };
6693 	static const struct hda_pintbl pincfgs[] = {
6694 		{ 0x14, 0x90170110 },  /* rear speaker */
6695 		{ }
6696 	};
6697 
6698 	switch (action) {
6699 	case HDA_FIXUP_ACT_PRE_PROBE:
6700 		snd_hda_apply_pincfgs(codec, pincfgs);
6701 		/* force front speaker to DAC1 */
6702 		snd_hda_override_conn_list(codec, 0x17, ARRAY_SIZE(conn), conn);
6703 		break;
6704 	}
6705 }
6706 
6707 static void alc285_fixup_hp_envy_x360(struct hda_codec *codec,
6708 				      const struct hda_fixup *fix,
6709 				      int action)
6710 {
6711 	static const struct coef_fw coefs[] = {
6712 		WRITE_COEF(0x08, 0x6a0c), WRITE_COEF(0x0d, 0xa023),
6713 		WRITE_COEF(0x10, 0x0320), WRITE_COEF(0x1a, 0x8c03),
6714 		WRITE_COEF(0x25, 0x1800), WRITE_COEF(0x26, 0x003a),
6715 		WRITE_COEF(0x28, 0x1dfe), WRITE_COEF(0x29, 0xb014),
6716 		WRITE_COEF(0x2b, 0x1dfe), WRITE_COEF(0x37, 0xfe15),
6717 		WRITE_COEF(0x38, 0x7909), WRITE_COEF(0x45, 0xd489),
6718 		WRITE_COEF(0x46, 0x00f4), WRITE_COEF(0x4a, 0x21e0),
6719 		WRITE_COEF(0x66, 0x03f0), WRITE_COEF(0x67, 0x1000),
6720 		WRITE_COEF(0x6e, 0x1005), { }
6721 	};
6722 
6723 	static const struct hda_pintbl pincfgs[] = {
6724 		{ 0x12, 0xb7a60130 },  /* Internal microphone*/
6725 		{ 0x14, 0x90170150 },  /* B&O soundbar speakers */
6726 		{ 0x17, 0x90170153 },  /* Side speakers */
6727 		{ 0x19, 0x03a11040 },  /* Headset microphone */
6728 		{ }
6729 	};
6730 
6731 	switch (action) {
6732 	case HDA_FIXUP_ACT_PRE_PROBE:
6733 		snd_hda_apply_pincfgs(codec, pincfgs);
6734 
6735 		/* Fixes volume control problem for side speakers */
6736 		alc295_fixup_disable_dac3(codec, fix, action);
6737 
6738 		/* Fixes no sound from headset speaker */
6739 		snd_hda_codec_amp_stereo(codec, 0x21, HDA_OUTPUT, 0, -1, 0);
6740 
6741 		/* Auto-enable headset mic when plugged */
6742 		snd_hda_jack_set_gating_jack(codec, 0x19, 0x21);
6743 
6744 		/* Headset mic volume enhancement */
6745 		snd_hda_codec_set_pin_target(codec, 0x19, PIN_VREF50);
6746 		break;
6747 	case HDA_FIXUP_ACT_INIT:
6748 		alc_process_coef_fw(codec, coefs);
6749 		break;
6750 	case HDA_FIXUP_ACT_BUILD:
6751 		rename_ctl(codec, "Bass Speaker Playback Volume",
6752 			   "B&O-Tuned Playback Volume");
6753 		rename_ctl(codec, "Front Playback Switch",
6754 			   "B&O Soundbar Playback Switch");
6755 		rename_ctl(codec, "Bass Speaker Playback Switch",
6756 			   "Side Speaker Playback Switch");
6757 		break;
6758 	}
6759 }
6760 
6761 /* for hda_fixup_thinkpad_acpi() */
6762 #include "thinkpad_helper.c"
6763 
6764 static void alc_fixup_thinkpad_acpi(struct hda_codec *codec,
6765 				    const struct hda_fixup *fix, int action)
6766 {
6767 	alc_fixup_no_shutup(codec, fix, action); /* reduce click noise */
6768 	hda_fixup_thinkpad_acpi(codec, fix, action);
6769 }
6770 
6771 /* Fixup for Lenovo Legion 15IMHg05 speaker output on headset removal. */
6772 static void alc287_fixup_legion_15imhg05_speakers(struct hda_codec *codec,
6773 						  const struct hda_fixup *fix,
6774 						  int action)
6775 {
6776 	struct alc_spec *spec = codec->spec;
6777 
6778 	switch (action) {
6779 	case HDA_FIXUP_ACT_PRE_PROBE:
6780 		spec->gen.suppress_auto_mute = 1;
6781 		break;
6782 	}
6783 }
6784 
6785 static void comp_acpi_device_notify(acpi_handle handle, u32 event, void *data)
6786 {
6787 	struct hda_codec *cdc = data;
6788 	struct alc_spec *spec = cdc->spec;
6789 
6790 	codec_info(cdc, "ACPI Notification %d\n", event);
6791 
6792 	hda_component_acpi_device_notify(spec->comps, ARRAY_SIZE(spec->comps),
6793 					 handle, event, data);
6794 }
6795 
6796 static int comp_bind(struct device *dev)
6797 {
6798 	struct hda_codec *cdc = dev_to_hda_codec(dev);
6799 	struct alc_spec *spec = cdc->spec;
6800 	int ret;
6801 
6802 	ret = hda_component_manager_bind(cdc, spec->comps, ARRAY_SIZE(spec->comps));
6803 	if (ret)
6804 		return ret;
6805 
6806 	return hda_component_manager_bind_acpi_notifications(cdc,
6807 							     spec->comps, ARRAY_SIZE(spec->comps),
6808 							     comp_acpi_device_notify, cdc);
6809 }
6810 
6811 static void comp_unbind(struct device *dev)
6812 {
6813 	struct hda_codec *cdc = dev_to_hda_codec(dev);
6814 	struct alc_spec *spec = cdc->spec;
6815 
6816 	hda_component_manager_unbind_acpi_notifications(cdc, spec->comps, comp_acpi_device_notify);
6817 	hda_component_manager_unbind(cdc, spec->comps);
6818 }
6819 
6820 static const struct component_master_ops comp_master_ops = {
6821 	.bind = comp_bind,
6822 	.unbind = comp_unbind,
6823 };
6824 
6825 static void comp_generic_playback_hook(struct hda_pcm_stream *hinfo, struct hda_codec *cdc,
6826 				       struct snd_pcm_substream *sub, int action)
6827 {
6828 	struct alc_spec *spec = cdc->spec;
6829 
6830 	hda_component_manager_playback_hook(spec->comps, ARRAY_SIZE(spec->comps), action);
6831 }
6832 
6833 static void comp_generic_fixup(struct hda_codec *cdc, int action, const char *bus,
6834 			       const char *hid, const char *match_str, int count)
6835 {
6836 	struct alc_spec *spec = cdc->spec;
6837 	int ret;
6838 
6839 	switch (action) {
6840 	case HDA_FIXUP_ACT_PRE_PROBE:
6841 		ret = hda_component_manager_init(cdc, spec->comps, count, bus, hid,
6842 						 match_str, &comp_master_ops);
6843 		if (ret)
6844 			return;
6845 
6846 		spec->gen.pcm_playback_hook = comp_generic_playback_hook;
6847 		break;
6848 	case HDA_FIXUP_ACT_FREE:
6849 		hda_component_manager_free(cdc, &comp_master_ops);
6850 		break;
6851 	}
6852 }
6853 
6854 static void cs35l41_fixup_i2c_two(struct hda_codec *cdc, const struct hda_fixup *fix, int action)
6855 {
6856 	comp_generic_fixup(cdc, action, "i2c", "CSC3551", "-%s:00-cs35l41-hda.%d", 2);
6857 }
6858 
6859 static void cs35l41_fixup_i2c_four(struct hda_codec *cdc, const struct hda_fixup *fix, int action)
6860 {
6861 	comp_generic_fixup(cdc, action, "i2c", "CSC3551", "-%s:00-cs35l41-hda.%d", 4);
6862 }
6863 
6864 static void cs35l41_fixup_spi_two(struct hda_codec *codec, const struct hda_fixup *fix, int action)
6865 {
6866 	comp_generic_fixup(codec, action, "spi", "CSC3551", "-%s:00-cs35l41-hda.%d", 2);
6867 }
6868 
6869 static void cs35l41_fixup_spi_four(struct hda_codec *codec, const struct hda_fixup *fix, int action)
6870 {
6871 	comp_generic_fixup(codec, action, "spi", "CSC3551", "-%s:00-cs35l41-hda.%d", 4);
6872 }
6873 
6874 static void alc287_fixup_legion_16achg6_speakers(struct hda_codec *cdc, const struct hda_fixup *fix,
6875 						 int action)
6876 {
6877 	comp_generic_fixup(cdc, action, "i2c", "CLSA0100", "-%s:00-cs35l41-hda.%d", 2);
6878 }
6879 
6880 static void alc287_fixup_legion_16ithg6_speakers(struct hda_codec *cdc, const struct hda_fixup *fix,
6881 						 int action)
6882 {
6883 	comp_generic_fixup(cdc, action, "i2c", "CLSA0101", "-%s:00-cs35l41-hda.%d", 2);
6884 }
6885 
6886 static void cs35l56_fixup_i2c_two(struct hda_codec *cdc, const struct hda_fixup *fix, int action)
6887 {
6888 	comp_generic_fixup(cdc, action, "i2c", "CSC3556", "-%s:00-cs35l56-hda.%d", 2);
6889 }
6890 
6891 static void cs35l56_fixup_i2c_four(struct hda_codec *cdc, const struct hda_fixup *fix, int action)
6892 {
6893 	comp_generic_fixup(cdc, action, "i2c", "CSC3556", "-%s:00-cs35l56-hda.%d", 4);
6894 }
6895 
6896 static void cs35l56_fixup_spi_two(struct hda_codec *cdc, const struct hda_fixup *fix, int action)
6897 {
6898 	comp_generic_fixup(cdc, action, "spi", "CSC3556", "-%s:00-cs35l56-hda.%d", 2);
6899 }
6900 
6901 static void cs35l56_fixup_spi_four(struct hda_codec *cdc, const struct hda_fixup *fix, int action)
6902 {
6903 	comp_generic_fixup(cdc, action, "spi", "CSC3556", "-%s:00-cs35l56-hda.%d", 4);
6904 }
6905 
6906 static void alc285_fixup_asus_ga403u(struct hda_codec *cdc, const struct hda_fixup *fix, int action)
6907 {
6908 	/*
6909 	 * The same SSID has been re-used in different hardware, they have
6910 	 * different codecs and the newer GA403U has a ALC285.
6911 	 */
6912 	if (cdc->core.vendor_id == 0x10ec0285)
6913 		cs35l56_fixup_i2c_two(cdc, fix, action);
6914 	else
6915 		alc_fixup_inv_dmic(cdc, fix, action);
6916 }
6917 
6918 static void tas2781_fixup_i2c(struct hda_codec *cdc,
6919 	const struct hda_fixup *fix, int action)
6920 {
6921 	comp_generic_fixup(cdc, action, "i2c", "TIAS2781", "-%s:00", 1);
6922 }
6923 
6924 static void yoga7_14arb7_fixup_i2c(struct hda_codec *cdc,
6925 	const struct hda_fixup *fix, int action)
6926 {
6927 	comp_generic_fixup(cdc, action, "i2c", "INT8866", "-%s:00", 1);
6928 }
6929 
6930 static void alc256_fixup_acer_sfg16_micmute_led(struct hda_codec *codec,
6931 	const struct hda_fixup *fix, int action)
6932 {
6933 	alc_fixup_hp_gpio_led(codec, action, 0, 0x04);
6934 }
6935 
6936 
6937 /* for alc295_fixup_hp_top_speakers */
6938 #include "hp_x360_helper.c"
6939 
6940 /* for alc285_fixup_ideapad_s740_coef() */
6941 #include "ideapad_s740_helper.c"
6942 
6943 static const struct coef_fw alc256_fixup_set_coef_defaults_coefs[] = {
6944 	WRITE_COEF(0x10, 0x0020), WRITE_COEF(0x24, 0x0000),
6945 	WRITE_COEF(0x26, 0x0000), WRITE_COEF(0x29, 0x3000),
6946 	WRITE_COEF(0x37, 0xfe05), WRITE_COEF(0x45, 0x5089),
6947 	{}
6948 };
6949 
6950 static void alc256_fixup_set_coef_defaults(struct hda_codec *codec,
6951 					   const struct hda_fixup *fix,
6952 					   int action)
6953 {
6954 	/*
6955 	 * A certain other OS sets these coeffs to different values. On at least
6956 	 * one TongFang barebone these settings might survive even a cold
6957 	 * reboot. So to restore a clean slate the values are explicitly reset
6958 	 * to default here. Without this, the external microphone is always in a
6959 	 * plugged-in state, while the internal microphone is always in an
6960 	 * unplugged state, breaking the ability to use the internal microphone.
6961 	 */
6962 	alc_process_coef_fw(codec, alc256_fixup_set_coef_defaults_coefs);
6963 }
6964 
6965 static const struct coef_fw alc233_fixup_no_audio_jack_coefs[] = {
6966 	WRITE_COEF(0x1a, 0x9003), WRITE_COEF(0x1b, 0x0e2b), WRITE_COEF(0x37, 0xfe06),
6967 	WRITE_COEF(0x38, 0x4981), WRITE_COEF(0x45, 0xd489), WRITE_COEF(0x46, 0x0074),
6968 	WRITE_COEF(0x49, 0x0149),
6969 	{}
6970 };
6971 
6972 static void alc233_fixup_no_audio_jack(struct hda_codec *codec,
6973 				       const struct hda_fixup *fix,
6974 				       int action)
6975 {
6976 	/*
6977 	 * The audio jack input and output is not detected on the ASRock NUC Box
6978 	 * 1100 series when cold booting without this fix. Warm rebooting from a
6979 	 * certain other OS makes the audio functional, as COEF settings are
6980 	 * preserved in this case. This fix sets these altered COEF values as
6981 	 * the default.
6982 	 */
6983 	alc_process_coef_fw(codec, alc233_fixup_no_audio_jack_coefs);
6984 }
6985 
6986 static void alc256_fixup_mic_no_presence_and_resume(struct hda_codec *codec,
6987 						    const struct hda_fixup *fix,
6988 						    int action)
6989 {
6990 	/*
6991 	 * The Clevo NJ51CU comes either with the ALC293 or the ALC256 codec,
6992 	 * but uses the 0x8686 subproduct id in both cases. The ALC256 codec
6993 	 * needs an additional quirk for sound working after suspend and resume.
6994 	 */
6995 	if (codec->core.vendor_id == 0x10ec0256) {
6996 		alc_update_coef_idx(codec, 0x10, 1<<9, 0);
6997 		snd_hda_codec_set_pincfg(codec, 0x19, 0x04a11120);
6998 	} else {
6999 		snd_hda_codec_set_pincfg(codec, 0x1a, 0x04a1113c);
7000 	}
7001 }
7002 
7003 static void alc256_decrease_headphone_amp_val(struct hda_codec *codec,
7004 					      const struct hda_fixup *fix, int action)
7005 {
7006 	u32 caps;
7007 	u8 nsteps, offs;
7008 
7009 	if (action != HDA_FIXUP_ACT_PRE_PROBE)
7010 		return;
7011 
7012 	caps = query_amp_caps(codec, 0x3, HDA_OUTPUT);
7013 	nsteps = ((caps & AC_AMPCAP_NUM_STEPS) >> AC_AMPCAP_NUM_STEPS_SHIFT) - 10;
7014 	offs = ((caps & AC_AMPCAP_OFFSET) >> AC_AMPCAP_OFFSET_SHIFT) - 10;
7015 	caps &= ~AC_AMPCAP_NUM_STEPS & ~AC_AMPCAP_OFFSET;
7016 	caps |= (nsteps << AC_AMPCAP_NUM_STEPS_SHIFT) | (offs << AC_AMPCAP_OFFSET_SHIFT);
7017 
7018 	if (snd_hda_override_amp_caps(codec, 0x3, HDA_OUTPUT, caps))
7019 		codec_warn(codec, "failed to override amp caps for NID 0x3\n");
7020 }
7021 
7022 static void alc_fixup_dell4_mic_no_presence_quiet(struct hda_codec *codec,
7023 						  const struct hda_fixup *fix,
7024 						  int action)
7025 {
7026 	struct alc_spec *spec = codec->spec;
7027 	struct hda_input_mux *imux = &spec->gen.input_mux;
7028 	int i;
7029 
7030 	alc269_fixup_limit_int_mic_boost(codec, fix, action);
7031 
7032 	switch (action) {
7033 	case HDA_FIXUP_ACT_PRE_PROBE:
7034 		/**
7035 		 * Set the vref of pin 0x19 (Headset Mic) and pin 0x1b (Headphone Mic)
7036 		 * to Hi-Z to avoid pop noises at startup and when plugging and
7037 		 * unplugging headphones.
7038 		 */
7039 		snd_hda_codec_set_pin_target(codec, 0x19, PIN_VREFHIZ);
7040 		snd_hda_codec_set_pin_target(codec, 0x1b, PIN_VREFHIZ);
7041 		break;
7042 	case HDA_FIXUP_ACT_PROBE:
7043 		/**
7044 		 * Make the internal mic (0x12) the default input source to
7045 		 * prevent pop noises on cold boot.
7046 		 */
7047 		for (i = 0; i < imux->num_items; i++) {
7048 			if (spec->gen.imux_pins[i] == 0x12) {
7049 				spec->gen.cur_mux[0] = i;
7050 				break;
7051 			}
7052 		}
7053 		break;
7054 	}
7055 }
7056 
7057 static void alc287_fixup_yoga9_14iap7_bass_spk_pin(struct hda_codec *codec,
7058 					  const struct hda_fixup *fix, int action)
7059 {
7060 	/*
7061 	 * The Pin Complex 0x17 for the bass speakers is wrongly reported as
7062 	 * unconnected.
7063 	 */
7064 	static const struct hda_pintbl pincfgs[] = {
7065 		{ 0x17, 0x90170121 },
7066 		{ }
7067 	};
7068 	/*
7069 	 * Avoid DAC 0x06 and 0x08, as they have no volume controls.
7070 	 * DAC 0x02 and 0x03 would be fine.
7071 	 */
7072 	static const hda_nid_t conn[] = { 0x02, 0x03 };
7073 	/*
7074 	 * Prefer both speakerbar (0x14) and bass speakers (0x17) connected to DAC 0x02.
7075 	 * Headphones (0x21) are connected to DAC 0x03.
7076 	 */
7077 	static const hda_nid_t preferred_pairs[] = {
7078 		0x14, 0x02,
7079 		0x17, 0x02,
7080 		0x21, 0x03,
7081 		0
7082 	};
7083 	struct alc_spec *spec = codec->spec;
7084 
7085 	switch (action) {
7086 	case HDA_FIXUP_ACT_PRE_PROBE:
7087 		snd_hda_apply_pincfgs(codec, pincfgs);
7088 		snd_hda_override_conn_list(codec, 0x17, ARRAY_SIZE(conn), conn);
7089 		spec->gen.preferred_dacs = preferred_pairs;
7090 		break;
7091 	}
7092 }
7093 
7094 static void alc295_fixup_dell_inspiron_top_speakers(struct hda_codec *codec,
7095 					  const struct hda_fixup *fix, int action)
7096 {
7097 	static const struct hda_pintbl pincfgs[] = {
7098 		{ 0x14, 0x90170151 },
7099 		{ 0x17, 0x90170150 },
7100 		{ }
7101 	};
7102 	static const hda_nid_t conn[] = { 0x02, 0x03 };
7103 	static const hda_nid_t preferred_pairs[] = {
7104 		0x14, 0x02,
7105 		0x17, 0x03,
7106 		0x21, 0x02,
7107 		0
7108 	};
7109 	struct alc_spec *spec = codec->spec;
7110 
7111 	alc_fixup_no_shutup(codec, fix, action);
7112 
7113 	switch (action) {
7114 	case HDA_FIXUP_ACT_PRE_PROBE:
7115 		snd_hda_apply_pincfgs(codec, pincfgs);
7116 		snd_hda_override_conn_list(codec, 0x17, ARRAY_SIZE(conn), conn);
7117 		spec->gen.preferred_dacs = preferred_pairs;
7118 		break;
7119 	}
7120 }
7121 
7122 /* Forcibly assign NID 0x03 to HP while NID 0x02 to SPK */
7123 static void alc287_fixup_bind_dacs(struct hda_codec *codec,
7124 				    const struct hda_fixup *fix, int action)
7125 {
7126 	struct alc_spec *spec = codec->spec;
7127 	static const hda_nid_t conn[] = { 0x02, 0x03 }; /* exclude 0x06 */
7128 	static const hda_nid_t preferred_pairs[] = {
7129 		0x17, 0x02, 0x21, 0x03, 0
7130 	};
7131 
7132 	if (action != HDA_FIXUP_ACT_PRE_PROBE)
7133 		return;
7134 
7135 	snd_hda_override_conn_list(codec, 0x17, ARRAY_SIZE(conn), conn);
7136 	spec->gen.preferred_dacs = preferred_pairs;
7137 	spec->gen.auto_mute_via_amp = 1;
7138 	if (spec->gen.autocfg.speaker_pins[0] != 0x14) {
7139 		snd_hda_codec_write_cache(codec, 0x14, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
7140 					0x0); /* Make sure 0x14 was disable */
7141 	}
7142 }
7143 /* Fix none verb table of Headset Mic pin */
7144 static void alc_fixup_headset_mic(struct hda_codec *codec,
7145 				   const struct hda_fixup *fix, int action)
7146 {
7147 	struct alc_spec *spec = codec->spec;
7148 	static const struct hda_pintbl pincfgs[] = {
7149 		{ 0x19, 0x03a1103c },
7150 		{ }
7151 	};
7152 
7153 	switch (action) {
7154 	case HDA_FIXUP_ACT_PRE_PROBE:
7155 		snd_hda_apply_pincfgs(codec, pincfgs);
7156 		alc_update_coef_idx(codec, 0x45, 0xf<<12 | 1<<10, 5<<12);
7157 		spec->parse_flags |= HDA_PINCFG_HEADSET_MIC;
7158 		break;
7159 	}
7160 }
7161 
7162 static void alc245_fixup_hp_spectre_x360_eu0xxx(struct hda_codec *codec,
7163 					  const struct hda_fixup *fix, int action)
7164 {
7165 	/*
7166 	 * The Pin Complex 0x14 for the treble speakers is wrongly reported as
7167 	 * unconnected.
7168 	 * The Pin Complex 0x17 for the bass speakers has the lowest association
7169 	 * and sequence values so shift it up a bit to squeeze 0x14 in.
7170 	 */
7171 	static const struct hda_pintbl pincfgs[] = {
7172 		{ 0x14, 0x90170110 }, // top/treble
7173 		{ 0x17, 0x90170111 }, // bottom/bass
7174 		{ }
7175 	};
7176 
7177 	/*
7178 	 * Force DAC 0x02 for the bass speakers 0x17.
7179 	 */
7180 	static const hda_nid_t conn[] = { 0x02 };
7181 
7182 	switch (action) {
7183 	case HDA_FIXUP_ACT_PRE_PROBE:
7184 		snd_hda_apply_pincfgs(codec, pincfgs);
7185 		snd_hda_override_conn_list(codec, 0x17, ARRAY_SIZE(conn), conn);
7186 		break;
7187 	}
7188 
7189 	cs35l41_fixup_i2c_two(codec, fix, action);
7190 	alc245_fixup_hp_mute_led_coefbit(codec, fix, action);
7191 	alc245_fixup_hp_gpio_led(codec, fix, action);
7192 }
7193 
7194 /*
7195  * ALC287 PCM hooks
7196  */
7197 static void alc287_alc1318_playback_pcm_hook(struct hda_pcm_stream *hinfo,
7198 				   struct hda_codec *codec,
7199 				   struct snd_pcm_substream *substream,
7200 				   int action)
7201 {
7202 	alc_write_coef_idx(codec, 0x10, 0x8806); /* Change MLK to GPIO3 */
7203 	switch (action) {
7204 	case HDA_GEN_PCM_ACT_OPEN:
7205 		alc_write_coefex_idx(codec, 0x5a, 0x00, 0x954f); /* write gpio3 to high */
7206 		break;
7207 	case HDA_GEN_PCM_ACT_CLOSE:
7208 		alc_write_coefex_idx(codec, 0x5a, 0x00, 0x554f); /* write gpio3 as default value */
7209 		break;
7210 	}
7211 }
7212 
7213 static void alc287_s4_power_gpio3_default(struct hda_codec *codec)
7214 {
7215 	if (is_s4_suspend(codec)) {
7216 		alc_write_coef_idx(codec, 0x10, 0x8806); /* Change MLK to GPIO3 */
7217 		alc_write_coefex_idx(codec, 0x5a, 0x00, 0x554f); /* write gpio3 as default value */
7218 	}
7219 }
7220 
7221 static void alc287_fixup_lenovo_thinkpad_with_alc1318(struct hda_codec *codec,
7222 			       const struct hda_fixup *fix, int action)
7223 {
7224 	struct alc_spec *spec = codec->spec;
7225 
7226 	if (action != HDA_FIXUP_ACT_PRE_PROBE)
7227 		return;
7228 	spec->power_hook = alc287_s4_power_gpio3_default;
7229 	spec->gen.pcm_playback_hook = alc287_alc1318_playback_pcm_hook;
7230 }
7231 
7232 
7233 enum {
7234 	ALC269_FIXUP_GPIO2,
7235 	ALC269_FIXUP_SONY_VAIO,
7236 	ALC275_FIXUP_SONY_VAIO_GPIO2,
7237 	ALC269_FIXUP_DELL_M101Z,
7238 	ALC269_FIXUP_SKU_IGNORE,
7239 	ALC269_FIXUP_ASUS_G73JW,
7240 	ALC269_FIXUP_ASUS_N7601ZM_PINS,
7241 	ALC269_FIXUP_ASUS_N7601ZM,
7242 	ALC269_FIXUP_LENOVO_EAPD,
7243 	ALC275_FIXUP_SONY_HWEQ,
7244 	ALC275_FIXUP_SONY_DISABLE_AAMIX,
7245 	ALC271_FIXUP_DMIC,
7246 	ALC269_FIXUP_PCM_44K,
7247 	ALC269_FIXUP_STEREO_DMIC,
7248 	ALC269_FIXUP_HEADSET_MIC,
7249 	ALC269_FIXUP_QUANTA_MUTE,
7250 	ALC269_FIXUP_LIFEBOOK,
7251 	ALC269_FIXUP_LIFEBOOK_EXTMIC,
7252 	ALC269_FIXUP_LIFEBOOK_HP_PIN,
7253 	ALC269_FIXUP_LIFEBOOK_NO_HP_TO_LINEOUT,
7254 	ALC255_FIXUP_LIFEBOOK_U7x7_HEADSET_MIC,
7255 	ALC269_FIXUP_AMIC,
7256 	ALC269_FIXUP_DMIC,
7257 	ALC269VB_FIXUP_AMIC,
7258 	ALC269VB_FIXUP_DMIC,
7259 	ALC269_FIXUP_HP_MUTE_LED,
7260 	ALC269_FIXUP_HP_MUTE_LED_MIC1,
7261 	ALC269_FIXUP_HP_MUTE_LED_MIC2,
7262 	ALC269_FIXUP_HP_MUTE_LED_MIC3,
7263 	ALC269_FIXUP_HP_GPIO_LED,
7264 	ALC269_FIXUP_HP_GPIO_MIC1_LED,
7265 	ALC269_FIXUP_HP_LINE1_MIC1_LED,
7266 	ALC269_FIXUP_INV_DMIC,
7267 	ALC269_FIXUP_LENOVO_DOCK,
7268 	ALC269_FIXUP_LENOVO_DOCK_LIMIT_BOOST,
7269 	ALC269_FIXUP_NO_SHUTUP,
7270 	ALC286_FIXUP_SONY_MIC_NO_PRESENCE,
7271 	ALC269_FIXUP_PINCFG_NO_HP_TO_LINEOUT,
7272 	ALC269_FIXUP_DELL1_MIC_NO_PRESENCE,
7273 	ALC269_FIXUP_DELL2_MIC_NO_PRESENCE,
7274 	ALC269_FIXUP_DELL3_MIC_NO_PRESENCE,
7275 	ALC269_FIXUP_DELL4_MIC_NO_PRESENCE,
7276 	ALC269_FIXUP_DELL4_MIC_NO_PRESENCE_QUIET,
7277 	ALC269_FIXUP_HEADSET_MODE,
7278 	ALC269_FIXUP_HEADSET_MODE_NO_HP_MIC,
7279 	ALC269_FIXUP_ASPIRE_HEADSET_MIC,
7280 	ALC269_FIXUP_ASUS_X101_FUNC,
7281 	ALC269_FIXUP_ASUS_X101_VERB,
7282 	ALC269_FIXUP_ASUS_X101,
7283 	ALC271_FIXUP_AMIC_MIC2,
7284 	ALC271_FIXUP_HP_GATE_MIC_JACK,
7285 	ALC271_FIXUP_HP_GATE_MIC_JACK_E1_572,
7286 	ALC269_FIXUP_ACER_AC700,
7287 	ALC269_FIXUP_LIMIT_INT_MIC_BOOST,
7288 	ALC269VB_FIXUP_ASUS_ZENBOOK,
7289 	ALC269VB_FIXUP_ASUS_ZENBOOK_UX31A,
7290 	ALC269VB_FIXUP_ASUS_MIC_NO_PRESENCE,
7291 	ALC269_FIXUP_LIMIT_INT_MIC_BOOST_MUTE_LED,
7292 	ALC269VB_FIXUP_ORDISSIMO_EVE2,
7293 	ALC283_FIXUP_CHROME_BOOK,
7294 	ALC283_FIXUP_SENSE_COMBO_JACK,
7295 	ALC282_FIXUP_ASUS_TX300,
7296 	ALC283_FIXUP_INT_MIC,
7297 	ALC290_FIXUP_MONO_SPEAKERS,
7298 	ALC290_FIXUP_MONO_SPEAKERS_HSJACK,
7299 	ALC290_FIXUP_SUBWOOFER,
7300 	ALC290_FIXUP_SUBWOOFER_HSJACK,
7301 	ALC269_FIXUP_THINKPAD_ACPI,
7302 	ALC269_FIXUP_DMIC_THINKPAD_ACPI,
7303 	ALC269VB_FIXUP_CHUWI_COREBOOK_XPRO,
7304 	ALC255_FIXUP_ACER_MIC_NO_PRESENCE,
7305 	ALC255_FIXUP_ASUS_MIC_NO_PRESENCE,
7306 	ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
7307 	ALC255_FIXUP_DELL2_MIC_NO_PRESENCE,
7308 	ALC255_FIXUP_HEADSET_MODE,
7309 	ALC255_FIXUP_HEADSET_MODE_NO_HP_MIC,
7310 	ALC293_FIXUP_DELL1_MIC_NO_PRESENCE,
7311 	ALC292_FIXUP_TPT440_DOCK,
7312 	ALC292_FIXUP_TPT440,
7313 	ALC283_FIXUP_HEADSET_MIC,
7314 	ALC255_FIXUP_MIC_MUTE_LED,
7315 	ALC282_FIXUP_ASPIRE_V5_PINS,
7316 	ALC269VB_FIXUP_ASPIRE_E1_COEF,
7317 	ALC280_FIXUP_HP_GPIO4,
7318 	ALC286_FIXUP_HP_GPIO_LED,
7319 	ALC280_FIXUP_HP_GPIO2_MIC_HOTKEY,
7320 	ALC280_FIXUP_HP_DOCK_PINS,
7321 	ALC269_FIXUP_HP_DOCK_GPIO_MIC1_LED,
7322 	ALC280_FIXUP_HP_9480M,
7323 	ALC245_FIXUP_HP_X360_AMP,
7324 	ALC285_FIXUP_HP_SPECTRE_X360_EB1,
7325 	ALC285_FIXUP_HP_ENVY_X360,
7326 	ALC288_FIXUP_DELL_HEADSET_MODE,
7327 	ALC288_FIXUP_DELL1_MIC_NO_PRESENCE,
7328 	ALC288_FIXUP_DELL_XPS_13,
7329 	ALC288_FIXUP_DISABLE_AAMIX,
7330 	ALC292_FIXUP_DELL_E7X_AAMIX,
7331 	ALC292_FIXUP_DELL_E7X,
7332 	ALC292_FIXUP_DISABLE_AAMIX,
7333 	ALC293_FIXUP_DISABLE_AAMIX_MULTIJACK,
7334 	ALC298_FIXUP_ALIENWARE_MIC_NO_PRESENCE,
7335 	ALC298_FIXUP_DELL1_MIC_NO_PRESENCE,
7336 	ALC298_FIXUP_DELL_AIO_MIC_NO_PRESENCE,
7337 	ALC275_FIXUP_DELL_XPS,
7338 	ALC293_FIXUP_LENOVO_SPK_NOISE,
7339 	ALC233_FIXUP_LENOVO_LINE2_MIC_HOTKEY,
7340 	ALC255_FIXUP_DELL_SPK_NOISE,
7341 	ALC225_FIXUP_DISABLE_MIC_VREF,
7342 	ALC225_FIXUP_DELL1_MIC_NO_PRESENCE,
7343 	ALC295_FIXUP_DISABLE_DAC3,
7344 	ALC285_FIXUP_SPEAKER2_TO_DAC1,
7345 	ALC285_FIXUP_ASUS_SPEAKER2_TO_DAC1,
7346 	ALC285_FIXUP_ASUS_HEADSET_MIC,
7347 	ALC285_FIXUP_ASUS_SPI_REAR_SPEAKERS,
7348 	ALC285_FIXUP_ASUS_I2C_SPEAKER2_TO_DAC1,
7349 	ALC285_FIXUP_ASUS_I2C_HEADSET_MIC,
7350 	ALC280_FIXUP_HP_HEADSET_MIC,
7351 	ALC221_FIXUP_HP_FRONT_MIC,
7352 	ALC292_FIXUP_TPT460,
7353 	ALC298_FIXUP_SPK_VOLUME,
7354 	ALC298_FIXUP_LENOVO_SPK_VOLUME,
7355 	ALC256_FIXUP_DELL_INSPIRON_7559_SUBWOOFER,
7356 	ALC269_FIXUP_ATIV_BOOK_8,
7357 	ALC221_FIXUP_HP_288PRO_MIC_NO_PRESENCE,
7358 	ALC221_FIXUP_HP_MIC_NO_PRESENCE,
7359 	ALC256_FIXUP_ASUS_HEADSET_MODE,
7360 	ALC256_FIXUP_ASUS_MIC,
7361 	ALC256_FIXUP_ASUS_AIO_GPIO2,
7362 	ALC233_FIXUP_ASUS_MIC_NO_PRESENCE,
7363 	ALC233_FIXUP_EAPD_COEF_AND_MIC_NO_PRESENCE,
7364 	ALC233_FIXUP_LENOVO_MULTI_CODECS,
7365 	ALC233_FIXUP_ACER_HEADSET_MIC,
7366 	ALC294_FIXUP_LENOVO_MIC_LOCATION,
7367 	ALC225_FIXUP_DELL_WYSE_MIC_NO_PRESENCE,
7368 	ALC225_FIXUP_S3_POP_NOISE,
7369 	ALC700_FIXUP_INTEL_REFERENCE,
7370 	ALC274_FIXUP_DELL_BIND_DACS,
7371 	ALC274_FIXUP_DELL_AIO_LINEOUT_VERB,
7372 	ALC298_FIXUP_TPT470_DOCK_FIX,
7373 	ALC298_FIXUP_TPT470_DOCK,
7374 	ALC255_FIXUP_DUMMY_LINEOUT_VERB,
7375 	ALC255_FIXUP_DELL_HEADSET_MIC,
7376 	ALC256_FIXUP_HUAWEI_MACH_WX9_PINS,
7377 	ALC298_FIXUP_HUAWEI_MBX_STEREO,
7378 	ALC295_FIXUP_HP_X360,
7379 	ALC221_FIXUP_HP_HEADSET_MIC,
7380 	ALC285_FIXUP_LENOVO_HEADPHONE_NOISE,
7381 	ALC295_FIXUP_HP_AUTO_MUTE,
7382 	ALC286_FIXUP_ACER_AIO_MIC_NO_PRESENCE,
7383 	ALC294_FIXUP_ASUS_MIC,
7384 	ALC294_FIXUP_ASUS_HEADSET_MIC,
7385 	ALC294_FIXUP_ASUS_SPK,
7386 	ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE,
7387 	ALC285_FIXUP_LENOVO_PC_BEEP_IN_NOISE,
7388 	ALC255_FIXUP_ACER_HEADSET_MIC,
7389 	ALC295_FIXUP_CHROME_BOOK,
7390 	ALC225_FIXUP_HEADSET_JACK,
7391 	ALC225_FIXUP_DELL_WYSE_AIO_MIC_NO_PRESENCE,
7392 	ALC225_FIXUP_WYSE_AUTO_MUTE,
7393 	ALC225_FIXUP_WYSE_DISABLE_MIC_VREF,
7394 	ALC286_FIXUP_ACER_AIO_HEADSET_MIC,
7395 	ALC256_FIXUP_ASUS_HEADSET_MIC,
7396 	ALC256_FIXUP_ASUS_MIC_NO_PRESENCE,
7397 	ALC299_FIXUP_PREDATOR_SPK,
7398 	ALC256_FIXUP_MEDION_HEADSET_NO_PRESENCE,
7399 	ALC289_FIXUP_DELL_SPK1,
7400 	ALC289_FIXUP_DELL_SPK2,
7401 	ALC289_FIXUP_DUAL_SPK,
7402 	ALC289_FIXUP_RTK_AMP_DUAL_SPK,
7403 	ALC294_FIXUP_SPK2_TO_DAC1,
7404 	ALC294_FIXUP_ASUS_DUAL_SPK,
7405 	ALC285_FIXUP_THINKPAD_X1_GEN7,
7406 	ALC285_FIXUP_THINKPAD_HEADSET_JACK,
7407 	ALC294_FIXUP_ASUS_ALLY,
7408 	ALC294_FIXUP_ASUS_ALLY_PINS,
7409 	ALC294_FIXUP_ASUS_ALLY_VERBS,
7410 	ALC294_FIXUP_ASUS_ALLY_SPEAKER,
7411 	ALC294_FIXUP_ASUS_HPE,
7412 	ALC294_FIXUP_ASUS_COEF_1B,
7413 	ALC294_FIXUP_ASUS_GX502_HP,
7414 	ALC294_FIXUP_ASUS_GX502_PINS,
7415 	ALC294_FIXUP_ASUS_GX502_VERBS,
7416 	ALC294_FIXUP_ASUS_GU502_HP,
7417 	ALC294_FIXUP_ASUS_GU502_PINS,
7418 	ALC294_FIXUP_ASUS_GU502_VERBS,
7419 	ALC294_FIXUP_ASUS_G513_PINS,
7420 	ALC285_FIXUP_ASUS_G533Z_PINS,
7421 	ALC285_FIXUP_HP_GPIO_LED,
7422 	ALC285_FIXUP_HP_MUTE_LED,
7423 	ALC285_FIXUP_HP_SPECTRE_X360_MUTE_LED,
7424 	ALC236_FIXUP_HP_MUTE_LED_COEFBIT2,
7425 	ALC236_FIXUP_HP_GPIO_LED,
7426 	ALC236_FIXUP_HP_MUTE_LED,
7427 	ALC236_FIXUP_HP_MUTE_LED_MICMUTE_VREF,
7428 	ALC298_FIXUP_SAMSUNG_AMP,
7429 	ALC298_FIXUP_SAMSUNG_HEADPHONE_VERY_QUIET,
7430 	ALC256_FIXUP_SAMSUNG_HEADPHONE_VERY_QUIET,
7431 	ALC295_FIXUP_ASUS_MIC_NO_PRESENCE,
7432 	ALC269VC_FIXUP_ACER_VCOPPERBOX_PINS,
7433 	ALC269VC_FIXUP_ACER_HEADSET_MIC,
7434 	ALC269VC_FIXUP_ACER_MIC_NO_PRESENCE,
7435 	ALC289_FIXUP_ASUS_GA401,
7436 	ALC289_FIXUP_ASUS_GA502,
7437 	ALC256_FIXUP_ACER_MIC_NO_PRESENCE,
7438 	ALC285_FIXUP_HP_GPIO_AMP_INIT,
7439 	ALC269_FIXUP_CZC_B20,
7440 	ALC269_FIXUP_CZC_TMI,
7441 	ALC269_FIXUP_CZC_L101,
7442 	ALC269_FIXUP_LEMOTE_A1802,
7443 	ALC269_FIXUP_LEMOTE_A190X,
7444 	ALC256_FIXUP_INTEL_NUC8_RUGGED,
7445 	ALC233_FIXUP_INTEL_NUC8_DMIC,
7446 	ALC233_FIXUP_INTEL_NUC8_BOOST,
7447 	ALC256_FIXUP_INTEL_NUC10,
7448 	ALC255_FIXUP_XIAOMI_HEADSET_MIC,
7449 	ALC274_FIXUP_HP_MIC,
7450 	ALC274_FIXUP_HP_HEADSET_MIC,
7451 	ALC274_FIXUP_HP_ENVY_GPIO,
7452 	ALC256_FIXUP_ASUS_HPE,
7453 	ALC285_FIXUP_THINKPAD_NO_BASS_SPK_HEADSET_JACK,
7454 	ALC287_FIXUP_HP_GPIO_LED,
7455 	ALC256_FIXUP_HP_HEADSET_MIC,
7456 	ALC245_FIXUP_HP_GPIO_LED,
7457 	ALC236_FIXUP_DELL_AIO_HEADSET_MIC,
7458 	ALC282_FIXUP_ACER_DISABLE_LINEOUT,
7459 	ALC255_FIXUP_ACER_LIMIT_INT_MIC_BOOST,
7460 	ALC256_FIXUP_ACER_HEADSET_MIC,
7461 	ALC285_FIXUP_IDEAPAD_S740_COEF,
7462 	ALC285_FIXUP_HP_LIMIT_INT_MIC_BOOST,
7463 	ALC295_FIXUP_ASUS_DACS,
7464 	ALC295_FIXUP_HP_OMEN,
7465 	ALC285_FIXUP_HP_SPECTRE_X360,
7466 	ALC287_FIXUP_IDEAPAD_BASS_SPK_AMP,
7467 	ALC623_FIXUP_LENOVO_THINKSTATION_P340,
7468 	ALC255_FIXUP_ACER_HEADPHONE_AND_MIC,
7469 	ALC236_FIXUP_HP_LIMIT_INT_MIC_BOOST,
7470 	ALC287_FIXUP_LEGION_15IMHG05_SPEAKERS,
7471 	ALC287_FIXUP_LEGION_15IMHG05_AUTOMUTE,
7472 	ALC287_FIXUP_YOGA7_14ITL_SPEAKERS,
7473 	ALC298_FIXUP_LENOVO_C940_DUET7,
7474 	ALC287_FIXUP_LENOVO_14IRP8_DUETITL,
7475 	ALC287_FIXUP_LENOVO_LEGION_7,
7476 	ALC287_FIXUP_13S_GEN2_SPEAKERS,
7477 	ALC256_FIXUP_SET_COEF_DEFAULTS,
7478 	ALC256_FIXUP_SYSTEM76_MIC_NO_PRESENCE,
7479 	ALC233_FIXUP_NO_AUDIO_JACK,
7480 	ALC256_FIXUP_MIC_NO_PRESENCE_AND_RESUME,
7481 	ALC285_FIXUP_LEGION_Y9000X_SPEAKERS,
7482 	ALC285_FIXUP_LEGION_Y9000X_AUTOMUTE,
7483 	ALC287_FIXUP_LEGION_16ACHG6,
7484 	ALC287_FIXUP_CS35L41_I2C_2,
7485 	ALC287_FIXUP_CS35L41_I2C_2_HP_GPIO_LED,
7486 	ALC287_FIXUP_CS35L41_I2C_4,
7487 	ALC245_FIXUP_CS35L41_SPI_2,
7488 	ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED,
7489 	ALC245_FIXUP_CS35L41_SPI_4,
7490 	ALC245_FIXUP_CS35L41_SPI_4_HP_GPIO_LED,
7491 	ALC285_FIXUP_HP_SPEAKERS_MICMUTE_LED,
7492 	ALC295_FIXUP_FRAMEWORK_LAPTOP_MIC_NO_PRESENCE,
7493 	ALC287_FIXUP_LEGION_16ITHG6,
7494 	ALC287_FIXUP_YOGA9_14IAP7_BASS_SPK,
7495 	ALC287_FIXUP_YOGA9_14IAP7_BASS_SPK_PIN,
7496 	ALC287_FIXUP_YOGA9_14IMH9_BASS_SPK_PIN,
7497 	ALC295_FIXUP_DELL_INSPIRON_TOP_SPEAKERS,
7498 	ALC236_FIXUP_DELL_DUAL_CODECS,
7499 	ALC287_FIXUP_CS35L41_I2C_2_THINKPAD_ACPI,
7500 	ALC287_FIXUP_TAS2781_I2C,
7501 	ALC287_FIXUP_YOGA7_14ARB7_I2C,
7502 	ALC245_FIXUP_HP_MUTE_LED_COEFBIT,
7503 	ALC245_FIXUP_HP_X360_MUTE_LEDS,
7504 	ALC287_FIXUP_THINKPAD_I2S_SPK,
7505 	ALC287_FIXUP_MG_RTKC_CSAMP_CS35L41_I2C_THINKPAD,
7506 	ALC2XX_FIXUP_HEADSET_MIC,
7507 	ALC289_FIXUP_DELL_CS35L41_SPI_2,
7508 	ALC294_FIXUP_CS35L41_I2C_2,
7509 	ALC245_FIXUP_CS35L56_SPI_4_HP_GPIO_LED,
7510 	ALC256_FIXUP_ACER_SFG16_MICMUTE_LED,
7511 	ALC256_FIXUP_HEADPHONE_AMP_VOL,
7512 	ALC245_FIXUP_HP_SPECTRE_X360_EU0XXX,
7513 	ALC285_FIXUP_CS35L56_SPI_2,
7514 	ALC285_FIXUP_CS35L56_I2C_2,
7515 	ALC285_FIXUP_CS35L56_I2C_4,
7516 	ALC285_FIXUP_ASUS_GA403U,
7517 	ALC285_FIXUP_ASUS_GA403U_HEADSET_MIC,
7518 	ALC285_FIXUP_ASUS_GA403U_I2C_SPEAKER2_TO_DAC1,
7519 	ALC285_FIXUP_ASUS_GU605_SPI_2_HEADSET_MIC,
7520 	ALC285_FIXUP_ASUS_GU605_SPI_SPEAKER2_TO_DAC1,
7521 	ALC287_FIXUP_LENOVO_THKPAD_WH_ALC1318,
7522 	ALC256_FIXUP_CHROME_BOOK,
7523 };
7524 
7525 /* A special fixup for Lenovo C940 and Yoga Duet 7;
7526  * both have the very same PCI SSID, and we need to apply different fixups
7527  * depending on the codec ID
7528  */
7529 static void alc298_fixup_lenovo_c940_duet7(struct hda_codec *codec,
7530 					   const struct hda_fixup *fix,
7531 					   int action)
7532 {
7533 	int id;
7534 
7535 	if (codec->core.vendor_id == 0x10ec0298)
7536 		id = ALC298_FIXUP_LENOVO_SPK_VOLUME; /* C940 */
7537 	else
7538 		id = ALC287_FIXUP_YOGA7_14ITL_SPEAKERS; /* Duet 7 */
7539 	__snd_hda_apply_fixup(codec, id, action, 0);
7540 }
7541 
7542 /* A special fixup for Lenovo Slim/Yoga Pro 9 14IRP8 and Yoga DuetITL 2021;
7543  * 14IRP8 PCI SSID will mistakenly be matched with the DuetITL codec SSID,
7544  * so we need to apply a different fixup in this case. The only DuetITL codec
7545  * SSID reported so far is the 17aa:3802 while the 14IRP8 has the 17aa:38be
7546  * and 17aa:38bf. If it weren't for the PCI SSID, the 14IRP8 models would
7547  * have matched correctly by their codecs.
7548  */
7549 static void alc287_fixup_lenovo_14irp8_duetitl(struct hda_codec *codec,
7550 					      const struct hda_fixup *fix,
7551 					      int action)
7552 {
7553 	int id;
7554 
7555 	if (codec->core.subsystem_id == 0x17aa3802)
7556 		id = ALC287_FIXUP_YOGA7_14ITL_SPEAKERS; /* DuetITL */
7557 	else
7558 		id = ALC287_FIXUP_TAS2781_I2C; /* 14IRP8 */
7559 	__snd_hda_apply_fixup(codec, id, action, 0);
7560 }
7561 
7562 /* Another hilarious PCI SSID conflict with Lenovo Legion Pro 7 16ARX8H (with
7563  * TAS2781 codec) and Legion 7i 16IAX7 (with CS35L41 codec);
7564  * we apply a corresponding fixup depending on the codec SSID instead
7565  */
7566 static void alc287_fixup_lenovo_legion_7(struct hda_codec *codec,
7567 					 const struct hda_fixup *fix,
7568 					 int action)
7569 {
7570 	int id;
7571 
7572 	if (codec->core.subsystem_id == 0x17aa38a8)
7573 		id = ALC287_FIXUP_TAS2781_I2C; /* Legion Pro 7 16ARX8H */
7574 	else
7575 		id = ALC287_FIXUP_CS35L41_I2C_2; /* Legion 7i 16IAX7 */
7576 	__snd_hda_apply_fixup(codec, id, action, 0);
7577 }
7578 
7579 static const struct hda_fixup alc269_fixups[] = {
7580 	[ALC269_FIXUP_GPIO2] = {
7581 		.type = HDA_FIXUP_FUNC,
7582 		.v.func = alc_fixup_gpio2,
7583 	},
7584 	[ALC269_FIXUP_SONY_VAIO] = {
7585 		.type = HDA_FIXUP_PINCTLS,
7586 		.v.pins = (const struct hda_pintbl[]) {
7587 			{0x19, PIN_VREFGRD},
7588 			{}
7589 		}
7590 	},
7591 	[ALC275_FIXUP_SONY_VAIO_GPIO2] = {
7592 		.type = HDA_FIXUP_FUNC,
7593 		.v.func = alc275_fixup_gpio4_off,
7594 		.chained = true,
7595 		.chain_id = ALC269_FIXUP_SONY_VAIO
7596 	},
7597 	[ALC269_FIXUP_DELL_M101Z] = {
7598 		.type = HDA_FIXUP_VERBS,
7599 		.v.verbs = (const struct hda_verb[]) {
7600 			/* Enables internal speaker */
7601 			{0x20, AC_VERB_SET_COEF_INDEX, 13},
7602 			{0x20, AC_VERB_SET_PROC_COEF, 0x4040},
7603 			{}
7604 		}
7605 	},
7606 	[ALC269_FIXUP_SKU_IGNORE] = {
7607 		.type = HDA_FIXUP_FUNC,
7608 		.v.func = alc_fixup_sku_ignore,
7609 	},
7610 	[ALC269_FIXUP_ASUS_G73JW] = {
7611 		.type = HDA_FIXUP_PINS,
7612 		.v.pins = (const struct hda_pintbl[]) {
7613 			{ 0x17, 0x99130111 }, /* subwoofer */
7614 			{ }
7615 		}
7616 	},
7617 	[ALC269_FIXUP_ASUS_N7601ZM_PINS] = {
7618 		.type = HDA_FIXUP_PINS,
7619 		.v.pins = (const struct hda_pintbl[]) {
7620 			{ 0x19, 0x03A11050 },
7621 			{ 0x1a, 0x03A11C30 },
7622 			{ 0x21, 0x03211420 },
7623 			{ }
7624 		}
7625 	},
7626 	[ALC269_FIXUP_ASUS_N7601ZM] = {
7627 		.type = HDA_FIXUP_VERBS,
7628 		.v.verbs = (const struct hda_verb[]) {
7629 			{0x20, AC_VERB_SET_COEF_INDEX, 0x62},
7630 			{0x20, AC_VERB_SET_PROC_COEF, 0xa007},
7631 			{0x20, AC_VERB_SET_COEF_INDEX, 0x10},
7632 			{0x20, AC_VERB_SET_PROC_COEF, 0x8420},
7633 			{0x20, AC_VERB_SET_COEF_INDEX, 0x0f},
7634 			{0x20, AC_VERB_SET_PROC_COEF, 0x7774},
7635 			{ }
7636 		},
7637 		.chained = true,
7638 		.chain_id = ALC269_FIXUP_ASUS_N7601ZM_PINS,
7639 	},
7640 	[ALC269_FIXUP_LENOVO_EAPD] = {
7641 		.type = HDA_FIXUP_VERBS,
7642 		.v.verbs = (const struct hda_verb[]) {
7643 			{0x14, AC_VERB_SET_EAPD_BTLENABLE, 0},
7644 			{}
7645 		}
7646 	},
7647 	[ALC275_FIXUP_SONY_HWEQ] = {
7648 		.type = HDA_FIXUP_FUNC,
7649 		.v.func = alc269_fixup_hweq,
7650 		.chained = true,
7651 		.chain_id = ALC275_FIXUP_SONY_VAIO_GPIO2
7652 	},
7653 	[ALC275_FIXUP_SONY_DISABLE_AAMIX] = {
7654 		.type = HDA_FIXUP_FUNC,
7655 		.v.func = alc_fixup_disable_aamix,
7656 		.chained = true,
7657 		.chain_id = ALC269_FIXUP_SONY_VAIO
7658 	},
7659 	[ALC271_FIXUP_DMIC] = {
7660 		.type = HDA_FIXUP_FUNC,
7661 		.v.func = alc271_fixup_dmic,
7662 	},
7663 	[ALC269_FIXUP_PCM_44K] = {
7664 		.type = HDA_FIXUP_FUNC,
7665 		.v.func = alc269_fixup_pcm_44k,
7666 		.chained = true,
7667 		.chain_id = ALC269_FIXUP_QUANTA_MUTE
7668 	},
7669 	[ALC269_FIXUP_STEREO_DMIC] = {
7670 		.type = HDA_FIXUP_FUNC,
7671 		.v.func = alc269_fixup_stereo_dmic,
7672 	},
7673 	[ALC269_FIXUP_HEADSET_MIC] = {
7674 		.type = HDA_FIXUP_FUNC,
7675 		.v.func = alc269_fixup_headset_mic,
7676 	},
7677 	[ALC269_FIXUP_QUANTA_MUTE] = {
7678 		.type = HDA_FIXUP_FUNC,
7679 		.v.func = alc269_fixup_quanta_mute,
7680 	},
7681 	[ALC269_FIXUP_LIFEBOOK] = {
7682 		.type = HDA_FIXUP_PINS,
7683 		.v.pins = (const struct hda_pintbl[]) {
7684 			{ 0x1a, 0x2101103f }, /* dock line-out */
7685 			{ 0x1b, 0x23a11040 }, /* dock mic-in */
7686 			{ }
7687 		},
7688 		.chained = true,
7689 		.chain_id = ALC269_FIXUP_QUANTA_MUTE
7690 	},
7691 	[ALC269_FIXUP_LIFEBOOK_EXTMIC] = {
7692 		.type = HDA_FIXUP_PINS,
7693 		.v.pins = (const struct hda_pintbl[]) {
7694 			{ 0x19, 0x01a1903c }, /* headset mic, with jack detect */
7695 			{ }
7696 		},
7697 	},
7698 	[ALC269_FIXUP_LIFEBOOK_HP_PIN] = {
7699 		.type = HDA_FIXUP_PINS,
7700 		.v.pins = (const struct hda_pintbl[]) {
7701 			{ 0x21, 0x0221102f }, /* HP out */
7702 			{ }
7703 		},
7704 	},
7705 	[ALC269_FIXUP_LIFEBOOK_NO_HP_TO_LINEOUT] = {
7706 		.type = HDA_FIXUP_FUNC,
7707 		.v.func = alc269_fixup_pincfg_no_hp_to_lineout,
7708 	},
7709 	[ALC255_FIXUP_LIFEBOOK_U7x7_HEADSET_MIC] = {
7710 		.type = HDA_FIXUP_FUNC,
7711 		.v.func = alc269_fixup_pincfg_U7x7_headset_mic,
7712 	},
7713 	[ALC269VB_FIXUP_CHUWI_COREBOOK_XPRO] = {
7714 		.type = HDA_FIXUP_PINS,
7715 		.v.pins = (const struct hda_pintbl[]) {
7716 			{ 0x18, 0x03a19020 }, /* headset mic */
7717 			{ 0x1b, 0x90170150 }, /* speaker */
7718 			{ }
7719 		},
7720 	},
7721 	[ALC269_FIXUP_AMIC] = {
7722 		.type = HDA_FIXUP_PINS,
7723 		.v.pins = (const struct hda_pintbl[]) {
7724 			{ 0x14, 0x99130110 }, /* speaker */
7725 			{ 0x15, 0x0121401f }, /* HP out */
7726 			{ 0x18, 0x01a19c20 }, /* mic */
7727 			{ 0x19, 0x99a3092f }, /* int-mic */
7728 			{ }
7729 		},
7730 	},
7731 	[ALC269_FIXUP_DMIC] = {
7732 		.type = HDA_FIXUP_PINS,
7733 		.v.pins = (const struct hda_pintbl[]) {
7734 			{ 0x12, 0x99a3092f }, /* int-mic */
7735 			{ 0x14, 0x99130110 }, /* speaker */
7736 			{ 0x15, 0x0121401f }, /* HP out */
7737 			{ 0x18, 0x01a19c20 }, /* mic */
7738 			{ }
7739 		},
7740 	},
7741 	[ALC269VB_FIXUP_AMIC] = {
7742 		.type = HDA_FIXUP_PINS,
7743 		.v.pins = (const struct hda_pintbl[]) {
7744 			{ 0x14, 0x99130110 }, /* speaker */
7745 			{ 0x18, 0x01a19c20 }, /* mic */
7746 			{ 0x19, 0x99a3092f }, /* int-mic */
7747 			{ 0x21, 0x0121401f }, /* HP out */
7748 			{ }
7749 		},
7750 	},
7751 	[ALC269VB_FIXUP_DMIC] = {
7752 		.type = HDA_FIXUP_PINS,
7753 		.v.pins = (const struct hda_pintbl[]) {
7754 			{ 0x12, 0x99a3092f }, /* int-mic */
7755 			{ 0x14, 0x99130110 }, /* speaker */
7756 			{ 0x18, 0x01a19c20 }, /* mic */
7757 			{ 0x21, 0x0121401f }, /* HP out */
7758 			{ }
7759 		},
7760 	},
7761 	[ALC269_FIXUP_HP_MUTE_LED] = {
7762 		.type = HDA_FIXUP_FUNC,
7763 		.v.func = alc269_fixup_hp_mute_led,
7764 	},
7765 	[ALC269_FIXUP_HP_MUTE_LED_MIC1] = {
7766 		.type = HDA_FIXUP_FUNC,
7767 		.v.func = alc269_fixup_hp_mute_led_mic1,
7768 	},
7769 	[ALC269_FIXUP_HP_MUTE_LED_MIC2] = {
7770 		.type = HDA_FIXUP_FUNC,
7771 		.v.func = alc269_fixup_hp_mute_led_mic2,
7772 	},
7773 	[ALC269_FIXUP_HP_MUTE_LED_MIC3] = {
7774 		.type = HDA_FIXUP_FUNC,
7775 		.v.func = alc269_fixup_hp_mute_led_mic3,
7776 		.chained = true,
7777 		.chain_id = ALC295_FIXUP_HP_AUTO_MUTE
7778 	},
7779 	[ALC269_FIXUP_HP_GPIO_LED] = {
7780 		.type = HDA_FIXUP_FUNC,
7781 		.v.func = alc269_fixup_hp_gpio_led,
7782 	},
7783 	[ALC269_FIXUP_HP_GPIO_MIC1_LED] = {
7784 		.type = HDA_FIXUP_FUNC,
7785 		.v.func = alc269_fixup_hp_gpio_mic1_led,
7786 	},
7787 	[ALC269_FIXUP_HP_LINE1_MIC1_LED] = {
7788 		.type = HDA_FIXUP_FUNC,
7789 		.v.func = alc269_fixup_hp_line1_mic1_led,
7790 	},
7791 	[ALC269_FIXUP_INV_DMIC] = {
7792 		.type = HDA_FIXUP_FUNC,
7793 		.v.func = alc_fixup_inv_dmic,
7794 	},
7795 	[ALC269_FIXUP_NO_SHUTUP] = {
7796 		.type = HDA_FIXUP_FUNC,
7797 		.v.func = alc_fixup_no_shutup,
7798 	},
7799 	[ALC269_FIXUP_LENOVO_DOCK] = {
7800 		.type = HDA_FIXUP_PINS,
7801 		.v.pins = (const struct hda_pintbl[]) {
7802 			{ 0x19, 0x23a11040 }, /* dock mic */
7803 			{ 0x1b, 0x2121103f }, /* dock headphone */
7804 			{ }
7805 		},
7806 		.chained = true,
7807 		.chain_id = ALC269_FIXUP_PINCFG_NO_HP_TO_LINEOUT
7808 	},
7809 	[ALC269_FIXUP_LENOVO_DOCK_LIMIT_BOOST] = {
7810 		.type = HDA_FIXUP_FUNC,
7811 		.v.func = alc269_fixup_limit_int_mic_boost,
7812 		.chained = true,
7813 		.chain_id = ALC269_FIXUP_LENOVO_DOCK,
7814 	},
7815 	[ALC269_FIXUP_PINCFG_NO_HP_TO_LINEOUT] = {
7816 		.type = HDA_FIXUP_FUNC,
7817 		.v.func = alc269_fixup_pincfg_no_hp_to_lineout,
7818 		.chained = true,
7819 		.chain_id = ALC269_FIXUP_THINKPAD_ACPI,
7820 	},
7821 	[ALC269_FIXUP_DELL1_MIC_NO_PRESENCE] = {
7822 		.type = HDA_FIXUP_PINS,
7823 		.v.pins = (const struct hda_pintbl[]) {
7824 			{ 0x19, 0x01a1913c }, /* use as headset mic, without its own jack detect */
7825 			{ 0x1a, 0x01a1913d }, /* use as headphone mic, without its own jack detect */
7826 			{ }
7827 		},
7828 		.chained = true,
7829 		.chain_id = ALC269_FIXUP_HEADSET_MODE
7830 	},
7831 	[ALC269_FIXUP_DELL2_MIC_NO_PRESENCE] = {
7832 		.type = HDA_FIXUP_PINS,
7833 		.v.pins = (const struct hda_pintbl[]) {
7834 			{ 0x16, 0x21014020 }, /* dock line out */
7835 			{ 0x19, 0x21a19030 }, /* dock mic */
7836 			{ 0x1a, 0x01a1913c }, /* use as headset mic, without its own jack detect */
7837 			{ }
7838 		},
7839 		.chained = true,
7840 		.chain_id = ALC269_FIXUP_HEADSET_MODE_NO_HP_MIC
7841 	},
7842 	[ALC269_FIXUP_DELL3_MIC_NO_PRESENCE] = {
7843 		.type = HDA_FIXUP_PINS,
7844 		.v.pins = (const struct hda_pintbl[]) {
7845 			{ 0x1a, 0x01a1913c }, /* use as headset mic, without its own jack detect */
7846 			{ }
7847 		},
7848 		.chained = true,
7849 		.chain_id = ALC269_FIXUP_HEADSET_MODE_NO_HP_MIC
7850 	},
7851 	[ALC269_FIXUP_DELL4_MIC_NO_PRESENCE] = {
7852 		.type = HDA_FIXUP_PINS,
7853 		.v.pins = (const struct hda_pintbl[]) {
7854 			{ 0x19, 0x01a1913c }, /* use as headset mic, without its own jack detect */
7855 			{ 0x1b, 0x01a1913d }, /* use as headphone mic, without its own jack detect */
7856 			{ }
7857 		},
7858 		.chained = true,
7859 		.chain_id = ALC269_FIXUP_HEADSET_MODE
7860 	},
7861 	[ALC269_FIXUP_HEADSET_MODE] = {
7862 		.type = HDA_FIXUP_FUNC,
7863 		.v.func = alc_fixup_headset_mode,
7864 		.chained = true,
7865 		.chain_id = ALC255_FIXUP_MIC_MUTE_LED
7866 	},
7867 	[ALC269_FIXUP_HEADSET_MODE_NO_HP_MIC] = {
7868 		.type = HDA_FIXUP_FUNC,
7869 		.v.func = alc_fixup_headset_mode_no_hp_mic,
7870 	},
7871 	[ALC269_FIXUP_ASPIRE_HEADSET_MIC] = {
7872 		.type = HDA_FIXUP_PINS,
7873 		.v.pins = (const struct hda_pintbl[]) {
7874 			{ 0x19, 0x01a1913c }, /* headset mic w/o jack detect */
7875 			{ }
7876 		},
7877 		.chained = true,
7878 		.chain_id = ALC269_FIXUP_HEADSET_MODE,
7879 	},
7880 	[ALC286_FIXUP_SONY_MIC_NO_PRESENCE] = {
7881 		.type = HDA_FIXUP_PINS,
7882 		.v.pins = (const struct hda_pintbl[]) {
7883 			{ 0x18, 0x01a1913c }, /* use as headset mic, without its own jack detect */
7884 			{ }
7885 		},
7886 		.chained = true,
7887 		.chain_id = ALC269_FIXUP_HEADSET_MIC
7888 	},
7889 	[ALC256_FIXUP_HUAWEI_MACH_WX9_PINS] = {
7890 		.type = HDA_FIXUP_PINS,
7891 		.v.pins = (const struct hda_pintbl[]) {
7892 			{0x12, 0x90a60130},
7893 			{0x13, 0x40000000},
7894 			{0x14, 0x90170110},
7895 			{0x18, 0x411111f0},
7896 			{0x19, 0x04a11040},
7897 			{0x1a, 0x411111f0},
7898 			{0x1b, 0x90170112},
7899 			{0x1d, 0x40759a05},
7900 			{0x1e, 0x411111f0},
7901 			{0x21, 0x04211020},
7902 			{ }
7903 		},
7904 		.chained = true,
7905 		.chain_id = ALC255_FIXUP_MIC_MUTE_LED
7906 	},
7907 	[ALC298_FIXUP_HUAWEI_MBX_STEREO] = {
7908 		.type = HDA_FIXUP_FUNC,
7909 		.v.func = alc298_fixup_huawei_mbx_stereo,
7910 		.chained = true,
7911 		.chain_id = ALC255_FIXUP_MIC_MUTE_LED
7912 	},
7913 	[ALC269_FIXUP_ASUS_X101_FUNC] = {
7914 		.type = HDA_FIXUP_FUNC,
7915 		.v.func = alc269_fixup_x101_headset_mic,
7916 	},
7917 	[ALC269_FIXUP_ASUS_X101_VERB] = {
7918 		.type = HDA_FIXUP_VERBS,
7919 		.v.verbs = (const struct hda_verb[]) {
7920 			{0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
7921 			{0x20, AC_VERB_SET_COEF_INDEX, 0x08},
7922 			{0x20, AC_VERB_SET_PROC_COEF,  0x0310},
7923 			{ }
7924 		},
7925 		.chained = true,
7926 		.chain_id = ALC269_FIXUP_ASUS_X101_FUNC
7927 	},
7928 	[ALC269_FIXUP_ASUS_X101] = {
7929 		.type = HDA_FIXUP_PINS,
7930 		.v.pins = (const struct hda_pintbl[]) {
7931 			{ 0x18, 0x04a1182c }, /* Headset mic */
7932 			{ }
7933 		},
7934 		.chained = true,
7935 		.chain_id = ALC269_FIXUP_ASUS_X101_VERB
7936 	},
7937 	[ALC271_FIXUP_AMIC_MIC2] = {
7938 		.type = HDA_FIXUP_PINS,
7939 		.v.pins = (const struct hda_pintbl[]) {
7940 			{ 0x14, 0x99130110 }, /* speaker */
7941 			{ 0x19, 0x01a19c20 }, /* mic */
7942 			{ 0x1b, 0x99a7012f }, /* int-mic */
7943 			{ 0x21, 0x0121401f }, /* HP out */
7944 			{ }
7945 		},
7946 	},
7947 	[ALC271_FIXUP_HP_GATE_MIC_JACK] = {
7948 		.type = HDA_FIXUP_FUNC,
7949 		.v.func = alc271_hp_gate_mic_jack,
7950 		.chained = true,
7951 		.chain_id = ALC271_FIXUP_AMIC_MIC2,
7952 	},
7953 	[ALC271_FIXUP_HP_GATE_MIC_JACK_E1_572] = {
7954 		.type = HDA_FIXUP_FUNC,
7955 		.v.func = alc269_fixup_limit_int_mic_boost,
7956 		.chained = true,
7957 		.chain_id = ALC271_FIXUP_HP_GATE_MIC_JACK,
7958 	},
7959 	[ALC269_FIXUP_ACER_AC700] = {
7960 		.type = HDA_FIXUP_PINS,
7961 		.v.pins = (const struct hda_pintbl[]) {
7962 			{ 0x12, 0x99a3092f }, /* int-mic */
7963 			{ 0x14, 0x99130110 }, /* speaker */
7964 			{ 0x18, 0x03a11c20 }, /* mic */
7965 			{ 0x1e, 0x0346101e }, /* SPDIF1 */
7966 			{ 0x21, 0x0321101f }, /* HP out */
7967 			{ }
7968 		},
7969 		.chained = true,
7970 		.chain_id = ALC271_FIXUP_DMIC,
7971 	},
7972 	[ALC269_FIXUP_LIMIT_INT_MIC_BOOST] = {
7973 		.type = HDA_FIXUP_FUNC,
7974 		.v.func = alc269_fixup_limit_int_mic_boost,
7975 		.chained = true,
7976 		.chain_id = ALC269_FIXUP_THINKPAD_ACPI,
7977 	},
7978 	[ALC269VB_FIXUP_ASUS_ZENBOOK] = {
7979 		.type = HDA_FIXUP_FUNC,
7980 		.v.func = alc269_fixup_limit_int_mic_boost,
7981 		.chained = true,
7982 		.chain_id = ALC269VB_FIXUP_DMIC,
7983 	},
7984 	[ALC269VB_FIXUP_ASUS_ZENBOOK_UX31A] = {
7985 		.type = HDA_FIXUP_VERBS,
7986 		.v.verbs = (const struct hda_verb[]) {
7987 			/* class-D output amp +5dB */
7988 			{ 0x20, AC_VERB_SET_COEF_INDEX, 0x12 },
7989 			{ 0x20, AC_VERB_SET_PROC_COEF, 0x2800 },
7990 			{}
7991 		},
7992 		.chained = true,
7993 		.chain_id = ALC269VB_FIXUP_ASUS_ZENBOOK,
7994 	},
7995 	[ALC269VB_FIXUP_ASUS_MIC_NO_PRESENCE] = {
7996 		.type = HDA_FIXUP_PINS,
7997 		.v.pins = (const struct hda_pintbl[]) {
7998 			{ 0x18, 0x01a110f0 },  /* use as headset mic */
7999 			{ }
8000 		},
8001 		.chained = true,
8002 		.chain_id = ALC269_FIXUP_HEADSET_MIC
8003 	},
8004 	[ALC269_FIXUP_LIMIT_INT_MIC_BOOST_MUTE_LED] = {
8005 		.type = HDA_FIXUP_FUNC,
8006 		.v.func = alc269_fixup_limit_int_mic_boost,
8007 		.chained = true,
8008 		.chain_id = ALC269_FIXUP_HP_MUTE_LED_MIC1,
8009 	},
8010 	[ALC269VB_FIXUP_ORDISSIMO_EVE2] = {
8011 		.type = HDA_FIXUP_PINS,
8012 		.v.pins = (const struct hda_pintbl[]) {
8013 			{ 0x12, 0x99a3092f }, /* int-mic */
8014 			{ 0x18, 0x03a11d20 }, /* mic */
8015 			{ 0x19, 0x411111f0 }, /* Unused bogus pin */
8016 			{ }
8017 		},
8018 	},
8019 	[ALC283_FIXUP_CHROME_BOOK] = {
8020 		.type = HDA_FIXUP_FUNC,
8021 		.v.func = alc283_fixup_chromebook,
8022 	},
8023 	[ALC283_FIXUP_SENSE_COMBO_JACK] = {
8024 		.type = HDA_FIXUP_FUNC,
8025 		.v.func = alc283_fixup_sense_combo_jack,
8026 		.chained = true,
8027 		.chain_id = ALC283_FIXUP_CHROME_BOOK,
8028 	},
8029 	[ALC282_FIXUP_ASUS_TX300] = {
8030 		.type = HDA_FIXUP_FUNC,
8031 		.v.func = alc282_fixup_asus_tx300,
8032 	},
8033 	[ALC283_FIXUP_INT_MIC] = {
8034 		.type = HDA_FIXUP_VERBS,
8035 		.v.verbs = (const struct hda_verb[]) {
8036 			{0x20, AC_VERB_SET_COEF_INDEX, 0x1a},
8037 			{0x20, AC_VERB_SET_PROC_COEF, 0x0011},
8038 			{ }
8039 		},
8040 		.chained = true,
8041 		.chain_id = ALC269_FIXUP_LIMIT_INT_MIC_BOOST
8042 	},
8043 	[ALC290_FIXUP_SUBWOOFER_HSJACK] = {
8044 		.type = HDA_FIXUP_PINS,
8045 		.v.pins = (const struct hda_pintbl[]) {
8046 			{ 0x17, 0x90170112 }, /* subwoofer */
8047 			{ }
8048 		},
8049 		.chained = true,
8050 		.chain_id = ALC290_FIXUP_MONO_SPEAKERS_HSJACK,
8051 	},
8052 	[ALC290_FIXUP_SUBWOOFER] = {
8053 		.type = HDA_FIXUP_PINS,
8054 		.v.pins = (const struct hda_pintbl[]) {
8055 			{ 0x17, 0x90170112 }, /* subwoofer */
8056 			{ }
8057 		},
8058 		.chained = true,
8059 		.chain_id = ALC290_FIXUP_MONO_SPEAKERS,
8060 	},
8061 	[ALC290_FIXUP_MONO_SPEAKERS] = {
8062 		.type = HDA_FIXUP_FUNC,
8063 		.v.func = alc290_fixup_mono_speakers,
8064 	},
8065 	[ALC290_FIXUP_MONO_SPEAKERS_HSJACK] = {
8066 		.type = HDA_FIXUP_FUNC,
8067 		.v.func = alc290_fixup_mono_speakers,
8068 		.chained = true,
8069 		.chain_id = ALC269_FIXUP_DELL3_MIC_NO_PRESENCE,
8070 	},
8071 	[ALC269_FIXUP_THINKPAD_ACPI] = {
8072 		.type = HDA_FIXUP_FUNC,
8073 		.v.func = alc_fixup_thinkpad_acpi,
8074 		.chained = true,
8075 		.chain_id = ALC269_FIXUP_SKU_IGNORE,
8076 	},
8077 	[ALC269_FIXUP_DMIC_THINKPAD_ACPI] = {
8078 		.type = HDA_FIXUP_FUNC,
8079 		.v.func = alc_fixup_inv_dmic,
8080 		.chained = true,
8081 		.chain_id = ALC269_FIXUP_THINKPAD_ACPI,
8082 	},
8083 	[ALC255_FIXUP_ACER_MIC_NO_PRESENCE] = {
8084 		.type = HDA_FIXUP_PINS,
8085 		.v.pins = (const struct hda_pintbl[]) {
8086 			{ 0x19, 0x01a1913c }, /* use as headset mic, without its own jack detect */
8087 			{ }
8088 		},
8089 		.chained = true,
8090 		.chain_id = ALC255_FIXUP_HEADSET_MODE
8091 	},
8092 	[ALC255_FIXUP_ASUS_MIC_NO_PRESENCE] = {
8093 		.type = HDA_FIXUP_PINS,
8094 		.v.pins = (const struct hda_pintbl[]) {
8095 			{ 0x19, 0x01a1913c }, /* use as headset mic, without its own jack detect */
8096 			{ }
8097 		},
8098 		.chained = true,
8099 		.chain_id = ALC255_FIXUP_HEADSET_MODE
8100 	},
8101 	[ALC255_FIXUP_DELL1_MIC_NO_PRESENCE] = {
8102 		.type = HDA_FIXUP_PINS,
8103 		.v.pins = (const struct hda_pintbl[]) {
8104 			{ 0x19, 0x01a1913c }, /* use as headset mic, without its own jack detect */
8105 			{ 0x1a, 0x01a1913d }, /* use as headphone mic, without its own jack detect */
8106 			{ }
8107 		},
8108 		.chained = true,
8109 		.chain_id = ALC255_FIXUP_HEADSET_MODE
8110 	},
8111 	[ALC255_FIXUP_DELL2_MIC_NO_PRESENCE] = {
8112 		.type = HDA_FIXUP_PINS,
8113 		.v.pins = (const struct hda_pintbl[]) {
8114 			{ 0x19, 0x01a1913c }, /* use as headset mic, without its own jack detect */
8115 			{ }
8116 		},
8117 		.chained = true,
8118 		.chain_id = ALC255_FIXUP_HEADSET_MODE_NO_HP_MIC
8119 	},
8120 	[ALC255_FIXUP_HEADSET_MODE] = {
8121 		.type = HDA_FIXUP_FUNC,
8122 		.v.func = alc_fixup_headset_mode_alc255,
8123 		.chained = true,
8124 		.chain_id = ALC255_FIXUP_MIC_MUTE_LED
8125 	},
8126 	[ALC255_FIXUP_HEADSET_MODE_NO_HP_MIC] = {
8127 		.type = HDA_FIXUP_FUNC,
8128 		.v.func = alc_fixup_headset_mode_alc255_no_hp_mic,
8129 	},
8130 	[ALC293_FIXUP_DELL1_MIC_NO_PRESENCE] = {
8131 		.type = HDA_FIXUP_PINS,
8132 		.v.pins = (const struct hda_pintbl[]) {
8133 			{ 0x18, 0x01a1913d }, /* use as headphone mic, without its own jack detect */
8134 			{ 0x1a, 0x01a1913c }, /* use as headset mic, without its own jack detect */
8135 			{ }
8136 		},
8137 		.chained = true,
8138 		.chain_id = ALC269_FIXUP_HEADSET_MODE
8139 	},
8140 	[ALC292_FIXUP_TPT440_DOCK] = {
8141 		.type = HDA_FIXUP_FUNC,
8142 		.v.func = alc_fixup_tpt440_dock,
8143 		.chained = true,
8144 		.chain_id = ALC269_FIXUP_LIMIT_INT_MIC_BOOST
8145 	},
8146 	[ALC292_FIXUP_TPT440] = {
8147 		.type = HDA_FIXUP_FUNC,
8148 		.v.func = alc_fixup_disable_aamix,
8149 		.chained = true,
8150 		.chain_id = ALC292_FIXUP_TPT440_DOCK,
8151 	},
8152 	[ALC283_FIXUP_HEADSET_MIC] = {
8153 		.type = HDA_FIXUP_PINS,
8154 		.v.pins = (const struct hda_pintbl[]) {
8155 			{ 0x19, 0x04a110f0 },
8156 			{ },
8157 		},
8158 	},
8159 	[ALC255_FIXUP_MIC_MUTE_LED] = {
8160 		.type = HDA_FIXUP_FUNC,
8161 		.v.func = alc_fixup_micmute_led,
8162 	},
8163 	[ALC282_FIXUP_ASPIRE_V5_PINS] = {
8164 		.type = HDA_FIXUP_PINS,
8165 		.v.pins = (const struct hda_pintbl[]) {
8166 			{ 0x12, 0x90a60130 },
8167 			{ 0x14, 0x90170110 },
8168 			{ 0x17, 0x40000008 },
8169 			{ 0x18, 0x411111f0 },
8170 			{ 0x19, 0x01a1913c },
8171 			{ 0x1a, 0x411111f0 },
8172 			{ 0x1b, 0x411111f0 },
8173 			{ 0x1d, 0x40f89b2d },
8174 			{ 0x1e, 0x411111f0 },
8175 			{ 0x21, 0x0321101f },
8176 			{ },
8177 		},
8178 	},
8179 	[ALC269VB_FIXUP_ASPIRE_E1_COEF] = {
8180 		.type = HDA_FIXUP_FUNC,
8181 		.v.func = alc269vb_fixup_aspire_e1_coef,
8182 	},
8183 	[ALC280_FIXUP_HP_GPIO4] = {
8184 		.type = HDA_FIXUP_FUNC,
8185 		.v.func = alc280_fixup_hp_gpio4,
8186 	},
8187 	[ALC286_FIXUP_HP_GPIO_LED] = {
8188 		.type = HDA_FIXUP_FUNC,
8189 		.v.func = alc286_fixup_hp_gpio_led,
8190 	},
8191 	[ALC280_FIXUP_HP_GPIO2_MIC_HOTKEY] = {
8192 		.type = HDA_FIXUP_FUNC,
8193 		.v.func = alc280_fixup_hp_gpio2_mic_hotkey,
8194 	},
8195 	[ALC280_FIXUP_HP_DOCK_PINS] = {
8196 		.type = HDA_FIXUP_PINS,
8197 		.v.pins = (const struct hda_pintbl[]) {
8198 			{ 0x1b, 0x21011020 }, /* line-out */
8199 			{ 0x1a, 0x01a1903c }, /* headset mic */
8200 			{ 0x18, 0x2181103f }, /* line-in */
8201 			{ },
8202 		},
8203 		.chained = true,
8204 		.chain_id = ALC280_FIXUP_HP_GPIO4
8205 	},
8206 	[ALC269_FIXUP_HP_DOCK_GPIO_MIC1_LED] = {
8207 		.type = HDA_FIXUP_PINS,
8208 		.v.pins = (const struct hda_pintbl[]) {
8209 			{ 0x1b, 0x21011020 }, /* line-out */
8210 			{ 0x18, 0x2181103f }, /* line-in */
8211 			{ },
8212 		},
8213 		.chained = true,
8214 		.chain_id = ALC269_FIXUP_HP_GPIO_MIC1_LED
8215 	},
8216 	[ALC280_FIXUP_HP_9480M] = {
8217 		.type = HDA_FIXUP_FUNC,
8218 		.v.func = alc280_fixup_hp_9480m,
8219 	},
8220 	[ALC245_FIXUP_HP_X360_AMP] = {
8221 		.type = HDA_FIXUP_FUNC,
8222 		.v.func = alc245_fixup_hp_x360_amp,
8223 		.chained = true,
8224 		.chain_id = ALC245_FIXUP_HP_GPIO_LED
8225 	},
8226 	[ALC288_FIXUP_DELL_HEADSET_MODE] = {
8227 		.type = HDA_FIXUP_FUNC,
8228 		.v.func = alc_fixup_headset_mode_dell_alc288,
8229 		.chained = true,
8230 		.chain_id = ALC255_FIXUP_MIC_MUTE_LED
8231 	},
8232 	[ALC288_FIXUP_DELL1_MIC_NO_PRESENCE] = {
8233 		.type = HDA_FIXUP_PINS,
8234 		.v.pins = (const struct hda_pintbl[]) {
8235 			{ 0x18, 0x01a1913c }, /* use as headset mic, without its own jack detect */
8236 			{ 0x1a, 0x01a1913d }, /* use as headphone mic, without its own jack detect */
8237 			{ }
8238 		},
8239 		.chained = true,
8240 		.chain_id = ALC288_FIXUP_DELL_HEADSET_MODE
8241 	},
8242 	[ALC288_FIXUP_DISABLE_AAMIX] = {
8243 		.type = HDA_FIXUP_FUNC,
8244 		.v.func = alc_fixup_disable_aamix,
8245 		.chained = true,
8246 		.chain_id = ALC288_FIXUP_DELL1_MIC_NO_PRESENCE
8247 	},
8248 	[ALC288_FIXUP_DELL_XPS_13] = {
8249 		.type = HDA_FIXUP_FUNC,
8250 		.v.func = alc_fixup_dell_xps13,
8251 		.chained = true,
8252 		.chain_id = ALC288_FIXUP_DISABLE_AAMIX
8253 	},
8254 	[ALC292_FIXUP_DISABLE_AAMIX] = {
8255 		.type = HDA_FIXUP_FUNC,
8256 		.v.func = alc_fixup_disable_aamix,
8257 		.chained = true,
8258 		.chain_id = ALC269_FIXUP_DELL2_MIC_NO_PRESENCE
8259 	},
8260 	[ALC293_FIXUP_DISABLE_AAMIX_MULTIJACK] = {
8261 		.type = HDA_FIXUP_FUNC,
8262 		.v.func = alc_fixup_disable_aamix,
8263 		.chained = true,
8264 		.chain_id = ALC293_FIXUP_DELL1_MIC_NO_PRESENCE
8265 	},
8266 	[ALC292_FIXUP_DELL_E7X_AAMIX] = {
8267 		.type = HDA_FIXUP_FUNC,
8268 		.v.func = alc_fixup_dell_xps13,
8269 		.chained = true,
8270 		.chain_id = ALC292_FIXUP_DISABLE_AAMIX
8271 	},
8272 	[ALC292_FIXUP_DELL_E7X] = {
8273 		.type = HDA_FIXUP_FUNC,
8274 		.v.func = alc_fixup_micmute_led,
8275 		/* micmute fixup must be applied at last */
8276 		.chained_before = true,
8277 		.chain_id = ALC292_FIXUP_DELL_E7X_AAMIX,
8278 	},
8279 	[ALC298_FIXUP_ALIENWARE_MIC_NO_PRESENCE] = {
8280 		.type = HDA_FIXUP_PINS,
8281 		.v.pins = (const struct hda_pintbl[]) {
8282 			{ 0x18, 0x01a1913c }, /* headset mic w/o jack detect */
8283 			{ }
8284 		},
8285 		.chained_before = true,
8286 		.chain_id = ALC269_FIXUP_HEADSET_MODE,
8287 	},
8288 	[ALC298_FIXUP_DELL1_MIC_NO_PRESENCE] = {
8289 		.type = HDA_FIXUP_PINS,
8290 		.v.pins = (const struct hda_pintbl[]) {
8291 			{ 0x18, 0x01a1913c }, /* use as headset mic, without its own jack detect */
8292 			{ 0x1a, 0x01a1913d }, /* use as headphone mic, without its own jack detect */
8293 			{ }
8294 		},
8295 		.chained = true,
8296 		.chain_id = ALC269_FIXUP_HEADSET_MODE
8297 	},
8298 	[ALC298_FIXUP_DELL_AIO_MIC_NO_PRESENCE] = {
8299 		.type = HDA_FIXUP_PINS,
8300 		.v.pins = (const struct hda_pintbl[]) {
8301 			{ 0x18, 0x01a1913c }, /* use as headset mic, without its own jack detect */
8302 			{ }
8303 		},
8304 		.chained = true,
8305 		.chain_id = ALC269_FIXUP_HEADSET_MODE
8306 	},
8307 	[ALC275_FIXUP_DELL_XPS] = {
8308 		.type = HDA_FIXUP_VERBS,
8309 		.v.verbs = (const struct hda_verb[]) {
8310 			/* Enables internal speaker */
8311 			{0x20, AC_VERB_SET_COEF_INDEX, 0x1f},
8312 			{0x20, AC_VERB_SET_PROC_COEF, 0x00c0},
8313 			{0x20, AC_VERB_SET_COEF_INDEX, 0x30},
8314 			{0x20, AC_VERB_SET_PROC_COEF, 0x00b1},
8315 			{}
8316 		}
8317 	},
8318 	[ALC293_FIXUP_LENOVO_SPK_NOISE] = {
8319 		.type = HDA_FIXUP_FUNC,
8320 		.v.func = alc_fixup_disable_aamix,
8321 		.chained = true,
8322 		.chain_id = ALC269_FIXUP_THINKPAD_ACPI
8323 	},
8324 	[ALC233_FIXUP_LENOVO_LINE2_MIC_HOTKEY] = {
8325 		.type = HDA_FIXUP_FUNC,
8326 		.v.func = alc233_fixup_lenovo_line2_mic_hotkey,
8327 	},
8328 	[ALC233_FIXUP_INTEL_NUC8_DMIC] = {
8329 		.type = HDA_FIXUP_FUNC,
8330 		.v.func = alc_fixup_inv_dmic,
8331 		.chained = true,
8332 		.chain_id = ALC233_FIXUP_INTEL_NUC8_BOOST,
8333 	},
8334 	[ALC233_FIXUP_INTEL_NUC8_BOOST] = {
8335 		.type = HDA_FIXUP_FUNC,
8336 		.v.func = alc269_fixup_limit_int_mic_boost
8337 	},
8338 	[ALC255_FIXUP_DELL_SPK_NOISE] = {
8339 		.type = HDA_FIXUP_FUNC,
8340 		.v.func = alc_fixup_disable_aamix,
8341 		.chained = true,
8342 		.chain_id = ALC255_FIXUP_DELL1_MIC_NO_PRESENCE
8343 	},
8344 	[ALC225_FIXUP_DISABLE_MIC_VREF] = {
8345 		.type = HDA_FIXUP_FUNC,
8346 		.v.func = alc_fixup_disable_mic_vref,
8347 		.chained = true,
8348 		.chain_id = ALC269_FIXUP_DELL1_MIC_NO_PRESENCE
8349 	},
8350 	[ALC225_FIXUP_DELL1_MIC_NO_PRESENCE] = {
8351 		.type = HDA_FIXUP_VERBS,
8352 		.v.verbs = (const struct hda_verb[]) {
8353 			/* Disable pass-through path for FRONT 14h */
8354 			{ 0x20, AC_VERB_SET_COEF_INDEX, 0x36 },
8355 			{ 0x20, AC_VERB_SET_PROC_COEF, 0x57d7 },
8356 			{}
8357 		},
8358 		.chained = true,
8359 		.chain_id = ALC225_FIXUP_DISABLE_MIC_VREF
8360 	},
8361 	[ALC280_FIXUP_HP_HEADSET_MIC] = {
8362 		.type = HDA_FIXUP_FUNC,
8363 		.v.func = alc_fixup_disable_aamix,
8364 		.chained = true,
8365 		.chain_id = ALC269_FIXUP_HEADSET_MIC,
8366 	},
8367 	[ALC221_FIXUP_HP_FRONT_MIC] = {
8368 		.type = HDA_FIXUP_PINS,
8369 		.v.pins = (const struct hda_pintbl[]) {
8370 			{ 0x19, 0x02a19020 }, /* Front Mic */
8371 			{ }
8372 		},
8373 	},
8374 	[ALC292_FIXUP_TPT460] = {
8375 		.type = HDA_FIXUP_FUNC,
8376 		.v.func = alc_fixup_tpt440_dock,
8377 		.chained = true,
8378 		.chain_id = ALC293_FIXUP_LENOVO_SPK_NOISE,
8379 	},
8380 	[ALC298_FIXUP_SPK_VOLUME] = {
8381 		.type = HDA_FIXUP_FUNC,
8382 		.v.func = alc298_fixup_speaker_volume,
8383 		.chained = true,
8384 		.chain_id = ALC298_FIXUP_DELL_AIO_MIC_NO_PRESENCE,
8385 	},
8386 	[ALC298_FIXUP_LENOVO_SPK_VOLUME] = {
8387 		.type = HDA_FIXUP_FUNC,
8388 		.v.func = alc298_fixup_speaker_volume,
8389 	},
8390 	[ALC295_FIXUP_DISABLE_DAC3] = {
8391 		.type = HDA_FIXUP_FUNC,
8392 		.v.func = alc295_fixup_disable_dac3,
8393 	},
8394 	[ALC285_FIXUP_SPEAKER2_TO_DAC1] = {
8395 		.type = HDA_FIXUP_FUNC,
8396 		.v.func = alc285_fixup_speaker2_to_dac1,
8397 		.chained = true,
8398 		.chain_id = ALC269_FIXUP_THINKPAD_ACPI
8399 	},
8400 	[ALC285_FIXUP_ASUS_SPEAKER2_TO_DAC1] = {
8401 		.type = HDA_FIXUP_FUNC,
8402 		.v.func = alc285_fixup_speaker2_to_dac1,
8403 		.chained = true,
8404 		.chain_id = ALC245_FIXUP_CS35L41_SPI_2
8405 	},
8406 	[ALC285_FIXUP_ASUS_HEADSET_MIC] = {
8407 		.type = HDA_FIXUP_PINS,
8408 		.v.pins = (const struct hda_pintbl[]) {
8409 			{ 0x19, 0x03a11050 },
8410 			{ 0x1b, 0x03a11c30 },
8411 			{ }
8412 		},
8413 		.chained = true,
8414 		.chain_id = ALC285_FIXUP_ASUS_SPEAKER2_TO_DAC1
8415 	},
8416 	[ALC285_FIXUP_ASUS_SPI_REAR_SPEAKERS] = {
8417 		.type = HDA_FIXUP_PINS,
8418 		.v.pins = (const struct hda_pintbl[]) {
8419 			{ 0x14, 0x90170120 },
8420 			{ }
8421 		},
8422 		.chained = true,
8423 		.chain_id = ALC285_FIXUP_ASUS_HEADSET_MIC
8424 	},
8425 	[ALC285_FIXUP_ASUS_I2C_SPEAKER2_TO_DAC1] = {
8426 		.type = HDA_FIXUP_FUNC,
8427 		.v.func = alc285_fixup_speaker2_to_dac1,
8428 		.chained = true,
8429 		.chain_id = ALC287_FIXUP_CS35L41_I2C_2
8430 	},
8431 	[ALC285_FIXUP_ASUS_I2C_HEADSET_MIC] = {
8432 		.type = HDA_FIXUP_PINS,
8433 		.v.pins = (const struct hda_pintbl[]) {
8434 			{ 0x19, 0x03a11050 },
8435 			{ 0x1b, 0x03a11c30 },
8436 			{ }
8437 		},
8438 		.chained = true,
8439 		.chain_id = ALC285_FIXUP_ASUS_I2C_SPEAKER2_TO_DAC1
8440 	},
8441 	[ALC256_FIXUP_DELL_INSPIRON_7559_SUBWOOFER] = {
8442 		.type = HDA_FIXUP_PINS,
8443 		.v.pins = (const struct hda_pintbl[]) {
8444 			{ 0x1b, 0x90170151 },
8445 			{ }
8446 		},
8447 		.chained = true,
8448 		.chain_id = ALC255_FIXUP_DELL1_MIC_NO_PRESENCE
8449 	},
8450 	[ALC269_FIXUP_ATIV_BOOK_8] = {
8451 		.type = HDA_FIXUP_FUNC,
8452 		.v.func = alc_fixup_auto_mute_via_amp,
8453 		.chained = true,
8454 		.chain_id = ALC269_FIXUP_NO_SHUTUP
8455 	},
8456 	[ALC221_FIXUP_HP_288PRO_MIC_NO_PRESENCE] = {
8457 		.type = HDA_FIXUP_PINS,
8458 		.v.pins = (const struct hda_pintbl[]) {
8459 			{ 0x19, 0x01a1913c }, /* use as headset mic, without its own jack detect */
8460 			{ 0x1a, 0x01813030 }, /* use as headphone mic, without its own jack detect */
8461 			{ }
8462 		},
8463 		.chained = true,
8464 		.chain_id = ALC269_FIXUP_HEADSET_MODE
8465 	},
8466 	[ALC221_FIXUP_HP_MIC_NO_PRESENCE] = {
8467 		.type = HDA_FIXUP_PINS,
8468 		.v.pins = (const struct hda_pintbl[]) {
8469 			{ 0x18, 0x01a1913c }, /* use as headset mic, without its own jack detect */
8470 			{ 0x1a, 0x01a1913d }, /* use as headphone mic, without its own jack detect */
8471 			{ }
8472 		},
8473 		.chained = true,
8474 		.chain_id = ALC269_FIXUP_HEADSET_MODE
8475 	},
8476 	[ALC256_FIXUP_ASUS_HEADSET_MODE] = {
8477 		.type = HDA_FIXUP_FUNC,
8478 		.v.func = alc_fixup_headset_mode,
8479 	},
8480 	[ALC256_FIXUP_ASUS_MIC] = {
8481 		.type = HDA_FIXUP_PINS,
8482 		.v.pins = (const struct hda_pintbl[]) {
8483 			{ 0x13, 0x90a60160 }, /* use as internal mic */
8484 			{ 0x19, 0x04a11120 }, /* use as headset mic, without its own jack detect */
8485 			{ }
8486 		},
8487 		.chained = true,
8488 		.chain_id = ALC256_FIXUP_ASUS_HEADSET_MODE
8489 	},
8490 	[ALC256_FIXUP_ASUS_AIO_GPIO2] = {
8491 		.type = HDA_FIXUP_FUNC,
8492 		/* Set up GPIO2 for the speaker amp */
8493 		.v.func = alc_fixup_gpio4,
8494 	},
8495 	[ALC233_FIXUP_ASUS_MIC_NO_PRESENCE] = {
8496 		.type = HDA_FIXUP_PINS,
8497 		.v.pins = (const struct hda_pintbl[]) {
8498 			{ 0x19, 0x01a1913c }, /* use as headset mic, without its own jack detect */
8499 			{ }
8500 		},
8501 		.chained = true,
8502 		.chain_id = ALC269_FIXUP_HEADSET_MIC
8503 	},
8504 	[ALC233_FIXUP_EAPD_COEF_AND_MIC_NO_PRESENCE] = {
8505 		.type = HDA_FIXUP_VERBS,
8506 		.v.verbs = (const struct hda_verb[]) {
8507 			/* Enables internal speaker */
8508 			{0x20, AC_VERB_SET_COEF_INDEX, 0x40},
8509 			{0x20, AC_VERB_SET_PROC_COEF, 0x8800},
8510 			{}
8511 		},
8512 		.chained = true,
8513 		.chain_id = ALC233_FIXUP_ASUS_MIC_NO_PRESENCE
8514 	},
8515 	[ALC233_FIXUP_LENOVO_MULTI_CODECS] = {
8516 		.type = HDA_FIXUP_FUNC,
8517 		.v.func = alc233_alc662_fixup_lenovo_dual_codecs,
8518 		.chained = true,
8519 		.chain_id = ALC269_FIXUP_GPIO2
8520 	},
8521 	[ALC233_FIXUP_ACER_HEADSET_MIC] = {
8522 		.type = HDA_FIXUP_VERBS,
8523 		.v.verbs = (const struct hda_verb[]) {
8524 			{ 0x20, AC_VERB_SET_COEF_INDEX, 0x45 },
8525 			{ 0x20, AC_VERB_SET_PROC_COEF, 0x5089 },
8526 			{ }
8527 		},
8528 		.chained = true,
8529 		.chain_id = ALC233_FIXUP_ASUS_MIC_NO_PRESENCE
8530 	},
8531 	[ALC294_FIXUP_LENOVO_MIC_LOCATION] = {
8532 		.type = HDA_FIXUP_PINS,
8533 		.v.pins = (const struct hda_pintbl[]) {
8534 			/* Change the mic location from front to right, otherwise there are
8535 			   two front mics with the same name, pulseaudio can't handle them.
8536 			   This is just a temporary workaround, after applying this fixup,
8537 			   there will be one "Front Mic" and one "Mic" in this machine.
8538 			 */
8539 			{ 0x1a, 0x04a19040 },
8540 			{ }
8541 		},
8542 	},
8543 	[ALC225_FIXUP_DELL_WYSE_MIC_NO_PRESENCE] = {
8544 		.type = HDA_FIXUP_PINS,
8545 		.v.pins = (const struct hda_pintbl[]) {
8546 			{ 0x16, 0x0101102f }, /* Rear Headset HP */
8547 			{ 0x19, 0x02a1913c }, /* use as Front headset mic, without its own jack detect */
8548 			{ 0x1a, 0x01a19030 }, /* Rear Headset MIC */
8549 			{ 0x1b, 0x02011020 },
8550 			{ }
8551 		},
8552 		.chained = true,
8553 		.chain_id = ALC225_FIXUP_S3_POP_NOISE
8554 	},
8555 	[ALC225_FIXUP_S3_POP_NOISE] = {
8556 		.type = HDA_FIXUP_FUNC,
8557 		.v.func = alc225_fixup_s3_pop_noise,
8558 		.chained = true,
8559 		.chain_id = ALC269_FIXUP_HEADSET_MODE_NO_HP_MIC
8560 	},
8561 	[ALC700_FIXUP_INTEL_REFERENCE] = {
8562 		.type = HDA_FIXUP_VERBS,
8563 		.v.verbs = (const struct hda_verb[]) {
8564 			/* Enables internal speaker */
8565 			{0x20, AC_VERB_SET_COEF_INDEX, 0x45},
8566 			{0x20, AC_VERB_SET_PROC_COEF, 0x5289},
8567 			{0x20, AC_VERB_SET_COEF_INDEX, 0x4A},
8568 			{0x20, AC_VERB_SET_PROC_COEF, 0x001b},
8569 			{0x58, AC_VERB_SET_COEF_INDEX, 0x00},
8570 			{0x58, AC_VERB_SET_PROC_COEF, 0x3888},
8571 			{0x20, AC_VERB_SET_COEF_INDEX, 0x6f},
8572 			{0x20, AC_VERB_SET_PROC_COEF, 0x2c0b},
8573 			{}
8574 		}
8575 	},
8576 	[ALC274_FIXUP_DELL_BIND_DACS] = {
8577 		.type = HDA_FIXUP_FUNC,
8578 		.v.func = alc274_fixup_bind_dacs,
8579 		.chained = true,
8580 		.chain_id = ALC269_FIXUP_DELL1_MIC_NO_PRESENCE
8581 	},
8582 	[ALC274_FIXUP_DELL_AIO_LINEOUT_VERB] = {
8583 		.type = HDA_FIXUP_PINS,
8584 		.v.pins = (const struct hda_pintbl[]) {
8585 			{ 0x1b, 0x0401102f },
8586 			{ }
8587 		},
8588 		.chained = true,
8589 		.chain_id = ALC274_FIXUP_DELL_BIND_DACS
8590 	},
8591 	[ALC298_FIXUP_TPT470_DOCK_FIX] = {
8592 		.type = HDA_FIXUP_FUNC,
8593 		.v.func = alc_fixup_tpt470_dock,
8594 		.chained = true,
8595 		.chain_id = ALC293_FIXUP_LENOVO_SPK_NOISE
8596 	},
8597 	[ALC298_FIXUP_TPT470_DOCK] = {
8598 		.type = HDA_FIXUP_FUNC,
8599 		.v.func = alc_fixup_tpt470_dacs,
8600 		.chained = true,
8601 		.chain_id = ALC298_FIXUP_TPT470_DOCK_FIX
8602 	},
8603 	[ALC255_FIXUP_DUMMY_LINEOUT_VERB] = {
8604 		.type = HDA_FIXUP_PINS,
8605 		.v.pins = (const struct hda_pintbl[]) {
8606 			{ 0x14, 0x0201101f },
8607 			{ }
8608 		},
8609 		.chained = true,
8610 		.chain_id = ALC255_FIXUP_DELL1_MIC_NO_PRESENCE
8611 	},
8612 	[ALC255_FIXUP_DELL_HEADSET_MIC] = {
8613 		.type = HDA_FIXUP_PINS,
8614 		.v.pins = (const struct hda_pintbl[]) {
8615 			{ 0x19, 0x01a1913c }, /* use as headset mic, without its own jack detect */
8616 			{ }
8617 		},
8618 		.chained = true,
8619 		.chain_id = ALC269_FIXUP_HEADSET_MIC
8620 	},
8621 	[ALC295_FIXUP_HP_X360] = {
8622 		.type = HDA_FIXUP_FUNC,
8623 		.v.func = alc295_fixup_hp_top_speakers,
8624 		.chained = true,
8625 		.chain_id = ALC269_FIXUP_HP_MUTE_LED_MIC3
8626 	},
8627 	[ALC221_FIXUP_HP_HEADSET_MIC] = {
8628 		.type = HDA_FIXUP_PINS,
8629 		.v.pins = (const struct hda_pintbl[]) {
8630 			{ 0x19, 0x0181313f},
8631 			{ }
8632 		},
8633 		.chained = true,
8634 		.chain_id = ALC269_FIXUP_HEADSET_MIC
8635 	},
8636 	[ALC285_FIXUP_LENOVO_HEADPHONE_NOISE] = {
8637 		.type = HDA_FIXUP_FUNC,
8638 		.v.func = alc285_fixup_invalidate_dacs,
8639 		.chained = true,
8640 		.chain_id = ALC269_FIXUP_THINKPAD_ACPI
8641 	},
8642 	[ALC295_FIXUP_HP_AUTO_MUTE] = {
8643 		.type = HDA_FIXUP_FUNC,
8644 		.v.func = alc_fixup_auto_mute_via_amp,
8645 	},
8646 	[ALC286_FIXUP_ACER_AIO_MIC_NO_PRESENCE] = {
8647 		.type = HDA_FIXUP_PINS,
8648 		.v.pins = (const struct hda_pintbl[]) {
8649 			{ 0x18, 0x01a1913c }, /* use as headset mic, without its own jack detect */
8650 			{ }
8651 		},
8652 		.chained = true,
8653 		.chain_id = ALC269_FIXUP_HEADSET_MIC
8654 	},
8655 	[ALC294_FIXUP_ASUS_MIC] = {
8656 		.type = HDA_FIXUP_PINS,
8657 		.v.pins = (const struct hda_pintbl[]) {
8658 			{ 0x13, 0x90a60160 }, /* use as internal mic */
8659 			{ 0x19, 0x04a11120 }, /* use as headset mic, without its own jack detect */
8660 			{ }
8661 		},
8662 		.chained = true,
8663 		.chain_id = ALC269_FIXUP_HEADSET_MIC
8664 	},
8665 	[ALC294_FIXUP_ASUS_HEADSET_MIC] = {
8666 		.type = HDA_FIXUP_PINS,
8667 		.v.pins = (const struct hda_pintbl[]) {
8668 			{ 0x19, 0x01a1103c }, /* use as headset mic */
8669 			{ }
8670 		},
8671 		.chained = true,
8672 		.chain_id = ALC269_FIXUP_HEADSET_MIC
8673 	},
8674 	[ALC294_FIXUP_ASUS_SPK] = {
8675 		.type = HDA_FIXUP_VERBS,
8676 		.v.verbs = (const struct hda_verb[]) {
8677 			/* Set EAPD high */
8678 			{ 0x20, AC_VERB_SET_COEF_INDEX, 0x40 },
8679 			{ 0x20, AC_VERB_SET_PROC_COEF, 0x8800 },
8680 			{ 0x20, AC_VERB_SET_COEF_INDEX, 0x0f },
8681 			{ 0x20, AC_VERB_SET_PROC_COEF, 0x7774 },
8682 			{ }
8683 		},
8684 		.chained = true,
8685 		.chain_id = ALC294_FIXUP_ASUS_HEADSET_MIC
8686 	},
8687 	[ALC295_FIXUP_CHROME_BOOK] = {
8688 		.type = HDA_FIXUP_FUNC,
8689 		.v.func = alc295_fixup_chromebook,
8690 		.chained = true,
8691 		.chain_id = ALC225_FIXUP_HEADSET_JACK
8692 	},
8693 	[ALC225_FIXUP_HEADSET_JACK] = {
8694 		.type = HDA_FIXUP_FUNC,
8695 		.v.func = alc_fixup_headset_jack,
8696 	},
8697 	[ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE] = {
8698 		.type = HDA_FIXUP_PINS,
8699 		.v.pins = (const struct hda_pintbl[]) {
8700 			{ 0x1a, 0x01a1913c }, /* use as headset mic, without its own jack detect */
8701 			{ }
8702 		},
8703 		.chained = true,
8704 		.chain_id = ALC269_FIXUP_HEADSET_MODE_NO_HP_MIC
8705 	},
8706 	[ALC285_FIXUP_LENOVO_PC_BEEP_IN_NOISE] = {
8707 		.type = HDA_FIXUP_VERBS,
8708 		.v.verbs = (const struct hda_verb[]) {
8709 			/* Disable PCBEEP-IN passthrough */
8710 			{ 0x20, AC_VERB_SET_COEF_INDEX, 0x36 },
8711 			{ 0x20, AC_VERB_SET_PROC_COEF, 0x57d7 },
8712 			{ }
8713 		},
8714 		.chained = true,
8715 		.chain_id = ALC285_FIXUP_LENOVO_HEADPHONE_NOISE
8716 	},
8717 	[ALC255_FIXUP_ACER_HEADSET_MIC] = {
8718 		.type = HDA_FIXUP_PINS,
8719 		.v.pins = (const struct hda_pintbl[]) {
8720 			{ 0x19, 0x03a11130 },
8721 			{ 0x1a, 0x90a60140 }, /* use as internal mic */
8722 			{ }
8723 		},
8724 		.chained = true,
8725 		.chain_id = ALC255_FIXUP_HEADSET_MODE_NO_HP_MIC
8726 	},
8727 	[ALC225_FIXUP_DELL_WYSE_AIO_MIC_NO_PRESENCE] = {
8728 		.type = HDA_FIXUP_PINS,
8729 		.v.pins = (const struct hda_pintbl[]) {
8730 			{ 0x16, 0x01011020 }, /* Rear Line out */
8731 			{ 0x19, 0x01a1913c }, /* use as Front headset mic, without its own jack detect */
8732 			{ }
8733 		},
8734 		.chained = true,
8735 		.chain_id = ALC225_FIXUP_WYSE_AUTO_MUTE
8736 	},
8737 	[ALC225_FIXUP_WYSE_AUTO_MUTE] = {
8738 		.type = HDA_FIXUP_FUNC,
8739 		.v.func = alc_fixup_auto_mute_via_amp,
8740 		.chained = true,
8741 		.chain_id = ALC225_FIXUP_WYSE_DISABLE_MIC_VREF
8742 	},
8743 	[ALC225_FIXUP_WYSE_DISABLE_MIC_VREF] = {
8744 		.type = HDA_FIXUP_FUNC,
8745 		.v.func = alc_fixup_disable_mic_vref,
8746 		.chained = true,
8747 		.chain_id = ALC269_FIXUP_HEADSET_MODE_NO_HP_MIC
8748 	},
8749 	[ALC286_FIXUP_ACER_AIO_HEADSET_MIC] = {
8750 		.type = HDA_FIXUP_VERBS,
8751 		.v.verbs = (const struct hda_verb[]) {
8752 			{ 0x20, AC_VERB_SET_COEF_INDEX, 0x4f },
8753 			{ 0x20, AC_VERB_SET_PROC_COEF, 0x5029 },
8754 			{ }
8755 		},
8756 		.chained = true,
8757 		.chain_id = ALC286_FIXUP_ACER_AIO_MIC_NO_PRESENCE
8758 	},
8759 	[ALC256_FIXUP_ASUS_HEADSET_MIC] = {
8760 		.type = HDA_FIXUP_PINS,
8761 		.v.pins = (const struct hda_pintbl[]) {
8762 			{ 0x19, 0x03a11020 }, /* headset mic with jack detect */
8763 			{ }
8764 		},
8765 		.chained = true,
8766 		.chain_id = ALC256_FIXUP_ASUS_HEADSET_MODE
8767 	},
8768 	[ALC256_FIXUP_ASUS_MIC_NO_PRESENCE] = {
8769 		.type = HDA_FIXUP_PINS,
8770 		.v.pins = (const struct hda_pintbl[]) {
8771 			{ 0x19, 0x04a11120 }, /* use as headset mic, without its own jack detect */
8772 			{ }
8773 		},
8774 		.chained = true,
8775 		.chain_id = ALC256_FIXUP_ASUS_HEADSET_MODE
8776 	},
8777 	[ALC299_FIXUP_PREDATOR_SPK] = {
8778 		.type = HDA_FIXUP_PINS,
8779 		.v.pins = (const struct hda_pintbl[]) {
8780 			{ 0x21, 0x90170150 }, /* use as headset mic, without its own jack detect */
8781 			{ }
8782 		}
8783 	},
8784 	[ALC256_FIXUP_MEDION_HEADSET_NO_PRESENCE] = {
8785 		.type = HDA_FIXUP_PINS,
8786 		.v.pins = (const struct hda_pintbl[]) {
8787 			{ 0x19, 0x04a11040 },
8788 			{ 0x21, 0x04211020 },
8789 			{ }
8790 		},
8791 		.chained = true,
8792 		.chain_id = ALC256_FIXUP_ASUS_HEADSET_MODE
8793 	},
8794 	[ALC289_FIXUP_DELL_SPK1] = {
8795 		.type = HDA_FIXUP_PINS,
8796 		.v.pins = (const struct hda_pintbl[]) {
8797 			{ 0x14, 0x90170140 },
8798 			{ }
8799 		},
8800 		.chained = true,
8801 		.chain_id = ALC269_FIXUP_DELL4_MIC_NO_PRESENCE
8802 	},
8803 	[ALC289_FIXUP_DELL_SPK2] = {
8804 		.type = HDA_FIXUP_PINS,
8805 		.v.pins = (const struct hda_pintbl[]) {
8806 			{ 0x17, 0x90170130 }, /* bass spk */
8807 			{ }
8808 		},
8809 		.chained = true,
8810 		.chain_id = ALC269_FIXUP_DELL4_MIC_NO_PRESENCE
8811 	},
8812 	[ALC289_FIXUP_DUAL_SPK] = {
8813 		.type = HDA_FIXUP_FUNC,
8814 		.v.func = alc285_fixup_speaker2_to_dac1,
8815 		.chained = true,
8816 		.chain_id = ALC289_FIXUP_DELL_SPK2
8817 	},
8818 	[ALC289_FIXUP_RTK_AMP_DUAL_SPK] = {
8819 		.type = HDA_FIXUP_FUNC,
8820 		.v.func = alc285_fixup_speaker2_to_dac1,
8821 		.chained = true,
8822 		.chain_id = ALC289_FIXUP_DELL_SPK1
8823 	},
8824 	[ALC294_FIXUP_SPK2_TO_DAC1] = {
8825 		.type = HDA_FIXUP_FUNC,
8826 		.v.func = alc285_fixup_speaker2_to_dac1,
8827 		.chained = true,
8828 		.chain_id = ALC294_FIXUP_ASUS_HEADSET_MIC
8829 	},
8830 	[ALC294_FIXUP_ASUS_DUAL_SPK] = {
8831 		.type = HDA_FIXUP_FUNC,
8832 		/* The GPIO must be pulled to initialize the AMP */
8833 		.v.func = alc_fixup_gpio4,
8834 		.chained = true,
8835 		.chain_id = ALC294_FIXUP_SPK2_TO_DAC1
8836 	},
8837 	[ALC294_FIXUP_ASUS_ALLY] = {
8838 		.type = HDA_FIXUP_FUNC,
8839 		.v.func = cs35l41_fixup_i2c_two,
8840 		.chained = true,
8841 		.chain_id = ALC294_FIXUP_ASUS_ALLY_PINS
8842 	},
8843 	[ALC294_FIXUP_ASUS_ALLY_PINS] = {
8844 		.type = HDA_FIXUP_PINS,
8845 		.v.pins = (const struct hda_pintbl[]) {
8846 			{ 0x19, 0x03a11050 },
8847 			{ 0x1a, 0x03a11c30 },
8848 			{ 0x21, 0x03211420 },
8849 			{ }
8850 		},
8851 		.chained = true,
8852 		.chain_id = ALC294_FIXUP_ASUS_ALLY_VERBS
8853 	},
8854 	[ALC294_FIXUP_ASUS_ALLY_VERBS] = {
8855 		.type = HDA_FIXUP_VERBS,
8856 		.v.verbs = (const struct hda_verb[]) {
8857 			{ 0x20, AC_VERB_SET_COEF_INDEX, 0x45 },
8858 			{ 0x20, AC_VERB_SET_PROC_COEF, 0x5089 },
8859 			{ 0x20, AC_VERB_SET_COEF_INDEX, 0x46 },
8860 			{ 0x20, AC_VERB_SET_PROC_COEF, 0x0004 },
8861 			{ 0x20, AC_VERB_SET_COEF_INDEX, 0x47 },
8862 			{ 0x20, AC_VERB_SET_PROC_COEF, 0xa47a },
8863 			{ 0x20, AC_VERB_SET_COEF_INDEX, 0x49 },
8864 			{ 0x20, AC_VERB_SET_PROC_COEF, 0x0049},
8865 			{ 0x20, AC_VERB_SET_COEF_INDEX, 0x4a },
8866 			{ 0x20, AC_VERB_SET_PROC_COEF, 0x201b },
8867 			{ 0x20, AC_VERB_SET_COEF_INDEX, 0x6b },
8868 			{ 0x20, AC_VERB_SET_PROC_COEF, 0x4278},
8869 			{ }
8870 		},
8871 		.chained = true,
8872 		.chain_id = ALC294_FIXUP_ASUS_ALLY_SPEAKER
8873 	},
8874 	[ALC294_FIXUP_ASUS_ALLY_SPEAKER] = {
8875 		.type = HDA_FIXUP_FUNC,
8876 		.v.func = alc285_fixup_speaker2_to_dac1,
8877 	},
8878 	[ALC285_FIXUP_THINKPAD_X1_GEN7] = {
8879 		.type = HDA_FIXUP_FUNC,
8880 		.v.func = alc285_fixup_thinkpad_x1_gen7,
8881 		.chained = true,
8882 		.chain_id = ALC269_FIXUP_THINKPAD_ACPI
8883 	},
8884 	[ALC285_FIXUP_THINKPAD_HEADSET_JACK] = {
8885 		.type = HDA_FIXUP_FUNC,
8886 		.v.func = alc_fixup_headset_jack,
8887 		.chained = true,
8888 		.chain_id = ALC285_FIXUP_THINKPAD_X1_GEN7
8889 	},
8890 	[ALC294_FIXUP_ASUS_HPE] = {
8891 		.type = HDA_FIXUP_VERBS,
8892 		.v.verbs = (const struct hda_verb[]) {
8893 			/* Set EAPD high */
8894 			{ 0x20, AC_VERB_SET_COEF_INDEX, 0x0f },
8895 			{ 0x20, AC_VERB_SET_PROC_COEF, 0x7774 },
8896 			{ }
8897 		},
8898 		.chained = true,
8899 		.chain_id = ALC294_FIXUP_ASUS_HEADSET_MIC
8900 	},
8901 	[ALC294_FIXUP_ASUS_GX502_PINS] = {
8902 		.type = HDA_FIXUP_PINS,
8903 		.v.pins = (const struct hda_pintbl[]) {
8904 			{ 0x19, 0x03a11050 }, /* front HP mic */
8905 			{ 0x1a, 0x01a11830 }, /* rear external mic */
8906 			{ 0x21, 0x03211020 }, /* front HP out */
8907 			{ }
8908 		},
8909 		.chained = true,
8910 		.chain_id = ALC294_FIXUP_ASUS_GX502_VERBS
8911 	},
8912 	[ALC294_FIXUP_ASUS_GX502_VERBS] = {
8913 		.type = HDA_FIXUP_VERBS,
8914 		.v.verbs = (const struct hda_verb[]) {
8915 			/* set 0x15 to HP-OUT ctrl */
8916 			{ 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0 },
8917 			/* unmute the 0x15 amp */
8918 			{ 0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000 },
8919 			{ }
8920 		},
8921 		.chained = true,
8922 		.chain_id = ALC294_FIXUP_ASUS_GX502_HP
8923 	},
8924 	[ALC294_FIXUP_ASUS_GX502_HP] = {
8925 		.type = HDA_FIXUP_FUNC,
8926 		.v.func = alc294_fixup_gx502_hp,
8927 	},
8928 	[ALC294_FIXUP_ASUS_GU502_PINS] = {
8929 		.type = HDA_FIXUP_PINS,
8930 		.v.pins = (const struct hda_pintbl[]) {
8931 			{ 0x19, 0x01a11050 }, /* rear HP mic */
8932 			{ 0x1a, 0x01a11830 }, /* rear external mic */
8933 			{ 0x21, 0x012110f0 }, /* rear HP out */
8934 			{ }
8935 		},
8936 		.chained = true,
8937 		.chain_id = ALC294_FIXUP_ASUS_GU502_VERBS
8938 	},
8939 	[ALC294_FIXUP_ASUS_GU502_VERBS] = {
8940 		.type = HDA_FIXUP_VERBS,
8941 		.v.verbs = (const struct hda_verb[]) {
8942 			/* set 0x15 to HP-OUT ctrl */
8943 			{ 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0 },
8944 			/* unmute the 0x15 amp */
8945 			{ 0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000 },
8946 			/* set 0x1b to HP-OUT */
8947 			{ 0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
8948 			{ }
8949 		},
8950 		.chained = true,
8951 		.chain_id = ALC294_FIXUP_ASUS_GU502_HP
8952 	},
8953 	[ALC294_FIXUP_ASUS_GU502_HP] = {
8954 		.type = HDA_FIXUP_FUNC,
8955 		.v.func = alc294_fixup_gu502_hp,
8956 	},
8957 	 [ALC294_FIXUP_ASUS_G513_PINS] = {
8958 		.type = HDA_FIXUP_PINS,
8959 		.v.pins = (const struct hda_pintbl[]) {
8960 				{ 0x19, 0x03a11050 }, /* front HP mic */
8961 				{ 0x1a, 0x03a11c30 }, /* rear external mic */
8962 				{ 0x21, 0x03211420 }, /* front HP out */
8963 				{ }
8964 		},
8965 	},
8966 	[ALC285_FIXUP_ASUS_G533Z_PINS] = {
8967 		.type = HDA_FIXUP_PINS,
8968 		.v.pins = (const struct hda_pintbl[]) {
8969 			{ 0x14, 0x90170152 }, /* Speaker Surround Playback Switch */
8970 			{ 0x19, 0x03a19020 }, /* Mic Boost Volume */
8971 			{ 0x1a, 0x03a11c30 }, /* Mic Boost Volume */
8972 			{ 0x1e, 0x90170151 }, /* Rear jack, IN OUT EAPD Detect */
8973 			{ 0x21, 0x03211420 },
8974 			{ }
8975 		},
8976 	},
8977 	[ALC294_FIXUP_ASUS_COEF_1B] = {
8978 		.type = HDA_FIXUP_VERBS,
8979 		.v.verbs = (const struct hda_verb[]) {
8980 			/* Set bit 10 to correct noisy output after reboot from
8981 			 * Windows 10 (due to pop noise reduction?)
8982 			 */
8983 			{ 0x20, AC_VERB_SET_COEF_INDEX, 0x1b },
8984 			{ 0x20, AC_VERB_SET_PROC_COEF, 0x4e4b },
8985 			{ }
8986 		},
8987 		.chained = true,
8988 		.chain_id = ALC289_FIXUP_ASUS_GA401,
8989 	},
8990 	[ALC285_FIXUP_HP_GPIO_LED] = {
8991 		.type = HDA_FIXUP_FUNC,
8992 		.v.func = alc285_fixup_hp_gpio_led,
8993 	},
8994 	[ALC285_FIXUP_HP_MUTE_LED] = {
8995 		.type = HDA_FIXUP_FUNC,
8996 		.v.func = alc285_fixup_hp_mute_led,
8997 	},
8998 	[ALC285_FIXUP_HP_SPECTRE_X360_MUTE_LED] = {
8999 		.type = HDA_FIXUP_FUNC,
9000 		.v.func = alc285_fixup_hp_spectre_x360_mute_led,
9001 	},
9002 	[ALC236_FIXUP_HP_MUTE_LED_COEFBIT2] = {
9003 	    .type = HDA_FIXUP_FUNC,
9004 	    .v.func = alc236_fixup_hp_mute_led_coefbit2,
9005 	},
9006 	[ALC236_FIXUP_HP_GPIO_LED] = {
9007 		.type = HDA_FIXUP_FUNC,
9008 		.v.func = alc236_fixup_hp_gpio_led,
9009 	},
9010 	[ALC236_FIXUP_HP_MUTE_LED] = {
9011 		.type = HDA_FIXUP_FUNC,
9012 		.v.func = alc236_fixup_hp_mute_led,
9013 	},
9014 	[ALC236_FIXUP_HP_MUTE_LED_MICMUTE_VREF] = {
9015 		.type = HDA_FIXUP_FUNC,
9016 		.v.func = alc236_fixup_hp_mute_led_micmute_vref,
9017 	},
9018 	[ALC298_FIXUP_SAMSUNG_AMP] = {
9019 		.type = HDA_FIXUP_FUNC,
9020 		.v.func = alc298_fixup_samsung_amp,
9021 		.chained = true,
9022 		.chain_id = ALC298_FIXUP_SAMSUNG_HEADPHONE_VERY_QUIET
9023 	},
9024 	[ALC298_FIXUP_SAMSUNG_HEADPHONE_VERY_QUIET] = {
9025 		.type = HDA_FIXUP_VERBS,
9026 		.v.verbs = (const struct hda_verb[]) {
9027 			{ 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc5 },
9028 			{ }
9029 		},
9030 	},
9031 	[ALC256_FIXUP_SAMSUNG_HEADPHONE_VERY_QUIET] = {
9032 		.type = HDA_FIXUP_VERBS,
9033 		.v.verbs = (const struct hda_verb[]) {
9034 			{ 0x20, AC_VERB_SET_COEF_INDEX, 0x08},
9035 			{ 0x20, AC_VERB_SET_PROC_COEF, 0x2fcf},
9036 			{ }
9037 		},
9038 	},
9039 	[ALC295_FIXUP_ASUS_MIC_NO_PRESENCE] = {
9040 		.type = HDA_FIXUP_PINS,
9041 		.v.pins = (const struct hda_pintbl[]) {
9042 			{ 0x19, 0x01a1913c }, /* use as headset mic, without its own jack detect */
9043 			{ }
9044 		},
9045 		.chained = true,
9046 		.chain_id = ALC269_FIXUP_HEADSET_MODE
9047 	},
9048 	[ALC269VC_FIXUP_ACER_VCOPPERBOX_PINS] = {
9049 		.type = HDA_FIXUP_PINS,
9050 		.v.pins = (const struct hda_pintbl[]) {
9051 			{ 0x14, 0x90100120 }, /* use as internal speaker */
9052 			{ 0x18, 0x02a111f0 }, /* use as headset mic, without its own jack detect */
9053 			{ 0x1a, 0x01011020 }, /* use as line out */
9054 			{ },
9055 		},
9056 		.chained = true,
9057 		.chain_id = ALC269_FIXUP_HEADSET_MIC
9058 	},
9059 	[ALC269VC_FIXUP_ACER_HEADSET_MIC] = {
9060 		.type = HDA_FIXUP_PINS,
9061 		.v.pins = (const struct hda_pintbl[]) {
9062 			{ 0x18, 0x02a11030 }, /* use as headset mic */
9063 			{ }
9064 		},
9065 		.chained = true,
9066 		.chain_id = ALC269_FIXUP_HEADSET_MIC
9067 	},
9068 	[ALC269VC_FIXUP_ACER_MIC_NO_PRESENCE] = {
9069 		.type = HDA_FIXUP_PINS,
9070 		.v.pins = (const struct hda_pintbl[]) {
9071 			{ 0x18, 0x01a11130 }, /* use as headset mic, without its own jack detect */
9072 			{ }
9073 		},
9074 		.chained = true,
9075 		.chain_id = ALC269_FIXUP_HEADSET_MIC
9076 	},
9077 	[ALC289_FIXUP_ASUS_GA401] = {
9078 		.type = HDA_FIXUP_FUNC,
9079 		.v.func = alc289_fixup_asus_ga401,
9080 		.chained = true,
9081 		.chain_id = ALC289_FIXUP_ASUS_GA502,
9082 	},
9083 	[ALC289_FIXUP_ASUS_GA502] = {
9084 		.type = HDA_FIXUP_PINS,
9085 		.v.pins = (const struct hda_pintbl[]) {
9086 			{ 0x19, 0x03a11020 }, /* headset mic with jack detect */
9087 			{ }
9088 		},
9089 	},
9090 	[ALC256_FIXUP_ACER_MIC_NO_PRESENCE] = {
9091 		.type = HDA_FIXUP_PINS,
9092 		.v.pins = (const struct hda_pintbl[]) {
9093 			{ 0x19, 0x02a11120 }, /* use as headset mic, without its own jack detect */
9094 			{ }
9095 		},
9096 		.chained = true,
9097 		.chain_id = ALC256_FIXUP_ASUS_HEADSET_MODE
9098 	},
9099 	[ALC285_FIXUP_HP_GPIO_AMP_INIT] = {
9100 		.type = HDA_FIXUP_FUNC,
9101 		.v.func = alc285_fixup_hp_gpio_amp_init,
9102 		.chained = true,
9103 		.chain_id = ALC285_FIXUP_HP_GPIO_LED
9104 	},
9105 	[ALC269_FIXUP_CZC_B20] = {
9106 		.type = HDA_FIXUP_PINS,
9107 		.v.pins = (const struct hda_pintbl[]) {
9108 			{ 0x12, 0x411111f0 },
9109 			{ 0x14, 0x90170110 }, /* speaker */
9110 			{ 0x15, 0x032f1020 }, /* HP out */
9111 			{ 0x17, 0x411111f0 },
9112 			{ 0x18, 0x03ab1040 }, /* mic */
9113 			{ 0x19, 0xb7a7013f },
9114 			{ 0x1a, 0x0181305f },
9115 			{ 0x1b, 0x411111f0 },
9116 			{ 0x1d, 0x411111f0 },
9117 			{ 0x1e, 0x411111f0 },
9118 			{ }
9119 		},
9120 		.chain_id = ALC269_FIXUP_DMIC,
9121 	},
9122 	[ALC269_FIXUP_CZC_TMI] = {
9123 		.type = HDA_FIXUP_PINS,
9124 		.v.pins = (const struct hda_pintbl[]) {
9125 			{ 0x12, 0x4000c000 },
9126 			{ 0x14, 0x90170110 }, /* speaker */
9127 			{ 0x15, 0x0421401f }, /* HP out */
9128 			{ 0x17, 0x411111f0 },
9129 			{ 0x18, 0x04a19020 }, /* mic */
9130 			{ 0x19, 0x411111f0 },
9131 			{ 0x1a, 0x411111f0 },
9132 			{ 0x1b, 0x411111f0 },
9133 			{ 0x1d, 0x40448505 },
9134 			{ 0x1e, 0x411111f0 },
9135 			{ 0x20, 0x8000ffff },
9136 			{ }
9137 		},
9138 		.chain_id = ALC269_FIXUP_DMIC,
9139 	},
9140 	[ALC269_FIXUP_CZC_L101] = {
9141 		.type = HDA_FIXUP_PINS,
9142 		.v.pins = (const struct hda_pintbl[]) {
9143 			{ 0x12, 0x40000000 },
9144 			{ 0x14, 0x01014010 }, /* speaker */
9145 			{ 0x15, 0x411111f0 }, /* HP out */
9146 			{ 0x16, 0x411111f0 },
9147 			{ 0x18, 0x01a19020 }, /* mic */
9148 			{ 0x19, 0x02a19021 },
9149 			{ 0x1a, 0x0181302f },
9150 			{ 0x1b, 0x0221401f },
9151 			{ 0x1c, 0x411111f0 },
9152 			{ 0x1d, 0x4044c601 },
9153 			{ 0x1e, 0x411111f0 },
9154 			{ }
9155 		},
9156 		.chain_id = ALC269_FIXUP_DMIC,
9157 	},
9158 	[ALC269_FIXUP_LEMOTE_A1802] = {
9159 		.type = HDA_FIXUP_PINS,
9160 		.v.pins = (const struct hda_pintbl[]) {
9161 			{ 0x12, 0x40000000 },
9162 			{ 0x14, 0x90170110 }, /* speaker */
9163 			{ 0x17, 0x411111f0 },
9164 			{ 0x18, 0x03a19040 }, /* mic1 */
9165 			{ 0x19, 0x90a70130 }, /* mic2 */
9166 			{ 0x1a, 0x411111f0 },
9167 			{ 0x1b, 0x411111f0 },
9168 			{ 0x1d, 0x40489d2d },
9169 			{ 0x1e, 0x411111f0 },
9170 			{ 0x20, 0x0003ffff },
9171 			{ 0x21, 0x03214020 },
9172 			{ }
9173 		},
9174 		.chain_id = ALC269_FIXUP_DMIC,
9175 	},
9176 	[ALC269_FIXUP_LEMOTE_A190X] = {
9177 		.type = HDA_FIXUP_PINS,
9178 		.v.pins = (const struct hda_pintbl[]) {
9179 			{ 0x14, 0x99130110 }, /* speaker */
9180 			{ 0x15, 0x0121401f }, /* HP out */
9181 			{ 0x18, 0x01a19c20 }, /* rear  mic */
9182 			{ 0x19, 0x99a3092f }, /* front mic */
9183 			{ 0x1b, 0x0201401f }, /* front lineout */
9184 			{ }
9185 		},
9186 		.chain_id = ALC269_FIXUP_DMIC,
9187 	},
9188 	[ALC256_FIXUP_INTEL_NUC8_RUGGED] = {
9189 		.type = HDA_FIXUP_PINS,
9190 		.v.pins = (const struct hda_pintbl[]) {
9191 			{ 0x1b, 0x01a1913c }, /* use as headset mic, without its own jack detect */
9192 			{ }
9193 		},
9194 		.chained = true,
9195 		.chain_id = ALC269_FIXUP_HEADSET_MODE
9196 	},
9197 	[ALC256_FIXUP_INTEL_NUC10] = {
9198 		.type = HDA_FIXUP_PINS,
9199 		.v.pins = (const struct hda_pintbl[]) {
9200 			{ 0x19, 0x01a1913c }, /* use as headset mic, without its own jack detect */
9201 			{ }
9202 		},
9203 		.chained = true,
9204 		.chain_id = ALC269_FIXUP_HEADSET_MODE
9205 	},
9206 	[ALC255_FIXUP_XIAOMI_HEADSET_MIC] = {
9207 		.type = HDA_FIXUP_VERBS,
9208 		.v.verbs = (const struct hda_verb[]) {
9209 			{ 0x20, AC_VERB_SET_COEF_INDEX, 0x45 },
9210 			{ 0x20, AC_VERB_SET_PROC_COEF, 0x5089 },
9211 			{ }
9212 		},
9213 		.chained = true,
9214 		.chain_id = ALC289_FIXUP_ASUS_GA502
9215 	},
9216 	[ALC274_FIXUP_HP_MIC] = {
9217 		.type = HDA_FIXUP_VERBS,
9218 		.v.verbs = (const struct hda_verb[]) {
9219 			{ 0x20, AC_VERB_SET_COEF_INDEX, 0x45 },
9220 			{ 0x20, AC_VERB_SET_PROC_COEF, 0x5089 },
9221 			{ }
9222 		},
9223 	},
9224 	[ALC274_FIXUP_HP_HEADSET_MIC] = {
9225 		.type = HDA_FIXUP_FUNC,
9226 		.v.func = alc274_fixup_hp_headset_mic,
9227 		.chained = true,
9228 		.chain_id = ALC274_FIXUP_HP_MIC
9229 	},
9230 	[ALC274_FIXUP_HP_ENVY_GPIO] = {
9231 		.type = HDA_FIXUP_FUNC,
9232 		.v.func = alc274_fixup_hp_envy_gpio,
9233 	},
9234 	[ALC256_FIXUP_ASUS_HPE] = {
9235 		.type = HDA_FIXUP_VERBS,
9236 		.v.verbs = (const struct hda_verb[]) {
9237 			/* Set EAPD high */
9238 			{ 0x20, AC_VERB_SET_COEF_INDEX, 0x0f },
9239 			{ 0x20, AC_VERB_SET_PROC_COEF, 0x7778 },
9240 			{ }
9241 		},
9242 		.chained = true,
9243 		.chain_id = ALC294_FIXUP_ASUS_HEADSET_MIC
9244 	},
9245 	[ALC285_FIXUP_THINKPAD_NO_BASS_SPK_HEADSET_JACK] = {
9246 		.type = HDA_FIXUP_FUNC,
9247 		.v.func = alc_fixup_headset_jack,
9248 		.chained = true,
9249 		.chain_id = ALC269_FIXUP_THINKPAD_ACPI
9250 	},
9251 	[ALC287_FIXUP_HP_GPIO_LED] = {
9252 		.type = HDA_FIXUP_FUNC,
9253 		.v.func = alc287_fixup_hp_gpio_led,
9254 	},
9255 	[ALC256_FIXUP_HP_HEADSET_MIC] = {
9256 		.type = HDA_FIXUP_FUNC,
9257 		.v.func = alc274_fixup_hp_headset_mic,
9258 	},
9259 	[ALC236_FIXUP_DELL_AIO_HEADSET_MIC] = {
9260 		.type = HDA_FIXUP_FUNC,
9261 		.v.func = alc_fixup_no_int_mic,
9262 		.chained = true,
9263 		.chain_id = ALC255_FIXUP_DELL1_MIC_NO_PRESENCE
9264 	},
9265 	[ALC282_FIXUP_ACER_DISABLE_LINEOUT] = {
9266 		.type = HDA_FIXUP_PINS,
9267 		.v.pins = (const struct hda_pintbl[]) {
9268 			{ 0x1b, 0x411111f0 },
9269 			{ 0x18, 0x01a1913c }, /* use as headset mic, without its own jack detect */
9270 			{ },
9271 		},
9272 		.chained = true,
9273 		.chain_id = ALC269_FIXUP_HEADSET_MODE
9274 	},
9275 	[ALC255_FIXUP_ACER_LIMIT_INT_MIC_BOOST] = {
9276 		.type = HDA_FIXUP_FUNC,
9277 		.v.func = alc269_fixup_limit_int_mic_boost,
9278 		.chained = true,
9279 		.chain_id = ALC255_FIXUP_ACER_MIC_NO_PRESENCE,
9280 	},
9281 	[ALC256_FIXUP_ACER_HEADSET_MIC] = {
9282 		.type = HDA_FIXUP_PINS,
9283 		.v.pins = (const struct hda_pintbl[]) {
9284 			{ 0x19, 0x02a1113c }, /* use as headset mic, without its own jack detect */
9285 			{ 0x1a, 0x90a1092f }, /* use as internal mic */
9286 			{ }
9287 		},
9288 		.chained = true,
9289 		.chain_id = ALC269_FIXUP_HEADSET_MODE_NO_HP_MIC
9290 	},
9291 	[ALC285_FIXUP_IDEAPAD_S740_COEF] = {
9292 		.type = HDA_FIXUP_FUNC,
9293 		.v.func = alc285_fixup_ideapad_s740_coef,
9294 		.chained = true,
9295 		.chain_id = ALC269_FIXUP_THINKPAD_ACPI,
9296 	},
9297 	[ALC285_FIXUP_HP_LIMIT_INT_MIC_BOOST] = {
9298 		.type = HDA_FIXUP_FUNC,
9299 		.v.func = alc269_fixup_limit_int_mic_boost,
9300 		.chained = true,
9301 		.chain_id = ALC285_FIXUP_HP_MUTE_LED,
9302 	},
9303 	[ALC295_FIXUP_ASUS_DACS] = {
9304 		.type = HDA_FIXUP_FUNC,
9305 		.v.func = alc295_fixup_asus_dacs,
9306 	},
9307 	[ALC295_FIXUP_HP_OMEN] = {
9308 		.type = HDA_FIXUP_PINS,
9309 		.v.pins = (const struct hda_pintbl[]) {
9310 			{ 0x12, 0xb7a60130 },
9311 			{ 0x13, 0x40000000 },
9312 			{ 0x14, 0x411111f0 },
9313 			{ 0x16, 0x411111f0 },
9314 			{ 0x17, 0x90170110 },
9315 			{ 0x18, 0x411111f0 },
9316 			{ 0x19, 0x02a11030 },
9317 			{ 0x1a, 0x411111f0 },
9318 			{ 0x1b, 0x04a19030 },
9319 			{ 0x1d, 0x40600001 },
9320 			{ 0x1e, 0x411111f0 },
9321 			{ 0x21, 0x03211020 },
9322 			{}
9323 		},
9324 		.chained = true,
9325 		.chain_id = ALC269_FIXUP_HP_LINE1_MIC1_LED,
9326 	},
9327 	[ALC285_FIXUP_HP_SPECTRE_X360] = {
9328 		.type = HDA_FIXUP_FUNC,
9329 		.v.func = alc285_fixup_hp_spectre_x360,
9330 	},
9331 	[ALC285_FIXUP_HP_SPECTRE_X360_EB1] = {
9332 		.type = HDA_FIXUP_FUNC,
9333 		.v.func = alc285_fixup_hp_spectre_x360_eb1
9334 	},
9335 	[ALC285_FIXUP_HP_ENVY_X360] = {
9336 		.type = HDA_FIXUP_FUNC,
9337 		.v.func = alc285_fixup_hp_envy_x360,
9338 		.chained = true,
9339 		.chain_id = ALC285_FIXUP_HP_GPIO_AMP_INIT,
9340 	},
9341 	[ALC287_FIXUP_IDEAPAD_BASS_SPK_AMP] = {
9342 		.type = HDA_FIXUP_FUNC,
9343 		.v.func = alc285_fixup_ideapad_s740_coef,
9344 		.chained = true,
9345 		.chain_id = ALC285_FIXUP_THINKPAD_HEADSET_JACK,
9346 	},
9347 	[ALC623_FIXUP_LENOVO_THINKSTATION_P340] = {
9348 		.type = HDA_FIXUP_FUNC,
9349 		.v.func = alc_fixup_no_shutup,
9350 		.chained = true,
9351 		.chain_id = ALC283_FIXUP_HEADSET_MIC,
9352 	},
9353 	[ALC255_FIXUP_ACER_HEADPHONE_AND_MIC] = {
9354 		.type = HDA_FIXUP_PINS,
9355 		.v.pins = (const struct hda_pintbl[]) {
9356 			{ 0x21, 0x03211030 }, /* Change the Headphone location to Left */
9357 			{ }
9358 		},
9359 		.chained = true,
9360 		.chain_id = ALC255_FIXUP_XIAOMI_HEADSET_MIC
9361 	},
9362 	[ALC236_FIXUP_HP_LIMIT_INT_MIC_BOOST] = {
9363 		.type = HDA_FIXUP_FUNC,
9364 		.v.func = alc269_fixup_limit_int_mic_boost,
9365 		.chained = true,
9366 		.chain_id = ALC236_FIXUP_HP_MUTE_LED_MICMUTE_VREF,
9367 	},
9368 	[ALC285_FIXUP_LEGION_Y9000X_SPEAKERS] = {
9369 		.type = HDA_FIXUP_FUNC,
9370 		.v.func = alc285_fixup_ideapad_s740_coef,
9371 		.chained = true,
9372 		.chain_id = ALC285_FIXUP_LEGION_Y9000X_AUTOMUTE,
9373 	},
9374 	[ALC285_FIXUP_LEGION_Y9000X_AUTOMUTE] = {
9375 		.type = HDA_FIXUP_FUNC,
9376 		.v.func = alc287_fixup_legion_15imhg05_speakers,
9377 		.chained = true,
9378 		.chain_id = ALC269_FIXUP_THINKPAD_ACPI,
9379 	},
9380 	[ALC287_FIXUP_LEGION_15IMHG05_SPEAKERS] = {
9381 		.type = HDA_FIXUP_VERBS,
9382 		//.v.verbs = legion_15imhg05_coefs,
9383 		.v.verbs = (const struct hda_verb[]) {
9384 			 // set left speaker Legion 7i.
9385 			 { 0x20, AC_VERB_SET_COEF_INDEX, 0x24 },
9386 			 { 0x20, AC_VERB_SET_PROC_COEF, 0x41 },
9387 
9388 			 { 0x20, AC_VERB_SET_COEF_INDEX, 0x26 },
9389 			 { 0x20, AC_VERB_SET_PROC_COEF, 0xc },
9390 			 { 0x20, AC_VERB_SET_PROC_COEF, 0x0 },
9391 			 { 0x20, AC_VERB_SET_PROC_COEF, 0x1a },
9392 			 { 0x20, AC_VERB_SET_PROC_COEF, 0xb020 },
9393 
9394 			 { 0x20, AC_VERB_SET_COEF_INDEX, 0x26 },
9395 			 { 0x20, AC_VERB_SET_PROC_COEF, 0x2 },
9396 			 { 0x20, AC_VERB_SET_PROC_COEF, 0x0 },
9397 			 { 0x20, AC_VERB_SET_PROC_COEF, 0x0 },
9398 			 { 0x20, AC_VERB_SET_PROC_COEF, 0xb020 },
9399 
9400 			 // set right speaker Legion 7i.
9401 			 { 0x20, AC_VERB_SET_COEF_INDEX, 0x24 },
9402 			 { 0x20, AC_VERB_SET_PROC_COEF, 0x42 },
9403 
9404 			 { 0x20, AC_VERB_SET_COEF_INDEX, 0x26 },
9405 			 { 0x20, AC_VERB_SET_PROC_COEF, 0xc },
9406 			 { 0x20, AC_VERB_SET_PROC_COEF, 0x0 },
9407 			 { 0x20, AC_VERB_SET_PROC_COEF, 0x2a },
9408 			 { 0x20, AC_VERB_SET_PROC_COEF, 0xb020 },
9409 
9410 			 { 0x20, AC_VERB_SET_COEF_INDEX, 0x26 },
9411 			 { 0x20, AC_VERB_SET_PROC_COEF, 0x2 },
9412 			 { 0x20, AC_VERB_SET_PROC_COEF, 0x0 },
9413 			 { 0x20, AC_VERB_SET_PROC_COEF, 0x0 },
9414 			 { 0x20, AC_VERB_SET_PROC_COEF, 0xb020 },
9415 			 {}
9416 		},
9417 		.chained = true,
9418 		.chain_id = ALC287_FIXUP_LEGION_15IMHG05_AUTOMUTE,
9419 	},
9420 	[ALC287_FIXUP_LEGION_15IMHG05_AUTOMUTE] = {
9421 		.type = HDA_FIXUP_FUNC,
9422 		.v.func = alc287_fixup_legion_15imhg05_speakers,
9423 		.chained = true,
9424 		.chain_id = ALC269_FIXUP_HEADSET_MODE,
9425 	},
9426 	[ALC287_FIXUP_YOGA7_14ITL_SPEAKERS] = {
9427 		.type = HDA_FIXUP_VERBS,
9428 		.v.verbs = (const struct hda_verb[]) {
9429 			 // set left speaker Yoga 7i.
9430 			 { 0x20, AC_VERB_SET_COEF_INDEX, 0x24 },
9431 			 { 0x20, AC_VERB_SET_PROC_COEF, 0x41 },
9432 
9433 			 { 0x20, AC_VERB_SET_COEF_INDEX, 0x26 },
9434 			 { 0x20, AC_VERB_SET_PROC_COEF, 0xc },
9435 			 { 0x20, AC_VERB_SET_PROC_COEF, 0x0 },
9436 			 { 0x20, AC_VERB_SET_PROC_COEF, 0x1a },
9437 			 { 0x20, AC_VERB_SET_PROC_COEF, 0xb020 },
9438 
9439 			 { 0x20, AC_VERB_SET_COEF_INDEX, 0x26 },
9440 			 { 0x20, AC_VERB_SET_PROC_COEF, 0x2 },
9441 			 { 0x20, AC_VERB_SET_PROC_COEF, 0x0 },
9442 			 { 0x20, AC_VERB_SET_PROC_COEF, 0x0 },
9443 			 { 0x20, AC_VERB_SET_PROC_COEF, 0xb020 },
9444 
9445 			 // set right speaker Yoga 7i.
9446 			 { 0x20, AC_VERB_SET_COEF_INDEX, 0x24 },
9447 			 { 0x20, AC_VERB_SET_PROC_COEF, 0x46 },
9448 
9449 			 { 0x20, AC_VERB_SET_COEF_INDEX, 0x26 },
9450 			 { 0x20, AC_VERB_SET_PROC_COEF, 0xc },
9451 			 { 0x20, AC_VERB_SET_PROC_COEF, 0x0 },
9452 			 { 0x20, AC_VERB_SET_PROC_COEF, 0x2a },
9453 			 { 0x20, AC_VERB_SET_PROC_COEF, 0xb020 },
9454 
9455 			 { 0x20, AC_VERB_SET_COEF_INDEX, 0x26 },
9456 			 { 0x20, AC_VERB_SET_PROC_COEF, 0x2 },
9457 			 { 0x20, AC_VERB_SET_PROC_COEF, 0x0 },
9458 			 { 0x20, AC_VERB_SET_PROC_COEF, 0x0 },
9459 			 { 0x20, AC_VERB_SET_PROC_COEF, 0xb020 },
9460 			 {}
9461 		},
9462 		.chained = true,
9463 		.chain_id = ALC269_FIXUP_HEADSET_MODE,
9464 	},
9465 	[ALC298_FIXUP_LENOVO_C940_DUET7] = {
9466 		.type = HDA_FIXUP_FUNC,
9467 		.v.func = alc298_fixup_lenovo_c940_duet7,
9468 	},
9469 	[ALC287_FIXUP_LENOVO_14IRP8_DUETITL] = {
9470 		.type = HDA_FIXUP_FUNC,
9471 		.v.func = alc287_fixup_lenovo_14irp8_duetitl,
9472 	},
9473 	[ALC287_FIXUP_LENOVO_LEGION_7] = {
9474 		.type = HDA_FIXUP_FUNC,
9475 		.v.func = alc287_fixup_lenovo_legion_7,
9476 	},
9477 	[ALC287_FIXUP_13S_GEN2_SPEAKERS] = {
9478 		.type = HDA_FIXUP_VERBS,
9479 		.v.verbs = (const struct hda_verb[]) {
9480 			{ 0x20, AC_VERB_SET_COEF_INDEX, 0x24 },
9481 			{ 0x20, AC_VERB_SET_PROC_COEF, 0x41 },
9482 			{ 0x20, AC_VERB_SET_COEF_INDEX, 0x26 },
9483 			{ 0x20, AC_VERB_SET_PROC_COEF, 0x2 },
9484 			{ 0x20, AC_VERB_SET_PROC_COEF, 0x0 },
9485 			{ 0x20, AC_VERB_SET_PROC_COEF, 0x0 },
9486 			{ 0x20, AC_VERB_SET_PROC_COEF, 0xb020 },
9487 			{ 0x20, AC_VERB_SET_COEF_INDEX, 0x24 },
9488 			{ 0x20, AC_VERB_SET_PROC_COEF, 0x42 },
9489 			{ 0x20, AC_VERB_SET_COEF_INDEX, 0x26 },
9490 			{ 0x20, AC_VERB_SET_PROC_COEF, 0x2 },
9491 			{ 0x20, AC_VERB_SET_PROC_COEF, 0x0 },
9492 			{ 0x20, AC_VERB_SET_PROC_COEF, 0x0 },
9493 			{ 0x20, AC_VERB_SET_PROC_COEF, 0xb020 },
9494 			{}
9495 		},
9496 		.chained = true,
9497 		.chain_id = ALC269_FIXUP_HEADSET_MODE,
9498 	},
9499 	[ALC256_FIXUP_SET_COEF_DEFAULTS] = {
9500 		.type = HDA_FIXUP_FUNC,
9501 		.v.func = alc256_fixup_set_coef_defaults,
9502 	},
9503 	[ALC245_FIXUP_HP_GPIO_LED] = {
9504 		.type = HDA_FIXUP_FUNC,
9505 		.v.func = alc245_fixup_hp_gpio_led,
9506 	},
9507 	[ALC256_FIXUP_SYSTEM76_MIC_NO_PRESENCE] = {
9508 		.type = HDA_FIXUP_PINS,
9509 		.v.pins = (const struct hda_pintbl[]) {
9510 			{ 0x19, 0x03a11120 }, /* use as headset mic, without its own jack detect */
9511 			{ }
9512 		},
9513 		.chained = true,
9514 		.chain_id = ALC269_FIXUP_HEADSET_MODE_NO_HP_MIC,
9515 	},
9516 	[ALC233_FIXUP_NO_AUDIO_JACK] = {
9517 		.type = HDA_FIXUP_FUNC,
9518 		.v.func = alc233_fixup_no_audio_jack,
9519 	},
9520 	[ALC256_FIXUP_MIC_NO_PRESENCE_AND_RESUME] = {
9521 		.type = HDA_FIXUP_FUNC,
9522 		.v.func = alc256_fixup_mic_no_presence_and_resume,
9523 		.chained = true,
9524 		.chain_id = ALC269_FIXUP_HEADSET_MODE_NO_HP_MIC
9525 	},
9526 	[ALC287_FIXUP_LEGION_16ACHG6] = {
9527 		.type = HDA_FIXUP_FUNC,
9528 		.v.func = alc287_fixup_legion_16achg6_speakers,
9529 	},
9530 	[ALC287_FIXUP_CS35L41_I2C_2] = {
9531 		.type = HDA_FIXUP_FUNC,
9532 		.v.func = cs35l41_fixup_i2c_two,
9533 	},
9534 	[ALC287_FIXUP_CS35L41_I2C_2_HP_GPIO_LED] = {
9535 		.type = HDA_FIXUP_FUNC,
9536 		.v.func = cs35l41_fixup_i2c_two,
9537 		.chained = true,
9538 		.chain_id = ALC285_FIXUP_HP_MUTE_LED,
9539 	},
9540 	[ALC287_FIXUP_CS35L41_I2C_4] = {
9541 		.type = HDA_FIXUP_FUNC,
9542 		.v.func = cs35l41_fixup_i2c_four,
9543 	},
9544 	[ALC245_FIXUP_CS35L41_SPI_2] = {
9545 		.type = HDA_FIXUP_FUNC,
9546 		.v.func = cs35l41_fixup_spi_two,
9547 	},
9548 	[ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED] = {
9549 		.type = HDA_FIXUP_FUNC,
9550 		.v.func = cs35l41_fixup_spi_two,
9551 		.chained = true,
9552 		.chain_id = ALC285_FIXUP_HP_GPIO_LED,
9553 	},
9554 	[ALC245_FIXUP_CS35L41_SPI_4] = {
9555 		.type = HDA_FIXUP_FUNC,
9556 		.v.func = cs35l41_fixup_spi_four,
9557 	},
9558 	[ALC245_FIXUP_CS35L41_SPI_4_HP_GPIO_LED] = {
9559 		.type = HDA_FIXUP_FUNC,
9560 		.v.func = cs35l41_fixup_spi_four,
9561 		.chained = true,
9562 		.chain_id = ALC285_FIXUP_HP_GPIO_LED,
9563 	},
9564 	[ALC285_FIXUP_HP_SPEAKERS_MICMUTE_LED] = {
9565 		.type = HDA_FIXUP_VERBS,
9566 		.v.verbs = (const struct hda_verb[]) {
9567 			 { 0x20, AC_VERB_SET_COEF_INDEX, 0x19 },
9568 			 { 0x20, AC_VERB_SET_PROC_COEF, 0x8e11 },
9569 			 { }
9570 		},
9571 		.chained = true,
9572 		.chain_id = ALC285_FIXUP_HP_MUTE_LED,
9573 	},
9574 	[ALC269_FIXUP_DELL4_MIC_NO_PRESENCE_QUIET] = {
9575 		.type = HDA_FIXUP_FUNC,
9576 		.v.func = alc_fixup_dell4_mic_no_presence_quiet,
9577 		.chained = true,
9578 		.chain_id = ALC269_FIXUP_DELL4_MIC_NO_PRESENCE,
9579 	},
9580 	[ALC295_FIXUP_FRAMEWORK_LAPTOP_MIC_NO_PRESENCE] = {
9581 		.type = HDA_FIXUP_PINS,
9582 		.v.pins = (const struct hda_pintbl[]) {
9583 			{ 0x19, 0x02a1112c }, /* use as headset mic, without its own jack detect */
9584 			{ }
9585 		},
9586 		.chained = true,
9587 		.chain_id = ALC269_FIXUP_HEADSET_MODE_NO_HP_MIC
9588 	},
9589 	[ALC287_FIXUP_LEGION_16ITHG6] = {
9590 		.type = HDA_FIXUP_FUNC,
9591 		.v.func = alc287_fixup_legion_16ithg6_speakers,
9592 	},
9593 	[ALC287_FIXUP_YOGA9_14IAP7_BASS_SPK] = {
9594 		.type = HDA_FIXUP_VERBS,
9595 		.v.verbs = (const struct hda_verb[]) {
9596 			// enable left speaker
9597 			{ 0x20, AC_VERB_SET_COEF_INDEX, 0x24 },
9598 			{ 0x20, AC_VERB_SET_PROC_COEF, 0x41 },
9599 
9600 			{ 0x20, AC_VERB_SET_COEF_INDEX, 0x26 },
9601 			{ 0x20, AC_VERB_SET_PROC_COEF, 0xc },
9602 			{ 0x20, AC_VERB_SET_PROC_COEF, 0x0 },
9603 			{ 0x20, AC_VERB_SET_PROC_COEF, 0x1a },
9604 			{ 0x20, AC_VERB_SET_PROC_COEF, 0xb020 },
9605 
9606 			{ 0x20, AC_VERB_SET_COEF_INDEX, 0x26 },
9607 			{ 0x20, AC_VERB_SET_PROC_COEF, 0xf },
9608 			{ 0x20, AC_VERB_SET_PROC_COEF, 0x0 },
9609 			{ 0x20, AC_VERB_SET_PROC_COEF, 0x42 },
9610 			{ 0x20, AC_VERB_SET_PROC_COEF, 0xb020 },
9611 
9612 			{ 0x20, AC_VERB_SET_COEF_INDEX, 0x26 },
9613 			{ 0x20, AC_VERB_SET_PROC_COEF, 0x10 },
9614 			{ 0x20, AC_VERB_SET_PROC_COEF, 0x0 },
9615 			{ 0x20, AC_VERB_SET_PROC_COEF, 0x40 },
9616 			{ 0x20, AC_VERB_SET_PROC_COEF, 0xb020 },
9617 
9618 			{ 0x20, AC_VERB_SET_COEF_INDEX, 0x26 },
9619 			{ 0x20, AC_VERB_SET_PROC_COEF, 0x2 },
9620 			{ 0x20, AC_VERB_SET_PROC_COEF, 0x0 },
9621 			{ 0x20, AC_VERB_SET_PROC_COEF, 0x0 },
9622 			{ 0x20, AC_VERB_SET_PROC_COEF, 0xb020 },
9623 
9624 			// enable right speaker
9625 			{ 0x20, AC_VERB_SET_COEF_INDEX, 0x24 },
9626 			{ 0x20, AC_VERB_SET_PROC_COEF, 0x46 },
9627 
9628 			{ 0x20, AC_VERB_SET_COEF_INDEX, 0x26 },
9629 			{ 0x20, AC_VERB_SET_PROC_COEF, 0xc },
9630 			{ 0x20, AC_VERB_SET_PROC_COEF, 0x0 },
9631 			{ 0x20, AC_VERB_SET_PROC_COEF, 0x2a },
9632 			{ 0x20, AC_VERB_SET_PROC_COEF, 0xb020 },
9633 
9634 			{ 0x20, AC_VERB_SET_COEF_INDEX, 0x26 },
9635 			{ 0x20, AC_VERB_SET_PROC_COEF, 0xf },
9636 			{ 0x20, AC_VERB_SET_PROC_COEF, 0x0 },
9637 			{ 0x20, AC_VERB_SET_PROC_COEF, 0x46 },
9638 			{ 0x20, AC_VERB_SET_PROC_COEF, 0xb020 },
9639 
9640 			{ 0x20, AC_VERB_SET_COEF_INDEX, 0x26 },
9641 			{ 0x20, AC_VERB_SET_PROC_COEF, 0x10 },
9642 			{ 0x20, AC_VERB_SET_PROC_COEF, 0x0 },
9643 			{ 0x20, AC_VERB_SET_PROC_COEF, 0x44 },
9644 			{ 0x20, AC_VERB_SET_PROC_COEF, 0xb020 },
9645 
9646 			{ 0x20, AC_VERB_SET_COEF_INDEX, 0x26 },
9647 			{ 0x20, AC_VERB_SET_PROC_COEF, 0x2 },
9648 			{ 0x20, AC_VERB_SET_PROC_COEF, 0x0 },
9649 			{ 0x20, AC_VERB_SET_PROC_COEF, 0x0 },
9650 			{ 0x20, AC_VERB_SET_PROC_COEF, 0xb020 },
9651 
9652 			{ },
9653 		},
9654 	},
9655 	[ALC287_FIXUP_YOGA9_14IAP7_BASS_SPK_PIN] = {
9656 		.type = HDA_FIXUP_FUNC,
9657 		.v.func = alc287_fixup_yoga9_14iap7_bass_spk_pin,
9658 		.chained = true,
9659 		.chain_id = ALC287_FIXUP_YOGA9_14IAP7_BASS_SPK,
9660 	},
9661 	[ALC287_FIXUP_YOGA9_14IMH9_BASS_SPK_PIN] = {
9662 		.type = HDA_FIXUP_FUNC,
9663 		.v.func = alc287_fixup_yoga9_14iap7_bass_spk_pin,
9664 		.chained = true,
9665 		.chain_id = ALC287_FIXUP_CS35L41_I2C_2,
9666 	},
9667 	[ALC295_FIXUP_DELL_INSPIRON_TOP_SPEAKERS] = {
9668 		.type = HDA_FIXUP_FUNC,
9669 		.v.func = alc295_fixup_dell_inspiron_top_speakers,
9670 		.chained = true,
9671 		.chain_id = ALC269_FIXUP_DELL4_MIC_NO_PRESENCE,
9672 	},
9673 	[ALC236_FIXUP_DELL_DUAL_CODECS] = {
9674 		.type = HDA_FIXUP_PINS,
9675 		.v.func = alc1220_fixup_gb_dual_codecs,
9676 		.chained = true,
9677 		.chain_id = ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
9678 	},
9679 	[ALC287_FIXUP_CS35L41_I2C_2_THINKPAD_ACPI] = {
9680 		.type = HDA_FIXUP_FUNC,
9681 		.v.func = cs35l41_fixup_i2c_two,
9682 		.chained = true,
9683 		.chain_id = ALC285_FIXUP_THINKPAD_NO_BASS_SPK_HEADSET_JACK,
9684 	},
9685 	[ALC287_FIXUP_TAS2781_I2C] = {
9686 		.type = HDA_FIXUP_FUNC,
9687 		.v.func = tas2781_fixup_i2c,
9688 		.chained = true,
9689 		.chain_id = ALC285_FIXUP_THINKPAD_HEADSET_JACK,
9690 	},
9691 	[ALC287_FIXUP_YOGA7_14ARB7_I2C] = {
9692 		.type = HDA_FIXUP_FUNC,
9693 		.v.func = yoga7_14arb7_fixup_i2c,
9694 		.chained = true,
9695 		.chain_id = ALC285_FIXUP_THINKPAD_HEADSET_JACK,
9696 	},
9697 	[ALC245_FIXUP_HP_MUTE_LED_COEFBIT] = {
9698 		.type = HDA_FIXUP_FUNC,
9699 		.v.func = alc245_fixup_hp_mute_led_coefbit,
9700 	},
9701 	[ALC245_FIXUP_HP_X360_MUTE_LEDS] = {
9702 		.type = HDA_FIXUP_FUNC,
9703 		.v.func = alc245_fixup_hp_mute_led_coefbit,
9704 		.chained = true,
9705 		.chain_id = ALC245_FIXUP_HP_GPIO_LED
9706 	},
9707 	[ALC287_FIXUP_THINKPAD_I2S_SPK] = {
9708 		.type = HDA_FIXUP_FUNC,
9709 		.v.func = alc287_fixup_bind_dacs,
9710 		.chained = true,
9711 		.chain_id = ALC285_FIXUP_THINKPAD_NO_BASS_SPK_HEADSET_JACK,
9712 	},
9713 	[ALC287_FIXUP_MG_RTKC_CSAMP_CS35L41_I2C_THINKPAD] = {
9714 		.type = HDA_FIXUP_FUNC,
9715 		.v.func = alc287_fixup_bind_dacs,
9716 		.chained = true,
9717 		.chain_id = ALC287_FIXUP_CS35L41_I2C_2_THINKPAD_ACPI,
9718 	},
9719 	[ALC2XX_FIXUP_HEADSET_MIC] = {
9720 		.type = HDA_FIXUP_FUNC,
9721 		.v.func = alc_fixup_headset_mic,
9722 	},
9723 	[ALC289_FIXUP_DELL_CS35L41_SPI_2] = {
9724 		.type = HDA_FIXUP_FUNC,
9725 		.v.func = cs35l41_fixup_spi_two,
9726 		.chained = true,
9727 		.chain_id = ALC289_FIXUP_DUAL_SPK
9728 	},
9729 	[ALC294_FIXUP_CS35L41_I2C_2] = {
9730 		.type = HDA_FIXUP_FUNC,
9731 		.v.func = cs35l41_fixup_i2c_two,
9732 	},
9733 	[ALC245_FIXUP_CS35L56_SPI_4_HP_GPIO_LED] = {
9734 		.type = HDA_FIXUP_FUNC,
9735 		.v.func = cs35l56_fixup_spi_four,
9736 		.chained = true,
9737 		.chain_id = ALC285_FIXUP_HP_GPIO_LED,
9738 	},
9739 	[ALC256_FIXUP_ACER_SFG16_MICMUTE_LED] = {
9740 		.type = HDA_FIXUP_FUNC,
9741 		.v.func = alc256_fixup_acer_sfg16_micmute_led,
9742 	},
9743 	[ALC256_FIXUP_HEADPHONE_AMP_VOL] = {
9744 		.type = HDA_FIXUP_FUNC,
9745 		.v.func = alc256_decrease_headphone_amp_val,
9746 	},
9747 	[ALC245_FIXUP_HP_SPECTRE_X360_EU0XXX] = {
9748 		.type = HDA_FIXUP_FUNC,
9749 		.v.func = alc245_fixup_hp_spectre_x360_eu0xxx,
9750 	},
9751 	[ALC285_FIXUP_CS35L56_SPI_2] = {
9752 		.type = HDA_FIXUP_FUNC,
9753 		.v.func = cs35l56_fixup_spi_two,
9754 	},
9755 	[ALC285_FIXUP_CS35L56_I2C_2] = {
9756 		.type = HDA_FIXUP_FUNC,
9757 		.v.func = cs35l56_fixup_i2c_two,
9758 	},
9759 	[ALC285_FIXUP_CS35L56_I2C_4] = {
9760 		.type = HDA_FIXUP_FUNC,
9761 		.v.func = cs35l56_fixup_i2c_four,
9762 	},
9763 	[ALC285_FIXUP_ASUS_GA403U] = {
9764 		.type = HDA_FIXUP_FUNC,
9765 		.v.func = alc285_fixup_asus_ga403u,
9766 	},
9767 	[ALC285_FIXUP_ASUS_GA403U_HEADSET_MIC] = {
9768 		.type = HDA_FIXUP_PINS,
9769 		.v.pins = (const struct hda_pintbl[]) {
9770 			{ 0x19, 0x03a11050 },
9771 			{ 0x1b, 0x03a11c30 },
9772 			{ }
9773 		},
9774 		.chained = true,
9775 		.chain_id = ALC285_FIXUP_ASUS_GA403U_I2C_SPEAKER2_TO_DAC1
9776 	},
9777 	[ALC285_FIXUP_ASUS_GU605_SPI_SPEAKER2_TO_DAC1] = {
9778 		.type = HDA_FIXUP_FUNC,
9779 		.v.func = alc285_fixup_speaker2_to_dac1,
9780 		.chained = true,
9781 		.chain_id = ALC285_FIXUP_ASUS_GU605_SPI_2_HEADSET_MIC,
9782 	},
9783 	[ALC285_FIXUP_ASUS_GU605_SPI_2_HEADSET_MIC] = {
9784 		.type = HDA_FIXUP_PINS,
9785 		.v.pins = (const struct hda_pintbl[]) {
9786 			{ 0x19, 0x03a11050 },
9787 			{ 0x1b, 0x03a11c30 },
9788 			{ }
9789 		},
9790 		.chained = true,
9791 		.chain_id = ALC285_FIXUP_CS35L56_SPI_2
9792 	},
9793 	[ALC285_FIXUP_ASUS_GA403U_I2C_SPEAKER2_TO_DAC1] = {
9794 		.type = HDA_FIXUP_FUNC,
9795 		.v.func = alc285_fixup_speaker2_to_dac1,
9796 		.chained = true,
9797 		.chain_id = ALC285_FIXUP_ASUS_GA403U,
9798 	},
9799 	[ALC287_FIXUP_LENOVO_THKPAD_WH_ALC1318] = {
9800 		.type = HDA_FIXUP_FUNC,
9801 		.v.func = alc287_fixup_lenovo_thinkpad_with_alc1318,
9802 		.chained = true,
9803 		.chain_id = ALC269_FIXUP_THINKPAD_ACPI
9804 	},
9805 	[ALC256_FIXUP_CHROME_BOOK] = {
9806 		.type = HDA_FIXUP_FUNC,
9807 		.v.func = alc256_fixup_chromebook,
9808 		.chained = true,
9809 		.chain_id = ALC225_FIXUP_HEADSET_JACK
9810 	},
9811 };
9812 
9813 static const struct snd_pci_quirk alc269_fixup_tbl[] = {
9814 	SND_PCI_QUIRK(0x1025, 0x0283, "Acer TravelMate 8371", ALC269_FIXUP_INV_DMIC),
9815 	SND_PCI_QUIRK(0x1025, 0x029b, "Acer 1810TZ", ALC269_FIXUP_INV_DMIC),
9816 	SND_PCI_QUIRK(0x1025, 0x0349, "Acer AOD260", ALC269_FIXUP_INV_DMIC),
9817 	SND_PCI_QUIRK(0x1025, 0x047c, "Acer AC700", ALC269_FIXUP_ACER_AC700),
9818 	SND_PCI_QUIRK(0x1025, 0x072d, "Acer Aspire V5-571G", ALC269_FIXUP_ASPIRE_HEADSET_MIC),
9819 	SND_PCI_QUIRK(0x1025, 0x0740, "Acer AO725", ALC271_FIXUP_HP_GATE_MIC_JACK),
9820 	SND_PCI_QUIRK(0x1025, 0x0742, "Acer AO756", ALC271_FIXUP_HP_GATE_MIC_JACK),
9821 	SND_PCI_QUIRK(0x1025, 0x0762, "Acer Aspire E1-472", ALC271_FIXUP_HP_GATE_MIC_JACK_E1_572),
9822 	SND_PCI_QUIRK(0x1025, 0x0775, "Acer Aspire E1-572", ALC271_FIXUP_HP_GATE_MIC_JACK_E1_572),
9823 	SND_PCI_QUIRK(0x1025, 0x079b, "Acer Aspire V5-573G", ALC282_FIXUP_ASPIRE_V5_PINS),
9824 	SND_PCI_QUIRK(0x1025, 0x080d, "Acer Aspire V5-122P", ALC269_FIXUP_ASPIRE_HEADSET_MIC),
9825 	SND_PCI_QUIRK(0x1025, 0x0840, "Acer Aspire E1", ALC269VB_FIXUP_ASPIRE_E1_COEF),
9826 	SND_PCI_QUIRK(0x1025, 0x101c, "Acer Veriton N2510G", ALC269_FIXUP_LIFEBOOK),
9827 	SND_PCI_QUIRK(0x1025, 0x102b, "Acer Aspire C24-860", ALC286_FIXUP_ACER_AIO_MIC_NO_PRESENCE),
9828 	SND_PCI_QUIRK(0x1025, 0x1065, "Acer Aspire C20-820", ALC269VC_FIXUP_ACER_HEADSET_MIC),
9829 	SND_PCI_QUIRK(0x1025, 0x106d, "Acer Cloudbook 14", ALC283_FIXUP_CHROME_BOOK),
9830 	SND_PCI_QUIRK(0x1025, 0x1094, "Acer Aspire E5-575T", ALC255_FIXUP_ACER_LIMIT_INT_MIC_BOOST),
9831 	SND_PCI_QUIRK(0x1025, 0x1099, "Acer Aspire E5-523G", ALC255_FIXUP_ACER_MIC_NO_PRESENCE),
9832 	SND_PCI_QUIRK(0x1025, 0x110e, "Acer Aspire ES1-432", ALC255_FIXUP_ACER_MIC_NO_PRESENCE),
9833 	SND_PCI_QUIRK(0x1025, 0x1166, "Acer Veriton N4640G", ALC269_FIXUP_LIFEBOOK),
9834 	SND_PCI_QUIRK(0x1025, 0x1167, "Acer Veriton N6640G", ALC269_FIXUP_LIFEBOOK),
9835 	SND_PCI_QUIRK(0x1025, 0x1246, "Acer Predator Helios 500", ALC299_FIXUP_PREDATOR_SPK),
9836 	SND_PCI_QUIRK(0x1025, 0x1247, "Acer vCopperbox", ALC269VC_FIXUP_ACER_VCOPPERBOX_PINS),
9837 	SND_PCI_QUIRK(0x1025, 0x1248, "Acer Veriton N4660G", ALC269VC_FIXUP_ACER_MIC_NO_PRESENCE),
9838 	SND_PCI_QUIRK(0x1025, 0x1269, "Acer SWIFT SF314-54", ALC256_FIXUP_ACER_HEADSET_MIC),
9839 	SND_PCI_QUIRK(0x1025, 0x126a, "Acer Swift SF114-32", ALC256_FIXUP_ACER_MIC_NO_PRESENCE),
9840 	SND_PCI_QUIRK(0x1025, 0x128f, "Acer Veriton Z6860G", ALC286_FIXUP_ACER_AIO_HEADSET_MIC),
9841 	SND_PCI_QUIRK(0x1025, 0x1290, "Acer Veriton Z4860G", ALC286_FIXUP_ACER_AIO_HEADSET_MIC),
9842 	SND_PCI_QUIRK(0x1025, 0x1291, "Acer Veriton Z4660G", ALC286_FIXUP_ACER_AIO_HEADSET_MIC),
9843 	SND_PCI_QUIRK(0x1025, 0x129c, "Acer SWIFT SF314-55", ALC256_FIXUP_ACER_HEADSET_MIC),
9844 	SND_PCI_QUIRK(0x1025, 0x129d, "Acer SWIFT SF313-51", ALC256_FIXUP_ACER_MIC_NO_PRESENCE),
9845 	SND_PCI_QUIRK(0x1025, 0x1300, "Acer SWIFT SF314-56", ALC256_FIXUP_ACER_MIC_NO_PRESENCE),
9846 	SND_PCI_QUIRK(0x1025, 0x1308, "Acer Aspire Z24-890", ALC286_FIXUP_ACER_AIO_HEADSET_MIC),
9847 	SND_PCI_QUIRK(0x1025, 0x132a, "Acer TravelMate B114-21", ALC233_FIXUP_ACER_HEADSET_MIC),
9848 	SND_PCI_QUIRK(0x1025, 0x1330, "Acer TravelMate X514-51T", ALC255_FIXUP_ACER_HEADSET_MIC),
9849 	SND_PCI_QUIRK(0x1025, 0x141f, "Acer Spin SP513-54N", ALC255_FIXUP_ACER_MIC_NO_PRESENCE),
9850 	SND_PCI_QUIRK(0x1025, 0x142b, "Acer Swift SF314-42", ALC255_FIXUP_ACER_MIC_NO_PRESENCE),
9851 	SND_PCI_QUIRK(0x1025, 0x1430, "Acer TravelMate B311R-31", ALC256_FIXUP_ACER_MIC_NO_PRESENCE),
9852 	SND_PCI_QUIRK(0x1025, 0x1466, "Acer Aspire A515-56", ALC255_FIXUP_ACER_HEADPHONE_AND_MIC),
9853 	SND_PCI_QUIRK(0x1025, 0x1534, "Acer Predator PH315-54", ALC255_FIXUP_ACER_MIC_NO_PRESENCE),
9854 	SND_PCI_QUIRK(0x1025, 0x169a, "Acer Swift SFG16", ALC256_FIXUP_ACER_SFG16_MICMUTE_LED),
9855 	SND_PCI_QUIRK(0x1028, 0x0470, "Dell M101z", ALC269_FIXUP_DELL_M101Z),
9856 	SND_PCI_QUIRK(0x1028, 0x053c, "Dell Latitude E5430", ALC292_FIXUP_DELL_E7X),
9857 	SND_PCI_QUIRK(0x1028, 0x054b, "Dell XPS one 2710", ALC275_FIXUP_DELL_XPS),
9858 	SND_PCI_QUIRK(0x1028, 0x05bd, "Dell Latitude E6440", ALC292_FIXUP_DELL_E7X),
9859 	SND_PCI_QUIRK(0x1028, 0x05be, "Dell Latitude E6540", ALC292_FIXUP_DELL_E7X),
9860 	SND_PCI_QUIRK(0x1028, 0x05ca, "Dell Latitude E7240", ALC292_FIXUP_DELL_E7X),
9861 	SND_PCI_QUIRK(0x1028, 0x05cb, "Dell Latitude E7440", ALC292_FIXUP_DELL_E7X),
9862 	SND_PCI_QUIRK(0x1028, 0x05da, "Dell Vostro 5460", ALC290_FIXUP_SUBWOOFER),
9863 	SND_PCI_QUIRK(0x1028, 0x05f4, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE),
9864 	SND_PCI_QUIRK(0x1028, 0x05f5, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE),
9865 	SND_PCI_QUIRK(0x1028, 0x05f6, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE),
9866 	SND_PCI_QUIRK(0x1028, 0x0615, "Dell Vostro 5470", ALC290_FIXUP_SUBWOOFER_HSJACK),
9867 	SND_PCI_QUIRK(0x1028, 0x0616, "Dell Vostro 5470", ALC290_FIXUP_SUBWOOFER_HSJACK),
9868 	SND_PCI_QUIRK(0x1028, 0x062c, "Dell Latitude E5550", ALC292_FIXUP_DELL_E7X),
9869 	SND_PCI_QUIRK(0x1028, 0x062e, "Dell Latitude E7450", ALC292_FIXUP_DELL_E7X),
9870 	SND_PCI_QUIRK(0x1028, 0x0638, "Dell Inspiron 5439", ALC290_FIXUP_MONO_SPEAKERS_HSJACK),
9871 	SND_PCI_QUIRK(0x1028, 0x064a, "Dell", ALC293_FIXUP_DELL1_MIC_NO_PRESENCE),
9872 	SND_PCI_QUIRK(0x1028, 0x064b, "Dell", ALC293_FIXUP_DELL1_MIC_NO_PRESENCE),
9873 	SND_PCI_QUIRK(0x1028, 0x0665, "Dell XPS 13", ALC288_FIXUP_DELL_XPS_13),
9874 	SND_PCI_QUIRK(0x1028, 0x0669, "Dell Optiplex 9020m", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE),
9875 	SND_PCI_QUIRK(0x1028, 0x069a, "Dell Vostro 5480", ALC290_FIXUP_SUBWOOFER_HSJACK),
9876 	SND_PCI_QUIRK(0x1028, 0x06c7, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE),
9877 	SND_PCI_QUIRK(0x1028, 0x06d9, "Dell", ALC293_FIXUP_DELL1_MIC_NO_PRESENCE),
9878 	SND_PCI_QUIRK(0x1028, 0x06da, "Dell", ALC293_FIXUP_DELL1_MIC_NO_PRESENCE),
9879 	SND_PCI_QUIRK(0x1028, 0x06db, "Dell", ALC293_FIXUP_DISABLE_AAMIX_MULTIJACK),
9880 	SND_PCI_QUIRK(0x1028, 0x06dd, "Dell", ALC293_FIXUP_DISABLE_AAMIX_MULTIJACK),
9881 	SND_PCI_QUIRK(0x1028, 0x06de, "Dell", ALC293_FIXUP_DISABLE_AAMIX_MULTIJACK),
9882 	SND_PCI_QUIRK(0x1028, 0x06df, "Dell", ALC293_FIXUP_DISABLE_AAMIX_MULTIJACK),
9883 	SND_PCI_QUIRK(0x1028, 0x06e0, "Dell", ALC293_FIXUP_DISABLE_AAMIX_MULTIJACK),
9884 	SND_PCI_QUIRK(0x1028, 0x0706, "Dell Inspiron 7559", ALC256_FIXUP_DELL_INSPIRON_7559_SUBWOOFER),
9885 	SND_PCI_QUIRK(0x1028, 0x0725, "Dell Inspiron 3162", ALC255_FIXUP_DELL_SPK_NOISE),
9886 	SND_PCI_QUIRK(0x1028, 0x0738, "Dell Precision 5820", ALC269_FIXUP_NO_SHUTUP),
9887 	SND_PCI_QUIRK(0x1028, 0x075c, "Dell XPS 27 7760", ALC298_FIXUP_SPK_VOLUME),
9888 	SND_PCI_QUIRK(0x1028, 0x075d, "Dell AIO", ALC298_FIXUP_SPK_VOLUME),
9889 	SND_PCI_QUIRK(0x1028, 0x0798, "Dell Inspiron 17 7000 Gaming", ALC256_FIXUP_DELL_INSPIRON_7559_SUBWOOFER),
9890 	SND_PCI_QUIRK(0x1028, 0x07b0, "Dell Precision 7520", ALC295_FIXUP_DISABLE_DAC3),
9891 	SND_PCI_QUIRK(0x1028, 0x080c, "Dell WYSE", ALC225_FIXUP_DELL_WYSE_MIC_NO_PRESENCE),
9892 	SND_PCI_QUIRK(0x1028, 0x084b, "Dell", ALC274_FIXUP_DELL_AIO_LINEOUT_VERB),
9893 	SND_PCI_QUIRK(0x1028, 0x084e, "Dell", ALC274_FIXUP_DELL_AIO_LINEOUT_VERB),
9894 	SND_PCI_QUIRK(0x1028, 0x0871, "Dell Precision 3630", ALC255_FIXUP_DELL_HEADSET_MIC),
9895 	SND_PCI_QUIRK(0x1028, 0x0872, "Dell Precision 3630", ALC255_FIXUP_DELL_HEADSET_MIC),
9896 	SND_PCI_QUIRK(0x1028, 0x0873, "Dell Precision 3930", ALC255_FIXUP_DUMMY_LINEOUT_VERB),
9897 	SND_PCI_QUIRK(0x1028, 0x08ad, "Dell WYSE AIO", ALC225_FIXUP_DELL_WYSE_AIO_MIC_NO_PRESENCE),
9898 	SND_PCI_QUIRK(0x1028, 0x08ae, "Dell WYSE NB", ALC225_FIXUP_DELL1_MIC_NO_PRESENCE),
9899 	SND_PCI_QUIRK(0x1028, 0x0935, "Dell", ALC274_FIXUP_DELL_AIO_LINEOUT_VERB),
9900 	SND_PCI_QUIRK(0x1028, 0x097d, "Dell Precision", ALC289_FIXUP_DUAL_SPK),
9901 	SND_PCI_QUIRK(0x1028, 0x097e, "Dell Precision", ALC289_FIXUP_DUAL_SPK),
9902 	SND_PCI_QUIRK(0x1028, 0x098d, "Dell Precision", ALC233_FIXUP_ASUS_MIC_NO_PRESENCE),
9903 	SND_PCI_QUIRK(0x1028, 0x09bf, "Dell Precision", ALC233_FIXUP_ASUS_MIC_NO_PRESENCE),
9904 	SND_PCI_QUIRK(0x1028, 0x0a2e, "Dell", ALC236_FIXUP_DELL_AIO_HEADSET_MIC),
9905 	SND_PCI_QUIRK(0x1028, 0x0a30, "Dell", ALC236_FIXUP_DELL_AIO_HEADSET_MIC),
9906 	SND_PCI_QUIRK(0x1028, 0x0a38, "Dell Latitude 7520", ALC269_FIXUP_DELL4_MIC_NO_PRESENCE_QUIET),
9907 	SND_PCI_QUIRK(0x1028, 0x0a58, "Dell", ALC255_FIXUP_DELL_HEADSET_MIC),
9908 	SND_PCI_QUIRK(0x1028, 0x0a61, "Dell XPS 15 9510", ALC289_FIXUP_DUAL_SPK),
9909 	SND_PCI_QUIRK(0x1028, 0x0a62, "Dell Precision 5560", ALC289_FIXUP_DUAL_SPK),
9910 	SND_PCI_QUIRK(0x1028, 0x0a9d, "Dell Latitude 5430", ALC269_FIXUP_DELL4_MIC_NO_PRESENCE),
9911 	SND_PCI_QUIRK(0x1028, 0x0a9e, "Dell Latitude 5430", ALC269_FIXUP_DELL4_MIC_NO_PRESENCE),
9912 	SND_PCI_QUIRK(0x1028, 0x0b19, "Dell XPS 15 9520", ALC289_FIXUP_DUAL_SPK),
9913 	SND_PCI_QUIRK(0x1028, 0x0b1a, "Dell Precision 5570", ALC289_FIXUP_DUAL_SPK),
9914 	SND_PCI_QUIRK(0x1028, 0x0b27, "Dell", ALC245_FIXUP_CS35L41_SPI_2),
9915 	SND_PCI_QUIRK(0x1028, 0x0b28, "Dell", ALC245_FIXUP_CS35L41_SPI_2),
9916 	SND_PCI_QUIRK(0x1028, 0x0b37, "Dell Inspiron 16 Plus 7620 2-in-1", ALC295_FIXUP_DELL_INSPIRON_TOP_SPEAKERS),
9917 	SND_PCI_QUIRK(0x1028, 0x0b71, "Dell Inspiron 16 Plus 7620", ALC295_FIXUP_DELL_INSPIRON_TOP_SPEAKERS),
9918 	SND_PCI_QUIRK(0x1028, 0x0beb, "Dell XPS 15 9530 (2023)", ALC289_FIXUP_DELL_CS35L41_SPI_2),
9919 	SND_PCI_QUIRK(0x1028, 0x0c03, "Dell Precision 5340", ALC269_FIXUP_DELL4_MIC_NO_PRESENCE),
9920 	SND_PCI_QUIRK(0x1028, 0x0c0b, "Dell Oasis 14 RPL-P", ALC289_FIXUP_RTK_AMP_DUAL_SPK),
9921 	SND_PCI_QUIRK(0x1028, 0x0c0d, "Dell Oasis", ALC289_FIXUP_RTK_AMP_DUAL_SPK),
9922 	SND_PCI_QUIRK(0x1028, 0x0c0e, "Dell Oasis 16", ALC289_FIXUP_RTK_AMP_DUAL_SPK),
9923 	SND_PCI_QUIRK(0x1028, 0x0c19, "Dell Precision 3340", ALC236_FIXUP_DELL_DUAL_CODECS),
9924 	SND_PCI_QUIRK(0x1028, 0x0c1a, "Dell Precision 3340", ALC236_FIXUP_DELL_DUAL_CODECS),
9925 	SND_PCI_QUIRK(0x1028, 0x0c1b, "Dell Precision 3440", ALC236_FIXUP_DELL_DUAL_CODECS),
9926 	SND_PCI_QUIRK(0x1028, 0x0c1c, "Dell Precision 3540", ALC236_FIXUP_DELL_DUAL_CODECS),
9927 	SND_PCI_QUIRK(0x1028, 0x0c1d, "Dell Precision 3440", ALC236_FIXUP_DELL_DUAL_CODECS),
9928 	SND_PCI_QUIRK(0x1028, 0x0c1e, "Dell Precision 3540", ALC236_FIXUP_DELL_DUAL_CODECS),
9929 	SND_PCI_QUIRK(0x1028, 0x0c28, "Dell Inspiron 16 Plus 7630", ALC295_FIXUP_DELL_INSPIRON_TOP_SPEAKERS),
9930 	SND_PCI_QUIRK(0x1028, 0x0c4d, "Dell", ALC287_FIXUP_CS35L41_I2C_4),
9931 	SND_PCI_QUIRK(0x1028, 0x0cbd, "Dell Oasis 13 CS MTL-U", ALC289_FIXUP_DELL_CS35L41_SPI_2),
9932 	SND_PCI_QUIRK(0x1028, 0x0cbe, "Dell Oasis 13 2-IN-1 MTL-U", ALC289_FIXUP_DELL_CS35L41_SPI_2),
9933 	SND_PCI_QUIRK(0x1028, 0x0cbf, "Dell Oasis 13 Low Weight MTU-L", ALC289_FIXUP_DELL_CS35L41_SPI_2),
9934 	SND_PCI_QUIRK(0x1028, 0x0cc0, "Dell Oasis 13", ALC289_FIXUP_RTK_AMP_DUAL_SPK),
9935 	SND_PCI_QUIRK(0x1028, 0x0cc1, "Dell Oasis 14 MTL-H/U", ALC289_FIXUP_DELL_CS35L41_SPI_2),
9936 	SND_PCI_QUIRK(0x1028, 0x0cc2, "Dell Oasis 14 2-in-1 MTL-H/U", ALC289_FIXUP_DELL_CS35L41_SPI_2),
9937 	SND_PCI_QUIRK(0x1028, 0x0cc3, "Dell Oasis 14 Low Weight MTL-U", ALC289_FIXUP_DELL_CS35L41_SPI_2),
9938 	SND_PCI_QUIRK(0x1028, 0x0cc4, "Dell Oasis 16 MTL-H/U", ALC289_FIXUP_DELL_CS35L41_SPI_2),
9939 	SND_PCI_QUIRK(0x1028, 0x0cc5, "Dell Oasis 14", ALC289_FIXUP_RTK_AMP_DUAL_SPK),
9940 	SND_PCI_QUIRK(0x1028, 0x164a, "Dell", ALC293_FIXUP_DELL1_MIC_NO_PRESENCE),
9941 	SND_PCI_QUIRK(0x1028, 0x164b, "Dell", ALC293_FIXUP_DELL1_MIC_NO_PRESENCE),
9942 	SND_PCI_QUIRK(0x103c, 0x1586, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC2),
9943 	SND_PCI_QUIRK(0x103c, 0x18e6, "HP", ALC269_FIXUP_HP_GPIO_LED),
9944 	SND_PCI_QUIRK(0x103c, 0x218b, "HP", ALC269_FIXUP_LIMIT_INT_MIC_BOOST_MUTE_LED),
9945 	SND_PCI_QUIRK(0x103c, 0x21f9, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
9946 	SND_PCI_QUIRK(0x103c, 0x2210, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
9947 	SND_PCI_QUIRK(0x103c, 0x2214, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
9948 	SND_PCI_QUIRK(0x103c, 0x221b, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),
9949 	SND_PCI_QUIRK(0x103c, 0x221c, "HP EliteBook 755 G2", ALC280_FIXUP_HP_HEADSET_MIC),
9950 	SND_PCI_QUIRK(0x103c, 0x2221, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),
9951 	SND_PCI_QUIRK(0x103c, 0x2225, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),
9952 	SND_PCI_QUIRK(0x103c, 0x2236, "HP", ALC269_FIXUP_HP_LINE1_MIC1_LED),
9953 	SND_PCI_QUIRK(0x103c, 0x2237, "HP", ALC269_FIXUP_HP_LINE1_MIC1_LED),
9954 	SND_PCI_QUIRK(0x103c, 0x2238, "HP", ALC269_FIXUP_HP_LINE1_MIC1_LED),
9955 	SND_PCI_QUIRK(0x103c, 0x2239, "HP", ALC269_FIXUP_HP_LINE1_MIC1_LED),
9956 	SND_PCI_QUIRK(0x103c, 0x224b, "HP", ALC269_FIXUP_HP_LINE1_MIC1_LED),
9957 	SND_PCI_QUIRK(0x103c, 0x2253, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),
9958 	SND_PCI_QUIRK(0x103c, 0x2254, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),
9959 	SND_PCI_QUIRK(0x103c, 0x2255, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),
9960 	SND_PCI_QUIRK(0x103c, 0x2256, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),
9961 	SND_PCI_QUIRK(0x103c, 0x2257, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),
9962 	SND_PCI_QUIRK(0x103c, 0x2259, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),
9963 	SND_PCI_QUIRK(0x103c, 0x225a, "HP", ALC269_FIXUP_HP_DOCK_GPIO_MIC1_LED),
9964 	SND_PCI_QUIRK(0x103c, 0x225f, "HP", ALC280_FIXUP_HP_GPIO2_MIC_HOTKEY),
9965 	SND_PCI_QUIRK(0x103c, 0x2260, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
9966 	SND_PCI_QUIRK(0x103c, 0x2263, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
9967 	SND_PCI_QUIRK(0x103c, 0x2264, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
9968 	SND_PCI_QUIRK(0x103c, 0x2265, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
9969 	SND_PCI_QUIRK(0x103c, 0x2268, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
9970 	SND_PCI_QUIRK(0x103c, 0x226a, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
9971 	SND_PCI_QUIRK(0x103c, 0x226b, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
9972 	SND_PCI_QUIRK(0x103c, 0x226e, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
9973 	SND_PCI_QUIRK(0x103c, 0x2271, "HP", ALC286_FIXUP_HP_GPIO_LED),
9974 	SND_PCI_QUIRK(0x103c, 0x2272, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),
9975 	SND_PCI_QUIRK(0x103c, 0x2272, "HP", ALC280_FIXUP_HP_DOCK_PINS),
9976 	SND_PCI_QUIRK(0x103c, 0x2273, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),
9977 	SND_PCI_QUIRK(0x103c, 0x2273, "HP", ALC280_FIXUP_HP_DOCK_PINS),
9978 	SND_PCI_QUIRK(0x103c, 0x2278, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),
9979 	SND_PCI_QUIRK(0x103c, 0x227f, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
9980 	SND_PCI_QUIRK(0x103c, 0x2282, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
9981 	SND_PCI_QUIRK(0x103c, 0x228b, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
9982 	SND_PCI_QUIRK(0x103c, 0x228e, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
9983 	SND_PCI_QUIRK(0x103c, 0x229e, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
9984 	SND_PCI_QUIRK(0x103c, 0x22b2, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
9985 	SND_PCI_QUIRK(0x103c, 0x22b7, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
9986 	SND_PCI_QUIRK(0x103c, 0x22bf, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
9987 	SND_PCI_QUIRK(0x103c, 0x22c4, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
9988 	SND_PCI_QUIRK(0x103c, 0x22c5, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
9989 	SND_PCI_QUIRK(0x103c, 0x22c7, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
9990 	SND_PCI_QUIRK(0x103c, 0x22c8, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
9991 	SND_PCI_QUIRK(0x103c, 0x22cf, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
9992 	SND_PCI_QUIRK(0x103c, 0x22db, "HP", ALC280_FIXUP_HP_9480M),
9993 	SND_PCI_QUIRK(0x103c, 0x22dc, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),
9994 	SND_PCI_QUIRK(0x103c, 0x22fb, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),
9995 	SND_PCI_QUIRK(0x103c, 0x2334, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
9996 	SND_PCI_QUIRK(0x103c, 0x2335, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
9997 	SND_PCI_QUIRK(0x103c, 0x2336, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
9998 	SND_PCI_QUIRK(0x103c, 0x2337, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
9999 	SND_PCI_QUIRK(0x103c, 0x2b5e, "HP 288 Pro G2 MT", ALC221_FIXUP_HP_288PRO_MIC_NO_PRESENCE),
10000 	SND_PCI_QUIRK(0x103c, 0x802e, "HP Z240 SFF", ALC221_FIXUP_HP_MIC_NO_PRESENCE),
10001 	SND_PCI_QUIRK(0x103c, 0x802f, "HP Z240", ALC221_FIXUP_HP_MIC_NO_PRESENCE),
10002 	SND_PCI_QUIRK(0x103c, 0x8077, "HP", ALC256_FIXUP_HP_HEADSET_MIC),
10003 	SND_PCI_QUIRK(0x103c, 0x8158, "HP", ALC256_FIXUP_HP_HEADSET_MIC),
10004 	SND_PCI_QUIRK(0x103c, 0x820d, "HP Pavilion 15", ALC295_FIXUP_HP_X360),
10005 	SND_PCI_QUIRK(0x103c, 0x8256, "HP", ALC221_FIXUP_HP_FRONT_MIC),
10006 	SND_PCI_QUIRK(0x103c, 0x827e, "HP x360", ALC295_FIXUP_HP_X360),
10007 	SND_PCI_QUIRK(0x103c, 0x827f, "HP x360", ALC269_FIXUP_HP_MUTE_LED_MIC3),
10008 	SND_PCI_QUIRK(0x103c, 0x82bf, "HP G3 mini", ALC221_FIXUP_HP_MIC_NO_PRESENCE),
10009 	SND_PCI_QUIRK(0x103c, 0x82c0, "HP G3 mini premium", ALC221_FIXUP_HP_MIC_NO_PRESENCE),
10010 	SND_PCI_QUIRK(0x103c, 0x83b9, "HP Spectre x360", ALC269_FIXUP_HP_MUTE_LED_MIC3),
10011 	SND_PCI_QUIRK(0x103c, 0x841c, "HP Pavilion 15-CK0xx", ALC269_FIXUP_HP_MUTE_LED_MIC3),
10012 	SND_PCI_QUIRK(0x103c, 0x8497, "HP Envy x360", ALC269_FIXUP_HP_MUTE_LED_MIC3),
10013 	SND_PCI_QUIRK(0x103c, 0x84ae, "HP 15-db0403ng", ALC236_FIXUP_HP_MUTE_LED_COEFBIT2),
10014 	SND_PCI_QUIRK(0x103c, 0x84da, "HP OMEN dc0019-ur", ALC295_FIXUP_HP_OMEN),
10015 	SND_PCI_QUIRK(0x103c, 0x84e7, "HP Pavilion 15", ALC269_FIXUP_HP_MUTE_LED_MIC3),
10016 	SND_PCI_QUIRK(0x103c, 0x8519, "HP Spectre x360 15-df0xxx", ALC285_FIXUP_HP_SPECTRE_X360),
10017 	SND_PCI_QUIRK(0x103c, 0x8537, "HP ProBook 440 G6", ALC236_FIXUP_HP_MUTE_LED_MICMUTE_VREF),
10018 	SND_PCI_QUIRK(0x103c, 0x85de, "HP Envy x360 13-ar0xxx", ALC285_FIXUP_HP_ENVY_X360),
10019 	SND_PCI_QUIRK(0x103c, 0x860f, "HP ZBook 15 G6", ALC285_FIXUP_HP_GPIO_AMP_INIT),
10020 	SND_PCI_QUIRK(0x103c, 0x861f, "HP Elite Dragonfly G1", ALC285_FIXUP_HP_GPIO_AMP_INIT),
10021 	SND_PCI_QUIRK(0x103c, 0x869d, "HP", ALC236_FIXUP_HP_MUTE_LED),
10022 	SND_PCI_QUIRK(0x103c, 0x86c1, "HP Laptop 15-da3001TU", ALC236_FIXUP_HP_MUTE_LED_COEFBIT2),
10023 	SND_PCI_QUIRK(0x103c, 0x86c7, "HP Envy AiO 32", ALC274_FIXUP_HP_ENVY_GPIO),
10024 	SND_PCI_QUIRK(0x103c, 0x86e7, "HP Spectre x360 15-eb0xxx", ALC285_FIXUP_HP_SPECTRE_X360_EB1),
10025 	SND_PCI_QUIRK(0x103c, 0x86e8, "HP Spectre x360 15-eb0xxx", ALC285_FIXUP_HP_SPECTRE_X360_EB1),
10026 	SND_PCI_QUIRK(0x103c, 0x86f9, "HP Spectre x360 13-aw0xxx", ALC285_FIXUP_HP_SPECTRE_X360_MUTE_LED),
10027 	SND_PCI_QUIRK(0x103c, 0x8716, "HP Elite Dragonfly G2 Notebook PC", ALC285_FIXUP_HP_GPIO_AMP_INIT),
10028 	SND_PCI_QUIRK(0x103c, 0x8720, "HP EliteBook x360 1040 G8 Notebook PC", ALC285_FIXUP_HP_GPIO_AMP_INIT),
10029 	SND_PCI_QUIRK(0x103c, 0x8724, "HP EliteBook 850 G7", ALC285_FIXUP_HP_GPIO_LED),
10030 	SND_PCI_QUIRK(0x103c, 0x8728, "HP EliteBook 840 G7", ALC285_FIXUP_HP_GPIO_LED),
10031 	SND_PCI_QUIRK(0x103c, 0x8729, "HP", ALC285_FIXUP_HP_GPIO_LED),
10032 	SND_PCI_QUIRK(0x103c, 0x8730, "HP ProBook 445 G7", ALC236_FIXUP_HP_MUTE_LED_MICMUTE_VREF),
10033 	SND_PCI_QUIRK(0x103c, 0x8735, "HP ProBook 435 G7", ALC236_FIXUP_HP_MUTE_LED_MICMUTE_VREF),
10034 	SND_PCI_QUIRK(0x103c, 0x8736, "HP", ALC285_FIXUP_HP_GPIO_AMP_INIT),
10035 	SND_PCI_QUIRK(0x103c, 0x8760, "HP", ALC285_FIXUP_HP_MUTE_LED),
10036 	SND_PCI_QUIRK(0x103c, 0x876e, "HP ENVY x360 Convertible 13-ay0xxx", ALC245_FIXUP_HP_X360_MUTE_LEDS),
10037 	SND_PCI_QUIRK(0x103c, 0x877a, "HP", ALC285_FIXUP_HP_MUTE_LED),
10038 	SND_PCI_QUIRK(0x103c, 0x877d, "HP", ALC236_FIXUP_HP_MUTE_LED),
10039 	SND_PCI_QUIRK(0x103c, 0x8780, "HP ZBook Fury 17 G7 Mobile Workstation",
10040 		      ALC285_FIXUP_HP_GPIO_AMP_INIT),
10041 	SND_PCI_QUIRK(0x103c, 0x8783, "HP ZBook Fury 15 G7 Mobile Workstation",
10042 		      ALC285_FIXUP_HP_GPIO_AMP_INIT),
10043 	SND_PCI_QUIRK(0x103c, 0x8786, "HP OMEN 15", ALC285_FIXUP_HP_MUTE_LED),
10044 	SND_PCI_QUIRK(0x103c, 0x8787, "HP OMEN 15", ALC285_FIXUP_HP_MUTE_LED),
10045 	SND_PCI_QUIRK(0x103c, 0x8788, "HP OMEN 15", ALC285_FIXUP_HP_MUTE_LED),
10046 	SND_PCI_QUIRK(0x103c, 0x87b7, "HP Laptop 14-fq0xxx", ALC236_FIXUP_HP_MUTE_LED_COEFBIT2),
10047 	SND_PCI_QUIRK(0x103c, 0x87c8, "HP", ALC287_FIXUP_HP_GPIO_LED),
10048 	SND_PCI_QUIRK(0x103c, 0x87e5, "HP ProBook 440 G8 Notebook PC", ALC236_FIXUP_HP_GPIO_LED),
10049 	SND_PCI_QUIRK(0x103c, 0x87e7, "HP ProBook 450 G8 Notebook PC", ALC236_FIXUP_HP_GPIO_LED),
10050 	SND_PCI_QUIRK(0x103c, 0x87f1, "HP ProBook 630 G8 Notebook PC", ALC236_FIXUP_HP_GPIO_LED),
10051 	SND_PCI_QUIRK(0x103c, 0x87f2, "HP ProBook 640 G8 Notebook PC", ALC236_FIXUP_HP_GPIO_LED),
10052 	SND_PCI_QUIRK(0x103c, 0x87f4, "HP", ALC287_FIXUP_HP_GPIO_LED),
10053 	SND_PCI_QUIRK(0x103c, 0x87f5, "HP", ALC287_FIXUP_HP_GPIO_LED),
10054 	SND_PCI_QUIRK(0x103c, 0x87f6, "HP Spectre x360 14", ALC245_FIXUP_HP_X360_AMP),
10055 	SND_PCI_QUIRK(0x103c, 0x87f7, "HP Spectre x360 14", ALC245_FIXUP_HP_X360_AMP),
10056 	SND_PCI_QUIRK(0x103c, 0x87fe, "HP Laptop 15s-fq2xxx", ALC236_FIXUP_HP_MUTE_LED_COEFBIT2),
10057 	SND_PCI_QUIRK(0x103c, 0x8805, "HP ProBook 650 G8 Notebook PC", ALC236_FIXUP_HP_GPIO_LED),
10058 	SND_PCI_QUIRK(0x103c, 0x880d, "HP EliteBook 830 G8 Notebook PC", ALC285_FIXUP_HP_GPIO_LED),
10059 	SND_PCI_QUIRK(0x103c, 0x8811, "HP Spectre x360 15-eb1xxx", ALC285_FIXUP_HP_SPECTRE_X360_EB1),
10060 	SND_PCI_QUIRK(0x103c, 0x8812, "HP Spectre x360 15-eb1xxx", ALC285_FIXUP_HP_SPECTRE_X360_EB1),
10061 	SND_PCI_QUIRK(0x103c, 0x881d, "HP 250 G8 Notebook PC", ALC236_FIXUP_HP_MUTE_LED_COEFBIT2),
10062 	SND_PCI_QUIRK(0x103c, 0x8846, "HP EliteBook 850 G8 Notebook PC", ALC285_FIXUP_HP_GPIO_LED),
10063 	SND_PCI_QUIRK(0x103c, 0x8847, "HP EliteBook x360 830 G8 Notebook PC", ALC285_FIXUP_HP_GPIO_LED),
10064 	SND_PCI_QUIRK(0x103c, 0x884b, "HP EliteBook 840 Aero G8 Notebook PC", ALC285_FIXUP_HP_GPIO_LED),
10065 	SND_PCI_QUIRK(0x103c, 0x884c, "HP EliteBook 840 G8 Notebook PC", ALC285_FIXUP_HP_GPIO_LED),
10066 	SND_PCI_QUIRK(0x103c, 0x8862, "HP ProBook 445 G8 Notebook PC", ALC236_FIXUP_HP_LIMIT_INT_MIC_BOOST),
10067 	SND_PCI_QUIRK(0x103c, 0x8863, "HP ProBook 445 G8 Notebook PC", ALC236_FIXUP_HP_LIMIT_INT_MIC_BOOST),
10068 	SND_PCI_QUIRK(0x103c, 0x886d, "HP ZBook Fury 17.3 Inch G8 Mobile Workstation PC", ALC285_FIXUP_HP_GPIO_AMP_INIT),
10069 	SND_PCI_QUIRK(0x103c, 0x8870, "HP ZBook Fury 15.6 Inch G8 Mobile Workstation PC", ALC285_FIXUP_HP_GPIO_AMP_INIT),
10070 	SND_PCI_QUIRK(0x103c, 0x8873, "HP ZBook Studio 15.6 Inch G8 Mobile Workstation PC", ALC285_FIXUP_HP_GPIO_AMP_INIT),
10071 	SND_PCI_QUIRK(0x103c, 0x887a, "HP Laptop 15s-eq2xxx", ALC236_FIXUP_HP_MUTE_LED_COEFBIT2),
10072 	SND_PCI_QUIRK(0x103c, 0x888a, "HP ENVY x360 Convertible 15-eu0xxx", ALC245_FIXUP_HP_X360_MUTE_LEDS),
10073 	SND_PCI_QUIRK(0x103c, 0x888d, "HP ZBook Power 15.6 inch G8 Mobile Workstation PC", ALC236_FIXUP_HP_GPIO_LED),
10074 	SND_PCI_QUIRK(0x103c, 0x8895, "HP EliteBook 855 G8 Notebook PC", ALC285_FIXUP_HP_SPEAKERS_MICMUTE_LED),
10075 	SND_PCI_QUIRK(0x103c, 0x8896, "HP EliteBook 855 G8 Notebook PC", ALC285_FIXUP_HP_MUTE_LED),
10076 	SND_PCI_QUIRK(0x103c, 0x8898, "HP EliteBook 845 G8 Notebook PC", ALC285_FIXUP_HP_LIMIT_INT_MIC_BOOST),
10077 	SND_PCI_QUIRK(0x103c, 0x88d0, "HP Pavilion 15-eh1xxx (mainboard 88D0)", ALC287_FIXUP_HP_GPIO_LED),
10078 	SND_PCI_QUIRK(0x103c, 0x8902, "HP OMEN 16", ALC285_FIXUP_HP_MUTE_LED),
10079 	SND_PCI_QUIRK(0x103c, 0x890e, "HP 255 G8 Notebook PC", ALC236_FIXUP_HP_MUTE_LED_COEFBIT2),
10080 	SND_PCI_QUIRK(0x103c, 0x8919, "HP Pavilion Aero Laptop 13-be0xxx", ALC287_FIXUP_HP_GPIO_LED),
10081 	SND_PCI_QUIRK(0x103c, 0x896d, "HP ZBook Firefly 16 G9", ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED),
10082 	SND_PCI_QUIRK(0x103c, 0x896e, "HP EliteBook x360 830 G9", ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED),
10083 	SND_PCI_QUIRK(0x103c, 0x8971, "HP EliteBook 830 G9", ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED),
10084 	SND_PCI_QUIRK(0x103c, 0x8972, "HP EliteBook 840 G9", ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED),
10085 	SND_PCI_QUIRK(0x103c, 0x8973, "HP EliteBook 860 G9", ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED),
10086 	SND_PCI_QUIRK(0x103c, 0x8974, "HP EliteBook 840 Aero G9", ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED),
10087 	SND_PCI_QUIRK(0x103c, 0x8975, "HP EliteBook x360 840 Aero G9", ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED),
10088 	SND_PCI_QUIRK(0x103c, 0x897d, "HP mt440 Mobile Thin Client U74", ALC236_FIXUP_HP_GPIO_LED),
10089 	SND_PCI_QUIRK(0x103c, 0x8981, "HP Elite Dragonfly G3", ALC245_FIXUP_CS35L41_SPI_4),
10090 	SND_PCI_QUIRK(0x103c, 0x898e, "HP EliteBook 835 G9", ALC287_FIXUP_CS35L41_I2C_2),
10091 	SND_PCI_QUIRK(0x103c, 0x898f, "HP EliteBook 835 G9", ALC287_FIXUP_CS35L41_I2C_2),
10092 	SND_PCI_QUIRK(0x103c, 0x8991, "HP EliteBook 845 G9", ALC287_FIXUP_CS35L41_I2C_2_HP_GPIO_LED),
10093 	SND_PCI_QUIRK(0x103c, 0x8992, "HP EliteBook 845 G9", ALC287_FIXUP_CS35L41_I2C_2),
10094 	SND_PCI_QUIRK(0x103c, 0x8994, "HP EliteBook 855 G9", ALC287_FIXUP_CS35L41_I2C_2_HP_GPIO_LED),
10095 	SND_PCI_QUIRK(0x103c, 0x8995, "HP EliteBook 855 G9", ALC287_FIXUP_CS35L41_I2C_2),
10096 	SND_PCI_QUIRK(0x103c, 0x89a4, "HP ProBook 440 G9", ALC236_FIXUP_HP_GPIO_LED),
10097 	SND_PCI_QUIRK(0x103c, 0x89a6, "HP ProBook 450 G9", ALC236_FIXUP_HP_GPIO_LED),
10098 	SND_PCI_QUIRK(0x103c, 0x89aa, "HP EliteBook 630 G9", ALC236_FIXUP_HP_GPIO_LED),
10099 	SND_PCI_QUIRK(0x103c, 0x89ac, "HP EliteBook 640 G9", ALC236_FIXUP_HP_GPIO_LED),
10100 	SND_PCI_QUIRK(0x103c, 0x89ae, "HP EliteBook 650 G9", ALC236_FIXUP_HP_GPIO_LED),
10101 	SND_PCI_QUIRK(0x103c, 0x89c0, "HP ZBook Power 15.6 G9", ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED),
10102 	SND_PCI_QUIRK(0x103c, 0x89c3, "Zbook Studio G9", ALC245_FIXUP_CS35L41_SPI_4_HP_GPIO_LED),
10103 	SND_PCI_QUIRK(0x103c, 0x89c6, "Zbook Fury 17 G9", ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED),
10104 	SND_PCI_QUIRK(0x103c, 0x89ca, "HP", ALC236_FIXUP_HP_MUTE_LED_MICMUTE_VREF),
10105 	SND_PCI_QUIRK(0x103c, 0x89d3, "HP EliteBook 645 G9 (MB 89D2)", ALC236_FIXUP_HP_MUTE_LED_MICMUTE_VREF),
10106 	SND_PCI_QUIRK(0x103c, 0x89e7, "HP Elite x2 G9", ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED),
10107 	SND_PCI_QUIRK(0x103c, 0x8a0f, "HP Pavilion 14-ec1xxx", ALC287_FIXUP_HP_GPIO_LED),
10108 	SND_PCI_QUIRK(0x103c, 0x8a20, "HP Laptop 15s-fq5xxx", ALC236_FIXUP_HP_MUTE_LED_COEFBIT2),
10109 	SND_PCI_QUIRK(0x103c, 0x8a25, "HP Victus 16-d1xxx (MB 8A25)", ALC245_FIXUP_HP_MUTE_LED_COEFBIT),
10110 	SND_PCI_QUIRK(0x103c, 0x8a28, "HP Envy 13", ALC287_FIXUP_CS35L41_I2C_2),
10111 	SND_PCI_QUIRK(0x103c, 0x8a29, "HP Envy 15", ALC287_FIXUP_CS35L41_I2C_2),
10112 	SND_PCI_QUIRK(0x103c, 0x8a2a, "HP Envy 15", ALC287_FIXUP_CS35L41_I2C_2),
10113 	SND_PCI_QUIRK(0x103c, 0x8a2b, "HP Envy 15", ALC287_FIXUP_CS35L41_I2C_2),
10114 	SND_PCI_QUIRK(0x103c, 0x8a2c, "HP Envy 16", ALC287_FIXUP_CS35L41_I2C_2),
10115 	SND_PCI_QUIRK(0x103c, 0x8a2d, "HP Envy 16", ALC287_FIXUP_CS35L41_I2C_2),
10116 	SND_PCI_QUIRK(0x103c, 0x8a2e, "HP Envy 16", ALC287_FIXUP_CS35L41_I2C_2),
10117 	SND_PCI_QUIRK(0x103c, 0x8a30, "HP Envy 17", ALC287_FIXUP_CS35L41_I2C_2),
10118 	SND_PCI_QUIRK(0x103c, 0x8a31, "HP Envy 15", ALC287_FIXUP_CS35L41_I2C_2),
10119 	SND_PCI_QUIRK(0x103c, 0x8a6e, "HP EDNA 360", ALC287_FIXUP_CS35L41_I2C_4),
10120 	SND_PCI_QUIRK(0x103c, 0x8a74, "HP ProBook 440 G8 Notebook PC", ALC236_FIXUP_HP_GPIO_LED),
10121 	SND_PCI_QUIRK(0x103c, 0x8a78, "HP Dev One", ALC285_FIXUP_HP_LIMIT_INT_MIC_BOOST),
10122 	SND_PCI_QUIRK(0x103c, 0x8aa0, "HP ProBook 440 G9 (MB 8A9E)", ALC236_FIXUP_HP_GPIO_LED),
10123 	SND_PCI_QUIRK(0x103c, 0x8aa3, "HP ProBook 450 G9 (MB 8AA1)", ALC236_FIXUP_HP_GPIO_LED),
10124 	SND_PCI_QUIRK(0x103c, 0x8aa8, "HP EliteBook 640 G9 (MB 8AA6)", ALC236_FIXUP_HP_GPIO_LED),
10125 	SND_PCI_QUIRK(0x103c, 0x8aab, "HP EliteBook 650 G9 (MB 8AA9)", ALC236_FIXUP_HP_GPIO_LED),
10126 	SND_PCI_QUIRK(0x103c, 0x8ab9, "HP EliteBook 840 G8 (MB 8AB8)", ALC285_FIXUP_HP_GPIO_LED),
10127 	SND_PCI_QUIRK(0x103c, 0x8abb, "HP ZBook Firefly 14 G9", ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED),
10128 	SND_PCI_QUIRK(0x103c, 0x8ad1, "HP EliteBook 840 14 inch G9 Notebook PC", ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED),
10129 	SND_PCI_QUIRK(0x103c, 0x8ad2, "HP EliteBook 860 16 inch G9 Notebook PC", ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED),
10130 	SND_PCI_QUIRK(0x103c, 0x8ad8, "HP 800 G9", ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED),
10131 	SND_PCI_QUIRK(0x103c, 0x8b0f, "HP Elite mt645 G7 Mobile Thin Client U81", ALC236_FIXUP_HP_MUTE_LED_MICMUTE_VREF),
10132 	SND_PCI_QUIRK(0x103c, 0x8b2f, "HP 255 15.6 inch G10 Notebook PC", ALC236_FIXUP_HP_MUTE_LED_COEFBIT2),
10133 	SND_PCI_QUIRK(0x103c, 0x8b3a, "HP Envy 15", ALC287_FIXUP_CS35L41_I2C_2),
10134 	SND_PCI_QUIRK(0x103c, 0x8b3f, "HP mt440 Mobile Thin Client U91", ALC236_FIXUP_HP_GPIO_LED),
10135 	SND_PCI_QUIRK(0x103c, 0x8b42, "HP", ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED),
10136 	SND_PCI_QUIRK(0x103c, 0x8b43, "HP", ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED),
10137 	SND_PCI_QUIRK(0x103c, 0x8b44, "HP", ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED),
10138 	SND_PCI_QUIRK(0x103c, 0x8b45, "HP", ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED),
10139 	SND_PCI_QUIRK(0x103c, 0x8b46, "HP", ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED),
10140 	SND_PCI_QUIRK(0x103c, 0x8b47, "HP", ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED),
10141 	SND_PCI_QUIRK(0x103c, 0x8b59, "HP Elite mt645 G7 Mobile Thin Client U89", ALC236_FIXUP_HP_MUTE_LED_MICMUTE_VREF),
10142 	SND_PCI_QUIRK(0x103c, 0x8b5d, "HP", ALC236_FIXUP_HP_MUTE_LED_MICMUTE_VREF),
10143 	SND_PCI_QUIRK(0x103c, 0x8b5e, "HP", ALC236_FIXUP_HP_MUTE_LED_MICMUTE_VREF),
10144 	SND_PCI_QUIRK(0x103c, 0x8b63, "HP Elite Dragonfly 13.5 inch G4", ALC245_FIXUP_CS35L41_SPI_4_HP_GPIO_LED),
10145 	SND_PCI_QUIRK(0x103c, 0x8b65, "HP ProBook 455 15.6 inch G10 Notebook PC", ALC236_FIXUP_HP_MUTE_LED_MICMUTE_VREF),
10146 	SND_PCI_QUIRK(0x103c, 0x8b66, "HP", ALC236_FIXUP_HP_MUTE_LED_MICMUTE_VREF),
10147 	SND_PCI_QUIRK(0x103c, 0x8b70, "HP EliteBook 835 G10", ALC287_FIXUP_CS35L41_I2C_2_HP_GPIO_LED),
10148 	SND_PCI_QUIRK(0x103c, 0x8b72, "HP EliteBook 845 G10", ALC287_FIXUP_CS35L41_I2C_2_HP_GPIO_LED),
10149 	SND_PCI_QUIRK(0x103c, 0x8b74, "HP EliteBook 845W G10", ALC287_FIXUP_CS35L41_I2C_2_HP_GPIO_LED),
10150 	SND_PCI_QUIRK(0x103c, 0x8b77, "HP ElieBook 865 G10", ALC287_FIXUP_CS35L41_I2C_2),
10151 	SND_PCI_QUIRK(0x103c, 0x8b7a, "HP", ALC236_FIXUP_HP_GPIO_LED),
10152 	SND_PCI_QUIRK(0x103c, 0x8b7d, "HP", ALC236_FIXUP_HP_GPIO_LED),
10153 	SND_PCI_QUIRK(0x103c, 0x8b87, "HP", ALC236_FIXUP_HP_GPIO_LED),
10154 	SND_PCI_QUIRK(0x103c, 0x8b8a, "HP", ALC236_FIXUP_HP_GPIO_LED),
10155 	SND_PCI_QUIRK(0x103c, 0x8b8b, "HP", ALC236_FIXUP_HP_GPIO_LED),
10156 	SND_PCI_QUIRK(0x103c, 0x8b8d, "HP", ALC236_FIXUP_HP_GPIO_LED),
10157 	SND_PCI_QUIRK(0x103c, 0x8b8f, "HP", ALC245_FIXUP_CS35L41_SPI_4_HP_GPIO_LED),
10158 	SND_PCI_QUIRK(0x103c, 0x8b92, "HP", ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED),
10159 	SND_PCI_QUIRK(0x103c, 0x8b96, "HP", ALC236_FIXUP_HP_MUTE_LED_MICMUTE_VREF),
10160 	SND_PCI_QUIRK(0x103c, 0x8b97, "HP", ALC236_FIXUP_HP_MUTE_LED_MICMUTE_VREF),
10161 	SND_PCI_QUIRK(0x103c, 0x8bb3, "HP Slim OMEN", ALC287_FIXUP_CS35L41_I2C_2),
10162 	SND_PCI_QUIRK(0x103c, 0x8bb4, "HP Slim OMEN", ALC287_FIXUP_CS35L41_I2C_2),
10163 	SND_PCI_QUIRK(0x103c, 0x8bdd, "HP Envy 17", ALC287_FIXUP_CS35L41_I2C_2),
10164 	SND_PCI_QUIRK(0x103c, 0x8bde, "HP Envy 17", ALC287_FIXUP_CS35L41_I2C_2),
10165 	SND_PCI_QUIRK(0x103c, 0x8bdf, "HP Envy 15", ALC287_FIXUP_CS35L41_I2C_2),
10166 	SND_PCI_QUIRK(0x103c, 0x8be0, "HP Envy 15", ALC287_FIXUP_CS35L41_I2C_2),
10167 	SND_PCI_QUIRK(0x103c, 0x8be1, "HP Envy 15", ALC287_FIXUP_CS35L41_I2C_2),
10168 	SND_PCI_QUIRK(0x103c, 0x8be2, "HP Envy 15", ALC287_FIXUP_CS35L41_I2C_2),
10169 	SND_PCI_QUIRK(0x103c, 0x8be3, "HP Envy 15", ALC287_FIXUP_CS35L41_I2C_2),
10170 	SND_PCI_QUIRK(0x103c, 0x8be5, "HP Envy 16", ALC287_FIXUP_CS35L41_I2C_2),
10171 	SND_PCI_QUIRK(0x103c, 0x8be6, "HP Envy 16", ALC287_FIXUP_CS35L41_I2C_2),
10172 	SND_PCI_QUIRK(0x103c, 0x8be7, "HP Envy 17", ALC287_FIXUP_CS35L41_I2C_2),
10173 	SND_PCI_QUIRK(0x103c, 0x8be8, "HP Envy 17", ALC287_FIXUP_CS35L41_I2C_2),
10174 	SND_PCI_QUIRK(0x103c, 0x8be9, "HP Envy 15", ALC287_FIXUP_CS35L41_I2C_2),
10175 	SND_PCI_QUIRK(0x103c, 0x8bf0, "HP", ALC236_FIXUP_HP_GPIO_LED),
10176 	SND_PCI_QUIRK(0x103c, 0x8c15, "HP Spectre x360 2-in-1 Laptop 14-eu0xxx", ALC245_FIXUP_HP_SPECTRE_X360_EU0XXX),
10177 	SND_PCI_QUIRK(0x103c, 0x8c16, "HP Spectre 16", ALC287_FIXUP_CS35L41_I2C_2),
10178 	SND_PCI_QUIRK(0x103c, 0x8c17, "HP Spectre 16", ALC287_FIXUP_CS35L41_I2C_2),
10179 	SND_PCI_QUIRK(0x103c, 0x8c46, "HP EliteBook 830 G11", ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED),
10180 	SND_PCI_QUIRK(0x103c, 0x8c47, "HP EliteBook 840 G11", ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED),
10181 	SND_PCI_QUIRK(0x103c, 0x8c48, "HP EliteBook 860 G11", ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED),
10182 	SND_PCI_QUIRK(0x103c, 0x8c49, "HP Elite x360 830 2-in-1 G11", ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED),
10183 	SND_PCI_QUIRK(0x103c, 0x8c4d, "HP Omen", ALC287_FIXUP_CS35L41_I2C_2),
10184 	SND_PCI_QUIRK(0x103c, 0x8c4e, "HP Omen", ALC287_FIXUP_CS35L41_I2C_2),
10185 	SND_PCI_QUIRK(0x103c, 0x8c4f, "HP Envy 15", ALC287_FIXUP_CS35L41_I2C_2),
10186 	SND_PCI_QUIRK(0x103c, 0x8c50, "HP Envy 17", ALC287_FIXUP_CS35L41_I2C_2),
10187 	SND_PCI_QUIRK(0x103c, 0x8c51, "HP Envy 17", ALC287_FIXUP_CS35L41_I2C_2),
10188 	SND_PCI_QUIRK(0x103c, 0x8c52, "HP EliteBook 1040 G11", ALC245_FIXUP_CS35L56_SPI_4_HP_GPIO_LED),
10189 	SND_PCI_QUIRK(0x103c, 0x8c53, "HP Elite x360 1040 2-in-1 G11", ALC245_FIXUP_CS35L56_SPI_4_HP_GPIO_LED),
10190 	SND_PCI_QUIRK(0x103c, 0x8c66, "HP Envy 16", ALC287_FIXUP_CS35L41_I2C_2),
10191 	SND_PCI_QUIRK(0x103c, 0x8c67, "HP Envy 17", ALC287_FIXUP_CS35L41_I2C_2),
10192 	SND_PCI_QUIRK(0x103c, 0x8c68, "HP Envy 17", ALC287_FIXUP_CS35L41_I2C_2),
10193 	SND_PCI_QUIRK(0x103c, 0x8c6a, "HP Envy 16", ALC287_FIXUP_CS35L41_I2C_2),
10194 	SND_PCI_QUIRK(0x103c, 0x8c70, "HP EliteBook 835 G11", ALC287_FIXUP_CS35L41_I2C_2_HP_GPIO_LED),
10195 	SND_PCI_QUIRK(0x103c, 0x8c71, "HP EliteBook 845 G11", ALC287_FIXUP_CS35L41_I2C_2_HP_GPIO_LED),
10196 	SND_PCI_QUIRK(0x103c, 0x8c72, "HP EliteBook 865 G11", ALC287_FIXUP_CS35L41_I2C_2_HP_GPIO_LED),
10197 	SND_PCI_QUIRK(0x103c, 0x8c89, "HP ProBook 460 G11", ALC236_FIXUP_HP_GPIO_LED),
10198 	SND_PCI_QUIRK(0x103c, 0x8c8a, "HP EliteBook 630", ALC236_FIXUP_HP_GPIO_LED),
10199 	SND_PCI_QUIRK(0x103c, 0x8c8c, "HP EliteBook 660", ALC236_FIXUP_HP_GPIO_LED),
10200 	SND_PCI_QUIRK(0x103c, 0x8c8d, "HP ProBook 440 G11", ALC236_FIXUP_HP_GPIO_LED),
10201 	SND_PCI_QUIRK(0x103c, 0x8c8e, "HP ProBook 460 G11", ALC236_FIXUP_HP_GPIO_LED),
10202 	SND_PCI_QUIRK(0x103c, 0x8c90, "HP EliteBook 640", ALC236_FIXUP_HP_GPIO_LED),
10203 	SND_PCI_QUIRK(0x103c, 0x8c91, "HP EliteBook 660", ALC236_FIXUP_HP_GPIO_LED),
10204 	SND_PCI_QUIRK(0x103c, 0x8c96, "HP", ALC236_FIXUP_HP_MUTE_LED_MICMUTE_VREF),
10205 	SND_PCI_QUIRK(0x103c, 0x8c97, "HP ZBook", ALC236_FIXUP_HP_MUTE_LED_MICMUTE_VREF),
10206 	SND_PCI_QUIRK(0x103c, 0x8ca1, "HP ZBook Power", ALC236_FIXUP_HP_GPIO_LED),
10207 	SND_PCI_QUIRK(0x103c, 0x8ca2, "HP ZBook Power", ALC236_FIXUP_HP_GPIO_LED),
10208 	SND_PCI_QUIRK(0x103c, 0x8ca4, "HP ZBook Fury", ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED),
10209 	SND_PCI_QUIRK(0x103c, 0x8ca7, "HP ZBook Fury", ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED),
10210 	SND_PCI_QUIRK(0x103c, 0x8cdd, "HP Spectre", ALC287_FIXUP_CS35L41_I2C_2),
10211 	SND_PCI_QUIRK(0x103c, 0x8cde, "HP Spectre", ALC287_FIXUP_CS35L41_I2C_2),
10212 	SND_PCI_QUIRK(0x103c, 0x8cdf, "HP SnowWhite", ALC287_FIXUP_CS35L41_I2C_2_HP_GPIO_LED),
10213 	SND_PCI_QUIRK(0x103c, 0x8ce0, "HP SnowWhite", ALC287_FIXUP_CS35L41_I2C_2_HP_GPIO_LED),
10214 	SND_PCI_QUIRK(0x103c, 0x8cf5, "HP ZBook Studio 16", ALC245_FIXUP_CS35L41_SPI_4_HP_GPIO_LED),
10215 	SND_PCI_QUIRK(0x1043, 0x103e, "ASUS X540SA", ALC256_FIXUP_ASUS_MIC),
10216 	SND_PCI_QUIRK(0x1043, 0x103f, "ASUS TX300", ALC282_FIXUP_ASUS_TX300),
10217 	SND_PCI_QUIRK(0x1043, 0x106d, "Asus K53BE", ALC269_FIXUP_LIMIT_INT_MIC_BOOST),
10218 	SND_PCI_QUIRK(0x1043, 0x10a1, "ASUS UX391UA", ALC294_FIXUP_ASUS_SPK),
10219 	SND_PCI_QUIRK(0x1043, 0x10c0, "ASUS X540SA", ALC256_FIXUP_ASUS_MIC),
10220 	SND_PCI_QUIRK(0x1043, 0x10d0, "ASUS X540LA/X540LJ", ALC255_FIXUP_ASUS_MIC_NO_PRESENCE),
10221 	SND_PCI_QUIRK(0x1043, 0x10d3, "ASUS K6500ZC", ALC294_FIXUP_ASUS_SPK),
10222 	SND_PCI_QUIRK(0x1043, 0x115d, "Asus 1015E", ALC269_FIXUP_LIMIT_INT_MIC_BOOST),
10223 	SND_PCI_QUIRK(0x1043, 0x11c0, "ASUS X556UR", ALC255_FIXUP_ASUS_MIC_NO_PRESENCE),
10224 	SND_PCI_QUIRK(0x1043, 0x125e, "ASUS Q524UQK", ALC255_FIXUP_ASUS_MIC_NO_PRESENCE),
10225 	SND_PCI_QUIRK(0x1043, 0x1271, "ASUS X430UN", ALC256_FIXUP_ASUS_MIC_NO_PRESENCE),
10226 	SND_PCI_QUIRK(0x1043, 0x1290, "ASUS X441SA", ALC233_FIXUP_EAPD_COEF_AND_MIC_NO_PRESENCE),
10227 	SND_PCI_QUIRK(0x1043, 0x12a0, "ASUS X441UV", ALC233_FIXUP_EAPD_COEF_AND_MIC_NO_PRESENCE),
10228 	SND_PCI_QUIRK(0x1043, 0x12a3, "Asus N7691ZM", ALC269_FIXUP_ASUS_N7601ZM),
10229 	SND_PCI_QUIRK(0x1043, 0x12af, "ASUS UX582ZS", ALC245_FIXUP_CS35L41_SPI_2),
10230 	SND_PCI_QUIRK(0x1043, 0x12e0, "ASUS X541SA", ALC256_FIXUP_ASUS_MIC),
10231 	SND_PCI_QUIRK(0x1043, 0x12f0, "ASUS X541UV", ALC256_FIXUP_ASUS_MIC),
10232 	SND_PCI_QUIRK(0x1043, 0x1313, "Asus K42JZ", ALC269VB_FIXUP_ASUS_MIC_NO_PRESENCE),
10233 	SND_PCI_QUIRK(0x1043, 0x13b0, "ASUS Z550SA", ALC256_FIXUP_ASUS_MIC),
10234 	SND_PCI_QUIRK(0x1043, 0x1427, "Asus Zenbook UX31E", ALC269VB_FIXUP_ASUS_ZENBOOK),
10235 	SND_PCI_QUIRK(0x1043, 0x1433, "ASUS GX650PY/PZ/PV/PU/PYV/PZV/PIV/PVV", ALC285_FIXUP_ASUS_I2C_HEADSET_MIC),
10236 	SND_PCI_QUIRK(0x1043, 0x1463, "Asus GA402X/GA402N", ALC285_FIXUP_ASUS_I2C_HEADSET_MIC),
10237 	SND_PCI_QUIRK(0x1043, 0x1473, "ASUS GU604VI/VC/VE/VG/VJ/VQ/VU/VV/VY/VZ", ALC285_FIXUP_ASUS_HEADSET_MIC),
10238 	SND_PCI_QUIRK(0x1043, 0x1483, "ASUS GU603VQ/VU/VV/VJ/VI", ALC285_FIXUP_ASUS_HEADSET_MIC),
10239 	SND_PCI_QUIRK(0x1043, 0x1493, "ASUS GV601VV/VU/VJ/VQ/VI", ALC285_FIXUP_ASUS_HEADSET_MIC),
10240 	SND_PCI_QUIRK(0x1043, 0x14d3, "ASUS G614JY/JZ/JG", ALC245_FIXUP_CS35L41_SPI_2),
10241 	SND_PCI_QUIRK(0x1043, 0x14e3, "ASUS G513PI/PU/PV", ALC287_FIXUP_CS35L41_I2C_2),
10242 	SND_PCI_QUIRK(0x1043, 0x1503, "ASUS G733PY/PZ/PZV/PYV", ALC287_FIXUP_CS35L41_I2C_2),
10243 	SND_PCI_QUIRK(0x1043, 0x1517, "Asus Zenbook UX31A", ALC269VB_FIXUP_ASUS_ZENBOOK_UX31A),
10244 	SND_PCI_QUIRK(0x1043, 0x1533, "ASUS GV302XA/XJ/XQ/XU/XV/XI", ALC287_FIXUP_CS35L41_I2C_2),
10245 	SND_PCI_QUIRK(0x1043, 0x1573, "ASUS GZ301VV/VQ/VU/VJ/VA/VC/VE/VVC/VQC/VUC/VJC/VEC/VCC", ALC285_FIXUP_ASUS_HEADSET_MIC),
10246 	SND_PCI_QUIRK(0x1043, 0x1662, "ASUS GV301QH", ALC294_FIXUP_ASUS_DUAL_SPK),
10247 	SND_PCI_QUIRK(0x1043, 0x1663, "ASUS GU603ZI/ZJ/ZQ/ZU/ZV", ALC285_FIXUP_ASUS_HEADSET_MIC),
10248 	SND_PCI_QUIRK(0x1043, 0x1683, "ASUS UM3402YAR", ALC287_FIXUP_CS35L41_I2C_2),
10249 	SND_PCI_QUIRK(0x1043, 0x16a3, "ASUS UX3402VA", ALC245_FIXUP_CS35L41_SPI_2),
10250 	SND_PCI_QUIRK(0x1043, 0x16b2, "ASUS GU603", ALC289_FIXUP_ASUS_GA401),
10251 	SND_PCI_QUIRK(0x1043, 0x16d3, "ASUS UX5304VA", ALC245_FIXUP_CS35L41_SPI_2),
10252 	SND_PCI_QUIRK(0x1043, 0x16e3, "ASUS UX50", ALC269_FIXUP_STEREO_DMIC),
10253 	SND_PCI_QUIRK(0x1043, 0x16f3, "ASUS UX7602VI/BZ", ALC245_FIXUP_CS35L41_SPI_2),
10254 	SND_PCI_QUIRK(0x1043, 0x1740, "ASUS UX430UA", ALC295_FIXUP_ASUS_DACS),
10255 	SND_PCI_QUIRK(0x1043, 0x17d1, "ASUS UX431FL", ALC294_FIXUP_ASUS_DUAL_SPK),
10256 	SND_PCI_QUIRK(0x1043, 0x17f3, "ROG Ally NR2301L/X", ALC294_FIXUP_ASUS_ALLY),
10257 	SND_PCI_QUIRK(0x1043, 0x1863, "ASUS UX6404VI/VV", ALC245_FIXUP_CS35L41_SPI_2),
10258 	SND_PCI_QUIRK(0x1043, 0x1881, "ASUS Zephyrus S/M", ALC294_FIXUP_ASUS_GX502_PINS),
10259 	SND_PCI_QUIRK(0x1043, 0x18b1, "Asus MJ401TA", ALC256_FIXUP_ASUS_HEADSET_MIC),
10260 	SND_PCI_QUIRK(0x1043, 0x18d3, "ASUS UM3504DA", ALC294_FIXUP_CS35L41_I2C_2),
10261 	SND_PCI_QUIRK(0x1043, 0x18f1, "Asus FX505DT", ALC256_FIXUP_ASUS_HEADSET_MIC),
10262 	SND_PCI_QUIRK(0x1043, 0x194e, "ASUS UX563FD", ALC294_FIXUP_ASUS_HPE),
10263 	SND_PCI_QUIRK(0x1043, 0x1970, "ASUS UX550VE", ALC289_FIXUP_ASUS_GA401),
10264 	SND_PCI_QUIRK(0x1043, 0x1982, "ASUS B1400CEPE", ALC256_FIXUP_ASUS_HPE),
10265 	SND_PCI_QUIRK(0x1043, 0x19ce, "ASUS B9450FA", ALC294_FIXUP_ASUS_HPE),
10266 	SND_PCI_QUIRK(0x1043, 0x19e1, "ASUS UX581LV", ALC295_FIXUP_ASUS_MIC_NO_PRESENCE),
10267 	SND_PCI_QUIRK(0x1043, 0x1a13, "Asus G73Jw", ALC269_FIXUP_ASUS_G73JW),
10268 	SND_PCI_QUIRK(0x1043, 0x1a30, "ASUS X705UD", ALC256_FIXUP_ASUS_MIC),
10269 	SND_PCI_QUIRK(0x1043, 0x1a63, "ASUS UX3405MA", ALC245_FIXUP_CS35L41_SPI_2),
10270 	SND_PCI_QUIRK(0x1043, 0x1a83, "ASUS UM5302LA", ALC294_FIXUP_CS35L41_I2C_2),
10271 	SND_PCI_QUIRK(0x1043, 0x1a8f, "ASUS UX582ZS", ALC245_FIXUP_CS35L41_SPI_2),
10272 	SND_PCI_QUIRK(0x1043, 0x1b11, "ASUS UX431DA", ALC294_FIXUP_ASUS_COEF_1B),
10273 	SND_PCI_QUIRK(0x1043, 0x1b13, "ASUS U41SV/GA403U", ALC285_FIXUP_ASUS_GA403U_HEADSET_MIC),
10274 	SND_PCI_QUIRK(0x1043, 0x1b93, "ASUS G614JVR/JIR", ALC245_FIXUP_CS35L41_SPI_2),
10275 	SND_PCI_QUIRK(0x1043, 0x1bbd, "ASUS Z550MA", ALC255_FIXUP_ASUS_MIC_NO_PRESENCE),
10276 	SND_PCI_QUIRK(0x1043, 0x1c03, "ASUS UM3406HA", ALC287_FIXUP_CS35L41_I2C_2),
10277 	SND_PCI_QUIRK(0x1043, 0x1c23, "Asus X55U", ALC269_FIXUP_LIMIT_INT_MIC_BOOST),
10278 	SND_PCI_QUIRK(0x1043, 0x1c33, "ASUS UX5304MA", ALC245_FIXUP_CS35L41_SPI_2),
10279 	SND_PCI_QUIRK(0x1043, 0x1c43, "ASUS UX8406MA", ALC245_FIXUP_CS35L41_SPI_2),
10280 	SND_PCI_QUIRK(0x1043, 0x1c62, "ASUS GU603", ALC289_FIXUP_ASUS_GA401),
10281 	SND_PCI_QUIRK(0x1043, 0x1c63, "ASUS GU605M", ALC285_FIXUP_ASUS_GU605_SPI_SPEAKER2_TO_DAC1),
10282 	SND_PCI_QUIRK(0x1043, 0x1c92, "ASUS ROG Strix G15", ALC285_FIXUP_ASUS_G533Z_PINS),
10283 	SND_PCI_QUIRK(0x1043, 0x1c9f, "ASUS G614JU/JV/JI", ALC285_FIXUP_ASUS_HEADSET_MIC),
10284 	SND_PCI_QUIRK(0x1043, 0x1caf, "ASUS G634JY/JZ/JI/JG", ALC285_FIXUP_ASUS_SPI_REAR_SPEAKERS),
10285 	SND_PCI_QUIRK(0x1043, 0x1ccd, "ASUS X555UB", ALC256_FIXUP_ASUS_MIC),
10286 	SND_PCI_QUIRK(0x1043, 0x1ccf, "ASUS G814JU/JV/JI", ALC245_FIXUP_CS35L41_SPI_2),
10287 	SND_PCI_QUIRK(0x1043, 0x1cdf, "ASUS G814JY/JZ/JG", ALC245_FIXUP_CS35L41_SPI_2),
10288 	SND_PCI_QUIRK(0x1043, 0x1cef, "ASUS G834JY/JZ/JI/JG", ALC285_FIXUP_ASUS_HEADSET_MIC),
10289 	SND_PCI_QUIRK(0x1043, 0x1d1f, "ASUS G713PI/PU/PV/PVN", ALC287_FIXUP_CS35L41_I2C_2),
10290 	SND_PCI_QUIRK(0x1043, 0x1d42, "ASUS Zephyrus G14 2022", ALC289_FIXUP_ASUS_GA401),
10291 	SND_PCI_QUIRK(0x1043, 0x1d4e, "ASUS TM420", ALC256_FIXUP_ASUS_HPE),
10292 	SND_PCI_QUIRK(0x1043, 0x1da2, "ASUS UP6502ZA/ZD", ALC245_FIXUP_CS35L41_SPI_2),
10293 	SND_PCI_QUIRK(0x1043, 0x1df3, "ASUS UM5606", ALC285_FIXUP_CS35L56_I2C_4),
10294 	SND_PCI_QUIRK(0x1043, 0x1e02, "ASUS UX3402ZA", ALC245_FIXUP_CS35L41_SPI_2),
10295 	SND_PCI_QUIRK(0x1043, 0x1e11, "ASUS Zephyrus G15", ALC289_FIXUP_ASUS_GA502),
10296 	SND_PCI_QUIRK(0x1043, 0x1e12, "ASUS UM3402", ALC287_FIXUP_CS35L41_I2C_2),
10297 	SND_PCI_QUIRK(0x1043, 0x1e51, "ASUS Zephyrus M15", ALC294_FIXUP_ASUS_GU502_PINS),
10298 	SND_PCI_QUIRK(0x1043, 0x1e5e, "ASUS ROG Strix G513", ALC294_FIXUP_ASUS_G513_PINS),
10299 	SND_PCI_QUIRK(0x1043, 0x1e63, "ASUS H7606W", ALC285_FIXUP_CS35L56_I2C_2),
10300 	SND_PCI_QUIRK(0x1043, 0x1e83, "ASUS GA605W", ALC285_FIXUP_CS35L56_I2C_2),
10301 	SND_PCI_QUIRK(0x1043, 0x1e8e, "ASUS Zephyrus G15", ALC289_FIXUP_ASUS_GA401),
10302 	SND_PCI_QUIRK(0x1043, 0x1ed3, "ASUS HN7306W", ALC287_FIXUP_CS35L41_I2C_2),
10303 	SND_PCI_QUIRK(0x1043, 0x1ee2, "ASUS UM6702RA/RC", ALC287_FIXUP_CS35L41_I2C_2),
10304 	SND_PCI_QUIRK(0x1043, 0x1c52, "ASUS Zephyrus G15 2022", ALC289_FIXUP_ASUS_GA401),
10305 	SND_PCI_QUIRK(0x1043, 0x1f11, "ASUS Zephyrus G14", ALC289_FIXUP_ASUS_GA401),
10306 	SND_PCI_QUIRK(0x1043, 0x1f12, "ASUS UM5302", ALC287_FIXUP_CS35L41_I2C_2),
10307 	SND_PCI_QUIRK(0x1043, 0x1f1f, "ASUS H7604JI/JV/J3D", ALC245_FIXUP_CS35L41_SPI_2),
10308 	SND_PCI_QUIRK(0x1043, 0x1f62, "ASUS UX7602ZM", ALC245_FIXUP_CS35L41_SPI_2),
10309 	SND_PCI_QUIRK(0x1043, 0x1f92, "ASUS ROG Flow X16", ALC289_FIXUP_ASUS_GA401),
10310 	SND_PCI_QUIRK(0x1043, 0x3030, "ASUS ZN270IE", ALC256_FIXUP_ASUS_AIO_GPIO2),
10311 	SND_PCI_QUIRK(0x1043, 0x3a20, "ASUS G614JZR", ALC245_FIXUP_CS35L41_SPI_2),
10312 	SND_PCI_QUIRK(0x1043, 0x3a30, "ASUS G814JVR/JIR", ALC245_FIXUP_CS35L41_SPI_2),
10313 	SND_PCI_QUIRK(0x1043, 0x3a40, "ASUS G814JZR", ALC285_FIXUP_ASUS_SPI_REAR_SPEAKERS),
10314 	SND_PCI_QUIRK(0x1043, 0x3a50, "ASUS G834JYR/JZR", ALC245_FIXUP_CS35L41_SPI_2),
10315 	SND_PCI_QUIRK(0x1043, 0x3a60, "ASUS G634JYR/JZR", ALC285_FIXUP_ASUS_SPI_REAR_SPEAKERS),
10316 	SND_PCI_QUIRK(0x1043, 0x831a, "ASUS P901", ALC269_FIXUP_STEREO_DMIC),
10317 	SND_PCI_QUIRK(0x1043, 0x834a, "ASUS S101", ALC269_FIXUP_STEREO_DMIC),
10318 	SND_PCI_QUIRK(0x1043, 0x8398, "ASUS P1005", ALC269_FIXUP_STEREO_DMIC),
10319 	SND_PCI_QUIRK(0x1043, 0x83ce, "ASUS P1005", ALC269_FIXUP_STEREO_DMIC),
10320 	SND_PCI_QUIRK(0x1043, 0x8516, "ASUS X101CH", ALC269_FIXUP_ASUS_X101),
10321 	SND_PCI_QUIRK(0x104d, 0x9073, "Sony VAIO", ALC275_FIXUP_SONY_VAIO_GPIO2),
10322 	SND_PCI_QUIRK(0x104d, 0x907b, "Sony VAIO", ALC275_FIXUP_SONY_HWEQ),
10323 	SND_PCI_QUIRK(0x104d, 0x9084, "Sony VAIO", ALC275_FIXUP_SONY_HWEQ),
10324 	SND_PCI_QUIRK(0x104d, 0x9099, "Sony VAIO S13", ALC275_FIXUP_SONY_DISABLE_AAMIX),
10325 	SND_PCI_QUIRK(0x104d, 0x90b5, "Sony VAIO Pro 11", ALC286_FIXUP_SONY_MIC_NO_PRESENCE),
10326 	SND_PCI_QUIRK(0x104d, 0x90b6, "Sony VAIO Pro 13", ALC286_FIXUP_SONY_MIC_NO_PRESENCE),
10327 	SND_PCI_QUIRK(0x10cf, 0x1475, "Lifebook", ALC269_FIXUP_LIFEBOOK),
10328 	SND_PCI_QUIRK(0x10cf, 0x159f, "Lifebook E780", ALC269_FIXUP_LIFEBOOK_NO_HP_TO_LINEOUT),
10329 	SND_PCI_QUIRK(0x10cf, 0x15dc, "Lifebook T731", ALC269_FIXUP_LIFEBOOK_HP_PIN),
10330 	SND_PCI_QUIRK(0x10cf, 0x1629, "Lifebook U7x7", ALC255_FIXUP_LIFEBOOK_U7x7_HEADSET_MIC),
10331 	SND_PCI_QUIRK(0x10cf, 0x1757, "Lifebook E752", ALC269_FIXUP_LIFEBOOK_HP_PIN),
10332 	SND_PCI_QUIRK(0x10cf, 0x1845, "Lifebook U904", ALC269_FIXUP_LIFEBOOK_EXTMIC),
10333 	SND_PCI_QUIRK(0x10ec, 0x10f2, "Intel Reference board", ALC700_FIXUP_INTEL_REFERENCE),
10334 	SND_PCI_QUIRK(0x10ec, 0x118c, "Medion EE4254 MD62100", ALC256_FIXUP_MEDION_HEADSET_NO_PRESENCE),
10335 	SND_PCI_QUIRK(0x10ec, 0x1230, "Intel Reference board", ALC295_FIXUP_CHROME_BOOK),
10336 	SND_PCI_QUIRK(0x10ec, 0x124c, "Intel Reference board", ALC295_FIXUP_CHROME_BOOK),
10337 	SND_PCI_QUIRK(0x10ec, 0x1252, "Intel Reference board", ALC295_FIXUP_CHROME_BOOK),
10338 	SND_PCI_QUIRK(0x10ec, 0x1254, "Intel Reference board", ALC295_FIXUP_CHROME_BOOK),
10339 	SND_PCI_QUIRK(0x10ec, 0x12cc, "Intel Reference board", ALC295_FIXUP_CHROME_BOOK),
10340 	SND_PCI_QUIRK(0x10ec, 0x12f6, "Intel Reference board", ALC295_FIXUP_CHROME_BOOK),
10341 	SND_PCI_QUIRK(0x10f7, 0x8338, "Panasonic CF-SZ6", ALC269_FIXUP_ASPIRE_HEADSET_MIC),
10342 	SND_PCI_QUIRK(0x144d, 0xc109, "Samsung Ativ book 9 (NP900X3G)", ALC269_FIXUP_INV_DMIC),
10343 	SND_PCI_QUIRK(0x144d, 0xc169, "Samsung Notebook 9 Pen (NP930SBE-K01US)", ALC298_FIXUP_SAMSUNG_AMP),
10344 	SND_PCI_QUIRK(0x144d, 0xc176, "Samsung Notebook 9 Pro (NP930MBE-K04US)", ALC298_FIXUP_SAMSUNG_AMP),
10345 	SND_PCI_QUIRK(0x144d, 0xc189, "Samsung Galaxy Flex Book (NT950QCG-X716)", ALC298_FIXUP_SAMSUNG_AMP),
10346 	SND_PCI_QUIRK(0x144d, 0xc18a, "Samsung Galaxy Book Ion (NP930XCJ-K01US)", ALC298_FIXUP_SAMSUNG_AMP),
10347 	SND_PCI_QUIRK(0x144d, 0xc1a3, "Samsung Galaxy Book Pro (NP935XDB-KC1SE)", ALC298_FIXUP_SAMSUNG_AMP),
10348 	SND_PCI_QUIRK(0x144d, 0xc1a6, "Samsung Galaxy Book Pro 360 (NP930QBD)", ALC298_FIXUP_SAMSUNG_AMP),
10349 	SND_PCI_QUIRK(0x144d, 0xc740, "Samsung Ativ book 8 (NP870Z5G)", ALC269_FIXUP_ATIV_BOOK_8),
10350 	SND_PCI_QUIRK(0x144d, 0xc812, "Samsung Notebook Pen S (NT950SBE-X58)", ALC298_FIXUP_SAMSUNG_AMP),
10351 	SND_PCI_QUIRK(0x144d, 0xc830, "Samsung Galaxy Book Ion (NT950XCJ-X716A)", ALC298_FIXUP_SAMSUNG_AMP),
10352 	SND_PCI_QUIRK(0x144d, 0xc832, "Samsung Galaxy Book Flex Alpha (NP730QCJ)", ALC256_FIXUP_SAMSUNG_HEADPHONE_VERY_QUIET),
10353 	SND_PCI_QUIRK(0x144d, 0xca03, "Samsung Galaxy Book2 Pro 360 (NP930QED)", ALC298_FIXUP_SAMSUNG_AMP),
10354 	SND_PCI_QUIRK(0x144d, 0xc868, "Samsung Galaxy Book2 Pro (NP930XED)", ALC298_FIXUP_SAMSUNG_AMP),
10355 	SND_PCI_QUIRK(0x1458, 0xfa53, "Gigabyte BXBT-2807", ALC283_FIXUP_HEADSET_MIC),
10356 	SND_PCI_QUIRK(0x1462, 0xb120, "MSI Cubi MS-B120", ALC283_FIXUP_HEADSET_MIC),
10357 	SND_PCI_QUIRK(0x1462, 0xb171, "Cubi N 8GL (MS-B171)", ALC283_FIXUP_HEADSET_MIC),
10358 	SND_PCI_QUIRK(0x152d, 0x1082, "Quanta NL3", ALC269_FIXUP_LIFEBOOK),
10359 	SND_PCI_QUIRK(0x152d, 0x1262, "Huawei NBLB-WAX9N", ALC2XX_FIXUP_HEADSET_MIC),
10360 	SND_PCI_QUIRK(0x1558, 0x0353, "Clevo V35[05]SN[CDE]Q", ALC256_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10361 	SND_PCI_QUIRK(0x1558, 0x1323, "Clevo N130ZU", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10362 	SND_PCI_QUIRK(0x1558, 0x1325, "Clevo N15[01][CW]U", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10363 	SND_PCI_QUIRK(0x1558, 0x1401, "Clevo L140[CZ]U", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10364 	SND_PCI_QUIRK(0x1558, 0x1403, "Clevo N140CU", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10365 	SND_PCI_QUIRK(0x1558, 0x1404, "Clevo N150CU", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10366 	SND_PCI_QUIRK(0x1558, 0x14a1, "Clevo L141MU", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10367 	SND_PCI_QUIRK(0x1558, 0x2624, "Clevo L240TU", ALC256_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10368 	SND_PCI_QUIRK(0x1558, 0x4018, "Clevo NV40M[BE]", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10369 	SND_PCI_QUIRK(0x1558, 0x4019, "Clevo NV40MZ", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10370 	SND_PCI_QUIRK(0x1558, 0x4020, "Clevo NV40MB", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10371 	SND_PCI_QUIRK(0x1558, 0x4041, "Clevo NV4[15]PZ", ALC256_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10372 	SND_PCI_QUIRK(0x1558, 0x40a1, "Clevo NL40GU", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10373 	SND_PCI_QUIRK(0x1558, 0x40c1, "Clevo NL40[CZ]U", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10374 	SND_PCI_QUIRK(0x1558, 0x40d1, "Clevo NL41DU", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10375 	SND_PCI_QUIRK(0x1558, 0x5015, "Clevo NH5[58]H[HJK]Q", ALC256_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10376 	SND_PCI_QUIRK(0x1558, 0x5017, "Clevo NH7[79]H[HJK]Q", ALC256_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10377 	SND_PCI_QUIRK(0x1558, 0x50a3, "Clevo NJ51GU", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10378 	SND_PCI_QUIRK(0x1558, 0x50b3, "Clevo NK50S[BEZ]", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10379 	SND_PCI_QUIRK(0x1558, 0x50b6, "Clevo NK50S5", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10380 	SND_PCI_QUIRK(0x1558, 0x50b8, "Clevo NK50SZ", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10381 	SND_PCI_QUIRK(0x1558, 0x50d5, "Clevo NP50D5", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10382 	SND_PCI_QUIRK(0x1558, 0x50e1, "Clevo NH5[58]HPQ", ALC256_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10383 	SND_PCI_QUIRK(0x1558, 0x50e2, "Clevo NH7[79]HPQ", ALC256_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10384 	SND_PCI_QUIRK(0x1558, 0x50f0, "Clevo NH50A[CDF]", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10385 	SND_PCI_QUIRK(0x1558, 0x50f2, "Clevo NH50E[PR]", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10386 	SND_PCI_QUIRK(0x1558, 0x50f3, "Clevo NH58DPQ", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10387 	SND_PCI_QUIRK(0x1558, 0x50f5, "Clevo NH55EPY", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10388 	SND_PCI_QUIRK(0x1558, 0x50f6, "Clevo NH55DPQ", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10389 	SND_PCI_QUIRK(0x1558, 0x5101, "Clevo S510WU", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10390 	SND_PCI_QUIRK(0x1558, 0x5157, "Clevo W517GU1", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10391 	SND_PCI_QUIRK(0x1558, 0x51a1, "Clevo NS50MU", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10392 	SND_PCI_QUIRK(0x1558, 0x51b1, "Clevo NS50AU", ALC256_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10393 	SND_PCI_QUIRK(0x1558, 0x51b3, "Clevo NS70AU", ALC256_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10394 	SND_PCI_QUIRK(0x1558, 0x5630, "Clevo NP50RNJS", ALC256_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10395 	SND_PCI_QUIRK(0x1558, 0x70a1, "Clevo NB70T[HJK]", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10396 	SND_PCI_QUIRK(0x1558, 0x70b3, "Clevo NK70SB", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10397 	SND_PCI_QUIRK(0x1558, 0x70f2, "Clevo NH79EPY", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10398 	SND_PCI_QUIRK(0x1558, 0x70f3, "Clevo NH77DPQ", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10399 	SND_PCI_QUIRK(0x1558, 0x70f4, "Clevo NH77EPY", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10400 	SND_PCI_QUIRK(0x1558, 0x70f6, "Clevo NH77DPQ-Y", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10401 	SND_PCI_QUIRK(0x1558, 0x7716, "Clevo NS50PU", ALC256_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10402 	SND_PCI_QUIRK(0x1558, 0x7717, "Clevo NS70PU", ALC256_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10403 	SND_PCI_QUIRK(0x1558, 0x7718, "Clevo L140PU", ALC256_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10404 	SND_PCI_QUIRK(0x1558, 0x7724, "Clevo L140AU", ALC256_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10405 	SND_PCI_QUIRK(0x1558, 0x8228, "Clevo NR40BU", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10406 	SND_PCI_QUIRK(0x1558, 0x8520, "Clevo NH50D[CD]", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10407 	SND_PCI_QUIRK(0x1558, 0x8521, "Clevo NH77D[CD]", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10408 	SND_PCI_QUIRK(0x1558, 0x8535, "Clevo NH50D[BE]", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10409 	SND_PCI_QUIRK(0x1558, 0x8536, "Clevo NH79D[BE]", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10410 	SND_PCI_QUIRK(0x1558, 0x8550, "Clevo NH[57][0-9][ER][ACDH]Q", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10411 	SND_PCI_QUIRK(0x1558, 0x8551, "Clevo NH[57][0-9][ER][ACDH]Q", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10412 	SND_PCI_QUIRK(0x1558, 0x8560, "Clevo NH[57][0-9][ER][ACDH]Q", ALC269_FIXUP_HEADSET_MIC),
10413 	SND_PCI_QUIRK(0x1558, 0x8561, "Clevo NH[57][0-9][ER][ACDH]Q", ALC269_FIXUP_HEADSET_MIC),
10414 	SND_PCI_QUIRK(0x1558, 0x8562, "Clevo NH[57][0-9]RZ[Q]", ALC269_FIXUP_DMIC),
10415 	SND_PCI_QUIRK(0x1558, 0x8668, "Clevo NP50B[BE]", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10416 	SND_PCI_QUIRK(0x1558, 0x866d, "Clevo NP5[05]PN[HJK]", ALC256_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10417 	SND_PCI_QUIRK(0x1558, 0x867c, "Clevo NP7[01]PNP", ALC256_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10418 	SND_PCI_QUIRK(0x1558, 0x867d, "Clevo NP7[01]PN[HJK]", ALC256_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10419 	SND_PCI_QUIRK(0x1558, 0x8680, "Clevo NJ50LU", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10420 	SND_PCI_QUIRK(0x1558, 0x8686, "Clevo NH50[CZ]U", ALC256_FIXUP_MIC_NO_PRESENCE_AND_RESUME),
10421 	SND_PCI_QUIRK(0x1558, 0x8a20, "Clevo NH55DCQ-Y", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10422 	SND_PCI_QUIRK(0x1558, 0x8a51, "Clevo NH70RCQ-Y", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10423 	SND_PCI_QUIRK(0x1558, 0x8d50, "Clevo NH55RCQ-M", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10424 	SND_PCI_QUIRK(0x1558, 0x951d, "Clevo N950T[CDF]", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10425 	SND_PCI_QUIRK(0x1558, 0x9600, "Clevo N960K[PR]", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10426 	SND_PCI_QUIRK(0x1558, 0x961d, "Clevo N960S[CDF]", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10427 	SND_PCI_QUIRK(0x1558, 0x971d, "Clevo N970T[CDF]", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10428 	SND_PCI_QUIRK(0x1558, 0xa500, "Clevo NL5[03]RU", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10429 	SND_PCI_QUIRK(0x1558, 0xa600, "Clevo NL50NU", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10430 	SND_PCI_QUIRK(0x1558, 0xa650, "Clevo NP[567]0SN[CD]", ALC256_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10431 	SND_PCI_QUIRK(0x1558, 0xa671, "Clevo NP70SN[CDE]", ALC256_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10432 	SND_PCI_QUIRK(0x1558, 0xb018, "Clevo NP50D[BE]", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10433 	SND_PCI_QUIRK(0x1558, 0xb019, "Clevo NH77D[BE]Q", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10434 	SND_PCI_QUIRK(0x1558, 0xb022, "Clevo NH77D[DC][QW]", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10435 	SND_PCI_QUIRK(0x1558, 0xc018, "Clevo NP50D[BE]", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10436 	SND_PCI_QUIRK(0x1558, 0xc019, "Clevo NH77D[BE]Q", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10437 	SND_PCI_QUIRK(0x1558, 0xc022, "Clevo NH77[DC][QW]", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10438 	SND_PCI_QUIRK(0x17aa, 0x1036, "Lenovo P520", ALC233_FIXUP_LENOVO_MULTI_CODECS),
10439 	SND_PCI_QUIRK(0x17aa, 0x1048, "ThinkCentre Station", ALC623_FIXUP_LENOVO_THINKSTATION_P340),
10440 	SND_PCI_QUIRK(0x17aa, 0x20f2, "Thinkpad SL410/510", ALC269_FIXUP_SKU_IGNORE),
10441 	SND_PCI_QUIRK(0x17aa, 0x215e, "Thinkpad L512", ALC269_FIXUP_SKU_IGNORE),
10442 	SND_PCI_QUIRK(0x17aa, 0x21b8, "Thinkpad Edge 14", ALC269_FIXUP_SKU_IGNORE),
10443 	SND_PCI_QUIRK(0x17aa, 0x21ca, "Thinkpad L412", ALC269_FIXUP_SKU_IGNORE),
10444 	SND_PCI_QUIRK(0x17aa, 0x21e9, "Thinkpad Edge 15", ALC269_FIXUP_SKU_IGNORE),
10445 	SND_PCI_QUIRK(0x17aa, 0x21f3, "Thinkpad T430", ALC269_FIXUP_LENOVO_DOCK),
10446 	SND_PCI_QUIRK(0x17aa, 0x21f6, "Thinkpad T530", ALC269_FIXUP_LENOVO_DOCK_LIMIT_BOOST),
10447 	SND_PCI_QUIRK(0x17aa, 0x21fa, "Thinkpad X230", ALC269_FIXUP_LENOVO_DOCK),
10448 	SND_PCI_QUIRK(0x17aa, 0x21fb, "Thinkpad T430s", ALC269_FIXUP_LENOVO_DOCK),
10449 	SND_PCI_QUIRK(0x17aa, 0x2203, "Thinkpad X230 Tablet", ALC269_FIXUP_LENOVO_DOCK),
10450 	SND_PCI_QUIRK(0x17aa, 0x2208, "Thinkpad T431s", ALC269_FIXUP_LENOVO_DOCK),
10451 	SND_PCI_QUIRK(0x17aa, 0x220c, "Thinkpad T440s", ALC292_FIXUP_TPT440),
10452 	SND_PCI_QUIRK(0x17aa, 0x220e, "Thinkpad T440p", ALC292_FIXUP_TPT440_DOCK),
10453 	SND_PCI_QUIRK(0x17aa, 0x2210, "Thinkpad T540p", ALC292_FIXUP_TPT440_DOCK),
10454 	SND_PCI_QUIRK(0x17aa, 0x2211, "Thinkpad W541", ALC292_FIXUP_TPT440_DOCK),
10455 	SND_PCI_QUIRK(0x17aa, 0x2212, "Thinkpad T440", ALC292_FIXUP_TPT440_DOCK),
10456 	SND_PCI_QUIRK(0x17aa, 0x2214, "Thinkpad X240", ALC292_FIXUP_TPT440_DOCK),
10457 	SND_PCI_QUIRK(0x17aa, 0x2215, "Thinkpad", ALC269_FIXUP_LIMIT_INT_MIC_BOOST),
10458 	SND_PCI_QUIRK(0x17aa, 0x2218, "Thinkpad X1 Carbon 2nd", ALC292_FIXUP_TPT440_DOCK),
10459 	SND_PCI_QUIRK(0x17aa, 0x2223, "ThinkPad T550", ALC292_FIXUP_TPT440_DOCK),
10460 	SND_PCI_QUIRK(0x17aa, 0x2226, "ThinkPad X250", ALC292_FIXUP_TPT440_DOCK),
10461 	SND_PCI_QUIRK(0x17aa, 0x222d, "Thinkpad", ALC298_FIXUP_TPT470_DOCK),
10462 	SND_PCI_QUIRK(0x17aa, 0x222e, "Thinkpad", ALC298_FIXUP_TPT470_DOCK),
10463 	SND_PCI_QUIRK(0x17aa, 0x2231, "Thinkpad T560", ALC292_FIXUP_TPT460),
10464 	SND_PCI_QUIRK(0x17aa, 0x2233, "Thinkpad", ALC292_FIXUP_TPT460),
10465 	SND_PCI_QUIRK(0x17aa, 0x2234, "Thinkpad ICE-1", ALC287_FIXUP_TAS2781_I2C),
10466 	SND_PCI_QUIRK(0x17aa, 0x2245, "Thinkpad T470", ALC298_FIXUP_TPT470_DOCK),
10467 	SND_PCI_QUIRK(0x17aa, 0x2246, "Thinkpad", ALC298_FIXUP_TPT470_DOCK),
10468 	SND_PCI_QUIRK(0x17aa, 0x2247, "Thinkpad", ALC298_FIXUP_TPT470_DOCK),
10469 	SND_PCI_QUIRK(0x17aa, 0x2249, "Thinkpad", ALC292_FIXUP_TPT460),
10470 	SND_PCI_QUIRK(0x17aa, 0x224b, "Thinkpad", ALC298_FIXUP_TPT470_DOCK),
10471 	SND_PCI_QUIRK(0x17aa, 0x224c, "Thinkpad", ALC298_FIXUP_TPT470_DOCK),
10472 	SND_PCI_QUIRK(0x17aa, 0x224d, "Thinkpad", ALC298_FIXUP_TPT470_DOCK),
10473 	SND_PCI_QUIRK(0x17aa, 0x225d, "Thinkpad T480", ALC269_FIXUP_LIMIT_INT_MIC_BOOST),
10474 	SND_PCI_QUIRK(0x17aa, 0x2292, "Thinkpad X1 Carbon 7th", ALC285_FIXUP_THINKPAD_HEADSET_JACK),
10475 	SND_PCI_QUIRK(0x17aa, 0x22be, "Thinkpad X1 Carbon 8th", ALC285_FIXUP_THINKPAD_HEADSET_JACK),
10476 	SND_PCI_QUIRK(0x17aa, 0x22c1, "Thinkpad P1 Gen 3", ALC285_FIXUP_THINKPAD_NO_BASS_SPK_HEADSET_JACK),
10477 	SND_PCI_QUIRK(0x17aa, 0x22c2, "Thinkpad X1 Extreme Gen 3", ALC285_FIXUP_THINKPAD_NO_BASS_SPK_HEADSET_JACK),
10478 	SND_PCI_QUIRK(0x17aa, 0x22f1, "Thinkpad", ALC287_FIXUP_MG_RTKC_CSAMP_CS35L41_I2C_THINKPAD),
10479 	SND_PCI_QUIRK(0x17aa, 0x22f2, "Thinkpad", ALC287_FIXUP_MG_RTKC_CSAMP_CS35L41_I2C_THINKPAD),
10480 	SND_PCI_QUIRK(0x17aa, 0x22f3, "Thinkpad", ALC287_FIXUP_MG_RTKC_CSAMP_CS35L41_I2C_THINKPAD),
10481 	SND_PCI_QUIRK(0x17aa, 0x2316, "Thinkpad P1 Gen 6", ALC287_FIXUP_MG_RTKC_CSAMP_CS35L41_I2C_THINKPAD),
10482 	SND_PCI_QUIRK(0x17aa, 0x2317, "Thinkpad P1 Gen 6", ALC287_FIXUP_MG_RTKC_CSAMP_CS35L41_I2C_THINKPAD),
10483 	SND_PCI_QUIRK(0x17aa, 0x2318, "Thinkpad Z13 Gen2", ALC287_FIXUP_MG_RTKC_CSAMP_CS35L41_I2C_THINKPAD),
10484 	SND_PCI_QUIRK(0x17aa, 0x2319, "Thinkpad Z16 Gen2", ALC287_FIXUP_MG_RTKC_CSAMP_CS35L41_I2C_THINKPAD),
10485 	SND_PCI_QUIRK(0x17aa, 0x231a, "Thinkpad Z16 Gen2", ALC287_FIXUP_MG_RTKC_CSAMP_CS35L41_I2C_THINKPAD),
10486 	SND_PCI_QUIRK(0x17aa, 0x231e, "Thinkpad", ALC287_FIXUP_LENOVO_THKPAD_WH_ALC1318),
10487 	SND_PCI_QUIRK(0x17aa, 0x231f, "Thinkpad", ALC287_FIXUP_LENOVO_THKPAD_WH_ALC1318),
10488 	SND_PCI_QUIRK(0x17aa, 0x30bb, "ThinkCentre AIO", ALC233_FIXUP_LENOVO_LINE2_MIC_HOTKEY),
10489 	SND_PCI_QUIRK(0x17aa, 0x30e2, "ThinkCentre AIO", ALC233_FIXUP_LENOVO_LINE2_MIC_HOTKEY),
10490 	SND_PCI_QUIRK(0x17aa, 0x310c, "ThinkCentre Station", ALC294_FIXUP_LENOVO_MIC_LOCATION),
10491 	SND_PCI_QUIRK(0x17aa, 0x3111, "ThinkCentre Station", ALC294_FIXUP_LENOVO_MIC_LOCATION),
10492 	SND_PCI_QUIRK(0x17aa, 0x312a, "ThinkCentre Station", ALC294_FIXUP_LENOVO_MIC_LOCATION),
10493 	SND_PCI_QUIRK(0x17aa, 0x312f, "ThinkCentre Station", ALC294_FIXUP_LENOVO_MIC_LOCATION),
10494 	SND_PCI_QUIRK(0x17aa, 0x313c, "ThinkCentre Station", ALC294_FIXUP_LENOVO_MIC_LOCATION),
10495 	SND_PCI_QUIRK(0x17aa, 0x3151, "ThinkCentre Station", ALC283_FIXUP_HEADSET_MIC),
10496 	SND_PCI_QUIRK(0x17aa, 0x3176, "ThinkCentre Station", ALC283_FIXUP_HEADSET_MIC),
10497 	SND_PCI_QUIRK(0x17aa, 0x3178, "ThinkCentre Station", ALC283_FIXUP_HEADSET_MIC),
10498 	SND_PCI_QUIRK(0x17aa, 0x31af, "ThinkCentre Station", ALC623_FIXUP_LENOVO_THINKSTATION_P340),
10499 	SND_PCI_QUIRK(0x17aa, 0x334b, "Lenovo ThinkCentre M70 Gen5", ALC283_FIXUP_HEADSET_MIC),
10500 	SND_PCI_QUIRK(0x17aa, 0x3801, "Lenovo Yoga9 14IAP7", ALC287_FIXUP_YOGA9_14IAP7_BASS_SPK_PIN),
10501 	SND_PCI_QUIRK(0x17aa, 0x3802, "Lenovo Yoga Pro 9 14IRP8 / DuetITL 2021", ALC287_FIXUP_LENOVO_14IRP8_DUETITL),
10502 	SND_PCI_QUIRK(0x17aa, 0x3813, "Legion 7i 15IMHG05", ALC287_FIXUP_LEGION_15IMHG05_SPEAKERS),
10503 	SND_PCI_QUIRK(0x17aa, 0x3818, "Lenovo C940 / Yoga Duet 7", ALC298_FIXUP_LENOVO_C940_DUET7),
10504 	SND_PCI_QUIRK(0x17aa, 0x3819, "Lenovo 13s Gen2 ITL", ALC287_FIXUP_13S_GEN2_SPEAKERS),
10505 	SND_PCI_QUIRK(0x17aa, 0x3820, "Yoga Duet 7 13ITL6", ALC287_FIXUP_YOGA7_14ITL_SPEAKERS),
10506 	SND_PCI_QUIRK(0x17aa, 0x3824, "Legion Y9000X 2020", ALC285_FIXUP_LEGION_Y9000X_SPEAKERS),
10507 	SND_PCI_QUIRK(0x17aa, 0x3827, "Ideapad S740", ALC285_FIXUP_IDEAPAD_S740_COEF),
10508 	SND_PCI_QUIRK(0x17aa, 0x3834, "Lenovo IdeaPad Slim 9i 14ITL5", ALC287_FIXUP_YOGA7_14ITL_SPEAKERS),
10509 	SND_PCI_QUIRK(0x17aa, 0x383d, "Legion Y9000X 2019", ALC285_FIXUP_LEGION_Y9000X_SPEAKERS),
10510 	SND_PCI_QUIRK(0x17aa, 0x3843, "Yoga 9i", ALC287_FIXUP_IDEAPAD_BASS_SPK_AMP),
10511 	SND_PCI_QUIRK(0x17aa, 0x3847, "Legion 7 16ACHG6", ALC287_FIXUP_LEGION_16ACHG6),
10512 	SND_PCI_QUIRK(0x17aa, 0x384a, "Lenovo Yoga 7 15ITL5", ALC287_FIXUP_YOGA7_14ITL_SPEAKERS),
10513 	SND_PCI_QUIRK(0x17aa, 0x3852, "Lenovo Yoga 7 14ITL5", ALC287_FIXUP_YOGA7_14ITL_SPEAKERS),
10514 	SND_PCI_QUIRK(0x17aa, 0x3853, "Lenovo Yoga 7 15ITL5", ALC287_FIXUP_YOGA7_14ITL_SPEAKERS),
10515 	SND_PCI_QUIRK(0x17aa, 0x3855, "Legion 7 16ITHG6", ALC287_FIXUP_LEGION_16ITHG6),
10516 	SND_PCI_QUIRK(0x17aa, 0x3865, "Lenovo 13X", ALC287_FIXUP_CS35L41_I2C_2),
10517 	SND_PCI_QUIRK(0x17aa, 0x3866, "Lenovo 13X", ALC287_FIXUP_CS35L41_I2C_2),
10518 	SND_PCI_QUIRK(0x17aa, 0x3869, "Lenovo Yoga7 14IAL7", ALC287_FIXUP_YOGA9_14IAP7_BASS_SPK_PIN),
10519 	SND_PCI_QUIRK(0x17aa, 0x386e, "Legion Y9000X 2022 IAH7", ALC287_FIXUP_CS35L41_I2C_2),
10520 	SND_PCI_QUIRK(0x17aa, 0x386f, "Legion Pro 7/7i", ALC287_FIXUP_LENOVO_LEGION_7),
10521 	SND_PCI_QUIRK(0x17aa, 0x3870, "Lenovo Yoga 7 14ARB7", ALC287_FIXUP_YOGA7_14ARB7_I2C),
10522 	SND_PCI_QUIRK(0x17aa, 0x3877, "Lenovo Legion 7 Slim 16ARHA7", ALC287_FIXUP_CS35L41_I2C_2),
10523 	SND_PCI_QUIRK(0x17aa, 0x3878, "Lenovo Legion 7 Slim 16ARHA7", ALC287_FIXUP_CS35L41_I2C_2),
10524 	SND_PCI_QUIRK(0x17aa, 0x387d, "Yoga S780-16 pro Quad AAC", ALC287_FIXUP_TAS2781_I2C),
10525 	SND_PCI_QUIRK(0x17aa, 0x387e, "Yoga S780-16 pro Quad YC", ALC287_FIXUP_TAS2781_I2C),
10526 	SND_PCI_QUIRK(0x17aa, 0x3881, "YB9 dual power mode2 YC", ALC287_FIXUP_TAS2781_I2C),
10527 	SND_PCI_QUIRK(0x17aa, 0x3882, "Lenovo Yoga Pro 7 14APH8", ALC287_FIXUP_YOGA9_14IAP7_BASS_SPK_PIN),
10528 	SND_PCI_QUIRK(0x17aa, 0x3884, "Y780 YG DUAL", ALC287_FIXUP_TAS2781_I2C),
10529 	SND_PCI_QUIRK(0x17aa, 0x3886, "Y780 VECO DUAL", ALC287_FIXUP_TAS2781_I2C),
10530 	SND_PCI_QUIRK(0x17aa, 0x38a7, "Y780P AMD YG dual", ALC287_FIXUP_TAS2781_I2C),
10531 	SND_PCI_QUIRK(0x17aa, 0x38a8, "Y780P AMD VECO dual", ALC287_FIXUP_TAS2781_I2C),
10532 	SND_PCI_QUIRK(0x17aa, 0x38a9, "Thinkbook 16P", ALC287_FIXUP_MG_RTKC_CSAMP_CS35L41_I2C_THINKPAD),
10533 	SND_PCI_QUIRK(0x17aa, 0x38ab, "Thinkbook 16P", ALC287_FIXUP_MG_RTKC_CSAMP_CS35L41_I2C_THINKPAD),
10534 	SND_PCI_QUIRK(0x17aa, 0x38b4, "Legion Slim 7 16IRH8", ALC287_FIXUP_CS35L41_I2C_2),
10535 	SND_PCI_QUIRK(0x17aa, 0x38b5, "Legion Slim 7 16IRH8", ALC287_FIXUP_CS35L41_I2C_2),
10536 	SND_PCI_QUIRK(0x17aa, 0x38b6, "Legion Slim 7 16APH8", ALC287_FIXUP_CS35L41_I2C_2),
10537 	SND_PCI_QUIRK(0x17aa, 0x38b7, "Legion Slim 7 16APH8", ALC287_FIXUP_CS35L41_I2C_2),
10538 	SND_PCI_QUIRK(0x17aa, 0x38ba, "Yoga S780-14.5 Air AMD quad YC", ALC287_FIXUP_TAS2781_I2C),
10539 	SND_PCI_QUIRK(0x17aa, 0x38bb, "Yoga S780-14.5 Air AMD quad AAC", ALC287_FIXUP_TAS2781_I2C),
10540 	SND_PCI_QUIRK(0x17aa, 0x38be, "Yoga S980-14.5 proX YC Dual", ALC287_FIXUP_TAS2781_I2C),
10541 	SND_PCI_QUIRK(0x17aa, 0x38bf, "Yoga S980-14.5 proX LX Dual", ALC287_FIXUP_TAS2781_I2C),
10542 	SND_PCI_QUIRK(0x17aa, 0x38c3, "Y980 DUAL", ALC287_FIXUP_TAS2781_I2C),
10543 	SND_PCI_QUIRK(0x17aa, 0x38cb, "Y790 YG DUAL", ALC287_FIXUP_TAS2781_I2C),
10544 	SND_PCI_QUIRK(0x17aa, 0x38cd, "Y790 VECO DUAL", ALC287_FIXUP_TAS2781_I2C),
10545 	SND_PCI_QUIRK(0x17aa, 0x38d2, "Lenovo Yoga 9 14IMH9", ALC287_FIXUP_YOGA9_14IMH9_BASS_SPK_PIN),
10546 	SND_PCI_QUIRK(0x17aa, 0x38d7, "Lenovo Yoga 9 14IMH9", ALC287_FIXUP_YOGA9_14IMH9_BASS_SPK_PIN),
10547 	SND_PCI_QUIRK(0x17aa, 0x3902, "Lenovo E50-80", ALC269_FIXUP_DMIC_THINKPAD_ACPI),
10548 	SND_PCI_QUIRK(0x17aa, 0x3977, "IdeaPad S210", ALC283_FIXUP_INT_MIC),
10549 	SND_PCI_QUIRK(0x17aa, 0x3978, "Lenovo B50-70", ALC269_FIXUP_DMIC_THINKPAD_ACPI),
10550 	SND_PCI_QUIRK(0x17aa, 0x3bf8, "Quanta FL1", ALC269_FIXUP_PCM_44K),
10551 	SND_PCI_QUIRK(0x17aa, 0x5013, "Thinkpad", ALC269_FIXUP_LIMIT_INT_MIC_BOOST),
10552 	SND_PCI_QUIRK(0x17aa, 0x501a, "Thinkpad", ALC283_FIXUP_INT_MIC),
10553 	SND_PCI_QUIRK(0x17aa, 0x501e, "Thinkpad L440", ALC292_FIXUP_TPT440_DOCK),
10554 	SND_PCI_QUIRK(0x17aa, 0x5026, "Thinkpad", ALC269_FIXUP_LIMIT_INT_MIC_BOOST),
10555 	SND_PCI_QUIRK(0x17aa, 0x5034, "Thinkpad T450", ALC292_FIXUP_TPT440_DOCK),
10556 	SND_PCI_QUIRK(0x17aa, 0x5036, "Thinkpad T450s", ALC292_FIXUP_TPT440_DOCK),
10557 	SND_PCI_QUIRK(0x17aa, 0x503c, "Thinkpad L450", ALC292_FIXUP_TPT440_DOCK),
10558 	SND_PCI_QUIRK(0x17aa, 0x504a, "ThinkPad X260", ALC292_FIXUP_TPT440_DOCK),
10559 	SND_PCI_QUIRK(0x17aa, 0x504b, "Thinkpad", ALC293_FIXUP_LENOVO_SPK_NOISE),
10560 	SND_PCI_QUIRK(0x17aa, 0x5050, "Thinkpad T560p", ALC292_FIXUP_TPT460),
10561 	SND_PCI_QUIRK(0x17aa, 0x5051, "Thinkpad L460", ALC292_FIXUP_TPT460),
10562 	SND_PCI_QUIRK(0x17aa, 0x5053, "Thinkpad T460", ALC292_FIXUP_TPT460),
10563 	SND_PCI_QUIRK(0x17aa, 0x505d, "Thinkpad", ALC298_FIXUP_TPT470_DOCK),
10564 	SND_PCI_QUIRK(0x17aa, 0x505f, "Thinkpad", ALC298_FIXUP_TPT470_DOCK),
10565 	SND_PCI_QUIRK(0x17aa, 0x5062, "Thinkpad", ALC298_FIXUP_TPT470_DOCK),
10566 	SND_PCI_QUIRK(0x17aa, 0x508b, "Thinkpad X12 Gen 1", ALC287_FIXUP_LEGION_15IMHG05_SPEAKERS),
10567 	SND_PCI_QUIRK(0x17aa, 0x5109, "Thinkpad", ALC269_FIXUP_LIMIT_INT_MIC_BOOST),
10568 	SND_PCI_QUIRK(0x17aa, 0x511e, "Thinkpad", ALC298_FIXUP_TPT470_DOCK),
10569 	SND_PCI_QUIRK(0x17aa, 0x511f, "Thinkpad", ALC298_FIXUP_TPT470_DOCK),
10570 	SND_PCI_QUIRK(0x17aa, 0x9e54, "LENOVO NB", ALC269_FIXUP_LENOVO_EAPD),
10571 	SND_PCI_QUIRK(0x17aa, 0x9e56, "Lenovo ZhaoYang CF4620Z", ALC286_FIXUP_SONY_MIC_NO_PRESENCE),
10572 	SND_PCI_QUIRK(0x1849, 0x1233, "ASRock NUC Box 1100", ALC233_FIXUP_NO_AUDIO_JACK),
10573 	SND_PCI_QUIRK(0x1849, 0xa233, "Positivo Master C6300", ALC269_FIXUP_HEADSET_MIC),
10574 	SND_PCI_QUIRK(0x1854, 0x0440, "LG CQ6", ALC256_FIXUP_HEADPHONE_AMP_VOL),
10575 	SND_PCI_QUIRK(0x1854, 0x0441, "LG CQ6 AIO", ALC256_FIXUP_HEADPHONE_AMP_VOL),
10576 	SND_PCI_QUIRK(0x19e5, 0x3204, "Huawei MACH-WX9", ALC256_FIXUP_HUAWEI_MACH_WX9_PINS),
10577 	SND_PCI_QUIRK(0x19e5, 0x320f, "Huawei WRT-WX9 ", ALC256_FIXUP_ASUS_MIC_NO_PRESENCE),
10578 	SND_PCI_QUIRK(0x1b35, 0x1235, "CZC B20", ALC269_FIXUP_CZC_B20),
10579 	SND_PCI_QUIRK(0x1b35, 0x1236, "CZC TMI", ALC269_FIXUP_CZC_TMI),
10580 	SND_PCI_QUIRK(0x1b35, 0x1237, "CZC L101", ALC269_FIXUP_CZC_L101),
10581 	SND_PCI_QUIRK(0x1b7d, 0xa831, "Ordissimo EVE2 ", ALC269VB_FIXUP_ORDISSIMO_EVE2), /* Also known as Malata PC-B1303 */
10582 	SND_PCI_QUIRK(0x1c06, 0x2013, "Lemote A1802", ALC269_FIXUP_LEMOTE_A1802),
10583 	SND_PCI_QUIRK(0x1c06, 0x2015, "Lemote A190X", ALC269_FIXUP_LEMOTE_A190X),
10584 	SND_PCI_QUIRK(0x1c6c, 0x1251, "Positivo N14KP6-TG", ALC288_FIXUP_DELL1_MIC_NO_PRESENCE),
10585 	SND_PCI_QUIRK(0x1d05, 0x1132, "TongFang PHxTxX1", ALC256_FIXUP_SET_COEF_DEFAULTS),
10586 	SND_PCI_QUIRK(0x1d05, 0x1096, "TongFang GMxMRxx", ALC269_FIXUP_NO_SHUTUP),
10587 	SND_PCI_QUIRK(0x1d05, 0x1100, "TongFang GKxNRxx", ALC269_FIXUP_NO_SHUTUP),
10588 	SND_PCI_QUIRK(0x1d05, 0x1111, "TongFang GMxZGxx", ALC269_FIXUP_NO_SHUTUP),
10589 	SND_PCI_QUIRK(0x1d05, 0x1119, "TongFang GMxZGxx", ALC269_FIXUP_NO_SHUTUP),
10590 	SND_PCI_QUIRK(0x1d05, 0x1129, "TongFang GMxZGxx", ALC269_FIXUP_NO_SHUTUP),
10591 	SND_PCI_QUIRK(0x1d05, 0x1147, "TongFang GMxTGxx", ALC269_FIXUP_NO_SHUTUP),
10592 	SND_PCI_QUIRK(0x1d05, 0x115c, "TongFang GMxTGxx", ALC269_FIXUP_NO_SHUTUP),
10593 	SND_PCI_QUIRK(0x1d05, 0x121b, "TongFang GMxAGxx", ALC269_FIXUP_NO_SHUTUP),
10594 	SND_PCI_QUIRK(0x1d05, 0x1387, "TongFang GMxIXxx", ALC2XX_FIXUP_HEADSET_MIC),
10595 	SND_PCI_QUIRK(0x1d17, 0x3288, "Haier Boyue G42", ALC269VC_FIXUP_ACER_VCOPPERBOX_PINS),
10596 	SND_PCI_QUIRK(0x1d72, 0x1602, "RedmiBook", ALC255_FIXUP_XIAOMI_HEADSET_MIC),
10597 	SND_PCI_QUIRK(0x1d72, 0x1701, "XiaomiNotebook Pro", ALC298_FIXUP_DELL1_MIC_NO_PRESENCE),
10598 	SND_PCI_QUIRK(0x1d72, 0x1901, "RedmiBook 14", ALC256_FIXUP_ASUS_HEADSET_MIC),
10599 	SND_PCI_QUIRK(0x1d72, 0x1945, "Redmi G", ALC256_FIXUP_ASUS_HEADSET_MIC),
10600 	SND_PCI_QUIRK(0x1d72, 0x1947, "RedmiBook Air", ALC255_FIXUP_XIAOMI_HEADSET_MIC),
10601 	SND_PCI_QUIRK(0x2782, 0x0232, "CHUWI CoreBook XPro", ALC269VB_FIXUP_CHUWI_COREBOOK_XPRO),
10602 	SND_PCI_QUIRK(0x2782, 0x1707, "Vaio VJFE-ADL", ALC298_FIXUP_SPK_VOLUME),
10603 	SND_PCI_QUIRK(0x8086, 0x2074, "Intel NUC 8", ALC233_FIXUP_INTEL_NUC8_DMIC),
10604 	SND_PCI_QUIRK(0x8086, 0x2080, "Intel NUC 8 Rugged", ALC256_FIXUP_INTEL_NUC8_RUGGED),
10605 	SND_PCI_QUIRK(0x8086, 0x2081, "Intel NUC 10", ALC256_FIXUP_INTEL_NUC10),
10606 	SND_PCI_QUIRK(0x8086, 0x3038, "Intel NUC 13", ALC295_FIXUP_CHROME_BOOK),
10607 	SND_PCI_QUIRK(0xf111, 0x0001, "Framework Laptop", ALC295_FIXUP_FRAMEWORK_LAPTOP_MIC_NO_PRESENCE),
10608 	SND_PCI_QUIRK(0xf111, 0x0005, "Framework Laptop", ALC295_FIXUP_FRAMEWORK_LAPTOP_MIC_NO_PRESENCE),
10609 	SND_PCI_QUIRK(0xf111, 0x0006, "Framework Laptop", ALC295_FIXUP_FRAMEWORK_LAPTOP_MIC_NO_PRESENCE),
10610 
10611 #if 0
10612 	/* Below is a quirk table taken from the old code.
10613 	 * Basically the device should work as is without the fixup table.
10614 	 * If BIOS doesn't give a proper info, enable the corresponding
10615 	 * fixup entry.
10616 	 */
10617 	SND_PCI_QUIRK(0x1043, 0x8330, "ASUS Eeepc P703 P900A",
10618 		      ALC269_FIXUP_AMIC),
10619 	SND_PCI_QUIRK(0x1043, 0x1013, "ASUS N61Da", ALC269_FIXUP_AMIC),
10620 	SND_PCI_QUIRK(0x1043, 0x1143, "ASUS B53f", ALC269_FIXUP_AMIC),
10621 	SND_PCI_QUIRK(0x1043, 0x1133, "ASUS UJ20ft", ALC269_FIXUP_AMIC),
10622 	SND_PCI_QUIRK(0x1043, 0x1183, "ASUS K72DR", ALC269_FIXUP_AMIC),
10623 	SND_PCI_QUIRK(0x1043, 0x11b3, "ASUS K52DR", ALC269_FIXUP_AMIC),
10624 	SND_PCI_QUIRK(0x1043, 0x11e3, "ASUS U33Jc", ALC269_FIXUP_AMIC),
10625 	SND_PCI_QUIRK(0x1043, 0x1273, "ASUS UL80Jt", ALC269_FIXUP_AMIC),
10626 	SND_PCI_QUIRK(0x1043, 0x1283, "ASUS U53Jc", ALC269_FIXUP_AMIC),
10627 	SND_PCI_QUIRK(0x1043, 0x12b3, "ASUS N82JV", ALC269_FIXUP_AMIC),
10628 	SND_PCI_QUIRK(0x1043, 0x12d3, "ASUS N61Jv", ALC269_FIXUP_AMIC),
10629 	SND_PCI_QUIRK(0x1043, 0x13a3, "ASUS UL30Vt", ALC269_FIXUP_AMIC),
10630 	SND_PCI_QUIRK(0x1043, 0x1373, "ASUS G73JX", ALC269_FIXUP_AMIC),
10631 	SND_PCI_QUIRK(0x1043, 0x1383, "ASUS UJ30Jc", ALC269_FIXUP_AMIC),
10632 	SND_PCI_QUIRK(0x1043, 0x13d3, "ASUS N61JA", ALC269_FIXUP_AMIC),
10633 	SND_PCI_QUIRK(0x1043, 0x1413, "ASUS UL50", ALC269_FIXUP_AMIC),
10634 	SND_PCI_QUIRK(0x1043, 0x1443, "ASUS UL30", ALC269_FIXUP_AMIC),
10635 	SND_PCI_QUIRK(0x1043, 0x1453, "ASUS M60Jv", ALC269_FIXUP_AMIC),
10636 	SND_PCI_QUIRK(0x1043, 0x1483, "ASUS UL80", ALC269_FIXUP_AMIC),
10637 	SND_PCI_QUIRK(0x1043, 0x14f3, "ASUS F83Vf", ALC269_FIXUP_AMIC),
10638 	SND_PCI_QUIRK(0x1043, 0x14e3, "ASUS UL20", ALC269_FIXUP_AMIC),
10639 	SND_PCI_QUIRK(0x1043, 0x1513, "ASUS UX30", ALC269_FIXUP_AMIC),
10640 	SND_PCI_QUIRK(0x1043, 0x1593, "ASUS N51Vn", ALC269_FIXUP_AMIC),
10641 	SND_PCI_QUIRK(0x1043, 0x15a3, "ASUS N60Jv", ALC269_FIXUP_AMIC),
10642 	SND_PCI_QUIRK(0x1043, 0x15b3, "ASUS N60Dp", ALC269_FIXUP_AMIC),
10643 	SND_PCI_QUIRK(0x1043, 0x15c3, "ASUS N70De", ALC269_FIXUP_AMIC),
10644 	SND_PCI_QUIRK(0x1043, 0x15e3, "ASUS F83T", ALC269_FIXUP_AMIC),
10645 	SND_PCI_QUIRK(0x1043, 0x1643, "ASUS M60J", ALC269_FIXUP_AMIC),
10646 	SND_PCI_QUIRK(0x1043, 0x1653, "ASUS U50", ALC269_FIXUP_AMIC),
10647 	SND_PCI_QUIRK(0x1043, 0x1693, "ASUS F50N", ALC269_FIXUP_AMIC),
10648 	SND_PCI_QUIRK(0x1043, 0x16a3, "ASUS F5Q", ALC269_FIXUP_AMIC),
10649 	SND_PCI_QUIRK(0x1043, 0x1723, "ASUS P80", ALC269_FIXUP_AMIC),
10650 	SND_PCI_QUIRK(0x1043, 0x1743, "ASUS U80", ALC269_FIXUP_AMIC),
10651 	SND_PCI_QUIRK(0x1043, 0x1773, "ASUS U20A", ALC269_FIXUP_AMIC),
10652 	SND_PCI_QUIRK(0x1043, 0x1883, "ASUS F81Se", ALC269_FIXUP_AMIC),
10653 	SND_PCI_QUIRK(0x152d, 0x1778, "Quanta ON1", ALC269_FIXUP_DMIC),
10654 	SND_PCI_QUIRK(0x17aa, 0x3be9, "Quanta Wistron", ALC269_FIXUP_AMIC),
10655 	SND_PCI_QUIRK(0x17aa, 0x3bf8, "Quanta FL1", ALC269_FIXUP_AMIC),
10656 	SND_PCI_QUIRK(0x17ff, 0x059a, "Quanta EL3", ALC269_FIXUP_DMIC),
10657 	SND_PCI_QUIRK(0x17ff, 0x059b, "Quanta JR1", ALC269_FIXUP_DMIC),
10658 #endif
10659 	{}
10660 };
10661 
10662 static const struct snd_pci_quirk alc269_fixup_vendor_tbl[] = {
10663 	SND_PCI_QUIRK_VENDOR(0x1025, "Acer Aspire", ALC271_FIXUP_DMIC),
10664 	SND_PCI_QUIRK_VENDOR(0x103c, "HP", ALC269_FIXUP_HP_MUTE_LED),
10665 	SND_PCI_QUIRK_VENDOR(0x104d, "Sony VAIO", ALC269_FIXUP_SONY_VAIO),
10666 	SND_PCI_QUIRK_VENDOR(0x17aa, "Thinkpad", ALC269_FIXUP_THINKPAD_ACPI),
10667 	SND_PCI_QUIRK_VENDOR(0x19e5, "Huawei Matebook", ALC255_FIXUP_MIC_MUTE_LED),
10668 	{}
10669 };
10670 
10671 static const struct hda_model_fixup alc269_fixup_models[] = {
10672 	{.id = ALC269_FIXUP_AMIC, .name = "laptop-amic"},
10673 	{.id = ALC269_FIXUP_DMIC, .name = "laptop-dmic"},
10674 	{.id = ALC269_FIXUP_STEREO_DMIC, .name = "alc269-dmic"},
10675 	{.id = ALC271_FIXUP_DMIC, .name = "alc271-dmic"},
10676 	{.id = ALC269_FIXUP_INV_DMIC, .name = "inv-dmic"},
10677 	{.id = ALC269_FIXUP_HEADSET_MIC, .name = "headset-mic"},
10678 	{.id = ALC269_FIXUP_HEADSET_MODE, .name = "headset-mode"},
10679 	{.id = ALC269_FIXUP_HEADSET_MODE_NO_HP_MIC, .name = "headset-mode-no-hp-mic"},
10680 	{.id = ALC269_FIXUP_LENOVO_DOCK, .name = "lenovo-dock"},
10681 	{.id = ALC269_FIXUP_LENOVO_DOCK_LIMIT_BOOST, .name = "lenovo-dock-limit-boost"},
10682 	{.id = ALC269_FIXUP_HP_GPIO_LED, .name = "hp-gpio-led"},
10683 	{.id = ALC269_FIXUP_HP_DOCK_GPIO_MIC1_LED, .name = "hp-dock-gpio-mic1-led"},
10684 	{.id = ALC269_FIXUP_DELL1_MIC_NO_PRESENCE, .name = "dell-headset-multi"},
10685 	{.id = ALC269_FIXUP_DELL2_MIC_NO_PRESENCE, .name = "dell-headset-dock"},
10686 	{.id = ALC269_FIXUP_DELL3_MIC_NO_PRESENCE, .name = "dell-headset3"},
10687 	{.id = ALC269_FIXUP_DELL4_MIC_NO_PRESENCE, .name = "dell-headset4"},
10688 	{.id = ALC283_FIXUP_CHROME_BOOK, .name = "alc283-dac-wcaps"},
10689 	{.id = ALC283_FIXUP_SENSE_COMBO_JACK, .name = "alc283-sense-combo"},
10690 	{.id = ALC292_FIXUP_TPT440_DOCK, .name = "tpt440-dock"},
10691 	{.id = ALC292_FIXUP_TPT440, .name = "tpt440"},
10692 	{.id = ALC292_FIXUP_TPT460, .name = "tpt460"},
10693 	{.id = ALC298_FIXUP_TPT470_DOCK_FIX, .name = "tpt470-dock-fix"},
10694 	{.id = ALC298_FIXUP_TPT470_DOCK, .name = "tpt470-dock"},
10695 	{.id = ALC233_FIXUP_LENOVO_MULTI_CODECS, .name = "dual-codecs"},
10696 	{.id = ALC700_FIXUP_INTEL_REFERENCE, .name = "alc700-ref"},
10697 	{.id = ALC269_FIXUP_SONY_VAIO, .name = "vaio"},
10698 	{.id = ALC269_FIXUP_DELL_M101Z, .name = "dell-m101z"},
10699 	{.id = ALC269_FIXUP_ASUS_G73JW, .name = "asus-g73jw"},
10700 	{.id = ALC269_FIXUP_LENOVO_EAPD, .name = "lenovo-eapd"},
10701 	{.id = ALC275_FIXUP_SONY_HWEQ, .name = "sony-hweq"},
10702 	{.id = ALC269_FIXUP_PCM_44K, .name = "pcm44k"},
10703 	{.id = ALC269_FIXUP_LIFEBOOK, .name = "lifebook"},
10704 	{.id = ALC269_FIXUP_LIFEBOOK_EXTMIC, .name = "lifebook-extmic"},
10705 	{.id = ALC269_FIXUP_LIFEBOOK_HP_PIN, .name = "lifebook-hp-pin"},
10706 	{.id = ALC255_FIXUP_LIFEBOOK_U7x7_HEADSET_MIC, .name = "lifebook-u7x7"},
10707 	{.id = ALC269VB_FIXUP_AMIC, .name = "alc269vb-amic"},
10708 	{.id = ALC269VB_FIXUP_DMIC, .name = "alc269vb-dmic"},
10709 	{.id = ALC269_FIXUP_HP_MUTE_LED_MIC1, .name = "hp-mute-led-mic1"},
10710 	{.id = ALC269_FIXUP_HP_MUTE_LED_MIC2, .name = "hp-mute-led-mic2"},
10711 	{.id = ALC269_FIXUP_HP_MUTE_LED_MIC3, .name = "hp-mute-led-mic3"},
10712 	{.id = ALC269_FIXUP_HP_GPIO_MIC1_LED, .name = "hp-gpio-mic1"},
10713 	{.id = ALC269_FIXUP_HP_LINE1_MIC1_LED, .name = "hp-line1-mic1"},
10714 	{.id = ALC269_FIXUP_NO_SHUTUP, .name = "noshutup"},
10715 	{.id = ALC286_FIXUP_SONY_MIC_NO_PRESENCE, .name = "sony-nomic"},
10716 	{.id = ALC269_FIXUP_ASPIRE_HEADSET_MIC, .name = "aspire-headset-mic"},
10717 	{.id = ALC269_FIXUP_ASUS_X101, .name = "asus-x101"},
10718 	{.id = ALC271_FIXUP_HP_GATE_MIC_JACK, .name = "acer-ao7xx"},
10719 	{.id = ALC271_FIXUP_HP_GATE_MIC_JACK_E1_572, .name = "acer-aspire-e1"},
10720 	{.id = ALC269_FIXUP_ACER_AC700, .name = "acer-ac700"},
10721 	{.id = ALC269_FIXUP_LIMIT_INT_MIC_BOOST, .name = "limit-mic-boost"},
10722 	{.id = ALC269VB_FIXUP_ASUS_ZENBOOK, .name = "asus-zenbook"},
10723 	{.id = ALC269VB_FIXUP_ASUS_ZENBOOK_UX31A, .name = "asus-zenbook-ux31a"},
10724 	{.id = ALC269VB_FIXUP_ORDISSIMO_EVE2, .name = "ordissimo"},
10725 	{.id = ALC282_FIXUP_ASUS_TX300, .name = "asus-tx300"},
10726 	{.id = ALC283_FIXUP_INT_MIC, .name = "alc283-int-mic"},
10727 	{.id = ALC290_FIXUP_MONO_SPEAKERS_HSJACK, .name = "mono-speakers"},
10728 	{.id = ALC290_FIXUP_SUBWOOFER_HSJACK, .name = "alc290-subwoofer"},
10729 	{.id = ALC269_FIXUP_THINKPAD_ACPI, .name = "thinkpad"},
10730 	{.id = ALC269_FIXUP_DMIC_THINKPAD_ACPI, .name = "dmic-thinkpad"},
10731 	{.id = ALC255_FIXUP_ACER_MIC_NO_PRESENCE, .name = "alc255-acer"},
10732 	{.id = ALC255_FIXUP_ASUS_MIC_NO_PRESENCE, .name = "alc255-asus"},
10733 	{.id = ALC255_FIXUP_DELL1_MIC_NO_PRESENCE, .name = "alc255-dell1"},
10734 	{.id = ALC255_FIXUP_DELL2_MIC_NO_PRESENCE, .name = "alc255-dell2"},
10735 	{.id = ALC293_FIXUP_DELL1_MIC_NO_PRESENCE, .name = "alc293-dell1"},
10736 	{.id = ALC283_FIXUP_HEADSET_MIC, .name = "alc283-headset"},
10737 	{.id = ALC255_FIXUP_MIC_MUTE_LED, .name = "alc255-dell-mute"},
10738 	{.id = ALC282_FIXUP_ASPIRE_V5_PINS, .name = "aspire-v5"},
10739 	{.id = ALC269VB_FIXUP_ASPIRE_E1_COEF, .name = "aspire-e1-coef"},
10740 	{.id = ALC280_FIXUP_HP_GPIO4, .name = "hp-gpio4"},
10741 	{.id = ALC286_FIXUP_HP_GPIO_LED, .name = "hp-gpio-led"},
10742 	{.id = ALC280_FIXUP_HP_GPIO2_MIC_HOTKEY, .name = "hp-gpio2-hotkey"},
10743 	{.id = ALC280_FIXUP_HP_DOCK_PINS, .name = "hp-dock-pins"},
10744 	{.id = ALC269_FIXUP_HP_DOCK_GPIO_MIC1_LED, .name = "hp-dock-gpio-mic"},
10745 	{.id = ALC280_FIXUP_HP_9480M, .name = "hp-9480m"},
10746 	{.id = ALC288_FIXUP_DELL_HEADSET_MODE, .name = "alc288-dell-headset"},
10747 	{.id = ALC288_FIXUP_DELL1_MIC_NO_PRESENCE, .name = "alc288-dell1"},
10748 	{.id = ALC288_FIXUP_DELL_XPS_13, .name = "alc288-dell-xps13"},
10749 	{.id = ALC292_FIXUP_DELL_E7X, .name = "dell-e7x"},
10750 	{.id = ALC293_FIXUP_DISABLE_AAMIX_MULTIJACK, .name = "alc293-dell"},
10751 	{.id = ALC298_FIXUP_DELL1_MIC_NO_PRESENCE, .name = "alc298-dell1"},
10752 	{.id = ALC298_FIXUP_DELL_AIO_MIC_NO_PRESENCE, .name = "alc298-dell-aio"},
10753 	{.id = ALC275_FIXUP_DELL_XPS, .name = "alc275-dell-xps"},
10754 	{.id = ALC293_FIXUP_LENOVO_SPK_NOISE, .name = "lenovo-spk-noise"},
10755 	{.id = ALC233_FIXUP_LENOVO_LINE2_MIC_HOTKEY, .name = "lenovo-hotkey"},
10756 	{.id = ALC255_FIXUP_DELL_SPK_NOISE, .name = "dell-spk-noise"},
10757 	{.id = ALC225_FIXUP_DELL1_MIC_NO_PRESENCE, .name = "alc225-dell1"},
10758 	{.id = ALC295_FIXUP_DISABLE_DAC3, .name = "alc295-disable-dac3"},
10759 	{.id = ALC285_FIXUP_SPEAKER2_TO_DAC1, .name = "alc285-speaker2-to-dac1"},
10760 	{.id = ALC280_FIXUP_HP_HEADSET_MIC, .name = "alc280-hp-headset"},
10761 	{.id = ALC221_FIXUP_HP_FRONT_MIC, .name = "alc221-hp-mic"},
10762 	{.id = ALC298_FIXUP_SPK_VOLUME, .name = "alc298-spk-volume"},
10763 	{.id = ALC256_FIXUP_DELL_INSPIRON_7559_SUBWOOFER, .name = "dell-inspiron-7559"},
10764 	{.id = ALC269_FIXUP_ATIV_BOOK_8, .name = "ativ-book"},
10765 	{.id = ALC221_FIXUP_HP_MIC_NO_PRESENCE, .name = "alc221-hp-mic"},
10766 	{.id = ALC256_FIXUP_ASUS_HEADSET_MODE, .name = "alc256-asus-headset"},
10767 	{.id = ALC256_FIXUP_ASUS_MIC, .name = "alc256-asus-mic"},
10768 	{.id = ALC256_FIXUP_ASUS_AIO_GPIO2, .name = "alc256-asus-aio"},
10769 	{.id = ALC233_FIXUP_ASUS_MIC_NO_PRESENCE, .name = "alc233-asus"},
10770 	{.id = ALC233_FIXUP_EAPD_COEF_AND_MIC_NO_PRESENCE, .name = "alc233-eapd"},
10771 	{.id = ALC294_FIXUP_LENOVO_MIC_LOCATION, .name = "alc294-lenovo-mic"},
10772 	{.id = ALC225_FIXUP_DELL_WYSE_MIC_NO_PRESENCE, .name = "alc225-wyse"},
10773 	{.id = ALC274_FIXUP_DELL_AIO_LINEOUT_VERB, .name = "alc274-dell-aio"},
10774 	{.id = ALC255_FIXUP_DUMMY_LINEOUT_VERB, .name = "alc255-dummy-lineout"},
10775 	{.id = ALC255_FIXUP_DELL_HEADSET_MIC, .name = "alc255-dell-headset"},
10776 	{.id = ALC295_FIXUP_HP_X360, .name = "alc295-hp-x360"},
10777 	{.id = ALC225_FIXUP_HEADSET_JACK, .name = "alc-headset-jack"},
10778 	{.id = ALC295_FIXUP_CHROME_BOOK, .name = "alc-chrome-book"},
10779 	{.id = ALC256_FIXUP_CHROME_BOOK, .name = "alc-2024y-chromebook"},
10780 	{.id = ALC299_FIXUP_PREDATOR_SPK, .name = "predator-spk"},
10781 	{.id = ALC298_FIXUP_HUAWEI_MBX_STEREO, .name = "huawei-mbx-stereo"},
10782 	{.id = ALC256_FIXUP_MEDION_HEADSET_NO_PRESENCE, .name = "alc256-medion-headset"},
10783 	{.id = ALC298_FIXUP_SAMSUNG_AMP, .name = "alc298-samsung-amp"},
10784 	{.id = ALC256_FIXUP_SAMSUNG_HEADPHONE_VERY_QUIET, .name = "alc256-samsung-headphone"},
10785 	{.id = ALC255_FIXUP_XIAOMI_HEADSET_MIC, .name = "alc255-xiaomi-headset"},
10786 	{.id = ALC274_FIXUP_HP_MIC, .name = "alc274-hp-mic-detect"},
10787 	{.id = ALC245_FIXUP_HP_X360_AMP, .name = "alc245-hp-x360-amp"},
10788 	{.id = ALC295_FIXUP_HP_OMEN, .name = "alc295-hp-omen"},
10789 	{.id = ALC285_FIXUP_HP_SPECTRE_X360, .name = "alc285-hp-spectre-x360"},
10790 	{.id = ALC285_FIXUP_HP_SPECTRE_X360_EB1, .name = "alc285-hp-spectre-x360-eb1"},
10791 	{.id = ALC285_FIXUP_HP_ENVY_X360, .name = "alc285-hp-envy-x360"},
10792 	{.id = ALC287_FIXUP_IDEAPAD_BASS_SPK_AMP, .name = "alc287-ideapad-bass-spk-amp"},
10793 	{.id = ALC287_FIXUP_YOGA9_14IAP7_BASS_SPK_PIN, .name = "alc287-yoga9-bass-spk-pin"},
10794 	{.id = ALC623_FIXUP_LENOVO_THINKSTATION_P340, .name = "alc623-lenovo-thinkstation-p340"},
10795 	{.id = ALC255_FIXUP_ACER_HEADPHONE_AND_MIC, .name = "alc255-acer-headphone-and-mic"},
10796 	{.id = ALC285_FIXUP_HP_GPIO_AMP_INIT, .name = "alc285-hp-amp-init"},
10797 	{}
10798 };
10799 #define ALC225_STANDARD_PINS \
10800 	{0x21, 0x04211020}
10801 
10802 #define ALC256_STANDARD_PINS \
10803 	{0x12, 0x90a60140}, \
10804 	{0x14, 0x90170110}, \
10805 	{0x21, 0x02211020}
10806 
10807 #define ALC282_STANDARD_PINS \
10808 	{0x14, 0x90170110}
10809 
10810 #define ALC290_STANDARD_PINS \
10811 	{0x12, 0x99a30130}
10812 
10813 #define ALC292_STANDARD_PINS \
10814 	{0x14, 0x90170110}, \
10815 	{0x15, 0x0221401f}
10816 
10817 #define ALC295_STANDARD_PINS \
10818 	{0x12, 0xb7a60130}, \
10819 	{0x14, 0x90170110}, \
10820 	{0x21, 0x04211020}
10821 
10822 #define ALC298_STANDARD_PINS \
10823 	{0x12, 0x90a60130}, \
10824 	{0x21, 0x03211020}
10825 
10826 static const struct snd_hda_pin_quirk alc269_pin_fixup_tbl[] = {
10827 	SND_HDA_PIN_QUIRK(0x10ec0221, 0x103c, "HP Workstation", ALC221_FIXUP_HP_HEADSET_MIC,
10828 		{0x14, 0x01014020},
10829 		{0x17, 0x90170110},
10830 		{0x18, 0x02a11030},
10831 		{0x19, 0x0181303F},
10832 		{0x21, 0x0221102f}),
10833 	SND_HDA_PIN_QUIRK(0x10ec0255, 0x1025, "Acer", ALC255_FIXUP_ACER_MIC_NO_PRESENCE,
10834 		{0x12, 0x90a601c0},
10835 		{0x14, 0x90171120},
10836 		{0x21, 0x02211030}),
10837 	SND_HDA_PIN_QUIRK(0x10ec0255, 0x1043, "ASUS", ALC255_FIXUP_ASUS_MIC_NO_PRESENCE,
10838 		{0x14, 0x90170110},
10839 		{0x1b, 0x90a70130},
10840 		{0x21, 0x03211020}),
10841 	SND_HDA_PIN_QUIRK(0x10ec0255, 0x1043, "ASUS", ALC255_FIXUP_ASUS_MIC_NO_PRESENCE,
10842 		{0x1a, 0x90a70130},
10843 		{0x1b, 0x90170110},
10844 		{0x21, 0x03211020}),
10845 	SND_HDA_PIN_QUIRK(0x10ec0225, 0x1028, "Dell", ALC225_FIXUP_DELL1_MIC_NO_PRESENCE,
10846 		ALC225_STANDARD_PINS,
10847 		{0x12, 0xb7a60130},
10848 		{0x14, 0x901701a0}),
10849 	SND_HDA_PIN_QUIRK(0x10ec0225, 0x1028, "Dell", ALC225_FIXUP_DELL1_MIC_NO_PRESENCE,
10850 		ALC225_STANDARD_PINS,
10851 		{0x12, 0xb7a60130},
10852 		{0x14, 0x901701b0}),
10853 	SND_HDA_PIN_QUIRK(0x10ec0225, 0x1028, "Dell", ALC225_FIXUP_DELL1_MIC_NO_PRESENCE,
10854 		ALC225_STANDARD_PINS,
10855 		{0x12, 0xb7a60150},
10856 		{0x14, 0x901701a0}),
10857 	SND_HDA_PIN_QUIRK(0x10ec0225, 0x1028, "Dell", ALC225_FIXUP_DELL1_MIC_NO_PRESENCE,
10858 		ALC225_STANDARD_PINS,
10859 		{0x12, 0xb7a60150},
10860 		{0x14, 0x901701b0}),
10861 	SND_HDA_PIN_QUIRK(0x10ec0225, 0x1028, "Dell", ALC225_FIXUP_DELL1_MIC_NO_PRESENCE,
10862 		ALC225_STANDARD_PINS,
10863 		{0x12, 0xb7a60130},
10864 		{0x1b, 0x90170110}),
10865 	SND_HDA_PIN_QUIRK(0x10ec0233, 0x8086, "Intel NUC Skull Canyon", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE,
10866 		{0x1b, 0x01111010},
10867 		{0x1e, 0x01451130},
10868 		{0x21, 0x02211020}),
10869 	SND_HDA_PIN_QUIRK(0x10ec0235, 0x17aa, "Lenovo", ALC233_FIXUP_LENOVO_LINE2_MIC_HOTKEY,
10870 		{0x12, 0x90a60140},
10871 		{0x14, 0x90170110},
10872 		{0x19, 0x02a11030},
10873 		{0x21, 0x02211020}),
10874 	SND_HDA_PIN_QUIRK(0x10ec0235, 0x17aa, "Lenovo", ALC294_FIXUP_LENOVO_MIC_LOCATION,
10875 		{0x14, 0x90170110},
10876 		{0x19, 0x02a11030},
10877 		{0x1a, 0x02a11040},
10878 		{0x1b, 0x01014020},
10879 		{0x21, 0x0221101f}),
10880 	SND_HDA_PIN_QUIRK(0x10ec0235, 0x17aa, "Lenovo", ALC294_FIXUP_LENOVO_MIC_LOCATION,
10881 		{0x14, 0x90170110},
10882 		{0x19, 0x02a11030},
10883 		{0x1a, 0x02a11040},
10884 		{0x1b, 0x01011020},
10885 		{0x21, 0x0221101f}),
10886 	SND_HDA_PIN_QUIRK(0x10ec0235, 0x17aa, "Lenovo", ALC294_FIXUP_LENOVO_MIC_LOCATION,
10887 		{0x14, 0x90170110},
10888 		{0x19, 0x02a11020},
10889 		{0x1a, 0x02a11030},
10890 		{0x21, 0x0221101f}),
10891 	SND_HDA_PIN_QUIRK(0x10ec0236, 0x1028, "Dell", ALC236_FIXUP_DELL_AIO_HEADSET_MIC,
10892 		{0x21, 0x02211010}),
10893 	SND_HDA_PIN_QUIRK(0x10ec0236, 0x103c, "HP", ALC256_FIXUP_HP_HEADSET_MIC,
10894 		{0x14, 0x90170110},
10895 		{0x19, 0x02a11020},
10896 		{0x21, 0x02211030}),
10897 	SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL2_MIC_NO_PRESENCE,
10898 		{0x14, 0x90170110},
10899 		{0x21, 0x02211020}),
10900 	SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
10901 		{0x14, 0x90170130},
10902 		{0x21, 0x02211040}),
10903 	SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
10904 		{0x12, 0x90a60140},
10905 		{0x14, 0x90170110},
10906 		{0x21, 0x02211020}),
10907 	SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
10908 		{0x12, 0x90a60160},
10909 		{0x14, 0x90170120},
10910 		{0x21, 0x02211030}),
10911 	SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
10912 		{0x14, 0x90170110},
10913 		{0x1b, 0x02011020},
10914 		{0x21, 0x0221101f}),
10915 	SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
10916 		{0x14, 0x90170110},
10917 		{0x1b, 0x01011020},
10918 		{0x21, 0x0221101f}),
10919 	SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
10920 		{0x14, 0x90170130},
10921 		{0x1b, 0x01014020},
10922 		{0x21, 0x0221103f}),
10923 	SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
10924 		{0x14, 0x90170130},
10925 		{0x1b, 0x01011020},
10926 		{0x21, 0x0221103f}),
10927 	SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
10928 		{0x14, 0x90170130},
10929 		{0x1b, 0x02011020},
10930 		{0x21, 0x0221103f}),
10931 	SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
10932 		{0x14, 0x90170150},
10933 		{0x1b, 0x02011020},
10934 		{0x21, 0x0221105f}),
10935 	SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
10936 		{0x14, 0x90170110},
10937 		{0x1b, 0x01014020},
10938 		{0x21, 0x0221101f}),
10939 	SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
10940 		{0x12, 0x90a60160},
10941 		{0x14, 0x90170120},
10942 		{0x17, 0x90170140},
10943 		{0x21, 0x0321102f}),
10944 	SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
10945 		{0x12, 0x90a60160},
10946 		{0x14, 0x90170130},
10947 		{0x21, 0x02211040}),
10948 	SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
10949 		{0x12, 0x90a60160},
10950 		{0x14, 0x90170140},
10951 		{0x21, 0x02211050}),
10952 	SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
10953 		{0x12, 0x90a60170},
10954 		{0x14, 0x90170120},
10955 		{0x21, 0x02211030}),
10956 	SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
10957 		{0x12, 0x90a60170},
10958 		{0x14, 0x90170130},
10959 		{0x21, 0x02211040}),
10960 	SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
10961 		{0x12, 0x90a60170},
10962 		{0x14, 0x90171130},
10963 		{0x21, 0x02211040}),
10964 	SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
10965 		{0x12, 0x90a60170},
10966 		{0x14, 0x90170140},
10967 		{0x21, 0x02211050}),
10968 	SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell Inspiron 5548", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
10969 		{0x12, 0x90a60180},
10970 		{0x14, 0x90170130},
10971 		{0x21, 0x02211040}),
10972 	SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell Inspiron 5565", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
10973 		{0x12, 0x90a60180},
10974 		{0x14, 0x90170120},
10975 		{0x21, 0x02211030}),
10976 	SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
10977 		{0x1b, 0x01011020},
10978 		{0x21, 0x02211010}),
10979 	SND_HDA_PIN_QUIRK(0x10ec0256, 0x1043, "ASUS", ALC256_FIXUP_ASUS_MIC,
10980 		{0x14, 0x90170110},
10981 		{0x1b, 0x90a70130},
10982 		{0x21, 0x04211020}),
10983 	SND_HDA_PIN_QUIRK(0x10ec0256, 0x1043, "ASUS", ALC256_FIXUP_ASUS_MIC,
10984 		{0x14, 0x90170110},
10985 		{0x1b, 0x90a70130},
10986 		{0x21, 0x03211020}),
10987 	SND_HDA_PIN_QUIRK(0x10ec0256, 0x1043, "ASUS", ALC256_FIXUP_ASUS_MIC_NO_PRESENCE,
10988 		{0x12, 0x90a60130},
10989 		{0x14, 0x90170110},
10990 		{0x21, 0x03211020}),
10991 	SND_HDA_PIN_QUIRK(0x10ec0256, 0x1043, "ASUS", ALC256_FIXUP_ASUS_MIC_NO_PRESENCE,
10992 		{0x12, 0x90a60130},
10993 		{0x14, 0x90170110},
10994 		{0x21, 0x04211020}),
10995 	SND_HDA_PIN_QUIRK(0x10ec0256, 0x1043, "ASUS", ALC256_FIXUP_ASUS_MIC_NO_PRESENCE,
10996 		{0x1a, 0x90a70130},
10997 		{0x1b, 0x90170110},
10998 		{0x21, 0x03211020}),
10999        SND_HDA_PIN_QUIRK(0x10ec0256, 0x103c, "HP", ALC256_FIXUP_HP_HEADSET_MIC,
11000 		{0x14, 0x90170110},
11001 		{0x19, 0x02a11020},
11002 		{0x21, 0x0221101f}),
11003        SND_HDA_PIN_QUIRK(0x10ec0274, 0x103c, "HP", ALC274_FIXUP_HP_HEADSET_MIC,
11004 		{0x17, 0x90170110},
11005 		{0x19, 0x03a11030},
11006 		{0x21, 0x03211020}),
11007 	SND_HDA_PIN_QUIRK(0x10ec0280, 0x103c, "HP", ALC280_FIXUP_HP_GPIO4,
11008 		{0x12, 0x90a60130},
11009 		{0x14, 0x90170110},
11010 		{0x15, 0x0421101f},
11011 		{0x1a, 0x04a11020}),
11012 	SND_HDA_PIN_QUIRK(0x10ec0280, 0x103c, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED,
11013 		{0x12, 0x90a60140},
11014 		{0x14, 0x90170110},
11015 		{0x15, 0x0421101f},
11016 		{0x18, 0x02811030},
11017 		{0x1a, 0x04a1103f},
11018 		{0x1b, 0x02011020}),
11019 	SND_HDA_PIN_QUIRK(0x10ec0282, 0x103c, "HP 15 Touchsmart", ALC269_FIXUP_HP_MUTE_LED_MIC1,
11020 		ALC282_STANDARD_PINS,
11021 		{0x12, 0x99a30130},
11022 		{0x19, 0x03a11020},
11023 		{0x21, 0x0321101f}),
11024 	SND_HDA_PIN_QUIRK(0x10ec0282, 0x103c, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1,
11025 		ALC282_STANDARD_PINS,
11026 		{0x12, 0x99a30130},
11027 		{0x19, 0x03a11020},
11028 		{0x21, 0x03211040}),
11029 	SND_HDA_PIN_QUIRK(0x10ec0282, 0x103c, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1,
11030 		ALC282_STANDARD_PINS,
11031 		{0x12, 0x99a30130},
11032 		{0x19, 0x03a11030},
11033 		{0x21, 0x03211020}),
11034 	SND_HDA_PIN_QUIRK(0x10ec0282, 0x103c, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1,
11035 		ALC282_STANDARD_PINS,
11036 		{0x12, 0x99a30130},
11037 		{0x19, 0x04a11020},
11038 		{0x21, 0x0421101f}),
11039 	SND_HDA_PIN_QUIRK(0x10ec0282, 0x103c, "HP", ALC269_FIXUP_HP_LINE1_MIC1_LED,
11040 		ALC282_STANDARD_PINS,
11041 		{0x12, 0x90a60140},
11042 		{0x19, 0x04a11030},
11043 		{0x21, 0x04211020}),
11044 	SND_HDA_PIN_QUIRK(0x10ec0282, 0x1025, "Acer", ALC282_FIXUP_ACER_DISABLE_LINEOUT,
11045 		ALC282_STANDARD_PINS,
11046 		{0x12, 0x90a609c0},
11047 		{0x18, 0x03a11830},
11048 		{0x19, 0x04a19831},
11049 		{0x1a, 0x0481303f},
11050 		{0x1b, 0x04211020},
11051 		{0x21, 0x0321101f}),
11052 	SND_HDA_PIN_QUIRK(0x10ec0282, 0x1025, "Acer", ALC282_FIXUP_ACER_DISABLE_LINEOUT,
11053 		ALC282_STANDARD_PINS,
11054 		{0x12, 0x90a60940},
11055 		{0x18, 0x03a11830},
11056 		{0x19, 0x04a19831},
11057 		{0x1a, 0x0481303f},
11058 		{0x1b, 0x04211020},
11059 		{0x21, 0x0321101f}),
11060 	SND_HDA_PIN_QUIRK(0x10ec0283, 0x1028, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE,
11061 		ALC282_STANDARD_PINS,
11062 		{0x12, 0x90a60130},
11063 		{0x21, 0x0321101f}),
11064 	SND_HDA_PIN_QUIRK(0x10ec0283, 0x1028, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE,
11065 		{0x12, 0x90a60160},
11066 		{0x14, 0x90170120},
11067 		{0x21, 0x02211030}),
11068 	SND_HDA_PIN_QUIRK(0x10ec0283, 0x1028, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE,
11069 		ALC282_STANDARD_PINS,
11070 		{0x12, 0x90a60130},
11071 		{0x19, 0x03a11020},
11072 		{0x21, 0x0321101f}),
11073 	SND_HDA_PIN_QUIRK(0x10ec0285, 0x17aa, "Lenovo", ALC285_FIXUP_LENOVO_PC_BEEP_IN_NOISE,
11074 		{0x12, 0x90a60130},
11075 		{0x14, 0x90170110},
11076 		{0x19, 0x04a11040},
11077 		{0x21, 0x04211020}),
11078 	SND_HDA_PIN_QUIRK(0x10ec0285, 0x17aa, "Lenovo", ALC285_FIXUP_LENOVO_PC_BEEP_IN_NOISE,
11079 		{0x14, 0x90170110},
11080 		{0x19, 0x04a11040},
11081 		{0x1d, 0x40600001},
11082 		{0x21, 0x04211020}),
11083 	SND_HDA_PIN_QUIRK(0x10ec0285, 0x17aa, "Lenovo", ALC285_FIXUP_THINKPAD_NO_BASS_SPK_HEADSET_JACK,
11084 		{0x14, 0x90170110},
11085 		{0x19, 0x04a11040},
11086 		{0x21, 0x04211020}),
11087 	SND_HDA_PIN_QUIRK(0x10ec0287, 0x17aa, "Lenovo", ALC285_FIXUP_THINKPAD_HEADSET_JACK,
11088 		{0x14, 0x90170110},
11089 		{0x17, 0x90170111},
11090 		{0x19, 0x03a11030},
11091 		{0x21, 0x03211020}),
11092 	SND_HDA_PIN_QUIRK(0x10ec0287, 0x17aa, "Lenovo", ALC287_FIXUP_THINKPAD_I2S_SPK,
11093 		{0x17, 0x90170110},
11094 		{0x19, 0x03a11030},
11095 		{0x21, 0x03211020}),
11096 	SND_HDA_PIN_QUIRK(0x10ec0287, 0x17aa, "Lenovo", ALC287_FIXUP_THINKPAD_I2S_SPK,
11097 		{0x17, 0x90170110}, /* 0x231f with RTK I2S AMP */
11098 		{0x19, 0x04a11040},
11099 		{0x21, 0x04211020}),
11100 	SND_HDA_PIN_QUIRK(0x10ec0286, 0x1025, "Acer", ALC286_FIXUP_ACER_AIO_MIC_NO_PRESENCE,
11101 		{0x12, 0x90a60130},
11102 		{0x17, 0x90170110},
11103 		{0x21, 0x02211020}),
11104 	SND_HDA_PIN_QUIRK(0x10ec0288, 0x1028, "Dell", ALC288_FIXUP_DELL1_MIC_NO_PRESENCE,
11105 		{0x12, 0x90a60120},
11106 		{0x14, 0x90170110},
11107 		{0x21, 0x0321101f}),
11108 	SND_HDA_PIN_QUIRK(0x10ec0290, 0x103c, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1,
11109 		ALC290_STANDARD_PINS,
11110 		{0x15, 0x04211040},
11111 		{0x18, 0x90170112},
11112 		{0x1a, 0x04a11020}),
11113 	SND_HDA_PIN_QUIRK(0x10ec0290, 0x103c, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1,
11114 		ALC290_STANDARD_PINS,
11115 		{0x15, 0x04211040},
11116 		{0x18, 0x90170110},
11117 		{0x1a, 0x04a11020}),
11118 	SND_HDA_PIN_QUIRK(0x10ec0290, 0x103c, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1,
11119 		ALC290_STANDARD_PINS,
11120 		{0x15, 0x0421101f},
11121 		{0x1a, 0x04a11020}),
11122 	SND_HDA_PIN_QUIRK(0x10ec0290, 0x103c, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1,
11123 		ALC290_STANDARD_PINS,
11124 		{0x15, 0x04211020},
11125 		{0x1a, 0x04a11040}),
11126 	SND_HDA_PIN_QUIRK(0x10ec0290, 0x103c, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1,
11127 		ALC290_STANDARD_PINS,
11128 		{0x14, 0x90170110},
11129 		{0x15, 0x04211020},
11130 		{0x1a, 0x04a11040}),
11131 	SND_HDA_PIN_QUIRK(0x10ec0290, 0x103c, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1,
11132 		ALC290_STANDARD_PINS,
11133 		{0x14, 0x90170110},
11134 		{0x15, 0x04211020},
11135 		{0x1a, 0x04a11020}),
11136 	SND_HDA_PIN_QUIRK(0x10ec0290, 0x103c, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1,
11137 		ALC290_STANDARD_PINS,
11138 		{0x14, 0x90170110},
11139 		{0x15, 0x0421101f},
11140 		{0x1a, 0x04a11020}),
11141 	SND_HDA_PIN_QUIRK(0x10ec0292, 0x1028, "Dell", ALC269_FIXUP_DELL2_MIC_NO_PRESENCE,
11142 		ALC292_STANDARD_PINS,
11143 		{0x12, 0x90a60140},
11144 		{0x16, 0x01014020},
11145 		{0x19, 0x01a19030}),
11146 	SND_HDA_PIN_QUIRK(0x10ec0292, 0x1028, "Dell", ALC269_FIXUP_DELL2_MIC_NO_PRESENCE,
11147 		ALC292_STANDARD_PINS,
11148 		{0x12, 0x90a60140},
11149 		{0x16, 0x01014020},
11150 		{0x18, 0x02a19031},
11151 		{0x19, 0x01a1903e}),
11152 	SND_HDA_PIN_QUIRK(0x10ec0292, 0x1028, "Dell", ALC269_FIXUP_DELL3_MIC_NO_PRESENCE,
11153 		ALC292_STANDARD_PINS,
11154 		{0x12, 0x90a60140}),
11155 	SND_HDA_PIN_QUIRK(0x10ec0293, 0x1028, "Dell", ALC293_FIXUP_DELL1_MIC_NO_PRESENCE,
11156 		ALC292_STANDARD_PINS,
11157 		{0x13, 0x90a60140},
11158 		{0x16, 0x21014020},
11159 		{0x19, 0x21a19030}),
11160 	SND_HDA_PIN_QUIRK(0x10ec0293, 0x1028, "Dell", ALC293_FIXUP_DELL1_MIC_NO_PRESENCE,
11161 		ALC292_STANDARD_PINS,
11162 		{0x13, 0x90a60140}),
11163 	SND_HDA_PIN_QUIRK(0x10ec0294, 0x1043, "ASUS", ALC294_FIXUP_ASUS_HPE,
11164 		{0x17, 0x90170110},
11165 		{0x21, 0x04211020}),
11166 	SND_HDA_PIN_QUIRK(0x10ec0294, 0x1043, "ASUS", ALC294_FIXUP_ASUS_MIC,
11167 		{0x14, 0x90170110},
11168 		{0x1b, 0x90a70130},
11169 		{0x21, 0x04211020}),
11170 	SND_HDA_PIN_QUIRK(0x10ec0294, 0x1043, "ASUS", ALC294_FIXUP_ASUS_SPK,
11171 		{0x12, 0x90a60130},
11172 		{0x17, 0x90170110},
11173 		{0x21, 0x03211020}),
11174 	SND_HDA_PIN_QUIRK(0x10ec0294, 0x1043, "ASUS", ALC294_FIXUP_ASUS_SPK,
11175 		{0x12, 0x90a60130},
11176 		{0x17, 0x90170110},
11177 		{0x21, 0x04211020}),
11178 	SND_HDA_PIN_QUIRK(0x10ec0295, 0x1043, "ASUS", ALC294_FIXUP_ASUS_SPK,
11179 		{0x12, 0x90a60130},
11180 		{0x17, 0x90170110},
11181 		{0x21, 0x03211020}),
11182 	SND_HDA_PIN_QUIRK(0x10ec0295, 0x1043, "ASUS", ALC295_FIXUP_ASUS_MIC_NO_PRESENCE,
11183 		{0x12, 0x90a60120},
11184 		{0x17, 0x90170110},
11185 		{0x21, 0x04211030}),
11186 	SND_HDA_PIN_QUIRK(0x10ec0295, 0x1043, "ASUS", ALC295_FIXUP_ASUS_MIC_NO_PRESENCE,
11187 		{0x12, 0x90a60130},
11188 		{0x17, 0x90170110},
11189 		{0x21, 0x03211020}),
11190 	SND_HDA_PIN_QUIRK(0x10ec0295, 0x1043, "ASUS", ALC295_FIXUP_ASUS_MIC_NO_PRESENCE,
11191 		{0x12, 0x90a60130},
11192 		{0x17, 0x90170110},
11193 		{0x21, 0x03211020}),
11194 	SND_HDA_PIN_QUIRK(0x10ec0298, 0x1028, "Dell", ALC298_FIXUP_DELL1_MIC_NO_PRESENCE,
11195 		ALC298_STANDARD_PINS,
11196 		{0x17, 0x90170110}),
11197 	SND_HDA_PIN_QUIRK(0x10ec0298, 0x1028, "Dell", ALC298_FIXUP_DELL1_MIC_NO_PRESENCE,
11198 		ALC298_STANDARD_PINS,
11199 		{0x17, 0x90170140}),
11200 	SND_HDA_PIN_QUIRK(0x10ec0298, 0x1028, "Dell", ALC298_FIXUP_DELL1_MIC_NO_PRESENCE,
11201 		ALC298_STANDARD_PINS,
11202 		{0x17, 0x90170150}),
11203 	SND_HDA_PIN_QUIRK(0x10ec0298, 0x1028, "Dell", ALC298_FIXUP_SPK_VOLUME,
11204 		{0x12, 0xb7a60140},
11205 		{0x13, 0xb7a60150},
11206 		{0x17, 0x90170110},
11207 		{0x1a, 0x03011020},
11208 		{0x21, 0x03211030}),
11209 	SND_HDA_PIN_QUIRK(0x10ec0298, 0x1028, "Dell", ALC298_FIXUP_ALIENWARE_MIC_NO_PRESENCE,
11210 		{0x12, 0xb7a60140},
11211 		{0x17, 0x90170110},
11212 		{0x1a, 0x03a11030},
11213 		{0x21, 0x03211020}),
11214 	SND_HDA_PIN_QUIRK(0x10ec0299, 0x1028, "Dell", ALC269_FIXUP_DELL4_MIC_NO_PRESENCE,
11215 		ALC225_STANDARD_PINS,
11216 		{0x12, 0xb7a60130},
11217 		{0x17, 0x90170110}),
11218 	SND_HDA_PIN_QUIRK(0x10ec0623, 0x17aa, "Lenovo", ALC283_FIXUP_HEADSET_MIC,
11219 		{0x14, 0x01014010},
11220 		{0x17, 0x90170120},
11221 		{0x18, 0x02a11030},
11222 		{0x19, 0x02a1103f},
11223 		{0x21, 0x0221101f}),
11224 	{}
11225 };
11226 
11227 /* This is the fallback pin_fixup_tbl for alc269 family, to make the tbl match
11228  * more machines, don't need to match all valid pins, just need to match
11229  * all the pins defined in the tbl. Just because of this reason, it is possible
11230  * that a single machine matches multiple tbls, so there is one limitation:
11231  *   at most one tbl is allowed to define for the same vendor and same codec
11232  */
11233 static const struct snd_hda_pin_quirk alc269_fallback_pin_fixup_tbl[] = {
11234 	SND_HDA_PIN_QUIRK(0x10ec0256, 0x1025, "Acer", ALC2XX_FIXUP_HEADSET_MIC,
11235 		{0x19, 0x40000000}),
11236 	SND_HDA_PIN_QUIRK(0x10ec0289, 0x1028, "Dell", ALC269_FIXUP_DELL4_MIC_NO_PRESENCE,
11237 		{0x19, 0x40000000},
11238 		{0x1b, 0x40000000}),
11239 	SND_HDA_PIN_QUIRK(0x10ec0295, 0x1028, "Dell", ALC269_FIXUP_DELL4_MIC_NO_PRESENCE,
11240 		{0x19, 0x40000000},
11241 		{0x1b, 0x40000000}),
11242 	SND_HDA_PIN_QUIRK(0x10ec0256, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
11243 		{0x19, 0x40000000},
11244 		{0x1a, 0x40000000}),
11245 	SND_HDA_PIN_QUIRK(0x10ec0236, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
11246 		{0x19, 0x40000000},
11247 		{0x1a, 0x40000000}),
11248 	SND_HDA_PIN_QUIRK(0x10ec0274, 0x1028, "Dell", ALC274_FIXUP_DELL_AIO_LINEOUT_VERB,
11249 		{0x19, 0x40000000},
11250 		{0x1a, 0x40000000}),
11251 	SND_HDA_PIN_QUIRK(0x10ec0256, 0x1043, "ASUS", ALC2XX_FIXUP_HEADSET_MIC,
11252 		{0x19, 0x40000000}),
11253 	{}
11254 };
11255 
11256 static void alc269_fill_coef(struct hda_codec *codec)
11257 {
11258 	struct alc_spec *spec = codec->spec;
11259 	int val;
11260 
11261 	if (spec->codec_variant != ALC269_TYPE_ALC269VB)
11262 		return;
11263 
11264 	if ((alc_get_coef0(codec) & 0x00ff) < 0x015) {
11265 		alc_write_coef_idx(codec, 0xf, 0x960b);
11266 		alc_write_coef_idx(codec, 0xe, 0x8817);
11267 	}
11268 
11269 	if ((alc_get_coef0(codec) & 0x00ff) == 0x016) {
11270 		alc_write_coef_idx(codec, 0xf, 0x960b);
11271 		alc_write_coef_idx(codec, 0xe, 0x8814);
11272 	}
11273 
11274 	if ((alc_get_coef0(codec) & 0x00ff) == 0x017) {
11275 		/* Power up output pin */
11276 		alc_update_coef_idx(codec, 0x04, 0, 1<<11);
11277 	}
11278 
11279 	if ((alc_get_coef0(codec) & 0x00ff) == 0x018) {
11280 		val = alc_read_coef_idx(codec, 0xd);
11281 		if (val != -1 && (val & 0x0c00) >> 10 != 0x1) {
11282 			/* Capless ramp up clock control */
11283 			alc_write_coef_idx(codec, 0xd, val | (1<<10));
11284 		}
11285 		val = alc_read_coef_idx(codec, 0x17);
11286 		if (val != -1 && (val & 0x01c0) >> 6 != 0x4) {
11287 			/* Class D power on reset */
11288 			alc_write_coef_idx(codec, 0x17, val | (1<<7));
11289 		}
11290 	}
11291 
11292 	/* HP */
11293 	alc_update_coef_idx(codec, 0x4, 0, 1<<11);
11294 }
11295 
11296 /*
11297  */
11298 static int patch_alc269(struct hda_codec *codec)
11299 {
11300 	struct alc_spec *spec;
11301 	int err;
11302 
11303 	err = alc_alloc_spec(codec, 0x0b);
11304 	if (err < 0)
11305 		return err;
11306 
11307 	spec = codec->spec;
11308 	spec->gen.shared_mic_vref_pin = 0x18;
11309 	codec->power_save_node = 0;
11310 	spec->en_3kpull_low = true;
11311 
11312 	codec->patch_ops.suspend = alc269_suspend;
11313 	codec->patch_ops.resume = alc269_resume;
11314 	spec->shutup = alc_default_shutup;
11315 	spec->init_hook = alc_default_init;
11316 
11317 	switch (codec->core.vendor_id) {
11318 	case 0x10ec0269:
11319 		spec->codec_variant = ALC269_TYPE_ALC269VA;
11320 		switch (alc_get_coef0(codec) & 0x00f0) {
11321 		case 0x0010:
11322 			if (codec->bus->pci &&
11323 			    codec->bus->pci->subsystem_vendor == 0x1025 &&
11324 			    spec->cdefine.platform_type == 1)
11325 				err = alc_codec_rename(codec, "ALC271X");
11326 			spec->codec_variant = ALC269_TYPE_ALC269VB;
11327 			break;
11328 		case 0x0020:
11329 			if (codec->bus->pci &&
11330 			    codec->bus->pci->subsystem_vendor == 0x17aa &&
11331 			    codec->bus->pci->subsystem_device == 0x21f3)
11332 				err = alc_codec_rename(codec, "ALC3202");
11333 			spec->codec_variant = ALC269_TYPE_ALC269VC;
11334 			break;
11335 		case 0x0030:
11336 			spec->codec_variant = ALC269_TYPE_ALC269VD;
11337 			break;
11338 		default:
11339 			alc_fix_pll_init(codec, 0x20, 0x04, 15);
11340 		}
11341 		if (err < 0)
11342 			goto error;
11343 		spec->shutup = alc269_shutup;
11344 		spec->init_hook = alc269_fill_coef;
11345 		alc269_fill_coef(codec);
11346 		break;
11347 
11348 	case 0x10ec0280:
11349 	case 0x10ec0290:
11350 		spec->codec_variant = ALC269_TYPE_ALC280;
11351 		break;
11352 	case 0x10ec0282:
11353 		spec->codec_variant = ALC269_TYPE_ALC282;
11354 		spec->shutup = alc282_shutup;
11355 		spec->init_hook = alc282_init;
11356 		break;
11357 	case 0x10ec0233:
11358 	case 0x10ec0283:
11359 		spec->codec_variant = ALC269_TYPE_ALC283;
11360 		spec->shutup = alc283_shutup;
11361 		spec->init_hook = alc283_init;
11362 		break;
11363 	case 0x10ec0284:
11364 	case 0x10ec0292:
11365 		spec->codec_variant = ALC269_TYPE_ALC284;
11366 		break;
11367 	case 0x10ec0293:
11368 		spec->codec_variant = ALC269_TYPE_ALC293;
11369 		break;
11370 	case 0x10ec0286:
11371 	case 0x10ec0288:
11372 		spec->codec_variant = ALC269_TYPE_ALC286;
11373 		break;
11374 	case 0x10ec0298:
11375 		spec->codec_variant = ALC269_TYPE_ALC298;
11376 		break;
11377 	case 0x10ec0235:
11378 	case 0x10ec0255:
11379 		spec->codec_variant = ALC269_TYPE_ALC255;
11380 		spec->shutup = alc256_shutup;
11381 		spec->init_hook = alc256_init;
11382 		break;
11383 	case 0x10ec0230:
11384 	case 0x10ec0236:
11385 	case 0x10ec0256:
11386 	case 0x19e58326:
11387 		spec->codec_variant = ALC269_TYPE_ALC256;
11388 		spec->shutup = alc256_shutup;
11389 		spec->init_hook = alc256_init;
11390 		spec->gen.mixer_nid = 0; /* ALC256 does not have any loopback mixer path */
11391 		if (codec->core.vendor_id == 0x10ec0236 &&
11392 		    codec->bus->pci->vendor != PCI_VENDOR_ID_AMD)
11393 			spec->en_3kpull_low = false;
11394 		break;
11395 	case 0x10ec0257:
11396 		spec->codec_variant = ALC269_TYPE_ALC257;
11397 		spec->shutup = alc256_shutup;
11398 		spec->init_hook = alc256_init;
11399 		spec->gen.mixer_nid = 0;
11400 		spec->en_3kpull_low = false;
11401 		break;
11402 	case 0x10ec0215:
11403 	case 0x10ec0245:
11404 	case 0x10ec0285:
11405 	case 0x10ec0289:
11406 		if (alc_get_coef0(codec) & 0x0010)
11407 			spec->codec_variant = ALC269_TYPE_ALC245;
11408 		else
11409 			spec->codec_variant = ALC269_TYPE_ALC215;
11410 		spec->shutup = alc225_shutup;
11411 		spec->init_hook = alc225_init;
11412 		spec->gen.mixer_nid = 0;
11413 		break;
11414 	case 0x10ec0225:
11415 	case 0x10ec0295:
11416 	case 0x10ec0299:
11417 		spec->codec_variant = ALC269_TYPE_ALC225;
11418 		spec->shutup = alc225_shutup;
11419 		spec->init_hook = alc225_init;
11420 		spec->gen.mixer_nid = 0; /* no loopback on ALC225, ALC295 and ALC299 */
11421 		break;
11422 	case 0x10ec0287:
11423 		spec->codec_variant = ALC269_TYPE_ALC287;
11424 		spec->shutup = alc225_shutup;
11425 		spec->init_hook = alc225_init;
11426 		spec->gen.mixer_nid = 0; /* no loopback on ALC287 */
11427 		break;
11428 	case 0x10ec0234:
11429 	case 0x10ec0274:
11430 	case 0x10ec0294:
11431 		spec->codec_variant = ALC269_TYPE_ALC294;
11432 		spec->gen.mixer_nid = 0; /* ALC2x4 does not have any loopback mixer path */
11433 		alc_update_coef_idx(codec, 0x6b, 0x0018, (1<<4) | (1<<3)); /* UAJ MIC Vref control by verb */
11434 		spec->init_hook = alc294_init;
11435 		break;
11436 	case 0x10ec0300:
11437 		spec->codec_variant = ALC269_TYPE_ALC300;
11438 		spec->gen.mixer_nid = 0; /* no loopback on ALC300 */
11439 		break;
11440 	case 0x10ec0623:
11441 		spec->codec_variant = ALC269_TYPE_ALC623;
11442 		break;
11443 	case 0x10ec0700:
11444 	case 0x10ec0701:
11445 	case 0x10ec0703:
11446 	case 0x10ec0711:
11447 		spec->codec_variant = ALC269_TYPE_ALC700;
11448 		spec->gen.mixer_nid = 0; /* ALC700 does not have any loopback mixer path */
11449 		alc_update_coef_idx(codec, 0x4a, 1 << 15, 0); /* Combo jack auto trigger control */
11450 		spec->init_hook = alc294_init;
11451 		break;
11452 
11453 	}
11454 
11455 	if (snd_hda_codec_read(codec, 0x51, 0, AC_VERB_PARAMETERS, 0) == 0x10ec5505) {
11456 		spec->has_alc5505_dsp = 1;
11457 		spec->init_hook = alc5505_dsp_init;
11458 	}
11459 
11460 	alc_pre_init(codec);
11461 
11462 	snd_hda_pick_fixup(codec, alc269_fixup_models,
11463 		       alc269_fixup_tbl, alc269_fixups);
11464 	/* FIXME: both TX300 and ROG Strix G17 have the same SSID, and
11465 	 * the quirk breaks the latter (bko#214101).
11466 	 * Clear the wrong entry.
11467 	 */
11468 	if (codec->fixup_id == ALC282_FIXUP_ASUS_TX300 &&
11469 	    codec->core.vendor_id == 0x10ec0294) {
11470 		codec_dbg(codec, "Clear wrong fixup for ASUS ROG Strix G17\n");
11471 		codec->fixup_id = HDA_FIXUP_ID_NOT_SET;
11472 	}
11473 
11474 	snd_hda_pick_pin_fixup(codec, alc269_pin_fixup_tbl, alc269_fixups, true);
11475 	snd_hda_pick_pin_fixup(codec, alc269_fallback_pin_fixup_tbl, alc269_fixups, false);
11476 	snd_hda_pick_fixup(codec, NULL,	alc269_fixup_vendor_tbl,
11477 			   alc269_fixups);
11478 	snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE);
11479 
11480 	alc_auto_parse_customize_define(codec);
11481 
11482 	if (has_cdefine_beep(codec))
11483 		spec->gen.beep_nid = 0x01;
11484 
11485 	/* automatic parse from the BIOS config */
11486 	err = alc269_parse_auto_config(codec);
11487 	if (err < 0)
11488 		goto error;
11489 
11490 	if (!spec->gen.no_analog && spec->gen.beep_nid && spec->gen.mixer_nid) {
11491 		err = set_beep_amp(spec, spec->gen.mixer_nid, 0x04, HDA_INPUT);
11492 		if (err < 0)
11493 			goto error;
11494 	}
11495 
11496 	snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE);
11497 
11498 	return 0;
11499 
11500  error:
11501 	alc_free(codec);
11502 	return err;
11503 }
11504 
11505 /*
11506  * ALC861
11507  */
11508 
11509 static int alc861_parse_auto_config(struct hda_codec *codec)
11510 {
11511 	static const hda_nid_t alc861_ignore[] = { 0x1d, 0 };
11512 	static const hda_nid_t alc861_ssids[] = { 0x0e, 0x0f, 0x0b, 0 };
11513 	return alc_parse_auto_config(codec, alc861_ignore, alc861_ssids);
11514 }
11515 
11516 /* Pin config fixes */
11517 enum {
11518 	ALC861_FIXUP_FSC_AMILO_PI1505,
11519 	ALC861_FIXUP_AMP_VREF_0F,
11520 	ALC861_FIXUP_NO_JACK_DETECT,
11521 	ALC861_FIXUP_ASUS_A6RP,
11522 	ALC660_FIXUP_ASUS_W7J,
11523 };
11524 
11525 /* On some laptops, VREF of pin 0x0f is abused for controlling the main amp */
11526 static void alc861_fixup_asus_amp_vref_0f(struct hda_codec *codec,
11527 			const struct hda_fixup *fix, int action)
11528 {
11529 	struct alc_spec *spec = codec->spec;
11530 	unsigned int val;
11531 
11532 	if (action != HDA_FIXUP_ACT_INIT)
11533 		return;
11534 	val = snd_hda_codec_get_pin_target(codec, 0x0f);
11535 	if (!(val & (AC_PINCTL_IN_EN | AC_PINCTL_OUT_EN)))
11536 		val |= AC_PINCTL_IN_EN;
11537 	val |= AC_PINCTL_VREF_50;
11538 	snd_hda_set_pin_ctl(codec, 0x0f, val);
11539 	spec->gen.keep_vref_in_automute = 1;
11540 }
11541 
11542 /* suppress the jack-detection */
11543 static void alc_fixup_no_jack_detect(struct hda_codec *codec,
11544 				     const struct hda_fixup *fix, int action)
11545 {
11546 	if (action == HDA_FIXUP_ACT_PRE_PROBE)
11547 		codec->no_jack_detect = 1;
11548 }
11549 
11550 static const struct hda_fixup alc861_fixups[] = {
11551 	[ALC861_FIXUP_FSC_AMILO_PI1505] = {
11552 		.type = HDA_FIXUP_PINS,
11553 		.v.pins = (const struct hda_pintbl[]) {
11554 			{ 0x0b, 0x0221101f }, /* HP */
11555 			{ 0x0f, 0x90170310 }, /* speaker */
11556 			{ }
11557 		}
11558 	},
11559 	[ALC861_FIXUP_AMP_VREF_0F] = {
11560 		.type = HDA_FIXUP_FUNC,
11561 		.v.func = alc861_fixup_asus_amp_vref_0f,
11562 	},
11563 	[ALC861_FIXUP_NO_JACK_DETECT] = {
11564 		.type = HDA_FIXUP_FUNC,
11565 		.v.func = alc_fixup_no_jack_detect,
11566 	},
11567 	[ALC861_FIXUP_ASUS_A6RP] = {
11568 		.type = HDA_FIXUP_FUNC,
11569 		.v.func = alc861_fixup_asus_amp_vref_0f,
11570 		.chained = true,
11571 		.chain_id = ALC861_FIXUP_NO_JACK_DETECT,
11572 	},
11573 	[ALC660_FIXUP_ASUS_W7J] = {
11574 		.type = HDA_FIXUP_VERBS,
11575 		.v.verbs = (const struct hda_verb[]) {
11576 			/* ASUS W7J needs a magic pin setup on unused NID 0x10
11577 			 * for enabling outputs
11578 			 */
11579 			{0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
11580 			{ }
11581 		},
11582 	}
11583 };
11584 
11585 static const struct snd_pci_quirk alc861_fixup_tbl[] = {
11586 	SND_PCI_QUIRK(0x1043, 0x1253, "ASUS W7J", ALC660_FIXUP_ASUS_W7J),
11587 	SND_PCI_QUIRK(0x1043, 0x1263, "ASUS Z35HL", ALC660_FIXUP_ASUS_W7J),
11588 	SND_PCI_QUIRK(0x1043, 0x1393, "ASUS A6Rp", ALC861_FIXUP_ASUS_A6RP),
11589 	SND_PCI_QUIRK_VENDOR(0x1043, "ASUS laptop", ALC861_FIXUP_AMP_VREF_0F),
11590 	SND_PCI_QUIRK(0x1462, 0x7254, "HP DX2200", ALC861_FIXUP_NO_JACK_DETECT),
11591 	SND_PCI_QUIRK_VENDOR(0x1584, "Haier/Uniwill", ALC861_FIXUP_AMP_VREF_0F),
11592 	SND_PCI_QUIRK(0x1734, 0x10c7, "FSC Amilo Pi1505", ALC861_FIXUP_FSC_AMILO_PI1505),
11593 	{}
11594 };
11595 
11596 /*
11597  */
11598 static int patch_alc861(struct hda_codec *codec)
11599 {
11600 	struct alc_spec *spec;
11601 	int err;
11602 
11603 	err = alc_alloc_spec(codec, 0x15);
11604 	if (err < 0)
11605 		return err;
11606 
11607 	spec = codec->spec;
11608 	if (has_cdefine_beep(codec))
11609 		spec->gen.beep_nid = 0x23;
11610 
11611 	spec->power_hook = alc_power_eapd;
11612 
11613 	alc_pre_init(codec);
11614 
11615 	snd_hda_pick_fixup(codec, NULL, alc861_fixup_tbl, alc861_fixups);
11616 	snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE);
11617 
11618 	/* automatic parse from the BIOS config */
11619 	err = alc861_parse_auto_config(codec);
11620 	if (err < 0)
11621 		goto error;
11622 
11623 	if (!spec->gen.no_analog) {
11624 		err = set_beep_amp(spec, 0x23, 0, HDA_OUTPUT);
11625 		if (err < 0)
11626 			goto error;
11627 	}
11628 
11629 	snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE);
11630 
11631 	return 0;
11632 
11633  error:
11634 	alc_free(codec);
11635 	return err;
11636 }
11637 
11638 /*
11639  * ALC861-VD support
11640  *
11641  * Based on ALC882
11642  *
11643  * In addition, an independent DAC
11644  */
11645 static int alc861vd_parse_auto_config(struct hda_codec *codec)
11646 {
11647 	static const hda_nid_t alc861vd_ignore[] = { 0x1d, 0 };
11648 	static const hda_nid_t alc861vd_ssids[] = { 0x15, 0x1b, 0x14, 0 };
11649 	return alc_parse_auto_config(codec, alc861vd_ignore, alc861vd_ssids);
11650 }
11651 
11652 enum {
11653 	ALC660VD_FIX_ASUS_GPIO1,
11654 	ALC861VD_FIX_DALLAS,
11655 };
11656 
11657 /* exclude VREF80 */
11658 static void alc861vd_fixup_dallas(struct hda_codec *codec,
11659 				  const struct hda_fixup *fix, int action)
11660 {
11661 	if (action == HDA_FIXUP_ACT_PRE_PROBE) {
11662 		snd_hda_override_pin_caps(codec, 0x18, 0x00000734);
11663 		snd_hda_override_pin_caps(codec, 0x19, 0x0000073c);
11664 	}
11665 }
11666 
11667 /* reset GPIO1 */
11668 static void alc660vd_fixup_asus_gpio1(struct hda_codec *codec,
11669 				      const struct hda_fixup *fix, int action)
11670 {
11671 	struct alc_spec *spec = codec->spec;
11672 
11673 	if (action == HDA_FIXUP_ACT_PRE_PROBE)
11674 		spec->gpio_mask |= 0x02;
11675 	alc_fixup_gpio(codec, action, 0x01);
11676 }
11677 
11678 static const struct hda_fixup alc861vd_fixups[] = {
11679 	[ALC660VD_FIX_ASUS_GPIO1] = {
11680 		.type = HDA_FIXUP_FUNC,
11681 		.v.func = alc660vd_fixup_asus_gpio1,
11682 	},
11683 	[ALC861VD_FIX_DALLAS] = {
11684 		.type = HDA_FIXUP_FUNC,
11685 		.v.func = alc861vd_fixup_dallas,
11686 	},
11687 };
11688 
11689 static const struct snd_pci_quirk alc861vd_fixup_tbl[] = {
11690 	SND_PCI_QUIRK(0x103c, 0x30bf, "HP TX1000", ALC861VD_FIX_DALLAS),
11691 	SND_PCI_QUIRK(0x1043, 0x1339, "ASUS A7-K", ALC660VD_FIX_ASUS_GPIO1),
11692 	SND_PCI_QUIRK(0x1179, 0xff31, "Toshiba L30-149", ALC861VD_FIX_DALLAS),
11693 	{}
11694 };
11695 
11696 /*
11697  */
11698 static int patch_alc861vd(struct hda_codec *codec)
11699 {
11700 	struct alc_spec *spec;
11701 	int err;
11702 
11703 	err = alc_alloc_spec(codec, 0x0b);
11704 	if (err < 0)
11705 		return err;
11706 
11707 	spec = codec->spec;
11708 	if (has_cdefine_beep(codec))
11709 		spec->gen.beep_nid = 0x23;
11710 
11711 	spec->shutup = alc_eapd_shutup;
11712 
11713 	alc_pre_init(codec);
11714 
11715 	snd_hda_pick_fixup(codec, NULL, alc861vd_fixup_tbl, alc861vd_fixups);
11716 	snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE);
11717 
11718 	/* automatic parse from the BIOS config */
11719 	err = alc861vd_parse_auto_config(codec);
11720 	if (err < 0)
11721 		goto error;
11722 
11723 	if (!spec->gen.no_analog) {
11724 		err = set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
11725 		if (err < 0)
11726 			goto error;
11727 	}
11728 
11729 	snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE);
11730 
11731 	return 0;
11732 
11733  error:
11734 	alc_free(codec);
11735 	return err;
11736 }
11737 
11738 /*
11739  * ALC662 support
11740  *
11741  * ALC662 is almost identical with ALC880 but has cleaner and more flexible
11742  * configuration.  Each pin widget can choose any input DACs and a mixer.
11743  * Each ADC is connected from a mixer of all inputs.  This makes possible
11744  * 6-channel independent captures.
11745  *
11746  * In addition, an independent DAC for the multi-playback (not used in this
11747  * driver yet).
11748  */
11749 
11750 /*
11751  * BIOS auto configuration
11752  */
11753 
11754 static int alc662_parse_auto_config(struct hda_codec *codec)
11755 {
11756 	static const hda_nid_t alc662_ignore[] = { 0x1d, 0 };
11757 	static const hda_nid_t alc663_ssids[] = { 0x15, 0x1b, 0x14, 0x21 };
11758 	static const hda_nid_t alc662_ssids[] = { 0x15, 0x1b, 0x14, 0 };
11759 	const hda_nid_t *ssids;
11760 
11761 	if (codec->core.vendor_id == 0x10ec0272 || codec->core.vendor_id == 0x10ec0663 ||
11762 	    codec->core.vendor_id == 0x10ec0665 || codec->core.vendor_id == 0x10ec0670 ||
11763 	    codec->core.vendor_id == 0x10ec0671)
11764 		ssids = alc663_ssids;
11765 	else
11766 		ssids = alc662_ssids;
11767 	return alc_parse_auto_config(codec, alc662_ignore, ssids);
11768 }
11769 
11770 static void alc272_fixup_mario(struct hda_codec *codec,
11771 			       const struct hda_fixup *fix, int action)
11772 {
11773 	if (action != HDA_FIXUP_ACT_PRE_PROBE)
11774 		return;
11775 	if (snd_hda_override_amp_caps(codec, 0x2, HDA_OUTPUT,
11776 				      (0x3b << AC_AMPCAP_OFFSET_SHIFT) |
11777 				      (0x3b << AC_AMPCAP_NUM_STEPS_SHIFT) |
11778 				      (0x03 << AC_AMPCAP_STEP_SIZE_SHIFT) |
11779 				      (0 << AC_AMPCAP_MUTE_SHIFT)))
11780 		codec_warn(codec, "failed to override amp caps for NID 0x2\n");
11781 }
11782 
11783 static const struct snd_pcm_chmap_elem asus_pcm_2_1_chmaps[] = {
11784 	{ .channels = 2,
11785 	  .map = { SNDRV_CHMAP_FL, SNDRV_CHMAP_FR } },
11786 	{ .channels = 4,
11787 	  .map = { SNDRV_CHMAP_FL, SNDRV_CHMAP_FR,
11788 		   SNDRV_CHMAP_NA, SNDRV_CHMAP_LFE } }, /* LFE only on right */
11789 	{ }
11790 };
11791 
11792 /* override the 2.1 chmap */
11793 static void alc_fixup_bass_chmap(struct hda_codec *codec,
11794 				    const struct hda_fixup *fix, int action)
11795 {
11796 	if (action == HDA_FIXUP_ACT_BUILD) {
11797 		struct alc_spec *spec = codec->spec;
11798 		spec->gen.pcm_rec[0]->stream[0].chmap = asus_pcm_2_1_chmaps;
11799 	}
11800 }
11801 
11802 /* avoid D3 for keeping GPIO up */
11803 static unsigned int gpio_led_power_filter(struct hda_codec *codec,
11804 					  hda_nid_t nid,
11805 					  unsigned int power_state)
11806 {
11807 	struct alc_spec *spec = codec->spec;
11808 	if (nid == codec->core.afg && power_state == AC_PWRST_D3 && spec->gpio_data)
11809 		return AC_PWRST_D0;
11810 	return power_state;
11811 }
11812 
11813 static void alc662_fixup_led_gpio1(struct hda_codec *codec,
11814 				   const struct hda_fixup *fix, int action)
11815 {
11816 	struct alc_spec *spec = codec->spec;
11817 
11818 	alc_fixup_hp_gpio_led(codec, action, 0x01, 0);
11819 	if (action == HDA_FIXUP_ACT_PRE_PROBE) {
11820 		spec->mute_led_polarity = 1;
11821 		codec->power_filter = gpio_led_power_filter;
11822 	}
11823 }
11824 
11825 static void alc662_usi_automute_hook(struct hda_codec *codec,
11826 					 struct hda_jack_callback *jack)
11827 {
11828 	struct alc_spec *spec = codec->spec;
11829 	int vref;
11830 	msleep(200);
11831 	snd_hda_gen_hp_automute(codec, jack);
11832 
11833 	vref = spec->gen.hp_jack_present ? PIN_VREF80 : 0;
11834 	msleep(100);
11835 	snd_hda_codec_write(codec, 0x19, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
11836 			    vref);
11837 }
11838 
11839 static void alc662_fixup_usi_headset_mic(struct hda_codec *codec,
11840 				     const struct hda_fixup *fix, int action)
11841 {
11842 	struct alc_spec *spec = codec->spec;
11843 	if (action == HDA_FIXUP_ACT_PRE_PROBE) {
11844 		spec->parse_flags |= HDA_PINCFG_HEADSET_MIC;
11845 		spec->gen.hp_automute_hook = alc662_usi_automute_hook;
11846 	}
11847 }
11848 
11849 static void alc662_aspire_ethos_mute_speakers(struct hda_codec *codec,
11850 					struct hda_jack_callback *cb)
11851 {
11852 	/* surround speakers at 0x1b already get muted automatically when
11853 	 * headphones are plugged in, but we have to mute/unmute the remaining
11854 	 * channels manually:
11855 	 * 0x15 - front left/front right
11856 	 * 0x18 - front center/ LFE
11857 	 */
11858 	if (snd_hda_jack_detect_state(codec, 0x1b) == HDA_JACK_PRESENT) {
11859 		snd_hda_set_pin_ctl_cache(codec, 0x15, 0);
11860 		snd_hda_set_pin_ctl_cache(codec, 0x18, 0);
11861 	} else {
11862 		snd_hda_set_pin_ctl_cache(codec, 0x15, PIN_OUT);
11863 		snd_hda_set_pin_ctl_cache(codec, 0x18, PIN_OUT);
11864 	}
11865 }
11866 
11867 static void alc662_fixup_aspire_ethos_hp(struct hda_codec *codec,
11868 					const struct hda_fixup *fix, int action)
11869 {
11870     /* Pin 0x1b: shared headphones jack and surround speakers */
11871 	if (!is_jack_detectable(codec, 0x1b))
11872 		return;
11873 
11874 	switch (action) {
11875 	case HDA_FIXUP_ACT_PRE_PROBE:
11876 		snd_hda_jack_detect_enable_callback(codec, 0x1b,
11877 				alc662_aspire_ethos_mute_speakers);
11878 		/* subwoofer needs an extra GPIO setting to become audible */
11879 		alc_setup_gpio(codec, 0x02);
11880 		break;
11881 	case HDA_FIXUP_ACT_INIT:
11882 		/* Make sure to start in a correct state, i.e. if
11883 		 * headphones have been plugged in before powering up the system
11884 		 */
11885 		alc662_aspire_ethos_mute_speakers(codec, NULL);
11886 		break;
11887 	}
11888 }
11889 
11890 static void alc671_fixup_hp_headset_mic2(struct hda_codec *codec,
11891 					     const struct hda_fixup *fix, int action)
11892 {
11893 	struct alc_spec *spec = codec->spec;
11894 
11895 	static const struct hda_pintbl pincfgs[] = {
11896 		{ 0x19, 0x02a11040 }, /* use as headset mic, with its own jack detect */
11897 		{ 0x1b, 0x0181304f },
11898 		{ }
11899 	};
11900 
11901 	switch (action) {
11902 	case HDA_FIXUP_ACT_PRE_PROBE:
11903 		spec->gen.mixer_nid = 0;
11904 		spec->parse_flags |= HDA_PINCFG_HEADSET_MIC;
11905 		snd_hda_apply_pincfgs(codec, pincfgs);
11906 		break;
11907 	case HDA_FIXUP_ACT_INIT:
11908 		alc_write_coef_idx(codec, 0x19, 0xa054);
11909 		break;
11910 	}
11911 }
11912 
11913 static void alc897_hp_automute_hook(struct hda_codec *codec,
11914 					 struct hda_jack_callback *jack)
11915 {
11916 	struct alc_spec *spec = codec->spec;
11917 	int vref;
11918 
11919 	snd_hda_gen_hp_automute(codec, jack);
11920 	vref = spec->gen.hp_jack_present ? (PIN_HP | AC_PINCTL_VREF_100) : PIN_HP;
11921 	snd_hda_set_pin_ctl(codec, 0x1b, vref);
11922 }
11923 
11924 static void alc897_fixup_lenovo_headset_mic(struct hda_codec *codec,
11925 				     const struct hda_fixup *fix, int action)
11926 {
11927 	struct alc_spec *spec = codec->spec;
11928 	if (action == HDA_FIXUP_ACT_PRE_PROBE) {
11929 		spec->gen.hp_automute_hook = alc897_hp_automute_hook;
11930 		spec->no_shutup_pins = 1;
11931 	}
11932 	if (action == HDA_FIXUP_ACT_PROBE) {
11933 		snd_hda_set_pin_ctl_cache(codec, 0x1a, PIN_IN | AC_PINCTL_VREF_100);
11934 	}
11935 }
11936 
11937 static void alc897_fixup_lenovo_headset_mode(struct hda_codec *codec,
11938 				     const struct hda_fixup *fix, int action)
11939 {
11940 	struct alc_spec *spec = codec->spec;
11941 
11942 	if (action == HDA_FIXUP_ACT_PRE_PROBE) {
11943 		spec->parse_flags |= HDA_PINCFG_HEADSET_MIC;
11944 		spec->gen.hp_automute_hook = alc897_hp_automute_hook;
11945 	}
11946 }
11947 
11948 static const struct coef_fw alc668_coefs[] = {
11949 	WRITE_COEF(0x01, 0xbebe), WRITE_COEF(0x02, 0xaaaa), WRITE_COEF(0x03,    0x0),
11950 	WRITE_COEF(0x04, 0x0180), WRITE_COEF(0x06,    0x0), WRITE_COEF(0x07, 0x0f80),
11951 	WRITE_COEF(0x08, 0x0031), WRITE_COEF(0x0a, 0x0060), WRITE_COEF(0x0b,    0x0),
11952 	WRITE_COEF(0x0c, 0x7cf7), WRITE_COEF(0x0d, 0x1080), WRITE_COEF(0x0e, 0x7f7f),
11953 	WRITE_COEF(0x0f, 0xcccc), WRITE_COEF(0x10, 0xddcc), WRITE_COEF(0x11, 0x0001),
11954 	WRITE_COEF(0x13,    0x0), WRITE_COEF(0x14, 0x2aa0), WRITE_COEF(0x17, 0xa940),
11955 	WRITE_COEF(0x19,    0x0), WRITE_COEF(0x1a,    0x0), WRITE_COEF(0x1b,    0x0),
11956 	WRITE_COEF(0x1c,    0x0), WRITE_COEF(0x1d,    0x0), WRITE_COEF(0x1e, 0x7418),
11957 	WRITE_COEF(0x1f, 0x0804), WRITE_COEF(0x20, 0x4200), WRITE_COEF(0x21, 0x0468),
11958 	WRITE_COEF(0x22, 0x8ccc), WRITE_COEF(0x23, 0x0250), WRITE_COEF(0x24, 0x7418),
11959 	WRITE_COEF(0x27,    0x0), WRITE_COEF(0x28, 0x8ccc), WRITE_COEF(0x2a, 0xff00),
11960 	WRITE_COEF(0x2b, 0x8000), WRITE_COEF(0xa7, 0xff00), WRITE_COEF(0xa8, 0x8000),
11961 	WRITE_COEF(0xaa, 0x2e17), WRITE_COEF(0xab, 0xa0c0), WRITE_COEF(0xac,    0x0),
11962 	WRITE_COEF(0xad,    0x0), WRITE_COEF(0xae, 0x2ac6), WRITE_COEF(0xaf, 0xa480),
11963 	WRITE_COEF(0xb0,    0x0), WRITE_COEF(0xb1,    0x0), WRITE_COEF(0xb2,    0x0),
11964 	WRITE_COEF(0xb3,    0x0), WRITE_COEF(0xb4,    0x0), WRITE_COEF(0xb5, 0x1040),
11965 	WRITE_COEF(0xb6, 0xd697), WRITE_COEF(0xb7, 0x902b), WRITE_COEF(0xb8, 0xd697),
11966 	WRITE_COEF(0xb9, 0x902b), WRITE_COEF(0xba, 0xb8ba), WRITE_COEF(0xbb, 0xaaab),
11967 	WRITE_COEF(0xbc, 0xaaaf), WRITE_COEF(0xbd, 0x6aaa), WRITE_COEF(0xbe, 0x1c02),
11968 	WRITE_COEF(0xc0, 0x00ff), WRITE_COEF(0xc1, 0x0fa6),
11969 	{}
11970 };
11971 
11972 static void alc668_restore_default_value(struct hda_codec *codec)
11973 {
11974 	alc_process_coef_fw(codec, alc668_coefs);
11975 }
11976 
11977 enum {
11978 	ALC662_FIXUP_ASPIRE,
11979 	ALC662_FIXUP_LED_GPIO1,
11980 	ALC662_FIXUP_IDEAPAD,
11981 	ALC272_FIXUP_MARIO,
11982 	ALC662_FIXUP_CZC_ET26,
11983 	ALC662_FIXUP_CZC_P10T,
11984 	ALC662_FIXUP_SKU_IGNORE,
11985 	ALC662_FIXUP_HP_RP5800,
11986 	ALC662_FIXUP_ASUS_MODE1,
11987 	ALC662_FIXUP_ASUS_MODE2,
11988 	ALC662_FIXUP_ASUS_MODE3,
11989 	ALC662_FIXUP_ASUS_MODE4,
11990 	ALC662_FIXUP_ASUS_MODE5,
11991 	ALC662_FIXUP_ASUS_MODE6,
11992 	ALC662_FIXUP_ASUS_MODE7,
11993 	ALC662_FIXUP_ASUS_MODE8,
11994 	ALC662_FIXUP_NO_JACK_DETECT,
11995 	ALC662_FIXUP_ZOTAC_Z68,
11996 	ALC662_FIXUP_INV_DMIC,
11997 	ALC662_FIXUP_DELL_MIC_NO_PRESENCE,
11998 	ALC668_FIXUP_DELL_MIC_NO_PRESENCE,
11999 	ALC662_FIXUP_HEADSET_MODE,
12000 	ALC668_FIXUP_HEADSET_MODE,
12001 	ALC662_FIXUP_BASS_MODE4_CHMAP,
12002 	ALC662_FIXUP_BASS_16,
12003 	ALC662_FIXUP_BASS_1A,
12004 	ALC662_FIXUP_BASS_CHMAP,
12005 	ALC668_FIXUP_AUTO_MUTE,
12006 	ALC668_FIXUP_DELL_DISABLE_AAMIX,
12007 	ALC668_FIXUP_DELL_XPS13,
12008 	ALC662_FIXUP_ASUS_Nx50,
12009 	ALC668_FIXUP_ASUS_Nx51_HEADSET_MODE,
12010 	ALC668_FIXUP_ASUS_Nx51,
12011 	ALC668_FIXUP_MIC_COEF,
12012 	ALC668_FIXUP_ASUS_G751,
12013 	ALC891_FIXUP_HEADSET_MODE,
12014 	ALC891_FIXUP_DELL_MIC_NO_PRESENCE,
12015 	ALC662_FIXUP_ACER_VERITON,
12016 	ALC892_FIXUP_ASROCK_MOBO,
12017 	ALC662_FIXUP_USI_FUNC,
12018 	ALC662_FIXUP_USI_HEADSET_MODE,
12019 	ALC662_FIXUP_LENOVO_MULTI_CODECS,
12020 	ALC669_FIXUP_ACER_ASPIRE_ETHOS,
12021 	ALC669_FIXUP_ACER_ASPIRE_ETHOS_HEADSET,
12022 	ALC671_FIXUP_HP_HEADSET_MIC2,
12023 	ALC662_FIXUP_ACER_X2660G_HEADSET_MODE,
12024 	ALC662_FIXUP_ACER_NITRO_HEADSET_MODE,
12025 	ALC668_FIXUP_ASUS_NO_HEADSET_MIC,
12026 	ALC668_FIXUP_HEADSET_MIC,
12027 	ALC668_FIXUP_MIC_DET_COEF,
12028 	ALC897_FIXUP_LENOVO_HEADSET_MIC,
12029 	ALC897_FIXUP_HEADSET_MIC_PIN,
12030 	ALC897_FIXUP_HP_HSMIC_VERB,
12031 	ALC897_FIXUP_LENOVO_HEADSET_MODE,
12032 	ALC897_FIXUP_HEADSET_MIC_PIN2,
12033 	ALC897_FIXUP_UNIS_H3C_X500S,
12034 	ALC897_FIXUP_HEADSET_MIC_PIN3,
12035 };
12036 
12037 static const struct hda_fixup alc662_fixups[] = {
12038 	[ALC662_FIXUP_ASPIRE] = {
12039 		.type = HDA_FIXUP_PINS,
12040 		.v.pins = (const struct hda_pintbl[]) {
12041 			{ 0x15, 0x99130112 }, /* subwoofer */
12042 			{ }
12043 		}
12044 	},
12045 	[ALC662_FIXUP_LED_GPIO1] = {
12046 		.type = HDA_FIXUP_FUNC,
12047 		.v.func = alc662_fixup_led_gpio1,
12048 	},
12049 	[ALC662_FIXUP_IDEAPAD] = {
12050 		.type = HDA_FIXUP_PINS,
12051 		.v.pins = (const struct hda_pintbl[]) {
12052 			{ 0x17, 0x99130112 }, /* subwoofer */
12053 			{ }
12054 		},
12055 		.chained = true,
12056 		.chain_id = ALC662_FIXUP_LED_GPIO1,
12057 	},
12058 	[ALC272_FIXUP_MARIO] = {
12059 		.type = HDA_FIXUP_FUNC,
12060 		.v.func = alc272_fixup_mario,
12061 	},
12062 	[ALC662_FIXUP_CZC_ET26] = {
12063 		.type = HDA_FIXUP_PINS,
12064 		.v.pins = (const struct hda_pintbl[]) {
12065 			{0x12, 0x403cc000},
12066 			{0x14, 0x90170110}, /* speaker */
12067 			{0x15, 0x411111f0},
12068 			{0x16, 0x411111f0},
12069 			{0x18, 0x01a19030}, /* mic */
12070 			{0x19, 0x90a7013f}, /* int-mic */
12071 			{0x1a, 0x01014020},
12072 			{0x1b, 0x0121401f},
12073 			{0x1c, 0x411111f0},
12074 			{0x1d, 0x411111f0},
12075 			{0x1e, 0x40478e35},
12076 			{}
12077 		},
12078 		.chained = true,
12079 		.chain_id = ALC662_FIXUP_SKU_IGNORE
12080 	},
12081 	[ALC662_FIXUP_CZC_P10T] = {
12082 		.type = HDA_FIXUP_VERBS,
12083 		.v.verbs = (const struct hda_verb[]) {
12084 			{0x14, AC_VERB_SET_EAPD_BTLENABLE, 0},
12085 			{}
12086 		}
12087 	},
12088 	[ALC662_FIXUP_SKU_IGNORE] = {
12089 		.type = HDA_FIXUP_FUNC,
12090 		.v.func = alc_fixup_sku_ignore,
12091 	},
12092 	[ALC662_FIXUP_HP_RP5800] = {
12093 		.type = HDA_FIXUP_PINS,
12094 		.v.pins = (const struct hda_pintbl[]) {
12095 			{ 0x14, 0x0221201f }, /* HP out */
12096 			{ }
12097 		},
12098 		.chained = true,
12099 		.chain_id = ALC662_FIXUP_SKU_IGNORE
12100 	},
12101 	[ALC662_FIXUP_ASUS_MODE1] = {
12102 		.type = HDA_FIXUP_PINS,
12103 		.v.pins = (const struct hda_pintbl[]) {
12104 			{ 0x14, 0x99130110 }, /* speaker */
12105 			{ 0x18, 0x01a19c20 }, /* mic */
12106 			{ 0x19, 0x99a3092f }, /* int-mic */
12107 			{ 0x21, 0x0121401f }, /* HP out */
12108 			{ }
12109 		},
12110 		.chained = true,
12111 		.chain_id = ALC662_FIXUP_SKU_IGNORE
12112 	},
12113 	[ALC662_FIXUP_ASUS_MODE2] = {
12114 		.type = HDA_FIXUP_PINS,
12115 		.v.pins = (const struct hda_pintbl[]) {
12116 			{ 0x14, 0x99130110 }, /* speaker */
12117 			{ 0x18, 0x01a19820 }, /* mic */
12118 			{ 0x19, 0x99a3092f }, /* int-mic */
12119 			{ 0x1b, 0x0121401f }, /* HP out */
12120 			{ }
12121 		},
12122 		.chained = true,
12123 		.chain_id = ALC662_FIXUP_SKU_IGNORE
12124 	},
12125 	[ALC662_FIXUP_ASUS_MODE3] = {
12126 		.type = HDA_FIXUP_PINS,
12127 		.v.pins = (const struct hda_pintbl[]) {
12128 			{ 0x14, 0x99130110 }, /* speaker */
12129 			{ 0x15, 0x0121441f }, /* HP */
12130 			{ 0x18, 0x01a19840 }, /* mic */
12131 			{ 0x19, 0x99a3094f }, /* int-mic */
12132 			{ 0x21, 0x01211420 }, /* HP2 */
12133 			{ }
12134 		},
12135 		.chained = true,
12136 		.chain_id = ALC662_FIXUP_SKU_IGNORE
12137 	},
12138 	[ALC662_FIXUP_ASUS_MODE4] = {
12139 		.type = HDA_FIXUP_PINS,
12140 		.v.pins = (const struct hda_pintbl[]) {
12141 			{ 0x14, 0x99130110 }, /* speaker */
12142 			{ 0x16, 0x99130111 }, /* speaker */
12143 			{ 0x18, 0x01a19840 }, /* mic */
12144 			{ 0x19, 0x99a3094f }, /* int-mic */
12145 			{ 0x21, 0x0121441f }, /* HP */
12146 			{ }
12147 		},
12148 		.chained = true,
12149 		.chain_id = ALC662_FIXUP_SKU_IGNORE
12150 	},
12151 	[ALC662_FIXUP_ASUS_MODE5] = {
12152 		.type = HDA_FIXUP_PINS,
12153 		.v.pins = (const struct hda_pintbl[]) {
12154 			{ 0x14, 0x99130110 }, /* speaker */
12155 			{ 0x15, 0x0121441f }, /* HP */
12156 			{ 0x16, 0x99130111 }, /* speaker */
12157 			{ 0x18, 0x01a19840 }, /* mic */
12158 			{ 0x19, 0x99a3094f }, /* int-mic */
12159 			{ }
12160 		},
12161 		.chained = true,
12162 		.chain_id = ALC662_FIXUP_SKU_IGNORE
12163 	},
12164 	[ALC662_FIXUP_ASUS_MODE6] = {
12165 		.type = HDA_FIXUP_PINS,
12166 		.v.pins = (const struct hda_pintbl[]) {
12167 			{ 0x14, 0x99130110 }, /* speaker */
12168 			{ 0x15, 0x01211420 }, /* HP2 */
12169 			{ 0x18, 0x01a19840 }, /* mic */
12170 			{ 0x19, 0x99a3094f }, /* int-mic */
12171 			{ 0x1b, 0x0121441f }, /* HP */
12172 			{ }
12173 		},
12174 		.chained = true,
12175 		.chain_id = ALC662_FIXUP_SKU_IGNORE
12176 	},
12177 	[ALC662_FIXUP_ASUS_MODE7] = {
12178 		.type = HDA_FIXUP_PINS,
12179 		.v.pins = (const struct hda_pintbl[]) {
12180 			{ 0x14, 0x99130110 }, /* speaker */
12181 			{ 0x17, 0x99130111 }, /* speaker */
12182 			{ 0x18, 0x01a19840 }, /* mic */
12183 			{ 0x19, 0x99a3094f }, /* int-mic */
12184 			{ 0x1b, 0x01214020 }, /* HP */
12185 			{ 0x21, 0x0121401f }, /* HP */
12186 			{ }
12187 		},
12188 		.chained = true,
12189 		.chain_id = ALC662_FIXUP_SKU_IGNORE
12190 	},
12191 	[ALC662_FIXUP_ASUS_MODE8] = {
12192 		.type = HDA_FIXUP_PINS,
12193 		.v.pins = (const struct hda_pintbl[]) {
12194 			{ 0x14, 0x99130110 }, /* speaker */
12195 			{ 0x12, 0x99a30970 }, /* int-mic */
12196 			{ 0x15, 0x01214020 }, /* HP */
12197 			{ 0x17, 0x99130111 }, /* speaker */
12198 			{ 0x18, 0x01a19840 }, /* mic */
12199 			{ 0x21, 0x0121401f }, /* HP */
12200 			{ }
12201 		},
12202 		.chained = true,
12203 		.chain_id = ALC662_FIXUP_SKU_IGNORE
12204 	},
12205 	[ALC662_FIXUP_NO_JACK_DETECT] = {
12206 		.type = HDA_FIXUP_FUNC,
12207 		.v.func = alc_fixup_no_jack_detect,
12208 	},
12209 	[ALC662_FIXUP_ZOTAC_Z68] = {
12210 		.type = HDA_FIXUP_PINS,
12211 		.v.pins = (const struct hda_pintbl[]) {
12212 			{ 0x1b, 0x02214020 }, /* Front HP */
12213 			{ }
12214 		}
12215 	},
12216 	[ALC662_FIXUP_INV_DMIC] = {
12217 		.type = HDA_FIXUP_FUNC,
12218 		.v.func = alc_fixup_inv_dmic,
12219 	},
12220 	[ALC668_FIXUP_DELL_XPS13] = {
12221 		.type = HDA_FIXUP_FUNC,
12222 		.v.func = alc_fixup_dell_xps13,
12223 		.chained = true,
12224 		.chain_id = ALC668_FIXUP_DELL_DISABLE_AAMIX
12225 	},
12226 	[ALC668_FIXUP_DELL_DISABLE_AAMIX] = {
12227 		.type = HDA_FIXUP_FUNC,
12228 		.v.func = alc_fixup_disable_aamix,
12229 		.chained = true,
12230 		.chain_id = ALC668_FIXUP_DELL_MIC_NO_PRESENCE
12231 	},
12232 	[ALC668_FIXUP_AUTO_MUTE] = {
12233 		.type = HDA_FIXUP_FUNC,
12234 		.v.func = alc_fixup_auto_mute_via_amp,
12235 		.chained = true,
12236 		.chain_id = ALC668_FIXUP_DELL_MIC_NO_PRESENCE
12237 	},
12238 	[ALC662_FIXUP_DELL_MIC_NO_PRESENCE] = {
12239 		.type = HDA_FIXUP_PINS,
12240 		.v.pins = (const struct hda_pintbl[]) {
12241 			{ 0x19, 0x03a1113c }, /* use as headset mic, without its own jack detect */
12242 			/* headphone mic by setting pin control of 0x1b (headphone out) to in + vref_50 */
12243 			{ }
12244 		},
12245 		.chained = true,
12246 		.chain_id = ALC662_FIXUP_HEADSET_MODE
12247 	},
12248 	[ALC662_FIXUP_HEADSET_MODE] = {
12249 		.type = HDA_FIXUP_FUNC,
12250 		.v.func = alc_fixup_headset_mode_alc662,
12251 	},
12252 	[ALC668_FIXUP_DELL_MIC_NO_PRESENCE] = {
12253 		.type = HDA_FIXUP_PINS,
12254 		.v.pins = (const struct hda_pintbl[]) {
12255 			{ 0x19, 0x03a1913d }, /* use as headphone mic, without its own jack detect */
12256 			{ 0x1b, 0x03a1113c }, /* use as headset mic, without its own jack detect */
12257 			{ }
12258 		},
12259 		.chained = true,
12260 		.chain_id = ALC668_FIXUP_HEADSET_MODE
12261 	},
12262 	[ALC668_FIXUP_HEADSET_MODE] = {
12263 		.type = HDA_FIXUP_FUNC,
12264 		.v.func = alc_fixup_headset_mode_alc668,
12265 	},
12266 	[ALC662_FIXUP_BASS_MODE4_CHMAP] = {
12267 		.type = HDA_FIXUP_FUNC,
12268 		.v.func = alc_fixup_bass_chmap,
12269 		.chained = true,
12270 		.chain_id = ALC662_FIXUP_ASUS_MODE4
12271 	},
12272 	[ALC662_FIXUP_BASS_16] = {
12273 		.type = HDA_FIXUP_PINS,
12274 		.v.pins = (const struct hda_pintbl[]) {
12275 			{0x16, 0x80106111}, /* bass speaker */
12276 			{}
12277 		},
12278 		.chained = true,
12279 		.chain_id = ALC662_FIXUP_BASS_CHMAP,
12280 	},
12281 	[ALC662_FIXUP_BASS_1A] = {
12282 		.type = HDA_FIXUP_PINS,
12283 		.v.pins = (const struct hda_pintbl[]) {
12284 			{0x1a, 0x80106111}, /* bass speaker */
12285 			{}
12286 		},
12287 		.chained = true,
12288 		.chain_id = ALC662_FIXUP_BASS_CHMAP,
12289 	},
12290 	[ALC662_FIXUP_BASS_CHMAP] = {
12291 		.type = HDA_FIXUP_FUNC,
12292 		.v.func = alc_fixup_bass_chmap,
12293 	},
12294 	[ALC662_FIXUP_ASUS_Nx50] = {
12295 		.type = HDA_FIXUP_FUNC,
12296 		.v.func = alc_fixup_auto_mute_via_amp,
12297 		.chained = true,
12298 		.chain_id = ALC662_FIXUP_BASS_1A
12299 	},
12300 	[ALC668_FIXUP_ASUS_Nx51_HEADSET_MODE] = {
12301 		.type = HDA_FIXUP_FUNC,
12302 		.v.func = alc_fixup_headset_mode_alc668,
12303 		.chain_id = ALC662_FIXUP_BASS_CHMAP
12304 	},
12305 	[ALC668_FIXUP_ASUS_Nx51] = {
12306 		.type = HDA_FIXUP_PINS,
12307 		.v.pins = (const struct hda_pintbl[]) {
12308 			{ 0x19, 0x03a1913d }, /* use as headphone mic, without its own jack detect */
12309 			{ 0x1a, 0x90170151 }, /* bass speaker */
12310 			{ 0x1b, 0x03a1113c }, /* use as headset mic, without its own jack detect */
12311 			{}
12312 		},
12313 		.chained = true,
12314 		.chain_id = ALC668_FIXUP_ASUS_Nx51_HEADSET_MODE,
12315 	},
12316 	[ALC668_FIXUP_MIC_COEF] = {
12317 		.type = HDA_FIXUP_VERBS,
12318 		.v.verbs = (const struct hda_verb[]) {
12319 			{ 0x20, AC_VERB_SET_COEF_INDEX, 0xc3 },
12320 			{ 0x20, AC_VERB_SET_PROC_COEF, 0x4000 },
12321 			{}
12322 		},
12323 	},
12324 	[ALC668_FIXUP_ASUS_G751] = {
12325 		.type = HDA_FIXUP_PINS,
12326 		.v.pins = (const struct hda_pintbl[]) {
12327 			{ 0x16, 0x0421101f }, /* HP */
12328 			{}
12329 		},
12330 		.chained = true,
12331 		.chain_id = ALC668_FIXUP_MIC_COEF
12332 	},
12333 	[ALC891_FIXUP_HEADSET_MODE] = {
12334 		.type = HDA_FIXUP_FUNC,
12335 		.v.func = alc_fixup_headset_mode,
12336 	},
12337 	[ALC891_FIXUP_DELL_MIC_NO_PRESENCE] = {
12338 		.type = HDA_FIXUP_PINS,
12339 		.v.pins = (const struct hda_pintbl[]) {
12340 			{ 0x19, 0x03a1913d }, /* use as headphone mic, without its own jack detect */
12341 			{ 0x1b, 0x03a1113c }, /* use as headset mic, without its own jack detect */
12342 			{ }
12343 		},
12344 		.chained = true,
12345 		.chain_id = ALC891_FIXUP_HEADSET_MODE
12346 	},
12347 	[ALC662_FIXUP_ACER_VERITON] = {
12348 		.type = HDA_FIXUP_PINS,
12349 		.v.pins = (const struct hda_pintbl[]) {
12350 			{ 0x15, 0x50170120 }, /* no internal speaker */
12351 			{ }
12352 		}
12353 	},
12354 	[ALC892_FIXUP_ASROCK_MOBO] = {
12355 		.type = HDA_FIXUP_PINS,
12356 		.v.pins = (const struct hda_pintbl[]) {
12357 			{ 0x15, 0x40f000f0 }, /* disabled */
12358 			{ 0x16, 0x40f000f0 }, /* disabled */
12359 			{ }
12360 		}
12361 	},
12362 	[ALC662_FIXUP_USI_FUNC] = {
12363 		.type = HDA_FIXUP_FUNC,
12364 		.v.func = alc662_fixup_usi_headset_mic,
12365 	},
12366 	[ALC662_FIXUP_USI_HEADSET_MODE] = {
12367 		.type = HDA_FIXUP_PINS,
12368 		.v.pins = (const struct hda_pintbl[]) {
12369 			{ 0x19, 0x02a1913c }, /* use as headset mic, without its own jack detect */
12370 			{ 0x18, 0x01a1903d },
12371 			{ }
12372 		},
12373 		.chained = true,
12374 		.chain_id = ALC662_FIXUP_USI_FUNC
12375 	},
12376 	[ALC662_FIXUP_LENOVO_MULTI_CODECS] = {
12377 		.type = HDA_FIXUP_FUNC,
12378 		.v.func = alc233_alc662_fixup_lenovo_dual_codecs,
12379 	},
12380 	[ALC669_FIXUP_ACER_ASPIRE_ETHOS_HEADSET] = {
12381 		.type = HDA_FIXUP_FUNC,
12382 		.v.func = alc662_fixup_aspire_ethos_hp,
12383 	},
12384 	[ALC669_FIXUP_ACER_ASPIRE_ETHOS] = {
12385 		.type = HDA_FIXUP_PINS,
12386 		.v.pins = (const struct hda_pintbl[]) {
12387 			{ 0x15, 0x92130110 }, /* front speakers */
12388 			{ 0x18, 0x99130111 }, /* center/subwoofer */
12389 			{ 0x1b, 0x11130012 }, /* surround plus jack for HP */
12390 			{ }
12391 		},
12392 		.chained = true,
12393 		.chain_id = ALC669_FIXUP_ACER_ASPIRE_ETHOS_HEADSET
12394 	},
12395 	[ALC671_FIXUP_HP_HEADSET_MIC2] = {
12396 		.type = HDA_FIXUP_FUNC,
12397 		.v.func = alc671_fixup_hp_headset_mic2,
12398 	},
12399 	[ALC662_FIXUP_ACER_X2660G_HEADSET_MODE] = {
12400 		.type = HDA_FIXUP_PINS,
12401 		.v.pins = (const struct hda_pintbl[]) {
12402 			{ 0x1a, 0x02a1113c }, /* use as headset mic, without its own jack detect */
12403 			{ }
12404 		},
12405 		.chained = true,
12406 		.chain_id = ALC662_FIXUP_USI_FUNC
12407 	},
12408 	[ALC662_FIXUP_ACER_NITRO_HEADSET_MODE] = {
12409 		.type = HDA_FIXUP_PINS,
12410 		.v.pins = (const struct hda_pintbl[]) {
12411 			{ 0x1a, 0x01a11140 }, /* use as headset mic, without its own jack detect */
12412 			{ 0x1b, 0x0221144f },
12413 			{ }
12414 		},
12415 		.chained = true,
12416 		.chain_id = ALC662_FIXUP_USI_FUNC
12417 	},
12418 	[ALC668_FIXUP_ASUS_NO_HEADSET_MIC] = {
12419 		.type = HDA_FIXUP_PINS,
12420 		.v.pins = (const struct hda_pintbl[]) {
12421 			{ 0x1b, 0x04a1112c },
12422 			{ }
12423 		},
12424 		.chained = true,
12425 		.chain_id = ALC668_FIXUP_HEADSET_MIC
12426 	},
12427 	[ALC668_FIXUP_HEADSET_MIC] = {
12428 		.type = HDA_FIXUP_FUNC,
12429 		.v.func = alc269_fixup_headset_mic,
12430 		.chained = true,
12431 		.chain_id = ALC668_FIXUP_MIC_DET_COEF
12432 	},
12433 	[ALC668_FIXUP_MIC_DET_COEF] = {
12434 		.type = HDA_FIXUP_VERBS,
12435 		.v.verbs = (const struct hda_verb[]) {
12436 			{ 0x20, AC_VERB_SET_COEF_INDEX, 0x15 },
12437 			{ 0x20, AC_VERB_SET_PROC_COEF, 0x0d60 },
12438 			{}
12439 		},
12440 	},
12441 	[ALC897_FIXUP_LENOVO_HEADSET_MIC] = {
12442 		.type = HDA_FIXUP_FUNC,
12443 		.v.func = alc897_fixup_lenovo_headset_mic,
12444 	},
12445 	[ALC897_FIXUP_HEADSET_MIC_PIN] = {
12446 		.type = HDA_FIXUP_PINS,
12447 		.v.pins = (const struct hda_pintbl[]) {
12448 			{ 0x1a, 0x03a11050 },
12449 			{ }
12450 		},
12451 		.chained = true,
12452 		.chain_id = ALC897_FIXUP_LENOVO_HEADSET_MIC
12453 	},
12454 	[ALC897_FIXUP_HP_HSMIC_VERB] = {
12455 		.type = HDA_FIXUP_PINS,
12456 		.v.pins = (const struct hda_pintbl[]) {
12457 			{ 0x19, 0x01a1913c }, /* use as headset mic, without its own jack detect */
12458 			{ }
12459 		},
12460 	},
12461 	[ALC897_FIXUP_LENOVO_HEADSET_MODE] = {
12462 		.type = HDA_FIXUP_FUNC,
12463 		.v.func = alc897_fixup_lenovo_headset_mode,
12464 	},
12465 	[ALC897_FIXUP_HEADSET_MIC_PIN2] = {
12466 		.type = HDA_FIXUP_PINS,
12467 		.v.pins = (const struct hda_pintbl[]) {
12468 			{ 0x1a, 0x01a11140 }, /* use as headset mic, without its own jack detect */
12469 			{ }
12470 		},
12471 		.chained = true,
12472 		.chain_id = ALC897_FIXUP_LENOVO_HEADSET_MODE
12473 	},
12474 	[ALC897_FIXUP_UNIS_H3C_X500S] = {
12475 		.type = HDA_FIXUP_VERBS,
12476 		.v.verbs = (const struct hda_verb[]) {
12477 			{ 0x14, AC_VERB_SET_EAPD_BTLENABLE, 0 },
12478 			{}
12479 		},
12480 	},
12481 	[ALC897_FIXUP_HEADSET_MIC_PIN3] = {
12482 		.type = HDA_FIXUP_PINS,
12483 		.v.pins = (const struct hda_pintbl[]) {
12484 			{ 0x19, 0x03a11050 }, /* use as headset mic */
12485 			{ }
12486 		},
12487 	},
12488 };
12489 
12490 static const struct snd_pci_quirk alc662_fixup_tbl[] = {
12491 	SND_PCI_QUIRK(0x1019, 0x9087, "ECS", ALC662_FIXUP_ASUS_MODE2),
12492 	SND_PCI_QUIRK(0x1019, 0x9859, "JP-IK LEAP W502", ALC897_FIXUP_HEADSET_MIC_PIN3),
12493 	SND_PCI_QUIRK(0x1025, 0x022f, "Acer Aspire One", ALC662_FIXUP_INV_DMIC),
12494 	SND_PCI_QUIRK(0x1025, 0x0241, "Packard Bell DOTS", ALC662_FIXUP_INV_DMIC),
12495 	SND_PCI_QUIRK(0x1025, 0x0308, "Acer Aspire 8942G", ALC662_FIXUP_ASPIRE),
12496 	SND_PCI_QUIRK(0x1025, 0x031c, "Gateway NV79", ALC662_FIXUP_SKU_IGNORE),
12497 	SND_PCI_QUIRK(0x1025, 0x0349, "eMachines eM250", ALC662_FIXUP_INV_DMIC),
12498 	SND_PCI_QUIRK(0x1025, 0x034a, "Gateway LT27", ALC662_FIXUP_INV_DMIC),
12499 	SND_PCI_QUIRK(0x1025, 0x038b, "Acer Aspire 8943G", ALC662_FIXUP_ASPIRE),
12500 	SND_PCI_QUIRK(0x1025, 0x0566, "Acer Aspire Ethos 8951G", ALC669_FIXUP_ACER_ASPIRE_ETHOS),
12501 	SND_PCI_QUIRK(0x1025, 0x123c, "Acer Nitro N50-600", ALC662_FIXUP_ACER_NITRO_HEADSET_MODE),
12502 	SND_PCI_QUIRK(0x1025, 0x124e, "Acer 2660G", ALC662_FIXUP_ACER_X2660G_HEADSET_MODE),
12503 	SND_PCI_QUIRK(0x1028, 0x05d8, "Dell", ALC668_FIXUP_DELL_MIC_NO_PRESENCE),
12504 	SND_PCI_QUIRK(0x1028, 0x05db, "Dell", ALC668_FIXUP_DELL_MIC_NO_PRESENCE),
12505 	SND_PCI_QUIRK(0x1028, 0x05fe, "Dell XPS 15", ALC668_FIXUP_DELL_XPS13),
12506 	SND_PCI_QUIRK(0x1028, 0x060a, "Dell XPS 13", ALC668_FIXUP_DELL_XPS13),
12507 	SND_PCI_QUIRK(0x1028, 0x060d, "Dell M3800", ALC668_FIXUP_DELL_XPS13),
12508 	SND_PCI_QUIRK(0x1028, 0x0625, "Dell", ALC668_FIXUP_DELL_MIC_NO_PRESENCE),
12509 	SND_PCI_QUIRK(0x1028, 0x0626, "Dell", ALC668_FIXUP_DELL_MIC_NO_PRESENCE),
12510 	SND_PCI_QUIRK(0x1028, 0x0696, "Dell", ALC668_FIXUP_DELL_MIC_NO_PRESENCE),
12511 	SND_PCI_QUIRK(0x1028, 0x0698, "Dell", ALC668_FIXUP_DELL_MIC_NO_PRESENCE),
12512 	SND_PCI_QUIRK(0x1028, 0x069f, "Dell", ALC668_FIXUP_DELL_MIC_NO_PRESENCE),
12513 	SND_PCI_QUIRK(0x103c, 0x1632, "HP RP5800", ALC662_FIXUP_HP_RP5800),
12514 	SND_PCI_QUIRK(0x103c, 0x870c, "HP", ALC897_FIXUP_HP_HSMIC_VERB),
12515 	SND_PCI_QUIRK(0x103c, 0x8719, "HP", ALC897_FIXUP_HP_HSMIC_VERB),
12516 	SND_PCI_QUIRK(0x103c, 0x872b, "HP", ALC897_FIXUP_HP_HSMIC_VERB),
12517 	SND_PCI_QUIRK(0x103c, 0x873e, "HP", ALC671_FIXUP_HP_HEADSET_MIC2),
12518 	SND_PCI_QUIRK(0x103c, 0x8768, "HP Slim Desktop S01", ALC671_FIXUP_HP_HEADSET_MIC2),
12519 	SND_PCI_QUIRK(0x103c, 0x877e, "HP 288 Pro G6", ALC671_FIXUP_HP_HEADSET_MIC2),
12520 	SND_PCI_QUIRK(0x103c, 0x885f, "HP 288 Pro G8", ALC671_FIXUP_HP_HEADSET_MIC2),
12521 	SND_PCI_QUIRK(0x1043, 0x1080, "Asus UX501VW", ALC668_FIXUP_HEADSET_MODE),
12522 	SND_PCI_QUIRK(0x1043, 0x11cd, "Asus N550", ALC662_FIXUP_ASUS_Nx50),
12523 	SND_PCI_QUIRK(0x1043, 0x129d, "Asus N750", ALC662_FIXUP_ASUS_Nx50),
12524 	SND_PCI_QUIRK(0x1043, 0x12ff, "ASUS G751", ALC668_FIXUP_ASUS_G751),
12525 	SND_PCI_QUIRK(0x1043, 0x13df, "Asus N550JX", ALC662_FIXUP_BASS_1A),
12526 	SND_PCI_QUIRK(0x1043, 0x1477, "ASUS N56VZ", ALC662_FIXUP_BASS_MODE4_CHMAP),
12527 	SND_PCI_QUIRK(0x1043, 0x15a7, "ASUS UX51VZH", ALC662_FIXUP_BASS_16),
12528 	SND_PCI_QUIRK(0x1043, 0x177d, "ASUS N551", ALC668_FIXUP_ASUS_Nx51),
12529 	SND_PCI_QUIRK(0x1043, 0x17bd, "ASUS N751", ALC668_FIXUP_ASUS_Nx51),
12530 	SND_PCI_QUIRK(0x1043, 0x185d, "ASUS G551JW", ALC668_FIXUP_ASUS_NO_HEADSET_MIC),
12531 	SND_PCI_QUIRK(0x1043, 0x1963, "ASUS X71SL", ALC662_FIXUP_ASUS_MODE8),
12532 	SND_PCI_QUIRK(0x1043, 0x1b73, "ASUS N55SF", ALC662_FIXUP_BASS_16),
12533 	SND_PCI_QUIRK(0x1043, 0x1bf3, "ASUS N76VZ", ALC662_FIXUP_BASS_MODE4_CHMAP),
12534 	SND_PCI_QUIRK(0x1043, 0x8469, "ASUS mobo", ALC662_FIXUP_NO_JACK_DETECT),
12535 	SND_PCI_QUIRK(0x105b, 0x0cd6, "Foxconn", ALC662_FIXUP_ASUS_MODE2),
12536 	SND_PCI_QUIRK(0x144d, 0xc051, "Samsung R720", ALC662_FIXUP_IDEAPAD),
12537 	SND_PCI_QUIRK(0x14cd, 0x5003, "USI", ALC662_FIXUP_USI_HEADSET_MODE),
12538 	SND_PCI_QUIRK(0x17aa, 0x1036, "Lenovo P520", ALC662_FIXUP_LENOVO_MULTI_CODECS),
12539 	SND_PCI_QUIRK(0x17aa, 0x1057, "Lenovo P360", ALC897_FIXUP_HEADSET_MIC_PIN),
12540 	SND_PCI_QUIRK(0x17aa, 0x1064, "Lenovo P3 Tower", ALC897_FIXUP_HEADSET_MIC_PIN),
12541 	SND_PCI_QUIRK(0x17aa, 0x32ca, "Lenovo ThinkCentre M80", ALC897_FIXUP_HEADSET_MIC_PIN),
12542 	SND_PCI_QUIRK(0x17aa, 0x32cb, "Lenovo ThinkCentre M70", ALC897_FIXUP_HEADSET_MIC_PIN),
12543 	SND_PCI_QUIRK(0x17aa, 0x32cf, "Lenovo ThinkCentre M950", ALC897_FIXUP_HEADSET_MIC_PIN),
12544 	SND_PCI_QUIRK(0x17aa, 0x32f7, "Lenovo ThinkCentre M90", ALC897_FIXUP_HEADSET_MIC_PIN),
12545 	SND_PCI_QUIRK(0x17aa, 0x3321, "Lenovo ThinkCentre M70 Gen4", ALC897_FIXUP_HEADSET_MIC_PIN),
12546 	SND_PCI_QUIRK(0x17aa, 0x331b, "Lenovo ThinkCentre M90 Gen4", ALC897_FIXUP_HEADSET_MIC_PIN),
12547 	SND_PCI_QUIRK(0x17aa, 0x3364, "Lenovo ThinkCentre M90 Gen5", ALC897_FIXUP_HEADSET_MIC_PIN),
12548 	SND_PCI_QUIRK(0x17aa, 0x3742, "Lenovo TianYi510Pro-14IOB", ALC897_FIXUP_HEADSET_MIC_PIN2),
12549 	SND_PCI_QUIRK(0x17aa, 0x38af, "Lenovo Ideapad Y550P", ALC662_FIXUP_IDEAPAD),
12550 	SND_PCI_QUIRK(0x17aa, 0x3a0d, "Lenovo Ideapad Y550", ALC662_FIXUP_IDEAPAD),
12551 	SND_PCI_QUIRK(0x1849, 0x5892, "ASRock B150M", ALC892_FIXUP_ASROCK_MOBO),
12552 	SND_PCI_QUIRK(0x19da, 0xa130, "Zotac Z68", ALC662_FIXUP_ZOTAC_Z68),
12553 	SND_PCI_QUIRK(0x1b0a, 0x01b8, "ACER Veriton", ALC662_FIXUP_ACER_VERITON),
12554 	SND_PCI_QUIRK(0x1b35, 0x1234, "CZC ET26", ALC662_FIXUP_CZC_ET26),
12555 	SND_PCI_QUIRK(0x1b35, 0x2206, "CZC P10T", ALC662_FIXUP_CZC_P10T),
12556 	SND_PCI_QUIRK(0x1c6c, 0x1239, "Compaq N14JP6-V2", ALC897_FIXUP_HP_HSMIC_VERB),
12557 
12558 #if 0
12559 	/* Below is a quirk table taken from the old code.
12560 	 * Basically the device should work as is without the fixup table.
12561 	 * If BIOS doesn't give a proper info, enable the corresponding
12562 	 * fixup entry.
12563 	 */
12564 	SND_PCI_QUIRK(0x1043, 0x1000, "ASUS N50Vm", ALC662_FIXUP_ASUS_MODE1),
12565 	SND_PCI_QUIRK(0x1043, 0x1092, "ASUS NB", ALC662_FIXUP_ASUS_MODE3),
12566 	SND_PCI_QUIRK(0x1043, 0x1173, "ASUS K73Jn", ALC662_FIXUP_ASUS_MODE1),
12567 	SND_PCI_QUIRK(0x1043, 0x11c3, "ASUS M70V", ALC662_FIXUP_ASUS_MODE3),
12568 	SND_PCI_QUIRK(0x1043, 0x11d3, "ASUS NB", ALC662_FIXUP_ASUS_MODE1),
12569 	SND_PCI_QUIRK(0x1043, 0x11f3, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),
12570 	SND_PCI_QUIRK(0x1043, 0x1203, "ASUS NB", ALC662_FIXUP_ASUS_MODE1),
12571 	SND_PCI_QUIRK(0x1043, 0x1303, "ASUS G60J", ALC662_FIXUP_ASUS_MODE1),
12572 	SND_PCI_QUIRK(0x1043, 0x1333, "ASUS G60Jx", ALC662_FIXUP_ASUS_MODE1),
12573 	SND_PCI_QUIRK(0x1043, 0x1339, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),
12574 	SND_PCI_QUIRK(0x1043, 0x13e3, "ASUS N71JA", ALC662_FIXUP_ASUS_MODE7),
12575 	SND_PCI_QUIRK(0x1043, 0x1463, "ASUS N71", ALC662_FIXUP_ASUS_MODE7),
12576 	SND_PCI_QUIRK(0x1043, 0x14d3, "ASUS G72", ALC662_FIXUP_ASUS_MODE8),
12577 	SND_PCI_QUIRK(0x1043, 0x1563, "ASUS N90", ALC662_FIXUP_ASUS_MODE3),
12578 	SND_PCI_QUIRK(0x1043, 0x15d3, "ASUS N50SF F50SF", ALC662_FIXUP_ASUS_MODE1),
12579 	SND_PCI_QUIRK(0x1043, 0x16c3, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),
12580 	SND_PCI_QUIRK(0x1043, 0x16f3, "ASUS K40C K50C", ALC662_FIXUP_ASUS_MODE2),
12581 	SND_PCI_QUIRK(0x1043, 0x1733, "ASUS N81De", ALC662_FIXUP_ASUS_MODE1),
12582 	SND_PCI_QUIRK(0x1043, 0x1753, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),
12583 	SND_PCI_QUIRK(0x1043, 0x1763, "ASUS NB", ALC662_FIXUP_ASUS_MODE6),
12584 	SND_PCI_QUIRK(0x1043, 0x1765, "ASUS NB", ALC662_FIXUP_ASUS_MODE6),
12585 	SND_PCI_QUIRK(0x1043, 0x1783, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),
12586 	SND_PCI_QUIRK(0x1043, 0x1793, "ASUS F50GX", ALC662_FIXUP_ASUS_MODE1),
12587 	SND_PCI_QUIRK(0x1043, 0x17b3, "ASUS F70SL", ALC662_FIXUP_ASUS_MODE3),
12588 	SND_PCI_QUIRK(0x1043, 0x17f3, "ASUS X58LE", ALC662_FIXUP_ASUS_MODE2),
12589 	SND_PCI_QUIRK(0x1043, 0x1813, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),
12590 	SND_PCI_QUIRK(0x1043, 0x1823, "ASUS NB", ALC662_FIXUP_ASUS_MODE5),
12591 	SND_PCI_QUIRK(0x1043, 0x1833, "ASUS NB", ALC662_FIXUP_ASUS_MODE6),
12592 	SND_PCI_QUIRK(0x1043, 0x1843, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),
12593 	SND_PCI_QUIRK(0x1043, 0x1853, "ASUS F50Z", ALC662_FIXUP_ASUS_MODE1),
12594 	SND_PCI_QUIRK(0x1043, 0x1864, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),
12595 	SND_PCI_QUIRK(0x1043, 0x1876, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),
12596 	SND_PCI_QUIRK(0x1043, 0x1893, "ASUS M50Vm", ALC662_FIXUP_ASUS_MODE3),
12597 	SND_PCI_QUIRK(0x1043, 0x1894, "ASUS X55", ALC662_FIXUP_ASUS_MODE3),
12598 	SND_PCI_QUIRK(0x1043, 0x18b3, "ASUS N80Vc", ALC662_FIXUP_ASUS_MODE1),
12599 	SND_PCI_QUIRK(0x1043, 0x18c3, "ASUS VX5", ALC662_FIXUP_ASUS_MODE1),
12600 	SND_PCI_QUIRK(0x1043, 0x18d3, "ASUS N81Te", ALC662_FIXUP_ASUS_MODE1),
12601 	SND_PCI_QUIRK(0x1043, 0x18f3, "ASUS N505Tp", ALC662_FIXUP_ASUS_MODE1),
12602 	SND_PCI_QUIRK(0x1043, 0x1903, "ASUS F5GL", ALC662_FIXUP_ASUS_MODE1),
12603 	SND_PCI_QUIRK(0x1043, 0x1913, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),
12604 	SND_PCI_QUIRK(0x1043, 0x1933, "ASUS F80Q", ALC662_FIXUP_ASUS_MODE2),
12605 	SND_PCI_QUIRK(0x1043, 0x1943, "ASUS Vx3V", ALC662_FIXUP_ASUS_MODE1),
12606 	SND_PCI_QUIRK(0x1043, 0x1953, "ASUS NB", ALC662_FIXUP_ASUS_MODE1),
12607 	SND_PCI_QUIRK(0x1043, 0x1963, "ASUS X71C", ALC662_FIXUP_ASUS_MODE3),
12608 	SND_PCI_QUIRK(0x1043, 0x1983, "ASUS N5051A", ALC662_FIXUP_ASUS_MODE1),
12609 	SND_PCI_QUIRK(0x1043, 0x1993, "ASUS N20", ALC662_FIXUP_ASUS_MODE1),
12610 	SND_PCI_QUIRK(0x1043, 0x19b3, "ASUS F7Z", ALC662_FIXUP_ASUS_MODE1),
12611 	SND_PCI_QUIRK(0x1043, 0x19c3, "ASUS F5Z/F6x", ALC662_FIXUP_ASUS_MODE2),
12612 	SND_PCI_QUIRK(0x1043, 0x19e3, "ASUS NB", ALC662_FIXUP_ASUS_MODE1),
12613 	SND_PCI_QUIRK(0x1043, 0x19f3, "ASUS NB", ALC662_FIXUP_ASUS_MODE4),
12614 #endif
12615 	{}
12616 };
12617 
12618 static const struct hda_model_fixup alc662_fixup_models[] = {
12619 	{.id = ALC662_FIXUP_ASPIRE, .name = "aspire"},
12620 	{.id = ALC662_FIXUP_IDEAPAD, .name = "ideapad"},
12621 	{.id = ALC272_FIXUP_MARIO, .name = "mario"},
12622 	{.id = ALC662_FIXUP_HP_RP5800, .name = "hp-rp5800"},
12623 	{.id = ALC662_FIXUP_ASUS_MODE1, .name = "asus-mode1"},
12624 	{.id = ALC662_FIXUP_ASUS_MODE2, .name = "asus-mode2"},
12625 	{.id = ALC662_FIXUP_ASUS_MODE3, .name = "asus-mode3"},
12626 	{.id = ALC662_FIXUP_ASUS_MODE4, .name = "asus-mode4"},
12627 	{.id = ALC662_FIXUP_ASUS_MODE5, .name = "asus-mode5"},
12628 	{.id = ALC662_FIXUP_ASUS_MODE6, .name = "asus-mode6"},
12629 	{.id = ALC662_FIXUP_ASUS_MODE7, .name = "asus-mode7"},
12630 	{.id = ALC662_FIXUP_ASUS_MODE8, .name = "asus-mode8"},
12631 	{.id = ALC662_FIXUP_ZOTAC_Z68, .name = "zotac-z68"},
12632 	{.id = ALC662_FIXUP_INV_DMIC, .name = "inv-dmic"},
12633 	{.id = ALC662_FIXUP_DELL_MIC_NO_PRESENCE, .name = "alc662-headset-multi"},
12634 	{.id = ALC668_FIXUP_DELL_MIC_NO_PRESENCE, .name = "dell-headset-multi"},
12635 	{.id = ALC662_FIXUP_HEADSET_MODE, .name = "alc662-headset"},
12636 	{.id = ALC668_FIXUP_HEADSET_MODE, .name = "alc668-headset"},
12637 	{.id = ALC662_FIXUP_BASS_16, .name = "bass16"},
12638 	{.id = ALC662_FIXUP_BASS_1A, .name = "bass1a"},
12639 	{.id = ALC668_FIXUP_AUTO_MUTE, .name = "automute"},
12640 	{.id = ALC668_FIXUP_DELL_XPS13, .name = "dell-xps13"},
12641 	{.id = ALC662_FIXUP_ASUS_Nx50, .name = "asus-nx50"},
12642 	{.id = ALC668_FIXUP_ASUS_Nx51, .name = "asus-nx51"},
12643 	{.id = ALC668_FIXUP_ASUS_G751, .name = "asus-g751"},
12644 	{.id = ALC891_FIXUP_HEADSET_MODE, .name = "alc891-headset"},
12645 	{.id = ALC891_FIXUP_DELL_MIC_NO_PRESENCE, .name = "alc891-headset-multi"},
12646 	{.id = ALC662_FIXUP_ACER_VERITON, .name = "acer-veriton"},
12647 	{.id = ALC892_FIXUP_ASROCK_MOBO, .name = "asrock-mobo"},
12648 	{.id = ALC662_FIXUP_USI_HEADSET_MODE, .name = "usi-headset"},
12649 	{.id = ALC662_FIXUP_LENOVO_MULTI_CODECS, .name = "dual-codecs"},
12650 	{.id = ALC669_FIXUP_ACER_ASPIRE_ETHOS, .name = "aspire-ethos"},
12651 	{.id = ALC897_FIXUP_UNIS_H3C_X500S, .name = "unis-h3c-x500s"},
12652 	{}
12653 };
12654 
12655 static const struct snd_hda_pin_quirk alc662_pin_fixup_tbl[] = {
12656 	SND_HDA_PIN_QUIRK(0x10ec0867, 0x1028, "Dell", ALC891_FIXUP_DELL_MIC_NO_PRESENCE,
12657 		{0x17, 0x02211010},
12658 		{0x18, 0x01a19030},
12659 		{0x1a, 0x01813040},
12660 		{0x21, 0x01014020}),
12661 	SND_HDA_PIN_QUIRK(0x10ec0867, 0x1028, "Dell", ALC891_FIXUP_DELL_MIC_NO_PRESENCE,
12662 		{0x16, 0x01813030},
12663 		{0x17, 0x02211010},
12664 		{0x18, 0x01a19040},
12665 		{0x21, 0x01014020}),
12666 	SND_HDA_PIN_QUIRK(0x10ec0662, 0x1028, "Dell", ALC662_FIXUP_DELL_MIC_NO_PRESENCE,
12667 		{0x14, 0x01014010},
12668 		{0x18, 0x01a19020},
12669 		{0x1a, 0x0181302f},
12670 		{0x1b, 0x0221401f}),
12671 	SND_HDA_PIN_QUIRK(0x10ec0668, 0x1028, "Dell", ALC668_FIXUP_AUTO_MUTE,
12672 		{0x12, 0x99a30130},
12673 		{0x14, 0x90170110},
12674 		{0x15, 0x0321101f},
12675 		{0x16, 0x03011020}),
12676 	SND_HDA_PIN_QUIRK(0x10ec0668, 0x1028, "Dell", ALC668_FIXUP_AUTO_MUTE,
12677 		{0x12, 0x99a30140},
12678 		{0x14, 0x90170110},
12679 		{0x15, 0x0321101f},
12680 		{0x16, 0x03011020}),
12681 	SND_HDA_PIN_QUIRK(0x10ec0668, 0x1028, "Dell", ALC668_FIXUP_AUTO_MUTE,
12682 		{0x12, 0x99a30150},
12683 		{0x14, 0x90170110},
12684 		{0x15, 0x0321101f},
12685 		{0x16, 0x03011020}),
12686 	SND_HDA_PIN_QUIRK(0x10ec0668, 0x1028, "Dell", ALC668_FIXUP_AUTO_MUTE,
12687 		{0x14, 0x90170110},
12688 		{0x15, 0x0321101f},
12689 		{0x16, 0x03011020}),
12690 	SND_HDA_PIN_QUIRK(0x10ec0668, 0x1028, "Dell XPS 15", ALC668_FIXUP_AUTO_MUTE,
12691 		{0x12, 0x90a60130},
12692 		{0x14, 0x90170110},
12693 		{0x15, 0x0321101f}),
12694 	SND_HDA_PIN_QUIRK(0x10ec0671, 0x103c, "HP cPC", ALC671_FIXUP_HP_HEADSET_MIC2,
12695 		{0x14, 0x01014010},
12696 		{0x17, 0x90170150},
12697 		{0x19, 0x02a11060},
12698 		{0x1b, 0x01813030},
12699 		{0x21, 0x02211020}),
12700 	SND_HDA_PIN_QUIRK(0x10ec0671, 0x103c, "HP cPC", ALC671_FIXUP_HP_HEADSET_MIC2,
12701 		{0x14, 0x01014010},
12702 		{0x18, 0x01a19040},
12703 		{0x1b, 0x01813030},
12704 		{0x21, 0x02211020}),
12705 	SND_HDA_PIN_QUIRK(0x10ec0671, 0x103c, "HP cPC", ALC671_FIXUP_HP_HEADSET_MIC2,
12706 		{0x14, 0x01014020},
12707 		{0x17, 0x90170110},
12708 		{0x18, 0x01a19050},
12709 		{0x1b, 0x01813040},
12710 		{0x21, 0x02211030}),
12711 	{}
12712 };
12713 
12714 /*
12715  */
12716 static int patch_alc662(struct hda_codec *codec)
12717 {
12718 	struct alc_spec *spec;
12719 	int err;
12720 
12721 	err = alc_alloc_spec(codec, 0x0b);
12722 	if (err < 0)
12723 		return err;
12724 
12725 	spec = codec->spec;
12726 
12727 	spec->shutup = alc_eapd_shutup;
12728 
12729 	/* handle multiple HPs as is */
12730 	spec->parse_flags = HDA_PINCFG_NO_HP_FIXUP;
12731 
12732 	alc_fix_pll_init(codec, 0x20, 0x04, 15);
12733 
12734 	switch (codec->core.vendor_id) {
12735 	case 0x10ec0668:
12736 		spec->init_hook = alc668_restore_default_value;
12737 		break;
12738 	}
12739 
12740 	alc_pre_init(codec);
12741 
12742 	snd_hda_pick_fixup(codec, alc662_fixup_models,
12743 		       alc662_fixup_tbl, alc662_fixups);
12744 	snd_hda_pick_pin_fixup(codec, alc662_pin_fixup_tbl, alc662_fixups, true);
12745 	snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE);
12746 
12747 	alc_auto_parse_customize_define(codec);
12748 
12749 	if (has_cdefine_beep(codec))
12750 		spec->gen.beep_nid = 0x01;
12751 
12752 	if ((alc_get_coef0(codec) & (1 << 14)) &&
12753 	    codec->bus->pci && codec->bus->pci->subsystem_vendor == 0x1025 &&
12754 	    spec->cdefine.platform_type == 1) {
12755 		err = alc_codec_rename(codec, "ALC272X");
12756 		if (err < 0)
12757 			goto error;
12758 	}
12759 
12760 	/* automatic parse from the BIOS config */
12761 	err = alc662_parse_auto_config(codec);
12762 	if (err < 0)
12763 		goto error;
12764 
12765 	if (!spec->gen.no_analog && spec->gen.beep_nid) {
12766 		switch (codec->core.vendor_id) {
12767 		case 0x10ec0662:
12768 			err = set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
12769 			break;
12770 		case 0x10ec0272:
12771 		case 0x10ec0663:
12772 		case 0x10ec0665:
12773 		case 0x10ec0668:
12774 			err = set_beep_amp(spec, 0x0b, 0x04, HDA_INPUT);
12775 			break;
12776 		case 0x10ec0273:
12777 			err = set_beep_amp(spec, 0x0b, 0x03, HDA_INPUT);
12778 			break;
12779 		}
12780 		if (err < 0)
12781 			goto error;
12782 	}
12783 
12784 	snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE);
12785 
12786 	return 0;
12787 
12788  error:
12789 	alc_free(codec);
12790 	return err;
12791 }
12792 
12793 /*
12794  * ALC680 support
12795  */
12796 
12797 static int alc680_parse_auto_config(struct hda_codec *codec)
12798 {
12799 	return alc_parse_auto_config(codec, NULL, NULL);
12800 }
12801 
12802 /*
12803  */
12804 static int patch_alc680(struct hda_codec *codec)
12805 {
12806 	int err;
12807 
12808 	/* ALC680 has no aa-loopback mixer */
12809 	err = alc_alloc_spec(codec, 0);
12810 	if (err < 0)
12811 		return err;
12812 
12813 	/* automatic parse from the BIOS config */
12814 	err = alc680_parse_auto_config(codec);
12815 	if (err < 0) {
12816 		alc_free(codec);
12817 		return err;
12818 	}
12819 
12820 	return 0;
12821 }
12822 
12823 /*
12824  * patch entries
12825  */
12826 static const struct hda_device_id snd_hda_id_realtek[] = {
12827 	HDA_CODEC_ENTRY(0x10ec0215, "ALC215", patch_alc269),
12828 	HDA_CODEC_ENTRY(0x10ec0221, "ALC221", patch_alc269),
12829 	HDA_CODEC_ENTRY(0x10ec0222, "ALC222", patch_alc269),
12830 	HDA_CODEC_ENTRY(0x10ec0225, "ALC225", patch_alc269),
12831 	HDA_CODEC_ENTRY(0x10ec0230, "ALC236", patch_alc269),
12832 	HDA_CODEC_ENTRY(0x10ec0231, "ALC231", patch_alc269),
12833 	HDA_CODEC_ENTRY(0x10ec0233, "ALC233", patch_alc269),
12834 	HDA_CODEC_ENTRY(0x10ec0234, "ALC234", patch_alc269),
12835 	HDA_CODEC_ENTRY(0x10ec0235, "ALC233", patch_alc269),
12836 	HDA_CODEC_ENTRY(0x10ec0236, "ALC236", patch_alc269),
12837 	HDA_CODEC_ENTRY(0x10ec0245, "ALC245", patch_alc269),
12838 	HDA_CODEC_ENTRY(0x10ec0255, "ALC255", patch_alc269),
12839 	HDA_CODEC_ENTRY(0x10ec0256, "ALC256", patch_alc269),
12840 	HDA_CODEC_ENTRY(0x10ec0257, "ALC257", patch_alc269),
12841 	HDA_CODEC_ENTRY(0x10ec0260, "ALC260", patch_alc260),
12842 	HDA_CODEC_ENTRY(0x10ec0262, "ALC262", patch_alc262),
12843 	HDA_CODEC_ENTRY(0x10ec0267, "ALC267", patch_alc268),
12844 	HDA_CODEC_ENTRY(0x10ec0268, "ALC268", patch_alc268),
12845 	HDA_CODEC_ENTRY(0x10ec0269, "ALC269", patch_alc269),
12846 	HDA_CODEC_ENTRY(0x10ec0270, "ALC270", patch_alc269),
12847 	HDA_CODEC_ENTRY(0x10ec0272, "ALC272", patch_alc662),
12848 	HDA_CODEC_ENTRY(0x10ec0274, "ALC274", patch_alc269),
12849 	HDA_CODEC_ENTRY(0x10ec0275, "ALC275", patch_alc269),
12850 	HDA_CODEC_ENTRY(0x10ec0276, "ALC276", patch_alc269),
12851 	HDA_CODEC_ENTRY(0x10ec0280, "ALC280", patch_alc269),
12852 	HDA_CODEC_ENTRY(0x10ec0282, "ALC282", patch_alc269),
12853 	HDA_CODEC_ENTRY(0x10ec0283, "ALC283", patch_alc269),
12854 	HDA_CODEC_ENTRY(0x10ec0284, "ALC284", patch_alc269),
12855 	HDA_CODEC_ENTRY(0x10ec0285, "ALC285", patch_alc269),
12856 	HDA_CODEC_ENTRY(0x10ec0286, "ALC286", patch_alc269),
12857 	HDA_CODEC_ENTRY(0x10ec0287, "ALC287", patch_alc269),
12858 	HDA_CODEC_ENTRY(0x10ec0288, "ALC288", patch_alc269),
12859 	HDA_CODEC_ENTRY(0x10ec0289, "ALC289", patch_alc269),
12860 	HDA_CODEC_ENTRY(0x10ec0290, "ALC290", patch_alc269),
12861 	HDA_CODEC_ENTRY(0x10ec0292, "ALC292", patch_alc269),
12862 	HDA_CODEC_ENTRY(0x10ec0293, "ALC293", patch_alc269),
12863 	HDA_CODEC_ENTRY(0x10ec0294, "ALC294", patch_alc269),
12864 	HDA_CODEC_ENTRY(0x10ec0295, "ALC295", patch_alc269),
12865 	HDA_CODEC_ENTRY(0x10ec0298, "ALC298", patch_alc269),
12866 	HDA_CODEC_ENTRY(0x10ec0299, "ALC299", patch_alc269),
12867 	HDA_CODEC_ENTRY(0x10ec0300, "ALC300", patch_alc269),
12868 	HDA_CODEC_ENTRY(0x10ec0623, "ALC623", patch_alc269),
12869 	HDA_CODEC_REV_ENTRY(0x10ec0861, 0x100340, "ALC660", patch_alc861),
12870 	HDA_CODEC_ENTRY(0x10ec0660, "ALC660-VD", patch_alc861vd),
12871 	HDA_CODEC_ENTRY(0x10ec0861, "ALC861", patch_alc861),
12872 	HDA_CODEC_ENTRY(0x10ec0862, "ALC861-VD", patch_alc861vd),
12873 	HDA_CODEC_REV_ENTRY(0x10ec0662, 0x100002, "ALC662 rev2", patch_alc882),
12874 	HDA_CODEC_REV_ENTRY(0x10ec0662, 0x100101, "ALC662 rev1", patch_alc662),
12875 	HDA_CODEC_REV_ENTRY(0x10ec0662, 0x100300, "ALC662 rev3", patch_alc662),
12876 	HDA_CODEC_ENTRY(0x10ec0663, "ALC663", patch_alc662),
12877 	HDA_CODEC_ENTRY(0x10ec0665, "ALC665", patch_alc662),
12878 	HDA_CODEC_ENTRY(0x10ec0667, "ALC667", patch_alc662),
12879 	HDA_CODEC_ENTRY(0x10ec0668, "ALC668", patch_alc662),
12880 	HDA_CODEC_ENTRY(0x10ec0670, "ALC670", patch_alc662),
12881 	HDA_CODEC_ENTRY(0x10ec0671, "ALC671", patch_alc662),
12882 	HDA_CODEC_ENTRY(0x10ec0680, "ALC680", patch_alc680),
12883 	HDA_CODEC_ENTRY(0x10ec0700, "ALC700", patch_alc269),
12884 	HDA_CODEC_ENTRY(0x10ec0701, "ALC701", patch_alc269),
12885 	HDA_CODEC_ENTRY(0x10ec0703, "ALC703", patch_alc269),
12886 	HDA_CODEC_ENTRY(0x10ec0711, "ALC711", patch_alc269),
12887 	HDA_CODEC_ENTRY(0x10ec0867, "ALC891", patch_alc662),
12888 	HDA_CODEC_ENTRY(0x10ec0880, "ALC880", patch_alc880),
12889 	HDA_CODEC_ENTRY(0x10ec0882, "ALC882", patch_alc882),
12890 	HDA_CODEC_ENTRY(0x10ec0883, "ALC883", patch_alc882),
12891 	HDA_CODEC_REV_ENTRY(0x10ec0885, 0x100101, "ALC889A", patch_alc882),
12892 	HDA_CODEC_REV_ENTRY(0x10ec0885, 0x100103, "ALC889A", patch_alc882),
12893 	HDA_CODEC_ENTRY(0x10ec0885, "ALC885", patch_alc882),
12894 	HDA_CODEC_ENTRY(0x10ec0887, "ALC887", patch_alc882),
12895 	HDA_CODEC_REV_ENTRY(0x10ec0888, 0x100101, "ALC1200", patch_alc882),
12896 	HDA_CODEC_ENTRY(0x10ec0888, "ALC888", patch_alc882),
12897 	HDA_CODEC_ENTRY(0x10ec0889, "ALC889", patch_alc882),
12898 	HDA_CODEC_ENTRY(0x10ec0892, "ALC892", patch_alc662),
12899 	HDA_CODEC_ENTRY(0x10ec0897, "ALC897", patch_alc662),
12900 	HDA_CODEC_ENTRY(0x10ec0899, "ALC898", patch_alc882),
12901 	HDA_CODEC_ENTRY(0x10ec0900, "ALC1150", patch_alc882),
12902 	HDA_CODEC_ENTRY(0x10ec0b00, "ALCS1200A", patch_alc882),
12903 	HDA_CODEC_ENTRY(0x10ec1168, "ALC1220", patch_alc882),
12904 	HDA_CODEC_ENTRY(0x10ec1220, "ALC1220", patch_alc882),
12905 	HDA_CODEC_ENTRY(0x19e58326, "HW8326", patch_alc269),
12906 	{} /* terminator */
12907 };
12908 MODULE_DEVICE_TABLE(hdaudio, snd_hda_id_realtek);
12909 
12910 MODULE_LICENSE("GPL");
12911 MODULE_DESCRIPTION("Realtek HD-audio codec");
12912 MODULE_IMPORT_NS(SND_HDA_SCODEC_COMPONENT);
12913 
12914 static struct hda_codec_driver realtek_driver = {
12915 	.id = snd_hda_id_realtek,
12916 };
12917 
12918 module_hda_codec_driver(realtek_driver);
12919