xref: /linux/sound/pci/hda/patch_realtek.c (revision c532de5a67a70f8533d495f8f2aaa9a0491c3ad0) 
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/cleanup.h>
15 #include <linux/init.h>
16 #include <linux/delay.h>
17 #include <linux/slab.h>
18 #include <linux/pci.h>
19 #include <linux/dmi.h>
20 #include <linux/module.h>
21 #include <linux/i2c.h>
22 #include <linux/input.h>
23 #include <linux/leds.h>
24 #include <linux/ctype.h>
25 #include <linux/spi/spi.h>
26 #include <sound/core.h>
27 #include <sound/jack.h>
28 #include <sound/hda_codec.h>
29 #include "hda_local.h"
30 #include "hda_auto_parser.h"
31 #include "hda_jack.h"
32 #include "hda_generic.h"
33 #include "hda_component.h"
34 
35 /* keep halting ALC5505 DSP, for power saving */
36 #define HALT_REALTEK_ALC5505
37 
38 /* extra amp-initialization sequence types */
39 enum {
40 	ALC_INIT_UNDEFINED,
41 	ALC_INIT_NONE,
42 	ALC_INIT_DEFAULT,
43 };
44 
45 enum {
46 	ALC_HEADSET_MODE_UNKNOWN,
47 	ALC_HEADSET_MODE_UNPLUGGED,
48 	ALC_HEADSET_MODE_HEADSET,
49 	ALC_HEADSET_MODE_MIC,
50 	ALC_HEADSET_MODE_HEADPHONE,
51 };
52 
53 enum {
54 	ALC_HEADSET_TYPE_UNKNOWN,
55 	ALC_HEADSET_TYPE_CTIA,
56 	ALC_HEADSET_TYPE_OMTP,
57 };
58 
59 enum {
60 	ALC_KEY_MICMUTE_INDEX,
61 };
62 
63 struct alc_customize_define {
64 	unsigned int  sku_cfg;
65 	unsigned char port_connectivity;
66 	unsigned char check_sum;
67 	unsigned char customization;
68 	unsigned char external_amp;
69 	unsigned int  enable_pcbeep:1;
70 	unsigned int  platform_type:1;
71 	unsigned int  swap:1;
72 	unsigned int  override:1;
73 	unsigned int  fixup:1; /* Means that this sku is set by driver, not read from hw */
74 };
75 
76 struct alc_coef_led {
77 	unsigned int idx;
78 	unsigned int mask;
79 	unsigned int on;
80 	unsigned int off;
81 };
82 
83 struct alc_spec {
84 	struct hda_gen_spec gen; /* must be at head */
85 
86 	/* codec parameterization */
87 	struct alc_customize_define cdefine;
88 	unsigned int parse_flags; /* flag for snd_hda_parse_pin_defcfg() */
89 
90 	/* GPIO bits */
91 	unsigned int gpio_mask;
92 	unsigned int gpio_dir;
93 	unsigned int gpio_data;
94 	bool gpio_write_delay;	/* add a delay before writing gpio_data */
95 
96 	/* mute LED for HP laptops, see vref_mute_led_set() */
97 	int mute_led_polarity;
98 	int micmute_led_polarity;
99 	hda_nid_t mute_led_nid;
100 	hda_nid_t cap_mute_led_nid;
101 
102 	unsigned int gpio_mute_led_mask;
103 	unsigned int gpio_mic_led_mask;
104 	struct alc_coef_led mute_led_coef;
105 	struct alc_coef_led mic_led_coef;
106 	struct mutex coef_mutex;
107 
108 	hda_nid_t headset_mic_pin;
109 	hda_nid_t headphone_mic_pin;
110 	int current_headset_mode;
111 	int current_headset_type;
112 
113 	/* hooks */
114 	void (*init_hook)(struct hda_codec *codec);
115 	void (*power_hook)(struct hda_codec *codec);
116 	void (*shutup)(struct hda_codec *codec);
117 
118 	int init_amp;
119 	int codec_variant;	/* flag for other variants */
120 	unsigned int has_alc5505_dsp:1;
121 	unsigned int no_depop_delay:1;
122 	unsigned int done_hp_init:1;
123 	unsigned int no_shutup_pins:1;
124 	unsigned int ultra_low_power:1;
125 	unsigned int has_hs_key:1;
126 	unsigned int no_internal_mic_pin:1;
127 	unsigned int en_3kpull_low:1;
128 	int num_speaker_amps;
129 
130 	/* for PLL fix */
131 	hda_nid_t pll_nid;
132 	unsigned int pll_coef_idx, pll_coef_bit;
133 	unsigned int coef0;
134 	struct input_dev *kb_dev;
135 	u8 alc_mute_keycode_map[1];
136 
137 	/* component binding */
138 	struct hda_component_parent comps;
139 };
140 
141 /*
142  * COEF access helper functions
143  */
144 
145 static void coef_mutex_lock(struct hda_codec *codec)
146 {
147 	struct alc_spec *spec = codec->spec;
148 
149 	snd_hda_power_up_pm(codec);
150 	mutex_lock(&spec->coef_mutex);
151 }
152 
153 static void coef_mutex_unlock(struct hda_codec *codec)
154 {
155 	struct alc_spec *spec = codec->spec;
156 
157 	mutex_unlock(&spec->coef_mutex);
158 	snd_hda_power_down_pm(codec);
159 }
160 
161 static int __alc_read_coefex_idx(struct hda_codec *codec, hda_nid_t nid,
162 				 unsigned int coef_idx)
163 {
164 	unsigned int val;
165 
166 	snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_COEF_INDEX, coef_idx);
167 	val = snd_hda_codec_read(codec, nid, 0, AC_VERB_GET_PROC_COEF, 0);
168 	return val;
169 }
170 
171 static int alc_read_coefex_idx(struct hda_codec *codec, hda_nid_t nid,
172 			       unsigned int coef_idx)
173 {
174 	unsigned int val;
175 
176 	coef_mutex_lock(codec);
177 	val = __alc_read_coefex_idx(codec, nid, coef_idx);
178 	coef_mutex_unlock(codec);
179 	return val;
180 }
181 
182 #define alc_read_coef_idx(codec, coef_idx) \
183 	alc_read_coefex_idx(codec, 0x20, coef_idx)
184 
185 static void __alc_write_coefex_idx(struct hda_codec *codec, hda_nid_t nid,
186 				   unsigned int coef_idx, unsigned int coef_val)
187 {
188 	snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_COEF_INDEX, coef_idx);
189 	snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_PROC_COEF, coef_val);
190 }
191 
192 static void alc_write_coefex_idx(struct hda_codec *codec, hda_nid_t nid,
193 				 unsigned int coef_idx, unsigned int coef_val)
194 {
195 	coef_mutex_lock(codec);
196 	__alc_write_coefex_idx(codec, nid, coef_idx, coef_val);
197 	coef_mutex_unlock(codec);
198 }
199 
200 #define alc_write_coef_idx(codec, coef_idx, coef_val) \
201 	alc_write_coefex_idx(codec, 0x20, coef_idx, coef_val)
202 
203 static void __alc_update_coefex_idx(struct hda_codec *codec, hda_nid_t nid,
204 				    unsigned int coef_idx, unsigned int mask,
205 				    unsigned int bits_set)
206 {
207 	unsigned int val = __alc_read_coefex_idx(codec, nid, coef_idx);
208 
209 	if (val != -1)
210 		__alc_write_coefex_idx(codec, nid, coef_idx,
211 				       (val & ~mask) | bits_set);
212 }
213 
214 static void alc_update_coefex_idx(struct hda_codec *codec, hda_nid_t nid,
215 				  unsigned int coef_idx, unsigned int mask,
216 				  unsigned int bits_set)
217 {
218 	coef_mutex_lock(codec);
219 	__alc_update_coefex_idx(codec, nid, coef_idx, mask, bits_set);
220 	coef_mutex_unlock(codec);
221 }
222 
223 #define alc_update_coef_idx(codec, coef_idx, mask, bits_set)	\
224 	alc_update_coefex_idx(codec, 0x20, coef_idx, mask, bits_set)
225 
226 /* a special bypass for COEF 0; read the cached value at the second time */
227 static unsigned int alc_get_coef0(struct hda_codec *codec)
228 {
229 	struct alc_spec *spec = codec->spec;
230 
231 	if (!spec->coef0)
232 		spec->coef0 = alc_read_coef_idx(codec, 0);
233 	return spec->coef0;
234 }
235 
236 /* coef writes/updates batch */
237 struct coef_fw {
238 	unsigned char nid;
239 	unsigned char idx;
240 	unsigned short mask;
241 	unsigned short val;
242 };
243 
244 #define UPDATE_COEFEX(_nid, _idx, _mask, _val) \
245 	{ .nid = (_nid), .idx = (_idx), .mask = (_mask), .val = (_val) }
246 #define WRITE_COEFEX(_nid, _idx, _val) UPDATE_COEFEX(_nid, _idx, -1, _val)
247 #define WRITE_COEF(_idx, _val) WRITE_COEFEX(0x20, _idx, _val)
248 #define UPDATE_COEF(_idx, _mask, _val) UPDATE_COEFEX(0x20, _idx, _mask, _val)
249 
250 static void alc_process_coef_fw(struct hda_codec *codec,
251 				const struct coef_fw *fw)
252 {
253 	coef_mutex_lock(codec);
254 	for (; fw->nid; fw++) {
255 		if (fw->mask == (unsigned short)-1)
256 			__alc_write_coefex_idx(codec, fw->nid, fw->idx, fw->val);
257 		else
258 			__alc_update_coefex_idx(codec, fw->nid, fw->idx,
259 						fw->mask, fw->val);
260 	}
261 	coef_mutex_unlock(codec);
262 }
263 
264 /*
265  * GPIO setup tables, used in initialization
266  */
267 
268 /* Enable GPIO mask and set output */
269 static void alc_setup_gpio(struct hda_codec *codec, unsigned int mask)
270 {
271 	struct alc_spec *spec = codec->spec;
272 
273 	spec->gpio_mask |= mask;
274 	spec->gpio_dir |= mask;
275 	spec->gpio_data |= mask;
276 }
277 
278 static void alc_write_gpio_data(struct hda_codec *codec)
279 {
280 	struct alc_spec *spec = codec->spec;
281 
282 	snd_hda_codec_write(codec, 0x01, 0, AC_VERB_SET_GPIO_DATA,
283 			    spec->gpio_data);
284 }
285 
286 static void alc_update_gpio_data(struct hda_codec *codec, unsigned int mask,
287 				 bool on)
288 {
289 	struct alc_spec *spec = codec->spec;
290 	unsigned int oldval = spec->gpio_data;
291 
292 	if (on)
293 		spec->gpio_data |= mask;
294 	else
295 		spec->gpio_data &= ~mask;
296 	if (oldval != spec->gpio_data)
297 		alc_write_gpio_data(codec);
298 }
299 
300 static void alc_write_gpio(struct hda_codec *codec)
301 {
302 	struct alc_spec *spec = codec->spec;
303 
304 	if (!spec->gpio_mask)
305 		return;
306 
307 	snd_hda_codec_write(codec, codec->core.afg, 0,
308 			    AC_VERB_SET_GPIO_MASK, spec->gpio_mask);
309 	snd_hda_codec_write(codec, codec->core.afg, 0,
310 			    AC_VERB_SET_GPIO_DIRECTION, spec->gpio_dir);
311 	if (spec->gpio_write_delay)
312 		msleep(1);
313 	alc_write_gpio_data(codec);
314 }
315 
316 static void alc_fixup_gpio(struct hda_codec *codec, int action,
317 			   unsigned int mask)
318 {
319 	if (action == HDA_FIXUP_ACT_PRE_PROBE)
320 		alc_setup_gpio(codec, mask);
321 }
322 
323 static void alc_fixup_gpio1(struct hda_codec *codec,
324 			    const struct hda_fixup *fix, int action)
325 {
326 	alc_fixup_gpio(codec, action, 0x01);
327 }
328 
329 static void alc_fixup_gpio2(struct hda_codec *codec,
330 			    const struct hda_fixup *fix, int action)
331 {
332 	alc_fixup_gpio(codec, action, 0x02);
333 }
334 
335 static void alc_fixup_gpio3(struct hda_codec *codec,
336 			    const struct hda_fixup *fix, int action)
337 {
338 	alc_fixup_gpio(codec, action, 0x03);
339 }
340 
341 static void alc_fixup_gpio4(struct hda_codec *codec,
342 			    const struct hda_fixup *fix, int action)
343 {
344 	alc_fixup_gpio(codec, action, 0x04);
345 }
346 
347 static void alc_fixup_micmute_led(struct hda_codec *codec,
348 				  const struct hda_fixup *fix, int action)
349 {
350 	if (action == HDA_FIXUP_ACT_PRE_PROBE)
351 		snd_hda_gen_add_micmute_led_cdev(codec, NULL);
352 }
353 
354 /*
355  * Fix hardware PLL issue
356  * On some codecs, the analog PLL gating control must be off while
357  * the default value is 1.
358  */
359 static void alc_fix_pll(struct hda_codec *codec)
360 {
361 	struct alc_spec *spec = codec->spec;
362 
363 	if (spec->pll_nid)
364 		alc_update_coefex_idx(codec, spec->pll_nid, spec->pll_coef_idx,
365 				      1 << spec->pll_coef_bit, 0);
366 }
367 
368 static void alc_fix_pll_init(struct hda_codec *codec, hda_nid_t nid,
369 			     unsigned int coef_idx, unsigned int coef_bit)
370 {
371 	struct alc_spec *spec = codec->spec;
372 	spec->pll_nid = nid;
373 	spec->pll_coef_idx = coef_idx;
374 	spec->pll_coef_bit = coef_bit;
375 	alc_fix_pll(codec);
376 }
377 
378 /* update the master volume per volume-knob's unsol event */
379 static void alc_update_knob_master(struct hda_codec *codec,
380 				   struct hda_jack_callback *jack)
381 {
382 	unsigned int val;
383 	struct snd_kcontrol *kctl;
384 	struct snd_ctl_elem_value *uctl;
385 
386 	kctl = snd_hda_find_mixer_ctl(codec, "Master Playback Volume");
387 	if (!kctl)
388 		return;
389 	uctl = kzalloc(sizeof(*uctl), GFP_KERNEL);
390 	if (!uctl)
391 		return;
392 	val = snd_hda_codec_read(codec, jack->nid, 0,
393 				 AC_VERB_GET_VOLUME_KNOB_CONTROL, 0);
394 	val &= HDA_AMP_VOLMASK;
395 	uctl->value.integer.value[0] = val;
396 	uctl->value.integer.value[1] = val;
397 	kctl->put(kctl, uctl);
398 	kfree(uctl);
399 }
400 
401 static void alc880_unsol_event(struct hda_codec *codec, unsigned int res)
402 {
403 	/* For some reason, the res given from ALC880 is broken.
404 	   Here we adjust it properly. */
405 	snd_hda_jack_unsol_event(codec, res >> 2);
406 }
407 
408 /* Change EAPD to verb control */
409 static void alc_fill_eapd_coef(struct hda_codec *codec)
410 {
411 	int coef;
412 
413 	coef = alc_get_coef0(codec);
414 
415 	switch (codec->core.vendor_id) {
416 	case 0x10ec0262:
417 		alc_update_coef_idx(codec, 0x7, 0, 1<<5);
418 		break;
419 	case 0x10ec0267:
420 	case 0x10ec0268:
421 		alc_update_coef_idx(codec, 0x7, 0, 1<<13);
422 		break;
423 	case 0x10ec0269:
424 		if ((coef & 0x00f0) == 0x0010)
425 			alc_update_coef_idx(codec, 0xd, 0, 1<<14);
426 		if ((coef & 0x00f0) == 0x0020)
427 			alc_update_coef_idx(codec, 0x4, 1<<15, 0);
428 		if ((coef & 0x00f0) == 0x0030)
429 			alc_update_coef_idx(codec, 0x10, 1<<9, 0);
430 		break;
431 	case 0x10ec0280:
432 	case 0x10ec0284:
433 	case 0x10ec0290:
434 	case 0x10ec0292:
435 		alc_update_coef_idx(codec, 0x4, 1<<15, 0);
436 		break;
437 	case 0x10ec0225:
438 	case 0x10ec0295:
439 	case 0x10ec0299:
440 		alc_update_coef_idx(codec, 0x67, 0xf000, 0x3000);
441 		fallthrough;
442 	case 0x10ec0215:
443 	case 0x10ec0285:
444 	case 0x10ec0289:
445 		alc_update_coef_idx(codec, 0x36, 1<<13, 0);
446 		fallthrough;
447 	case 0x10ec0230:
448 	case 0x10ec0233:
449 	case 0x10ec0235:
450 	case 0x10ec0236:
451 	case 0x10ec0245:
452 	case 0x10ec0255:
453 	case 0x10ec0256:
454 	case 0x19e58326:
455 	case 0x10ec0257:
456 	case 0x10ec0282:
457 	case 0x10ec0283:
458 	case 0x10ec0286:
459 	case 0x10ec0288:
460 	case 0x10ec0298:
461 	case 0x10ec0300:
462 		alc_update_coef_idx(codec, 0x10, 1<<9, 0);
463 		break;
464 	case 0x10ec0275:
465 		alc_update_coef_idx(codec, 0xe, 0, 1<<0);
466 		break;
467 	case 0x10ec0287:
468 		alc_update_coef_idx(codec, 0x10, 1<<9, 0);
469 		alc_write_coef_idx(codec, 0x8, 0x4ab7);
470 		break;
471 	case 0x10ec0293:
472 		alc_update_coef_idx(codec, 0xa, 1<<13, 0);
473 		break;
474 	case 0x10ec0234:
475 	case 0x10ec0274:
476 	case 0x10ec0294:
477 	case 0x10ec0700:
478 	case 0x10ec0701:
479 	case 0x10ec0703:
480 	case 0x10ec0711:
481 		alc_update_coef_idx(codec, 0x10, 1<<15, 0);
482 		break;
483 	case 0x10ec0662:
484 		if ((coef & 0x00f0) == 0x0030)
485 			alc_update_coef_idx(codec, 0x4, 1<<10, 0); /* EAPD Ctrl */
486 		break;
487 	case 0x10ec0272:
488 	case 0x10ec0273:
489 	case 0x10ec0663:
490 	case 0x10ec0665:
491 	case 0x10ec0670:
492 	case 0x10ec0671:
493 	case 0x10ec0672:
494 		alc_update_coef_idx(codec, 0xd, 0, 1<<14); /* EAPD Ctrl */
495 		break;
496 	case 0x10ec0222:
497 	case 0x10ec0623:
498 		alc_update_coef_idx(codec, 0x19, 1<<13, 0);
499 		break;
500 	case 0x10ec0668:
501 		alc_update_coef_idx(codec, 0x7, 3<<13, 0);
502 		break;
503 	case 0x10ec0867:
504 		alc_update_coef_idx(codec, 0x4, 1<<10, 0);
505 		break;
506 	case 0x10ec0888:
507 		if ((coef & 0x00f0) == 0x0020 || (coef & 0x00f0) == 0x0030)
508 			alc_update_coef_idx(codec, 0x7, 1<<5, 0);
509 		break;
510 	case 0x10ec0892:
511 	case 0x10ec0897:
512 		alc_update_coef_idx(codec, 0x7, 1<<5, 0);
513 		break;
514 	case 0x10ec0899:
515 	case 0x10ec0900:
516 	case 0x10ec0b00:
517 	case 0x10ec1168:
518 	case 0x10ec1220:
519 		alc_update_coef_idx(codec, 0x7, 1<<1, 0);
520 		break;
521 	}
522 }
523 
524 /* additional initialization for ALC888 variants */
525 static void alc888_coef_init(struct hda_codec *codec)
526 {
527 	switch (alc_get_coef0(codec) & 0x00f0) {
528 	/* alc888-VA */
529 	case 0x00:
530 	/* alc888-VB */
531 	case 0x10:
532 		alc_update_coef_idx(codec, 7, 0, 0x2030); /* Turn EAPD to High */
533 		break;
534 	}
535 }
536 
537 /* turn on/off EAPD control (only if available) */
538 static void set_eapd(struct hda_codec *codec, hda_nid_t nid, int on)
539 {
540 	if (get_wcaps_type(get_wcaps(codec, nid)) != AC_WID_PIN)
541 		return;
542 	if (snd_hda_query_pin_caps(codec, nid) & AC_PINCAP_EAPD)
543 		snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_EAPD_BTLENABLE,
544 				    on ? 2 : 0);
545 }
546 
547 /* turn on/off EAPD controls of the codec */
548 static void alc_auto_setup_eapd(struct hda_codec *codec, bool on)
549 {
550 	/* We currently only handle front, HP */
551 	static const hda_nid_t pins[] = {
552 		0x0f, 0x10, 0x14, 0x15, 0x17, 0
553 	};
554 	const hda_nid_t *p;
555 	for (p = pins; *p; p++)
556 		set_eapd(codec, *p, on);
557 }
558 
559 static int find_ext_mic_pin(struct hda_codec *codec);
560 
561 static void alc_headset_mic_no_shutup(struct hda_codec *codec)
562 {
563 	const struct hda_pincfg *pin;
564 	int mic_pin = find_ext_mic_pin(codec);
565 	int i;
566 
567 	/* don't shut up pins when unloading the driver; otherwise it breaks
568 	 * the default pin setup at the next load of the driver
569 	 */
570 	if (codec->bus->shutdown)
571 		return;
572 
573 	snd_array_for_each(&codec->init_pins, i, pin) {
574 		/* use read here for syncing after issuing each verb */
575 		if (pin->nid != mic_pin)
576 			snd_hda_codec_read(codec, pin->nid, 0,
577 					AC_VERB_SET_PIN_WIDGET_CONTROL, 0);
578 	}
579 
580 	codec->pins_shutup = 1;
581 }
582 
583 static void alc_shutup_pins(struct hda_codec *codec)
584 {
585 	struct alc_spec *spec = codec->spec;
586 
587 	switch (codec->core.vendor_id) {
588 	case 0x10ec0236:
589 	case 0x10ec0256:
590 	case 0x10ec0257:
591 	case 0x19e58326:
592 	case 0x10ec0283:
593 	case 0x10ec0285:
594 	case 0x10ec0286:
595 	case 0x10ec0287:
596 	case 0x10ec0288:
597 	case 0x10ec0295:
598 	case 0x10ec0298:
599 		alc_headset_mic_no_shutup(codec);
600 		break;
601 	default:
602 		if (!spec->no_shutup_pins)
603 			snd_hda_shutup_pins(codec);
604 		break;
605 	}
606 }
607 
608 /* generic shutup callback;
609  * just turning off EAPD and a little pause for avoiding pop-noise
610  */
611 static void alc_eapd_shutup(struct hda_codec *codec)
612 {
613 	struct alc_spec *spec = codec->spec;
614 
615 	alc_auto_setup_eapd(codec, false);
616 	if (!spec->no_depop_delay)
617 		msleep(200);
618 	alc_shutup_pins(codec);
619 }
620 
621 /* generic EAPD initialization */
622 static void alc_auto_init_amp(struct hda_codec *codec, int type)
623 {
624 	alc_auto_setup_eapd(codec, true);
625 	alc_write_gpio(codec);
626 	switch (type) {
627 	case ALC_INIT_DEFAULT:
628 		switch (codec->core.vendor_id) {
629 		case 0x10ec0260:
630 			alc_update_coefex_idx(codec, 0x1a, 7, 0, 0x2010);
631 			break;
632 		case 0x10ec0880:
633 		case 0x10ec0882:
634 		case 0x10ec0883:
635 		case 0x10ec0885:
636 			alc_update_coef_idx(codec, 7, 0, 0x2030);
637 			break;
638 		case 0x10ec0888:
639 			alc888_coef_init(codec);
640 			break;
641 		}
642 		break;
643 	}
644 }
645 
646 /* get a primary headphone pin if available */
647 static hda_nid_t alc_get_hp_pin(struct alc_spec *spec)
648 {
649 	if (spec->gen.autocfg.hp_pins[0])
650 		return spec->gen.autocfg.hp_pins[0];
651 	if (spec->gen.autocfg.line_out_type == AC_JACK_HP_OUT)
652 		return spec->gen.autocfg.line_out_pins[0];
653 	return 0;
654 }
655 
656 /*
657  * Realtek SSID verification
658  */
659 
660 /* Could be any non-zero and even value. When used as fixup, tells
661  * the driver to ignore any present sku defines.
662  */
663 #define ALC_FIXUP_SKU_IGNORE (2)
664 
665 static void alc_fixup_sku_ignore(struct hda_codec *codec,
666 				 const struct hda_fixup *fix, int action)
667 {
668 	struct alc_spec *spec = codec->spec;
669 	if (action == HDA_FIXUP_ACT_PRE_PROBE) {
670 		spec->cdefine.fixup = 1;
671 		spec->cdefine.sku_cfg = ALC_FIXUP_SKU_IGNORE;
672 	}
673 }
674 
675 static void alc_fixup_no_depop_delay(struct hda_codec *codec,
676 				    const struct hda_fixup *fix, int action)
677 {
678 	struct alc_spec *spec = codec->spec;
679 
680 	if (action == HDA_FIXUP_ACT_PROBE) {
681 		spec->no_depop_delay = 1;
682 		codec->depop_delay = 0;
683 	}
684 }
685 
686 static int alc_auto_parse_customize_define(struct hda_codec *codec)
687 {
688 	unsigned int ass, tmp, i;
689 	unsigned nid = 0;
690 	struct alc_spec *spec = codec->spec;
691 
692 	spec->cdefine.enable_pcbeep = 1; /* assume always enabled */
693 
694 	if (spec->cdefine.fixup) {
695 		ass = spec->cdefine.sku_cfg;
696 		if (ass == ALC_FIXUP_SKU_IGNORE)
697 			return -1;
698 		goto do_sku;
699 	}
700 
701 	if (!codec->bus->pci)
702 		return -1;
703 	ass = codec->core.subsystem_id & 0xffff;
704 	if (ass != codec->bus->pci->subsystem_device && (ass & 1))
705 		goto do_sku;
706 
707 	nid = 0x1d;
708 	if (codec->core.vendor_id == 0x10ec0260)
709 		nid = 0x17;
710 	ass = snd_hda_codec_get_pincfg(codec, nid);
711 
712 	if (!(ass & 1)) {
713 		codec_info(codec, "%s: SKU not ready 0x%08x\n",
714 			   codec->core.chip_name, ass);
715 		return -1;
716 	}
717 
718 	/* check sum */
719 	tmp = 0;
720 	for (i = 1; i < 16; i++) {
721 		if ((ass >> i) & 1)
722 			tmp++;
723 	}
724 	if (((ass >> 16) & 0xf) != tmp)
725 		return -1;
726 
727 	spec->cdefine.port_connectivity = ass >> 30;
728 	spec->cdefine.enable_pcbeep = (ass & 0x100000) >> 20;
729 	spec->cdefine.check_sum = (ass >> 16) & 0xf;
730 	spec->cdefine.customization = ass >> 8;
731 do_sku:
732 	spec->cdefine.sku_cfg = ass;
733 	spec->cdefine.external_amp = (ass & 0x38) >> 3;
734 	spec->cdefine.platform_type = (ass & 0x4) >> 2;
735 	spec->cdefine.swap = (ass & 0x2) >> 1;
736 	spec->cdefine.override = ass & 0x1;
737 
738 	codec_dbg(codec, "SKU: Nid=0x%x sku_cfg=0x%08x\n",
739 		   nid, spec->cdefine.sku_cfg);
740 	codec_dbg(codec, "SKU: port_connectivity=0x%x\n",
741 		   spec->cdefine.port_connectivity);
742 	codec_dbg(codec, "SKU: enable_pcbeep=0x%x\n", spec->cdefine.enable_pcbeep);
743 	codec_dbg(codec, "SKU: check_sum=0x%08x\n", spec->cdefine.check_sum);
744 	codec_dbg(codec, "SKU: customization=0x%08x\n", spec->cdefine.customization);
745 	codec_dbg(codec, "SKU: external_amp=0x%x\n", spec->cdefine.external_amp);
746 	codec_dbg(codec, "SKU: platform_type=0x%x\n", spec->cdefine.platform_type);
747 	codec_dbg(codec, "SKU: swap=0x%x\n", spec->cdefine.swap);
748 	codec_dbg(codec, "SKU: override=0x%x\n", spec->cdefine.override);
749 
750 	return 0;
751 }
752 
753 /* return the position of NID in the list, or -1 if not found */
754 static int find_idx_in_nid_list(hda_nid_t nid, const hda_nid_t *list, int nums)
755 {
756 	int i;
757 	for (i = 0; i < nums; i++)
758 		if (list[i] == nid)
759 			return i;
760 	return -1;
761 }
762 /* return true if the given NID is found in the list */
763 static bool found_in_nid_list(hda_nid_t nid, const hda_nid_t *list, int nums)
764 {
765 	return find_idx_in_nid_list(nid, list, nums) >= 0;
766 }
767 
768 /* check subsystem ID and set up device-specific initialization;
769  * return 1 if initialized, 0 if invalid SSID
770  */
771 /* 32-bit subsystem ID for BIOS loading in HD Audio codec.
772  *	31 ~ 16 :	Manufacture ID
773  *	15 ~ 8	:	SKU ID
774  *	7  ~ 0	:	Assembly ID
775  *	port-A --> pin 39/41, port-E --> pin 14/15, port-D --> pin 35/36
776  */
777 static int alc_subsystem_id(struct hda_codec *codec, const hda_nid_t *ports)
778 {
779 	unsigned int ass, tmp, i;
780 	unsigned nid;
781 	struct alc_spec *spec = codec->spec;
782 
783 	if (spec->cdefine.fixup) {
784 		ass = spec->cdefine.sku_cfg;
785 		if (ass == ALC_FIXUP_SKU_IGNORE)
786 			return 0;
787 		goto do_sku;
788 	}
789 
790 	ass = codec->core.subsystem_id & 0xffff;
791 	if (codec->bus->pci &&
792 	    ass != codec->bus->pci->subsystem_device && (ass & 1))
793 		goto do_sku;
794 
795 	/* invalid SSID, check the special NID pin defcfg instead */
796 	/*
797 	 * 31~30	: port connectivity
798 	 * 29~21	: reserve
799 	 * 20		: PCBEEP input
800 	 * 19~16	: Check sum (15:1)
801 	 * 15~1		: Custom
802 	 * 0		: override
803 	*/
804 	nid = 0x1d;
805 	if (codec->core.vendor_id == 0x10ec0260)
806 		nid = 0x17;
807 	ass = snd_hda_codec_get_pincfg(codec, nid);
808 	codec_dbg(codec,
809 		  "realtek: No valid SSID, checking pincfg 0x%08x for NID 0x%x\n",
810 		   ass, nid);
811 	if (!(ass & 1))
812 		return 0;
813 	if ((ass >> 30) != 1)	/* no physical connection */
814 		return 0;
815 
816 	/* check sum */
817 	tmp = 0;
818 	for (i = 1; i < 16; i++) {
819 		if ((ass >> i) & 1)
820 			tmp++;
821 	}
822 	if (((ass >> 16) & 0xf) != tmp)
823 		return 0;
824 do_sku:
825 	codec_dbg(codec, "realtek: Enabling init ASM_ID=0x%04x CODEC_ID=%08x\n",
826 		   ass & 0xffff, codec->core.vendor_id);
827 	/*
828 	 * 0 : override
829 	 * 1 :	Swap Jack
830 	 * 2 : 0 --> Desktop, 1 --> Laptop
831 	 * 3~5 : External Amplifier control
832 	 * 7~6 : Reserved
833 	*/
834 	tmp = (ass & 0x38) >> 3;	/* external Amp control */
835 	if (spec->init_amp == ALC_INIT_UNDEFINED) {
836 		switch (tmp) {
837 		case 1:
838 			alc_setup_gpio(codec, 0x01);
839 			break;
840 		case 3:
841 			alc_setup_gpio(codec, 0x02);
842 			break;
843 		case 7:
844 			alc_setup_gpio(codec, 0x04);
845 			break;
846 		case 5:
847 		default:
848 			spec->init_amp = ALC_INIT_DEFAULT;
849 			break;
850 		}
851 	}
852 
853 	/* is laptop or Desktop and enable the function "Mute internal speaker
854 	 * when the external headphone out jack is plugged"
855 	 */
856 	if (!(ass & 0x8000))
857 		return 1;
858 	/*
859 	 * 10~8 : Jack location
860 	 * 12~11: Headphone out -> 00: PortA, 01: PortE, 02: PortD, 03: Resvered
861 	 * 14~13: Resvered
862 	 * 15   : 1 --> enable the function "Mute internal speaker
863 	 *	        when the external headphone out jack is plugged"
864 	 */
865 	if (!alc_get_hp_pin(spec)) {
866 		hda_nid_t nid;
867 		tmp = (ass >> 11) & 0x3;	/* HP to chassis */
868 		nid = ports[tmp];
869 		if (found_in_nid_list(nid, spec->gen.autocfg.line_out_pins,
870 				      spec->gen.autocfg.line_outs))
871 			return 1;
872 		spec->gen.autocfg.hp_pins[0] = nid;
873 	}
874 	return 1;
875 }
876 
877 /* Check the validity of ALC subsystem-id
878  * ports contains an array of 4 pin NIDs for port-A, E, D and I */
879 static void alc_ssid_check(struct hda_codec *codec, const hda_nid_t *ports)
880 {
881 	if (!alc_subsystem_id(codec, ports)) {
882 		struct alc_spec *spec = codec->spec;
883 		if (spec->init_amp == ALC_INIT_UNDEFINED) {
884 			codec_dbg(codec,
885 				  "realtek: Enable default setup for auto mode as fallback\n");
886 			spec->init_amp = ALC_INIT_DEFAULT;
887 		}
888 	}
889 }
890 
891 /*
892  */
893 
894 static void alc_fixup_inv_dmic(struct hda_codec *codec,
895 			       const struct hda_fixup *fix, int action)
896 {
897 	struct alc_spec *spec = codec->spec;
898 
899 	spec->gen.inv_dmic_split = 1;
900 }
901 
902 
903 static int alc_build_controls(struct hda_codec *codec)
904 {
905 	int err;
906 
907 	err = snd_hda_gen_build_controls(codec);
908 	if (err < 0)
909 		return err;
910 
911 	snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_BUILD);
912 	return 0;
913 }
914 
915 
916 /*
917  * Common callbacks
918  */
919 
920 static void alc_pre_init(struct hda_codec *codec)
921 {
922 	alc_fill_eapd_coef(codec);
923 }
924 
925 #define is_s3_resume(codec) \
926 	((codec)->core.dev.power.power_state.event == PM_EVENT_RESUME)
927 #define is_s4_resume(codec) \
928 	((codec)->core.dev.power.power_state.event == PM_EVENT_RESTORE)
929 #define is_s4_suspend(codec) \
930 	((codec)->core.dev.power.power_state.event == PM_EVENT_FREEZE)
931 
932 static int alc_init(struct hda_codec *codec)
933 {
934 	struct alc_spec *spec = codec->spec;
935 
936 	/* hibernation resume needs the full chip initialization */
937 	if (is_s4_resume(codec))
938 		alc_pre_init(codec);
939 
940 	if (spec->init_hook)
941 		spec->init_hook(codec);
942 
943 	spec->gen.skip_verbs = 1; /* applied in below */
944 	snd_hda_gen_init(codec);
945 	alc_fix_pll(codec);
946 	alc_auto_init_amp(codec, spec->init_amp);
947 	snd_hda_apply_verbs(codec); /* apply verbs here after own init */
948 
949 	snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_INIT);
950 
951 	return 0;
952 }
953 
954 /* forward declaration */
955 static const struct component_master_ops comp_master_ops;
956 
957 static void alc_free(struct hda_codec *codec)
958 {
959 	struct alc_spec *spec = codec->spec;
960 
961 	if (spec)
962 		hda_component_manager_free(&spec->comps, &comp_master_ops);
963 
964 	snd_hda_gen_free(codec);
965 }
966 
967 static inline void alc_shutup(struct hda_codec *codec)
968 {
969 	struct alc_spec *spec = codec->spec;
970 
971 	if (!snd_hda_get_bool_hint(codec, "shutup"))
972 		return; /* disabled explicitly by hints */
973 
974 	if (spec && spec->shutup)
975 		spec->shutup(codec);
976 	else
977 		alc_shutup_pins(codec);
978 }
979 
980 static void alc_power_eapd(struct hda_codec *codec)
981 {
982 	alc_auto_setup_eapd(codec, false);
983 }
984 
985 static int alc_suspend(struct hda_codec *codec)
986 {
987 	struct alc_spec *spec = codec->spec;
988 	alc_shutup(codec);
989 	if (spec && spec->power_hook)
990 		spec->power_hook(codec);
991 	return 0;
992 }
993 
994 static int alc_resume(struct hda_codec *codec)
995 {
996 	struct alc_spec *spec = codec->spec;
997 
998 	if (!spec->no_depop_delay)
999 		msleep(150); /* to avoid pop noise */
1000 	codec->patch_ops.init(codec);
1001 	snd_hda_regmap_sync(codec);
1002 	hda_call_check_power_status(codec, 0x01);
1003 	return 0;
1004 }
1005 
1006 /*
1007  */
1008 static const struct hda_codec_ops alc_patch_ops = {
1009 	.build_controls = alc_build_controls,
1010 	.build_pcms = snd_hda_gen_build_pcms,
1011 	.init = alc_init,
1012 	.free = alc_free,
1013 	.unsol_event = snd_hda_jack_unsol_event,
1014 	.resume = alc_resume,
1015 	.suspend = alc_suspend,
1016 	.check_power_status = snd_hda_gen_check_power_status,
1017 };
1018 
1019 
1020 #define alc_codec_rename(codec, name) snd_hda_codec_set_name(codec, name)
1021 
1022 /*
1023  * Rename codecs appropriately from COEF value or subvendor id
1024  */
1025 struct alc_codec_rename_table {
1026 	unsigned int vendor_id;
1027 	unsigned short coef_mask;
1028 	unsigned short coef_bits;
1029 	const char *name;
1030 };
1031 
1032 struct alc_codec_rename_pci_table {
1033 	unsigned int codec_vendor_id;
1034 	unsigned short pci_subvendor;
1035 	unsigned short pci_subdevice;
1036 	const char *name;
1037 };
1038 
1039 static const struct alc_codec_rename_table rename_tbl[] = {
1040 	{ 0x10ec0221, 0xf00f, 0x1003, "ALC231" },
1041 	{ 0x10ec0269, 0xfff0, 0x3010, "ALC277" },
1042 	{ 0x10ec0269, 0xf0f0, 0x2010, "ALC259" },
1043 	{ 0x10ec0269, 0xf0f0, 0x3010, "ALC258" },
1044 	{ 0x10ec0269, 0x00f0, 0x0010, "ALC269VB" },
1045 	{ 0x10ec0269, 0xffff, 0xa023, "ALC259" },
1046 	{ 0x10ec0269, 0xffff, 0x6023, "ALC281X" },
1047 	{ 0x10ec0269, 0x00f0, 0x0020, "ALC269VC" },
1048 	{ 0x10ec0269, 0x00f0, 0x0030, "ALC269VD" },
1049 	{ 0x10ec0662, 0xffff, 0x4020, "ALC656" },
1050 	{ 0x10ec0887, 0x00f0, 0x0030, "ALC887-VD" },
1051 	{ 0x10ec0888, 0x00f0, 0x0030, "ALC888-VD" },
1052 	{ 0x10ec0888, 0xf0f0, 0x3020, "ALC886" },
1053 	{ 0x10ec0899, 0x2000, 0x2000, "ALC899" },
1054 	{ 0x10ec0892, 0xffff, 0x8020, "ALC661" },
1055 	{ 0x10ec0892, 0xffff, 0x8011, "ALC661" },
1056 	{ 0x10ec0892, 0xffff, 0x4011, "ALC656" },
1057 	{ } /* terminator */
1058 };
1059 
1060 static const struct alc_codec_rename_pci_table rename_pci_tbl[] = {
1061 	{ 0x10ec0280, 0x1028, 0, "ALC3220" },
1062 	{ 0x10ec0282, 0x1028, 0, "ALC3221" },
1063 	{ 0x10ec0283, 0x1028, 0, "ALC3223" },
1064 	{ 0x10ec0288, 0x1028, 0, "ALC3263" },
1065 	{ 0x10ec0292, 0x1028, 0, "ALC3226" },
1066 	{ 0x10ec0293, 0x1028, 0, "ALC3235" },
1067 	{ 0x10ec0255, 0x1028, 0, "ALC3234" },
1068 	{ 0x10ec0668, 0x1028, 0, "ALC3661" },
1069 	{ 0x10ec0275, 0x1028, 0, "ALC3260" },
1070 	{ 0x10ec0899, 0x1028, 0, "ALC3861" },
1071 	{ 0x10ec0298, 0x1028, 0, "ALC3266" },
1072 	{ 0x10ec0236, 0x1028, 0, "ALC3204" },
1073 	{ 0x10ec0256, 0x1028, 0, "ALC3246" },
1074 	{ 0x10ec0225, 0x1028, 0, "ALC3253" },
1075 	{ 0x10ec0295, 0x1028, 0, "ALC3254" },
1076 	{ 0x10ec0299, 0x1028, 0, "ALC3271" },
1077 	{ 0x10ec0670, 0x1025, 0, "ALC669X" },
1078 	{ 0x10ec0676, 0x1025, 0, "ALC679X" },
1079 	{ 0x10ec0282, 0x1043, 0, "ALC3229" },
1080 	{ 0x10ec0233, 0x1043, 0, "ALC3236" },
1081 	{ 0x10ec0280, 0x103c, 0, "ALC3228" },
1082 	{ 0x10ec0282, 0x103c, 0, "ALC3227" },
1083 	{ 0x10ec0286, 0x103c, 0, "ALC3242" },
1084 	{ 0x10ec0290, 0x103c, 0, "ALC3241" },
1085 	{ 0x10ec0668, 0x103c, 0, "ALC3662" },
1086 	{ 0x10ec0283, 0x17aa, 0, "ALC3239" },
1087 	{ 0x10ec0292, 0x17aa, 0, "ALC3232" },
1088 	{ } /* terminator */
1089 };
1090 
1091 static int alc_codec_rename_from_preset(struct hda_codec *codec)
1092 {
1093 	const struct alc_codec_rename_table *p;
1094 	const struct alc_codec_rename_pci_table *q;
1095 
1096 	for (p = rename_tbl; p->vendor_id; p++) {
1097 		if (p->vendor_id != codec->core.vendor_id)
1098 			continue;
1099 		if ((alc_get_coef0(codec) & p->coef_mask) == p->coef_bits)
1100 			return alc_codec_rename(codec, p->name);
1101 	}
1102 
1103 	if (!codec->bus->pci)
1104 		return 0;
1105 	for (q = rename_pci_tbl; q->codec_vendor_id; q++) {
1106 		if (q->codec_vendor_id != codec->core.vendor_id)
1107 			continue;
1108 		if (q->pci_subvendor != codec->bus->pci->subsystem_vendor)
1109 			continue;
1110 		if (!q->pci_subdevice ||
1111 		    q->pci_subdevice == codec->bus->pci->subsystem_device)
1112 			return alc_codec_rename(codec, q->name);
1113 	}
1114 
1115 	return 0;
1116 }
1117 
1118 
1119 /*
1120  * Digital-beep handlers
1121  */
1122 #ifdef CONFIG_SND_HDA_INPUT_BEEP
1123 
1124 /* additional beep mixers; private_value will be overwritten */
1125 static const struct snd_kcontrol_new alc_beep_mixer[] = {
1126 	HDA_CODEC_VOLUME("Beep Playback Volume", 0, 0, HDA_INPUT),
1127 	HDA_CODEC_MUTE_BEEP("Beep Playback Switch", 0, 0, HDA_INPUT),
1128 };
1129 
1130 /* set up and create beep controls */
1131 static int set_beep_amp(struct alc_spec *spec, hda_nid_t nid,
1132 			int idx, int dir)
1133 {
1134 	struct snd_kcontrol_new *knew;
1135 	unsigned int beep_amp = HDA_COMPOSE_AMP_VAL(nid, 3, idx, dir);
1136 	int i;
1137 
1138 	for (i = 0; i < ARRAY_SIZE(alc_beep_mixer); i++) {
1139 		knew = snd_hda_gen_add_kctl(&spec->gen, NULL,
1140 					    &alc_beep_mixer[i]);
1141 		if (!knew)
1142 			return -ENOMEM;
1143 		knew->private_value = beep_amp;
1144 	}
1145 	return 0;
1146 }
1147 
1148 static const struct snd_pci_quirk beep_allow_list[] = {
1149 	SND_PCI_QUIRK(0x1043, 0x103c, "ASUS", 1),
1150 	SND_PCI_QUIRK(0x1043, 0x115d, "ASUS", 1),
1151 	SND_PCI_QUIRK(0x1043, 0x829f, "ASUS", 1),
1152 	SND_PCI_QUIRK(0x1043, 0x8376, "EeePC", 1),
1153 	SND_PCI_QUIRK(0x1043, 0x83ce, "EeePC", 1),
1154 	SND_PCI_QUIRK(0x1043, 0x831a, "EeePC", 1),
1155 	SND_PCI_QUIRK(0x1043, 0x834a, "EeePC", 1),
1156 	SND_PCI_QUIRK(0x1458, 0xa002, "GA-MA790X", 1),
1157 	SND_PCI_QUIRK(0x8086, 0xd613, "Intel", 1),
1158 	/* denylist -- no beep available */
1159 	SND_PCI_QUIRK(0x17aa, 0x309e, "Lenovo ThinkCentre M73", 0),
1160 	SND_PCI_QUIRK(0x17aa, 0x30a3, "Lenovo ThinkCentre M93", 0),
1161 	{}
1162 };
1163 
1164 static inline int has_cdefine_beep(struct hda_codec *codec)
1165 {
1166 	struct alc_spec *spec = codec->spec;
1167 	const struct snd_pci_quirk *q;
1168 	q = snd_pci_quirk_lookup(codec->bus->pci, beep_allow_list);
1169 	if (q)
1170 		return q->value;
1171 	return spec->cdefine.enable_pcbeep;
1172 }
1173 #else
1174 #define set_beep_amp(spec, nid, idx, dir)	0
1175 #define has_cdefine_beep(codec)		0
1176 #endif
1177 
1178 /* parse the BIOS configuration and set up the alc_spec */
1179 /* return 1 if successful, 0 if the proper config is not found,
1180  * or a negative error code
1181  */
1182 static int alc_parse_auto_config(struct hda_codec *codec,
1183 				 const hda_nid_t *ignore_nids,
1184 				 const hda_nid_t *ssid_nids)
1185 {
1186 	struct alc_spec *spec = codec->spec;
1187 	struct auto_pin_cfg *cfg = &spec->gen.autocfg;
1188 	int err;
1189 
1190 	err = snd_hda_parse_pin_defcfg(codec, cfg, ignore_nids,
1191 				       spec->parse_flags);
1192 	if (err < 0)
1193 		return err;
1194 
1195 	if (ssid_nids)
1196 		alc_ssid_check(codec, ssid_nids);
1197 
1198 	err = snd_hda_gen_parse_auto_config(codec, cfg);
1199 	if (err < 0)
1200 		return err;
1201 
1202 	return 1;
1203 }
1204 
1205 /* common preparation job for alc_spec */
1206 static int alc_alloc_spec(struct hda_codec *codec, hda_nid_t mixer_nid)
1207 {
1208 	struct alc_spec *spec = kzalloc(sizeof(*spec), GFP_KERNEL);
1209 	int err;
1210 
1211 	if (!spec)
1212 		return -ENOMEM;
1213 	codec->spec = spec;
1214 	snd_hda_gen_spec_init(&spec->gen);
1215 	spec->gen.mixer_nid = mixer_nid;
1216 	spec->gen.own_eapd_ctl = 1;
1217 	codec->single_adc_amp = 1;
1218 	/* FIXME: do we need this for all Realtek codec models? */
1219 	codec->spdif_status_reset = 1;
1220 	codec->forced_resume = 1;
1221 	codec->patch_ops = alc_patch_ops;
1222 	mutex_init(&spec->coef_mutex);
1223 
1224 	err = alc_codec_rename_from_preset(codec);
1225 	if (err < 0) {
1226 		kfree(spec);
1227 		return err;
1228 	}
1229 	return 0;
1230 }
1231 
1232 static int alc880_parse_auto_config(struct hda_codec *codec)
1233 {
1234 	static const hda_nid_t alc880_ignore[] = { 0x1d, 0 };
1235 	static const hda_nid_t alc880_ssids[] = { 0x15, 0x1b, 0x14, 0 };
1236 	return alc_parse_auto_config(codec, alc880_ignore, alc880_ssids);
1237 }
1238 
1239 /*
1240  * ALC880 fix-ups
1241  */
1242 enum {
1243 	ALC880_FIXUP_GPIO1,
1244 	ALC880_FIXUP_GPIO2,
1245 	ALC880_FIXUP_MEDION_RIM,
1246 	ALC880_FIXUP_LG,
1247 	ALC880_FIXUP_LG_LW25,
1248 	ALC880_FIXUP_W810,
1249 	ALC880_FIXUP_EAPD_COEF,
1250 	ALC880_FIXUP_TCL_S700,
1251 	ALC880_FIXUP_VOL_KNOB,
1252 	ALC880_FIXUP_FUJITSU,
1253 	ALC880_FIXUP_F1734,
1254 	ALC880_FIXUP_UNIWILL,
1255 	ALC880_FIXUP_UNIWILL_DIG,
1256 	ALC880_FIXUP_Z71V,
1257 	ALC880_FIXUP_ASUS_W5A,
1258 	ALC880_FIXUP_3ST_BASE,
1259 	ALC880_FIXUP_3ST,
1260 	ALC880_FIXUP_3ST_DIG,
1261 	ALC880_FIXUP_5ST_BASE,
1262 	ALC880_FIXUP_5ST,
1263 	ALC880_FIXUP_5ST_DIG,
1264 	ALC880_FIXUP_6ST_BASE,
1265 	ALC880_FIXUP_6ST,
1266 	ALC880_FIXUP_6ST_DIG,
1267 	ALC880_FIXUP_6ST_AUTOMUTE,
1268 };
1269 
1270 /* enable the volume-knob widget support on NID 0x21 */
1271 static void alc880_fixup_vol_knob(struct hda_codec *codec,
1272 				  const struct hda_fixup *fix, int action)
1273 {
1274 	if (action == HDA_FIXUP_ACT_PROBE)
1275 		snd_hda_jack_detect_enable_callback(codec, 0x21,
1276 						    alc_update_knob_master);
1277 }
1278 
1279 static const struct hda_fixup alc880_fixups[] = {
1280 	[ALC880_FIXUP_GPIO1] = {
1281 		.type = HDA_FIXUP_FUNC,
1282 		.v.func = alc_fixup_gpio1,
1283 	},
1284 	[ALC880_FIXUP_GPIO2] = {
1285 		.type = HDA_FIXUP_FUNC,
1286 		.v.func = alc_fixup_gpio2,
1287 	},
1288 	[ALC880_FIXUP_MEDION_RIM] = {
1289 		.type = HDA_FIXUP_VERBS,
1290 		.v.verbs = (const struct hda_verb[]) {
1291 			{ 0x20, AC_VERB_SET_COEF_INDEX, 0x07 },
1292 			{ 0x20, AC_VERB_SET_PROC_COEF,  0x3060 },
1293 			{ }
1294 		},
1295 		.chained = true,
1296 		.chain_id = ALC880_FIXUP_GPIO2,
1297 	},
1298 	[ALC880_FIXUP_LG] = {
1299 		.type = HDA_FIXUP_PINS,
1300 		.v.pins = (const struct hda_pintbl[]) {
1301 			/* disable bogus unused pins */
1302 			{ 0x16, 0x411111f0 },
1303 			{ 0x18, 0x411111f0 },
1304 			{ 0x1a, 0x411111f0 },
1305 			{ }
1306 		}
1307 	},
1308 	[ALC880_FIXUP_LG_LW25] = {
1309 		.type = HDA_FIXUP_PINS,
1310 		.v.pins = (const struct hda_pintbl[]) {
1311 			{ 0x1a, 0x0181344f }, /* line-in */
1312 			{ 0x1b, 0x0321403f }, /* headphone */
1313 			{ }
1314 		}
1315 	},
1316 	[ALC880_FIXUP_W810] = {
1317 		.type = HDA_FIXUP_PINS,
1318 		.v.pins = (const struct hda_pintbl[]) {
1319 			/* disable bogus unused pins */
1320 			{ 0x17, 0x411111f0 },
1321 			{ }
1322 		},
1323 		.chained = true,
1324 		.chain_id = ALC880_FIXUP_GPIO2,
1325 	},
1326 	[ALC880_FIXUP_EAPD_COEF] = {
1327 		.type = HDA_FIXUP_VERBS,
1328 		.v.verbs = (const struct hda_verb[]) {
1329 			/* change to EAPD mode */
1330 			{ 0x20, AC_VERB_SET_COEF_INDEX, 0x07 },
1331 			{ 0x20, AC_VERB_SET_PROC_COEF,  0x3060 },
1332 			{}
1333 		},
1334 	},
1335 	[ALC880_FIXUP_TCL_S700] = {
1336 		.type = HDA_FIXUP_VERBS,
1337 		.v.verbs = (const struct hda_verb[]) {
1338 			/* change to EAPD mode */
1339 			{ 0x20, AC_VERB_SET_COEF_INDEX, 0x07 },
1340 			{ 0x20, AC_VERB_SET_PROC_COEF,  0x3070 },
1341 			{}
1342 		},
1343 		.chained = true,
1344 		.chain_id = ALC880_FIXUP_GPIO2,
1345 	},
1346 	[ALC880_FIXUP_VOL_KNOB] = {
1347 		.type = HDA_FIXUP_FUNC,
1348 		.v.func = alc880_fixup_vol_knob,
1349 	},
1350 	[ALC880_FIXUP_FUJITSU] = {
1351 		/* override all pins as BIOS on old Amilo is broken */
1352 		.type = HDA_FIXUP_PINS,
1353 		.v.pins = (const struct hda_pintbl[]) {
1354 			{ 0x14, 0x0121401f }, /* HP */
1355 			{ 0x15, 0x99030120 }, /* speaker */
1356 			{ 0x16, 0x99030130 }, /* bass speaker */
1357 			{ 0x17, 0x411111f0 }, /* N/A */
1358 			{ 0x18, 0x411111f0 }, /* N/A */
1359 			{ 0x19, 0x01a19950 }, /* mic-in */
1360 			{ 0x1a, 0x411111f0 }, /* N/A */
1361 			{ 0x1b, 0x411111f0 }, /* N/A */
1362 			{ 0x1c, 0x411111f0 }, /* N/A */
1363 			{ 0x1d, 0x411111f0 }, /* N/A */
1364 			{ 0x1e, 0x01454140 }, /* SPDIF out */
1365 			{ }
1366 		},
1367 		.chained = true,
1368 		.chain_id = ALC880_FIXUP_VOL_KNOB,
1369 	},
1370 	[ALC880_FIXUP_F1734] = {
1371 		/* almost compatible with FUJITSU, but no bass and SPDIF */
1372 		.type = HDA_FIXUP_PINS,
1373 		.v.pins = (const struct hda_pintbl[]) {
1374 			{ 0x14, 0x0121401f }, /* HP */
1375 			{ 0x15, 0x99030120 }, /* speaker */
1376 			{ 0x16, 0x411111f0 }, /* N/A */
1377 			{ 0x17, 0x411111f0 }, /* N/A */
1378 			{ 0x18, 0x411111f0 }, /* N/A */
1379 			{ 0x19, 0x01a19950 }, /* mic-in */
1380 			{ 0x1a, 0x411111f0 }, /* N/A */
1381 			{ 0x1b, 0x411111f0 }, /* N/A */
1382 			{ 0x1c, 0x411111f0 }, /* N/A */
1383 			{ 0x1d, 0x411111f0 }, /* N/A */
1384 			{ 0x1e, 0x411111f0 }, /* N/A */
1385 			{ }
1386 		},
1387 		.chained = true,
1388 		.chain_id = ALC880_FIXUP_VOL_KNOB,
1389 	},
1390 	[ALC880_FIXUP_UNIWILL] = {
1391 		/* need to fix HP and speaker pins to be parsed correctly */
1392 		.type = HDA_FIXUP_PINS,
1393 		.v.pins = (const struct hda_pintbl[]) {
1394 			{ 0x14, 0x0121411f }, /* HP */
1395 			{ 0x15, 0x99030120 }, /* speaker */
1396 			{ 0x16, 0x99030130 }, /* bass speaker */
1397 			{ }
1398 		},
1399 	},
1400 	[ALC880_FIXUP_UNIWILL_DIG] = {
1401 		.type = HDA_FIXUP_PINS,
1402 		.v.pins = (const struct hda_pintbl[]) {
1403 			/* disable bogus unused pins */
1404 			{ 0x17, 0x411111f0 },
1405 			{ 0x19, 0x411111f0 },
1406 			{ 0x1b, 0x411111f0 },
1407 			{ 0x1f, 0x411111f0 },
1408 			{ }
1409 		}
1410 	},
1411 	[ALC880_FIXUP_Z71V] = {
1412 		.type = HDA_FIXUP_PINS,
1413 		.v.pins = (const struct hda_pintbl[]) {
1414 			/* set up the whole pins as BIOS is utterly broken */
1415 			{ 0x14, 0x99030120 }, /* speaker */
1416 			{ 0x15, 0x0121411f }, /* HP */
1417 			{ 0x16, 0x411111f0 }, /* N/A */
1418 			{ 0x17, 0x411111f0 }, /* N/A */
1419 			{ 0x18, 0x01a19950 }, /* mic-in */
1420 			{ 0x19, 0x411111f0 }, /* N/A */
1421 			{ 0x1a, 0x01813031 }, /* line-in */
1422 			{ 0x1b, 0x411111f0 }, /* N/A */
1423 			{ 0x1c, 0x411111f0 }, /* N/A */
1424 			{ 0x1d, 0x411111f0 }, /* N/A */
1425 			{ 0x1e, 0x0144111e }, /* SPDIF */
1426 			{ }
1427 		}
1428 	},
1429 	[ALC880_FIXUP_ASUS_W5A] = {
1430 		.type = HDA_FIXUP_PINS,
1431 		.v.pins = (const struct hda_pintbl[]) {
1432 			/* set up the whole pins as BIOS is utterly broken */
1433 			{ 0x14, 0x0121411f }, /* HP */
1434 			{ 0x15, 0x411111f0 }, /* N/A */
1435 			{ 0x16, 0x411111f0 }, /* N/A */
1436 			{ 0x17, 0x411111f0 }, /* N/A */
1437 			{ 0x18, 0x90a60160 }, /* mic */
1438 			{ 0x19, 0x411111f0 }, /* N/A */
1439 			{ 0x1a, 0x411111f0 }, /* N/A */
1440 			{ 0x1b, 0x411111f0 }, /* N/A */
1441 			{ 0x1c, 0x411111f0 }, /* N/A */
1442 			{ 0x1d, 0x411111f0 }, /* N/A */
1443 			{ 0x1e, 0xb743111e }, /* SPDIF out */
1444 			{ }
1445 		},
1446 		.chained = true,
1447 		.chain_id = ALC880_FIXUP_GPIO1,
1448 	},
1449 	[ALC880_FIXUP_3ST_BASE] = {
1450 		.type = HDA_FIXUP_PINS,
1451 		.v.pins = (const struct hda_pintbl[]) {
1452 			{ 0x14, 0x01014010 }, /* line-out */
1453 			{ 0x15, 0x411111f0 }, /* N/A */
1454 			{ 0x16, 0x411111f0 }, /* N/A */
1455 			{ 0x17, 0x411111f0 }, /* N/A */
1456 			{ 0x18, 0x01a19c30 }, /* mic-in */
1457 			{ 0x19, 0x0121411f }, /* HP */
1458 			{ 0x1a, 0x01813031 }, /* line-in */
1459 			{ 0x1b, 0x02a19c40 }, /* front-mic */
1460 			{ 0x1c, 0x411111f0 }, /* N/A */
1461 			{ 0x1d, 0x411111f0 }, /* N/A */
1462 			/* 0x1e is filled in below */
1463 			{ 0x1f, 0x411111f0 }, /* N/A */
1464 			{ }
1465 		}
1466 	},
1467 	[ALC880_FIXUP_3ST] = {
1468 		.type = HDA_FIXUP_PINS,
1469 		.v.pins = (const struct hda_pintbl[]) {
1470 			{ 0x1e, 0x411111f0 }, /* N/A */
1471 			{ }
1472 		},
1473 		.chained = true,
1474 		.chain_id = ALC880_FIXUP_3ST_BASE,
1475 	},
1476 	[ALC880_FIXUP_3ST_DIG] = {
1477 		.type = HDA_FIXUP_PINS,
1478 		.v.pins = (const struct hda_pintbl[]) {
1479 			{ 0x1e, 0x0144111e }, /* SPDIF */
1480 			{ }
1481 		},
1482 		.chained = true,
1483 		.chain_id = ALC880_FIXUP_3ST_BASE,
1484 	},
1485 	[ALC880_FIXUP_5ST_BASE] = {
1486 		.type = HDA_FIXUP_PINS,
1487 		.v.pins = (const struct hda_pintbl[]) {
1488 			{ 0x14, 0x01014010 }, /* front */
1489 			{ 0x15, 0x411111f0 }, /* N/A */
1490 			{ 0x16, 0x01011411 }, /* CLFE */
1491 			{ 0x17, 0x01016412 }, /* surr */
1492 			{ 0x18, 0x01a19c30 }, /* mic-in */
1493 			{ 0x19, 0x0121411f }, /* HP */
1494 			{ 0x1a, 0x01813031 }, /* line-in */
1495 			{ 0x1b, 0x02a19c40 }, /* front-mic */
1496 			{ 0x1c, 0x411111f0 }, /* N/A */
1497 			{ 0x1d, 0x411111f0 }, /* N/A */
1498 			/* 0x1e is filled in below */
1499 			{ 0x1f, 0x411111f0 }, /* N/A */
1500 			{ }
1501 		}
1502 	},
1503 	[ALC880_FIXUP_5ST] = {
1504 		.type = HDA_FIXUP_PINS,
1505 		.v.pins = (const struct hda_pintbl[]) {
1506 			{ 0x1e, 0x411111f0 }, /* N/A */
1507 			{ }
1508 		},
1509 		.chained = true,
1510 		.chain_id = ALC880_FIXUP_5ST_BASE,
1511 	},
1512 	[ALC880_FIXUP_5ST_DIG] = {
1513 		.type = HDA_FIXUP_PINS,
1514 		.v.pins = (const struct hda_pintbl[]) {
1515 			{ 0x1e, 0x0144111e }, /* SPDIF */
1516 			{ }
1517 		},
1518 		.chained = true,
1519 		.chain_id = ALC880_FIXUP_5ST_BASE,
1520 	},
1521 	[ALC880_FIXUP_6ST_BASE] = {
1522 		.type = HDA_FIXUP_PINS,
1523 		.v.pins = (const struct hda_pintbl[]) {
1524 			{ 0x14, 0x01014010 }, /* front */
1525 			{ 0x15, 0x01016412 }, /* surr */
1526 			{ 0x16, 0x01011411 }, /* CLFE */
1527 			{ 0x17, 0x01012414 }, /* side */
1528 			{ 0x18, 0x01a19c30 }, /* mic-in */
1529 			{ 0x19, 0x02a19c40 }, /* front-mic */
1530 			{ 0x1a, 0x01813031 }, /* line-in */
1531 			{ 0x1b, 0x0121411f }, /* HP */
1532 			{ 0x1c, 0x411111f0 }, /* N/A */
1533 			{ 0x1d, 0x411111f0 }, /* N/A */
1534 			/* 0x1e is filled in below */
1535 			{ 0x1f, 0x411111f0 }, /* N/A */
1536 			{ }
1537 		}
1538 	},
1539 	[ALC880_FIXUP_6ST] = {
1540 		.type = HDA_FIXUP_PINS,
1541 		.v.pins = (const struct hda_pintbl[]) {
1542 			{ 0x1e, 0x411111f0 }, /* N/A */
1543 			{ }
1544 		},
1545 		.chained = true,
1546 		.chain_id = ALC880_FIXUP_6ST_BASE,
1547 	},
1548 	[ALC880_FIXUP_6ST_DIG] = {
1549 		.type = HDA_FIXUP_PINS,
1550 		.v.pins = (const struct hda_pintbl[]) {
1551 			{ 0x1e, 0x0144111e }, /* SPDIF */
1552 			{ }
1553 		},
1554 		.chained = true,
1555 		.chain_id = ALC880_FIXUP_6ST_BASE,
1556 	},
1557 	[ALC880_FIXUP_6ST_AUTOMUTE] = {
1558 		.type = HDA_FIXUP_PINS,
1559 		.v.pins = (const struct hda_pintbl[]) {
1560 			{ 0x1b, 0x0121401f }, /* HP with jack detect */
1561 			{ }
1562 		},
1563 		.chained_before = true,
1564 		.chain_id = ALC880_FIXUP_6ST_BASE,
1565 	},
1566 };
1567 
1568 static const struct snd_pci_quirk alc880_fixup_tbl[] = {
1569 	SND_PCI_QUIRK(0x1019, 0x0f69, "Coeus G610P", ALC880_FIXUP_W810),
1570 	SND_PCI_QUIRK(0x1043, 0x10c3, "ASUS W5A", ALC880_FIXUP_ASUS_W5A),
1571 	SND_PCI_QUIRK(0x1043, 0x1964, "ASUS Z71V", ALC880_FIXUP_Z71V),
1572 	SND_PCI_QUIRK_VENDOR(0x1043, "ASUS", ALC880_FIXUP_GPIO1),
1573 	SND_PCI_QUIRK(0x147b, 0x1045, "ABit AA8XE", ALC880_FIXUP_6ST_AUTOMUTE),
1574 	SND_PCI_QUIRK(0x1558, 0x5401, "Clevo GPIO2", ALC880_FIXUP_GPIO2),
1575 	SND_PCI_QUIRK_VENDOR(0x1558, "Clevo", ALC880_FIXUP_EAPD_COEF),
1576 	SND_PCI_QUIRK(0x1584, 0x9050, "Uniwill", ALC880_FIXUP_UNIWILL_DIG),
1577 	SND_PCI_QUIRK(0x1584, 0x9054, "Uniwill", ALC880_FIXUP_F1734),
1578 	SND_PCI_QUIRK(0x1584, 0x9070, "Uniwill", ALC880_FIXUP_UNIWILL),
1579 	SND_PCI_QUIRK(0x1584, 0x9077, "Uniwill P53", ALC880_FIXUP_VOL_KNOB),
1580 	SND_PCI_QUIRK(0x161f, 0x203d, "W810", ALC880_FIXUP_W810),
1581 	SND_PCI_QUIRK(0x161f, 0x205d, "Medion Rim 2150", ALC880_FIXUP_MEDION_RIM),
1582 	SND_PCI_QUIRK(0x1631, 0xe011, "PB 13201056", ALC880_FIXUP_6ST_AUTOMUTE),
1583 	SND_PCI_QUIRK(0x1734, 0x107c, "FSC Amilo M1437", ALC880_FIXUP_FUJITSU),
1584 	SND_PCI_QUIRK(0x1734, 0x1094, "FSC Amilo M1451G", ALC880_FIXUP_FUJITSU),
1585 	SND_PCI_QUIRK(0x1734, 0x10ac, "FSC AMILO Xi 1526", ALC880_FIXUP_F1734),
1586 	SND_PCI_QUIRK(0x1734, 0x10b0, "FSC Amilo Pi1556", ALC880_FIXUP_FUJITSU),
1587 	SND_PCI_QUIRK(0x1854, 0x003b, "LG", ALC880_FIXUP_LG),
1588 	SND_PCI_QUIRK(0x1854, 0x005f, "LG P1 Express", ALC880_FIXUP_LG),
1589 	SND_PCI_QUIRK(0x1854, 0x0068, "LG w1", ALC880_FIXUP_LG),
1590 	SND_PCI_QUIRK(0x1854, 0x0077, "LG LW25", ALC880_FIXUP_LG_LW25),
1591 	SND_PCI_QUIRK(0x19db, 0x4188, "TCL S700", ALC880_FIXUP_TCL_S700),
1592 
1593 	/* Below is the copied entries from alc880_quirks.c.
1594 	 * It's not quite sure whether BIOS sets the correct pin-config table
1595 	 * on these machines, thus they are kept to be compatible with
1596 	 * the old static quirks.  Once when it's confirmed to work without
1597 	 * these overrides, it'd be better to remove.
1598 	 */
1599 	SND_PCI_QUIRK(0x1019, 0xa880, "ECS", ALC880_FIXUP_5ST_DIG),
1600 	SND_PCI_QUIRK(0x1019, 0xa884, "Acer APFV", ALC880_FIXUP_6ST),
1601 	SND_PCI_QUIRK(0x1025, 0x0070, "ULI", ALC880_FIXUP_3ST_DIG),
1602 	SND_PCI_QUIRK(0x1025, 0x0077, "ULI", ALC880_FIXUP_6ST_DIG),
1603 	SND_PCI_QUIRK(0x1025, 0x0078, "ULI", ALC880_FIXUP_6ST_DIG),
1604 	SND_PCI_QUIRK(0x1025, 0x0087, "ULI", ALC880_FIXUP_6ST_DIG),
1605 	SND_PCI_QUIRK(0x1025, 0xe309, "ULI", ALC880_FIXUP_3ST_DIG),
1606 	SND_PCI_QUIRK(0x1025, 0xe310, "ULI", ALC880_FIXUP_3ST),
1607 	SND_PCI_QUIRK(0x1039, 0x1234, NULL, ALC880_FIXUP_6ST_DIG),
1608 	SND_PCI_QUIRK(0x104d, 0x81a0, "Sony", ALC880_FIXUP_3ST),
1609 	SND_PCI_QUIRK(0x104d, 0x81d6, "Sony", ALC880_FIXUP_3ST),
1610 	SND_PCI_QUIRK(0x107b, 0x3032, "Gateway", ALC880_FIXUP_5ST),
1611 	SND_PCI_QUIRK(0x107b, 0x3033, "Gateway", ALC880_FIXUP_5ST),
1612 	SND_PCI_QUIRK(0x107b, 0x4039, "Gateway", ALC880_FIXUP_5ST),
1613 	SND_PCI_QUIRK(0x1297, 0xc790, "Shuttle ST20G5", ALC880_FIXUP_6ST_DIG),
1614 	SND_PCI_QUIRK(0x1458, 0xa102, "Gigabyte K8", ALC880_FIXUP_6ST_DIG),
1615 	SND_PCI_QUIRK(0x1462, 0x1150, "MSI", ALC880_FIXUP_6ST_DIG),
1616 	SND_PCI_QUIRK(0x1509, 0x925d, "FIC P4M", ALC880_FIXUP_6ST_DIG),
1617 	SND_PCI_QUIRK(0x1565, 0x8202, "Biostar", ALC880_FIXUP_5ST_DIG),
1618 	SND_PCI_QUIRK(0x1695, 0x400d, "EPoX", ALC880_FIXUP_5ST_DIG),
1619 	SND_PCI_QUIRK(0x1695, 0x4012, "EPox EP-5LDA", ALC880_FIXUP_5ST_DIG),
1620 	SND_PCI_QUIRK(0x2668, 0x8086, NULL, ALC880_FIXUP_6ST_DIG), /* broken BIOS */
1621 	SND_PCI_QUIRK(0x8086, 0x2668, NULL, ALC880_FIXUP_6ST_DIG),
1622 	SND_PCI_QUIRK(0x8086, 0xa100, "Intel mobo", ALC880_FIXUP_5ST_DIG),
1623 	SND_PCI_QUIRK(0x8086, 0xd400, "Intel mobo", ALC880_FIXUP_5ST_DIG),
1624 	SND_PCI_QUIRK(0x8086, 0xd401, "Intel mobo", ALC880_FIXUP_5ST_DIG),
1625 	SND_PCI_QUIRK(0x8086, 0xd402, "Intel mobo", ALC880_FIXUP_3ST_DIG),
1626 	SND_PCI_QUIRK(0x8086, 0xe224, "Intel mobo", ALC880_FIXUP_5ST_DIG),
1627 	SND_PCI_QUIRK(0x8086, 0xe305, "Intel mobo", ALC880_FIXUP_3ST_DIG),
1628 	SND_PCI_QUIRK(0x8086, 0xe308, "Intel mobo", ALC880_FIXUP_3ST_DIG),
1629 	SND_PCI_QUIRK(0x8086, 0xe400, "Intel mobo", ALC880_FIXUP_5ST_DIG),
1630 	SND_PCI_QUIRK(0x8086, 0xe401, "Intel mobo", ALC880_FIXUP_5ST_DIG),
1631 	SND_PCI_QUIRK(0x8086, 0xe402, "Intel mobo", ALC880_FIXUP_5ST_DIG),
1632 	/* default Intel */
1633 	SND_PCI_QUIRK_VENDOR(0x8086, "Intel mobo", ALC880_FIXUP_3ST),
1634 	SND_PCI_QUIRK(0xa0a0, 0x0560, "AOpen i915GMm-HFS", ALC880_FIXUP_5ST_DIG),
1635 	SND_PCI_QUIRK(0xe803, 0x1019, NULL, ALC880_FIXUP_6ST_DIG),
1636 	{}
1637 };
1638 
1639 static const struct hda_model_fixup alc880_fixup_models[] = {
1640 	{.id = ALC880_FIXUP_3ST, .name = "3stack"},
1641 	{.id = ALC880_FIXUP_3ST_DIG, .name = "3stack-digout"},
1642 	{.id = ALC880_FIXUP_5ST, .name = "5stack"},
1643 	{.id = ALC880_FIXUP_5ST_DIG, .name = "5stack-digout"},
1644 	{.id = ALC880_FIXUP_6ST, .name = "6stack"},
1645 	{.id = ALC880_FIXUP_6ST_DIG, .name = "6stack-digout"},
1646 	{.id = ALC880_FIXUP_6ST_AUTOMUTE, .name = "6stack-automute"},
1647 	{}
1648 };
1649 
1650 
1651 /*
1652  * OK, here we have finally the patch for ALC880
1653  */
1654 static int patch_alc880(struct hda_codec *codec)
1655 {
1656 	struct alc_spec *spec;
1657 	int err;
1658 
1659 	err = alc_alloc_spec(codec, 0x0b);
1660 	if (err < 0)
1661 		return err;
1662 
1663 	spec = codec->spec;
1664 	spec->gen.need_dac_fix = 1;
1665 	spec->gen.beep_nid = 0x01;
1666 
1667 	codec->patch_ops.unsol_event = alc880_unsol_event;
1668 
1669 	alc_pre_init(codec);
1670 
1671 	snd_hda_pick_fixup(codec, alc880_fixup_models, alc880_fixup_tbl,
1672 		       alc880_fixups);
1673 	snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE);
1674 
1675 	/* automatic parse from the BIOS config */
1676 	err = alc880_parse_auto_config(codec);
1677 	if (err < 0)
1678 		goto error;
1679 
1680 	if (!spec->gen.no_analog) {
1681 		err = set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
1682 		if (err < 0)
1683 			goto error;
1684 	}
1685 
1686 	snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE);
1687 
1688 	return 0;
1689 
1690  error:
1691 	alc_free(codec);
1692 	return err;
1693 }
1694 
1695 
1696 /*
1697  * ALC260 support
1698  */
1699 static int alc260_parse_auto_config(struct hda_codec *codec)
1700 {
1701 	static const hda_nid_t alc260_ignore[] = { 0x17, 0 };
1702 	static const hda_nid_t alc260_ssids[] = { 0x10, 0x15, 0x0f, 0 };
1703 	return alc_parse_auto_config(codec, alc260_ignore, alc260_ssids);
1704 }
1705 
1706 /*
1707  * Pin config fixes
1708  */
1709 enum {
1710 	ALC260_FIXUP_HP_DC5750,
1711 	ALC260_FIXUP_HP_PIN_0F,
1712 	ALC260_FIXUP_COEF,
1713 	ALC260_FIXUP_GPIO1,
1714 	ALC260_FIXUP_GPIO1_TOGGLE,
1715 	ALC260_FIXUP_REPLACER,
1716 	ALC260_FIXUP_HP_B1900,
1717 	ALC260_FIXUP_KN1,
1718 	ALC260_FIXUP_FSC_S7020,
1719 	ALC260_FIXUP_FSC_S7020_JWSE,
1720 	ALC260_FIXUP_VAIO_PINS,
1721 };
1722 
1723 static void alc260_gpio1_automute(struct hda_codec *codec)
1724 {
1725 	struct alc_spec *spec = codec->spec;
1726 
1727 	alc_update_gpio_data(codec, 0x01, spec->gen.hp_jack_present);
1728 }
1729 
1730 static void alc260_fixup_gpio1_toggle(struct hda_codec *codec,
1731 				      const struct hda_fixup *fix, int action)
1732 {
1733 	struct alc_spec *spec = codec->spec;
1734 	if (action == HDA_FIXUP_ACT_PROBE) {
1735 		/* although the machine has only one output pin, we need to
1736 		 * toggle GPIO1 according to the jack state
1737 		 */
1738 		spec->gen.automute_hook = alc260_gpio1_automute;
1739 		spec->gen.detect_hp = 1;
1740 		spec->gen.automute_speaker = 1;
1741 		spec->gen.autocfg.hp_pins[0] = 0x0f; /* copy it for automute */
1742 		snd_hda_jack_detect_enable_callback(codec, 0x0f,
1743 						    snd_hda_gen_hp_automute);
1744 		alc_setup_gpio(codec, 0x01);
1745 	}
1746 }
1747 
1748 static void alc260_fixup_kn1(struct hda_codec *codec,
1749 			     const struct hda_fixup *fix, int action)
1750 {
1751 	struct alc_spec *spec = codec->spec;
1752 	static const struct hda_pintbl pincfgs[] = {
1753 		{ 0x0f, 0x02214000 }, /* HP/speaker */
1754 		{ 0x12, 0x90a60160 }, /* int mic */
1755 		{ 0x13, 0x02a19000 }, /* ext mic */
1756 		{ 0x18, 0x01446000 }, /* SPDIF out */
1757 		/* disable bogus I/O pins */
1758 		{ 0x10, 0x411111f0 },
1759 		{ 0x11, 0x411111f0 },
1760 		{ 0x14, 0x411111f0 },
1761 		{ 0x15, 0x411111f0 },
1762 		{ 0x16, 0x411111f0 },
1763 		{ 0x17, 0x411111f0 },
1764 		{ 0x19, 0x411111f0 },
1765 		{ }
1766 	};
1767 
1768 	switch (action) {
1769 	case HDA_FIXUP_ACT_PRE_PROBE:
1770 		snd_hda_apply_pincfgs(codec, pincfgs);
1771 		spec->init_amp = ALC_INIT_NONE;
1772 		break;
1773 	}
1774 }
1775 
1776 static void alc260_fixup_fsc_s7020(struct hda_codec *codec,
1777 				   const struct hda_fixup *fix, int action)
1778 {
1779 	struct alc_spec *spec = codec->spec;
1780 	if (action == HDA_FIXUP_ACT_PRE_PROBE)
1781 		spec->init_amp = ALC_INIT_NONE;
1782 }
1783 
1784 static void alc260_fixup_fsc_s7020_jwse(struct hda_codec *codec,
1785 				   const struct hda_fixup *fix, int action)
1786 {
1787 	struct alc_spec *spec = codec->spec;
1788 	if (action == HDA_FIXUP_ACT_PRE_PROBE) {
1789 		spec->gen.add_jack_modes = 1;
1790 		spec->gen.hp_mic = 1;
1791 	}
1792 }
1793 
1794 static const struct hda_fixup alc260_fixups[] = {
1795 	[ALC260_FIXUP_HP_DC5750] = {
1796 		.type = HDA_FIXUP_PINS,
1797 		.v.pins = (const struct hda_pintbl[]) {
1798 			{ 0x11, 0x90130110 }, /* speaker */
1799 			{ }
1800 		}
1801 	},
1802 	[ALC260_FIXUP_HP_PIN_0F] = {
1803 		.type = HDA_FIXUP_PINS,
1804 		.v.pins = (const struct hda_pintbl[]) {
1805 			{ 0x0f, 0x01214000 }, /* HP */
1806 			{ }
1807 		}
1808 	},
1809 	[ALC260_FIXUP_COEF] = {
1810 		.type = HDA_FIXUP_VERBS,
1811 		.v.verbs = (const struct hda_verb[]) {
1812 			{ 0x1a, AC_VERB_SET_COEF_INDEX, 0x07 },
1813 			{ 0x1a, AC_VERB_SET_PROC_COEF,  0x3040 },
1814 			{ }
1815 		},
1816 	},
1817 	[ALC260_FIXUP_GPIO1] = {
1818 		.type = HDA_FIXUP_FUNC,
1819 		.v.func = alc_fixup_gpio1,
1820 	},
1821 	[ALC260_FIXUP_GPIO1_TOGGLE] = {
1822 		.type = HDA_FIXUP_FUNC,
1823 		.v.func = alc260_fixup_gpio1_toggle,
1824 		.chained = true,
1825 		.chain_id = ALC260_FIXUP_HP_PIN_0F,
1826 	},
1827 	[ALC260_FIXUP_REPLACER] = {
1828 		.type = HDA_FIXUP_VERBS,
1829 		.v.verbs = (const struct hda_verb[]) {
1830 			{ 0x1a, AC_VERB_SET_COEF_INDEX, 0x07 },
1831 			{ 0x1a, AC_VERB_SET_PROC_COEF,  0x3050 },
1832 			{ }
1833 		},
1834 		.chained = true,
1835 		.chain_id = ALC260_FIXUP_GPIO1_TOGGLE,
1836 	},
1837 	[ALC260_FIXUP_HP_B1900] = {
1838 		.type = HDA_FIXUP_FUNC,
1839 		.v.func = alc260_fixup_gpio1_toggle,
1840 		.chained = true,
1841 		.chain_id = ALC260_FIXUP_COEF,
1842 	},
1843 	[ALC260_FIXUP_KN1] = {
1844 		.type = HDA_FIXUP_FUNC,
1845 		.v.func = alc260_fixup_kn1,
1846 	},
1847 	[ALC260_FIXUP_FSC_S7020] = {
1848 		.type = HDA_FIXUP_FUNC,
1849 		.v.func = alc260_fixup_fsc_s7020,
1850 	},
1851 	[ALC260_FIXUP_FSC_S7020_JWSE] = {
1852 		.type = HDA_FIXUP_FUNC,
1853 		.v.func = alc260_fixup_fsc_s7020_jwse,
1854 		.chained = true,
1855 		.chain_id = ALC260_FIXUP_FSC_S7020,
1856 	},
1857 	[ALC260_FIXUP_VAIO_PINS] = {
1858 		.type = HDA_FIXUP_PINS,
1859 		.v.pins = (const struct hda_pintbl[]) {
1860 			/* Pin configs are missing completely on some VAIOs */
1861 			{ 0x0f, 0x01211020 },
1862 			{ 0x10, 0x0001003f },
1863 			{ 0x11, 0x411111f0 },
1864 			{ 0x12, 0x01a15930 },
1865 			{ 0x13, 0x411111f0 },
1866 			{ 0x14, 0x411111f0 },
1867 			{ 0x15, 0x411111f0 },
1868 			{ 0x16, 0x411111f0 },
1869 			{ 0x17, 0x411111f0 },
1870 			{ 0x18, 0x411111f0 },
1871 			{ 0x19, 0x411111f0 },
1872 			{ }
1873 		}
1874 	},
1875 };
1876 
1877 static const struct snd_pci_quirk alc260_fixup_tbl[] = {
1878 	SND_PCI_QUIRK(0x1025, 0x007b, "Acer C20x", ALC260_FIXUP_GPIO1),
1879 	SND_PCI_QUIRK(0x1025, 0x007f, "Acer Aspire 9500", ALC260_FIXUP_COEF),
1880 	SND_PCI_QUIRK(0x1025, 0x008f, "Acer", ALC260_FIXUP_GPIO1),
1881 	SND_PCI_QUIRK(0x103c, 0x280a, "HP dc5750", ALC260_FIXUP_HP_DC5750),
1882 	SND_PCI_QUIRK(0x103c, 0x30ba, "HP Presario B1900", ALC260_FIXUP_HP_B1900),
1883 	SND_PCI_QUIRK(0x104d, 0x81bb, "Sony VAIO", ALC260_FIXUP_VAIO_PINS),
1884 	SND_PCI_QUIRK(0x104d, 0x81e2, "Sony VAIO TX", ALC260_FIXUP_HP_PIN_0F),
1885 	SND_PCI_QUIRK(0x10cf, 0x1326, "FSC LifeBook S7020", ALC260_FIXUP_FSC_S7020),
1886 	SND_PCI_QUIRK(0x1509, 0x4540, "Favorit 100XS", ALC260_FIXUP_GPIO1),
1887 	SND_PCI_QUIRK(0x152d, 0x0729, "Quanta KN1", ALC260_FIXUP_KN1),
1888 	SND_PCI_QUIRK(0x161f, 0x2057, "Replacer 672V", ALC260_FIXUP_REPLACER),
1889 	SND_PCI_QUIRK(0x1631, 0xc017, "PB V7900", ALC260_FIXUP_COEF),
1890 	{}
1891 };
1892 
1893 static const struct hda_model_fixup alc260_fixup_models[] = {
1894 	{.id = ALC260_FIXUP_GPIO1, .name = "gpio1"},
1895 	{.id = ALC260_FIXUP_COEF, .name = "coef"},
1896 	{.id = ALC260_FIXUP_FSC_S7020, .name = "fujitsu"},
1897 	{.id = ALC260_FIXUP_FSC_S7020_JWSE, .name = "fujitsu-jwse"},
1898 	{}
1899 };
1900 
1901 /*
1902  */
1903 static int patch_alc260(struct hda_codec *codec)
1904 {
1905 	struct alc_spec *spec;
1906 	int err;
1907 
1908 	err = alc_alloc_spec(codec, 0x07);
1909 	if (err < 0)
1910 		return err;
1911 
1912 	spec = codec->spec;
1913 	/* as quite a few machines require HP amp for speaker outputs,
1914 	 * it's easier to enable it unconditionally; even if it's unneeded,
1915 	 * it's almost harmless.
1916 	 */
1917 	spec->gen.prefer_hp_amp = 1;
1918 	spec->gen.beep_nid = 0x01;
1919 
1920 	spec->shutup = alc_eapd_shutup;
1921 
1922 	alc_pre_init(codec);
1923 
1924 	snd_hda_pick_fixup(codec, alc260_fixup_models, alc260_fixup_tbl,
1925 			   alc260_fixups);
1926 	snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE);
1927 
1928 	/* automatic parse from the BIOS config */
1929 	err = alc260_parse_auto_config(codec);
1930 	if (err < 0)
1931 		goto error;
1932 
1933 	if (!spec->gen.no_analog) {
1934 		err = set_beep_amp(spec, 0x07, 0x05, HDA_INPUT);
1935 		if (err < 0)
1936 			goto error;
1937 	}
1938 
1939 	snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE);
1940 
1941 	return 0;
1942 
1943  error:
1944 	alc_free(codec);
1945 	return err;
1946 }
1947 
1948 
1949 /*
1950  * ALC882/883/885/888/889 support
1951  *
1952  * ALC882 is almost identical with ALC880 but has cleaner and more flexible
1953  * configuration.  Each pin widget can choose any input DACs and a mixer.
1954  * Each ADC is connected from a mixer of all inputs.  This makes possible
1955  * 6-channel independent captures.
1956  *
1957  * In addition, an independent DAC for the multi-playback (not used in this
1958  * driver yet).
1959  */
1960 
1961 /*
1962  * Pin config fixes
1963  */
1964 enum {
1965 	ALC882_FIXUP_ABIT_AW9D_MAX,
1966 	ALC882_FIXUP_LENOVO_Y530,
1967 	ALC882_FIXUP_PB_M5210,
1968 	ALC882_FIXUP_ACER_ASPIRE_7736,
1969 	ALC882_FIXUP_ASUS_W90V,
1970 	ALC889_FIXUP_CD,
1971 	ALC889_FIXUP_FRONT_HP_NO_PRESENCE,
1972 	ALC889_FIXUP_VAIO_TT,
1973 	ALC888_FIXUP_EEE1601,
1974 	ALC886_FIXUP_EAPD,
1975 	ALC882_FIXUP_EAPD,
1976 	ALC883_FIXUP_EAPD,
1977 	ALC883_FIXUP_ACER_EAPD,
1978 	ALC882_FIXUP_GPIO1,
1979 	ALC882_FIXUP_GPIO2,
1980 	ALC882_FIXUP_GPIO3,
1981 	ALC889_FIXUP_COEF,
1982 	ALC882_FIXUP_ASUS_W2JC,
1983 	ALC882_FIXUP_ACER_ASPIRE_4930G,
1984 	ALC882_FIXUP_ACER_ASPIRE_8930G,
1985 	ALC882_FIXUP_ASPIRE_8930G_VERBS,
1986 	ALC885_FIXUP_MACPRO_GPIO,
1987 	ALC889_FIXUP_DAC_ROUTE,
1988 	ALC889_FIXUP_MBP_VREF,
1989 	ALC889_FIXUP_IMAC91_VREF,
1990 	ALC889_FIXUP_MBA11_VREF,
1991 	ALC889_FIXUP_MBA21_VREF,
1992 	ALC889_FIXUP_MP11_VREF,
1993 	ALC889_FIXUP_MP41_VREF,
1994 	ALC882_FIXUP_INV_DMIC,
1995 	ALC882_FIXUP_NO_PRIMARY_HP,
1996 	ALC887_FIXUP_ASUS_BASS,
1997 	ALC887_FIXUP_BASS_CHMAP,
1998 	ALC1220_FIXUP_GB_DUAL_CODECS,
1999 	ALC1220_FIXUP_GB_X570,
2000 	ALC1220_FIXUP_CLEVO_P950,
2001 	ALC1220_FIXUP_CLEVO_PB51ED,
2002 	ALC1220_FIXUP_CLEVO_PB51ED_PINS,
2003 	ALC887_FIXUP_ASUS_AUDIO,
2004 	ALC887_FIXUP_ASUS_HMIC,
2005 	ALCS1200A_FIXUP_MIC_VREF,
2006 	ALC888VD_FIXUP_MIC_100VREF,
2007 };
2008 
2009 static void alc889_fixup_coef(struct hda_codec *codec,
2010 			      const struct hda_fixup *fix, int action)
2011 {
2012 	if (action != HDA_FIXUP_ACT_INIT)
2013 		return;
2014 	alc_update_coef_idx(codec, 7, 0, 0x2030);
2015 }
2016 
2017 /* set up GPIO at initialization */
2018 static void alc885_fixup_macpro_gpio(struct hda_codec *codec,
2019 				     const struct hda_fixup *fix, int action)
2020 {
2021 	struct alc_spec *spec = codec->spec;
2022 
2023 	spec->gpio_write_delay = true;
2024 	alc_fixup_gpio3(codec, fix, action);
2025 }
2026 
2027 /* Fix the connection of some pins for ALC889:
2028  * At least, Acer Aspire 5935 shows the connections to DAC3/4 don't
2029  * work correctly (bko#42740)
2030  */
2031 static void alc889_fixup_dac_route(struct hda_codec *codec,
2032 				   const struct hda_fixup *fix, int action)
2033 {
2034 	if (action == HDA_FIXUP_ACT_PRE_PROBE) {
2035 		/* fake the connections during parsing the tree */
2036 		static const hda_nid_t conn1[] = { 0x0c, 0x0d };
2037 		static const hda_nid_t conn2[] = { 0x0e, 0x0f };
2038 		snd_hda_override_conn_list(codec, 0x14, ARRAY_SIZE(conn1), conn1);
2039 		snd_hda_override_conn_list(codec, 0x15, ARRAY_SIZE(conn1), conn1);
2040 		snd_hda_override_conn_list(codec, 0x18, ARRAY_SIZE(conn2), conn2);
2041 		snd_hda_override_conn_list(codec, 0x1a, ARRAY_SIZE(conn2), conn2);
2042 	} else if (action == HDA_FIXUP_ACT_PROBE) {
2043 		/* restore the connections */
2044 		static const hda_nid_t conn[] = { 0x0c, 0x0d, 0x0e, 0x0f, 0x26 };
2045 		snd_hda_override_conn_list(codec, 0x14, ARRAY_SIZE(conn), conn);
2046 		snd_hda_override_conn_list(codec, 0x15, ARRAY_SIZE(conn), conn);
2047 		snd_hda_override_conn_list(codec, 0x18, ARRAY_SIZE(conn), conn);
2048 		snd_hda_override_conn_list(codec, 0x1a, ARRAY_SIZE(conn), conn);
2049 	}
2050 }
2051 
2052 /* Set VREF on HP pin */
2053 static void alc889_fixup_mbp_vref(struct hda_codec *codec,
2054 				  const struct hda_fixup *fix, int action)
2055 {
2056 	static const hda_nid_t nids[] = { 0x14, 0x15, 0x19 };
2057 	struct alc_spec *spec = codec->spec;
2058 	int i;
2059 
2060 	if (action != HDA_FIXUP_ACT_INIT)
2061 		return;
2062 	for (i = 0; i < ARRAY_SIZE(nids); i++) {
2063 		unsigned int val = snd_hda_codec_get_pincfg(codec, nids[i]);
2064 		if (get_defcfg_device(val) != AC_JACK_HP_OUT)
2065 			continue;
2066 		val = snd_hda_codec_get_pin_target(codec, nids[i]);
2067 		val |= AC_PINCTL_VREF_80;
2068 		snd_hda_set_pin_ctl(codec, nids[i], val);
2069 		spec->gen.keep_vref_in_automute = 1;
2070 		break;
2071 	}
2072 }
2073 
2074 static void alc889_fixup_mac_pins(struct hda_codec *codec,
2075 				  const hda_nid_t *nids, int num_nids)
2076 {
2077 	struct alc_spec *spec = codec->spec;
2078 	int i;
2079 
2080 	for (i = 0; i < num_nids; i++) {
2081 		unsigned int val;
2082 		val = snd_hda_codec_get_pin_target(codec, nids[i]);
2083 		val |= AC_PINCTL_VREF_50;
2084 		snd_hda_set_pin_ctl(codec, nids[i], val);
2085 	}
2086 	spec->gen.keep_vref_in_automute = 1;
2087 }
2088 
2089 /* Set VREF on speaker pins on imac91 */
2090 static void alc889_fixup_imac91_vref(struct hda_codec *codec,
2091 				     const struct hda_fixup *fix, int action)
2092 {
2093 	static const hda_nid_t nids[] = { 0x18, 0x1a };
2094 
2095 	if (action == HDA_FIXUP_ACT_INIT)
2096 		alc889_fixup_mac_pins(codec, nids, ARRAY_SIZE(nids));
2097 }
2098 
2099 /* Set VREF on speaker pins on mba11 */
2100 static void alc889_fixup_mba11_vref(struct hda_codec *codec,
2101 				    const struct hda_fixup *fix, int action)
2102 {
2103 	static const hda_nid_t nids[] = { 0x18 };
2104 
2105 	if (action == HDA_FIXUP_ACT_INIT)
2106 		alc889_fixup_mac_pins(codec, nids, ARRAY_SIZE(nids));
2107 }
2108 
2109 /* Set VREF on speaker pins on mba21 */
2110 static void alc889_fixup_mba21_vref(struct hda_codec *codec,
2111 				    const struct hda_fixup *fix, int action)
2112 {
2113 	static const hda_nid_t nids[] = { 0x18, 0x19 };
2114 
2115 	if (action == HDA_FIXUP_ACT_INIT)
2116 		alc889_fixup_mac_pins(codec, nids, ARRAY_SIZE(nids));
2117 }
2118 
2119 /* Don't take HP output as primary
2120  * Strangely, the speaker output doesn't work on Vaio Z and some Vaio
2121  * all-in-one desktop PCs (for example VGC-LN51JGB) through DAC 0x05
2122  */
2123 static void alc882_fixup_no_primary_hp(struct hda_codec *codec,
2124 				       const struct hda_fixup *fix, int action)
2125 {
2126 	struct alc_spec *spec = codec->spec;
2127 	if (action == HDA_FIXUP_ACT_PRE_PROBE) {
2128 		spec->gen.no_primary_hp = 1;
2129 		spec->gen.no_multi_io = 1;
2130 	}
2131 }
2132 
2133 static void alc_fixup_bass_chmap(struct hda_codec *codec,
2134 				 const struct hda_fixup *fix, int action);
2135 
2136 /* For dual-codec configuration, we need to disable some features to avoid
2137  * conflicts of kctls and PCM streams
2138  */
2139 static void alc_fixup_dual_codecs(struct hda_codec *codec,
2140 				  const struct hda_fixup *fix, int action)
2141 {
2142 	struct alc_spec *spec = codec->spec;
2143 
2144 	if (action != HDA_FIXUP_ACT_PRE_PROBE)
2145 		return;
2146 	/* disable vmaster */
2147 	spec->gen.suppress_vmaster = 1;
2148 	/* auto-mute and auto-mic switch don't work with multiple codecs */
2149 	spec->gen.suppress_auto_mute = 1;
2150 	spec->gen.suppress_auto_mic = 1;
2151 	/* disable aamix as well */
2152 	spec->gen.mixer_nid = 0;
2153 	/* add location prefix to avoid conflicts */
2154 	codec->force_pin_prefix = 1;
2155 }
2156 
2157 static void rename_ctl(struct hda_codec *codec, const char *oldname,
2158 		       const char *newname)
2159 {
2160 	struct snd_kcontrol *kctl;
2161 
2162 	kctl = snd_hda_find_mixer_ctl(codec, oldname);
2163 	if (kctl)
2164 		snd_ctl_rename(codec->card, kctl, newname);
2165 }
2166 
2167 static void alc1220_fixup_gb_dual_codecs(struct hda_codec *codec,
2168 					 const struct hda_fixup *fix,
2169 					 int action)
2170 {
2171 	alc_fixup_dual_codecs(codec, fix, action);
2172 	switch (action) {
2173 	case HDA_FIXUP_ACT_PRE_PROBE:
2174 		/* override card longname to provide a unique UCM profile */
2175 		strcpy(codec->card->longname, "HDAudio-Gigabyte-ALC1220DualCodecs");
2176 		break;
2177 	case HDA_FIXUP_ACT_BUILD:
2178 		/* rename Capture controls depending on the codec */
2179 		rename_ctl(codec, "Capture Volume",
2180 			   codec->addr == 0 ?
2181 			   "Rear-Panel Capture Volume" :
2182 			   "Front-Panel Capture Volume");
2183 		rename_ctl(codec, "Capture Switch",
2184 			   codec->addr == 0 ?
2185 			   "Rear-Panel Capture Switch" :
2186 			   "Front-Panel Capture Switch");
2187 		break;
2188 	}
2189 }
2190 
2191 static void alc1220_fixup_gb_x570(struct hda_codec *codec,
2192 				     const struct hda_fixup *fix,
2193 				     int action)
2194 {
2195 	static const hda_nid_t conn1[] = { 0x0c };
2196 	static const struct coef_fw gb_x570_coefs[] = {
2197 		WRITE_COEF(0x07, 0x03c0),
2198 		WRITE_COEF(0x1a, 0x01c1),
2199 		WRITE_COEF(0x1b, 0x0202),
2200 		WRITE_COEF(0x43, 0x3005),
2201 		{}
2202 	};
2203 
2204 	switch (action) {
2205 	case HDA_FIXUP_ACT_PRE_PROBE:
2206 		snd_hda_override_conn_list(codec, 0x14, ARRAY_SIZE(conn1), conn1);
2207 		snd_hda_override_conn_list(codec, 0x1b, ARRAY_SIZE(conn1), conn1);
2208 		break;
2209 	case HDA_FIXUP_ACT_INIT:
2210 		alc_process_coef_fw(codec, gb_x570_coefs);
2211 		break;
2212 	}
2213 }
2214 
2215 static void alc1220_fixup_clevo_p950(struct hda_codec *codec,
2216 				     const struct hda_fixup *fix,
2217 				     int action)
2218 {
2219 	static const hda_nid_t conn1[] = { 0x0c };
2220 
2221 	if (action != HDA_FIXUP_ACT_PRE_PROBE)
2222 		return;
2223 
2224 	alc_update_coef_idx(codec, 0x7, 0, 0x3c3);
2225 	/* We therefore want to make sure 0x14 (front headphone) and
2226 	 * 0x1b (speakers) use the stereo DAC 0x02
2227 	 */
2228 	snd_hda_override_conn_list(codec, 0x14, ARRAY_SIZE(conn1), conn1);
2229 	snd_hda_override_conn_list(codec, 0x1b, ARRAY_SIZE(conn1), conn1);
2230 }
2231 
2232 static void alc_fixup_headset_mode_no_hp_mic(struct hda_codec *codec,
2233 				const struct hda_fixup *fix, int action);
2234 
2235 static void alc1220_fixup_clevo_pb51ed(struct hda_codec *codec,
2236 				     const struct hda_fixup *fix,
2237 				     int action)
2238 {
2239 	alc1220_fixup_clevo_p950(codec, fix, action);
2240 	alc_fixup_headset_mode_no_hp_mic(codec, fix, action);
2241 }
2242 
2243 static void alc887_asus_hp_automute_hook(struct hda_codec *codec,
2244 					 struct hda_jack_callback *jack)
2245 {
2246 	struct alc_spec *spec = codec->spec;
2247 	unsigned int vref;
2248 
2249 	snd_hda_gen_hp_automute(codec, jack);
2250 
2251 	if (spec->gen.hp_jack_present)
2252 		vref = AC_PINCTL_VREF_80;
2253 	else
2254 		vref = AC_PINCTL_VREF_HIZ;
2255 	snd_hda_set_pin_ctl(codec, 0x19, PIN_HP | vref);
2256 }
2257 
2258 static void alc887_fixup_asus_jack(struct hda_codec *codec,
2259 				     const struct hda_fixup *fix, int action)
2260 {
2261 	struct alc_spec *spec = codec->spec;
2262 	if (action != HDA_FIXUP_ACT_PROBE)
2263 		return;
2264 	snd_hda_set_pin_ctl_cache(codec, 0x1b, PIN_HP);
2265 	spec->gen.hp_automute_hook = alc887_asus_hp_automute_hook;
2266 }
2267 
2268 static const struct hda_fixup alc882_fixups[] = {
2269 	[ALC882_FIXUP_ABIT_AW9D_MAX] = {
2270 		.type = HDA_FIXUP_PINS,
2271 		.v.pins = (const struct hda_pintbl[]) {
2272 			{ 0x15, 0x01080104 }, /* side */
2273 			{ 0x16, 0x01011012 }, /* rear */
2274 			{ 0x17, 0x01016011 }, /* clfe */
2275 			{ }
2276 		}
2277 	},
2278 	[ALC882_FIXUP_LENOVO_Y530] = {
2279 		.type = HDA_FIXUP_PINS,
2280 		.v.pins = (const struct hda_pintbl[]) {
2281 			{ 0x15, 0x99130112 }, /* rear int speakers */
2282 			{ 0x16, 0x99130111 }, /* subwoofer */
2283 			{ }
2284 		}
2285 	},
2286 	[ALC882_FIXUP_PB_M5210] = {
2287 		.type = HDA_FIXUP_PINCTLS,
2288 		.v.pins = (const struct hda_pintbl[]) {
2289 			{ 0x19, PIN_VREF50 },
2290 			{}
2291 		}
2292 	},
2293 	[ALC882_FIXUP_ACER_ASPIRE_7736] = {
2294 		.type = HDA_FIXUP_FUNC,
2295 		.v.func = alc_fixup_sku_ignore,
2296 	},
2297 	[ALC882_FIXUP_ASUS_W90V] = {
2298 		.type = HDA_FIXUP_PINS,
2299 		.v.pins = (const struct hda_pintbl[]) {
2300 			{ 0x16, 0x99130110 }, /* fix sequence for CLFE */
2301 			{ }
2302 		}
2303 	},
2304 	[ALC889_FIXUP_CD] = {
2305 		.type = HDA_FIXUP_PINS,
2306 		.v.pins = (const struct hda_pintbl[]) {
2307 			{ 0x1c, 0x993301f0 }, /* CD */
2308 			{ }
2309 		}
2310 	},
2311 	[ALC889_FIXUP_FRONT_HP_NO_PRESENCE] = {
2312 		.type = HDA_FIXUP_PINS,
2313 		.v.pins = (const struct hda_pintbl[]) {
2314 			{ 0x1b, 0x02214120 }, /* Front HP jack is flaky, disable jack detect */
2315 			{ }
2316 		},
2317 		.chained = true,
2318 		.chain_id = ALC889_FIXUP_CD,
2319 	},
2320 	[ALC889_FIXUP_VAIO_TT] = {
2321 		.type = HDA_FIXUP_PINS,
2322 		.v.pins = (const struct hda_pintbl[]) {
2323 			{ 0x17, 0x90170111 }, /* hidden surround speaker */
2324 			{ }
2325 		}
2326 	},
2327 	[ALC888_FIXUP_EEE1601] = {
2328 		.type = HDA_FIXUP_VERBS,
2329 		.v.verbs = (const struct hda_verb[]) {
2330 			{ 0x20, AC_VERB_SET_COEF_INDEX, 0x0b },
2331 			{ 0x20, AC_VERB_SET_PROC_COEF,  0x0838 },
2332 			{ }
2333 		}
2334 	},
2335 	[ALC886_FIXUP_EAPD] = {
2336 		.type = HDA_FIXUP_VERBS,
2337 		.v.verbs = (const struct hda_verb[]) {
2338 			/* change to EAPD mode */
2339 			{ 0x20, AC_VERB_SET_COEF_INDEX, 0x07 },
2340 			{ 0x20, AC_VERB_SET_PROC_COEF, 0x0068 },
2341 			{ }
2342 		}
2343 	},
2344 	[ALC882_FIXUP_EAPD] = {
2345 		.type = HDA_FIXUP_VERBS,
2346 		.v.verbs = (const struct hda_verb[]) {
2347 			/* change to EAPD mode */
2348 			{ 0x20, AC_VERB_SET_COEF_INDEX, 0x07 },
2349 			{ 0x20, AC_VERB_SET_PROC_COEF, 0x3060 },
2350 			{ }
2351 		}
2352 	},
2353 	[ALC883_FIXUP_EAPD] = {
2354 		.type = HDA_FIXUP_VERBS,
2355 		.v.verbs = (const struct hda_verb[]) {
2356 			/* change to EAPD mode */
2357 			{ 0x20, AC_VERB_SET_COEF_INDEX, 0x07 },
2358 			{ 0x20, AC_VERB_SET_PROC_COEF, 0x3070 },
2359 			{ }
2360 		}
2361 	},
2362 	[ALC883_FIXUP_ACER_EAPD] = {
2363 		.type = HDA_FIXUP_VERBS,
2364 		.v.verbs = (const struct hda_verb[]) {
2365 			/* eanable EAPD on Acer laptops */
2366 			{ 0x20, AC_VERB_SET_COEF_INDEX, 0x07 },
2367 			{ 0x20, AC_VERB_SET_PROC_COEF, 0x3050 },
2368 			{ }
2369 		}
2370 	},
2371 	[ALC882_FIXUP_GPIO1] = {
2372 		.type = HDA_FIXUP_FUNC,
2373 		.v.func = alc_fixup_gpio1,
2374 	},
2375 	[ALC882_FIXUP_GPIO2] = {
2376 		.type = HDA_FIXUP_FUNC,
2377 		.v.func = alc_fixup_gpio2,
2378 	},
2379 	[ALC882_FIXUP_GPIO3] = {
2380 		.type = HDA_FIXUP_FUNC,
2381 		.v.func = alc_fixup_gpio3,
2382 	},
2383 	[ALC882_FIXUP_ASUS_W2JC] = {
2384 		.type = HDA_FIXUP_FUNC,
2385 		.v.func = alc_fixup_gpio1,
2386 		.chained = true,
2387 		.chain_id = ALC882_FIXUP_EAPD,
2388 	},
2389 	[ALC889_FIXUP_COEF] = {
2390 		.type = HDA_FIXUP_FUNC,
2391 		.v.func = alc889_fixup_coef,
2392 	},
2393 	[ALC882_FIXUP_ACER_ASPIRE_4930G] = {
2394 		.type = HDA_FIXUP_PINS,
2395 		.v.pins = (const struct hda_pintbl[]) {
2396 			{ 0x16, 0x99130111 }, /* CLFE speaker */
2397 			{ 0x17, 0x99130112 }, /* surround speaker */
2398 			{ }
2399 		},
2400 		.chained = true,
2401 		.chain_id = ALC882_FIXUP_GPIO1,
2402 	},
2403 	[ALC882_FIXUP_ACER_ASPIRE_8930G] = {
2404 		.type = HDA_FIXUP_PINS,
2405 		.v.pins = (const struct hda_pintbl[]) {
2406 			{ 0x16, 0x99130111 }, /* CLFE speaker */
2407 			{ 0x1b, 0x99130112 }, /* surround speaker */
2408 			{ }
2409 		},
2410 		.chained = true,
2411 		.chain_id = ALC882_FIXUP_ASPIRE_8930G_VERBS,
2412 	},
2413 	[ALC882_FIXUP_ASPIRE_8930G_VERBS] = {
2414 		/* additional init verbs for Acer Aspire 8930G */
2415 		.type = HDA_FIXUP_VERBS,
2416 		.v.verbs = (const struct hda_verb[]) {
2417 			/* Enable all DACs */
2418 			/* DAC DISABLE/MUTE 1? */
2419 			/*  setting bits 1-5 disables DAC nids 0x02-0x06
2420 			 *  apparently. Init=0x38 */
2421 			{ 0x20, AC_VERB_SET_COEF_INDEX, 0x03 },
2422 			{ 0x20, AC_VERB_SET_PROC_COEF, 0x0000 },
2423 			/* DAC DISABLE/MUTE 2? */
2424 			/*  some bit here disables the other DACs.
2425 			 *  Init=0x4900 */
2426 			{ 0x20, AC_VERB_SET_COEF_INDEX, 0x08 },
2427 			{ 0x20, AC_VERB_SET_PROC_COEF, 0x0000 },
2428 			/* DMIC fix
2429 			 * This laptop has a stereo digital microphone.
2430 			 * The mics are only 1cm apart which makes the stereo
2431 			 * useless. However, either the mic or the ALC889
2432 			 * makes the signal become a difference/sum signal
2433 			 * instead of standard stereo, which is annoying.
2434 			 * So instead we flip this bit which makes the
2435 			 * codec replicate the sum signal to both channels,
2436 			 * turning it into a normal mono mic.
2437 			 */
2438 			/* DMIC_CONTROL? Init value = 0x0001 */
2439 			{ 0x20, AC_VERB_SET_COEF_INDEX, 0x0b },
2440 			{ 0x20, AC_VERB_SET_PROC_COEF, 0x0003 },
2441 			{ 0x20, AC_VERB_SET_COEF_INDEX, 0x07 },
2442 			{ 0x20, AC_VERB_SET_PROC_COEF, 0x3050 },
2443 			{ }
2444 		},
2445 		.chained = true,
2446 		.chain_id = ALC882_FIXUP_GPIO1,
2447 	},
2448 	[ALC885_FIXUP_MACPRO_GPIO] = {
2449 		.type = HDA_FIXUP_FUNC,
2450 		.v.func = alc885_fixup_macpro_gpio,
2451 	},
2452 	[ALC889_FIXUP_DAC_ROUTE] = {
2453 		.type = HDA_FIXUP_FUNC,
2454 		.v.func = alc889_fixup_dac_route,
2455 	},
2456 	[ALC889_FIXUP_MBP_VREF] = {
2457 		.type = HDA_FIXUP_FUNC,
2458 		.v.func = alc889_fixup_mbp_vref,
2459 		.chained = true,
2460 		.chain_id = ALC882_FIXUP_GPIO1,
2461 	},
2462 	[ALC889_FIXUP_IMAC91_VREF] = {
2463 		.type = HDA_FIXUP_FUNC,
2464 		.v.func = alc889_fixup_imac91_vref,
2465 		.chained = true,
2466 		.chain_id = ALC882_FIXUP_GPIO1,
2467 	},
2468 	[ALC889_FIXUP_MBA11_VREF] = {
2469 		.type = HDA_FIXUP_FUNC,
2470 		.v.func = alc889_fixup_mba11_vref,
2471 		.chained = true,
2472 		.chain_id = ALC889_FIXUP_MBP_VREF,
2473 	},
2474 	[ALC889_FIXUP_MBA21_VREF] = {
2475 		.type = HDA_FIXUP_FUNC,
2476 		.v.func = alc889_fixup_mba21_vref,
2477 		.chained = true,
2478 		.chain_id = ALC889_FIXUP_MBP_VREF,
2479 	},
2480 	[ALC889_FIXUP_MP11_VREF] = {
2481 		.type = HDA_FIXUP_FUNC,
2482 		.v.func = alc889_fixup_mba11_vref,
2483 		.chained = true,
2484 		.chain_id = ALC885_FIXUP_MACPRO_GPIO,
2485 	},
2486 	[ALC889_FIXUP_MP41_VREF] = {
2487 		.type = HDA_FIXUP_FUNC,
2488 		.v.func = alc889_fixup_mbp_vref,
2489 		.chained = true,
2490 		.chain_id = ALC885_FIXUP_MACPRO_GPIO,
2491 	},
2492 	[ALC882_FIXUP_INV_DMIC] = {
2493 		.type = HDA_FIXUP_FUNC,
2494 		.v.func = alc_fixup_inv_dmic,
2495 	},
2496 	[ALC882_FIXUP_NO_PRIMARY_HP] = {
2497 		.type = HDA_FIXUP_FUNC,
2498 		.v.func = alc882_fixup_no_primary_hp,
2499 	},
2500 	[ALC887_FIXUP_ASUS_BASS] = {
2501 		.type = HDA_FIXUP_PINS,
2502 		.v.pins = (const struct hda_pintbl[]) {
2503 			{0x16, 0x99130130}, /* bass speaker */
2504 			{}
2505 		},
2506 		.chained = true,
2507 		.chain_id = ALC887_FIXUP_BASS_CHMAP,
2508 	},
2509 	[ALC887_FIXUP_BASS_CHMAP] = {
2510 		.type = HDA_FIXUP_FUNC,
2511 		.v.func = alc_fixup_bass_chmap,
2512 	},
2513 	[ALC1220_FIXUP_GB_DUAL_CODECS] = {
2514 		.type = HDA_FIXUP_FUNC,
2515 		.v.func = alc1220_fixup_gb_dual_codecs,
2516 	},
2517 	[ALC1220_FIXUP_GB_X570] = {
2518 		.type = HDA_FIXUP_FUNC,
2519 		.v.func = alc1220_fixup_gb_x570,
2520 	},
2521 	[ALC1220_FIXUP_CLEVO_P950] = {
2522 		.type = HDA_FIXUP_FUNC,
2523 		.v.func = alc1220_fixup_clevo_p950,
2524 	},
2525 	[ALC1220_FIXUP_CLEVO_PB51ED] = {
2526 		.type = HDA_FIXUP_FUNC,
2527 		.v.func = alc1220_fixup_clevo_pb51ed,
2528 	},
2529 	[ALC1220_FIXUP_CLEVO_PB51ED_PINS] = {
2530 		.type = HDA_FIXUP_PINS,
2531 		.v.pins = (const struct hda_pintbl[]) {
2532 			{ 0x19, 0x01a1913c }, /* use as headset mic, without its own jack detect */
2533 			{}
2534 		},
2535 		.chained = true,
2536 		.chain_id = ALC1220_FIXUP_CLEVO_PB51ED,
2537 	},
2538 	[ALC887_FIXUP_ASUS_AUDIO] = {
2539 		.type = HDA_FIXUP_PINS,
2540 		.v.pins = (const struct hda_pintbl[]) {
2541 			{ 0x15, 0x02a14150 }, /* use as headset mic, without its own jack detect */
2542 			{ 0x19, 0x22219420 },
2543 			{}
2544 		},
2545 	},
2546 	[ALC887_FIXUP_ASUS_HMIC] = {
2547 		.type = HDA_FIXUP_FUNC,
2548 		.v.func = alc887_fixup_asus_jack,
2549 		.chained = true,
2550 		.chain_id = ALC887_FIXUP_ASUS_AUDIO,
2551 	},
2552 	[ALCS1200A_FIXUP_MIC_VREF] = {
2553 		.type = HDA_FIXUP_PINCTLS,
2554 		.v.pins = (const struct hda_pintbl[]) {
2555 			{ 0x18, PIN_VREF50 }, /* rear mic */
2556 			{ 0x19, PIN_VREF50 }, /* front mic */
2557 			{}
2558 		}
2559 	},
2560 	[ALC888VD_FIXUP_MIC_100VREF] = {
2561 		.type = HDA_FIXUP_PINCTLS,
2562 		.v.pins = (const struct hda_pintbl[]) {
2563 			{ 0x18, PIN_VREF100 }, /* headset mic */
2564 			{}
2565 		}
2566 	},
2567 };
2568 
2569 static const struct snd_pci_quirk alc882_fixup_tbl[] = {
2570 	SND_PCI_QUIRK(0x1025, 0x006c, "Acer Aspire 9810", ALC883_FIXUP_ACER_EAPD),
2571 	SND_PCI_QUIRK(0x1025, 0x0090, "Acer Aspire", ALC883_FIXUP_ACER_EAPD),
2572 	SND_PCI_QUIRK(0x1025, 0x0107, "Acer Aspire", ALC883_FIXUP_ACER_EAPD),
2573 	SND_PCI_QUIRK(0x1025, 0x010a, "Acer Ferrari 5000", ALC883_FIXUP_ACER_EAPD),
2574 	SND_PCI_QUIRK(0x1025, 0x0110, "Acer Aspire", ALC883_FIXUP_ACER_EAPD),
2575 	SND_PCI_QUIRK(0x1025, 0x0112, "Acer Aspire 9303", ALC883_FIXUP_ACER_EAPD),
2576 	SND_PCI_QUIRK(0x1025, 0x0121, "Acer Aspire 5920G", ALC883_FIXUP_ACER_EAPD),
2577 	SND_PCI_QUIRK(0x1025, 0x013e, "Acer Aspire 4930G",
2578 		      ALC882_FIXUP_ACER_ASPIRE_4930G),
2579 	SND_PCI_QUIRK(0x1025, 0x013f, "Acer Aspire 5930G",
2580 		      ALC882_FIXUP_ACER_ASPIRE_4930G),
2581 	SND_PCI_QUIRK(0x1025, 0x0145, "Acer Aspire 8930G",
2582 		      ALC882_FIXUP_ACER_ASPIRE_8930G),
2583 	SND_PCI_QUIRK(0x1025, 0x0146, "Acer Aspire 6935G",
2584 		      ALC882_FIXUP_ACER_ASPIRE_8930G),
2585 	SND_PCI_QUIRK(0x1025, 0x0142, "Acer Aspire 7730G",
2586 		      ALC882_FIXUP_ACER_ASPIRE_4930G),
2587 	SND_PCI_QUIRK(0x1025, 0x0155, "Packard-Bell M5120", ALC882_FIXUP_PB_M5210),
2588 	SND_PCI_QUIRK(0x1025, 0x015e, "Acer Aspire 6930G",
2589 		      ALC882_FIXUP_ACER_ASPIRE_4930G),
2590 	SND_PCI_QUIRK(0x1025, 0x0166, "Acer Aspire 6530G",
2591 		      ALC882_FIXUP_ACER_ASPIRE_4930G),
2592 	SND_PCI_QUIRK(0x1025, 0x021e, "Acer Aspire 5739G",
2593 		      ALC882_FIXUP_ACER_ASPIRE_4930G),
2594 	SND_PCI_QUIRK(0x1025, 0x0259, "Acer Aspire 5935", ALC889_FIXUP_DAC_ROUTE),
2595 	SND_PCI_QUIRK(0x1025, 0x026b, "Acer Aspire 8940G", ALC882_FIXUP_ACER_ASPIRE_8930G),
2596 	SND_PCI_QUIRK(0x1025, 0x0296, "Acer Aspire 7736z", ALC882_FIXUP_ACER_ASPIRE_7736),
2597 	SND_PCI_QUIRK(0x1043, 0x13c2, "Asus A7M", ALC882_FIXUP_EAPD),
2598 	SND_PCI_QUIRK(0x1043, 0x1873, "ASUS W90V", ALC882_FIXUP_ASUS_W90V),
2599 	SND_PCI_QUIRK(0x1043, 0x1971, "Asus W2JC", ALC882_FIXUP_ASUS_W2JC),
2600 	SND_PCI_QUIRK(0x1043, 0x2390, "Asus D700SA", ALC887_FIXUP_ASUS_HMIC),
2601 	SND_PCI_QUIRK(0x1043, 0x835f, "Asus Eee 1601", ALC888_FIXUP_EEE1601),
2602 	SND_PCI_QUIRK(0x1043, 0x84bc, "ASUS ET2700", ALC887_FIXUP_ASUS_BASS),
2603 	SND_PCI_QUIRK(0x1043, 0x8691, "ASUS ROG Ranger VIII", ALC882_FIXUP_GPIO3),
2604 	SND_PCI_QUIRK(0x1043, 0x8797, "ASUS TUF B550M-PLUS", ALCS1200A_FIXUP_MIC_VREF),
2605 	SND_PCI_QUIRK(0x104d, 0x9043, "Sony Vaio VGC-LN51JGB", ALC882_FIXUP_NO_PRIMARY_HP),
2606 	SND_PCI_QUIRK(0x104d, 0x9044, "Sony VAIO AiO", ALC882_FIXUP_NO_PRIMARY_HP),
2607 	SND_PCI_QUIRK(0x104d, 0x9047, "Sony Vaio TT", ALC889_FIXUP_VAIO_TT),
2608 	SND_PCI_QUIRK(0x104d, 0x905a, "Sony Vaio Z", ALC882_FIXUP_NO_PRIMARY_HP),
2609 	SND_PCI_QUIRK(0x104d, 0x9060, "Sony Vaio VPCL14M1R", ALC882_FIXUP_NO_PRIMARY_HP),
2610 
2611 	/* All Apple entries are in codec SSIDs */
2612 	SND_PCI_QUIRK(0x106b, 0x00a0, "MacBookPro 3,1", ALC889_FIXUP_MBP_VREF),
2613 	SND_PCI_QUIRK(0x106b, 0x00a1, "Macbook", ALC889_FIXUP_MBP_VREF),
2614 	SND_PCI_QUIRK(0x106b, 0x00a4, "MacbookPro 4,1", ALC889_FIXUP_MBP_VREF),
2615 	SND_PCI_QUIRK(0x106b, 0x0c00, "Mac Pro", ALC889_FIXUP_MP11_VREF),
2616 	SND_PCI_QUIRK(0x106b, 0x1000, "iMac 24", ALC885_FIXUP_MACPRO_GPIO),
2617 	SND_PCI_QUIRK(0x106b, 0x2800, "AppleTV", ALC885_FIXUP_MACPRO_GPIO),
2618 	SND_PCI_QUIRK(0x106b, 0x2c00, "MacbookPro rev3", ALC889_FIXUP_MBP_VREF),
2619 	SND_PCI_QUIRK(0x106b, 0x3000, "iMac", ALC889_FIXUP_MBP_VREF),
2620 	SND_PCI_QUIRK(0x106b, 0x3200, "iMac 7,1 Aluminum", ALC882_FIXUP_EAPD),
2621 	SND_PCI_QUIRK(0x106b, 0x3400, "MacBookAir 1,1", ALC889_FIXUP_MBA11_VREF),
2622 	SND_PCI_QUIRK(0x106b, 0x3500, "MacBookAir 2,1", ALC889_FIXUP_MBA21_VREF),
2623 	SND_PCI_QUIRK(0x106b, 0x3600, "Macbook 3,1", ALC889_FIXUP_MBP_VREF),
2624 	SND_PCI_QUIRK(0x106b, 0x3800, "MacbookPro 4,1", ALC889_FIXUP_MBP_VREF),
2625 	SND_PCI_QUIRK(0x106b, 0x3e00, "iMac 24 Aluminum", ALC885_FIXUP_MACPRO_GPIO),
2626 	SND_PCI_QUIRK(0x106b, 0x3f00, "Macbook 5,1", ALC889_FIXUP_IMAC91_VREF),
2627 	SND_PCI_QUIRK(0x106b, 0x4000, "MacbookPro 5,1", ALC889_FIXUP_IMAC91_VREF),
2628 	SND_PCI_QUIRK(0x106b, 0x4100, "Macmini 3,1", ALC889_FIXUP_IMAC91_VREF),
2629 	SND_PCI_QUIRK(0x106b, 0x4200, "Mac Pro 4,1/5,1", ALC889_FIXUP_MP41_VREF),
2630 	SND_PCI_QUIRK(0x106b, 0x4300, "iMac 9,1", ALC889_FIXUP_IMAC91_VREF),
2631 	SND_PCI_QUIRK(0x106b, 0x4600, "MacbookPro 5,2", ALC889_FIXUP_IMAC91_VREF),
2632 	SND_PCI_QUIRK(0x106b, 0x4900, "iMac 9,1 Aluminum", ALC889_FIXUP_IMAC91_VREF),
2633 	SND_PCI_QUIRK(0x106b, 0x4a00, "Macbook 5,2", ALC889_FIXUP_MBA11_VREF),
2634 
2635 	SND_PCI_QUIRK(0x1071, 0x8258, "Evesham Voyaeger", ALC882_FIXUP_EAPD),
2636 	SND_PCI_QUIRK(0x10ec, 0x12d8, "iBase Elo Touch", ALC888VD_FIXUP_MIC_100VREF),
2637 	SND_PCI_QUIRK(0x13fe, 0x1009, "Advantech MIT-W101", ALC886_FIXUP_EAPD),
2638 	SND_PCI_QUIRK(0x1458, 0xa002, "Gigabyte EP45-DS3/Z87X-UD3H", ALC889_FIXUP_FRONT_HP_NO_PRESENCE),
2639 	SND_PCI_QUIRK(0x1458, 0xa0b8, "Gigabyte AZ370-Gaming", ALC1220_FIXUP_GB_DUAL_CODECS),
2640 	SND_PCI_QUIRK(0x1458, 0xa0cd, "Gigabyte X570 Aorus Master", ALC1220_FIXUP_GB_X570),
2641 	SND_PCI_QUIRK(0x1458, 0xa0ce, "Gigabyte X570 Aorus Xtreme", ALC1220_FIXUP_GB_X570),
2642 	SND_PCI_QUIRK(0x1458, 0xa0d5, "Gigabyte X570S Aorus Master", ALC1220_FIXUP_GB_X570),
2643 	SND_PCI_QUIRK(0x1462, 0x11f7, "MSI-GE63", ALC1220_FIXUP_CLEVO_P950),
2644 	SND_PCI_QUIRK(0x1462, 0x1228, "MSI-GP63", ALC1220_FIXUP_CLEVO_P950),
2645 	SND_PCI_QUIRK(0x1462, 0x1229, "MSI-GP73", ALC1220_FIXUP_CLEVO_P950),
2646 	SND_PCI_QUIRK(0x1462, 0x1275, "MSI-GL63", ALC1220_FIXUP_CLEVO_P950),
2647 	SND_PCI_QUIRK(0x1462, 0x1276, "MSI-GL73", ALC1220_FIXUP_CLEVO_P950),
2648 	SND_PCI_QUIRK(0x1462, 0x1293, "MSI-GP65", ALC1220_FIXUP_CLEVO_P950),
2649 	SND_PCI_QUIRK(0x1462, 0x7350, "MSI-7350", ALC889_FIXUP_CD),
2650 	SND_PCI_QUIRK(0x1462, 0xcc34, "MSI Godlike X570", ALC1220_FIXUP_GB_DUAL_CODECS),
2651 	SND_PCI_QUIRK(0x1462, 0xda57, "MSI Z270-Gaming", ALC1220_FIXUP_GB_DUAL_CODECS),
2652 	SND_PCI_QUIRK_VENDOR(0x1462, "MSI", ALC882_FIXUP_GPIO3),
2653 	SND_PCI_QUIRK(0x147b, 0x107a, "Abit AW9D-MAX", ALC882_FIXUP_ABIT_AW9D_MAX),
2654 	SND_PCI_QUIRK(0x1558, 0x3702, "Clevo X370SN[VW]", ALC1220_FIXUP_CLEVO_PB51ED_PINS),
2655 	SND_PCI_QUIRK(0x1558, 0x50d3, "Clevo PC50[ER][CDF]", ALC1220_FIXUP_CLEVO_PB51ED_PINS),
2656 	SND_PCI_QUIRK(0x1558, 0x65d1, "Clevo PB51[ER][CDF]", ALC1220_FIXUP_CLEVO_PB51ED_PINS),
2657 	SND_PCI_QUIRK(0x1558, 0x65d2, "Clevo PB51R[CDF]", ALC1220_FIXUP_CLEVO_PB51ED_PINS),
2658 	SND_PCI_QUIRK(0x1558, 0x65e1, "Clevo PB51[ED][DF]", ALC1220_FIXUP_CLEVO_PB51ED_PINS),
2659 	SND_PCI_QUIRK(0x1558, 0x65e5, "Clevo PC50D[PRS](?:-D|-G)?", ALC1220_FIXUP_CLEVO_PB51ED_PINS),
2660 	SND_PCI_QUIRK(0x1558, 0x65f1, "Clevo PC50HS", ALC1220_FIXUP_CLEVO_PB51ED_PINS),
2661 	SND_PCI_QUIRK(0x1558, 0x65f5, "Clevo PD50PN[NRT]", ALC1220_FIXUP_CLEVO_PB51ED_PINS),
2662 	SND_PCI_QUIRK(0x1558, 0x66a2, "Clevo PE60RNE", ALC1220_FIXUP_CLEVO_PB51ED_PINS),
2663 	SND_PCI_QUIRK(0x1558, 0x66a6, "Clevo PE60SN[CDE]-[GS]", ALC1220_FIXUP_CLEVO_PB51ED_PINS),
2664 	SND_PCI_QUIRK(0x1558, 0x67d1, "Clevo PB71[ER][CDF]", ALC1220_FIXUP_CLEVO_PB51ED_PINS),
2665 	SND_PCI_QUIRK(0x1558, 0x67e1, "Clevo PB71[DE][CDF]", ALC1220_FIXUP_CLEVO_PB51ED_PINS),
2666 	SND_PCI_QUIRK(0x1558, 0x67e5, "Clevo PC70D[PRS](?:-D|-G)?", ALC1220_FIXUP_CLEVO_PB51ED_PINS),
2667 	SND_PCI_QUIRK(0x1558, 0x67f1, "Clevo PC70H[PRS]", ALC1220_FIXUP_CLEVO_PB51ED_PINS),
2668 	SND_PCI_QUIRK(0x1558, 0x67f5, "Clevo PD70PN[NRT]", ALC1220_FIXUP_CLEVO_PB51ED_PINS),
2669 	SND_PCI_QUIRK(0x1558, 0x70d1, "Clevo PC70[ER][CDF]", ALC1220_FIXUP_CLEVO_PB51ED_PINS),
2670 	SND_PCI_QUIRK(0x1558, 0x7714, "Clevo X170SM", ALC1220_FIXUP_CLEVO_PB51ED_PINS),
2671 	SND_PCI_QUIRK(0x1558, 0x7715, "Clevo X170KM-G", ALC1220_FIXUP_CLEVO_PB51ED),
2672 	SND_PCI_QUIRK(0x1558, 0x9501, "Clevo P950HR", ALC1220_FIXUP_CLEVO_P950),
2673 	SND_PCI_QUIRK(0x1558, 0x9506, "Clevo P955HQ", ALC1220_FIXUP_CLEVO_P950),
2674 	SND_PCI_QUIRK(0x1558, 0x950a, "Clevo P955H[PR]", ALC1220_FIXUP_CLEVO_P950),
2675 	SND_PCI_QUIRK(0x1558, 0x95e1, "Clevo P95xER", ALC1220_FIXUP_CLEVO_P950),
2676 	SND_PCI_QUIRK(0x1558, 0x95e2, "Clevo P950ER", ALC1220_FIXUP_CLEVO_P950),
2677 	SND_PCI_QUIRK(0x1558, 0x95e3, "Clevo P955[ER]T", ALC1220_FIXUP_CLEVO_P950),
2678 	SND_PCI_QUIRK(0x1558, 0x95e4, "Clevo P955ER", ALC1220_FIXUP_CLEVO_P950),
2679 	SND_PCI_QUIRK(0x1558, 0x95e5, "Clevo P955EE6", ALC1220_FIXUP_CLEVO_P950),
2680 	SND_PCI_QUIRK(0x1558, 0x95e6, "Clevo P950R[CDF]", ALC1220_FIXUP_CLEVO_P950),
2681 	SND_PCI_QUIRK(0x1558, 0x96e1, "Clevo P960[ER][CDFN]-K", ALC1220_FIXUP_CLEVO_P950),
2682 	SND_PCI_QUIRK(0x1558, 0x97e1, "Clevo P970[ER][CDFN]", ALC1220_FIXUP_CLEVO_P950),
2683 	SND_PCI_QUIRK(0x1558, 0x97e2, "Clevo P970RC-M", ALC1220_FIXUP_CLEVO_P950),
2684 	SND_PCI_QUIRK(0x1558, 0xd502, "Clevo PD50SNE", ALC1220_FIXUP_CLEVO_PB51ED_PINS),
2685 	SND_PCI_QUIRK_VENDOR(0x1558, "Clevo laptop", ALC882_FIXUP_EAPD),
2686 	SND_PCI_QUIRK(0x161f, 0x2054, "Medion laptop", ALC883_FIXUP_EAPD),
2687 	SND_PCI_QUIRK(0x17aa, 0x3a0d, "Lenovo Y530", ALC882_FIXUP_LENOVO_Y530),
2688 	SND_PCI_QUIRK(0x8086, 0x0022, "DX58SO", ALC889_FIXUP_COEF),
2689 	{}
2690 };
2691 
2692 static const struct hda_model_fixup alc882_fixup_models[] = {
2693 	{.id = ALC882_FIXUP_ABIT_AW9D_MAX, .name = "abit-aw9d"},
2694 	{.id = ALC882_FIXUP_LENOVO_Y530, .name = "lenovo-y530"},
2695 	{.id = ALC882_FIXUP_ACER_ASPIRE_7736, .name = "acer-aspire-7736"},
2696 	{.id = ALC882_FIXUP_ASUS_W90V, .name = "asus-w90v"},
2697 	{.id = ALC889_FIXUP_CD, .name = "cd"},
2698 	{.id = ALC889_FIXUP_FRONT_HP_NO_PRESENCE, .name = "no-front-hp"},
2699 	{.id = ALC889_FIXUP_VAIO_TT, .name = "vaio-tt"},
2700 	{.id = ALC888_FIXUP_EEE1601, .name = "eee1601"},
2701 	{.id = ALC882_FIXUP_EAPD, .name = "alc882-eapd"},
2702 	{.id = ALC883_FIXUP_EAPD, .name = "alc883-eapd"},
2703 	{.id = ALC882_FIXUP_GPIO1, .name = "gpio1"},
2704 	{.id = ALC882_FIXUP_GPIO2, .name = "gpio2"},
2705 	{.id = ALC882_FIXUP_GPIO3, .name = "gpio3"},
2706 	{.id = ALC889_FIXUP_COEF, .name = "alc889-coef"},
2707 	{.id = ALC882_FIXUP_ASUS_W2JC, .name = "asus-w2jc"},
2708 	{.id = ALC882_FIXUP_ACER_ASPIRE_4930G, .name = "acer-aspire-4930g"},
2709 	{.id = ALC882_FIXUP_ACER_ASPIRE_8930G, .name = "acer-aspire-8930g"},
2710 	{.id = ALC883_FIXUP_ACER_EAPD, .name = "acer-aspire"},
2711 	{.id = ALC885_FIXUP_MACPRO_GPIO, .name = "macpro-gpio"},
2712 	{.id = ALC889_FIXUP_DAC_ROUTE, .name = "dac-route"},
2713 	{.id = ALC889_FIXUP_MBP_VREF, .name = "mbp-vref"},
2714 	{.id = ALC889_FIXUP_IMAC91_VREF, .name = "imac91-vref"},
2715 	{.id = ALC889_FIXUP_MBA11_VREF, .name = "mba11-vref"},
2716 	{.id = ALC889_FIXUP_MBA21_VREF, .name = "mba21-vref"},
2717 	{.id = ALC889_FIXUP_MP11_VREF, .name = "mp11-vref"},
2718 	{.id = ALC889_FIXUP_MP41_VREF, .name = "mp41-vref"},
2719 	{.id = ALC882_FIXUP_INV_DMIC, .name = "inv-dmic"},
2720 	{.id = ALC882_FIXUP_NO_PRIMARY_HP, .name = "no-primary-hp"},
2721 	{.id = ALC887_FIXUP_ASUS_BASS, .name = "asus-bass"},
2722 	{.id = ALC1220_FIXUP_GB_DUAL_CODECS, .name = "dual-codecs"},
2723 	{.id = ALC1220_FIXUP_GB_X570, .name = "gb-x570"},
2724 	{.id = ALC1220_FIXUP_CLEVO_P950, .name = "clevo-p950"},
2725 	{}
2726 };
2727 
2728 static const struct snd_hda_pin_quirk alc882_pin_fixup_tbl[] = {
2729 	SND_HDA_PIN_QUIRK(0x10ec1220, 0x1043, "ASUS", ALC1220_FIXUP_CLEVO_P950,
2730 		{0x14, 0x01014010},
2731 		{0x15, 0x01011012},
2732 		{0x16, 0x01016011},
2733 		{0x18, 0x01a19040},
2734 		{0x19, 0x02a19050},
2735 		{0x1a, 0x0181304f},
2736 		{0x1b, 0x0221401f},
2737 		{0x1e, 0x01456130}),
2738 	SND_HDA_PIN_QUIRK(0x10ec1220, 0x1462, "MS-7C35", ALC1220_FIXUP_CLEVO_P950,
2739 		{0x14, 0x01015010},
2740 		{0x15, 0x01011012},
2741 		{0x16, 0x01011011},
2742 		{0x18, 0x01a11040},
2743 		{0x19, 0x02a19050},
2744 		{0x1a, 0x0181104f},
2745 		{0x1b, 0x0221401f},
2746 		{0x1e, 0x01451130}),
2747 	{}
2748 };
2749 
2750 /*
2751  * BIOS auto configuration
2752  */
2753 /* almost identical with ALC880 parser... */
2754 static int alc882_parse_auto_config(struct hda_codec *codec)
2755 {
2756 	static const hda_nid_t alc882_ignore[] = { 0x1d, 0 };
2757 	static const hda_nid_t alc882_ssids[] = { 0x15, 0x1b, 0x14, 0 };
2758 	return alc_parse_auto_config(codec, alc882_ignore, alc882_ssids);
2759 }
2760 
2761 /*
2762  */
2763 static int patch_alc882(struct hda_codec *codec)
2764 {
2765 	struct alc_spec *spec;
2766 	int err;
2767 
2768 	err = alc_alloc_spec(codec, 0x0b);
2769 	if (err < 0)
2770 		return err;
2771 
2772 	spec = codec->spec;
2773 
2774 	switch (codec->core.vendor_id) {
2775 	case 0x10ec0882:
2776 	case 0x10ec0885:
2777 	case 0x10ec0900:
2778 	case 0x10ec0b00:
2779 	case 0x10ec1220:
2780 		break;
2781 	default:
2782 		/* ALC883 and variants */
2783 		alc_fix_pll_init(codec, 0x20, 0x0a, 10);
2784 		break;
2785 	}
2786 
2787 	alc_pre_init(codec);
2788 
2789 	snd_hda_pick_fixup(codec, alc882_fixup_models, alc882_fixup_tbl,
2790 		       alc882_fixups);
2791 	snd_hda_pick_pin_fixup(codec, alc882_pin_fixup_tbl, alc882_fixups, true);
2792 	snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE);
2793 
2794 	alc_auto_parse_customize_define(codec);
2795 
2796 	if (has_cdefine_beep(codec))
2797 		spec->gen.beep_nid = 0x01;
2798 
2799 	/* automatic parse from the BIOS config */
2800 	err = alc882_parse_auto_config(codec);
2801 	if (err < 0)
2802 		goto error;
2803 
2804 	if (!spec->gen.no_analog && spec->gen.beep_nid) {
2805 		err = set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
2806 		if (err < 0)
2807 			goto error;
2808 	}
2809 
2810 	snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE);
2811 
2812 	return 0;
2813 
2814  error:
2815 	alc_free(codec);
2816 	return err;
2817 }
2818 
2819 
2820 /*
2821  * ALC262 support
2822  */
2823 static int alc262_parse_auto_config(struct hda_codec *codec)
2824 {
2825 	static const hda_nid_t alc262_ignore[] = { 0x1d, 0 };
2826 	static const hda_nid_t alc262_ssids[] = { 0x15, 0x1b, 0x14, 0 };
2827 	return alc_parse_auto_config(codec, alc262_ignore, alc262_ssids);
2828 }
2829 
2830 /*
2831  * Pin config fixes
2832  */
2833 enum {
2834 	ALC262_FIXUP_FSC_H270,
2835 	ALC262_FIXUP_FSC_S7110,
2836 	ALC262_FIXUP_HP_Z200,
2837 	ALC262_FIXUP_TYAN,
2838 	ALC262_FIXUP_LENOVO_3000,
2839 	ALC262_FIXUP_BENQ,
2840 	ALC262_FIXUP_BENQ_T31,
2841 	ALC262_FIXUP_INV_DMIC,
2842 	ALC262_FIXUP_INTEL_BAYLEYBAY,
2843 };
2844 
2845 static const struct hda_fixup alc262_fixups[] = {
2846 	[ALC262_FIXUP_FSC_H270] = {
2847 		.type = HDA_FIXUP_PINS,
2848 		.v.pins = (const struct hda_pintbl[]) {
2849 			{ 0x14, 0x99130110 }, /* speaker */
2850 			{ 0x15, 0x0221142f }, /* front HP */
2851 			{ 0x1b, 0x0121141f }, /* rear HP */
2852 			{ }
2853 		}
2854 	},
2855 	[ALC262_FIXUP_FSC_S7110] = {
2856 		.type = HDA_FIXUP_PINS,
2857 		.v.pins = (const struct hda_pintbl[]) {
2858 			{ 0x15, 0x90170110 }, /* speaker */
2859 			{ }
2860 		},
2861 		.chained = true,
2862 		.chain_id = ALC262_FIXUP_BENQ,
2863 	},
2864 	[ALC262_FIXUP_HP_Z200] = {
2865 		.type = HDA_FIXUP_PINS,
2866 		.v.pins = (const struct hda_pintbl[]) {
2867 			{ 0x16, 0x99130120 }, /* internal speaker */
2868 			{ }
2869 		}
2870 	},
2871 	[ALC262_FIXUP_TYAN] = {
2872 		.type = HDA_FIXUP_PINS,
2873 		.v.pins = (const struct hda_pintbl[]) {
2874 			{ 0x14, 0x1993e1f0 }, /* int AUX */
2875 			{ }
2876 		}
2877 	},
2878 	[ALC262_FIXUP_LENOVO_3000] = {
2879 		.type = HDA_FIXUP_PINCTLS,
2880 		.v.pins = (const struct hda_pintbl[]) {
2881 			{ 0x19, PIN_VREF50 },
2882 			{}
2883 		},
2884 		.chained = true,
2885 		.chain_id = ALC262_FIXUP_BENQ,
2886 	},
2887 	[ALC262_FIXUP_BENQ] = {
2888 		.type = HDA_FIXUP_VERBS,
2889 		.v.verbs = (const struct hda_verb[]) {
2890 			{ 0x20, AC_VERB_SET_COEF_INDEX, 0x07 },
2891 			{ 0x20, AC_VERB_SET_PROC_COEF, 0x3070 },
2892 			{}
2893 		}
2894 	},
2895 	[ALC262_FIXUP_BENQ_T31] = {
2896 		.type = HDA_FIXUP_VERBS,
2897 		.v.verbs = (const struct hda_verb[]) {
2898 			{ 0x20, AC_VERB_SET_COEF_INDEX, 0x07 },
2899 			{ 0x20, AC_VERB_SET_PROC_COEF, 0x3050 },
2900 			{}
2901 		}
2902 	},
2903 	[ALC262_FIXUP_INV_DMIC] = {
2904 		.type = HDA_FIXUP_FUNC,
2905 		.v.func = alc_fixup_inv_dmic,
2906 	},
2907 	[ALC262_FIXUP_INTEL_BAYLEYBAY] = {
2908 		.type = HDA_FIXUP_FUNC,
2909 		.v.func = alc_fixup_no_depop_delay,
2910 	},
2911 };
2912 
2913 static const struct snd_pci_quirk alc262_fixup_tbl[] = {
2914 	SND_PCI_QUIRK(0x103c, 0x170b, "HP Z200", ALC262_FIXUP_HP_Z200),
2915 	SND_PCI_QUIRK(0x10cf, 0x1397, "Fujitsu Lifebook S7110", ALC262_FIXUP_FSC_S7110),
2916 	SND_PCI_QUIRK(0x10cf, 0x142d, "Fujitsu Lifebook E8410", ALC262_FIXUP_BENQ),
2917 	SND_PCI_QUIRK(0x10f1, 0x2915, "Tyan Thunder n6650W", ALC262_FIXUP_TYAN),
2918 	SND_PCI_QUIRK(0x1734, 0x1141, "FSC ESPRIMO U9210", ALC262_FIXUP_FSC_H270),
2919 	SND_PCI_QUIRK(0x1734, 0x1147, "FSC Celsius H270", ALC262_FIXUP_FSC_H270),
2920 	SND_PCI_QUIRK(0x17aa, 0x384e, "Lenovo 3000", ALC262_FIXUP_LENOVO_3000),
2921 	SND_PCI_QUIRK(0x17ff, 0x0560, "Benq ED8", ALC262_FIXUP_BENQ),
2922 	SND_PCI_QUIRK(0x17ff, 0x058d, "Benq T31-16", ALC262_FIXUP_BENQ_T31),
2923 	SND_PCI_QUIRK(0x8086, 0x7270, "BayleyBay", ALC262_FIXUP_INTEL_BAYLEYBAY),
2924 	{}
2925 };
2926 
2927 static const struct hda_model_fixup alc262_fixup_models[] = {
2928 	{.id = ALC262_FIXUP_INV_DMIC, .name = "inv-dmic"},
2929 	{.id = ALC262_FIXUP_FSC_H270, .name = "fsc-h270"},
2930 	{.id = ALC262_FIXUP_FSC_S7110, .name = "fsc-s7110"},
2931 	{.id = ALC262_FIXUP_HP_Z200, .name = "hp-z200"},
2932 	{.id = ALC262_FIXUP_TYAN, .name = "tyan"},
2933 	{.id = ALC262_FIXUP_LENOVO_3000, .name = "lenovo-3000"},
2934 	{.id = ALC262_FIXUP_BENQ, .name = "benq"},
2935 	{.id = ALC262_FIXUP_BENQ_T31, .name = "benq-t31"},
2936 	{.id = ALC262_FIXUP_INTEL_BAYLEYBAY, .name = "bayleybay"},
2937 	{}
2938 };
2939 
2940 /*
2941  */
2942 static int patch_alc262(struct hda_codec *codec)
2943 {
2944 	struct alc_spec *spec;
2945 	int err;
2946 
2947 	err = alc_alloc_spec(codec, 0x0b);
2948 	if (err < 0)
2949 		return err;
2950 
2951 	spec = codec->spec;
2952 	spec->gen.shared_mic_vref_pin = 0x18;
2953 
2954 	spec->shutup = alc_eapd_shutup;
2955 
2956 #if 0
2957 	/* pshou 07/11/05  set a zero PCM sample to DAC when FIFO is
2958 	 * under-run
2959 	 */
2960 	alc_update_coefex_idx(codec, 0x1a, 7, 0, 0x80);
2961 #endif
2962 	alc_fix_pll_init(codec, 0x20, 0x0a, 10);
2963 
2964 	alc_pre_init(codec);
2965 
2966 	snd_hda_pick_fixup(codec, alc262_fixup_models, alc262_fixup_tbl,
2967 		       alc262_fixups);
2968 	snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE);
2969 
2970 	alc_auto_parse_customize_define(codec);
2971 
2972 	if (has_cdefine_beep(codec))
2973 		spec->gen.beep_nid = 0x01;
2974 
2975 	/* automatic parse from the BIOS config */
2976 	err = alc262_parse_auto_config(codec);
2977 	if (err < 0)
2978 		goto error;
2979 
2980 	if (!spec->gen.no_analog && spec->gen.beep_nid) {
2981 		err = set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
2982 		if (err < 0)
2983 			goto error;
2984 	}
2985 
2986 	snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE);
2987 
2988 	return 0;
2989 
2990  error:
2991 	alc_free(codec);
2992 	return err;
2993 }
2994 
2995 /*
2996  *  ALC268
2997  */
2998 /* bind Beep switches of both NID 0x0f and 0x10 */
2999 static int alc268_beep_switch_put(struct snd_kcontrol *kcontrol,
3000 				  struct snd_ctl_elem_value *ucontrol)
3001 {
3002 	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3003 	unsigned long pval;
3004 	int err;
3005 
3006 	mutex_lock(&codec->control_mutex);
3007 	pval = kcontrol->private_value;
3008 	kcontrol->private_value = (pval & ~0xff) | 0x0f;
3009 	err = snd_hda_mixer_amp_switch_put(kcontrol, ucontrol);
3010 	if (err >= 0) {
3011 		kcontrol->private_value = (pval & ~0xff) | 0x10;
3012 		err = snd_hda_mixer_amp_switch_put(kcontrol, ucontrol);
3013 	}
3014 	kcontrol->private_value = pval;
3015 	mutex_unlock(&codec->control_mutex);
3016 	return err;
3017 }
3018 
3019 static const struct snd_kcontrol_new alc268_beep_mixer[] = {
3020 	HDA_CODEC_VOLUME("Beep Playback Volume", 0x1d, 0x0, HDA_INPUT),
3021 	{
3022 		.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3023 		.name = "Beep Playback Switch",
3024 		.subdevice = HDA_SUBDEV_AMP_FLAG,
3025 		.info = snd_hda_mixer_amp_switch_info,
3026 		.get = snd_hda_mixer_amp_switch_get,
3027 		.put = alc268_beep_switch_put,
3028 		.private_value = HDA_COMPOSE_AMP_VAL(0x0f, 3, 1, HDA_INPUT)
3029 	},
3030 };
3031 
3032 /* set PCBEEP vol = 0, mute connections */
3033 static const struct hda_verb alc268_beep_init_verbs[] = {
3034 	{0x1d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
3035 	{0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
3036 	{0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
3037 	{ }
3038 };
3039 
3040 enum {
3041 	ALC268_FIXUP_INV_DMIC,
3042 	ALC268_FIXUP_HP_EAPD,
3043 	ALC268_FIXUP_SPDIF,
3044 };
3045 
3046 static const struct hda_fixup alc268_fixups[] = {
3047 	[ALC268_FIXUP_INV_DMIC] = {
3048 		.type = HDA_FIXUP_FUNC,
3049 		.v.func = alc_fixup_inv_dmic,
3050 	},
3051 	[ALC268_FIXUP_HP_EAPD] = {
3052 		.type = HDA_FIXUP_VERBS,
3053 		.v.verbs = (const struct hda_verb[]) {
3054 			{0x15, AC_VERB_SET_EAPD_BTLENABLE, 0},
3055 			{}
3056 		}
3057 	},
3058 	[ALC268_FIXUP_SPDIF] = {
3059 		.type = HDA_FIXUP_PINS,
3060 		.v.pins = (const struct hda_pintbl[]) {
3061 			{ 0x1e, 0x014b1180 }, /* enable SPDIF out */
3062 			{}
3063 		}
3064 	},
3065 };
3066 
3067 static const struct hda_model_fixup alc268_fixup_models[] = {
3068 	{.id = ALC268_FIXUP_INV_DMIC, .name = "inv-dmic"},
3069 	{.id = ALC268_FIXUP_HP_EAPD, .name = "hp-eapd"},
3070 	{.id = ALC268_FIXUP_SPDIF, .name = "spdif"},
3071 	{}
3072 };
3073 
3074 static const struct snd_pci_quirk alc268_fixup_tbl[] = {
3075 	SND_PCI_QUIRK(0x1025, 0x0139, "Acer TravelMate 6293", ALC268_FIXUP_SPDIF),
3076 	SND_PCI_QUIRK(0x1025, 0x015b, "Acer AOA 150 (ZG5)", ALC268_FIXUP_INV_DMIC),
3077 	/* below is codec SSID since multiple Toshiba laptops have the
3078 	 * same PCI SSID 1179:ff00
3079 	 */
3080 	SND_PCI_QUIRK(0x1179, 0xff06, "Toshiba P200", ALC268_FIXUP_HP_EAPD),
3081 	{}
3082 };
3083 
3084 /*
3085  * BIOS auto configuration
3086  */
3087 static int alc268_parse_auto_config(struct hda_codec *codec)
3088 {
3089 	static const hda_nid_t alc268_ssids[] = { 0x15, 0x1b, 0x14, 0 };
3090 	return alc_parse_auto_config(codec, NULL, alc268_ssids);
3091 }
3092 
3093 /*
3094  */
3095 static int patch_alc268(struct hda_codec *codec)
3096 {
3097 	struct alc_spec *spec;
3098 	int i, err;
3099 
3100 	/* ALC268 has no aa-loopback mixer */
3101 	err = alc_alloc_spec(codec, 0);
3102 	if (err < 0)
3103 		return err;
3104 
3105 	spec = codec->spec;
3106 	if (has_cdefine_beep(codec))
3107 		spec->gen.beep_nid = 0x01;
3108 
3109 	spec->shutup = alc_eapd_shutup;
3110 
3111 	alc_pre_init(codec);
3112 
3113 	snd_hda_pick_fixup(codec, alc268_fixup_models, alc268_fixup_tbl, alc268_fixups);
3114 	snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE);
3115 
3116 	/* automatic parse from the BIOS config */
3117 	err = alc268_parse_auto_config(codec);
3118 	if (err < 0)
3119 		goto error;
3120 
3121 	if (err > 0 && !spec->gen.no_analog &&
3122 	    spec->gen.autocfg.speaker_pins[0] != 0x1d) {
3123 		for (i = 0; i < ARRAY_SIZE(alc268_beep_mixer); i++) {
3124 			if (!snd_hda_gen_add_kctl(&spec->gen, NULL,
3125 						  &alc268_beep_mixer[i])) {
3126 				err = -ENOMEM;
3127 				goto error;
3128 			}
3129 		}
3130 		snd_hda_add_verbs(codec, alc268_beep_init_verbs);
3131 		if (!query_amp_caps(codec, 0x1d, HDA_INPUT))
3132 			/* override the amp caps for beep generator */
3133 			snd_hda_override_amp_caps(codec, 0x1d, HDA_INPUT,
3134 					  (0x0c << AC_AMPCAP_OFFSET_SHIFT) |
3135 					  (0x0c << AC_AMPCAP_NUM_STEPS_SHIFT) |
3136 					  (0x07 << AC_AMPCAP_STEP_SIZE_SHIFT) |
3137 					  (0 << AC_AMPCAP_MUTE_SHIFT));
3138 	}
3139 
3140 	snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE);
3141 
3142 	return 0;
3143 
3144  error:
3145 	alc_free(codec);
3146 	return err;
3147 }
3148 
3149 /*
3150  * ALC269
3151  */
3152 
3153 static const struct hda_pcm_stream alc269_44k_pcm_analog_playback = {
3154 	.rates = SNDRV_PCM_RATE_44100, /* fixed rate */
3155 };
3156 
3157 static const struct hda_pcm_stream alc269_44k_pcm_analog_capture = {
3158 	.rates = SNDRV_PCM_RATE_44100, /* fixed rate */
3159 };
3160 
3161 /* different alc269-variants */
3162 enum {
3163 	ALC269_TYPE_ALC269VA,
3164 	ALC269_TYPE_ALC269VB,
3165 	ALC269_TYPE_ALC269VC,
3166 	ALC269_TYPE_ALC269VD,
3167 	ALC269_TYPE_ALC280,
3168 	ALC269_TYPE_ALC282,
3169 	ALC269_TYPE_ALC283,
3170 	ALC269_TYPE_ALC284,
3171 	ALC269_TYPE_ALC293,
3172 	ALC269_TYPE_ALC286,
3173 	ALC269_TYPE_ALC298,
3174 	ALC269_TYPE_ALC255,
3175 	ALC269_TYPE_ALC256,
3176 	ALC269_TYPE_ALC257,
3177 	ALC269_TYPE_ALC215,
3178 	ALC269_TYPE_ALC225,
3179 	ALC269_TYPE_ALC245,
3180 	ALC269_TYPE_ALC287,
3181 	ALC269_TYPE_ALC294,
3182 	ALC269_TYPE_ALC300,
3183 	ALC269_TYPE_ALC623,
3184 	ALC269_TYPE_ALC700,
3185 };
3186 
3187 /*
3188  * BIOS auto configuration
3189  */
3190 static int alc269_parse_auto_config(struct hda_codec *codec)
3191 {
3192 	static const hda_nid_t alc269_ignore[] = { 0x1d, 0 };
3193 	static const hda_nid_t alc269_ssids[] = { 0, 0x1b, 0x14, 0x21 };
3194 	static const hda_nid_t alc269va_ssids[] = { 0x15, 0x1b, 0x14, 0 };
3195 	struct alc_spec *spec = codec->spec;
3196 	const hda_nid_t *ssids;
3197 
3198 	switch (spec->codec_variant) {
3199 	case ALC269_TYPE_ALC269VA:
3200 	case ALC269_TYPE_ALC269VC:
3201 	case ALC269_TYPE_ALC280:
3202 	case ALC269_TYPE_ALC284:
3203 	case ALC269_TYPE_ALC293:
3204 		ssids = alc269va_ssids;
3205 		break;
3206 	case ALC269_TYPE_ALC269VB:
3207 	case ALC269_TYPE_ALC269VD:
3208 	case ALC269_TYPE_ALC282:
3209 	case ALC269_TYPE_ALC283:
3210 	case ALC269_TYPE_ALC286:
3211 	case ALC269_TYPE_ALC298:
3212 	case ALC269_TYPE_ALC255:
3213 	case ALC269_TYPE_ALC256:
3214 	case ALC269_TYPE_ALC257:
3215 	case ALC269_TYPE_ALC215:
3216 	case ALC269_TYPE_ALC225:
3217 	case ALC269_TYPE_ALC245:
3218 	case ALC269_TYPE_ALC287:
3219 	case ALC269_TYPE_ALC294:
3220 	case ALC269_TYPE_ALC300:
3221 	case ALC269_TYPE_ALC623:
3222 	case ALC269_TYPE_ALC700:
3223 		ssids = alc269_ssids;
3224 		break;
3225 	default:
3226 		ssids = alc269_ssids;
3227 		break;
3228 	}
3229 
3230 	return alc_parse_auto_config(codec, alc269_ignore, ssids);
3231 }
3232 
3233 static const struct hda_jack_keymap alc_headset_btn_keymap[] = {
3234 	{ SND_JACK_BTN_0, KEY_PLAYPAUSE },
3235 	{ SND_JACK_BTN_1, KEY_VOICECOMMAND },
3236 	{ SND_JACK_BTN_2, KEY_VOLUMEUP },
3237 	{ SND_JACK_BTN_3, KEY_VOLUMEDOWN },
3238 	{}
3239 };
3240 
3241 static void alc_headset_btn_callback(struct hda_codec *codec,
3242 				     struct hda_jack_callback *jack)
3243 {
3244 	int report = 0;
3245 
3246 	if (jack->unsol_res & (7 << 13))
3247 		report |= SND_JACK_BTN_0;
3248 
3249 	if (jack->unsol_res  & (1 << 16 | 3 << 8))
3250 		report |= SND_JACK_BTN_1;
3251 
3252 	/* Volume up key */
3253 	if (jack->unsol_res & (7 << 23))
3254 		report |= SND_JACK_BTN_2;
3255 
3256 	/* Volume down key */
3257 	if (jack->unsol_res & (7 << 10))
3258 		report |= SND_JACK_BTN_3;
3259 
3260 	snd_hda_jack_set_button_state(codec, jack->nid, report);
3261 }
3262 
3263 static void alc_disable_headset_jack_key(struct hda_codec *codec)
3264 {
3265 	struct alc_spec *spec = codec->spec;
3266 
3267 	if (!spec->has_hs_key)
3268 		return;
3269 
3270 	switch (codec->core.vendor_id) {
3271 	case 0x10ec0215:
3272 	case 0x10ec0225:
3273 	case 0x10ec0285:
3274 	case 0x10ec0287:
3275 	case 0x10ec0295:
3276 	case 0x10ec0289:
3277 	case 0x10ec0299:
3278 		alc_write_coef_idx(codec, 0x48, 0x0);
3279 		alc_update_coef_idx(codec, 0x49, 0x0045, 0x0);
3280 		alc_update_coef_idx(codec, 0x44, 0x0045 << 8, 0x0);
3281 		break;
3282 	case 0x10ec0230:
3283 	case 0x10ec0236:
3284 	case 0x10ec0256:
3285 	case 0x10ec0257:
3286 	case 0x19e58326:
3287 		alc_write_coef_idx(codec, 0x48, 0x0);
3288 		alc_update_coef_idx(codec, 0x49, 0x0045, 0x0);
3289 		break;
3290 	}
3291 }
3292 
3293 static void alc_enable_headset_jack_key(struct hda_codec *codec)
3294 {
3295 	struct alc_spec *spec = codec->spec;
3296 
3297 	if (!spec->has_hs_key)
3298 		return;
3299 
3300 	switch (codec->core.vendor_id) {
3301 	case 0x10ec0215:
3302 	case 0x10ec0225:
3303 	case 0x10ec0285:
3304 	case 0x10ec0287:
3305 	case 0x10ec0295:
3306 	case 0x10ec0289:
3307 	case 0x10ec0299:
3308 		alc_write_coef_idx(codec, 0x48, 0xd011);
3309 		alc_update_coef_idx(codec, 0x49, 0x007f, 0x0045);
3310 		alc_update_coef_idx(codec, 0x44, 0x007f << 8, 0x0045 << 8);
3311 		break;
3312 	case 0x10ec0230:
3313 	case 0x10ec0236:
3314 	case 0x10ec0256:
3315 	case 0x10ec0257:
3316 	case 0x19e58326:
3317 		alc_write_coef_idx(codec, 0x48, 0xd011);
3318 		alc_update_coef_idx(codec, 0x49, 0x007f, 0x0045);
3319 		break;
3320 	}
3321 }
3322 
3323 static void alc_fixup_headset_jack(struct hda_codec *codec,
3324 				    const struct hda_fixup *fix, int action)
3325 {
3326 	struct alc_spec *spec = codec->spec;
3327 	hda_nid_t hp_pin;
3328 
3329 	switch (action) {
3330 	case HDA_FIXUP_ACT_PRE_PROBE:
3331 		spec->has_hs_key = 1;
3332 		snd_hda_jack_detect_enable_callback(codec, 0x55,
3333 						    alc_headset_btn_callback);
3334 		break;
3335 	case HDA_FIXUP_ACT_BUILD:
3336 		hp_pin = alc_get_hp_pin(spec);
3337 		if (!hp_pin || snd_hda_jack_bind_keymap(codec, 0x55,
3338 							alc_headset_btn_keymap,
3339 							hp_pin))
3340 			snd_hda_jack_add_kctl(codec, 0x55, "Headset Jack",
3341 					      false, SND_JACK_HEADSET,
3342 					      alc_headset_btn_keymap);
3343 
3344 		alc_enable_headset_jack_key(codec);
3345 		break;
3346 	}
3347 }
3348 
3349 static void alc269vb_toggle_power_output(struct hda_codec *codec, int power_up)
3350 {
3351 	alc_update_coef_idx(codec, 0x04, 1 << 11, power_up ? (1 << 11) : 0);
3352 }
3353 
3354 static void alc269_shutup(struct hda_codec *codec)
3355 {
3356 	struct alc_spec *spec = codec->spec;
3357 
3358 	if (spec->codec_variant == ALC269_TYPE_ALC269VB)
3359 		alc269vb_toggle_power_output(codec, 0);
3360 	if (spec->codec_variant == ALC269_TYPE_ALC269VB &&
3361 			(alc_get_coef0(codec) & 0x00ff) == 0x018) {
3362 		msleep(150);
3363 	}
3364 	alc_shutup_pins(codec);
3365 }
3366 
3367 static const struct coef_fw alc282_coefs[] = {
3368 	WRITE_COEF(0x03, 0x0002), /* Power Down Control */
3369 	UPDATE_COEF(0x05, 0xff3f, 0x0700), /* FIFO and filter clock */
3370 	WRITE_COEF(0x07, 0x0200), /* DMIC control */
3371 	UPDATE_COEF(0x06, 0x00f0, 0), /* Analog clock */
3372 	UPDATE_COEF(0x08, 0xfffc, 0x0c2c), /* JD */
3373 	WRITE_COEF(0x0a, 0xcccc), /* JD offset1 */
3374 	WRITE_COEF(0x0b, 0xcccc), /* JD offset2 */
3375 	WRITE_COEF(0x0e, 0x6e00), /* LDO1/2/3, DAC/ADC */
3376 	UPDATE_COEF(0x0f, 0xf800, 0x1000), /* JD */
3377 	UPDATE_COEF(0x10, 0xfc00, 0x0c00), /* Capless */
3378 	WRITE_COEF(0x6f, 0x0), /* Class D test 4 */
3379 	UPDATE_COEF(0x0c, 0xfe00, 0), /* IO power down directly */
3380 	WRITE_COEF(0x34, 0xa0c0), /* ANC */
3381 	UPDATE_COEF(0x16, 0x0008, 0), /* AGC MUX */
3382 	UPDATE_COEF(0x1d, 0x00e0, 0), /* DAC simple content protection */
3383 	UPDATE_COEF(0x1f, 0x00e0, 0), /* ADC simple content protection */
3384 	WRITE_COEF(0x21, 0x8804), /* DAC ADC Zero Detection */
3385 	WRITE_COEF(0x63, 0x2902), /* PLL */
3386 	WRITE_COEF(0x68, 0xa080), /* capless control 2 */
3387 	WRITE_COEF(0x69, 0x3400), /* capless control 3 */
3388 	WRITE_COEF(0x6a, 0x2f3e), /* capless control 4 */
3389 	WRITE_COEF(0x6b, 0x0), /* capless control 5 */
3390 	UPDATE_COEF(0x6d, 0x0fff, 0x0900), /* class D test 2 */
3391 	WRITE_COEF(0x6e, 0x110a), /* class D test 3 */
3392 	UPDATE_COEF(0x70, 0x00f8, 0x00d8), /* class D test 5 */
3393 	WRITE_COEF(0x71, 0x0014), /* class D test 6 */
3394 	WRITE_COEF(0x72, 0xc2ba), /* classD OCP */
3395 	UPDATE_COEF(0x77, 0x0f80, 0), /* classD pure DC test */
3396 	WRITE_COEF(0x6c, 0xfc06), /* Class D amp control */
3397 	{}
3398 };
3399 
3400 static void alc282_restore_default_value(struct hda_codec *codec)
3401 {
3402 	alc_process_coef_fw(codec, alc282_coefs);
3403 }
3404 
3405 static void alc282_init(struct hda_codec *codec)
3406 {
3407 	struct alc_spec *spec = codec->spec;
3408 	hda_nid_t hp_pin = alc_get_hp_pin(spec);
3409 	bool hp_pin_sense;
3410 	int coef78;
3411 
3412 	alc282_restore_default_value(codec);
3413 
3414 	if (!hp_pin)
3415 		return;
3416 	hp_pin_sense = snd_hda_jack_detect(codec, hp_pin);
3417 	coef78 = alc_read_coef_idx(codec, 0x78);
3418 
3419 	/* Index 0x78 Direct Drive HP AMP LPM Control 1 */
3420 	/* Headphone capless set to high power mode */
3421 	alc_write_coef_idx(codec, 0x78, 0x9004);
3422 
3423 	if (hp_pin_sense)
3424 		msleep(2);
3425 
3426 	snd_hda_codec_write(codec, hp_pin, 0,
3427 			    AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);
3428 
3429 	if (hp_pin_sense)
3430 		msleep(85);
3431 
3432 	snd_hda_codec_write(codec, hp_pin, 0,
3433 			    AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT);
3434 
3435 	if (hp_pin_sense)
3436 		msleep(100);
3437 
3438 	/* Headphone capless set to normal mode */
3439 	alc_write_coef_idx(codec, 0x78, coef78);
3440 }
3441 
3442 static void alc282_shutup(struct hda_codec *codec)
3443 {
3444 	struct alc_spec *spec = codec->spec;
3445 	hda_nid_t hp_pin = alc_get_hp_pin(spec);
3446 	bool hp_pin_sense;
3447 	int coef78;
3448 
3449 	if (!hp_pin) {
3450 		alc269_shutup(codec);
3451 		return;
3452 	}
3453 
3454 	hp_pin_sense = snd_hda_jack_detect(codec, hp_pin);
3455 	coef78 = alc_read_coef_idx(codec, 0x78);
3456 	alc_write_coef_idx(codec, 0x78, 0x9004);
3457 
3458 	if (hp_pin_sense)
3459 		msleep(2);
3460 
3461 	snd_hda_codec_write(codec, hp_pin, 0,
3462 			    AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);
3463 
3464 	if (hp_pin_sense)
3465 		msleep(85);
3466 
3467 	if (!spec->no_shutup_pins)
3468 		snd_hda_codec_write(codec, hp_pin, 0,
3469 				    AC_VERB_SET_PIN_WIDGET_CONTROL, 0x0);
3470 
3471 	if (hp_pin_sense)
3472 		msleep(100);
3473 
3474 	alc_auto_setup_eapd(codec, false);
3475 	alc_shutup_pins(codec);
3476 	alc_write_coef_idx(codec, 0x78, coef78);
3477 }
3478 
3479 static const struct coef_fw alc283_coefs[] = {
3480 	WRITE_COEF(0x03, 0x0002), /* Power Down Control */
3481 	UPDATE_COEF(0x05, 0xff3f, 0x0700), /* FIFO and filter clock */
3482 	WRITE_COEF(0x07, 0x0200), /* DMIC control */
3483 	UPDATE_COEF(0x06, 0x00f0, 0), /* Analog clock */
3484 	UPDATE_COEF(0x08, 0xfffc, 0x0c2c), /* JD */
3485 	WRITE_COEF(0x0a, 0xcccc), /* JD offset1 */
3486 	WRITE_COEF(0x0b, 0xcccc), /* JD offset2 */
3487 	WRITE_COEF(0x0e, 0x6fc0), /* LDO1/2/3, DAC/ADC */
3488 	UPDATE_COEF(0x0f, 0xf800, 0x1000), /* JD */
3489 	UPDATE_COEF(0x10, 0xfc00, 0x0c00), /* Capless */
3490 	WRITE_COEF(0x3a, 0x0), /* Class D test 4 */
3491 	UPDATE_COEF(0x0c, 0xfe00, 0x0), /* IO power down directly */
3492 	WRITE_COEF(0x22, 0xa0c0), /* ANC */
3493 	UPDATE_COEFEX(0x53, 0x01, 0x000f, 0x0008), /* AGC MUX */
3494 	UPDATE_COEF(0x1d, 0x00e0, 0), /* DAC simple content protection */
3495 	UPDATE_COEF(0x1f, 0x00e0, 0), /* ADC simple content protection */
3496 	WRITE_COEF(0x21, 0x8804), /* DAC ADC Zero Detection */
3497 	WRITE_COEF(0x2e, 0x2902), /* PLL */
3498 	WRITE_COEF(0x33, 0xa080), /* capless control 2 */
3499 	WRITE_COEF(0x34, 0x3400), /* capless control 3 */
3500 	WRITE_COEF(0x35, 0x2f3e), /* capless control 4 */
3501 	WRITE_COEF(0x36, 0x0), /* capless control 5 */
3502 	UPDATE_COEF(0x38, 0x0fff, 0x0900), /* class D test 2 */
3503 	WRITE_COEF(0x39, 0x110a), /* class D test 3 */
3504 	UPDATE_COEF(0x3b, 0x00f8, 0x00d8), /* class D test 5 */
3505 	WRITE_COEF(0x3c, 0x0014), /* class D test 6 */
3506 	WRITE_COEF(0x3d, 0xc2ba), /* classD OCP */
3507 	UPDATE_COEF(0x42, 0x0f80, 0x0), /* classD pure DC test */
3508 	WRITE_COEF(0x49, 0x0), /* test mode */
3509 	UPDATE_COEF(0x40, 0xf800, 0x9800), /* Class D DC enable */
3510 	UPDATE_COEF(0x42, 0xf000, 0x2000), /* DC offset */
3511 	WRITE_COEF(0x37, 0xfc06), /* Class D amp control */
3512 	UPDATE_COEF(0x1b, 0x8000, 0), /* HP JD control */
3513 	{}
3514 };
3515 
3516 static void alc283_restore_default_value(struct hda_codec *codec)
3517 {
3518 	alc_process_coef_fw(codec, alc283_coefs);
3519 }
3520 
3521 static void alc283_init(struct hda_codec *codec)
3522 {
3523 	struct alc_spec *spec = codec->spec;
3524 	hda_nid_t hp_pin = alc_get_hp_pin(spec);
3525 	bool hp_pin_sense;
3526 
3527 	alc283_restore_default_value(codec);
3528 
3529 	if (!hp_pin)
3530 		return;
3531 
3532 	msleep(30);
3533 	hp_pin_sense = snd_hda_jack_detect(codec, hp_pin);
3534 
3535 	/* Index 0x43 Direct Drive HP AMP LPM Control 1 */
3536 	/* Headphone capless set to high power mode */
3537 	alc_write_coef_idx(codec, 0x43, 0x9004);
3538 
3539 	snd_hda_codec_write(codec, hp_pin, 0,
3540 			    AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);
3541 
3542 	if (hp_pin_sense)
3543 		msleep(85);
3544 
3545 	snd_hda_codec_write(codec, hp_pin, 0,
3546 			    AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT);
3547 
3548 	if (hp_pin_sense)
3549 		msleep(85);
3550 	/* Index 0x46 Combo jack auto switch control 2 */
3551 	/* 3k pull low control for Headset jack. */
3552 	alc_update_coef_idx(codec, 0x46, 3 << 12, 0);
3553 	/* Headphone capless set to normal mode */
3554 	alc_write_coef_idx(codec, 0x43, 0x9614);
3555 }
3556 
3557 static void alc283_shutup(struct hda_codec *codec)
3558 {
3559 	struct alc_spec *spec = codec->spec;
3560 	hda_nid_t hp_pin = alc_get_hp_pin(spec);
3561 	bool hp_pin_sense;
3562 
3563 	if (!hp_pin) {
3564 		alc269_shutup(codec);
3565 		return;
3566 	}
3567 
3568 	hp_pin_sense = snd_hda_jack_detect(codec, hp_pin);
3569 
3570 	alc_write_coef_idx(codec, 0x43, 0x9004);
3571 
3572 	/*depop hp during suspend*/
3573 	alc_write_coef_idx(codec, 0x06, 0x2100);
3574 
3575 	snd_hda_codec_write(codec, hp_pin, 0,
3576 			    AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);
3577 
3578 	if (hp_pin_sense)
3579 		msleep(100);
3580 
3581 	if (!spec->no_shutup_pins)
3582 		snd_hda_codec_write(codec, hp_pin, 0,
3583 				    AC_VERB_SET_PIN_WIDGET_CONTROL, 0x0);
3584 
3585 	alc_update_coef_idx(codec, 0x46, 0, 3 << 12);
3586 
3587 	if (hp_pin_sense)
3588 		msleep(100);
3589 	alc_auto_setup_eapd(codec, false);
3590 	alc_shutup_pins(codec);
3591 	alc_write_coef_idx(codec, 0x43, 0x9614);
3592 }
3593 
3594 static void alc256_init(struct hda_codec *codec)
3595 {
3596 	struct alc_spec *spec = codec->spec;
3597 	hda_nid_t hp_pin = alc_get_hp_pin(spec);
3598 	bool hp_pin_sense;
3599 
3600 	if (spec->ultra_low_power) {
3601 		alc_update_coef_idx(codec, 0x03, 1<<1, 1<<1);
3602 		alc_update_coef_idx(codec, 0x08, 3<<2, 3<<2);
3603 		alc_update_coef_idx(codec, 0x08, 7<<4, 0);
3604 		alc_update_coef_idx(codec, 0x3b, 1<<15, 0);
3605 		alc_update_coef_idx(codec, 0x0e, 7<<6, 7<<6);
3606 		msleep(30);
3607 	}
3608 
3609 	if (!hp_pin)
3610 		hp_pin = 0x21;
3611 
3612 	msleep(30);
3613 
3614 	hp_pin_sense = snd_hda_jack_detect(codec, hp_pin);
3615 
3616 	if (hp_pin_sense)
3617 		msleep(2);
3618 
3619 	alc_update_coefex_idx(codec, 0x57, 0x04, 0x0007, 0x1); /* Low power */
3620 
3621 	snd_hda_codec_write(codec, hp_pin, 0,
3622 			    AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);
3623 
3624 	if (hp_pin_sense || spec->ultra_low_power)
3625 		msleep(85);
3626 
3627 	snd_hda_codec_write(codec, hp_pin, 0,
3628 			    AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT);
3629 
3630 	if (hp_pin_sense || spec->ultra_low_power)
3631 		msleep(100);
3632 
3633 	alc_update_coef_idx(codec, 0x46, 3 << 12, 0);
3634 	alc_update_coefex_idx(codec, 0x57, 0x04, 0x0007, 0x4); /* Hight power */
3635 	alc_update_coefex_idx(codec, 0x53, 0x02, 0x8000, 1 << 15); /* Clear bit */
3636 	alc_update_coefex_idx(codec, 0x53, 0x02, 0x8000, 0 << 15);
3637 	/*
3638 	 * Expose headphone mic (or possibly Line In on some machines) instead
3639 	 * of PC Beep on 1Ah, and disable 1Ah loopback for all outputs. See
3640 	 * Documentation/sound/hd-audio/realtek-pc-beep.rst for details of
3641 	 * this register.
3642 	 */
3643 	alc_write_coef_idx(codec, 0x36, 0x5757);
3644 }
3645 
3646 static void alc256_shutup(struct hda_codec *codec)
3647 {
3648 	struct alc_spec *spec = codec->spec;
3649 	hda_nid_t hp_pin = alc_get_hp_pin(spec);
3650 	bool hp_pin_sense;
3651 
3652 	if (!hp_pin)
3653 		hp_pin = 0x21;
3654 
3655 	alc_update_coefex_idx(codec, 0x57, 0x04, 0x0007, 0x1); /* Low power */
3656 	hp_pin_sense = snd_hda_jack_detect(codec, hp_pin);
3657 
3658 	if (hp_pin_sense)
3659 		msleep(2);
3660 
3661 	snd_hda_codec_write(codec, hp_pin, 0,
3662 			    AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);
3663 
3664 	if (hp_pin_sense || spec->ultra_low_power)
3665 		msleep(85);
3666 
3667 	/* 3k pull low control for Headset jack. */
3668 	/* NOTE: call this before clearing the pin, otherwise codec stalls */
3669 	/* If disable 3k pulldown control for alc257, the Mic detection will not work correctly
3670 	 * when booting with headset plugged. So skip setting it for the codec alc257
3671 	 */
3672 	if (spec->en_3kpull_low)
3673 		alc_update_coef_idx(codec, 0x46, 0, 3 << 12);
3674 
3675 	if (!spec->no_shutup_pins)
3676 		snd_hda_codec_write(codec, hp_pin, 0,
3677 				    AC_VERB_SET_PIN_WIDGET_CONTROL, 0x0);
3678 
3679 	if (hp_pin_sense || spec->ultra_low_power)
3680 		msleep(100);
3681 
3682 	alc_auto_setup_eapd(codec, false);
3683 	alc_shutup_pins(codec);
3684 	if (spec->ultra_low_power) {
3685 		msleep(50);
3686 		alc_update_coef_idx(codec, 0x03, 1<<1, 0);
3687 		alc_update_coef_idx(codec, 0x08, 7<<4, 7<<4);
3688 		alc_update_coef_idx(codec, 0x08, 3<<2, 0);
3689 		alc_update_coef_idx(codec, 0x3b, 1<<15, 1<<15);
3690 		alc_update_coef_idx(codec, 0x0e, 7<<6, 0);
3691 		msleep(30);
3692 	}
3693 }
3694 
3695 static void alc285_hp_init(struct hda_codec *codec)
3696 {
3697 	struct alc_spec *spec = codec->spec;
3698 	hda_nid_t hp_pin = alc_get_hp_pin(spec);
3699 	int i, val;
3700 	int coef38, coef0d, coef36;
3701 
3702 	alc_write_coefex_idx(codec, 0x58, 0x00, 0x1888); /* write default value */
3703 	alc_update_coef_idx(codec, 0x4a, 1<<15, 1<<15); /* Reset HP JD */
3704 	coef38 = alc_read_coef_idx(codec, 0x38); /* Amp control */
3705 	coef0d = alc_read_coef_idx(codec, 0x0d); /* Digital Misc control */
3706 	coef36 = alc_read_coef_idx(codec, 0x36); /* Passthrough Control */
3707 	alc_update_coef_idx(codec, 0x38, 1<<4, 0x0);
3708 	alc_update_coef_idx(codec, 0x0d, 0x110, 0x0);
3709 
3710 	alc_update_coef_idx(codec, 0x67, 0xf000, 0x3000);
3711 
3712 	if (hp_pin)
3713 		snd_hda_codec_write(codec, hp_pin, 0,
3714 			    AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);
3715 
3716 	msleep(130);
3717 	alc_update_coef_idx(codec, 0x36, 1<<14, 1<<14);
3718 	alc_update_coef_idx(codec, 0x36, 1<<13, 0x0);
3719 
3720 	if (hp_pin)
3721 		snd_hda_codec_write(codec, hp_pin, 0,
3722 			    AC_VERB_SET_PIN_WIDGET_CONTROL, 0x0);
3723 	msleep(10);
3724 	alc_write_coef_idx(codec, 0x67, 0x0); /* Set HP depop to manual mode */
3725 	alc_write_coefex_idx(codec, 0x58, 0x00, 0x7880);
3726 	alc_write_coefex_idx(codec, 0x58, 0x0f, 0xf049);
3727 	alc_update_coefex_idx(codec, 0x58, 0x03, 0x00f0, 0x00c0);
3728 
3729 	alc_write_coefex_idx(codec, 0x58, 0x00, 0xf888); /* HP depop procedure start */
3730 	val = alc_read_coefex_idx(codec, 0x58, 0x00);
3731 	for (i = 0; i < 20 && val & 0x8000; i++) {
3732 		msleep(50);
3733 		val = alc_read_coefex_idx(codec, 0x58, 0x00);
3734 	} /* Wait for depop procedure finish  */
3735 
3736 	alc_write_coefex_idx(codec, 0x58, 0x00, val); /* write back the result */
3737 	alc_update_coef_idx(codec, 0x38, 1<<4, coef38);
3738 	alc_update_coef_idx(codec, 0x0d, 0x110, coef0d);
3739 	alc_update_coef_idx(codec, 0x36, 3<<13, coef36);
3740 
3741 	msleep(50);
3742 	alc_update_coef_idx(codec, 0x4a, 1<<15, 0);
3743 }
3744 
3745 static void alc225_init(struct hda_codec *codec)
3746 {
3747 	struct alc_spec *spec = codec->spec;
3748 	hda_nid_t hp_pin = alc_get_hp_pin(spec);
3749 	bool hp1_pin_sense, hp2_pin_sense;
3750 
3751 	if (spec->ultra_low_power) {
3752 		alc_update_coef_idx(codec, 0x08, 0x0f << 2, 3<<2);
3753 		alc_update_coef_idx(codec, 0x0e, 7<<6, 7<<6);
3754 		alc_update_coef_idx(codec, 0x33, 1<<11, 0);
3755 		msleep(30);
3756 	}
3757 
3758 	if (spec->codec_variant != ALC269_TYPE_ALC287 &&
3759 		spec->codec_variant != ALC269_TYPE_ALC245)
3760 		/* required only at boot or S3 and S4 resume time */
3761 		if (!spec->done_hp_init ||
3762 			is_s3_resume(codec) ||
3763 			is_s4_resume(codec)) {
3764 			alc285_hp_init(codec);
3765 			spec->done_hp_init = true;
3766 		}
3767 
3768 	if (!hp_pin)
3769 		hp_pin = 0x21;
3770 	msleep(30);
3771 
3772 	hp1_pin_sense = snd_hda_jack_detect(codec, hp_pin);
3773 	hp2_pin_sense = snd_hda_jack_detect(codec, 0x16);
3774 
3775 	if (hp1_pin_sense || hp2_pin_sense)
3776 		msleep(2);
3777 
3778 	alc_update_coefex_idx(codec, 0x57, 0x04, 0x0007, 0x1); /* Low power */
3779 
3780 	if (hp1_pin_sense || spec->ultra_low_power)
3781 		snd_hda_codec_write(codec, hp_pin, 0,
3782 			    AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);
3783 	if (hp2_pin_sense)
3784 		snd_hda_codec_write(codec, 0x16, 0,
3785 			    AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);
3786 
3787 	if (hp1_pin_sense || hp2_pin_sense || spec->ultra_low_power)
3788 		msleep(85);
3789 
3790 	if (hp1_pin_sense || spec->ultra_low_power)
3791 		snd_hda_codec_write(codec, hp_pin, 0,
3792 			    AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT);
3793 	if (hp2_pin_sense)
3794 		snd_hda_codec_write(codec, 0x16, 0,
3795 			    AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT);
3796 
3797 	if (hp1_pin_sense || hp2_pin_sense || spec->ultra_low_power)
3798 		msleep(100);
3799 
3800 	alc_update_coef_idx(codec, 0x4a, 3 << 10, 0);
3801 	alc_update_coefex_idx(codec, 0x57, 0x04, 0x0007, 0x4); /* Hight power */
3802 }
3803 
3804 static void alc225_shutup(struct hda_codec *codec)
3805 {
3806 	struct alc_spec *spec = codec->spec;
3807 	hda_nid_t hp_pin = alc_get_hp_pin(spec);
3808 	bool hp1_pin_sense, hp2_pin_sense;
3809 
3810 	if (!hp_pin)
3811 		hp_pin = 0x21;
3812 
3813 	alc_disable_headset_jack_key(codec);
3814 	/* 3k pull low control for Headset jack. */
3815 	alc_update_coef_idx(codec, 0x4a, 0, 3 << 10);
3816 
3817 	hp1_pin_sense = snd_hda_jack_detect(codec, hp_pin);
3818 	hp2_pin_sense = snd_hda_jack_detect(codec, 0x16);
3819 
3820 	if (hp1_pin_sense || hp2_pin_sense)
3821 		msleep(2);
3822 
3823 	if (hp1_pin_sense || spec->ultra_low_power)
3824 		snd_hda_codec_write(codec, hp_pin, 0,
3825 			    AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);
3826 	if (hp2_pin_sense)
3827 		snd_hda_codec_write(codec, 0x16, 0,
3828 			    AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);
3829 
3830 	if (hp1_pin_sense || hp2_pin_sense || spec->ultra_low_power)
3831 		msleep(85);
3832 
3833 	if (hp1_pin_sense || spec->ultra_low_power)
3834 		snd_hda_codec_write(codec, hp_pin, 0,
3835 			    AC_VERB_SET_PIN_WIDGET_CONTROL, 0x0);
3836 	if (hp2_pin_sense)
3837 		snd_hda_codec_write(codec, 0x16, 0,
3838 			    AC_VERB_SET_PIN_WIDGET_CONTROL, 0x0);
3839 
3840 	if (hp1_pin_sense || hp2_pin_sense || spec->ultra_low_power)
3841 		msleep(100);
3842 
3843 	alc_auto_setup_eapd(codec, false);
3844 	alc_shutup_pins(codec);
3845 	if (spec->ultra_low_power) {
3846 		msleep(50);
3847 		alc_update_coef_idx(codec, 0x08, 0x0f << 2, 0x0c << 2);
3848 		alc_update_coef_idx(codec, 0x0e, 7<<6, 0);
3849 		alc_update_coef_idx(codec, 0x33, 1<<11, 1<<11);
3850 		alc_update_coef_idx(codec, 0x4a, 3<<4, 2<<4);
3851 		msleep(30);
3852 	}
3853 
3854 	alc_update_coef_idx(codec, 0x4a, 3 << 10, 0);
3855 	alc_enable_headset_jack_key(codec);
3856 }
3857 
3858 static void alc_default_init(struct hda_codec *codec)
3859 {
3860 	struct alc_spec *spec = codec->spec;
3861 	hda_nid_t hp_pin = alc_get_hp_pin(spec);
3862 	bool hp_pin_sense;
3863 
3864 	if (!hp_pin)
3865 		return;
3866 
3867 	msleep(30);
3868 
3869 	hp_pin_sense = snd_hda_jack_detect(codec, hp_pin);
3870 
3871 	if (hp_pin_sense) {
3872 		msleep(2);
3873 
3874 		snd_hda_codec_write(codec, hp_pin, 0,
3875 				    AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT);
3876 
3877 		msleep(75);
3878 
3879 		snd_hda_codec_write(codec, hp_pin, 0,
3880 				    AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE);
3881 		msleep(75);
3882 	}
3883 }
3884 
3885 static void alc_default_shutup(struct hda_codec *codec)
3886 {
3887 	struct alc_spec *spec = codec->spec;
3888 	hda_nid_t hp_pin = alc_get_hp_pin(spec);
3889 	bool hp_pin_sense;
3890 
3891 	if (!hp_pin) {
3892 		alc269_shutup(codec);
3893 		return;
3894 	}
3895 
3896 	hp_pin_sense = snd_hda_jack_detect(codec, hp_pin);
3897 
3898 	if (hp_pin_sense) {
3899 		msleep(2);
3900 
3901 		snd_hda_codec_write(codec, hp_pin, 0,
3902 				    AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);
3903 
3904 		msleep(75);
3905 
3906 		if (!spec->no_shutup_pins)
3907 			snd_hda_codec_write(codec, hp_pin, 0,
3908 					    AC_VERB_SET_PIN_WIDGET_CONTROL, 0x0);
3909 
3910 		msleep(75);
3911 	}
3912 	alc_auto_setup_eapd(codec, false);
3913 	alc_shutup_pins(codec);
3914 }
3915 
3916 static void alc294_hp_init(struct hda_codec *codec)
3917 {
3918 	struct alc_spec *spec = codec->spec;
3919 	hda_nid_t hp_pin = alc_get_hp_pin(spec);
3920 	int i, val;
3921 
3922 	if (!hp_pin)
3923 		return;
3924 
3925 	snd_hda_codec_write(codec, hp_pin, 0,
3926 			    AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);
3927 
3928 	msleep(100);
3929 
3930 	if (!spec->no_shutup_pins)
3931 		snd_hda_codec_write(codec, hp_pin, 0,
3932 				    AC_VERB_SET_PIN_WIDGET_CONTROL, 0x0);
3933 
3934 	alc_update_coef_idx(codec, 0x6f, 0x000f, 0);/* Set HP depop to manual mode */
3935 	alc_update_coefex_idx(codec, 0x58, 0x00, 0x8000, 0x8000); /* HP depop procedure start */
3936 
3937 	/* Wait for depop procedure finish  */
3938 	val = alc_read_coefex_idx(codec, 0x58, 0x01);
3939 	for (i = 0; i < 20 && val & 0x0080; i++) {
3940 		msleep(50);
3941 		val = alc_read_coefex_idx(codec, 0x58, 0x01);
3942 	}
3943 	/* Set HP depop to auto mode */
3944 	alc_update_coef_idx(codec, 0x6f, 0x000f, 0x000b);
3945 	msleep(50);
3946 }
3947 
3948 static void alc294_init(struct hda_codec *codec)
3949 {
3950 	struct alc_spec *spec = codec->spec;
3951 
3952 	/* required only at boot or S4 resume time */
3953 	if (!spec->done_hp_init ||
3954 	    codec->core.dev.power.power_state.event == PM_EVENT_RESTORE) {
3955 		alc294_hp_init(codec);
3956 		spec->done_hp_init = true;
3957 	}
3958 	alc_default_init(codec);
3959 }
3960 
3961 static void alc5505_coef_set(struct hda_codec *codec, unsigned int index_reg,
3962 			     unsigned int val)
3963 {
3964 	snd_hda_codec_write(codec, 0x51, 0, AC_VERB_SET_COEF_INDEX, index_reg >> 1);
3965 	snd_hda_codec_write(codec, 0x51, 0, AC_VERB_SET_PROC_COEF, val & 0xffff); /* LSB */
3966 	snd_hda_codec_write(codec, 0x51, 0, AC_VERB_SET_PROC_COEF, val >> 16); /* MSB */
3967 }
3968 
3969 static int alc5505_coef_get(struct hda_codec *codec, unsigned int index_reg)
3970 {
3971 	unsigned int val;
3972 
3973 	snd_hda_codec_write(codec, 0x51, 0, AC_VERB_SET_COEF_INDEX, index_reg >> 1);
3974 	val = snd_hda_codec_read(codec, 0x51, 0, AC_VERB_GET_PROC_COEF, 0)
3975 		& 0xffff;
3976 	val |= snd_hda_codec_read(codec, 0x51, 0, AC_VERB_GET_PROC_COEF, 0)
3977 		<< 16;
3978 	return val;
3979 }
3980 
3981 static void alc5505_dsp_halt(struct hda_codec *codec)
3982 {
3983 	unsigned int val;
3984 
3985 	alc5505_coef_set(codec, 0x3000, 0x000c); /* DSP CPU stop */
3986 	alc5505_coef_set(codec, 0x880c, 0x0008); /* DDR enter self refresh */
3987 	alc5505_coef_set(codec, 0x61c0, 0x11110080); /* Clock control for PLL and CPU */
3988 	alc5505_coef_set(codec, 0x6230, 0xfc0d4011); /* Disable Input OP */
3989 	alc5505_coef_set(codec, 0x61b4, 0x040a2b03); /* Stop PLL2 */
3990 	alc5505_coef_set(codec, 0x61b0, 0x00005b17); /* Stop PLL1 */
3991 	alc5505_coef_set(codec, 0x61b8, 0x04133303); /* Stop PLL3 */
3992 	val = alc5505_coef_get(codec, 0x6220);
3993 	alc5505_coef_set(codec, 0x6220, (val | 0x3000)); /* switch Ringbuffer clock to DBUS clock */
3994 }
3995 
3996 static void alc5505_dsp_back_from_halt(struct hda_codec *codec)
3997 {
3998 	alc5505_coef_set(codec, 0x61b8, 0x04133302);
3999 	alc5505_coef_set(codec, 0x61b0, 0x00005b16);
4000 	alc5505_coef_set(codec, 0x61b4, 0x040a2b02);
4001 	alc5505_coef_set(codec, 0x6230, 0xf80d4011);
4002 	alc5505_coef_set(codec, 0x6220, 0x2002010f);
4003 	alc5505_coef_set(codec, 0x880c, 0x00000004);
4004 }
4005 
4006 static void alc5505_dsp_init(struct hda_codec *codec)
4007 {
4008 	unsigned int val;
4009 
4010 	alc5505_dsp_halt(codec);
4011 	alc5505_dsp_back_from_halt(codec);
4012 	alc5505_coef_set(codec, 0x61b0, 0x5b14); /* PLL1 control */
4013 	alc5505_coef_set(codec, 0x61b0, 0x5b16);
4014 	alc5505_coef_set(codec, 0x61b4, 0x04132b00); /* PLL2 control */
4015 	alc5505_coef_set(codec, 0x61b4, 0x04132b02);
4016 	alc5505_coef_set(codec, 0x61b8, 0x041f3300); /* PLL3 control*/
4017 	alc5505_coef_set(codec, 0x61b8, 0x041f3302);
4018 	snd_hda_codec_write(codec, 0x51, 0, AC_VERB_SET_CODEC_RESET, 0); /* Function reset */
4019 	alc5505_coef_set(codec, 0x61b8, 0x041b3302);
4020 	alc5505_coef_set(codec, 0x61b8, 0x04173302);
4021 	alc5505_coef_set(codec, 0x61b8, 0x04163302);
4022 	alc5505_coef_set(codec, 0x8800, 0x348b328b); /* DRAM control */
4023 	alc5505_coef_set(codec, 0x8808, 0x00020022); /* DRAM control */
4024 	alc5505_coef_set(codec, 0x8818, 0x00000400); /* DRAM control */
4025 
4026 	val = alc5505_coef_get(codec, 0x6200) >> 16; /* Read revision ID */
4027 	if (val <= 3)
4028 		alc5505_coef_set(codec, 0x6220, 0x2002010f); /* I/O PAD Configuration */
4029 	else
4030 		alc5505_coef_set(codec, 0x6220, 0x6002018f);
4031 
4032 	alc5505_coef_set(codec, 0x61ac, 0x055525f0); /**/
4033 	alc5505_coef_set(codec, 0x61c0, 0x12230080); /* Clock control */
4034 	alc5505_coef_set(codec, 0x61b4, 0x040e2b02); /* PLL2 control */
4035 	alc5505_coef_set(codec, 0x61bc, 0x010234f8); /* OSC Control */
4036 	alc5505_coef_set(codec, 0x880c, 0x00000004); /* DRAM Function control */
4037 	alc5505_coef_set(codec, 0x880c, 0x00000003);
4038 	alc5505_coef_set(codec, 0x880c, 0x00000010);
4039 
4040 #ifdef HALT_REALTEK_ALC5505
4041 	alc5505_dsp_halt(codec);
4042 #endif
4043 }
4044 
4045 #ifdef HALT_REALTEK_ALC5505
4046 #define alc5505_dsp_suspend(codec)	do { } while (0) /* NOP */
4047 #define alc5505_dsp_resume(codec)	do { } while (0) /* NOP */
4048 #else
4049 #define alc5505_dsp_suspend(codec)	alc5505_dsp_halt(codec)
4050 #define alc5505_dsp_resume(codec)	alc5505_dsp_back_from_halt(codec)
4051 #endif
4052 
4053 static int alc269_suspend(struct hda_codec *codec)
4054 {
4055 	struct alc_spec *spec = codec->spec;
4056 
4057 	if (spec->has_alc5505_dsp)
4058 		alc5505_dsp_suspend(codec);
4059 
4060 	return alc_suspend(codec);
4061 }
4062 
4063 static int alc269_resume(struct hda_codec *codec)
4064 {
4065 	struct alc_spec *spec = codec->spec;
4066 
4067 	if (spec->codec_variant == ALC269_TYPE_ALC269VB)
4068 		alc269vb_toggle_power_output(codec, 0);
4069 	if (spec->codec_variant == ALC269_TYPE_ALC269VB &&
4070 			(alc_get_coef0(codec) & 0x00ff) == 0x018) {
4071 		msleep(150);
4072 	}
4073 
4074 	codec->patch_ops.init(codec);
4075 
4076 	if (spec->codec_variant == ALC269_TYPE_ALC269VB)
4077 		alc269vb_toggle_power_output(codec, 1);
4078 	if (spec->codec_variant == ALC269_TYPE_ALC269VB &&
4079 			(alc_get_coef0(codec) & 0x00ff) == 0x017) {
4080 		msleep(200);
4081 	}
4082 
4083 	snd_hda_regmap_sync(codec);
4084 	hda_call_check_power_status(codec, 0x01);
4085 
4086 	/* on some machine, the BIOS will clear the codec gpio data when enter
4087 	 * suspend, and won't restore the data after resume, so we restore it
4088 	 * in the driver.
4089 	 */
4090 	if (spec->gpio_data)
4091 		alc_write_gpio_data(codec);
4092 
4093 	if (spec->has_alc5505_dsp)
4094 		alc5505_dsp_resume(codec);
4095 
4096 	return 0;
4097 }
4098 
4099 static void alc269_fixup_pincfg_no_hp_to_lineout(struct hda_codec *codec,
4100 						 const struct hda_fixup *fix, int action)
4101 {
4102 	struct alc_spec *spec = codec->spec;
4103 
4104 	if (action == HDA_FIXUP_ACT_PRE_PROBE)
4105 		spec->parse_flags = HDA_PINCFG_NO_HP_FIXUP;
4106 }
4107 
4108 static void alc269_fixup_pincfg_U7x7_headset_mic(struct hda_codec *codec,
4109 						 const struct hda_fixup *fix,
4110 						 int action)
4111 {
4112 	unsigned int cfg_headphone = snd_hda_codec_get_pincfg(codec, 0x21);
4113 	unsigned int cfg_headset_mic = snd_hda_codec_get_pincfg(codec, 0x19);
4114 
4115 	if (cfg_headphone && cfg_headset_mic == 0x411111f0)
4116 		snd_hda_codec_set_pincfg(codec, 0x19,
4117 			(cfg_headphone & ~AC_DEFCFG_DEVICE) |
4118 			(AC_JACK_MIC_IN << AC_DEFCFG_DEVICE_SHIFT));
4119 }
4120 
4121 static void alc269_fixup_hweq(struct hda_codec *codec,
4122 			       const struct hda_fixup *fix, int action)
4123 {
4124 	if (action == HDA_FIXUP_ACT_INIT)
4125 		alc_update_coef_idx(codec, 0x1e, 0, 0x80);
4126 }
4127 
4128 static void alc269_fixup_headset_mic(struct hda_codec *codec,
4129 				       const struct hda_fixup *fix, int action)
4130 {
4131 	struct alc_spec *spec = codec->spec;
4132 
4133 	if (action == HDA_FIXUP_ACT_PRE_PROBE)
4134 		spec->parse_flags |= HDA_PINCFG_HEADSET_MIC;
4135 }
4136 
4137 static void alc271_fixup_dmic(struct hda_codec *codec,
4138 			      const struct hda_fixup *fix, int action)
4139 {
4140 	static const struct hda_verb verbs[] = {
4141 		{0x20, AC_VERB_SET_COEF_INDEX, 0x0d},
4142 		{0x20, AC_VERB_SET_PROC_COEF, 0x4000},
4143 		{}
4144 	};
4145 	unsigned int cfg;
4146 
4147 	if (strcmp(codec->core.chip_name, "ALC271X") &&
4148 	    strcmp(codec->core.chip_name, "ALC269VB"))
4149 		return;
4150 	cfg = snd_hda_codec_get_pincfg(codec, 0x12);
4151 	if (get_defcfg_connect(cfg) == AC_JACK_PORT_FIXED)
4152 		snd_hda_sequence_write(codec, verbs);
4153 }
4154 
4155 /* Fix the speaker amp after resume, etc */
4156 static void alc269vb_fixup_aspire_e1_coef(struct hda_codec *codec,
4157 					  const struct hda_fixup *fix,
4158 					  int action)
4159 {
4160 	if (action == HDA_FIXUP_ACT_INIT)
4161 		alc_update_coef_idx(codec, 0x0d, 0x6000, 0x6000);
4162 }
4163 
4164 static void alc269_fixup_pcm_44k(struct hda_codec *codec,
4165 				 const struct hda_fixup *fix, int action)
4166 {
4167 	struct alc_spec *spec = codec->spec;
4168 
4169 	if (action != HDA_FIXUP_ACT_PROBE)
4170 		return;
4171 
4172 	/* Due to a hardware problem on Lenovo Ideadpad, we need to
4173 	 * fix the sample rate of analog I/O to 44.1kHz
4174 	 */
4175 	spec->gen.stream_analog_playback = &alc269_44k_pcm_analog_playback;
4176 	spec->gen.stream_analog_capture = &alc269_44k_pcm_analog_capture;
4177 }
4178 
4179 static void alc269_fixup_stereo_dmic(struct hda_codec *codec,
4180 				     const struct hda_fixup *fix, int action)
4181 {
4182 	/* The digital-mic unit sends PDM (differential signal) instead of
4183 	 * the standard PCM, thus you can't record a valid mono stream as is.
4184 	 * Below is a workaround specific to ALC269 to control the dmic
4185 	 * signal source as mono.
4186 	 */
4187 	if (action == HDA_FIXUP_ACT_INIT)
4188 		alc_update_coef_idx(codec, 0x07, 0, 0x80);
4189 }
4190 
4191 static void alc269_quanta_automute(struct hda_codec *codec)
4192 {
4193 	snd_hda_gen_update_outputs(codec);
4194 
4195 	alc_write_coef_idx(codec, 0x0c, 0x680);
4196 	alc_write_coef_idx(codec, 0x0c, 0x480);
4197 }
4198 
4199 static void alc269_fixup_quanta_mute(struct hda_codec *codec,
4200 				     const struct hda_fixup *fix, int action)
4201 {
4202 	struct alc_spec *spec = codec->spec;
4203 	if (action != HDA_FIXUP_ACT_PROBE)
4204 		return;
4205 	spec->gen.automute_hook = alc269_quanta_automute;
4206 }
4207 
4208 static void alc269_x101_hp_automute_hook(struct hda_codec *codec,
4209 					 struct hda_jack_callback *jack)
4210 {
4211 	struct alc_spec *spec = codec->spec;
4212 	int vref;
4213 	msleep(200);
4214 	snd_hda_gen_hp_automute(codec, jack);
4215 
4216 	vref = spec->gen.hp_jack_present ? PIN_VREF80 : 0;
4217 	msleep(100);
4218 	snd_hda_codec_write(codec, 0x18, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
4219 			    vref);
4220 	msleep(500);
4221 	snd_hda_codec_write(codec, 0x18, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
4222 			    vref);
4223 }
4224 
4225 /*
4226  * Magic sequence to make Huawei Matebook X right speaker working (bko#197801)
4227  */
4228 struct hda_alc298_mbxinit {
4229 	unsigned char value_0x23;
4230 	unsigned char value_0x25;
4231 };
4232 
4233 static void alc298_huawei_mbx_stereo_seq(struct hda_codec *codec,
4234 					 const struct hda_alc298_mbxinit *initval,
4235 					 bool first)
4236 {
4237 	snd_hda_codec_write(codec, 0x06, 0, AC_VERB_SET_DIGI_CONVERT_3, 0x0);
4238 	alc_write_coef_idx(codec, 0x26, 0xb000);
4239 
4240 	if (first)
4241 		snd_hda_codec_write(codec, 0x21, 0, AC_VERB_GET_PIN_SENSE, 0x0);
4242 
4243 	snd_hda_codec_write(codec, 0x6, 0, AC_VERB_SET_DIGI_CONVERT_3, 0x80);
4244 	alc_write_coef_idx(codec, 0x26, 0xf000);
4245 	alc_write_coef_idx(codec, 0x23, initval->value_0x23);
4246 
4247 	if (initval->value_0x23 != 0x1e)
4248 		alc_write_coef_idx(codec, 0x25, initval->value_0x25);
4249 
4250 	snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_COEF_INDEX, 0x26);
4251 	snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_PROC_COEF, 0xb010);
4252 }
4253 
4254 static void alc298_fixup_huawei_mbx_stereo(struct hda_codec *codec,
4255 					   const struct hda_fixup *fix,
4256 					   int action)
4257 {
4258 	/* Initialization magic */
4259 	static const struct hda_alc298_mbxinit dac_init[] = {
4260 		{0x0c, 0x00}, {0x0d, 0x00}, {0x0e, 0x00}, {0x0f, 0x00},
4261 		{0x10, 0x00}, {0x1a, 0x40}, {0x1b, 0x82}, {0x1c, 0x00},
4262 		{0x1d, 0x00}, {0x1e, 0x00}, {0x1f, 0x00},
4263 		{0x20, 0xc2}, {0x21, 0xc8}, {0x22, 0x26}, {0x23, 0x24},
4264 		{0x27, 0xff}, {0x28, 0xff}, {0x29, 0xff}, {0x2a, 0x8f},
4265 		{0x2b, 0x02}, {0x2c, 0x48}, {0x2d, 0x34}, {0x2e, 0x00},
4266 		{0x2f, 0x00},
4267 		{0x30, 0x00}, {0x31, 0x00}, {0x32, 0x00}, {0x33, 0x00},
4268 		{0x34, 0x00}, {0x35, 0x01}, {0x36, 0x93}, {0x37, 0x0c},
4269 		{0x38, 0x00}, {0x39, 0x00}, {0x3a, 0xf8}, {0x38, 0x80},
4270 		{}
4271 	};
4272 	const struct hda_alc298_mbxinit *seq;
4273 
4274 	if (action != HDA_FIXUP_ACT_INIT)
4275 		return;
4276 
4277 	/* Start */
4278 	snd_hda_codec_write(codec, 0x06, 0, AC_VERB_SET_DIGI_CONVERT_3, 0x00);
4279 	snd_hda_codec_write(codec, 0x06, 0, AC_VERB_SET_DIGI_CONVERT_3, 0x80);
4280 	alc_write_coef_idx(codec, 0x26, 0xf000);
4281 	alc_write_coef_idx(codec, 0x22, 0x31);
4282 	alc_write_coef_idx(codec, 0x23, 0x0b);
4283 	alc_write_coef_idx(codec, 0x25, 0x00);
4284 	snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_COEF_INDEX, 0x26);
4285 	snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_PROC_COEF, 0xb010);
4286 
4287 	for (seq = dac_init; seq->value_0x23; seq++)
4288 		alc298_huawei_mbx_stereo_seq(codec, seq, seq == dac_init);
4289 }
4290 
4291 static void alc269_fixup_x101_headset_mic(struct hda_codec *codec,
4292 				     const struct hda_fixup *fix, int action)
4293 {
4294 	struct alc_spec *spec = codec->spec;
4295 	if (action == HDA_FIXUP_ACT_PRE_PROBE) {
4296 		spec->parse_flags |= HDA_PINCFG_HEADSET_MIC;
4297 		spec->gen.hp_automute_hook = alc269_x101_hp_automute_hook;
4298 	}
4299 }
4300 
4301 static void alc_update_vref_led(struct hda_codec *codec, hda_nid_t pin,
4302 				bool polarity, bool on)
4303 {
4304 	unsigned int pinval;
4305 
4306 	if (!pin)
4307 		return;
4308 	if (polarity)
4309 		on = !on;
4310 	pinval = snd_hda_codec_get_pin_target(codec, pin);
4311 	pinval &= ~AC_PINCTL_VREFEN;
4312 	pinval |= on ? AC_PINCTL_VREF_80 : AC_PINCTL_VREF_HIZ;
4313 	/* temporarily power up/down for setting VREF */
4314 	snd_hda_power_up_pm(codec);
4315 	snd_hda_set_pin_ctl_cache(codec, pin, pinval);
4316 	snd_hda_power_down_pm(codec);
4317 }
4318 
4319 /* update mute-LED according to the speaker mute state via mic VREF pin */
4320 static int vref_mute_led_set(struct led_classdev *led_cdev,
4321 			     enum led_brightness brightness)
4322 {
4323 	struct hda_codec *codec = dev_to_hda_codec(led_cdev->dev->parent);
4324 	struct alc_spec *spec = codec->spec;
4325 
4326 	alc_update_vref_led(codec, spec->mute_led_nid,
4327 			    spec->mute_led_polarity, brightness);
4328 	return 0;
4329 }
4330 
4331 /* Make sure the led works even in runtime suspend */
4332 static unsigned int led_power_filter(struct hda_codec *codec,
4333 						  hda_nid_t nid,
4334 						  unsigned int power_state)
4335 {
4336 	struct alc_spec *spec = codec->spec;
4337 
4338 	if (power_state != AC_PWRST_D3 || nid == 0 ||
4339 	    (nid != spec->mute_led_nid && nid != spec->cap_mute_led_nid))
4340 		return power_state;
4341 
4342 	/* Set pin ctl again, it might have just been set to 0 */
4343 	snd_hda_set_pin_ctl(codec, nid,
4344 			    snd_hda_codec_get_pin_target(codec, nid));
4345 
4346 	return snd_hda_gen_path_power_filter(codec, nid, power_state);
4347 }
4348 
4349 static void alc269_fixup_hp_mute_led(struct hda_codec *codec,
4350 				     const struct hda_fixup *fix, int action)
4351 {
4352 	struct alc_spec *spec = codec->spec;
4353 	const struct dmi_device *dev = NULL;
4354 
4355 	if (action != HDA_FIXUP_ACT_PRE_PROBE)
4356 		return;
4357 
4358 	while ((dev = dmi_find_device(DMI_DEV_TYPE_OEM_STRING, NULL, dev))) {
4359 		int pol, pin;
4360 		if (sscanf(dev->name, "HP_Mute_LED_%d_%x", &pol, &pin) != 2)
4361 			continue;
4362 		if (pin < 0x0a || pin >= 0x10)
4363 			break;
4364 		spec->mute_led_polarity = pol;
4365 		spec->mute_led_nid = pin - 0x0a + 0x18;
4366 		snd_hda_gen_add_mute_led_cdev(codec, vref_mute_led_set);
4367 		codec->power_filter = led_power_filter;
4368 		codec_dbg(codec,
4369 			  "Detected mute LED for %x:%d\n", spec->mute_led_nid,
4370 			   spec->mute_led_polarity);
4371 		break;
4372 	}
4373 }
4374 
4375 static void alc269_fixup_hp_mute_led_micx(struct hda_codec *codec,
4376 					  const struct hda_fixup *fix,
4377 					  int action, hda_nid_t pin)
4378 {
4379 	struct alc_spec *spec = codec->spec;
4380 
4381 	if (action == HDA_FIXUP_ACT_PRE_PROBE) {
4382 		spec->mute_led_polarity = 0;
4383 		spec->mute_led_nid = pin;
4384 		snd_hda_gen_add_mute_led_cdev(codec, vref_mute_led_set);
4385 		codec->power_filter = led_power_filter;
4386 	}
4387 }
4388 
4389 static void alc269_fixup_hp_mute_led_mic1(struct hda_codec *codec,
4390 				const struct hda_fixup *fix, int action)
4391 {
4392 	alc269_fixup_hp_mute_led_micx(codec, fix, action, 0x18);
4393 }
4394 
4395 static void alc269_fixup_hp_mute_led_mic2(struct hda_codec *codec,
4396 				const struct hda_fixup *fix, int action)
4397 {
4398 	alc269_fixup_hp_mute_led_micx(codec, fix, action, 0x19);
4399 }
4400 
4401 static void alc269_fixup_hp_mute_led_mic3(struct hda_codec *codec,
4402 				const struct hda_fixup *fix, int action)
4403 {
4404 	alc269_fixup_hp_mute_led_micx(codec, fix, action, 0x1b);
4405 }
4406 
4407 /* update LED status via GPIO */
4408 static void alc_update_gpio_led(struct hda_codec *codec, unsigned int mask,
4409 				int polarity, bool enabled)
4410 {
4411 	if (polarity)
4412 		enabled = !enabled;
4413 	alc_update_gpio_data(codec, mask, !enabled); /* muted -> LED on */
4414 }
4415 
4416 /* turn on/off mute LED via GPIO per vmaster hook */
4417 static int gpio_mute_led_set(struct led_classdev *led_cdev,
4418 			     enum led_brightness brightness)
4419 {
4420 	struct hda_codec *codec = dev_to_hda_codec(led_cdev->dev->parent);
4421 	struct alc_spec *spec = codec->spec;
4422 
4423 	alc_update_gpio_led(codec, spec->gpio_mute_led_mask,
4424 			    spec->mute_led_polarity, !brightness);
4425 	return 0;
4426 }
4427 
4428 /* turn on/off mic-mute LED via GPIO per capture hook */
4429 static int micmute_led_set(struct led_classdev *led_cdev,
4430 			   enum led_brightness brightness)
4431 {
4432 	struct hda_codec *codec = dev_to_hda_codec(led_cdev->dev->parent);
4433 	struct alc_spec *spec = codec->spec;
4434 
4435 	alc_update_gpio_led(codec, spec->gpio_mic_led_mask,
4436 			    spec->micmute_led_polarity, !brightness);
4437 	return 0;
4438 }
4439 
4440 /* setup mute and mic-mute GPIO bits, add hooks appropriately */
4441 static void alc_fixup_hp_gpio_led(struct hda_codec *codec,
4442 				  int action,
4443 				  unsigned int mute_mask,
4444 				  unsigned int micmute_mask)
4445 {
4446 	struct alc_spec *spec = codec->spec;
4447 
4448 	alc_fixup_gpio(codec, action, mute_mask | micmute_mask);
4449 
4450 	if (action != HDA_FIXUP_ACT_PRE_PROBE)
4451 		return;
4452 	if (mute_mask) {
4453 		spec->gpio_mute_led_mask = mute_mask;
4454 		snd_hda_gen_add_mute_led_cdev(codec, gpio_mute_led_set);
4455 	}
4456 	if (micmute_mask) {
4457 		spec->gpio_mic_led_mask = micmute_mask;
4458 		snd_hda_gen_add_micmute_led_cdev(codec, micmute_led_set);
4459 	}
4460 }
4461 
4462 static void alc236_fixup_hp_gpio_led(struct hda_codec *codec,
4463 				const struct hda_fixup *fix, int action)
4464 {
4465 	alc_fixup_hp_gpio_led(codec, action, 0x02, 0x01);
4466 }
4467 
4468 static void alc269_fixup_hp_gpio_led(struct hda_codec *codec,
4469 				const struct hda_fixup *fix, int action)
4470 {
4471 	alc_fixup_hp_gpio_led(codec, action, 0x08, 0x10);
4472 }
4473 
4474 static void alc285_fixup_hp_gpio_led(struct hda_codec *codec,
4475 				const struct hda_fixup *fix, int action)
4476 {
4477 	alc_fixup_hp_gpio_led(codec, action, 0x04, 0x01);
4478 }
4479 
4480 static void alc286_fixup_hp_gpio_led(struct hda_codec *codec,
4481 				const struct hda_fixup *fix, int action)
4482 {
4483 	alc_fixup_hp_gpio_led(codec, action, 0x02, 0x20);
4484 }
4485 
4486 static void alc287_fixup_hp_gpio_led(struct hda_codec *codec,
4487 				const struct hda_fixup *fix, int action)
4488 {
4489 	alc_fixup_hp_gpio_led(codec, action, 0x10, 0);
4490 }
4491 
4492 static void alc245_fixup_hp_gpio_led(struct hda_codec *codec,
4493 				const struct hda_fixup *fix, int action)
4494 {
4495 	struct alc_spec *spec = codec->spec;
4496 
4497 	if (action == HDA_FIXUP_ACT_PRE_PROBE)
4498 		spec->micmute_led_polarity = 1;
4499 	alc_fixup_hp_gpio_led(codec, action, 0, 0x04);
4500 }
4501 
4502 /* turn on/off mic-mute LED per capture hook via VREF change */
4503 static int vref_micmute_led_set(struct led_classdev *led_cdev,
4504 				enum led_brightness brightness)
4505 {
4506 	struct hda_codec *codec = dev_to_hda_codec(led_cdev->dev->parent);
4507 	struct alc_spec *spec = codec->spec;
4508 
4509 	alc_update_vref_led(codec, spec->cap_mute_led_nid,
4510 			    spec->micmute_led_polarity, brightness);
4511 	return 0;
4512 }
4513 
4514 static void alc269_fixup_hp_gpio_mic1_led(struct hda_codec *codec,
4515 				const struct hda_fixup *fix, int action)
4516 {
4517 	struct alc_spec *spec = codec->spec;
4518 
4519 	alc_fixup_hp_gpio_led(codec, action, 0x08, 0);
4520 	if (action == HDA_FIXUP_ACT_PRE_PROBE) {
4521 		/* Like hp_gpio_mic1_led, but also needs GPIO4 low to
4522 		 * enable headphone amp
4523 		 */
4524 		spec->gpio_mask |= 0x10;
4525 		spec->gpio_dir |= 0x10;
4526 		spec->cap_mute_led_nid = 0x18;
4527 		snd_hda_gen_add_micmute_led_cdev(codec, vref_micmute_led_set);
4528 		codec->power_filter = led_power_filter;
4529 	}
4530 }
4531 
4532 static void alc280_fixup_hp_gpio4(struct hda_codec *codec,
4533 				   const struct hda_fixup *fix, int action)
4534 {
4535 	struct alc_spec *spec = codec->spec;
4536 
4537 	alc_fixup_hp_gpio_led(codec, action, 0x08, 0);
4538 	if (action == HDA_FIXUP_ACT_PRE_PROBE) {
4539 		spec->cap_mute_led_nid = 0x18;
4540 		snd_hda_gen_add_micmute_led_cdev(codec, vref_micmute_led_set);
4541 		codec->power_filter = led_power_filter;
4542 	}
4543 }
4544 
4545 /* HP Spectre x360 14 model needs a unique workaround for enabling the amp;
4546  * it needs to toggle the GPIO0 once on and off at each time (bko#210633)
4547  */
4548 static void alc245_fixup_hp_x360_amp(struct hda_codec *codec,
4549 				     const struct hda_fixup *fix, int action)
4550 {
4551 	struct alc_spec *spec = codec->spec;
4552 
4553 	switch (action) {
4554 	case HDA_FIXUP_ACT_PRE_PROBE:
4555 		spec->gpio_mask |= 0x01;
4556 		spec->gpio_dir |= 0x01;
4557 		break;
4558 	case HDA_FIXUP_ACT_INIT:
4559 		/* need to toggle GPIO to enable the amp */
4560 		alc_update_gpio_data(codec, 0x01, true);
4561 		msleep(100);
4562 		alc_update_gpio_data(codec, 0x01, false);
4563 		break;
4564 	}
4565 }
4566 
4567 /* toggle GPIO2 at each time stream is started; we use PREPARE state instead */
4568 static void alc274_hp_envy_pcm_hook(struct hda_pcm_stream *hinfo,
4569 				    struct hda_codec *codec,
4570 				    struct snd_pcm_substream *substream,
4571 				    int action)
4572 {
4573 	switch (action) {
4574 	case HDA_GEN_PCM_ACT_PREPARE:
4575 		alc_update_gpio_data(codec, 0x04, true);
4576 		break;
4577 	case HDA_GEN_PCM_ACT_CLEANUP:
4578 		alc_update_gpio_data(codec, 0x04, false);
4579 		break;
4580 	}
4581 }
4582 
4583 static void alc274_fixup_hp_envy_gpio(struct hda_codec *codec,
4584 				      const struct hda_fixup *fix,
4585 				      int action)
4586 {
4587 	struct alc_spec *spec = codec->spec;
4588 
4589 	if (action == HDA_FIXUP_ACT_PROBE) {
4590 		spec->gpio_mask |= 0x04;
4591 		spec->gpio_dir |= 0x04;
4592 		spec->gen.pcm_playback_hook = alc274_hp_envy_pcm_hook;
4593 	}
4594 }
4595 
4596 static void alc_update_coef_led(struct hda_codec *codec,
4597 				struct alc_coef_led *led,
4598 				bool polarity, bool on)
4599 {
4600 	if (polarity)
4601 		on = !on;
4602 	/* temporarily power up/down for setting COEF bit */
4603 	alc_update_coef_idx(codec, led->idx, led->mask,
4604 			    on ? led->on : led->off);
4605 }
4606 
4607 /* update mute-LED according to the speaker mute state via COEF bit */
4608 static int coef_mute_led_set(struct led_classdev *led_cdev,
4609 			     enum led_brightness brightness)
4610 {
4611 	struct hda_codec *codec = dev_to_hda_codec(led_cdev->dev->parent);
4612 	struct alc_spec *spec = codec->spec;
4613 
4614 	alc_update_coef_led(codec, &spec->mute_led_coef,
4615 			    spec->mute_led_polarity, brightness);
4616 	return 0;
4617 }
4618 
4619 static void alc285_fixup_hp_mute_led_coefbit(struct hda_codec *codec,
4620 					  const struct hda_fixup *fix,
4621 					  int action)
4622 {
4623 	struct alc_spec *spec = codec->spec;
4624 
4625 	if (action == HDA_FIXUP_ACT_PRE_PROBE) {
4626 		spec->mute_led_polarity = 0;
4627 		spec->mute_led_coef.idx = 0x0b;
4628 		spec->mute_led_coef.mask = 1 << 3;
4629 		spec->mute_led_coef.on = 1 << 3;
4630 		spec->mute_led_coef.off = 0;
4631 		snd_hda_gen_add_mute_led_cdev(codec, coef_mute_led_set);
4632 	}
4633 }
4634 
4635 static void alc236_fixup_hp_mute_led_coefbit(struct hda_codec *codec,
4636 					  const struct hda_fixup *fix,
4637 					  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 = 0x34;
4644 		spec->mute_led_coef.mask = 1 << 5;
4645 		spec->mute_led_coef.on = 0;
4646 		spec->mute_led_coef.off = 1 << 5;
4647 		snd_hda_gen_add_mute_led_cdev(codec, coef_mute_led_set);
4648 	}
4649 }
4650 
4651 static void alc236_fixup_hp_mute_led_coefbit2(struct hda_codec *codec,
4652 					  const struct hda_fixup *fix, int action)
4653 {
4654 	struct alc_spec *spec = codec->spec;
4655 
4656 	if (action == HDA_FIXUP_ACT_PRE_PROBE) {
4657 		spec->mute_led_polarity = 0;
4658 		spec->mute_led_coef.idx = 0x07;
4659 		spec->mute_led_coef.mask = 1;
4660 		spec->mute_led_coef.on = 1;
4661 		spec->mute_led_coef.off = 0;
4662 		snd_hda_gen_add_mute_led_cdev(codec, coef_mute_led_set);
4663 	}
4664 }
4665 
4666 static void alc245_fixup_hp_mute_led_coefbit(struct hda_codec *codec,
4667 					  const struct hda_fixup *fix,
4668 					  int action)
4669 {
4670 	struct alc_spec *spec = codec->spec;
4671 
4672 	if (action == HDA_FIXUP_ACT_PRE_PROBE) {
4673 		spec->mute_led_polarity = 0;
4674 		spec->mute_led_coef.idx = 0x0b;
4675 		spec->mute_led_coef.mask = 3 << 2;
4676 		spec->mute_led_coef.on = 2 << 2;
4677 		spec->mute_led_coef.off = 1 << 2;
4678 		snd_hda_gen_add_mute_led_cdev(codec, coef_mute_led_set);
4679 	}
4680 }
4681 
4682 /* turn on/off mic-mute LED per capture hook by coef bit */
4683 static int coef_micmute_led_set(struct led_classdev *led_cdev,
4684 				enum led_brightness brightness)
4685 {
4686 	struct hda_codec *codec = dev_to_hda_codec(led_cdev->dev->parent);
4687 	struct alc_spec *spec = codec->spec;
4688 
4689 	alc_update_coef_led(codec, &spec->mic_led_coef,
4690 			    spec->micmute_led_polarity, brightness);
4691 	return 0;
4692 }
4693 
4694 static void alc285_fixup_hp_coef_micmute_led(struct hda_codec *codec,
4695 				const struct hda_fixup *fix, int action)
4696 {
4697 	struct alc_spec *spec = codec->spec;
4698 
4699 	if (action == HDA_FIXUP_ACT_PRE_PROBE) {
4700 		spec->mic_led_coef.idx = 0x19;
4701 		spec->mic_led_coef.mask = 1 << 13;
4702 		spec->mic_led_coef.on = 1 << 13;
4703 		spec->mic_led_coef.off = 0;
4704 		snd_hda_gen_add_micmute_led_cdev(codec, coef_micmute_led_set);
4705 	}
4706 }
4707 
4708 static void alc285_fixup_hp_gpio_micmute_led(struct hda_codec *codec,
4709 				const struct hda_fixup *fix, int action)
4710 {
4711 	struct alc_spec *spec = codec->spec;
4712 
4713 	if (action == HDA_FIXUP_ACT_PRE_PROBE)
4714 		spec->micmute_led_polarity = 1;
4715 	alc_fixup_hp_gpio_led(codec, action, 0, 0x04);
4716 }
4717 
4718 static void alc236_fixup_hp_coef_micmute_led(struct hda_codec *codec,
4719 				const struct hda_fixup *fix, int action)
4720 {
4721 	struct alc_spec *spec = codec->spec;
4722 
4723 	if (action == HDA_FIXUP_ACT_PRE_PROBE) {
4724 		spec->mic_led_coef.idx = 0x35;
4725 		spec->mic_led_coef.mask = 3 << 2;
4726 		spec->mic_led_coef.on = 2 << 2;
4727 		spec->mic_led_coef.off = 1 << 2;
4728 		snd_hda_gen_add_micmute_led_cdev(codec, coef_micmute_led_set);
4729 	}
4730 }
4731 
4732 static void alc285_fixup_hp_mute_led(struct hda_codec *codec,
4733 				const struct hda_fixup *fix, int action)
4734 {
4735 	alc285_fixup_hp_mute_led_coefbit(codec, fix, action);
4736 	alc285_fixup_hp_coef_micmute_led(codec, fix, action);
4737 }
4738 
4739 static void alc285_fixup_hp_spectre_x360_mute_led(struct hda_codec *codec,
4740 				const struct hda_fixup *fix, int action)
4741 {
4742 	alc285_fixup_hp_mute_led_coefbit(codec, fix, action);
4743 	alc285_fixup_hp_gpio_micmute_led(codec, fix, action);
4744 }
4745 
4746 static void alc236_fixup_hp_mute_led(struct hda_codec *codec,
4747 				const struct hda_fixup *fix, int action)
4748 {
4749 	alc236_fixup_hp_mute_led_coefbit(codec, fix, action);
4750 	alc236_fixup_hp_coef_micmute_led(codec, fix, action);
4751 }
4752 
4753 static void alc236_fixup_hp_micmute_led_vref(struct hda_codec *codec,
4754 				const struct hda_fixup *fix, int action)
4755 {
4756 	struct alc_spec *spec = codec->spec;
4757 
4758 	if (action == HDA_FIXUP_ACT_PRE_PROBE) {
4759 		spec->cap_mute_led_nid = 0x1a;
4760 		snd_hda_gen_add_micmute_led_cdev(codec, vref_micmute_led_set);
4761 		codec->power_filter = led_power_filter;
4762 	}
4763 }
4764 
4765 static void alc236_fixup_hp_mute_led_micmute_vref(struct hda_codec *codec,
4766 				const struct hda_fixup *fix, int action)
4767 {
4768 	alc236_fixup_hp_mute_led_coefbit(codec, fix, action);
4769 	alc236_fixup_hp_micmute_led_vref(codec, fix, action);
4770 }
4771 
4772 static inline void alc298_samsung_write_coef_pack(struct hda_codec *codec,
4773 						  const unsigned short coefs[2])
4774 {
4775 	alc_write_coef_idx(codec, 0x23, coefs[0]);
4776 	alc_write_coef_idx(codec, 0x25, coefs[1]);
4777 	alc_write_coef_idx(codec, 0x26, 0xb011);
4778 }
4779 
4780 struct alc298_samsung_amp_desc {
4781 	unsigned char nid;
4782 	unsigned short init_seq[2][2];
4783 };
4784 
4785 static void alc298_fixup_samsung_amp(struct hda_codec *codec,
4786 				     const struct hda_fixup *fix, int action)
4787 {
4788 	int i, j;
4789 	static const unsigned short init_seq[][2] = {
4790 		{ 0x19, 0x00 }, { 0x20, 0xc0 }, { 0x22, 0x44 }, { 0x23, 0x08 },
4791 		{ 0x24, 0x85 }, { 0x25, 0x41 }, { 0x35, 0x40 }, { 0x36, 0x01 },
4792 		{ 0x38, 0x81 }, { 0x3a, 0x03 }, { 0x3b, 0x81 }, { 0x40, 0x3e },
4793 		{ 0x41, 0x07 }, { 0x400, 0x1 }
4794 	};
4795 	static const struct alc298_samsung_amp_desc amps[] = {
4796 		{ 0x3a, { { 0x18, 0x1 }, { 0x26, 0x0 } } },
4797 		{ 0x39, { { 0x18, 0x2 }, { 0x26, 0x1 } } }
4798 	};
4799 
4800 	if (action != HDA_FIXUP_ACT_INIT)
4801 		return;
4802 
4803 	for (i = 0; i < ARRAY_SIZE(amps); i++) {
4804 		alc_write_coef_idx(codec, 0x22, amps[i].nid);
4805 
4806 		for (j = 0; j < ARRAY_SIZE(amps[i].init_seq); j++)
4807 			alc298_samsung_write_coef_pack(codec, amps[i].init_seq[j]);
4808 
4809 		for (j = 0; j < ARRAY_SIZE(init_seq); j++)
4810 			alc298_samsung_write_coef_pack(codec, init_seq[j]);
4811 	}
4812 }
4813 
4814 struct alc298_samsung_v2_amp_desc {
4815 	unsigned short nid;
4816 	int init_seq_size;
4817 	unsigned short init_seq[18][2];
4818 };
4819 
4820 static const struct alc298_samsung_v2_amp_desc
4821 alc298_samsung_v2_amp_desc_tbl[] = {
4822 	{ 0x38, 18, {
4823 		{ 0x23e1, 0x0000 }, { 0x2012, 0x006f }, { 0x2014, 0x0000 },
4824 		{ 0x201b, 0x0001 }, { 0x201d, 0x0001 }, { 0x201f, 0x00fe },
4825 		{ 0x2021, 0x0000 }, { 0x2022, 0x0010 }, { 0x203d, 0x0005 },
4826 		{ 0x203f, 0x0003 }, { 0x2050, 0x002c }, { 0x2076, 0x000e },
4827 		{ 0x207c, 0x004a }, { 0x2081, 0x0003 }, { 0x2399, 0x0003 },
4828 		{ 0x23a4, 0x00b5 }, { 0x23a5, 0x0001 }, { 0x23ba, 0x0094 }
4829 	}},
4830 	{ 0x39, 18, {
4831 		{ 0x23e1, 0x0000 }, { 0x2012, 0x006f }, { 0x2014, 0x0000 },
4832 		{ 0x201b, 0x0002 }, { 0x201d, 0x0002 }, { 0x201f, 0x00fd },
4833 		{ 0x2021, 0x0001 }, { 0x2022, 0x0010 }, { 0x203d, 0x0005 },
4834 		{ 0x203f, 0x0003 }, { 0x2050, 0x002c }, { 0x2076, 0x000e },
4835 		{ 0x207c, 0x004a }, { 0x2081, 0x0003 }, { 0x2399, 0x0003 },
4836 		{ 0x23a4, 0x00b5 }, { 0x23a5, 0x0001 }, { 0x23ba, 0x0094 }
4837 	}},
4838 	{ 0x3c, 15, {
4839 		{ 0x23e1, 0x0000 }, { 0x2012, 0x006f }, { 0x2014, 0x0000 },
4840 		{ 0x201b, 0x0001 }, { 0x201d, 0x0001 }, { 0x201f, 0x00fe },
4841 		{ 0x2021, 0x0000 }, { 0x2022, 0x0010 }, { 0x203d, 0x0005 },
4842 		{ 0x203f, 0x0003 }, { 0x2050, 0x002c }, { 0x2076, 0x000e },
4843 		{ 0x207c, 0x004a }, { 0x2081, 0x0003 }, { 0x23ba, 0x008d }
4844 	}},
4845 	{ 0x3d, 15, {
4846 		{ 0x23e1, 0x0000 }, { 0x2012, 0x006f }, { 0x2014, 0x0000 },
4847 		{ 0x201b, 0x0002 }, { 0x201d, 0x0002 }, { 0x201f, 0x00fd },
4848 		{ 0x2021, 0x0001 }, { 0x2022, 0x0010 }, { 0x203d, 0x0005 },
4849 		{ 0x203f, 0x0003 }, { 0x2050, 0x002c }, { 0x2076, 0x000e },
4850 		{ 0x207c, 0x004a }, { 0x2081, 0x0003 }, { 0x23ba, 0x008d }
4851 	}}
4852 };
4853 
4854 static void alc298_samsung_v2_enable_amps(struct hda_codec *codec)
4855 {
4856 	struct alc_spec *spec = codec->spec;
4857 	static const unsigned short enable_seq[][2] = {
4858 		{ 0x203a, 0x0081 }, { 0x23ff, 0x0001 },
4859 	};
4860 	int i, j;
4861 
4862 	for (i = 0; i < spec->num_speaker_amps; i++) {
4863 		alc_write_coef_idx(codec, 0x22, alc298_samsung_v2_amp_desc_tbl[i].nid);
4864 		for (j = 0; j < ARRAY_SIZE(enable_seq); j++)
4865 			alc298_samsung_write_coef_pack(codec, enable_seq[j]);
4866 		codec_dbg(codec, "alc298_samsung_v2: Enabled speaker amp 0x%02x\n",
4867 				alc298_samsung_v2_amp_desc_tbl[i].nid);
4868 	}
4869 }
4870 
4871 static void alc298_samsung_v2_disable_amps(struct hda_codec *codec)
4872 {
4873 	struct alc_spec *spec = codec->spec;
4874 	static const unsigned short disable_seq[][2] = {
4875 		{ 0x23ff, 0x0000 }, { 0x203a, 0x0080 },
4876 	};
4877 	int i, j;
4878 
4879 	for (i = 0; i < spec->num_speaker_amps; i++) {
4880 		alc_write_coef_idx(codec, 0x22, alc298_samsung_v2_amp_desc_tbl[i].nid);
4881 		for (j = 0; j < ARRAY_SIZE(disable_seq); j++)
4882 			alc298_samsung_write_coef_pack(codec, disable_seq[j]);
4883 		codec_dbg(codec, "alc298_samsung_v2: Disabled speaker amp 0x%02x\n",
4884 				alc298_samsung_v2_amp_desc_tbl[i].nid);
4885 	}
4886 }
4887 
4888 static void alc298_samsung_v2_playback_hook(struct hda_pcm_stream *hinfo,
4889 				struct hda_codec *codec,
4890 				struct snd_pcm_substream *substream,
4891 				int action)
4892 {
4893 	/* Dynamically enable/disable speaker amps before and after playback */
4894 	if (action == HDA_GEN_PCM_ACT_OPEN)
4895 		alc298_samsung_v2_enable_amps(codec);
4896 	if (action == HDA_GEN_PCM_ACT_CLOSE)
4897 		alc298_samsung_v2_disable_amps(codec);
4898 }
4899 
4900 static void alc298_samsung_v2_init_amps(struct hda_codec *codec,
4901 				int num_speaker_amps)
4902 {
4903 	struct alc_spec *spec = codec->spec;
4904 	int i, j;
4905 
4906 	/* Set spec's num_speaker_amps before doing anything else */
4907 	spec->num_speaker_amps = num_speaker_amps;
4908 
4909 	/* Disable speaker amps before init to prevent any physical damage */
4910 	alc298_samsung_v2_disable_amps(codec);
4911 
4912 	/* Initialize the speaker amps */
4913 	for (i = 0; i < spec->num_speaker_amps; i++) {
4914 		alc_write_coef_idx(codec, 0x22, alc298_samsung_v2_amp_desc_tbl[i].nid);
4915 		for (j = 0; j < alc298_samsung_v2_amp_desc_tbl[i].init_seq_size; j++) {
4916 			alc298_samsung_write_coef_pack(codec,
4917 					alc298_samsung_v2_amp_desc_tbl[i].init_seq[j]);
4918 		}
4919 		alc_write_coef_idx(codec, 0x89, 0x0);
4920 		codec_dbg(codec, "alc298_samsung_v2: Initialized speaker amp 0x%02x\n",
4921 				alc298_samsung_v2_amp_desc_tbl[i].nid);
4922 	}
4923 
4924 	/* register hook to enable speaker amps only when they are needed */
4925 	spec->gen.pcm_playback_hook = alc298_samsung_v2_playback_hook;
4926 }
4927 
4928 static void alc298_fixup_samsung_amp_v2_2_amps(struct hda_codec *codec,
4929 				const struct hda_fixup *fix, int action)
4930 {
4931 	if (action == HDA_FIXUP_ACT_PROBE)
4932 		alc298_samsung_v2_init_amps(codec, 2);
4933 }
4934 
4935 static void alc298_fixup_samsung_amp_v2_4_amps(struct hda_codec *codec,
4936 				const struct hda_fixup *fix, int action)
4937 {
4938 	if (action == HDA_FIXUP_ACT_PROBE)
4939 		alc298_samsung_v2_init_amps(codec, 4);
4940 }
4941 
4942 #if IS_REACHABLE(CONFIG_INPUT)
4943 static void gpio2_mic_hotkey_event(struct hda_codec *codec,
4944 				   struct hda_jack_callback *event)
4945 {
4946 	struct alc_spec *spec = codec->spec;
4947 
4948 	/* GPIO2 just toggles on a keypress/keyrelease cycle. Therefore
4949 	   send both key on and key off event for every interrupt. */
4950 	input_report_key(spec->kb_dev, spec->alc_mute_keycode_map[ALC_KEY_MICMUTE_INDEX], 1);
4951 	input_sync(spec->kb_dev);
4952 	input_report_key(spec->kb_dev, spec->alc_mute_keycode_map[ALC_KEY_MICMUTE_INDEX], 0);
4953 	input_sync(spec->kb_dev);
4954 }
4955 
4956 static int alc_register_micmute_input_device(struct hda_codec *codec)
4957 {
4958 	struct alc_spec *spec = codec->spec;
4959 	int i;
4960 
4961 	spec->kb_dev = input_allocate_device();
4962 	if (!spec->kb_dev) {
4963 		codec_err(codec, "Out of memory (input_allocate_device)\n");
4964 		return -ENOMEM;
4965 	}
4966 
4967 	spec->alc_mute_keycode_map[ALC_KEY_MICMUTE_INDEX] = KEY_MICMUTE;
4968 
4969 	spec->kb_dev->name = "Microphone Mute Button";
4970 	spec->kb_dev->evbit[0] = BIT_MASK(EV_KEY);
4971 	spec->kb_dev->keycodesize = sizeof(spec->alc_mute_keycode_map[0]);
4972 	spec->kb_dev->keycodemax = ARRAY_SIZE(spec->alc_mute_keycode_map);
4973 	spec->kb_dev->keycode = spec->alc_mute_keycode_map;
4974 	for (i = 0; i < ARRAY_SIZE(spec->alc_mute_keycode_map); i++)
4975 		set_bit(spec->alc_mute_keycode_map[i], spec->kb_dev->keybit);
4976 
4977 	if (input_register_device(spec->kb_dev)) {
4978 		codec_err(codec, "input_register_device failed\n");
4979 		input_free_device(spec->kb_dev);
4980 		spec->kb_dev = NULL;
4981 		return -ENOMEM;
4982 	}
4983 
4984 	return 0;
4985 }
4986 
4987 /* GPIO1 = set according to SKU external amp
4988  * GPIO2 = mic mute hotkey
4989  * GPIO3 = mute LED
4990  * GPIO4 = mic mute LED
4991  */
4992 static void alc280_fixup_hp_gpio2_mic_hotkey(struct hda_codec *codec,
4993 					     const struct hda_fixup *fix, int action)
4994 {
4995 	struct alc_spec *spec = codec->spec;
4996 
4997 	alc_fixup_hp_gpio_led(codec, action, 0x08, 0x10);
4998 	if (action == HDA_FIXUP_ACT_PRE_PROBE) {
4999 		spec->init_amp = ALC_INIT_DEFAULT;
5000 		if (alc_register_micmute_input_device(codec) != 0)
5001 			return;
5002 
5003 		spec->gpio_mask |= 0x06;
5004 		spec->gpio_dir |= 0x02;
5005 		spec->gpio_data |= 0x02;
5006 		snd_hda_codec_write_cache(codec, codec->core.afg, 0,
5007 					  AC_VERB_SET_GPIO_UNSOLICITED_RSP_MASK, 0x04);
5008 		snd_hda_jack_detect_enable_callback(codec, codec->core.afg,
5009 						    gpio2_mic_hotkey_event);
5010 		return;
5011 	}
5012 
5013 	if (!spec->kb_dev)
5014 		return;
5015 
5016 	switch (action) {
5017 	case HDA_FIXUP_ACT_FREE:
5018 		input_unregister_device(spec->kb_dev);
5019 		spec->kb_dev = NULL;
5020 	}
5021 }
5022 
5023 /* Line2 = mic mute hotkey
5024  * GPIO2 = mic mute LED
5025  */
5026 static void alc233_fixup_lenovo_line2_mic_hotkey(struct hda_codec *codec,
5027 					     const struct hda_fixup *fix, int action)
5028 {
5029 	struct alc_spec *spec = codec->spec;
5030 
5031 	alc_fixup_hp_gpio_led(codec, action, 0, 0x04);
5032 	if (action == HDA_FIXUP_ACT_PRE_PROBE) {
5033 		spec->init_amp = ALC_INIT_DEFAULT;
5034 		if (alc_register_micmute_input_device(codec) != 0)
5035 			return;
5036 
5037 		snd_hda_jack_detect_enable_callback(codec, 0x1b,
5038 						    gpio2_mic_hotkey_event);
5039 		return;
5040 	}
5041 
5042 	if (!spec->kb_dev)
5043 		return;
5044 
5045 	switch (action) {
5046 	case HDA_FIXUP_ACT_FREE:
5047 		input_unregister_device(spec->kb_dev);
5048 		spec->kb_dev = NULL;
5049 	}
5050 }
5051 #else /* INPUT */
5052 #define alc280_fixup_hp_gpio2_mic_hotkey	NULL
5053 #define alc233_fixup_lenovo_line2_mic_hotkey	NULL
5054 #endif /* INPUT */
5055 
5056 static void alc269_fixup_hp_line1_mic1_led(struct hda_codec *codec,
5057 				const struct hda_fixup *fix, int action)
5058 {
5059 	struct alc_spec *spec = codec->spec;
5060 
5061 	alc269_fixup_hp_mute_led_micx(codec, fix, action, 0x1a);
5062 	if (action == HDA_FIXUP_ACT_PRE_PROBE) {
5063 		spec->cap_mute_led_nid = 0x18;
5064 		snd_hda_gen_add_micmute_led_cdev(codec, vref_micmute_led_set);
5065 	}
5066 }
5067 
5068 static void alc_hp_mute_disable(struct hda_codec *codec, unsigned int delay)
5069 {
5070 	if (delay <= 0)
5071 		delay = 75;
5072 	snd_hda_codec_write(codec, 0x21, 0,
5073 		    AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);
5074 	msleep(delay);
5075 	snd_hda_codec_write(codec, 0x21, 0,
5076 		    AC_VERB_SET_PIN_WIDGET_CONTROL, 0x0);
5077 	msleep(delay);
5078 }
5079 
5080 static void alc_hp_enable_unmute(struct hda_codec *codec, unsigned int delay)
5081 {
5082 	if (delay <= 0)
5083 		delay = 75;
5084 	snd_hda_codec_write(codec, 0x21, 0,
5085 		    AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT);
5086 	msleep(delay);
5087 	snd_hda_codec_write(codec, 0x21, 0,
5088 		    AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE);
5089 	msleep(delay);
5090 }
5091 
5092 static const struct coef_fw alc225_pre_hsmode[] = {
5093 	UPDATE_COEF(0x4a, 1<<8, 0),
5094 	UPDATE_COEFEX(0x57, 0x05, 1<<14, 0),
5095 	UPDATE_COEF(0x63, 3<<14, 3<<14),
5096 	UPDATE_COEF(0x4a, 3<<4, 2<<4),
5097 	UPDATE_COEF(0x4a, 3<<10, 3<<10),
5098 	UPDATE_COEF(0x45, 0x3f<<10, 0x34<<10),
5099 	UPDATE_COEF(0x4a, 3<<10, 0),
5100 	{}
5101 };
5102 
5103 static void alc_headset_mode_unplugged(struct hda_codec *codec)
5104 {
5105 	struct alc_spec *spec = codec->spec;
5106 	static const struct coef_fw coef0255[] = {
5107 		WRITE_COEF(0x1b, 0x0c0b), /* LDO and MISC control */
5108 		WRITE_COEF(0x45, 0xd089), /* UAJ function set to menual mode */
5109 		UPDATE_COEFEX(0x57, 0x05, 1<<14, 0), /* Direct Drive HP Amp control(Set to verb control)*/
5110 		WRITE_COEF(0x06, 0x6104), /* Set MIC2 Vref gate with HP */
5111 		WRITE_COEFEX(0x57, 0x03, 0x8aa6), /* Direct Drive HP Amp control */
5112 		{}
5113 	};
5114 	static const struct coef_fw coef0256[] = {
5115 		WRITE_COEF(0x1b, 0x0c4b), /* LDO and MISC control */
5116 		WRITE_COEF(0x45, 0xd089), /* UAJ function set to menual mode */
5117 		WRITE_COEF(0x06, 0x6104), /* Set MIC2 Vref gate with HP */
5118 		WRITE_COEFEX(0x57, 0x03, 0x09a3), /* Direct Drive HP Amp control */
5119 		UPDATE_COEFEX(0x57, 0x05, 1<<14, 0), /* Direct Drive HP Amp control(Set to verb control)*/
5120 		{}
5121 	};
5122 	static const struct coef_fw coef0233[] = {
5123 		WRITE_COEF(0x1b, 0x0c0b),
5124 		WRITE_COEF(0x45, 0xc429),
5125 		UPDATE_COEF(0x35, 0x4000, 0),
5126 		WRITE_COEF(0x06, 0x2104),
5127 		WRITE_COEF(0x1a, 0x0001),
5128 		WRITE_COEF(0x26, 0x0004),
5129 		WRITE_COEF(0x32, 0x42a3),
5130 		{}
5131 	};
5132 	static const struct coef_fw coef0288[] = {
5133 		UPDATE_COEF(0x4f, 0xfcc0, 0xc400),
5134 		UPDATE_COEF(0x50, 0x2000, 0x2000),
5135 		UPDATE_COEF(0x56, 0x0006, 0x0006),
5136 		UPDATE_COEF(0x66, 0x0008, 0),
5137 		UPDATE_COEF(0x67, 0x2000, 0),
5138 		{}
5139 	};
5140 	static const struct coef_fw coef0298[] = {
5141 		UPDATE_COEF(0x19, 0x1300, 0x0300),
5142 		{}
5143 	};
5144 	static const struct coef_fw coef0292[] = {
5145 		WRITE_COEF(0x76, 0x000e),
5146 		WRITE_COEF(0x6c, 0x2400),
5147 		WRITE_COEF(0x18, 0x7308),
5148 		WRITE_COEF(0x6b, 0xc429),
5149 		{}
5150 	};
5151 	static const struct coef_fw coef0293[] = {
5152 		UPDATE_COEF(0x10, 7<<8, 6<<8), /* SET Line1 JD to 0 */
5153 		UPDATE_COEFEX(0x57, 0x05, 1<<15|1<<13, 0x0), /* SET charge pump by verb */
5154 		UPDATE_COEFEX(0x57, 0x03, 1<<10, 1<<10), /* SET EN_OSW to 1 */
5155 		UPDATE_COEF(0x1a, 1<<3, 1<<3), /* Combo JD gating with LINE1-VREFO */
5156 		WRITE_COEF(0x45, 0xc429), /* Set to TRS type */
5157 		UPDATE_COEF(0x4a, 0x000f, 0x000e), /* Combo Jack auto detect */
5158 		{}
5159 	};
5160 	static const struct coef_fw coef0668[] = {
5161 		WRITE_COEF(0x15, 0x0d40),
5162 		WRITE_COEF(0xb7, 0x802b),
5163 		{}
5164 	};
5165 	static const struct coef_fw coef0225[] = {
5166 		UPDATE_COEF(0x63, 3<<14, 0),
5167 		{}
5168 	};
5169 	static const struct coef_fw coef0274[] = {
5170 		UPDATE_COEF(0x4a, 0x0100, 0),
5171 		UPDATE_COEFEX(0x57, 0x05, 0x4000, 0),
5172 		UPDATE_COEF(0x6b, 0xf000, 0x5000),
5173 		UPDATE_COEF(0x4a, 0x0010, 0),
5174 		UPDATE_COEF(0x4a, 0x0c00, 0x0c00),
5175 		WRITE_COEF(0x45, 0x5289),
5176 		UPDATE_COEF(0x4a, 0x0c00, 0),
5177 		{}
5178 	};
5179 
5180 	if (spec->no_internal_mic_pin) {
5181 		alc_update_coef_idx(codec, 0x45, 0xf<<12 | 1<<10, 5<<12);
5182 		return;
5183 	}
5184 
5185 	switch (codec->core.vendor_id) {
5186 	case 0x10ec0255:
5187 		alc_process_coef_fw(codec, coef0255);
5188 		break;
5189 	case 0x10ec0230:
5190 	case 0x10ec0236:
5191 	case 0x10ec0256:
5192 	case 0x19e58326:
5193 		alc_hp_mute_disable(codec, 75);
5194 		alc_process_coef_fw(codec, coef0256);
5195 		break;
5196 	case 0x10ec0234:
5197 	case 0x10ec0274:
5198 	case 0x10ec0294:
5199 		alc_process_coef_fw(codec, coef0274);
5200 		break;
5201 	case 0x10ec0233:
5202 	case 0x10ec0283:
5203 		alc_process_coef_fw(codec, coef0233);
5204 		break;
5205 	case 0x10ec0286:
5206 	case 0x10ec0288:
5207 		alc_process_coef_fw(codec, coef0288);
5208 		break;
5209 	case 0x10ec0298:
5210 		alc_process_coef_fw(codec, coef0298);
5211 		alc_process_coef_fw(codec, coef0288);
5212 		break;
5213 	case 0x10ec0292:
5214 		alc_process_coef_fw(codec, coef0292);
5215 		break;
5216 	case 0x10ec0293:
5217 		alc_process_coef_fw(codec, coef0293);
5218 		break;
5219 	case 0x10ec0668:
5220 		alc_process_coef_fw(codec, coef0668);
5221 		break;
5222 	case 0x10ec0215:
5223 	case 0x10ec0225:
5224 	case 0x10ec0285:
5225 	case 0x10ec0295:
5226 	case 0x10ec0289:
5227 	case 0x10ec0299:
5228 		alc_hp_mute_disable(codec, 75);
5229 		alc_process_coef_fw(codec, alc225_pre_hsmode);
5230 		alc_process_coef_fw(codec, coef0225);
5231 		break;
5232 	case 0x10ec0867:
5233 		alc_update_coefex_idx(codec, 0x57, 0x5, 1<<14, 0);
5234 		break;
5235 	}
5236 	codec_dbg(codec, "Headset jack set to unplugged mode.\n");
5237 }
5238 
5239 
5240 static void alc_headset_mode_mic_in(struct hda_codec *codec, hda_nid_t hp_pin,
5241 				    hda_nid_t mic_pin)
5242 {
5243 	static const struct coef_fw coef0255[] = {
5244 		WRITE_COEFEX(0x57, 0x03, 0x8aa6),
5245 		WRITE_COEF(0x06, 0x6100), /* Set MIC2 Vref gate to normal */
5246 		{}
5247 	};
5248 	static const struct coef_fw coef0256[] = {
5249 		UPDATE_COEFEX(0x57, 0x05, 1<<14, 1<<14), /* Direct Drive HP Amp control(Set to verb control)*/
5250 		WRITE_COEFEX(0x57, 0x03, 0x09a3),
5251 		WRITE_COEF(0x06, 0x6100), /* Set MIC2 Vref gate to normal */
5252 		{}
5253 	};
5254 	static const struct coef_fw coef0233[] = {
5255 		UPDATE_COEF(0x35, 0, 1<<14),
5256 		WRITE_COEF(0x06, 0x2100),
5257 		WRITE_COEF(0x1a, 0x0021),
5258 		WRITE_COEF(0x26, 0x008c),
5259 		{}
5260 	};
5261 	static const struct coef_fw coef0288[] = {
5262 		UPDATE_COEF(0x4f, 0x00c0, 0),
5263 		UPDATE_COEF(0x50, 0x2000, 0),
5264 		UPDATE_COEF(0x56, 0x0006, 0),
5265 		UPDATE_COEF(0x4f, 0xfcc0, 0xc400),
5266 		UPDATE_COEF(0x66, 0x0008, 0x0008),
5267 		UPDATE_COEF(0x67, 0x2000, 0x2000),
5268 		{}
5269 	};
5270 	static const struct coef_fw coef0292[] = {
5271 		WRITE_COEF(0x19, 0xa208),
5272 		WRITE_COEF(0x2e, 0xacf0),
5273 		{}
5274 	};
5275 	static const struct coef_fw coef0293[] = {
5276 		UPDATE_COEFEX(0x57, 0x05, 0, 1<<15|1<<13), /* SET charge pump by verb */
5277 		UPDATE_COEFEX(0x57, 0x03, 1<<10, 0), /* SET EN_OSW to 0 */
5278 		UPDATE_COEF(0x1a, 1<<3, 0), /* Combo JD gating without LINE1-VREFO */
5279 		{}
5280 	};
5281 	static const struct coef_fw coef0688[] = {
5282 		WRITE_COEF(0xb7, 0x802b),
5283 		WRITE_COEF(0xb5, 0x1040),
5284 		UPDATE_COEF(0xc3, 0, 1<<12),
5285 		{}
5286 	};
5287 	static const struct coef_fw coef0225[] = {
5288 		UPDATE_COEFEX(0x57, 0x05, 1<<14, 1<<14),
5289 		UPDATE_COEF(0x4a, 3<<4, 2<<4),
5290 		UPDATE_COEF(0x63, 3<<14, 0),
5291 		{}
5292 	};
5293 	static const struct coef_fw coef0274[] = {
5294 		UPDATE_COEFEX(0x57, 0x05, 0x4000, 0x4000),
5295 		UPDATE_COEF(0x4a, 0x0010, 0),
5296 		UPDATE_COEF(0x6b, 0xf000, 0),
5297 		{}
5298 	};
5299 
5300 	switch (codec->core.vendor_id) {
5301 	case 0x10ec0255:
5302 		alc_write_coef_idx(codec, 0x45, 0xc489);
5303 		snd_hda_set_pin_ctl_cache(codec, hp_pin, 0);
5304 		alc_process_coef_fw(codec, coef0255);
5305 		snd_hda_set_pin_ctl_cache(codec, mic_pin, PIN_VREF50);
5306 		break;
5307 	case 0x10ec0230:
5308 	case 0x10ec0236:
5309 	case 0x10ec0256:
5310 	case 0x19e58326:
5311 		alc_write_coef_idx(codec, 0x45, 0xc489);
5312 		snd_hda_set_pin_ctl_cache(codec, hp_pin, 0);
5313 		alc_process_coef_fw(codec, coef0256);
5314 		snd_hda_set_pin_ctl_cache(codec, mic_pin, PIN_VREF50);
5315 		break;
5316 	case 0x10ec0234:
5317 	case 0x10ec0274:
5318 	case 0x10ec0294:
5319 		alc_write_coef_idx(codec, 0x45, 0x4689);
5320 		snd_hda_set_pin_ctl_cache(codec, hp_pin, 0);
5321 		alc_process_coef_fw(codec, coef0274);
5322 		snd_hda_set_pin_ctl_cache(codec, mic_pin, PIN_VREF50);
5323 		break;
5324 	case 0x10ec0233:
5325 	case 0x10ec0283:
5326 		alc_write_coef_idx(codec, 0x45, 0xc429);
5327 		snd_hda_set_pin_ctl_cache(codec, hp_pin, 0);
5328 		alc_process_coef_fw(codec, coef0233);
5329 		snd_hda_set_pin_ctl_cache(codec, mic_pin, PIN_VREF50);
5330 		break;
5331 	case 0x10ec0286:
5332 	case 0x10ec0288:
5333 	case 0x10ec0298:
5334 		snd_hda_set_pin_ctl_cache(codec, hp_pin, 0);
5335 		alc_process_coef_fw(codec, coef0288);
5336 		snd_hda_set_pin_ctl_cache(codec, mic_pin, PIN_VREF50);
5337 		break;
5338 	case 0x10ec0292:
5339 		snd_hda_set_pin_ctl_cache(codec, hp_pin, 0);
5340 		alc_process_coef_fw(codec, coef0292);
5341 		break;
5342 	case 0x10ec0293:
5343 		/* Set to TRS mode */
5344 		alc_write_coef_idx(codec, 0x45, 0xc429);
5345 		snd_hda_set_pin_ctl_cache(codec, hp_pin, 0);
5346 		alc_process_coef_fw(codec, coef0293);
5347 		snd_hda_set_pin_ctl_cache(codec, mic_pin, PIN_VREF50);
5348 		break;
5349 	case 0x10ec0867:
5350 		alc_update_coefex_idx(codec, 0x57, 0x5, 0, 1<<14);
5351 		fallthrough;
5352 	case 0x10ec0221:
5353 	case 0x10ec0662:
5354 		snd_hda_set_pin_ctl_cache(codec, hp_pin, 0);
5355 		snd_hda_set_pin_ctl_cache(codec, mic_pin, PIN_VREF50);
5356 		break;
5357 	case 0x10ec0668:
5358 		alc_write_coef_idx(codec, 0x11, 0x0001);
5359 		snd_hda_set_pin_ctl_cache(codec, hp_pin, 0);
5360 		alc_process_coef_fw(codec, coef0688);
5361 		snd_hda_set_pin_ctl_cache(codec, mic_pin, PIN_VREF50);
5362 		break;
5363 	case 0x10ec0215:
5364 	case 0x10ec0225:
5365 	case 0x10ec0285:
5366 	case 0x10ec0295:
5367 	case 0x10ec0289:
5368 	case 0x10ec0299:
5369 		alc_process_coef_fw(codec, alc225_pre_hsmode);
5370 		alc_update_coef_idx(codec, 0x45, 0x3f<<10, 0x31<<10);
5371 		snd_hda_set_pin_ctl_cache(codec, hp_pin, 0);
5372 		alc_process_coef_fw(codec, coef0225);
5373 		snd_hda_set_pin_ctl_cache(codec, mic_pin, PIN_VREF50);
5374 		break;
5375 	}
5376 	codec_dbg(codec, "Headset jack set to mic-in mode.\n");
5377 }
5378 
5379 static void alc_headset_mode_default(struct hda_codec *codec)
5380 {
5381 	static const struct coef_fw coef0225[] = {
5382 		UPDATE_COEF(0x45, 0x3f<<10, 0x30<<10),
5383 		UPDATE_COEF(0x45, 0x3f<<10, 0x31<<10),
5384 		UPDATE_COEF(0x49, 3<<8, 0<<8),
5385 		UPDATE_COEF(0x4a, 3<<4, 3<<4),
5386 		UPDATE_COEF(0x63, 3<<14, 0),
5387 		UPDATE_COEF(0x67, 0xf000, 0x3000),
5388 		{}
5389 	};
5390 	static const struct coef_fw coef0255[] = {
5391 		WRITE_COEF(0x45, 0xc089),
5392 		WRITE_COEF(0x45, 0xc489),
5393 		WRITE_COEFEX(0x57, 0x03, 0x8ea6),
5394 		WRITE_COEF(0x49, 0x0049),
5395 		{}
5396 	};
5397 	static const struct coef_fw coef0256[] = {
5398 		WRITE_COEF(0x45, 0xc489),
5399 		WRITE_COEFEX(0x57, 0x03, 0x0da3),
5400 		WRITE_COEF(0x49, 0x0049),
5401 		UPDATE_COEFEX(0x57, 0x05, 1<<14, 0), /* Direct Drive HP Amp control(Set to verb control)*/
5402 		WRITE_COEF(0x06, 0x6100),
5403 		{}
5404 	};
5405 	static const struct coef_fw coef0233[] = {
5406 		WRITE_COEF(0x06, 0x2100),
5407 		WRITE_COEF(0x32, 0x4ea3),
5408 		{}
5409 	};
5410 	static const struct coef_fw coef0288[] = {
5411 		UPDATE_COEF(0x4f, 0xfcc0, 0xc400), /* Set to TRS type */
5412 		UPDATE_COEF(0x50, 0x2000, 0x2000),
5413 		UPDATE_COEF(0x56, 0x0006, 0x0006),
5414 		UPDATE_COEF(0x66, 0x0008, 0),
5415 		UPDATE_COEF(0x67, 0x2000, 0),
5416 		{}
5417 	};
5418 	static const struct coef_fw coef0292[] = {
5419 		WRITE_COEF(0x76, 0x000e),
5420 		WRITE_COEF(0x6c, 0x2400),
5421 		WRITE_COEF(0x6b, 0xc429),
5422 		WRITE_COEF(0x18, 0x7308),
5423 		{}
5424 	};
5425 	static const struct coef_fw coef0293[] = {
5426 		UPDATE_COEF(0x4a, 0x000f, 0x000e), /* Combo Jack auto detect */
5427 		WRITE_COEF(0x45, 0xC429), /* Set to TRS type */
5428 		UPDATE_COEF(0x1a, 1<<3, 0), /* Combo JD gating without LINE1-VREFO */
5429 		{}
5430 	};
5431 	static const struct coef_fw coef0688[] = {
5432 		WRITE_COEF(0x11, 0x0041),
5433 		WRITE_COEF(0x15, 0x0d40),
5434 		WRITE_COEF(0xb7, 0x802b),
5435 		{}
5436 	};
5437 	static const struct coef_fw coef0274[] = {
5438 		WRITE_COEF(0x45, 0x4289),
5439 		UPDATE_COEF(0x4a, 0x0010, 0x0010),
5440 		UPDATE_COEF(0x6b, 0x0f00, 0),
5441 		UPDATE_COEF(0x49, 0x0300, 0x0300),
5442 		{}
5443 	};
5444 
5445 	switch (codec->core.vendor_id) {
5446 	case 0x10ec0215:
5447 	case 0x10ec0225:
5448 	case 0x10ec0285:
5449 	case 0x10ec0295:
5450 	case 0x10ec0289:
5451 	case 0x10ec0299:
5452 		alc_process_coef_fw(codec, alc225_pre_hsmode);
5453 		alc_process_coef_fw(codec, coef0225);
5454 		alc_hp_enable_unmute(codec, 75);
5455 		break;
5456 	case 0x10ec0255:
5457 		alc_process_coef_fw(codec, coef0255);
5458 		break;
5459 	case 0x10ec0230:
5460 	case 0x10ec0236:
5461 	case 0x10ec0256:
5462 	case 0x19e58326:
5463 		alc_write_coef_idx(codec, 0x1b, 0x0e4b);
5464 		alc_write_coef_idx(codec, 0x45, 0xc089);
5465 		msleep(50);
5466 		alc_process_coef_fw(codec, coef0256);
5467 		alc_hp_enable_unmute(codec, 75);
5468 		break;
5469 	case 0x10ec0234:
5470 	case 0x10ec0274:
5471 	case 0x10ec0294:
5472 		alc_process_coef_fw(codec, coef0274);
5473 		break;
5474 	case 0x10ec0233:
5475 	case 0x10ec0283:
5476 		alc_process_coef_fw(codec, coef0233);
5477 		break;
5478 	case 0x10ec0286:
5479 	case 0x10ec0288:
5480 	case 0x10ec0298:
5481 		alc_process_coef_fw(codec, coef0288);
5482 		break;
5483 	case 0x10ec0292:
5484 		alc_process_coef_fw(codec, coef0292);
5485 		break;
5486 	case 0x10ec0293:
5487 		alc_process_coef_fw(codec, coef0293);
5488 		break;
5489 	case 0x10ec0668:
5490 		alc_process_coef_fw(codec, coef0688);
5491 		break;
5492 	case 0x10ec0867:
5493 		alc_update_coefex_idx(codec, 0x57, 0x5, 1<<14, 0);
5494 		break;
5495 	}
5496 	codec_dbg(codec, "Headset jack set to headphone (default) mode.\n");
5497 }
5498 
5499 /* Iphone type */
5500 static void alc_headset_mode_ctia(struct hda_codec *codec)
5501 {
5502 	int val;
5503 
5504 	static const struct coef_fw coef0255[] = {
5505 		WRITE_COEF(0x45, 0xd489), /* Set to CTIA type */
5506 		WRITE_COEF(0x1b, 0x0c2b),
5507 		WRITE_COEFEX(0x57, 0x03, 0x8ea6),
5508 		{}
5509 	};
5510 	static const struct coef_fw coef0256[] = {
5511 		WRITE_COEF(0x45, 0xd489), /* Set to CTIA type */
5512 		WRITE_COEF(0x1b, 0x0e6b),
5513 		{}
5514 	};
5515 	static const struct coef_fw coef0233[] = {
5516 		WRITE_COEF(0x45, 0xd429),
5517 		WRITE_COEF(0x1b, 0x0c2b),
5518 		WRITE_COEF(0x32, 0x4ea3),
5519 		{}
5520 	};
5521 	static const struct coef_fw coef0288[] = {
5522 		UPDATE_COEF(0x50, 0x2000, 0x2000),
5523 		UPDATE_COEF(0x56, 0x0006, 0x0006),
5524 		UPDATE_COEF(0x66, 0x0008, 0),
5525 		UPDATE_COEF(0x67, 0x2000, 0),
5526 		{}
5527 	};
5528 	static const struct coef_fw coef0292[] = {
5529 		WRITE_COEF(0x6b, 0xd429),
5530 		WRITE_COEF(0x76, 0x0008),
5531 		WRITE_COEF(0x18, 0x7388),
5532 		{}
5533 	};
5534 	static const struct coef_fw coef0293[] = {
5535 		WRITE_COEF(0x45, 0xd429), /* Set to ctia type */
5536 		UPDATE_COEF(0x10, 7<<8, 7<<8), /* SET Line1 JD to 1 */
5537 		{}
5538 	};
5539 	static const struct coef_fw coef0688[] = {
5540 		WRITE_COEF(0x11, 0x0001),
5541 		WRITE_COEF(0x15, 0x0d60),
5542 		WRITE_COEF(0xc3, 0x0000),
5543 		{}
5544 	};
5545 	static const struct coef_fw coef0225_1[] = {
5546 		UPDATE_COEF(0x45, 0x3f<<10, 0x35<<10),
5547 		UPDATE_COEF(0x63, 3<<14, 2<<14),
5548 		{}
5549 	};
5550 	static const struct coef_fw coef0225_2[] = {
5551 		UPDATE_COEF(0x45, 0x3f<<10, 0x35<<10),
5552 		UPDATE_COEF(0x63, 3<<14, 1<<14),
5553 		{}
5554 	};
5555 
5556 	switch (codec->core.vendor_id) {
5557 	case 0x10ec0255:
5558 		alc_process_coef_fw(codec, coef0255);
5559 		break;
5560 	case 0x10ec0230:
5561 	case 0x10ec0236:
5562 	case 0x10ec0256:
5563 	case 0x19e58326:
5564 		alc_process_coef_fw(codec, coef0256);
5565 		alc_hp_enable_unmute(codec, 75);
5566 		break;
5567 	case 0x10ec0234:
5568 	case 0x10ec0274:
5569 	case 0x10ec0294:
5570 		alc_write_coef_idx(codec, 0x45, 0xd689);
5571 		break;
5572 	case 0x10ec0233:
5573 	case 0x10ec0283:
5574 		alc_process_coef_fw(codec, coef0233);
5575 		break;
5576 	case 0x10ec0298:
5577 		val = alc_read_coef_idx(codec, 0x50);
5578 		if (val & (1 << 12)) {
5579 			alc_update_coef_idx(codec, 0x8e, 0x0070, 0x0020);
5580 			alc_update_coef_idx(codec, 0x4f, 0xfcc0, 0xd400);
5581 			msleep(300);
5582 		} else {
5583 			alc_update_coef_idx(codec, 0x8e, 0x0070, 0x0010);
5584 			alc_update_coef_idx(codec, 0x4f, 0xfcc0, 0xd400);
5585 			msleep(300);
5586 		}
5587 		break;
5588 	case 0x10ec0286:
5589 	case 0x10ec0288:
5590 		alc_update_coef_idx(codec, 0x4f, 0xfcc0, 0xd400);
5591 		msleep(300);
5592 		alc_process_coef_fw(codec, coef0288);
5593 		break;
5594 	case 0x10ec0292:
5595 		alc_process_coef_fw(codec, coef0292);
5596 		break;
5597 	case 0x10ec0293:
5598 		alc_process_coef_fw(codec, coef0293);
5599 		break;
5600 	case 0x10ec0668:
5601 		alc_process_coef_fw(codec, coef0688);
5602 		break;
5603 	case 0x10ec0215:
5604 	case 0x10ec0225:
5605 	case 0x10ec0285:
5606 	case 0x10ec0295:
5607 	case 0x10ec0289:
5608 	case 0x10ec0299:
5609 		val = alc_read_coef_idx(codec, 0x45);
5610 		if (val & (1 << 9))
5611 			alc_process_coef_fw(codec, coef0225_2);
5612 		else
5613 			alc_process_coef_fw(codec, coef0225_1);
5614 		alc_hp_enable_unmute(codec, 75);
5615 		break;
5616 	case 0x10ec0867:
5617 		alc_update_coefex_idx(codec, 0x57, 0x5, 1<<14, 0);
5618 		break;
5619 	}
5620 	codec_dbg(codec, "Headset jack set to iPhone-style headset mode.\n");
5621 }
5622 
5623 /* Nokia type */
5624 static void alc_headset_mode_omtp(struct hda_codec *codec)
5625 {
5626 	static const struct coef_fw coef0255[] = {
5627 		WRITE_COEF(0x45, 0xe489), /* Set to OMTP Type */
5628 		WRITE_COEF(0x1b, 0x0c2b),
5629 		WRITE_COEFEX(0x57, 0x03, 0x8ea6),
5630 		{}
5631 	};
5632 	static const struct coef_fw coef0256[] = {
5633 		WRITE_COEF(0x45, 0xe489), /* Set to OMTP Type */
5634 		WRITE_COEF(0x1b, 0x0e6b),
5635 		{}
5636 	};
5637 	static const struct coef_fw coef0233[] = {
5638 		WRITE_COEF(0x45, 0xe429),
5639 		WRITE_COEF(0x1b, 0x0c2b),
5640 		WRITE_COEF(0x32, 0x4ea3),
5641 		{}
5642 	};
5643 	static const struct coef_fw coef0288[] = {
5644 		UPDATE_COEF(0x50, 0x2000, 0x2000),
5645 		UPDATE_COEF(0x56, 0x0006, 0x0006),
5646 		UPDATE_COEF(0x66, 0x0008, 0),
5647 		UPDATE_COEF(0x67, 0x2000, 0),
5648 		{}
5649 	};
5650 	static const struct coef_fw coef0292[] = {
5651 		WRITE_COEF(0x6b, 0xe429),
5652 		WRITE_COEF(0x76, 0x0008),
5653 		WRITE_COEF(0x18, 0x7388),
5654 		{}
5655 	};
5656 	static const struct coef_fw coef0293[] = {
5657 		WRITE_COEF(0x45, 0xe429), /* Set to omtp type */
5658 		UPDATE_COEF(0x10, 7<<8, 7<<8), /* SET Line1 JD to 1 */
5659 		{}
5660 	};
5661 	static const struct coef_fw coef0688[] = {
5662 		WRITE_COEF(0x11, 0x0001),
5663 		WRITE_COEF(0x15, 0x0d50),
5664 		WRITE_COEF(0xc3, 0x0000),
5665 		{}
5666 	};
5667 	static const struct coef_fw coef0225[] = {
5668 		UPDATE_COEF(0x45, 0x3f<<10, 0x39<<10),
5669 		UPDATE_COEF(0x63, 3<<14, 2<<14),
5670 		{}
5671 	};
5672 
5673 	switch (codec->core.vendor_id) {
5674 	case 0x10ec0255:
5675 		alc_process_coef_fw(codec, coef0255);
5676 		break;
5677 	case 0x10ec0230:
5678 	case 0x10ec0236:
5679 	case 0x10ec0256:
5680 	case 0x19e58326:
5681 		alc_process_coef_fw(codec, coef0256);
5682 		alc_hp_enable_unmute(codec, 75);
5683 		break;
5684 	case 0x10ec0234:
5685 	case 0x10ec0274:
5686 	case 0x10ec0294:
5687 		alc_write_coef_idx(codec, 0x45, 0xe689);
5688 		break;
5689 	case 0x10ec0233:
5690 	case 0x10ec0283:
5691 		alc_process_coef_fw(codec, coef0233);
5692 		break;
5693 	case 0x10ec0298:
5694 		alc_update_coef_idx(codec, 0x8e, 0x0070, 0x0010);/* Headset output enable */
5695 		alc_update_coef_idx(codec, 0x4f, 0xfcc0, 0xe400);
5696 		msleep(300);
5697 		break;
5698 	case 0x10ec0286:
5699 	case 0x10ec0288:
5700 		alc_update_coef_idx(codec, 0x4f, 0xfcc0, 0xe400);
5701 		msleep(300);
5702 		alc_process_coef_fw(codec, coef0288);
5703 		break;
5704 	case 0x10ec0292:
5705 		alc_process_coef_fw(codec, coef0292);
5706 		break;
5707 	case 0x10ec0293:
5708 		alc_process_coef_fw(codec, coef0293);
5709 		break;
5710 	case 0x10ec0668:
5711 		alc_process_coef_fw(codec, coef0688);
5712 		break;
5713 	case 0x10ec0215:
5714 	case 0x10ec0225:
5715 	case 0x10ec0285:
5716 	case 0x10ec0295:
5717 	case 0x10ec0289:
5718 	case 0x10ec0299:
5719 		alc_process_coef_fw(codec, coef0225);
5720 		alc_hp_enable_unmute(codec, 75);
5721 		break;
5722 	}
5723 	codec_dbg(codec, "Headset jack set to Nokia-style headset mode.\n");
5724 }
5725 
5726 static void alc_determine_headset_type(struct hda_codec *codec)
5727 {
5728 	int val;
5729 	bool is_ctia = false;
5730 	struct alc_spec *spec = codec->spec;
5731 	static const struct coef_fw coef0255[] = {
5732 		WRITE_COEF(0x45, 0xd089), /* combo jack auto switch control(Check type)*/
5733 		WRITE_COEF(0x49, 0x0149), /* combo jack auto switch control(Vref
5734  conteol) */
5735 		{}
5736 	};
5737 	static const struct coef_fw coef0288[] = {
5738 		UPDATE_COEF(0x4f, 0xfcc0, 0xd400), /* Check Type */
5739 		{}
5740 	};
5741 	static const struct coef_fw coef0298[] = {
5742 		UPDATE_COEF(0x50, 0x2000, 0x2000),
5743 		UPDATE_COEF(0x56, 0x0006, 0x0006),
5744 		UPDATE_COEF(0x66, 0x0008, 0),
5745 		UPDATE_COEF(0x67, 0x2000, 0),
5746 		UPDATE_COEF(0x19, 0x1300, 0x1300),
5747 		{}
5748 	};
5749 	static const struct coef_fw coef0293[] = {
5750 		UPDATE_COEF(0x4a, 0x000f, 0x0008), /* Combo Jack auto detect */
5751 		WRITE_COEF(0x45, 0xD429), /* Set to ctia type */
5752 		{}
5753 	};
5754 	static const struct coef_fw coef0688[] = {
5755 		WRITE_COEF(0x11, 0x0001),
5756 		WRITE_COEF(0xb7, 0x802b),
5757 		WRITE_COEF(0x15, 0x0d60),
5758 		WRITE_COEF(0xc3, 0x0c00),
5759 		{}
5760 	};
5761 	static const struct coef_fw coef0274[] = {
5762 		UPDATE_COEF(0x4a, 0x0010, 0),
5763 		UPDATE_COEF(0x4a, 0x8000, 0),
5764 		WRITE_COEF(0x45, 0xd289),
5765 		UPDATE_COEF(0x49, 0x0300, 0x0300),
5766 		{}
5767 	};
5768 
5769 	if (spec->no_internal_mic_pin) {
5770 		alc_update_coef_idx(codec, 0x45, 0xf<<12 | 1<<10, 5<<12);
5771 		return;
5772 	}
5773 
5774 	switch (codec->core.vendor_id) {
5775 	case 0x10ec0255:
5776 		alc_process_coef_fw(codec, coef0255);
5777 		msleep(300);
5778 		val = alc_read_coef_idx(codec, 0x46);
5779 		is_ctia = (val & 0x0070) == 0x0070;
5780 		break;
5781 	case 0x10ec0230:
5782 	case 0x10ec0236:
5783 	case 0x10ec0256:
5784 	case 0x19e58326:
5785 		alc_write_coef_idx(codec, 0x1b, 0x0e4b);
5786 		alc_write_coef_idx(codec, 0x06, 0x6104);
5787 		alc_write_coefex_idx(codec, 0x57, 0x3, 0x09a3);
5788 
5789 		alc_process_coef_fw(codec, coef0255);
5790 		msleep(300);
5791 		val = alc_read_coef_idx(codec, 0x46);
5792 		is_ctia = (val & 0x0070) == 0x0070;
5793 		if (!is_ctia) {
5794 			alc_write_coef_idx(codec, 0x45, 0xe089);
5795 			msleep(100);
5796 			val = alc_read_coef_idx(codec, 0x46);
5797 			if ((val & 0x0070) == 0x0070)
5798 				is_ctia = false;
5799 			else
5800 				is_ctia = true;
5801 		}
5802 		alc_write_coefex_idx(codec, 0x57, 0x3, 0x0da3);
5803 		alc_update_coefex_idx(codec, 0x57, 0x5, 1<<14, 0);
5804 		break;
5805 	case 0x10ec0234:
5806 	case 0x10ec0274:
5807 	case 0x10ec0294:
5808 		alc_process_coef_fw(codec, coef0274);
5809 		msleep(850);
5810 		val = alc_read_coef_idx(codec, 0x46);
5811 		is_ctia = (val & 0x00f0) == 0x00f0;
5812 		break;
5813 	case 0x10ec0233:
5814 	case 0x10ec0283:
5815 		alc_write_coef_idx(codec, 0x45, 0xd029);
5816 		msleep(300);
5817 		val = alc_read_coef_idx(codec, 0x46);
5818 		is_ctia = (val & 0x0070) == 0x0070;
5819 		break;
5820 	case 0x10ec0298:
5821 		snd_hda_codec_write(codec, 0x21, 0,
5822 			    AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);
5823 		msleep(100);
5824 		snd_hda_codec_write(codec, 0x21, 0,
5825 			    AC_VERB_SET_PIN_WIDGET_CONTROL, 0x0);
5826 		msleep(200);
5827 
5828 		val = alc_read_coef_idx(codec, 0x50);
5829 		if (val & (1 << 12)) {
5830 			alc_update_coef_idx(codec, 0x8e, 0x0070, 0x0020);
5831 			alc_process_coef_fw(codec, coef0288);
5832 			msleep(350);
5833 			val = alc_read_coef_idx(codec, 0x50);
5834 			is_ctia = (val & 0x0070) == 0x0070;
5835 		} else {
5836 			alc_update_coef_idx(codec, 0x8e, 0x0070, 0x0010);
5837 			alc_process_coef_fw(codec, coef0288);
5838 			msleep(350);
5839 			val = alc_read_coef_idx(codec, 0x50);
5840 			is_ctia = (val & 0x0070) == 0x0070;
5841 		}
5842 		alc_process_coef_fw(codec, coef0298);
5843 		snd_hda_codec_write(codec, 0x21, 0,
5844 			    AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP);
5845 		msleep(75);
5846 		snd_hda_codec_write(codec, 0x21, 0,
5847 			    AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE);
5848 		break;
5849 	case 0x10ec0286:
5850 	case 0x10ec0288:
5851 		alc_process_coef_fw(codec, coef0288);
5852 		msleep(350);
5853 		val = alc_read_coef_idx(codec, 0x50);
5854 		is_ctia = (val & 0x0070) == 0x0070;
5855 		break;
5856 	case 0x10ec0292:
5857 		alc_write_coef_idx(codec, 0x6b, 0xd429);
5858 		msleep(300);
5859 		val = alc_read_coef_idx(codec, 0x6c);
5860 		is_ctia = (val & 0x001c) == 0x001c;
5861 		break;
5862 	case 0x10ec0293:
5863 		alc_process_coef_fw(codec, coef0293);
5864 		msleep(300);
5865 		val = alc_read_coef_idx(codec, 0x46);
5866 		is_ctia = (val & 0x0070) == 0x0070;
5867 		break;
5868 	case 0x10ec0668:
5869 		alc_process_coef_fw(codec, coef0688);
5870 		msleep(300);
5871 		val = alc_read_coef_idx(codec, 0xbe);
5872 		is_ctia = (val & 0x1c02) == 0x1c02;
5873 		break;
5874 	case 0x10ec0215:
5875 	case 0x10ec0225:
5876 	case 0x10ec0285:
5877 	case 0x10ec0295:
5878 	case 0x10ec0289:
5879 	case 0x10ec0299:
5880 		alc_process_coef_fw(codec, alc225_pre_hsmode);
5881 		alc_update_coef_idx(codec, 0x67, 0xf000, 0x1000);
5882 		val = alc_read_coef_idx(codec, 0x45);
5883 		if (val & (1 << 9)) {
5884 			alc_update_coef_idx(codec, 0x45, 0x3f<<10, 0x34<<10);
5885 			alc_update_coef_idx(codec, 0x49, 3<<8, 2<<8);
5886 			msleep(800);
5887 			val = alc_read_coef_idx(codec, 0x46);
5888 			is_ctia = (val & 0x00f0) == 0x00f0;
5889 		} else {
5890 			alc_update_coef_idx(codec, 0x45, 0x3f<<10, 0x34<<10);
5891 			alc_update_coef_idx(codec, 0x49, 3<<8, 1<<8);
5892 			msleep(800);
5893 			val = alc_read_coef_idx(codec, 0x46);
5894 			is_ctia = (val & 0x00f0) == 0x00f0;
5895 		}
5896 		if (!is_ctia) {
5897 			alc_update_coef_idx(codec, 0x45, 0x3f<<10, 0x38<<10);
5898 			alc_update_coef_idx(codec, 0x49, 3<<8, 1<<8);
5899 			msleep(100);
5900 			val = alc_read_coef_idx(codec, 0x46);
5901 			if ((val & 0x00f0) == 0x00f0)
5902 				is_ctia = false;
5903 			else
5904 				is_ctia = true;
5905 		}
5906 		alc_update_coef_idx(codec, 0x4a, 7<<6, 7<<6);
5907 		alc_update_coef_idx(codec, 0x4a, 3<<4, 3<<4);
5908 		alc_update_coef_idx(codec, 0x67, 0xf000, 0x3000);
5909 		break;
5910 	case 0x10ec0867:
5911 		is_ctia = true;
5912 		break;
5913 	}
5914 
5915 	codec_dbg(codec, "Headset jack detected iPhone-style headset: %s\n",
5916 		    is_ctia ? "yes" : "no");
5917 	spec->current_headset_type = is_ctia ? ALC_HEADSET_TYPE_CTIA : ALC_HEADSET_TYPE_OMTP;
5918 }
5919 
5920 static void alc_update_headset_mode(struct hda_codec *codec)
5921 {
5922 	struct alc_spec *spec = codec->spec;
5923 
5924 	hda_nid_t mux_pin = spec->gen.imux_pins[spec->gen.cur_mux[0]];
5925 	hda_nid_t hp_pin = alc_get_hp_pin(spec);
5926 
5927 	int new_headset_mode;
5928 
5929 	if (!snd_hda_jack_detect(codec, hp_pin))
5930 		new_headset_mode = ALC_HEADSET_MODE_UNPLUGGED;
5931 	else if (mux_pin == spec->headset_mic_pin)
5932 		new_headset_mode = ALC_HEADSET_MODE_HEADSET;
5933 	else if (mux_pin == spec->headphone_mic_pin)
5934 		new_headset_mode = ALC_HEADSET_MODE_MIC;
5935 	else
5936 		new_headset_mode = ALC_HEADSET_MODE_HEADPHONE;
5937 
5938 	if (new_headset_mode == spec->current_headset_mode) {
5939 		snd_hda_gen_update_outputs(codec);
5940 		return;
5941 	}
5942 
5943 	switch (new_headset_mode) {
5944 	case ALC_HEADSET_MODE_UNPLUGGED:
5945 		alc_headset_mode_unplugged(codec);
5946 		spec->current_headset_mode = ALC_HEADSET_MODE_UNKNOWN;
5947 		spec->current_headset_type = ALC_HEADSET_TYPE_UNKNOWN;
5948 		spec->gen.hp_jack_present = false;
5949 		break;
5950 	case ALC_HEADSET_MODE_HEADSET:
5951 		if (spec->current_headset_type == ALC_HEADSET_TYPE_UNKNOWN)
5952 			alc_determine_headset_type(codec);
5953 		if (spec->current_headset_type == ALC_HEADSET_TYPE_CTIA)
5954 			alc_headset_mode_ctia(codec);
5955 		else if (spec->current_headset_type == ALC_HEADSET_TYPE_OMTP)
5956 			alc_headset_mode_omtp(codec);
5957 		spec->gen.hp_jack_present = true;
5958 		break;
5959 	case ALC_HEADSET_MODE_MIC:
5960 		alc_headset_mode_mic_in(codec, hp_pin, spec->headphone_mic_pin);
5961 		spec->gen.hp_jack_present = false;
5962 		break;
5963 	case ALC_HEADSET_MODE_HEADPHONE:
5964 		alc_headset_mode_default(codec);
5965 		spec->gen.hp_jack_present = true;
5966 		break;
5967 	}
5968 	if (new_headset_mode != ALC_HEADSET_MODE_MIC) {
5969 		snd_hda_set_pin_ctl_cache(codec, hp_pin,
5970 					  AC_PINCTL_OUT_EN | AC_PINCTL_HP_EN);
5971 		if (spec->headphone_mic_pin && spec->headphone_mic_pin != hp_pin)
5972 			snd_hda_set_pin_ctl_cache(codec, spec->headphone_mic_pin,
5973 						  PIN_VREFHIZ);
5974 	}
5975 	spec->current_headset_mode = new_headset_mode;
5976 
5977 	snd_hda_gen_update_outputs(codec);
5978 }
5979 
5980 static void alc_update_headset_mode_hook(struct hda_codec *codec,
5981 					 struct snd_kcontrol *kcontrol,
5982 					 struct snd_ctl_elem_value *ucontrol)
5983 {
5984 	alc_update_headset_mode(codec);
5985 }
5986 
5987 static void alc_update_headset_jack_cb(struct hda_codec *codec,
5988 				       struct hda_jack_callback *jack)
5989 {
5990 	snd_hda_gen_hp_automute(codec, jack);
5991 	alc_update_headset_mode(codec);
5992 }
5993 
5994 static void alc_probe_headset_mode(struct hda_codec *codec)
5995 {
5996 	int i;
5997 	struct alc_spec *spec = codec->spec;
5998 	struct auto_pin_cfg *cfg = &spec->gen.autocfg;
5999 
6000 	/* Find mic pins */
6001 	for (i = 0; i < cfg->num_inputs; i++) {
6002 		if (cfg->inputs[i].is_headset_mic && !spec->headset_mic_pin)
6003 			spec->headset_mic_pin = cfg->inputs[i].pin;
6004 		if (cfg->inputs[i].is_headphone_mic && !spec->headphone_mic_pin)
6005 			spec->headphone_mic_pin = cfg->inputs[i].pin;
6006 	}
6007 
6008 	WARN_ON(spec->gen.cap_sync_hook);
6009 	spec->gen.cap_sync_hook = alc_update_headset_mode_hook;
6010 	spec->gen.automute_hook = alc_update_headset_mode;
6011 	spec->gen.hp_automute_hook = alc_update_headset_jack_cb;
6012 }
6013 
6014 static void alc_fixup_headset_mode(struct hda_codec *codec,
6015 				const struct hda_fixup *fix, int action)
6016 {
6017 	struct alc_spec *spec = codec->spec;
6018 
6019 	switch (action) {
6020 	case HDA_FIXUP_ACT_PRE_PROBE:
6021 		spec->parse_flags |= HDA_PINCFG_HEADSET_MIC | HDA_PINCFG_HEADPHONE_MIC;
6022 		break;
6023 	case HDA_FIXUP_ACT_PROBE:
6024 		alc_probe_headset_mode(codec);
6025 		break;
6026 	case HDA_FIXUP_ACT_INIT:
6027 		if (is_s3_resume(codec) || is_s4_resume(codec)) {
6028 			spec->current_headset_mode = ALC_HEADSET_MODE_UNKNOWN;
6029 			spec->current_headset_type = ALC_HEADSET_TYPE_UNKNOWN;
6030 		}
6031 		alc_update_headset_mode(codec);
6032 		break;
6033 	}
6034 }
6035 
6036 static void alc_fixup_headset_mode_no_hp_mic(struct hda_codec *codec,
6037 				const struct hda_fixup *fix, int action)
6038 {
6039 	if (action == HDA_FIXUP_ACT_PRE_PROBE) {
6040 		struct alc_spec *spec = codec->spec;
6041 		spec->parse_flags |= HDA_PINCFG_HEADSET_MIC;
6042 	}
6043 	else
6044 		alc_fixup_headset_mode(codec, fix, action);
6045 }
6046 
6047 static void alc255_set_default_jack_type(struct hda_codec *codec)
6048 {
6049 	/* Set to iphone type */
6050 	static const struct coef_fw alc255fw[] = {
6051 		WRITE_COEF(0x1b, 0x880b),
6052 		WRITE_COEF(0x45, 0xd089),
6053 		WRITE_COEF(0x1b, 0x080b),
6054 		WRITE_COEF(0x46, 0x0004),
6055 		WRITE_COEF(0x1b, 0x0c0b),
6056 		{}
6057 	};
6058 	static const struct coef_fw alc256fw[] = {
6059 		WRITE_COEF(0x1b, 0x884b),
6060 		WRITE_COEF(0x45, 0xd089),
6061 		WRITE_COEF(0x1b, 0x084b),
6062 		WRITE_COEF(0x46, 0x0004),
6063 		WRITE_COEF(0x1b, 0x0c4b),
6064 		{}
6065 	};
6066 	switch (codec->core.vendor_id) {
6067 	case 0x10ec0255:
6068 		alc_process_coef_fw(codec, alc255fw);
6069 		break;
6070 	case 0x10ec0230:
6071 	case 0x10ec0236:
6072 	case 0x10ec0256:
6073 	case 0x19e58326:
6074 		alc_process_coef_fw(codec, alc256fw);
6075 		break;
6076 	}
6077 	msleep(30);
6078 }
6079 
6080 static void alc_fixup_headset_mode_alc255(struct hda_codec *codec,
6081 				const struct hda_fixup *fix, int action)
6082 {
6083 	if (action == HDA_FIXUP_ACT_PRE_PROBE) {
6084 		alc255_set_default_jack_type(codec);
6085 	}
6086 	alc_fixup_headset_mode(codec, fix, action);
6087 }
6088 
6089 static void alc_fixup_headset_mode_alc255_no_hp_mic(struct hda_codec *codec,
6090 				const struct hda_fixup *fix, int action)
6091 {
6092 	if (action == HDA_FIXUP_ACT_PRE_PROBE) {
6093 		struct alc_spec *spec = codec->spec;
6094 		spec->parse_flags |= HDA_PINCFG_HEADSET_MIC;
6095 		alc255_set_default_jack_type(codec);
6096 	}
6097 	else
6098 		alc_fixup_headset_mode(codec, fix, action);
6099 }
6100 
6101 static void alc288_update_headset_jack_cb(struct hda_codec *codec,
6102 				       struct hda_jack_callback *jack)
6103 {
6104 	struct alc_spec *spec = codec->spec;
6105 
6106 	alc_update_headset_jack_cb(codec, jack);
6107 	/* Headset Mic enable or disable, only for Dell Dino */
6108 	alc_update_gpio_data(codec, 0x40, spec->gen.hp_jack_present);
6109 }
6110 
6111 static void alc_fixup_headset_mode_dell_alc288(struct hda_codec *codec,
6112 				const struct hda_fixup *fix, int action)
6113 {
6114 	alc_fixup_headset_mode(codec, fix, action);
6115 	if (action == HDA_FIXUP_ACT_PROBE) {
6116 		struct alc_spec *spec = codec->spec;
6117 		/* toggled via hp_automute_hook */
6118 		spec->gpio_mask |= 0x40;
6119 		spec->gpio_dir |= 0x40;
6120 		spec->gen.hp_automute_hook = alc288_update_headset_jack_cb;
6121 	}
6122 }
6123 
6124 static void alc_fixup_auto_mute_via_amp(struct hda_codec *codec,
6125 					const struct hda_fixup *fix, int action)
6126 {
6127 	if (action == HDA_FIXUP_ACT_PRE_PROBE) {
6128 		struct alc_spec *spec = codec->spec;
6129 		spec->gen.auto_mute_via_amp = 1;
6130 	}
6131 }
6132 
6133 static void alc_fixup_no_shutup(struct hda_codec *codec,
6134 				const struct hda_fixup *fix, int action)
6135 {
6136 	if (action == HDA_FIXUP_ACT_PRE_PROBE) {
6137 		struct alc_spec *spec = codec->spec;
6138 		spec->no_shutup_pins = 1;
6139 	}
6140 }
6141 
6142 static void alc_fixup_disable_aamix(struct hda_codec *codec,
6143 				    const struct hda_fixup *fix, int action)
6144 {
6145 	if (action == HDA_FIXUP_ACT_PRE_PROBE) {
6146 		struct alc_spec *spec = codec->spec;
6147 		/* Disable AA-loopback as it causes white noise */
6148 		spec->gen.mixer_nid = 0;
6149 	}
6150 }
6151 
6152 /* fixup for Thinkpad docks: add dock pins, avoid HP parser fixup */
6153 static void alc_fixup_tpt440_dock(struct hda_codec *codec,
6154 				  const struct hda_fixup *fix, int action)
6155 {
6156 	static const struct hda_pintbl pincfgs[] = {
6157 		{ 0x16, 0x21211010 }, /* dock headphone */
6158 		{ 0x19, 0x21a11010 }, /* dock mic */
6159 		{ }
6160 	};
6161 	struct alc_spec *spec = codec->spec;
6162 
6163 	if (action == HDA_FIXUP_ACT_PRE_PROBE) {
6164 		spec->parse_flags = HDA_PINCFG_NO_HP_FIXUP;
6165 		codec->power_save_node = 0; /* avoid click noises */
6166 		snd_hda_apply_pincfgs(codec, pincfgs);
6167 	}
6168 }
6169 
6170 static void alc_fixup_tpt470_dock(struct hda_codec *codec,
6171 				  const struct hda_fixup *fix, int action)
6172 {
6173 	static const struct hda_pintbl pincfgs[] = {
6174 		{ 0x17, 0x21211010 }, /* dock headphone */
6175 		{ 0x19, 0x21a11010 }, /* dock mic */
6176 		{ }
6177 	};
6178 	struct alc_spec *spec = codec->spec;
6179 
6180 	if (action == HDA_FIXUP_ACT_PRE_PROBE) {
6181 		spec->parse_flags = HDA_PINCFG_NO_HP_FIXUP;
6182 		snd_hda_apply_pincfgs(codec, pincfgs);
6183 	} else if (action == HDA_FIXUP_ACT_INIT) {
6184 		/* Enable DOCK device */
6185 		snd_hda_codec_write(codec, 0x17, 0,
6186 			    AC_VERB_SET_CONFIG_DEFAULT_BYTES_3, 0);
6187 		/* Enable DOCK device */
6188 		snd_hda_codec_write(codec, 0x19, 0,
6189 			    AC_VERB_SET_CONFIG_DEFAULT_BYTES_3, 0);
6190 	}
6191 }
6192 
6193 static void alc_fixup_tpt470_dacs(struct hda_codec *codec,
6194 				  const struct hda_fixup *fix, int action)
6195 {
6196 	/* Assure the speaker pin to be coupled with DAC NID 0x03; otherwise
6197 	 * the speaker output becomes too low by some reason on Thinkpads with
6198 	 * ALC298 codec
6199 	 */
6200 	static const hda_nid_t preferred_pairs[] = {
6201 		0x14, 0x03, 0x17, 0x02, 0x21, 0x02,
6202 		0
6203 	};
6204 	struct alc_spec *spec = codec->spec;
6205 
6206 	if (action == HDA_FIXUP_ACT_PRE_PROBE)
6207 		spec->gen.preferred_dacs = preferred_pairs;
6208 }
6209 
6210 static void alc295_fixup_asus_dacs(struct hda_codec *codec,
6211 				   const struct hda_fixup *fix, int action)
6212 {
6213 	static const hda_nid_t preferred_pairs[] = {
6214 		0x17, 0x02, 0x21, 0x03, 0
6215 	};
6216 	struct alc_spec *spec = codec->spec;
6217 
6218 	if (action == HDA_FIXUP_ACT_PRE_PROBE)
6219 		spec->gen.preferred_dacs = preferred_pairs;
6220 }
6221 
6222 static void alc_shutup_dell_xps13(struct hda_codec *codec)
6223 {
6224 	struct alc_spec *spec = codec->spec;
6225 	int hp_pin = alc_get_hp_pin(spec);
6226 
6227 	/* Prevent pop noises when headphones are plugged in */
6228 	snd_hda_codec_write(codec, hp_pin, 0,
6229 			    AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);
6230 	msleep(20);
6231 }
6232 
6233 static void alc_fixup_dell_xps13(struct hda_codec *codec,
6234 				const struct hda_fixup *fix, int action)
6235 {
6236 	struct alc_spec *spec = codec->spec;
6237 	struct hda_input_mux *imux = &spec->gen.input_mux;
6238 	int i;
6239 
6240 	switch (action) {
6241 	case HDA_FIXUP_ACT_PRE_PROBE:
6242 		/* mic pin 0x19 must be initialized with Vref Hi-Z, otherwise
6243 		 * it causes a click noise at start up
6244 		 */
6245 		snd_hda_codec_set_pin_target(codec, 0x19, PIN_VREFHIZ);
6246 		spec->shutup = alc_shutup_dell_xps13;
6247 		break;
6248 	case HDA_FIXUP_ACT_PROBE:
6249 		/* Make the internal mic the default input source. */
6250 		for (i = 0; i < imux->num_items; i++) {
6251 			if (spec->gen.imux_pins[i] == 0x12) {
6252 				spec->gen.cur_mux[0] = i;
6253 				break;
6254 			}
6255 		}
6256 		break;
6257 	}
6258 }
6259 
6260 static void alc_fixup_headset_mode_alc662(struct hda_codec *codec,
6261 				const struct hda_fixup *fix, int action)
6262 {
6263 	struct alc_spec *spec = codec->spec;
6264 
6265 	if (action == HDA_FIXUP_ACT_PRE_PROBE) {
6266 		spec->parse_flags |= HDA_PINCFG_HEADSET_MIC;
6267 		spec->gen.hp_mic = 1; /* Mic-in is same pin as headphone */
6268 
6269 		/* Disable boost for mic-in permanently. (This code is only called
6270 		   from quirks that guarantee that the headphone is at NID 0x1b.) */
6271 		snd_hda_codec_write(codec, 0x1b, 0, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000);
6272 		snd_hda_override_wcaps(codec, 0x1b, get_wcaps(codec, 0x1b) & ~AC_WCAP_IN_AMP);
6273 	} else
6274 		alc_fixup_headset_mode(codec, fix, action);
6275 }
6276 
6277 static void alc_fixup_headset_mode_alc668(struct hda_codec *codec,
6278 				const struct hda_fixup *fix, int action)
6279 {
6280 	if (action == HDA_FIXUP_ACT_PRE_PROBE) {
6281 		alc_write_coef_idx(codec, 0xc4, 0x8000);
6282 		alc_update_coef_idx(codec, 0xc2, ~0xfe, 0);
6283 		snd_hda_set_pin_ctl_cache(codec, 0x18, 0);
6284 	}
6285 	alc_fixup_headset_mode(codec, fix, action);
6286 }
6287 
6288 /* Returns the nid of the external mic input pin, or 0 if it cannot be found. */
6289 static int find_ext_mic_pin(struct hda_codec *codec)
6290 {
6291 	struct alc_spec *spec = codec->spec;
6292 	struct auto_pin_cfg *cfg = &spec->gen.autocfg;
6293 	hda_nid_t nid;
6294 	unsigned int defcfg;
6295 	int i;
6296 
6297 	for (i = 0; i < cfg->num_inputs; i++) {
6298 		if (cfg->inputs[i].type != AUTO_PIN_MIC)
6299 			continue;
6300 		nid = cfg->inputs[i].pin;
6301 		defcfg = snd_hda_codec_get_pincfg(codec, nid);
6302 		if (snd_hda_get_input_pin_attr(defcfg) == INPUT_PIN_ATTR_INT)
6303 			continue;
6304 		return nid;
6305 	}
6306 
6307 	return 0;
6308 }
6309 
6310 static void alc271_hp_gate_mic_jack(struct hda_codec *codec,
6311 				    const struct hda_fixup *fix,
6312 				    int action)
6313 {
6314 	struct alc_spec *spec = codec->spec;
6315 
6316 	if (action == HDA_FIXUP_ACT_PROBE) {
6317 		int mic_pin = find_ext_mic_pin(codec);
6318 		int hp_pin = alc_get_hp_pin(spec);
6319 
6320 		if (snd_BUG_ON(!mic_pin || !hp_pin))
6321 			return;
6322 		snd_hda_jack_set_gating_jack(codec, mic_pin, hp_pin);
6323 	}
6324 }
6325 
6326 static void alc269_fixup_limit_int_mic_boost(struct hda_codec *codec,
6327 					     const struct hda_fixup *fix,
6328 					     int action)
6329 {
6330 	struct alc_spec *spec = codec->spec;
6331 	struct auto_pin_cfg *cfg = &spec->gen.autocfg;
6332 	int i;
6333 
6334 	/* The mic boosts on level 2 and 3 are too noisy
6335 	   on the internal mic input.
6336 	   Therefore limit the boost to 0 or 1. */
6337 
6338 	if (action != HDA_FIXUP_ACT_PROBE)
6339 		return;
6340 
6341 	for (i = 0; i < cfg->num_inputs; i++) {
6342 		hda_nid_t nid = cfg->inputs[i].pin;
6343 		unsigned int defcfg;
6344 		if (cfg->inputs[i].type != AUTO_PIN_MIC)
6345 			continue;
6346 		defcfg = snd_hda_codec_get_pincfg(codec, nid);
6347 		if (snd_hda_get_input_pin_attr(defcfg) != INPUT_PIN_ATTR_INT)
6348 			continue;
6349 
6350 		snd_hda_override_amp_caps(codec, nid, HDA_INPUT,
6351 					  (0x00 << AC_AMPCAP_OFFSET_SHIFT) |
6352 					  (0x01 << AC_AMPCAP_NUM_STEPS_SHIFT) |
6353 					  (0x2f << AC_AMPCAP_STEP_SIZE_SHIFT) |
6354 					  (0 << AC_AMPCAP_MUTE_SHIFT));
6355 	}
6356 }
6357 
6358 static void alc283_hp_automute_hook(struct hda_codec *codec,
6359 				    struct hda_jack_callback *jack)
6360 {
6361 	struct alc_spec *spec = codec->spec;
6362 	int vref;
6363 
6364 	msleep(200);
6365 	snd_hda_gen_hp_automute(codec, jack);
6366 
6367 	vref = spec->gen.hp_jack_present ? PIN_VREF80 : 0;
6368 
6369 	msleep(600);
6370 	snd_hda_codec_write(codec, 0x19, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
6371 			    vref);
6372 }
6373 
6374 static void alc283_fixup_chromebook(struct hda_codec *codec,
6375 				    const struct hda_fixup *fix, int action)
6376 {
6377 	struct alc_spec *spec = codec->spec;
6378 
6379 	switch (action) {
6380 	case HDA_FIXUP_ACT_PRE_PROBE:
6381 		snd_hda_override_wcaps(codec, 0x03, 0);
6382 		/* Disable AA-loopback as it causes white noise */
6383 		spec->gen.mixer_nid = 0;
6384 		break;
6385 	case HDA_FIXUP_ACT_INIT:
6386 		/* MIC2-VREF control */
6387 		/* Set to manual mode */
6388 		alc_update_coef_idx(codec, 0x06, 0x000c, 0);
6389 		/* Enable Line1 input control by verb */
6390 		alc_update_coef_idx(codec, 0x1a, 0, 1 << 4);
6391 		break;
6392 	}
6393 }
6394 
6395 static void alc283_fixup_sense_combo_jack(struct hda_codec *codec,
6396 				    const struct hda_fixup *fix, int action)
6397 {
6398 	struct alc_spec *spec = codec->spec;
6399 
6400 	switch (action) {
6401 	case HDA_FIXUP_ACT_PRE_PROBE:
6402 		spec->gen.hp_automute_hook = alc283_hp_automute_hook;
6403 		break;
6404 	case HDA_FIXUP_ACT_INIT:
6405 		/* MIC2-VREF control */
6406 		/* Set to manual mode */
6407 		alc_update_coef_idx(codec, 0x06, 0x000c, 0);
6408 		break;
6409 	}
6410 }
6411 
6412 /* mute tablet speaker pin (0x14) via dock plugging in addition */
6413 static void asus_tx300_automute(struct hda_codec *codec)
6414 {
6415 	struct alc_spec *spec = codec->spec;
6416 	snd_hda_gen_update_outputs(codec);
6417 	if (snd_hda_jack_detect(codec, 0x1b))
6418 		spec->gen.mute_bits |= (1ULL << 0x14);
6419 }
6420 
6421 static void alc282_fixup_asus_tx300(struct hda_codec *codec,
6422 				    const struct hda_fixup *fix, int action)
6423 {
6424 	struct alc_spec *spec = codec->spec;
6425 	static const struct hda_pintbl dock_pins[] = {
6426 		{ 0x1b, 0x21114000 }, /* dock speaker pin */
6427 		{}
6428 	};
6429 
6430 	switch (action) {
6431 	case HDA_FIXUP_ACT_PRE_PROBE:
6432 		spec->init_amp = ALC_INIT_DEFAULT;
6433 		/* TX300 needs to set up GPIO2 for the speaker amp */
6434 		alc_setup_gpio(codec, 0x04);
6435 		snd_hda_apply_pincfgs(codec, dock_pins);
6436 		spec->gen.auto_mute_via_amp = 1;
6437 		spec->gen.automute_hook = asus_tx300_automute;
6438 		snd_hda_jack_detect_enable_callback(codec, 0x1b,
6439 						    snd_hda_gen_hp_automute);
6440 		break;
6441 	case HDA_FIXUP_ACT_PROBE:
6442 		spec->init_amp = ALC_INIT_DEFAULT;
6443 		break;
6444 	case HDA_FIXUP_ACT_BUILD:
6445 		/* this is a bit tricky; give more sane names for the main
6446 		 * (tablet) speaker and the dock speaker, respectively
6447 		 */
6448 		rename_ctl(codec, "Speaker Playback Switch",
6449 			   "Dock Speaker Playback Switch");
6450 		rename_ctl(codec, "Bass Speaker Playback Switch",
6451 			   "Speaker Playback Switch");
6452 		break;
6453 	}
6454 }
6455 
6456 static void alc290_fixup_mono_speakers(struct hda_codec *codec,
6457 				       const struct hda_fixup *fix, int action)
6458 {
6459 	if (action == HDA_FIXUP_ACT_PRE_PROBE) {
6460 		/* DAC node 0x03 is giving mono output. We therefore want to
6461 		   make sure 0x14 (front speaker) and 0x15 (headphones) use the
6462 		   stereo DAC, while leaving 0x17 (bass speaker) for node 0x03. */
6463 		static const hda_nid_t conn1[] = { 0x0c };
6464 		snd_hda_override_conn_list(codec, 0x14, ARRAY_SIZE(conn1), conn1);
6465 		snd_hda_override_conn_list(codec, 0x15, ARRAY_SIZE(conn1), conn1);
6466 	}
6467 }
6468 
6469 static void alc298_fixup_speaker_volume(struct hda_codec *codec,
6470 					const struct hda_fixup *fix, int action)
6471 {
6472 	if (action == HDA_FIXUP_ACT_PRE_PROBE) {
6473 		/* The speaker is routed to the Node 0x06 by a mistake, as a result
6474 		   we can't adjust the speaker's volume since this node does not has
6475 		   Amp-out capability. we change the speaker's route to:
6476 		   Node 0x02 (Audio Output) -> Node 0x0c (Audio Mixer) -> Node 0x17 (
6477 		   Pin Complex), since Node 0x02 has Amp-out caps, we can adjust
6478 		   speaker's volume now. */
6479 
6480 		static const hda_nid_t conn1[] = { 0x0c };
6481 		snd_hda_override_conn_list(codec, 0x17, ARRAY_SIZE(conn1), conn1);
6482 	}
6483 }
6484 
6485 /* disable DAC3 (0x06) selection on NID 0x17 as it has no volume amp control */
6486 static void alc295_fixup_disable_dac3(struct hda_codec *codec,
6487 				      const struct hda_fixup *fix, int action)
6488 {
6489 	if (action == HDA_FIXUP_ACT_PRE_PROBE) {
6490 		static const hda_nid_t conn[] = { 0x02, 0x03 };
6491 		snd_hda_override_conn_list(codec, 0x17, ARRAY_SIZE(conn), conn);
6492 	}
6493 }
6494 
6495 /* force NID 0x17 (Bass Speaker) to DAC1 to share it with the main speaker */
6496 static void alc285_fixup_speaker2_to_dac1(struct hda_codec *codec,
6497 					  const struct hda_fixup *fix, int action)
6498 {
6499 	if (action == HDA_FIXUP_ACT_PRE_PROBE) {
6500 		static const hda_nid_t conn[] = { 0x02 };
6501 		snd_hda_override_conn_list(codec, 0x17, ARRAY_SIZE(conn), conn);
6502 	}
6503 }
6504 
6505 /* Hook to update amp GPIO4 for automute */
6506 static void alc280_hp_gpio4_automute_hook(struct hda_codec *codec,
6507 					  struct hda_jack_callback *jack)
6508 {
6509 	struct alc_spec *spec = codec->spec;
6510 
6511 	snd_hda_gen_hp_automute(codec, jack);
6512 	/* mute_led_polarity is set to 0, so we pass inverted value here */
6513 	alc_update_gpio_led(codec, 0x10, spec->mute_led_polarity,
6514 			    !spec->gen.hp_jack_present);
6515 }
6516 
6517 /* Manage GPIOs for HP EliteBook Folio 9480m.
6518  *
6519  * GPIO4 is the headphone amplifier power control
6520  * GPIO3 is the audio output mute indicator LED
6521  */
6522 
6523 static void alc280_fixup_hp_9480m(struct hda_codec *codec,
6524 				  const struct hda_fixup *fix,
6525 				  int action)
6526 {
6527 	struct alc_spec *spec = codec->spec;
6528 
6529 	alc_fixup_hp_gpio_led(codec, action, 0x08, 0);
6530 	if (action == HDA_FIXUP_ACT_PRE_PROBE) {
6531 		/* amp at GPIO4; toggled via alc280_hp_gpio4_automute_hook() */
6532 		spec->gpio_mask |= 0x10;
6533 		spec->gpio_dir |= 0x10;
6534 		spec->gen.hp_automute_hook = alc280_hp_gpio4_automute_hook;
6535 	}
6536 }
6537 
6538 static void alc275_fixup_gpio4_off(struct hda_codec *codec,
6539 				   const struct hda_fixup *fix,
6540 				   int action)
6541 {
6542 	struct alc_spec *spec = codec->spec;
6543 
6544 	if (action == HDA_FIXUP_ACT_PRE_PROBE) {
6545 		spec->gpio_mask |= 0x04;
6546 		spec->gpio_dir |= 0x04;
6547 		/* set data bit low */
6548 	}
6549 }
6550 
6551 /* Quirk for Thinkpad X1 7th and 8th Gen
6552  * The following fixed routing needed
6553  * DAC1 (NID 0x02) -> Speaker (NID 0x14); some eq applied secretly
6554  * DAC2 (NID 0x03) -> Bass (NID 0x17) & Headphone (NID 0x21); sharing a DAC
6555  * DAC3 (NID 0x06) -> Unused, due to the lack of volume amp
6556  */
6557 static void alc285_fixup_thinkpad_x1_gen7(struct hda_codec *codec,
6558 					  const struct hda_fixup *fix, int action)
6559 {
6560 	static const hda_nid_t conn[] = { 0x02, 0x03 }; /* exclude 0x06 */
6561 	static const hda_nid_t preferred_pairs[] = {
6562 		0x14, 0x02, 0x17, 0x03, 0x21, 0x03, 0
6563 	};
6564 	struct alc_spec *spec = codec->spec;
6565 
6566 	switch (action) {
6567 	case HDA_FIXUP_ACT_PRE_PROBE:
6568 		snd_hda_override_conn_list(codec, 0x17, ARRAY_SIZE(conn), conn);
6569 		spec->gen.preferred_dacs = preferred_pairs;
6570 		break;
6571 	case HDA_FIXUP_ACT_BUILD:
6572 		/* The generic parser creates somewhat unintuitive volume ctls
6573 		 * with the fixed routing above, and the shared DAC2 may be
6574 		 * confusing for PA.
6575 		 * Rename those to unique names so that PA doesn't touch them
6576 		 * and use only Master volume.
6577 		 */
6578 		rename_ctl(codec, "Front Playback Volume", "DAC1 Playback Volume");
6579 		rename_ctl(codec, "Bass Speaker Playback Volume", "DAC2 Playback Volume");
6580 		break;
6581 	}
6582 }
6583 
6584 static void alc233_alc662_fixup_lenovo_dual_codecs(struct hda_codec *codec,
6585 					 const struct hda_fixup *fix,
6586 					 int action)
6587 {
6588 	alc_fixup_dual_codecs(codec, fix, action);
6589 	switch (action) {
6590 	case HDA_FIXUP_ACT_PRE_PROBE:
6591 		/* override card longname to provide a unique UCM profile */
6592 		strcpy(codec->card->longname, "HDAudio-Lenovo-DualCodecs");
6593 		break;
6594 	case HDA_FIXUP_ACT_BUILD:
6595 		/* rename Capture controls depending on the codec */
6596 		rename_ctl(codec, "Capture Volume",
6597 			   codec->addr == 0 ?
6598 			   "Rear-Panel Capture Volume" :
6599 			   "Front-Panel Capture Volume");
6600 		rename_ctl(codec, "Capture Switch",
6601 			   codec->addr == 0 ?
6602 			   "Rear-Panel Capture Switch" :
6603 			   "Front-Panel Capture Switch");
6604 		break;
6605 	}
6606 }
6607 
6608 static void alc225_fixup_s3_pop_noise(struct hda_codec *codec,
6609 				      const struct hda_fixup *fix, int action)
6610 {
6611 	if (action != HDA_FIXUP_ACT_PRE_PROBE)
6612 		return;
6613 
6614 	codec->power_save_node = 1;
6615 }
6616 
6617 /* Forcibly assign NID 0x03 to HP/LO while NID 0x02 to SPK for EQ */
6618 static void alc274_fixup_bind_dacs(struct hda_codec *codec,
6619 				    const struct hda_fixup *fix, int action)
6620 {
6621 	struct alc_spec *spec = codec->spec;
6622 	static const hda_nid_t preferred_pairs[] = {
6623 		0x21, 0x03, 0x1b, 0x03, 0x16, 0x02,
6624 		0
6625 	};
6626 
6627 	if (action != HDA_FIXUP_ACT_PRE_PROBE)
6628 		return;
6629 
6630 	spec->gen.preferred_dacs = preferred_pairs;
6631 	spec->gen.auto_mute_via_amp = 1;
6632 	codec->power_save_node = 0;
6633 }
6634 
6635 /* avoid DAC 0x06 for bass speaker 0x17; it has no volume control */
6636 static void alc289_fixup_asus_ga401(struct hda_codec *codec,
6637 				    const struct hda_fixup *fix, int action)
6638 {
6639 	static const hda_nid_t preferred_pairs[] = {
6640 		0x14, 0x02, 0x17, 0x02, 0x21, 0x03, 0
6641 	};
6642 	struct alc_spec *spec = codec->spec;
6643 
6644 	if (action == HDA_FIXUP_ACT_PRE_PROBE)
6645 		spec->gen.preferred_dacs = preferred_pairs;
6646 }
6647 
6648 /* The DAC of NID 0x3 will introduce click/pop noise on headphones, so invalidate it */
6649 static void alc285_fixup_invalidate_dacs(struct hda_codec *codec,
6650 			      const struct hda_fixup *fix, int action)
6651 {
6652 	if (action != HDA_FIXUP_ACT_PRE_PROBE)
6653 		return;
6654 
6655 	snd_hda_override_wcaps(codec, 0x03, 0);
6656 }
6657 
6658 static void alc_combo_jack_hp_jd_restart(struct hda_codec *codec)
6659 {
6660 	switch (codec->core.vendor_id) {
6661 	case 0x10ec0274:
6662 	case 0x10ec0294:
6663 	case 0x10ec0225:
6664 	case 0x10ec0295:
6665 	case 0x10ec0299:
6666 		alc_update_coef_idx(codec, 0x4a, 0x8000, 1 << 15); /* Reset HP JD */
6667 		alc_update_coef_idx(codec, 0x4a, 0x8000, 0 << 15);
6668 		break;
6669 	case 0x10ec0230:
6670 	case 0x10ec0235:
6671 	case 0x10ec0236:
6672 	case 0x10ec0255:
6673 	case 0x10ec0256:
6674 	case 0x10ec0257:
6675 	case 0x19e58326:
6676 		alc_update_coef_idx(codec, 0x1b, 0x8000, 1 << 15); /* Reset HP JD */
6677 		alc_update_coef_idx(codec, 0x1b, 0x8000, 0 << 15);
6678 		break;
6679 	}
6680 }
6681 
6682 static void alc295_fixup_chromebook(struct hda_codec *codec,
6683 				    const struct hda_fixup *fix, int action)
6684 {
6685 	struct alc_spec *spec = codec->spec;
6686 
6687 	switch (action) {
6688 	case HDA_FIXUP_ACT_PRE_PROBE:
6689 		spec->ultra_low_power = true;
6690 		break;
6691 	case HDA_FIXUP_ACT_INIT:
6692 		alc_combo_jack_hp_jd_restart(codec);
6693 		break;
6694 	}
6695 }
6696 
6697 static void alc256_fixup_chromebook(struct hda_codec *codec,
6698 				    const struct hda_fixup *fix, int action)
6699 {
6700 	struct alc_spec *spec = codec->spec;
6701 
6702 	switch (action) {
6703 	case HDA_FIXUP_ACT_PRE_PROBE:
6704 		spec->gen.suppress_auto_mute = 1;
6705 		spec->gen.suppress_auto_mic = 1;
6706 		spec->en_3kpull_low = false;
6707 		break;
6708 	}
6709 }
6710 
6711 static void alc_fixup_disable_mic_vref(struct hda_codec *codec,
6712 				  const struct hda_fixup *fix, int action)
6713 {
6714 	if (action == HDA_FIXUP_ACT_PRE_PROBE)
6715 		snd_hda_codec_set_pin_target(codec, 0x19, PIN_VREFHIZ);
6716 }
6717 
6718 
6719 static void alc294_gx502_toggle_output(struct hda_codec *codec,
6720 					struct hda_jack_callback *cb)
6721 {
6722 	/* The Windows driver sets the codec up in a very different way where
6723 	 * it appears to leave 0x10 = 0x8a20 set. For Linux we need to toggle it
6724 	 */
6725 	if (snd_hda_jack_detect_state(codec, 0x21) == HDA_JACK_PRESENT)
6726 		alc_write_coef_idx(codec, 0x10, 0x8a20);
6727 	else
6728 		alc_write_coef_idx(codec, 0x10, 0x0a20);
6729 }
6730 
6731 static void alc294_fixup_gx502_hp(struct hda_codec *codec,
6732 					const struct hda_fixup *fix, int action)
6733 {
6734 	/* Pin 0x21: headphones/headset mic */
6735 	if (!is_jack_detectable(codec, 0x21))
6736 		return;
6737 
6738 	switch (action) {
6739 	case HDA_FIXUP_ACT_PRE_PROBE:
6740 		snd_hda_jack_detect_enable_callback(codec, 0x21,
6741 				alc294_gx502_toggle_output);
6742 		break;
6743 	case HDA_FIXUP_ACT_INIT:
6744 		/* Make sure to start in a correct state, i.e. if
6745 		 * headphones have been plugged in before powering up the system
6746 		 */
6747 		alc294_gx502_toggle_output(codec, NULL);
6748 		break;
6749 	}
6750 }
6751 
6752 static void alc294_gu502_toggle_output(struct hda_codec *codec,
6753 				       struct hda_jack_callback *cb)
6754 {
6755 	/* Windows sets 0x10 to 0x8420 for Node 0x20 which is
6756 	 * responsible from changes between speakers and headphones
6757 	 */
6758 	if (snd_hda_jack_detect_state(codec, 0x21) == HDA_JACK_PRESENT)
6759 		alc_write_coef_idx(codec, 0x10, 0x8420);
6760 	else
6761 		alc_write_coef_idx(codec, 0x10, 0x0a20);
6762 }
6763 
6764 static void alc294_fixup_gu502_hp(struct hda_codec *codec,
6765 				  const struct hda_fixup *fix, int action)
6766 {
6767 	if (!is_jack_detectable(codec, 0x21))
6768 		return;
6769 
6770 	switch (action) {
6771 	case HDA_FIXUP_ACT_PRE_PROBE:
6772 		snd_hda_jack_detect_enable_callback(codec, 0x21,
6773 				alc294_gu502_toggle_output);
6774 		break;
6775 	case HDA_FIXUP_ACT_INIT:
6776 		alc294_gu502_toggle_output(codec, NULL);
6777 		break;
6778 	}
6779 }
6780 
6781 static void  alc285_fixup_hp_gpio_amp_init(struct hda_codec *codec,
6782 			      const struct hda_fixup *fix, int action)
6783 {
6784 	if (action != HDA_FIXUP_ACT_INIT)
6785 		return;
6786 
6787 	msleep(100);
6788 	alc_write_coef_idx(codec, 0x65, 0x0);
6789 }
6790 
6791 static void alc274_fixup_hp_headset_mic(struct hda_codec *codec,
6792 				    const struct hda_fixup *fix, int action)
6793 {
6794 	switch (action) {
6795 	case HDA_FIXUP_ACT_INIT:
6796 		alc_combo_jack_hp_jd_restart(codec);
6797 		break;
6798 	}
6799 }
6800 
6801 static void alc_fixup_no_int_mic(struct hda_codec *codec,
6802 				    const struct hda_fixup *fix, int action)
6803 {
6804 	struct alc_spec *spec = codec->spec;
6805 
6806 	switch (action) {
6807 	case HDA_FIXUP_ACT_PRE_PROBE:
6808 		/* Mic RING SLEEVE swap for combo jack */
6809 		alc_update_coef_idx(codec, 0x45, 0xf<<12 | 1<<10, 5<<12);
6810 		spec->no_internal_mic_pin = true;
6811 		break;
6812 	case HDA_FIXUP_ACT_INIT:
6813 		alc_combo_jack_hp_jd_restart(codec);
6814 		break;
6815 	}
6816 }
6817 
6818 /* GPIO1 = amplifier on/off
6819  * GPIO3 = mic mute LED
6820  */
6821 static void alc285_fixup_hp_spectre_x360_eb1(struct hda_codec *codec,
6822 					  const struct hda_fixup *fix, int action)
6823 {
6824 	static const hda_nid_t conn[] = { 0x02 };
6825 
6826 	struct alc_spec *spec = codec->spec;
6827 	static const struct hda_pintbl pincfgs[] = {
6828 		{ 0x14, 0x90170110 },  /* front/high speakers */
6829 		{ 0x17, 0x90170130 },  /* back/bass speakers */
6830 		{ }
6831 	};
6832 
6833 	//enable micmute led
6834 	alc_fixup_hp_gpio_led(codec, action, 0x00, 0x04);
6835 
6836 	switch (action) {
6837 	case HDA_FIXUP_ACT_PRE_PROBE:
6838 		spec->micmute_led_polarity = 1;
6839 		/* needed for amp of back speakers */
6840 		spec->gpio_mask |= 0x01;
6841 		spec->gpio_dir |= 0x01;
6842 		snd_hda_apply_pincfgs(codec, pincfgs);
6843 		/* share DAC to have unified volume control */
6844 		snd_hda_override_conn_list(codec, 0x14, ARRAY_SIZE(conn), conn);
6845 		snd_hda_override_conn_list(codec, 0x17, ARRAY_SIZE(conn), conn);
6846 		break;
6847 	case HDA_FIXUP_ACT_INIT:
6848 		/* need to toggle GPIO to enable the amp of back speakers */
6849 		alc_update_gpio_data(codec, 0x01, true);
6850 		msleep(100);
6851 		alc_update_gpio_data(codec, 0x01, false);
6852 		break;
6853 	}
6854 }
6855 
6856 static void alc285_fixup_hp_spectre_x360(struct hda_codec *codec,
6857 					  const struct hda_fixup *fix, int action)
6858 {
6859 	static const hda_nid_t conn[] = { 0x02 };
6860 	static const struct hda_pintbl pincfgs[] = {
6861 		{ 0x14, 0x90170110 },  /* rear speaker */
6862 		{ }
6863 	};
6864 
6865 	switch (action) {
6866 	case HDA_FIXUP_ACT_PRE_PROBE:
6867 		snd_hda_apply_pincfgs(codec, pincfgs);
6868 		/* force front speaker to DAC1 */
6869 		snd_hda_override_conn_list(codec, 0x17, ARRAY_SIZE(conn), conn);
6870 		break;
6871 	}
6872 }
6873 
6874 static void alc285_fixup_hp_envy_x360(struct hda_codec *codec,
6875 				      const struct hda_fixup *fix,
6876 				      int action)
6877 {
6878 	static const struct coef_fw coefs[] = {
6879 		WRITE_COEF(0x08, 0x6a0c), WRITE_COEF(0x0d, 0xa023),
6880 		WRITE_COEF(0x10, 0x0320), WRITE_COEF(0x1a, 0x8c03),
6881 		WRITE_COEF(0x25, 0x1800), WRITE_COEF(0x26, 0x003a),
6882 		WRITE_COEF(0x28, 0x1dfe), WRITE_COEF(0x29, 0xb014),
6883 		WRITE_COEF(0x2b, 0x1dfe), WRITE_COEF(0x37, 0xfe15),
6884 		WRITE_COEF(0x38, 0x7909), WRITE_COEF(0x45, 0xd489),
6885 		WRITE_COEF(0x46, 0x00f4), WRITE_COEF(0x4a, 0x21e0),
6886 		WRITE_COEF(0x66, 0x03f0), WRITE_COEF(0x67, 0x1000),
6887 		WRITE_COEF(0x6e, 0x1005), { }
6888 	};
6889 
6890 	static const struct hda_pintbl pincfgs[] = {
6891 		{ 0x12, 0xb7a60130 },  /* Internal microphone*/
6892 		{ 0x14, 0x90170150 },  /* B&O soundbar speakers */
6893 		{ 0x17, 0x90170153 },  /* Side speakers */
6894 		{ 0x19, 0x03a11040 },  /* Headset microphone */
6895 		{ }
6896 	};
6897 
6898 	switch (action) {
6899 	case HDA_FIXUP_ACT_PRE_PROBE:
6900 		snd_hda_apply_pincfgs(codec, pincfgs);
6901 
6902 		/* Fixes volume control problem for side speakers */
6903 		alc295_fixup_disable_dac3(codec, fix, action);
6904 
6905 		/* Fixes no sound from headset speaker */
6906 		snd_hda_codec_amp_stereo(codec, 0x21, HDA_OUTPUT, 0, -1, 0);
6907 
6908 		/* Auto-enable headset mic when plugged */
6909 		snd_hda_jack_set_gating_jack(codec, 0x19, 0x21);
6910 
6911 		/* Headset mic volume enhancement */
6912 		snd_hda_codec_set_pin_target(codec, 0x19, PIN_VREF50);
6913 		break;
6914 	case HDA_FIXUP_ACT_INIT:
6915 		alc_process_coef_fw(codec, coefs);
6916 		break;
6917 	case HDA_FIXUP_ACT_BUILD:
6918 		rename_ctl(codec, "Bass Speaker Playback Volume",
6919 			   "B&O-Tuned Playback Volume");
6920 		rename_ctl(codec, "Front Playback Switch",
6921 			   "B&O Soundbar Playback Switch");
6922 		rename_ctl(codec, "Bass Speaker Playback Switch",
6923 			   "Side Speaker Playback Switch");
6924 		break;
6925 	}
6926 }
6927 
6928 /* for hda_fixup_thinkpad_acpi() */
6929 #include "thinkpad_helper.c"
6930 
6931 static void alc_fixup_thinkpad_acpi(struct hda_codec *codec,
6932 				    const struct hda_fixup *fix, int action)
6933 {
6934 	alc_fixup_no_shutup(codec, fix, action); /* reduce click noise */
6935 	hda_fixup_thinkpad_acpi(codec, fix, action);
6936 }
6937 
6938 /* Fixup for Lenovo Legion 15IMHg05 speaker output on headset removal. */
6939 static void alc287_fixup_legion_15imhg05_speakers(struct hda_codec *codec,
6940 						  const struct hda_fixup *fix,
6941 						  int action)
6942 {
6943 	struct alc_spec *spec = codec->spec;
6944 
6945 	switch (action) {
6946 	case HDA_FIXUP_ACT_PRE_PROBE:
6947 		spec->gen.suppress_auto_mute = 1;
6948 		break;
6949 	}
6950 }
6951 
6952 static void comp_acpi_device_notify(acpi_handle handle, u32 event, void *data)
6953 {
6954 	struct hda_codec *cdc = data;
6955 	struct alc_spec *spec = cdc->spec;
6956 
6957 	codec_info(cdc, "ACPI Notification %d\n", event);
6958 
6959 	hda_component_acpi_device_notify(&spec->comps, handle, event, data);
6960 }
6961 
6962 static int comp_bind(struct device *dev)
6963 {
6964 	struct hda_codec *cdc = dev_to_hda_codec(dev);
6965 	struct alc_spec *spec = cdc->spec;
6966 	int ret;
6967 
6968 	ret = hda_component_manager_bind(cdc, &spec->comps);
6969 	if (ret)
6970 		return ret;
6971 
6972 	return hda_component_manager_bind_acpi_notifications(cdc,
6973 							     &spec->comps,
6974 							     comp_acpi_device_notify, cdc);
6975 }
6976 
6977 static void comp_unbind(struct device *dev)
6978 {
6979 	struct hda_codec *cdc = dev_to_hda_codec(dev);
6980 	struct alc_spec *spec = cdc->spec;
6981 
6982 	hda_component_manager_unbind_acpi_notifications(cdc, &spec->comps, comp_acpi_device_notify);
6983 	hda_component_manager_unbind(cdc, &spec->comps);
6984 }
6985 
6986 static const struct component_master_ops comp_master_ops = {
6987 	.bind = comp_bind,
6988 	.unbind = comp_unbind,
6989 };
6990 
6991 static void comp_generic_playback_hook(struct hda_pcm_stream *hinfo, struct hda_codec *cdc,
6992 				       struct snd_pcm_substream *sub, int action)
6993 {
6994 	struct alc_spec *spec = cdc->spec;
6995 
6996 	hda_component_manager_playback_hook(&spec->comps, action);
6997 }
6998 
6999 static void comp_generic_fixup(struct hda_codec *cdc, int action, const char *bus,
7000 			       const char *hid, const char *match_str, int count)
7001 {
7002 	struct alc_spec *spec = cdc->spec;
7003 	int ret;
7004 
7005 	switch (action) {
7006 	case HDA_FIXUP_ACT_PRE_PROBE:
7007 		ret = hda_component_manager_init(cdc, &spec->comps, count, bus, hid,
7008 						 match_str, &comp_master_ops);
7009 		if (ret)
7010 			return;
7011 
7012 		spec->gen.pcm_playback_hook = comp_generic_playback_hook;
7013 		break;
7014 	case HDA_FIXUP_ACT_FREE:
7015 		hda_component_manager_free(&spec->comps, &comp_master_ops);
7016 		break;
7017 	}
7018 }
7019 
7020 static void find_cirrus_companion_amps(struct hda_codec *cdc)
7021 {
7022 	struct device *dev = hda_codec_dev(cdc);
7023 	struct acpi_device *adev;
7024 	struct fwnode_handle *fwnode __free(fwnode_handle) = NULL;
7025 	const char *bus = NULL;
7026 	static const struct {
7027 		const char *hid;
7028 		const char *name;
7029 	} acpi_ids[] = {{ "CSC3554", "cs35l54-hda" },
7030 			{ "CSC3556", "cs35l56-hda" },
7031 			{ "CSC3557", "cs35l57-hda" }};
7032 	char *match;
7033 	int i, count = 0, count_devindex = 0;
7034 
7035 	for (i = 0; i < ARRAY_SIZE(acpi_ids); ++i) {
7036 		adev = acpi_dev_get_first_match_dev(acpi_ids[i].hid, NULL, -1);
7037 		if (adev)
7038 			break;
7039 	}
7040 	if (!adev) {
7041 		codec_dbg(cdc, "Did not find ACPI entry for a Cirrus Amp\n");
7042 		return;
7043 	}
7044 
7045 	count = i2c_acpi_client_count(adev);
7046 	if (count > 0) {
7047 		bus = "i2c";
7048 	} else {
7049 		count = acpi_spi_count_resources(adev);
7050 		if (count > 0)
7051 			bus = "spi";
7052 	}
7053 
7054 	fwnode = fwnode_handle_get(acpi_fwnode_handle(adev));
7055 	acpi_dev_put(adev);
7056 
7057 	if (!bus) {
7058 		codec_err(cdc, "Did not find any buses for %s\n", acpi_ids[i].hid);
7059 		return;
7060 	}
7061 
7062 	if (!fwnode) {
7063 		codec_err(cdc, "Could not get fwnode for %s\n", acpi_ids[i].hid);
7064 		return;
7065 	}
7066 
7067 	/*
7068 	 * When available the cirrus,dev-index property is an accurate
7069 	 * count of the amps in a system and is used in preference to
7070 	 * the count of bus devices that can contain additional address
7071 	 * alias entries.
7072 	 */
7073 	count_devindex = fwnode_property_count_u32(fwnode, "cirrus,dev-index");
7074 	if (count_devindex > 0)
7075 		count = count_devindex;
7076 
7077 	match = devm_kasprintf(dev, GFP_KERNEL, "-%%s:00-%s.%%d", acpi_ids[i].name);
7078 	if (!match)
7079 		return;
7080 	codec_info(cdc, "Found %d %s on %s (%s)\n", count, acpi_ids[i].hid, bus, match);
7081 	comp_generic_fixup(cdc, HDA_FIXUP_ACT_PRE_PROBE, bus, acpi_ids[i].hid, match, count);
7082 }
7083 
7084 static void cs35l41_fixup_i2c_two(struct hda_codec *cdc, const struct hda_fixup *fix, int action)
7085 {
7086 	comp_generic_fixup(cdc, action, "i2c", "CSC3551", "-%s:00-cs35l41-hda.%d", 2);
7087 }
7088 
7089 static void cs35l41_fixup_i2c_four(struct hda_codec *cdc, const struct hda_fixup *fix, int action)
7090 {
7091 	comp_generic_fixup(cdc, action, "i2c", "CSC3551", "-%s:00-cs35l41-hda.%d", 4);
7092 }
7093 
7094 static void cs35l41_fixup_spi_two(struct hda_codec *codec, const struct hda_fixup *fix, int action)
7095 {
7096 	comp_generic_fixup(codec, action, "spi", "CSC3551", "-%s:00-cs35l41-hda.%d", 2);
7097 }
7098 
7099 static void cs35l41_fixup_spi_four(struct hda_codec *codec, const struct hda_fixup *fix, int action)
7100 {
7101 	comp_generic_fixup(codec, action, "spi", "CSC3551", "-%s:00-cs35l41-hda.%d", 4);
7102 }
7103 
7104 static void alc287_fixup_legion_16achg6_speakers(struct hda_codec *cdc, const struct hda_fixup *fix,
7105 						 int action)
7106 {
7107 	comp_generic_fixup(cdc, action, "i2c", "CLSA0100", "-%s:00-cs35l41-hda.%d", 2);
7108 }
7109 
7110 static void alc287_fixup_legion_16ithg6_speakers(struct hda_codec *cdc, const struct hda_fixup *fix,
7111 						 int action)
7112 {
7113 	comp_generic_fixup(cdc, action, "i2c", "CLSA0101", "-%s:00-cs35l41-hda.%d", 2);
7114 }
7115 
7116 static void alc285_fixup_asus_ga403u(struct hda_codec *cdc, const struct hda_fixup *fix, int action)
7117 {
7118 	/*
7119 	 * The same SSID has been re-used in different hardware, they have
7120 	 * different codecs and the newer GA403U has a ALC285.
7121 	 */
7122 	if (cdc->core.vendor_id != 0x10ec0285)
7123 		alc_fixup_inv_dmic(cdc, fix, action);
7124 }
7125 
7126 static void tas2781_fixup_i2c(struct hda_codec *cdc,
7127 	const struct hda_fixup *fix, int action)
7128 {
7129 	comp_generic_fixup(cdc, action, "i2c", "TIAS2781", "-%s:00", 1);
7130 }
7131 
7132 static void yoga7_14arb7_fixup_i2c(struct hda_codec *cdc,
7133 	const struct hda_fixup *fix, int action)
7134 {
7135 	comp_generic_fixup(cdc, action, "i2c", "INT8866", "-%s:00", 1);
7136 }
7137 
7138 static void alc256_fixup_acer_sfg16_micmute_led(struct hda_codec *codec,
7139 	const struct hda_fixup *fix, int action)
7140 {
7141 	alc_fixup_hp_gpio_led(codec, action, 0, 0x04);
7142 }
7143 
7144 
7145 /* for alc295_fixup_hp_top_speakers */
7146 #include "hp_x360_helper.c"
7147 
7148 /* for alc285_fixup_ideapad_s740_coef() */
7149 #include "ideapad_s740_helper.c"
7150 
7151 static const struct coef_fw alc256_fixup_set_coef_defaults_coefs[] = {
7152 	WRITE_COEF(0x10, 0x0020), WRITE_COEF(0x24, 0x0000),
7153 	WRITE_COEF(0x26, 0x0000), WRITE_COEF(0x29, 0x3000),
7154 	WRITE_COEF(0x37, 0xfe05), WRITE_COEF(0x45, 0x5089),
7155 	{}
7156 };
7157 
7158 static void alc256_fixup_set_coef_defaults(struct hda_codec *codec,
7159 					   const struct hda_fixup *fix,
7160 					   int action)
7161 {
7162 	/*
7163 	 * A certain other OS sets these coeffs to different values. On at least
7164 	 * one TongFang barebone these settings might survive even a cold
7165 	 * reboot. So to restore a clean slate the values are explicitly reset
7166 	 * to default here. Without this, the external microphone is always in a
7167 	 * plugged-in state, while the internal microphone is always in an
7168 	 * unplugged state, breaking the ability to use the internal microphone.
7169 	 */
7170 	alc_process_coef_fw(codec, alc256_fixup_set_coef_defaults_coefs);
7171 }
7172 
7173 static const struct coef_fw alc233_fixup_no_audio_jack_coefs[] = {
7174 	WRITE_COEF(0x1a, 0x9003), WRITE_COEF(0x1b, 0x0e2b), WRITE_COEF(0x37, 0xfe06),
7175 	WRITE_COEF(0x38, 0x4981), WRITE_COEF(0x45, 0xd489), WRITE_COEF(0x46, 0x0074),
7176 	WRITE_COEF(0x49, 0x0149),
7177 	{}
7178 };
7179 
7180 static void alc233_fixup_no_audio_jack(struct hda_codec *codec,
7181 				       const struct hda_fixup *fix,
7182 				       int action)
7183 {
7184 	/*
7185 	 * The audio jack input and output is not detected on the ASRock NUC Box
7186 	 * 1100 series when cold booting without this fix. Warm rebooting from a
7187 	 * certain other OS makes the audio functional, as COEF settings are
7188 	 * preserved in this case. This fix sets these altered COEF values as
7189 	 * the default.
7190 	 */
7191 	alc_process_coef_fw(codec, alc233_fixup_no_audio_jack_coefs);
7192 }
7193 
7194 static void alc256_fixup_mic_no_presence_and_resume(struct hda_codec *codec,
7195 						    const struct hda_fixup *fix,
7196 						    int action)
7197 {
7198 	/*
7199 	 * The Clevo NJ51CU comes either with the ALC293 or the ALC256 codec,
7200 	 * but uses the 0x8686 subproduct id in both cases. The ALC256 codec
7201 	 * needs an additional quirk for sound working after suspend and resume.
7202 	 */
7203 	if (codec->core.vendor_id == 0x10ec0256) {
7204 		alc_update_coef_idx(codec, 0x10, 1<<9, 0);
7205 		snd_hda_codec_set_pincfg(codec, 0x19, 0x04a11120);
7206 	} else {
7207 		snd_hda_codec_set_pincfg(codec, 0x1a, 0x04a1113c);
7208 	}
7209 }
7210 
7211 static void alc256_decrease_headphone_amp_val(struct hda_codec *codec,
7212 					      const struct hda_fixup *fix, int action)
7213 {
7214 	u32 caps;
7215 	u8 nsteps, offs;
7216 
7217 	if (action != HDA_FIXUP_ACT_PRE_PROBE)
7218 		return;
7219 
7220 	caps = query_amp_caps(codec, 0x3, HDA_OUTPUT);
7221 	nsteps = ((caps & AC_AMPCAP_NUM_STEPS) >> AC_AMPCAP_NUM_STEPS_SHIFT) - 10;
7222 	offs = ((caps & AC_AMPCAP_OFFSET) >> AC_AMPCAP_OFFSET_SHIFT) - 10;
7223 	caps &= ~AC_AMPCAP_NUM_STEPS & ~AC_AMPCAP_OFFSET;
7224 	caps |= (nsteps << AC_AMPCAP_NUM_STEPS_SHIFT) | (offs << AC_AMPCAP_OFFSET_SHIFT);
7225 
7226 	if (snd_hda_override_amp_caps(codec, 0x3, HDA_OUTPUT, caps))
7227 		codec_warn(codec, "failed to override amp caps for NID 0x3\n");
7228 }
7229 
7230 static void alc_fixup_dell4_mic_no_presence_quiet(struct hda_codec *codec,
7231 						  const struct hda_fixup *fix,
7232 						  int action)
7233 {
7234 	struct alc_spec *spec = codec->spec;
7235 	struct hda_input_mux *imux = &spec->gen.input_mux;
7236 	int i;
7237 
7238 	alc269_fixup_limit_int_mic_boost(codec, fix, action);
7239 
7240 	switch (action) {
7241 	case HDA_FIXUP_ACT_PRE_PROBE:
7242 		/**
7243 		 * Set the vref of pin 0x19 (Headset Mic) and pin 0x1b (Headphone Mic)
7244 		 * to Hi-Z to avoid pop noises at startup and when plugging and
7245 		 * unplugging headphones.
7246 		 */
7247 		snd_hda_codec_set_pin_target(codec, 0x19, PIN_VREFHIZ);
7248 		snd_hda_codec_set_pin_target(codec, 0x1b, PIN_VREFHIZ);
7249 		break;
7250 	case HDA_FIXUP_ACT_PROBE:
7251 		/**
7252 		 * Make the internal mic (0x12) the default input source to
7253 		 * prevent pop noises on cold boot.
7254 		 */
7255 		for (i = 0; i < imux->num_items; i++) {
7256 			if (spec->gen.imux_pins[i] == 0x12) {
7257 				spec->gen.cur_mux[0] = i;
7258 				break;
7259 			}
7260 		}
7261 		break;
7262 	}
7263 }
7264 
7265 static void alc287_fixup_yoga9_14iap7_bass_spk_pin(struct hda_codec *codec,
7266 					  const struct hda_fixup *fix, int action)
7267 {
7268 	/*
7269 	 * The Pin Complex 0x17 for the bass speakers is wrongly reported as
7270 	 * unconnected.
7271 	 */
7272 	static const struct hda_pintbl pincfgs[] = {
7273 		{ 0x17, 0x90170121 },
7274 		{ }
7275 	};
7276 	/*
7277 	 * Avoid DAC 0x06 and 0x08, as they have no volume controls.
7278 	 * DAC 0x02 and 0x03 would be fine.
7279 	 */
7280 	static const hda_nid_t conn[] = { 0x02, 0x03 };
7281 	/*
7282 	 * Prefer both speakerbar (0x14) and bass speakers (0x17) connected to DAC 0x02.
7283 	 * Headphones (0x21) are connected to DAC 0x03.
7284 	 */
7285 	static const hda_nid_t preferred_pairs[] = {
7286 		0x14, 0x02,
7287 		0x17, 0x02,
7288 		0x21, 0x03,
7289 		0
7290 	};
7291 	struct alc_spec *spec = codec->spec;
7292 
7293 	switch (action) {
7294 	case HDA_FIXUP_ACT_PRE_PROBE:
7295 		snd_hda_apply_pincfgs(codec, pincfgs);
7296 		snd_hda_override_conn_list(codec, 0x17, ARRAY_SIZE(conn), conn);
7297 		spec->gen.preferred_dacs = preferred_pairs;
7298 		break;
7299 	}
7300 }
7301 
7302 static void alc295_fixup_dell_inspiron_top_speakers(struct hda_codec *codec,
7303 					  const struct hda_fixup *fix, int action)
7304 {
7305 	static const struct hda_pintbl pincfgs[] = {
7306 		{ 0x14, 0x90170151 },
7307 		{ 0x17, 0x90170150 },
7308 		{ }
7309 	};
7310 	static const hda_nid_t conn[] = { 0x02, 0x03 };
7311 	static const hda_nid_t preferred_pairs[] = {
7312 		0x14, 0x02,
7313 		0x17, 0x03,
7314 		0x21, 0x02,
7315 		0
7316 	};
7317 	struct alc_spec *spec = codec->spec;
7318 
7319 	alc_fixup_no_shutup(codec, fix, action);
7320 
7321 	switch (action) {
7322 	case HDA_FIXUP_ACT_PRE_PROBE:
7323 		snd_hda_apply_pincfgs(codec, pincfgs);
7324 		snd_hda_override_conn_list(codec, 0x17, ARRAY_SIZE(conn), conn);
7325 		spec->gen.preferred_dacs = preferred_pairs;
7326 		break;
7327 	}
7328 }
7329 
7330 /* Forcibly assign NID 0x03 to HP while NID 0x02 to SPK */
7331 static void alc287_fixup_bind_dacs(struct hda_codec *codec,
7332 				    const struct hda_fixup *fix, int action)
7333 {
7334 	struct alc_spec *spec = codec->spec;
7335 	static const hda_nid_t conn[] = { 0x02, 0x03 }; /* exclude 0x06 */
7336 	static const hda_nid_t preferred_pairs[] = {
7337 		0x17, 0x02, 0x21, 0x03, 0
7338 	};
7339 
7340 	if (action != HDA_FIXUP_ACT_PRE_PROBE)
7341 		return;
7342 
7343 	snd_hda_override_conn_list(codec, 0x17, ARRAY_SIZE(conn), conn);
7344 	spec->gen.preferred_dacs = preferred_pairs;
7345 	spec->gen.auto_mute_via_amp = 1;
7346 	if (spec->gen.autocfg.speaker_pins[0] != 0x14) {
7347 		snd_hda_codec_write_cache(codec, 0x14, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
7348 					0x0); /* Make sure 0x14 was disable */
7349 	}
7350 }
7351 /* Fix none verb table of Headset Mic pin */
7352 static void alc_fixup_headset_mic(struct hda_codec *codec,
7353 				   const struct hda_fixup *fix, int action)
7354 {
7355 	struct alc_spec *spec = codec->spec;
7356 	static const struct hda_pintbl pincfgs[] = {
7357 		{ 0x19, 0x03a1103c },
7358 		{ }
7359 	};
7360 
7361 	switch (action) {
7362 	case HDA_FIXUP_ACT_PRE_PROBE:
7363 		snd_hda_apply_pincfgs(codec, pincfgs);
7364 		alc_update_coef_idx(codec, 0x45, 0xf<<12 | 1<<10, 5<<12);
7365 		spec->parse_flags |= HDA_PINCFG_HEADSET_MIC;
7366 		break;
7367 	}
7368 }
7369 
7370 static void alc245_fixup_hp_spectre_x360_eu0xxx(struct hda_codec *codec,
7371 					  const struct hda_fixup *fix, int action)
7372 {
7373 	/*
7374 	 * The Pin Complex 0x14 for the treble speakers is wrongly reported as
7375 	 * unconnected.
7376 	 * The Pin Complex 0x17 for the bass speakers has the lowest association
7377 	 * and sequence values so shift it up a bit to squeeze 0x14 in.
7378 	 */
7379 	static const struct hda_pintbl pincfgs[] = {
7380 		{ 0x14, 0x90170110 }, // top/treble
7381 		{ 0x17, 0x90170111 }, // bottom/bass
7382 		{ }
7383 	};
7384 
7385 	/*
7386 	 * Force DAC 0x02 for the bass speakers 0x17.
7387 	 */
7388 	static const hda_nid_t conn[] = { 0x02 };
7389 
7390 	switch (action) {
7391 	case HDA_FIXUP_ACT_PRE_PROBE:
7392 		snd_hda_apply_pincfgs(codec, pincfgs);
7393 		snd_hda_override_conn_list(codec, 0x17, ARRAY_SIZE(conn), conn);
7394 		break;
7395 	}
7396 
7397 	cs35l41_fixup_i2c_two(codec, fix, action);
7398 	alc245_fixup_hp_mute_led_coefbit(codec, fix, action);
7399 	alc245_fixup_hp_gpio_led(codec, fix, action);
7400 }
7401 
7402 /* some changes for Spectre x360 16, 2024 model */
7403 static void alc245_fixup_hp_spectre_x360_16_aa0xxx(struct hda_codec *codec,
7404 					  const struct hda_fixup *fix, int action)
7405 {
7406 	/*
7407 	 * The Pin Complex 0x14 for the treble speakers is wrongly reported as
7408 	 * unconnected.
7409 	 * The Pin Complex 0x17 for the bass speakers has the lowest association
7410 	 * and sequence values so shift it up a bit to squeeze 0x14 in.
7411 	 */
7412 	struct alc_spec *spec = codec->spec;
7413 	static const struct hda_pintbl pincfgs[] = {
7414 		{ 0x14, 0x90170110 }, // top/treble
7415 		{ 0x17, 0x90170111 }, // bottom/bass
7416 		{ }
7417 	};
7418 
7419 	/*
7420 	 * Force DAC 0x02 for the bass speakers 0x17.
7421 	 */
7422 	static const hda_nid_t conn[] = { 0x02 };
7423 
7424 	switch (action) {
7425 	case HDA_FIXUP_ACT_PRE_PROBE:
7426 		/* needed for amp of back speakers */
7427 		spec->gpio_mask |= 0x01;
7428 		spec->gpio_dir |= 0x01;
7429 		snd_hda_apply_pincfgs(codec, pincfgs);
7430 		snd_hda_override_conn_list(codec, 0x17, ARRAY_SIZE(conn), conn);
7431 		break;
7432 	case HDA_FIXUP_ACT_INIT:
7433 		/* need to toggle GPIO to enable the amp of back speakers */
7434 		alc_update_gpio_data(codec, 0x01, true);
7435 		msleep(100);
7436 		alc_update_gpio_data(codec, 0x01, false);
7437 		break;
7438 	}
7439 
7440 	cs35l41_fixup_i2c_two(codec, fix, action);
7441 	alc245_fixup_hp_mute_led_coefbit(codec, fix, action);
7442 	alc245_fixup_hp_gpio_led(codec, fix, action);
7443 }
7444 
7445 /*
7446  * ALC287 PCM hooks
7447  */
7448 static void alc287_alc1318_playback_pcm_hook(struct hda_pcm_stream *hinfo,
7449 				   struct hda_codec *codec,
7450 				   struct snd_pcm_substream *substream,
7451 				   int action)
7452 {
7453 	alc_write_coef_idx(codec, 0x10, 0x8806); /* Change MLK to GPIO3 */
7454 	switch (action) {
7455 	case HDA_GEN_PCM_ACT_OPEN:
7456 		alc_write_coefex_idx(codec, 0x5a, 0x00, 0x954f); /* write gpio3 to high */
7457 		break;
7458 	case HDA_GEN_PCM_ACT_CLOSE:
7459 		alc_write_coefex_idx(codec, 0x5a, 0x00, 0x554f); /* write gpio3 as default value */
7460 		break;
7461 	}
7462 }
7463 
7464 static void alc287_s4_power_gpio3_default(struct hda_codec *codec)
7465 {
7466 	if (is_s4_suspend(codec)) {
7467 		alc_write_coef_idx(codec, 0x10, 0x8806); /* Change MLK to GPIO3 */
7468 		alc_write_coefex_idx(codec, 0x5a, 0x00, 0x554f); /* write gpio3 as default value */
7469 	}
7470 }
7471 
7472 static void alc287_fixup_lenovo_thinkpad_with_alc1318(struct hda_codec *codec,
7473 			       const struct hda_fixup *fix, int action)
7474 {
7475 	struct alc_spec *spec = codec->spec;
7476 
7477 	if (action != HDA_FIXUP_ACT_PRE_PROBE)
7478 		return;
7479 	spec->power_hook = alc287_s4_power_gpio3_default;
7480 	spec->gen.pcm_playback_hook = alc287_alc1318_playback_pcm_hook;
7481 }
7482 
7483 
7484 enum {
7485 	ALC269_FIXUP_GPIO2,
7486 	ALC269_FIXUP_SONY_VAIO,
7487 	ALC275_FIXUP_SONY_VAIO_GPIO2,
7488 	ALC269_FIXUP_DELL_M101Z,
7489 	ALC269_FIXUP_SKU_IGNORE,
7490 	ALC269_FIXUP_ASUS_G73JW,
7491 	ALC269_FIXUP_ASUS_N7601ZM_PINS,
7492 	ALC269_FIXUP_ASUS_N7601ZM,
7493 	ALC269_FIXUP_LENOVO_EAPD,
7494 	ALC275_FIXUP_SONY_HWEQ,
7495 	ALC275_FIXUP_SONY_DISABLE_AAMIX,
7496 	ALC271_FIXUP_DMIC,
7497 	ALC269_FIXUP_PCM_44K,
7498 	ALC269_FIXUP_STEREO_DMIC,
7499 	ALC269_FIXUP_HEADSET_MIC,
7500 	ALC269_FIXUP_QUANTA_MUTE,
7501 	ALC269_FIXUP_LIFEBOOK,
7502 	ALC269_FIXUP_LIFEBOOK_EXTMIC,
7503 	ALC269_FIXUP_LIFEBOOK_HP_PIN,
7504 	ALC269_FIXUP_LIFEBOOK_NO_HP_TO_LINEOUT,
7505 	ALC255_FIXUP_LIFEBOOK_U7x7_HEADSET_MIC,
7506 	ALC269_FIXUP_AMIC,
7507 	ALC269_FIXUP_DMIC,
7508 	ALC269VB_FIXUP_AMIC,
7509 	ALC269VB_FIXUP_DMIC,
7510 	ALC269_FIXUP_HP_MUTE_LED,
7511 	ALC269_FIXUP_HP_MUTE_LED_MIC1,
7512 	ALC269_FIXUP_HP_MUTE_LED_MIC2,
7513 	ALC269_FIXUP_HP_MUTE_LED_MIC3,
7514 	ALC269_FIXUP_HP_GPIO_LED,
7515 	ALC269_FIXUP_HP_GPIO_MIC1_LED,
7516 	ALC269_FIXUP_HP_LINE1_MIC1_LED,
7517 	ALC269_FIXUP_INV_DMIC,
7518 	ALC269_FIXUP_LENOVO_DOCK,
7519 	ALC269_FIXUP_LENOVO_DOCK_LIMIT_BOOST,
7520 	ALC269_FIXUP_NO_SHUTUP,
7521 	ALC286_FIXUP_SONY_MIC_NO_PRESENCE,
7522 	ALC269_FIXUP_PINCFG_NO_HP_TO_LINEOUT,
7523 	ALC269_FIXUP_DELL1_MIC_NO_PRESENCE,
7524 	ALC269_FIXUP_DELL1_LIMIT_INT_MIC_BOOST,
7525 	ALC269_FIXUP_DELL2_MIC_NO_PRESENCE,
7526 	ALC269_FIXUP_DELL3_MIC_NO_PRESENCE,
7527 	ALC269_FIXUP_DELL4_MIC_NO_PRESENCE,
7528 	ALC269_FIXUP_DELL4_MIC_NO_PRESENCE_QUIET,
7529 	ALC269_FIXUP_HEADSET_MODE,
7530 	ALC269_FIXUP_HEADSET_MODE_NO_HP_MIC,
7531 	ALC269_FIXUP_ASPIRE_HEADSET_MIC,
7532 	ALC269_FIXUP_ASUS_X101_FUNC,
7533 	ALC269_FIXUP_ASUS_X101_VERB,
7534 	ALC269_FIXUP_ASUS_X101,
7535 	ALC271_FIXUP_AMIC_MIC2,
7536 	ALC271_FIXUP_HP_GATE_MIC_JACK,
7537 	ALC271_FIXUP_HP_GATE_MIC_JACK_E1_572,
7538 	ALC269_FIXUP_ACER_AC700,
7539 	ALC269_FIXUP_LIMIT_INT_MIC_BOOST,
7540 	ALC269VB_FIXUP_ASUS_ZENBOOK,
7541 	ALC269VB_FIXUP_ASUS_ZENBOOK_UX31A,
7542 	ALC269VB_FIXUP_ASUS_MIC_NO_PRESENCE,
7543 	ALC269_FIXUP_LIMIT_INT_MIC_BOOST_MUTE_LED,
7544 	ALC269VB_FIXUP_ORDISSIMO_EVE2,
7545 	ALC283_FIXUP_CHROME_BOOK,
7546 	ALC283_FIXUP_SENSE_COMBO_JACK,
7547 	ALC282_FIXUP_ASUS_TX300,
7548 	ALC283_FIXUP_INT_MIC,
7549 	ALC290_FIXUP_MONO_SPEAKERS,
7550 	ALC290_FIXUP_MONO_SPEAKERS_HSJACK,
7551 	ALC290_FIXUP_SUBWOOFER,
7552 	ALC290_FIXUP_SUBWOOFER_HSJACK,
7553 	ALC269_FIXUP_THINKPAD_ACPI,
7554 	ALC269_FIXUP_DMIC_THINKPAD_ACPI,
7555 	ALC269VB_FIXUP_INFINIX_ZERO_BOOK_13,
7556 	ALC269VB_FIXUP_CHUWI_COREBOOK_XPRO,
7557 	ALC255_FIXUP_ACER_MIC_NO_PRESENCE,
7558 	ALC255_FIXUP_ASUS_MIC_NO_PRESENCE,
7559 	ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
7560 	ALC255_FIXUP_DELL1_LIMIT_INT_MIC_BOOST,
7561 	ALC255_FIXUP_DELL2_MIC_NO_PRESENCE,
7562 	ALC255_FIXUP_HEADSET_MODE,
7563 	ALC255_FIXUP_HEADSET_MODE_NO_HP_MIC,
7564 	ALC293_FIXUP_DELL1_MIC_NO_PRESENCE,
7565 	ALC292_FIXUP_TPT440_DOCK,
7566 	ALC292_FIXUP_TPT440,
7567 	ALC283_FIXUP_HEADSET_MIC,
7568 	ALC255_FIXUP_MIC_MUTE_LED,
7569 	ALC282_FIXUP_ASPIRE_V5_PINS,
7570 	ALC269VB_FIXUP_ASPIRE_E1_COEF,
7571 	ALC280_FIXUP_HP_GPIO4,
7572 	ALC286_FIXUP_HP_GPIO_LED,
7573 	ALC280_FIXUP_HP_GPIO2_MIC_HOTKEY,
7574 	ALC280_FIXUP_HP_DOCK_PINS,
7575 	ALC269_FIXUP_HP_DOCK_GPIO_MIC1_LED,
7576 	ALC280_FIXUP_HP_9480M,
7577 	ALC245_FIXUP_HP_X360_AMP,
7578 	ALC285_FIXUP_HP_SPECTRE_X360_EB1,
7579 	ALC285_FIXUP_HP_ENVY_X360,
7580 	ALC288_FIXUP_DELL_HEADSET_MODE,
7581 	ALC288_FIXUP_DELL1_MIC_NO_PRESENCE,
7582 	ALC288_FIXUP_DELL_XPS_13,
7583 	ALC288_FIXUP_DISABLE_AAMIX,
7584 	ALC292_FIXUP_DELL_E7X_AAMIX,
7585 	ALC292_FIXUP_DELL_E7X,
7586 	ALC292_FIXUP_DISABLE_AAMIX,
7587 	ALC293_FIXUP_DISABLE_AAMIX_MULTIJACK,
7588 	ALC298_FIXUP_ALIENWARE_MIC_NO_PRESENCE,
7589 	ALC298_FIXUP_DELL1_MIC_NO_PRESENCE,
7590 	ALC298_FIXUP_DELL_AIO_MIC_NO_PRESENCE,
7591 	ALC275_FIXUP_DELL_XPS,
7592 	ALC293_FIXUP_LENOVO_SPK_NOISE,
7593 	ALC233_FIXUP_LENOVO_LINE2_MIC_HOTKEY,
7594 	ALC255_FIXUP_DELL_SPK_NOISE,
7595 	ALC225_FIXUP_DISABLE_MIC_VREF,
7596 	ALC225_FIXUP_DELL1_MIC_NO_PRESENCE,
7597 	ALC295_FIXUP_DISABLE_DAC3,
7598 	ALC285_FIXUP_SPEAKER2_TO_DAC1,
7599 	ALC285_FIXUP_ASUS_SPEAKER2_TO_DAC1,
7600 	ALC285_FIXUP_ASUS_HEADSET_MIC,
7601 	ALC285_FIXUP_ASUS_SPI_REAR_SPEAKERS,
7602 	ALC285_FIXUP_ASUS_I2C_SPEAKER2_TO_DAC1,
7603 	ALC285_FIXUP_ASUS_I2C_HEADSET_MIC,
7604 	ALC280_FIXUP_HP_HEADSET_MIC,
7605 	ALC221_FIXUP_HP_FRONT_MIC,
7606 	ALC292_FIXUP_TPT460,
7607 	ALC298_FIXUP_SPK_VOLUME,
7608 	ALC298_FIXUP_LENOVO_SPK_VOLUME,
7609 	ALC256_FIXUP_DELL_INSPIRON_7559_SUBWOOFER,
7610 	ALC269_FIXUP_ATIV_BOOK_8,
7611 	ALC221_FIXUP_HP_288PRO_MIC_NO_PRESENCE,
7612 	ALC221_FIXUP_HP_MIC_NO_PRESENCE,
7613 	ALC256_FIXUP_ASUS_HEADSET_MODE,
7614 	ALC256_FIXUP_ASUS_MIC,
7615 	ALC256_FIXUP_ASUS_AIO_GPIO2,
7616 	ALC233_FIXUP_ASUS_MIC_NO_PRESENCE,
7617 	ALC233_FIXUP_EAPD_COEF_AND_MIC_NO_PRESENCE,
7618 	ALC233_FIXUP_LENOVO_MULTI_CODECS,
7619 	ALC233_FIXUP_ACER_HEADSET_MIC,
7620 	ALC294_FIXUP_LENOVO_MIC_LOCATION,
7621 	ALC225_FIXUP_DELL_WYSE_MIC_NO_PRESENCE,
7622 	ALC225_FIXUP_S3_POP_NOISE,
7623 	ALC700_FIXUP_INTEL_REFERENCE,
7624 	ALC274_FIXUP_DELL_BIND_DACS,
7625 	ALC274_FIXUP_DELL_AIO_LINEOUT_VERB,
7626 	ALC298_FIXUP_TPT470_DOCK_FIX,
7627 	ALC298_FIXUP_TPT470_DOCK,
7628 	ALC255_FIXUP_DUMMY_LINEOUT_VERB,
7629 	ALC255_FIXUP_DELL_HEADSET_MIC,
7630 	ALC256_FIXUP_HUAWEI_MACH_WX9_PINS,
7631 	ALC298_FIXUP_HUAWEI_MBX_STEREO,
7632 	ALC295_FIXUP_HP_X360,
7633 	ALC221_FIXUP_HP_HEADSET_MIC,
7634 	ALC285_FIXUP_LENOVO_HEADPHONE_NOISE,
7635 	ALC295_FIXUP_HP_AUTO_MUTE,
7636 	ALC286_FIXUP_ACER_AIO_MIC_NO_PRESENCE,
7637 	ALC294_FIXUP_ASUS_MIC,
7638 	ALC294_FIXUP_ASUS_HEADSET_MIC,
7639 	ALC294_FIXUP_ASUS_SPK,
7640 	ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE,
7641 	ALC285_FIXUP_LENOVO_PC_BEEP_IN_NOISE,
7642 	ALC255_FIXUP_ACER_HEADSET_MIC,
7643 	ALC295_FIXUP_CHROME_BOOK,
7644 	ALC225_FIXUP_HEADSET_JACK,
7645 	ALC225_FIXUP_DELL_WYSE_AIO_MIC_NO_PRESENCE,
7646 	ALC225_FIXUP_WYSE_AUTO_MUTE,
7647 	ALC225_FIXUP_WYSE_DISABLE_MIC_VREF,
7648 	ALC286_FIXUP_ACER_AIO_HEADSET_MIC,
7649 	ALC256_FIXUP_ASUS_HEADSET_MIC,
7650 	ALC256_FIXUP_ASUS_MIC_NO_PRESENCE,
7651 	ALC255_FIXUP_PREDATOR_SUBWOOFER,
7652 	ALC299_FIXUP_PREDATOR_SPK,
7653 	ALC256_FIXUP_MEDION_HEADSET_NO_PRESENCE,
7654 	ALC289_FIXUP_DELL_SPK1,
7655 	ALC289_FIXUP_DELL_SPK2,
7656 	ALC289_FIXUP_DUAL_SPK,
7657 	ALC289_FIXUP_RTK_AMP_DUAL_SPK,
7658 	ALC294_FIXUP_SPK2_TO_DAC1,
7659 	ALC294_FIXUP_ASUS_DUAL_SPK,
7660 	ALC285_FIXUP_THINKPAD_X1_GEN7,
7661 	ALC285_FIXUP_THINKPAD_HEADSET_JACK,
7662 	ALC294_FIXUP_ASUS_ALLY,
7663 	ALC294_FIXUP_ASUS_ALLY_X,
7664 	ALC294_FIXUP_ASUS_ALLY_PINS,
7665 	ALC294_FIXUP_ASUS_ALLY_VERBS,
7666 	ALC294_FIXUP_ASUS_ALLY_SPEAKER,
7667 	ALC294_FIXUP_ASUS_HPE,
7668 	ALC294_FIXUP_ASUS_COEF_1B,
7669 	ALC294_FIXUP_ASUS_GX502_HP,
7670 	ALC294_FIXUP_ASUS_GX502_PINS,
7671 	ALC294_FIXUP_ASUS_GX502_VERBS,
7672 	ALC294_FIXUP_ASUS_GU502_HP,
7673 	ALC294_FIXUP_ASUS_GU502_PINS,
7674 	ALC294_FIXUP_ASUS_GU502_VERBS,
7675 	ALC294_FIXUP_ASUS_G513_PINS,
7676 	ALC285_FIXUP_ASUS_G533Z_PINS,
7677 	ALC285_FIXUP_HP_GPIO_LED,
7678 	ALC285_FIXUP_HP_MUTE_LED,
7679 	ALC285_FIXUP_HP_SPECTRE_X360_MUTE_LED,
7680 	ALC236_FIXUP_HP_MUTE_LED_COEFBIT2,
7681 	ALC236_FIXUP_HP_GPIO_LED,
7682 	ALC236_FIXUP_HP_MUTE_LED,
7683 	ALC236_FIXUP_HP_MUTE_LED_MICMUTE_VREF,
7684 	ALC236_FIXUP_LENOVO_INV_DMIC,
7685 	ALC298_FIXUP_SAMSUNG_AMP,
7686 	ALC298_FIXUP_SAMSUNG_AMP_V2_2_AMPS,
7687 	ALC298_FIXUP_SAMSUNG_AMP_V2_4_AMPS,
7688 	ALC298_FIXUP_SAMSUNG_HEADPHONE_VERY_QUIET,
7689 	ALC256_FIXUP_SAMSUNG_HEADPHONE_VERY_QUIET,
7690 	ALC295_FIXUP_ASUS_MIC_NO_PRESENCE,
7691 	ALC269VC_FIXUP_ACER_VCOPPERBOX_PINS,
7692 	ALC269VC_FIXUP_ACER_HEADSET_MIC,
7693 	ALC269VC_FIXUP_ACER_MIC_NO_PRESENCE,
7694 	ALC289_FIXUP_ASUS_GA401,
7695 	ALC289_FIXUP_ASUS_GA502,
7696 	ALC256_FIXUP_ACER_MIC_NO_PRESENCE,
7697 	ALC285_FIXUP_HP_GPIO_AMP_INIT,
7698 	ALC269_FIXUP_CZC_B20,
7699 	ALC269_FIXUP_CZC_TMI,
7700 	ALC269_FIXUP_CZC_L101,
7701 	ALC269_FIXUP_LEMOTE_A1802,
7702 	ALC269_FIXUP_LEMOTE_A190X,
7703 	ALC256_FIXUP_INTEL_NUC8_RUGGED,
7704 	ALC233_FIXUP_INTEL_NUC8_DMIC,
7705 	ALC233_FIXUP_INTEL_NUC8_BOOST,
7706 	ALC256_FIXUP_INTEL_NUC10,
7707 	ALC255_FIXUP_XIAOMI_HEADSET_MIC,
7708 	ALC274_FIXUP_HP_MIC,
7709 	ALC274_FIXUP_HP_HEADSET_MIC,
7710 	ALC274_FIXUP_HP_ENVY_GPIO,
7711 	ALC256_FIXUP_ASUS_HPE,
7712 	ALC285_FIXUP_THINKPAD_NO_BASS_SPK_HEADSET_JACK,
7713 	ALC287_FIXUP_HP_GPIO_LED,
7714 	ALC256_FIXUP_HP_HEADSET_MIC,
7715 	ALC245_FIXUP_HP_GPIO_LED,
7716 	ALC236_FIXUP_DELL_AIO_HEADSET_MIC,
7717 	ALC282_FIXUP_ACER_DISABLE_LINEOUT,
7718 	ALC255_FIXUP_ACER_LIMIT_INT_MIC_BOOST,
7719 	ALC256_FIXUP_ACER_HEADSET_MIC,
7720 	ALC285_FIXUP_IDEAPAD_S740_COEF,
7721 	ALC285_FIXUP_HP_LIMIT_INT_MIC_BOOST,
7722 	ALC295_FIXUP_ASUS_DACS,
7723 	ALC295_FIXUP_HP_OMEN,
7724 	ALC285_FIXUP_HP_SPECTRE_X360,
7725 	ALC287_FIXUP_IDEAPAD_BASS_SPK_AMP,
7726 	ALC623_FIXUP_LENOVO_THINKSTATION_P340,
7727 	ALC255_FIXUP_ACER_HEADPHONE_AND_MIC,
7728 	ALC236_FIXUP_HP_LIMIT_INT_MIC_BOOST,
7729 	ALC287_FIXUP_LEGION_15IMHG05_SPEAKERS,
7730 	ALC287_FIXUP_LEGION_15IMHG05_AUTOMUTE,
7731 	ALC287_FIXUP_YOGA7_14ITL_SPEAKERS,
7732 	ALC298_FIXUP_LENOVO_C940_DUET7,
7733 	ALC287_FIXUP_LENOVO_14IRP8_DUETITL,
7734 	ALC287_FIXUP_LENOVO_LEGION_7,
7735 	ALC287_FIXUP_13S_GEN2_SPEAKERS,
7736 	ALC256_FIXUP_SET_COEF_DEFAULTS,
7737 	ALC256_FIXUP_SYSTEM76_MIC_NO_PRESENCE,
7738 	ALC233_FIXUP_NO_AUDIO_JACK,
7739 	ALC256_FIXUP_MIC_NO_PRESENCE_AND_RESUME,
7740 	ALC285_FIXUP_LEGION_Y9000X_SPEAKERS,
7741 	ALC285_FIXUP_LEGION_Y9000X_AUTOMUTE,
7742 	ALC287_FIXUP_LEGION_16ACHG6,
7743 	ALC287_FIXUP_CS35L41_I2C_2,
7744 	ALC287_FIXUP_CS35L41_I2C_2_HP_GPIO_LED,
7745 	ALC287_FIXUP_CS35L41_I2C_4,
7746 	ALC245_FIXUP_CS35L41_SPI_2,
7747 	ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED,
7748 	ALC245_FIXUP_CS35L41_SPI_4,
7749 	ALC245_FIXUP_CS35L41_SPI_4_HP_GPIO_LED,
7750 	ALC285_FIXUP_HP_SPEAKERS_MICMUTE_LED,
7751 	ALC295_FIXUP_FRAMEWORK_LAPTOP_MIC_NO_PRESENCE,
7752 	ALC287_FIXUP_LEGION_16ITHG6,
7753 	ALC287_FIXUP_YOGA9_14IAP7_BASS_SPK,
7754 	ALC287_FIXUP_YOGA9_14IAP7_BASS_SPK_PIN,
7755 	ALC287_FIXUP_YOGA9_14IMH9_BASS_SPK_PIN,
7756 	ALC295_FIXUP_DELL_INSPIRON_TOP_SPEAKERS,
7757 	ALC236_FIXUP_DELL_DUAL_CODECS,
7758 	ALC287_FIXUP_CS35L41_I2C_2_THINKPAD_ACPI,
7759 	ALC287_FIXUP_TAS2781_I2C,
7760 	ALC287_FIXUP_YOGA7_14ARB7_I2C,
7761 	ALC245_FIXUP_HP_MUTE_LED_COEFBIT,
7762 	ALC245_FIXUP_HP_X360_MUTE_LEDS,
7763 	ALC287_FIXUP_THINKPAD_I2S_SPK,
7764 	ALC287_FIXUP_MG_RTKC_CSAMP_CS35L41_I2C_THINKPAD,
7765 	ALC2XX_FIXUP_HEADSET_MIC,
7766 	ALC289_FIXUP_DELL_CS35L41_SPI_2,
7767 	ALC294_FIXUP_CS35L41_I2C_2,
7768 	ALC256_FIXUP_ACER_SFG16_MICMUTE_LED,
7769 	ALC256_FIXUP_HEADPHONE_AMP_VOL,
7770 	ALC245_FIXUP_HP_SPECTRE_X360_EU0XXX,
7771 	ALC245_FIXUP_HP_SPECTRE_X360_16_AA0XXX,
7772 	ALC285_FIXUP_ASUS_GA403U,
7773 	ALC285_FIXUP_ASUS_GA403U_HEADSET_MIC,
7774 	ALC285_FIXUP_ASUS_GA403U_I2C_SPEAKER2_TO_DAC1,
7775 	ALC285_FIXUP_ASUS_GU605_SPI_2_HEADSET_MIC,
7776 	ALC285_FIXUP_ASUS_GU605_SPI_SPEAKER2_TO_DAC1,
7777 	ALC287_FIXUP_LENOVO_THKPAD_WH_ALC1318,
7778 	ALC256_FIXUP_CHROME_BOOK,
7779 	ALC287_FIXUP_LENOVO_14ARP8_LEGION_IAH7,
7780 	ALC287_FIXUP_LENOVO_SSID_17AA3820,
7781 	ALC245_FIXUP_CLEVO_NOISY_MIC,
7782 	ALC269_FIXUP_VAIO_VJFH52_MIC_NO_PRESENCE,
7783 };
7784 
7785 /* A special fixup for Lenovo C940 and Yoga Duet 7;
7786  * both have the very same PCI SSID, and we need to apply different fixups
7787  * depending on the codec ID
7788  */
7789 static void alc298_fixup_lenovo_c940_duet7(struct hda_codec *codec,
7790 					   const struct hda_fixup *fix,
7791 					   int action)
7792 {
7793 	int id;
7794 
7795 	if (codec->core.vendor_id == 0x10ec0298)
7796 		id = ALC298_FIXUP_LENOVO_SPK_VOLUME; /* C940 */
7797 	else
7798 		id = ALC287_FIXUP_YOGA7_14ITL_SPEAKERS; /* Duet 7 */
7799 	__snd_hda_apply_fixup(codec, id, action, 0);
7800 }
7801 
7802 /* A special fixup for Lenovo Slim/Yoga Pro 9 14IRP8 and Yoga DuetITL 2021;
7803  * 14IRP8 PCI SSID will mistakenly be matched with the DuetITL codec SSID,
7804  * so we need to apply a different fixup in this case. The only DuetITL codec
7805  * SSID reported so far is the 17aa:3802 while the 14IRP8 has the 17aa:38be
7806  * and 17aa:38bf. If it weren't for the PCI SSID, the 14IRP8 models would
7807  * have matched correctly by their codecs.
7808  */
7809 static void alc287_fixup_lenovo_14irp8_duetitl(struct hda_codec *codec,
7810 					      const struct hda_fixup *fix,
7811 					      int action)
7812 {
7813 	int id;
7814 
7815 	if (codec->core.subsystem_id == 0x17aa3802)
7816 		id = ALC287_FIXUP_YOGA7_14ITL_SPEAKERS; /* DuetITL */
7817 	else
7818 		id = ALC287_FIXUP_TAS2781_I2C; /* 14IRP8 */
7819 	__snd_hda_apply_fixup(codec, id, action, 0);
7820 }
7821 
7822 /* Similar to above the Lenovo Yoga Pro 7 14ARP8 PCI SSID matches the codec SSID of the
7823    Legion Y9000X 2022 IAH7.*/
7824 static void alc287_fixup_lenovo_14arp8_legion_iah7(struct hda_codec *codec,
7825 					   const struct hda_fixup *fix,
7826 					   int action)
7827 {
7828 	int id;
7829 
7830 	if (codec->core.subsystem_id == 0x17aa386e)
7831 		id = ALC287_FIXUP_CS35L41_I2C_2; /* Legion Y9000X 2022 IAH7 */
7832 	else
7833 		id = ALC285_FIXUP_SPEAKER2_TO_DAC1; /* Yoga Pro 7 14ARP8 */
7834 	__snd_hda_apply_fixup(codec, id, action, 0);
7835 }
7836 
7837 /* Another hilarious PCI SSID conflict with Lenovo Legion Pro 7 16ARX8H (with
7838  * TAS2781 codec) and Legion 7i 16IAX7 (with CS35L41 codec);
7839  * we apply a corresponding fixup depending on the codec SSID instead
7840  */
7841 static void alc287_fixup_lenovo_legion_7(struct hda_codec *codec,
7842 					 const struct hda_fixup *fix,
7843 					 int action)
7844 {
7845 	int id;
7846 
7847 	if (codec->core.subsystem_id == 0x17aa38a8)
7848 		id = ALC287_FIXUP_TAS2781_I2C; /* Legion Pro 7 16ARX8H */
7849 	else
7850 		id = ALC287_FIXUP_CS35L41_I2C_2; /* Legion 7i 16IAX7 */
7851 	__snd_hda_apply_fixup(codec, id, action, 0);
7852 }
7853 
7854 /* Yet more conflicting PCI SSID (17aa:3820) on two Lenovo models */
7855 static void alc287_fixup_lenovo_ssid_17aa3820(struct hda_codec *codec,
7856 					      const struct hda_fixup *fix,
7857 					      int action)
7858 {
7859 	int id;
7860 
7861 	if (codec->core.subsystem_id == 0x17aa3820)
7862 		id = ALC269_FIXUP_ASPIRE_HEADSET_MIC; /* IdeaPad 330-17IKB 81DM */
7863 	else /* 0x17aa3802 */
7864 		id =  ALC287_FIXUP_YOGA7_14ITL_SPEAKERS; /* "Yoga Duet 7 13ITL6 */
7865 	__snd_hda_apply_fixup(codec, id, action, 0);
7866 }
7867 
7868 static const struct hda_fixup alc269_fixups[] = {
7869 	[ALC269_FIXUP_GPIO2] = {
7870 		.type = HDA_FIXUP_FUNC,
7871 		.v.func = alc_fixup_gpio2,
7872 	},
7873 	[ALC269_FIXUP_SONY_VAIO] = {
7874 		.type = HDA_FIXUP_PINCTLS,
7875 		.v.pins = (const struct hda_pintbl[]) {
7876 			{0x19, PIN_VREFGRD},
7877 			{}
7878 		}
7879 	},
7880 	[ALC275_FIXUP_SONY_VAIO_GPIO2] = {
7881 		.type = HDA_FIXUP_FUNC,
7882 		.v.func = alc275_fixup_gpio4_off,
7883 		.chained = true,
7884 		.chain_id = ALC269_FIXUP_SONY_VAIO
7885 	},
7886 	[ALC269_FIXUP_DELL_M101Z] = {
7887 		.type = HDA_FIXUP_VERBS,
7888 		.v.verbs = (const struct hda_verb[]) {
7889 			/* Enables internal speaker */
7890 			{0x20, AC_VERB_SET_COEF_INDEX, 13},
7891 			{0x20, AC_VERB_SET_PROC_COEF, 0x4040},
7892 			{}
7893 		}
7894 	},
7895 	[ALC269_FIXUP_SKU_IGNORE] = {
7896 		.type = HDA_FIXUP_FUNC,
7897 		.v.func = alc_fixup_sku_ignore,
7898 	},
7899 	[ALC269_FIXUP_ASUS_G73JW] = {
7900 		.type = HDA_FIXUP_PINS,
7901 		.v.pins = (const struct hda_pintbl[]) {
7902 			{ 0x17, 0x99130111 }, /* subwoofer */
7903 			{ }
7904 		}
7905 	},
7906 	[ALC269_FIXUP_ASUS_N7601ZM_PINS] = {
7907 		.type = HDA_FIXUP_PINS,
7908 		.v.pins = (const struct hda_pintbl[]) {
7909 			{ 0x19, 0x03A11050 },
7910 			{ 0x1a, 0x03A11C30 },
7911 			{ 0x21, 0x03211420 },
7912 			{ }
7913 		}
7914 	},
7915 	[ALC269_FIXUP_ASUS_N7601ZM] = {
7916 		.type = HDA_FIXUP_VERBS,
7917 		.v.verbs = (const struct hda_verb[]) {
7918 			{0x20, AC_VERB_SET_COEF_INDEX, 0x62},
7919 			{0x20, AC_VERB_SET_PROC_COEF, 0xa007},
7920 			{0x20, AC_VERB_SET_COEF_INDEX, 0x10},
7921 			{0x20, AC_VERB_SET_PROC_COEF, 0x8420},
7922 			{0x20, AC_VERB_SET_COEF_INDEX, 0x0f},
7923 			{0x20, AC_VERB_SET_PROC_COEF, 0x7774},
7924 			{ }
7925 		},
7926 		.chained = true,
7927 		.chain_id = ALC269_FIXUP_ASUS_N7601ZM_PINS,
7928 	},
7929 	[ALC269_FIXUP_LENOVO_EAPD] = {
7930 		.type = HDA_FIXUP_VERBS,
7931 		.v.verbs = (const struct hda_verb[]) {
7932 			{0x14, AC_VERB_SET_EAPD_BTLENABLE, 0},
7933 			{}
7934 		}
7935 	},
7936 	[ALC275_FIXUP_SONY_HWEQ] = {
7937 		.type = HDA_FIXUP_FUNC,
7938 		.v.func = alc269_fixup_hweq,
7939 		.chained = true,
7940 		.chain_id = ALC275_FIXUP_SONY_VAIO_GPIO2
7941 	},
7942 	[ALC275_FIXUP_SONY_DISABLE_AAMIX] = {
7943 		.type = HDA_FIXUP_FUNC,
7944 		.v.func = alc_fixup_disable_aamix,
7945 		.chained = true,
7946 		.chain_id = ALC269_FIXUP_SONY_VAIO
7947 	},
7948 	[ALC271_FIXUP_DMIC] = {
7949 		.type = HDA_FIXUP_FUNC,
7950 		.v.func = alc271_fixup_dmic,
7951 	},
7952 	[ALC269_FIXUP_PCM_44K] = {
7953 		.type = HDA_FIXUP_FUNC,
7954 		.v.func = alc269_fixup_pcm_44k,
7955 		.chained = true,
7956 		.chain_id = ALC269_FIXUP_QUANTA_MUTE
7957 	},
7958 	[ALC269_FIXUP_STEREO_DMIC] = {
7959 		.type = HDA_FIXUP_FUNC,
7960 		.v.func = alc269_fixup_stereo_dmic,
7961 	},
7962 	[ALC269_FIXUP_HEADSET_MIC] = {
7963 		.type = HDA_FIXUP_FUNC,
7964 		.v.func = alc269_fixup_headset_mic,
7965 	},
7966 	[ALC269_FIXUP_QUANTA_MUTE] = {
7967 		.type = HDA_FIXUP_FUNC,
7968 		.v.func = alc269_fixup_quanta_mute,
7969 	},
7970 	[ALC269_FIXUP_LIFEBOOK] = {
7971 		.type = HDA_FIXUP_PINS,
7972 		.v.pins = (const struct hda_pintbl[]) {
7973 			{ 0x1a, 0x2101103f }, /* dock line-out */
7974 			{ 0x1b, 0x23a11040 }, /* dock mic-in */
7975 			{ }
7976 		},
7977 		.chained = true,
7978 		.chain_id = ALC269_FIXUP_QUANTA_MUTE
7979 	},
7980 	[ALC269_FIXUP_LIFEBOOK_EXTMIC] = {
7981 		.type = HDA_FIXUP_PINS,
7982 		.v.pins = (const struct hda_pintbl[]) {
7983 			{ 0x19, 0x01a1903c }, /* headset mic, with jack detect */
7984 			{ }
7985 		},
7986 	},
7987 	[ALC269_FIXUP_LIFEBOOK_HP_PIN] = {
7988 		.type = HDA_FIXUP_PINS,
7989 		.v.pins = (const struct hda_pintbl[]) {
7990 			{ 0x21, 0x0221102f }, /* HP out */
7991 			{ }
7992 		},
7993 	},
7994 	[ALC269_FIXUP_LIFEBOOK_NO_HP_TO_LINEOUT] = {
7995 		.type = HDA_FIXUP_FUNC,
7996 		.v.func = alc269_fixup_pincfg_no_hp_to_lineout,
7997 	},
7998 	[ALC255_FIXUP_LIFEBOOK_U7x7_HEADSET_MIC] = {
7999 		.type = HDA_FIXUP_FUNC,
8000 		.v.func = alc269_fixup_pincfg_U7x7_headset_mic,
8001 	},
8002 	[ALC269VB_FIXUP_INFINIX_ZERO_BOOK_13] = {
8003 		.type = HDA_FIXUP_PINS,
8004 		.v.pins = (const struct hda_pintbl[]) {
8005 			{ 0x14, 0x90170151 }, /* use as internal speaker (LFE) */
8006 			{ 0x1b, 0x90170152 }, /* use as internal speaker (back) */
8007 			{ }
8008 		},
8009 		.chained = true,
8010 		.chain_id = ALC269_FIXUP_LIMIT_INT_MIC_BOOST
8011 	},
8012 	[ALC269VB_FIXUP_CHUWI_COREBOOK_XPRO] = {
8013 		.type = HDA_FIXUP_PINS,
8014 		.v.pins = (const struct hda_pintbl[]) {
8015 			{ 0x18, 0x03a19020 }, /* headset mic */
8016 			{ 0x1b, 0x90170150 }, /* speaker */
8017 			{ }
8018 		},
8019 	},
8020 	[ALC269_FIXUP_AMIC] = {
8021 		.type = HDA_FIXUP_PINS,
8022 		.v.pins = (const struct hda_pintbl[]) {
8023 			{ 0x14, 0x99130110 }, /* speaker */
8024 			{ 0x15, 0x0121401f }, /* HP out */
8025 			{ 0x18, 0x01a19c20 }, /* mic */
8026 			{ 0x19, 0x99a3092f }, /* int-mic */
8027 			{ }
8028 		},
8029 	},
8030 	[ALC269_FIXUP_DMIC] = {
8031 		.type = HDA_FIXUP_PINS,
8032 		.v.pins = (const struct hda_pintbl[]) {
8033 			{ 0x12, 0x99a3092f }, /* int-mic */
8034 			{ 0x14, 0x99130110 }, /* speaker */
8035 			{ 0x15, 0x0121401f }, /* HP out */
8036 			{ 0x18, 0x01a19c20 }, /* mic */
8037 			{ }
8038 		},
8039 	},
8040 	[ALC269VB_FIXUP_AMIC] = {
8041 		.type = HDA_FIXUP_PINS,
8042 		.v.pins = (const struct hda_pintbl[]) {
8043 			{ 0x14, 0x99130110 }, /* speaker */
8044 			{ 0x18, 0x01a19c20 }, /* mic */
8045 			{ 0x19, 0x99a3092f }, /* int-mic */
8046 			{ 0x21, 0x0121401f }, /* HP out */
8047 			{ }
8048 		},
8049 	},
8050 	[ALC269VB_FIXUP_DMIC] = {
8051 		.type = HDA_FIXUP_PINS,
8052 		.v.pins = (const struct hda_pintbl[]) {
8053 			{ 0x12, 0x99a3092f }, /* int-mic */
8054 			{ 0x14, 0x99130110 }, /* speaker */
8055 			{ 0x18, 0x01a19c20 }, /* mic */
8056 			{ 0x21, 0x0121401f }, /* HP out */
8057 			{ }
8058 		},
8059 	},
8060 	[ALC269_FIXUP_HP_MUTE_LED] = {
8061 		.type = HDA_FIXUP_FUNC,
8062 		.v.func = alc269_fixup_hp_mute_led,
8063 	},
8064 	[ALC269_FIXUP_HP_MUTE_LED_MIC1] = {
8065 		.type = HDA_FIXUP_FUNC,
8066 		.v.func = alc269_fixup_hp_mute_led_mic1,
8067 	},
8068 	[ALC269_FIXUP_HP_MUTE_LED_MIC2] = {
8069 		.type = HDA_FIXUP_FUNC,
8070 		.v.func = alc269_fixup_hp_mute_led_mic2,
8071 	},
8072 	[ALC269_FIXUP_HP_MUTE_LED_MIC3] = {
8073 		.type = HDA_FIXUP_FUNC,
8074 		.v.func = alc269_fixup_hp_mute_led_mic3,
8075 		.chained = true,
8076 		.chain_id = ALC295_FIXUP_HP_AUTO_MUTE
8077 	},
8078 	[ALC269_FIXUP_HP_GPIO_LED] = {
8079 		.type = HDA_FIXUP_FUNC,
8080 		.v.func = alc269_fixup_hp_gpio_led,
8081 	},
8082 	[ALC269_FIXUP_HP_GPIO_MIC1_LED] = {
8083 		.type = HDA_FIXUP_FUNC,
8084 		.v.func = alc269_fixup_hp_gpio_mic1_led,
8085 	},
8086 	[ALC269_FIXUP_HP_LINE1_MIC1_LED] = {
8087 		.type = HDA_FIXUP_FUNC,
8088 		.v.func = alc269_fixup_hp_line1_mic1_led,
8089 	},
8090 	[ALC269_FIXUP_INV_DMIC] = {
8091 		.type = HDA_FIXUP_FUNC,
8092 		.v.func = alc_fixup_inv_dmic,
8093 	},
8094 	[ALC269_FIXUP_NO_SHUTUP] = {
8095 		.type = HDA_FIXUP_FUNC,
8096 		.v.func = alc_fixup_no_shutup,
8097 	},
8098 	[ALC269_FIXUP_LENOVO_DOCK] = {
8099 		.type = HDA_FIXUP_PINS,
8100 		.v.pins = (const struct hda_pintbl[]) {
8101 			{ 0x19, 0x23a11040 }, /* dock mic */
8102 			{ 0x1b, 0x2121103f }, /* dock headphone */
8103 			{ }
8104 		},
8105 		.chained = true,
8106 		.chain_id = ALC269_FIXUP_PINCFG_NO_HP_TO_LINEOUT
8107 	},
8108 	[ALC269_FIXUP_LENOVO_DOCK_LIMIT_BOOST] = {
8109 		.type = HDA_FIXUP_FUNC,
8110 		.v.func = alc269_fixup_limit_int_mic_boost,
8111 		.chained = true,
8112 		.chain_id = ALC269_FIXUP_LENOVO_DOCK,
8113 	},
8114 	[ALC269_FIXUP_PINCFG_NO_HP_TO_LINEOUT] = {
8115 		.type = HDA_FIXUP_FUNC,
8116 		.v.func = alc269_fixup_pincfg_no_hp_to_lineout,
8117 		.chained = true,
8118 		.chain_id = ALC269_FIXUP_THINKPAD_ACPI,
8119 	},
8120 	[ALC269_FIXUP_DELL1_MIC_NO_PRESENCE] = {
8121 		.type = HDA_FIXUP_PINS,
8122 		.v.pins = (const struct hda_pintbl[]) {
8123 			{ 0x19, 0x01a1913c }, /* use as headset mic, without its own jack detect */
8124 			{ 0x1a, 0x01a1913d }, /* use as headphone mic, without its own jack detect */
8125 			{ }
8126 		},
8127 		.chained = true,
8128 		.chain_id = ALC269_FIXUP_HEADSET_MODE
8129 	},
8130 	[ALC269_FIXUP_DELL1_LIMIT_INT_MIC_BOOST] = {
8131 		.type = HDA_FIXUP_FUNC,
8132 		.v.func = alc269_fixup_limit_int_mic_boost,
8133 		.chained = true,
8134 		.chain_id = ALC269_FIXUP_DELL1_MIC_NO_PRESENCE
8135 	},
8136 	[ALC269_FIXUP_DELL2_MIC_NO_PRESENCE] = {
8137 		.type = HDA_FIXUP_PINS,
8138 		.v.pins = (const struct hda_pintbl[]) {
8139 			{ 0x16, 0x21014020 }, /* dock line out */
8140 			{ 0x19, 0x21a19030 }, /* dock mic */
8141 			{ 0x1a, 0x01a1913c }, /* use as headset mic, without its own jack detect */
8142 			{ }
8143 		},
8144 		.chained = true,
8145 		.chain_id = ALC269_FIXUP_HEADSET_MODE_NO_HP_MIC
8146 	},
8147 	[ALC269_FIXUP_DELL3_MIC_NO_PRESENCE] = {
8148 		.type = HDA_FIXUP_PINS,
8149 		.v.pins = (const struct hda_pintbl[]) {
8150 			{ 0x1a, 0x01a1913c }, /* use as headset mic, without its own jack detect */
8151 			{ }
8152 		},
8153 		.chained = true,
8154 		.chain_id = ALC269_FIXUP_HEADSET_MODE_NO_HP_MIC
8155 	},
8156 	[ALC269_FIXUP_DELL4_MIC_NO_PRESENCE] = {
8157 		.type = HDA_FIXUP_PINS,
8158 		.v.pins = (const struct hda_pintbl[]) {
8159 			{ 0x19, 0x01a1913c }, /* use as headset mic, without its own jack detect */
8160 			{ 0x1b, 0x01a1913d }, /* use as headphone mic, without its own jack detect */
8161 			{ }
8162 		},
8163 		.chained = true,
8164 		.chain_id = ALC269_FIXUP_HEADSET_MODE
8165 	},
8166 	[ALC269_FIXUP_HEADSET_MODE] = {
8167 		.type = HDA_FIXUP_FUNC,
8168 		.v.func = alc_fixup_headset_mode,
8169 		.chained = true,
8170 		.chain_id = ALC255_FIXUP_MIC_MUTE_LED
8171 	},
8172 	[ALC269_FIXUP_HEADSET_MODE_NO_HP_MIC] = {
8173 		.type = HDA_FIXUP_FUNC,
8174 		.v.func = alc_fixup_headset_mode_no_hp_mic,
8175 	},
8176 	[ALC269_FIXUP_ASPIRE_HEADSET_MIC] = {
8177 		.type = HDA_FIXUP_PINS,
8178 		.v.pins = (const struct hda_pintbl[]) {
8179 			{ 0x19, 0x01a1913c }, /* headset mic w/o jack detect */
8180 			{ }
8181 		},
8182 		.chained = true,
8183 		.chain_id = ALC269_FIXUP_HEADSET_MODE,
8184 	},
8185 	[ALC286_FIXUP_SONY_MIC_NO_PRESENCE] = {
8186 		.type = HDA_FIXUP_PINS,
8187 		.v.pins = (const struct hda_pintbl[]) {
8188 			{ 0x18, 0x01a1913c }, /* use as headset mic, without its own jack detect */
8189 			{ }
8190 		},
8191 		.chained = true,
8192 		.chain_id = ALC269_FIXUP_HEADSET_MIC
8193 	},
8194 	[ALC256_FIXUP_HUAWEI_MACH_WX9_PINS] = {
8195 		.type = HDA_FIXUP_PINS,
8196 		.v.pins = (const struct hda_pintbl[]) {
8197 			{0x12, 0x90a60130},
8198 			{0x13, 0x40000000},
8199 			{0x14, 0x90170110},
8200 			{0x18, 0x411111f0},
8201 			{0x19, 0x04a11040},
8202 			{0x1a, 0x411111f0},
8203 			{0x1b, 0x90170112},
8204 			{0x1d, 0x40759a05},
8205 			{0x1e, 0x411111f0},
8206 			{0x21, 0x04211020},
8207 			{ }
8208 		},
8209 		.chained = true,
8210 		.chain_id = ALC255_FIXUP_MIC_MUTE_LED
8211 	},
8212 	[ALC298_FIXUP_HUAWEI_MBX_STEREO] = {
8213 		.type = HDA_FIXUP_FUNC,
8214 		.v.func = alc298_fixup_huawei_mbx_stereo,
8215 		.chained = true,
8216 		.chain_id = ALC255_FIXUP_MIC_MUTE_LED
8217 	},
8218 	[ALC269_FIXUP_ASUS_X101_FUNC] = {
8219 		.type = HDA_FIXUP_FUNC,
8220 		.v.func = alc269_fixup_x101_headset_mic,
8221 	},
8222 	[ALC269_FIXUP_ASUS_X101_VERB] = {
8223 		.type = HDA_FIXUP_VERBS,
8224 		.v.verbs = (const struct hda_verb[]) {
8225 			{0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
8226 			{0x20, AC_VERB_SET_COEF_INDEX, 0x08},
8227 			{0x20, AC_VERB_SET_PROC_COEF,  0x0310},
8228 			{ }
8229 		},
8230 		.chained = true,
8231 		.chain_id = ALC269_FIXUP_ASUS_X101_FUNC
8232 	},
8233 	[ALC269_FIXUP_ASUS_X101] = {
8234 		.type = HDA_FIXUP_PINS,
8235 		.v.pins = (const struct hda_pintbl[]) {
8236 			{ 0x18, 0x04a1182c }, /* Headset mic */
8237 			{ }
8238 		},
8239 		.chained = true,
8240 		.chain_id = ALC269_FIXUP_ASUS_X101_VERB
8241 	},
8242 	[ALC271_FIXUP_AMIC_MIC2] = {
8243 		.type = HDA_FIXUP_PINS,
8244 		.v.pins = (const struct hda_pintbl[]) {
8245 			{ 0x14, 0x99130110 }, /* speaker */
8246 			{ 0x19, 0x01a19c20 }, /* mic */
8247 			{ 0x1b, 0x99a7012f }, /* int-mic */
8248 			{ 0x21, 0x0121401f }, /* HP out */
8249 			{ }
8250 		},
8251 	},
8252 	[ALC271_FIXUP_HP_GATE_MIC_JACK] = {
8253 		.type = HDA_FIXUP_FUNC,
8254 		.v.func = alc271_hp_gate_mic_jack,
8255 		.chained = true,
8256 		.chain_id = ALC271_FIXUP_AMIC_MIC2,
8257 	},
8258 	[ALC271_FIXUP_HP_GATE_MIC_JACK_E1_572] = {
8259 		.type = HDA_FIXUP_FUNC,
8260 		.v.func = alc269_fixup_limit_int_mic_boost,
8261 		.chained = true,
8262 		.chain_id = ALC271_FIXUP_HP_GATE_MIC_JACK,
8263 	},
8264 	[ALC269_FIXUP_ACER_AC700] = {
8265 		.type = HDA_FIXUP_PINS,
8266 		.v.pins = (const struct hda_pintbl[]) {
8267 			{ 0x12, 0x99a3092f }, /* int-mic */
8268 			{ 0x14, 0x99130110 }, /* speaker */
8269 			{ 0x18, 0x03a11c20 }, /* mic */
8270 			{ 0x1e, 0x0346101e }, /* SPDIF1 */
8271 			{ 0x21, 0x0321101f }, /* HP out */
8272 			{ }
8273 		},
8274 		.chained = true,
8275 		.chain_id = ALC271_FIXUP_DMIC,
8276 	},
8277 	[ALC269_FIXUP_LIMIT_INT_MIC_BOOST] = {
8278 		.type = HDA_FIXUP_FUNC,
8279 		.v.func = alc269_fixup_limit_int_mic_boost,
8280 		.chained = true,
8281 		.chain_id = ALC269_FIXUP_THINKPAD_ACPI,
8282 	},
8283 	[ALC269VB_FIXUP_ASUS_ZENBOOK] = {
8284 		.type = HDA_FIXUP_FUNC,
8285 		.v.func = alc269_fixup_limit_int_mic_boost,
8286 		.chained = true,
8287 		.chain_id = ALC269VB_FIXUP_DMIC,
8288 	},
8289 	[ALC269VB_FIXUP_ASUS_ZENBOOK_UX31A] = {
8290 		.type = HDA_FIXUP_VERBS,
8291 		.v.verbs = (const struct hda_verb[]) {
8292 			/* class-D output amp +5dB */
8293 			{ 0x20, AC_VERB_SET_COEF_INDEX, 0x12 },
8294 			{ 0x20, AC_VERB_SET_PROC_COEF, 0x2800 },
8295 			{}
8296 		},
8297 		.chained = true,
8298 		.chain_id = ALC269VB_FIXUP_ASUS_ZENBOOK,
8299 	},
8300 	[ALC269VB_FIXUP_ASUS_MIC_NO_PRESENCE] = {
8301 		.type = HDA_FIXUP_PINS,
8302 		.v.pins = (const struct hda_pintbl[]) {
8303 			{ 0x18, 0x01a110f0 },  /* use as headset mic */
8304 			{ }
8305 		},
8306 		.chained = true,
8307 		.chain_id = ALC269_FIXUP_HEADSET_MIC
8308 	},
8309 	[ALC269_FIXUP_LIMIT_INT_MIC_BOOST_MUTE_LED] = {
8310 		.type = HDA_FIXUP_FUNC,
8311 		.v.func = alc269_fixup_limit_int_mic_boost,
8312 		.chained = true,
8313 		.chain_id = ALC269_FIXUP_HP_MUTE_LED_MIC1,
8314 	},
8315 	[ALC269VB_FIXUP_ORDISSIMO_EVE2] = {
8316 		.type = HDA_FIXUP_PINS,
8317 		.v.pins = (const struct hda_pintbl[]) {
8318 			{ 0x12, 0x99a3092f }, /* int-mic */
8319 			{ 0x18, 0x03a11d20 }, /* mic */
8320 			{ 0x19, 0x411111f0 }, /* Unused bogus pin */
8321 			{ }
8322 		},
8323 	},
8324 	[ALC283_FIXUP_CHROME_BOOK] = {
8325 		.type = HDA_FIXUP_FUNC,
8326 		.v.func = alc283_fixup_chromebook,
8327 	},
8328 	[ALC283_FIXUP_SENSE_COMBO_JACK] = {
8329 		.type = HDA_FIXUP_FUNC,
8330 		.v.func = alc283_fixup_sense_combo_jack,
8331 		.chained = true,
8332 		.chain_id = ALC283_FIXUP_CHROME_BOOK,
8333 	},
8334 	[ALC282_FIXUP_ASUS_TX300] = {
8335 		.type = HDA_FIXUP_FUNC,
8336 		.v.func = alc282_fixup_asus_tx300,
8337 	},
8338 	[ALC283_FIXUP_INT_MIC] = {
8339 		.type = HDA_FIXUP_VERBS,
8340 		.v.verbs = (const struct hda_verb[]) {
8341 			{0x20, AC_VERB_SET_COEF_INDEX, 0x1a},
8342 			{0x20, AC_VERB_SET_PROC_COEF, 0x0011},
8343 			{ }
8344 		},
8345 		.chained = true,
8346 		.chain_id = ALC269_FIXUP_LIMIT_INT_MIC_BOOST
8347 	},
8348 	[ALC290_FIXUP_SUBWOOFER_HSJACK] = {
8349 		.type = HDA_FIXUP_PINS,
8350 		.v.pins = (const struct hda_pintbl[]) {
8351 			{ 0x17, 0x90170112 }, /* subwoofer */
8352 			{ }
8353 		},
8354 		.chained = true,
8355 		.chain_id = ALC290_FIXUP_MONO_SPEAKERS_HSJACK,
8356 	},
8357 	[ALC290_FIXUP_SUBWOOFER] = {
8358 		.type = HDA_FIXUP_PINS,
8359 		.v.pins = (const struct hda_pintbl[]) {
8360 			{ 0x17, 0x90170112 }, /* subwoofer */
8361 			{ }
8362 		},
8363 		.chained = true,
8364 		.chain_id = ALC290_FIXUP_MONO_SPEAKERS,
8365 	},
8366 	[ALC290_FIXUP_MONO_SPEAKERS] = {
8367 		.type = HDA_FIXUP_FUNC,
8368 		.v.func = alc290_fixup_mono_speakers,
8369 	},
8370 	[ALC290_FIXUP_MONO_SPEAKERS_HSJACK] = {
8371 		.type = HDA_FIXUP_FUNC,
8372 		.v.func = alc290_fixup_mono_speakers,
8373 		.chained = true,
8374 		.chain_id = ALC269_FIXUP_DELL3_MIC_NO_PRESENCE,
8375 	},
8376 	[ALC269_FIXUP_THINKPAD_ACPI] = {
8377 		.type = HDA_FIXUP_FUNC,
8378 		.v.func = alc_fixup_thinkpad_acpi,
8379 		.chained = true,
8380 		.chain_id = ALC269_FIXUP_SKU_IGNORE,
8381 	},
8382 	[ALC269_FIXUP_DMIC_THINKPAD_ACPI] = {
8383 		.type = HDA_FIXUP_FUNC,
8384 		.v.func = alc_fixup_inv_dmic,
8385 		.chained = true,
8386 		.chain_id = ALC269_FIXUP_THINKPAD_ACPI,
8387 	},
8388 	[ALC255_FIXUP_ACER_MIC_NO_PRESENCE] = {
8389 		.type = HDA_FIXUP_PINS,
8390 		.v.pins = (const struct hda_pintbl[]) {
8391 			{ 0x19, 0x01a1913c }, /* use as headset mic, without its own jack detect */
8392 			{ }
8393 		},
8394 		.chained = true,
8395 		.chain_id = ALC255_FIXUP_HEADSET_MODE
8396 	},
8397 	[ALC255_FIXUP_ASUS_MIC_NO_PRESENCE] = {
8398 		.type = HDA_FIXUP_PINS,
8399 		.v.pins = (const struct hda_pintbl[]) {
8400 			{ 0x19, 0x01a1913c }, /* use as headset mic, without its own jack detect */
8401 			{ }
8402 		},
8403 		.chained = true,
8404 		.chain_id = ALC255_FIXUP_HEADSET_MODE
8405 	},
8406 	[ALC255_FIXUP_DELL1_MIC_NO_PRESENCE] = {
8407 		.type = HDA_FIXUP_PINS,
8408 		.v.pins = (const struct hda_pintbl[]) {
8409 			{ 0x19, 0x01a1913c }, /* use as headset mic, without its own jack detect */
8410 			{ 0x1a, 0x01a1913d }, /* use as headphone mic, without its own jack detect */
8411 			{ }
8412 		},
8413 		.chained = true,
8414 		.chain_id = ALC255_FIXUP_HEADSET_MODE
8415 	},
8416 	[ALC255_FIXUP_DELL1_LIMIT_INT_MIC_BOOST] = {
8417 		.type = HDA_FIXUP_FUNC,
8418 		.v.func = alc269_fixup_limit_int_mic_boost,
8419 		.chained = true,
8420 		.chain_id = ALC255_FIXUP_DELL1_MIC_NO_PRESENCE
8421 	},
8422 	[ALC255_FIXUP_DELL2_MIC_NO_PRESENCE] = {
8423 		.type = HDA_FIXUP_PINS,
8424 		.v.pins = (const struct hda_pintbl[]) {
8425 			{ 0x19, 0x01a1913c }, /* use as headset mic, without its own jack detect */
8426 			{ }
8427 		},
8428 		.chained = true,
8429 		.chain_id = ALC255_FIXUP_HEADSET_MODE_NO_HP_MIC
8430 	},
8431 	[ALC255_FIXUP_HEADSET_MODE] = {
8432 		.type = HDA_FIXUP_FUNC,
8433 		.v.func = alc_fixup_headset_mode_alc255,
8434 		.chained = true,
8435 		.chain_id = ALC255_FIXUP_MIC_MUTE_LED
8436 	},
8437 	[ALC255_FIXUP_HEADSET_MODE_NO_HP_MIC] = {
8438 		.type = HDA_FIXUP_FUNC,
8439 		.v.func = alc_fixup_headset_mode_alc255_no_hp_mic,
8440 	},
8441 	[ALC293_FIXUP_DELL1_MIC_NO_PRESENCE] = {
8442 		.type = HDA_FIXUP_PINS,
8443 		.v.pins = (const struct hda_pintbl[]) {
8444 			{ 0x18, 0x01a1913d }, /* use as headphone mic, without its own jack detect */
8445 			{ 0x1a, 0x01a1913c }, /* use as headset mic, without its own jack detect */
8446 			{ }
8447 		},
8448 		.chained = true,
8449 		.chain_id = ALC269_FIXUP_HEADSET_MODE
8450 	},
8451 	[ALC292_FIXUP_TPT440_DOCK] = {
8452 		.type = HDA_FIXUP_FUNC,
8453 		.v.func = alc_fixup_tpt440_dock,
8454 		.chained = true,
8455 		.chain_id = ALC269_FIXUP_LIMIT_INT_MIC_BOOST
8456 	},
8457 	[ALC292_FIXUP_TPT440] = {
8458 		.type = HDA_FIXUP_FUNC,
8459 		.v.func = alc_fixup_disable_aamix,
8460 		.chained = true,
8461 		.chain_id = ALC292_FIXUP_TPT440_DOCK,
8462 	},
8463 	[ALC283_FIXUP_HEADSET_MIC] = {
8464 		.type = HDA_FIXUP_PINS,
8465 		.v.pins = (const struct hda_pintbl[]) {
8466 			{ 0x19, 0x04a110f0 },
8467 			{ },
8468 		},
8469 	},
8470 	[ALC255_FIXUP_MIC_MUTE_LED] = {
8471 		.type = HDA_FIXUP_FUNC,
8472 		.v.func = alc_fixup_micmute_led,
8473 	},
8474 	[ALC282_FIXUP_ASPIRE_V5_PINS] = {
8475 		.type = HDA_FIXUP_PINS,
8476 		.v.pins = (const struct hda_pintbl[]) {
8477 			{ 0x12, 0x90a60130 },
8478 			{ 0x14, 0x90170110 },
8479 			{ 0x17, 0x40000008 },
8480 			{ 0x18, 0x411111f0 },
8481 			{ 0x19, 0x01a1913c },
8482 			{ 0x1a, 0x411111f0 },
8483 			{ 0x1b, 0x411111f0 },
8484 			{ 0x1d, 0x40f89b2d },
8485 			{ 0x1e, 0x411111f0 },
8486 			{ 0x21, 0x0321101f },
8487 			{ },
8488 		},
8489 	},
8490 	[ALC269VB_FIXUP_ASPIRE_E1_COEF] = {
8491 		.type = HDA_FIXUP_FUNC,
8492 		.v.func = alc269vb_fixup_aspire_e1_coef,
8493 	},
8494 	[ALC280_FIXUP_HP_GPIO4] = {
8495 		.type = HDA_FIXUP_FUNC,
8496 		.v.func = alc280_fixup_hp_gpio4,
8497 	},
8498 	[ALC286_FIXUP_HP_GPIO_LED] = {
8499 		.type = HDA_FIXUP_FUNC,
8500 		.v.func = alc286_fixup_hp_gpio_led,
8501 	},
8502 	[ALC280_FIXUP_HP_GPIO2_MIC_HOTKEY] = {
8503 		.type = HDA_FIXUP_FUNC,
8504 		.v.func = alc280_fixup_hp_gpio2_mic_hotkey,
8505 	},
8506 	[ALC280_FIXUP_HP_DOCK_PINS] = {
8507 		.type = HDA_FIXUP_PINS,
8508 		.v.pins = (const struct hda_pintbl[]) {
8509 			{ 0x1b, 0x21011020 }, /* line-out */
8510 			{ 0x1a, 0x01a1903c }, /* headset mic */
8511 			{ 0x18, 0x2181103f }, /* line-in */
8512 			{ },
8513 		},
8514 		.chained = true,
8515 		.chain_id = ALC280_FIXUP_HP_GPIO4
8516 	},
8517 	[ALC269_FIXUP_HP_DOCK_GPIO_MIC1_LED] = {
8518 		.type = HDA_FIXUP_PINS,
8519 		.v.pins = (const struct hda_pintbl[]) {
8520 			{ 0x1b, 0x21011020 }, /* line-out */
8521 			{ 0x18, 0x2181103f }, /* line-in */
8522 			{ },
8523 		},
8524 		.chained = true,
8525 		.chain_id = ALC269_FIXUP_HP_GPIO_MIC1_LED
8526 	},
8527 	[ALC280_FIXUP_HP_9480M] = {
8528 		.type = HDA_FIXUP_FUNC,
8529 		.v.func = alc280_fixup_hp_9480m,
8530 	},
8531 	[ALC245_FIXUP_HP_X360_AMP] = {
8532 		.type = HDA_FIXUP_FUNC,
8533 		.v.func = alc245_fixup_hp_x360_amp,
8534 		.chained = true,
8535 		.chain_id = ALC245_FIXUP_HP_GPIO_LED
8536 	},
8537 	[ALC288_FIXUP_DELL_HEADSET_MODE] = {
8538 		.type = HDA_FIXUP_FUNC,
8539 		.v.func = alc_fixup_headset_mode_dell_alc288,
8540 		.chained = true,
8541 		.chain_id = ALC255_FIXUP_MIC_MUTE_LED
8542 	},
8543 	[ALC288_FIXUP_DELL1_MIC_NO_PRESENCE] = {
8544 		.type = HDA_FIXUP_PINS,
8545 		.v.pins = (const struct hda_pintbl[]) {
8546 			{ 0x18, 0x01a1913c }, /* use as headset mic, without its own jack detect */
8547 			{ 0x1a, 0x01a1913d }, /* use as headphone mic, without its own jack detect */
8548 			{ }
8549 		},
8550 		.chained = true,
8551 		.chain_id = ALC288_FIXUP_DELL_HEADSET_MODE
8552 	},
8553 	[ALC288_FIXUP_DISABLE_AAMIX] = {
8554 		.type = HDA_FIXUP_FUNC,
8555 		.v.func = alc_fixup_disable_aamix,
8556 		.chained = true,
8557 		.chain_id = ALC288_FIXUP_DELL1_MIC_NO_PRESENCE
8558 	},
8559 	[ALC288_FIXUP_DELL_XPS_13] = {
8560 		.type = HDA_FIXUP_FUNC,
8561 		.v.func = alc_fixup_dell_xps13,
8562 		.chained = true,
8563 		.chain_id = ALC288_FIXUP_DISABLE_AAMIX
8564 	},
8565 	[ALC292_FIXUP_DISABLE_AAMIX] = {
8566 		.type = HDA_FIXUP_FUNC,
8567 		.v.func = alc_fixup_disable_aamix,
8568 		.chained = true,
8569 		.chain_id = ALC269_FIXUP_DELL2_MIC_NO_PRESENCE
8570 	},
8571 	[ALC293_FIXUP_DISABLE_AAMIX_MULTIJACK] = {
8572 		.type = HDA_FIXUP_FUNC,
8573 		.v.func = alc_fixup_disable_aamix,
8574 		.chained = true,
8575 		.chain_id = ALC293_FIXUP_DELL1_MIC_NO_PRESENCE
8576 	},
8577 	[ALC292_FIXUP_DELL_E7X_AAMIX] = {
8578 		.type = HDA_FIXUP_FUNC,
8579 		.v.func = alc_fixup_dell_xps13,
8580 		.chained = true,
8581 		.chain_id = ALC292_FIXUP_DISABLE_AAMIX
8582 	},
8583 	[ALC292_FIXUP_DELL_E7X] = {
8584 		.type = HDA_FIXUP_FUNC,
8585 		.v.func = alc_fixup_micmute_led,
8586 		/* micmute fixup must be applied at last */
8587 		.chained_before = true,
8588 		.chain_id = ALC292_FIXUP_DELL_E7X_AAMIX,
8589 	},
8590 	[ALC298_FIXUP_ALIENWARE_MIC_NO_PRESENCE] = {
8591 		.type = HDA_FIXUP_PINS,
8592 		.v.pins = (const struct hda_pintbl[]) {
8593 			{ 0x18, 0x01a1913c }, /* headset mic w/o jack detect */
8594 			{ }
8595 		},
8596 		.chained_before = true,
8597 		.chain_id = ALC269_FIXUP_HEADSET_MODE,
8598 	},
8599 	[ALC298_FIXUP_DELL1_MIC_NO_PRESENCE] = {
8600 		.type = HDA_FIXUP_PINS,
8601 		.v.pins = (const struct hda_pintbl[]) {
8602 			{ 0x18, 0x01a1913c }, /* use as headset mic, without its own jack detect */
8603 			{ 0x1a, 0x01a1913d }, /* use as headphone mic, without its own jack detect */
8604 			{ }
8605 		},
8606 		.chained = true,
8607 		.chain_id = ALC269_FIXUP_HEADSET_MODE
8608 	},
8609 	[ALC298_FIXUP_DELL_AIO_MIC_NO_PRESENCE] = {
8610 		.type = HDA_FIXUP_PINS,
8611 		.v.pins = (const struct hda_pintbl[]) {
8612 			{ 0x18, 0x01a1913c }, /* use as headset mic, without its own jack detect */
8613 			{ }
8614 		},
8615 		.chained = true,
8616 		.chain_id = ALC269_FIXUP_HEADSET_MODE
8617 	},
8618 	[ALC275_FIXUP_DELL_XPS] = {
8619 		.type = HDA_FIXUP_VERBS,
8620 		.v.verbs = (const struct hda_verb[]) {
8621 			/* Enables internal speaker */
8622 			{0x20, AC_VERB_SET_COEF_INDEX, 0x1f},
8623 			{0x20, AC_VERB_SET_PROC_COEF, 0x00c0},
8624 			{0x20, AC_VERB_SET_COEF_INDEX, 0x30},
8625 			{0x20, AC_VERB_SET_PROC_COEF, 0x00b1},
8626 			{}
8627 		}
8628 	},
8629 	[ALC293_FIXUP_LENOVO_SPK_NOISE] = {
8630 		.type = HDA_FIXUP_FUNC,
8631 		.v.func = alc_fixup_disable_aamix,
8632 		.chained = true,
8633 		.chain_id = ALC269_FIXUP_THINKPAD_ACPI
8634 	},
8635 	[ALC233_FIXUP_LENOVO_LINE2_MIC_HOTKEY] = {
8636 		.type = HDA_FIXUP_FUNC,
8637 		.v.func = alc233_fixup_lenovo_line2_mic_hotkey,
8638 	},
8639 	[ALC233_FIXUP_INTEL_NUC8_DMIC] = {
8640 		.type = HDA_FIXUP_FUNC,
8641 		.v.func = alc_fixup_inv_dmic,
8642 		.chained = true,
8643 		.chain_id = ALC233_FIXUP_INTEL_NUC8_BOOST,
8644 	},
8645 	[ALC233_FIXUP_INTEL_NUC8_BOOST] = {
8646 		.type = HDA_FIXUP_FUNC,
8647 		.v.func = alc269_fixup_limit_int_mic_boost
8648 	},
8649 	[ALC255_FIXUP_DELL_SPK_NOISE] = {
8650 		.type = HDA_FIXUP_FUNC,
8651 		.v.func = alc_fixup_disable_aamix,
8652 		.chained = true,
8653 		.chain_id = ALC255_FIXUP_DELL1_MIC_NO_PRESENCE
8654 	},
8655 	[ALC225_FIXUP_DISABLE_MIC_VREF] = {
8656 		.type = HDA_FIXUP_FUNC,
8657 		.v.func = alc_fixup_disable_mic_vref,
8658 		.chained = true,
8659 		.chain_id = ALC269_FIXUP_DELL1_MIC_NO_PRESENCE
8660 	},
8661 	[ALC225_FIXUP_DELL1_MIC_NO_PRESENCE] = {
8662 		.type = HDA_FIXUP_VERBS,
8663 		.v.verbs = (const struct hda_verb[]) {
8664 			/* Disable pass-through path for FRONT 14h */
8665 			{ 0x20, AC_VERB_SET_COEF_INDEX, 0x36 },
8666 			{ 0x20, AC_VERB_SET_PROC_COEF, 0x57d7 },
8667 			{}
8668 		},
8669 		.chained = true,
8670 		.chain_id = ALC225_FIXUP_DISABLE_MIC_VREF
8671 	},
8672 	[ALC280_FIXUP_HP_HEADSET_MIC] = {
8673 		.type = HDA_FIXUP_FUNC,
8674 		.v.func = alc_fixup_disable_aamix,
8675 		.chained = true,
8676 		.chain_id = ALC269_FIXUP_HEADSET_MIC,
8677 	},
8678 	[ALC221_FIXUP_HP_FRONT_MIC] = {
8679 		.type = HDA_FIXUP_PINS,
8680 		.v.pins = (const struct hda_pintbl[]) {
8681 			{ 0x19, 0x02a19020 }, /* Front Mic */
8682 			{ }
8683 		},
8684 	},
8685 	[ALC292_FIXUP_TPT460] = {
8686 		.type = HDA_FIXUP_FUNC,
8687 		.v.func = alc_fixup_tpt440_dock,
8688 		.chained = true,
8689 		.chain_id = ALC293_FIXUP_LENOVO_SPK_NOISE,
8690 	},
8691 	[ALC298_FIXUP_SPK_VOLUME] = {
8692 		.type = HDA_FIXUP_FUNC,
8693 		.v.func = alc298_fixup_speaker_volume,
8694 		.chained = true,
8695 		.chain_id = ALC298_FIXUP_DELL_AIO_MIC_NO_PRESENCE,
8696 	},
8697 	[ALC298_FIXUP_LENOVO_SPK_VOLUME] = {
8698 		.type = HDA_FIXUP_FUNC,
8699 		.v.func = alc298_fixup_speaker_volume,
8700 	},
8701 	[ALC295_FIXUP_DISABLE_DAC3] = {
8702 		.type = HDA_FIXUP_FUNC,
8703 		.v.func = alc295_fixup_disable_dac3,
8704 	},
8705 	[ALC285_FIXUP_SPEAKER2_TO_DAC1] = {
8706 		.type = HDA_FIXUP_FUNC,
8707 		.v.func = alc285_fixup_speaker2_to_dac1,
8708 		.chained = true,
8709 		.chain_id = ALC269_FIXUP_THINKPAD_ACPI
8710 	},
8711 	[ALC285_FIXUP_ASUS_SPEAKER2_TO_DAC1] = {
8712 		.type = HDA_FIXUP_FUNC,
8713 		.v.func = alc285_fixup_speaker2_to_dac1,
8714 		.chained = true,
8715 		.chain_id = ALC245_FIXUP_CS35L41_SPI_2
8716 	},
8717 	[ALC285_FIXUP_ASUS_HEADSET_MIC] = {
8718 		.type = HDA_FIXUP_PINS,
8719 		.v.pins = (const struct hda_pintbl[]) {
8720 			{ 0x19, 0x03a11050 },
8721 			{ 0x1b, 0x03a11c30 },
8722 			{ }
8723 		},
8724 		.chained = true,
8725 		.chain_id = ALC285_FIXUP_ASUS_SPEAKER2_TO_DAC1
8726 	},
8727 	[ALC285_FIXUP_ASUS_SPI_REAR_SPEAKERS] = {
8728 		.type = HDA_FIXUP_PINS,
8729 		.v.pins = (const struct hda_pintbl[]) {
8730 			{ 0x14, 0x90170120 },
8731 			{ }
8732 		},
8733 		.chained = true,
8734 		.chain_id = ALC285_FIXUP_ASUS_HEADSET_MIC
8735 	},
8736 	[ALC285_FIXUP_ASUS_I2C_SPEAKER2_TO_DAC1] = {
8737 		.type = HDA_FIXUP_FUNC,
8738 		.v.func = alc285_fixup_speaker2_to_dac1,
8739 		.chained = true,
8740 		.chain_id = ALC287_FIXUP_CS35L41_I2C_2
8741 	},
8742 	[ALC285_FIXUP_ASUS_I2C_HEADSET_MIC] = {
8743 		.type = HDA_FIXUP_PINS,
8744 		.v.pins = (const struct hda_pintbl[]) {
8745 			{ 0x19, 0x03a11050 },
8746 			{ 0x1b, 0x03a11c30 },
8747 			{ }
8748 		},
8749 		.chained = true,
8750 		.chain_id = ALC285_FIXUP_ASUS_I2C_SPEAKER2_TO_DAC1
8751 	},
8752 	[ALC256_FIXUP_DELL_INSPIRON_7559_SUBWOOFER] = {
8753 		.type = HDA_FIXUP_PINS,
8754 		.v.pins = (const struct hda_pintbl[]) {
8755 			{ 0x1b, 0x90170151 },
8756 			{ }
8757 		},
8758 		.chained = true,
8759 		.chain_id = ALC255_FIXUP_DELL1_MIC_NO_PRESENCE
8760 	},
8761 	[ALC269_FIXUP_ATIV_BOOK_8] = {
8762 		.type = HDA_FIXUP_FUNC,
8763 		.v.func = alc_fixup_auto_mute_via_amp,
8764 		.chained = true,
8765 		.chain_id = ALC269_FIXUP_NO_SHUTUP
8766 	},
8767 	[ALC221_FIXUP_HP_288PRO_MIC_NO_PRESENCE] = {
8768 		.type = HDA_FIXUP_PINS,
8769 		.v.pins = (const struct hda_pintbl[]) {
8770 			{ 0x19, 0x01a1913c }, /* use as headset mic, without its own jack detect */
8771 			{ 0x1a, 0x01813030 }, /* use as headphone mic, without its own jack detect */
8772 			{ }
8773 		},
8774 		.chained = true,
8775 		.chain_id = ALC269_FIXUP_HEADSET_MODE
8776 	},
8777 	[ALC221_FIXUP_HP_MIC_NO_PRESENCE] = {
8778 		.type = HDA_FIXUP_PINS,
8779 		.v.pins = (const struct hda_pintbl[]) {
8780 			{ 0x18, 0x01a1913c }, /* use as headset mic, without its own jack detect */
8781 			{ 0x1a, 0x01a1913d }, /* use as headphone mic, without its own jack detect */
8782 			{ }
8783 		},
8784 		.chained = true,
8785 		.chain_id = ALC269_FIXUP_HEADSET_MODE
8786 	},
8787 	[ALC256_FIXUP_ASUS_HEADSET_MODE] = {
8788 		.type = HDA_FIXUP_FUNC,
8789 		.v.func = alc_fixup_headset_mode,
8790 	},
8791 	[ALC256_FIXUP_ASUS_MIC] = {
8792 		.type = HDA_FIXUP_PINS,
8793 		.v.pins = (const struct hda_pintbl[]) {
8794 			{ 0x13, 0x90a60160 }, /* use as internal mic */
8795 			{ 0x19, 0x04a11120 }, /* use as headset mic, without its own jack detect */
8796 			{ }
8797 		},
8798 		.chained = true,
8799 		.chain_id = ALC256_FIXUP_ASUS_HEADSET_MODE
8800 	},
8801 	[ALC256_FIXUP_ASUS_AIO_GPIO2] = {
8802 		.type = HDA_FIXUP_FUNC,
8803 		/* Set up GPIO2 for the speaker amp */
8804 		.v.func = alc_fixup_gpio4,
8805 	},
8806 	[ALC233_FIXUP_ASUS_MIC_NO_PRESENCE] = {
8807 		.type = HDA_FIXUP_PINS,
8808 		.v.pins = (const struct hda_pintbl[]) {
8809 			{ 0x19, 0x01a1913c }, /* use as headset mic, without its own jack detect */
8810 			{ }
8811 		},
8812 		.chained = true,
8813 		.chain_id = ALC269_FIXUP_HEADSET_MIC
8814 	},
8815 	[ALC233_FIXUP_EAPD_COEF_AND_MIC_NO_PRESENCE] = {
8816 		.type = HDA_FIXUP_VERBS,
8817 		.v.verbs = (const struct hda_verb[]) {
8818 			/* Enables internal speaker */
8819 			{0x20, AC_VERB_SET_COEF_INDEX, 0x40},
8820 			{0x20, AC_VERB_SET_PROC_COEF, 0x8800},
8821 			{}
8822 		},
8823 		.chained = true,
8824 		.chain_id = ALC233_FIXUP_ASUS_MIC_NO_PRESENCE
8825 	},
8826 	[ALC233_FIXUP_LENOVO_MULTI_CODECS] = {
8827 		.type = HDA_FIXUP_FUNC,
8828 		.v.func = alc233_alc662_fixup_lenovo_dual_codecs,
8829 		.chained = true,
8830 		.chain_id = ALC269_FIXUP_GPIO2
8831 	},
8832 	[ALC233_FIXUP_ACER_HEADSET_MIC] = {
8833 		.type = HDA_FIXUP_VERBS,
8834 		.v.verbs = (const struct hda_verb[]) {
8835 			{ 0x20, AC_VERB_SET_COEF_INDEX, 0x45 },
8836 			{ 0x20, AC_VERB_SET_PROC_COEF, 0x5089 },
8837 			{ }
8838 		},
8839 		.chained = true,
8840 		.chain_id = ALC233_FIXUP_ASUS_MIC_NO_PRESENCE
8841 	},
8842 	[ALC294_FIXUP_LENOVO_MIC_LOCATION] = {
8843 		.type = HDA_FIXUP_PINS,
8844 		.v.pins = (const struct hda_pintbl[]) {
8845 			/* Change the mic location from front to right, otherwise there are
8846 			   two front mics with the same name, pulseaudio can't handle them.
8847 			   This is just a temporary workaround, after applying this fixup,
8848 			   there will be one "Front Mic" and one "Mic" in this machine.
8849 			 */
8850 			{ 0x1a, 0x04a19040 },
8851 			{ }
8852 		},
8853 	},
8854 	[ALC225_FIXUP_DELL_WYSE_MIC_NO_PRESENCE] = {
8855 		.type = HDA_FIXUP_PINS,
8856 		.v.pins = (const struct hda_pintbl[]) {
8857 			{ 0x16, 0x0101102f }, /* Rear Headset HP */
8858 			{ 0x19, 0x02a1913c }, /* use as Front headset mic, without its own jack detect */
8859 			{ 0x1a, 0x01a19030 }, /* Rear Headset MIC */
8860 			{ 0x1b, 0x02011020 },
8861 			{ }
8862 		},
8863 		.chained = true,
8864 		.chain_id = ALC225_FIXUP_S3_POP_NOISE
8865 	},
8866 	[ALC225_FIXUP_S3_POP_NOISE] = {
8867 		.type = HDA_FIXUP_FUNC,
8868 		.v.func = alc225_fixup_s3_pop_noise,
8869 		.chained = true,
8870 		.chain_id = ALC269_FIXUP_HEADSET_MODE_NO_HP_MIC
8871 	},
8872 	[ALC700_FIXUP_INTEL_REFERENCE] = {
8873 		.type = HDA_FIXUP_VERBS,
8874 		.v.verbs = (const struct hda_verb[]) {
8875 			/* Enables internal speaker */
8876 			{0x20, AC_VERB_SET_COEF_INDEX, 0x45},
8877 			{0x20, AC_VERB_SET_PROC_COEF, 0x5289},
8878 			{0x20, AC_VERB_SET_COEF_INDEX, 0x4A},
8879 			{0x20, AC_VERB_SET_PROC_COEF, 0x001b},
8880 			{0x58, AC_VERB_SET_COEF_INDEX, 0x00},
8881 			{0x58, AC_VERB_SET_PROC_COEF, 0x3888},
8882 			{0x20, AC_VERB_SET_COEF_INDEX, 0x6f},
8883 			{0x20, AC_VERB_SET_PROC_COEF, 0x2c0b},
8884 			{}
8885 		}
8886 	},
8887 	[ALC274_FIXUP_DELL_BIND_DACS] = {
8888 		.type = HDA_FIXUP_FUNC,
8889 		.v.func = alc274_fixup_bind_dacs,
8890 		.chained = true,
8891 		.chain_id = ALC269_FIXUP_DELL1_MIC_NO_PRESENCE
8892 	},
8893 	[ALC274_FIXUP_DELL_AIO_LINEOUT_VERB] = {
8894 		.type = HDA_FIXUP_PINS,
8895 		.v.pins = (const struct hda_pintbl[]) {
8896 			{ 0x1b, 0x0401102f },
8897 			{ }
8898 		},
8899 		.chained = true,
8900 		.chain_id = ALC274_FIXUP_DELL_BIND_DACS
8901 	},
8902 	[ALC298_FIXUP_TPT470_DOCK_FIX] = {
8903 		.type = HDA_FIXUP_FUNC,
8904 		.v.func = alc_fixup_tpt470_dock,
8905 		.chained = true,
8906 		.chain_id = ALC293_FIXUP_LENOVO_SPK_NOISE
8907 	},
8908 	[ALC298_FIXUP_TPT470_DOCK] = {
8909 		.type = HDA_FIXUP_FUNC,
8910 		.v.func = alc_fixup_tpt470_dacs,
8911 		.chained = true,
8912 		.chain_id = ALC298_FIXUP_TPT470_DOCK_FIX
8913 	},
8914 	[ALC255_FIXUP_DUMMY_LINEOUT_VERB] = {
8915 		.type = HDA_FIXUP_PINS,
8916 		.v.pins = (const struct hda_pintbl[]) {
8917 			{ 0x14, 0x0201101f },
8918 			{ }
8919 		},
8920 		.chained = true,
8921 		.chain_id = ALC255_FIXUP_DELL1_MIC_NO_PRESENCE
8922 	},
8923 	[ALC255_FIXUP_DELL_HEADSET_MIC] = {
8924 		.type = HDA_FIXUP_PINS,
8925 		.v.pins = (const struct hda_pintbl[]) {
8926 			{ 0x19, 0x01a1913c }, /* use as headset mic, without its own jack detect */
8927 			{ }
8928 		},
8929 		.chained = true,
8930 		.chain_id = ALC269_FIXUP_HEADSET_MIC
8931 	},
8932 	[ALC295_FIXUP_HP_X360] = {
8933 		.type = HDA_FIXUP_FUNC,
8934 		.v.func = alc295_fixup_hp_top_speakers,
8935 		.chained = true,
8936 		.chain_id = ALC269_FIXUP_HP_MUTE_LED_MIC3
8937 	},
8938 	[ALC221_FIXUP_HP_HEADSET_MIC] = {
8939 		.type = HDA_FIXUP_PINS,
8940 		.v.pins = (const struct hda_pintbl[]) {
8941 			{ 0x19, 0x0181313f},
8942 			{ }
8943 		},
8944 		.chained = true,
8945 		.chain_id = ALC269_FIXUP_HEADSET_MIC
8946 	},
8947 	[ALC285_FIXUP_LENOVO_HEADPHONE_NOISE] = {
8948 		.type = HDA_FIXUP_FUNC,
8949 		.v.func = alc285_fixup_invalidate_dacs,
8950 		.chained = true,
8951 		.chain_id = ALC269_FIXUP_THINKPAD_ACPI
8952 	},
8953 	[ALC295_FIXUP_HP_AUTO_MUTE] = {
8954 		.type = HDA_FIXUP_FUNC,
8955 		.v.func = alc_fixup_auto_mute_via_amp,
8956 	},
8957 	[ALC286_FIXUP_ACER_AIO_MIC_NO_PRESENCE] = {
8958 		.type = HDA_FIXUP_PINS,
8959 		.v.pins = (const struct hda_pintbl[]) {
8960 			{ 0x18, 0x01a1913c }, /* use as headset mic, without its own jack detect */
8961 			{ }
8962 		},
8963 		.chained = true,
8964 		.chain_id = ALC269_FIXUP_HEADSET_MIC
8965 	},
8966 	[ALC294_FIXUP_ASUS_MIC] = {
8967 		.type = HDA_FIXUP_PINS,
8968 		.v.pins = (const struct hda_pintbl[]) {
8969 			{ 0x13, 0x90a60160 }, /* use as internal mic */
8970 			{ 0x19, 0x04a11120 }, /* use as headset mic, without its own jack detect */
8971 			{ }
8972 		},
8973 		.chained = true,
8974 		.chain_id = ALC269_FIXUP_HEADSET_MIC
8975 	},
8976 	[ALC294_FIXUP_ASUS_HEADSET_MIC] = {
8977 		.type = HDA_FIXUP_PINS,
8978 		.v.pins = (const struct hda_pintbl[]) {
8979 			{ 0x19, 0x01a1103c }, /* use as headset mic */
8980 			{ }
8981 		},
8982 		.chained = true,
8983 		.chain_id = ALC269_FIXUP_HEADSET_MIC
8984 	},
8985 	[ALC294_FIXUP_ASUS_SPK] = {
8986 		.type = HDA_FIXUP_VERBS,
8987 		.v.verbs = (const struct hda_verb[]) {
8988 			/* Set EAPD high */
8989 			{ 0x20, AC_VERB_SET_COEF_INDEX, 0x40 },
8990 			{ 0x20, AC_VERB_SET_PROC_COEF, 0x8800 },
8991 			{ 0x20, AC_VERB_SET_COEF_INDEX, 0x0f },
8992 			{ 0x20, AC_VERB_SET_PROC_COEF, 0x7774 },
8993 			{ }
8994 		},
8995 		.chained = true,
8996 		.chain_id = ALC294_FIXUP_ASUS_HEADSET_MIC
8997 	},
8998 	[ALC295_FIXUP_CHROME_BOOK] = {
8999 		.type = HDA_FIXUP_FUNC,
9000 		.v.func = alc295_fixup_chromebook,
9001 		.chained = true,
9002 		.chain_id = ALC225_FIXUP_HEADSET_JACK
9003 	},
9004 	[ALC225_FIXUP_HEADSET_JACK] = {
9005 		.type = HDA_FIXUP_FUNC,
9006 		.v.func = alc_fixup_headset_jack,
9007 	},
9008 	[ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE] = {
9009 		.type = HDA_FIXUP_PINS,
9010 		.v.pins = (const struct hda_pintbl[]) {
9011 			{ 0x1a, 0x01a1913c }, /* use as headset mic, without its own jack detect */
9012 			{ }
9013 		},
9014 		.chained = true,
9015 		.chain_id = ALC269_FIXUP_HEADSET_MODE_NO_HP_MIC
9016 	},
9017 	[ALC285_FIXUP_LENOVO_PC_BEEP_IN_NOISE] = {
9018 		.type = HDA_FIXUP_VERBS,
9019 		.v.verbs = (const struct hda_verb[]) {
9020 			/* Disable PCBEEP-IN passthrough */
9021 			{ 0x20, AC_VERB_SET_COEF_INDEX, 0x36 },
9022 			{ 0x20, AC_VERB_SET_PROC_COEF, 0x57d7 },
9023 			{ }
9024 		},
9025 		.chained = true,
9026 		.chain_id = ALC285_FIXUP_LENOVO_HEADPHONE_NOISE
9027 	},
9028 	[ALC255_FIXUP_ACER_HEADSET_MIC] = {
9029 		.type = HDA_FIXUP_PINS,
9030 		.v.pins = (const struct hda_pintbl[]) {
9031 			{ 0x19, 0x03a11130 },
9032 			{ 0x1a, 0x90a60140 }, /* use as internal mic */
9033 			{ }
9034 		},
9035 		.chained = true,
9036 		.chain_id = ALC255_FIXUP_HEADSET_MODE_NO_HP_MIC
9037 	},
9038 	[ALC225_FIXUP_DELL_WYSE_AIO_MIC_NO_PRESENCE] = {
9039 		.type = HDA_FIXUP_PINS,
9040 		.v.pins = (const struct hda_pintbl[]) {
9041 			{ 0x16, 0x01011020 }, /* Rear Line out */
9042 			{ 0x19, 0x01a1913c }, /* use as Front headset mic, without its own jack detect */
9043 			{ }
9044 		},
9045 		.chained = true,
9046 		.chain_id = ALC225_FIXUP_WYSE_AUTO_MUTE
9047 	},
9048 	[ALC225_FIXUP_WYSE_AUTO_MUTE] = {
9049 		.type = HDA_FIXUP_FUNC,
9050 		.v.func = alc_fixup_auto_mute_via_amp,
9051 		.chained = true,
9052 		.chain_id = ALC225_FIXUP_WYSE_DISABLE_MIC_VREF
9053 	},
9054 	[ALC225_FIXUP_WYSE_DISABLE_MIC_VREF] = {
9055 		.type = HDA_FIXUP_FUNC,
9056 		.v.func = alc_fixup_disable_mic_vref,
9057 		.chained = true,
9058 		.chain_id = ALC269_FIXUP_HEADSET_MODE_NO_HP_MIC
9059 	},
9060 	[ALC286_FIXUP_ACER_AIO_HEADSET_MIC] = {
9061 		.type = HDA_FIXUP_VERBS,
9062 		.v.verbs = (const struct hda_verb[]) {
9063 			{ 0x20, AC_VERB_SET_COEF_INDEX, 0x4f },
9064 			{ 0x20, AC_VERB_SET_PROC_COEF, 0x5029 },
9065 			{ }
9066 		},
9067 		.chained = true,
9068 		.chain_id = ALC286_FIXUP_ACER_AIO_MIC_NO_PRESENCE
9069 	},
9070 	[ALC256_FIXUP_ASUS_HEADSET_MIC] = {
9071 		.type = HDA_FIXUP_PINS,
9072 		.v.pins = (const struct hda_pintbl[]) {
9073 			{ 0x19, 0x03a11020 }, /* headset mic with jack detect */
9074 			{ }
9075 		},
9076 		.chained = true,
9077 		.chain_id = ALC256_FIXUP_ASUS_HEADSET_MODE
9078 	},
9079 	[ALC256_FIXUP_ASUS_MIC_NO_PRESENCE] = {
9080 		.type = HDA_FIXUP_PINS,
9081 		.v.pins = (const struct hda_pintbl[]) {
9082 			{ 0x19, 0x04a11120 }, /* use as headset mic, without its own jack detect */
9083 			{ }
9084 		},
9085 		.chained = true,
9086 		.chain_id = ALC256_FIXUP_ASUS_HEADSET_MODE
9087 	},
9088 	[ALC255_FIXUP_PREDATOR_SUBWOOFER] = {
9089 		.type = HDA_FIXUP_PINS,
9090 		.v.pins = (const struct hda_pintbl[]) {
9091 			{ 0x17, 0x90170151 }, /* use as internal speaker (LFE) */
9092 			{ 0x1b, 0x90170152 } /* use as internal speaker (back) */
9093 		}
9094 	},
9095 	[ALC299_FIXUP_PREDATOR_SPK] = {
9096 		.type = HDA_FIXUP_PINS,
9097 		.v.pins = (const struct hda_pintbl[]) {
9098 			{ 0x21, 0x90170150 }, /* use as headset mic, without its own jack detect */
9099 			{ }
9100 		}
9101 	},
9102 	[ALC256_FIXUP_MEDION_HEADSET_NO_PRESENCE] = {
9103 		.type = HDA_FIXUP_PINS,
9104 		.v.pins = (const struct hda_pintbl[]) {
9105 			{ 0x19, 0x04a11040 },
9106 			{ 0x21, 0x04211020 },
9107 			{ }
9108 		},
9109 		.chained = true,
9110 		.chain_id = ALC256_FIXUP_ASUS_HEADSET_MODE
9111 	},
9112 	[ALC289_FIXUP_DELL_SPK1] = {
9113 		.type = HDA_FIXUP_PINS,
9114 		.v.pins = (const struct hda_pintbl[]) {
9115 			{ 0x14, 0x90170140 },
9116 			{ }
9117 		},
9118 		.chained = true,
9119 		.chain_id = ALC269_FIXUP_DELL4_MIC_NO_PRESENCE
9120 	},
9121 	[ALC289_FIXUP_DELL_SPK2] = {
9122 		.type = HDA_FIXUP_PINS,
9123 		.v.pins = (const struct hda_pintbl[]) {
9124 			{ 0x17, 0x90170130 }, /* bass spk */
9125 			{ }
9126 		},
9127 		.chained = true,
9128 		.chain_id = ALC269_FIXUP_DELL4_MIC_NO_PRESENCE
9129 	},
9130 	[ALC289_FIXUP_DUAL_SPK] = {
9131 		.type = HDA_FIXUP_FUNC,
9132 		.v.func = alc285_fixup_speaker2_to_dac1,
9133 		.chained = true,
9134 		.chain_id = ALC289_FIXUP_DELL_SPK2
9135 	},
9136 	[ALC289_FIXUP_RTK_AMP_DUAL_SPK] = {
9137 		.type = HDA_FIXUP_FUNC,
9138 		.v.func = alc285_fixup_speaker2_to_dac1,
9139 		.chained = true,
9140 		.chain_id = ALC289_FIXUP_DELL_SPK1
9141 	},
9142 	[ALC294_FIXUP_SPK2_TO_DAC1] = {
9143 		.type = HDA_FIXUP_FUNC,
9144 		.v.func = alc285_fixup_speaker2_to_dac1,
9145 		.chained = true,
9146 		.chain_id = ALC294_FIXUP_ASUS_HEADSET_MIC
9147 	},
9148 	[ALC294_FIXUP_ASUS_DUAL_SPK] = {
9149 		.type = HDA_FIXUP_FUNC,
9150 		/* The GPIO must be pulled to initialize the AMP */
9151 		.v.func = alc_fixup_gpio4,
9152 		.chained = true,
9153 		.chain_id = ALC294_FIXUP_SPK2_TO_DAC1
9154 	},
9155 	[ALC294_FIXUP_ASUS_ALLY] = {
9156 		.type = HDA_FIXUP_FUNC,
9157 		.v.func = cs35l41_fixup_i2c_two,
9158 		.chained = true,
9159 		.chain_id = ALC294_FIXUP_ASUS_ALLY_PINS
9160 	},
9161 	[ALC294_FIXUP_ASUS_ALLY_X] = {
9162 		.type = HDA_FIXUP_FUNC,
9163 		.v.func = tas2781_fixup_i2c,
9164 		.chained = true,
9165 		.chain_id = ALC294_FIXUP_ASUS_ALLY_PINS
9166 	},
9167 	[ALC294_FIXUP_ASUS_ALLY_PINS] = {
9168 		.type = HDA_FIXUP_PINS,
9169 		.v.pins = (const struct hda_pintbl[]) {
9170 			{ 0x19, 0x03a11050 },
9171 			{ 0x1a, 0x03a11c30 },
9172 			{ 0x21, 0x03211420 },
9173 			{ }
9174 		},
9175 		.chained = true,
9176 		.chain_id = ALC294_FIXUP_ASUS_ALLY_VERBS
9177 	},
9178 	[ALC294_FIXUP_ASUS_ALLY_VERBS] = {
9179 		.type = HDA_FIXUP_VERBS,
9180 		.v.verbs = (const struct hda_verb[]) {
9181 			{ 0x20, AC_VERB_SET_COEF_INDEX, 0x45 },
9182 			{ 0x20, AC_VERB_SET_PROC_COEF, 0x5089 },
9183 			{ 0x20, AC_VERB_SET_COEF_INDEX, 0x46 },
9184 			{ 0x20, AC_VERB_SET_PROC_COEF, 0x0004 },
9185 			{ 0x20, AC_VERB_SET_COEF_INDEX, 0x47 },
9186 			{ 0x20, AC_VERB_SET_PROC_COEF, 0xa47a },
9187 			{ 0x20, AC_VERB_SET_COEF_INDEX, 0x49 },
9188 			{ 0x20, AC_VERB_SET_PROC_COEF, 0x0049},
9189 			{ 0x20, AC_VERB_SET_COEF_INDEX, 0x4a },
9190 			{ 0x20, AC_VERB_SET_PROC_COEF, 0x201b },
9191 			{ 0x20, AC_VERB_SET_COEF_INDEX, 0x6b },
9192 			{ 0x20, AC_VERB_SET_PROC_COEF, 0x4278},
9193 			{ }
9194 		},
9195 		.chained = true,
9196 		.chain_id = ALC294_FIXUP_ASUS_ALLY_SPEAKER
9197 	},
9198 	[ALC294_FIXUP_ASUS_ALLY_SPEAKER] = {
9199 		.type = HDA_FIXUP_FUNC,
9200 		.v.func = alc285_fixup_speaker2_to_dac1,
9201 	},
9202 	[ALC285_FIXUP_THINKPAD_X1_GEN7] = {
9203 		.type = HDA_FIXUP_FUNC,
9204 		.v.func = alc285_fixup_thinkpad_x1_gen7,
9205 		.chained = true,
9206 		.chain_id = ALC269_FIXUP_THINKPAD_ACPI
9207 	},
9208 	[ALC285_FIXUP_THINKPAD_HEADSET_JACK] = {
9209 		.type = HDA_FIXUP_FUNC,
9210 		.v.func = alc_fixup_headset_jack,
9211 		.chained = true,
9212 		.chain_id = ALC285_FIXUP_THINKPAD_X1_GEN7
9213 	},
9214 	[ALC294_FIXUP_ASUS_HPE] = {
9215 		.type = HDA_FIXUP_VERBS,
9216 		.v.verbs = (const struct hda_verb[]) {
9217 			/* Set EAPD high */
9218 			{ 0x20, AC_VERB_SET_COEF_INDEX, 0x0f },
9219 			{ 0x20, AC_VERB_SET_PROC_COEF, 0x7774 },
9220 			{ }
9221 		},
9222 		.chained = true,
9223 		.chain_id = ALC294_FIXUP_ASUS_HEADSET_MIC
9224 	},
9225 	[ALC294_FIXUP_ASUS_GX502_PINS] = {
9226 		.type = HDA_FIXUP_PINS,
9227 		.v.pins = (const struct hda_pintbl[]) {
9228 			{ 0x19, 0x03a11050 }, /* front HP mic */
9229 			{ 0x1a, 0x01a11830 }, /* rear external mic */
9230 			{ 0x21, 0x03211020 }, /* front HP out */
9231 			{ }
9232 		},
9233 		.chained = true,
9234 		.chain_id = ALC294_FIXUP_ASUS_GX502_VERBS
9235 	},
9236 	[ALC294_FIXUP_ASUS_GX502_VERBS] = {
9237 		.type = HDA_FIXUP_VERBS,
9238 		.v.verbs = (const struct hda_verb[]) {
9239 			/* set 0x15 to HP-OUT ctrl */
9240 			{ 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0 },
9241 			/* unmute the 0x15 amp */
9242 			{ 0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000 },
9243 			{ }
9244 		},
9245 		.chained = true,
9246 		.chain_id = ALC294_FIXUP_ASUS_GX502_HP
9247 	},
9248 	[ALC294_FIXUP_ASUS_GX502_HP] = {
9249 		.type = HDA_FIXUP_FUNC,
9250 		.v.func = alc294_fixup_gx502_hp,
9251 	},
9252 	[ALC294_FIXUP_ASUS_GU502_PINS] = {
9253 		.type = HDA_FIXUP_PINS,
9254 		.v.pins = (const struct hda_pintbl[]) {
9255 			{ 0x19, 0x01a11050 }, /* rear HP mic */
9256 			{ 0x1a, 0x01a11830 }, /* rear external mic */
9257 			{ 0x21, 0x012110f0 }, /* rear HP out */
9258 			{ }
9259 		},
9260 		.chained = true,
9261 		.chain_id = ALC294_FIXUP_ASUS_GU502_VERBS
9262 	},
9263 	[ALC294_FIXUP_ASUS_GU502_VERBS] = {
9264 		.type = HDA_FIXUP_VERBS,
9265 		.v.verbs = (const struct hda_verb[]) {
9266 			/* set 0x15 to HP-OUT ctrl */
9267 			{ 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0 },
9268 			/* unmute the 0x15 amp */
9269 			{ 0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000 },
9270 			/* set 0x1b to HP-OUT */
9271 			{ 0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
9272 			{ }
9273 		},
9274 		.chained = true,
9275 		.chain_id = ALC294_FIXUP_ASUS_GU502_HP
9276 	},
9277 	[ALC294_FIXUP_ASUS_GU502_HP] = {
9278 		.type = HDA_FIXUP_FUNC,
9279 		.v.func = alc294_fixup_gu502_hp,
9280 	},
9281 	 [ALC294_FIXUP_ASUS_G513_PINS] = {
9282 		.type = HDA_FIXUP_PINS,
9283 		.v.pins = (const struct hda_pintbl[]) {
9284 				{ 0x19, 0x03a11050 }, /* front HP mic */
9285 				{ 0x1a, 0x03a11c30 }, /* rear external mic */
9286 				{ 0x21, 0x03211420 }, /* front HP out */
9287 				{ }
9288 		},
9289 	},
9290 	[ALC285_FIXUP_ASUS_G533Z_PINS] = {
9291 		.type = HDA_FIXUP_PINS,
9292 		.v.pins = (const struct hda_pintbl[]) {
9293 			{ 0x14, 0x90170152 }, /* Speaker Surround Playback Switch */
9294 			{ 0x19, 0x03a19020 }, /* Mic Boost Volume */
9295 			{ 0x1a, 0x03a11c30 }, /* Mic Boost Volume */
9296 			{ 0x1e, 0x90170151 }, /* Rear jack, IN OUT EAPD Detect */
9297 			{ 0x21, 0x03211420 },
9298 			{ }
9299 		},
9300 	},
9301 	[ALC294_FIXUP_ASUS_COEF_1B] = {
9302 		.type = HDA_FIXUP_VERBS,
9303 		.v.verbs = (const struct hda_verb[]) {
9304 			/* Set bit 10 to correct noisy output after reboot from
9305 			 * Windows 10 (due to pop noise reduction?)
9306 			 */
9307 			{ 0x20, AC_VERB_SET_COEF_INDEX, 0x1b },
9308 			{ 0x20, AC_VERB_SET_PROC_COEF, 0x4e4b },
9309 			{ }
9310 		},
9311 		.chained = true,
9312 		.chain_id = ALC289_FIXUP_ASUS_GA401,
9313 	},
9314 	[ALC285_FIXUP_HP_GPIO_LED] = {
9315 		.type = HDA_FIXUP_FUNC,
9316 		.v.func = alc285_fixup_hp_gpio_led,
9317 	},
9318 	[ALC285_FIXUP_HP_MUTE_LED] = {
9319 		.type = HDA_FIXUP_FUNC,
9320 		.v.func = alc285_fixup_hp_mute_led,
9321 	},
9322 	[ALC285_FIXUP_HP_SPECTRE_X360_MUTE_LED] = {
9323 		.type = HDA_FIXUP_FUNC,
9324 		.v.func = alc285_fixup_hp_spectre_x360_mute_led,
9325 	},
9326 	[ALC236_FIXUP_HP_MUTE_LED_COEFBIT2] = {
9327 	    .type = HDA_FIXUP_FUNC,
9328 	    .v.func = alc236_fixup_hp_mute_led_coefbit2,
9329 	},
9330 	[ALC236_FIXUP_HP_GPIO_LED] = {
9331 		.type = HDA_FIXUP_FUNC,
9332 		.v.func = alc236_fixup_hp_gpio_led,
9333 	},
9334 	[ALC236_FIXUP_HP_MUTE_LED] = {
9335 		.type = HDA_FIXUP_FUNC,
9336 		.v.func = alc236_fixup_hp_mute_led,
9337 	},
9338 	[ALC236_FIXUP_HP_MUTE_LED_MICMUTE_VREF] = {
9339 		.type = HDA_FIXUP_FUNC,
9340 		.v.func = alc236_fixup_hp_mute_led_micmute_vref,
9341 	},
9342 	[ALC236_FIXUP_LENOVO_INV_DMIC] = {
9343 		.type = HDA_FIXUP_FUNC,
9344 		.v.func = alc_fixup_inv_dmic,
9345 		.chained = true,
9346 		.chain_id = ALC283_FIXUP_INT_MIC,
9347 	},
9348 	[ALC298_FIXUP_SAMSUNG_AMP] = {
9349 		.type = HDA_FIXUP_FUNC,
9350 		.v.func = alc298_fixup_samsung_amp,
9351 		.chained = true,
9352 		.chain_id = ALC298_FIXUP_SAMSUNG_HEADPHONE_VERY_QUIET
9353 	},
9354 	[ALC298_FIXUP_SAMSUNG_AMP_V2_2_AMPS] = {
9355 		.type = HDA_FIXUP_FUNC,
9356 		.v.func = alc298_fixup_samsung_amp_v2_2_amps
9357 	},
9358 	[ALC298_FIXUP_SAMSUNG_AMP_V2_4_AMPS] = {
9359 		.type = HDA_FIXUP_FUNC,
9360 		.v.func = alc298_fixup_samsung_amp_v2_4_amps
9361 	},
9362 	[ALC298_FIXUP_SAMSUNG_HEADPHONE_VERY_QUIET] = {
9363 		.type = HDA_FIXUP_VERBS,
9364 		.v.verbs = (const struct hda_verb[]) {
9365 			{ 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc5 },
9366 			{ }
9367 		},
9368 	},
9369 	[ALC256_FIXUP_SAMSUNG_HEADPHONE_VERY_QUIET] = {
9370 		.type = HDA_FIXUP_VERBS,
9371 		.v.verbs = (const struct hda_verb[]) {
9372 			{ 0x20, AC_VERB_SET_COEF_INDEX, 0x08},
9373 			{ 0x20, AC_VERB_SET_PROC_COEF, 0x2fcf},
9374 			{ }
9375 		},
9376 	},
9377 	[ALC295_FIXUP_ASUS_MIC_NO_PRESENCE] = {
9378 		.type = HDA_FIXUP_PINS,
9379 		.v.pins = (const struct hda_pintbl[]) {
9380 			{ 0x19, 0x01a1913c }, /* use as headset mic, without its own jack detect */
9381 			{ }
9382 		},
9383 		.chained = true,
9384 		.chain_id = ALC269_FIXUP_HEADSET_MODE
9385 	},
9386 	[ALC269VC_FIXUP_ACER_VCOPPERBOX_PINS] = {
9387 		.type = HDA_FIXUP_PINS,
9388 		.v.pins = (const struct hda_pintbl[]) {
9389 			{ 0x14, 0x90100120 }, /* use as internal speaker */
9390 			{ 0x18, 0x02a111f0 }, /* use as headset mic, without its own jack detect */
9391 			{ 0x1a, 0x01011020 }, /* use as line out */
9392 			{ },
9393 		},
9394 		.chained = true,
9395 		.chain_id = ALC269_FIXUP_HEADSET_MIC
9396 	},
9397 	[ALC269VC_FIXUP_ACER_HEADSET_MIC] = {
9398 		.type = HDA_FIXUP_PINS,
9399 		.v.pins = (const struct hda_pintbl[]) {
9400 			{ 0x18, 0x02a11030 }, /* use as headset mic */
9401 			{ }
9402 		},
9403 		.chained = true,
9404 		.chain_id = ALC269_FIXUP_HEADSET_MIC
9405 	},
9406 	[ALC269VC_FIXUP_ACER_MIC_NO_PRESENCE] = {
9407 		.type = HDA_FIXUP_PINS,
9408 		.v.pins = (const struct hda_pintbl[]) {
9409 			{ 0x18, 0x01a11130 }, /* use as headset mic, without its own jack detect */
9410 			{ }
9411 		},
9412 		.chained = true,
9413 		.chain_id = ALC269_FIXUP_HEADSET_MIC
9414 	},
9415 	[ALC289_FIXUP_ASUS_GA401] = {
9416 		.type = HDA_FIXUP_FUNC,
9417 		.v.func = alc289_fixup_asus_ga401,
9418 		.chained = true,
9419 		.chain_id = ALC289_FIXUP_ASUS_GA502,
9420 	},
9421 	[ALC289_FIXUP_ASUS_GA502] = {
9422 		.type = HDA_FIXUP_PINS,
9423 		.v.pins = (const struct hda_pintbl[]) {
9424 			{ 0x19, 0x03a11020 }, /* headset mic with jack detect */
9425 			{ }
9426 		},
9427 	},
9428 	[ALC256_FIXUP_ACER_MIC_NO_PRESENCE] = {
9429 		.type = HDA_FIXUP_PINS,
9430 		.v.pins = (const struct hda_pintbl[]) {
9431 			{ 0x19, 0x02a11120 }, /* use as headset mic, without its own jack detect */
9432 			{ }
9433 		},
9434 		.chained = true,
9435 		.chain_id = ALC256_FIXUP_ASUS_HEADSET_MODE
9436 	},
9437 	[ALC285_FIXUP_HP_GPIO_AMP_INIT] = {
9438 		.type = HDA_FIXUP_FUNC,
9439 		.v.func = alc285_fixup_hp_gpio_amp_init,
9440 		.chained = true,
9441 		.chain_id = ALC285_FIXUP_HP_GPIO_LED
9442 	},
9443 	[ALC269_FIXUP_CZC_B20] = {
9444 		.type = HDA_FIXUP_PINS,
9445 		.v.pins = (const struct hda_pintbl[]) {
9446 			{ 0x12, 0x411111f0 },
9447 			{ 0x14, 0x90170110 }, /* speaker */
9448 			{ 0x15, 0x032f1020 }, /* HP out */
9449 			{ 0x17, 0x411111f0 },
9450 			{ 0x18, 0x03ab1040 }, /* mic */
9451 			{ 0x19, 0xb7a7013f },
9452 			{ 0x1a, 0x0181305f },
9453 			{ 0x1b, 0x411111f0 },
9454 			{ 0x1d, 0x411111f0 },
9455 			{ 0x1e, 0x411111f0 },
9456 			{ }
9457 		},
9458 		.chain_id = ALC269_FIXUP_DMIC,
9459 	},
9460 	[ALC269_FIXUP_CZC_TMI] = {
9461 		.type = HDA_FIXUP_PINS,
9462 		.v.pins = (const struct hda_pintbl[]) {
9463 			{ 0x12, 0x4000c000 },
9464 			{ 0x14, 0x90170110 }, /* speaker */
9465 			{ 0x15, 0x0421401f }, /* HP out */
9466 			{ 0x17, 0x411111f0 },
9467 			{ 0x18, 0x04a19020 }, /* mic */
9468 			{ 0x19, 0x411111f0 },
9469 			{ 0x1a, 0x411111f0 },
9470 			{ 0x1b, 0x411111f0 },
9471 			{ 0x1d, 0x40448505 },
9472 			{ 0x1e, 0x411111f0 },
9473 			{ 0x20, 0x8000ffff },
9474 			{ }
9475 		},
9476 		.chain_id = ALC269_FIXUP_DMIC,
9477 	},
9478 	[ALC269_FIXUP_CZC_L101] = {
9479 		.type = HDA_FIXUP_PINS,
9480 		.v.pins = (const struct hda_pintbl[]) {
9481 			{ 0x12, 0x40000000 },
9482 			{ 0x14, 0x01014010 }, /* speaker */
9483 			{ 0x15, 0x411111f0 }, /* HP out */
9484 			{ 0x16, 0x411111f0 },
9485 			{ 0x18, 0x01a19020 }, /* mic */
9486 			{ 0x19, 0x02a19021 },
9487 			{ 0x1a, 0x0181302f },
9488 			{ 0x1b, 0x0221401f },
9489 			{ 0x1c, 0x411111f0 },
9490 			{ 0x1d, 0x4044c601 },
9491 			{ 0x1e, 0x411111f0 },
9492 			{ }
9493 		},
9494 		.chain_id = ALC269_FIXUP_DMIC,
9495 	},
9496 	[ALC269_FIXUP_LEMOTE_A1802] = {
9497 		.type = HDA_FIXUP_PINS,
9498 		.v.pins = (const struct hda_pintbl[]) {
9499 			{ 0x12, 0x40000000 },
9500 			{ 0x14, 0x90170110 }, /* speaker */
9501 			{ 0x17, 0x411111f0 },
9502 			{ 0x18, 0x03a19040 }, /* mic1 */
9503 			{ 0x19, 0x90a70130 }, /* mic2 */
9504 			{ 0x1a, 0x411111f0 },
9505 			{ 0x1b, 0x411111f0 },
9506 			{ 0x1d, 0x40489d2d },
9507 			{ 0x1e, 0x411111f0 },
9508 			{ 0x20, 0x0003ffff },
9509 			{ 0x21, 0x03214020 },
9510 			{ }
9511 		},
9512 		.chain_id = ALC269_FIXUP_DMIC,
9513 	},
9514 	[ALC269_FIXUP_LEMOTE_A190X] = {
9515 		.type = HDA_FIXUP_PINS,
9516 		.v.pins = (const struct hda_pintbl[]) {
9517 			{ 0x14, 0x99130110 }, /* speaker */
9518 			{ 0x15, 0x0121401f }, /* HP out */
9519 			{ 0x18, 0x01a19c20 }, /* rear  mic */
9520 			{ 0x19, 0x99a3092f }, /* front mic */
9521 			{ 0x1b, 0x0201401f }, /* front lineout */
9522 			{ }
9523 		},
9524 		.chain_id = ALC269_FIXUP_DMIC,
9525 	},
9526 	[ALC256_FIXUP_INTEL_NUC8_RUGGED] = {
9527 		.type = HDA_FIXUP_PINS,
9528 		.v.pins = (const struct hda_pintbl[]) {
9529 			{ 0x1b, 0x01a1913c }, /* use as headset mic, without its own jack detect */
9530 			{ }
9531 		},
9532 		.chained = true,
9533 		.chain_id = ALC269_FIXUP_HEADSET_MODE
9534 	},
9535 	[ALC256_FIXUP_INTEL_NUC10] = {
9536 		.type = HDA_FIXUP_PINS,
9537 		.v.pins = (const struct hda_pintbl[]) {
9538 			{ 0x19, 0x01a1913c }, /* use as headset mic, without its own jack detect */
9539 			{ }
9540 		},
9541 		.chained = true,
9542 		.chain_id = ALC269_FIXUP_HEADSET_MODE
9543 	},
9544 	[ALC255_FIXUP_XIAOMI_HEADSET_MIC] = {
9545 		.type = HDA_FIXUP_VERBS,
9546 		.v.verbs = (const struct hda_verb[]) {
9547 			{ 0x20, AC_VERB_SET_COEF_INDEX, 0x45 },
9548 			{ 0x20, AC_VERB_SET_PROC_COEF, 0x5089 },
9549 			{ }
9550 		},
9551 		.chained = true,
9552 		.chain_id = ALC289_FIXUP_ASUS_GA502
9553 	},
9554 	[ALC274_FIXUP_HP_MIC] = {
9555 		.type = HDA_FIXUP_VERBS,
9556 		.v.verbs = (const struct hda_verb[]) {
9557 			{ 0x20, AC_VERB_SET_COEF_INDEX, 0x45 },
9558 			{ 0x20, AC_VERB_SET_PROC_COEF, 0x5089 },
9559 			{ }
9560 		},
9561 	},
9562 	[ALC274_FIXUP_HP_HEADSET_MIC] = {
9563 		.type = HDA_FIXUP_FUNC,
9564 		.v.func = alc274_fixup_hp_headset_mic,
9565 		.chained = true,
9566 		.chain_id = ALC274_FIXUP_HP_MIC
9567 	},
9568 	[ALC274_FIXUP_HP_ENVY_GPIO] = {
9569 		.type = HDA_FIXUP_FUNC,
9570 		.v.func = alc274_fixup_hp_envy_gpio,
9571 	},
9572 	[ALC256_FIXUP_ASUS_HPE] = {
9573 		.type = HDA_FIXUP_VERBS,
9574 		.v.verbs = (const struct hda_verb[]) {
9575 			/* Set EAPD high */
9576 			{ 0x20, AC_VERB_SET_COEF_INDEX, 0x0f },
9577 			{ 0x20, AC_VERB_SET_PROC_COEF, 0x7778 },
9578 			{ }
9579 		},
9580 		.chained = true,
9581 		.chain_id = ALC294_FIXUP_ASUS_HEADSET_MIC
9582 	},
9583 	[ALC285_FIXUP_THINKPAD_NO_BASS_SPK_HEADSET_JACK] = {
9584 		.type = HDA_FIXUP_FUNC,
9585 		.v.func = alc_fixup_headset_jack,
9586 		.chained = true,
9587 		.chain_id = ALC269_FIXUP_THINKPAD_ACPI
9588 	},
9589 	[ALC287_FIXUP_HP_GPIO_LED] = {
9590 		.type = HDA_FIXUP_FUNC,
9591 		.v.func = alc287_fixup_hp_gpio_led,
9592 	},
9593 	[ALC256_FIXUP_HP_HEADSET_MIC] = {
9594 		.type = HDA_FIXUP_FUNC,
9595 		.v.func = alc274_fixup_hp_headset_mic,
9596 	},
9597 	[ALC236_FIXUP_DELL_AIO_HEADSET_MIC] = {
9598 		.type = HDA_FIXUP_FUNC,
9599 		.v.func = alc_fixup_no_int_mic,
9600 		.chained = true,
9601 		.chain_id = ALC255_FIXUP_DELL1_MIC_NO_PRESENCE
9602 	},
9603 	[ALC282_FIXUP_ACER_DISABLE_LINEOUT] = {
9604 		.type = HDA_FIXUP_PINS,
9605 		.v.pins = (const struct hda_pintbl[]) {
9606 			{ 0x1b, 0x411111f0 },
9607 			{ 0x18, 0x01a1913c }, /* use as headset mic, without its own jack detect */
9608 			{ },
9609 		},
9610 		.chained = true,
9611 		.chain_id = ALC269_FIXUP_HEADSET_MODE
9612 	},
9613 	[ALC255_FIXUP_ACER_LIMIT_INT_MIC_BOOST] = {
9614 		.type = HDA_FIXUP_FUNC,
9615 		.v.func = alc269_fixup_limit_int_mic_boost,
9616 		.chained = true,
9617 		.chain_id = ALC255_FIXUP_ACER_MIC_NO_PRESENCE,
9618 	},
9619 	[ALC256_FIXUP_ACER_HEADSET_MIC] = {
9620 		.type = HDA_FIXUP_PINS,
9621 		.v.pins = (const struct hda_pintbl[]) {
9622 			{ 0x19, 0x02a1113c }, /* use as headset mic, without its own jack detect */
9623 			{ 0x1a, 0x90a1092f }, /* use as internal mic */
9624 			{ }
9625 		},
9626 		.chained = true,
9627 		.chain_id = ALC269_FIXUP_HEADSET_MODE_NO_HP_MIC
9628 	},
9629 	[ALC285_FIXUP_IDEAPAD_S740_COEF] = {
9630 		.type = HDA_FIXUP_FUNC,
9631 		.v.func = alc285_fixup_ideapad_s740_coef,
9632 		.chained = true,
9633 		.chain_id = ALC269_FIXUP_THINKPAD_ACPI,
9634 	},
9635 	[ALC285_FIXUP_HP_LIMIT_INT_MIC_BOOST] = {
9636 		.type = HDA_FIXUP_FUNC,
9637 		.v.func = alc269_fixup_limit_int_mic_boost,
9638 		.chained = true,
9639 		.chain_id = ALC285_FIXUP_HP_MUTE_LED,
9640 	},
9641 	[ALC295_FIXUP_ASUS_DACS] = {
9642 		.type = HDA_FIXUP_FUNC,
9643 		.v.func = alc295_fixup_asus_dacs,
9644 	},
9645 	[ALC295_FIXUP_HP_OMEN] = {
9646 		.type = HDA_FIXUP_PINS,
9647 		.v.pins = (const struct hda_pintbl[]) {
9648 			{ 0x12, 0xb7a60130 },
9649 			{ 0x13, 0x40000000 },
9650 			{ 0x14, 0x411111f0 },
9651 			{ 0x16, 0x411111f0 },
9652 			{ 0x17, 0x90170110 },
9653 			{ 0x18, 0x411111f0 },
9654 			{ 0x19, 0x02a11030 },
9655 			{ 0x1a, 0x411111f0 },
9656 			{ 0x1b, 0x04a19030 },
9657 			{ 0x1d, 0x40600001 },
9658 			{ 0x1e, 0x411111f0 },
9659 			{ 0x21, 0x03211020 },
9660 			{}
9661 		},
9662 		.chained = true,
9663 		.chain_id = ALC269_FIXUP_HP_LINE1_MIC1_LED,
9664 	},
9665 	[ALC285_FIXUP_HP_SPECTRE_X360] = {
9666 		.type = HDA_FIXUP_FUNC,
9667 		.v.func = alc285_fixup_hp_spectre_x360,
9668 	},
9669 	[ALC285_FIXUP_HP_SPECTRE_X360_EB1] = {
9670 		.type = HDA_FIXUP_FUNC,
9671 		.v.func = alc285_fixup_hp_spectre_x360_eb1
9672 	},
9673 	[ALC285_FIXUP_HP_ENVY_X360] = {
9674 		.type = HDA_FIXUP_FUNC,
9675 		.v.func = alc285_fixup_hp_envy_x360,
9676 		.chained = true,
9677 		.chain_id = ALC285_FIXUP_HP_GPIO_AMP_INIT,
9678 	},
9679 	[ALC287_FIXUP_IDEAPAD_BASS_SPK_AMP] = {
9680 		.type = HDA_FIXUP_FUNC,
9681 		.v.func = alc285_fixup_ideapad_s740_coef,
9682 		.chained = true,
9683 		.chain_id = ALC285_FIXUP_THINKPAD_HEADSET_JACK,
9684 	},
9685 	[ALC623_FIXUP_LENOVO_THINKSTATION_P340] = {
9686 		.type = HDA_FIXUP_FUNC,
9687 		.v.func = alc_fixup_no_shutup,
9688 		.chained = true,
9689 		.chain_id = ALC283_FIXUP_HEADSET_MIC,
9690 	},
9691 	[ALC255_FIXUP_ACER_HEADPHONE_AND_MIC] = {
9692 		.type = HDA_FIXUP_PINS,
9693 		.v.pins = (const struct hda_pintbl[]) {
9694 			{ 0x21, 0x03211030 }, /* Change the Headphone location to Left */
9695 			{ }
9696 		},
9697 		.chained = true,
9698 		.chain_id = ALC255_FIXUP_XIAOMI_HEADSET_MIC
9699 	},
9700 	[ALC236_FIXUP_HP_LIMIT_INT_MIC_BOOST] = {
9701 		.type = HDA_FIXUP_FUNC,
9702 		.v.func = alc269_fixup_limit_int_mic_boost,
9703 		.chained = true,
9704 		.chain_id = ALC236_FIXUP_HP_MUTE_LED_MICMUTE_VREF,
9705 	},
9706 	[ALC285_FIXUP_LEGION_Y9000X_SPEAKERS] = {
9707 		.type = HDA_FIXUP_FUNC,
9708 		.v.func = alc285_fixup_ideapad_s740_coef,
9709 		.chained = true,
9710 		.chain_id = ALC285_FIXUP_LEGION_Y9000X_AUTOMUTE,
9711 	},
9712 	[ALC285_FIXUP_LEGION_Y9000X_AUTOMUTE] = {
9713 		.type = HDA_FIXUP_FUNC,
9714 		.v.func = alc287_fixup_legion_15imhg05_speakers,
9715 		.chained = true,
9716 		.chain_id = ALC269_FIXUP_THINKPAD_ACPI,
9717 	},
9718 	[ALC287_FIXUP_LEGION_15IMHG05_SPEAKERS] = {
9719 		.type = HDA_FIXUP_VERBS,
9720 		//.v.verbs = legion_15imhg05_coefs,
9721 		.v.verbs = (const struct hda_verb[]) {
9722 			 // set left speaker Legion 7i.
9723 			 { 0x20, AC_VERB_SET_COEF_INDEX, 0x24 },
9724 			 { 0x20, AC_VERB_SET_PROC_COEF, 0x41 },
9725 
9726 			 { 0x20, AC_VERB_SET_COEF_INDEX, 0x26 },
9727 			 { 0x20, AC_VERB_SET_PROC_COEF, 0xc },
9728 			 { 0x20, AC_VERB_SET_PROC_COEF, 0x0 },
9729 			 { 0x20, AC_VERB_SET_PROC_COEF, 0x1a },
9730 			 { 0x20, AC_VERB_SET_PROC_COEF, 0xb020 },
9731 
9732 			 { 0x20, AC_VERB_SET_COEF_INDEX, 0x26 },
9733 			 { 0x20, AC_VERB_SET_PROC_COEF, 0x2 },
9734 			 { 0x20, AC_VERB_SET_PROC_COEF, 0x0 },
9735 			 { 0x20, AC_VERB_SET_PROC_COEF, 0x0 },
9736 			 { 0x20, AC_VERB_SET_PROC_COEF, 0xb020 },
9737 
9738 			 // set right speaker Legion 7i.
9739 			 { 0x20, AC_VERB_SET_COEF_INDEX, 0x24 },
9740 			 { 0x20, AC_VERB_SET_PROC_COEF, 0x42 },
9741 
9742 			 { 0x20, AC_VERB_SET_COEF_INDEX, 0x26 },
9743 			 { 0x20, AC_VERB_SET_PROC_COEF, 0xc },
9744 			 { 0x20, AC_VERB_SET_PROC_COEF, 0x0 },
9745 			 { 0x20, AC_VERB_SET_PROC_COEF, 0x2a },
9746 			 { 0x20, AC_VERB_SET_PROC_COEF, 0xb020 },
9747 
9748 			 { 0x20, AC_VERB_SET_COEF_INDEX, 0x26 },
9749 			 { 0x20, AC_VERB_SET_PROC_COEF, 0x2 },
9750 			 { 0x20, AC_VERB_SET_PROC_COEF, 0x0 },
9751 			 { 0x20, AC_VERB_SET_PROC_COEF, 0x0 },
9752 			 { 0x20, AC_VERB_SET_PROC_COEF, 0xb020 },
9753 			 {}
9754 		},
9755 		.chained = true,
9756 		.chain_id = ALC287_FIXUP_LEGION_15IMHG05_AUTOMUTE,
9757 	},
9758 	[ALC287_FIXUP_LEGION_15IMHG05_AUTOMUTE] = {
9759 		.type = HDA_FIXUP_FUNC,
9760 		.v.func = alc287_fixup_legion_15imhg05_speakers,
9761 		.chained = true,
9762 		.chain_id = ALC269_FIXUP_HEADSET_MODE,
9763 	},
9764 	[ALC287_FIXUP_YOGA7_14ITL_SPEAKERS] = {
9765 		.type = HDA_FIXUP_VERBS,
9766 		.v.verbs = (const struct hda_verb[]) {
9767 			 // set left speaker Yoga 7i.
9768 			 { 0x20, AC_VERB_SET_COEF_INDEX, 0x24 },
9769 			 { 0x20, AC_VERB_SET_PROC_COEF, 0x41 },
9770 
9771 			 { 0x20, AC_VERB_SET_COEF_INDEX, 0x26 },
9772 			 { 0x20, AC_VERB_SET_PROC_COEF, 0xc },
9773 			 { 0x20, AC_VERB_SET_PROC_COEF, 0x0 },
9774 			 { 0x20, AC_VERB_SET_PROC_COEF, 0x1a },
9775 			 { 0x20, AC_VERB_SET_PROC_COEF, 0xb020 },
9776 
9777 			 { 0x20, AC_VERB_SET_COEF_INDEX, 0x26 },
9778 			 { 0x20, AC_VERB_SET_PROC_COEF, 0x2 },
9779 			 { 0x20, AC_VERB_SET_PROC_COEF, 0x0 },
9780 			 { 0x20, AC_VERB_SET_PROC_COEF, 0x0 },
9781 			 { 0x20, AC_VERB_SET_PROC_COEF, 0xb020 },
9782 
9783 			 // set right speaker Yoga 7i.
9784 			 { 0x20, AC_VERB_SET_COEF_INDEX, 0x24 },
9785 			 { 0x20, AC_VERB_SET_PROC_COEF, 0x46 },
9786 
9787 			 { 0x20, AC_VERB_SET_COEF_INDEX, 0x26 },
9788 			 { 0x20, AC_VERB_SET_PROC_COEF, 0xc },
9789 			 { 0x20, AC_VERB_SET_PROC_COEF, 0x0 },
9790 			 { 0x20, AC_VERB_SET_PROC_COEF, 0x2a },
9791 			 { 0x20, AC_VERB_SET_PROC_COEF, 0xb020 },
9792 
9793 			 { 0x20, AC_VERB_SET_COEF_INDEX, 0x26 },
9794 			 { 0x20, AC_VERB_SET_PROC_COEF, 0x2 },
9795 			 { 0x20, AC_VERB_SET_PROC_COEF, 0x0 },
9796 			 { 0x20, AC_VERB_SET_PROC_COEF, 0x0 },
9797 			 { 0x20, AC_VERB_SET_PROC_COEF, 0xb020 },
9798 			 {}
9799 		},
9800 		.chained = true,
9801 		.chain_id = ALC269_FIXUP_HEADSET_MODE,
9802 	},
9803 	[ALC298_FIXUP_LENOVO_C940_DUET7] = {
9804 		.type = HDA_FIXUP_FUNC,
9805 		.v.func = alc298_fixup_lenovo_c940_duet7,
9806 	},
9807 	[ALC287_FIXUP_LENOVO_14IRP8_DUETITL] = {
9808 		.type = HDA_FIXUP_FUNC,
9809 		.v.func = alc287_fixup_lenovo_14irp8_duetitl,
9810 	},
9811 	[ALC287_FIXUP_LENOVO_LEGION_7] = {
9812 		.type = HDA_FIXUP_FUNC,
9813 		.v.func = alc287_fixup_lenovo_legion_7,
9814 	},
9815 	[ALC287_FIXUP_13S_GEN2_SPEAKERS] = {
9816 		.type = HDA_FIXUP_VERBS,
9817 		.v.verbs = (const struct hda_verb[]) {
9818 			{ 0x20, AC_VERB_SET_COEF_INDEX, 0x24 },
9819 			{ 0x20, AC_VERB_SET_PROC_COEF, 0x41 },
9820 			{ 0x20, AC_VERB_SET_COEF_INDEX, 0x26 },
9821 			{ 0x20, AC_VERB_SET_PROC_COEF, 0x2 },
9822 			{ 0x20, AC_VERB_SET_PROC_COEF, 0x0 },
9823 			{ 0x20, AC_VERB_SET_PROC_COEF, 0x0 },
9824 			{ 0x20, AC_VERB_SET_PROC_COEF, 0xb020 },
9825 			{ 0x20, AC_VERB_SET_COEF_INDEX, 0x24 },
9826 			{ 0x20, AC_VERB_SET_PROC_COEF, 0x42 },
9827 			{ 0x20, AC_VERB_SET_COEF_INDEX, 0x26 },
9828 			{ 0x20, AC_VERB_SET_PROC_COEF, 0x2 },
9829 			{ 0x20, AC_VERB_SET_PROC_COEF, 0x0 },
9830 			{ 0x20, AC_VERB_SET_PROC_COEF, 0x0 },
9831 			{ 0x20, AC_VERB_SET_PROC_COEF, 0xb020 },
9832 			{}
9833 		},
9834 		.chained = true,
9835 		.chain_id = ALC269_FIXUP_HEADSET_MODE,
9836 	},
9837 	[ALC256_FIXUP_SET_COEF_DEFAULTS] = {
9838 		.type = HDA_FIXUP_FUNC,
9839 		.v.func = alc256_fixup_set_coef_defaults,
9840 	},
9841 	[ALC245_FIXUP_HP_GPIO_LED] = {
9842 		.type = HDA_FIXUP_FUNC,
9843 		.v.func = alc245_fixup_hp_gpio_led,
9844 	},
9845 	[ALC256_FIXUP_SYSTEM76_MIC_NO_PRESENCE] = {
9846 		.type = HDA_FIXUP_PINS,
9847 		.v.pins = (const struct hda_pintbl[]) {
9848 			{ 0x19, 0x03a11120 }, /* use as headset mic, without its own jack detect */
9849 			{ }
9850 		},
9851 		.chained = true,
9852 		.chain_id = ALC269_FIXUP_HEADSET_MODE_NO_HP_MIC,
9853 	},
9854 	[ALC233_FIXUP_NO_AUDIO_JACK] = {
9855 		.type = HDA_FIXUP_FUNC,
9856 		.v.func = alc233_fixup_no_audio_jack,
9857 	},
9858 	[ALC256_FIXUP_MIC_NO_PRESENCE_AND_RESUME] = {
9859 		.type = HDA_FIXUP_FUNC,
9860 		.v.func = alc256_fixup_mic_no_presence_and_resume,
9861 		.chained = true,
9862 		.chain_id = ALC269_FIXUP_HEADSET_MODE_NO_HP_MIC
9863 	},
9864 	[ALC287_FIXUP_LEGION_16ACHG6] = {
9865 		.type = HDA_FIXUP_FUNC,
9866 		.v.func = alc287_fixup_legion_16achg6_speakers,
9867 	},
9868 	[ALC287_FIXUP_CS35L41_I2C_2] = {
9869 		.type = HDA_FIXUP_FUNC,
9870 		.v.func = cs35l41_fixup_i2c_two,
9871 	},
9872 	[ALC287_FIXUP_CS35L41_I2C_2_HP_GPIO_LED] = {
9873 		.type = HDA_FIXUP_FUNC,
9874 		.v.func = cs35l41_fixup_i2c_two,
9875 		.chained = true,
9876 		.chain_id = ALC285_FIXUP_HP_MUTE_LED,
9877 	},
9878 	[ALC287_FIXUP_CS35L41_I2C_4] = {
9879 		.type = HDA_FIXUP_FUNC,
9880 		.v.func = cs35l41_fixup_i2c_four,
9881 	},
9882 	[ALC245_FIXUP_CS35L41_SPI_2] = {
9883 		.type = HDA_FIXUP_FUNC,
9884 		.v.func = cs35l41_fixup_spi_two,
9885 	},
9886 	[ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED] = {
9887 		.type = HDA_FIXUP_FUNC,
9888 		.v.func = cs35l41_fixup_spi_two,
9889 		.chained = true,
9890 		.chain_id = ALC285_FIXUP_HP_GPIO_LED,
9891 	},
9892 	[ALC245_FIXUP_CS35L41_SPI_4] = {
9893 		.type = HDA_FIXUP_FUNC,
9894 		.v.func = cs35l41_fixup_spi_four,
9895 	},
9896 	[ALC245_FIXUP_CS35L41_SPI_4_HP_GPIO_LED] = {
9897 		.type = HDA_FIXUP_FUNC,
9898 		.v.func = cs35l41_fixup_spi_four,
9899 		.chained = true,
9900 		.chain_id = ALC285_FIXUP_HP_GPIO_LED,
9901 	},
9902 	[ALC285_FIXUP_HP_SPEAKERS_MICMUTE_LED] = {
9903 		.type = HDA_FIXUP_VERBS,
9904 		.v.verbs = (const struct hda_verb[]) {
9905 			 { 0x20, AC_VERB_SET_COEF_INDEX, 0x19 },
9906 			 { 0x20, AC_VERB_SET_PROC_COEF, 0x8e11 },
9907 			 { }
9908 		},
9909 		.chained = true,
9910 		.chain_id = ALC285_FIXUP_HP_MUTE_LED,
9911 	},
9912 	[ALC269_FIXUP_DELL4_MIC_NO_PRESENCE_QUIET] = {
9913 		.type = HDA_FIXUP_FUNC,
9914 		.v.func = alc_fixup_dell4_mic_no_presence_quiet,
9915 		.chained = true,
9916 		.chain_id = ALC269_FIXUP_DELL4_MIC_NO_PRESENCE,
9917 	},
9918 	[ALC295_FIXUP_FRAMEWORK_LAPTOP_MIC_NO_PRESENCE] = {
9919 		.type = HDA_FIXUP_PINS,
9920 		.v.pins = (const struct hda_pintbl[]) {
9921 			{ 0x19, 0x02a1112c }, /* use as headset mic, without its own jack detect */
9922 			{ }
9923 		},
9924 		.chained = true,
9925 		.chain_id = ALC269_FIXUP_HEADSET_MODE_NO_HP_MIC
9926 	},
9927 	[ALC287_FIXUP_LEGION_16ITHG6] = {
9928 		.type = HDA_FIXUP_FUNC,
9929 		.v.func = alc287_fixup_legion_16ithg6_speakers,
9930 	},
9931 	[ALC287_FIXUP_YOGA9_14IAP7_BASS_SPK] = {
9932 		.type = HDA_FIXUP_VERBS,
9933 		.v.verbs = (const struct hda_verb[]) {
9934 			// enable left speaker
9935 			{ 0x20, AC_VERB_SET_COEF_INDEX, 0x24 },
9936 			{ 0x20, AC_VERB_SET_PROC_COEF, 0x41 },
9937 
9938 			{ 0x20, AC_VERB_SET_COEF_INDEX, 0x26 },
9939 			{ 0x20, AC_VERB_SET_PROC_COEF, 0xc },
9940 			{ 0x20, AC_VERB_SET_PROC_COEF, 0x0 },
9941 			{ 0x20, AC_VERB_SET_PROC_COEF, 0x1a },
9942 			{ 0x20, AC_VERB_SET_PROC_COEF, 0xb020 },
9943 
9944 			{ 0x20, AC_VERB_SET_COEF_INDEX, 0x26 },
9945 			{ 0x20, AC_VERB_SET_PROC_COEF, 0xf },
9946 			{ 0x20, AC_VERB_SET_PROC_COEF, 0x0 },
9947 			{ 0x20, AC_VERB_SET_PROC_COEF, 0x42 },
9948 			{ 0x20, AC_VERB_SET_PROC_COEF, 0xb020 },
9949 
9950 			{ 0x20, AC_VERB_SET_COEF_INDEX, 0x26 },
9951 			{ 0x20, AC_VERB_SET_PROC_COEF, 0x10 },
9952 			{ 0x20, AC_VERB_SET_PROC_COEF, 0x0 },
9953 			{ 0x20, AC_VERB_SET_PROC_COEF, 0x40 },
9954 			{ 0x20, AC_VERB_SET_PROC_COEF, 0xb020 },
9955 
9956 			{ 0x20, AC_VERB_SET_COEF_INDEX, 0x26 },
9957 			{ 0x20, AC_VERB_SET_PROC_COEF, 0x2 },
9958 			{ 0x20, AC_VERB_SET_PROC_COEF, 0x0 },
9959 			{ 0x20, AC_VERB_SET_PROC_COEF, 0x0 },
9960 			{ 0x20, AC_VERB_SET_PROC_COEF, 0xb020 },
9961 
9962 			// enable right speaker
9963 			{ 0x20, AC_VERB_SET_COEF_INDEX, 0x24 },
9964 			{ 0x20, AC_VERB_SET_PROC_COEF, 0x46 },
9965 
9966 			{ 0x20, AC_VERB_SET_COEF_INDEX, 0x26 },
9967 			{ 0x20, AC_VERB_SET_PROC_COEF, 0xc },
9968 			{ 0x20, AC_VERB_SET_PROC_COEF, 0x0 },
9969 			{ 0x20, AC_VERB_SET_PROC_COEF, 0x2a },
9970 			{ 0x20, AC_VERB_SET_PROC_COEF, 0xb020 },
9971 
9972 			{ 0x20, AC_VERB_SET_COEF_INDEX, 0x26 },
9973 			{ 0x20, AC_VERB_SET_PROC_COEF, 0xf },
9974 			{ 0x20, AC_VERB_SET_PROC_COEF, 0x0 },
9975 			{ 0x20, AC_VERB_SET_PROC_COEF, 0x46 },
9976 			{ 0x20, AC_VERB_SET_PROC_COEF, 0xb020 },
9977 
9978 			{ 0x20, AC_VERB_SET_COEF_INDEX, 0x26 },
9979 			{ 0x20, AC_VERB_SET_PROC_COEF, 0x10 },
9980 			{ 0x20, AC_VERB_SET_PROC_COEF, 0x0 },
9981 			{ 0x20, AC_VERB_SET_PROC_COEF, 0x44 },
9982 			{ 0x20, AC_VERB_SET_PROC_COEF, 0xb020 },
9983 
9984 			{ 0x20, AC_VERB_SET_COEF_INDEX, 0x26 },
9985 			{ 0x20, AC_VERB_SET_PROC_COEF, 0x2 },
9986 			{ 0x20, AC_VERB_SET_PROC_COEF, 0x0 },
9987 			{ 0x20, AC_VERB_SET_PROC_COEF, 0x0 },
9988 			{ 0x20, AC_VERB_SET_PROC_COEF, 0xb020 },
9989 
9990 			{ },
9991 		},
9992 	},
9993 	[ALC287_FIXUP_YOGA9_14IAP7_BASS_SPK_PIN] = {
9994 		.type = HDA_FIXUP_FUNC,
9995 		.v.func = alc287_fixup_yoga9_14iap7_bass_spk_pin,
9996 		.chained = true,
9997 		.chain_id = ALC287_FIXUP_YOGA9_14IAP7_BASS_SPK,
9998 	},
9999 	[ALC287_FIXUP_LENOVO_14ARP8_LEGION_IAH7] = {
10000 		.type = HDA_FIXUP_FUNC,
10001 		.v.func = alc287_fixup_lenovo_14arp8_legion_iah7,
10002 	},
10003 	[ALC287_FIXUP_YOGA9_14IMH9_BASS_SPK_PIN] = {
10004 		.type = HDA_FIXUP_FUNC,
10005 		.v.func = alc287_fixup_yoga9_14iap7_bass_spk_pin,
10006 		.chained = true,
10007 		.chain_id = ALC287_FIXUP_CS35L41_I2C_2,
10008 	},
10009 	[ALC295_FIXUP_DELL_INSPIRON_TOP_SPEAKERS] = {
10010 		.type = HDA_FIXUP_FUNC,
10011 		.v.func = alc295_fixup_dell_inspiron_top_speakers,
10012 		.chained = true,
10013 		.chain_id = ALC269_FIXUP_DELL4_MIC_NO_PRESENCE,
10014 	},
10015 	[ALC236_FIXUP_DELL_DUAL_CODECS] = {
10016 		.type = HDA_FIXUP_PINS,
10017 		.v.func = alc1220_fixup_gb_dual_codecs,
10018 		.chained = true,
10019 		.chain_id = ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
10020 	},
10021 	[ALC287_FIXUP_CS35L41_I2C_2_THINKPAD_ACPI] = {
10022 		.type = HDA_FIXUP_FUNC,
10023 		.v.func = cs35l41_fixup_i2c_two,
10024 		.chained = true,
10025 		.chain_id = ALC285_FIXUP_THINKPAD_NO_BASS_SPK_HEADSET_JACK,
10026 	},
10027 	[ALC287_FIXUP_TAS2781_I2C] = {
10028 		.type = HDA_FIXUP_FUNC,
10029 		.v.func = tas2781_fixup_i2c,
10030 		.chained = true,
10031 		.chain_id = ALC285_FIXUP_THINKPAD_HEADSET_JACK,
10032 	},
10033 	[ALC287_FIXUP_YOGA7_14ARB7_I2C] = {
10034 		.type = HDA_FIXUP_FUNC,
10035 		.v.func = yoga7_14arb7_fixup_i2c,
10036 		.chained = true,
10037 		.chain_id = ALC285_FIXUP_THINKPAD_HEADSET_JACK,
10038 	},
10039 	[ALC245_FIXUP_HP_MUTE_LED_COEFBIT] = {
10040 		.type = HDA_FIXUP_FUNC,
10041 		.v.func = alc245_fixup_hp_mute_led_coefbit,
10042 	},
10043 	[ALC245_FIXUP_HP_X360_MUTE_LEDS] = {
10044 		.type = HDA_FIXUP_FUNC,
10045 		.v.func = alc245_fixup_hp_mute_led_coefbit,
10046 		.chained = true,
10047 		.chain_id = ALC245_FIXUP_HP_GPIO_LED
10048 	},
10049 	[ALC287_FIXUP_THINKPAD_I2S_SPK] = {
10050 		.type = HDA_FIXUP_FUNC,
10051 		.v.func = alc287_fixup_bind_dacs,
10052 		.chained = true,
10053 		.chain_id = ALC285_FIXUP_THINKPAD_NO_BASS_SPK_HEADSET_JACK,
10054 	},
10055 	[ALC287_FIXUP_MG_RTKC_CSAMP_CS35L41_I2C_THINKPAD] = {
10056 		.type = HDA_FIXUP_FUNC,
10057 		.v.func = alc287_fixup_bind_dacs,
10058 		.chained = true,
10059 		.chain_id = ALC287_FIXUP_CS35L41_I2C_2_THINKPAD_ACPI,
10060 	},
10061 	[ALC2XX_FIXUP_HEADSET_MIC] = {
10062 		.type = HDA_FIXUP_FUNC,
10063 		.v.func = alc_fixup_headset_mic,
10064 	},
10065 	[ALC289_FIXUP_DELL_CS35L41_SPI_2] = {
10066 		.type = HDA_FIXUP_FUNC,
10067 		.v.func = cs35l41_fixup_spi_two,
10068 		.chained = true,
10069 		.chain_id = ALC289_FIXUP_DUAL_SPK
10070 	},
10071 	[ALC294_FIXUP_CS35L41_I2C_2] = {
10072 		.type = HDA_FIXUP_FUNC,
10073 		.v.func = cs35l41_fixup_i2c_two,
10074 	},
10075 	[ALC256_FIXUP_ACER_SFG16_MICMUTE_LED] = {
10076 		.type = HDA_FIXUP_FUNC,
10077 		.v.func = alc256_fixup_acer_sfg16_micmute_led,
10078 	},
10079 	[ALC256_FIXUP_HEADPHONE_AMP_VOL] = {
10080 		.type = HDA_FIXUP_FUNC,
10081 		.v.func = alc256_decrease_headphone_amp_val,
10082 	},
10083 	[ALC245_FIXUP_HP_SPECTRE_X360_EU0XXX] = {
10084 		.type = HDA_FIXUP_FUNC,
10085 		.v.func = alc245_fixup_hp_spectre_x360_eu0xxx,
10086 	},
10087 	[ALC245_FIXUP_HP_SPECTRE_X360_16_AA0XXX] = {
10088 		.type = HDA_FIXUP_FUNC,
10089 		.v.func = alc245_fixup_hp_spectre_x360_16_aa0xxx,
10090 	},
10091 	[ALC285_FIXUP_ASUS_GA403U] = {
10092 		.type = HDA_FIXUP_FUNC,
10093 		.v.func = alc285_fixup_asus_ga403u,
10094 	},
10095 	[ALC285_FIXUP_ASUS_GA403U_HEADSET_MIC] = {
10096 		.type = HDA_FIXUP_PINS,
10097 		.v.pins = (const struct hda_pintbl[]) {
10098 			{ 0x19, 0x03a11050 },
10099 			{ 0x1b, 0x03a11c30 },
10100 			{ }
10101 		},
10102 		.chained = true,
10103 		.chain_id = ALC285_FIXUP_ASUS_GA403U_I2C_SPEAKER2_TO_DAC1
10104 	},
10105 	[ALC285_FIXUP_ASUS_GU605_SPI_SPEAKER2_TO_DAC1] = {
10106 		.type = HDA_FIXUP_FUNC,
10107 		.v.func = alc285_fixup_speaker2_to_dac1,
10108 		.chained = true,
10109 		.chain_id = ALC285_FIXUP_ASUS_GU605_SPI_2_HEADSET_MIC,
10110 	},
10111 	[ALC285_FIXUP_ASUS_GU605_SPI_2_HEADSET_MIC] = {
10112 		.type = HDA_FIXUP_PINS,
10113 		.v.pins = (const struct hda_pintbl[]) {
10114 			{ 0x19, 0x03a11050 },
10115 			{ 0x1b, 0x03a11c30 },
10116 			{ }
10117 		},
10118 	},
10119 	[ALC285_FIXUP_ASUS_GA403U_I2C_SPEAKER2_TO_DAC1] = {
10120 		.type = HDA_FIXUP_FUNC,
10121 		.v.func = alc285_fixup_speaker2_to_dac1,
10122 		.chained = true,
10123 		.chain_id = ALC285_FIXUP_ASUS_GA403U,
10124 	},
10125 	[ALC287_FIXUP_LENOVO_THKPAD_WH_ALC1318] = {
10126 		.type = HDA_FIXUP_FUNC,
10127 		.v.func = alc287_fixup_lenovo_thinkpad_with_alc1318,
10128 		.chained = true,
10129 		.chain_id = ALC269_FIXUP_THINKPAD_ACPI
10130 	},
10131 	[ALC256_FIXUP_CHROME_BOOK] = {
10132 		.type = HDA_FIXUP_FUNC,
10133 		.v.func = alc256_fixup_chromebook,
10134 		.chained = true,
10135 		.chain_id = ALC225_FIXUP_HEADSET_JACK
10136 	},
10137 	[ALC287_FIXUP_LENOVO_SSID_17AA3820] = {
10138 		.type = HDA_FIXUP_FUNC,
10139 		.v.func = alc287_fixup_lenovo_ssid_17aa3820,
10140 	},
10141 	[ALC245_FIXUP_CLEVO_NOISY_MIC] = {
10142 		.type = HDA_FIXUP_FUNC,
10143 		.v.func = alc269_fixup_limit_int_mic_boost,
10144 		.chained = true,
10145 		.chain_id = ALC256_FIXUP_SYSTEM76_MIC_NO_PRESENCE,
10146 	},
10147 	[ALC269_FIXUP_VAIO_VJFH52_MIC_NO_PRESENCE] = {
10148 		.type = HDA_FIXUP_PINS,
10149 		.v.pins = (const struct hda_pintbl[]) {
10150 			{ 0x19, 0x03a1113c }, /* use as headset mic, without its own jack detect */
10151 			{ 0x1b, 0x20a11040 }, /* dock mic */
10152 			{ }
10153 		},
10154 		.chained = true,
10155 		.chain_id = ALC269_FIXUP_LIMIT_INT_MIC_BOOST
10156 	},
10157 };
10158 
10159 static const struct snd_pci_quirk alc269_fixup_tbl[] = {
10160 	SND_PCI_QUIRK(0x1025, 0x0283, "Acer TravelMate 8371", ALC269_FIXUP_INV_DMIC),
10161 	SND_PCI_QUIRK(0x1025, 0x029b, "Acer 1810TZ", ALC269_FIXUP_INV_DMIC),
10162 	SND_PCI_QUIRK(0x1025, 0x0349, "Acer AOD260", ALC269_FIXUP_INV_DMIC),
10163 	SND_PCI_QUIRK(0x1025, 0x047c, "Acer AC700", ALC269_FIXUP_ACER_AC700),
10164 	SND_PCI_QUIRK(0x1025, 0x072d, "Acer Aspire V5-571G", ALC269_FIXUP_ASPIRE_HEADSET_MIC),
10165 	SND_PCI_QUIRK(0x1025, 0x0740, "Acer AO725", ALC271_FIXUP_HP_GATE_MIC_JACK),
10166 	SND_PCI_QUIRK(0x1025, 0x0742, "Acer AO756", ALC271_FIXUP_HP_GATE_MIC_JACK),
10167 	SND_PCI_QUIRK(0x1025, 0x0762, "Acer Aspire E1-472", ALC271_FIXUP_HP_GATE_MIC_JACK_E1_572),
10168 	SND_PCI_QUIRK(0x1025, 0x0775, "Acer Aspire E1-572", ALC271_FIXUP_HP_GATE_MIC_JACK_E1_572),
10169 	SND_PCI_QUIRK(0x1025, 0x079b, "Acer Aspire V5-573G", ALC282_FIXUP_ASPIRE_V5_PINS),
10170 	SND_PCI_QUIRK(0x1025, 0x080d, "Acer Aspire V5-122P", ALC269_FIXUP_ASPIRE_HEADSET_MIC),
10171 	SND_PCI_QUIRK(0x1025, 0x0840, "Acer Aspire E1", ALC269VB_FIXUP_ASPIRE_E1_COEF),
10172 	SND_PCI_QUIRK(0x1025, 0x100c, "Acer Aspire E5-574G", ALC255_FIXUP_ACER_LIMIT_INT_MIC_BOOST),
10173 	SND_PCI_QUIRK(0x1025, 0x101c, "Acer Veriton N2510G", ALC269_FIXUP_LIFEBOOK),
10174 	SND_PCI_QUIRK(0x1025, 0x102b, "Acer Aspire C24-860", ALC286_FIXUP_ACER_AIO_MIC_NO_PRESENCE),
10175 	SND_PCI_QUIRK(0x1025, 0x1065, "Acer Aspire C20-820", ALC269VC_FIXUP_ACER_HEADSET_MIC),
10176 	SND_PCI_QUIRK(0x1025, 0x106d, "Acer Cloudbook 14", ALC283_FIXUP_CHROME_BOOK),
10177 	SND_PCI_QUIRK(0x1025, 0x1094, "Acer Aspire E5-575T", ALC255_FIXUP_ACER_LIMIT_INT_MIC_BOOST),
10178 	SND_PCI_QUIRK(0x1025, 0x1099, "Acer Aspire E5-523G", ALC255_FIXUP_ACER_MIC_NO_PRESENCE),
10179 	SND_PCI_QUIRK(0x1025, 0x110e, "Acer Aspire ES1-432", ALC255_FIXUP_ACER_MIC_NO_PRESENCE),
10180 	SND_PCI_QUIRK(0x1025, 0x1166, "Acer Veriton N4640G", ALC269_FIXUP_LIFEBOOK),
10181 	SND_PCI_QUIRK(0x1025, 0x1167, "Acer Veriton N6640G", ALC269_FIXUP_LIFEBOOK),
10182 	SND_PCI_QUIRK(0x1025, 0x1177, "Acer Predator G9-593", ALC255_FIXUP_PREDATOR_SUBWOOFER),
10183 	SND_PCI_QUIRK(0x1025, 0x1178, "Acer Predator G9-593", ALC255_FIXUP_PREDATOR_SUBWOOFER),
10184 	SND_PCI_QUIRK(0x1025, 0x1246, "Acer Predator Helios 500", ALC299_FIXUP_PREDATOR_SPK),
10185 	SND_PCI_QUIRK(0x1025, 0x1247, "Acer vCopperbox", ALC269VC_FIXUP_ACER_VCOPPERBOX_PINS),
10186 	SND_PCI_QUIRK(0x1025, 0x1248, "Acer Veriton N4660G", ALC269VC_FIXUP_ACER_MIC_NO_PRESENCE),
10187 	SND_PCI_QUIRK(0x1025, 0x1269, "Acer SWIFT SF314-54", ALC256_FIXUP_ACER_HEADSET_MIC),
10188 	SND_PCI_QUIRK(0x1025, 0x126a, "Acer Swift SF114-32", ALC256_FIXUP_ACER_MIC_NO_PRESENCE),
10189 	SND_PCI_QUIRK(0x1025, 0x128f, "Acer Veriton Z6860G", ALC286_FIXUP_ACER_AIO_HEADSET_MIC),
10190 	SND_PCI_QUIRK(0x1025, 0x1290, "Acer Veriton Z4860G", ALC286_FIXUP_ACER_AIO_HEADSET_MIC),
10191 	SND_PCI_QUIRK(0x1025, 0x1291, "Acer Veriton Z4660G", ALC286_FIXUP_ACER_AIO_HEADSET_MIC),
10192 	SND_PCI_QUIRK(0x1025, 0x129c, "Acer SWIFT SF314-55", ALC256_FIXUP_ACER_HEADSET_MIC),
10193 	SND_PCI_QUIRK(0x1025, 0x129d, "Acer SWIFT SF313-51", ALC256_FIXUP_ACER_MIC_NO_PRESENCE),
10194 	SND_PCI_QUIRK(0x1025, 0x1300, "Acer SWIFT SF314-56", ALC256_FIXUP_ACER_MIC_NO_PRESENCE),
10195 	SND_PCI_QUIRK(0x1025, 0x1308, "Acer Aspire Z24-890", ALC286_FIXUP_ACER_AIO_HEADSET_MIC),
10196 	SND_PCI_QUIRK(0x1025, 0x132a, "Acer TravelMate B114-21", ALC233_FIXUP_ACER_HEADSET_MIC),
10197 	SND_PCI_QUIRK(0x1025, 0x1330, "Acer TravelMate X514-51T", ALC255_FIXUP_ACER_HEADSET_MIC),
10198 	SND_PCI_QUIRK(0x1025, 0x141f, "Acer Spin SP513-54N", ALC255_FIXUP_ACER_MIC_NO_PRESENCE),
10199 	SND_PCI_QUIRK(0x1025, 0x142b, "Acer Swift SF314-42", ALC255_FIXUP_ACER_MIC_NO_PRESENCE),
10200 	SND_PCI_QUIRK(0x1025, 0x1430, "Acer TravelMate B311R-31", ALC256_FIXUP_ACER_MIC_NO_PRESENCE),
10201 	SND_PCI_QUIRK(0x1025, 0x1466, "Acer Aspire A515-56", ALC255_FIXUP_ACER_HEADPHONE_AND_MIC),
10202 	SND_PCI_QUIRK(0x1025, 0x1534, "Acer Predator PH315-54", ALC255_FIXUP_ACER_MIC_NO_PRESENCE),
10203 	SND_PCI_QUIRK(0x1025, 0x169a, "Acer Swift SFG16", ALC256_FIXUP_ACER_SFG16_MICMUTE_LED),
10204 	SND_PCI_QUIRK(0x1028, 0x0470, "Dell M101z", ALC269_FIXUP_DELL_M101Z),
10205 	SND_PCI_QUIRK(0x1028, 0x053c, "Dell Latitude E5430", ALC292_FIXUP_DELL_E7X),
10206 	SND_PCI_QUIRK(0x1028, 0x054b, "Dell XPS one 2710", ALC275_FIXUP_DELL_XPS),
10207 	SND_PCI_QUIRK(0x1028, 0x05bd, "Dell Latitude E6440", ALC292_FIXUP_DELL_E7X),
10208 	SND_PCI_QUIRK(0x1028, 0x05be, "Dell Latitude E6540", ALC292_FIXUP_DELL_E7X),
10209 	SND_PCI_QUIRK(0x1028, 0x05ca, "Dell Latitude E7240", ALC292_FIXUP_DELL_E7X),
10210 	SND_PCI_QUIRK(0x1028, 0x05cb, "Dell Latitude E7440", ALC292_FIXUP_DELL_E7X),
10211 	SND_PCI_QUIRK(0x1028, 0x05da, "Dell Vostro 5460", ALC290_FIXUP_SUBWOOFER),
10212 	SND_PCI_QUIRK(0x1028, 0x05f4, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE),
10213 	SND_PCI_QUIRK(0x1028, 0x05f5, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE),
10214 	SND_PCI_QUIRK(0x1028, 0x05f6, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE),
10215 	SND_PCI_QUIRK(0x1028, 0x0615, "Dell Vostro 5470", ALC290_FIXUP_SUBWOOFER_HSJACK),
10216 	SND_PCI_QUIRK(0x1028, 0x0616, "Dell Vostro 5470", ALC290_FIXUP_SUBWOOFER_HSJACK),
10217 	SND_PCI_QUIRK(0x1028, 0x062c, "Dell Latitude E5550", ALC292_FIXUP_DELL_E7X),
10218 	SND_PCI_QUIRK(0x1028, 0x062e, "Dell Latitude E7450", ALC292_FIXUP_DELL_E7X),
10219 	SND_PCI_QUIRK(0x1028, 0x0638, "Dell Inspiron 5439", ALC290_FIXUP_MONO_SPEAKERS_HSJACK),
10220 	SND_PCI_QUIRK(0x1028, 0x064a, "Dell", ALC293_FIXUP_DELL1_MIC_NO_PRESENCE),
10221 	SND_PCI_QUIRK(0x1028, 0x064b, "Dell", ALC293_FIXUP_DELL1_MIC_NO_PRESENCE),
10222 	SND_PCI_QUIRK(0x1028, 0x0665, "Dell XPS 13", ALC288_FIXUP_DELL_XPS_13),
10223 	SND_PCI_QUIRK(0x1028, 0x0669, "Dell Optiplex 9020m", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE),
10224 	SND_PCI_QUIRK(0x1028, 0x069a, "Dell Vostro 5480", ALC290_FIXUP_SUBWOOFER_HSJACK),
10225 	SND_PCI_QUIRK(0x1028, 0x06c7, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE),
10226 	SND_PCI_QUIRK(0x1028, 0x06d9, "Dell", ALC293_FIXUP_DELL1_MIC_NO_PRESENCE),
10227 	SND_PCI_QUIRK(0x1028, 0x06da, "Dell", ALC293_FIXUP_DELL1_MIC_NO_PRESENCE),
10228 	SND_PCI_QUIRK(0x1028, 0x06db, "Dell", ALC293_FIXUP_DISABLE_AAMIX_MULTIJACK),
10229 	SND_PCI_QUIRK(0x1028, 0x06dd, "Dell", ALC293_FIXUP_DISABLE_AAMIX_MULTIJACK),
10230 	SND_PCI_QUIRK(0x1028, 0x06de, "Dell", ALC293_FIXUP_DISABLE_AAMIX_MULTIJACK),
10231 	SND_PCI_QUIRK(0x1028, 0x06df, "Dell", ALC293_FIXUP_DISABLE_AAMIX_MULTIJACK),
10232 	SND_PCI_QUIRK(0x1028, 0x06e0, "Dell", ALC293_FIXUP_DISABLE_AAMIX_MULTIJACK),
10233 	SND_PCI_QUIRK(0x1028, 0x0706, "Dell Inspiron 7559", ALC256_FIXUP_DELL_INSPIRON_7559_SUBWOOFER),
10234 	SND_PCI_QUIRK(0x1028, 0x0725, "Dell Inspiron 3162", ALC255_FIXUP_DELL_SPK_NOISE),
10235 	SND_PCI_QUIRK(0x1028, 0x0738, "Dell Precision 5820", ALC269_FIXUP_NO_SHUTUP),
10236 	SND_PCI_QUIRK(0x1028, 0x075c, "Dell XPS 27 7760", ALC298_FIXUP_SPK_VOLUME),
10237 	SND_PCI_QUIRK(0x1028, 0x075d, "Dell AIO", ALC298_FIXUP_SPK_VOLUME),
10238 	SND_PCI_QUIRK(0x1028, 0x0798, "Dell Inspiron 17 7000 Gaming", ALC256_FIXUP_DELL_INSPIRON_7559_SUBWOOFER),
10239 	SND_PCI_QUIRK(0x1028, 0x07b0, "Dell Precision 7520", ALC295_FIXUP_DISABLE_DAC3),
10240 	SND_PCI_QUIRK(0x1028, 0x080c, "Dell WYSE", ALC225_FIXUP_DELL_WYSE_MIC_NO_PRESENCE),
10241 	SND_PCI_QUIRK(0x1028, 0x084b, "Dell", ALC274_FIXUP_DELL_AIO_LINEOUT_VERB),
10242 	SND_PCI_QUIRK(0x1028, 0x084e, "Dell", ALC274_FIXUP_DELL_AIO_LINEOUT_VERB),
10243 	SND_PCI_QUIRK(0x1028, 0x0871, "Dell Precision 3630", ALC255_FIXUP_DELL_HEADSET_MIC),
10244 	SND_PCI_QUIRK(0x1028, 0x0872, "Dell Precision 3630", ALC255_FIXUP_DELL_HEADSET_MIC),
10245 	SND_PCI_QUIRK(0x1028, 0x0873, "Dell Precision 3930", ALC255_FIXUP_DUMMY_LINEOUT_VERB),
10246 	SND_PCI_QUIRK(0x1028, 0x08ad, "Dell WYSE AIO", ALC225_FIXUP_DELL_WYSE_AIO_MIC_NO_PRESENCE),
10247 	SND_PCI_QUIRK(0x1028, 0x08ae, "Dell WYSE NB", ALC225_FIXUP_DELL1_MIC_NO_PRESENCE),
10248 	SND_PCI_QUIRK(0x1028, 0x0935, "Dell", ALC274_FIXUP_DELL_AIO_LINEOUT_VERB),
10249 	SND_PCI_QUIRK(0x1028, 0x097d, "Dell Precision", ALC289_FIXUP_DUAL_SPK),
10250 	SND_PCI_QUIRK(0x1028, 0x097e, "Dell Precision", ALC289_FIXUP_DUAL_SPK),
10251 	SND_PCI_QUIRK(0x1028, 0x098d, "Dell Precision", ALC233_FIXUP_ASUS_MIC_NO_PRESENCE),
10252 	SND_PCI_QUIRK(0x1028, 0x09bf, "Dell Precision", ALC233_FIXUP_ASUS_MIC_NO_PRESENCE),
10253 	SND_PCI_QUIRK(0x1028, 0x0a2e, "Dell", ALC236_FIXUP_DELL_AIO_HEADSET_MIC),
10254 	SND_PCI_QUIRK(0x1028, 0x0a30, "Dell", ALC236_FIXUP_DELL_AIO_HEADSET_MIC),
10255 	SND_PCI_QUIRK(0x1028, 0x0a38, "Dell Latitude 7520", ALC269_FIXUP_DELL4_MIC_NO_PRESENCE_QUIET),
10256 	SND_PCI_QUIRK(0x1028, 0x0a58, "Dell", ALC255_FIXUP_DELL_HEADSET_MIC),
10257 	SND_PCI_QUIRK(0x1028, 0x0a61, "Dell XPS 15 9510", ALC289_FIXUP_DUAL_SPK),
10258 	SND_PCI_QUIRK(0x1028, 0x0a62, "Dell Precision 5560", ALC289_FIXUP_DUAL_SPK),
10259 	SND_PCI_QUIRK(0x1028, 0x0a9d, "Dell Latitude 5430", ALC269_FIXUP_DELL4_MIC_NO_PRESENCE),
10260 	SND_PCI_QUIRK(0x1028, 0x0a9e, "Dell Latitude 5430", ALC269_FIXUP_DELL4_MIC_NO_PRESENCE),
10261 	SND_PCI_QUIRK(0x1028, 0x0b19, "Dell XPS 15 9520", ALC289_FIXUP_DUAL_SPK),
10262 	SND_PCI_QUIRK(0x1028, 0x0b1a, "Dell Precision 5570", ALC289_FIXUP_DUAL_SPK),
10263 	SND_PCI_QUIRK(0x1028, 0x0b27, "Dell", ALC245_FIXUP_CS35L41_SPI_2),
10264 	SND_PCI_QUIRK(0x1028, 0x0b28, "Dell", ALC245_FIXUP_CS35L41_SPI_2),
10265 	SND_PCI_QUIRK(0x1028, 0x0b37, "Dell Inspiron 16 Plus 7620 2-in-1", ALC295_FIXUP_DELL_INSPIRON_TOP_SPEAKERS),
10266 	SND_PCI_QUIRK(0x1028, 0x0b71, "Dell Inspiron 16 Plus 7620", ALC295_FIXUP_DELL_INSPIRON_TOP_SPEAKERS),
10267 	SND_PCI_QUIRK(0x1028, 0x0beb, "Dell XPS 15 9530 (2023)", ALC289_FIXUP_DELL_CS35L41_SPI_2),
10268 	SND_PCI_QUIRK(0x1028, 0x0c03, "Dell Precision 5340", ALC269_FIXUP_DELL4_MIC_NO_PRESENCE),
10269 	SND_PCI_QUIRK(0x1028, 0x0c0b, "Dell Oasis 14 RPL-P", ALC289_FIXUP_RTK_AMP_DUAL_SPK),
10270 	SND_PCI_QUIRK(0x1028, 0x0c0d, "Dell Oasis", ALC289_FIXUP_RTK_AMP_DUAL_SPK),
10271 	SND_PCI_QUIRK(0x1028, 0x0c0e, "Dell Oasis 16", ALC289_FIXUP_RTK_AMP_DUAL_SPK),
10272 	SND_PCI_QUIRK(0x1028, 0x0c19, "Dell Precision 3340", ALC236_FIXUP_DELL_DUAL_CODECS),
10273 	SND_PCI_QUIRK(0x1028, 0x0c1a, "Dell Precision 3340", ALC236_FIXUP_DELL_DUAL_CODECS),
10274 	SND_PCI_QUIRK(0x1028, 0x0c1b, "Dell Precision 3440", ALC236_FIXUP_DELL_DUAL_CODECS),
10275 	SND_PCI_QUIRK(0x1028, 0x0c1c, "Dell Precision 3540", ALC236_FIXUP_DELL_DUAL_CODECS),
10276 	SND_PCI_QUIRK(0x1028, 0x0c1d, "Dell Precision 3440", ALC236_FIXUP_DELL_DUAL_CODECS),
10277 	SND_PCI_QUIRK(0x1028, 0x0c1e, "Dell Precision 3540", ALC236_FIXUP_DELL_DUAL_CODECS),
10278 	SND_PCI_QUIRK(0x1028, 0x0c28, "Dell Inspiron 16 Plus 7630", ALC295_FIXUP_DELL_INSPIRON_TOP_SPEAKERS),
10279 	SND_PCI_QUIRK(0x1028, 0x0c4d, "Dell", ALC287_FIXUP_CS35L41_I2C_4),
10280 	SND_PCI_QUIRK(0x1028, 0x0c94, "Dell Polaris 3 metal", ALC287_FIXUP_TAS2781_I2C),
10281 	SND_PCI_QUIRK(0x1028, 0x0c96, "Dell Polaris 2in1", ALC287_FIXUP_TAS2781_I2C),
10282 	SND_PCI_QUIRK(0x1028, 0x0cbd, "Dell Oasis 13 CS MTL-U", ALC289_FIXUP_DELL_CS35L41_SPI_2),
10283 	SND_PCI_QUIRK(0x1028, 0x0cbe, "Dell Oasis 13 2-IN-1 MTL-U", ALC289_FIXUP_DELL_CS35L41_SPI_2),
10284 	SND_PCI_QUIRK(0x1028, 0x0cbf, "Dell Oasis 13 Low Weight MTU-L", ALC289_FIXUP_DELL_CS35L41_SPI_2),
10285 	SND_PCI_QUIRK(0x1028, 0x0cc0, "Dell Oasis 13", ALC289_FIXUP_RTK_AMP_DUAL_SPK),
10286 	SND_PCI_QUIRK(0x1028, 0x0cc1, "Dell Oasis 14 MTL-H/U", ALC289_FIXUP_DELL_CS35L41_SPI_2),
10287 	SND_PCI_QUIRK(0x1028, 0x0cc2, "Dell Oasis 14 2-in-1 MTL-H/U", ALC289_FIXUP_DELL_CS35L41_SPI_2),
10288 	SND_PCI_QUIRK(0x1028, 0x0cc3, "Dell Oasis 14 Low Weight MTL-U", ALC289_FIXUP_DELL_CS35L41_SPI_2),
10289 	SND_PCI_QUIRK(0x1028, 0x0cc4, "Dell Oasis 16 MTL-H/U", ALC289_FIXUP_DELL_CS35L41_SPI_2),
10290 	SND_PCI_QUIRK(0x1028, 0x0cc5, "Dell Oasis 14", ALC289_FIXUP_RTK_AMP_DUAL_SPK),
10291 	SND_PCI_QUIRK(0x1028, 0x164a, "Dell", ALC293_FIXUP_DELL1_MIC_NO_PRESENCE),
10292 	SND_PCI_QUIRK(0x1028, 0x164b, "Dell", ALC293_FIXUP_DELL1_MIC_NO_PRESENCE),
10293 	SND_PCI_QUIRK(0x103c, 0x1586, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC2),
10294 	SND_PCI_QUIRK(0x103c, 0x18e6, "HP", ALC269_FIXUP_HP_GPIO_LED),
10295 	SND_PCI_QUIRK(0x103c, 0x218b, "HP", ALC269_FIXUP_LIMIT_INT_MIC_BOOST_MUTE_LED),
10296 	SND_PCI_QUIRK(0x103c, 0x21f9, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
10297 	SND_PCI_QUIRK(0x103c, 0x2210, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
10298 	SND_PCI_QUIRK(0x103c, 0x2214, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
10299 	SND_PCI_QUIRK(0x103c, 0x221b, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),
10300 	SND_PCI_QUIRK(0x103c, 0x221c, "HP EliteBook 755 G2", ALC280_FIXUP_HP_HEADSET_MIC),
10301 	SND_PCI_QUIRK(0x103c, 0x2221, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),
10302 	SND_PCI_QUIRK(0x103c, 0x2225, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),
10303 	SND_PCI_QUIRK(0x103c, 0x2236, "HP", ALC269_FIXUP_HP_LINE1_MIC1_LED),
10304 	SND_PCI_QUIRK(0x103c, 0x2237, "HP", ALC269_FIXUP_HP_LINE1_MIC1_LED),
10305 	SND_PCI_QUIRK(0x103c, 0x2238, "HP", ALC269_FIXUP_HP_LINE1_MIC1_LED),
10306 	SND_PCI_QUIRK(0x103c, 0x2239, "HP", ALC269_FIXUP_HP_LINE1_MIC1_LED),
10307 	SND_PCI_QUIRK(0x103c, 0x224b, "HP", ALC269_FIXUP_HP_LINE1_MIC1_LED),
10308 	SND_PCI_QUIRK(0x103c, 0x2253, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),
10309 	SND_PCI_QUIRK(0x103c, 0x2254, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),
10310 	SND_PCI_QUIRK(0x103c, 0x2255, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),
10311 	SND_PCI_QUIRK(0x103c, 0x2256, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),
10312 	SND_PCI_QUIRK(0x103c, 0x2257, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),
10313 	SND_PCI_QUIRK(0x103c, 0x2259, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),
10314 	SND_PCI_QUIRK(0x103c, 0x225a, "HP", ALC269_FIXUP_HP_DOCK_GPIO_MIC1_LED),
10315 	SND_PCI_QUIRK(0x103c, 0x225f, "HP", ALC280_FIXUP_HP_GPIO2_MIC_HOTKEY),
10316 	SND_PCI_QUIRK(0x103c, 0x2260, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
10317 	SND_PCI_QUIRK(0x103c, 0x2263, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
10318 	SND_PCI_QUIRK(0x103c, 0x2264, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
10319 	SND_PCI_QUIRK(0x103c, 0x2265, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
10320 	SND_PCI_QUIRK(0x103c, 0x2268, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
10321 	SND_PCI_QUIRK(0x103c, 0x226a, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
10322 	SND_PCI_QUIRK(0x103c, 0x226b, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
10323 	SND_PCI_QUIRK(0x103c, 0x226e, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
10324 	SND_PCI_QUIRK(0x103c, 0x2271, "HP", ALC286_FIXUP_HP_GPIO_LED),
10325 	SND_PCI_QUIRK(0x103c, 0x2272, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),
10326 	SND_PCI_QUIRK(0x103c, 0x2272, "HP", ALC280_FIXUP_HP_DOCK_PINS),
10327 	SND_PCI_QUIRK(0x103c, 0x2273, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),
10328 	SND_PCI_QUIRK(0x103c, 0x2273, "HP", ALC280_FIXUP_HP_DOCK_PINS),
10329 	SND_PCI_QUIRK(0x103c, 0x2278, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),
10330 	SND_PCI_QUIRK(0x103c, 0x227f, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
10331 	SND_PCI_QUIRK(0x103c, 0x2282, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
10332 	SND_PCI_QUIRK(0x103c, 0x228b, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
10333 	SND_PCI_QUIRK(0x103c, 0x228e, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
10334 	SND_PCI_QUIRK(0x103c, 0x229e, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
10335 	SND_PCI_QUIRK(0x103c, 0x22b2, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
10336 	SND_PCI_QUIRK(0x103c, 0x22b7, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
10337 	SND_PCI_QUIRK(0x103c, 0x22bf, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
10338 	SND_PCI_QUIRK(0x103c, 0x22c4, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
10339 	SND_PCI_QUIRK(0x103c, 0x22c5, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
10340 	SND_PCI_QUIRK(0x103c, 0x22c7, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
10341 	SND_PCI_QUIRK(0x103c, 0x22c8, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
10342 	SND_PCI_QUIRK(0x103c, 0x22cf, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
10343 	SND_PCI_QUIRK(0x103c, 0x22db, "HP", ALC280_FIXUP_HP_9480M),
10344 	SND_PCI_QUIRK(0x103c, 0x22dc, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),
10345 	SND_PCI_QUIRK(0x103c, 0x22fb, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),
10346 	SND_PCI_QUIRK(0x103c, 0x2334, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
10347 	SND_PCI_QUIRK(0x103c, 0x2335, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
10348 	SND_PCI_QUIRK(0x103c, 0x2336, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
10349 	SND_PCI_QUIRK(0x103c, 0x2337, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
10350 	SND_PCI_QUIRK(0x103c, 0x2b5e, "HP 288 Pro G2 MT", ALC221_FIXUP_HP_288PRO_MIC_NO_PRESENCE),
10351 	SND_PCI_QUIRK(0x103c, 0x802e, "HP Z240 SFF", ALC221_FIXUP_HP_MIC_NO_PRESENCE),
10352 	SND_PCI_QUIRK(0x103c, 0x802f, "HP Z240", ALC221_FIXUP_HP_MIC_NO_PRESENCE),
10353 	SND_PCI_QUIRK(0x103c, 0x8077, "HP", ALC256_FIXUP_HP_HEADSET_MIC),
10354 	SND_PCI_QUIRK(0x103c, 0x8158, "HP", ALC256_FIXUP_HP_HEADSET_MIC),
10355 	SND_PCI_QUIRK(0x103c, 0x820d, "HP Pavilion 15", ALC295_FIXUP_HP_X360),
10356 	SND_PCI_QUIRK(0x103c, 0x8256, "HP", ALC221_FIXUP_HP_FRONT_MIC),
10357 	SND_PCI_QUIRK(0x103c, 0x827e, "HP x360", ALC295_FIXUP_HP_X360),
10358 	SND_PCI_QUIRK(0x103c, 0x827f, "HP x360", ALC269_FIXUP_HP_MUTE_LED_MIC3),
10359 	SND_PCI_QUIRK(0x103c, 0x82bf, "HP G3 mini", ALC221_FIXUP_HP_MIC_NO_PRESENCE),
10360 	SND_PCI_QUIRK(0x103c, 0x82c0, "HP G3 mini premium", ALC221_FIXUP_HP_MIC_NO_PRESENCE),
10361 	SND_PCI_QUIRK(0x103c, 0x83b9, "HP Spectre x360", ALC269_FIXUP_HP_MUTE_LED_MIC3),
10362 	SND_PCI_QUIRK(0x103c, 0x841c, "HP Pavilion 15-CK0xx", ALC269_FIXUP_HP_MUTE_LED_MIC3),
10363 	SND_PCI_QUIRK(0x103c, 0x8497, "HP Envy x360", ALC269_FIXUP_HP_MUTE_LED_MIC3),
10364 	SND_PCI_QUIRK(0x103c, 0x84a6, "HP 250 G7 Notebook PC", ALC269_FIXUP_HP_LINE1_MIC1_LED),
10365 	SND_PCI_QUIRK(0x103c, 0x84ae, "HP 15-db0403ng", ALC236_FIXUP_HP_MUTE_LED_COEFBIT2),
10366 	SND_PCI_QUIRK(0x103c, 0x84da, "HP OMEN dc0019-ur", ALC295_FIXUP_HP_OMEN),
10367 	SND_PCI_QUIRK(0x103c, 0x84e7, "HP Pavilion 15", ALC269_FIXUP_HP_MUTE_LED_MIC3),
10368 	SND_PCI_QUIRK(0x103c, 0x8519, "HP Spectre x360 15-df0xxx", ALC285_FIXUP_HP_SPECTRE_X360),
10369 	SND_PCI_QUIRK(0x103c, 0x8537, "HP ProBook 440 G6", ALC236_FIXUP_HP_MUTE_LED_MICMUTE_VREF),
10370 	SND_PCI_QUIRK(0x103c, 0x85de, "HP Envy x360 13-ar0xxx", ALC285_FIXUP_HP_ENVY_X360),
10371 	SND_PCI_QUIRK(0x103c, 0x860f, "HP ZBook 15 G6", ALC285_FIXUP_HP_GPIO_AMP_INIT),
10372 	SND_PCI_QUIRK(0x103c, 0x861f, "HP Elite Dragonfly G1", ALC285_FIXUP_HP_GPIO_AMP_INIT),
10373 	SND_PCI_QUIRK(0x103c, 0x869d, "HP", ALC236_FIXUP_HP_MUTE_LED),
10374 	SND_PCI_QUIRK(0x103c, 0x86c1, "HP Laptop 15-da3001TU", ALC236_FIXUP_HP_MUTE_LED_COEFBIT2),
10375 	SND_PCI_QUIRK(0x103c, 0x86c7, "HP Envy AiO 32", ALC274_FIXUP_HP_ENVY_GPIO),
10376 	SND_PCI_QUIRK(0x103c, 0x86e7, "HP Spectre x360 15-eb0xxx", ALC285_FIXUP_HP_SPECTRE_X360_EB1),
10377 	SND_PCI_QUIRK(0x103c, 0x86e8, "HP Spectre x360 15-eb0xxx", ALC285_FIXUP_HP_SPECTRE_X360_EB1),
10378 	SND_PCI_QUIRK(0x103c, 0x86f9, "HP Spectre x360 13-aw0xxx", ALC285_FIXUP_HP_SPECTRE_X360_MUTE_LED),
10379 	SND_PCI_QUIRK(0x103c, 0x8716, "HP Elite Dragonfly G2 Notebook PC", ALC285_FIXUP_HP_GPIO_AMP_INIT),
10380 	SND_PCI_QUIRK(0x103c, 0x8720, "HP EliteBook x360 1040 G8 Notebook PC", ALC285_FIXUP_HP_GPIO_AMP_INIT),
10381 	SND_PCI_QUIRK(0x103c, 0x8724, "HP EliteBook 850 G7", ALC285_FIXUP_HP_GPIO_LED),
10382 	SND_PCI_QUIRK(0x103c, 0x8728, "HP EliteBook 840 G7", ALC285_FIXUP_HP_GPIO_LED),
10383 	SND_PCI_QUIRK(0x103c, 0x8729, "HP", ALC285_FIXUP_HP_GPIO_LED),
10384 	SND_PCI_QUIRK(0x103c, 0x8730, "HP ProBook 445 G7", ALC236_FIXUP_HP_MUTE_LED_MICMUTE_VREF),
10385 	SND_PCI_QUIRK(0x103c, 0x8735, "HP ProBook 435 G7", ALC236_FIXUP_HP_MUTE_LED_MICMUTE_VREF),
10386 	SND_PCI_QUIRK(0x103c, 0x8736, "HP", ALC285_FIXUP_HP_GPIO_AMP_INIT),
10387 	SND_PCI_QUIRK(0x103c, 0x8760, "HP", ALC285_FIXUP_HP_MUTE_LED),
10388 	SND_PCI_QUIRK(0x103c, 0x876e, "HP ENVY x360 Convertible 13-ay0xxx", ALC245_FIXUP_HP_X360_MUTE_LEDS),
10389 	SND_PCI_QUIRK(0x103c, 0x877a, "HP", ALC285_FIXUP_HP_MUTE_LED),
10390 	SND_PCI_QUIRK(0x103c, 0x877d, "HP", ALC236_FIXUP_HP_MUTE_LED),
10391 	SND_PCI_QUIRK(0x103c, 0x8780, "HP ZBook Fury 17 G7 Mobile Workstation",
10392 		      ALC285_FIXUP_HP_GPIO_AMP_INIT),
10393 	SND_PCI_QUIRK(0x103c, 0x8783, "HP ZBook Fury 15 G7 Mobile Workstation",
10394 		      ALC285_FIXUP_HP_GPIO_AMP_INIT),
10395 	SND_PCI_QUIRK(0x103c, 0x8786, "HP OMEN 15", ALC285_FIXUP_HP_MUTE_LED),
10396 	SND_PCI_QUIRK(0x103c, 0x8787, "HP OMEN 15", ALC285_FIXUP_HP_MUTE_LED),
10397 	SND_PCI_QUIRK(0x103c, 0x8788, "HP OMEN 15", ALC285_FIXUP_HP_MUTE_LED),
10398 	SND_PCI_QUIRK(0x103c, 0x87b7, "HP Laptop 14-fq0xxx", ALC236_FIXUP_HP_MUTE_LED_COEFBIT2),
10399 	SND_PCI_QUIRK(0x103c, 0x87c8, "HP", ALC287_FIXUP_HP_GPIO_LED),
10400 	SND_PCI_QUIRK(0x103c, 0x87d3, "HP Laptop 15-gw0xxx", ALC236_FIXUP_HP_MUTE_LED_COEFBIT2),
10401 	SND_PCI_QUIRK(0x103c, 0x87e5, "HP ProBook 440 G8 Notebook PC", ALC236_FIXUP_HP_GPIO_LED),
10402 	SND_PCI_QUIRK(0x103c, 0x87e7, "HP ProBook 450 G8 Notebook PC", ALC236_FIXUP_HP_GPIO_LED),
10403 	SND_PCI_QUIRK(0x103c, 0x87f1, "HP ProBook 630 G8 Notebook PC", ALC236_FIXUP_HP_GPIO_LED),
10404 	SND_PCI_QUIRK(0x103c, 0x87f2, "HP ProBook 640 G8 Notebook PC", ALC236_FIXUP_HP_GPIO_LED),
10405 	SND_PCI_QUIRK(0x103c, 0x87f4, "HP", ALC287_FIXUP_HP_GPIO_LED),
10406 	SND_PCI_QUIRK(0x103c, 0x87f5, "HP", ALC287_FIXUP_HP_GPIO_LED),
10407 	SND_PCI_QUIRK(0x103c, 0x87f6, "HP Spectre x360 14", ALC245_FIXUP_HP_X360_AMP),
10408 	SND_PCI_QUIRK(0x103c, 0x87f7, "HP Spectre x360 14", ALC245_FIXUP_HP_X360_AMP),
10409 	SND_PCI_QUIRK(0x103c, 0x87fd, "HP Laptop 14-dq2xxx", ALC236_FIXUP_HP_MUTE_LED_COEFBIT2),
10410 	SND_PCI_QUIRK(0x103c, 0x87fe, "HP Laptop 15s-fq2xxx", ALC236_FIXUP_HP_MUTE_LED_COEFBIT2),
10411 	SND_PCI_QUIRK(0x103c, 0x8805, "HP ProBook 650 G8 Notebook PC", ALC236_FIXUP_HP_GPIO_LED),
10412 	SND_PCI_QUIRK(0x103c, 0x880d, "HP EliteBook 830 G8 Notebook PC", ALC285_FIXUP_HP_GPIO_LED),
10413 	SND_PCI_QUIRK(0x103c, 0x8811, "HP Spectre x360 15-eb1xxx", ALC285_FIXUP_HP_SPECTRE_X360_EB1),
10414 	SND_PCI_QUIRK(0x103c, 0x8812, "HP Spectre x360 15-eb1xxx", ALC285_FIXUP_HP_SPECTRE_X360_EB1),
10415 	SND_PCI_QUIRK(0x103c, 0x881d, "HP 250 G8 Notebook PC", ALC236_FIXUP_HP_MUTE_LED_COEFBIT2),
10416 	SND_PCI_QUIRK(0x103c, 0x8846, "HP EliteBook 850 G8 Notebook PC", ALC285_FIXUP_HP_GPIO_LED),
10417 	SND_PCI_QUIRK(0x103c, 0x8847, "HP EliteBook x360 830 G8 Notebook PC", ALC285_FIXUP_HP_GPIO_LED),
10418 	SND_PCI_QUIRK(0x103c, 0x884b, "HP EliteBook 840 Aero G8 Notebook PC", ALC285_FIXUP_HP_GPIO_LED),
10419 	SND_PCI_QUIRK(0x103c, 0x884c, "HP EliteBook 840 G8 Notebook PC", ALC285_FIXUP_HP_GPIO_LED),
10420 	SND_PCI_QUIRK(0x103c, 0x8862, "HP ProBook 445 G8 Notebook PC", ALC236_FIXUP_HP_LIMIT_INT_MIC_BOOST),
10421 	SND_PCI_QUIRK(0x103c, 0x8863, "HP ProBook 445 G8 Notebook PC", ALC236_FIXUP_HP_LIMIT_INT_MIC_BOOST),
10422 	SND_PCI_QUIRK(0x103c, 0x886d, "HP ZBook Fury 17.3 Inch G8 Mobile Workstation PC", ALC285_FIXUP_HP_GPIO_AMP_INIT),
10423 	SND_PCI_QUIRK(0x103c, 0x8870, "HP ZBook Fury 15.6 Inch G8 Mobile Workstation PC", ALC285_FIXUP_HP_GPIO_AMP_INIT),
10424 	SND_PCI_QUIRK(0x103c, 0x8873, "HP ZBook Studio 15.6 Inch G8 Mobile Workstation PC", ALC285_FIXUP_HP_GPIO_AMP_INIT),
10425 	SND_PCI_QUIRK(0x103c, 0x887a, "HP Laptop 15s-eq2xxx", ALC236_FIXUP_HP_MUTE_LED_COEFBIT2),
10426 	SND_PCI_QUIRK(0x103c, 0x888a, "HP ENVY x360 Convertible 15-eu0xxx", ALC245_FIXUP_HP_X360_MUTE_LEDS),
10427 	SND_PCI_QUIRK(0x103c, 0x888d, "HP ZBook Power 15.6 inch G8 Mobile Workstation PC", ALC236_FIXUP_HP_GPIO_LED),
10428 	SND_PCI_QUIRK(0x103c, 0x8895, "HP EliteBook 855 G8 Notebook PC", ALC285_FIXUP_HP_SPEAKERS_MICMUTE_LED),
10429 	SND_PCI_QUIRK(0x103c, 0x8896, "HP EliteBook 855 G8 Notebook PC", ALC285_FIXUP_HP_MUTE_LED),
10430 	SND_PCI_QUIRK(0x103c, 0x8898, "HP EliteBook 845 G8 Notebook PC", ALC285_FIXUP_HP_LIMIT_INT_MIC_BOOST),
10431 	SND_PCI_QUIRK(0x103c, 0x88d0, "HP Pavilion 15-eh1xxx (mainboard 88D0)", ALC287_FIXUP_HP_GPIO_LED),
10432 	SND_PCI_QUIRK(0x103c, 0x88dd, "HP Pavilion 15z-ec200", ALC285_FIXUP_HP_MUTE_LED),
10433 	SND_PCI_QUIRK(0x103c, 0x8902, "HP OMEN 16", ALC285_FIXUP_HP_MUTE_LED),
10434 	SND_PCI_QUIRK(0x103c, 0x890e, "HP 255 G8 Notebook PC", ALC236_FIXUP_HP_MUTE_LED_COEFBIT2),
10435 	SND_PCI_QUIRK(0x103c, 0x8919, "HP Pavilion Aero Laptop 13-be0xxx", ALC287_FIXUP_HP_GPIO_LED),
10436 	SND_PCI_QUIRK(0x103c, 0x896d, "HP ZBook Firefly 16 G9", ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED),
10437 	SND_PCI_QUIRK(0x103c, 0x896e, "HP EliteBook x360 830 G9", ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED),
10438 	SND_PCI_QUIRK(0x103c, 0x8971, "HP EliteBook 830 G9", ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED),
10439 	SND_PCI_QUIRK(0x103c, 0x8972, "HP EliteBook 840 G9", ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED),
10440 	SND_PCI_QUIRK(0x103c, 0x8973, "HP EliteBook 860 G9", ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED),
10441 	SND_PCI_QUIRK(0x103c, 0x8974, "HP EliteBook 840 Aero G9", ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED),
10442 	SND_PCI_QUIRK(0x103c, 0x8975, "HP EliteBook x360 840 Aero G9", ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED),
10443 	SND_PCI_QUIRK(0x103c, 0x897d, "HP mt440 Mobile Thin Client U74", ALC236_FIXUP_HP_GPIO_LED),
10444 	SND_PCI_QUIRK(0x103c, 0x8981, "HP Elite Dragonfly G3", ALC245_FIXUP_CS35L41_SPI_4),
10445 	SND_PCI_QUIRK(0x103c, 0x898e, "HP EliteBook 835 G9", ALC287_FIXUP_CS35L41_I2C_2),
10446 	SND_PCI_QUIRK(0x103c, 0x898f, "HP EliteBook 835 G9", ALC287_FIXUP_CS35L41_I2C_2),
10447 	SND_PCI_QUIRK(0x103c, 0x8991, "HP EliteBook 845 G9", ALC287_FIXUP_CS35L41_I2C_2_HP_GPIO_LED),
10448 	SND_PCI_QUIRK(0x103c, 0x8992, "HP EliteBook 845 G9", ALC287_FIXUP_CS35L41_I2C_2),
10449 	SND_PCI_QUIRK(0x103c, 0x8994, "HP EliteBook 855 G9", ALC287_FIXUP_CS35L41_I2C_2_HP_GPIO_LED),
10450 	SND_PCI_QUIRK(0x103c, 0x8995, "HP EliteBook 855 G9", ALC287_FIXUP_CS35L41_I2C_2),
10451 	SND_PCI_QUIRK(0x103c, 0x89a4, "HP ProBook 440 G9", ALC236_FIXUP_HP_GPIO_LED),
10452 	SND_PCI_QUIRK(0x103c, 0x89a6, "HP ProBook 450 G9", ALC236_FIXUP_HP_GPIO_LED),
10453 	SND_PCI_QUIRK(0x103c, 0x89aa, "HP EliteBook 630 G9", ALC236_FIXUP_HP_GPIO_LED),
10454 	SND_PCI_QUIRK(0x103c, 0x89ac, "HP EliteBook 640 G9", ALC236_FIXUP_HP_GPIO_LED),
10455 	SND_PCI_QUIRK(0x103c, 0x89ae, "HP EliteBook 650 G9", ALC236_FIXUP_HP_GPIO_LED),
10456 	SND_PCI_QUIRK(0x103c, 0x89c0, "HP ZBook Power 15.6 G9", ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED),
10457 	SND_PCI_QUIRK(0x103c, 0x89c3, "Zbook Studio G9", ALC245_FIXUP_CS35L41_SPI_4_HP_GPIO_LED),
10458 	SND_PCI_QUIRK(0x103c, 0x89c6, "Zbook Fury 17 G9", ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED),
10459 	SND_PCI_QUIRK(0x103c, 0x89ca, "HP", ALC236_FIXUP_HP_MUTE_LED_MICMUTE_VREF),
10460 	SND_PCI_QUIRK(0x103c, 0x89d3, "HP EliteBook 645 G9 (MB 89D2)", ALC236_FIXUP_HP_MUTE_LED_MICMUTE_VREF),
10461 	SND_PCI_QUIRK(0x103c, 0x89e7, "HP Elite x2 G9", ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED),
10462 	SND_PCI_QUIRK(0x103c, 0x8a0f, "HP Pavilion 14-ec1xxx", ALC287_FIXUP_HP_GPIO_LED),
10463 	SND_PCI_QUIRK(0x103c, 0x8a20, "HP Laptop 15s-fq5xxx", ALC236_FIXUP_HP_MUTE_LED_COEFBIT2),
10464 	SND_PCI_QUIRK(0x103c, 0x8a25, "HP Victus 16-d1xxx (MB 8A25)", ALC245_FIXUP_HP_MUTE_LED_COEFBIT),
10465 	SND_PCI_QUIRK(0x103c, 0x8a28, "HP Envy 13", ALC287_FIXUP_CS35L41_I2C_2),
10466 	SND_PCI_QUIRK(0x103c, 0x8a29, "HP Envy 15", ALC287_FIXUP_CS35L41_I2C_2),
10467 	SND_PCI_QUIRK(0x103c, 0x8a2a, "HP Envy 15", ALC287_FIXUP_CS35L41_I2C_2),
10468 	SND_PCI_QUIRK(0x103c, 0x8a2b, "HP Envy 15", ALC287_FIXUP_CS35L41_I2C_2),
10469 	SND_PCI_QUIRK(0x103c, 0x8a2c, "HP Envy 16", ALC287_FIXUP_CS35L41_I2C_2),
10470 	SND_PCI_QUIRK(0x103c, 0x8a2d, "HP Envy 16", ALC287_FIXUP_CS35L41_I2C_2),
10471 	SND_PCI_QUIRK(0x103c, 0x8a2e, "HP Envy 16", ALC287_FIXUP_CS35L41_I2C_2),
10472 	SND_PCI_QUIRK(0x103c, 0x8a30, "HP Envy 17", ALC287_FIXUP_CS35L41_I2C_2),
10473 	SND_PCI_QUIRK(0x103c, 0x8a31, "HP Envy 15", ALC287_FIXUP_CS35L41_I2C_2),
10474 	SND_PCI_QUIRK(0x103c, 0x8a6e, "HP EDNA 360", ALC287_FIXUP_CS35L41_I2C_4),
10475 	SND_PCI_QUIRK(0x103c, 0x8a74, "HP ProBook 440 G8 Notebook PC", ALC236_FIXUP_HP_GPIO_LED),
10476 	SND_PCI_QUIRK(0x103c, 0x8a78, "HP Dev One", ALC285_FIXUP_HP_LIMIT_INT_MIC_BOOST),
10477 	SND_PCI_QUIRK(0x103c, 0x8aa0, "HP ProBook 440 G9 (MB 8A9E)", ALC236_FIXUP_HP_GPIO_LED),
10478 	SND_PCI_QUIRK(0x103c, 0x8aa3, "HP ProBook 450 G9 (MB 8AA1)", ALC236_FIXUP_HP_GPIO_LED),
10479 	SND_PCI_QUIRK(0x103c, 0x8aa8, "HP EliteBook 640 G9 (MB 8AA6)", ALC236_FIXUP_HP_GPIO_LED),
10480 	SND_PCI_QUIRK(0x103c, 0x8aab, "HP EliteBook 650 G9 (MB 8AA9)", ALC236_FIXUP_HP_GPIO_LED),
10481 	SND_PCI_QUIRK(0x103c, 0x8ab9, "HP EliteBook 840 G8 (MB 8AB8)", ALC285_FIXUP_HP_GPIO_LED),
10482 	SND_PCI_QUIRK(0x103c, 0x8abb, "HP ZBook Firefly 14 G9", ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED),
10483 	SND_PCI_QUIRK(0x103c, 0x8ad1, "HP EliteBook 840 14 inch G9 Notebook PC", ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED),
10484 	SND_PCI_QUIRK(0x103c, 0x8ad2, "HP EliteBook 860 16 inch G9 Notebook PC", ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED),
10485 	SND_PCI_QUIRK(0x103c, 0x8ad8, "HP 800 G9", ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED),
10486 	SND_PCI_QUIRK(0x103c, 0x8b0f, "HP Elite mt645 G7 Mobile Thin Client U81", ALC236_FIXUP_HP_MUTE_LED_MICMUTE_VREF),
10487 	SND_PCI_QUIRK(0x103c, 0x8b2f, "HP 255 15.6 inch G10 Notebook PC", ALC236_FIXUP_HP_MUTE_LED_COEFBIT2),
10488 	SND_PCI_QUIRK(0x103c, 0x8b3a, "HP Envy 15", ALC287_FIXUP_CS35L41_I2C_2),
10489 	SND_PCI_QUIRK(0x103c, 0x8b3f, "HP mt440 Mobile Thin Client U91", ALC236_FIXUP_HP_GPIO_LED),
10490 	SND_PCI_QUIRK(0x103c, 0x8b42, "HP", ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED),
10491 	SND_PCI_QUIRK(0x103c, 0x8b43, "HP", ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED),
10492 	SND_PCI_QUIRK(0x103c, 0x8b44, "HP", ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED),
10493 	SND_PCI_QUIRK(0x103c, 0x8b45, "HP", ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED),
10494 	SND_PCI_QUIRK(0x103c, 0x8b46, "HP", ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED),
10495 	SND_PCI_QUIRK(0x103c, 0x8b47, "HP", ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED),
10496 	SND_PCI_QUIRK(0x103c, 0x8b59, "HP Elite mt645 G7 Mobile Thin Client U89", ALC236_FIXUP_HP_MUTE_LED_MICMUTE_VREF),
10497 	SND_PCI_QUIRK(0x103c, 0x8b5d, "HP", ALC236_FIXUP_HP_MUTE_LED_MICMUTE_VREF),
10498 	SND_PCI_QUIRK(0x103c, 0x8b5e, "HP", ALC236_FIXUP_HP_MUTE_LED_MICMUTE_VREF),
10499 	SND_PCI_QUIRK(0x103c, 0x8b63, "HP Elite Dragonfly 13.5 inch G4", ALC245_FIXUP_CS35L41_SPI_4_HP_GPIO_LED),
10500 	SND_PCI_QUIRK(0x103c, 0x8b65, "HP ProBook 455 15.6 inch G10 Notebook PC", ALC236_FIXUP_HP_MUTE_LED_MICMUTE_VREF),
10501 	SND_PCI_QUIRK(0x103c, 0x8b66, "HP", ALC236_FIXUP_HP_MUTE_LED_MICMUTE_VREF),
10502 	SND_PCI_QUIRK(0x103c, 0x8b70, "HP EliteBook 835 G10", ALC287_FIXUP_CS35L41_I2C_2_HP_GPIO_LED),
10503 	SND_PCI_QUIRK(0x103c, 0x8b72, "HP EliteBook 845 G10", ALC287_FIXUP_CS35L41_I2C_2_HP_GPIO_LED),
10504 	SND_PCI_QUIRK(0x103c, 0x8b74, "HP EliteBook 845W G10", ALC287_FIXUP_CS35L41_I2C_2_HP_GPIO_LED),
10505 	SND_PCI_QUIRK(0x103c, 0x8b77, "HP ElieBook 865 G10", ALC287_FIXUP_CS35L41_I2C_2),
10506 	SND_PCI_QUIRK(0x103c, 0x8b7a, "HP", ALC236_FIXUP_HP_GPIO_LED),
10507 	SND_PCI_QUIRK(0x103c, 0x8b7d, "HP", ALC236_FIXUP_HP_GPIO_LED),
10508 	SND_PCI_QUIRK(0x103c, 0x8b87, "HP", ALC236_FIXUP_HP_GPIO_LED),
10509 	SND_PCI_QUIRK(0x103c, 0x8b8a, "HP", ALC236_FIXUP_HP_GPIO_LED),
10510 	SND_PCI_QUIRK(0x103c, 0x8b8b, "HP", ALC236_FIXUP_HP_GPIO_LED),
10511 	SND_PCI_QUIRK(0x103c, 0x8b8d, "HP", ALC236_FIXUP_HP_GPIO_LED),
10512 	SND_PCI_QUIRK(0x103c, 0x8b8f, "HP", ALC245_FIXUP_CS35L41_SPI_4_HP_GPIO_LED),
10513 	SND_PCI_QUIRK(0x103c, 0x8b92, "HP", ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED),
10514 	SND_PCI_QUIRK(0x103c, 0x8b96, "HP", ALC236_FIXUP_HP_MUTE_LED_MICMUTE_VREF),
10515 	SND_PCI_QUIRK(0x103c, 0x8b97, "HP", ALC236_FIXUP_HP_MUTE_LED_MICMUTE_VREF),
10516 	SND_PCI_QUIRK(0x103c, 0x8bb3, "HP Slim OMEN", ALC287_FIXUP_CS35L41_I2C_2),
10517 	SND_PCI_QUIRK(0x103c, 0x8bb4, "HP Slim OMEN", ALC287_FIXUP_CS35L41_I2C_2),
10518 	SND_PCI_QUIRK(0x103c, 0x8bdd, "HP Envy 17", ALC287_FIXUP_CS35L41_I2C_2),
10519 	SND_PCI_QUIRK(0x103c, 0x8bde, "HP Envy 17", ALC287_FIXUP_CS35L41_I2C_2),
10520 	SND_PCI_QUIRK(0x103c, 0x8bdf, "HP Envy 15", ALC287_FIXUP_CS35L41_I2C_2),
10521 	SND_PCI_QUIRK(0x103c, 0x8be0, "HP Envy 15", ALC287_FIXUP_CS35L41_I2C_2),
10522 	SND_PCI_QUIRK(0x103c, 0x8be1, "HP Envy 15", ALC287_FIXUP_CS35L41_I2C_2),
10523 	SND_PCI_QUIRK(0x103c, 0x8be2, "HP Envy 15", ALC287_FIXUP_CS35L41_I2C_2),
10524 	SND_PCI_QUIRK(0x103c, 0x8be3, "HP Envy 15", ALC287_FIXUP_CS35L41_I2C_2),
10525 	SND_PCI_QUIRK(0x103c, 0x8be5, "HP Envy 16", ALC287_FIXUP_CS35L41_I2C_2),
10526 	SND_PCI_QUIRK(0x103c, 0x8be6, "HP Envy 16", ALC287_FIXUP_CS35L41_I2C_2),
10527 	SND_PCI_QUIRK(0x103c, 0x8be7, "HP Envy 17", ALC287_FIXUP_CS35L41_I2C_2),
10528 	SND_PCI_QUIRK(0x103c, 0x8be8, "HP Envy 17", ALC287_FIXUP_CS35L41_I2C_2),
10529 	SND_PCI_QUIRK(0x103c, 0x8be9, "HP Envy 15", ALC287_FIXUP_CS35L41_I2C_2),
10530 	SND_PCI_QUIRK(0x103c, 0x8bf0, "HP", ALC236_FIXUP_HP_GPIO_LED),
10531 	SND_PCI_QUIRK(0x103c, 0x8c15, "HP Spectre x360 2-in-1 Laptop 14-eu0xxx", ALC245_FIXUP_HP_SPECTRE_X360_EU0XXX),
10532 	SND_PCI_QUIRK(0x103c, 0x8c16, "HP Spectre x360 2-in-1 Laptop 16-aa0xxx", ALC245_FIXUP_HP_SPECTRE_X360_16_AA0XXX),
10533 	SND_PCI_QUIRK(0x103c, 0x8c17, "HP Spectre 16", ALC287_FIXUP_CS35L41_I2C_2),
10534 	SND_PCI_QUIRK(0x103c, 0x8c21, "HP Pavilion Plus Laptop 14-ey0XXX", ALC245_FIXUP_HP_X360_MUTE_LEDS),
10535 	SND_PCI_QUIRK(0x103c, 0x8c30, "HP Victus 15-fb1xxx", ALC245_FIXUP_HP_MUTE_LED_COEFBIT),
10536 	SND_PCI_QUIRK(0x103c, 0x8c46, "HP EliteBook 830 G11", ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED),
10537 	SND_PCI_QUIRK(0x103c, 0x8c47, "HP EliteBook 840 G11", ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED),
10538 	SND_PCI_QUIRK(0x103c, 0x8c48, "HP EliteBook 860 G11", ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED),
10539 	SND_PCI_QUIRK(0x103c, 0x8c49, "HP Elite x360 830 2-in-1 G11", ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED),
10540 	SND_PCI_QUIRK(0x103c, 0x8c4d, "HP Omen", ALC287_FIXUP_CS35L41_I2C_2),
10541 	SND_PCI_QUIRK(0x103c, 0x8c4e, "HP Omen", ALC287_FIXUP_CS35L41_I2C_2),
10542 	SND_PCI_QUIRK(0x103c, 0x8c4f, "HP Envy 15", ALC287_FIXUP_CS35L41_I2C_2),
10543 	SND_PCI_QUIRK(0x103c, 0x8c50, "HP Envy 17", ALC287_FIXUP_CS35L41_I2C_2),
10544 	SND_PCI_QUIRK(0x103c, 0x8c51, "HP Envy 17", ALC287_FIXUP_CS35L41_I2C_2),
10545 	SND_PCI_QUIRK(0x103c, 0x8c52, "HP EliteBook 1040 G11", ALC285_FIXUP_HP_GPIO_LED),
10546 	SND_PCI_QUIRK(0x103c, 0x8c53, "HP Elite x360 1040 2-in-1 G11", ALC285_FIXUP_HP_GPIO_LED),
10547 	SND_PCI_QUIRK(0x103c, 0x8c66, "HP Envy 16", ALC287_FIXUP_CS35L41_I2C_2),
10548 	SND_PCI_QUIRK(0x103c, 0x8c67, "HP Envy 17", ALC287_FIXUP_CS35L41_I2C_2),
10549 	SND_PCI_QUIRK(0x103c, 0x8c68, "HP Envy 17", ALC287_FIXUP_CS35L41_I2C_2),
10550 	SND_PCI_QUIRK(0x103c, 0x8c6a, "HP Envy 16", ALC287_FIXUP_CS35L41_I2C_2),
10551 	SND_PCI_QUIRK(0x103c, 0x8c70, "HP EliteBook 835 G11", ALC287_FIXUP_CS35L41_I2C_2_HP_GPIO_LED),
10552 	SND_PCI_QUIRK(0x103c, 0x8c71, "HP EliteBook 845 G11", ALC287_FIXUP_CS35L41_I2C_2_HP_GPIO_LED),
10553 	SND_PCI_QUIRK(0x103c, 0x8c72, "HP EliteBook 865 G11", ALC287_FIXUP_CS35L41_I2C_2_HP_GPIO_LED),
10554 	SND_PCI_QUIRK(0x103c, 0x8c7b, "HP ProBook 445 G11", ALC236_FIXUP_HP_MUTE_LED_MICMUTE_VREF),
10555 	SND_PCI_QUIRK(0x103c, 0x8c7c, "HP ProBook 445 G11", ALC236_FIXUP_HP_MUTE_LED_MICMUTE_VREF),
10556 	SND_PCI_QUIRK(0x103c, 0x8c7d, "HP ProBook 465 G11", ALC236_FIXUP_HP_MUTE_LED_MICMUTE_VREF),
10557 	SND_PCI_QUIRK(0x103c, 0x8c7e, "HP ProBook 465 G11", ALC236_FIXUP_HP_MUTE_LED_MICMUTE_VREF),
10558 	SND_PCI_QUIRK(0x103c, 0x8c7f, "HP EliteBook 645 G11", ALC236_FIXUP_HP_MUTE_LED_MICMUTE_VREF),
10559 	SND_PCI_QUIRK(0x103c, 0x8c80, "HP EliteBook 645 G11", ALC236_FIXUP_HP_MUTE_LED_MICMUTE_VREF),
10560 	SND_PCI_QUIRK(0x103c, 0x8c81, "HP EliteBook 665 G11", ALC236_FIXUP_HP_MUTE_LED_MICMUTE_VREF),
10561 	SND_PCI_QUIRK(0x103c, 0x8c89, "HP ProBook 460 G11", ALC236_FIXUP_HP_GPIO_LED),
10562 	SND_PCI_QUIRK(0x103c, 0x8c8a, "HP EliteBook 630", ALC236_FIXUP_HP_GPIO_LED),
10563 	SND_PCI_QUIRK(0x103c, 0x8c8c, "HP EliteBook 660", ALC236_FIXUP_HP_GPIO_LED),
10564 	SND_PCI_QUIRK(0x103c, 0x8c8d, "HP ProBook 440 G11", ALC236_FIXUP_HP_GPIO_LED),
10565 	SND_PCI_QUIRK(0x103c, 0x8c8e, "HP ProBook 460 G11", ALC236_FIXUP_HP_GPIO_LED),
10566 	SND_PCI_QUIRK(0x103c, 0x8c90, "HP EliteBook 640", ALC236_FIXUP_HP_GPIO_LED),
10567 	SND_PCI_QUIRK(0x103c, 0x8c91, "HP EliteBook 660", ALC236_FIXUP_HP_GPIO_LED),
10568 	SND_PCI_QUIRK(0x103c, 0x8c96, "HP", ALC236_FIXUP_HP_MUTE_LED_MICMUTE_VREF),
10569 	SND_PCI_QUIRK(0x103c, 0x8c97, "HP ZBook", ALC236_FIXUP_HP_MUTE_LED_MICMUTE_VREF),
10570 	SND_PCI_QUIRK(0x103c, 0x8ca1, "HP ZBook Power", ALC236_FIXUP_HP_GPIO_LED),
10571 	SND_PCI_QUIRK(0x103c, 0x8ca2, "HP ZBook Power", ALC236_FIXUP_HP_GPIO_LED),
10572 	SND_PCI_QUIRK(0x103c, 0x8ca4, "HP ZBook Fury", ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED),
10573 	SND_PCI_QUIRK(0x103c, 0x8ca7, "HP ZBook Fury", ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED),
10574 	SND_PCI_QUIRK(0x103c, 0x8caf, "HP Elite mt645 G8 Mobile Thin Client", ALC236_FIXUP_HP_MUTE_LED_MICMUTE_VREF),
10575 	SND_PCI_QUIRK(0x103c, 0x8cbd, "HP Pavilion Aero Laptop 13-bg0xxx", ALC245_FIXUP_HP_X360_MUTE_LEDS),
10576 	SND_PCI_QUIRK(0x103c, 0x8cdd, "HP Spectre", ALC287_FIXUP_CS35L41_I2C_2),
10577 	SND_PCI_QUIRK(0x103c, 0x8cde, "HP Spectre", ALC287_FIXUP_CS35L41_I2C_2),
10578 	SND_PCI_QUIRK(0x103c, 0x8cdf, "HP SnowWhite", ALC287_FIXUP_CS35L41_I2C_2_HP_GPIO_LED),
10579 	SND_PCI_QUIRK(0x103c, 0x8ce0, "HP SnowWhite", ALC287_FIXUP_CS35L41_I2C_2_HP_GPIO_LED),
10580 	SND_PCI_QUIRK(0x103c, 0x8cf5, "HP ZBook Studio 16", ALC245_FIXUP_CS35L41_SPI_4_HP_GPIO_LED),
10581 	SND_PCI_QUIRK(0x1043, 0x103e, "ASUS X540SA", ALC256_FIXUP_ASUS_MIC),
10582 	SND_PCI_QUIRK(0x1043, 0x103f, "ASUS TX300", ALC282_FIXUP_ASUS_TX300),
10583 	SND_PCI_QUIRK(0x1043, 0x106d, "Asus K53BE", ALC269_FIXUP_LIMIT_INT_MIC_BOOST),
10584 	SND_PCI_QUIRK(0x1043, 0x10a1, "ASUS UX391UA", ALC294_FIXUP_ASUS_SPK),
10585 	SND_PCI_QUIRK(0x1043, 0x10a4, "ASUS TP3407SA", ALC287_FIXUP_TAS2781_I2C),
10586 	SND_PCI_QUIRK(0x1043, 0x10c0, "ASUS X540SA", ALC256_FIXUP_ASUS_MIC),
10587 	SND_PCI_QUIRK(0x1043, 0x10d0, "ASUS X540LA/X540LJ", ALC255_FIXUP_ASUS_MIC_NO_PRESENCE),
10588 	SND_PCI_QUIRK(0x1043, 0x10d3, "ASUS K6500ZC", ALC294_FIXUP_ASUS_SPK),
10589 	SND_PCI_QUIRK(0x1043, 0x1154, "ASUS TP3607SH", ALC287_FIXUP_TAS2781_I2C),
10590 	SND_PCI_QUIRK(0x1043, 0x115d, "Asus 1015E", ALC269_FIXUP_LIMIT_INT_MIC_BOOST),
10591 	SND_PCI_QUIRK(0x1043, 0x11c0, "ASUS X556UR", ALC255_FIXUP_ASUS_MIC_NO_PRESENCE),
10592 	SND_PCI_QUIRK(0x1043, 0x1204, "ASUS Strix G615JHR_JMR_JPR", ALC287_FIXUP_TAS2781_I2C),
10593 	SND_PCI_QUIRK(0x1043, 0x1214, "ASUS Strix G615LH_LM_LP", ALC287_FIXUP_TAS2781_I2C),
10594 	SND_PCI_QUIRK(0x1043, 0x125e, "ASUS Q524UQK", ALC255_FIXUP_ASUS_MIC_NO_PRESENCE),
10595 	SND_PCI_QUIRK(0x1043, 0x1271, "ASUS X430UN", ALC256_FIXUP_ASUS_MIC_NO_PRESENCE),
10596 	SND_PCI_QUIRK(0x1043, 0x1290, "ASUS X441SA", ALC233_FIXUP_EAPD_COEF_AND_MIC_NO_PRESENCE),
10597 	SND_PCI_QUIRK(0x1043, 0x12a0, "ASUS X441UV", ALC233_FIXUP_EAPD_COEF_AND_MIC_NO_PRESENCE),
10598 	SND_PCI_QUIRK(0x1043, 0x12a3, "Asus N7691ZM", ALC269_FIXUP_ASUS_N7601ZM),
10599 	SND_PCI_QUIRK(0x1043, 0x12af, "ASUS UX582ZS", ALC245_FIXUP_CS35L41_SPI_2),
10600 	SND_PCI_QUIRK(0x1043, 0x12e0, "ASUS X541SA", ALC256_FIXUP_ASUS_MIC),
10601 	SND_PCI_QUIRK(0x1043, 0x12f0, "ASUS X541UV", ALC256_FIXUP_ASUS_MIC),
10602 	SND_PCI_QUIRK(0x1043, 0x1313, "Asus K42JZ", ALC269VB_FIXUP_ASUS_MIC_NO_PRESENCE),
10603 	SND_PCI_QUIRK(0x1043, 0x13b0, "ASUS Z550SA", ALC256_FIXUP_ASUS_MIC),
10604 	SND_PCI_QUIRK(0x1043, 0x1427, "Asus Zenbook UX31E", ALC269VB_FIXUP_ASUS_ZENBOOK),
10605 	SND_PCI_QUIRK(0x1043, 0x1433, "ASUS GX650PY/PZ/PV/PU/PYV/PZV/PIV/PVV", ALC285_FIXUP_ASUS_I2C_HEADSET_MIC),
10606 	SND_PCI_QUIRK(0x1043, 0x1463, "Asus GA402X/GA402N", ALC285_FIXUP_ASUS_I2C_HEADSET_MIC),
10607 	SND_PCI_QUIRK(0x1043, 0x1473, "ASUS GU604VI/VC/VE/VG/VJ/VQ/VU/VV/VY/VZ", ALC285_FIXUP_ASUS_HEADSET_MIC),
10608 	SND_PCI_QUIRK(0x1043, 0x1483, "ASUS GU603VQ/VU/VV/VJ/VI", ALC285_FIXUP_ASUS_HEADSET_MIC),
10609 	SND_PCI_QUIRK(0x1043, 0x1493, "ASUS GV601VV/VU/VJ/VQ/VI", ALC285_FIXUP_ASUS_HEADSET_MIC),
10610 	SND_PCI_QUIRK(0x1043, 0x14d3, "ASUS G614JY/JZ/JG", ALC245_FIXUP_CS35L41_SPI_2),
10611 	SND_PCI_QUIRK(0x1043, 0x14e3, "ASUS G513PI/PU/PV", ALC287_FIXUP_CS35L41_I2C_2),
10612 	SND_PCI_QUIRK(0x1043, 0x1503, "ASUS G733PY/PZ/PZV/PYV", ALC287_FIXUP_CS35L41_I2C_2),
10613 	SND_PCI_QUIRK(0x1043, 0x1517, "Asus Zenbook UX31A", ALC269VB_FIXUP_ASUS_ZENBOOK_UX31A),
10614 	SND_PCI_QUIRK(0x1043, 0x1533, "ASUS GV302XA/XJ/XQ/XU/XV/XI", ALC287_FIXUP_CS35L41_I2C_2),
10615 	SND_PCI_QUIRK(0x1043, 0x1573, "ASUS GZ301VV/VQ/VU/VJ/VA/VC/VE/VVC/VQC/VUC/VJC/VEC/VCC", ALC285_FIXUP_ASUS_HEADSET_MIC),
10616 	SND_PCI_QUIRK(0x1043, 0x1662, "ASUS GV301QH", ALC294_FIXUP_ASUS_DUAL_SPK),
10617 	SND_PCI_QUIRK(0x1043, 0x1663, "ASUS GU603ZI/ZJ/ZQ/ZU/ZV", ALC285_FIXUP_ASUS_HEADSET_MIC),
10618 	SND_PCI_QUIRK(0x1043, 0x1683, "ASUS UM3402YAR", ALC287_FIXUP_CS35L41_I2C_2),
10619 	SND_PCI_QUIRK(0x1043, 0x16a3, "ASUS UX3402VA", ALC245_FIXUP_CS35L41_SPI_2),
10620 	SND_PCI_QUIRK(0x1043, 0x16b2, "ASUS GU603", ALC289_FIXUP_ASUS_GA401),
10621 	SND_PCI_QUIRK(0x1043, 0x16d3, "ASUS UX5304VA", ALC245_FIXUP_CS35L41_SPI_2),
10622 	SND_PCI_QUIRK(0x1043, 0x16e3, "ASUS UX50", ALC269_FIXUP_STEREO_DMIC),
10623 	SND_PCI_QUIRK(0x1043, 0x16f3, "ASUS UX7602VI/BZ", ALC245_FIXUP_CS35L41_SPI_2),
10624 	SND_PCI_QUIRK(0x1043, 0x1740, "ASUS UX430UA", ALC295_FIXUP_ASUS_DACS),
10625 	SND_PCI_QUIRK(0x1043, 0x17d1, "ASUS UX431FL", ALC294_FIXUP_ASUS_DUAL_SPK),
10626 	SND_PCI_QUIRK(0x1043, 0x17f3, "ROG Ally NR2301L/X", ALC294_FIXUP_ASUS_ALLY),
10627 	SND_PCI_QUIRK(0x1043, 0x1eb3, "ROG Ally X RC72LA", ALC294_FIXUP_ASUS_ALLY_X),
10628 	SND_PCI_QUIRK(0x1043, 0x1863, "ASUS UX6404VI/VV", ALC245_FIXUP_CS35L41_SPI_2),
10629 	SND_PCI_QUIRK(0x1043, 0x1881, "ASUS Zephyrus S/M", ALC294_FIXUP_ASUS_GX502_PINS),
10630 	SND_PCI_QUIRK(0x1043, 0x18b1, "Asus MJ401TA", ALC256_FIXUP_ASUS_HEADSET_MIC),
10631 	SND_PCI_QUIRK(0x1043, 0x18d3, "ASUS UM3504DA", ALC294_FIXUP_CS35L41_I2C_2),
10632 	SND_PCI_QUIRK(0x1043, 0x18f1, "Asus FX505DT", ALC256_FIXUP_ASUS_HEADSET_MIC),
10633 	SND_PCI_QUIRK(0x1043, 0x194e, "ASUS UX563FD", ALC294_FIXUP_ASUS_HPE),
10634 	SND_PCI_QUIRK(0x1043, 0x1970, "ASUS UX550VE", ALC289_FIXUP_ASUS_GA401),
10635 	SND_PCI_QUIRK(0x1043, 0x1982, "ASUS B1400CEPE", ALC256_FIXUP_ASUS_HPE),
10636 	SND_PCI_QUIRK(0x1043, 0x19ce, "ASUS B9450FA", ALC294_FIXUP_ASUS_HPE),
10637 	SND_PCI_QUIRK(0x1043, 0x19e1, "ASUS UX581LV", ALC295_FIXUP_ASUS_MIC_NO_PRESENCE),
10638 	SND_PCI_QUIRK(0x1043, 0x1a13, "Asus G73Jw", ALC269_FIXUP_ASUS_G73JW),
10639 	SND_PCI_QUIRK(0x1043, 0x1a30, "ASUS X705UD", ALC256_FIXUP_ASUS_MIC),
10640 	SND_PCI_QUIRK(0x1043, 0x1a63, "ASUS UX3405MA", ALC245_FIXUP_CS35L41_SPI_2),
10641 	SND_PCI_QUIRK(0x1043, 0x1a83, "ASUS UM5302LA", ALC294_FIXUP_CS35L41_I2C_2),
10642 	SND_PCI_QUIRK(0x1043, 0x1a8f, "ASUS UX582ZS", ALC245_FIXUP_CS35L41_SPI_2),
10643 	SND_PCI_QUIRK(0x1043, 0x1b11, "ASUS UX431DA", ALC294_FIXUP_ASUS_COEF_1B),
10644 	SND_PCI_QUIRK(0x1043, 0x1b13, "ASUS U41SV/GA403U", ALC285_FIXUP_ASUS_GA403U_HEADSET_MIC),
10645 	SND_PCI_QUIRK(0x1043, 0x1b93, "ASUS G614JVR/JIR", ALC245_FIXUP_CS35L41_SPI_2),
10646 	SND_PCI_QUIRK(0x1043, 0x1bbd, "ASUS Z550MA", ALC255_FIXUP_ASUS_MIC_NO_PRESENCE),
10647 	SND_PCI_QUIRK(0x1043, 0x1c03, "ASUS UM3406HA", ALC287_FIXUP_CS35L41_I2C_2),
10648 	SND_PCI_QUIRK(0x1043, 0x1c23, "Asus X55U", ALC269_FIXUP_LIMIT_INT_MIC_BOOST),
10649 	SND_PCI_QUIRK(0x1043, 0x1c33, "ASUS UX5304MA", ALC245_FIXUP_CS35L41_SPI_2),
10650 	SND_PCI_QUIRK(0x1043, 0x1c43, "ASUS UX8406MA", ALC245_FIXUP_CS35L41_SPI_2),
10651 	SND_PCI_QUIRK(0x1043, 0x1c62, "ASUS GU603", ALC289_FIXUP_ASUS_GA401),
10652 	SND_PCI_QUIRK(0x1043, 0x1c63, "ASUS GU605M", ALC285_FIXUP_ASUS_GU605_SPI_SPEAKER2_TO_DAC1),
10653 	SND_PCI_QUIRK(0x1043, 0x1c92, "ASUS ROG Strix G15", ALC285_FIXUP_ASUS_G533Z_PINS),
10654 	SND_PCI_QUIRK(0x1043, 0x1c9f, "ASUS G614JU/JV/JI", ALC285_FIXUP_ASUS_HEADSET_MIC),
10655 	SND_PCI_QUIRK(0x1043, 0x1caf, "ASUS G634JY/JZ/JI/JG", ALC285_FIXUP_ASUS_SPI_REAR_SPEAKERS),
10656 	SND_PCI_QUIRK(0x1043, 0x1ccd, "ASUS X555UB", ALC256_FIXUP_ASUS_MIC),
10657 	SND_PCI_QUIRK(0x1043, 0x1ccf, "ASUS G814JU/JV/JI", ALC245_FIXUP_CS35L41_SPI_2),
10658 	SND_PCI_QUIRK(0x1043, 0x1cdf, "ASUS G814JY/JZ/JG", ALC245_FIXUP_CS35L41_SPI_2),
10659 	SND_PCI_QUIRK(0x1043, 0x1cef, "ASUS G834JY/JZ/JI/JG", ALC285_FIXUP_ASUS_HEADSET_MIC),
10660 	SND_PCI_QUIRK(0x1043, 0x1d1f, "ASUS G713PI/PU/PV/PVN", ALC287_FIXUP_CS35L41_I2C_2),
10661 	SND_PCI_QUIRK(0x1043, 0x1d42, "ASUS Zephyrus G14 2022", ALC289_FIXUP_ASUS_GA401),
10662 	SND_PCI_QUIRK(0x1043, 0x1d4e, "ASUS TM420", ALC256_FIXUP_ASUS_HPE),
10663 	SND_PCI_QUIRK(0x1043, 0x1da2, "ASUS UP6502ZA/ZD", ALC245_FIXUP_CS35L41_SPI_2),
10664 	SND_PCI_QUIRK(0x1043, 0x1e02, "ASUS UX3402ZA", ALC245_FIXUP_CS35L41_SPI_2),
10665 	SND_PCI_QUIRK(0x1043, 0x1e11, "ASUS Zephyrus G15", ALC289_FIXUP_ASUS_GA502),
10666 	SND_PCI_QUIRK(0x1043, 0x1e12, "ASUS UM3402", ALC287_FIXUP_CS35L41_I2C_2),
10667 	SND_PCI_QUIRK(0x1043, 0x1e1f, "ASUS Vivobook 15 X1504VAP", ALC2XX_FIXUP_HEADSET_MIC),
10668 	SND_PCI_QUIRK(0x1043, 0x1e51, "ASUS Zephyrus M15", ALC294_FIXUP_ASUS_GU502_PINS),
10669 	SND_PCI_QUIRK(0x1043, 0x1e5e, "ASUS ROG Strix G513", ALC294_FIXUP_ASUS_G513_PINS),
10670 	SND_PCI_QUIRK(0x1043, 0x1e8e, "ASUS Zephyrus G15", ALC289_FIXUP_ASUS_GA401),
10671 	SND_PCI_QUIRK(0x1043, 0x1eb3, "ASUS Ally RCLA72", ALC287_FIXUP_TAS2781_I2C),
10672 	SND_PCI_QUIRK(0x1043, 0x1ed3, "ASUS HN7306W", ALC287_FIXUP_CS35L41_I2C_2),
10673 	SND_PCI_QUIRK(0x1043, 0x1ee2, "ASUS UM6702RA/RC", ALC287_FIXUP_CS35L41_I2C_2),
10674 	SND_PCI_QUIRK(0x1043, 0x1c52, "ASUS Zephyrus G15 2022", ALC289_FIXUP_ASUS_GA401),
10675 	SND_PCI_QUIRK(0x1043, 0x1f11, "ASUS Zephyrus G14", ALC289_FIXUP_ASUS_GA401),
10676 	SND_PCI_QUIRK(0x1043, 0x1f12, "ASUS UM5302", ALC287_FIXUP_CS35L41_I2C_2),
10677 	SND_PCI_QUIRK(0x1043, 0x1f1f, "ASUS H7604JI/JV/J3D", ALC245_FIXUP_CS35L41_SPI_2),
10678 	SND_PCI_QUIRK(0x1043, 0x1f62, "ASUS UX7602ZM", ALC245_FIXUP_CS35L41_SPI_2),
10679 	SND_PCI_QUIRK(0x1043, 0x1f92, "ASUS ROG Flow X16", ALC289_FIXUP_ASUS_GA401),
10680 	SND_PCI_QUIRK(0x1043, 0x3030, "ASUS ZN270IE", ALC256_FIXUP_ASUS_AIO_GPIO2),
10681 	SND_PCI_QUIRK(0x1043, 0x3a20, "ASUS G614JZR", ALC285_FIXUP_ASUS_SPI_REAR_SPEAKERS),
10682 	SND_PCI_QUIRK(0x1043, 0x3a30, "ASUS G814JVR/JIR", ALC285_FIXUP_ASUS_SPI_REAR_SPEAKERS),
10683 	SND_PCI_QUIRK(0x1043, 0x3a40, "ASUS G814JZR", ALC285_FIXUP_ASUS_SPI_REAR_SPEAKERS),
10684 	SND_PCI_QUIRK(0x1043, 0x3a50, "ASUS G834JYR/JZR", ALC285_FIXUP_ASUS_SPI_REAR_SPEAKERS),
10685 	SND_PCI_QUIRK(0x1043, 0x3a60, "ASUS G634JYR/JZR", ALC285_FIXUP_ASUS_SPI_REAR_SPEAKERS),
10686 	SND_PCI_QUIRK(0x1043, 0x3e30, "ASUS TP3607SA", ALC287_FIXUP_TAS2781_I2C),
10687 	SND_PCI_QUIRK(0x1043, 0x3ee0, "ASUS Strix G815_JHR_JMR_JPR", ALC287_FIXUP_TAS2781_I2C),
10688 	SND_PCI_QUIRK(0x1043, 0x3ef0, "ASUS Strix G635LR_LW_LX", ALC287_FIXUP_TAS2781_I2C),
10689 	SND_PCI_QUIRK(0x1043, 0x3f00, "ASUS Strix G815LH_LM_LP", ALC287_FIXUP_TAS2781_I2C),
10690 	SND_PCI_QUIRK(0x1043, 0x3f10, "ASUS Strix G835LR_LW_LX", ALC287_FIXUP_TAS2781_I2C),
10691 	SND_PCI_QUIRK(0x1043, 0x3f20, "ASUS Strix G615LR_LW", ALC287_FIXUP_TAS2781_I2C),
10692 	SND_PCI_QUIRK(0x1043, 0x3f30, "ASUS Strix G815LR_LW", ALC287_FIXUP_TAS2781_I2C),
10693 	SND_PCI_QUIRK(0x1043, 0x831a, "ASUS P901", ALC269_FIXUP_STEREO_DMIC),
10694 	SND_PCI_QUIRK(0x1043, 0x834a, "ASUS S101", ALC269_FIXUP_STEREO_DMIC),
10695 	SND_PCI_QUIRK(0x1043, 0x8398, "ASUS P1005", ALC269_FIXUP_STEREO_DMIC),
10696 	SND_PCI_QUIRK(0x1043, 0x83ce, "ASUS P1005", ALC269_FIXUP_STEREO_DMIC),
10697 	SND_PCI_QUIRK(0x1043, 0x8516, "ASUS X101CH", ALC269_FIXUP_ASUS_X101),
10698 	SND_PCI_QUIRK(0x104d, 0x9073, "Sony VAIO", ALC275_FIXUP_SONY_VAIO_GPIO2),
10699 	SND_PCI_QUIRK(0x104d, 0x907b, "Sony VAIO", ALC275_FIXUP_SONY_HWEQ),
10700 	SND_PCI_QUIRK(0x104d, 0x9084, "Sony VAIO", ALC275_FIXUP_SONY_HWEQ),
10701 	SND_PCI_QUIRK(0x104d, 0x9099, "Sony VAIO S13", ALC275_FIXUP_SONY_DISABLE_AAMIX),
10702 	SND_PCI_QUIRK(0x104d, 0x90b5, "Sony VAIO Pro 11", ALC286_FIXUP_SONY_MIC_NO_PRESENCE),
10703 	SND_PCI_QUIRK(0x104d, 0x90b6, "Sony VAIO Pro 13", ALC286_FIXUP_SONY_MIC_NO_PRESENCE),
10704 	SND_PCI_QUIRK(0x10cf, 0x1475, "Lifebook", ALC269_FIXUP_LIFEBOOK),
10705 	SND_PCI_QUIRK(0x10cf, 0x159f, "Lifebook E780", ALC269_FIXUP_LIFEBOOK_NO_HP_TO_LINEOUT),
10706 	SND_PCI_QUIRK(0x10cf, 0x15dc, "Lifebook T731", ALC269_FIXUP_LIFEBOOK_HP_PIN),
10707 	SND_PCI_QUIRK(0x10cf, 0x1629, "Lifebook U7x7", ALC255_FIXUP_LIFEBOOK_U7x7_HEADSET_MIC),
10708 	SND_PCI_QUIRK(0x10cf, 0x1757, "Lifebook E752", ALC269_FIXUP_LIFEBOOK_HP_PIN),
10709 	SND_PCI_QUIRK(0x10cf, 0x1845, "Lifebook U904", ALC269_FIXUP_LIFEBOOK_EXTMIC),
10710 	SND_PCI_QUIRK(0x10ec, 0x10f2, "Intel Reference board", ALC700_FIXUP_INTEL_REFERENCE),
10711 	SND_PCI_QUIRK(0x10ec, 0x118c, "Medion EE4254 MD62100", ALC256_FIXUP_MEDION_HEADSET_NO_PRESENCE),
10712 	SND_PCI_QUIRK(0x10ec, 0x119e, "Positivo SU C1400", ALC269_FIXUP_ASPIRE_HEADSET_MIC),
10713 	SND_PCI_QUIRK(0x10ec, 0x11bc, "VAIO VJFE-IL", ALC269_FIXUP_LIMIT_INT_MIC_BOOST),
10714 	SND_PCI_QUIRK(0x10ec, 0x1230, "Intel Reference board", ALC295_FIXUP_CHROME_BOOK),
10715 	SND_PCI_QUIRK(0x10ec, 0x124c, "Intel Reference board", ALC295_FIXUP_CHROME_BOOK),
10716 	SND_PCI_QUIRK(0x10ec, 0x1252, "Intel Reference board", ALC295_FIXUP_CHROME_BOOK),
10717 	SND_PCI_QUIRK(0x10ec, 0x1254, "Intel Reference board", ALC295_FIXUP_CHROME_BOOK),
10718 	SND_PCI_QUIRK(0x10ec, 0x12cc, "Intel Reference board", ALC295_FIXUP_CHROME_BOOK),
10719 	SND_PCI_QUIRK(0x10ec, 0x12f6, "Intel Reference board", ALC295_FIXUP_CHROME_BOOK),
10720 	SND_PCI_QUIRK(0x10f7, 0x8338, "Panasonic CF-SZ6", ALC269_FIXUP_ASPIRE_HEADSET_MIC),
10721 	SND_PCI_QUIRK(0x144d, 0xc109, "Samsung Ativ book 9 (NP900X3G)", ALC269_FIXUP_INV_DMIC),
10722 	SND_PCI_QUIRK(0x144d, 0xc169, "Samsung Notebook 9 Pen (NP930SBE-K01US)", ALC298_FIXUP_SAMSUNG_AMP),
10723 	SND_PCI_QUIRK(0x144d, 0xc176, "Samsung Notebook 9 Pro (NP930MBE-K04US)", ALC298_FIXUP_SAMSUNG_AMP),
10724 	SND_PCI_QUIRK(0x144d, 0xc189, "Samsung Galaxy Flex Book (NT950QCG-X716)", ALC298_FIXUP_SAMSUNG_AMP),
10725 	SND_PCI_QUIRK(0x144d, 0xc18a, "Samsung Galaxy Book Ion (NP930XCJ-K01US)", ALC298_FIXUP_SAMSUNG_AMP),
10726 	SND_PCI_QUIRK(0x144d, 0xc1a3, "Samsung Galaxy Book Pro (NP935XDB-KC1SE)", ALC298_FIXUP_SAMSUNG_AMP),
10727 	SND_PCI_QUIRK(0x144d, 0xc1a4, "Samsung Galaxy Book Pro 360 (NT935QBD)", ALC298_FIXUP_SAMSUNG_AMP),
10728 	SND_PCI_QUIRK(0x144d, 0xc1a6, "Samsung Galaxy Book Pro 360 (NP930QBD)", ALC298_FIXUP_SAMSUNG_AMP),
10729 	SND_PCI_QUIRK(0x144d, 0xc740, "Samsung Ativ book 8 (NP870Z5G)", ALC269_FIXUP_ATIV_BOOK_8),
10730 	SND_PCI_QUIRK(0x144d, 0xc812, "Samsung Notebook Pen S (NT950SBE-X58)", ALC298_FIXUP_SAMSUNG_AMP),
10731 	SND_PCI_QUIRK(0x144d, 0xc830, "Samsung Galaxy Book Ion (NT950XCJ-X716A)", ALC298_FIXUP_SAMSUNG_AMP),
10732 	SND_PCI_QUIRK(0x144d, 0xc832, "Samsung Galaxy Book Flex Alpha (NP730QCJ)", ALC256_FIXUP_SAMSUNG_HEADPHONE_VERY_QUIET),
10733 	SND_PCI_QUIRK(0x144d, 0xca03, "Samsung Galaxy Book2 Pro 360 (NP930QED)", ALC298_FIXUP_SAMSUNG_AMP),
10734 	SND_PCI_QUIRK(0x144d, 0xc868, "Samsung Galaxy Book2 Pro (NP930XED)", ALC298_FIXUP_SAMSUNG_AMP),
10735 	SND_PCI_QUIRK(0x144d, 0xc870, "Samsung Galaxy Book2 Pro (NP950XED)", ALC298_FIXUP_SAMSUNG_AMP_V2_2_AMPS),
10736 	SND_PCI_QUIRK(0x144d, 0xc872, "Samsung Galaxy Book2 Pro (NP950XEE)", ALC298_FIXUP_SAMSUNG_AMP_V2_2_AMPS),
10737 	SND_PCI_QUIRK(0x144d, 0xc886, "Samsung Galaxy Book3 Pro (NP964XFG)", ALC298_FIXUP_SAMSUNG_AMP_V2_4_AMPS),
10738 	SND_PCI_QUIRK(0x144d, 0xc1ca, "Samsung Galaxy Book3 Pro 360 (NP960QFG)", ALC298_FIXUP_SAMSUNG_AMP_V2_4_AMPS),
10739 	SND_PCI_QUIRK(0x144d, 0xc1cc, "Samsung Galaxy Book3 Ultra (NT960XFH)", ALC298_FIXUP_SAMSUNG_AMP_V2_4_AMPS),
10740 	SND_PCI_QUIRK(0x1458, 0xfa53, "Gigabyte BXBT-2807", ALC283_FIXUP_HEADSET_MIC),
10741 	SND_PCI_QUIRK(0x1462, 0xb120, "MSI Cubi MS-B120", ALC283_FIXUP_HEADSET_MIC),
10742 	SND_PCI_QUIRK(0x1462, 0xb171, "Cubi N 8GL (MS-B171)", ALC283_FIXUP_HEADSET_MIC),
10743 	SND_PCI_QUIRK(0x152d, 0x1082, "Quanta NL3", ALC269_FIXUP_LIFEBOOK),
10744 	SND_PCI_QUIRK(0x152d, 0x1262, "Huawei NBLB-WAX9N", ALC2XX_FIXUP_HEADSET_MIC),
10745 	SND_PCI_QUIRK(0x1558, 0x0353, "Clevo V35[05]SN[CDE]Q", ALC256_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10746 	SND_PCI_QUIRK(0x1558, 0x1323, "Clevo N130ZU", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10747 	SND_PCI_QUIRK(0x1558, 0x1325, "Clevo N15[01][CW]U", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10748 	SND_PCI_QUIRK(0x1558, 0x1401, "Clevo L140[CZ]U", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10749 	SND_PCI_QUIRK(0x1558, 0x1403, "Clevo N140CU", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10750 	SND_PCI_QUIRK(0x1558, 0x1404, "Clevo N150CU", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10751 	SND_PCI_QUIRK(0x1558, 0x14a1, "Clevo L141MU", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10752 	SND_PCI_QUIRK(0x1558, 0x2624, "Clevo L240TU", ALC256_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10753 	SND_PCI_QUIRK(0x1558, 0x28c1, "Clevo V370VND", ALC2XX_FIXUP_HEADSET_MIC),
10754 	SND_PCI_QUIRK(0x1558, 0x4018, "Clevo NV40M[BE]", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10755 	SND_PCI_QUIRK(0x1558, 0x4019, "Clevo NV40MZ", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10756 	SND_PCI_QUIRK(0x1558, 0x4020, "Clevo NV40MB", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10757 	SND_PCI_QUIRK(0x1558, 0x4041, "Clevo NV4[15]PZ", ALC256_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10758 	SND_PCI_QUIRK(0x1558, 0x40a1, "Clevo NL40GU", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10759 	SND_PCI_QUIRK(0x1558, 0x40c1, "Clevo NL40[CZ]U", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10760 	SND_PCI_QUIRK(0x1558, 0x40d1, "Clevo NL41DU", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10761 	SND_PCI_QUIRK(0x1558, 0x5015, "Clevo NH5[58]H[HJK]Q", ALC256_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10762 	SND_PCI_QUIRK(0x1558, 0x5017, "Clevo NH7[79]H[HJK]Q", ALC256_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10763 	SND_PCI_QUIRK(0x1558, 0x50a3, "Clevo NJ51GU", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10764 	SND_PCI_QUIRK(0x1558, 0x50b3, "Clevo NK50S[BEZ]", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10765 	SND_PCI_QUIRK(0x1558, 0x50b6, "Clevo NK50S5", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10766 	SND_PCI_QUIRK(0x1558, 0x50b8, "Clevo NK50SZ", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10767 	SND_PCI_QUIRK(0x1558, 0x50d5, "Clevo NP50D5", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10768 	SND_PCI_QUIRK(0x1558, 0x50e1, "Clevo NH5[58]HPQ", ALC256_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10769 	SND_PCI_QUIRK(0x1558, 0x50e2, "Clevo NH7[79]HPQ", ALC256_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10770 	SND_PCI_QUIRK(0x1558, 0x50f0, "Clevo NH50A[CDF]", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10771 	SND_PCI_QUIRK(0x1558, 0x50f2, "Clevo NH50E[PR]", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10772 	SND_PCI_QUIRK(0x1558, 0x50f3, "Clevo NH58DPQ", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10773 	SND_PCI_QUIRK(0x1558, 0x50f5, "Clevo NH55EPY", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10774 	SND_PCI_QUIRK(0x1558, 0x50f6, "Clevo NH55DPQ", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10775 	SND_PCI_QUIRK(0x1558, 0x5101, "Clevo S510WU", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10776 	SND_PCI_QUIRK(0x1558, 0x5157, "Clevo W517GU1", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10777 	SND_PCI_QUIRK(0x1558, 0x51a1, "Clevo NS50MU", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10778 	SND_PCI_QUIRK(0x1558, 0x51b1, "Clevo NS50AU", ALC256_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10779 	SND_PCI_QUIRK(0x1558, 0x51b3, "Clevo NS70AU", ALC256_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10780 	SND_PCI_QUIRK(0x1558, 0x5630, "Clevo NP50RNJS", ALC256_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10781 	SND_PCI_QUIRK(0x1558, 0x70a1, "Clevo NB70T[HJK]", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10782 	SND_PCI_QUIRK(0x1558, 0x70b3, "Clevo NK70SB", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10783 	SND_PCI_QUIRK(0x1558, 0x70f2, "Clevo NH79EPY", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10784 	SND_PCI_QUIRK(0x1558, 0x70f3, "Clevo NH77DPQ", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10785 	SND_PCI_QUIRK(0x1558, 0x70f4, "Clevo NH77EPY", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10786 	SND_PCI_QUIRK(0x1558, 0x70f6, "Clevo NH77DPQ-Y", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10787 	SND_PCI_QUIRK(0x1558, 0x7716, "Clevo NS50PU", ALC256_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10788 	SND_PCI_QUIRK(0x1558, 0x7717, "Clevo NS70PU", ALC256_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10789 	SND_PCI_QUIRK(0x1558, 0x7718, "Clevo L140PU", ALC256_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10790 	SND_PCI_QUIRK(0x1558, 0x7724, "Clevo L140AU", ALC256_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10791 	SND_PCI_QUIRK(0x1558, 0x8228, "Clevo NR40BU", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10792 	SND_PCI_QUIRK(0x1558, 0x8520, "Clevo NH50D[CD]", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10793 	SND_PCI_QUIRK(0x1558, 0x8521, "Clevo NH77D[CD]", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10794 	SND_PCI_QUIRK(0x1558, 0x8535, "Clevo NH50D[BE]", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10795 	SND_PCI_QUIRK(0x1558, 0x8536, "Clevo NH79D[BE]", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10796 	SND_PCI_QUIRK(0x1558, 0x8550, "Clevo NH[57][0-9][ER][ACDH]Q", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10797 	SND_PCI_QUIRK(0x1558, 0x8551, "Clevo NH[57][0-9][ER][ACDH]Q", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10798 	SND_PCI_QUIRK(0x1558, 0x8560, "Clevo NH[57][0-9][ER][ACDH]Q", ALC269_FIXUP_HEADSET_MIC),
10799 	SND_PCI_QUIRK(0x1558, 0x8561, "Clevo NH[57][0-9][ER][ACDH]Q", ALC269_FIXUP_HEADSET_MIC),
10800 	SND_PCI_QUIRK(0x1558, 0x8562, "Clevo NH[57][0-9]RZ[Q]", ALC269_FIXUP_DMIC),
10801 	SND_PCI_QUIRK(0x1558, 0x8668, "Clevo NP50B[BE]", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10802 	SND_PCI_QUIRK(0x1558, 0x866d, "Clevo NP5[05]PN[HJK]", ALC256_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10803 	SND_PCI_QUIRK(0x1558, 0x867c, "Clevo NP7[01]PNP", ALC256_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10804 	SND_PCI_QUIRK(0x1558, 0x867d, "Clevo NP7[01]PN[HJK]", ALC256_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10805 	SND_PCI_QUIRK(0x1558, 0x8680, "Clevo NJ50LU", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10806 	SND_PCI_QUIRK(0x1558, 0x8686, "Clevo NH50[CZ]U", ALC256_FIXUP_MIC_NO_PRESENCE_AND_RESUME),
10807 	SND_PCI_QUIRK(0x1558, 0x8a20, "Clevo NH55DCQ-Y", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10808 	SND_PCI_QUIRK(0x1558, 0x8a51, "Clevo NH70RCQ-Y", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10809 	SND_PCI_QUIRK(0x1558, 0x8d50, "Clevo NH55RCQ-M", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10810 	SND_PCI_QUIRK(0x1558, 0x951d, "Clevo N950T[CDF]", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10811 	SND_PCI_QUIRK(0x1558, 0x9600, "Clevo N960K[PR]", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10812 	SND_PCI_QUIRK(0x1558, 0x961d, "Clevo N960S[CDF]", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10813 	SND_PCI_QUIRK(0x1558, 0x971d, "Clevo N970T[CDF]", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10814 	SND_PCI_QUIRK(0x1558, 0xa500, "Clevo NL5[03]RU", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10815 	SND_PCI_QUIRK(0x1558, 0xa554, "VAIO VJFH52", ALC269_FIXUP_VAIO_VJFH52_MIC_NO_PRESENCE),
10816 	SND_PCI_QUIRK(0x1558, 0xa600, "Clevo NL50NU", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10817 	SND_PCI_QUIRK(0x1558, 0xa650, "Clevo NP[567]0SN[CD]", ALC256_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10818 	SND_PCI_QUIRK(0x1558, 0xa671, "Clevo NP70SN[CDE]", ALC256_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10819 	SND_PCI_QUIRK(0x1558, 0xa741, "Clevo V54x_6x_TNE", ALC245_FIXUP_CLEVO_NOISY_MIC),
10820 	SND_PCI_QUIRK(0x1558, 0xa763, "Clevo V54x_6x_TU", ALC245_FIXUP_CLEVO_NOISY_MIC),
10821 	SND_PCI_QUIRK(0x1558, 0xb018, "Clevo NP50D[BE]", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10822 	SND_PCI_QUIRK(0x1558, 0xb019, "Clevo NH77D[BE]Q", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10823 	SND_PCI_QUIRK(0x1558, 0xb022, "Clevo NH77D[DC][QW]", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10824 	SND_PCI_QUIRK(0x1558, 0xc018, "Clevo NP50D[BE]", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10825 	SND_PCI_QUIRK(0x1558, 0xc019, "Clevo NH77D[BE]Q", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10826 	SND_PCI_QUIRK(0x1558, 0xc022, "Clevo NH77[DC][QW]", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10827 	SND_PCI_QUIRK(0x17aa, 0x1036, "Lenovo P520", ALC233_FIXUP_LENOVO_MULTI_CODECS),
10828 	SND_PCI_QUIRK(0x17aa, 0x1048, "ThinkCentre Station", ALC623_FIXUP_LENOVO_THINKSTATION_P340),
10829 	SND_PCI_QUIRK(0x17aa, 0x20f2, "Thinkpad SL410/510", ALC269_FIXUP_SKU_IGNORE),
10830 	SND_PCI_QUIRK(0x17aa, 0x215e, "Thinkpad L512", ALC269_FIXUP_SKU_IGNORE),
10831 	SND_PCI_QUIRK(0x17aa, 0x21b8, "Thinkpad Edge 14", ALC269_FIXUP_SKU_IGNORE),
10832 	SND_PCI_QUIRK(0x17aa, 0x21ca, "Thinkpad L412", ALC269_FIXUP_SKU_IGNORE),
10833 	SND_PCI_QUIRK(0x17aa, 0x21e9, "Thinkpad Edge 15", ALC269_FIXUP_SKU_IGNORE),
10834 	SND_PCI_QUIRK(0x17aa, 0x21f3, "Thinkpad T430", ALC269_FIXUP_LENOVO_DOCK),
10835 	SND_PCI_QUIRK(0x17aa, 0x21f6, "Thinkpad T530", ALC269_FIXUP_LENOVO_DOCK_LIMIT_BOOST),
10836 	SND_PCI_QUIRK(0x17aa, 0x21fa, "Thinkpad X230", ALC269_FIXUP_LENOVO_DOCK),
10837 	SND_PCI_QUIRK(0x17aa, 0x21fb, "Thinkpad T430s", ALC269_FIXUP_LENOVO_DOCK),
10838 	SND_PCI_QUIRK(0x17aa, 0x2203, "Thinkpad X230 Tablet", ALC269_FIXUP_LENOVO_DOCK),
10839 	SND_PCI_QUIRK(0x17aa, 0x2208, "Thinkpad T431s", ALC269_FIXUP_LENOVO_DOCK),
10840 	SND_PCI_QUIRK(0x17aa, 0x220c, "Thinkpad T440s", ALC292_FIXUP_TPT440),
10841 	SND_PCI_QUIRK(0x17aa, 0x220e, "Thinkpad T440p", ALC292_FIXUP_TPT440_DOCK),
10842 	SND_PCI_QUIRK(0x17aa, 0x2210, "Thinkpad T540p", ALC292_FIXUP_TPT440_DOCK),
10843 	SND_PCI_QUIRK(0x17aa, 0x2211, "Thinkpad W541", ALC292_FIXUP_TPT440_DOCK),
10844 	SND_PCI_QUIRK(0x17aa, 0x2212, "Thinkpad T440", ALC292_FIXUP_TPT440_DOCK),
10845 	SND_PCI_QUIRK(0x17aa, 0x2214, "Thinkpad X240", ALC292_FIXUP_TPT440_DOCK),
10846 	SND_PCI_QUIRK(0x17aa, 0x2215, "Thinkpad", ALC269_FIXUP_LIMIT_INT_MIC_BOOST),
10847 	SND_PCI_QUIRK(0x17aa, 0x2218, "Thinkpad X1 Carbon 2nd", ALC292_FIXUP_TPT440_DOCK),
10848 	SND_PCI_QUIRK(0x17aa, 0x2223, "ThinkPad T550", ALC292_FIXUP_TPT440_DOCK),
10849 	SND_PCI_QUIRK(0x17aa, 0x2226, "ThinkPad X250", ALC292_FIXUP_TPT440_DOCK),
10850 	SND_PCI_QUIRK(0x17aa, 0x222d, "Thinkpad", ALC298_FIXUP_TPT470_DOCK),
10851 	SND_PCI_QUIRK(0x17aa, 0x222e, "Thinkpad", ALC298_FIXUP_TPT470_DOCK),
10852 	SND_PCI_QUIRK(0x17aa, 0x2231, "Thinkpad T560", ALC292_FIXUP_TPT460),
10853 	SND_PCI_QUIRK(0x17aa, 0x2233, "Thinkpad", ALC292_FIXUP_TPT460),
10854 	SND_PCI_QUIRK(0x17aa, 0x2234, "Thinkpad ICE-1", ALC287_FIXUP_TAS2781_I2C),
10855 	SND_PCI_QUIRK(0x17aa, 0x2245, "Thinkpad T470", ALC298_FIXUP_TPT470_DOCK),
10856 	SND_PCI_QUIRK(0x17aa, 0x2246, "Thinkpad", ALC298_FIXUP_TPT470_DOCK),
10857 	SND_PCI_QUIRK(0x17aa, 0x2247, "Thinkpad", ALC298_FIXUP_TPT470_DOCK),
10858 	SND_PCI_QUIRK(0x17aa, 0x2249, "Thinkpad", ALC292_FIXUP_TPT460),
10859 	SND_PCI_QUIRK(0x17aa, 0x224b, "Thinkpad", ALC298_FIXUP_TPT470_DOCK),
10860 	SND_PCI_QUIRK(0x17aa, 0x224c, "Thinkpad", ALC298_FIXUP_TPT470_DOCK),
10861 	SND_PCI_QUIRK(0x17aa, 0x224d, "Thinkpad", ALC298_FIXUP_TPT470_DOCK),
10862 	SND_PCI_QUIRK(0x17aa, 0x225d, "Thinkpad T480", ALC269_FIXUP_LIMIT_INT_MIC_BOOST),
10863 	SND_PCI_QUIRK(0x17aa, 0x2292, "Thinkpad X1 Carbon 7th", ALC285_FIXUP_THINKPAD_HEADSET_JACK),
10864 	SND_PCI_QUIRK(0x17aa, 0x22be, "Thinkpad X1 Carbon 8th", ALC285_FIXUP_THINKPAD_HEADSET_JACK),
10865 	SND_PCI_QUIRK(0x17aa, 0x22c1, "Thinkpad P1 Gen 3", ALC285_FIXUP_THINKPAD_NO_BASS_SPK_HEADSET_JACK),
10866 	SND_PCI_QUIRK(0x17aa, 0x22c2, "Thinkpad X1 Extreme Gen 3", ALC285_FIXUP_THINKPAD_NO_BASS_SPK_HEADSET_JACK),
10867 	SND_PCI_QUIRK(0x17aa, 0x22f1, "Thinkpad", ALC287_FIXUP_MG_RTKC_CSAMP_CS35L41_I2C_THINKPAD),
10868 	SND_PCI_QUIRK(0x17aa, 0x22f2, "Thinkpad", ALC287_FIXUP_MG_RTKC_CSAMP_CS35L41_I2C_THINKPAD),
10869 	SND_PCI_QUIRK(0x17aa, 0x22f3, "Thinkpad", ALC287_FIXUP_MG_RTKC_CSAMP_CS35L41_I2C_THINKPAD),
10870 	SND_PCI_QUIRK(0x17aa, 0x2316, "Thinkpad P1 Gen 6", ALC287_FIXUP_MG_RTKC_CSAMP_CS35L41_I2C_THINKPAD),
10871 	SND_PCI_QUIRK(0x17aa, 0x2317, "Thinkpad P1 Gen 6", ALC287_FIXUP_MG_RTKC_CSAMP_CS35L41_I2C_THINKPAD),
10872 	SND_PCI_QUIRK(0x17aa, 0x2318, "Thinkpad Z13 Gen2", ALC287_FIXUP_MG_RTKC_CSAMP_CS35L41_I2C_THINKPAD),
10873 	SND_PCI_QUIRK(0x17aa, 0x2319, "Thinkpad Z16 Gen2", ALC287_FIXUP_MG_RTKC_CSAMP_CS35L41_I2C_THINKPAD),
10874 	SND_PCI_QUIRK(0x17aa, 0x231a, "Thinkpad Z16 Gen2", ALC287_FIXUP_MG_RTKC_CSAMP_CS35L41_I2C_THINKPAD),
10875 	SND_PCI_QUIRK(0x17aa, 0x231e, "Thinkpad", ALC287_FIXUP_LENOVO_THKPAD_WH_ALC1318),
10876 	SND_PCI_QUIRK(0x17aa, 0x231f, "Thinkpad", ALC287_FIXUP_LENOVO_THKPAD_WH_ALC1318),
10877 	SND_PCI_QUIRK(0x17aa, 0x2326, "Hera2", ALC287_FIXUP_TAS2781_I2C),
10878 	SND_PCI_QUIRK(0x17aa, 0x30bb, "ThinkCentre AIO", ALC233_FIXUP_LENOVO_LINE2_MIC_HOTKEY),
10879 	SND_PCI_QUIRK(0x17aa, 0x30e2, "ThinkCentre AIO", ALC233_FIXUP_LENOVO_LINE2_MIC_HOTKEY),
10880 	SND_PCI_QUIRK(0x17aa, 0x310c, "ThinkCentre Station", ALC294_FIXUP_LENOVO_MIC_LOCATION),
10881 	SND_PCI_QUIRK(0x17aa, 0x3111, "ThinkCentre Station", ALC294_FIXUP_LENOVO_MIC_LOCATION),
10882 	SND_PCI_QUIRK(0x17aa, 0x312a, "ThinkCentre Station", ALC294_FIXUP_LENOVO_MIC_LOCATION),
10883 	SND_PCI_QUIRK(0x17aa, 0x312f, "ThinkCentre Station", ALC294_FIXUP_LENOVO_MIC_LOCATION),
10884 	SND_PCI_QUIRK(0x17aa, 0x313c, "ThinkCentre Station", ALC294_FIXUP_LENOVO_MIC_LOCATION),
10885 	SND_PCI_QUIRK(0x17aa, 0x3151, "ThinkCentre Station", ALC283_FIXUP_HEADSET_MIC),
10886 	SND_PCI_QUIRK(0x17aa, 0x3176, "ThinkCentre Station", ALC283_FIXUP_HEADSET_MIC),
10887 	SND_PCI_QUIRK(0x17aa, 0x3178, "ThinkCentre Station", ALC283_FIXUP_HEADSET_MIC),
10888 	SND_PCI_QUIRK(0x17aa, 0x31af, "ThinkCentre Station", ALC623_FIXUP_LENOVO_THINKSTATION_P340),
10889 	SND_PCI_QUIRK(0x17aa, 0x334b, "Lenovo ThinkCentre M70 Gen5", ALC283_FIXUP_HEADSET_MIC),
10890 	SND_PCI_QUIRK(0x17aa, 0x3801, "Lenovo Yoga9 14IAP7", ALC287_FIXUP_YOGA9_14IAP7_BASS_SPK_PIN),
10891 	SND_PCI_QUIRK(0x17aa, 0x3802, "Lenovo Yoga Pro 9 14IRP8 / DuetITL 2021", ALC287_FIXUP_LENOVO_14IRP8_DUETITL),
10892 	SND_PCI_QUIRK(0x17aa, 0x3813, "Legion 7i 15IMHG05", ALC287_FIXUP_LEGION_15IMHG05_SPEAKERS),
10893 	SND_PCI_QUIRK(0x17aa, 0x3818, "Lenovo C940 / Yoga Duet 7", ALC298_FIXUP_LENOVO_C940_DUET7),
10894 	SND_PCI_QUIRK(0x17aa, 0x3819, "Lenovo 13s Gen2 ITL", ALC287_FIXUP_13S_GEN2_SPEAKERS),
10895 	SND_PCI_QUIRK(0x17aa, 0x3820, "IdeaPad 330 / Yoga Duet 7", ALC287_FIXUP_LENOVO_SSID_17AA3820),
10896 	SND_PCI_QUIRK(0x17aa, 0x3824, "Legion Y9000X 2020", ALC285_FIXUP_LEGION_Y9000X_SPEAKERS),
10897 	SND_PCI_QUIRK(0x17aa, 0x3827, "Ideapad S740", ALC285_FIXUP_IDEAPAD_S740_COEF),
10898 	SND_PCI_QUIRK(0x17aa, 0x3834, "Lenovo IdeaPad Slim 9i 14ITL5", ALC287_FIXUP_YOGA7_14ITL_SPEAKERS),
10899 	SND_PCI_QUIRK(0x17aa, 0x383d, "Legion Y9000X 2019", ALC285_FIXUP_LEGION_Y9000X_SPEAKERS),
10900 	SND_PCI_QUIRK(0x17aa, 0x3843, "Yoga 9i", ALC287_FIXUP_IDEAPAD_BASS_SPK_AMP),
10901 	SND_PCI_QUIRK(0x17aa, 0x3847, "Legion 7 16ACHG6", ALC287_FIXUP_LEGION_16ACHG6),
10902 	SND_PCI_QUIRK(0x17aa, 0x384a, "Lenovo Yoga 7 15ITL5", ALC287_FIXUP_YOGA7_14ITL_SPEAKERS),
10903 	SND_PCI_QUIRK(0x17aa, 0x3852, "Lenovo Yoga 7 14ITL5", ALC287_FIXUP_YOGA7_14ITL_SPEAKERS),
10904 	SND_PCI_QUIRK(0x17aa, 0x3853, "Lenovo Yoga 7 15ITL5", ALC287_FIXUP_YOGA7_14ITL_SPEAKERS),
10905 	SND_PCI_QUIRK(0x17aa, 0x3855, "Legion 7 16ITHG6", ALC287_FIXUP_LEGION_16ITHG6),
10906 	SND_PCI_QUIRK(0x17aa, 0x3865, "Lenovo 13X", ALC287_FIXUP_CS35L41_I2C_2),
10907 	SND_PCI_QUIRK(0x17aa, 0x3866, "Lenovo 13X", ALC287_FIXUP_CS35L41_I2C_2),
10908 	SND_PCI_QUIRK(0x17aa, 0x3869, "Lenovo Yoga7 14IAL7", ALC287_FIXUP_YOGA9_14IAP7_BASS_SPK_PIN),
10909 	SND_PCI_QUIRK(0x17aa, 0x386e, "Legion Y9000X 2022 IAH7 / Yoga Pro 7 14ARP8",  ALC287_FIXUP_LENOVO_14ARP8_LEGION_IAH7),
10910 	SND_PCI_QUIRK(0x17aa, 0x386f, "Legion Pro 7/7i", ALC287_FIXUP_LENOVO_LEGION_7),
10911 	SND_PCI_QUIRK(0x17aa, 0x3870, "Lenovo Yoga 7 14ARB7", ALC287_FIXUP_YOGA7_14ARB7_I2C),
10912 	SND_PCI_QUIRK(0x17aa, 0x3877, "Lenovo Legion 7 Slim 16ARHA7", ALC287_FIXUP_CS35L41_I2C_2),
10913 	SND_PCI_QUIRK(0x17aa, 0x3878, "Lenovo Legion 7 Slim 16ARHA7", ALC287_FIXUP_CS35L41_I2C_2),
10914 	SND_PCI_QUIRK(0x17aa, 0x387d, "Yoga S780-16 pro Quad AAC", ALC287_FIXUP_TAS2781_I2C),
10915 	SND_PCI_QUIRK(0x17aa, 0x387e, "Yoga S780-16 pro Quad YC", ALC287_FIXUP_TAS2781_I2C),
10916 	SND_PCI_QUIRK(0x17aa, 0x387f, "Yoga S780-16 pro dual LX", ALC287_FIXUP_TAS2781_I2C),
10917 	SND_PCI_QUIRK(0x17aa, 0x3880, "Yoga S780-16 pro dual YC", ALC287_FIXUP_TAS2781_I2C),
10918 	SND_PCI_QUIRK(0x17aa, 0x3881, "YB9 dual power mode2 YC", ALC287_FIXUP_TAS2781_I2C),
10919 	SND_PCI_QUIRK(0x17aa, 0x3882, "Lenovo Yoga Pro 7 14APH8", ALC287_FIXUP_YOGA9_14IAP7_BASS_SPK_PIN),
10920 	SND_PCI_QUIRK(0x17aa, 0x3884, "Y780 YG DUAL", ALC287_FIXUP_TAS2781_I2C),
10921 	SND_PCI_QUIRK(0x17aa, 0x3886, "Y780 VECO DUAL", ALC287_FIXUP_TAS2781_I2C),
10922 	SND_PCI_QUIRK(0x17aa, 0x3891, "Lenovo Yoga Pro 7 14AHP9", ALC287_FIXUP_YOGA9_14IAP7_BASS_SPK_PIN),
10923 	SND_PCI_QUIRK(0x17aa, 0x38a5, "Y580P AMD dual", ALC287_FIXUP_TAS2781_I2C),
10924 	SND_PCI_QUIRK(0x17aa, 0x38a7, "Y780P AMD YG dual", ALC287_FIXUP_TAS2781_I2C),
10925 	SND_PCI_QUIRK(0x17aa, 0x38a8, "Y780P AMD VECO dual", ALC287_FIXUP_TAS2781_I2C),
10926 	SND_PCI_QUIRK(0x17aa, 0x38a9, "Thinkbook 16P", ALC287_FIXUP_MG_RTKC_CSAMP_CS35L41_I2C_THINKPAD),
10927 	SND_PCI_QUIRK(0x17aa, 0x38ab, "Thinkbook 16P", ALC287_FIXUP_MG_RTKC_CSAMP_CS35L41_I2C_THINKPAD),
10928 	SND_PCI_QUIRK(0x17aa, 0x38b4, "Legion Slim 7 16IRH8", ALC287_FIXUP_CS35L41_I2C_2),
10929 	SND_PCI_QUIRK(0x17aa, 0x38b5, "Legion Slim 7 16IRH8", ALC287_FIXUP_CS35L41_I2C_2),
10930 	SND_PCI_QUIRK(0x17aa, 0x38b6, "Legion Slim 7 16APH8", ALC287_FIXUP_CS35L41_I2C_2),
10931 	SND_PCI_QUIRK(0x17aa, 0x38b7, "Legion Slim 7 16APH8", ALC287_FIXUP_CS35L41_I2C_2),
10932 	SND_PCI_QUIRK(0x17aa, 0x38b8, "Yoga S780-14.5 proX AMD YC Dual", ALC287_FIXUP_TAS2781_I2C),
10933 	SND_PCI_QUIRK(0x17aa, 0x38b9, "Yoga S780-14.5 proX AMD LX Dual", ALC287_FIXUP_TAS2781_I2C),
10934 	SND_PCI_QUIRK(0x17aa, 0x38ba, "Yoga S780-14.5 Air AMD quad YC", ALC287_FIXUP_TAS2781_I2C),
10935 	SND_PCI_QUIRK(0x17aa, 0x38bb, "Yoga S780-14.5 Air AMD quad AAC", ALC287_FIXUP_TAS2781_I2C),
10936 	SND_PCI_QUIRK(0x17aa, 0x38be, "Yoga S980-14.5 proX YC Dual", ALC287_FIXUP_TAS2781_I2C),
10937 	SND_PCI_QUIRK(0x17aa, 0x38bf, "Yoga S980-14.5 proX LX Dual", ALC287_FIXUP_TAS2781_I2C),
10938 	SND_PCI_QUIRK(0x17aa, 0x38c3, "Y980 DUAL", ALC287_FIXUP_TAS2781_I2C),
10939 	SND_PCI_QUIRK(0x17aa, 0x38c7, "Thinkbook 13x Gen 4", ALC287_FIXUP_CS35L41_I2C_4),
10940 	SND_PCI_QUIRK(0x17aa, 0x38c8, "Thinkbook 13x Gen 4", ALC287_FIXUP_CS35L41_I2C_4),
10941 	SND_PCI_QUIRK(0x17aa, 0x38cb, "Y790 YG DUAL", ALC287_FIXUP_TAS2781_I2C),
10942 	SND_PCI_QUIRK(0x17aa, 0x38cd, "Y790 VECO DUAL", ALC287_FIXUP_TAS2781_I2C),
10943 	SND_PCI_QUIRK(0x17aa, 0x38d2, "Lenovo Yoga 9 14IMH9", ALC287_FIXUP_YOGA9_14IMH9_BASS_SPK_PIN),
10944 	SND_PCI_QUIRK(0x17aa, 0x38d3, "Yoga S990-16 Pro IMH YC Dual", ALC287_FIXUP_TAS2781_I2C),
10945 	SND_PCI_QUIRK(0x17aa, 0x38d4, "Yoga S990-16 Pro IMH VECO Dual", ALC287_FIXUP_TAS2781_I2C),
10946 	SND_PCI_QUIRK(0x17aa, 0x38d5, "Yoga S990-16 Pro IMH YC Quad", ALC287_FIXUP_TAS2781_I2C),
10947 	SND_PCI_QUIRK(0x17aa, 0x38d6, "Yoga S990-16 Pro IMH VECO Quad", ALC287_FIXUP_TAS2781_I2C),
10948 	SND_PCI_QUIRK(0x17aa, 0x38d7, "Lenovo Yoga 9 14IMH9", ALC287_FIXUP_YOGA9_14IMH9_BASS_SPK_PIN),
10949 	SND_PCI_QUIRK(0x17aa, 0x38df, "Yoga Y990 Intel YC Dual", ALC287_FIXUP_TAS2781_I2C),
10950 	SND_PCI_QUIRK(0x17aa, 0x38e0, "Yoga Y990 Intel VECO Dual", ALC287_FIXUP_TAS2781_I2C),
10951 	SND_PCI_QUIRK(0x17aa, 0x38f8, "Yoga Book 9i", ALC287_FIXUP_TAS2781_I2C),
10952 	SND_PCI_QUIRK(0x17aa, 0x38df, "Y990 YG DUAL", ALC287_FIXUP_TAS2781_I2C),
10953 	SND_PCI_QUIRK(0x17aa, 0x38f9, "Thinkbook 16P Gen5", ALC287_FIXUP_CS35L41_I2C_2),
10954 	SND_PCI_QUIRK(0x17aa, 0x38fa, "Thinkbook 16P Gen5", ALC287_FIXUP_CS35L41_I2C_2),
10955 	SND_PCI_QUIRK(0x17aa, 0x38fd, "ThinkBook plus Gen5 Hybrid", ALC287_FIXUP_TAS2781_I2C),
10956 	SND_PCI_QUIRK(0x17aa, 0x3902, "Lenovo E50-80", ALC269_FIXUP_DMIC_THINKPAD_ACPI),
10957 	SND_PCI_QUIRK(0x17aa, 0x3913, "Lenovo 145", ALC236_FIXUP_LENOVO_INV_DMIC),
10958 	SND_PCI_QUIRK(0x17aa, 0x391f, "Yoga S990-16 pro Quad YC Quad", ALC287_FIXUP_TAS2781_I2C),
10959 	SND_PCI_QUIRK(0x17aa, 0x3920, "Yoga S990-16 pro Quad VECO Quad", ALC287_FIXUP_TAS2781_I2C),
10960 	SND_PCI_QUIRK(0x17aa, 0x3977, "IdeaPad S210", ALC283_FIXUP_INT_MIC),
10961 	SND_PCI_QUIRK(0x17aa, 0x3978, "Lenovo B50-70", ALC269_FIXUP_DMIC_THINKPAD_ACPI),
10962 	SND_PCI_QUIRK(0x17aa, 0x3bf8, "Quanta FL1", ALC269_FIXUP_PCM_44K),
10963 	SND_PCI_QUIRK(0x17aa, 0x5013, "Thinkpad", ALC269_FIXUP_LIMIT_INT_MIC_BOOST),
10964 	SND_PCI_QUIRK(0x17aa, 0x501a, "Thinkpad", ALC283_FIXUP_INT_MIC),
10965 	SND_PCI_QUIRK(0x17aa, 0x501e, "Thinkpad L440", ALC292_FIXUP_TPT440_DOCK),
10966 	SND_PCI_QUIRK(0x17aa, 0x5026, "Thinkpad", ALC269_FIXUP_LIMIT_INT_MIC_BOOST),
10967 	SND_PCI_QUIRK(0x17aa, 0x5034, "Thinkpad T450", ALC292_FIXUP_TPT440_DOCK),
10968 	SND_PCI_QUIRK(0x17aa, 0x5036, "Thinkpad T450s", ALC292_FIXUP_TPT440_DOCK),
10969 	SND_PCI_QUIRK(0x17aa, 0x503c, "Thinkpad L450", ALC292_FIXUP_TPT440_DOCK),
10970 	SND_PCI_QUIRK(0x17aa, 0x504a, "ThinkPad X260", ALC292_FIXUP_TPT440_DOCK),
10971 	SND_PCI_QUIRK(0x17aa, 0x504b, "Thinkpad", ALC293_FIXUP_LENOVO_SPK_NOISE),
10972 	SND_PCI_QUIRK(0x17aa, 0x5050, "Thinkpad T560p", ALC292_FIXUP_TPT460),
10973 	SND_PCI_QUIRK(0x17aa, 0x5051, "Thinkpad L460", ALC292_FIXUP_TPT460),
10974 	SND_PCI_QUIRK(0x17aa, 0x5053, "Thinkpad T460", ALC292_FIXUP_TPT460),
10975 	SND_PCI_QUIRK(0x17aa, 0x505d, "Thinkpad", ALC298_FIXUP_TPT470_DOCK),
10976 	SND_PCI_QUIRK(0x17aa, 0x505f, "Thinkpad", ALC298_FIXUP_TPT470_DOCK),
10977 	SND_PCI_QUIRK(0x17aa, 0x5062, "Thinkpad", ALC298_FIXUP_TPT470_DOCK),
10978 	SND_PCI_QUIRK(0x17aa, 0x508b, "Thinkpad X12 Gen 1", ALC287_FIXUP_LEGION_15IMHG05_SPEAKERS),
10979 	SND_PCI_QUIRK(0x17aa, 0x5109, "Thinkpad", ALC269_FIXUP_LIMIT_INT_MIC_BOOST),
10980 	SND_PCI_QUIRK(0x17aa, 0x511e, "Thinkpad", ALC298_FIXUP_TPT470_DOCK),
10981 	SND_PCI_QUIRK(0x17aa, 0x511f, "Thinkpad", ALC298_FIXUP_TPT470_DOCK),
10982 	SND_PCI_QUIRK(0x17aa, 0x9e54, "LENOVO NB", ALC269_FIXUP_LENOVO_EAPD),
10983 	SND_PCI_QUIRK(0x17aa, 0x9e56, "Lenovo ZhaoYang CF4620Z", ALC286_FIXUP_SONY_MIC_NO_PRESENCE),
10984 	SND_PCI_QUIRK(0x1849, 0x1233, "ASRock NUC Box 1100", ALC233_FIXUP_NO_AUDIO_JACK),
10985 	SND_PCI_QUIRK(0x1849, 0xa233, "Positivo Master C6300", ALC269_FIXUP_HEADSET_MIC),
10986 	SND_PCI_QUIRK(0x1854, 0x0440, "LG CQ6", ALC256_FIXUP_HEADPHONE_AMP_VOL),
10987 	SND_PCI_QUIRK(0x1854, 0x0441, "LG CQ6 AIO", ALC256_FIXUP_HEADPHONE_AMP_VOL),
10988 	SND_PCI_QUIRK(0x1854, 0x0488, "LG gram 16 (16Z90R)", ALC298_FIXUP_SAMSUNG_AMP_V2_4_AMPS),
10989 	SND_PCI_QUIRK(0x1854, 0x048a, "LG gram 17 (17ZD90R)", ALC298_FIXUP_SAMSUNG_AMP_V2_4_AMPS),
10990 	SND_PCI_QUIRK(0x19e5, 0x3204, "Huawei MACH-WX9", ALC256_FIXUP_HUAWEI_MACH_WX9_PINS),
10991 	SND_PCI_QUIRK(0x19e5, 0x320f, "Huawei WRT-WX9 ", ALC256_FIXUP_ASUS_MIC_NO_PRESENCE),
10992 	SND_PCI_QUIRK(0x19e5, 0x3212, "Huawei KLV-WX9 ", ALC256_FIXUP_ACER_HEADSET_MIC),
10993 	SND_PCI_QUIRK(0x1b35, 0x1235, "CZC B20", ALC269_FIXUP_CZC_B20),
10994 	SND_PCI_QUIRK(0x1b35, 0x1236, "CZC TMI", ALC269_FIXUP_CZC_TMI),
10995 	SND_PCI_QUIRK(0x1b35, 0x1237, "CZC L101", ALC269_FIXUP_CZC_L101),
10996 	SND_PCI_QUIRK(0x1b7d, 0xa831, "Ordissimo EVE2 ", ALC269VB_FIXUP_ORDISSIMO_EVE2), /* Also known as Malata PC-B1303 */
10997 	SND_PCI_QUIRK(0x1c06, 0x2013, "Lemote A1802", ALC269_FIXUP_LEMOTE_A1802),
10998 	SND_PCI_QUIRK(0x1c06, 0x2015, "Lemote A190X", ALC269_FIXUP_LEMOTE_A190X),
10999 	SND_PCI_QUIRK(0x1c6c, 0x122a, "Positivo N14AP7", ALC269_FIXUP_LIMIT_INT_MIC_BOOST),
11000 	SND_PCI_QUIRK(0x1c6c, 0x1251, "Positivo N14KP6-TG", ALC288_FIXUP_DELL1_MIC_NO_PRESENCE),
11001 	SND_PCI_QUIRK(0x1d05, 0x1132, "TongFang PHxTxX1", ALC256_FIXUP_SET_COEF_DEFAULTS),
11002 	SND_PCI_QUIRK(0x1d05, 0x1096, "TongFang GMxMRxx", ALC269_FIXUP_NO_SHUTUP),
11003 	SND_PCI_QUIRK(0x1d05, 0x1100, "TongFang GKxNRxx", ALC269_FIXUP_NO_SHUTUP),
11004 	SND_PCI_QUIRK(0x1d05, 0x1111, "TongFang GMxZGxx", ALC269_FIXUP_NO_SHUTUP),
11005 	SND_PCI_QUIRK(0x1d05, 0x1119, "TongFang GMxZGxx", ALC269_FIXUP_NO_SHUTUP),
11006 	SND_PCI_QUIRK(0x1d05, 0x1129, "TongFang GMxZGxx", ALC269_FIXUP_NO_SHUTUP),
11007 	SND_PCI_QUIRK(0x1d05, 0x1147, "TongFang GMxTGxx", ALC269_FIXUP_NO_SHUTUP),
11008 	SND_PCI_QUIRK(0x1d05, 0x115c, "TongFang GMxTGxx", ALC269_FIXUP_NO_SHUTUP),
11009 	SND_PCI_QUIRK(0x1d05, 0x121b, "TongFang GMxAGxx", ALC269_FIXUP_NO_SHUTUP),
11010 	SND_PCI_QUIRK(0x1d05, 0x1387, "TongFang GMxIXxx", ALC2XX_FIXUP_HEADSET_MIC),
11011 	SND_PCI_QUIRK(0x1d05, 0x1409, "TongFang GMxIXxx", ALC2XX_FIXUP_HEADSET_MIC),
11012 	SND_PCI_QUIRK(0x1d17, 0x3288, "Haier Boyue G42", ALC269VC_FIXUP_ACER_VCOPPERBOX_PINS),
11013 	SND_PCI_QUIRK(0x1d72, 0x1602, "RedmiBook", ALC255_FIXUP_XIAOMI_HEADSET_MIC),
11014 	SND_PCI_QUIRK(0x1d72, 0x1701, "XiaomiNotebook Pro", ALC298_FIXUP_DELL1_MIC_NO_PRESENCE),
11015 	SND_PCI_QUIRK(0x1d72, 0x1901, "RedmiBook 14", ALC256_FIXUP_ASUS_HEADSET_MIC),
11016 	SND_PCI_QUIRK(0x1d72, 0x1945, "Redmi G", ALC256_FIXUP_ASUS_HEADSET_MIC),
11017 	SND_PCI_QUIRK(0x1d72, 0x1947, "RedmiBook Air", ALC255_FIXUP_XIAOMI_HEADSET_MIC),
11018 	SND_PCI_QUIRK(0x2782, 0x0214, "VAIO VJFE-CL", ALC269_FIXUP_LIMIT_INT_MIC_BOOST),
11019 	SND_PCI_QUIRK(0x2782, 0x0228, "Infinix ZERO BOOK 13", ALC269VB_FIXUP_INFINIX_ZERO_BOOK_13),
11020 	SND_PCI_QUIRK(0x2782, 0x0232, "CHUWI CoreBook XPro", ALC269VB_FIXUP_CHUWI_COREBOOK_XPRO),
11021 	SND_PCI_QUIRK(0x2782, 0x1707, "Vaio VJFE-ADL", ALC298_FIXUP_SPK_VOLUME),
11022 	SND_PCI_QUIRK(0x8086, 0x2074, "Intel NUC 8", ALC233_FIXUP_INTEL_NUC8_DMIC),
11023 	SND_PCI_QUIRK(0x8086, 0x2080, "Intel NUC 8 Rugged", ALC256_FIXUP_INTEL_NUC8_RUGGED),
11024 	SND_PCI_QUIRK(0x8086, 0x2081, "Intel NUC 10", ALC256_FIXUP_INTEL_NUC10),
11025 	SND_PCI_QUIRK(0x8086, 0x3038, "Intel NUC 13", ALC295_FIXUP_CHROME_BOOK),
11026 	SND_PCI_QUIRK(0xf111, 0x0001, "Framework Laptop", ALC295_FIXUP_FRAMEWORK_LAPTOP_MIC_NO_PRESENCE),
11027 	SND_PCI_QUIRK(0xf111, 0x0006, "Framework Laptop", ALC295_FIXUP_FRAMEWORK_LAPTOP_MIC_NO_PRESENCE),
11028 	SND_PCI_QUIRK(0xf111, 0x0009, "Framework Laptop", ALC295_FIXUP_FRAMEWORK_LAPTOP_MIC_NO_PRESENCE),
11029 
11030 #if 0
11031 	/* Below is a quirk table taken from the old code.
11032 	 * Basically the device should work as is without the fixup table.
11033 	 * If BIOS doesn't give a proper info, enable the corresponding
11034 	 * fixup entry.
11035 	 */
11036 	SND_PCI_QUIRK(0x1043, 0x8330, "ASUS Eeepc P703 P900A",
11037 		      ALC269_FIXUP_AMIC),
11038 	SND_PCI_QUIRK(0x1043, 0x1013, "ASUS N61Da", ALC269_FIXUP_AMIC),
11039 	SND_PCI_QUIRK(0x1043, 0x1143, "ASUS B53f", ALC269_FIXUP_AMIC),
11040 	SND_PCI_QUIRK(0x1043, 0x1133, "ASUS UJ20ft", ALC269_FIXUP_AMIC),
11041 	SND_PCI_QUIRK(0x1043, 0x1183, "ASUS K72DR", ALC269_FIXUP_AMIC),
11042 	SND_PCI_QUIRK(0x1043, 0x11b3, "ASUS K52DR", ALC269_FIXUP_AMIC),
11043 	SND_PCI_QUIRK(0x1043, 0x11e3, "ASUS U33Jc", ALC269_FIXUP_AMIC),
11044 	SND_PCI_QUIRK(0x1043, 0x1273, "ASUS UL80Jt", ALC269_FIXUP_AMIC),
11045 	SND_PCI_QUIRK(0x1043, 0x1283, "ASUS U53Jc", ALC269_FIXUP_AMIC),
11046 	SND_PCI_QUIRK(0x1043, 0x12b3, "ASUS N82JV", ALC269_FIXUP_AMIC),
11047 	SND_PCI_QUIRK(0x1043, 0x12d3, "ASUS N61Jv", ALC269_FIXUP_AMIC),
11048 	SND_PCI_QUIRK(0x1043, 0x13a3, "ASUS UL30Vt", ALC269_FIXUP_AMIC),
11049 	SND_PCI_QUIRK(0x1043, 0x1373, "ASUS G73JX", ALC269_FIXUP_AMIC),
11050 	SND_PCI_QUIRK(0x1043, 0x1383, "ASUS UJ30Jc", ALC269_FIXUP_AMIC),
11051 	SND_PCI_QUIRK(0x1043, 0x13d3, "ASUS N61JA", ALC269_FIXUP_AMIC),
11052 	SND_PCI_QUIRK(0x1043, 0x1413, "ASUS UL50", ALC269_FIXUP_AMIC),
11053 	SND_PCI_QUIRK(0x1043, 0x1443, "ASUS UL30", ALC269_FIXUP_AMIC),
11054 	SND_PCI_QUIRK(0x1043, 0x1453, "ASUS M60Jv", ALC269_FIXUP_AMIC),
11055 	SND_PCI_QUIRK(0x1043, 0x1483, "ASUS UL80", ALC269_FIXUP_AMIC),
11056 	SND_PCI_QUIRK(0x1043, 0x14f3, "ASUS F83Vf", ALC269_FIXUP_AMIC),
11057 	SND_PCI_QUIRK(0x1043, 0x14e3, "ASUS UL20", ALC269_FIXUP_AMIC),
11058 	SND_PCI_QUIRK(0x1043, 0x1513, "ASUS UX30", ALC269_FIXUP_AMIC),
11059 	SND_PCI_QUIRK(0x1043, 0x1593, "ASUS N51Vn", ALC269_FIXUP_AMIC),
11060 	SND_PCI_QUIRK(0x1043, 0x15a3, "ASUS N60Jv", ALC269_FIXUP_AMIC),
11061 	SND_PCI_QUIRK(0x1043, 0x15b3, "ASUS N60Dp", ALC269_FIXUP_AMIC),
11062 	SND_PCI_QUIRK(0x1043, 0x15c3, "ASUS N70De", ALC269_FIXUP_AMIC),
11063 	SND_PCI_QUIRK(0x1043, 0x15e3, "ASUS F83T", ALC269_FIXUP_AMIC),
11064 	SND_PCI_QUIRK(0x1043, 0x1643, "ASUS M60J", ALC269_FIXUP_AMIC),
11065 	SND_PCI_QUIRK(0x1043, 0x1653, "ASUS U50", ALC269_FIXUP_AMIC),
11066 	SND_PCI_QUIRK(0x1043, 0x1693, "ASUS F50N", ALC269_FIXUP_AMIC),
11067 	SND_PCI_QUIRK(0x1043, 0x16a3, "ASUS F5Q", ALC269_FIXUP_AMIC),
11068 	SND_PCI_QUIRK(0x1043, 0x1723, "ASUS P80", ALC269_FIXUP_AMIC),
11069 	SND_PCI_QUIRK(0x1043, 0x1743, "ASUS U80", ALC269_FIXUP_AMIC),
11070 	SND_PCI_QUIRK(0x1043, 0x1773, "ASUS U20A", ALC269_FIXUP_AMIC),
11071 	SND_PCI_QUIRK(0x1043, 0x1883, "ASUS F81Se", ALC269_FIXUP_AMIC),
11072 	SND_PCI_QUIRK(0x152d, 0x1778, "Quanta ON1", ALC269_FIXUP_DMIC),
11073 	SND_PCI_QUIRK(0x17aa, 0x3be9, "Quanta Wistron", ALC269_FIXUP_AMIC),
11074 	SND_PCI_QUIRK(0x17aa, 0x3bf8, "Quanta FL1", ALC269_FIXUP_AMIC),
11075 	SND_PCI_QUIRK(0x17ff, 0x059a, "Quanta EL3", ALC269_FIXUP_DMIC),
11076 	SND_PCI_QUIRK(0x17ff, 0x059b, "Quanta JR1", ALC269_FIXUP_DMIC),
11077 #endif
11078 	{}
11079 };
11080 
11081 static const struct snd_pci_quirk alc269_fixup_vendor_tbl[] = {
11082 	SND_PCI_QUIRK_VENDOR(0x1025, "Acer Aspire", ALC271_FIXUP_DMIC),
11083 	SND_PCI_QUIRK_VENDOR(0x103c, "HP", ALC269_FIXUP_HP_MUTE_LED),
11084 	SND_PCI_QUIRK_VENDOR(0x104d, "Sony VAIO", ALC269_FIXUP_SONY_VAIO),
11085 	SND_PCI_QUIRK_VENDOR(0x17aa, "Thinkpad", ALC269_FIXUP_THINKPAD_ACPI),
11086 	SND_PCI_QUIRK_VENDOR(0x19e5, "Huawei Matebook", ALC255_FIXUP_MIC_MUTE_LED),
11087 	{}
11088 };
11089 
11090 static const struct hda_model_fixup alc269_fixup_models[] = {
11091 	{.id = ALC269_FIXUP_AMIC, .name = "laptop-amic"},
11092 	{.id = ALC269_FIXUP_DMIC, .name = "laptop-dmic"},
11093 	{.id = ALC269_FIXUP_STEREO_DMIC, .name = "alc269-dmic"},
11094 	{.id = ALC271_FIXUP_DMIC, .name = "alc271-dmic"},
11095 	{.id = ALC269_FIXUP_INV_DMIC, .name = "inv-dmic"},
11096 	{.id = ALC269_FIXUP_HEADSET_MIC, .name = "headset-mic"},
11097 	{.id = ALC269_FIXUP_HEADSET_MODE, .name = "headset-mode"},
11098 	{.id = ALC269_FIXUP_HEADSET_MODE_NO_HP_MIC, .name = "headset-mode-no-hp-mic"},
11099 	{.id = ALC269_FIXUP_LENOVO_DOCK, .name = "lenovo-dock"},
11100 	{.id = ALC269_FIXUP_LENOVO_DOCK_LIMIT_BOOST, .name = "lenovo-dock-limit-boost"},
11101 	{.id = ALC269_FIXUP_HP_GPIO_LED, .name = "hp-gpio-led"},
11102 	{.id = ALC269_FIXUP_HP_DOCK_GPIO_MIC1_LED, .name = "hp-dock-gpio-mic1-led"},
11103 	{.id = ALC269_FIXUP_DELL1_MIC_NO_PRESENCE, .name = "dell-headset-multi"},
11104 	{.id = ALC269_FIXUP_DELL2_MIC_NO_PRESENCE, .name = "dell-headset-dock"},
11105 	{.id = ALC269_FIXUP_DELL3_MIC_NO_PRESENCE, .name = "dell-headset3"},
11106 	{.id = ALC269_FIXUP_DELL4_MIC_NO_PRESENCE, .name = "dell-headset4"},
11107 	{.id = ALC269_FIXUP_DELL4_MIC_NO_PRESENCE_QUIET, .name = "dell-headset4-quiet"},
11108 	{.id = ALC283_FIXUP_CHROME_BOOK, .name = "alc283-dac-wcaps"},
11109 	{.id = ALC283_FIXUP_SENSE_COMBO_JACK, .name = "alc283-sense-combo"},
11110 	{.id = ALC292_FIXUP_TPT440_DOCK, .name = "tpt440-dock"},
11111 	{.id = ALC292_FIXUP_TPT440, .name = "tpt440"},
11112 	{.id = ALC292_FIXUP_TPT460, .name = "tpt460"},
11113 	{.id = ALC298_FIXUP_TPT470_DOCK_FIX, .name = "tpt470-dock-fix"},
11114 	{.id = ALC298_FIXUP_TPT470_DOCK, .name = "tpt470-dock"},
11115 	{.id = ALC233_FIXUP_LENOVO_MULTI_CODECS, .name = "dual-codecs"},
11116 	{.id = ALC700_FIXUP_INTEL_REFERENCE, .name = "alc700-ref"},
11117 	{.id = ALC269_FIXUP_SONY_VAIO, .name = "vaio"},
11118 	{.id = ALC269_FIXUP_DELL_M101Z, .name = "dell-m101z"},
11119 	{.id = ALC269_FIXUP_ASUS_G73JW, .name = "asus-g73jw"},
11120 	{.id = ALC269_FIXUP_LENOVO_EAPD, .name = "lenovo-eapd"},
11121 	{.id = ALC275_FIXUP_SONY_HWEQ, .name = "sony-hweq"},
11122 	{.id = ALC269_FIXUP_PCM_44K, .name = "pcm44k"},
11123 	{.id = ALC269_FIXUP_LIFEBOOK, .name = "lifebook"},
11124 	{.id = ALC269_FIXUP_LIFEBOOK_EXTMIC, .name = "lifebook-extmic"},
11125 	{.id = ALC269_FIXUP_LIFEBOOK_HP_PIN, .name = "lifebook-hp-pin"},
11126 	{.id = ALC255_FIXUP_LIFEBOOK_U7x7_HEADSET_MIC, .name = "lifebook-u7x7"},
11127 	{.id = ALC269VB_FIXUP_AMIC, .name = "alc269vb-amic"},
11128 	{.id = ALC269VB_FIXUP_DMIC, .name = "alc269vb-dmic"},
11129 	{.id = ALC269_FIXUP_HP_MUTE_LED_MIC1, .name = "hp-mute-led-mic1"},
11130 	{.id = ALC269_FIXUP_HP_MUTE_LED_MIC2, .name = "hp-mute-led-mic2"},
11131 	{.id = ALC269_FIXUP_HP_MUTE_LED_MIC3, .name = "hp-mute-led-mic3"},
11132 	{.id = ALC269_FIXUP_HP_GPIO_MIC1_LED, .name = "hp-gpio-mic1"},
11133 	{.id = ALC269_FIXUP_HP_LINE1_MIC1_LED, .name = "hp-line1-mic1"},
11134 	{.id = ALC269_FIXUP_NO_SHUTUP, .name = "noshutup"},
11135 	{.id = ALC286_FIXUP_SONY_MIC_NO_PRESENCE, .name = "sony-nomic"},
11136 	{.id = ALC269_FIXUP_ASPIRE_HEADSET_MIC, .name = "aspire-headset-mic"},
11137 	{.id = ALC269_FIXUP_ASUS_X101, .name = "asus-x101"},
11138 	{.id = ALC271_FIXUP_HP_GATE_MIC_JACK, .name = "acer-ao7xx"},
11139 	{.id = ALC271_FIXUP_HP_GATE_MIC_JACK_E1_572, .name = "acer-aspire-e1"},
11140 	{.id = ALC269_FIXUP_ACER_AC700, .name = "acer-ac700"},
11141 	{.id = ALC269_FIXUP_LIMIT_INT_MIC_BOOST, .name = "limit-mic-boost"},
11142 	{.id = ALC269VB_FIXUP_ASUS_ZENBOOK, .name = "asus-zenbook"},
11143 	{.id = ALC269VB_FIXUP_ASUS_ZENBOOK_UX31A, .name = "asus-zenbook-ux31a"},
11144 	{.id = ALC269VB_FIXUP_ORDISSIMO_EVE2, .name = "ordissimo"},
11145 	{.id = ALC282_FIXUP_ASUS_TX300, .name = "asus-tx300"},
11146 	{.id = ALC283_FIXUP_INT_MIC, .name = "alc283-int-mic"},
11147 	{.id = ALC290_FIXUP_MONO_SPEAKERS_HSJACK, .name = "mono-speakers"},
11148 	{.id = ALC290_FIXUP_SUBWOOFER_HSJACK, .name = "alc290-subwoofer"},
11149 	{.id = ALC269_FIXUP_THINKPAD_ACPI, .name = "thinkpad"},
11150 	{.id = ALC269_FIXUP_DMIC_THINKPAD_ACPI, .name = "dmic-thinkpad"},
11151 	{.id = ALC255_FIXUP_ACER_MIC_NO_PRESENCE, .name = "alc255-acer"},
11152 	{.id = ALC255_FIXUP_ASUS_MIC_NO_PRESENCE, .name = "alc255-asus"},
11153 	{.id = ALC255_FIXUP_DELL1_MIC_NO_PRESENCE, .name = "alc255-dell1"},
11154 	{.id = ALC255_FIXUP_DELL2_MIC_NO_PRESENCE, .name = "alc255-dell2"},
11155 	{.id = ALC293_FIXUP_DELL1_MIC_NO_PRESENCE, .name = "alc293-dell1"},
11156 	{.id = ALC283_FIXUP_HEADSET_MIC, .name = "alc283-headset"},
11157 	{.id = ALC255_FIXUP_MIC_MUTE_LED, .name = "alc255-dell-mute"},
11158 	{.id = ALC282_FIXUP_ASPIRE_V5_PINS, .name = "aspire-v5"},
11159 	{.id = ALC269VB_FIXUP_ASPIRE_E1_COEF, .name = "aspire-e1-coef"},
11160 	{.id = ALC280_FIXUP_HP_GPIO4, .name = "hp-gpio4"},
11161 	{.id = ALC286_FIXUP_HP_GPIO_LED, .name = "hp-gpio-led"},
11162 	{.id = ALC280_FIXUP_HP_GPIO2_MIC_HOTKEY, .name = "hp-gpio2-hotkey"},
11163 	{.id = ALC280_FIXUP_HP_DOCK_PINS, .name = "hp-dock-pins"},
11164 	{.id = ALC269_FIXUP_HP_DOCK_GPIO_MIC1_LED, .name = "hp-dock-gpio-mic"},
11165 	{.id = ALC280_FIXUP_HP_9480M, .name = "hp-9480m"},
11166 	{.id = ALC288_FIXUP_DELL_HEADSET_MODE, .name = "alc288-dell-headset"},
11167 	{.id = ALC288_FIXUP_DELL1_MIC_NO_PRESENCE, .name = "alc288-dell1"},
11168 	{.id = ALC288_FIXUP_DELL_XPS_13, .name = "alc288-dell-xps13"},
11169 	{.id = ALC292_FIXUP_DELL_E7X, .name = "dell-e7x"},
11170 	{.id = ALC293_FIXUP_DISABLE_AAMIX_MULTIJACK, .name = "alc293-dell"},
11171 	{.id = ALC298_FIXUP_DELL1_MIC_NO_PRESENCE, .name = "alc298-dell1"},
11172 	{.id = ALC298_FIXUP_DELL_AIO_MIC_NO_PRESENCE, .name = "alc298-dell-aio"},
11173 	{.id = ALC275_FIXUP_DELL_XPS, .name = "alc275-dell-xps"},
11174 	{.id = ALC293_FIXUP_LENOVO_SPK_NOISE, .name = "lenovo-spk-noise"},
11175 	{.id = ALC233_FIXUP_LENOVO_LINE2_MIC_HOTKEY, .name = "lenovo-hotkey"},
11176 	{.id = ALC255_FIXUP_DELL_SPK_NOISE, .name = "dell-spk-noise"},
11177 	{.id = ALC225_FIXUP_DELL1_MIC_NO_PRESENCE, .name = "alc225-dell1"},
11178 	{.id = ALC295_FIXUP_DISABLE_DAC3, .name = "alc295-disable-dac3"},
11179 	{.id = ALC285_FIXUP_SPEAKER2_TO_DAC1, .name = "alc285-speaker2-to-dac1"},
11180 	{.id = ALC280_FIXUP_HP_HEADSET_MIC, .name = "alc280-hp-headset"},
11181 	{.id = ALC221_FIXUP_HP_FRONT_MIC, .name = "alc221-hp-mic"},
11182 	{.id = ALC298_FIXUP_SPK_VOLUME, .name = "alc298-spk-volume"},
11183 	{.id = ALC256_FIXUP_DELL_INSPIRON_7559_SUBWOOFER, .name = "dell-inspiron-7559"},
11184 	{.id = ALC269_FIXUP_ATIV_BOOK_8, .name = "ativ-book"},
11185 	{.id = ALC221_FIXUP_HP_MIC_NO_PRESENCE, .name = "alc221-hp-mic"},
11186 	{.id = ALC256_FIXUP_ASUS_HEADSET_MODE, .name = "alc256-asus-headset"},
11187 	{.id = ALC256_FIXUP_ASUS_MIC, .name = "alc256-asus-mic"},
11188 	{.id = ALC256_FIXUP_ASUS_AIO_GPIO2, .name = "alc256-asus-aio"},
11189 	{.id = ALC233_FIXUP_ASUS_MIC_NO_PRESENCE, .name = "alc233-asus"},
11190 	{.id = ALC233_FIXUP_EAPD_COEF_AND_MIC_NO_PRESENCE, .name = "alc233-eapd"},
11191 	{.id = ALC294_FIXUP_LENOVO_MIC_LOCATION, .name = "alc294-lenovo-mic"},
11192 	{.id = ALC225_FIXUP_DELL_WYSE_MIC_NO_PRESENCE, .name = "alc225-wyse"},
11193 	{.id = ALC274_FIXUP_DELL_AIO_LINEOUT_VERB, .name = "alc274-dell-aio"},
11194 	{.id = ALC255_FIXUP_DUMMY_LINEOUT_VERB, .name = "alc255-dummy-lineout"},
11195 	{.id = ALC255_FIXUP_DELL_HEADSET_MIC, .name = "alc255-dell-headset"},
11196 	{.id = ALC295_FIXUP_HP_X360, .name = "alc295-hp-x360"},
11197 	{.id = ALC225_FIXUP_HEADSET_JACK, .name = "alc-headset-jack"},
11198 	{.id = ALC295_FIXUP_CHROME_BOOK, .name = "alc-chrome-book"},
11199 	{.id = ALC256_FIXUP_CHROME_BOOK, .name = "alc-2024y-chromebook"},
11200 	{.id = ALC299_FIXUP_PREDATOR_SPK, .name = "predator-spk"},
11201 	{.id = ALC298_FIXUP_HUAWEI_MBX_STEREO, .name = "huawei-mbx-stereo"},
11202 	{.id = ALC256_FIXUP_MEDION_HEADSET_NO_PRESENCE, .name = "alc256-medion-headset"},
11203 	{.id = ALC298_FIXUP_SAMSUNG_AMP, .name = "alc298-samsung-amp"},
11204 	{.id = ALC298_FIXUP_SAMSUNG_AMP_V2_2_AMPS, .name = "alc298-samsung-amp-v2-2-amps"},
11205 	{.id = ALC298_FIXUP_SAMSUNG_AMP_V2_4_AMPS, .name = "alc298-samsung-amp-v2-4-amps"},
11206 	{.id = ALC256_FIXUP_SAMSUNG_HEADPHONE_VERY_QUIET, .name = "alc256-samsung-headphone"},
11207 	{.id = ALC255_FIXUP_XIAOMI_HEADSET_MIC, .name = "alc255-xiaomi-headset"},
11208 	{.id = ALC274_FIXUP_HP_MIC, .name = "alc274-hp-mic-detect"},
11209 	{.id = ALC245_FIXUP_HP_X360_AMP, .name = "alc245-hp-x360-amp"},
11210 	{.id = ALC295_FIXUP_HP_OMEN, .name = "alc295-hp-omen"},
11211 	{.id = ALC285_FIXUP_HP_SPECTRE_X360, .name = "alc285-hp-spectre-x360"},
11212 	{.id = ALC285_FIXUP_HP_SPECTRE_X360_EB1, .name = "alc285-hp-spectre-x360-eb1"},
11213 	{.id = ALC285_FIXUP_HP_ENVY_X360, .name = "alc285-hp-envy-x360"},
11214 	{.id = ALC287_FIXUP_IDEAPAD_BASS_SPK_AMP, .name = "alc287-ideapad-bass-spk-amp"},
11215 	{.id = ALC287_FIXUP_YOGA9_14IAP7_BASS_SPK_PIN, .name = "alc287-yoga9-bass-spk-pin"},
11216 	{.id = ALC623_FIXUP_LENOVO_THINKSTATION_P340, .name = "alc623-lenovo-thinkstation-p340"},
11217 	{.id = ALC255_FIXUP_ACER_HEADPHONE_AND_MIC, .name = "alc255-acer-headphone-and-mic"},
11218 	{.id = ALC285_FIXUP_HP_GPIO_AMP_INIT, .name = "alc285-hp-amp-init"},
11219 	{.id = ALC236_FIXUP_LENOVO_INV_DMIC, .name = "alc236-fixup-lenovo-inv-mic"},
11220 	{}
11221 };
11222 #define ALC225_STANDARD_PINS \
11223 	{0x21, 0x04211020}
11224 
11225 #define ALC256_STANDARD_PINS \
11226 	{0x12, 0x90a60140}, \
11227 	{0x14, 0x90170110}, \
11228 	{0x21, 0x02211020}
11229 
11230 #define ALC282_STANDARD_PINS \
11231 	{0x14, 0x90170110}
11232 
11233 #define ALC290_STANDARD_PINS \
11234 	{0x12, 0x99a30130}
11235 
11236 #define ALC292_STANDARD_PINS \
11237 	{0x14, 0x90170110}, \
11238 	{0x15, 0x0221401f}
11239 
11240 #define ALC295_STANDARD_PINS \
11241 	{0x12, 0xb7a60130}, \
11242 	{0x14, 0x90170110}, \
11243 	{0x21, 0x04211020}
11244 
11245 #define ALC298_STANDARD_PINS \
11246 	{0x12, 0x90a60130}, \
11247 	{0x21, 0x03211020}
11248 
11249 static const struct snd_hda_pin_quirk alc269_pin_fixup_tbl[] = {
11250 	SND_HDA_PIN_QUIRK(0x10ec0221, 0x103c, "HP Workstation", ALC221_FIXUP_HP_HEADSET_MIC,
11251 		{0x14, 0x01014020},
11252 		{0x17, 0x90170110},
11253 		{0x18, 0x02a11030},
11254 		{0x19, 0x0181303F},
11255 		{0x21, 0x0221102f}),
11256 	SND_HDA_PIN_QUIRK(0x10ec0255, 0x1025, "Acer", ALC255_FIXUP_ACER_MIC_NO_PRESENCE,
11257 		{0x12, 0x90a601c0},
11258 		{0x14, 0x90171120},
11259 		{0x21, 0x02211030}),
11260 	SND_HDA_PIN_QUIRK(0x10ec0255, 0x1043, "ASUS", ALC255_FIXUP_ASUS_MIC_NO_PRESENCE,
11261 		{0x14, 0x90170110},
11262 		{0x1b, 0x90a70130},
11263 		{0x21, 0x03211020}),
11264 	SND_HDA_PIN_QUIRK(0x10ec0255, 0x1043, "ASUS", ALC255_FIXUP_ASUS_MIC_NO_PRESENCE,
11265 		{0x1a, 0x90a70130},
11266 		{0x1b, 0x90170110},
11267 		{0x21, 0x03211020}),
11268 	SND_HDA_PIN_QUIRK(0x10ec0225, 0x1028, "Dell", ALC225_FIXUP_DELL1_MIC_NO_PRESENCE,
11269 		ALC225_STANDARD_PINS,
11270 		{0x12, 0xb7a60130},
11271 		{0x14, 0x901701a0}),
11272 	SND_HDA_PIN_QUIRK(0x10ec0225, 0x1028, "Dell", ALC225_FIXUP_DELL1_MIC_NO_PRESENCE,
11273 		ALC225_STANDARD_PINS,
11274 		{0x12, 0xb7a60130},
11275 		{0x14, 0x901701b0}),
11276 	SND_HDA_PIN_QUIRK(0x10ec0225, 0x1028, "Dell", ALC225_FIXUP_DELL1_MIC_NO_PRESENCE,
11277 		ALC225_STANDARD_PINS,
11278 		{0x12, 0xb7a60150},
11279 		{0x14, 0x901701a0}),
11280 	SND_HDA_PIN_QUIRK(0x10ec0225, 0x1028, "Dell", ALC225_FIXUP_DELL1_MIC_NO_PRESENCE,
11281 		ALC225_STANDARD_PINS,
11282 		{0x12, 0xb7a60150},
11283 		{0x14, 0x901701b0}),
11284 	SND_HDA_PIN_QUIRK(0x10ec0225, 0x1028, "Dell", ALC225_FIXUP_DELL1_MIC_NO_PRESENCE,
11285 		ALC225_STANDARD_PINS,
11286 		{0x12, 0xb7a60130},
11287 		{0x1b, 0x90170110}),
11288 	SND_HDA_PIN_QUIRK(0x10ec0233, 0x8086, "Intel NUC Skull Canyon", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE,
11289 		{0x1b, 0x01111010},
11290 		{0x1e, 0x01451130},
11291 		{0x21, 0x02211020}),
11292 	SND_HDA_PIN_QUIRK(0x10ec0235, 0x17aa, "Lenovo", ALC233_FIXUP_LENOVO_LINE2_MIC_HOTKEY,
11293 		{0x12, 0x90a60140},
11294 		{0x14, 0x90170110},
11295 		{0x19, 0x02a11030},
11296 		{0x21, 0x02211020}),
11297 	SND_HDA_PIN_QUIRK(0x10ec0235, 0x17aa, "Lenovo", ALC294_FIXUP_LENOVO_MIC_LOCATION,
11298 		{0x14, 0x90170110},
11299 		{0x19, 0x02a11030},
11300 		{0x1a, 0x02a11040},
11301 		{0x1b, 0x01014020},
11302 		{0x21, 0x0221101f}),
11303 	SND_HDA_PIN_QUIRK(0x10ec0235, 0x17aa, "Lenovo", ALC294_FIXUP_LENOVO_MIC_LOCATION,
11304 		{0x14, 0x90170110},
11305 		{0x19, 0x02a11030},
11306 		{0x1a, 0x02a11040},
11307 		{0x1b, 0x01011020},
11308 		{0x21, 0x0221101f}),
11309 	SND_HDA_PIN_QUIRK(0x10ec0235, 0x17aa, "Lenovo", ALC294_FIXUP_LENOVO_MIC_LOCATION,
11310 		{0x14, 0x90170110},
11311 		{0x19, 0x02a11020},
11312 		{0x1a, 0x02a11030},
11313 		{0x21, 0x0221101f}),
11314 	SND_HDA_PIN_QUIRK(0x10ec0236, 0x1028, "Dell", ALC236_FIXUP_DELL_AIO_HEADSET_MIC,
11315 		{0x21, 0x02211010}),
11316 	SND_HDA_PIN_QUIRK(0x10ec0236, 0x103c, "HP", ALC256_FIXUP_HP_HEADSET_MIC,
11317 		{0x14, 0x90170110},
11318 		{0x19, 0x02a11020},
11319 		{0x21, 0x02211030}),
11320 	SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL2_MIC_NO_PRESENCE,
11321 		{0x14, 0x90170110},
11322 		{0x21, 0x02211020}),
11323 	SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
11324 		{0x14, 0x90170130},
11325 		{0x21, 0x02211040}),
11326 	SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
11327 		{0x12, 0x90a60140},
11328 		{0x14, 0x90170110},
11329 		{0x21, 0x02211020}),
11330 	SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
11331 		{0x12, 0x90a60160},
11332 		{0x14, 0x90170120},
11333 		{0x21, 0x02211030}),
11334 	SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
11335 		{0x14, 0x90170110},
11336 		{0x1b, 0x02011020},
11337 		{0x21, 0x0221101f}),
11338 	SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
11339 		{0x14, 0x90170110},
11340 		{0x1b, 0x01011020},
11341 		{0x21, 0x0221101f}),
11342 	SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
11343 		{0x14, 0x90170130},
11344 		{0x1b, 0x01014020},
11345 		{0x21, 0x0221103f}),
11346 	SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
11347 		{0x14, 0x90170130},
11348 		{0x1b, 0x01011020},
11349 		{0x21, 0x0221103f}),
11350 	SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
11351 		{0x14, 0x90170130},
11352 		{0x1b, 0x02011020},
11353 		{0x21, 0x0221103f}),
11354 	SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
11355 		{0x14, 0x90170150},
11356 		{0x1b, 0x02011020},
11357 		{0x21, 0x0221105f}),
11358 	SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
11359 		{0x14, 0x90170110},
11360 		{0x1b, 0x01014020},
11361 		{0x21, 0x0221101f}),
11362 	SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
11363 		{0x12, 0x90a60160},
11364 		{0x14, 0x90170120},
11365 		{0x17, 0x90170140},
11366 		{0x21, 0x0321102f}),
11367 	SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
11368 		{0x12, 0x90a60160},
11369 		{0x14, 0x90170130},
11370 		{0x21, 0x02211040}),
11371 	SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
11372 		{0x12, 0x90a60160},
11373 		{0x14, 0x90170140},
11374 		{0x21, 0x02211050}),
11375 	SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
11376 		{0x12, 0x90a60170},
11377 		{0x14, 0x90170120},
11378 		{0x21, 0x02211030}),
11379 	SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
11380 		{0x12, 0x90a60170},
11381 		{0x14, 0x90170130},
11382 		{0x21, 0x02211040}),
11383 	SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
11384 		{0x12, 0x90a60170},
11385 		{0x14, 0x90171130},
11386 		{0x21, 0x02211040}),
11387 	SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
11388 		{0x12, 0x90a60170},
11389 		{0x14, 0x90170140},
11390 		{0x21, 0x02211050}),
11391 	SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell Inspiron 5548", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
11392 		{0x12, 0x90a60180},
11393 		{0x14, 0x90170130},
11394 		{0x21, 0x02211040}),
11395 	SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell Inspiron 5565", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
11396 		{0x12, 0x90a60180},
11397 		{0x14, 0x90170120},
11398 		{0x21, 0x02211030}),
11399 	SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
11400 		{0x1b, 0x01011020},
11401 		{0x21, 0x02211010}),
11402 	SND_HDA_PIN_QUIRK(0x10ec0256, 0x1043, "ASUS", ALC256_FIXUP_ASUS_MIC,
11403 		{0x14, 0x90170110},
11404 		{0x1b, 0x90a70130},
11405 		{0x21, 0x04211020}),
11406 	SND_HDA_PIN_QUIRK(0x10ec0256, 0x1043, "ASUS", ALC256_FIXUP_ASUS_MIC,
11407 		{0x14, 0x90170110},
11408 		{0x1b, 0x90a70130},
11409 		{0x21, 0x03211020}),
11410 	SND_HDA_PIN_QUIRK(0x10ec0256, 0x1043, "ASUS", ALC256_FIXUP_ASUS_MIC_NO_PRESENCE,
11411 		{0x12, 0x90a60130},
11412 		{0x14, 0x90170110},
11413 		{0x21, 0x03211020}),
11414 	SND_HDA_PIN_QUIRK(0x10ec0256, 0x1043, "ASUS", ALC256_FIXUP_ASUS_MIC_NO_PRESENCE,
11415 		{0x12, 0x90a60130},
11416 		{0x14, 0x90170110},
11417 		{0x21, 0x04211020}),
11418 	SND_HDA_PIN_QUIRK(0x10ec0256, 0x1043, "ASUS", ALC256_FIXUP_ASUS_MIC_NO_PRESENCE,
11419 		{0x1a, 0x90a70130},
11420 		{0x1b, 0x90170110},
11421 		{0x21, 0x03211020}),
11422        SND_HDA_PIN_QUIRK(0x10ec0256, 0x103c, "HP", ALC256_FIXUP_HP_HEADSET_MIC,
11423 		{0x14, 0x90170110},
11424 		{0x19, 0x02a11020},
11425 		{0x21, 0x0221101f}),
11426        SND_HDA_PIN_QUIRK(0x10ec0274, 0x103c, "HP", ALC274_FIXUP_HP_HEADSET_MIC,
11427 		{0x17, 0x90170110},
11428 		{0x19, 0x03a11030},
11429 		{0x21, 0x03211020}),
11430 	SND_HDA_PIN_QUIRK(0x10ec0280, 0x103c, "HP", ALC280_FIXUP_HP_GPIO4,
11431 		{0x12, 0x90a60130},
11432 		{0x14, 0x90170110},
11433 		{0x15, 0x0421101f},
11434 		{0x1a, 0x04a11020}),
11435 	SND_HDA_PIN_QUIRK(0x10ec0280, 0x103c, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED,
11436 		{0x12, 0x90a60140},
11437 		{0x14, 0x90170110},
11438 		{0x15, 0x0421101f},
11439 		{0x18, 0x02811030},
11440 		{0x1a, 0x04a1103f},
11441 		{0x1b, 0x02011020}),
11442 	SND_HDA_PIN_QUIRK(0x10ec0282, 0x103c, "HP 15 Touchsmart", ALC269_FIXUP_HP_MUTE_LED_MIC1,
11443 		ALC282_STANDARD_PINS,
11444 		{0x12, 0x99a30130},
11445 		{0x19, 0x03a11020},
11446 		{0x21, 0x0321101f}),
11447 	SND_HDA_PIN_QUIRK(0x10ec0282, 0x103c, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1,
11448 		ALC282_STANDARD_PINS,
11449 		{0x12, 0x99a30130},
11450 		{0x19, 0x03a11020},
11451 		{0x21, 0x03211040}),
11452 	SND_HDA_PIN_QUIRK(0x10ec0282, 0x103c, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1,
11453 		ALC282_STANDARD_PINS,
11454 		{0x12, 0x99a30130},
11455 		{0x19, 0x03a11030},
11456 		{0x21, 0x03211020}),
11457 	SND_HDA_PIN_QUIRK(0x10ec0282, 0x103c, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1,
11458 		ALC282_STANDARD_PINS,
11459 		{0x12, 0x99a30130},
11460 		{0x19, 0x04a11020},
11461 		{0x21, 0x0421101f}),
11462 	SND_HDA_PIN_QUIRK(0x10ec0282, 0x103c, "HP", ALC269_FIXUP_HP_LINE1_MIC1_LED,
11463 		ALC282_STANDARD_PINS,
11464 		{0x12, 0x90a60140},
11465 		{0x19, 0x04a11030},
11466 		{0x21, 0x04211020}),
11467 	SND_HDA_PIN_QUIRK(0x10ec0282, 0x1025, "Acer", ALC282_FIXUP_ACER_DISABLE_LINEOUT,
11468 		ALC282_STANDARD_PINS,
11469 		{0x12, 0x90a609c0},
11470 		{0x18, 0x03a11830},
11471 		{0x19, 0x04a19831},
11472 		{0x1a, 0x0481303f},
11473 		{0x1b, 0x04211020},
11474 		{0x21, 0x0321101f}),
11475 	SND_HDA_PIN_QUIRK(0x10ec0282, 0x1025, "Acer", ALC282_FIXUP_ACER_DISABLE_LINEOUT,
11476 		ALC282_STANDARD_PINS,
11477 		{0x12, 0x90a60940},
11478 		{0x18, 0x03a11830},
11479 		{0x19, 0x04a19831},
11480 		{0x1a, 0x0481303f},
11481 		{0x1b, 0x04211020},
11482 		{0x21, 0x0321101f}),
11483 	SND_HDA_PIN_QUIRK(0x10ec0283, 0x1028, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE,
11484 		ALC282_STANDARD_PINS,
11485 		{0x12, 0x90a60130},
11486 		{0x21, 0x0321101f}),
11487 	SND_HDA_PIN_QUIRK(0x10ec0283, 0x1028, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE,
11488 		{0x12, 0x90a60160},
11489 		{0x14, 0x90170120},
11490 		{0x21, 0x02211030}),
11491 	SND_HDA_PIN_QUIRK(0x10ec0283, 0x1028, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE,
11492 		ALC282_STANDARD_PINS,
11493 		{0x12, 0x90a60130},
11494 		{0x19, 0x03a11020},
11495 		{0x21, 0x0321101f}),
11496 	SND_HDA_PIN_QUIRK(0x10ec0285, 0x17aa, "Lenovo", ALC285_FIXUP_LENOVO_PC_BEEP_IN_NOISE,
11497 		{0x12, 0x90a60130},
11498 		{0x14, 0x90170110},
11499 		{0x19, 0x04a11040},
11500 		{0x21, 0x04211020}),
11501 	SND_HDA_PIN_QUIRK(0x10ec0285, 0x17aa, "Lenovo", ALC285_FIXUP_LENOVO_PC_BEEP_IN_NOISE,
11502 		{0x14, 0x90170110},
11503 		{0x19, 0x04a11040},
11504 		{0x1d, 0x40600001},
11505 		{0x21, 0x04211020}),
11506 	SND_HDA_PIN_QUIRK(0x10ec0285, 0x17aa, "Lenovo", ALC285_FIXUP_THINKPAD_NO_BASS_SPK_HEADSET_JACK,
11507 		{0x14, 0x90170110},
11508 		{0x19, 0x04a11040},
11509 		{0x21, 0x04211020}),
11510 	SND_HDA_PIN_QUIRK(0x10ec0287, 0x17aa, "Lenovo", ALC285_FIXUP_THINKPAD_HEADSET_JACK,
11511 		{0x14, 0x90170110},
11512 		{0x17, 0x90170111},
11513 		{0x19, 0x03a11030},
11514 		{0x21, 0x03211020}),
11515 	SND_HDA_PIN_QUIRK(0x10ec0287, 0x17aa, "Lenovo", ALC287_FIXUP_THINKPAD_I2S_SPK,
11516 		{0x17, 0x90170110},
11517 		{0x19, 0x03a11030},
11518 		{0x21, 0x03211020}),
11519 	SND_HDA_PIN_QUIRK(0x10ec0287, 0x17aa, "Lenovo", ALC287_FIXUP_THINKPAD_I2S_SPK,
11520 		{0x17, 0x90170110}, /* 0x231f with RTK I2S AMP */
11521 		{0x19, 0x04a11040},
11522 		{0x21, 0x04211020}),
11523 	SND_HDA_PIN_QUIRK(0x10ec0286, 0x1025, "Acer", ALC286_FIXUP_ACER_AIO_MIC_NO_PRESENCE,
11524 		{0x12, 0x90a60130},
11525 		{0x17, 0x90170110},
11526 		{0x21, 0x02211020}),
11527 	SND_HDA_PIN_QUIRK(0x10ec0288, 0x1028, "Dell", ALC288_FIXUP_DELL1_MIC_NO_PRESENCE,
11528 		{0x12, 0x90a60120},
11529 		{0x14, 0x90170110},
11530 		{0x21, 0x0321101f}),
11531 	SND_HDA_PIN_QUIRK(0x10ec0290, 0x103c, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1,
11532 		ALC290_STANDARD_PINS,
11533 		{0x15, 0x04211040},
11534 		{0x18, 0x90170112},
11535 		{0x1a, 0x04a11020}),
11536 	SND_HDA_PIN_QUIRK(0x10ec0290, 0x103c, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1,
11537 		ALC290_STANDARD_PINS,
11538 		{0x15, 0x04211040},
11539 		{0x18, 0x90170110},
11540 		{0x1a, 0x04a11020}),
11541 	SND_HDA_PIN_QUIRK(0x10ec0290, 0x103c, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1,
11542 		ALC290_STANDARD_PINS,
11543 		{0x15, 0x0421101f},
11544 		{0x1a, 0x04a11020}),
11545 	SND_HDA_PIN_QUIRK(0x10ec0290, 0x103c, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1,
11546 		ALC290_STANDARD_PINS,
11547 		{0x15, 0x04211020},
11548 		{0x1a, 0x04a11040}),
11549 	SND_HDA_PIN_QUIRK(0x10ec0290, 0x103c, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1,
11550 		ALC290_STANDARD_PINS,
11551 		{0x14, 0x90170110},
11552 		{0x15, 0x04211020},
11553 		{0x1a, 0x04a11040}),
11554 	SND_HDA_PIN_QUIRK(0x10ec0290, 0x103c, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1,
11555 		ALC290_STANDARD_PINS,
11556 		{0x14, 0x90170110},
11557 		{0x15, 0x04211020},
11558 		{0x1a, 0x04a11020}),
11559 	SND_HDA_PIN_QUIRK(0x10ec0290, 0x103c, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1,
11560 		ALC290_STANDARD_PINS,
11561 		{0x14, 0x90170110},
11562 		{0x15, 0x0421101f},
11563 		{0x1a, 0x04a11020}),
11564 	SND_HDA_PIN_QUIRK(0x10ec0292, 0x1028, "Dell", ALC269_FIXUP_DELL2_MIC_NO_PRESENCE,
11565 		ALC292_STANDARD_PINS,
11566 		{0x12, 0x90a60140},
11567 		{0x16, 0x01014020},
11568 		{0x19, 0x01a19030}),
11569 	SND_HDA_PIN_QUIRK(0x10ec0292, 0x1028, "Dell", ALC269_FIXUP_DELL2_MIC_NO_PRESENCE,
11570 		ALC292_STANDARD_PINS,
11571 		{0x12, 0x90a60140},
11572 		{0x16, 0x01014020},
11573 		{0x18, 0x02a19031},
11574 		{0x19, 0x01a1903e}),
11575 	SND_HDA_PIN_QUIRK(0x10ec0292, 0x1028, "Dell", ALC269_FIXUP_DELL3_MIC_NO_PRESENCE,
11576 		ALC292_STANDARD_PINS,
11577 		{0x12, 0x90a60140}),
11578 	SND_HDA_PIN_QUIRK(0x10ec0293, 0x1028, "Dell", ALC293_FIXUP_DELL1_MIC_NO_PRESENCE,
11579 		ALC292_STANDARD_PINS,
11580 		{0x13, 0x90a60140},
11581 		{0x16, 0x21014020},
11582 		{0x19, 0x21a19030}),
11583 	SND_HDA_PIN_QUIRK(0x10ec0293, 0x1028, "Dell", ALC293_FIXUP_DELL1_MIC_NO_PRESENCE,
11584 		ALC292_STANDARD_PINS,
11585 		{0x13, 0x90a60140}),
11586 	SND_HDA_PIN_QUIRK(0x10ec0294, 0x1043, "ASUS", ALC294_FIXUP_ASUS_HPE,
11587 		{0x17, 0x90170110},
11588 		{0x21, 0x04211020}),
11589 	SND_HDA_PIN_QUIRK(0x10ec0294, 0x1043, "ASUS", ALC294_FIXUP_ASUS_MIC,
11590 		{0x14, 0x90170110},
11591 		{0x1b, 0x90a70130},
11592 		{0x21, 0x04211020}),
11593 	SND_HDA_PIN_QUIRK(0x10ec0294, 0x1043, "ASUS", ALC294_FIXUP_ASUS_SPK,
11594 		{0x12, 0x90a60130},
11595 		{0x17, 0x90170110},
11596 		{0x21, 0x03211020}),
11597 	SND_HDA_PIN_QUIRK(0x10ec0294, 0x1043, "ASUS", ALC294_FIXUP_ASUS_SPK,
11598 		{0x12, 0x90a60130},
11599 		{0x17, 0x90170110},
11600 		{0x21, 0x04211020}),
11601 	SND_HDA_PIN_QUIRK(0x10ec0295, 0x1043, "ASUS", ALC294_FIXUP_ASUS_SPK,
11602 		{0x12, 0x90a60130},
11603 		{0x17, 0x90170110},
11604 		{0x21, 0x03211020}),
11605 	SND_HDA_PIN_QUIRK(0x10ec0295, 0x1043, "ASUS", ALC295_FIXUP_ASUS_MIC_NO_PRESENCE,
11606 		{0x12, 0x90a60120},
11607 		{0x17, 0x90170110},
11608 		{0x21, 0x04211030}),
11609 	SND_HDA_PIN_QUIRK(0x10ec0295, 0x1043, "ASUS", ALC295_FIXUP_ASUS_MIC_NO_PRESENCE,
11610 		{0x12, 0x90a60130},
11611 		{0x17, 0x90170110},
11612 		{0x21, 0x03211020}),
11613 	SND_HDA_PIN_QUIRK(0x10ec0295, 0x1043, "ASUS", ALC295_FIXUP_ASUS_MIC_NO_PRESENCE,
11614 		{0x12, 0x90a60130},
11615 		{0x17, 0x90170110},
11616 		{0x21, 0x03211020}),
11617 	SND_HDA_PIN_QUIRK(0x10ec0298, 0x1028, "Dell", ALC298_FIXUP_DELL1_MIC_NO_PRESENCE,
11618 		ALC298_STANDARD_PINS,
11619 		{0x17, 0x90170110}),
11620 	SND_HDA_PIN_QUIRK(0x10ec0298, 0x1028, "Dell", ALC298_FIXUP_DELL1_MIC_NO_PRESENCE,
11621 		ALC298_STANDARD_PINS,
11622 		{0x17, 0x90170140}),
11623 	SND_HDA_PIN_QUIRK(0x10ec0298, 0x1028, "Dell", ALC298_FIXUP_DELL1_MIC_NO_PRESENCE,
11624 		ALC298_STANDARD_PINS,
11625 		{0x17, 0x90170150}),
11626 	SND_HDA_PIN_QUIRK(0x10ec0298, 0x1028, "Dell", ALC298_FIXUP_SPK_VOLUME,
11627 		{0x12, 0xb7a60140},
11628 		{0x13, 0xb7a60150},
11629 		{0x17, 0x90170110},
11630 		{0x1a, 0x03011020},
11631 		{0x21, 0x03211030}),
11632 	SND_HDA_PIN_QUIRK(0x10ec0298, 0x1028, "Dell", ALC298_FIXUP_ALIENWARE_MIC_NO_PRESENCE,
11633 		{0x12, 0xb7a60140},
11634 		{0x17, 0x90170110},
11635 		{0x1a, 0x03a11030},
11636 		{0x21, 0x03211020}),
11637 	SND_HDA_PIN_QUIRK(0x10ec0299, 0x1028, "Dell", ALC269_FIXUP_DELL4_MIC_NO_PRESENCE,
11638 		ALC225_STANDARD_PINS,
11639 		{0x12, 0xb7a60130},
11640 		{0x17, 0x90170110}),
11641 	SND_HDA_PIN_QUIRK(0x10ec0623, 0x17aa, "Lenovo", ALC283_FIXUP_HEADSET_MIC,
11642 		{0x14, 0x01014010},
11643 		{0x17, 0x90170120},
11644 		{0x18, 0x02a11030},
11645 		{0x19, 0x02a1103f},
11646 		{0x21, 0x0221101f}),
11647 	{}
11648 };
11649 
11650 /* This is the fallback pin_fixup_tbl for alc269 family, to make the tbl match
11651  * more machines, don't need to match all valid pins, just need to match
11652  * all the pins defined in the tbl. Just because of this reason, it is possible
11653  * that a single machine matches multiple tbls, so there is one limitation:
11654  *   at most one tbl is allowed to define for the same vendor and same codec
11655  */
11656 static const struct snd_hda_pin_quirk alc269_fallback_pin_fixup_tbl[] = {
11657 	SND_HDA_PIN_QUIRK(0x10ec0256, 0x1025, "Acer", ALC2XX_FIXUP_HEADSET_MIC,
11658 		{0x19, 0x40000000}),
11659 	SND_HDA_PIN_QUIRK(0x10ec0289, 0x1028, "Dell", ALC269_FIXUP_DELL4_MIC_NO_PRESENCE,
11660 		{0x19, 0x40000000},
11661 		{0x1b, 0x40000000}),
11662 	SND_HDA_PIN_QUIRK(0x10ec0295, 0x1028, "Dell", ALC269_FIXUP_DELL4_MIC_NO_PRESENCE_QUIET,
11663 		{0x19, 0x40000000},
11664 		{0x1b, 0x40000000}),
11665 	SND_HDA_PIN_QUIRK(0x10ec0256, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
11666 		{0x19, 0x40000000},
11667 		{0x1a, 0x40000000}),
11668 	SND_HDA_PIN_QUIRK(0x10ec0236, 0x1028, "Dell", ALC255_FIXUP_DELL1_LIMIT_INT_MIC_BOOST,
11669 		{0x19, 0x40000000},
11670 		{0x1a, 0x40000000}),
11671 	SND_HDA_PIN_QUIRK(0x10ec0274, 0x1028, "Dell", ALC269_FIXUP_DELL1_LIMIT_INT_MIC_BOOST,
11672 		{0x19, 0x40000000},
11673 		{0x1a, 0x40000000}),
11674 	SND_HDA_PIN_QUIRK(0x10ec0256, 0x1043, "ASUS", ALC2XX_FIXUP_HEADSET_MIC,
11675 		{0x19, 0x40000000}),
11676 	{}
11677 };
11678 
11679 static void alc269_fill_coef(struct hda_codec *codec)
11680 {
11681 	struct alc_spec *spec = codec->spec;
11682 	int val;
11683 
11684 	if (spec->codec_variant != ALC269_TYPE_ALC269VB)
11685 		return;
11686 
11687 	if ((alc_get_coef0(codec) & 0x00ff) < 0x015) {
11688 		alc_write_coef_idx(codec, 0xf, 0x960b);
11689 		alc_write_coef_idx(codec, 0xe, 0x8817);
11690 	}
11691 
11692 	if ((alc_get_coef0(codec) & 0x00ff) == 0x016) {
11693 		alc_write_coef_idx(codec, 0xf, 0x960b);
11694 		alc_write_coef_idx(codec, 0xe, 0x8814);
11695 	}
11696 
11697 	if ((alc_get_coef0(codec) & 0x00ff) == 0x017) {
11698 		/* Power up output pin */
11699 		alc_update_coef_idx(codec, 0x04, 0, 1<<11);
11700 	}
11701 
11702 	if ((alc_get_coef0(codec) & 0x00ff) == 0x018) {
11703 		val = alc_read_coef_idx(codec, 0xd);
11704 		if (val != -1 && (val & 0x0c00) >> 10 != 0x1) {
11705 			/* Capless ramp up clock control */
11706 			alc_write_coef_idx(codec, 0xd, val | (1<<10));
11707 		}
11708 		val = alc_read_coef_idx(codec, 0x17);
11709 		if (val != -1 && (val & 0x01c0) >> 6 != 0x4) {
11710 			/* Class D power on reset */
11711 			alc_write_coef_idx(codec, 0x17, val | (1<<7));
11712 		}
11713 	}
11714 
11715 	/* HP */
11716 	alc_update_coef_idx(codec, 0x4, 0, 1<<11);
11717 }
11718 
11719 /*
11720  */
11721 static int patch_alc269(struct hda_codec *codec)
11722 {
11723 	struct alc_spec *spec;
11724 	int err;
11725 
11726 	err = alc_alloc_spec(codec, 0x0b);
11727 	if (err < 0)
11728 		return err;
11729 
11730 	spec = codec->spec;
11731 	spec->gen.shared_mic_vref_pin = 0x18;
11732 	codec->power_save_node = 0;
11733 	spec->en_3kpull_low = true;
11734 
11735 	codec->patch_ops.suspend = alc269_suspend;
11736 	codec->patch_ops.resume = alc269_resume;
11737 	spec->shutup = alc_default_shutup;
11738 	spec->init_hook = alc_default_init;
11739 
11740 	switch (codec->core.vendor_id) {
11741 	case 0x10ec0269:
11742 		spec->codec_variant = ALC269_TYPE_ALC269VA;
11743 		switch (alc_get_coef0(codec) & 0x00f0) {
11744 		case 0x0010:
11745 			if (codec->bus->pci &&
11746 			    codec->bus->pci->subsystem_vendor == 0x1025 &&
11747 			    spec->cdefine.platform_type == 1)
11748 				err = alc_codec_rename(codec, "ALC271X");
11749 			spec->codec_variant = ALC269_TYPE_ALC269VB;
11750 			break;
11751 		case 0x0020:
11752 			if (codec->bus->pci &&
11753 			    codec->bus->pci->subsystem_vendor == 0x17aa &&
11754 			    codec->bus->pci->subsystem_device == 0x21f3)
11755 				err = alc_codec_rename(codec, "ALC3202");
11756 			spec->codec_variant = ALC269_TYPE_ALC269VC;
11757 			break;
11758 		case 0x0030:
11759 			spec->codec_variant = ALC269_TYPE_ALC269VD;
11760 			break;
11761 		default:
11762 			alc_fix_pll_init(codec, 0x20, 0x04, 15);
11763 		}
11764 		if (err < 0)
11765 			goto error;
11766 		spec->shutup = alc269_shutup;
11767 		spec->init_hook = alc269_fill_coef;
11768 		alc269_fill_coef(codec);
11769 		break;
11770 
11771 	case 0x10ec0280:
11772 	case 0x10ec0290:
11773 		spec->codec_variant = ALC269_TYPE_ALC280;
11774 		break;
11775 	case 0x10ec0282:
11776 		spec->codec_variant = ALC269_TYPE_ALC282;
11777 		spec->shutup = alc282_shutup;
11778 		spec->init_hook = alc282_init;
11779 		break;
11780 	case 0x10ec0233:
11781 	case 0x10ec0283:
11782 		spec->codec_variant = ALC269_TYPE_ALC283;
11783 		spec->shutup = alc283_shutup;
11784 		spec->init_hook = alc283_init;
11785 		break;
11786 	case 0x10ec0284:
11787 	case 0x10ec0292:
11788 		spec->codec_variant = ALC269_TYPE_ALC284;
11789 		break;
11790 	case 0x10ec0293:
11791 		spec->codec_variant = ALC269_TYPE_ALC293;
11792 		break;
11793 	case 0x10ec0286:
11794 	case 0x10ec0288:
11795 		spec->codec_variant = ALC269_TYPE_ALC286;
11796 		break;
11797 	case 0x10ec0298:
11798 		spec->codec_variant = ALC269_TYPE_ALC298;
11799 		break;
11800 	case 0x10ec0235:
11801 	case 0x10ec0255:
11802 		spec->codec_variant = ALC269_TYPE_ALC255;
11803 		spec->shutup = alc256_shutup;
11804 		spec->init_hook = alc256_init;
11805 		break;
11806 	case 0x10ec0230:
11807 	case 0x10ec0236:
11808 	case 0x10ec0256:
11809 	case 0x19e58326:
11810 		spec->codec_variant = ALC269_TYPE_ALC256;
11811 		spec->shutup = alc256_shutup;
11812 		spec->init_hook = alc256_init;
11813 		spec->gen.mixer_nid = 0; /* ALC256 does not have any loopback mixer path */
11814 		if (codec->core.vendor_id == 0x10ec0236 &&
11815 		    codec->bus->pci->vendor != PCI_VENDOR_ID_AMD)
11816 			spec->en_3kpull_low = false;
11817 		break;
11818 	case 0x10ec0257:
11819 		spec->codec_variant = ALC269_TYPE_ALC257;
11820 		spec->shutup = alc256_shutup;
11821 		spec->init_hook = alc256_init;
11822 		spec->gen.mixer_nid = 0;
11823 		spec->en_3kpull_low = false;
11824 		break;
11825 	case 0x10ec0215:
11826 	case 0x10ec0245:
11827 	case 0x10ec0285:
11828 	case 0x10ec0289:
11829 		if (alc_get_coef0(codec) & 0x0010)
11830 			spec->codec_variant = ALC269_TYPE_ALC245;
11831 		else
11832 			spec->codec_variant = ALC269_TYPE_ALC215;
11833 		spec->shutup = alc225_shutup;
11834 		spec->init_hook = alc225_init;
11835 		spec->gen.mixer_nid = 0;
11836 		break;
11837 	case 0x10ec0225:
11838 	case 0x10ec0295:
11839 	case 0x10ec0299:
11840 		spec->codec_variant = ALC269_TYPE_ALC225;
11841 		spec->shutup = alc225_shutup;
11842 		spec->init_hook = alc225_init;
11843 		spec->gen.mixer_nid = 0; /* no loopback on ALC225, ALC295 and ALC299 */
11844 		break;
11845 	case 0x10ec0287:
11846 		spec->codec_variant = ALC269_TYPE_ALC287;
11847 		spec->shutup = alc225_shutup;
11848 		spec->init_hook = alc225_init;
11849 		spec->gen.mixer_nid = 0; /* no loopback on ALC287 */
11850 		break;
11851 	case 0x10ec0234:
11852 	case 0x10ec0274:
11853 	case 0x10ec0294:
11854 		spec->codec_variant = ALC269_TYPE_ALC294;
11855 		spec->gen.mixer_nid = 0; /* ALC2x4 does not have any loopback mixer path */
11856 		alc_update_coef_idx(codec, 0x6b, 0x0018, (1<<4) | (1<<3)); /* UAJ MIC Vref control by verb */
11857 		spec->init_hook = alc294_init;
11858 		break;
11859 	case 0x10ec0300:
11860 		spec->codec_variant = ALC269_TYPE_ALC300;
11861 		spec->gen.mixer_nid = 0; /* no loopback on ALC300 */
11862 		break;
11863 	case 0x10ec0623:
11864 		spec->codec_variant = ALC269_TYPE_ALC623;
11865 		break;
11866 	case 0x10ec0700:
11867 	case 0x10ec0701:
11868 	case 0x10ec0703:
11869 	case 0x10ec0711:
11870 		spec->codec_variant = ALC269_TYPE_ALC700;
11871 		spec->gen.mixer_nid = 0; /* ALC700 does not have any loopback mixer path */
11872 		alc_update_coef_idx(codec, 0x4a, 1 << 15, 0); /* Combo jack auto trigger control */
11873 		spec->init_hook = alc294_init;
11874 		break;
11875 
11876 	}
11877 
11878 	if (snd_hda_codec_read(codec, 0x51, 0, AC_VERB_PARAMETERS, 0) == 0x10ec5505) {
11879 		spec->has_alc5505_dsp = 1;
11880 		spec->init_hook = alc5505_dsp_init;
11881 	}
11882 
11883 	alc_pre_init(codec);
11884 
11885 	snd_hda_pick_fixup(codec, alc269_fixup_models,
11886 		       alc269_fixup_tbl, alc269_fixups);
11887 	/* FIXME: both TX300 and ROG Strix G17 have the same SSID, and
11888 	 * the quirk breaks the latter (bko#214101).
11889 	 * Clear the wrong entry.
11890 	 */
11891 	if (codec->fixup_id == ALC282_FIXUP_ASUS_TX300 &&
11892 	    codec->core.vendor_id == 0x10ec0294) {
11893 		codec_dbg(codec, "Clear wrong fixup for ASUS ROG Strix G17\n");
11894 		codec->fixup_id = HDA_FIXUP_ID_NOT_SET;
11895 	}
11896 
11897 	snd_hda_pick_pin_fixup(codec, alc269_pin_fixup_tbl, alc269_fixups, true);
11898 	snd_hda_pick_pin_fixup(codec, alc269_fallback_pin_fixup_tbl, alc269_fixups, false);
11899 	snd_hda_pick_fixup(codec, NULL,	alc269_fixup_vendor_tbl,
11900 			   alc269_fixups);
11901 
11902 	/*
11903 	 * Check whether ACPI describes companion amplifiers that require
11904 	 * component binding
11905 	 */
11906 	find_cirrus_companion_amps(codec);
11907 
11908 	snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE);
11909 
11910 	alc_auto_parse_customize_define(codec);
11911 
11912 	if (has_cdefine_beep(codec))
11913 		spec->gen.beep_nid = 0x01;
11914 
11915 	/* automatic parse from the BIOS config */
11916 	err = alc269_parse_auto_config(codec);
11917 	if (err < 0)
11918 		goto error;
11919 
11920 	if (!spec->gen.no_analog && spec->gen.beep_nid && spec->gen.mixer_nid) {
11921 		err = set_beep_amp(spec, spec->gen.mixer_nid, 0x04, HDA_INPUT);
11922 		if (err < 0)
11923 			goto error;
11924 	}
11925 
11926 	snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE);
11927 
11928 	return 0;
11929 
11930  error:
11931 	alc_free(codec);
11932 	return err;
11933 }
11934 
11935 /*
11936  * ALC861
11937  */
11938 
11939 static int alc861_parse_auto_config(struct hda_codec *codec)
11940 {
11941 	static const hda_nid_t alc861_ignore[] = { 0x1d, 0 };
11942 	static const hda_nid_t alc861_ssids[] = { 0x0e, 0x0f, 0x0b, 0 };
11943 	return alc_parse_auto_config(codec, alc861_ignore, alc861_ssids);
11944 }
11945 
11946 /* Pin config fixes */
11947 enum {
11948 	ALC861_FIXUP_FSC_AMILO_PI1505,
11949 	ALC861_FIXUP_AMP_VREF_0F,
11950 	ALC861_FIXUP_NO_JACK_DETECT,
11951 	ALC861_FIXUP_ASUS_A6RP,
11952 	ALC660_FIXUP_ASUS_W7J,
11953 };
11954 
11955 /* On some laptops, VREF of pin 0x0f is abused for controlling the main amp */
11956 static void alc861_fixup_asus_amp_vref_0f(struct hda_codec *codec,
11957 			const struct hda_fixup *fix, int action)
11958 {
11959 	struct alc_spec *spec = codec->spec;
11960 	unsigned int val;
11961 
11962 	if (action != HDA_FIXUP_ACT_INIT)
11963 		return;
11964 	val = snd_hda_codec_get_pin_target(codec, 0x0f);
11965 	if (!(val & (AC_PINCTL_IN_EN | AC_PINCTL_OUT_EN)))
11966 		val |= AC_PINCTL_IN_EN;
11967 	val |= AC_PINCTL_VREF_50;
11968 	snd_hda_set_pin_ctl(codec, 0x0f, val);
11969 	spec->gen.keep_vref_in_automute = 1;
11970 }
11971 
11972 /* suppress the jack-detection */
11973 static void alc_fixup_no_jack_detect(struct hda_codec *codec,
11974 				     const struct hda_fixup *fix, int action)
11975 {
11976 	if (action == HDA_FIXUP_ACT_PRE_PROBE)
11977 		codec->no_jack_detect = 1;
11978 }
11979 
11980 static const struct hda_fixup alc861_fixups[] = {
11981 	[ALC861_FIXUP_FSC_AMILO_PI1505] = {
11982 		.type = HDA_FIXUP_PINS,
11983 		.v.pins = (const struct hda_pintbl[]) {
11984 			{ 0x0b, 0x0221101f }, /* HP */
11985 			{ 0x0f, 0x90170310 }, /* speaker */
11986 			{ }
11987 		}
11988 	},
11989 	[ALC861_FIXUP_AMP_VREF_0F] = {
11990 		.type = HDA_FIXUP_FUNC,
11991 		.v.func = alc861_fixup_asus_amp_vref_0f,
11992 	},
11993 	[ALC861_FIXUP_NO_JACK_DETECT] = {
11994 		.type = HDA_FIXUP_FUNC,
11995 		.v.func = alc_fixup_no_jack_detect,
11996 	},
11997 	[ALC861_FIXUP_ASUS_A6RP] = {
11998 		.type = HDA_FIXUP_FUNC,
11999 		.v.func = alc861_fixup_asus_amp_vref_0f,
12000 		.chained = true,
12001 		.chain_id = ALC861_FIXUP_NO_JACK_DETECT,
12002 	},
12003 	[ALC660_FIXUP_ASUS_W7J] = {
12004 		.type = HDA_FIXUP_VERBS,
12005 		.v.verbs = (const struct hda_verb[]) {
12006 			/* ASUS W7J needs a magic pin setup on unused NID 0x10
12007 			 * for enabling outputs
12008 			 */
12009 			{0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
12010 			{ }
12011 		},
12012 	}
12013 };
12014 
12015 static const struct snd_pci_quirk alc861_fixup_tbl[] = {
12016 	SND_PCI_QUIRK(0x1043, 0x1253, "ASUS W7J", ALC660_FIXUP_ASUS_W7J),
12017 	SND_PCI_QUIRK(0x1043, 0x1263, "ASUS Z35HL", ALC660_FIXUP_ASUS_W7J),
12018 	SND_PCI_QUIRK(0x1043, 0x1393, "ASUS A6Rp", ALC861_FIXUP_ASUS_A6RP),
12019 	SND_PCI_QUIRK_VENDOR(0x1043, "ASUS laptop", ALC861_FIXUP_AMP_VREF_0F),
12020 	SND_PCI_QUIRK(0x1462, 0x7254, "HP DX2200", ALC861_FIXUP_NO_JACK_DETECT),
12021 	SND_PCI_QUIRK_VENDOR(0x1584, "Haier/Uniwill", ALC861_FIXUP_AMP_VREF_0F),
12022 	SND_PCI_QUIRK(0x1734, 0x10c7, "FSC Amilo Pi1505", ALC861_FIXUP_FSC_AMILO_PI1505),
12023 	{}
12024 };
12025 
12026 /*
12027  */
12028 static int patch_alc861(struct hda_codec *codec)
12029 {
12030 	struct alc_spec *spec;
12031 	int err;
12032 
12033 	err = alc_alloc_spec(codec, 0x15);
12034 	if (err < 0)
12035 		return err;
12036 
12037 	spec = codec->spec;
12038 	if (has_cdefine_beep(codec))
12039 		spec->gen.beep_nid = 0x23;
12040 
12041 	spec->power_hook = alc_power_eapd;
12042 
12043 	alc_pre_init(codec);
12044 
12045 	snd_hda_pick_fixup(codec, NULL, alc861_fixup_tbl, alc861_fixups);
12046 	snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE);
12047 
12048 	/* automatic parse from the BIOS config */
12049 	err = alc861_parse_auto_config(codec);
12050 	if (err < 0)
12051 		goto error;
12052 
12053 	if (!spec->gen.no_analog) {
12054 		err = set_beep_amp(spec, 0x23, 0, HDA_OUTPUT);
12055 		if (err < 0)
12056 			goto error;
12057 	}
12058 
12059 	snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE);
12060 
12061 	return 0;
12062 
12063  error:
12064 	alc_free(codec);
12065 	return err;
12066 }
12067 
12068 /*
12069  * ALC861-VD support
12070  *
12071  * Based on ALC882
12072  *
12073  * In addition, an independent DAC
12074  */
12075 static int alc861vd_parse_auto_config(struct hda_codec *codec)
12076 {
12077 	static const hda_nid_t alc861vd_ignore[] = { 0x1d, 0 };
12078 	static const hda_nid_t alc861vd_ssids[] = { 0x15, 0x1b, 0x14, 0 };
12079 	return alc_parse_auto_config(codec, alc861vd_ignore, alc861vd_ssids);
12080 }
12081 
12082 enum {
12083 	ALC660VD_FIX_ASUS_GPIO1,
12084 	ALC861VD_FIX_DALLAS,
12085 };
12086 
12087 /* exclude VREF80 */
12088 static void alc861vd_fixup_dallas(struct hda_codec *codec,
12089 				  const struct hda_fixup *fix, int action)
12090 {
12091 	if (action == HDA_FIXUP_ACT_PRE_PROBE) {
12092 		snd_hda_override_pin_caps(codec, 0x18, 0x00000734);
12093 		snd_hda_override_pin_caps(codec, 0x19, 0x0000073c);
12094 	}
12095 }
12096 
12097 /* reset GPIO1 */
12098 static void alc660vd_fixup_asus_gpio1(struct hda_codec *codec,
12099 				      const struct hda_fixup *fix, int action)
12100 {
12101 	struct alc_spec *spec = codec->spec;
12102 
12103 	if (action == HDA_FIXUP_ACT_PRE_PROBE)
12104 		spec->gpio_mask |= 0x02;
12105 	alc_fixup_gpio(codec, action, 0x01);
12106 }
12107 
12108 static const struct hda_fixup alc861vd_fixups[] = {
12109 	[ALC660VD_FIX_ASUS_GPIO1] = {
12110 		.type = HDA_FIXUP_FUNC,
12111 		.v.func = alc660vd_fixup_asus_gpio1,
12112 	},
12113 	[ALC861VD_FIX_DALLAS] = {
12114 		.type = HDA_FIXUP_FUNC,
12115 		.v.func = alc861vd_fixup_dallas,
12116 	},
12117 };
12118 
12119 static const struct snd_pci_quirk alc861vd_fixup_tbl[] = {
12120 	SND_PCI_QUIRK(0x103c, 0x30bf, "HP TX1000", ALC861VD_FIX_DALLAS),
12121 	SND_PCI_QUIRK(0x1043, 0x1339, "ASUS A7-K", ALC660VD_FIX_ASUS_GPIO1),
12122 	SND_PCI_QUIRK(0x1179, 0xff31, "Toshiba L30-149", ALC861VD_FIX_DALLAS),
12123 	{}
12124 };
12125 
12126 /*
12127  */
12128 static int patch_alc861vd(struct hda_codec *codec)
12129 {
12130 	struct alc_spec *spec;
12131 	int err;
12132 
12133 	err = alc_alloc_spec(codec, 0x0b);
12134 	if (err < 0)
12135 		return err;
12136 
12137 	spec = codec->spec;
12138 	if (has_cdefine_beep(codec))
12139 		spec->gen.beep_nid = 0x23;
12140 
12141 	spec->shutup = alc_eapd_shutup;
12142 
12143 	alc_pre_init(codec);
12144 
12145 	snd_hda_pick_fixup(codec, NULL, alc861vd_fixup_tbl, alc861vd_fixups);
12146 	snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE);
12147 
12148 	/* automatic parse from the BIOS config */
12149 	err = alc861vd_parse_auto_config(codec);
12150 	if (err < 0)
12151 		goto error;
12152 
12153 	if (!spec->gen.no_analog) {
12154 		err = set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
12155 		if (err < 0)
12156 			goto error;
12157 	}
12158 
12159 	snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE);
12160 
12161 	return 0;
12162 
12163  error:
12164 	alc_free(codec);
12165 	return err;
12166 }
12167 
12168 /*
12169  * ALC662 support
12170  *
12171  * ALC662 is almost identical with ALC880 but has cleaner and more flexible
12172  * configuration.  Each pin widget can choose any input DACs and a mixer.
12173  * Each ADC is connected from a mixer of all inputs.  This makes possible
12174  * 6-channel independent captures.
12175  *
12176  * In addition, an independent DAC for the multi-playback (not used in this
12177  * driver yet).
12178  */
12179 
12180 /*
12181  * BIOS auto configuration
12182  */
12183 
12184 static int alc662_parse_auto_config(struct hda_codec *codec)
12185 {
12186 	static const hda_nid_t alc662_ignore[] = { 0x1d, 0 };
12187 	static const hda_nid_t alc663_ssids[] = { 0x15, 0x1b, 0x14, 0x21 };
12188 	static const hda_nid_t alc662_ssids[] = { 0x15, 0x1b, 0x14, 0 };
12189 	const hda_nid_t *ssids;
12190 
12191 	if (codec->core.vendor_id == 0x10ec0272 || codec->core.vendor_id == 0x10ec0663 ||
12192 	    codec->core.vendor_id == 0x10ec0665 || codec->core.vendor_id == 0x10ec0670 ||
12193 	    codec->core.vendor_id == 0x10ec0671)
12194 		ssids = alc663_ssids;
12195 	else
12196 		ssids = alc662_ssids;
12197 	return alc_parse_auto_config(codec, alc662_ignore, ssids);
12198 }
12199 
12200 static void alc272_fixup_mario(struct hda_codec *codec,
12201 			       const struct hda_fixup *fix, int action)
12202 {
12203 	if (action != HDA_FIXUP_ACT_PRE_PROBE)
12204 		return;
12205 	if (snd_hda_override_amp_caps(codec, 0x2, HDA_OUTPUT,
12206 				      (0x3b << AC_AMPCAP_OFFSET_SHIFT) |
12207 				      (0x3b << AC_AMPCAP_NUM_STEPS_SHIFT) |
12208 				      (0x03 << AC_AMPCAP_STEP_SIZE_SHIFT) |
12209 				      (0 << AC_AMPCAP_MUTE_SHIFT)))
12210 		codec_warn(codec, "failed to override amp caps for NID 0x2\n");
12211 }
12212 
12213 static const struct snd_pcm_chmap_elem asus_pcm_2_1_chmaps[] = {
12214 	{ .channels = 2,
12215 	  .map = { SNDRV_CHMAP_FL, SNDRV_CHMAP_FR } },
12216 	{ .channels = 4,
12217 	  .map = { SNDRV_CHMAP_FL, SNDRV_CHMAP_FR,
12218 		   SNDRV_CHMAP_NA, SNDRV_CHMAP_LFE } }, /* LFE only on right */
12219 	{ }
12220 };
12221 
12222 /* override the 2.1 chmap */
12223 static void alc_fixup_bass_chmap(struct hda_codec *codec,
12224 				    const struct hda_fixup *fix, int action)
12225 {
12226 	if (action == HDA_FIXUP_ACT_BUILD) {
12227 		struct alc_spec *spec = codec->spec;
12228 		spec->gen.pcm_rec[0]->stream[0].chmap = asus_pcm_2_1_chmaps;
12229 	}
12230 }
12231 
12232 /* avoid D3 for keeping GPIO up */
12233 static unsigned int gpio_led_power_filter(struct hda_codec *codec,
12234 					  hda_nid_t nid,
12235 					  unsigned int power_state)
12236 {
12237 	struct alc_spec *spec = codec->spec;
12238 	if (nid == codec->core.afg && power_state == AC_PWRST_D3 && spec->gpio_data)
12239 		return AC_PWRST_D0;
12240 	return power_state;
12241 }
12242 
12243 static void alc662_fixup_led_gpio1(struct hda_codec *codec,
12244 				   const struct hda_fixup *fix, int action)
12245 {
12246 	struct alc_spec *spec = codec->spec;
12247 
12248 	alc_fixup_hp_gpio_led(codec, action, 0x01, 0);
12249 	if (action == HDA_FIXUP_ACT_PRE_PROBE) {
12250 		spec->mute_led_polarity = 1;
12251 		codec->power_filter = gpio_led_power_filter;
12252 	}
12253 }
12254 
12255 static void alc662_usi_automute_hook(struct hda_codec *codec,
12256 					 struct hda_jack_callback *jack)
12257 {
12258 	struct alc_spec *spec = codec->spec;
12259 	int vref;
12260 	msleep(200);
12261 	snd_hda_gen_hp_automute(codec, jack);
12262 
12263 	vref = spec->gen.hp_jack_present ? PIN_VREF80 : 0;
12264 	msleep(100);
12265 	snd_hda_codec_write(codec, 0x19, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
12266 			    vref);
12267 }
12268 
12269 static void alc662_fixup_usi_headset_mic(struct hda_codec *codec,
12270 				     const struct hda_fixup *fix, int action)
12271 {
12272 	struct alc_spec *spec = codec->spec;
12273 	if (action == HDA_FIXUP_ACT_PRE_PROBE) {
12274 		spec->parse_flags |= HDA_PINCFG_HEADSET_MIC;
12275 		spec->gen.hp_automute_hook = alc662_usi_automute_hook;
12276 	}
12277 }
12278 
12279 static void alc662_aspire_ethos_mute_speakers(struct hda_codec *codec,
12280 					struct hda_jack_callback *cb)
12281 {
12282 	/* surround speakers at 0x1b already get muted automatically when
12283 	 * headphones are plugged in, but we have to mute/unmute the remaining
12284 	 * channels manually:
12285 	 * 0x15 - front left/front right
12286 	 * 0x18 - front center/ LFE
12287 	 */
12288 	if (snd_hda_jack_detect_state(codec, 0x1b) == HDA_JACK_PRESENT) {
12289 		snd_hda_set_pin_ctl_cache(codec, 0x15, 0);
12290 		snd_hda_set_pin_ctl_cache(codec, 0x18, 0);
12291 	} else {
12292 		snd_hda_set_pin_ctl_cache(codec, 0x15, PIN_OUT);
12293 		snd_hda_set_pin_ctl_cache(codec, 0x18, PIN_OUT);
12294 	}
12295 }
12296 
12297 static void alc662_fixup_aspire_ethos_hp(struct hda_codec *codec,
12298 					const struct hda_fixup *fix, int action)
12299 {
12300     /* Pin 0x1b: shared headphones jack and surround speakers */
12301 	if (!is_jack_detectable(codec, 0x1b))
12302 		return;
12303 
12304 	switch (action) {
12305 	case HDA_FIXUP_ACT_PRE_PROBE:
12306 		snd_hda_jack_detect_enable_callback(codec, 0x1b,
12307 				alc662_aspire_ethos_mute_speakers);
12308 		/* subwoofer needs an extra GPIO setting to become audible */
12309 		alc_setup_gpio(codec, 0x02);
12310 		break;
12311 	case HDA_FIXUP_ACT_INIT:
12312 		/* Make sure to start in a correct state, i.e. if
12313 		 * headphones have been plugged in before powering up the system
12314 		 */
12315 		alc662_aspire_ethos_mute_speakers(codec, NULL);
12316 		break;
12317 	}
12318 }
12319 
12320 static void alc671_fixup_hp_headset_mic2(struct hda_codec *codec,
12321 					     const struct hda_fixup *fix, int action)
12322 {
12323 	struct alc_spec *spec = codec->spec;
12324 
12325 	static const struct hda_pintbl pincfgs[] = {
12326 		{ 0x19, 0x02a11040 }, /* use as headset mic, with its own jack detect */
12327 		{ 0x1b, 0x0181304f },
12328 		{ }
12329 	};
12330 
12331 	switch (action) {
12332 	case HDA_FIXUP_ACT_PRE_PROBE:
12333 		spec->gen.mixer_nid = 0;
12334 		spec->parse_flags |= HDA_PINCFG_HEADSET_MIC;
12335 		snd_hda_apply_pincfgs(codec, pincfgs);
12336 		break;
12337 	case HDA_FIXUP_ACT_INIT:
12338 		alc_write_coef_idx(codec, 0x19, 0xa054);
12339 		break;
12340 	}
12341 }
12342 
12343 static void alc897_hp_automute_hook(struct hda_codec *codec,
12344 					 struct hda_jack_callback *jack)
12345 {
12346 	struct alc_spec *spec = codec->spec;
12347 	int vref;
12348 
12349 	snd_hda_gen_hp_automute(codec, jack);
12350 	vref = spec->gen.hp_jack_present ? (PIN_HP | AC_PINCTL_VREF_100) : PIN_HP;
12351 	snd_hda_set_pin_ctl(codec, 0x1b, vref);
12352 }
12353 
12354 static void alc897_fixup_lenovo_headset_mic(struct hda_codec *codec,
12355 				     const struct hda_fixup *fix, int action)
12356 {
12357 	struct alc_spec *spec = codec->spec;
12358 	if (action == HDA_FIXUP_ACT_PRE_PROBE) {
12359 		spec->gen.hp_automute_hook = alc897_hp_automute_hook;
12360 		spec->no_shutup_pins = 1;
12361 	}
12362 	if (action == HDA_FIXUP_ACT_PROBE) {
12363 		snd_hda_set_pin_ctl_cache(codec, 0x1a, PIN_IN | AC_PINCTL_VREF_100);
12364 	}
12365 }
12366 
12367 static void alc897_fixup_lenovo_headset_mode(struct hda_codec *codec,
12368 				     const struct hda_fixup *fix, int action)
12369 {
12370 	struct alc_spec *spec = codec->spec;
12371 
12372 	if (action == HDA_FIXUP_ACT_PRE_PROBE) {
12373 		spec->parse_flags |= HDA_PINCFG_HEADSET_MIC;
12374 		spec->gen.hp_automute_hook = alc897_hp_automute_hook;
12375 	}
12376 }
12377 
12378 static const struct coef_fw alc668_coefs[] = {
12379 	WRITE_COEF(0x01, 0xbebe), WRITE_COEF(0x02, 0xaaaa), WRITE_COEF(0x03,    0x0),
12380 	WRITE_COEF(0x04, 0x0180), WRITE_COEF(0x06,    0x0), WRITE_COEF(0x07, 0x0f80),
12381 	WRITE_COEF(0x08, 0x0031), WRITE_COEF(0x0a, 0x0060), WRITE_COEF(0x0b,    0x0),
12382 	WRITE_COEF(0x0c, 0x7cf7), WRITE_COEF(0x0d, 0x1080), WRITE_COEF(0x0e, 0x7f7f),
12383 	WRITE_COEF(0x0f, 0xcccc), WRITE_COEF(0x10, 0xddcc), WRITE_COEF(0x11, 0x0001),
12384 	WRITE_COEF(0x13,    0x0), WRITE_COEF(0x14, 0x2aa0), WRITE_COEF(0x17, 0xa940),
12385 	WRITE_COEF(0x19,    0x0), WRITE_COEF(0x1a,    0x0), WRITE_COEF(0x1b,    0x0),
12386 	WRITE_COEF(0x1c,    0x0), WRITE_COEF(0x1d,    0x0), WRITE_COEF(0x1e, 0x7418),
12387 	WRITE_COEF(0x1f, 0x0804), WRITE_COEF(0x20, 0x4200), WRITE_COEF(0x21, 0x0468),
12388 	WRITE_COEF(0x22, 0x8ccc), WRITE_COEF(0x23, 0x0250), WRITE_COEF(0x24, 0x7418),
12389 	WRITE_COEF(0x27,    0x0), WRITE_COEF(0x28, 0x8ccc), WRITE_COEF(0x2a, 0xff00),
12390 	WRITE_COEF(0x2b, 0x8000), WRITE_COEF(0xa7, 0xff00), WRITE_COEF(0xa8, 0x8000),
12391 	WRITE_COEF(0xaa, 0x2e17), WRITE_COEF(0xab, 0xa0c0), WRITE_COEF(0xac,    0x0),
12392 	WRITE_COEF(0xad,    0x0), WRITE_COEF(0xae, 0x2ac6), WRITE_COEF(0xaf, 0xa480),
12393 	WRITE_COEF(0xb0,    0x0), WRITE_COEF(0xb1,    0x0), WRITE_COEF(0xb2,    0x0),
12394 	WRITE_COEF(0xb3,    0x0), WRITE_COEF(0xb4,    0x0), WRITE_COEF(0xb5, 0x1040),
12395 	WRITE_COEF(0xb6, 0xd697), WRITE_COEF(0xb7, 0x902b), WRITE_COEF(0xb8, 0xd697),
12396 	WRITE_COEF(0xb9, 0x902b), WRITE_COEF(0xba, 0xb8ba), WRITE_COEF(0xbb, 0xaaab),
12397 	WRITE_COEF(0xbc, 0xaaaf), WRITE_COEF(0xbd, 0x6aaa), WRITE_COEF(0xbe, 0x1c02),
12398 	WRITE_COEF(0xc0, 0x00ff), WRITE_COEF(0xc1, 0x0fa6),
12399 	{}
12400 };
12401 
12402 static void alc668_restore_default_value(struct hda_codec *codec)
12403 {
12404 	alc_process_coef_fw(codec, alc668_coefs);
12405 }
12406 
12407 enum {
12408 	ALC662_FIXUP_ASPIRE,
12409 	ALC662_FIXUP_LED_GPIO1,
12410 	ALC662_FIXUP_IDEAPAD,
12411 	ALC272_FIXUP_MARIO,
12412 	ALC662_FIXUP_CZC_ET26,
12413 	ALC662_FIXUP_CZC_P10T,
12414 	ALC662_FIXUP_SKU_IGNORE,
12415 	ALC662_FIXUP_HP_RP5800,
12416 	ALC662_FIXUP_ASUS_MODE1,
12417 	ALC662_FIXUP_ASUS_MODE2,
12418 	ALC662_FIXUP_ASUS_MODE3,
12419 	ALC662_FIXUP_ASUS_MODE4,
12420 	ALC662_FIXUP_ASUS_MODE5,
12421 	ALC662_FIXUP_ASUS_MODE6,
12422 	ALC662_FIXUP_ASUS_MODE7,
12423 	ALC662_FIXUP_ASUS_MODE8,
12424 	ALC662_FIXUP_NO_JACK_DETECT,
12425 	ALC662_FIXUP_ZOTAC_Z68,
12426 	ALC662_FIXUP_INV_DMIC,
12427 	ALC662_FIXUP_DELL_MIC_NO_PRESENCE,
12428 	ALC668_FIXUP_DELL_MIC_NO_PRESENCE,
12429 	ALC662_FIXUP_HEADSET_MODE,
12430 	ALC668_FIXUP_HEADSET_MODE,
12431 	ALC662_FIXUP_BASS_MODE4_CHMAP,
12432 	ALC662_FIXUP_BASS_16,
12433 	ALC662_FIXUP_BASS_1A,
12434 	ALC662_FIXUP_BASS_CHMAP,
12435 	ALC668_FIXUP_AUTO_MUTE,
12436 	ALC668_FIXUP_DELL_DISABLE_AAMIX,
12437 	ALC668_FIXUP_DELL_XPS13,
12438 	ALC662_FIXUP_ASUS_Nx50,
12439 	ALC668_FIXUP_ASUS_Nx51_HEADSET_MODE,
12440 	ALC668_FIXUP_ASUS_Nx51,
12441 	ALC668_FIXUP_MIC_COEF,
12442 	ALC668_FIXUP_ASUS_G751,
12443 	ALC891_FIXUP_HEADSET_MODE,
12444 	ALC891_FIXUP_DELL_MIC_NO_PRESENCE,
12445 	ALC662_FIXUP_ACER_VERITON,
12446 	ALC892_FIXUP_ASROCK_MOBO,
12447 	ALC662_FIXUP_USI_FUNC,
12448 	ALC662_FIXUP_USI_HEADSET_MODE,
12449 	ALC662_FIXUP_LENOVO_MULTI_CODECS,
12450 	ALC669_FIXUP_ACER_ASPIRE_ETHOS,
12451 	ALC669_FIXUP_ACER_ASPIRE_ETHOS_HEADSET,
12452 	ALC671_FIXUP_HP_HEADSET_MIC2,
12453 	ALC662_FIXUP_ACER_X2660G_HEADSET_MODE,
12454 	ALC662_FIXUP_ACER_NITRO_HEADSET_MODE,
12455 	ALC668_FIXUP_ASUS_NO_HEADSET_MIC,
12456 	ALC668_FIXUP_HEADSET_MIC,
12457 	ALC668_FIXUP_MIC_DET_COEF,
12458 	ALC897_FIXUP_LENOVO_HEADSET_MIC,
12459 	ALC897_FIXUP_HEADSET_MIC_PIN,
12460 	ALC897_FIXUP_HP_HSMIC_VERB,
12461 	ALC897_FIXUP_LENOVO_HEADSET_MODE,
12462 	ALC897_FIXUP_HEADSET_MIC_PIN2,
12463 	ALC897_FIXUP_UNIS_H3C_X500S,
12464 	ALC897_FIXUP_HEADSET_MIC_PIN3,
12465 };
12466 
12467 static const struct hda_fixup alc662_fixups[] = {
12468 	[ALC662_FIXUP_ASPIRE] = {
12469 		.type = HDA_FIXUP_PINS,
12470 		.v.pins = (const struct hda_pintbl[]) {
12471 			{ 0x15, 0x99130112 }, /* subwoofer */
12472 			{ }
12473 		}
12474 	},
12475 	[ALC662_FIXUP_LED_GPIO1] = {
12476 		.type = HDA_FIXUP_FUNC,
12477 		.v.func = alc662_fixup_led_gpio1,
12478 	},
12479 	[ALC662_FIXUP_IDEAPAD] = {
12480 		.type = HDA_FIXUP_PINS,
12481 		.v.pins = (const struct hda_pintbl[]) {
12482 			{ 0x17, 0x99130112 }, /* subwoofer */
12483 			{ }
12484 		},
12485 		.chained = true,
12486 		.chain_id = ALC662_FIXUP_LED_GPIO1,
12487 	},
12488 	[ALC272_FIXUP_MARIO] = {
12489 		.type = HDA_FIXUP_FUNC,
12490 		.v.func = alc272_fixup_mario,
12491 	},
12492 	[ALC662_FIXUP_CZC_ET26] = {
12493 		.type = HDA_FIXUP_PINS,
12494 		.v.pins = (const struct hda_pintbl[]) {
12495 			{0x12, 0x403cc000},
12496 			{0x14, 0x90170110}, /* speaker */
12497 			{0x15, 0x411111f0},
12498 			{0x16, 0x411111f0},
12499 			{0x18, 0x01a19030}, /* mic */
12500 			{0x19, 0x90a7013f}, /* int-mic */
12501 			{0x1a, 0x01014020},
12502 			{0x1b, 0x0121401f},
12503 			{0x1c, 0x411111f0},
12504 			{0x1d, 0x411111f0},
12505 			{0x1e, 0x40478e35},
12506 			{}
12507 		},
12508 		.chained = true,
12509 		.chain_id = ALC662_FIXUP_SKU_IGNORE
12510 	},
12511 	[ALC662_FIXUP_CZC_P10T] = {
12512 		.type = HDA_FIXUP_VERBS,
12513 		.v.verbs = (const struct hda_verb[]) {
12514 			{0x14, AC_VERB_SET_EAPD_BTLENABLE, 0},
12515 			{}
12516 		}
12517 	},
12518 	[ALC662_FIXUP_SKU_IGNORE] = {
12519 		.type = HDA_FIXUP_FUNC,
12520 		.v.func = alc_fixup_sku_ignore,
12521 	},
12522 	[ALC662_FIXUP_HP_RP5800] = {
12523 		.type = HDA_FIXUP_PINS,
12524 		.v.pins = (const struct hda_pintbl[]) {
12525 			{ 0x14, 0x0221201f }, /* HP out */
12526 			{ }
12527 		},
12528 		.chained = true,
12529 		.chain_id = ALC662_FIXUP_SKU_IGNORE
12530 	},
12531 	[ALC662_FIXUP_ASUS_MODE1] = {
12532 		.type = HDA_FIXUP_PINS,
12533 		.v.pins = (const struct hda_pintbl[]) {
12534 			{ 0x14, 0x99130110 }, /* speaker */
12535 			{ 0x18, 0x01a19c20 }, /* mic */
12536 			{ 0x19, 0x99a3092f }, /* int-mic */
12537 			{ 0x21, 0x0121401f }, /* HP out */
12538 			{ }
12539 		},
12540 		.chained = true,
12541 		.chain_id = ALC662_FIXUP_SKU_IGNORE
12542 	},
12543 	[ALC662_FIXUP_ASUS_MODE2] = {
12544 		.type = HDA_FIXUP_PINS,
12545 		.v.pins = (const struct hda_pintbl[]) {
12546 			{ 0x14, 0x99130110 }, /* speaker */
12547 			{ 0x18, 0x01a19820 }, /* mic */
12548 			{ 0x19, 0x99a3092f }, /* int-mic */
12549 			{ 0x1b, 0x0121401f }, /* HP out */
12550 			{ }
12551 		},
12552 		.chained = true,
12553 		.chain_id = ALC662_FIXUP_SKU_IGNORE
12554 	},
12555 	[ALC662_FIXUP_ASUS_MODE3] = {
12556 		.type = HDA_FIXUP_PINS,
12557 		.v.pins = (const struct hda_pintbl[]) {
12558 			{ 0x14, 0x99130110 }, /* speaker */
12559 			{ 0x15, 0x0121441f }, /* HP */
12560 			{ 0x18, 0x01a19840 }, /* mic */
12561 			{ 0x19, 0x99a3094f }, /* int-mic */
12562 			{ 0x21, 0x01211420 }, /* HP2 */
12563 			{ }
12564 		},
12565 		.chained = true,
12566 		.chain_id = ALC662_FIXUP_SKU_IGNORE
12567 	},
12568 	[ALC662_FIXUP_ASUS_MODE4] = {
12569 		.type = HDA_FIXUP_PINS,
12570 		.v.pins = (const struct hda_pintbl[]) {
12571 			{ 0x14, 0x99130110 }, /* speaker */
12572 			{ 0x16, 0x99130111 }, /* speaker */
12573 			{ 0x18, 0x01a19840 }, /* mic */
12574 			{ 0x19, 0x99a3094f }, /* int-mic */
12575 			{ 0x21, 0x0121441f }, /* HP */
12576 			{ }
12577 		},
12578 		.chained = true,
12579 		.chain_id = ALC662_FIXUP_SKU_IGNORE
12580 	},
12581 	[ALC662_FIXUP_ASUS_MODE5] = {
12582 		.type = HDA_FIXUP_PINS,
12583 		.v.pins = (const struct hda_pintbl[]) {
12584 			{ 0x14, 0x99130110 }, /* speaker */
12585 			{ 0x15, 0x0121441f }, /* HP */
12586 			{ 0x16, 0x99130111 }, /* speaker */
12587 			{ 0x18, 0x01a19840 }, /* mic */
12588 			{ 0x19, 0x99a3094f }, /* int-mic */
12589 			{ }
12590 		},
12591 		.chained = true,
12592 		.chain_id = ALC662_FIXUP_SKU_IGNORE
12593 	},
12594 	[ALC662_FIXUP_ASUS_MODE6] = {
12595 		.type = HDA_FIXUP_PINS,
12596 		.v.pins = (const struct hda_pintbl[]) {
12597 			{ 0x14, 0x99130110 }, /* speaker */
12598 			{ 0x15, 0x01211420 }, /* HP2 */
12599 			{ 0x18, 0x01a19840 }, /* mic */
12600 			{ 0x19, 0x99a3094f }, /* int-mic */
12601 			{ 0x1b, 0x0121441f }, /* HP */
12602 			{ }
12603 		},
12604 		.chained = true,
12605 		.chain_id = ALC662_FIXUP_SKU_IGNORE
12606 	},
12607 	[ALC662_FIXUP_ASUS_MODE7] = {
12608 		.type = HDA_FIXUP_PINS,
12609 		.v.pins = (const struct hda_pintbl[]) {
12610 			{ 0x14, 0x99130110 }, /* speaker */
12611 			{ 0x17, 0x99130111 }, /* speaker */
12612 			{ 0x18, 0x01a19840 }, /* mic */
12613 			{ 0x19, 0x99a3094f }, /* int-mic */
12614 			{ 0x1b, 0x01214020 }, /* HP */
12615 			{ 0x21, 0x0121401f }, /* HP */
12616 			{ }
12617 		},
12618 		.chained = true,
12619 		.chain_id = ALC662_FIXUP_SKU_IGNORE
12620 	},
12621 	[ALC662_FIXUP_ASUS_MODE8] = {
12622 		.type = HDA_FIXUP_PINS,
12623 		.v.pins = (const struct hda_pintbl[]) {
12624 			{ 0x14, 0x99130110 }, /* speaker */
12625 			{ 0x12, 0x99a30970 }, /* int-mic */
12626 			{ 0x15, 0x01214020 }, /* HP */
12627 			{ 0x17, 0x99130111 }, /* speaker */
12628 			{ 0x18, 0x01a19840 }, /* mic */
12629 			{ 0x21, 0x0121401f }, /* HP */
12630 			{ }
12631 		},
12632 		.chained = true,
12633 		.chain_id = ALC662_FIXUP_SKU_IGNORE
12634 	},
12635 	[ALC662_FIXUP_NO_JACK_DETECT] = {
12636 		.type = HDA_FIXUP_FUNC,
12637 		.v.func = alc_fixup_no_jack_detect,
12638 	},
12639 	[ALC662_FIXUP_ZOTAC_Z68] = {
12640 		.type = HDA_FIXUP_PINS,
12641 		.v.pins = (const struct hda_pintbl[]) {
12642 			{ 0x1b, 0x02214020 }, /* Front HP */
12643 			{ }
12644 		}
12645 	},
12646 	[ALC662_FIXUP_INV_DMIC] = {
12647 		.type = HDA_FIXUP_FUNC,
12648 		.v.func = alc_fixup_inv_dmic,
12649 	},
12650 	[ALC668_FIXUP_DELL_XPS13] = {
12651 		.type = HDA_FIXUP_FUNC,
12652 		.v.func = alc_fixup_dell_xps13,
12653 		.chained = true,
12654 		.chain_id = ALC668_FIXUP_DELL_DISABLE_AAMIX
12655 	},
12656 	[ALC668_FIXUP_DELL_DISABLE_AAMIX] = {
12657 		.type = HDA_FIXUP_FUNC,
12658 		.v.func = alc_fixup_disable_aamix,
12659 		.chained = true,
12660 		.chain_id = ALC668_FIXUP_DELL_MIC_NO_PRESENCE
12661 	},
12662 	[ALC668_FIXUP_AUTO_MUTE] = {
12663 		.type = HDA_FIXUP_FUNC,
12664 		.v.func = alc_fixup_auto_mute_via_amp,
12665 		.chained = true,
12666 		.chain_id = ALC668_FIXUP_DELL_MIC_NO_PRESENCE
12667 	},
12668 	[ALC662_FIXUP_DELL_MIC_NO_PRESENCE] = {
12669 		.type = HDA_FIXUP_PINS,
12670 		.v.pins = (const struct hda_pintbl[]) {
12671 			{ 0x19, 0x03a1113c }, /* use as headset mic, without its own jack detect */
12672 			/* headphone mic by setting pin control of 0x1b (headphone out) to in + vref_50 */
12673 			{ }
12674 		},
12675 		.chained = true,
12676 		.chain_id = ALC662_FIXUP_HEADSET_MODE
12677 	},
12678 	[ALC662_FIXUP_HEADSET_MODE] = {
12679 		.type = HDA_FIXUP_FUNC,
12680 		.v.func = alc_fixup_headset_mode_alc662,
12681 	},
12682 	[ALC668_FIXUP_DELL_MIC_NO_PRESENCE] = {
12683 		.type = HDA_FIXUP_PINS,
12684 		.v.pins = (const struct hda_pintbl[]) {
12685 			{ 0x19, 0x03a1913d }, /* use as headphone mic, without its own jack detect */
12686 			{ 0x1b, 0x03a1113c }, /* use as headset mic, without its own jack detect */
12687 			{ }
12688 		},
12689 		.chained = true,
12690 		.chain_id = ALC668_FIXUP_HEADSET_MODE
12691 	},
12692 	[ALC668_FIXUP_HEADSET_MODE] = {
12693 		.type = HDA_FIXUP_FUNC,
12694 		.v.func = alc_fixup_headset_mode_alc668,
12695 	},
12696 	[ALC662_FIXUP_BASS_MODE4_CHMAP] = {
12697 		.type = HDA_FIXUP_FUNC,
12698 		.v.func = alc_fixup_bass_chmap,
12699 		.chained = true,
12700 		.chain_id = ALC662_FIXUP_ASUS_MODE4
12701 	},
12702 	[ALC662_FIXUP_BASS_16] = {
12703 		.type = HDA_FIXUP_PINS,
12704 		.v.pins = (const struct hda_pintbl[]) {
12705 			{0x16, 0x80106111}, /* bass speaker */
12706 			{}
12707 		},
12708 		.chained = true,
12709 		.chain_id = ALC662_FIXUP_BASS_CHMAP,
12710 	},
12711 	[ALC662_FIXUP_BASS_1A] = {
12712 		.type = HDA_FIXUP_PINS,
12713 		.v.pins = (const struct hda_pintbl[]) {
12714 			{0x1a, 0x80106111}, /* bass speaker */
12715 			{}
12716 		},
12717 		.chained = true,
12718 		.chain_id = ALC662_FIXUP_BASS_CHMAP,
12719 	},
12720 	[ALC662_FIXUP_BASS_CHMAP] = {
12721 		.type = HDA_FIXUP_FUNC,
12722 		.v.func = alc_fixup_bass_chmap,
12723 	},
12724 	[ALC662_FIXUP_ASUS_Nx50] = {
12725 		.type = HDA_FIXUP_FUNC,
12726 		.v.func = alc_fixup_auto_mute_via_amp,
12727 		.chained = true,
12728 		.chain_id = ALC662_FIXUP_BASS_1A
12729 	},
12730 	[ALC668_FIXUP_ASUS_Nx51_HEADSET_MODE] = {
12731 		.type = HDA_FIXUP_FUNC,
12732 		.v.func = alc_fixup_headset_mode_alc668,
12733 		.chain_id = ALC662_FIXUP_BASS_CHMAP
12734 	},
12735 	[ALC668_FIXUP_ASUS_Nx51] = {
12736 		.type = HDA_FIXUP_PINS,
12737 		.v.pins = (const struct hda_pintbl[]) {
12738 			{ 0x19, 0x03a1913d }, /* use as headphone mic, without its own jack detect */
12739 			{ 0x1a, 0x90170151 }, /* bass speaker */
12740 			{ 0x1b, 0x03a1113c }, /* use as headset mic, without its own jack detect */
12741 			{}
12742 		},
12743 		.chained = true,
12744 		.chain_id = ALC668_FIXUP_ASUS_Nx51_HEADSET_MODE,
12745 	},
12746 	[ALC668_FIXUP_MIC_COEF] = {
12747 		.type = HDA_FIXUP_VERBS,
12748 		.v.verbs = (const struct hda_verb[]) {
12749 			{ 0x20, AC_VERB_SET_COEF_INDEX, 0xc3 },
12750 			{ 0x20, AC_VERB_SET_PROC_COEF, 0x4000 },
12751 			{}
12752 		},
12753 	},
12754 	[ALC668_FIXUP_ASUS_G751] = {
12755 		.type = HDA_FIXUP_PINS,
12756 		.v.pins = (const struct hda_pintbl[]) {
12757 			{ 0x16, 0x0421101f }, /* HP */
12758 			{}
12759 		},
12760 		.chained = true,
12761 		.chain_id = ALC668_FIXUP_MIC_COEF
12762 	},
12763 	[ALC891_FIXUP_HEADSET_MODE] = {
12764 		.type = HDA_FIXUP_FUNC,
12765 		.v.func = alc_fixup_headset_mode,
12766 	},
12767 	[ALC891_FIXUP_DELL_MIC_NO_PRESENCE] = {
12768 		.type = HDA_FIXUP_PINS,
12769 		.v.pins = (const struct hda_pintbl[]) {
12770 			{ 0x19, 0x03a1913d }, /* use as headphone mic, without its own jack detect */
12771 			{ 0x1b, 0x03a1113c }, /* use as headset mic, without its own jack detect */
12772 			{ }
12773 		},
12774 		.chained = true,
12775 		.chain_id = ALC891_FIXUP_HEADSET_MODE
12776 	},
12777 	[ALC662_FIXUP_ACER_VERITON] = {
12778 		.type = HDA_FIXUP_PINS,
12779 		.v.pins = (const struct hda_pintbl[]) {
12780 			{ 0x15, 0x50170120 }, /* no internal speaker */
12781 			{ }
12782 		}
12783 	},
12784 	[ALC892_FIXUP_ASROCK_MOBO] = {
12785 		.type = HDA_FIXUP_PINS,
12786 		.v.pins = (const struct hda_pintbl[]) {
12787 			{ 0x15, 0x40f000f0 }, /* disabled */
12788 			{ 0x16, 0x40f000f0 }, /* disabled */
12789 			{ }
12790 		}
12791 	},
12792 	[ALC662_FIXUP_USI_FUNC] = {
12793 		.type = HDA_FIXUP_FUNC,
12794 		.v.func = alc662_fixup_usi_headset_mic,
12795 	},
12796 	[ALC662_FIXUP_USI_HEADSET_MODE] = {
12797 		.type = HDA_FIXUP_PINS,
12798 		.v.pins = (const struct hda_pintbl[]) {
12799 			{ 0x19, 0x02a1913c }, /* use as headset mic, without its own jack detect */
12800 			{ 0x18, 0x01a1903d },
12801 			{ }
12802 		},
12803 		.chained = true,
12804 		.chain_id = ALC662_FIXUP_USI_FUNC
12805 	},
12806 	[ALC662_FIXUP_LENOVO_MULTI_CODECS] = {
12807 		.type = HDA_FIXUP_FUNC,
12808 		.v.func = alc233_alc662_fixup_lenovo_dual_codecs,
12809 	},
12810 	[ALC669_FIXUP_ACER_ASPIRE_ETHOS_HEADSET] = {
12811 		.type = HDA_FIXUP_FUNC,
12812 		.v.func = alc662_fixup_aspire_ethos_hp,
12813 	},
12814 	[ALC669_FIXUP_ACER_ASPIRE_ETHOS] = {
12815 		.type = HDA_FIXUP_PINS,
12816 		.v.pins = (const struct hda_pintbl[]) {
12817 			{ 0x15, 0x92130110 }, /* front speakers */
12818 			{ 0x18, 0x99130111 }, /* center/subwoofer */
12819 			{ 0x1b, 0x11130012 }, /* surround plus jack for HP */
12820 			{ }
12821 		},
12822 		.chained = true,
12823 		.chain_id = ALC669_FIXUP_ACER_ASPIRE_ETHOS_HEADSET
12824 	},
12825 	[ALC671_FIXUP_HP_HEADSET_MIC2] = {
12826 		.type = HDA_FIXUP_FUNC,
12827 		.v.func = alc671_fixup_hp_headset_mic2,
12828 	},
12829 	[ALC662_FIXUP_ACER_X2660G_HEADSET_MODE] = {
12830 		.type = HDA_FIXUP_PINS,
12831 		.v.pins = (const struct hda_pintbl[]) {
12832 			{ 0x1a, 0x02a1113c }, /* use as headset mic, without its own jack detect */
12833 			{ }
12834 		},
12835 		.chained = true,
12836 		.chain_id = ALC662_FIXUP_USI_FUNC
12837 	},
12838 	[ALC662_FIXUP_ACER_NITRO_HEADSET_MODE] = {
12839 		.type = HDA_FIXUP_PINS,
12840 		.v.pins = (const struct hda_pintbl[]) {
12841 			{ 0x1a, 0x01a11140 }, /* use as headset mic, without its own jack detect */
12842 			{ 0x1b, 0x0221144f },
12843 			{ }
12844 		},
12845 		.chained = true,
12846 		.chain_id = ALC662_FIXUP_USI_FUNC
12847 	},
12848 	[ALC668_FIXUP_ASUS_NO_HEADSET_MIC] = {
12849 		.type = HDA_FIXUP_PINS,
12850 		.v.pins = (const struct hda_pintbl[]) {
12851 			{ 0x1b, 0x04a1112c },
12852 			{ }
12853 		},
12854 		.chained = true,
12855 		.chain_id = ALC668_FIXUP_HEADSET_MIC
12856 	},
12857 	[ALC668_FIXUP_HEADSET_MIC] = {
12858 		.type = HDA_FIXUP_FUNC,
12859 		.v.func = alc269_fixup_headset_mic,
12860 		.chained = true,
12861 		.chain_id = ALC668_FIXUP_MIC_DET_COEF
12862 	},
12863 	[ALC668_FIXUP_MIC_DET_COEF] = {
12864 		.type = HDA_FIXUP_VERBS,
12865 		.v.verbs = (const struct hda_verb[]) {
12866 			{ 0x20, AC_VERB_SET_COEF_INDEX, 0x15 },
12867 			{ 0x20, AC_VERB_SET_PROC_COEF, 0x0d60 },
12868 			{}
12869 		},
12870 	},
12871 	[ALC897_FIXUP_LENOVO_HEADSET_MIC] = {
12872 		.type = HDA_FIXUP_FUNC,
12873 		.v.func = alc897_fixup_lenovo_headset_mic,
12874 	},
12875 	[ALC897_FIXUP_HEADSET_MIC_PIN] = {
12876 		.type = HDA_FIXUP_PINS,
12877 		.v.pins = (const struct hda_pintbl[]) {
12878 			{ 0x1a, 0x03a11050 },
12879 			{ }
12880 		},
12881 		.chained = true,
12882 		.chain_id = ALC897_FIXUP_LENOVO_HEADSET_MIC
12883 	},
12884 	[ALC897_FIXUP_HP_HSMIC_VERB] = {
12885 		.type = HDA_FIXUP_PINS,
12886 		.v.pins = (const struct hda_pintbl[]) {
12887 			{ 0x19, 0x01a1913c }, /* use as headset mic, without its own jack detect */
12888 			{ }
12889 		},
12890 	},
12891 	[ALC897_FIXUP_LENOVO_HEADSET_MODE] = {
12892 		.type = HDA_FIXUP_FUNC,
12893 		.v.func = alc897_fixup_lenovo_headset_mode,
12894 	},
12895 	[ALC897_FIXUP_HEADSET_MIC_PIN2] = {
12896 		.type = HDA_FIXUP_PINS,
12897 		.v.pins = (const struct hda_pintbl[]) {
12898 			{ 0x1a, 0x01a11140 }, /* use as headset mic, without its own jack detect */
12899 			{ }
12900 		},
12901 		.chained = true,
12902 		.chain_id = ALC897_FIXUP_LENOVO_HEADSET_MODE
12903 	},
12904 	[ALC897_FIXUP_UNIS_H3C_X500S] = {
12905 		.type = HDA_FIXUP_VERBS,
12906 		.v.verbs = (const struct hda_verb[]) {
12907 			{ 0x14, AC_VERB_SET_EAPD_BTLENABLE, 0 },
12908 			{}
12909 		},
12910 	},
12911 	[ALC897_FIXUP_HEADSET_MIC_PIN3] = {
12912 		.type = HDA_FIXUP_PINS,
12913 		.v.pins = (const struct hda_pintbl[]) {
12914 			{ 0x19, 0x03a11050 }, /* use as headset mic */
12915 			{ }
12916 		},
12917 	},
12918 };
12919 
12920 static const struct snd_pci_quirk alc662_fixup_tbl[] = {
12921 	SND_PCI_QUIRK(0x1019, 0x9087, "ECS", ALC662_FIXUP_ASUS_MODE2),
12922 	SND_PCI_QUIRK(0x1019, 0x9859, "JP-IK LEAP W502", ALC897_FIXUP_HEADSET_MIC_PIN3),
12923 	SND_PCI_QUIRK(0x1025, 0x022f, "Acer Aspire One", ALC662_FIXUP_INV_DMIC),
12924 	SND_PCI_QUIRK(0x1025, 0x0241, "Packard Bell DOTS", ALC662_FIXUP_INV_DMIC),
12925 	SND_PCI_QUIRK(0x1025, 0x0308, "Acer Aspire 8942G", ALC662_FIXUP_ASPIRE),
12926 	SND_PCI_QUIRK(0x1025, 0x031c, "Gateway NV79", ALC662_FIXUP_SKU_IGNORE),
12927 	SND_PCI_QUIRK(0x1025, 0x0349, "eMachines eM250", ALC662_FIXUP_INV_DMIC),
12928 	SND_PCI_QUIRK(0x1025, 0x034a, "Gateway LT27", ALC662_FIXUP_INV_DMIC),
12929 	SND_PCI_QUIRK(0x1025, 0x038b, "Acer Aspire 8943G", ALC662_FIXUP_ASPIRE),
12930 	SND_PCI_QUIRK(0x1025, 0x0566, "Acer Aspire Ethos 8951G", ALC669_FIXUP_ACER_ASPIRE_ETHOS),
12931 	SND_PCI_QUIRK(0x1025, 0x123c, "Acer Nitro N50-600", ALC662_FIXUP_ACER_NITRO_HEADSET_MODE),
12932 	SND_PCI_QUIRK(0x1025, 0x124e, "Acer 2660G", ALC662_FIXUP_ACER_X2660G_HEADSET_MODE),
12933 	SND_PCI_QUIRK(0x1028, 0x05d8, "Dell", ALC668_FIXUP_DELL_MIC_NO_PRESENCE),
12934 	SND_PCI_QUIRK(0x1028, 0x05db, "Dell", ALC668_FIXUP_DELL_MIC_NO_PRESENCE),
12935 	SND_PCI_QUIRK(0x1028, 0x05fe, "Dell XPS 15", ALC668_FIXUP_DELL_XPS13),
12936 	SND_PCI_QUIRK(0x1028, 0x060a, "Dell XPS 13", ALC668_FIXUP_DELL_XPS13),
12937 	SND_PCI_QUIRK(0x1028, 0x060d, "Dell M3800", ALC668_FIXUP_DELL_XPS13),
12938 	SND_PCI_QUIRK(0x1028, 0x0625, "Dell", ALC668_FIXUP_DELL_MIC_NO_PRESENCE),
12939 	SND_PCI_QUIRK(0x1028, 0x0626, "Dell", ALC668_FIXUP_DELL_MIC_NO_PRESENCE),
12940 	SND_PCI_QUIRK(0x1028, 0x0696, "Dell", ALC668_FIXUP_DELL_MIC_NO_PRESENCE),
12941 	SND_PCI_QUIRK(0x1028, 0x0698, "Dell", ALC668_FIXUP_DELL_MIC_NO_PRESENCE),
12942 	SND_PCI_QUIRK(0x1028, 0x069f, "Dell", ALC668_FIXUP_DELL_MIC_NO_PRESENCE),
12943 	SND_PCI_QUIRK(0x103c, 0x1632, "HP RP5800", ALC662_FIXUP_HP_RP5800),
12944 	SND_PCI_QUIRK(0x103c, 0x870c, "HP", ALC897_FIXUP_HP_HSMIC_VERB),
12945 	SND_PCI_QUIRK(0x103c, 0x8719, "HP", ALC897_FIXUP_HP_HSMIC_VERB),
12946 	SND_PCI_QUIRK(0x103c, 0x872b, "HP", ALC897_FIXUP_HP_HSMIC_VERB),
12947 	SND_PCI_QUIRK(0x103c, 0x873e, "HP", ALC671_FIXUP_HP_HEADSET_MIC2),
12948 	SND_PCI_QUIRK(0x103c, 0x8768, "HP Slim Desktop S01", ALC671_FIXUP_HP_HEADSET_MIC2),
12949 	SND_PCI_QUIRK(0x103c, 0x877e, "HP 288 Pro G6", ALC671_FIXUP_HP_HEADSET_MIC2),
12950 	SND_PCI_QUIRK(0x103c, 0x885f, "HP 288 Pro G8", ALC671_FIXUP_HP_HEADSET_MIC2),
12951 	SND_PCI_QUIRK(0x1043, 0x1080, "Asus UX501VW", ALC668_FIXUP_HEADSET_MODE),
12952 	SND_PCI_QUIRK(0x1043, 0x11cd, "Asus N550", ALC662_FIXUP_ASUS_Nx50),
12953 	SND_PCI_QUIRK(0x1043, 0x129d, "Asus N750", ALC662_FIXUP_ASUS_Nx50),
12954 	SND_PCI_QUIRK(0x1043, 0x12ff, "ASUS G751", ALC668_FIXUP_ASUS_G751),
12955 	SND_PCI_QUIRK(0x1043, 0x13df, "Asus N550JX", ALC662_FIXUP_BASS_1A),
12956 	SND_PCI_QUIRK(0x1043, 0x1477, "ASUS N56VZ", ALC662_FIXUP_BASS_MODE4_CHMAP),
12957 	SND_PCI_QUIRK(0x1043, 0x15a7, "ASUS UX51VZH", ALC662_FIXUP_BASS_16),
12958 	SND_PCI_QUIRK(0x1043, 0x177d, "ASUS N551", ALC668_FIXUP_ASUS_Nx51),
12959 	SND_PCI_QUIRK(0x1043, 0x17bd, "ASUS N751", ALC668_FIXUP_ASUS_Nx51),
12960 	SND_PCI_QUIRK(0x1043, 0x185d, "ASUS G551JW", ALC668_FIXUP_ASUS_NO_HEADSET_MIC),
12961 	SND_PCI_QUIRK(0x1043, 0x1963, "ASUS X71SL", ALC662_FIXUP_ASUS_MODE8),
12962 	SND_PCI_QUIRK(0x1043, 0x1b73, "ASUS N55SF", ALC662_FIXUP_BASS_16),
12963 	SND_PCI_QUIRK(0x1043, 0x1bf3, "ASUS N76VZ", ALC662_FIXUP_BASS_MODE4_CHMAP),
12964 	SND_PCI_QUIRK(0x1043, 0x8469, "ASUS mobo", ALC662_FIXUP_NO_JACK_DETECT),
12965 	SND_PCI_QUIRK(0x105b, 0x0cd6, "Foxconn", ALC662_FIXUP_ASUS_MODE2),
12966 	SND_PCI_QUIRK(0x144d, 0xc051, "Samsung R720", ALC662_FIXUP_IDEAPAD),
12967 	SND_PCI_QUIRK(0x14cd, 0x5003, "USI", ALC662_FIXUP_USI_HEADSET_MODE),
12968 	SND_PCI_QUIRK(0x17aa, 0x1036, "Lenovo P520", ALC662_FIXUP_LENOVO_MULTI_CODECS),
12969 	SND_PCI_QUIRK(0x17aa, 0x1057, "Lenovo P360", ALC897_FIXUP_HEADSET_MIC_PIN),
12970 	SND_PCI_QUIRK(0x17aa, 0x1064, "Lenovo P3 Tower", ALC897_FIXUP_HEADSET_MIC_PIN),
12971 	SND_PCI_QUIRK(0x17aa, 0x32ca, "Lenovo ThinkCentre M80", ALC897_FIXUP_HEADSET_MIC_PIN),
12972 	SND_PCI_QUIRK(0x17aa, 0x32cb, "Lenovo ThinkCentre M70", ALC897_FIXUP_HEADSET_MIC_PIN),
12973 	SND_PCI_QUIRK(0x17aa, 0x32cf, "Lenovo ThinkCentre M950", ALC897_FIXUP_HEADSET_MIC_PIN),
12974 	SND_PCI_QUIRK(0x17aa, 0x32f7, "Lenovo ThinkCentre M90", ALC897_FIXUP_HEADSET_MIC_PIN),
12975 	SND_PCI_QUIRK(0x17aa, 0x3321, "Lenovo ThinkCentre M70 Gen4", ALC897_FIXUP_HEADSET_MIC_PIN),
12976 	SND_PCI_QUIRK(0x17aa, 0x331b, "Lenovo ThinkCentre M90 Gen4", ALC897_FIXUP_HEADSET_MIC_PIN),
12977 	SND_PCI_QUIRK(0x17aa, 0x3364, "Lenovo ThinkCentre M90 Gen5", ALC897_FIXUP_HEADSET_MIC_PIN),
12978 	SND_PCI_QUIRK(0x17aa, 0x3742, "Lenovo TianYi510Pro-14IOB", ALC897_FIXUP_HEADSET_MIC_PIN2),
12979 	SND_PCI_QUIRK(0x17aa, 0x38af, "Lenovo Ideapad Y550P", ALC662_FIXUP_IDEAPAD),
12980 	SND_PCI_QUIRK(0x17aa, 0x3a0d, "Lenovo Ideapad Y550", ALC662_FIXUP_IDEAPAD),
12981 	SND_PCI_QUIRK(0x1849, 0x5892, "ASRock B150M", ALC892_FIXUP_ASROCK_MOBO),
12982 	SND_PCI_QUIRK(0x19da, 0xa130, "Zotac Z68", ALC662_FIXUP_ZOTAC_Z68),
12983 	SND_PCI_QUIRK(0x1b0a, 0x01b8, "ACER Veriton", ALC662_FIXUP_ACER_VERITON),
12984 	SND_PCI_QUIRK(0x1b35, 0x1234, "CZC ET26", ALC662_FIXUP_CZC_ET26),
12985 	SND_PCI_QUIRK(0x1b35, 0x2206, "CZC P10T", ALC662_FIXUP_CZC_P10T),
12986 	SND_PCI_QUIRK(0x1c6c, 0x1239, "Compaq N14JP6-V2", ALC897_FIXUP_HP_HSMIC_VERB),
12987 
12988 #if 0
12989 	/* Below is a quirk table taken from the old code.
12990 	 * Basically the device should work as is without the fixup table.
12991 	 * If BIOS doesn't give a proper info, enable the corresponding
12992 	 * fixup entry.
12993 	 */
12994 	SND_PCI_QUIRK(0x1043, 0x1000, "ASUS N50Vm", ALC662_FIXUP_ASUS_MODE1),
12995 	SND_PCI_QUIRK(0x1043, 0x1092, "ASUS NB", ALC662_FIXUP_ASUS_MODE3),
12996 	SND_PCI_QUIRK(0x1043, 0x1173, "ASUS K73Jn", ALC662_FIXUP_ASUS_MODE1),
12997 	SND_PCI_QUIRK(0x1043, 0x11c3, "ASUS M70V", ALC662_FIXUP_ASUS_MODE3),
12998 	SND_PCI_QUIRK(0x1043, 0x11d3, "ASUS NB", ALC662_FIXUP_ASUS_MODE1),
12999 	SND_PCI_QUIRK(0x1043, 0x11f3, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),
13000 	SND_PCI_QUIRK(0x1043, 0x1203, "ASUS NB", ALC662_FIXUP_ASUS_MODE1),
13001 	SND_PCI_QUIRK(0x1043, 0x1303, "ASUS G60J", ALC662_FIXUP_ASUS_MODE1),
13002 	SND_PCI_QUIRK(0x1043, 0x1333, "ASUS G60Jx", ALC662_FIXUP_ASUS_MODE1),
13003 	SND_PCI_QUIRK(0x1043, 0x1339, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),
13004 	SND_PCI_QUIRK(0x1043, 0x13e3, "ASUS N71JA", ALC662_FIXUP_ASUS_MODE7),
13005 	SND_PCI_QUIRK(0x1043, 0x1463, "ASUS N71", ALC662_FIXUP_ASUS_MODE7),
13006 	SND_PCI_QUIRK(0x1043, 0x14d3, "ASUS G72", ALC662_FIXUP_ASUS_MODE8),
13007 	SND_PCI_QUIRK(0x1043, 0x1563, "ASUS N90", ALC662_FIXUP_ASUS_MODE3),
13008 	SND_PCI_QUIRK(0x1043, 0x15d3, "ASUS N50SF F50SF", ALC662_FIXUP_ASUS_MODE1),
13009 	SND_PCI_QUIRK(0x1043, 0x16c3, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),
13010 	SND_PCI_QUIRK(0x1043, 0x16f3, "ASUS K40C K50C", ALC662_FIXUP_ASUS_MODE2),
13011 	SND_PCI_QUIRK(0x1043, 0x1733, "ASUS N81De", ALC662_FIXUP_ASUS_MODE1),
13012 	SND_PCI_QUIRK(0x1043, 0x1753, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),
13013 	SND_PCI_QUIRK(0x1043, 0x1763, "ASUS NB", ALC662_FIXUP_ASUS_MODE6),
13014 	SND_PCI_QUIRK(0x1043, 0x1765, "ASUS NB", ALC662_FIXUP_ASUS_MODE6),
13015 	SND_PCI_QUIRK(0x1043, 0x1783, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),
13016 	SND_PCI_QUIRK(0x1043, 0x1793, "ASUS F50GX", ALC662_FIXUP_ASUS_MODE1),
13017 	SND_PCI_QUIRK(0x1043, 0x17b3, "ASUS F70SL", ALC662_FIXUP_ASUS_MODE3),
13018 	SND_PCI_QUIRK(0x1043, 0x17f3, "ASUS X58LE", ALC662_FIXUP_ASUS_MODE2),
13019 	SND_PCI_QUIRK(0x1043, 0x1813, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),
13020 	SND_PCI_QUIRK(0x1043, 0x1823, "ASUS NB", ALC662_FIXUP_ASUS_MODE5),
13021 	SND_PCI_QUIRK(0x1043, 0x1833, "ASUS NB", ALC662_FIXUP_ASUS_MODE6),
13022 	SND_PCI_QUIRK(0x1043, 0x1843, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),
13023 	SND_PCI_QUIRK(0x1043, 0x1853, "ASUS F50Z", ALC662_FIXUP_ASUS_MODE1),
13024 	SND_PCI_QUIRK(0x1043, 0x1864, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),
13025 	SND_PCI_QUIRK(0x1043, 0x1876, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),
13026 	SND_PCI_QUIRK(0x1043, 0x1893, "ASUS M50Vm", ALC662_FIXUP_ASUS_MODE3),
13027 	SND_PCI_QUIRK(0x1043, 0x1894, "ASUS X55", ALC662_FIXUP_ASUS_MODE3),
13028 	SND_PCI_QUIRK(0x1043, 0x18b3, "ASUS N80Vc", ALC662_FIXUP_ASUS_MODE1),
13029 	SND_PCI_QUIRK(0x1043, 0x18c3, "ASUS VX5", ALC662_FIXUP_ASUS_MODE1),
13030 	SND_PCI_QUIRK(0x1043, 0x18d3, "ASUS N81Te", ALC662_FIXUP_ASUS_MODE1),
13031 	SND_PCI_QUIRK(0x1043, 0x18f3, "ASUS N505Tp", ALC662_FIXUP_ASUS_MODE1),
13032 	SND_PCI_QUIRK(0x1043, 0x1903, "ASUS F5GL", ALC662_FIXUP_ASUS_MODE1),
13033 	SND_PCI_QUIRK(0x1043, 0x1913, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),
13034 	SND_PCI_QUIRK(0x1043, 0x1933, "ASUS F80Q", ALC662_FIXUP_ASUS_MODE2),
13035 	SND_PCI_QUIRK(0x1043, 0x1943, "ASUS Vx3V", ALC662_FIXUP_ASUS_MODE1),
13036 	SND_PCI_QUIRK(0x1043, 0x1953, "ASUS NB", ALC662_FIXUP_ASUS_MODE1),
13037 	SND_PCI_QUIRK(0x1043, 0x1963, "ASUS X71C", ALC662_FIXUP_ASUS_MODE3),
13038 	SND_PCI_QUIRK(0x1043, 0x1983, "ASUS N5051A", ALC662_FIXUP_ASUS_MODE1),
13039 	SND_PCI_QUIRK(0x1043, 0x1993, "ASUS N20", ALC662_FIXUP_ASUS_MODE1),
13040 	SND_PCI_QUIRK(0x1043, 0x19b3, "ASUS F7Z", ALC662_FIXUP_ASUS_MODE1),
13041 	SND_PCI_QUIRK(0x1043, 0x19c3, "ASUS F5Z/F6x", ALC662_FIXUP_ASUS_MODE2),
13042 	SND_PCI_QUIRK(0x1043, 0x19e3, "ASUS NB", ALC662_FIXUP_ASUS_MODE1),
13043 	SND_PCI_QUIRK(0x1043, 0x19f3, "ASUS NB", ALC662_FIXUP_ASUS_MODE4),
13044 #endif
13045 	{}
13046 };
13047 
13048 static const struct hda_model_fixup alc662_fixup_models[] = {
13049 	{.id = ALC662_FIXUP_ASPIRE, .name = "aspire"},
13050 	{.id = ALC662_FIXUP_IDEAPAD, .name = "ideapad"},
13051 	{.id = ALC272_FIXUP_MARIO, .name = "mario"},
13052 	{.id = ALC662_FIXUP_HP_RP5800, .name = "hp-rp5800"},
13053 	{.id = ALC662_FIXUP_ASUS_MODE1, .name = "asus-mode1"},
13054 	{.id = ALC662_FIXUP_ASUS_MODE2, .name = "asus-mode2"},
13055 	{.id = ALC662_FIXUP_ASUS_MODE3, .name = "asus-mode3"},
13056 	{.id = ALC662_FIXUP_ASUS_MODE4, .name = "asus-mode4"},
13057 	{.id = ALC662_FIXUP_ASUS_MODE5, .name = "asus-mode5"},
13058 	{.id = ALC662_FIXUP_ASUS_MODE6, .name = "asus-mode6"},
13059 	{.id = ALC662_FIXUP_ASUS_MODE7, .name = "asus-mode7"},
13060 	{.id = ALC662_FIXUP_ASUS_MODE8, .name = "asus-mode8"},
13061 	{.id = ALC662_FIXUP_ZOTAC_Z68, .name = "zotac-z68"},
13062 	{.id = ALC662_FIXUP_INV_DMIC, .name = "inv-dmic"},
13063 	{.id = ALC662_FIXUP_DELL_MIC_NO_PRESENCE, .name = "alc662-headset-multi"},
13064 	{.id = ALC668_FIXUP_DELL_MIC_NO_PRESENCE, .name = "dell-headset-multi"},
13065 	{.id = ALC662_FIXUP_HEADSET_MODE, .name = "alc662-headset"},
13066 	{.id = ALC668_FIXUP_HEADSET_MODE, .name = "alc668-headset"},
13067 	{.id = ALC662_FIXUP_BASS_16, .name = "bass16"},
13068 	{.id = ALC662_FIXUP_BASS_1A, .name = "bass1a"},
13069 	{.id = ALC668_FIXUP_AUTO_MUTE, .name = "automute"},
13070 	{.id = ALC668_FIXUP_DELL_XPS13, .name = "dell-xps13"},
13071 	{.id = ALC662_FIXUP_ASUS_Nx50, .name = "asus-nx50"},
13072 	{.id = ALC668_FIXUP_ASUS_Nx51, .name = "asus-nx51"},
13073 	{.id = ALC668_FIXUP_ASUS_G751, .name = "asus-g751"},
13074 	{.id = ALC891_FIXUP_HEADSET_MODE, .name = "alc891-headset"},
13075 	{.id = ALC891_FIXUP_DELL_MIC_NO_PRESENCE, .name = "alc891-headset-multi"},
13076 	{.id = ALC662_FIXUP_ACER_VERITON, .name = "acer-veriton"},
13077 	{.id = ALC892_FIXUP_ASROCK_MOBO, .name = "asrock-mobo"},
13078 	{.id = ALC662_FIXUP_USI_HEADSET_MODE, .name = "usi-headset"},
13079 	{.id = ALC662_FIXUP_LENOVO_MULTI_CODECS, .name = "dual-codecs"},
13080 	{.id = ALC669_FIXUP_ACER_ASPIRE_ETHOS, .name = "aspire-ethos"},
13081 	{.id = ALC897_FIXUP_UNIS_H3C_X500S, .name = "unis-h3c-x500s"},
13082 	{}
13083 };
13084 
13085 static const struct snd_hda_pin_quirk alc662_pin_fixup_tbl[] = {
13086 	SND_HDA_PIN_QUIRK(0x10ec0867, 0x1028, "Dell", ALC891_FIXUP_DELL_MIC_NO_PRESENCE,
13087 		{0x17, 0x02211010},
13088 		{0x18, 0x01a19030},
13089 		{0x1a, 0x01813040},
13090 		{0x21, 0x01014020}),
13091 	SND_HDA_PIN_QUIRK(0x10ec0867, 0x1028, "Dell", ALC891_FIXUP_DELL_MIC_NO_PRESENCE,
13092 		{0x16, 0x01813030},
13093 		{0x17, 0x02211010},
13094 		{0x18, 0x01a19040},
13095 		{0x21, 0x01014020}),
13096 	SND_HDA_PIN_QUIRK(0x10ec0662, 0x1028, "Dell", ALC662_FIXUP_DELL_MIC_NO_PRESENCE,
13097 		{0x14, 0x01014010},
13098 		{0x18, 0x01a19020},
13099 		{0x1a, 0x0181302f},
13100 		{0x1b, 0x0221401f}),
13101 	SND_HDA_PIN_QUIRK(0x10ec0668, 0x1028, "Dell", ALC668_FIXUP_AUTO_MUTE,
13102 		{0x12, 0x99a30130},
13103 		{0x14, 0x90170110},
13104 		{0x15, 0x0321101f},
13105 		{0x16, 0x03011020}),
13106 	SND_HDA_PIN_QUIRK(0x10ec0668, 0x1028, "Dell", ALC668_FIXUP_AUTO_MUTE,
13107 		{0x12, 0x99a30140},
13108 		{0x14, 0x90170110},
13109 		{0x15, 0x0321101f},
13110 		{0x16, 0x03011020}),
13111 	SND_HDA_PIN_QUIRK(0x10ec0668, 0x1028, "Dell", ALC668_FIXUP_AUTO_MUTE,
13112 		{0x12, 0x99a30150},
13113 		{0x14, 0x90170110},
13114 		{0x15, 0x0321101f},
13115 		{0x16, 0x03011020}),
13116 	SND_HDA_PIN_QUIRK(0x10ec0668, 0x1028, "Dell", ALC668_FIXUP_AUTO_MUTE,
13117 		{0x14, 0x90170110},
13118 		{0x15, 0x0321101f},
13119 		{0x16, 0x03011020}),
13120 	SND_HDA_PIN_QUIRK(0x10ec0668, 0x1028, "Dell XPS 15", ALC668_FIXUP_AUTO_MUTE,
13121 		{0x12, 0x90a60130},
13122 		{0x14, 0x90170110},
13123 		{0x15, 0x0321101f}),
13124 	SND_HDA_PIN_QUIRK(0x10ec0671, 0x103c, "HP cPC", ALC671_FIXUP_HP_HEADSET_MIC2,
13125 		{0x14, 0x01014010},
13126 		{0x17, 0x90170150},
13127 		{0x19, 0x02a11060},
13128 		{0x1b, 0x01813030},
13129 		{0x21, 0x02211020}),
13130 	SND_HDA_PIN_QUIRK(0x10ec0671, 0x103c, "HP cPC", ALC671_FIXUP_HP_HEADSET_MIC2,
13131 		{0x14, 0x01014010},
13132 		{0x18, 0x01a19040},
13133 		{0x1b, 0x01813030},
13134 		{0x21, 0x02211020}),
13135 	SND_HDA_PIN_QUIRK(0x10ec0671, 0x103c, "HP cPC", ALC671_FIXUP_HP_HEADSET_MIC2,
13136 		{0x14, 0x01014020},
13137 		{0x17, 0x90170110},
13138 		{0x18, 0x01a19050},
13139 		{0x1b, 0x01813040},
13140 		{0x21, 0x02211030}),
13141 	{}
13142 };
13143 
13144 /*
13145  */
13146 static int patch_alc662(struct hda_codec *codec)
13147 {
13148 	struct alc_spec *spec;
13149 	int err;
13150 
13151 	err = alc_alloc_spec(codec, 0x0b);
13152 	if (err < 0)
13153 		return err;
13154 
13155 	spec = codec->spec;
13156 
13157 	spec->shutup = alc_eapd_shutup;
13158 
13159 	/* handle multiple HPs as is */
13160 	spec->parse_flags = HDA_PINCFG_NO_HP_FIXUP;
13161 
13162 	alc_fix_pll_init(codec, 0x20, 0x04, 15);
13163 
13164 	switch (codec->core.vendor_id) {
13165 	case 0x10ec0668:
13166 		spec->init_hook = alc668_restore_default_value;
13167 		break;
13168 	}
13169 
13170 	alc_pre_init(codec);
13171 
13172 	snd_hda_pick_fixup(codec, alc662_fixup_models,
13173 		       alc662_fixup_tbl, alc662_fixups);
13174 	snd_hda_pick_pin_fixup(codec, alc662_pin_fixup_tbl, alc662_fixups, true);
13175 	snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE);
13176 
13177 	alc_auto_parse_customize_define(codec);
13178 
13179 	if (has_cdefine_beep(codec))
13180 		spec->gen.beep_nid = 0x01;
13181 
13182 	if ((alc_get_coef0(codec) & (1 << 14)) &&
13183 	    codec->bus->pci && codec->bus->pci->subsystem_vendor == 0x1025 &&
13184 	    spec->cdefine.platform_type == 1) {
13185 		err = alc_codec_rename(codec, "ALC272X");
13186 		if (err < 0)
13187 			goto error;
13188 	}
13189 
13190 	/* automatic parse from the BIOS config */
13191 	err = alc662_parse_auto_config(codec);
13192 	if (err < 0)
13193 		goto error;
13194 
13195 	if (!spec->gen.no_analog && spec->gen.beep_nid) {
13196 		switch (codec->core.vendor_id) {
13197 		case 0x10ec0662:
13198 			err = set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
13199 			break;
13200 		case 0x10ec0272:
13201 		case 0x10ec0663:
13202 		case 0x10ec0665:
13203 		case 0x10ec0668:
13204 			err = set_beep_amp(spec, 0x0b, 0x04, HDA_INPUT);
13205 			break;
13206 		case 0x10ec0273:
13207 			err = set_beep_amp(spec, 0x0b, 0x03, HDA_INPUT);
13208 			break;
13209 		}
13210 		if (err < 0)
13211 			goto error;
13212 	}
13213 
13214 	snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE);
13215 
13216 	return 0;
13217 
13218  error:
13219 	alc_free(codec);
13220 	return err;
13221 }
13222 
13223 /*
13224  * ALC680 support
13225  */
13226 
13227 static int alc680_parse_auto_config(struct hda_codec *codec)
13228 {
13229 	return alc_parse_auto_config(codec, NULL, NULL);
13230 }
13231 
13232 /*
13233  */
13234 static int patch_alc680(struct hda_codec *codec)
13235 {
13236 	int err;
13237 
13238 	/* ALC680 has no aa-loopback mixer */
13239 	err = alc_alloc_spec(codec, 0);
13240 	if (err < 0)
13241 		return err;
13242 
13243 	/* automatic parse from the BIOS config */
13244 	err = alc680_parse_auto_config(codec);
13245 	if (err < 0) {
13246 		alc_free(codec);
13247 		return err;
13248 	}
13249 
13250 	return 0;
13251 }
13252 
13253 /*
13254  * patch entries
13255  */
13256 static const struct hda_device_id snd_hda_id_realtek[] = {
13257 	HDA_CODEC_ENTRY(0x10ec0215, "ALC215", patch_alc269),
13258 	HDA_CODEC_ENTRY(0x10ec0221, "ALC221", patch_alc269),
13259 	HDA_CODEC_ENTRY(0x10ec0222, "ALC222", patch_alc269),
13260 	HDA_CODEC_ENTRY(0x10ec0225, "ALC225", patch_alc269),
13261 	HDA_CODEC_ENTRY(0x10ec0230, "ALC236", patch_alc269),
13262 	HDA_CODEC_ENTRY(0x10ec0231, "ALC231", patch_alc269),
13263 	HDA_CODEC_ENTRY(0x10ec0233, "ALC233", patch_alc269),
13264 	HDA_CODEC_ENTRY(0x10ec0234, "ALC234", patch_alc269),
13265 	HDA_CODEC_ENTRY(0x10ec0235, "ALC233", patch_alc269),
13266 	HDA_CODEC_ENTRY(0x10ec0236, "ALC236", patch_alc269),
13267 	HDA_CODEC_ENTRY(0x10ec0245, "ALC245", patch_alc269),
13268 	HDA_CODEC_ENTRY(0x10ec0255, "ALC255", patch_alc269),
13269 	HDA_CODEC_ENTRY(0x10ec0256, "ALC256", patch_alc269),
13270 	HDA_CODEC_ENTRY(0x10ec0257, "ALC257", patch_alc269),
13271 	HDA_CODEC_ENTRY(0x10ec0260, "ALC260", patch_alc260),
13272 	HDA_CODEC_ENTRY(0x10ec0262, "ALC262", patch_alc262),
13273 	HDA_CODEC_ENTRY(0x10ec0267, "ALC267", patch_alc268),
13274 	HDA_CODEC_ENTRY(0x10ec0268, "ALC268", patch_alc268),
13275 	HDA_CODEC_ENTRY(0x10ec0269, "ALC269", patch_alc269),
13276 	HDA_CODEC_ENTRY(0x10ec0270, "ALC270", patch_alc269),
13277 	HDA_CODEC_ENTRY(0x10ec0272, "ALC272", patch_alc662),
13278 	HDA_CODEC_ENTRY(0x10ec0274, "ALC274", patch_alc269),
13279 	HDA_CODEC_ENTRY(0x10ec0275, "ALC275", patch_alc269),
13280 	HDA_CODEC_ENTRY(0x10ec0276, "ALC276", patch_alc269),
13281 	HDA_CODEC_ENTRY(0x10ec0280, "ALC280", patch_alc269),
13282 	HDA_CODEC_ENTRY(0x10ec0282, "ALC282", patch_alc269),
13283 	HDA_CODEC_ENTRY(0x10ec0283, "ALC283", patch_alc269),
13284 	HDA_CODEC_ENTRY(0x10ec0284, "ALC284", patch_alc269),
13285 	HDA_CODEC_ENTRY(0x10ec0285, "ALC285", patch_alc269),
13286 	HDA_CODEC_ENTRY(0x10ec0286, "ALC286", patch_alc269),
13287 	HDA_CODEC_ENTRY(0x10ec0287, "ALC287", patch_alc269),
13288 	HDA_CODEC_ENTRY(0x10ec0288, "ALC288", patch_alc269),
13289 	HDA_CODEC_ENTRY(0x10ec0289, "ALC289", patch_alc269),
13290 	HDA_CODEC_ENTRY(0x10ec0290, "ALC290", patch_alc269),
13291 	HDA_CODEC_ENTRY(0x10ec0292, "ALC292", patch_alc269),
13292 	HDA_CODEC_ENTRY(0x10ec0293, "ALC293", patch_alc269),
13293 	HDA_CODEC_ENTRY(0x10ec0294, "ALC294", patch_alc269),
13294 	HDA_CODEC_ENTRY(0x10ec0295, "ALC295", patch_alc269),
13295 	HDA_CODEC_ENTRY(0x10ec0298, "ALC298", patch_alc269),
13296 	HDA_CODEC_ENTRY(0x10ec0299, "ALC299", patch_alc269),
13297 	HDA_CODEC_ENTRY(0x10ec0300, "ALC300", patch_alc269),
13298 	HDA_CODEC_ENTRY(0x10ec0623, "ALC623", patch_alc269),
13299 	HDA_CODEC_REV_ENTRY(0x10ec0861, 0x100340, "ALC660", patch_alc861),
13300 	HDA_CODEC_ENTRY(0x10ec0660, "ALC660-VD", patch_alc861vd),
13301 	HDA_CODEC_ENTRY(0x10ec0861, "ALC861", patch_alc861),
13302 	HDA_CODEC_ENTRY(0x10ec0862, "ALC861-VD", patch_alc861vd),
13303 	HDA_CODEC_REV_ENTRY(0x10ec0662, 0x100002, "ALC662 rev2", patch_alc882),
13304 	HDA_CODEC_REV_ENTRY(0x10ec0662, 0x100101, "ALC662 rev1", patch_alc662),
13305 	HDA_CODEC_REV_ENTRY(0x10ec0662, 0x100300, "ALC662 rev3", patch_alc662),
13306 	HDA_CODEC_ENTRY(0x10ec0663, "ALC663", patch_alc662),
13307 	HDA_CODEC_ENTRY(0x10ec0665, "ALC665", patch_alc662),
13308 	HDA_CODEC_ENTRY(0x10ec0667, "ALC667", patch_alc662),
13309 	HDA_CODEC_ENTRY(0x10ec0668, "ALC668", patch_alc662),
13310 	HDA_CODEC_ENTRY(0x10ec0670, "ALC670", patch_alc662),
13311 	HDA_CODEC_ENTRY(0x10ec0671, "ALC671", patch_alc662),
13312 	HDA_CODEC_ENTRY(0x10ec0680, "ALC680", patch_alc680),
13313 	HDA_CODEC_ENTRY(0x10ec0700, "ALC700", patch_alc269),
13314 	HDA_CODEC_ENTRY(0x10ec0701, "ALC701", patch_alc269),
13315 	HDA_CODEC_ENTRY(0x10ec0703, "ALC703", patch_alc269),
13316 	HDA_CODEC_ENTRY(0x10ec0711, "ALC711", patch_alc269),
13317 	HDA_CODEC_ENTRY(0x10ec0867, "ALC891", patch_alc662),
13318 	HDA_CODEC_ENTRY(0x10ec0880, "ALC880", patch_alc880),
13319 	HDA_CODEC_ENTRY(0x10ec0882, "ALC882", patch_alc882),
13320 	HDA_CODEC_ENTRY(0x10ec0883, "ALC883", patch_alc882),
13321 	HDA_CODEC_REV_ENTRY(0x10ec0885, 0x100101, "ALC889A", patch_alc882),
13322 	HDA_CODEC_REV_ENTRY(0x10ec0885, 0x100103, "ALC889A", patch_alc882),
13323 	HDA_CODEC_ENTRY(0x10ec0885, "ALC885", patch_alc882),
13324 	HDA_CODEC_ENTRY(0x10ec0887, "ALC887", patch_alc882),
13325 	HDA_CODEC_REV_ENTRY(0x10ec0888, 0x100101, "ALC1200", patch_alc882),
13326 	HDA_CODEC_ENTRY(0x10ec0888, "ALC888", patch_alc882),
13327 	HDA_CODEC_ENTRY(0x10ec0889, "ALC889", patch_alc882),
13328 	HDA_CODEC_ENTRY(0x10ec0892, "ALC892", patch_alc662),
13329 	HDA_CODEC_ENTRY(0x10ec0897, "ALC897", patch_alc662),
13330 	HDA_CODEC_ENTRY(0x10ec0899, "ALC898", patch_alc882),
13331 	HDA_CODEC_ENTRY(0x10ec0900, "ALC1150", patch_alc882),
13332 	HDA_CODEC_ENTRY(0x10ec0b00, "ALCS1200A", patch_alc882),
13333 	HDA_CODEC_ENTRY(0x10ec1168, "ALC1220", patch_alc882),
13334 	HDA_CODEC_ENTRY(0x10ec1220, "ALC1220", patch_alc882),
13335 	HDA_CODEC_ENTRY(0x19e58326, "HW8326", patch_alc269),
13336 	{} /* terminator */
13337 };
13338 MODULE_DEVICE_TABLE(hdaudio, snd_hda_id_realtek);
13339 
13340 MODULE_LICENSE("GPL");
13341 MODULE_DESCRIPTION("Realtek HD-audio codec");
13342 MODULE_IMPORT_NS(SND_HDA_SCODEC_COMPONENT);
13343 
13344 static struct hda_codec_driver realtek_driver = {
13345 	.id = snd_hda_id_realtek,
13346 };
13347 
13348 module_hda_codec_driver(realtek_driver);
13349