xref: /linux/sound/pci/hda/patch_realtek.c (revision 2a405b36a6418e9a9e07314c90c14ebe370ed79b)
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 
coef_mutex_lock(struct hda_codec * codec)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 
coef_mutex_unlock(struct hda_codec * codec)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 
__alc_read_coefex_idx(struct hda_codec * codec,hda_nid_t nid,unsigned int coef_idx)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 
alc_read_coefex_idx(struct hda_codec * codec,hda_nid_t nid,unsigned int coef_idx)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 
__alc_write_coefex_idx(struct hda_codec * codec,hda_nid_t nid,unsigned int coef_idx,unsigned int coef_val)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 
alc_write_coefex_idx(struct hda_codec * codec,hda_nid_t nid,unsigned int coef_idx,unsigned int coef_val)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 
__alc_update_coefex_idx(struct hda_codec * codec,hda_nid_t nid,unsigned int coef_idx,unsigned int mask,unsigned int bits_set)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 
alc_update_coefex_idx(struct hda_codec * codec,hda_nid_t nid,unsigned int coef_idx,unsigned int mask,unsigned int bits_set)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 */
alc_get_coef0(struct hda_codec * codec)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 
alc_process_coef_fw(struct hda_codec * codec,const struct coef_fw * fw)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 */
alc_setup_gpio(struct hda_codec * codec,unsigned int mask)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 
alc_write_gpio_data(struct hda_codec * codec)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 
alc_update_gpio_data(struct hda_codec * codec,unsigned int mask,bool on)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 
alc_write_gpio(struct hda_codec * codec)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 
alc_fixup_gpio(struct hda_codec * codec,int action,unsigned int mask)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 
alc_fixup_gpio1(struct hda_codec * codec,const struct hda_fixup * fix,int action)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 
alc_fixup_gpio2(struct hda_codec * codec,const struct hda_fixup * fix,int action)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 
alc_fixup_gpio3(struct hda_codec * codec,const struct hda_fixup * fix,int action)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 
alc_fixup_gpio4(struct hda_codec * codec,const struct hda_fixup * fix,int action)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 
alc_fixup_micmute_led(struct hda_codec * codec,const struct hda_fixup * fix,int action)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  */
alc_fix_pll(struct hda_codec * codec)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 
alc_fix_pll_init(struct hda_codec * codec,hda_nid_t nid,unsigned int coef_idx,unsigned int coef_bit)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 */
alc_update_knob_master(struct hda_codec * codec,struct hda_jack_callback * jack)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 
alc880_unsol_event(struct hda_codec * codec,unsigned int res)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 */
alc_fill_eapd_coef(struct hda_codec * codec)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 		alc_write_coef_idx(codec, 0x6e, 0x0c25);
477 		fallthrough;
478 	case 0x10ec0294:
479 	case 0x10ec0700:
480 	case 0x10ec0701:
481 	case 0x10ec0703:
482 	case 0x10ec0711:
483 		alc_update_coef_idx(codec, 0x10, 1<<15, 0);
484 		break;
485 	case 0x10ec0662:
486 		if ((coef & 0x00f0) == 0x0030)
487 			alc_update_coef_idx(codec, 0x4, 1<<10, 0); /* EAPD Ctrl */
488 		break;
489 	case 0x10ec0272:
490 	case 0x10ec0273:
491 	case 0x10ec0663:
492 	case 0x10ec0665:
493 	case 0x10ec0670:
494 	case 0x10ec0671:
495 	case 0x10ec0672:
496 		alc_update_coef_idx(codec, 0xd, 0, 1<<14); /* EAPD Ctrl */
497 		break;
498 	case 0x10ec0222:
499 	case 0x10ec0623:
500 		alc_update_coef_idx(codec, 0x19, 1<<13, 0);
501 		break;
502 	case 0x10ec0668:
503 		alc_update_coef_idx(codec, 0x7, 3<<13, 0);
504 		break;
505 	case 0x10ec0867:
506 		alc_update_coef_idx(codec, 0x4, 1<<10, 0);
507 		break;
508 	case 0x10ec0888:
509 		if ((coef & 0x00f0) == 0x0020 || (coef & 0x00f0) == 0x0030)
510 			alc_update_coef_idx(codec, 0x7, 1<<5, 0);
511 		break;
512 	case 0x10ec0892:
513 	case 0x10ec0897:
514 		alc_update_coef_idx(codec, 0x7, 1<<5, 0);
515 		break;
516 	case 0x10ec0899:
517 	case 0x10ec0900:
518 	case 0x10ec0b00:
519 	case 0x10ec1168:
520 	case 0x10ec1220:
521 		alc_update_coef_idx(codec, 0x7, 1<<1, 0);
522 		break;
523 	}
524 }
525 
526 /* additional initialization for ALC888 variants */
alc888_coef_init(struct hda_codec * codec)527 static void alc888_coef_init(struct hda_codec *codec)
528 {
529 	switch (alc_get_coef0(codec) & 0x00f0) {
530 	/* alc888-VA */
531 	case 0x00:
532 	/* alc888-VB */
533 	case 0x10:
534 		alc_update_coef_idx(codec, 7, 0, 0x2030); /* Turn EAPD to High */
535 		break;
536 	}
537 }
538 
539 /* turn on/off EAPD control (only if available) */
set_eapd(struct hda_codec * codec,hda_nid_t nid,int on)540 static void set_eapd(struct hda_codec *codec, hda_nid_t nid, int on)
541 {
542 	if (get_wcaps_type(get_wcaps(codec, nid)) != AC_WID_PIN)
543 		return;
544 	if (snd_hda_query_pin_caps(codec, nid) & AC_PINCAP_EAPD)
545 		snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_EAPD_BTLENABLE,
546 				    on ? 2 : 0);
547 }
548 
549 /* turn on/off EAPD controls of the codec */
alc_auto_setup_eapd(struct hda_codec * codec,bool on)550 static void alc_auto_setup_eapd(struct hda_codec *codec, bool on)
551 {
552 	/* We currently only handle front, HP */
553 	static const hda_nid_t pins[] = {
554 		0x0f, 0x10, 0x14, 0x15, 0x17, 0
555 	};
556 	const hda_nid_t *p;
557 	for (p = pins; *p; p++)
558 		set_eapd(codec, *p, on);
559 }
560 
561 static int find_ext_mic_pin(struct hda_codec *codec);
562 
alc_headset_mic_no_shutup(struct hda_codec * codec)563 static void alc_headset_mic_no_shutup(struct hda_codec *codec)
564 {
565 	const struct hda_pincfg *pin;
566 	int mic_pin = find_ext_mic_pin(codec);
567 	int i;
568 
569 	/* don't shut up pins when unloading the driver; otherwise it breaks
570 	 * the default pin setup at the next load of the driver
571 	 */
572 	if (codec->bus->shutdown)
573 		return;
574 
575 	snd_array_for_each(&codec->init_pins, i, pin) {
576 		/* use read here for syncing after issuing each verb */
577 		if (pin->nid != mic_pin)
578 			snd_hda_codec_read(codec, pin->nid, 0,
579 					AC_VERB_SET_PIN_WIDGET_CONTROL, 0);
580 	}
581 
582 	codec->pins_shutup = 1;
583 }
584 
alc_shutup_pins(struct hda_codec * codec)585 static void alc_shutup_pins(struct hda_codec *codec)
586 {
587 	struct alc_spec *spec = codec->spec;
588 
589 	switch (codec->core.vendor_id) {
590 	case 0x10ec0236:
591 	case 0x10ec0256:
592 	case 0x10ec0257:
593 	case 0x19e58326:
594 	case 0x10ec0283:
595 	case 0x10ec0285:
596 	case 0x10ec0286:
597 	case 0x10ec0287:
598 	case 0x10ec0288:
599 	case 0x10ec0295:
600 	case 0x10ec0298:
601 		alc_headset_mic_no_shutup(codec);
602 		break;
603 	default:
604 		if (!spec->no_shutup_pins)
605 			snd_hda_shutup_pins(codec);
606 		break;
607 	}
608 }
609 
610 /* generic shutup callback;
611  * just turning off EAPD and a little pause for avoiding pop-noise
612  */
alc_eapd_shutup(struct hda_codec * codec)613 static void alc_eapd_shutup(struct hda_codec *codec)
614 {
615 	struct alc_spec *spec = codec->spec;
616 
617 	alc_auto_setup_eapd(codec, false);
618 	if (!spec->no_depop_delay)
619 		msleep(200);
620 	alc_shutup_pins(codec);
621 }
622 
623 /* generic EAPD initialization */
alc_auto_init_amp(struct hda_codec * codec,int type)624 static void alc_auto_init_amp(struct hda_codec *codec, int type)
625 {
626 	alc_auto_setup_eapd(codec, true);
627 	alc_write_gpio(codec);
628 	switch (type) {
629 	case ALC_INIT_DEFAULT:
630 		switch (codec->core.vendor_id) {
631 		case 0x10ec0260:
632 			alc_update_coefex_idx(codec, 0x1a, 7, 0, 0x2010);
633 			break;
634 		case 0x10ec0880:
635 		case 0x10ec0882:
636 		case 0x10ec0883:
637 		case 0x10ec0885:
638 			alc_update_coef_idx(codec, 7, 0, 0x2030);
639 			break;
640 		case 0x10ec0888:
641 			alc888_coef_init(codec);
642 			break;
643 		}
644 		break;
645 	}
646 }
647 
648 /* get a primary headphone pin if available */
alc_get_hp_pin(struct alc_spec * spec)649 static hda_nid_t alc_get_hp_pin(struct alc_spec *spec)
650 {
651 	if (spec->gen.autocfg.hp_pins[0])
652 		return spec->gen.autocfg.hp_pins[0];
653 	if (spec->gen.autocfg.line_out_type == AC_JACK_HP_OUT)
654 		return spec->gen.autocfg.line_out_pins[0];
655 	return 0;
656 }
657 
658 /*
659  * Realtek SSID verification
660  */
661 
662 /* Could be any non-zero and even value. When used as fixup, tells
663  * the driver to ignore any present sku defines.
664  */
665 #define ALC_FIXUP_SKU_IGNORE (2)
666 
alc_fixup_sku_ignore(struct hda_codec * codec,const struct hda_fixup * fix,int action)667 static void alc_fixup_sku_ignore(struct hda_codec *codec,
668 				 const struct hda_fixup *fix, int action)
669 {
670 	struct alc_spec *spec = codec->spec;
671 	if (action == HDA_FIXUP_ACT_PRE_PROBE) {
672 		spec->cdefine.fixup = 1;
673 		spec->cdefine.sku_cfg = ALC_FIXUP_SKU_IGNORE;
674 	}
675 }
676 
alc_fixup_no_depop_delay(struct hda_codec * codec,const struct hda_fixup * fix,int action)677 static void alc_fixup_no_depop_delay(struct hda_codec *codec,
678 				    const struct hda_fixup *fix, int action)
679 {
680 	struct alc_spec *spec = codec->spec;
681 
682 	if (action == HDA_FIXUP_ACT_PROBE) {
683 		spec->no_depop_delay = 1;
684 		codec->depop_delay = 0;
685 	}
686 }
687 
alc_auto_parse_customize_define(struct hda_codec * codec)688 static int alc_auto_parse_customize_define(struct hda_codec *codec)
689 {
690 	unsigned int ass, tmp, i;
691 	unsigned nid = 0;
692 	struct alc_spec *spec = codec->spec;
693 
694 	spec->cdefine.enable_pcbeep = 1; /* assume always enabled */
695 
696 	if (spec->cdefine.fixup) {
697 		ass = spec->cdefine.sku_cfg;
698 		if (ass == ALC_FIXUP_SKU_IGNORE)
699 			return -1;
700 		goto do_sku;
701 	}
702 
703 	if (!codec->bus->pci)
704 		return -1;
705 	ass = codec->core.subsystem_id & 0xffff;
706 	if (ass != codec->bus->pci->subsystem_device && (ass & 1))
707 		goto do_sku;
708 
709 	nid = 0x1d;
710 	if (codec->core.vendor_id == 0x10ec0260)
711 		nid = 0x17;
712 	ass = snd_hda_codec_get_pincfg(codec, nid);
713 
714 	if (!(ass & 1)) {
715 		codec_info(codec, "%s: SKU not ready 0x%08x\n",
716 			   codec->core.chip_name, ass);
717 		return -1;
718 	}
719 
720 	/* check sum */
721 	tmp = 0;
722 	for (i = 1; i < 16; i++) {
723 		if ((ass >> i) & 1)
724 			tmp++;
725 	}
726 	if (((ass >> 16) & 0xf) != tmp)
727 		return -1;
728 
729 	spec->cdefine.port_connectivity = ass >> 30;
730 	spec->cdefine.enable_pcbeep = (ass & 0x100000) >> 20;
731 	spec->cdefine.check_sum = (ass >> 16) & 0xf;
732 	spec->cdefine.customization = ass >> 8;
733 do_sku:
734 	spec->cdefine.sku_cfg = ass;
735 	spec->cdefine.external_amp = (ass & 0x38) >> 3;
736 	spec->cdefine.platform_type = (ass & 0x4) >> 2;
737 	spec->cdefine.swap = (ass & 0x2) >> 1;
738 	spec->cdefine.override = ass & 0x1;
739 
740 	codec_dbg(codec, "SKU: Nid=0x%x sku_cfg=0x%08x\n",
741 		   nid, spec->cdefine.sku_cfg);
742 	codec_dbg(codec, "SKU: port_connectivity=0x%x\n",
743 		   spec->cdefine.port_connectivity);
744 	codec_dbg(codec, "SKU: enable_pcbeep=0x%x\n", spec->cdefine.enable_pcbeep);
745 	codec_dbg(codec, "SKU: check_sum=0x%08x\n", spec->cdefine.check_sum);
746 	codec_dbg(codec, "SKU: customization=0x%08x\n", spec->cdefine.customization);
747 	codec_dbg(codec, "SKU: external_amp=0x%x\n", spec->cdefine.external_amp);
748 	codec_dbg(codec, "SKU: platform_type=0x%x\n", spec->cdefine.platform_type);
749 	codec_dbg(codec, "SKU: swap=0x%x\n", spec->cdefine.swap);
750 	codec_dbg(codec, "SKU: override=0x%x\n", spec->cdefine.override);
751 
752 	return 0;
753 }
754 
755 /* return the position of NID in the list, or -1 if not found */
find_idx_in_nid_list(hda_nid_t nid,const hda_nid_t * list,int nums)756 static int find_idx_in_nid_list(hda_nid_t nid, const hda_nid_t *list, int nums)
757 {
758 	int i;
759 	for (i = 0; i < nums; i++)
760 		if (list[i] == nid)
761 			return i;
762 	return -1;
763 }
764 /* return true if the given NID is found in the list */
found_in_nid_list(hda_nid_t nid,const hda_nid_t * list,int nums)765 static bool found_in_nid_list(hda_nid_t nid, const hda_nid_t *list, int nums)
766 {
767 	return find_idx_in_nid_list(nid, list, nums) >= 0;
768 }
769 
770 /* check subsystem ID and set up device-specific initialization;
771  * return 1 if initialized, 0 if invalid SSID
772  */
773 /* 32-bit subsystem ID for BIOS loading in HD Audio codec.
774  *	31 ~ 16 :	Manufacture ID
775  *	15 ~ 8	:	SKU ID
776  *	7  ~ 0	:	Assembly ID
777  *	port-A --> pin 39/41, port-E --> pin 14/15, port-D --> pin 35/36
778  */
alc_subsystem_id(struct hda_codec * codec,const hda_nid_t * ports)779 static int alc_subsystem_id(struct hda_codec *codec, const hda_nid_t *ports)
780 {
781 	unsigned int ass, tmp, i;
782 	unsigned nid;
783 	struct alc_spec *spec = codec->spec;
784 
785 	if (spec->cdefine.fixup) {
786 		ass = spec->cdefine.sku_cfg;
787 		if (ass == ALC_FIXUP_SKU_IGNORE)
788 			return 0;
789 		goto do_sku;
790 	}
791 
792 	ass = codec->core.subsystem_id & 0xffff;
793 	if (codec->bus->pci &&
794 	    ass != codec->bus->pci->subsystem_device && (ass & 1))
795 		goto do_sku;
796 
797 	/* invalid SSID, check the special NID pin defcfg instead */
798 	/*
799 	 * 31~30	: port connectivity
800 	 * 29~21	: reserve
801 	 * 20		: PCBEEP input
802 	 * 19~16	: Check sum (15:1)
803 	 * 15~1		: Custom
804 	 * 0		: override
805 	*/
806 	nid = 0x1d;
807 	if (codec->core.vendor_id == 0x10ec0260)
808 		nid = 0x17;
809 	ass = snd_hda_codec_get_pincfg(codec, nid);
810 	codec_dbg(codec,
811 		  "realtek: No valid SSID, checking pincfg 0x%08x for NID 0x%x\n",
812 		   ass, nid);
813 	if (!(ass & 1))
814 		return 0;
815 	if ((ass >> 30) != 1)	/* no physical connection */
816 		return 0;
817 
818 	/* check sum */
819 	tmp = 0;
820 	for (i = 1; i < 16; i++) {
821 		if ((ass >> i) & 1)
822 			tmp++;
823 	}
824 	if (((ass >> 16) & 0xf) != tmp)
825 		return 0;
826 do_sku:
827 	codec_dbg(codec, "realtek: Enabling init ASM_ID=0x%04x CODEC_ID=%08x\n",
828 		   ass & 0xffff, codec->core.vendor_id);
829 	/*
830 	 * 0 : override
831 	 * 1 :	Swap Jack
832 	 * 2 : 0 --> Desktop, 1 --> Laptop
833 	 * 3~5 : External Amplifier control
834 	 * 7~6 : Reserved
835 	*/
836 	tmp = (ass & 0x38) >> 3;	/* external Amp control */
837 	if (spec->init_amp == ALC_INIT_UNDEFINED) {
838 		switch (tmp) {
839 		case 1:
840 			alc_setup_gpio(codec, 0x01);
841 			break;
842 		case 3:
843 			alc_setup_gpio(codec, 0x02);
844 			break;
845 		case 7:
846 			alc_setup_gpio(codec, 0x04);
847 			break;
848 		case 5:
849 		default:
850 			spec->init_amp = ALC_INIT_DEFAULT;
851 			break;
852 		}
853 	}
854 
855 	/* is laptop or Desktop and enable the function "Mute internal speaker
856 	 * when the external headphone out jack is plugged"
857 	 */
858 	if (!(ass & 0x8000))
859 		return 1;
860 	/*
861 	 * 10~8 : Jack location
862 	 * 12~11: Headphone out -> 00: PortA, 01: PortE, 02: PortD, 03: Resvered
863 	 * 14~13: Resvered
864 	 * 15   : 1 --> enable the function "Mute internal speaker
865 	 *	        when the external headphone out jack is plugged"
866 	 */
867 	if (!alc_get_hp_pin(spec)) {
868 		hda_nid_t nid;
869 		tmp = (ass >> 11) & 0x3;	/* HP to chassis */
870 		nid = ports[tmp];
871 		if (found_in_nid_list(nid, spec->gen.autocfg.line_out_pins,
872 				      spec->gen.autocfg.line_outs))
873 			return 1;
874 		spec->gen.autocfg.hp_pins[0] = nid;
875 	}
876 	return 1;
877 }
878 
879 /* Check the validity of ALC subsystem-id
880  * ports contains an array of 4 pin NIDs for port-A, E, D and I */
alc_ssid_check(struct hda_codec * codec,const hda_nid_t * ports)881 static void alc_ssid_check(struct hda_codec *codec, const hda_nid_t *ports)
882 {
883 	if (!alc_subsystem_id(codec, ports)) {
884 		struct alc_spec *spec = codec->spec;
885 		if (spec->init_amp == ALC_INIT_UNDEFINED) {
886 			codec_dbg(codec,
887 				  "realtek: Enable default setup for auto mode as fallback\n");
888 			spec->init_amp = ALC_INIT_DEFAULT;
889 		}
890 	}
891 }
892 
893 /* inverted digital-mic */
alc_fixup_inv_dmic(struct hda_codec * codec,const struct hda_fixup * fix,int action)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 
alc_build_controls(struct hda_codec * codec)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 
alc_pre_init(struct hda_codec * codec)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 
alc_init(struct hda_codec * codec)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 
alc_free(struct hda_codec * codec)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 
alc_shutup(struct hda_codec * codec)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 
alc_power_eapd(struct hda_codec * codec)980 static void alc_power_eapd(struct hda_codec *codec)
981 {
982 	alc_auto_setup_eapd(codec, false);
983 }
984 
alc_suspend(struct hda_codec * codec)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 
alc_resume(struct hda_codec * codec)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 
alc_codec_rename_from_preset(struct hda_codec * codec)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 */
set_beep_amp(struct alc_spec * spec,hda_nid_t nid,int idx,int dir)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 
has_cdefine_beep(struct hda_codec * codec)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  */
alc_parse_auto_config(struct hda_codec * codec,const hda_nid_t * ignore_nids,const hda_nid_t * ssid_nids)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 */
alc_alloc_spec(struct hda_codec * codec,hda_nid_t mixer_nid)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 
alc880_parse_auto_config(struct hda_codec * codec)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 */
alc880_fixup_vol_knob(struct hda_codec * codec,const struct hda_fixup * fix,int action)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 hda_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  */
patch_alc880(struct hda_codec * codec)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  */
alc260_parse_auto_config(struct hda_codec * codec)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 
alc260_gpio1_automute(struct hda_codec * codec)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 
alc260_fixup_gpio1_toggle(struct hda_codec * codec,const struct hda_fixup * fix,int action)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 
alc260_fixup_kn1(struct hda_codec * codec,const struct hda_fixup * fix,int action)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 
alc260_fixup_fsc_s7020(struct hda_codec * codec,const struct hda_fixup * fix,int action)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 
alc260_fixup_fsc_s7020_jwse(struct hda_codec * codec,const struct hda_fixup * fix,int action)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 hda_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  */
patch_alc260(struct hda_codec * codec)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 
alc889_fixup_coef(struct hda_codec * codec,const struct hda_fixup * fix,int action)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 */
alc885_fixup_macpro_gpio(struct hda_codec * codec,const struct hda_fixup * fix,int action)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  */
alc889_fixup_dac_route(struct hda_codec * codec,const struct hda_fixup * fix,int action)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 */
alc889_fixup_mbp_vref(struct hda_codec * codec,const struct hda_fixup * fix,int action)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 
alc889_fixup_mac_pins(struct hda_codec * codec,const hda_nid_t * nids,int num_nids)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 */
alc889_fixup_imac91_vref(struct hda_codec * codec,const struct hda_fixup * fix,int action)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 */
alc889_fixup_mba11_vref(struct hda_codec * codec,const struct hda_fixup * fix,int action)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 */
alc889_fixup_mba21_vref(struct hda_codec * codec,const struct hda_fixup * fix,int action)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  */
alc882_fixup_no_primary_hp(struct hda_codec * codec,const struct hda_fixup * fix,int action)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  */
alc_fixup_dual_codecs(struct hda_codec * codec,const struct hda_fixup * fix,int action)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 
rename_ctl(struct hda_codec * codec,const char * oldname,const char * newname)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 
alc1220_fixup_gb_dual_codecs(struct hda_codec * codec,const struct hda_fixup * fix,int action)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 
alc1220_fixup_gb_x570(struct hda_codec * codec,const struct hda_fixup * fix,int action)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 
alc1220_fixup_clevo_p950(struct hda_codec * codec,const struct hda_fixup * fix,int action)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 
alc1220_fixup_clevo_pb51ed(struct hda_codec * codec,const struct hda_fixup * fix,int action)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 
alc887_asus_hp_automute_hook(struct hda_codec * codec,struct hda_jack_callback * jack)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 
alc887_fixup_asus_jack(struct hda_codec * codec,const struct hda_fixup * fix,int action)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 hda_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... */
alc882_parse_auto_config(struct hda_codec * codec)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  */
patch_alc882(struct hda_codec * codec)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  */
alc262_parse_auto_config(struct hda_codec * codec)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 hda_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  */
patch_alc262(struct hda_codec * codec)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 */
alc268_beep_switch_put(struct snd_kcontrol * kcontrol,struct snd_ctl_elem_value * ucontrol)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 hda_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  */
alc268_parse_auto_config(struct hda_codec * codec)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  */
patch_alc268(struct hda_codec * codec)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  */
alc269_parse_auto_config(struct hda_codec * codec)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 
alc_headset_btn_callback(struct hda_codec * codec,struct hda_jack_callback * jack)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 
alc_disable_headset_jack_key(struct hda_codec * codec)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 
alc_enable_headset_jack_key(struct hda_codec * codec)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 
alc_fixup_headset_jack(struct hda_codec * codec,const struct hda_fixup * fix,int action)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 
alc269vb_toggle_power_output(struct hda_codec * codec,int power_up)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 
alc269_shutup(struct hda_codec * codec)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 
alc282_restore_default_value(struct hda_codec * codec)3400 static void alc282_restore_default_value(struct hda_codec *codec)
3401 {
3402 	alc_process_coef_fw(codec, alc282_coefs);
3403 }
3404 
alc282_init(struct hda_codec * codec)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 
alc282_shutup(struct hda_codec * codec)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 
alc283_restore_default_value(struct hda_codec * codec)3516 static void alc283_restore_default_value(struct hda_codec *codec)
3517 {
3518 	alc_process_coef_fw(codec, alc283_coefs);
3519 }
3520 
alc283_init(struct hda_codec * codec)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 
alc283_shutup(struct hda_codec * codec)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 
alc256_init(struct hda_codec * codec)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 		alc_update_coefex_idx(codec, 0x57, 0x04, 0x0007, 0x1); /* Low power */
3619 
3620 		snd_hda_codec_write(codec, hp_pin, 0,
3621 			    AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT);
3622 
3623 		msleep(75);
3624 
3625 		snd_hda_codec_write(codec, hp_pin, 0,
3626 			    AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE);
3627 
3628 		msleep(75);
3629 		alc_update_coefex_idx(codec, 0x57, 0x04, 0x0007, 0x4); /* Hight power */
3630 	}
3631 	alc_update_coef_idx(codec, 0x46, 3 << 12, 0);
3632 	alc_update_coefex_idx(codec, 0x53, 0x02, 0x8000, 1 << 15); /* Clear bit */
3633 	alc_update_coefex_idx(codec, 0x53, 0x02, 0x8000, 0 << 15);
3634 	/*
3635 	 * Expose headphone mic (or possibly Line In on some machines) instead
3636 	 * of PC Beep on 1Ah, and disable 1Ah loopback for all outputs. See
3637 	 * Documentation/sound/hd-audio/realtek-pc-beep.rst for details of
3638 	 * this register.
3639 	 */
3640 	alc_write_coef_idx(codec, 0x36, 0x5757);
3641 }
3642 
alc256_shutup(struct hda_codec * codec)3643 static void alc256_shutup(struct hda_codec *codec)
3644 {
3645 	struct alc_spec *spec = codec->spec;
3646 	hda_nid_t hp_pin = alc_get_hp_pin(spec);
3647 	bool hp_pin_sense;
3648 
3649 	if (!hp_pin)
3650 		hp_pin = 0x21;
3651 
3652 	alc_update_coefex_idx(codec, 0x57, 0x04, 0x0007, 0x1); /* Low power */
3653 	hp_pin_sense = snd_hda_jack_detect(codec, hp_pin);
3654 
3655 	if (hp_pin_sense) {
3656 		msleep(2);
3657 
3658 		snd_hda_codec_write(codec, hp_pin, 0,
3659 			    AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);
3660 
3661 		msleep(75);
3662 
3663 	/* 3k pull low control for Headset jack. */
3664 	/* NOTE: call this before clearing the pin, otherwise codec stalls */
3665 	/* If disable 3k pulldown control for alc257, the Mic detection will not work correctly
3666 	 * when booting with headset plugged. So skip setting it for the codec alc257
3667 	 */
3668 		if (spec->en_3kpull_low)
3669 			alc_update_coef_idx(codec, 0x46, 0, 3 << 12);
3670 
3671 		if (!spec->no_shutup_pins)
3672 			snd_hda_codec_write(codec, hp_pin, 0,
3673 				    AC_VERB_SET_PIN_WIDGET_CONTROL, 0x0);
3674 
3675 		msleep(75);
3676 	}
3677 
3678 	alc_auto_setup_eapd(codec, false);
3679 	alc_shutup_pins(codec);
3680 	if (spec->ultra_low_power) {
3681 		msleep(50);
3682 		alc_update_coef_idx(codec, 0x03, 1<<1, 0);
3683 		alc_update_coef_idx(codec, 0x08, 7<<4, 7<<4);
3684 		alc_update_coef_idx(codec, 0x08, 3<<2, 0);
3685 		alc_update_coef_idx(codec, 0x3b, 1<<15, 1<<15);
3686 		alc_update_coef_idx(codec, 0x0e, 7<<6, 0);
3687 		msleep(30);
3688 	}
3689 }
3690 
alc285_hp_init(struct hda_codec * codec)3691 static void alc285_hp_init(struct hda_codec *codec)
3692 {
3693 	struct alc_spec *spec = codec->spec;
3694 	hda_nid_t hp_pin = alc_get_hp_pin(spec);
3695 	int i, val;
3696 	int coef38, coef0d, coef36;
3697 
3698 	alc_write_coefex_idx(codec, 0x58, 0x00, 0x1888); /* write default value */
3699 	alc_update_coef_idx(codec, 0x4a, 1<<15, 1<<15); /* Reset HP JD */
3700 	coef38 = alc_read_coef_idx(codec, 0x38); /* Amp control */
3701 	coef0d = alc_read_coef_idx(codec, 0x0d); /* Digital Misc control */
3702 	coef36 = alc_read_coef_idx(codec, 0x36); /* Passthrough Control */
3703 	alc_update_coef_idx(codec, 0x38, 1<<4, 0x0);
3704 	alc_update_coef_idx(codec, 0x0d, 0x110, 0x0);
3705 
3706 	alc_update_coef_idx(codec, 0x67, 0xf000, 0x3000);
3707 
3708 	if (hp_pin)
3709 		snd_hda_codec_write(codec, hp_pin, 0,
3710 			    AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);
3711 
3712 	msleep(130);
3713 	alc_update_coef_idx(codec, 0x36, 1<<14, 1<<14);
3714 	alc_update_coef_idx(codec, 0x36, 1<<13, 0x0);
3715 
3716 	if (hp_pin)
3717 		snd_hda_codec_write(codec, hp_pin, 0,
3718 			    AC_VERB_SET_PIN_WIDGET_CONTROL, 0x0);
3719 	msleep(10);
3720 	alc_write_coef_idx(codec, 0x67, 0x0); /* Set HP depop to manual mode */
3721 	alc_write_coefex_idx(codec, 0x58, 0x00, 0x7880);
3722 	alc_write_coefex_idx(codec, 0x58, 0x0f, 0xf049);
3723 	alc_update_coefex_idx(codec, 0x58, 0x03, 0x00f0, 0x00c0);
3724 
3725 	alc_write_coefex_idx(codec, 0x58, 0x00, 0xf888); /* HP depop procedure start */
3726 	val = alc_read_coefex_idx(codec, 0x58, 0x00);
3727 	for (i = 0; i < 20 && val & 0x8000; i++) {
3728 		msleep(50);
3729 		val = alc_read_coefex_idx(codec, 0x58, 0x00);
3730 	} /* Wait for depop procedure finish  */
3731 
3732 	alc_write_coefex_idx(codec, 0x58, 0x00, val); /* write back the result */
3733 	alc_update_coef_idx(codec, 0x38, 1<<4, coef38);
3734 	alc_update_coef_idx(codec, 0x0d, 0x110, coef0d);
3735 	alc_update_coef_idx(codec, 0x36, 3<<13, coef36);
3736 
3737 	msleep(50);
3738 	alc_update_coef_idx(codec, 0x4a, 1<<15, 0);
3739 }
3740 
alc225_init(struct hda_codec * codec)3741 static void alc225_init(struct hda_codec *codec)
3742 {
3743 	struct alc_spec *spec = codec->spec;
3744 	hda_nid_t hp_pin = alc_get_hp_pin(spec);
3745 	bool hp1_pin_sense, hp2_pin_sense;
3746 
3747 	if (spec->ultra_low_power) {
3748 		alc_update_coef_idx(codec, 0x08, 0x0f << 2, 3<<2);
3749 		alc_update_coef_idx(codec, 0x0e, 7<<6, 7<<6);
3750 		alc_update_coef_idx(codec, 0x33, 1<<11, 0);
3751 		msleep(30);
3752 	}
3753 
3754 	if (spec->codec_variant != ALC269_TYPE_ALC287 &&
3755 		spec->codec_variant != ALC269_TYPE_ALC245)
3756 		/* required only at boot or S3 and S4 resume time */
3757 		if (!spec->done_hp_init ||
3758 			is_s3_resume(codec) ||
3759 			is_s4_resume(codec)) {
3760 			alc285_hp_init(codec);
3761 			spec->done_hp_init = true;
3762 		}
3763 
3764 	if (!hp_pin)
3765 		hp_pin = 0x21;
3766 	msleep(30);
3767 
3768 	hp1_pin_sense = snd_hda_jack_detect(codec, hp_pin);
3769 	hp2_pin_sense = snd_hda_jack_detect(codec, 0x16);
3770 
3771 	if (hp1_pin_sense || hp2_pin_sense) {
3772 		msleep(2);
3773 		alc_update_coefex_idx(codec, 0x57, 0x04, 0x0007, 0x1); /* Low power */
3774 
3775 		if (hp1_pin_sense)
3776 			snd_hda_codec_write(codec, hp_pin, 0,
3777 				    AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT);
3778 		if (hp2_pin_sense)
3779 			snd_hda_codec_write(codec, 0x16, 0,
3780 				    AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT);
3781 		msleep(75);
3782 
3783 		if (hp1_pin_sense)
3784 			snd_hda_codec_write(codec, hp_pin, 0,
3785 				    AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE);
3786 		if (hp2_pin_sense)
3787 			snd_hda_codec_write(codec, 0x16, 0,
3788 				    AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE);
3789 
3790 		msleep(75);
3791 		alc_update_coef_idx(codec, 0x4a, 3 << 10, 0);
3792 		alc_update_coefex_idx(codec, 0x57, 0x04, 0x0007, 0x4); /* Hight power */
3793 	}
3794 }
3795 
alc225_shutup(struct hda_codec * codec)3796 static void alc225_shutup(struct hda_codec *codec)
3797 {
3798 	struct alc_spec *spec = codec->spec;
3799 	hda_nid_t hp_pin = alc_get_hp_pin(spec);
3800 	bool hp1_pin_sense, hp2_pin_sense;
3801 
3802 	if (!hp_pin)
3803 		hp_pin = 0x21;
3804 
3805 	hp1_pin_sense = snd_hda_jack_detect(codec, hp_pin);
3806 	hp2_pin_sense = snd_hda_jack_detect(codec, 0x16);
3807 
3808 	if (hp1_pin_sense || hp2_pin_sense) {
3809 		alc_disable_headset_jack_key(codec);
3810 		/* 3k pull low control for Headset jack. */
3811 		alc_update_coef_idx(codec, 0x4a, 0, 3 << 10);
3812 		msleep(2);
3813 
3814 		if (hp1_pin_sense)
3815 			snd_hda_codec_write(codec, hp_pin, 0,
3816 				    AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);
3817 		if (hp2_pin_sense)
3818 			snd_hda_codec_write(codec, 0x16, 0,
3819 				    AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);
3820 
3821 		msleep(75);
3822 
3823 		if (hp1_pin_sense)
3824 			snd_hda_codec_write(codec, hp_pin, 0,
3825 				    AC_VERB_SET_PIN_WIDGET_CONTROL, 0x0);
3826 		if (hp2_pin_sense)
3827 			snd_hda_codec_write(codec, 0x16, 0,
3828 				    AC_VERB_SET_PIN_WIDGET_CONTROL, 0x0);
3829 
3830 		msleep(75);
3831 		alc_update_coef_idx(codec, 0x4a, 3 << 10, 0);
3832 		alc_enable_headset_jack_key(codec);
3833 	}
3834 	alc_auto_setup_eapd(codec, false);
3835 	alc_shutup_pins(codec);
3836 	if (spec->ultra_low_power) {
3837 		msleep(50);
3838 		alc_update_coef_idx(codec, 0x08, 0x0f << 2, 0x0c << 2);
3839 		alc_update_coef_idx(codec, 0x0e, 7<<6, 0);
3840 		alc_update_coef_idx(codec, 0x33, 1<<11, 1<<11);
3841 		alc_update_coef_idx(codec, 0x4a, 3<<4, 2<<4);
3842 		msleep(30);
3843 	}
3844 }
3845 
alc222_init(struct hda_codec * codec)3846 static void alc222_init(struct hda_codec *codec)
3847 {
3848 	struct alc_spec *spec = codec->spec;
3849 	hda_nid_t hp_pin = alc_get_hp_pin(spec);
3850 	bool hp1_pin_sense, hp2_pin_sense;
3851 
3852 	if (!hp_pin)
3853 		return;
3854 
3855 	msleep(30);
3856 
3857 	hp1_pin_sense = snd_hda_jack_detect(codec, hp_pin);
3858 	hp2_pin_sense = snd_hda_jack_detect(codec, 0x14);
3859 
3860 	if (hp1_pin_sense || hp2_pin_sense) {
3861 		msleep(2);
3862 
3863 		if (hp1_pin_sense)
3864 			snd_hda_codec_write(codec, hp_pin, 0,
3865 				    AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT);
3866 		if (hp2_pin_sense)
3867 			snd_hda_codec_write(codec, 0x14, 0,
3868 				    AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT);
3869 		msleep(75);
3870 
3871 		if (hp1_pin_sense)
3872 			snd_hda_codec_write(codec, hp_pin, 0,
3873 				    AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE);
3874 		if (hp2_pin_sense)
3875 			snd_hda_codec_write(codec, 0x14, 0,
3876 				    AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE);
3877 
3878 		msleep(75);
3879 	}
3880 }
3881 
alc222_shutup(struct hda_codec * codec)3882 static void alc222_shutup(struct hda_codec *codec)
3883 {
3884 	struct alc_spec *spec = codec->spec;
3885 	hda_nid_t hp_pin = alc_get_hp_pin(spec);
3886 	bool hp1_pin_sense, hp2_pin_sense;
3887 
3888 	if (!hp_pin)
3889 		hp_pin = 0x21;
3890 
3891 	hp1_pin_sense = snd_hda_jack_detect(codec, hp_pin);
3892 	hp2_pin_sense = snd_hda_jack_detect(codec, 0x14);
3893 
3894 	if (hp1_pin_sense || hp2_pin_sense) {
3895 		msleep(2);
3896 
3897 		if (hp1_pin_sense)
3898 			snd_hda_codec_write(codec, hp_pin, 0,
3899 				    AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);
3900 		if (hp2_pin_sense)
3901 			snd_hda_codec_write(codec, 0x14, 0,
3902 				    AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);
3903 
3904 		msleep(75);
3905 
3906 		if (hp1_pin_sense)
3907 			snd_hda_codec_write(codec, hp_pin, 0,
3908 				    AC_VERB_SET_PIN_WIDGET_CONTROL, 0x0);
3909 		if (hp2_pin_sense)
3910 			snd_hda_codec_write(codec, 0x14, 0,
3911 				    AC_VERB_SET_PIN_WIDGET_CONTROL, 0x0);
3912 
3913 		msleep(75);
3914 	}
3915 	alc_auto_setup_eapd(codec, false);
3916 	alc_shutup_pins(codec);
3917 }
3918 
alc_default_init(struct hda_codec * codec)3919 static void alc_default_init(struct hda_codec *codec)
3920 {
3921 	struct alc_spec *spec = codec->spec;
3922 	hda_nid_t hp_pin = alc_get_hp_pin(spec);
3923 	bool hp_pin_sense;
3924 
3925 	if (!hp_pin)
3926 		return;
3927 
3928 	msleep(30);
3929 
3930 	hp_pin_sense = snd_hda_jack_detect(codec, hp_pin);
3931 
3932 	if (hp_pin_sense) {
3933 		msleep(2);
3934 
3935 		snd_hda_codec_write(codec, hp_pin, 0,
3936 				    AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT);
3937 
3938 		msleep(75);
3939 
3940 		snd_hda_codec_write(codec, hp_pin, 0,
3941 				    AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE);
3942 		msleep(75);
3943 	}
3944 }
3945 
alc_default_shutup(struct hda_codec * codec)3946 static void alc_default_shutup(struct hda_codec *codec)
3947 {
3948 	struct alc_spec *spec = codec->spec;
3949 	hda_nid_t hp_pin = alc_get_hp_pin(spec);
3950 	bool hp_pin_sense;
3951 
3952 	if (!hp_pin) {
3953 		alc269_shutup(codec);
3954 		return;
3955 	}
3956 
3957 	hp_pin_sense = snd_hda_jack_detect(codec, hp_pin);
3958 
3959 	if (hp_pin_sense) {
3960 		msleep(2);
3961 
3962 		snd_hda_codec_write(codec, hp_pin, 0,
3963 				    AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);
3964 
3965 		msleep(75);
3966 
3967 		if (!spec->no_shutup_pins)
3968 			snd_hda_codec_write(codec, hp_pin, 0,
3969 					    AC_VERB_SET_PIN_WIDGET_CONTROL, 0x0);
3970 
3971 		msleep(75);
3972 	}
3973 	alc_auto_setup_eapd(codec, false);
3974 	alc_shutup_pins(codec);
3975 }
3976 
alc294_hp_init(struct hda_codec * codec)3977 static void alc294_hp_init(struct hda_codec *codec)
3978 {
3979 	struct alc_spec *spec = codec->spec;
3980 	hda_nid_t hp_pin = alc_get_hp_pin(spec);
3981 	int i, val;
3982 
3983 	if (!hp_pin)
3984 		return;
3985 
3986 	snd_hda_codec_write(codec, hp_pin, 0,
3987 			    AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);
3988 
3989 	msleep(100);
3990 
3991 	if (!spec->no_shutup_pins)
3992 		snd_hda_codec_write(codec, hp_pin, 0,
3993 				    AC_VERB_SET_PIN_WIDGET_CONTROL, 0x0);
3994 
3995 	alc_update_coef_idx(codec, 0x6f, 0x000f, 0);/* Set HP depop to manual mode */
3996 	alc_update_coefex_idx(codec, 0x58, 0x00, 0x8000, 0x8000); /* HP depop procedure start */
3997 
3998 	/* Wait for depop procedure finish  */
3999 	val = alc_read_coefex_idx(codec, 0x58, 0x01);
4000 	for (i = 0; i < 20 && val & 0x0080; i++) {
4001 		msleep(50);
4002 		val = alc_read_coefex_idx(codec, 0x58, 0x01);
4003 	}
4004 	/* Set HP depop to auto mode */
4005 	alc_update_coef_idx(codec, 0x6f, 0x000f, 0x000b);
4006 	msleep(50);
4007 }
4008 
alc294_init(struct hda_codec * codec)4009 static void alc294_init(struct hda_codec *codec)
4010 {
4011 	struct alc_spec *spec = codec->spec;
4012 
4013 	/* required only at boot or S4 resume time */
4014 	if (!spec->done_hp_init ||
4015 	    codec->core.dev.power.power_state.event == PM_EVENT_RESTORE) {
4016 		alc294_hp_init(codec);
4017 		spec->done_hp_init = true;
4018 	}
4019 	alc_default_init(codec);
4020 }
4021 
alc5505_coef_set(struct hda_codec * codec,unsigned int index_reg,unsigned int val)4022 static void alc5505_coef_set(struct hda_codec *codec, unsigned int index_reg,
4023 			     unsigned int val)
4024 {
4025 	snd_hda_codec_write(codec, 0x51, 0, AC_VERB_SET_COEF_INDEX, index_reg >> 1);
4026 	snd_hda_codec_write(codec, 0x51, 0, AC_VERB_SET_PROC_COEF, val & 0xffff); /* LSB */
4027 	snd_hda_codec_write(codec, 0x51, 0, AC_VERB_SET_PROC_COEF, val >> 16); /* MSB */
4028 }
4029 
alc5505_coef_get(struct hda_codec * codec,unsigned int index_reg)4030 static int alc5505_coef_get(struct hda_codec *codec, unsigned int index_reg)
4031 {
4032 	unsigned int val;
4033 
4034 	snd_hda_codec_write(codec, 0x51, 0, AC_VERB_SET_COEF_INDEX, index_reg >> 1);
4035 	val = snd_hda_codec_read(codec, 0x51, 0, AC_VERB_GET_PROC_COEF, 0)
4036 		& 0xffff;
4037 	val |= snd_hda_codec_read(codec, 0x51, 0, AC_VERB_GET_PROC_COEF, 0)
4038 		<< 16;
4039 	return val;
4040 }
4041 
alc5505_dsp_halt(struct hda_codec * codec)4042 static void alc5505_dsp_halt(struct hda_codec *codec)
4043 {
4044 	unsigned int val;
4045 
4046 	alc5505_coef_set(codec, 0x3000, 0x000c); /* DSP CPU stop */
4047 	alc5505_coef_set(codec, 0x880c, 0x0008); /* DDR enter self refresh */
4048 	alc5505_coef_set(codec, 0x61c0, 0x11110080); /* Clock control for PLL and CPU */
4049 	alc5505_coef_set(codec, 0x6230, 0xfc0d4011); /* Disable Input OP */
4050 	alc5505_coef_set(codec, 0x61b4, 0x040a2b03); /* Stop PLL2 */
4051 	alc5505_coef_set(codec, 0x61b0, 0x00005b17); /* Stop PLL1 */
4052 	alc5505_coef_set(codec, 0x61b8, 0x04133303); /* Stop PLL3 */
4053 	val = alc5505_coef_get(codec, 0x6220);
4054 	alc5505_coef_set(codec, 0x6220, (val | 0x3000)); /* switch Ringbuffer clock to DBUS clock */
4055 }
4056 
alc5505_dsp_back_from_halt(struct hda_codec * codec)4057 static void alc5505_dsp_back_from_halt(struct hda_codec *codec)
4058 {
4059 	alc5505_coef_set(codec, 0x61b8, 0x04133302);
4060 	alc5505_coef_set(codec, 0x61b0, 0x00005b16);
4061 	alc5505_coef_set(codec, 0x61b4, 0x040a2b02);
4062 	alc5505_coef_set(codec, 0x6230, 0xf80d4011);
4063 	alc5505_coef_set(codec, 0x6220, 0x2002010f);
4064 	alc5505_coef_set(codec, 0x880c, 0x00000004);
4065 }
4066 
alc5505_dsp_init(struct hda_codec * codec)4067 static void alc5505_dsp_init(struct hda_codec *codec)
4068 {
4069 	unsigned int val;
4070 
4071 	alc5505_dsp_halt(codec);
4072 	alc5505_dsp_back_from_halt(codec);
4073 	alc5505_coef_set(codec, 0x61b0, 0x5b14); /* PLL1 control */
4074 	alc5505_coef_set(codec, 0x61b0, 0x5b16);
4075 	alc5505_coef_set(codec, 0x61b4, 0x04132b00); /* PLL2 control */
4076 	alc5505_coef_set(codec, 0x61b4, 0x04132b02);
4077 	alc5505_coef_set(codec, 0x61b8, 0x041f3300); /* PLL3 control*/
4078 	alc5505_coef_set(codec, 0x61b8, 0x041f3302);
4079 	snd_hda_codec_write(codec, 0x51, 0, AC_VERB_SET_CODEC_RESET, 0); /* Function reset */
4080 	alc5505_coef_set(codec, 0x61b8, 0x041b3302);
4081 	alc5505_coef_set(codec, 0x61b8, 0x04173302);
4082 	alc5505_coef_set(codec, 0x61b8, 0x04163302);
4083 	alc5505_coef_set(codec, 0x8800, 0x348b328b); /* DRAM control */
4084 	alc5505_coef_set(codec, 0x8808, 0x00020022); /* DRAM control */
4085 	alc5505_coef_set(codec, 0x8818, 0x00000400); /* DRAM control */
4086 
4087 	val = alc5505_coef_get(codec, 0x6200) >> 16; /* Read revision ID */
4088 	if (val <= 3)
4089 		alc5505_coef_set(codec, 0x6220, 0x2002010f); /* I/O PAD Configuration */
4090 	else
4091 		alc5505_coef_set(codec, 0x6220, 0x6002018f);
4092 
4093 	alc5505_coef_set(codec, 0x61ac, 0x055525f0); /**/
4094 	alc5505_coef_set(codec, 0x61c0, 0x12230080); /* Clock control */
4095 	alc5505_coef_set(codec, 0x61b4, 0x040e2b02); /* PLL2 control */
4096 	alc5505_coef_set(codec, 0x61bc, 0x010234f8); /* OSC Control */
4097 	alc5505_coef_set(codec, 0x880c, 0x00000004); /* DRAM Function control */
4098 	alc5505_coef_set(codec, 0x880c, 0x00000003);
4099 	alc5505_coef_set(codec, 0x880c, 0x00000010);
4100 
4101 #ifdef HALT_REALTEK_ALC5505
4102 	alc5505_dsp_halt(codec);
4103 #endif
4104 }
4105 
4106 #ifdef HALT_REALTEK_ALC5505
4107 #define alc5505_dsp_suspend(codec)	do { } while (0) /* NOP */
4108 #define alc5505_dsp_resume(codec)	do { } while (0) /* NOP */
4109 #else
4110 #define alc5505_dsp_suspend(codec)	alc5505_dsp_halt(codec)
4111 #define alc5505_dsp_resume(codec)	alc5505_dsp_back_from_halt(codec)
4112 #endif
4113 
alc269_suspend(struct hda_codec * codec)4114 static int alc269_suspend(struct hda_codec *codec)
4115 {
4116 	struct alc_spec *spec = codec->spec;
4117 
4118 	if (spec->has_alc5505_dsp)
4119 		alc5505_dsp_suspend(codec);
4120 
4121 	return alc_suspend(codec);
4122 }
4123 
alc269_resume(struct hda_codec * codec)4124 static int alc269_resume(struct hda_codec *codec)
4125 {
4126 	struct alc_spec *spec = codec->spec;
4127 
4128 	if (spec->codec_variant == ALC269_TYPE_ALC269VB)
4129 		alc269vb_toggle_power_output(codec, 0);
4130 	if (spec->codec_variant == ALC269_TYPE_ALC269VB &&
4131 			(alc_get_coef0(codec) & 0x00ff) == 0x018) {
4132 		msleep(150);
4133 	}
4134 
4135 	codec->patch_ops.init(codec);
4136 
4137 	if (spec->codec_variant == ALC269_TYPE_ALC269VB)
4138 		alc269vb_toggle_power_output(codec, 1);
4139 	if (spec->codec_variant == ALC269_TYPE_ALC269VB &&
4140 			(alc_get_coef0(codec) & 0x00ff) == 0x017) {
4141 		msleep(200);
4142 	}
4143 
4144 	snd_hda_regmap_sync(codec);
4145 	hda_call_check_power_status(codec, 0x01);
4146 
4147 	/* on some machine, the BIOS will clear the codec gpio data when enter
4148 	 * suspend, and won't restore the data after resume, so we restore it
4149 	 * in the driver.
4150 	 */
4151 	if (spec->gpio_data)
4152 		alc_write_gpio_data(codec);
4153 
4154 	if (spec->has_alc5505_dsp)
4155 		alc5505_dsp_resume(codec);
4156 
4157 	return 0;
4158 }
4159 
alc269_fixup_pincfg_no_hp_to_lineout(struct hda_codec * codec,const struct hda_fixup * fix,int action)4160 static void alc269_fixup_pincfg_no_hp_to_lineout(struct hda_codec *codec,
4161 						 const struct hda_fixup *fix, int action)
4162 {
4163 	struct alc_spec *spec = codec->spec;
4164 
4165 	if (action == HDA_FIXUP_ACT_PRE_PROBE)
4166 		spec->parse_flags = HDA_PINCFG_NO_HP_FIXUP;
4167 }
4168 
alc269_fixup_pincfg_U7x7_headset_mic(struct hda_codec * codec,const struct hda_fixup * fix,int action)4169 static void alc269_fixup_pincfg_U7x7_headset_mic(struct hda_codec *codec,
4170 						 const struct hda_fixup *fix,
4171 						 int action)
4172 {
4173 	unsigned int cfg_headphone = snd_hda_codec_get_pincfg(codec, 0x21);
4174 	unsigned int cfg_headset_mic = snd_hda_codec_get_pincfg(codec, 0x19);
4175 
4176 	if (cfg_headphone && cfg_headset_mic == 0x411111f0)
4177 		snd_hda_codec_set_pincfg(codec, 0x19,
4178 			(cfg_headphone & ~AC_DEFCFG_DEVICE) |
4179 			(AC_JACK_MIC_IN << AC_DEFCFG_DEVICE_SHIFT));
4180 }
4181 
alc269_fixup_hweq(struct hda_codec * codec,const struct hda_fixup * fix,int action)4182 static void alc269_fixup_hweq(struct hda_codec *codec,
4183 			       const struct hda_fixup *fix, int action)
4184 {
4185 	if (action == HDA_FIXUP_ACT_INIT)
4186 		alc_update_coef_idx(codec, 0x1e, 0, 0x80);
4187 }
4188 
alc269_fixup_headset_mic(struct hda_codec * codec,const struct hda_fixup * fix,int action)4189 static void alc269_fixup_headset_mic(struct hda_codec *codec,
4190 				       const struct hda_fixup *fix, int action)
4191 {
4192 	struct alc_spec *spec = codec->spec;
4193 
4194 	if (action == HDA_FIXUP_ACT_PRE_PROBE)
4195 		spec->parse_flags |= HDA_PINCFG_HEADSET_MIC;
4196 }
4197 
alc271_fixup_dmic(struct hda_codec * codec,const struct hda_fixup * fix,int action)4198 static void alc271_fixup_dmic(struct hda_codec *codec,
4199 			      const struct hda_fixup *fix, int action)
4200 {
4201 	static const struct hda_verb verbs[] = {
4202 		{0x20, AC_VERB_SET_COEF_INDEX, 0x0d},
4203 		{0x20, AC_VERB_SET_PROC_COEF, 0x4000},
4204 		{}
4205 	};
4206 	unsigned int cfg;
4207 
4208 	if (strcmp(codec->core.chip_name, "ALC271X") &&
4209 	    strcmp(codec->core.chip_name, "ALC269VB"))
4210 		return;
4211 	cfg = snd_hda_codec_get_pincfg(codec, 0x12);
4212 	if (get_defcfg_connect(cfg) == AC_JACK_PORT_FIXED)
4213 		snd_hda_sequence_write(codec, verbs);
4214 }
4215 
4216 /* Fix the speaker amp after resume, etc */
alc269vb_fixup_aspire_e1_coef(struct hda_codec * codec,const struct hda_fixup * fix,int action)4217 static void alc269vb_fixup_aspire_e1_coef(struct hda_codec *codec,
4218 					  const struct hda_fixup *fix,
4219 					  int action)
4220 {
4221 	if (action == HDA_FIXUP_ACT_INIT)
4222 		alc_update_coef_idx(codec, 0x0d, 0x6000, 0x6000);
4223 }
4224 
alc269_fixup_pcm_44k(struct hda_codec * codec,const struct hda_fixup * fix,int action)4225 static void alc269_fixup_pcm_44k(struct hda_codec *codec,
4226 				 const struct hda_fixup *fix, int action)
4227 {
4228 	struct alc_spec *spec = codec->spec;
4229 
4230 	if (action != HDA_FIXUP_ACT_PROBE)
4231 		return;
4232 
4233 	/* Due to a hardware problem on Lenovo Ideadpad, we need to
4234 	 * fix the sample rate of analog I/O to 44.1kHz
4235 	 */
4236 	spec->gen.stream_analog_playback = &alc269_44k_pcm_analog_playback;
4237 	spec->gen.stream_analog_capture = &alc269_44k_pcm_analog_capture;
4238 }
4239 
alc269_fixup_stereo_dmic(struct hda_codec * codec,const struct hda_fixup * fix,int action)4240 static void alc269_fixup_stereo_dmic(struct hda_codec *codec,
4241 				     const struct hda_fixup *fix, int action)
4242 {
4243 	/* The digital-mic unit sends PDM (differential signal) instead of
4244 	 * the standard PCM, thus you can't record a valid mono stream as is.
4245 	 * Below is a workaround specific to ALC269 to control the dmic
4246 	 * signal source as mono.
4247 	 */
4248 	if (action == HDA_FIXUP_ACT_INIT)
4249 		alc_update_coef_idx(codec, 0x07, 0, 0x80);
4250 }
4251 
alc269_quanta_automute(struct hda_codec * codec)4252 static void alc269_quanta_automute(struct hda_codec *codec)
4253 {
4254 	snd_hda_gen_update_outputs(codec);
4255 
4256 	alc_write_coef_idx(codec, 0x0c, 0x680);
4257 	alc_write_coef_idx(codec, 0x0c, 0x480);
4258 }
4259 
alc269_fixup_quanta_mute(struct hda_codec * codec,const struct hda_fixup * fix,int action)4260 static void alc269_fixup_quanta_mute(struct hda_codec *codec,
4261 				     const struct hda_fixup *fix, int action)
4262 {
4263 	struct alc_spec *spec = codec->spec;
4264 	if (action != HDA_FIXUP_ACT_PROBE)
4265 		return;
4266 	spec->gen.automute_hook = alc269_quanta_automute;
4267 }
4268 
alc269_x101_hp_automute_hook(struct hda_codec * codec,struct hda_jack_callback * jack)4269 static void alc269_x101_hp_automute_hook(struct hda_codec *codec,
4270 					 struct hda_jack_callback *jack)
4271 {
4272 	struct alc_spec *spec = codec->spec;
4273 	int vref;
4274 	msleep(200);
4275 	snd_hda_gen_hp_automute(codec, jack);
4276 
4277 	vref = spec->gen.hp_jack_present ? PIN_VREF80 : 0;
4278 	msleep(100);
4279 	snd_hda_codec_write(codec, 0x18, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
4280 			    vref);
4281 	msleep(500);
4282 	snd_hda_codec_write(codec, 0x18, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
4283 			    vref);
4284 }
4285 
4286 /*
4287  * Magic sequence to make Huawei Matebook X right speaker working (bko#197801)
4288  */
4289 struct hda_alc298_mbxinit {
4290 	unsigned char value_0x23;
4291 	unsigned char value_0x25;
4292 };
4293 
alc298_huawei_mbx_stereo_seq(struct hda_codec * codec,const struct hda_alc298_mbxinit * initval,bool first)4294 static void alc298_huawei_mbx_stereo_seq(struct hda_codec *codec,
4295 					 const struct hda_alc298_mbxinit *initval,
4296 					 bool first)
4297 {
4298 	snd_hda_codec_write(codec, 0x06, 0, AC_VERB_SET_DIGI_CONVERT_3, 0x0);
4299 	alc_write_coef_idx(codec, 0x26, 0xb000);
4300 
4301 	if (first)
4302 		snd_hda_codec_write(codec, 0x21, 0, AC_VERB_GET_PIN_SENSE, 0x0);
4303 
4304 	snd_hda_codec_write(codec, 0x6, 0, AC_VERB_SET_DIGI_CONVERT_3, 0x80);
4305 	alc_write_coef_idx(codec, 0x26, 0xf000);
4306 	alc_write_coef_idx(codec, 0x23, initval->value_0x23);
4307 
4308 	if (initval->value_0x23 != 0x1e)
4309 		alc_write_coef_idx(codec, 0x25, initval->value_0x25);
4310 
4311 	snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_COEF_INDEX, 0x26);
4312 	snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_PROC_COEF, 0xb010);
4313 }
4314 
alc298_fixup_huawei_mbx_stereo(struct hda_codec * codec,const struct hda_fixup * fix,int action)4315 static void alc298_fixup_huawei_mbx_stereo(struct hda_codec *codec,
4316 					   const struct hda_fixup *fix,
4317 					   int action)
4318 {
4319 	/* Initialization magic */
4320 	static const struct hda_alc298_mbxinit dac_init[] = {
4321 		{0x0c, 0x00}, {0x0d, 0x00}, {0x0e, 0x00}, {0x0f, 0x00},
4322 		{0x10, 0x00}, {0x1a, 0x40}, {0x1b, 0x82}, {0x1c, 0x00},
4323 		{0x1d, 0x00}, {0x1e, 0x00}, {0x1f, 0x00},
4324 		{0x20, 0xc2}, {0x21, 0xc8}, {0x22, 0x26}, {0x23, 0x24},
4325 		{0x27, 0xff}, {0x28, 0xff}, {0x29, 0xff}, {0x2a, 0x8f},
4326 		{0x2b, 0x02}, {0x2c, 0x48}, {0x2d, 0x34}, {0x2e, 0x00},
4327 		{0x2f, 0x00},
4328 		{0x30, 0x00}, {0x31, 0x00}, {0x32, 0x00}, {0x33, 0x00},
4329 		{0x34, 0x00}, {0x35, 0x01}, {0x36, 0x93}, {0x37, 0x0c},
4330 		{0x38, 0x00}, {0x39, 0x00}, {0x3a, 0xf8}, {0x38, 0x80},
4331 		{}
4332 	};
4333 	const struct hda_alc298_mbxinit *seq;
4334 
4335 	if (action != HDA_FIXUP_ACT_INIT)
4336 		return;
4337 
4338 	/* Start */
4339 	snd_hda_codec_write(codec, 0x06, 0, AC_VERB_SET_DIGI_CONVERT_3, 0x00);
4340 	snd_hda_codec_write(codec, 0x06, 0, AC_VERB_SET_DIGI_CONVERT_3, 0x80);
4341 	alc_write_coef_idx(codec, 0x26, 0xf000);
4342 	alc_write_coef_idx(codec, 0x22, 0x31);
4343 	alc_write_coef_idx(codec, 0x23, 0x0b);
4344 	alc_write_coef_idx(codec, 0x25, 0x00);
4345 	snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_COEF_INDEX, 0x26);
4346 	snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_PROC_COEF, 0xb010);
4347 
4348 	for (seq = dac_init; seq->value_0x23; seq++)
4349 		alc298_huawei_mbx_stereo_seq(codec, seq, seq == dac_init);
4350 }
4351 
alc269_fixup_x101_headset_mic(struct hda_codec * codec,const struct hda_fixup * fix,int action)4352 static void alc269_fixup_x101_headset_mic(struct hda_codec *codec,
4353 				     const struct hda_fixup *fix, int action)
4354 {
4355 	struct alc_spec *spec = codec->spec;
4356 	if (action == HDA_FIXUP_ACT_PRE_PROBE) {
4357 		spec->parse_flags |= HDA_PINCFG_HEADSET_MIC;
4358 		spec->gen.hp_automute_hook = alc269_x101_hp_automute_hook;
4359 	}
4360 }
4361 
alc_update_vref_led(struct hda_codec * codec,hda_nid_t pin,bool polarity,bool on)4362 static void alc_update_vref_led(struct hda_codec *codec, hda_nid_t pin,
4363 				bool polarity, bool on)
4364 {
4365 	unsigned int pinval;
4366 
4367 	if (!pin)
4368 		return;
4369 	if (polarity)
4370 		on = !on;
4371 	pinval = snd_hda_codec_get_pin_target(codec, pin);
4372 	pinval &= ~AC_PINCTL_VREFEN;
4373 	pinval |= on ? AC_PINCTL_VREF_80 : AC_PINCTL_VREF_HIZ;
4374 	/* temporarily power up/down for setting VREF */
4375 	snd_hda_power_up_pm(codec);
4376 	snd_hda_set_pin_ctl_cache(codec, pin, pinval);
4377 	snd_hda_power_down_pm(codec);
4378 }
4379 
4380 /* update mute-LED according to the speaker mute state via mic VREF pin */
vref_mute_led_set(struct led_classdev * led_cdev,enum led_brightness brightness)4381 static int vref_mute_led_set(struct led_classdev *led_cdev,
4382 			     enum led_brightness brightness)
4383 {
4384 	struct hda_codec *codec = dev_to_hda_codec(led_cdev->dev->parent);
4385 	struct alc_spec *spec = codec->spec;
4386 
4387 	alc_update_vref_led(codec, spec->mute_led_nid,
4388 			    spec->mute_led_polarity, brightness);
4389 	return 0;
4390 }
4391 
4392 /* Make sure the led works even in runtime suspend */
led_power_filter(struct hda_codec * codec,hda_nid_t nid,unsigned int power_state)4393 static unsigned int led_power_filter(struct hda_codec *codec,
4394 						  hda_nid_t nid,
4395 						  unsigned int power_state)
4396 {
4397 	struct alc_spec *spec = codec->spec;
4398 
4399 	if (power_state != AC_PWRST_D3 || nid == 0 ||
4400 	    (nid != spec->mute_led_nid && nid != spec->cap_mute_led_nid))
4401 		return power_state;
4402 
4403 	/* Set pin ctl again, it might have just been set to 0 */
4404 	snd_hda_set_pin_ctl(codec, nid,
4405 			    snd_hda_codec_get_pin_target(codec, nid));
4406 
4407 	return snd_hda_gen_path_power_filter(codec, nid, power_state);
4408 }
4409 
alc269_fixup_hp_mute_led(struct hda_codec * codec,const struct hda_fixup * fix,int action)4410 static void alc269_fixup_hp_mute_led(struct hda_codec *codec,
4411 				     const struct hda_fixup *fix, int action)
4412 {
4413 	struct alc_spec *spec = codec->spec;
4414 	const struct dmi_device *dev = NULL;
4415 
4416 	if (action != HDA_FIXUP_ACT_PRE_PROBE)
4417 		return;
4418 
4419 	while ((dev = dmi_find_device(DMI_DEV_TYPE_OEM_STRING, NULL, dev))) {
4420 		int pol, pin;
4421 		if (sscanf(dev->name, "HP_Mute_LED_%d_%x", &pol, &pin) != 2)
4422 			continue;
4423 		if (pin < 0x0a || pin >= 0x10)
4424 			break;
4425 		spec->mute_led_polarity = pol;
4426 		spec->mute_led_nid = pin - 0x0a + 0x18;
4427 		snd_hda_gen_add_mute_led_cdev(codec, vref_mute_led_set);
4428 		codec->power_filter = led_power_filter;
4429 		codec_dbg(codec,
4430 			  "Detected mute LED for %x:%d\n", spec->mute_led_nid,
4431 			   spec->mute_led_polarity);
4432 		break;
4433 	}
4434 }
4435 
alc269_fixup_hp_mute_led_micx(struct hda_codec * codec,const struct hda_fixup * fix,int action,hda_nid_t pin)4436 static void alc269_fixup_hp_mute_led_micx(struct hda_codec *codec,
4437 					  const struct hda_fixup *fix,
4438 					  int action, hda_nid_t pin)
4439 {
4440 	struct alc_spec *spec = codec->spec;
4441 
4442 	if (action == HDA_FIXUP_ACT_PRE_PROBE) {
4443 		spec->mute_led_polarity = 0;
4444 		spec->mute_led_nid = pin;
4445 		snd_hda_gen_add_mute_led_cdev(codec, vref_mute_led_set);
4446 		codec->power_filter = led_power_filter;
4447 	}
4448 }
4449 
alc269_fixup_hp_mute_led_mic1(struct hda_codec * codec,const struct hda_fixup * fix,int action)4450 static void alc269_fixup_hp_mute_led_mic1(struct hda_codec *codec,
4451 				const struct hda_fixup *fix, int action)
4452 {
4453 	alc269_fixup_hp_mute_led_micx(codec, fix, action, 0x18);
4454 }
4455 
alc269_fixup_hp_mute_led_mic2(struct hda_codec * codec,const struct hda_fixup * fix,int action)4456 static void alc269_fixup_hp_mute_led_mic2(struct hda_codec *codec,
4457 				const struct hda_fixup *fix, int action)
4458 {
4459 	alc269_fixup_hp_mute_led_micx(codec, fix, action, 0x19);
4460 }
4461 
alc269_fixup_hp_mute_led_mic3(struct hda_codec * codec,const struct hda_fixup * fix,int action)4462 static void alc269_fixup_hp_mute_led_mic3(struct hda_codec *codec,
4463 				const struct hda_fixup *fix, int action)
4464 {
4465 	alc269_fixup_hp_mute_led_micx(codec, fix, action, 0x1b);
4466 }
4467 
4468 /* update LED status via GPIO */
alc_update_gpio_led(struct hda_codec * codec,unsigned int mask,int polarity,bool enabled)4469 static void alc_update_gpio_led(struct hda_codec *codec, unsigned int mask,
4470 				int polarity, bool enabled)
4471 {
4472 	if (polarity)
4473 		enabled = !enabled;
4474 	alc_update_gpio_data(codec, mask, !enabled); /* muted -> LED on */
4475 }
4476 
4477 /* turn on/off mute LED via GPIO per vmaster hook */
gpio_mute_led_set(struct led_classdev * led_cdev,enum led_brightness brightness)4478 static int gpio_mute_led_set(struct led_classdev *led_cdev,
4479 			     enum led_brightness brightness)
4480 {
4481 	struct hda_codec *codec = dev_to_hda_codec(led_cdev->dev->parent);
4482 	struct alc_spec *spec = codec->spec;
4483 
4484 	alc_update_gpio_led(codec, spec->gpio_mute_led_mask,
4485 			    spec->mute_led_polarity, !brightness);
4486 	return 0;
4487 }
4488 
4489 /* turn on/off mic-mute LED via GPIO per capture hook */
micmute_led_set(struct led_classdev * led_cdev,enum led_brightness brightness)4490 static int micmute_led_set(struct led_classdev *led_cdev,
4491 			   enum led_brightness brightness)
4492 {
4493 	struct hda_codec *codec = dev_to_hda_codec(led_cdev->dev->parent);
4494 	struct alc_spec *spec = codec->spec;
4495 
4496 	alc_update_gpio_led(codec, spec->gpio_mic_led_mask,
4497 			    spec->micmute_led_polarity, !brightness);
4498 	return 0;
4499 }
4500 
4501 /* setup mute and mic-mute GPIO bits, add hooks appropriately */
alc_fixup_hp_gpio_led(struct hda_codec * codec,int action,unsigned int mute_mask,unsigned int micmute_mask)4502 static void alc_fixup_hp_gpio_led(struct hda_codec *codec,
4503 				  int action,
4504 				  unsigned int mute_mask,
4505 				  unsigned int micmute_mask)
4506 {
4507 	struct alc_spec *spec = codec->spec;
4508 
4509 	alc_fixup_gpio(codec, action, mute_mask | micmute_mask);
4510 
4511 	if (action != HDA_FIXUP_ACT_PRE_PROBE)
4512 		return;
4513 	if (mute_mask) {
4514 		spec->gpio_mute_led_mask = mute_mask;
4515 		snd_hda_gen_add_mute_led_cdev(codec, gpio_mute_led_set);
4516 	}
4517 	if (micmute_mask) {
4518 		spec->gpio_mic_led_mask = micmute_mask;
4519 		snd_hda_gen_add_micmute_led_cdev(codec, micmute_led_set);
4520 	}
4521 }
4522 
alc236_fixup_hp_gpio_led(struct hda_codec * codec,const struct hda_fixup * fix,int action)4523 static void alc236_fixup_hp_gpio_led(struct hda_codec *codec,
4524 				const struct hda_fixup *fix, int action)
4525 {
4526 	alc_fixup_hp_gpio_led(codec, action, 0x02, 0x01);
4527 }
4528 
alc269_fixup_hp_gpio_led(struct hda_codec * codec,const struct hda_fixup * fix,int action)4529 static void alc269_fixup_hp_gpio_led(struct hda_codec *codec,
4530 				const struct hda_fixup *fix, int action)
4531 {
4532 	alc_fixup_hp_gpio_led(codec, action, 0x08, 0x10);
4533 }
4534 
alc285_fixup_hp_gpio_led(struct hda_codec * codec,const struct hda_fixup * fix,int action)4535 static void alc285_fixup_hp_gpio_led(struct hda_codec *codec,
4536 				const struct hda_fixup *fix, int action)
4537 {
4538 	alc_fixup_hp_gpio_led(codec, action, 0x04, 0x01);
4539 }
4540 
alc286_fixup_hp_gpio_led(struct hda_codec * codec,const struct hda_fixup * fix,int action)4541 static void alc286_fixup_hp_gpio_led(struct hda_codec *codec,
4542 				const struct hda_fixup *fix, int action)
4543 {
4544 	alc_fixup_hp_gpio_led(codec, action, 0x02, 0x20);
4545 }
4546 
alc287_fixup_hp_gpio_led(struct hda_codec * codec,const struct hda_fixup * fix,int action)4547 static void alc287_fixup_hp_gpio_led(struct hda_codec *codec,
4548 				const struct hda_fixup *fix, int action)
4549 {
4550 	alc_fixup_hp_gpio_led(codec, action, 0x10, 0);
4551 }
4552 
alc245_fixup_hp_gpio_led(struct hda_codec * codec,const struct hda_fixup * fix,int action)4553 static void alc245_fixup_hp_gpio_led(struct hda_codec *codec,
4554 				const struct hda_fixup *fix, int action)
4555 {
4556 	struct alc_spec *spec = codec->spec;
4557 
4558 	if (action == HDA_FIXUP_ACT_PRE_PROBE)
4559 		spec->micmute_led_polarity = 1;
4560 	alc_fixup_hp_gpio_led(codec, action, 0, 0x04);
4561 }
4562 
4563 /* turn on/off mic-mute LED per capture hook via VREF change */
vref_micmute_led_set(struct led_classdev * led_cdev,enum led_brightness brightness)4564 static int vref_micmute_led_set(struct led_classdev *led_cdev,
4565 				enum led_brightness brightness)
4566 {
4567 	struct hda_codec *codec = dev_to_hda_codec(led_cdev->dev->parent);
4568 	struct alc_spec *spec = codec->spec;
4569 
4570 	alc_update_vref_led(codec, spec->cap_mute_led_nid,
4571 			    spec->micmute_led_polarity, brightness);
4572 	return 0;
4573 }
4574 
alc269_fixup_hp_gpio_mic1_led(struct hda_codec * codec,const struct hda_fixup * fix,int action)4575 static void alc269_fixup_hp_gpio_mic1_led(struct hda_codec *codec,
4576 				const struct hda_fixup *fix, int action)
4577 {
4578 	struct alc_spec *spec = codec->spec;
4579 
4580 	alc_fixup_hp_gpio_led(codec, action, 0x08, 0);
4581 	if (action == HDA_FIXUP_ACT_PRE_PROBE) {
4582 		/* Like hp_gpio_mic1_led, but also needs GPIO4 low to
4583 		 * enable headphone amp
4584 		 */
4585 		spec->gpio_mask |= 0x10;
4586 		spec->gpio_dir |= 0x10;
4587 		spec->cap_mute_led_nid = 0x18;
4588 		snd_hda_gen_add_micmute_led_cdev(codec, vref_micmute_led_set);
4589 		codec->power_filter = led_power_filter;
4590 	}
4591 }
4592 
alc280_fixup_hp_gpio4(struct hda_codec * codec,const struct hda_fixup * fix,int action)4593 static void alc280_fixup_hp_gpio4(struct hda_codec *codec,
4594 				   const struct hda_fixup *fix, int action)
4595 {
4596 	struct alc_spec *spec = codec->spec;
4597 
4598 	alc_fixup_hp_gpio_led(codec, action, 0x08, 0);
4599 	if (action == HDA_FIXUP_ACT_PRE_PROBE) {
4600 		spec->cap_mute_led_nid = 0x18;
4601 		snd_hda_gen_add_micmute_led_cdev(codec, vref_micmute_led_set);
4602 		codec->power_filter = led_power_filter;
4603 	}
4604 }
4605 
4606 /* HP Spectre x360 14 model needs a unique workaround for enabling the amp;
4607  * it needs to toggle the GPIO0 once on and off at each time (bko#210633)
4608  */
alc245_fixup_hp_x360_amp(struct hda_codec * codec,const struct hda_fixup * fix,int action)4609 static void alc245_fixup_hp_x360_amp(struct hda_codec *codec,
4610 				     const struct hda_fixup *fix, int action)
4611 {
4612 	struct alc_spec *spec = codec->spec;
4613 
4614 	switch (action) {
4615 	case HDA_FIXUP_ACT_PRE_PROBE:
4616 		spec->gpio_mask |= 0x01;
4617 		spec->gpio_dir |= 0x01;
4618 		break;
4619 	case HDA_FIXUP_ACT_INIT:
4620 		/* need to toggle GPIO to enable the amp */
4621 		alc_update_gpio_data(codec, 0x01, true);
4622 		msleep(100);
4623 		alc_update_gpio_data(codec, 0x01, false);
4624 		break;
4625 	}
4626 }
4627 
4628 /* toggle GPIO2 at each time stream is started; we use PREPARE state instead */
alc274_hp_envy_pcm_hook(struct hda_pcm_stream * hinfo,struct hda_codec * codec,struct snd_pcm_substream * substream,int action)4629 static void alc274_hp_envy_pcm_hook(struct hda_pcm_stream *hinfo,
4630 				    struct hda_codec *codec,
4631 				    struct snd_pcm_substream *substream,
4632 				    int action)
4633 {
4634 	switch (action) {
4635 	case HDA_GEN_PCM_ACT_PREPARE:
4636 		alc_update_gpio_data(codec, 0x04, true);
4637 		break;
4638 	case HDA_GEN_PCM_ACT_CLEANUP:
4639 		alc_update_gpio_data(codec, 0x04, false);
4640 		break;
4641 	}
4642 }
4643 
alc274_fixup_hp_envy_gpio(struct hda_codec * codec,const struct hda_fixup * fix,int action)4644 static void alc274_fixup_hp_envy_gpio(struct hda_codec *codec,
4645 				      const struct hda_fixup *fix,
4646 				      int action)
4647 {
4648 	struct alc_spec *spec = codec->spec;
4649 
4650 	if (action == HDA_FIXUP_ACT_PROBE) {
4651 		spec->gpio_mask |= 0x04;
4652 		spec->gpio_dir |= 0x04;
4653 		spec->gen.pcm_playback_hook = alc274_hp_envy_pcm_hook;
4654 	}
4655 }
4656 
alc_update_coef_led(struct hda_codec * codec,struct alc_coef_led * led,bool polarity,bool on)4657 static void alc_update_coef_led(struct hda_codec *codec,
4658 				struct alc_coef_led *led,
4659 				bool polarity, bool on)
4660 {
4661 	if (polarity)
4662 		on = !on;
4663 	/* temporarily power up/down for setting COEF bit */
4664 	alc_update_coef_idx(codec, led->idx, led->mask,
4665 			    on ? led->on : led->off);
4666 }
4667 
4668 /* update mute-LED according to the speaker mute state via COEF bit */
coef_mute_led_set(struct led_classdev * led_cdev,enum led_brightness brightness)4669 static int coef_mute_led_set(struct led_classdev *led_cdev,
4670 			     enum led_brightness brightness)
4671 {
4672 	struct hda_codec *codec = dev_to_hda_codec(led_cdev->dev->parent);
4673 	struct alc_spec *spec = codec->spec;
4674 
4675 	alc_update_coef_led(codec, &spec->mute_led_coef,
4676 			    spec->mute_led_polarity, brightness);
4677 	return 0;
4678 }
4679 
alc285_fixup_hp_mute_led_coefbit(struct hda_codec * codec,const struct hda_fixup * fix,int action)4680 static void alc285_fixup_hp_mute_led_coefbit(struct hda_codec *codec,
4681 					  const struct hda_fixup *fix,
4682 					  int action)
4683 {
4684 	struct alc_spec *spec = codec->spec;
4685 
4686 	if (action == HDA_FIXUP_ACT_PRE_PROBE) {
4687 		spec->mute_led_polarity = 0;
4688 		spec->mute_led_coef.idx = 0x0b;
4689 		spec->mute_led_coef.mask = 1 << 3;
4690 		spec->mute_led_coef.on = 1 << 3;
4691 		spec->mute_led_coef.off = 0;
4692 		snd_hda_gen_add_mute_led_cdev(codec, coef_mute_led_set);
4693 	}
4694 }
4695 
alc236_fixup_hp_mute_led_coefbit(struct hda_codec * codec,const struct hda_fixup * fix,int action)4696 static void alc236_fixup_hp_mute_led_coefbit(struct hda_codec *codec,
4697 					  const struct hda_fixup *fix,
4698 					  int action)
4699 {
4700 	struct alc_spec *spec = codec->spec;
4701 
4702 	if (action == HDA_FIXUP_ACT_PRE_PROBE) {
4703 		spec->mute_led_polarity = 0;
4704 		spec->mute_led_coef.idx = 0x34;
4705 		spec->mute_led_coef.mask = 1 << 5;
4706 		spec->mute_led_coef.on = 0;
4707 		spec->mute_led_coef.off = 1 << 5;
4708 		snd_hda_gen_add_mute_led_cdev(codec, coef_mute_led_set);
4709 	}
4710 }
4711 
alc236_fixup_hp_mute_led_coefbit2(struct hda_codec * codec,const struct hda_fixup * fix,int action)4712 static void alc236_fixup_hp_mute_led_coefbit2(struct hda_codec *codec,
4713 					  const struct hda_fixup *fix, int action)
4714 {
4715 	struct alc_spec *spec = codec->spec;
4716 
4717 	if (action == HDA_FIXUP_ACT_PRE_PROBE) {
4718 		spec->mute_led_polarity = 0;
4719 		spec->mute_led_coef.idx = 0x07;
4720 		spec->mute_led_coef.mask = 1;
4721 		spec->mute_led_coef.on = 1;
4722 		spec->mute_led_coef.off = 0;
4723 		snd_hda_gen_add_mute_led_cdev(codec, coef_mute_led_set);
4724 	}
4725 }
4726 
alc245_fixup_hp_mute_led_coefbit(struct hda_codec * codec,const struct hda_fixup * fix,int action)4727 static void alc245_fixup_hp_mute_led_coefbit(struct hda_codec *codec,
4728 					  const struct hda_fixup *fix,
4729 					  int action)
4730 {
4731 	struct alc_spec *spec = codec->spec;
4732 
4733 	if (action == HDA_FIXUP_ACT_PRE_PROBE) {
4734 		spec->mute_led_polarity = 0;
4735 		spec->mute_led_coef.idx = 0x0b;
4736 		spec->mute_led_coef.mask = 3 << 2;
4737 		spec->mute_led_coef.on = 2 << 2;
4738 		spec->mute_led_coef.off = 1 << 2;
4739 		snd_hda_gen_add_mute_led_cdev(codec, coef_mute_led_set);
4740 	}
4741 }
4742 
4743 /* turn on/off mic-mute LED per capture hook by coef bit */
coef_micmute_led_set(struct led_classdev * led_cdev,enum led_brightness brightness)4744 static int coef_micmute_led_set(struct led_classdev *led_cdev,
4745 				enum led_brightness brightness)
4746 {
4747 	struct hda_codec *codec = dev_to_hda_codec(led_cdev->dev->parent);
4748 	struct alc_spec *spec = codec->spec;
4749 
4750 	alc_update_coef_led(codec, &spec->mic_led_coef,
4751 			    spec->micmute_led_polarity, brightness);
4752 	return 0;
4753 }
4754 
alc285_fixup_hp_coef_micmute_led(struct hda_codec * codec,const struct hda_fixup * fix,int action)4755 static void alc285_fixup_hp_coef_micmute_led(struct hda_codec *codec,
4756 				const struct hda_fixup *fix, int action)
4757 {
4758 	struct alc_spec *spec = codec->spec;
4759 
4760 	if (action == HDA_FIXUP_ACT_PRE_PROBE) {
4761 		spec->mic_led_coef.idx = 0x19;
4762 		spec->mic_led_coef.mask = 1 << 13;
4763 		spec->mic_led_coef.on = 1 << 13;
4764 		spec->mic_led_coef.off = 0;
4765 		snd_hda_gen_add_micmute_led_cdev(codec, coef_micmute_led_set);
4766 	}
4767 }
4768 
alc285_fixup_hp_gpio_micmute_led(struct hda_codec * codec,const struct hda_fixup * fix,int action)4769 static void alc285_fixup_hp_gpio_micmute_led(struct hda_codec *codec,
4770 				const struct hda_fixup *fix, int action)
4771 {
4772 	struct alc_spec *spec = codec->spec;
4773 
4774 	if (action == HDA_FIXUP_ACT_PRE_PROBE)
4775 		spec->micmute_led_polarity = 1;
4776 	alc_fixup_hp_gpio_led(codec, action, 0, 0x04);
4777 }
4778 
alc236_fixup_hp_coef_micmute_led(struct hda_codec * codec,const struct hda_fixup * fix,int action)4779 static void alc236_fixup_hp_coef_micmute_led(struct hda_codec *codec,
4780 				const struct hda_fixup *fix, int action)
4781 {
4782 	struct alc_spec *spec = codec->spec;
4783 
4784 	if (action == HDA_FIXUP_ACT_PRE_PROBE) {
4785 		spec->mic_led_coef.idx = 0x35;
4786 		spec->mic_led_coef.mask = 3 << 2;
4787 		spec->mic_led_coef.on = 2 << 2;
4788 		spec->mic_led_coef.off = 1 << 2;
4789 		snd_hda_gen_add_micmute_led_cdev(codec, coef_micmute_led_set);
4790 	}
4791 }
4792 
alc285_fixup_hp_mute_led(struct hda_codec * codec,const struct hda_fixup * fix,int action)4793 static void alc285_fixup_hp_mute_led(struct hda_codec *codec,
4794 				const struct hda_fixup *fix, int action)
4795 {
4796 	alc285_fixup_hp_mute_led_coefbit(codec, fix, action);
4797 	alc285_fixup_hp_coef_micmute_led(codec, fix, action);
4798 }
4799 
alc285_fixup_hp_spectre_x360_mute_led(struct hda_codec * codec,const struct hda_fixup * fix,int action)4800 static void alc285_fixup_hp_spectre_x360_mute_led(struct hda_codec *codec,
4801 				const struct hda_fixup *fix, int action)
4802 {
4803 	alc285_fixup_hp_mute_led_coefbit(codec, fix, action);
4804 	alc285_fixup_hp_gpio_micmute_led(codec, fix, action);
4805 }
4806 
alc236_fixup_hp_mute_led(struct hda_codec * codec,const struct hda_fixup * fix,int action)4807 static void alc236_fixup_hp_mute_led(struct hda_codec *codec,
4808 				const struct hda_fixup *fix, int action)
4809 {
4810 	alc236_fixup_hp_mute_led_coefbit(codec, fix, action);
4811 	alc236_fixup_hp_coef_micmute_led(codec, fix, action);
4812 }
4813 
alc236_fixup_hp_micmute_led_vref(struct hda_codec * codec,const struct hda_fixup * fix,int action)4814 static void alc236_fixup_hp_micmute_led_vref(struct hda_codec *codec,
4815 				const struct hda_fixup *fix, int action)
4816 {
4817 	struct alc_spec *spec = codec->spec;
4818 
4819 	if (action == HDA_FIXUP_ACT_PRE_PROBE) {
4820 		spec->cap_mute_led_nid = 0x1a;
4821 		snd_hda_gen_add_micmute_led_cdev(codec, vref_micmute_led_set);
4822 		codec->power_filter = led_power_filter;
4823 	}
4824 }
4825 
alc236_fixup_hp_mute_led_micmute_vref(struct hda_codec * codec,const struct hda_fixup * fix,int action)4826 static void alc236_fixup_hp_mute_led_micmute_vref(struct hda_codec *codec,
4827 				const struct hda_fixup *fix, int action)
4828 {
4829 	alc236_fixup_hp_mute_led_coefbit(codec, fix, action);
4830 	alc236_fixup_hp_micmute_led_vref(codec, fix, action);
4831 }
4832 
alc298_samsung_write_coef_pack(struct hda_codec * codec,const unsigned short coefs[2])4833 static inline void alc298_samsung_write_coef_pack(struct hda_codec *codec,
4834 						  const unsigned short coefs[2])
4835 {
4836 	alc_write_coef_idx(codec, 0x23, coefs[0]);
4837 	alc_write_coef_idx(codec, 0x25, coefs[1]);
4838 	alc_write_coef_idx(codec, 0x26, 0xb011);
4839 }
4840 
4841 struct alc298_samsung_amp_desc {
4842 	unsigned char nid;
4843 	unsigned short init_seq[2][2];
4844 };
4845 
alc298_fixup_samsung_amp(struct hda_codec * codec,const struct hda_fixup * fix,int action)4846 static void alc298_fixup_samsung_amp(struct hda_codec *codec,
4847 				     const struct hda_fixup *fix, int action)
4848 {
4849 	int i, j;
4850 	static const unsigned short init_seq[][2] = {
4851 		{ 0x19, 0x00 }, { 0x20, 0xc0 }, { 0x22, 0x44 }, { 0x23, 0x08 },
4852 		{ 0x24, 0x85 }, { 0x25, 0x41 }, { 0x35, 0x40 }, { 0x36, 0x01 },
4853 		{ 0x38, 0x81 }, { 0x3a, 0x03 }, { 0x3b, 0x81 }, { 0x40, 0x3e },
4854 		{ 0x41, 0x07 }, { 0x400, 0x1 }
4855 	};
4856 	static const struct alc298_samsung_amp_desc amps[] = {
4857 		{ 0x3a, { { 0x18, 0x1 }, { 0x26, 0x0 } } },
4858 		{ 0x39, { { 0x18, 0x2 }, { 0x26, 0x1 } } }
4859 	};
4860 
4861 	if (action != HDA_FIXUP_ACT_INIT)
4862 		return;
4863 
4864 	for (i = 0; i < ARRAY_SIZE(amps); i++) {
4865 		alc_write_coef_idx(codec, 0x22, amps[i].nid);
4866 
4867 		for (j = 0; j < ARRAY_SIZE(amps[i].init_seq); j++)
4868 			alc298_samsung_write_coef_pack(codec, amps[i].init_seq[j]);
4869 
4870 		for (j = 0; j < ARRAY_SIZE(init_seq); j++)
4871 			alc298_samsung_write_coef_pack(codec, init_seq[j]);
4872 	}
4873 }
4874 
4875 struct alc298_samsung_v2_amp_desc {
4876 	unsigned short nid;
4877 	int init_seq_size;
4878 	unsigned short init_seq[18][2];
4879 };
4880 
4881 static const struct alc298_samsung_v2_amp_desc
4882 alc298_samsung_v2_amp_desc_tbl[] = {
4883 	{ 0x38, 18, {
4884 		{ 0x23e1, 0x0000 }, { 0x2012, 0x006f }, { 0x2014, 0x0000 },
4885 		{ 0x201b, 0x0001 }, { 0x201d, 0x0001 }, { 0x201f, 0x00fe },
4886 		{ 0x2021, 0x0000 }, { 0x2022, 0x0010 }, { 0x203d, 0x0005 },
4887 		{ 0x203f, 0x0003 }, { 0x2050, 0x002c }, { 0x2076, 0x000e },
4888 		{ 0x207c, 0x004a }, { 0x2081, 0x0003 }, { 0x2399, 0x0003 },
4889 		{ 0x23a4, 0x00b5 }, { 0x23a5, 0x0001 }, { 0x23ba, 0x0094 }
4890 	}},
4891 	{ 0x39, 18, {
4892 		{ 0x23e1, 0x0000 }, { 0x2012, 0x006f }, { 0x2014, 0x0000 },
4893 		{ 0x201b, 0x0002 }, { 0x201d, 0x0002 }, { 0x201f, 0x00fd },
4894 		{ 0x2021, 0x0001 }, { 0x2022, 0x0010 }, { 0x203d, 0x0005 },
4895 		{ 0x203f, 0x0003 }, { 0x2050, 0x002c }, { 0x2076, 0x000e },
4896 		{ 0x207c, 0x004a }, { 0x2081, 0x0003 }, { 0x2399, 0x0003 },
4897 		{ 0x23a4, 0x00b5 }, { 0x23a5, 0x0001 }, { 0x23ba, 0x0094 }
4898 	}},
4899 	{ 0x3c, 15, {
4900 		{ 0x23e1, 0x0000 }, { 0x2012, 0x006f }, { 0x2014, 0x0000 },
4901 		{ 0x201b, 0x0001 }, { 0x201d, 0x0001 }, { 0x201f, 0x00fe },
4902 		{ 0x2021, 0x0000 }, { 0x2022, 0x0010 }, { 0x203d, 0x0005 },
4903 		{ 0x203f, 0x0003 }, { 0x2050, 0x002c }, { 0x2076, 0x000e },
4904 		{ 0x207c, 0x004a }, { 0x2081, 0x0003 }, { 0x23ba, 0x008d }
4905 	}},
4906 	{ 0x3d, 15, {
4907 		{ 0x23e1, 0x0000 }, { 0x2012, 0x006f }, { 0x2014, 0x0000 },
4908 		{ 0x201b, 0x0002 }, { 0x201d, 0x0002 }, { 0x201f, 0x00fd },
4909 		{ 0x2021, 0x0001 }, { 0x2022, 0x0010 }, { 0x203d, 0x0005 },
4910 		{ 0x203f, 0x0003 }, { 0x2050, 0x002c }, { 0x2076, 0x000e },
4911 		{ 0x207c, 0x004a }, { 0x2081, 0x0003 }, { 0x23ba, 0x008d }
4912 	}}
4913 };
4914 
alc298_samsung_v2_enable_amps(struct hda_codec * codec)4915 static void alc298_samsung_v2_enable_amps(struct hda_codec *codec)
4916 {
4917 	struct alc_spec *spec = codec->spec;
4918 	static const unsigned short enable_seq[][2] = {
4919 		{ 0x203a, 0x0081 }, { 0x23ff, 0x0001 },
4920 	};
4921 	int i, j;
4922 
4923 	for (i = 0; i < spec->num_speaker_amps; i++) {
4924 		alc_write_coef_idx(codec, 0x22, alc298_samsung_v2_amp_desc_tbl[i].nid);
4925 		for (j = 0; j < ARRAY_SIZE(enable_seq); j++)
4926 			alc298_samsung_write_coef_pack(codec, enable_seq[j]);
4927 		codec_dbg(codec, "alc298_samsung_v2: Enabled speaker amp 0x%02x\n",
4928 				alc298_samsung_v2_amp_desc_tbl[i].nid);
4929 	}
4930 }
4931 
alc298_samsung_v2_disable_amps(struct hda_codec * codec)4932 static void alc298_samsung_v2_disable_amps(struct hda_codec *codec)
4933 {
4934 	struct alc_spec *spec = codec->spec;
4935 	static const unsigned short disable_seq[][2] = {
4936 		{ 0x23ff, 0x0000 }, { 0x203a, 0x0080 },
4937 	};
4938 	int i, j;
4939 
4940 	for (i = 0; i < spec->num_speaker_amps; i++) {
4941 		alc_write_coef_idx(codec, 0x22, alc298_samsung_v2_amp_desc_tbl[i].nid);
4942 		for (j = 0; j < ARRAY_SIZE(disable_seq); j++)
4943 			alc298_samsung_write_coef_pack(codec, disable_seq[j]);
4944 		codec_dbg(codec, "alc298_samsung_v2: Disabled speaker amp 0x%02x\n",
4945 				alc298_samsung_v2_amp_desc_tbl[i].nid);
4946 	}
4947 }
4948 
alc298_samsung_v2_playback_hook(struct hda_pcm_stream * hinfo,struct hda_codec * codec,struct snd_pcm_substream * substream,int action)4949 static void alc298_samsung_v2_playback_hook(struct hda_pcm_stream *hinfo,
4950 				struct hda_codec *codec,
4951 				struct snd_pcm_substream *substream,
4952 				int action)
4953 {
4954 	/* Dynamically enable/disable speaker amps before and after playback */
4955 	if (action == HDA_GEN_PCM_ACT_OPEN)
4956 		alc298_samsung_v2_enable_amps(codec);
4957 	if (action == HDA_GEN_PCM_ACT_CLOSE)
4958 		alc298_samsung_v2_disable_amps(codec);
4959 }
4960 
alc298_samsung_v2_init_amps(struct hda_codec * codec,int num_speaker_amps)4961 static void alc298_samsung_v2_init_amps(struct hda_codec *codec,
4962 				int num_speaker_amps)
4963 {
4964 	struct alc_spec *spec = codec->spec;
4965 	int i, j;
4966 
4967 	/* Set spec's num_speaker_amps before doing anything else */
4968 	spec->num_speaker_amps = num_speaker_amps;
4969 
4970 	/* Disable speaker amps before init to prevent any physical damage */
4971 	alc298_samsung_v2_disable_amps(codec);
4972 
4973 	/* Initialize the speaker amps */
4974 	for (i = 0; i < spec->num_speaker_amps; i++) {
4975 		alc_write_coef_idx(codec, 0x22, alc298_samsung_v2_amp_desc_tbl[i].nid);
4976 		for (j = 0; j < alc298_samsung_v2_amp_desc_tbl[i].init_seq_size; j++) {
4977 			alc298_samsung_write_coef_pack(codec,
4978 					alc298_samsung_v2_amp_desc_tbl[i].init_seq[j]);
4979 		}
4980 		alc_write_coef_idx(codec, 0x89, 0x0);
4981 		codec_dbg(codec, "alc298_samsung_v2: Initialized speaker amp 0x%02x\n",
4982 				alc298_samsung_v2_amp_desc_tbl[i].nid);
4983 	}
4984 
4985 	/* register hook to enable speaker amps only when they are needed */
4986 	spec->gen.pcm_playback_hook = alc298_samsung_v2_playback_hook;
4987 }
4988 
alc298_fixup_samsung_amp_v2_2_amps(struct hda_codec * codec,const struct hda_fixup * fix,int action)4989 static void alc298_fixup_samsung_amp_v2_2_amps(struct hda_codec *codec,
4990 				const struct hda_fixup *fix, int action)
4991 {
4992 	if (action == HDA_FIXUP_ACT_PROBE)
4993 		alc298_samsung_v2_init_amps(codec, 2);
4994 }
4995 
alc298_fixup_samsung_amp_v2_4_amps(struct hda_codec * codec,const struct hda_fixup * fix,int action)4996 static void alc298_fixup_samsung_amp_v2_4_amps(struct hda_codec *codec,
4997 				const struct hda_fixup *fix, int action)
4998 {
4999 	if (action == HDA_FIXUP_ACT_PROBE)
5000 		alc298_samsung_v2_init_amps(codec, 4);
5001 }
5002 
gpio2_mic_hotkey_event(struct hda_codec * codec,struct hda_jack_callback * event)5003 static void gpio2_mic_hotkey_event(struct hda_codec *codec,
5004 				   struct hda_jack_callback *event)
5005 {
5006 	struct alc_spec *spec = codec->spec;
5007 
5008 	/* GPIO2 just toggles on a keypress/keyrelease cycle. Therefore
5009 	   send both key on and key off event for every interrupt. */
5010 	input_report_key(spec->kb_dev, spec->alc_mute_keycode_map[ALC_KEY_MICMUTE_INDEX], 1);
5011 	input_sync(spec->kb_dev);
5012 	input_report_key(spec->kb_dev, spec->alc_mute_keycode_map[ALC_KEY_MICMUTE_INDEX], 0);
5013 	input_sync(spec->kb_dev);
5014 }
5015 
alc_register_micmute_input_device(struct hda_codec * codec)5016 static int alc_register_micmute_input_device(struct hda_codec *codec)
5017 {
5018 	struct alc_spec *spec = codec->spec;
5019 	int i;
5020 
5021 	spec->kb_dev = input_allocate_device();
5022 	if (!spec->kb_dev) {
5023 		codec_err(codec, "Out of memory (input_allocate_device)\n");
5024 		return -ENOMEM;
5025 	}
5026 
5027 	spec->alc_mute_keycode_map[ALC_KEY_MICMUTE_INDEX] = KEY_MICMUTE;
5028 
5029 	spec->kb_dev->name = "Microphone Mute Button";
5030 	spec->kb_dev->evbit[0] = BIT_MASK(EV_KEY);
5031 	spec->kb_dev->keycodesize = sizeof(spec->alc_mute_keycode_map[0]);
5032 	spec->kb_dev->keycodemax = ARRAY_SIZE(spec->alc_mute_keycode_map);
5033 	spec->kb_dev->keycode = spec->alc_mute_keycode_map;
5034 	for (i = 0; i < ARRAY_SIZE(spec->alc_mute_keycode_map); i++)
5035 		set_bit(spec->alc_mute_keycode_map[i], spec->kb_dev->keybit);
5036 
5037 	if (input_register_device(spec->kb_dev)) {
5038 		codec_err(codec, "input_register_device failed\n");
5039 		input_free_device(spec->kb_dev);
5040 		spec->kb_dev = NULL;
5041 		return -ENOMEM;
5042 	}
5043 
5044 	return 0;
5045 }
5046 
5047 /* GPIO1 = set according to SKU external amp
5048  * GPIO2 = mic mute hotkey
5049  * GPIO3 = mute LED
5050  * GPIO4 = mic mute LED
5051  */
alc280_fixup_hp_gpio2_mic_hotkey(struct hda_codec * codec,const struct hda_fixup * fix,int action)5052 static void alc280_fixup_hp_gpio2_mic_hotkey(struct hda_codec *codec,
5053 					     const struct hda_fixup *fix, int action)
5054 {
5055 	struct alc_spec *spec = codec->spec;
5056 
5057 	alc_fixup_hp_gpio_led(codec, action, 0x08, 0x10);
5058 	if (action == HDA_FIXUP_ACT_PRE_PROBE) {
5059 		spec->init_amp = ALC_INIT_DEFAULT;
5060 		if (alc_register_micmute_input_device(codec) != 0)
5061 			return;
5062 
5063 		spec->gpio_mask |= 0x06;
5064 		spec->gpio_dir |= 0x02;
5065 		spec->gpio_data |= 0x02;
5066 		snd_hda_codec_write_cache(codec, codec->core.afg, 0,
5067 					  AC_VERB_SET_GPIO_UNSOLICITED_RSP_MASK, 0x04);
5068 		snd_hda_jack_detect_enable_callback(codec, codec->core.afg,
5069 						    gpio2_mic_hotkey_event);
5070 		return;
5071 	}
5072 
5073 	if (!spec->kb_dev)
5074 		return;
5075 
5076 	switch (action) {
5077 	case HDA_FIXUP_ACT_FREE:
5078 		input_unregister_device(spec->kb_dev);
5079 		spec->kb_dev = NULL;
5080 	}
5081 }
5082 
5083 /* Line2 = mic mute hotkey
5084  * GPIO2 = mic mute LED
5085  */
alc233_fixup_lenovo_line2_mic_hotkey(struct hda_codec * codec,const struct hda_fixup * fix,int action)5086 static void alc233_fixup_lenovo_line2_mic_hotkey(struct hda_codec *codec,
5087 					     const struct hda_fixup *fix, int action)
5088 {
5089 	struct alc_spec *spec = codec->spec;
5090 
5091 	alc_fixup_hp_gpio_led(codec, action, 0, 0x04);
5092 	if (action == HDA_FIXUP_ACT_PRE_PROBE) {
5093 		spec->init_amp = ALC_INIT_DEFAULT;
5094 		if (alc_register_micmute_input_device(codec) != 0)
5095 			return;
5096 
5097 		snd_hda_jack_detect_enable_callback(codec, 0x1b,
5098 						    gpio2_mic_hotkey_event);
5099 		return;
5100 	}
5101 
5102 	if (!spec->kb_dev)
5103 		return;
5104 
5105 	switch (action) {
5106 	case HDA_FIXUP_ACT_FREE:
5107 		input_unregister_device(spec->kb_dev);
5108 		spec->kb_dev = NULL;
5109 	}
5110 }
5111 
alc269_fixup_hp_line1_mic1_led(struct hda_codec * codec,const struct hda_fixup * fix,int action)5112 static void alc269_fixup_hp_line1_mic1_led(struct hda_codec *codec,
5113 				const struct hda_fixup *fix, int action)
5114 {
5115 	struct alc_spec *spec = codec->spec;
5116 
5117 	alc269_fixup_hp_mute_led_micx(codec, fix, action, 0x1a);
5118 	if (action == HDA_FIXUP_ACT_PRE_PROBE) {
5119 		spec->cap_mute_led_nid = 0x18;
5120 		snd_hda_gen_add_micmute_led_cdev(codec, vref_micmute_led_set);
5121 	}
5122 }
5123 
alc233_fixup_lenovo_low_en_micmute_led(struct hda_codec * codec,const struct hda_fixup * fix,int action)5124 static void alc233_fixup_lenovo_low_en_micmute_led(struct hda_codec *codec,
5125 				const struct hda_fixup *fix, int action)
5126 {
5127 	struct alc_spec *spec = codec->spec;
5128 
5129 	if (action == HDA_FIXUP_ACT_PRE_PROBE)
5130 		spec->micmute_led_polarity = 1;
5131 	alc233_fixup_lenovo_line2_mic_hotkey(codec, fix, action);
5132 }
5133 
alc_hp_mute_disable(struct hda_codec * codec,unsigned int delay)5134 static void alc_hp_mute_disable(struct hda_codec *codec, unsigned int delay)
5135 {
5136 	if (delay <= 0)
5137 		delay = 75;
5138 	snd_hda_codec_write(codec, 0x21, 0,
5139 		    AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);
5140 	msleep(delay);
5141 	snd_hda_codec_write(codec, 0x21, 0,
5142 		    AC_VERB_SET_PIN_WIDGET_CONTROL, 0x0);
5143 	msleep(delay);
5144 }
5145 
alc_hp_enable_unmute(struct hda_codec * codec,unsigned int delay)5146 static void alc_hp_enable_unmute(struct hda_codec *codec, unsigned int delay)
5147 {
5148 	if (delay <= 0)
5149 		delay = 75;
5150 	snd_hda_codec_write(codec, 0x21, 0,
5151 		    AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT);
5152 	msleep(delay);
5153 	snd_hda_codec_write(codec, 0x21, 0,
5154 		    AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE);
5155 	msleep(delay);
5156 }
5157 
5158 static const struct coef_fw alc225_pre_hsmode[] = {
5159 	UPDATE_COEF(0x4a, 1<<8, 0),
5160 	UPDATE_COEFEX(0x57, 0x05, 1<<14, 0),
5161 	UPDATE_COEF(0x63, 3<<14, 3<<14),
5162 	UPDATE_COEF(0x4a, 3<<4, 2<<4),
5163 	UPDATE_COEF(0x4a, 3<<10, 3<<10),
5164 	UPDATE_COEF(0x45, 0x3f<<10, 0x34<<10),
5165 	UPDATE_COEF(0x4a, 3<<10, 0),
5166 	{}
5167 };
5168 
alc_headset_mode_unplugged(struct hda_codec * codec)5169 static void alc_headset_mode_unplugged(struct hda_codec *codec)
5170 {
5171 	struct alc_spec *spec = codec->spec;
5172 	static const struct coef_fw coef0255[] = {
5173 		WRITE_COEF(0x1b, 0x0c0b), /* LDO and MISC control */
5174 		WRITE_COEF(0x45, 0xd089), /* UAJ function set to menual mode */
5175 		UPDATE_COEFEX(0x57, 0x05, 1<<14, 0), /* Direct Drive HP Amp control(Set to verb control)*/
5176 		WRITE_COEF(0x06, 0x6104), /* Set MIC2 Vref gate with HP */
5177 		WRITE_COEFEX(0x57, 0x03, 0x8aa6), /* Direct Drive HP Amp control */
5178 		{}
5179 	};
5180 	static const struct coef_fw coef0256[] = {
5181 		WRITE_COEF(0x1b, 0x0c4b), /* LDO and MISC control */
5182 		WRITE_COEF(0x45, 0xd089), /* UAJ function set to menual mode */
5183 		WRITE_COEF(0x06, 0x6104), /* Set MIC2 Vref gate with HP */
5184 		WRITE_COEFEX(0x57, 0x03, 0x09a3), /* Direct Drive HP Amp control */
5185 		UPDATE_COEFEX(0x57, 0x05, 1<<14, 0), /* Direct Drive HP Amp control(Set to verb control)*/
5186 		{}
5187 	};
5188 	static const struct coef_fw coef0233[] = {
5189 		WRITE_COEF(0x1b, 0x0c0b),
5190 		WRITE_COEF(0x45, 0xc429),
5191 		UPDATE_COEF(0x35, 0x4000, 0),
5192 		WRITE_COEF(0x06, 0x2104),
5193 		WRITE_COEF(0x1a, 0x0001),
5194 		WRITE_COEF(0x26, 0x0004),
5195 		WRITE_COEF(0x32, 0x42a3),
5196 		{}
5197 	};
5198 	static const struct coef_fw coef0288[] = {
5199 		UPDATE_COEF(0x4f, 0xfcc0, 0xc400),
5200 		UPDATE_COEF(0x50, 0x2000, 0x2000),
5201 		UPDATE_COEF(0x56, 0x0006, 0x0006),
5202 		UPDATE_COEF(0x66, 0x0008, 0),
5203 		UPDATE_COEF(0x67, 0x2000, 0),
5204 		{}
5205 	};
5206 	static const struct coef_fw coef0298[] = {
5207 		UPDATE_COEF(0x19, 0x1300, 0x0300),
5208 		{}
5209 	};
5210 	static const struct coef_fw coef0292[] = {
5211 		WRITE_COEF(0x76, 0x000e),
5212 		WRITE_COEF(0x6c, 0x2400),
5213 		WRITE_COEF(0x18, 0x7308),
5214 		WRITE_COEF(0x6b, 0xc429),
5215 		{}
5216 	};
5217 	static const struct coef_fw coef0293[] = {
5218 		UPDATE_COEF(0x10, 7<<8, 6<<8), /* SET Line1 JD to 0 */
5219 		UPDATE_COEFEX(0x57, 0x05, 1<<15|1<<13, 0x0), /* SET charge pump by verb */
5220 		UPDATE_COEFEX(0x57, 0x03, 1<<10, 1<<10), /* SET EN_OSW to 1 */
5221 		UPDATE_COEF(0x1a, 1<<3, 1<<3), /* Combo JD gating with LINE1-VREFO */
5222 		WRITE_COEF(0x45, 0xc429), /* Set to TRS type */
5223 		UPDATE_COEF(0x4a, 0x000f, 0x000e), /* Combo Jack auto detect */
5224 		{}
5225 	};
5226 	static const struct coef_fw coef0668[] = {
5227 		WRITE_COEF(0x15, 0x0d40),
5228 		WRITE_COEF(0xb7, 0x802b),
5229 		{}
5230 	};
5231 	static const struct coef_fw coef0225[] = {
5232 		UPDATE_COEF(0x63, 3<<14, 0),
5233 		{}
5234 	};
5235 	static const struct coef_fw coef0274[] = {
5236 		UPDATE_COEF(0x4a, 0x0100, 0),
5237 		UPDATE_COEFEX(0x57, 0x05, 0x4000, 0),
5238 		UPDATE_COEF(0x6b, 0xf000, 0x5000),
5239 		UPDATE_COEF(0x4a, 0x0010, 0),
5240 		UPDATE_COEF(0x4a, 0x0c00, 0x0c00),
5241 		WRITE_COEF(0x45, 0x5289),
5242 		UPDATE_COEF(0x4a, 0x0c00, 0),
5243 		{}
5244 	};
5245 
5246 	if (spec->no_internal_mic_pin) {
5247 		alc_update_coef_idx(codec, 0x45, 0xf<<12 | 1<<10, 5<<12);
5248 		return;
5249 	}
5250 
5251 	switch (codec->core.vendor_id) {
5252 	case 0x10ec0255:
5253 		alc_process_coef_fw(codec, coef0255);
5254 		break;
5255 	case 0x10ec0230:
5256 	case 0x10ec0236:
5257 	case 0x10ec0256:
5258 	case 0x19e58326:
5259 		alc_hp_mute_disable(codec, 75);
5260 		alc_process_coef_fw(codec, coef0256);
5261 		break;
5262 	case 0x10ec0234:
5263 	case 0x10ec0274:
5264 	case 0x10ec0294:
5265 		alc_process_coef_fw(codec, coef0274);
5266 		break;
5267 	case 0x10ec0233:
5268 	case 0x10ec0283:
5269 		alc_process_coef_fw(codec, coef0233);
5270 		break;
5271 	case 0x10ec0286:
5272 	case 0x10ec0288:
5273 		alc_process_coef_fw(codec, coef0288);
5274 		break;
5275 	case 0x10ec0298:
5276 		alc_process_coef_fw(codec, coef0298);
5277 		alc_process_coef_fw(codec, coef0288);
5278 		break;
5279 	case 0x10ec0292:
5280 		alc_process_coef_fw(codec, coef0292);
5281 		break;
5282 	case 0x10ec0293:
5283 		alc_process_coef_fw(codec, coef0293);
5284 		break;
5285 	case 0x10ec0668:
5286 		alc_process_coef_fw(codec, coef0668);
5287 		break;
5288 	case 0x10ec0215:
5289 	case 0x10ec0225:
5290 	case 0x10ec0285:
5291 	case 0x10ec0295:
5292 	case 0x10ec0289:
5293 	case 0x10ec0299:
5294 		alc_hp_mute_disable(codec, 75);
5295 		alc_process_coef_fw(codec, alc225_pre_hsmode);
5296 		alc_process_coef_fw(codec, coef0225);
5297 		break;
5298 	case 0x10ec0867:
5299 		alc_update_coefex_idx(codec, 0x57, 0x5, 1<<14, 0);
5300 		break;
5301 	}
5302 	codec_dbg(codec, "Headset jack set to unplugged mode.\n");
5303 }
5304 
5305 
alc_headset_mode_mic_in(struct hda_codec * codec,hda_nid_t hp_pin,hda_nid_t mic_pin)5306 static void alc_headset_mode_mic_in(struct hda_codec *codec, hda_nid_t hp_pin,
5307 				    hda_nid_t mic_pin)
5308 {
5309 	static const struct coef_fw coef0255[] = {
5310 		WRITE_COEFEX(0x57, 0x03, 0x8aa6),
5311 		WRITE_COEF(0x06, 0x6100), /* Set MIC2 Vref gate to normal */
5312 		{}
5313 	};
5314 	static const struct coef_fw coef0256[] = {
5315 		UPDATE_COEFEX(0x57, 0x05, 1<<14, 1<<14), /* Direct Drive HP Amp control(Set to verb control)*/
5316 		WRITE_COEFEX(0x57, 0x03, 0x09a3),
5317 		WRITE_COEF(0x06, 0x6100), /* Set MIC2 Vref gate to normal */
5318 		{}
5319 	};
5320 	static const struct coef_fw coef0233[] = {
5321 		UPDATE_COEF(0x35, 0, 1<<14),
5322 		WRITE_COEF(0x06, 0x2100),
5323 		WRITE_COEF(0x1a, 0x0021),
5324 		WRITE_COEF(0x26, 0x008c),
5325 		{}
5326 	};
5327 	static const struct coef_fw coef0288[] = {
5328 		UPDATE_COEF(0x4f, 0x00c0, 0),
5329 		UPDATE_COEF(0x50, 0x2000, 0),
5330 		UPDATE_COEF(0x56, 0x0006, 0),
5331 		UPDATE_COEF(0x4f, 0xfcc0, 0xc400),
5332 		UPDATE_COEF(0x66, 0x0008, 0x0008),
5333 		UPDATE_COEF(0x67, 0x2000, 0x2000),
5334 		{}
5335 	};
5336 	static const struct coef_fw coef0292[] = {
5337 		WRITE_COEF(0x19, 0xa208),
5338 		WRITE_COEF(0x2e, 0xacf0),
5339 		{}
5340 	};
5341 	static const struct coef_fw coef0293[] = {
5342 		UPDATE_COEFEX(0x57, 0x05, 0, 1<<15|1<<13), /* SET charge pump by verb */
5343 		UPDATE_COEFEX(0x57, 0x03, 1<<10, 0), /* SET EN_OSW to 0 */
5344 		UPDATE_COEF(0x1a, 1<<3, 0), /* Combo JD gating without LINE1-VREFO */
5345 		{}
5346 	};
5347 	static const struct coef_fw coef0688[] = {
5348 		WRITE_COEF(0xb7, 0x802b),
5349 		WRITE_COEF(0xb5, 0x1040),
5350 		UPDATE_COEF(0xc3, 0, 1<<12),
5351 		{}
5352 	};
5353 	static const struct coef_fw coef0225[] = {
5354 		UPDATE_COEFEX(0x57, 0x05, 1<<14, 1<<14),
5355 		UPDATE_COEF(0x4a, 3<<4, 2<<4),
5356 		UPDATE_COEF(0x63, 3<<14, 0),
5357 		{}
5358 	};
5359 	static const struct coef_fw coef0274[] = {
5360 		UPDATE_COEFEX(0x57, 0x05, 0x4000, 0x4000),
5361 		UPDATE_COEF(0x4a, 0x0010, 0),
5362 		UPDATE_COEF(0x6b, 0xf000, 0),
5363 		{}
5364 	};
5365 
5366 	switch (codec->core.vendor_id) {
5367 	case 0x10ec0255:
5368 		alc_write_coef_idx(codec, 0x45, 0xc489);
5369 		snd_hda_set_pin_ctl_cache(codec, hp_pin, 0);
5370 		alc_process_coef_fw(codec, coef0255);
5371 		snd_hda_set_pin_ctl_cache(codec, mic_pin, PIN_VREF50);
5372 		break;
5373 	case 0x10ec0230:
5374 	case 0x10ec0236:
5375 	case 0x10ec0256:
5376 	case 0x19e58326:
5377 		alc_write_coef_idx(codec, 0x45, 0xc489);
5378 		snd_hda_set_pin_ctl_cache(codec, hp_pin, 0);
5379 		alc_process_coef_fw(codec, coef0256);
5380 		snd_hda_set_pin_ctl_cache(codec, mic_pin, PIN_VREF50);
5381 		break;
5382 	case 0x10ec0234:
5383 	case 0x10ec0274:
5384 	case 0x10ec0294:
5385 		alc_write_coef_idx(codec, 0x45, 0x4689);
5386 		snd_hda_set_pin_ctl_cache(codec, hp_pin, 0);
5387 		alc_process_coef_fw(codec, coef0274);
5388 		snd_hda_set_pin_ctl_cache(codec, mic_pin, PIN_VREF50);
5389 		break;
5390 	case 0x10ec0233:
5391 	case 0x10ec0283:
5392 		alc_write_coef_idx(codec, 0x45, 0xc429);
5393 		snd_hda_set_pin_ctl_cache(codec, hp_pin, 0);
5394 		alc_process_coef_fw(codec, coef0233);
5395 		snd_hda_set_pin_ctl_cache(codec, mic_pin, PIN_VREF50);
5396 		break;
5397 	case 0x10ec0286:
5398 	case 0x10ec0288:
5399 	case 0x10ec0298:
5400 		snd_hda_set_pin_ctl_cache(codec, hp_pin, 0);
5401 		alc_process_coef_fw(codec, coef0288);
5402 		snd_hda_set_pin_ctl_cache(codec, mic_pin, PIN_VREF50);
5403 		break;
5404 	case 0x10ec0292:
5405 		snd_hda_set_pin_ctl_cache(codec, hp_pin, 0);
5406 		alc_process_coef_fw(codec, coef0292);
5407 		break;
5408 	case 0x10ec0293:
5409 		/* Set to TRS mode */
5410 		alc_write_coef_idx(codec, 0x45, 0xc429);
5411 		snd_hda_set_pin_ctl_cache(codec, hp_pin, 0);
5412 		alc_process_coef_fw(codec, coef0293);
5413 		snd_hda_set_pin_ctl_cache(codec, mic_pin, PIN_VREF50);
5414 		break;
5415 	case 0x10ec0867:
5416 		alc_update_coefex_idx(codec, 0x57, 0x5, 0, 1<<14);
5417 		fallthrough;
5418 	case 0x10ec0221:
5419 	case 0x10ec0662:
5420 		snd_hda_set_pin_ctl_cache(codec, hp_pin, 0);
5421 		snd_hda_set_pin_ctl_cache(codec, mic_pin, PIN_VREF50);
5422 		break;
5423 	case 0x10ec0668:
5424 		alc_write_coef_idx(codec, 0x11, 0x0001);
5425 		snd_hda_set_pin_ctl_cache(codec, hp_pin, 0);
5426 		alc_process_coef_fw(codec, coef0688);
5427 		snd_hda_set_pin_ctl_cache(codec, mic_pin, PIN_VREF50);
5428 		break;
5429 	case 0x10ec0215:
5430 	case 0x10ec0225:
5431 	case 0x10ec0285:
5432 	case 0x10ec0295:
5433 	case 0x10ec0289:
5434 	case 0x10ec0299:
5435 		alc_process_coef_fw(codec, alc225_pre_hsmode);
5436 		alc_update_coef_idx(codec, 0x45, 0x3f<<10, 0x31<<10);
5437 		snd_hda_set_pin_ctl_cache(codec, hp_pin, 0);
5438 		alc_process_coef_fw(codec, coef0225);
5439 		snd_hda_set_pin_ctl_cache(codec, mic_pin, PIN_VREF50);
5440 		break;
5441 	}
5442 	codec_dbg(codec, "Headset jack set to mic-in mode.\n");
5443 }
5444 
alc_headset_mode_default(struct hda_codec * codec)5445 static void alc_headset_mode_default(struct hda_codec *codec)
5446 {
5447 	static const struct coef_fw coef0225[] = {
5448 		UPDATE_COEF(0x45, 0x3f<<10, 0x30<<10),
5449 		UPDATE_COEF(0x45, 0x3f<<10, 0x31<<10),
5450 		UPDATE_COEF(0x49, 3<<8, 0<<8),
5451 		UPDATE_COEF(0x4a, 3<<4, 3<<4),
5452 		UPDATE_COEF(0x63, 3<<14, 0),
5453 		UPDATE_COEF(0x67, 0xf000, 0x3000),
5454 		{}
5455 	};
5456 	static const struct coef_fw coef0255[] = {
5457 		WRITE_COEF(0x45, 0xc089),
5458 		WRITE_COEF(0x45, 0xc489),
5459 		WRITE_COEFEX(0x57, 0x03, 0x8ea6),
5460 		WRITE_COEF(0x49, 0x0049),
5461 		{}
5462 	};
5463 	static const struct coef_fw coef0256[] = {
5464 		WRITE_COEF(0x45, 0xc489),
5465 		WRITE_COEFEX(0x57, 0x03, 0x0da3),
5466 		WRITE_COEF(0x49, 0x0049),
5467 		UPDATE_COEFEX(0x57, 0x05, 1<<14, 0), /* Direct Drive HP Amp control(Set to verb control)*/
5468 		WRITE_COEF(0x06, 0x6100),
5469 		{}
5470 	};
5471 	static const struct coef_fw coef0233[] = {
5472 		WRITE_COEF(0x06, 0x2100),
5473 		WRITE_COEF(0x32, 0x4ea3),
5474 		{}
5475 	};
5476 	static const struct coef_fw coef0288[] = {
5477 		UPDATE_COEF(0x4f, 0xfcc0, 0xc400), /* Set to TRS type */
5478 		UPDATE_COEF(0x50, 0x2000, 0x2000),
5479 		UPDATE_COEF(0x56, 0x0006, 0x0006),
5480 		UPDATE_COEF(0x66, 0x0008, 0),
5481 		UPDATE_COEF(0x67, 0x2000, 0),
5482 		{}
5483 	};
5484 	static const struct coef_fw coef0292[] = {
5485 		WRITE_COEF(0x76, 0x000e),
5486 		WRITE_COEF(0x6c, 0x2400),
5487 		WRITE_COEF(0x6b, 0xc429),
5488 		WRITE_COEF(0x18, 0x7308),
5489 		{}
5490 	};
5491 	static const struct coef_fw coef0293[] = {
5492 		UPDATE_COEF(0x4a, 0x000f, 0x000e), /* Combo Jack auto detect */
5493 		WRITE_COEF(0x45, 0xC429), /* Set to TRS type */
5494 		UPDATE_COEF(0x1a, 1<<3, 0), /* Combo JD gating without LINE1-VREFO */
5495 		{}
5496 	};
5497 	static const struct coef_fw coef0688[] = {
5498 		WRITE_COEF(0x11, 0x0041),
5499 		WRITE_COEF(0x15, 0x0d40),
5500 		WRITE_COEF(0xb7, 0x802b),
5501 		{}
5502 	};
5503 	static const struct coef_fw coef0274[] = {
5504 		WRITE_COEF(0x45, 0x4289),
5505 		UPDATE_COEF(0x4a, 0x0010, 0x0010),
5506 		UPDATE_COEF(0x6b, 0x0f00, 0),
5507 		UPDATE_COEF(0x49, 0x0300, 0x0300),
5508 		{}
5509 	};
5510 
5511 	switch (codec->core.vendor_id) {
5512 	case 0x10ec0215:
5513 	case 0x10ec0225:
5514 	case 0x10ec0285:
5515 	case 0x10ec0295:
5516 	case 0x10ec0289:
5517 	case 0x10ec0299:
5518 		alc_process_coef_fw(codec, alc225_pre_hsmode);
5519 		alc_process_coef_fw(codec, coef0225);
5520 		alc_hp_enable_unmute(codec, 75);
5521 		break;
5522 	case 0x10ec0255:
5523 		alc_process_coef_fw(codec, coef0255);
5524 		break;
5525 	case 0x10ec0230:
5526 	case 0x10ec0236:
5527 	case 0x10ec0256:
5528 	case 0x19e58326:
5529 		alc_write_coef_idx(codec, 0x1b, 0x0e4b);
5530 		alc_write_coef_idx(codec, 0x45, 0xc089);
5531 		msleep(50);
5532 		alc_process_coef_fw(codec, coef0256);
5533 		alc_hp_enable_unmute(codec, 75);
5534 		break;
5535 	case 0x10ec0234:
5536 	case 0x10ec0274:
5537 	case 0x10ec0294:
5538 		alc_process_coef_fw(codec, coef0274);
5539 		break;
5540 	case 0x10ec0233:
5541 	case 0x10ec0283:
5542 		alc_process_coef_fw(codec, coef0233);
5543 		break;
5544 	case 0x10ec0286:
5545 	case 0x10ec0288:
5546 	case 0x10ec0298:
5547 		alc_process_coef_fw(codec, coef0288);
5548 		break;
5549 	case 0x10ec0292:
5550 		alc_process_coef_fw(codec, coef0292);
5551 		break;
5552 	case 0x10ec0293:
5553 		alc_process_coef_fw(codec, coef0293);
5554 		break;
5555 	case 0x10ec0668:
5556 		alc_process_coef_fw(codec, coef0688);
5557 		break;
5558 	case 0x10ec0867:
5559 		alc_update_coefex_idx(codec, 0x57, 0x5, 1<<14, 0);
5560 		break;
5561 	}
5562 	codec_dbg(codec, "Headset jack set to headphone (default) mode.\n");
5563 }
5564 
5565 /* Iphone type */
alc_headset_mode_ctia(struct hda_codec * codec)5566 static void alc_headset_mode_ctia(struct hda_codec *codec)
5567 {
5568 	int val;
5569 
5570 	static const struct coef_fw coef0255[] = {
5571 		WRITE_COEF(0x45, 0xd489), /* Set to CTIA type */
5572 		WRITE_COEF(0x1b, 0x0c2b),
5573 		WRITE_COEFEX(0x57, 0x03, 0x8ea6),
5574 		{}
5575 	};
5576 	static const struct coef_fw coef0256[] = {
5577 		WRITE_COEF(0x45, 0xd489), /* Set to CTIA type */
5578 		WRITE_COEF(0x1b, 0x0e6b),
5579 		{}
5580 	};
5581 	static const struct coef_fw coef0233[] = {
5582 		WRITE_COEF(0x45, 0xd429),
5583 		WRITE_COEF(0x1b, 0x0c2b),
5584 		WRITE_COEF(0x32, 0x4ea3),
5585 		{}
5586 	};
5587 	static const struct coef_fw coef0288[] = {
5588 		UPDATE_COEF(0x50, 0x2000, 0x2000),
5589 		UPDATE_COEF(0x56, 0x0006, 0x0006),
5590 		UPDATE_COEF(0x66, 0x0008, 0),
5591 		UPDATE_COEF(0x67, 0x2000, 0),
5592 		{}
5593 	};
5594 	static const struct coef_fw coef0292[] = {
5595 		WRITE_COEF(0x6b, 0xd429),
5596 		WRITE_COEF(0x76, 0x0008),
5597 		WRITE_COEF(0x18, 0x7388),
5598 		{}
5599 	};
5600 	static const struct coef_fw coef0293[] = {
5601 		WRITE_COEF(0x45, 0xd429), /* Set to ctia type */
5602 		UPDATE_COEF(0x10, 7<<8, 7<<8), /* SET Line1 JD to 1 */
5603 		{}
5604 	};
5605 	static const struct coef_fw coef0688[] = {
5606 		WRITE_COEF(0x11, 0x0001),
5607 		WRITE_COEF(0x15, 0x0d60),
5608 		WRITE_COEF(0xc3, 0x0000),
5609 		{}
5610 	};
5611 	static const struct coef_fw coef0225_1[] = {
5612 		UPDATE_COEF(0x45, 0x3f<<10, 0x35<<10),
5613 		UPDATE_COEF(0x63, 3<<14, 2<<14),
5614 		{}
5615 	};
5616 	static const struct coef_fw coef0225_2[] = {
5617 		UPDATE_COEF(0x45, 0x3f<<10, 0x35<<10),
5618 		UPDATE_COEF(0x63, 3<<14, 1<<14),
5619 		{}
5620 	};
5621 
5622 	switch (codec->core.vendor_id) {
5623 	case 0x10ec0255:
5624 		alc_process_coef_fw(codec, coef0255);
5625 		break;
5626 	case 0x10ec0230:
5627 	case 0x10ec0236:
5628 	case 0x10ec0256:
5629 	case 0x19e58326:
5630 		alc_process_coef_fw(codec, coef0256);
5631 		alc_hp_enable_unmute(codec, 75);
5632 		break;
5633 	case 0x10ec0234:
5634 	case 0x10ec0274:
5635 	case 0x10ec0294:
5636 		alc_write_coef_idx(codec, 0x45, 0xd689);
5637 		break;
5638 	case 0x10ec0233:
5639 	case 0x10ec0283:
5640 		alc_process_coef_fw(codec, coef0233);
5641 		break;
5642 	case 0x10ec0298:
5643 		val = alc_read_coef_idx(codec, 0x50);
5644 		if (val & (1 << 12)) {
5645 			alc_update_coef_idx(codec, 0x8e, 0x0070, 0x0020);
5646 			alc_update_coef_idx(codec, 0x4f, 0xfcc0, 0xd400);
5647 			msleep(300);
5648 		} else {
5649 			alc_update_coef_idx(codec, 0x8e, 0x0070, 0x0010);
5650 			alc_update_coef_idx(codec, 0x4f, 0xfcc0, 0xd400);
5651 			msleep(300);
5652 		}
5653 		break;
5654 	case 0x10ec0286:
5655 	case 0x10ec0288:
5656 		alc_update_coef_idx(codec, 0x4f, 0xfcc0, 0xd400);
5657 		msleep(300);
5658 		alc_process_coef_fw(codec, coef0288);
5659 		break;
5660 	case 0x10ec0292:
5661 		alc_process_coef_fw(codec, coef0292);
5662 		break;
5663 	case 0x10ec0293:
5664 		alc_process_coef_fw(codec, coef0293);
5665 		break;
5666 	case 0x10ec0668:
5667 		alc_process_coef_fw(codec, coef0688);
5668 		break;
5669 	case 0x10ec0215:
5670 	case 0x10ec0225:
5671 	case 0x10ec0285:
5672 	case 0x10ec0295:
5673 	case 0x10ec0289:
5674 	case 0x10ec0299:
5675 		val = alc_read_coef_idx(codec, 0x45);
5676 		if (val & (1 << 9))
5677 			alc_process_coef_fw(codec, coef0225_2);
5678 		else
5679 			alc_process_coef_fw(codec, coef0225_1);
5680 		alc_hp_enable_unmute(codec, 75);
5681 		break;
5682 	case 0x10ec0867:
5683 		alc_update_coefex_idx(codec, 0x57, 0x5, 1<<14, 0);
5684 		break;
5685 	}
5686 	codec_dbg(codec, "Headset jack set to iPhone-style headset mode.\n");
5687 }
5688 
5689 /* Nokia type */
alc_headset_mode_omtp(struct hda_codec * codec)5690 static void alc_headset_mode_omtp(struct hda_codec *codec)
5691 {
5692 	static const struct coef_fw coef0255[] = {
5693 		WRITE_COEF(0x45, 0xe489), /* Set to OMTP Type */
5694 		WRITE_COEF(0x1b, 0x0c2b),
5695 		WRITE_COEFEX(0x57, 0x03, 0x8ea6),
5696 		{}
5697 	};
5698 	static const struct coef_fw coef0256[] = {
5699 		WRITE_COEF(0x45, 0xe489), /* Set to OMTP Type */
5700 		WRITE_COEF(0x1b, 0x0e6b),
5701 		{}
5702 	};
5703 	static const struct coef_fw coef0233[] = {
5704 		WRITE_COEF(0x45, 0xe429),
5705 		WRITE_COEF(0x1b, 0x0c2b),
5706 		WRITE_COEF(0x32, 0x4ea3),
5707 		{}
5708 	};
5709 	static const struct coef_fw coef0288[] = {
5710 		UPDATE_COEF(0x50, 0x2000, 0x2000),
5711 		UPDATE_COEF(0x56, 0x0006, 0x0006),
5712 		UPDATE_COEF(0x66, 0x0008, 0),
5713 		UPDATE_COEF(0x67, 0x2000, 0),
5714 		{}
5715 	};
5716 	static const struct coef_fw coef0292[] = {
5717 		WRITE_COEF(0x6b, 0xe429),
5718 		WRITE_COEF(0x76, 0x0008),
5719 		WRITE_COEF(0x18, 0x7388),
5720 		{}
5721 	};
5722 	static const struct coef_fw coef0293[] = {
5723 		WRITE_COEF(0x45, 0xe429), /* Set to omtp type */
5724 		UPDATE_COEF(0x10, 7<<8, 7<<8), /* SET Line1 JD to 1 */
5725 		{}
5726 	};
5727 	static const struct coef_fw coef0688[] = {
5728 		WRITE_COEF(0x11, 0x0001),
5729 		WRITE_COEF(0x15, 0x0d50),
5730 		WRITE_COEF(0xc3, 0x0000),
5731 		{}
5732 	};
5733 	static const struct coef_fw coef0225[] = {
5734 		UPDATE_COEF(0x45, 0x3f<<10, 0x39<<10),
5735 		UPDATE_COEF(0x63, 3<<14, 2<<14),
5736 		{}
5737 	};
5738 
5739 	switch (codec->core.vendor_id) {
5740 	case 0x10ec0255:
5741 		alc_process_coef_fw(codec, coef0255);
5742 		break;
5743 	case 0x10ec0230:
5744 	case 0x10ec0236:
5745 	case 0x10ec0256:
5746 	case 0x19e58326:
5747 		alc_process_coef_fw(codec, coef0256);
5748 		alc_hp_enable_unmute(codec, 75);
5749 		break;
5750 	case 0x10ec0234:
5751 	case 0x10ec0274:
5752 	case 0x10ec0294:
5753 		alc_write_coef_idx(codec, 0x45, 0xe689);
5754 		break;
5755 	case 0x10ec0233:
5756 	case 0x10ec0283:
5757 		alc_process_coef_fw(codec, coef0233);
5758 		break;
5759 	case 0x10ec0298:
5760 		alc_update_coef_idx(codec, 0x8e, 0x0070, 0x0010);/* Headset output enable */
5761 		alc_update_coef_idx(codec, 0x4f, 0xfcc0, 0xe400);
5762 		msleep(300);
5763 		break;
5764 	case 0x10ec0286:
5765 	case 0x10ec0288:
5766 		alc_update_coef_idx(codec, 0x4f, 0xfcc0, 0xe400);
5767 		msleep(300);
5768 		alc_process_coef_fw(codec, coef0288);
5769 		break;
5770 	case 0x10ec0292:
5771 		alc_process_coef_fw(codec, coef0292);
5772 		break;
5773 	case 0x10ec0293:
5774 		alc_process_coef_fw(codec, coef0293);
5775 		break;
5776 	case 0x10ec0668:
5777 		alc_process_coef_fw(codec, coef0688);
5778 		break;
5779 	case 0x10ec0215:
5780 	case 0x10ec0225:
5781 	case 0x10ec0285:
5782 	case 0x10ec0295:
5783 	case 0x10ec0289:
5784 	case 0x10ec0299:
5785 		alc_process_coef_fw(codec, coef0225);
5786 		alc_hp_enable_unmute(codec, 75);
5787 		break;
5788 	}
5789 	codec_dbg(codec, "Headset jack set to Nokia-style headset mode.\n");
5790 }
5791 
alc_determine_headset_type(struct hda_codec * codec)5792 static void alc_determine_headset_type(struct hda_codec *codec)
5793 {
5794 	int val;
5795 	bool is_ctia = false;
5796 	struct alc_spec *spec = codec->spec;
5797 	static const struct coef_fw coef0255[] = {
5798 		WRITE_COEF(0x45, 0xd089), /* combo jack auto switch control(Check type)*/
5799 		WRITE_COEF(0x49, 0x0149), /* combo jack auto switch control(Vref
5800  conteol) */
5801 		{}
5802 	};
5803 	static const struct coef_fw coef0288[] = {
5804 		UPDATE_COEF(0x4f, 0xfcc0, 0xd400), /* Check Type */
5805 		{}
5806 	};
5807 	static const struct coef_fw coef0298[] = {
5808 		UPDATE_COEF(0x50, 0x2000, 0x2000),
5809 		UPDATE_COEF(0x56, 0x0006, 0x0006),
5810 		UPDATE_COEF(0x66, 0x0008, 0),
5811 		UPDATE_COEF(0x67, 0x2000, 0),
5812 		UPDATE_COEF(0x19, 0x1300, 0x1300),
5813 		{}
5814 	};
5815 	static const struct coef_fw coef0293[] = {
5816 		UPDATE_COEF(0x4a, 0x000f, 0x0008), /* Combo Jack auto detect */
5817 		WRITE_COEF(0x45, 0xD429), /* Set to ctia type */
5818 		{}
5819 	};
5820 	static const struct coef_fw coef0688[] = {
5821 		WRITE_COEF(0x11, 0x0001),
5822 		WRITE_COEF(0xb7, 0x802b),
5823 		WRITE_COEF(0x15, 0x0d60),
5824 		WRITE_COEF(0xc3, 0x0c00),
5825 		{}
5826 	};
5827 	static const struct coef_fw coef0274[] = {
5828 		UPDATE_COEF(0x4a, 0x0010, 0),
5829 		UPDATE_COEF(0x4a, 0x8000, 0),
5830 		WRITE_COEF(0x45, 0xd289),
5831 		UPDATE_COEF(0x49, 0x0300, 0x0300),
5832 		{}
5833 	};
5834 
5835 	if (spec->no_internal_mic_pin) {
5836 		alc_update_coef_idx(codec, 0x45, 0xf<<12 | 1<<10, 5<<12);
5837 		return;
5838 	}
5839 
5840 	switch (codec->core.vendor_id) {
5841 	case 0x10ec0255:
5842 		alc_process_coef_fw(codec, coef0255);
5843 		msleep(300);
5844 		val = alc_read_coef_idx(codec, 0x46);
5845 		is_ctia = (val & 0x0070) == 0x0070;
5846 		break;
5847 	case 0x10ec0230:
5848 	case 0x10ec0236:
5849 	case 0x10ec0256:
5850 	case 0x19e58326:
5851 		alc_write_coef_idx(codec, 0x1b, 0x0e4b);
5852 		alc_write_coef_idx(codec, 0x06, 0x6104);
5853 		alc_write_coefex_idx(codec, 0x57, 0x3, 0x09a3);
5854 
5855 		alc_process_coef_fw(codec, coef0255);
5856 		msleep(300);
5857 		val = alc_read_coef_idx(codec, 0x46);
5858 		is_ctia = (val & 0x0070) == 0x0070;
5859 		if (!is_ctia) {
5860 			alc_write_coef_idx(codec, 0x45, 0xe089);
5861 			msleep(100);
5862 			val = alc_read_coef_idx(codec, 0x46);
5863 			if ((val & 0x0070) == 0x0070)
5864 				is_ctia = false;
5865 			else
5866 				is_ctia = true;
5867 		}
5868 		alc_write_coefex_idx(codec, 0x57, 0x3, 0x0da3);
5869 		alc_update_coefex_idx(codec, 0x57, 0x5, 1<<14, 0);
5870 		break;
5871 	case 0x10ec0234:
5872 	case 0x10ec0274:
5873 	case 0x10ec0294:
5874 		alc_process_coef_fw(codec, coef0274);
5875 		msleep(850);
5876 		val = alc_read_coef_idx(codec, 0x46);
5877 		is_ctia = (val & 0x00f0) == 0x00f0;
5878 		break;
5879 	case 0x10ec0233:
5880 	case 0x10ec0283:
5881 		alc_write_coef_idx(codec, 0x45, 0xd029);
5882 		msleep(300);
5883 		val = alc_read_coef_idx(codec, 0x46);
5884 		is_ctia = (val & 0x0070) == 0x0070;
5885 		break;
5886 	case 0x10ec0298:
5887 		snd_hda_codec_write(codec, 0x21, 0,
5888 			    AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);
5889 		msleep(100);
5890 		snd_hda_codec_write(codec, 0x21, 0,
5891 			    AC_VERB_SET_PIN_WIDGET_CONTROL, 0x0);
5892 		msleep(200);
5893 
5894 		val = alc_read_coef_idx(codec, 0x50);
5895 		if (val & (1 << 12)) {
5896 			alc_update_coef_idx(codec, 0x8e, 0x0070, 0x0020);
5897 			alc_process_coef_fw(codec, coef0288);
5898 			msleep(350);
5899 			val = alc_read_coef_idx(codec, 0x50);
5900 			is_ctia = (val & 0x0070) == 0x0070;
5901 		} else {
5902 			alc_update_coef_idx(codec, 0x8e, 0x0070, 0x0010);
5903 			alc_process_coef_fw(codec, coef0288);
5904 			msleep(350);
5905 			val = alc_read_coef_idx(codec, 0x50);
5906 			is_ctia = (val & 0x0070) == 0x0070;
5907 		}
5908 		alc_process_coef_fw(codec, coef0298);
5909 		snd_hda_codec_write(codec, 0x21, 0,
5910 			    AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP);
5911 		msleep(75);
5912 		snd_hda_codec_write(codec, 0x21, 0,
5913 			    AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE);
5914 		break;
5915 	case 0x10ec0286:
5916 	case 0x10ec0288:
5917 		alc_process_coef_fw(codec, coef0288);
5918 		msleep(350);
5919 		val = alc_read_coef_idx(codec, 0x50);
5920 		is_ctia = (val & 0x0070) == 0x0070;
5921 		break;
5922 	case 0x10ec0292:
5923 		alc_write_coef_idx(codec, 0x6b, 0xd429);
5924 		msleep(300);
5925 		val = alc_read_coef_idx(codec, 0x6c);
5926 		is_ctia = (val & 0x001c) == 0x001c;
5927 		break;
5928 	case 0x10ec0293:
5929 		alc_process_coef_fw(codec, coef0293);
5930 		msleep(300);
5931 		val = alc_read_coef_idx(codec, 0x46);
5932 		is_ctia = (val & 0x0070) == 0x0070;
5933 		break;
5934 	case 0x10ec0668:
5935 		alc_process_coef_fw(codec, coef0688);
5936 		msleep(300);
5937 		val = alc_read_coef_idx(codec, 0xbe);
5938 		is_ctia = (val & 0x1c02) == 0x1c02;
5939 		break;
5940 	case 0x10ec0215:
5941 	case 0x10ec0225:
5942 	case 0x10ec0285:
5943 	case 0x10ec0295:
5944 	case 0x10ec0289:
5945 	case 0x10ec0299:
5946 		alc_process_coef_fw(codec, alc225_pre_hsmode);
5947 		alc_update_coef_idx(codec, 0x67, 0xf000, 0x1000);
5948 		val = alc_read_coef_idx(codec, 0x45);
5949 		if (val & (1 << 9)) {
5950 			alc_update_coef_idx(codec, 0x45, 0x3f<<10, 0x34<<10);
5951 			alc_update_coef_idx(codec, 0x49, 3<<8, 2<<8);
5952 			msleep(800);
5953 			val = alc_read_coef_idx(codec, 0x46);
5954 			is_ctia = (val & 0x00f0) == 0x00f0;
5955 		} else {
5956 			alc_update_coef_idx(codec, 0x45, 0x3f<<10, 0x34<<10);
5957 			alc_update_coef_idx(codec, 0x49, 3<<8, 1<<8);
5958 			msleep(800);
5959 			val = alc_read_coef_idx(codec, 0x46);
5960 			is_ctia = (val & 0x00f0) == 0x00f0;
5961 		}
5962 		if (!is_ctia) {
5963 			alc_update_coef_idx(codec, 0x45, 0x3f<<10, 0x38<<10);
5964 			alc_update_coef_idx(codec, 0x49, 3<<8, 1<<8);
5965 			msleep(100);
5966 			val = alc_read_coef_idx(codec, 0x46);
5967 			if ((val & 0x00f0) == 0x00f0)
5968 				is_ctia = false;
5969 			else
5970 				is_ctia = true;
5971 		}
5972 		alc_update_coef_idx(codec, 0x4a, 7<<6, 7<<6);
5973 		alc_update_coef_idx(codec, 0x4a, 3<<4, 3<<4);
5974 		alc_update_coef_idx(codec, 0x67, 0xf000, 0x3000);
5975 		break;
5976 	case 0x10ec0867:
5977 		is_ctia = true;
5978 		break;
5979 	}
5980 
5981 	codec_dbg(codec, "Headset jack detected iPhone-style headset: %s\n",
5982 		  str_yes_no(is_ctia));
5983 	spec->current_headset_type = is_ctia ? ALC_HEADSET_TYPE_CTIA : ALC_HEADSET_TYPE_OMTP;
5984 }
5985 
alc_update_headset_mode(struct hda_codec * codec)5986 static void alc_update_headset_mode(struct hda_codec *codec)
5987 {
5988 	struct alc_spec *spec = codec->spec;
5989 
5990 	hda_nid_t mux_pin = spec->gen.imux_pins[spec->gen.cur_mux[0]];
5991 	hda_nid_t hp_pin = alc_get_hp_pin(spec);
5992 
5993 	int new_headset_mode;
5994 
5995 	if (!snd_hda_jack_detect(codec, hp_pin))
5996 		new_headset_mode = ALC_HEADSET_MODE_UNPLUGGED;
5997 	else if (mux_pin == spec->headset_mic_pin)
5998 		new_headset_mode = ALC_HEADSET_MODE_HEADSET;
5999 	else if (mux_pin == spec->headphone_mic_pin)
6000 		new_headset_mode = ALC_HEADSET_MODE_MIC;
6001 	else
6002 		new_headset_mode = ALC_HEADSET_MODE_HEADPHONE;
6003 
6004 	if (new_headset_mode == spec->current_headset_mode) {
6005 		snd_hda_gen_update_outputs(codec);
6006 		return;
6007 	}
6008 
6009 	switch (new_headset_mode) {
6010 	case ALC_HEADSET_MODE_UNPLUGGED:
6011 		alc_headset_mode_unplugged(codec);
6012 		spec->current_headset_mode = ALC_HEADSET_MODE_UNKNOWN;
6013 		spec->current_headset_type = ALC_HEADSET_TYPE_UNKNOWN;
6014 		spec->gen.hp_jack_present = false;
6015 		break;
6016 	case ALC_HEADSET_MODE_HEADSET:
6017 		if (spec->current_headset_type == ALC_HEADSET_TYPE_UNKNOWN)
6018 			alc_determine_headset_type(codec);
6019 		if (spec->current_headset_type == ALC_HEADSET_TYPE_CTIA)
6020 			alc_headset_mode_ctia(codec);
6021 		else if (spec->current_headset_type == ALC_HEADSET_TYPE_OMTP)
6022 			alc_headset_mode_omtp(codec);
6023 		spec->gen.hp_jack_present = true;
6024 		break;
6025 	case ALC_HEADSET_MODE_MIC:
6026 		alc_headset_mode_mic_in(codec, hp_pin, spec->headphone_mic_pin);
6027 		spec->gen.hp_jack_present = false;
6028 		break;
6029 	case ALC_HEADSET_MODE_HEADPHONE:
6030 		alc_headset_mode_default(codec);
6031 		spec->gen.hp_jack_present = true;
6032 		break;
6033 	}
6034 	if (new_headset_mode != ALC_HEADSET_MODE_MIC) {
6035 		snd_hda_set_pin_ctl_cache(codec, hp_pin,
6036 					  AC_PINCTL_OUT_EN | AC_PINCTL_HP_EN);
6037 		if (spec->headphone_mic_pin && spec->headphone_mic_pin != hp_pin)
6038 			snd_hda_set_pin_ctl_cache(codec, spec->headphone_mic_pin,
6039 						  PIN_VREFHIZ);
6040 	}
6041 	spec->current_headset_mode = new_headset_mode;
6042 
6043 	snd_hda_gen_update_outputs(codec);
6044 }
6045 
alc_update_headset_mode_hook(struct hda_codec * codec,struct snd_kcontrol * kcontrol,struct snd_ctl_elem_value * ucontrol)6046 static void alc_update_headset_mode_hook(struct hda_codec *codec,
6047 					 struct snd_kcontrol *kcontrol,
6048 					 struct snd_ctl_elem_value *ucontrol)
6049 {
6050 	alc_update_headset_mode(codec);
6051 }
6052 
alc_update_headset_jack_cb(struct hda_codec * codec,struct hda_jack_callback * jack)6053 static void alc_update_headset_jack_cb(struct hda_codec *codec,
6054 				       struct hda_jack_callback *jack)
6055 {
6056 	snd_hda_gen_hp_automute(codec, jack);
6057 	alc_update_headset_mode(codec);
6058 }
6059 
alc_probe_headset_mode(struct hda_codec * codec)6060 static void alc_probe_headset_mode(struct hda_codec *codec)
6061 {
6062 	int i;
6063 	struct alc_spec *spec = codec->spec;
6064 	struct auto_pin_cfg *cfg = &spec->gen.autocfg;
6065 
6066 	/* Find mic pins */
6067 	for (i = 0; i < cfg->num_inputs; i++) {
6068 		if (cfg->inputs[i].is_headset_mic && !spec->headset_mic_pin)
6069 			spec->headset_mic_pin = cfg->inputs[i].pin;
6070 		if (cfg->inputs[i].is_headphone_mic && !spec->headphone_mic_pin)
6071 			spec->headphone_mic_pin = cfg->inputs[i].pin;
6072 	}
6073 
6074 	WARN_ON(spec->gen.cap_sync_hook);
6075 	spec->gen.cap_sync_hook = alc_update_headset_mode_hook;
6076 	spec->gen.automute_hook = alc_update_headset_mode;
6077 	spec->gen.hp_automute_hook = alc_update_headset_jack_cb;
6078 }
6079 
alc_fixup_headset_mode(struct hda_codec * codec,const struct hda_fixup * fix,int action)6080 static void alc_fixup_headset_mode(struct hda_codec *codec,
6081 				const struct hda_fixup *fix, int action)
6082 {
6083 	struct alc_spec *spec = codec->spec;
6084 
6085 	switch (action) {
6086 	case HDA_FIXUP_ACT_PRE_PROBE:
6087 		spec->parse_flags |= HDA_PINCFG_HEADSET_MIC | HDA_PINCFG_HEADPHONE_MIC;
6088 		break;
6089 	case HDA_FIXUP_ACT_PROBE:
6090 		alc_probe_headset_mode(codec);
6091 		break;
6092 	case HDA_FIXUP_ACT_INIT:
6093 		if (is_s3_resume(codec) || is_s4_resume(codec)) {
6094 			spec->current_headset_mode = ALC_HEADSET_MODE_UNKNOWN;
6095 			spec->current_headset_type = ALC_HEADSET_TYPE_UNKNOWN;
6096 		}
6097 		alc_update_headset_mode(codec);
6098 		break;
6099 	}
6100 }
6101 
alc_fixup_headset_mode_no_hp_mic(struct hda_codec * codec,const struct hda_fixup * fix,int action)6102 static void alc_fixup_headset_mode_no_hp_mic(struct hda_codec *codec,
6103 				const struct hda_fixup *fix, int action)
6104 {
6105 	if (action == HDA_FIXUP_ACT_PRE_PROBE) {
6106 		struct alc_spec *spec = codec->spec;
6107 		spec->parse_flags |= HDA_PINCFG_HEADSET_MIC;
6108 	}
6109 	else
6110 		alc_fixup_headset_mode(codec, fix, action);
6111 }
6112 
alc255_set_default_jack_type(struct hda_codec * codec)6113 static void alc255_set_default_jack_type(struct hda_codec *codec)
6114 {
6115 	/* Set to iphone type */
6116 	static const struct coef_fw alc255fw[] = {
6117 		WRITE_COEF(0x1b, 0x880b),
6118 		WRITE_COEF(0x45, 0xd089),
6119 		WRITE_COEF(0x1b, 0x080b),
6120 		WRITE_COEF(0x46, 0x0004),
6121 		WRITE_COEF(0x1b, 0x0c0b),
6122 		{}
6123 	};
6124 	static const struct coef_fw alc256fw[] = {
6125 		WRITE_COEF(0x1b, 0x884b),
6126 		WRITE_COEF(0x45, 0xd089),
6127 		WRITE_COEF(0x1b, 0x084b),
6128 		WRITE_COEF(0x46, 0x0004),
6129 		WRITE_COEF(0x1b, 0x0c4b),
6130 		{}
6131 	};
6132 	switch (codec->core.vendor_id) {
6133 	case 0x10ec0255:
6134 		alc_process_coef_fw(codec, alc255fw);
6135 		break;
6136 	case 0x10ec0230:
6137 	case 0x10ec0236:
6138 	case 0x10ec0256:
6139 	case 0x19e58326:
6140 		alc_process_coef_fw(codec, alc256fw);
6141 		break;
6142 	}
6143 	msleep(30);
6144 }
6145 
alc_fixup_headset_mode_alc255(struct hda_codec * codec,const struct hda_fixup * fix,int action)6146 static void alc_fixup_headset_mode_alc255(struct hda_codec *codec,
6147 				const struct hda_fixup *fix, int action)
6148 {
6149 	if (action == HDA_FIXUP_ACT_PRE_PROBE) {
6150 		alc255_set_default_jack_type(codec);
6151 	}
6152 	alc_fixup_headset_mode(codec, fix, action);
6153 }
6154 
alc_fixup_headset_mode_alc255_no_hp_mic(struct hda_codec * codec,const struct hda_fixup * fix,int action)6155 static void alc_fixup_headset_mode_alc255_no_hp_mic(struct hda_codec *codec,
6156 				const struct hda_fixup *fix, int action)
6157 {
6158 	if (action == HDA_FIXUP_ACT_PRE_PROBE) {
6159 		struct alc_spec *spec = codec->spec;
6160 		spec->parse_flags |= HDA_PINCFG_HEADSET_MIC;
6161 		alc255_set_default_jack_type(codec);
6162 	}
6163 	else
6164 		alc_fixup_headset_mode(codec, fix, action);
6165 }
6166 
alc288_update_headset_jack_cb(struct hda_codec * codec,struct hda_jack_callback * jack)6167 static void alc288_update_headset_jack_cb(struct hda_codec *codec,
6168 				       struct hda_jack_callback *jack)
6169 {
6170 	struct alc_spec *spec = codec->spec;
6171 
6172 	alc_update_headset_jack_cb(codec, jack);
6173 	/* Headset Mic enable or disable, only for Dell Dino */
6174 	alc_update_gpio_data(codec, 0x40, spec->gen.hp_jack_present);
6175 }
6176 
alc_fixup_headset_mode_dell_alc288(struct hda_codec * codec,const struct hda_fixup * fix,int action)6177 static void alc_fixup_headset_mode_dell_alc288(struct hda_codec *codec,
6178 				const struct hda_fixup *fix, int action)
6179 {
6180 	alc_fixup_headset_mode(codec, fix, action);
6181 	if (action == HDA_FIXUP_ACT_PROBE) {
6182 		struct alc_spec *spec = codec->spec;
6183 		/* toggled via hp_automute_hook */
6184 		spec->gpio_mask |= 0x40;
6185 		spec->gpio_dir |= 0x40;
6186 		spec->gen.hp_automute_hook = alc288_update_headset_jack_cb;
6187 	}
6188 }
6189 
alc_fixup_auto_mute_via_amp(struct hda_codec * codec,const struct hda_fixup * fix,int action)6190 static void alc_fixup_auto_mute_via_amp(struct hda_codec *codec,
6191 					const struct hda_fixup *fix, int action)
6192 {
6193 	if (action == HDA_FIXUP_ACT_PRE_PROBE) {
6194 		struct alc_spec *spec = codec->spec;
6195 		spec->gen.auto_mute_via_amp = 1;
6196 	}
6197 }
6198 
alc_fixup_no_shutup(struct hda_codec * codec,const struct hda_fixup * fix,int action)6199 static void alc_fixup_no_shutup(struct hda_codec *codec,
6200 				const struct hda_fixup *fix, int action)
6201 {
6202 	if (action == HDA_FIXUP_ACT_PRE_PROBE) {
6203 		struct alc_spec *spec = codec->spec;
6204 		spec->no_shutup_pins = 1;
6205 	}
6206 }
6207 
alc_fixup_disable_aamix(struct hda_codec * codec,const struct hda_fixup * fix,int action)6208 static void alc_fixup_disable_aamix(struct hda_codec *codec,
6209 				    const struct hda_fixup *fix, int action)
6210 {
6211 	if (action == HDA_FIXUP_ACT_PRE_PROBE) {
6212 		struct alc_spec *spec = codec->spec;
6213 		/* Disable AA-loopback as it causes white noise */
6214 		spec->gen.mixer_nid = 0;
6215 	}
6216 }
6217 
6218 /* fixup for Thinkpad docks: add dock pins, avoid HP parser fixup */
alc_fixup_tpt440_dock(struct hda_codec * codec,const struct hda_fixup * fix,int action)6219 static void alc_fixup_tpt440_dock(struct hda_codec *codec,
6220 				  const struct hda_fixup *fix, int action)
6221 {
6222 	static const struct hda_pintbl pincfgs[] = {
6223 		{ 0x16, 0x21211010 }, /* dock headphone */
6224 		{ 0x19, 0x21a11010 }, /* dock mic */
6225 		{ }
6226 	};
6227 	struct alc_spec *spec = codec->spec;
6228 
6229 	if (action == HDA_FIXUP_ACT_PRE_PROBE) {
6230 		spec->parse_flags = HDA_PINCFG_NO_HP_FIXUP;
6231 		codec->power_save_node = 0; /* avoid click noises */
6232 		snd_hda_apply_pincfgs(codec, pincfgs);
6233 	}
6234 }
6235 
alc_fixup_tpt470_dock(struct hda_codec * codec,const struct hda_fixup * fix,int action)6236 static void alc_fixup_tpt470_dock(struct hda_codec *codec,
6237 				  const struct hda_fixup *fix, int action)
6238 {
6239 	static const struct hda_pintbl pincfgs[] = {
6240 		{ 0x17, 0x21211010 }, /* dock headphone */
6241 		{ 0x19, 0x21a11010 }, /* dock mic */
6242 		{ }
6243 	};
6244 	struct alc_spec *spec = codec->spec;
6245 
6246 	if (action == HDA_FIXUP_ACT_PRE_PROBE) {
6247 		spec->parse_flags = HDA_PINCFG_NO_HP_FIXUP;
6248 		snd_hda_apply_pincfgs(codec, pincfgs);
6249 	} else if (action == HDA_FIXUP_ACT_INIT) {
6250 		/* Enable DOCK device */
6251 		snd_hda_codec_write(codec, 0x17, 0,
6252 			    AC_VERB_SET_CONFIG_DEFAULT_BYTES_3, 0);
6253 		/* Enable DOCK device */
6254 		snd_hda_codec_write(codec, 0x19, 0,
6255 			    AC_VERB_SET_CONFIG_DEFAULT_BYTES_3, 0);
6256 	}
6257 }
6258 
alc_fixup_tpt470_dacs(struct hda_codec * codec,const struct hda_fixup * fix,int action)6259 static void alc_fixup_tpt470_dacs(struct hda_codec *codec,
6260 				  const struct hda_fixup *fix, int action)
6261 {
6262 	/* Assure the speaker pin to be coupled with DAC NID 0x03; otherwise
6263 	 * the speaker output becomes too low by some reason on Thinkpads with
6264 	 * ALC298 codec
6265 	 */
6266 	static const hda_nid_t preferred_pairs[] = {
6267 		0x14, 0x03, 0x17, 0x02, 0x21, 0x02,
6268 		0
6269 	};
6270 	struct alc_spec *spec = codec->spec;
6271 
6272 	if (action == HDA_FIXUP_ACT_PRE_PROBE)
6273 		spec->gen.preferred_dacs = preferred_pairs;
6274 }
6275 
alc295_fixup_asus_dacs(struct hda_codec * codec,const struct hda_fixup * fix,int action)6276 static void alc295_fixup_asus_dacs(struct hda_codec *codec,
6277 				   const struct hda_fixup *fix, int action)
6278 {
6279 	static const hda_nid_t preferred_pairs[] = {
6280 		0x17, 0x02, 0x21, 0x03, 0
6281 	};
6282 	struct alc_spec *spec = codec->spec;
6283 
6284 	if (action == HDA_FIXUP_ACT_PRE_PROBE)
6285 		spec->gen.preferred_dacs = preferred_pairs;
6286 }
6287 
alc_shutup_dell_xps13(struct hda_codec * codec)6288 static void alc_shutup_dell_xps13(struct hda_codec *codec)
6289 {
6290 	struct alc_spec *spec = codec->spec;
6291 	int hp_pin = alc_get_hp_pin(spec);
6292 
6293 	/* Prevent pop noises when headphones are plugged in */
6294 	snd_hda_codec_write(codec, hp_pin, 0,
6295 			    AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);
6296 	msleep(20);
6297 }
6298 
alc_fixup_dell_xps13(struct hda_codec * codec,const struct hda_fixup * fix,int action)6299 static void alc_fixup_dell_xps13(struct hda_codec *codec,
6300 				const struct hda_fixup *fix, int action)
6301 {
6302 	struct alc_spec *spec = codec->spec;
6303 	struct hda_input_mux *imux = &spec->gen.input_mux;
6304 	int i;
6305 
6306 	switch (action) {
6307 	case HDA_FIXUP_ACT_PRE_PROBE:
6308 		/* mic pin 0x19 must be initialized with Vref Hi-Z, otherwise
6309 		 * it causes a click noise at start up
6310 		 */
6311 		snd_hda_codec_set_pin_target(codec, 0x19, PIN_VREFHIZ);
6312 		spec->shutup = alc_shutup_dell_xps13;
6313 		break;
6314 	case HDA_FIXUP_ACT_PROBE:
6315 		/* Make the internal mic the default input source. */
6316 		for (i = 0; i < imux->num_items; i++) {
6317 			if (spec->gen.imux_pins[i] == 0x12) {
6318 				spec->gen.cur_mux[0] = i;
6319 				break;
6320 			}
6321 		}
6322 		break;
6323 	}
6324 }
6325 
alc_fixup_headset_mode_alc662(struct hda_codec * codec,const struct hda_fixup * fix,int action)6326 static void alc_fixup_headset_mode_alc662(struct hda_codec *codec,
6327 				const struct hda_fixup *fix, int action)
6328 {
6329 	struct alc_spec *spec = codec->spec;
6330 
6331 	if (action == HDA_FIXUP_ACT_PRE_PROBE) {
6332 		spec->parse_flags |= HDA_PINCFG_HEADSET_MIC;
6333 		spec->gen.hp_mic = 1; /* Mic-in is same pin as headphone */
6334 
6335 		/* Disable boost for mic-in permanently. (This code is only called
6336 		   from quirks that guarantee that the headphone is at NID 0x1b.) */
6337 		snd_hda_codec_write(codec, 0x1b, 0, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000);
6338 		snd_hda_override_wcaps(codec, 0x1b, get_wcaps(codec, 0x1b) & ~AC_WCAP_IN_AMP);
6339 	} else
6340 		alc_fixup_headset_mode(codec, fix, action);
6341 }
6342 
alc_fixup_headset_mode_alc668(struct hda_codec * codec,const struct hda_fixup * fix,int action)6343 static void alc_fixup_headset_mode_alc668(struct hda_codec *codec,
6344 				const struct hda_fixup *fix, int action)
6345 {
6346 	if (action == HDA_FIXUP_ACT_PRE_PROBE) {
6347 		alc_write_coef_idx(codec, 0xc4, 0x8000);
6348 		alc_update_coef_idx(codec, 0xc2, ~0xfe, 0);
6349 		snd_hda_set_pin_ctl_cache(codec, 0x18, 0);
6350 	}
6351 	alc_fixup_headset_mode(codec, fix, action);
6352 }
6353 
6354 /* Returns the nid of the external mic input pin, or 0 if it cannot be found. */
find_ext_mic_pin(struct hda_codec * codec)6355 static int find_ext_mic_pin(struct hda_codec *codec)
6356 {
6357 	struct alc_spec *spec = codec->spec;
6358 	struct auto_pin_cfg *cfg = &spec->gen.autocfg;
6359 	hda_nid_t nid;
6360 	unsigned int defcfg;
6361 	int i;
6362 
6363 	for (i = 0; i < cfg->num_inputs; i++) {
6364 		if (cfg->inputs[i].type != AUTO_PIN_MIC)
6365 			continue;
6366 		nid = cfg->inputs[i].pin;
6367 		defcfg = snd_hda_codec_get_pincfg(codec, nid);
6368 		if (snd_hda_get_input_pin_attr(defcfg) == INPUT_PIN_ATTR_INT)
6369 			continue;
6370 		return nid;
6371 	}
6372 
6373 	return 0;
6374 }
6375 
alc271_hp_gate_mic_jack(struct hda_codec * codec,const struct hda_fixup * fix,int action)6376 static void alc271_hp_gate_mic_jack(struct hda_codec *codec,
6377 				    const struct hda_fixup *fix,
6378 				    int action)
6379 {
6380 	struct alc_spec *spec = codec->spec;
6381 
6382 	if (action == HDA_FIXUP_ACT_PROBE) {
6383 		int mic_pin = find_ext_mic_pin(codec);
6384 		int hp_pin = alc_get_hp_pin(spec);
6385 
6386 		if (snd_BUG_ON(!mic_pin || !hp_pin))
6387 			return;
6388 		snd_hda_jack_set_gating_jack(codec, mic_pin, hp_pin);
6389 	}
6390 }
6391 
alc269_fixup_limit_int_mic_boost(struct hda_codec * codec,const struct hda_fixup * fix,int action)6392 static void alc269_fixup_limit_int_mic_boost(struct hda_codec *codec,
6393 					     const struct hda_fixup *fix,
6394 					     int action)
6395 {
6396 	struct alc_spec *spec = codec->spec;
6397 	struct auto_pin_cfg *cfg = &spec->gen.autocfg;
6398 	int i;
6399 
6400 	/* The mic boosts on level 2 and 3 are too noisy
6401 	   on the internal mic input.
6402 	   Therefore limit the boost to 0 or 1. */
6403 
6404 	if (action != HDA_FIXUP_ACT_PROBE)
6405 		return;
6406 
6407 	for (i = 0; i < cfg->num_inputs; i++) {
6408 		hda_nid_t nid = cfg->inputs[i].pin;
6409 		unsigned int defcfg;
6410 		if (cfg->inputs[i].type != AUTO_PIN_MIC)
6411 			continue;
6412 		defcfg = snd_hda_codec_get_pincfg(codec, nid);
6413 		if (snd_hda_get_input_pin_attr(defcfg) != INPUT_PIN_ATTR_INT)
6414 			continue;
6415 
6416 		snd_hda_override_amp_caps(codec, nid, HDA_INPUT,
6417 					  (0x00 << AC_AMPCAP_OFFSET_SHIFT) |
6418 					  (0x01 << AC_AMPCAP_NUM_STEPS_SHIFT) |
6419 					  (0x2f << AC_AMPCAP_STEP_SIZE_SHIFT) |
6420 					  (0 << AC_AMPCAP_MUTE_SHIFT));
6421 	}
6422 }
6423 
alc283_hp_automute_hook(struct hda_codec * codec,struct hda_jack_callback * jack)6424 static void alc283_hp_automute_hook(struct hda_codec *codec,
6425 				    struct hda_jack_callback *jack)
6426 {
6427 	struct alc_spec *spec = codec->spec;
6428 	int vref;
6429 
6430 	msleep(200);
6431 	snd_hda_gen_hp_automute(codec, jack);
6432 
6433 	vref = spec->gen.hp_jack_present ? PIN_VREF80 : 0;
6434 
6435 	msleep(600);
6436 	snd_hda_codec_write(codec, 0x19, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
6437 			    vref);
6438 }
6439 
alc283_fixup_chromebook(struct hda_codec * codec,const struct hda_fixup * fix,int action)6440 static void alc283_fixup_chromebook(struct hda_codec *codec,
6441 				    const struct hda_fixup *fix, int action)
6442 {
6443 	struct alc_spec *spec = codec->spec;
6444 
6445 	switch (action) {
6446 	case HDA_FIXUP_ACT_PRE_PROBE:
6447 		snd_hda_override_wcaps(codec, 0x03, 0);
6448 		/* Disable AA-loopback as it causes white noise */
6449 		spec->gen.mixer_nid = 0;
6450 		break;
6451 	case HDA_FIXUP_ACT_INIT:
6452 		/* MIC2-VREF control */
6453 		/* Set to manual mode */
6454 		alc_update_coef_idx(codec, 0x06, 0x000c, 0);
6455 		/* Enable Line1 input control by verb */
6456 		alc_update_coef_idx(codec, 0x1a, 0, 1 << 4);
6457 		break;
6458 	}
6459 }
6460 
alc283_fixup_sense_combo_jack(struct hda_codec * codec,const struct hda_fixup * fix,int action)6461 static void alc283_fixup_sense_combo_jack(struct hda_codec *codec,
6462 				    const struct hda_fixup *fix, int action)
6463 {
6464 	struct alc_spec *spec = codec->spec;
6465 
6466 	switch (action) {
6467 	case HDA_FIXUP_ACT_PRE_PROBE:
6468 		spec->gen.hp_automute_hook = alc283_hp_automute_hook;
6469 		break;
6470 	case HDA_FIXUP_ACT_INIT:
6471 		/* MIC2-VREF control */
6472 		/* Set to manual mode */
6473 		alc_update_coef_idx(codec, 0x06, 0x000c, 0);
6474 		break;
6475 	}
6476 }
6477 
6478 /* mute tablet speaker pin (0x14) via dock plugging in addition */
asus_tx300_automute(struct hda_codec * codec)6479 static void asus_tx300_automute(struct hda_codec *codec)
6480 {
6481 	struct alc_spec *spec = codec->spec;
6482 	snd_hda_gen_update_outputs(codec);
6483 	if (snd_hda_jack_detect(codec, 0x1b))
6484 		spec->gen.mute_bits |= (1ULL << 0x14);
6485 }
6486 
alc282_fixup_asus_tx300(struct hda_codec * codec,const struct hda_fixup * fix,int action)6487 static void alc282_fixup_asus_tx300(struct hda_codec *codec,
6488 				    const struct hda_fixup *fix, int action)
6489 {
6490 	struct alc_spec *spec = codec->spec;
6491 	static const struct hda_pintbl dock_pins[] = {
6492 		{ 0x1b, 0x21114000 }, /* dock speaker pin */
6493 		{}
6494 	};
6495 
6496 	switch (action) {
6497 	case HDA_FIXUP_ACT_PRE_PROBE:
6498 		spec->init_amp = ALC_INIT_DEFAULT;
6499 		/* TX300 needs to set up GPIO2 for the speaker amp */
6500 		alc_setup_gpio(codec, 0x04);
6501 		snd_hda_apply_pincfgs(codec, dock_pins);
6502 		spec->gen.auto_mute_via_amp = 1;
6503 		spec->gen.automute_hook = asus_tx300_automute;
6504 		snd_hda_jack_detect_enable_callback(codec, 0x1b,
6505 						    snd_hda_gen_hp_automute);
6506 		break;
6507 	case HDA_FIXUP_ACT_PROBE:
6508 		spec->init_amp = ALC_INIT_DEFAULT;
6509 		break;
6510 	case HDA_FIXUP_ACT_BUILD:
6511 		/* this is a bit tricky; give more sane names for the main
6512 		 * (tablet) speaker and the dock speaker, respectively
6513 		 */
6514 		rename_ctl(codec, "Speaker Playback Switch",
6515 			   "Dock Speaker Playback Switch");
6516 		rename_ctl(codec, "Bass Speaker Playback Switch",
6517 			   "Speaker Playback Switch");
6518 		break;
6519 	}
6520 }
6521 
alc290_fixup_mono_speakers(struct hda_codec * codec,const struct hda_fixup * fix,int action)6522 static void alc290_fixup_mono_speakers(struct hda_codec *codec,
6523 				       const struct hda_fixup *fix, int action)
6524 {
6525 	if (action == HDA_FIXUP_ACT_PRE_PROBE) {
6526 		/* DAC node 0x03 is giving mono output. We therefore want to
6527 		   make sure 0x14 (front speaker) and 0x15 (headphones) use the
6528 		   stereo DAC, while leaving 0x17 (bass speaker) for node 0x03. */
6529 		static const hda_nid_t conn1[] = { 0x0c };
6530 		snd_hda_override_conn_list(codec, 0x14, ARRAY_SIZE(conn1), conn1);
6531 		snd_hda_override_conn_list(codec, 0x15, ARRAY_SIZE(conn1), conn1);
6532 	}
6533 }
6534 
alc298_fixup_speaker_volume(struct hda_codec * codec,const struct hda_fixup * fix,int action)6535 static void alc298_fixup_speaker_volume(struct hda_codec *codec,
6536 					const struct hda_fixup *fix, int action)
6537 {
6538 	if (action == HDA_FIXUP_ACT_PRE_PROBE) {
6539 		/* The speaker is routed to the Node 0x06 by a mistake, as a result
6540 		   we can't adjust the speaker's volume since this node does not has
6541 		   Amp-out capability. we change the speaker's route to:
6542 		   Node 0x02 (Audio Output) -> Node 0x0c (Audio Mixer) -> Node 0x17 (
6543 		   Pin Complex), since Node 0x02 has Amp-out caps, we can adjust
6544 		   speaker's volume now. */
6545 
6546 		static const hda_nid_t conn1[] = { 0x0c };
6547 		snd_hda_override_conn_list(codec, 0x17, ARRAY_SIZE(conn1), conn1);
6548 	}
6549 }
6550 
6551 /* disable DAC3 (0x06) selection on NID 0x17 as it has no volume amp control */
alc295_fixup_disable_dac3(struct hda_codec * codec,const struct hda_fixup * fix,int action)6552 static void alc295_fixup_disable_dac3(struct hda_codec *codec,
6553 				      const struct hda_fixup *fix, int action)
6554 {
6555 	if (action == HDA_FIXUP_ACT_PRE_PROBE) {
6556 		static const hda_nid_t conn[] = { 0x02, 0x03 };
6557 		snd_hda_override_conn_list(codec, 0x17, ARRAY_SIZE(conn), conn);
6558 	}
6559 }
6560 
6561 /* force NID 0x17 (Bass Speaker) to DAC1 to share it with the main speaker */
alc285_fixup_speaker2_to_dac1(struct hda_codec * codec,const struct hda_fixup * fix,int action)6562 static void alc285_fixup_speaker2_to_dac1(struct hda_codec *codec,
6563 					  const struct hda_fixup *fix, int action)
6564 {
6565 	if (action == HDA_FIXUP_ACT_PRE_PROBE) {
6566 		static const hda_nid_t conn[] = { 0x02 };
6567 		snd_hda_override_conn_list(codec, 0x17, ARRAY_SIZE(conn), conn);
6568 	}
6569 }
6570 
6571 /* disable DAC3 (0x06) selection on NID 0x15 - share Speaker/Bass Speaker DAC 0x03 */
alc294_fixup_bass_speaker_15(struct hda_codec * codec,const struct hda_fixup * fix,int action)6572 static void alc294_fixup_bass_speaker_15(struct hda_codec *codec,
6573 					 const struct hda_fixup *fix, int action)
6574 {
6575 	if (action == HDA_FIXUP_ACT_PRE_PROBE) {
6576 		static const hda_nid_t conn[] = { 0x02, 0x03 };
6577 		snd_hda_override_conn_list(codec, 0x15, ARRAY_SIZE(conn), conn);
6578 	}
6579 }
6580 
6581 /* Hook to update amp GPIO4 for automute */
alc280_hp_gpio4_automute_hook(struct hda_codec * codec,struct hda_jack_callback * jack)6582 static void alc280_hp_gpio4_automute_hook(struct hda_codec *codec,
6583 					  struct hda_jack_callback *jack)
6584 {
6585 	struct alc_spec *spec = codec->spec;
6586 
6587 	snd_hda_gen_hp_automute(codec, jack);
6588 	/* mute_led_polarity is set to 0, so we pass inverted value here */
6589 	alc_update_gpio_led(codec, 0x10, spec->mute_led_polarity,
6590 			    !spec->gen.hp_jack_present);
6591 }
6592 
6593 /* Manage GPIOs for HP EliteBook Folio 9480m.
6594  *
6595  * GPIO4 is the headphone amplifier power control
6596  * GPIO3 is the audio output mute indicator LED
6597  */
6598 
alc280_fixup_hp_9480m(struct hda_codec * codec,const struct hda_fixup * fix,int action)6599 static void alc280_fixup_hp_9480m(struct hda_codec *codec,
6600 				  const struct hda_fixup *fix,
6601 				  int action)
6602 {
6603 	struct alc_spec *spec = codec->spec;
6604 
6605 	alc_fixup_hp_gpio_led(codec, action, 0x08, 0);
6606 	if (action == HDA_FIXUP_ACT_PRE_PROBE) {
6607 		/* amp at GPIO4; toggled via alc280_hp_gpio4_automute_hook() */
6608 		spec->gpio_mask |= 0x10;
6609 		spec->gpio_dir |= 0x10;
6610 		spec->gen.hp_automute_hook = alc280_hp_gpio4_automute_hook;
6611 	}
6612 }
6613 
alc275_fixup_gpio4_off(struct hda_codec * codec,const struct hda_fixup * fix,int action)6614 static void alc275_fixup_gpio4_off(struct hda_codec *codec,
6615 				   const struct hda_fixup *fix,
6616 				   int action)
6617 {
6618 	struct alc_spec *spec = codec->spec;
6619 
6620 	if (action == HDA_FIXUP_ACT_PRE_PROBE) {
6621 		spec->gpio_mask |= 0x04;
6622 		spec->gpio_dir |= 0x04;
6623 		/* set data bit low */
6624 	}
6625 }
6626 
6627 /* Quirk for Thinkpad X1 7th and 8th Gen
6628  * The following fixed routing needed
6629  * DAC1 (NID 0x02) -> Speaker (NID 0x14); some eq applied secretly
6630  * DAC2 (NID 0x03) -> Bass (NID 0x17) & Headphone (NID 0x21); sharing a DAC
6631  * DAC3 (NID 0x06) -> Unused, due to the lack of volume amp
6632  */
alc285_fixup_thinkpad_x1_gen7(struct hda_codec * codec,const struct hda_fixup * fix,int action)6633 static void alc285_fixup_thinkpad_x1_gen7(struct hda_codec *codec,
6634 					  const struct hda_fixup *fix, int action)
6635 {
6636 	static const hda_nid_t conn[] = { 0x02, 0x03 }; /* exclude 0x06 */
6637 	static const hda_nid_t preferred_pairs[] = {
6638 		0x14, 0x02, 0x17, 0x03, 0x21, 0x03, 0
6639 	};
6640 	struct alc_spec *spec = codec->spec;
6641 
6642 	switch (action) {
6643 	case HDA_FIXUP_ACT_PRE_PROBE:
6644 		snd_hda_override_conn_list(codec, 0x17, ARRAY_SIZE(conn), conn);
6645 		spec->gen.preferred_dacs = preferred_pairs;
6646 		break;
6647 	case HDA_FIXUP_ACT_BUILD:
6648 		/* The generic parser creates somewhat unintuitive volume ctls
6649 		 * with the fixed routing above, and the shared DAC2 may be
6650 		 * confusing for PA.
6651 		 * Rename those to unique names so that PA doesn't touch them
6652 		 * and use only Master volume.
6653 		 */
6654 		rename_ctl(codec, "Front Playback Volume", "DAC1 Playback Volume");
6655 		rename_ctl(codec, "Bass Speaker Playback Volume", "DAC2 Playback Volume");
6656 		break;
6657 	}
6658 }
6659 
alc233_alc662_fixup_lenovo_dual_codecs(struct hda_codec * codec,const struct hda_fixup * fix,int action)6660 static void alc233_alc662_fixup_lenovo_dual_codecs(struct hda_codec *codec,
6661 					 const struct hda_fixup *fix,
6662 					 int action)
6663 {
6664 	alc_fixup_dual_codecs(codec, fix, action);
6665 	switch (action) {
6666 	case HDA_FIXUP_ACT_PRE_PROBE:
6667 		/* override card longname to provide a unique UCM profile */
6668 		strcpy(codec->card->longname, "HDAudio-Lenovo-DualCodecs");
6669 		break;
6670 	case HDA_FIXUP_ACT_BUILD:
6671 		/* rename Capture controls depending on the codec */
6672 		rename_ctl(codec, "Capture Volume",
6673 			   codec->addr == 0 ?
6674 			   "Rear-Panel Capture Volume" :
6675 			   "Front-Panel Capture Volume");
6676 		rename_ctl(codec, "Capture Switch",
6677 			   codec->addr == 0 ?
6678 			   "Rear-Panel Capture Switch" :
6679 			   "Front-Panel Capture Switch");
6680 		break;
6681 	}
6682 }
6683 
alc225_fixup_s3_pop_noise(struct hda_codec * codec,const struct hda_fixup * fix,int action)6684 static void alc225_fixup_s3_pop_noise(struct hda_codec *codec,
6685 				      const struct hda_fixup *fix, int action)
6686 {
6687 	if (action != HDA_FIXUP_ACT_PRE_PROBE)
6688 		return;
6689 
6690 	codec->power_save_node = 1;
6691 }
6692 
6693 /* Forcibly assign NID 0x03 to HP/LO while NID 0x02 to SPK for EQ */
alc274_fixup_bind_dacs(struct hda_codec * codec,const struct hda_fixup * fix,int action)6694 static void alc274_fixup_bind_dacs(struct hda_codec *codec,
6695 				    const struct hda_fixup *fix, int action)
6696 {
6697 	struct alc_spec *spec = codec->spec;
6698 	static const hda_nid_t preferred_pairs[] = {
6699 		0x21, 0x03, 0x1b, 0x03, 0x16, 0x02,
6700 		0
6701 	};
6702 
6703 	if (action != HDA_FIXUP_ACT_PRE_PROBE)
6704 		return;
6705 
6706 	spec->gen.preferred_dacs = preferred_pairs;
6707 	spec->gen.auto_mute_via_amp = 1;
6708 	codec->power_save_node = 0;
6709 }
6710 
6711 /* avoid DAC 0x06 for bass speaker 0x17; it has no volume control */
alc289_fixup_asus_ga401(struct hda_codec * codec,const struct hda_fixup * fix,int action)6712 static void alc289_fixup_asus_ga401(struct hda_codec *codec,
6713 				    const struct hda_fixup *fix, int action)
6714 {
6715 	static const hda_nid_t preferred_pairs[] = {
6716 		0x14, 0x02, 0x17, 0x02, 0x21, 0x03, 0
6717 	};
6718 	struct alc_spec *spec = codec->spec;
6719 
6720 	if (action == HDA_FIXUP_ACT_PRE_PROBE)
6721 		spec->gen.preferred_dacs = preferred_pairs;
6722 }
6723 
6724 /* The DAC of NID 0x3 will introduce click/pop noise on headphones, so invalidate it */
alc285_fixup_invalidate_dacs(struct hda_codec * codec,const struct hda_fixup * fix,int action)6725 static void alc285_fixup_invalidate_dacs(struct hda_codec *codec,
6726 			      const struct hda_fixup *fix, int action)
6727 {
6728 	if (action != HDA_FIXUP_ACT_PRE_PROBE)
6729 		return;
6730 
6731 	snd_hda_override_wcaps(codec, 0x03, 0);
6732 }
6733 
alc_combo_jack_hp_jd_restart(struct hda_codec * codec)6734 static void alc_combo_jack_hp_jd_restart(struct hda_codec *codec)
6735 {
6736 	switch (codec->core.vendor_id) {
6737 	case 0x10ec0274:
6738 	case 0x10ec0294:
6739 	case 0x10ec0225:
6740 	case 0x10ec0295:
6741 	case 0x10ec0299:
6742 		alc_update_coef_idx(codec, 0x4a, 0x8000, 1 << 15); /* Reset HP JD */
6743 		alc_update_coef_idx(codec, 0x4a, 0x8000, 0 << 15);
6744 		break;
6745 	case 0x10ec0230:
6746 	case 0x10ec0235:
6747 	case 0x10ec0236:
6748 	case 0x10ec0255:
6749 	case 0x10ec0256:
6750 	case 0x10ec0257:
6751 	case 0x19e58326:
6752 		alc_update_coef_idx(codec, 0x1b, 0x8000, 1 << 15); /* Reset HP JD */
6753 		alc_update_coef_idx(codec, 0x1b, 0x8000, 0 << 15);
6754 		break;
6755 	}
6756 }
6757 
alc295_fixup_chromebook(struct hda_codec * codec,const struct hda_fixup * fix,int action)6758 static void alc295_fixup_chromebook(struct hda_codec *codec,
6759 				    const struct hda_fixup *fix, int action)
6760 {
6761 	struct alc_spec *spec = codec->spec;
6762 
6763 	switch (action) {
6764 	case HDA_FIXUP_ACT_PRE_PROBE:
6765 		spec->ultra_low_power = true;
6766 		break;
6767 	case HDA_FIXUP_ACT_INIT:
6768 		alc_combo_jack_hp_jd_restart(codec);
6769 		break;
6770 	}
6771 }
6772 
alc256_fixup_chromebook(struct hda_codec * codec,const struct hda_fixup * fix,int action)6773 static void alc256_fixup_chromebook(struct hda_codec *codec,
6774 				    const struct hda_fixup *fix, int action)
6775 {
6776 	struct alc_spec *spec = codec->spec;
6777 
6778 	switch (action) {
6779 	case HDA_FIXUP_ACT_PRE_PROBE:
6780 		spec->gen.suppress_auto_mute = 1;
6781 		spec->gen.suppress_auto_mic = 1;
6782 		spec->en_3kpull_low = false;
6783 		break;
6784 	}
6785 }
6786 
alc_fixup_disable_mic_vref(struct hda_codec * codec,const struct hda_fixup * fix,int action)6787 static void alc_fixup_disable_mic_vref(struct hda_codec *codec,
6788 				  const struct hda_fixup *fix, int action)
6789 {
6790 	if (action == HDA_FIXUP_ACT_PRE_PROBE)
6791 		snd_hda_codec_set_pin_target(codec, 0x19, PIN_VREFHIZ);
6792 }
6793 
6794 
alc294_gx502_toggle_output(struct hda_codec * codec,struct hda_jack_callback * cb)6795 static void alc294_gx502_toggle_output(struct hda_codec *codec,
6796 					struct hda_jack_callback *cb)
6797 {
6798 	/* The Windows driver sets the codec up in a very different way where
6799 	 * it appears to leave 0x10 = 0x8a20 set. For Linux we need to toggle it
6800 	 */
6801 	if (snd_hda_jack_detect_state(codec, 0x21) == HDA_JACK_PRESENT)
6802 		alc_write_coef_idx(codec, 0x10, 0x8a20);
6803 	else
6804 		alc_write_coef_idx(codec, 0x10, 0x0a20);
6805 }
6806 
alc294_fixup_gx502_hp(struct hda_codec * codec,const struct hda_fixup * fix,int action)6807 static void alc294_fixup_gx502_hp(struct hda_codec *codec,
6808 					const struct hda_fixup *fix, int action)
6809 {
6810 	/* Pin 0x21: headphones/headset mic */
6811 	if (!is_jack_detectable(codec, 0x21))
6812 		return;
6813 
6814 	switch (action) {
6815 	case HDA_FIXUP_ACT_PRE_PROBE:
6816 		snd_hda_jack_detect_enable_callback(codec, 0x21,
6817 				alc294_gx502_toggle_output);
6818 		break;
6819 	case HDA_FIXUP_ACT_INIT:
6820 		/* Make sure to start in a correct state, i.e. if
6821 		 * headphones have been plugged in before powering up the system
6822 		 */
6823 		alc294_gx502_toggle_output(codec, NULL);
6824 		break;
6825 	}
6826 }
6827 
alc294_gu502_toggle_output(struct hda_codec * codec,struct hda_jack_callback * cb)6828 static void alc294_gu502_toggle_output(struct hda_codec *codec,
6829 				       struct hda_jack_callback *cb)
6830 {
6831 	/* Windows sets 0x10 to 0x8420 for Node 0x20 which is
6832 	 * responsible from changes between speakers and headphones
6833 	 */
6834 	if (snd_hda_jack_detect_state(codec, 0x21) == HDA_JACK_PRESENT)
6835 		alc_write_coef_idx(codec, 0x10, 0x8420);
6836 	else
6837 		alc_write_coef_idx(codec, 0x10, 0x0a20);
6838 }
6839 
alc294_fixup_gu502_hp(struct hda_codec * codec,const struct hda_fixup * fix,int action)6840 static void alc294_fixup_gu502_hp(struct hda_codec *codec,
6841 				  const struct hda_fixup *fix, int action)
6842 {
6843 	if (!is_jack_detectable(codec, 0x21))
6844 		return;
6845 
6846 	switch (action) {
6847 	case HDA_FIXUP_ACT_PRE_PROBE:
6848 		snd_hda_jack_detect_enable_callback(codec, 0x21,
6849 				alc294_gu502_toggle_output);
6850 		break;
6851 	case HDA_FIXUP_ACT_INIT:
6852 		alc294_gu502_toggle_output(codec, NULL);
6853 		break;
6854 	}
6855 }
6856 
alc285_fixup_hp_gpio_amp_init(struct hda_codec * codec,const struct hda_fixup * fix,int action)6857 static void  alc285_fixup_hp_gpio_amp_init(struct hda_codec *codec,
6858 			      const struct hda_fixup *fix, int action)
6859 {
6860 	if (action != HDA_FIXUP_ACT_INIT)
6861 		return;
6862 
6863 	msleep(100);
6864 	alc_write_coef_idx(codec, 0x65, 0x0);
6865 }
6866 
alc274_fixup_hp_headset_mic(struct hda_codec * codec,const struct hda_fixup * fix,int action)6867 static void alc274_fixup_hp_headset_mic(struct hda_codec *codec,
6868 				    const struct hda_fixup *fix, int action)
6869 {
6870 	switch (action) {
6871 	case HDA_FIXUP_ACT_INIT:
6872 		alc_combo_jack_hp_jd_restart(codec);
6873 		break;
6874 	}
6875 }
6876 
alc_fixup_no_int_mic(struct hda_codec * codec,const struct hda_fixup * fix,int action)6877 static void alc_fixup_no_int_mic(struct hda_codec *codec,
6878 				    const struct hda_fixup *fix, int action)
6879 {
6880 	struct alc_spec *spec = codec->spec;
6881 
6882 	switch (action) {
6883 	case HDA_FIXUP_ACT_PRE_PROBE:
6884 		/* Mic RING SLEEVE swap for combo jack */
6885 		alc_update_coef_idx(codec, 0x45, 0xf<<12 | 1<<10, 5<<12);
6886 		spec->no_internal_mic_pin = true;
6887 		break;
6888 	case HDA_FIXUP_ACT_INIT:
6889 		alc_combo_jack_hp_jd_restart(codec);
6890 		break;
6891 	}
6892 }
6893 
6894 /* GPIO1 = amplifier on/off
6895  * GPIO3 = mic mute LED
6896  */
alc285_fixup_hp_spectre_x360_eb1(struct hda_codec * codec,const struct hda_fixup * fix,int action)6897 static void alc285_fixup_hp_spectre_x360_eb1(struct hda_codec *codec,
6898 					  const struct hda_fixup *fix, int action)
6899 {
6900 	static const hda_nid_t conn[] = { 0x02 };
6901 
6902 	struct alc_spec *spec = codec->spec;
6903 	static const struct hda_pintbl pincfgs[] = {
6904 		{ 0x14, 0x90170110 },  /* front/high speakers */
6905 		{ 0x17, 0x90170130 },  /* back/bass speakers */
6906 		{ }
6907 	};
6908 
6909 	//enable micmute led
6910 	alc_fixup_hp_gpio_led(codec, action, 0x00, 0x04);
6911 
6912 	switch (action) {
6913 	case HDA_FIXUP_ACT_PRE_PROBE:
6914 		spec->micmute_led_polarity = 1;
6915 		/* needed for amp of back speakers */
6916 		spec->gpio_mask |= 0x01;
6917 		spec->gpio_dir |= 0x01;
6918 		snd_hda_apply_pincfgs(codec, pincfgs);
6919 		/* share DAC to have unified volume control */
6920 		snd_hda_override_conn_list(codec, 0x14, ARRAY_SIZE(conn), conn);
6921 		snd_hda_override_conn_list(codec, 0x17, ARRAY_SIZE(conn), conn);
6922 		break;
6923 	case HDA_FIXUP_ACT_INIT:
6924 		/* need to toggle GPIO to enable the amp of back speakers */
6925 		alc_update_gpio_data(codec, 0x01, true);
6926 		msleep(100);
6927 		alc_update_gpio_data(codec, 0x01, false);
6928 		break;
6929 	}
6930 }
6931 
alc285_fixup_hp_spectre_x360(struct hda_codec * codec,const struct hda_fixup * fix,int action)6932 static void alc285_fixup_hp_spectre_x360(struct hda_codec *codec,
6933 					  const struct hda_fixup *fix, int action)
6934 {
6935 	static const hda_nid_t conn[] = { 0x02 };
6936 	static const struct hda_pintbl pincfgs[] = {
6937 		{ 0x14, 0x90170110 },  /* rear speaker */
6938 		{ }
6939 	};
6940 
6941 	switch (action) {
6942 	case HDA_FIXUP_ACT_PRE_PROBE:
6943 		snd_hda_apply_pincfgs(codec, pincfgs);
6944 		/* force front speaker to DAC1 */
6945 		snd_hda_override_conn_list(codec, 0x17, ARRAY_SIZE(conn), conn);
6946 		break;
6947 	}
6948 }
6949 
alc285_fixup_hp_envy_x360(struct hda_codec * codec,const struct hda_fixup * fix,int action)6950 static void alc285_fixup_hp_envy_x360(struct hda_codec *codec,
6951 				      const struct hda_fixup *fix,
6952 				      int action)
6953 {
6954 	static const struct coef_fw coefs[] = {
6955 		WRITE_COEF(0x08, 0x6a0c), WRITE_COEF(0x0d, 0xa023),
6956 		WRITE_COEF(0x10, 0x0320), WRITE_COEF(0x1a, 0x8c03),
6957 		WRITE_COEF(0x25, 0x1800), WRITE_COEF(0x26, 0x003a),
6958 		WRITE_COEF(0x28, 0x1dfe), WRITE_COEF(0x29, 0xb014),
6959 		WRITE_COEF(0x2b, 0x1dfe), WRITE_COEF(0x37, 0xfe15),
6960 		WRITE_COEF(0x38, 0x7909), WRITE_COEF(0x45, 0xd489),
6961 		WRITE_COEF(0x46, 0x00f4), WRITE_COEF(0x4a, 0x21e0),
6962 		WRITE_COEF(0x66, 0x03f0), WRITE_COEF(0x67, 0x1000),
6963 		WRITE_COEF(0x6e, 0x1005), { }
6964 	};
6965 
6966 	static const struct hda_pintbl pincfgs[] = {
6967 		{ 0x12, 0xb7a60130 },  /* Internal microphone*/
6968 		{ 0x14, 0x90170150 },  /* B&O soundbar speakers */
6969 		{ 0x17, 0x90170153 },  /* Side speakers */
6970 		{ 0x19, 0x03a11040 },  /* Headset microphone */
6971 		{ }
6972 	};
6973 
6974 	switch (action) {
6975 	case HDA_FIXUP_ACT_PRE_PROBE:
6976 		snd_hda_apply_pincfgs(codec, pincfgs);
6977 
6978 		/* Fixes volume control problem for side speakers */
6979 		alc295_fixup_disable_dac3(codec, fix, action);
6980 
6981 		/* Fixes no sound from headset speaker */
6982 		snd_hda_codec_amp_stereo(codec, 0x21, HDA_OUTPUT, 0, -1, 0);
6983 
6984 		/* Auto-enable headset mic when plugged */
6985 		snd_hda_jack_set_gating_jack(codec, 0x19, 0x21);
6986 
6987 		/* Headset mic volume enhancement */
6988 		snd_hda_codec_set_pin_target(codec, 0x19, PIN_VREF50);
6989 		break;
6990 	case HDA_FIXUP_ACT_INIT:
6991 		alc_process_coef_fw(codec, coefs);
6992 		break;
6993 	case HDA_FIXUP_ACT_BUILD:
6994 		rename_ctl(codec, "Bass Speaker Playback Volume",
6995 			   "B&O-Tuned Playback Volume");
6996 		rename_ctl(codec, "Front Playback Switch",
6997 			   "B&O Soundbar Playback Switch");
6998 		rename_ctl(codec, "Bass Speaker Playback Switch",
6999 			   "Side Speaker Playback Switch");
7000 		break;
7001 	}
7002 }
7003 
7004 /* for hda_fixup_thinkpad_acpi() */
7005 #include "thinkpad_helper.c"
7006 
alc_fixup_thinkpad_acpi(struct hda_codec * codec,const struct hda_fixup * fix,int action)7007 static void alc_fixup_thinkpad_acpi(struct hda_codec *codec,
7008 				    const struct hda_fixup *fix, int action)
7009 {
7010 	alc_fixup_no_shutup(codec, fix, action); /* reduce click noise */
7011 	hda_fixup_thinkpad_acpi(codec, fix, action);
7012 }
7013 
7014 /* for hda_fixup_ideapad_acpi() */
7015 #include "ideapad_hotkey_led_helper.c"
7016 
alc_fixup_ideapad_acpi(struct hda_codec * codec,const struct hda_fixup * fix,int action)7017 static void alc_fixup_ideapad_acpi(struct hda_codec *codec,
7018 				   const struct hda_fixup *fix, int action)
7019 {
7020 	hda_fixup_ideapad_acpi(codec, fix, action);
7021 }
7022 
7023 /* Fixup for Lenovo Legion 15IMHg05 speaker output on headset removal. */
alc287_fixup_legion_15imhg05_speakers(struct hda_codec * codec,const struct hda_fixup * fix,int action)7024 static void alc287_fixup_legion_15imhg05_speakers(struct hda_codec *codec,
7025 						  const struct hda_fixup *fix,
7026 						  int action)
7027 {
7028 	struct alc_spec *spec = codec->spec;
7029 
7030 	switch (action) {
7031 	case HDA_FIXUP_ACT_PRE_PROBE:
7032 		spec->gen.suppress_auto_mute = 1;
7033 		break;
7034 	}
7035 }
7036 
comp_acpi_device_notify(acpi_handle handle,u32 event,void * data)7037 static void comp_acpi_device_notify(acpi_handle handle, u32 event, void *data)
7038 {
7039 	struct hda_codec *cdc = data;
7040 	struct alc_spec *spec = cdc->spec;
7041 
7042 	codec_info(cdc, "ACPI Notification %d\n", event);
7043 
7044 	hda_component_acpi_device_notify(&spec->comps, handle, event, data);
7045 }
7046 
comp_bind(struct device * dev)7047 static int comp_bind(struct device *dev)
7048 {
7049 	struct hda_codec *cdc = dev_to_hda_codec(dev);
7050 	struct alc_spec *spec = cdc->spec;
7051 	int ret;
7052 
7053 	ret = hda_component_manager_bind(cdc, &spec->comps);
7054 	if (ret)
7055 		return ret;
7056 
7057 	return hda_component_manager_bind_acpi_notifications(cdc,
7058 							     &spec->comps,
7059 							     comp_acpi_device_notify, cdc);
7060 }
7061 
comp_unbind(struct device * dev)7062 static void comp_unbind(struct device *dev)
7063 {
7064 	struct hda_codec *cdc = dev_to_hda_codec(dev);
7065 	struct alc_spec *spec = cdc->spec;
7066 
7067 	hda_component_manager_unbind_acpi_notifications(cdc, &spec->comps, comp_acpi_device_notify);
7068 	hda_component_manager_unbind(cdc, &spec->comps);
7069 }
7070 
7071 static const struct component_master_ops comp_master_ops = {
7072 	.bind = comp_bind,
7073 	.unbind = comp_unbind,
7074 };
7075 
comp_generic_playback_hook(struct hda_pcm_stream * hinfo,struct hda_codec * cdc,struct snd_pcm_substream * sub,int action)7076 static void comp_generic_playback_hook(struct hda_pcm_stream *hinfo, struct hda_codec *cdc,
7077 				       struct snd_pcm_substream *sub, int action)
7078 {
7079 	struct alc_spec *spec = cdc->spec;
7080 
7081 	hda_component_manager_playback_hook(&spec->comps, action);
7082 }
7083 
comp_generic_fixup(struct hda_codec * cdc,int action,const char * bus,const char * hid,const char * match_str,int count)7084 static void comp_generic_fixup(struct hda_codec *cdc, int action, const char *bus,
7085 			       const char *hid, const char *match_str, int count)
7086 {
7087 	struct alc_spec *spec = cdc->spec;
7088 	int ret;
7089 
7090 	switch (action) {
7091 	case HDA_FIXUP_ACT_PRE_PROBE:
7092 		ret = hda_component_manager_init(cdc, &spec->comps, count, bus, hid,
7093 						 match_str, &comp_master_ops);
7094 		if (ret)
7095 			return;
7096 
7097 		spec->gen.pcm_playback_hook = comp_generic_playback_hook;
7098 		break;
7099 	case HDA_FIXUP_ACT_FREE:
7100 		hda_component_manager_free(&spec->comps, &comp_master_ops);
7101 		break;
7102 	}
7103 }
7104 
find_cirrus_companion_amps(struct hda_codec * cdc)7105 static void find_cirrus_companion_amps(struct hda_codec *cdc)
7106 {
7107 	struct device *dev = hda_codec_dev(cdc);
7108 	struct acpi_device *adev;
7109 	struct fwnode_handle *fwnode __free(fwnode_handle) = NULL;
7110 	const char *bus = NULL;
7111 	static const struct {
7112 		const char *hid;
7113 		const char *name;
7114 	} acpi_ids[] = {{ "CSC3554", "cs35l54-hda" },
7115 			{ "CSC3556", "cs35l56-hda" },
7116 			{ "CSC3557", "cs35l57-hda" }};
7117 	char *match;
7118 	int i, count = 0, count_devindex = 0;
7119 
7120 	for (i = 0; i < ARRAY_SIZE(acpi_ids); ++i) {
7121 		adev = acpi_dev_get_first_match_dev(acpi_ids[i].hid, NULL, -1);
7122 		if (adev)
7123 			break;
7124 	}
7125 	if (!adev) {
7126 		codec_dbg(cdc, "Did not find ACPI entry for a Cirrus Amp\n");
7127 		return;
7128 	}
7129 
7130 	count = i2c_acpi_client_count(adev);
7131 	if (count > 0) {
7132 		bus = "i2c";
7133 	} else {
7134 		count = acpi_spi_count_resources(adev);
7135 		if (count > 0)
7136 			bus = "spi";
7137 	}
7138 
7139 	fwnode = fwnode_handle_get(acpi_fwnode_handle(adev));
7140 	acpi_dev_put(adev);
7141 
7142 	if (!bus) {
7143 		codec_err(cdc, "Did not find any buses for %s\n", acpi_ids[i].hid);
7144 		return;
7145 	}
7146 
7147 	if (!fwnode) {
7148 		codec_err(cdc, "Could not get fwnode for %s\n", acpi_ids[i].hid);
7149 		return;
7150 	}
7151 
7152 	/*
7153 	 * When available the cirrus,dev-index property is an accurate
7154 	 * count of the amps in a system and is used in preference to
7155 	 * the count of bus devices that can contain additional address
7156 	 * alias entries.
7157 	 */
7158 	count_devindex = fwnode_property_count_u32(fwnode, "cirrus,dev-index");
7159 	if (count_devindex > 0)
7160 		count = count_devindex;
7161 
7162 	match = devm_kasprintf(dev, GFP_KERNEL, "-%%s:00-%s.%%d", acpi_ids[i].name);
7163 	if (!match)
7164 		return;
7165 	codec_info(cdc, "Found %d %s on %s (%s)\n", count, acpi_ids[i].hid, bus, match);
7166 	comp_generic_fixup(cdc, HDA_FIXUP_ACT_PRE_PROBE, bus, acpi_ids[i].hid, match, count);
7167 }
7168 
cs35l41_fixup_i2c_two(struct hda_codec * cdc,const struct hda_fixup * fix,int action)7169 static void cs35l41_fixup_i2c_two(struct hda_codec *cdc, const struct hda_fixup *fix, int action)
7170 {
7171 	comp_generic_fixup(cdc, action, "i2c", "CSC3551", "-%s:00-cs35l41-hda.%d", 2);
7172 }
7173 
cs35l41_fixup_i2c_four(struct hda_codec * cdc,const struct hda_fixup * fix,int action)7174 static void cs35l41_fixup_i2c_four(struct hda_codec *cdc, const struct hda_fixup *fix, int action)
7175 {
7176 	comp_generic_fixup(cdc, action, "i2c", "CSC3551", "-%s:00-cs35l41-hda.%d", 4);
7177 }
7178 
cs35l41_fixup_spi_two(struct hda_codec * codec,const struct hda_fixup * fix,int action)7179 static void cs35l41_fixup_spi_two(struct hda_codec *codec, const struct hda_fixup *fix, int action)
7180 {
7181 	comp_generic_fixup(codec, action, "spi", "CSC3551", "-%s:00-cs35l41-hda.%d", 2);
7182 }
7183 
cs35l41_fixup_spi_four(struct hda_codec * codec,const struct hda_fixup * fix,int action)7184 static void cs35l41_fixup_spi_four(struct hda_codec *codec, const struct hda_fixup *fix, int action)
7185 {
7186 	comp_generic_fixup(codec, action, "spi", "CSC3551", "-%s:00-cs35l41-hda.%d", 4);
7187 }
7188 
alc287_fixup_legion_16achg6_speakers(struct hda_codec * cdc,const struct hda_fixup * fix,int action)7189 static void alc287_fixup_legion_16achg6_speakers(struct hda_codec *cdc, const struct hda_fixup *fix,
7190 						 int action)
7191 {
7192 	comp_generic_fixup(cdc, action, "i2c", "CLSA0100", "-%s:00-cs35l41-hda.%d", 2);
7193 }
7194 
alc287_fixup_legion_16ithg6_speakers(struct hda_codec * cdc,const struct hda_fixup * fix,int action)7195 static void alc287_fixup_legion_16ithg6_speakers(struct hda_codec *cdc, const struct hda_fixup *fix,
7196 						 int action)
7197 {
7198 	comp_generic_fixup(cdc, action, "i2c", "CLSA0101", "-%s:00-cs35l41-hda.%d", 2);
7199 }
7200 
alc285_fixup_asus_ga403u(struct hda_codec * cdc,const struct hda_fixup * fix,int action)7201 static void alc285_fixup_asus_ga403u(struct hda_codec *cdc, const struct hda_fixup *fix, int action)
7202 {
7203 	/*
7204 	 * The same SSID has been re-used in different hardware, they have
7205 	 * different codecs and the newer GA403U has a ALC285.
7206 	 */
7207 	if (cdc->core.vendor_id != 0x10ec0285)
7208 		alc_fixup_inv_dmic(cdc, fix, action);
7209 }
7210 
tas2781_fixup_i2c(struct hda_codec * cdc,const struct hda_fixup * fix,int action)7211 static void tas2781_fixup_i2c(struct hda_codec *cdc,
7212 	const struct hda_fixup *fix, int action)
7213 {
7214 	comp_generic_fixup(cdc, action, "i2c", "TIAS2781", "-%s:00", 1);
7215 }
7216 
tas2781_fixup_spi(struct hda_codec * cdc,const struct hda_fixup * fix,int action)7217 static void tas2781_fixup_spi(struct hda_codec *cdc, const struct hda_fixup *fix, int action)
7218 {
7219 	comp_generic_fixup(cdc, action, "spi", "TXNW2781", "-%s:00-tas2781-hda.%d", 2);
7220 }
7221 
yoga7_14arb7_fixup_i2c(struct hda_codec * cdc,const struct hda_fixup * fix,int action)7222 static void yoga7_14arb7_fixup_i2c(struct hda_codec *cdc,
7223 	const struct hda_fixup *fix, int action)
7224 {
7225 	comp_generic_fixup(cdc, action, "i2c", "INT8866", "-%s:00", 1);
7226 }
7227 
alc256_fixup_acer_sfg16_micmute_led(struct hda_codec * codec,const struct hda_fixup * fix,int action)7228 static void alc256_fixup_acer_sfg16_micmute_led(struct hda_codec *codec,
7229 	const struct hda_fixup *fix, int action)
7230 {
7231 	alc_fixup_hp_gpio_led(codec, action, 0, 0x04);
7232 }
7233 
7234 
7235 /* for alc295_fixup_hp_top_speakers */
7236 #include "hp_x360_helper.c"
7237 
7238 /* for alc285_fixup_ideapad_s740_coef() */
7239 #include "ideapad_s740_helper.c"
7240 
7241 static const struct coef_fw alc256_fixup_set_coef_defaults_coefs[] = {
7242 	WRITE_COEF(0x10, 0x0020), WRITE_COEF(0x24, 0x0000),
7243 	WRITE_COEF(0x26, 0x0000), WRITE_COEF(0x29, 0x3000),
7244 	WRITE_COEF(0x37, 0xfe05), WRITE_COEF(0x45, 0x5089),
7245 	{}
7246 };
7247 
alc256_fixup_set_coef_defaults(struct hda_codec * codec,const struct hda_fixup * fix,int action)7248 static void alc256_fixup_set_coef_defaults(struct hda_codec *codec,
7249 					   const struct hda_fixup *fix,
7250 					   int action)
7251 {
7252 	/*
7253 	 * A certain other OS sets these coeffs to different values. On at least
7254 	 * one TongFang barebone these settings might survive even a cold
7255 	 * reboot. So to restore a clean slate the values are explicitly reset
7256 	 * to default here. Without this, the external microphone is always in a
7257 	 * plugged-in state, while the internal microphone is always in an
7258 	 * unplugged state, breaking the ability to use the internal microphone.
7259 	 */
7260 	alc_process_coef_fw(codec, alc256_fixup_set_coef_defaults_coefs);
7261 }
7262 
7263 static const struct coef_fw alc233_fixup_no_audio_jack_coefs[] = {
7264 	WRITE_COEF(0x1a, 0x9003), WRITE_COEF(0x1b, 0x0e2b), WRITE_COEF(0x37, 0xfe06),
7265 	WRITE_COEF(0x38, 0x4981), WRITE_COEF(0x45, 0xd489), WRITE_COEF(0x46, 0x0074),
7266 	WRITE_COEF(0x49, 0x0149),
7267 	{}
7268 };
7269 
alc233_fixup_no_audio_jack(struct hda_codec * codec,const struct hda_fixup * fix,int action)7270 static void alc233_fixup_no_audio_jack(struct hda_codec *codec,
7271 				       const struct hda_fixup *fix,
7272 				       int action)
7273 {
7274 	/*
7275 	 * The audio jack input and output is not detected on the ASRock NUC Box
7276 	 * 1100 series when cold booting without this fix. Warm rebooting from a
7277 	 * certain other OS makes the audio functional, as COEF settings are
7278 	 * preserved in this case. This fix sets these altered COEF values as
7279 	 * the default.
7280 	 */
7281 	alc_process_coef_fw(codec, alc233_fixup_no_audio_jack_coefs);
7282 }
7283 
alc256_fixup_mic_no_presence_and_resume(struct hda_codec * codec,const struct hda_fixup * fix,int action)7284 static void alc256_fixup_mic_no_presence_and_resume(struct hda_codec *codec,
7285 						    const struct hda_fixup *fix,
7286 						    int action)
7287 {
7288 	/*
7289 	 * The Clevo NJ51CU comes either with the ALC293 or the ALC256 codec,
7290 	 * but uses the 0x8686 subproduct id in both cases. The ALC256 codec
7291 	 * needs an additional quirk for sound working after suspend and resume.
7292 	 */
7293 	if (codec->core.vendor_id == 0x10ec0256) {
7294 		alc_update_coef_idx(codec, 0x10, 1<<9, 0);
7295 		snd_hda_codec_set_pincfg(codec, 0x19, 0x04a11120);
7296 	} else {
7297 		snd_hda_codec_set_pincfg(codec, 0x1a, 0x04a1113c);
7298 	}
7299 }
7300 
alc256_decrease_headphone_amp_val(struct hda_codec * codec,const struct hda_fixup * fix,int action)7301 static void alc256_decrease_headphone_amp_val(struct hda_codec *codec,
7302 					      const struct hda_fixup *fix, int action)
7303 {
7304 	u32 caps;
7305 	u8 nsteps, offs;
7306 
7307 	if (action != HDA_FIXUP_ACT_PRE_PROBE)
7308 		return;
7309 
7310 	caps = query_amp_caps(codec, 0x3, HDA_OUTPUT);
7311 	nsteps = ((caps & AC_AMPCAP_NUM_STEPS) >> AC_AMPCAP_NUM_STEPS_SHIFT) - 10;
7312 	offs = ((caps & AC_AMPCAP_OFFSET) >> AC_AMPCAP_OFFSET_SHIFT) - 10;
7313 	caps &= ~AC_AMPCAP_NUM_STEPS & ~AC_AMPCAP_OFFSET;
7314 	caps |= (nsteps << AC_AMPCAP_NUM_STEPS_SHIFT) | (offs << AC_AMPCAP_OFFSET_SHIFT);
7315 
7316 	if (snd_hda_override_amp_caps(codec, 0x3, HDA_OUTPUT, caps))
7317 		codec_warn(codec, "failed to override amp caps for NID 0x3\n");
7318 }
7319 
alc_fixup_dell4_mic_no_presence_quiet(struct hda_codec * codec,const struct hda_fixup * fix,int action)7320 static void alc_fixup_dell4_mic_no_presence_quiet(struct hda_codec *codec,
7321 						  const struct hda_fixup *fix,
7322 						  int action)
7323 {
7324 	struct alc_spec *spec = codec->spec;
7325 	struct hda_input_mux *imux = &spec->gen.input_mux;
7326 	int i;
7327 
7328 	alc269_fixup_limit_int_mic_boost(codec, fix, action);
7329 
7330 	switch (action) {
7331 	case HDA_FIXUP_ACT_PRE_PROBE:
7332 		/**
7333 		 * Set the vref of pin 0x19 (Headset Mic) and pin 0x1b (Headphone Mic)
7334 		 * to Hi-Z to avoid pop noises at startup and when plugging and
7335 		 * unplugging headphones.
7336 		 */
7337 		snd_hda_codec_set_pin_target(codec, 0x19, PIN_VREFHIZ);
7338 		snd_hda_codec_set_pin_target(codec, 0x1b, PIN_VREFHIZ);
7339 		break;
7340 	case HDA_FIXUP_ACT_PROBE:
7341 		/**
7342 		 * Make the internal mic (0x12) the default input source to
7343 		 * prevent pop noises on cold boot.
7344 		 */
7345 		for (i = 0; i < imux->num_items; i++) {
7346 			if (spec->gen.imux_pins[i] == 0x12) {
7347 				spec->gen.cur_mux[0] = i;
7348 				break;
7349 			}
7350 		}
7351 		break;
7352 	}
7353 }
7354 
alc287_fixup_yoga9_14iap7_bass_spk_pin(struct hda_codec * codec,const struct hda_fixup * fix,int action)7355 static void alc287_fixup_yoga9_14iap7_bass_spk_pin(struct hda_codec *codec,
7356 					  const struct hda_fixup *fix, int action)
7357 {
7358 	/*
7359 	 * The Pin Complex 0x17 for the bass speakers is wrongly reported as
7360 	 * unconnected.
7361 	 */
7362 	static const struct hda_pintbl pincfgs[] = {
7363 		{ 0x17, 0x90170121 },
7364 		{ }
7365 	};
7366 	/*
7367 	 * Avoid DAC 0x06 and 0x08, as they have no volume controls.
7368 	 * DAC 0x02 and 0x03 would be fine.
7369 	 */
7370 	static const hda_nid_t conn[] = { 0x02, 0x03 };
7371 	/*
7372 	 * Prefer both speakerbar (0x14) and bass speakers (0x17) connected to DAC 0x02.
7373 	 * Headphones (0x21) are connected to DAC 0x03.
7374 	 */
7375 	static const hda_nid_t preferred_pairs[] = {
7376 		0x14, 0x02,
7377 		0x17, 0x02,
7378 		0x21, 0x03,
7379 		0
7380 	};
7381 	struct alc_spec *spec = codec->spec;
7382 
7383 	switch (action) {
7384 	case HDA_FIXUP_ACT_PRE_PROBE:
7385 		snd_hda_apply_pincfgs(codec, pincfgs);
7386 		snd_hda_override_conn_list(codec, 0x17, ARRAY_SIZE(conn), conn);
7387 		spec->gen.preferred_dacs = preferred_pairs;
7388 		break;
7389 	}
7390 }
7391 
alc295_fixup_dell_inspiron_top_speakers(struct hda_codec * codec,const struct hda_fixup * fix,int action)7392 static void alc295_fixup_dell_inspiron_top_speakers(struct hda_codec *codec,
7393 					  const struct hda_fixup *fix, int action)
7394 {
7395 	static const struct hda_pintbl pincfgs[] = {
7396 		{ 0x14, 0x90170151 },
7397 		{ 0x17, 0x90170150 },
7398 		{ }
7399 	};
7400 	static const hda_nid_t conn[] = { 0x02, 0x03 };
7401 	static const hda_nid_t preferred_pairs[] = {
7402 		0x14, 0x02,
7403 		0x17, 0x03,
7404 		0x21, 0x02,
7405 		0
7406 	};
7407 	struct alc_spec *spec = codec->spec;
7408 
7409 	alc_fixup_no_shutup(codec, fix, action);
7410 
7411 	switch (action) {
7412 	case HDA_FIXUP_ACT_PRE_PROBE:
7413 		snd_hda_apply_pincfgs(codec, pincfgs);
7414 		snd_hda_override_conn_list(codec, 0x17, ARRAY_SIZE(conn), conn);
7415 		spec->gen.preferred_dacs = preferred_pairs;
7416 		break;
7417 	}
7418 }
7419 
7420 /* Forcibly assign NID 0x03 to HP while NID 0x02 to SPK */
alc287_fixup_bind_dacs(struct hda_codec * codec,const struct hda_fixup * fix,int action)7421 static void alc287_fixup_bind_dacs(struct hda_codec *codec,
7422 				    const struct hda_fixup *fix, int action)
7423 {
7424 	struct alc_spec *spec = codec->spec;
7425 	static const hda_nid_t conn[] = { 0x02, 0x03 }; /* exclude 0x06 */
7426 	static const hda_nid_t preferred_pairs[] = {
7427 		0x17, 0x02, 0x21, 0x03, 0
7428 	};
7429 
7430 	if (action != HDA_FIXUP_ACT_PRE_PROBE)
7431 		return;
7432 
7433 	snd_hda_override_conn_list(codec, 0x17, ARRAY_SIZE(conn), conn);
7434 	spec->gen.preferred_dacs = preferred_pairs;
7435 	spec->gen.auto_mute_via_amp = 1;
7436 	if (spec->gen.autocfg.speaker_pins[0] != 0x14) {
7437 		snd_hda_codec_write_cache(codec, 0x14, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
7438 					0x0); /* Make sure 0x14 was disable */
7439 	}
7440 }
7441 /* Fix none verb table of Headset Mic pin */
alc_fixup_headset_mic(struct hda_codec * codec,const struct hda_fixup * fix,int action)7442 static void alc_fixup_headset_mic(struct hda_codec *codec,
7443 				   const struct hda_fixup *fix, int action)
7444 {
7445 	struct alc_spec *spec = codec->spec;
7446 	static const struct hda_pintbl pincfgs[] = {
7447 		{ 0x19, 0x03a1103c },
7448 		{ }
7449 	};
7450 
7451 	switch (action) {
7452 	case HDA_FIXUP_ACT_PRE_PROBE:
7453 		snd_hda_apply_pincfgs(codec, pincfgs);
7454 		alc_update_coef_idx(codec, 0x45, 0xf<<12 | 1<<10, 5<<12);
7455 		spec->parse_flags |= HDA_PINCFG_HEADSET_MIC;
7456 		break;
7457 	}
7458 }
7459 
alc245_fixup_hp_spectre_x360_eu0xxx(struct hda_codec * codec,const struct hda_fixup * fix,int action)7460 static void alc245_fixup_hp_spectre_x360_eu0xxx(struct hda_codec *codec,
7461 					  const struct hda_fixup *fix, int action)
7462 {
7463 	/*
7464 	 * The Pin Complex 0x14 for the treble speakers is wrongly reported as
7465 	 * unconnected.
7466 	 * The Pin Complex 0x17 for the bass speakers has the lowest association
7467 	 * and sequence values so shift it up a bit to squeeze 0x14 in.
7468 	 */
7469 	static const struct hda_pintbl pincfgs[] = {
7470 		{ 0x14, 0x90170110 }, // top/treble
7471 		{ 0x17, 0x90170111 }, // bottom/bass
7472 		{ }
7473 	};
7474 
7475 	/*
7476 	 * Force DAC 0x02 for the bass speakers 0x17.
7477 	 */
7478 	static const hda_nid_t conn[] = { 0x02 };
7479 
7480 	switch (action) {
7481 	case HDA_FIXUP_ACT_PRE_PROBE:
7482 		snd_hda_apply_pincfgs(codec, pincfgs);
7483 		snd_hda_override_conn_list(codec, 0x17, ARRAY_SIZE(conn), conn);
7484 		break;
7485 	}
7486 
7487 	cs35l41_fixup_i2c_two(codec, fix, action);
7488 	alc245_fixup_hp_mute_led_coefbit(codec, fix, action);
7489 	alc245_fixup_hp_gpio_led(codec, fix, action);
7490 }
7491 
7492 /* some changes for Spectre x360 16, 2024 model */
alc245_fixup_hp_spectre_x360_16_aa0xxx(struct hda_codec * codec,const struct hda_fixup * fix,int action)7493 static void alc245_fixup_hp_spectre_x360_16_aa0xxx(struct hda_codec *codec,
7494 					  const struct hda_fixup *fix, int action)
7495 {
7496 	/*
7497 	 * The Pin Complex 0x14 for the treble speakers is wrongly reported as
7498 	 * unconnected.
7499 	 * The Pin Complex 0x17 for the bass speakers has the lowest association
7500 	 * and sequence values so shift it up a bit to squeeze 0x14 in.
7501 	 */
7502 	struct alc_spec *spec = codec->spec;
7503 	static const struct hda_pintbl pincfgs[] = {
7504 		{ 0x14, 0x90170110 }, // top/treble
7505 		{ 0x17, 0x90170111 }, // bottom/bass
7506 		{ }
7507 	};
7508 
7509 	/*
7510 	 * Force DAC 0x02 for the bass speakers 0x17.
7511 	 */
7512 	static const hda_nid_t conn[] = { 0x02 };
7513 
7514 	switch (action) {
7515 	case HDA_FIXUP_ACT_PRE_PROBE:
7516 		/* needed for amp of back speakers */
7517 		spec->gpio_mask |= 0x01;
7518 		spec->gpio_dir |= 0x01;
7519 		snd_hda_apply_pincfgs(codec, pincfgs);
7520 		snd_hda_override_conn_list(codec, 0x17, ARRAY_SIZE(conn), conn);
7521 		break;
7522 	case HDA_FIXUP_ACT_INIT:
7523 		/* need to toggle GPIO to enable the amp of back speakers */
7524 		alc_update_gpio_data(codec, 0x01, true);
7525 		msleep(100);
7526 		alc_update_gpio_data(codec, 0x01, false);
7527 		break;
7528 	}
7529 
7530 	cs35l41_fixup_i2c_two(codec, fix, action);
7531 	alc245_fixup_hp_mute_led_coefbit(codec, fix, action);
7532 	alc245_fixup_hp_gpio_led(codec, fix, action);
7533 }
7534 
7535 /*
7536  * ALC287 PCM hooks
7537  */
alc287_alc1318_playback_pcm_hook(struct hda_pcm_stream * hinfo,struct hda_codec * codec,struct snd_pcm_substream * substream,int action)7538 static void alc287_alc1318_playback_pcm_hook(struct hda_pcm_stream *hinfo,
7539 				   struct hda_codec *codec,
7540 				   struct snd_pcm_substream *substream,
7541 				   int action)
7542 {
7543 	switch (action) {
7544 	case HDA_GEN_PCM_ACT_OPEN:
7545 		alc_write_coefex_idx(codec, 0x5a, 0x00, 0x954f); /* write gpio3 to high */
7546 		break;
7547 	case HDA_GEN_PCM_ACT_CLOSE:
7548 		alc_write_coefex_idx(codec, 0x5a, 0x00, 0x554f); /* write gpio3 as default value */
7549 		break;
7550 	}
7551 }
7552 
alc287_s4_power_gpio3_default(struct hda_codec * codec)7553 static void alc287_s4_power_gpio3_default(struct hda_codec *codec)
7554 {
7555 	if (is_s4_suspend(codec)) {
7556 		alc_write_coefex_idx(codec, 0x5a, 0x00, 0x554f); /* write gpio3 as default value */
7557 	}
7558 }
7559 
alc287_fixup_lenovo_thinkpad_with_alc1318(struct hda_codec * codec,const struct hda_fixup * fix,int action)7560 static void alc287_fixup_lenovo_thinkpad_with_alc1318(struct hda_codec *codec,
7561 			       const struct hda_fixup *fix, int action)
7562 {
7563 	struct alc_spec *spec = codec->spec;
7564 	static const struct coef_fw coefs[] = {
7565 		WRITE_COEF(0x24, 0x0013), WRITE_COEF(0x25, 0x0000), WRITE_COEF(0x26, 0xC300),
7566 		WRITE_COEF(0x28, 0x0001), WRITE_COEF(0x29, 0xb023),
7567 		WRITE_COEF(0x24, 0x0013), WRITE_COEF(0x25, 0x0000), WRITE_COEF(0x26, 0xC301),
7568 		WRITE_COEF(0x28, 0x0001), WRITE_COEF(0x29, 0xb023),
7569 	};
7570 
7571 	if (action != HDA_FIXUP_ACT_PRE_PROBE)
7572 		return;
7573 	alc_update_coef_idx(codec, 0x10, 1<<11, 1<<11);
7574 	alc_process_coef_fw(codec, coefs);
7575 	spec->power_hook = alc287_s4_power_gpio3_default;
7576 	spec->gen.pcm_playback_hook = alc287_alc1318_playback_pcm_hook;
7577 }
7578 
7579 /*
7580  * Clear COEF 0x0d (PCBEEP passthrough) bit 0x40 where BIOS sets it wrongly
7581  * at PM resume
7582  */
alc283_fixup_dell_hp_resume(struct hda_codec * codec,const struct hda_fixup * fix,int action)7583 static void alc283_fixup_dell_hp_resume(struct hda_codec *codec,
7584 					const struct hda_fixup *fix, int action)
7585 {
7586 	if (action == HDA_FIXUP_ACT_INIT)
7587 		alc_write_coef_idx(codec, 0xd, 0x2800);
7588 }
7589 
7590 enum {
7591 	ALC269_FIXUP_GPIO2,
7592 	ALC269_FIXUP_SONY_VAIO,
7593 	ALC275_FIXUP_SONY_VAIO_GPIO2,
7594 	ALC269_FIXUP_DELL_M101Z,
7595 	ALC269_FIXUP_SKU_IGNORE,
7596 	ALC269_FIXUP_ASUS_G73JW,
7597 	ALC269_FIXUP_ASUS_N7601ZM_PINS,
7598 	ALC269_FIXUP_ASUS_N7601ZM,
7599 	ALC269_FIXUP_LENOVO_EAPD,
7600 	ALC275_FIXUP_SONY_HWEQ,
7601 	ALC275_FIXUP_SONY_DISABLE_AAMIX,
7602 	ALC271_FIXUP_DMIC,
7603 	ALC269_FIXUP_PCM_44K,
7604 	ALC269_FIXUP_STEREO_DMIC,
7605 	ALC269_FIXUP_HEADSET_MIC,
7606 	ALC269_FIXUP_QUANTA_MUTE,
7607 	ALC269_FIXUP_LIFEBOOK,
7608 	ALC269_FIXUP_LIFEBOOK_EXTMIC,
7609 	ALC269_FIXUP_LIFEBOOK_HP_PIN,
7610 	ALC269_FIXUP_LIFEBOOK_NO_HP_TO_LINEOUT,
7611 	ALC255_FIXUP_LIFEBOOK_U7x7_HEADSET_MIC,
7612 	ALC269_FIXUP_AMIC,
7613 	ALC269_FIXUP_DMIC,
7614 	ALC269VB_FIXUP_AMIC,
7615 	ALC269VB_FIXUP_DMIC,
7616 	ALC269_FIXUP_HP_MUTE_LED,
7617 	ALC269_FIXUP_HP_MUTE_LED_MIC1,
7618 	ALC269_FIXUP_HP_MUTE_LED_MIC2,
7619 	ALC269_FIXUP_HP_MUTE_LED_MIC3,
7620 	ALC269_FIXUP_HP_GPIO_LED,
7621 	ALC269_FIXUP_HP_GPIO_MIC1_LED,
7622 	ALC269_FIXUP_HP_LINE1_MIC1_LED,
7623 	ALC269_FIXUP_INV_DMIC,
7624 	ALC269_FIXUP_LENOVO_DOCK,
7625 	ALC269_FIXUP_LENOVO_DOCK_LIMIT_BOOST,
7626 	ALC269_FIXUP_NO_SHUTUP,
7627 	ALC286_FIXUP_SONY_MIC_NO_PRESENCE,
7628 	ALC269_FIXUP_PINCFG_NO_HP_TO_LINEOUT,
7629 	ALC269_FIXUP_DELL1_MIC_NO_PRESENCE,
7630 	ALC269_FIXUP_DELL1_LIMIT_INT_MIC_BOOST,
7631 	ALC269_FIXUP_DELL2_MIC_NO_PRESENCE,
7632 	ALC269_FIXUP_DELL3_MIC_NO_PRESENCE,
7633 	ALC269_FIXUP_DELL4_MIC_NO_PRESENCE,
7634 	ALC269_FIXUP_DELL4_MIC_NO_PRESENCE_QUIET,
7635 	ALC269_FIXUP_HEADSET_MODE,
7636 	ALC269_FIXUP_HEADSET_MODE_NO_HP_MIC,
7637 	ALC269_FIXUP_ASPIRE_HEADSET_MIC,
7638 	ALC269_FIXUP_ASUS_X101_FUNC,
7639 	ALC269_FIXUP_ASUS_X101_VERB,
7640 	ALC269_FIXUP_ASUS_X101,
7641 	ALC271_FIXUP_AMIC_MIC2,
7642 	ALC271_FIXUP_HP_GATE_MIC_JACK,
7643 	ALC271_FIXUP_HP_GATE_MIC_JACK_E1_572,
7644 	ALC269_FIXUP_ACER_AC700,
7645 	ALC269_FIXUP_LIMIT_INT_MIC_BOOST,
7646 	ALC269VB_FIXUP_ASUS_ZENBOOK,
7647 	ALC269VB_FIXUP_ASUS_ZENBOOK_UX31A,
7648 	ALC269VB_FIXUP_ASUS_MIC_NO_PRESENCE,
7649 	ALC269_FIXUP_LIMIT_INT_MIC_BOOST_MUTE_LED,
7650 	ALC269VB_FIXUP_ORDISSIMO_EVE2,
7651 	ALC283_FIXUP_CHROME_BOOK,
7652 	ALC283_FIXUP_SENSE_COMBO_JACK,
7653 	ALC282_FIXUP_ASUS_TX300,
7654 	ALC283_FIXUP_INT_MIC,
7655 	ALC290_FIXUP_MONO_SPEAKERS,
7656 	ALC290_FIXUP_MONO_SPEAKERS_HSJACK,
7657 	ALC290_FIXUP_SUBWOOFER,
7658 	ALC290_FIXUP_SUBWOOFER_HSJACK,
7659 	ALC269_FIXUP_THINKPAD_ACPI,
7660 	ALC269_FIXUP_LENOVO_XPAD_ACPI,
7661 	ALC269_FIXUP_DMIC_THINKPAD_ACPI,
7662 	ALC269VB_FIXUP_INFINIX_ZERO_BOOK_13,
7663 	ALC269VC_FIXUP_INFINIX_Y4_MAX,
7664 	ALC269VB_FIXUP_CHUWI_COREBOOK_XPRO,
7665 	ALC255_FIXUP_ACER_MIC_NO_PRESENCE,
7666 	ALC255_FIXUP_ASUS_MIC_NO_PRESENCE,
7667 	ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
7668 	ALC255_FIXUP_DELL1_LIMIT_INT_MIC_BOOST,
7669 	ALC255_FIXUP_DELL2_MIC_NO_PRESENCE,
7670 	ALC255_FIXUP_HEADSET_MODE,
7671 	ALC255_FIXUP_HEADSET_MODE_NO_HP_MIC,
7672 	ALC293_FIXUP_DELL1_MIC_NO_PRESENCE,
7673 	ALC292_FIXUP_TPT440_DOCK,
7674 	ALC292_FIXUP_TPT440,
7675 	ALC283_FIXUP_HEADSET_MIC,
7676 	ALC255_FIXUP_MIC_MUTE_LED,
7677 	ALC282_FIXUP_ASPIRE_V5_PINS,
7678 	ALC269VB_FIXUP_ASPIRE_E1_COEF,
7679 	ALC280_FIXUP_HP_GPIO4,
7680 	ALC286_FIXUP_HP_GPIO_LED,
7681 	ALC280_FIXUP_HP_GPIO2_MIC_HOTKEY,
7682 	ALC280_FIXUP_HP_DOCK_PINS,
7683 	ALC269_FIXUP_HP_DOCK_GPIO_MIC1_LED,
7684 	ALC280_FIXUP_HP_9480M,
7685 	ALC245_FIXUP_HP_X360_AMP,
7686 	ALC285_FIXUP_HP_SPECTRE_X360_EB1,
7687 	ALC285_FIXUP_HP_ENVY_X360,
7688 	ALC288_FIXUP_DELL_HEADSET_MODE,
7689 	ALC288_FIXUP_DELL1_MIC_NO_PRESENCE,
7690 	ALC288_FIXUP_DELL_XPS_13,
7691 	ALC288_FIXUP_DISABLE_AAMIX,
7692 	ALC292_FIXUP_DELL_E7X_AAMIX,
7693 	ALC292_FIXUP_DELL_E7X,
7694 	ALC292_FIXUP_DISABLE_AAMIX,
7695 	ALC293_FIXUP_DISABLE_AAMIX_MULTIJACK,
7696 	ALC298_FIXUP_ALIENWARE_MIC_NO_PRESENCE,
7697 	ALC298_FIXUP_DELL1_MIC_NO_PRESENCE,
7698 	ALC298_FIXUP_DELL_AIO_MIC_NO_PRESENCE,
7699 	ALC275_FIXUP_DELL_XPS,
7700 	ALC293_FIXUP_LENOVO_SPK_NOISE,
7701 	ALC233_FIXUP_LENOVO_LINE2_MIC_HOTKEY,
7702 	ALC233_FIXUP_LENOVO_L2MH_LOW_ENLED,
7703 	ALC255_FIXUP_DELL_SPK_NOISE,
7704 	ALC225_FIXUP_DISABLE_MIC_VREF,
7705 	ALC225_FIXUP_DELL1_MIC_NO_PRESENCE,
7706 	ALC295_FIXUP_DISABLE_DAC3,
7707 	ALC285_FIXUP_SPEAKER2_TO_DAC1,
7708 	ALC285_FIXUP_ASUS_SPEAKER2_TO_DAC1,
7709 	ALC285_FIXUP_ASUS_HEADSET_MIC,
7710 	ALC285_FIXUP_ASUS_SPI_REAR_SPEAKERS,
7711 	ALC285_FIXUP_ASUS_I2C_SPEAKER2_TO_DAC1,
7712 	ALC285_FIXUP_ASUS_I2C_HEADSET_MIC,
7713 	ALC280_FIXUP_HP_HEADSET_MIC,
7714 	ALC221_FIXUP_HP_FRONT_MIC,
7715 	ALC292_FIXUP_TPT460,
7716 	ALC298_FIXUP_SPK_VOLUME,
7717 	ALC298_FIXUP_LENOVO_SPK_VOLUME,
7718 	ALC256_FIXUP_DELL_INSPIRON_7559_SUBWOOFER,
7719 	ALC269_FIXUP_ATIV_BOOK_8,
7720 	ALC221_FIXUP_HP_288PRO_MIC_NO_PRESENCE,
7721 	ALC221_FIXUP_HP_MIC_NO_PRESENCE,
7722 	ALC256_FIXUP_ASUS_HEADSET_MODE,
7723 	ALC256_FIXUP_ASUS_MIC,
7724 	ALC256_FIXUP_ASUS_AIO_GPIO2,
7725 	ALC233_FIXUP_ASUS_MIC_NO_PRESENCE,
7726 	ALC233_FIXUP_EAPD_COEF_AND_MIC_NO_PRESENCE,
7727 	ALC233_FIXUP_LENOVO_MULTI_CODECS,
7728 	ALC233_FIXUP_ACER_HEADSET_MIC,
7729 	ALC294_FIXUP_LENOVO_MIC_LOCATION,
7730 	ALC225_FIXUP_DELL_WYSE_MIC_NO_PRESENCE,
7731 	ALC225_FIXUP_S3_POP_NOISE,
7732 	ALC700_FIXUP_INTEL_REFERENCE,
7733 	ALC274_FIXUP_DELL_BIND_DACS,
7734 	ALC274_FIXUP_DELL_AIO_LINEOUT_VERB,
7735 	ALC298_FIXUP_TPT470_DOCK_FIX,
7736 	ALC298_FIXUP_TPT470_DOCK,
7737 	ALC255_FIXUP_DUMMY_LINEOUT_VERB,
7738 	ALC255_FIXUP_DELL_HEADSET_MIC,
7739 	ALC256_FIXUP_HUAWEI_MACH_WX9_PINS,
7740 	ALC298_FIXUP_HUAWEI_MBX_STEREO,
7741 	ALC295_FIXUP_HP_X360,
7742 	ALC221_FIXUP_HP_HEADSET_MIC,
7743 	ALC285_FIXUP_LENOVO_HEADPHONE_NOISE,
7744 	ALC295_FIXUP_HP_AUTO_MUTE,
7745 	ALC286_FIXUP_ACER_AIO_MIC_NO_PRESENCE,
7746 	ALC294_FIXUP_ASUS_MIC,
7747 	ALC294_FIXUP_ASUS_HEADSET_MIC,
7748 	ALC294_FIXUP_ASUS_SPK,
7749 	ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE,
7750 	ALC285_FIXUP_LENOVO_PC_BEEP_IN_NOISE,
7751 	ALC255_FIXUP_ACER_HEADSET_MIC,
7752 	ALC295_FIXUP_CHROME_BOOK,
7753 	ALC225_FIXUP_HEADSET_JACK,
7754 	ALC225_FIXUP_DELL_WYSE_AIO_MIC_NO_PRESENCE,
7755 	ALC225_FIXUP_WYSE_AUTO_MUTE,
7756 	ALC225_FIXUP_WYSE_DISABLE_MIC_VREF,
7757 	ALC286_FIXUP_ACER_AIO_HEADSET_MIC,
7758 	ALC256_FIXUP_ASUS_HEADSET_MIC,
7759 	ALC256_FIXUP_ASUS_MIC_NO_PRESENCE,
7760 	ALC255_FIXUP_PREDATOR_SUBWOOFER,
7761 	ALC299_FIXUP_PREDATOR_SPK,
7762 	ALC256_FIXUP_MEDION_HEADSET_NO_PRESENCE,
7763 	ALC289_FIXUP_DELL_SPK1,
7764 	ALC289_FIXUP_DELL_SPK2,
7765 	ALC289_FIXUP_DUAL_SPK,
7766 	ALC289_FIXUP_RTK_AMP_DUAL_SPK,
7767 	ALC294_FIXUP_SPK2_TO_DAC1,
7768 	ALC294_FIXUP_ASUS_DUAL_SPK,
7769 	ALC285_FIXUP_THINKPAD_X1_GEN7,
7770 	ALC285_FIXUP_THINKPAD_HEADSET_JACK,
7771 	ALC294_FIXUP_ASUS_ALLY,
7772 	ALC294_FIXUP_ASUS_ALLY_PINS,
7773 	ALC294_FIXUP_ASUS_ALLY_VERBS,
7774 	ALC294_FIXUP_ASUS_ALLY_SPEAKER,
7775 	ALC294_FIXUP_ASUS_HPE,
7776 	ALC294_FIXUP_ASUS_COEF_1B,
7777 	ALC294_FIXUP_ASUS_GX502_HP,
7778 	ALC294_FIXUP_ASUS_GX502_PINS,
7779 	ALC294_FIXUP_ASUS_GX502_VERBS,
7780 	ALC294_FIXUP_ASUS_GU502_HP,
7781 	ALC294_FIXUP_ASUS_GU502_PINS,
7782 	ALC294_FIXUP_ASUS_GU502_VERBS,
7783 	ALC294_FIXUP_ASUS_G513_PINS,
7784 	ALC285_FIXUP_ASUS_G533Z_PINS,
7785 	ALC285_FIXUP_HP_GPIO_LED,
7786 	ALC285_FIXUP_HP_MUTE_LED,
7787 	ALC285_FIXUP_HP_SPECTRE_X360_MUTE_LED,
7788 	ALC236_FIXUP_HP_MUTE_LED_COEFBIT2,
7789 	ALC236_FIXUP_HP_GPIO_LED,
7790 	ALC236_FIXUP_HP_MUTE_LED,
7791 	ALC236_FIXUP_HP_MUTE_LED_MICMUTE_VREF,
7792 	ALC236_FIXUP_LENOVO_INV_DMIC,
7793 	ALC298_FIXUP_SAMSUNG_AMP,
7794 	ALC298_FIXUP_SAMSUNG_AMP_V2_2_AMPS,
7795 	ALC298_FIXUP_SAMSUNG_AMP_V2_4_AMPS,
7796 	ALC298_FIXUP_SAMSUNG_HEADPHONE_VERY_QUIET,
7797 	ALC256_FIXUP_SAMSUNG_HEADPHONE_VERY_QUIET,
7798 	ALC295_FIXUP_ASUS_MIC_NO_PRESENCE,
7799 	ALC269VC_FIXUP_ACER_VCOPPERBOX_PINS,
7800 	ALC269VC_FIXUP_ACER_HEADSET_MIC,
7801 	ALC269VC_FIXUP_ACER_MIC_NO_PRESENCE,
7802 	ALC289_FIXUP_ASUS_GA401,
7803 	ALC289_FIXUP_ASUS_GA502,
7804 	ALC256_FIXUP_ACER_MIC_NO_PRESENCE,
7805 	ALC285_FIXUP_HP_GPIO_AMP_INIT,
7806 	ALC269_FIXUP_CZC_B20,
7807 	ALC269_FIXUP_CZC_TMI,
7808 	ALC269_FIXUP_CZC_L101,
7809 	ALC269_FIXUP_LEMOTE_A1802,
7810 	ALC269_FIXUP_LEMOTE_A190X,
7811 	ALC256_FIXUP_INTEL_NUC8_RUGGED,
7812 	ALC233_FIXUP_INTEL_NUC8_DMIC,
7813 	ALC233_FIXUP_INTEL_NUC8_BOOST,
7814 	ALC256_FIXUP_INTEL_NUC10,
7815 	ALC255_FIXUP_XIAOMI_HEADSET_MIC,
7816 	ALC274_FIXUP_HP_MIC,
7817 	ALC274_FIXUP_HP_HEADSET_MIC,
7818 	ALC274_FIXUP_HP_ENVY_GPIO,
7819 	ALC274_FIXUP_ASUS_ZEN_AIO_27,
7820 	ALC256_FIXUP_ASUS_HPE,
7821 	ALC285_FIXUP_THINKPAD_NO_BASS_SPK_HEADSET_JACK,
7822 	ALC287_FIXUP_HP_GPIO_LED,
7823 	ALC256_FIXUP_HP_HEADSET_MIC,
7824 	ALC245_FIXUP_HP_GPIO_LED,
7825 	ALC236_FIXUP_DELL_AIO_HEADSET_MIC,
7826 	ALC282_FIXUP_ACER_DISABLE_LINEOUT,
7827 	ALC255_FIXUP_ACER_LIMIT_INT_MIC_BOOST,
7828 	ALC256_FIXUP_ACER_HEADSET_MIC,
7829 	ALC285_FIXUP_IDEAPAD_S740_COEF,
7830 	ALC285_FIXUP_HP_LIMIT_INT_MIC_BOOST,
7831 	ALC295_FIXUP_ASUS_DACS,
7832 	ALC295_FIXUP_HP_OMEN,
7833 	ALC285_FIXUP_HP_SPECTRE_X360,
7834 	ALC287_FIXUP_IDEAPAD_BASS_SPK_AMP,
7835 	ALC623_FIXUP_LENOVO_THINKSTATION_P340,
7836 	ALC255_FIXUP_ACER_HEADPHONE_AND_MIC,
7837 	ALC236_FIXUP_HP_LIMIT_INT_MIC_BOOST,
7838 	ALC287_FIXUP_LEGION_15IMHG05_SPEAKERS,
7839 	ALC287_FIXUP_LEGION_15IMHG05_AUTOMUTE,
7840 	ALC287_FIXUP_YOGA7_14ITL_SPEAKERS,
7841 	ALC298_FIXUP_LENOVO_C940_DUET7,
7842 	ALC287_FIXUP_13S_GEN2_SPEAKERS,
7843 	ALC256_FIXUP_SET_COEF_DEFAULTS,
7844 	ALC256_FIXUP_SYSTEM76_MIC_NO_PRESENCE,
7845 	ALC233_FIXUP_NO_AUDIO_JACK,
7846 	ALC256_FIXUP_MIC_NO_PRESENCE_AND_RESUME,
7847 	ALC285_FIXUP_LEGION_Y9000X_SPEAKERS,
7848 	ALC285_FIXUP_LEGION_Y9000X_AUTOMUTE,
7849 	ALC287_FIXUP_LEGION_16ACHG6,
7850 	ALC287_FIXUP_CS35L41_I2C_2,
7851 	ALC287_FIXUP_CS35L41_I2C_2_HP_GPIO_LED,
7852 	ALC287_FIXUP_CS35L41_I2C_4,
7853 	ALC245_FIXUP_CS35L41_SPI_2,
7854 	ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED,
7855 	ALC245_FIXUP_CS35L41_SPI_4,
7856 	ALC245_FIXUP_CS35L41_SPI_4_HP_GPIO_LED,
7857 	ALC285_FIXUP_HP_SPEAKERS_MICMUTE_LED,
7858 	ALC295_FIXUP_FRAMEWORK_LAPTOP_MIC_NO_PRESENCE,
7859 	ALC287_FIXUP_LEGION_16ITHG6,
7860 	ALC287_FIXUP_YOGA9_14IAP7_BASS_SPK,
7861 	ALC287_FIXUP_YOGA9_14IAP7_BASS_SPK_PIN,
7862 	ALC287_FIXUP_YOGA9_14IMH9_BASS_SPK_PIN,
7863 	ALC295_FIXUP_DELL_INSPIRON_TOP_SPEAKERS,
7864 	ALC236_FIXUP_DELL_DUAL_CODECS,
7865 	ALC287_FIXUP_CS35L41_I2C_2_THINKPAD_ACPI,
7866 	ALC287_FIXUP_TAS2781_I2C,
7867 	ALC245_FIXUP_TAS2781_SPI_2,
7868 	ALC287_FIXUP_YOGA7_14ARB7_I2C,
7869 	ALC245_FIXUP_HP_MUTE_LED_COEFBIT,
7870 	ALC245_FIXUP_HP_X360_MUTE_LEDS,
7871 	ALC287_FIXUP_THINKPAD_I2S_SPK,
7872 	ALC287_FIXUP_MG_RTKC_CSAMP_CS35L41_I2C_THINKPAD,
7873 	ALC2XX_FIXUP_HEADSET_MIC,
7874 	ALC289_FIXUP_DELL_CS35L41_SPI_2,
7875 	ALC294_FIXUP_CS35L41_I2C_2,
7876 	ALC256_FIXUP_ACER_SFG16_MICMUTE_LED,
7877 	ALC256_FIXUP_HEADPHONE_AMP_VOL,
7878 	ALC245_FIXUP_HP_SPECTRE_X360_EU0XXX,
7879 	ALC245_FIXUP_HP_SPECTRE_X360_16_AA0XXX,
7880 	ALC285_FIXUP_ASUS_GA403U,
7881 	ALC285_FIXUP_ASUS_GA403U_HEADSET_MIC,
7882 	ALC285_FIXUP_ASUS_GA403U_I2C_SPEAKER2_TO_DAC1,
7883 	ALC285_FIXUP_ASUS_GU605_SPI_2_HEADSET_MIC,
7884 	ALC285_FIXUP_ASUS_GU605_SPI_SPEAKER2_TO_DAC1,
7885 	ALC287_FIXUP_LENOVO_THKPAD_WH_ALC1318,
7886 	ALC256_FIXUP_CHROME_BOOK,
7887 	ALC245_FIXUP_CLEVO_NOISY_MIC,
7888 	ALC269_FIXUP_VAIO_VJFH52_MIC_NO_PRESENCE,
7889 	ALC233_FIXUP_MEDION_MTL_SPK,
7890 	ALC294_FIXUP_BASS_SPEAKER_15,
7891 	ALC283_FIXUP_DELL_HP_RESUME,
7892 };
7893 
7894 /* A special fixup for Lenovo C940 and Yoga Duet 7;
7895  * both have the very same PCI SSID, and we need to apply different fixups
7896  * depending on the codec ID
7897  */
alc298_fixup_lenovo_c940_duet7(struct hda_codec * codec,const struct hda_fixup * fix,int action)7898 static void alc298_fixup_lenovo_c940_duet7(struct hda_codec *codec,
7899 					   const struct hda_fixup *fix,
7900 					   int action)
7901 {
7902 	int id;
7903 
7904 	if (codec->core.vendor_id == 0x10ec0298)
7905 		id = ALC298_FIXUP_LENOVO_SPK_VOLUME; /* C940 */
7906 	else
7907 		id = ALC287_FIXUP_YOGA7_14ITL_SPEAKERS; /* Duet 7 */
7908 	__snd_hda_apply_fixup(codec, id, action, 0);
7909 }
7910 
7911 static const struct hda_fixup alc269_fixups[] = {
7912 	[ALC269_FIXUP_GPIO2] = {
7913 		.type = HDA_FIXUP_FUNC,
7914 		.v.func = alc_fixup_gpio2,
7915 	},
7916 	[ALC269_FIXUP_SONY_VAIO] = {
7917 		.type = HDA_FIXUP_PINCTLS,
7918 		.v.pins = (const struct hda_pintbl[]) {
7919 			{0x19, PIN_VREFGRD},
7920 			{}
7921 		}
7922 	},
7923 	[ALC275_FIXUP_SONY_VAIO_GPIO2] = {
7924 		.type = HDA_FIXUP_FUNC,
7925 		.v.func = alc275_fixup_gpio4_off,
7926 		.chained = true,
7927 		.chain_id = ALC269_FIXUP_SONY_VAIO
7928 	},
7929 	[ALC269_FIXUP_DELL_M101Z] = {
7930 		.type = HDA_FIXUP_VERBS,
7931 		.v.verbs = (const struct hda_verb[]) {
7932 			/* Enables internal speaker */
7933 			{0x20, AC_VERB_SET_COEF_INDEX, 13},
7934 			{0x20, AC_VERB_SET_PROC_COEF, 0x4040},
7935 			{}
7936 		}
7937 	},
7938 	[ALC269_FIXUP_SKU_IGNORE] = {
7939 		.type = HDA_FIXUP_FUNC,
7940 		.v.func = alc_fixup_sku_ignore,
7941 	},
7942 	[ALC269_FIXUP_ASUS_G73JW] = {
7943 		.type = HDA_FIXUP_PINS,
7944 		.v.pins = (const struct hda_pintbl[]) {
7945 			{ 0x17, 0x99130111 }, /* subwoofer */
7946 			{ }
7947 		}
7948 	},
7949 	[ALC269_FIXUP_ASUS_N7601ZM_PINS] = {
7950 		.type = HDA_FIXUP_PINS,
7951 		.v.pins = (const struct hda_pintbl[]) {
7952 			{ 0x19, 0x03A11050 },
7953 			{ 0x1a, 0x03A11C30 },
7954 			{ 0x21, 0x03211420 },
7955 			{ }
7956 		}
7957 	},
7958 	[ALC269_FIXUP_ASUS_N7601ZM] = {
7959 		.type = HDA_FIXUP_VERBS,
7960 		.v.verbs = (const struct hda_verb[]) {
7961 			{0x20, AC_VERB_SET_COEF_INDEX, 0x62},
7962 			{0x20, AC_VERB_SET_PROC_COEF, 0xa007},
7963 			{0x20, AC_VERB_SET_COEF_INDEX, 0x10},
7964 			{0x20, AC_VERB_SET_PROC_COEF, 0x8420},
7965 			{0x20, AC_VERB_SET_COEF_INDEX, 0x0f},
7966 			{0x20, AC_VERB_SET_PROC_COEF, 0x7774},
7967 			{ }
7968 		},
7969 		.chained = true,
7970 		.chain_id = ALC269_FIXUP_ASUS_N7601ZM_PINS,
7971 	},
7972 	[ALC269_FIXUP_LENOVO_EAPD] = {
7973 		.type = HDA_FIXUP_VERBS,
7974 		.v.verbs = (const struct hda_verb[]) {
7975 			{0x14, AC_VERB_SET_EAPD_BTLENABLE, 0},
7976 			{}
7977 		}
7978 	},
7979 	[ALC275_FIXUP_SONY_HWEQ] = {
7980 		.type = HDA_FIXUP_FUNC,
7981 		.v.func = alc269_fixup_hweq,
7982 		.chained = true,
7983 		.chain_id = ALC275_FIXUP_SONY_VAIO_GPIO2
7984 	},
7985 	[ALC275_FIXUP_SONY_DISABLE_AAMIX] = {
7986 		.type = HDA_FIXUP_FUNC,
7987 		.v.func = alc_fixup_disable_aamix,
7988 		.chained = true,
7989 		.chain_id = ALC269_FIXUP_SONY_VAIO
7990 	},
7991 	[ALC271_FIXUP_DMIC] = {
7992 		.type = HDA_FIXUP_FUNC,
7993 		.v.func = alc271_fixup_dmic,
7994 	},
7995 	[ALC269_FIXUP_PCM_44K] = {
7996 		.type = HDA_FIXUP_FUNC,
7997 		.v.func = alc269_fixup_pcm_44k,
7998 		.chained = true,
7999 		.chain_id = ALC269_FIXUP_QUANTA_MUTE
8000 	},
8001 	[ALC269_FIXUP_STEREO_DMIC] = {
8002 		.type = HDA_FIXUP_FUNC,
8003 		.v.func = alc269_fixup_stereo_dmic,
8004 	},
8005 	[ALC269_FIXUP_HEADSET_MIC] = {
8006 		.type = HDA_FIXUP_FUNC,
8007 		.v.func = alc269_fixup_headset_mic,
8008 	},
8009 	[ALC269_FIXUP_QUANTA_MUTE] = {
8010 		.type = HDA_FIXUP_FUNC,
8011 		.v.func = alc269_fixup_quanta_mute,
8012 	},
8013 	[ALC269_FIXUP_LIFEBOOK] = {
8014 		.type = HDA_FIXUP_PINS,
8015 		.v.pins = (const struct hda_pintbl[]) {
8016 			{ 0x1a, 0x2101103f }, /* dock line-out */
8017 			{ 0x1b, 0x23a11040 }, /* dock mic-in */
8018 			{ }
8019 		},
8020 		.chained = true,
8021 		.chain_id = ALC269_FIXUP_QUANTA_MUTE
8022 	},
8023 	[ALC269_FIXUP_LIFEBOOK_EXTMIC] = {
8024 		.type = HDA_FIXUP_PINS,
8025 		.v.pins = (const struct hda_pintbl[]) {
8026 			{ 0x19, 0x01a1903c }, /* headset mic, with jack detect */
8027 			{ }
8028 		},
8029 	},
8030 	[ALC269_FIXUP_LIFEBOOK_HP_PIN] = {
8031 		.type = HDA_FIXUP_PINS,
8032 		.v.pins = (const struct hda_pintbl[]) {
8033 			{ 0x21, 0x0221102f }, /* HP out */
8034 			{ }
8035 		},
8036 	},
8037 	[ALC269_FIXUP_LIFEBOOK_NO_HP_TO_LINEOUT] = {
8038 		.type = HDA_FIXUP_FUNC,
8039 		.v.func = alc269_fixup_pincfg_no_hp_to_lineout,
8040 	},
8041 	[ALC255_FIXUP_LIFEBOOK_U7x7_HEADSET_MIC] = {
8042 		.type = HDA_FIXUP_FUNC,
8043 		.v.func = alc269_fixup_pincfg_U7x7_headset_mic,
8044 	},
8045 	[ALC269VB_FIXUP_INFINIX_ZERO_BOOK_13] = {
8046 		.type = HDA_FIXUP_PINS,
8047 		.v.pins = (const struct hda_pintbl[]) {
8048 			{ 0x14, 0x90170151 }, /* use as internal speaker (LFE) */
8049 			{ 0x1b, 0x90170152 }, /* use as internal speaker (back) */
8050 			{ }
8051 		},
8052 		.chained = true,
8053 		.chain_id = ALC269_FIXUP_LIMIT_INT_MIC_BOOST
8054 	},
8055 	[ALC269VC_FIXUP_INFINIX_Y4_MAX] = {
8056 		.type = HDA_FIXUP_PINS,
8057 		.v.pins = (const struct hda_pintbl[]) {
8058 			{ 0x1b, 0x90170150 }, /* use as internal speaker */
8059 			{ }
8060 		},
8061 		.chained = true,
8062 		.chain_id = ALC269_FIXUP_LIMIT_INT_MIC_BOOST
8063 	},
8064 	[ALC269VB_FIXUP_CHUWI_COREBOOK_XPRO] = {
8065 		.type = HDA_FIXUP_PINS,
8066 		.v.pins = (const struct hda_pintbl[]) {
8067 			{ 0x18, 0x03a19020 }, /* headset mic */
8068 			{ 0x1b, 0x90170150 }, /* speaker */
8069 			{ }
8070 		},
8071 	},
8072 	[ALC269_FIXUP_AMIC] = {
8073 		.type = HDA_FIXUP_PINS,
8074 		.v.pins = (const struct hda_pintbl[]) {
8075 			{ 0x14, 0x99130110 }, /* speaker */
8076 			{ 0x15, 0x0121401f }, /* HP out */
8077 			{ 0x18, 0x01a19c20 }, /* mic */
8078 			{ 0x19, 0x99a3092f }, /* int-mic */
8079 			{ }
8080 		},
8081 	},
8082 	[ALC269_FIXUP_DMIC] = {
8083 		.type = HDA_FIXUP_PINS,
8084 		.v.pins = (const struct hda_pintbl[]) {
8085 			{ 0x12, 0x99a3092f }, /* int-mic */
8086 			{ 0x14, 0x99130110 }, /* speaker */
8087 			{ 0x15, 0x0121401f }, /* HP out */
8088 			{ 0x18, 0x01a19c20 }, /* mic */
8089 			{ }
8090 		},
8091 	},
8092 	[ALC269VB_FIXUP_AMIC] = {
8093 		.type = HDA_FIXUP_PINS,
8094 		.v.pins = (const struct hda_pintbl[]) {
8095 			{ 0x14, 0x99130110 }, /* speaker */
8096 			{ 0x18, 0x01a19c20 }, /* mic */
8097 			{ 0x19, 0x99a3092f }, /* int-mic */
8098 			{ 0x21, 0x0121401f }, /* HP out */
8099 			{ }
8100 		},
8101 	},
8102 	[ALC269VB_FIXUP_DMIC] = {
8103 		.type = HDA_FIXUP_PINS,
8104 		.v.pins = (const struct hda_pintbl[]) {
8105 			{ 0x12, 0x99a3092f }, /* int-mic */
8106 			{ 0x14, 0x99130110 }, /* speaker */
8107 			{ 0x18, 0x01a19c20 }, /* mic */
8108 			{ 0x21, 0x0121401f }, /* HP out */
8109 			{ }
8110 		},
8111 	},
8112 	[ALC269_FIXUP_HP_MUTE_LED] = {
8113 		.type = HDA_FIXUP_FUNC,
8114 		.v.func = alc269_fixup_hp_mute_led,
8115 	},
8116 	[ALC269_FIXUP_HP_MUTE_LED_MIC1] = {
8117 		.type = HDA_FIXUP_FUNC,
8118 		.v.func = alc269_fixup_hp_mute_led_mic1,
8119 	},
8120 	[ALC269_FIXUP_HP_MUTE_LED_MIC2] = {
8121 		.type = HDA_FIXUP_FUNC,
8122 		.v.func = alc269_fixup_hp_mute_led_mic2,
8123 	},
8124 	[ALC269_FIXUP_HP_MUTE_LED_MIC3] = {
8125 		.type = HDA_FIXUP_FUNC,
8126 		.v.func = alc269_fixup_hp_mute_led_mic3,
8127 		.chained = true,
8128 		.chain_id = ALC295_FIXUP_HP_AUTO_MUTE
8129 	},
8130 	[ALC269_FIXUP_HP_GPIO_LED] = {
8131 		.type = HDA_FIXUP_FUNC,
8132 		.v.func = alc269_fixup_hp_gpio_led,
8133 	},
8134 	[ALC269_FIXUP_HP_GPIO_MIC1_LED] = {
8135 		.type = HDA_FIXUP_FUNC,
8136 		.v.func = alc269_fixup_hp_gpio_mic1_led,
8137 	},
8138 	[ALC269_FIXUP_HP_LINE1_MIC1_LED] = {
8139 		.type = HDA_FIXUP_FUNC,
8140 		.v.func = alc269_fixup_hp_line1_mic1_led,
8141 	},
8142 	[ALC269_FIXUP_INV_DMIC] = {
8143 		.type = HDA_FIXUP_FUNC,
8144 		.v.func = alc_fixup_inv_dmic,
8145 	},
8146 	[ALC269_FIXUP_NO_SHUTUP] = {
8147 		.type = HDA_FIXUP_FUNC,
8148 		.v.func = alc_fixup_no_shutup,
8149 	},
8150 	[ALC269_FIXUP_LENOVO_DOCK] = {
8151 		.type = HDA_FIXUP_PINS,
8152 		.v.pins = (const struct hda_pintbl[]) {
8153 			{ 0x19, 0x23a11040 }, /* dock mic */
8154 			{ 0x1b, 0x2121103f }, /* dock headphone */
8155 			{ }
8156 		},
8157 		.chained = true,
8158 		.chain_id = ALC269_FIXUP_PINCFG_NO_HP_TO_LINEOUT
8159 	},
8160 	[ALC269_FIXUP_LENOVO_DOCK_LIMIT_BOOST] = {
8161 		.type = HDA_FIXUP_FUNC,
8162 		.v.func = alc269_fixup_limit_int_mic_boost,
8163 		.chained = true,
8164 		.chain_id = ALC269_FIXUP_LENOVO_DOCK,
8165 	},
8166 	[ALC269_FIXUP_PINCFG_NO_HP_TO_LINEOUT] = {
8167 		.type = HDA_FIXUP_FUNC,
8168 		.v.func = alc269_fixup_pincfg_no_hp_to_lineout,
8169 		.chained = true,
8170 		.chain_id = ALC269_FIXUP_THINKPAD_ACPI,
8171 	},
8172 	[ALC269_FIXUP_DELL1_MIC_NO_PRESENCE] = {
8173 		.type = HDA_FIXUP_PINS,
8174 		.v.pins = (const struct hda_pintbl[]) {
8175 			{ 0x19, 0x01a1913c }, /* use as headset mic, without its own jack detect */
8176 			{ 0x1a, 0x01a1913d }, /* use as headphone mic, without its own jack detect */
8177 			{ }
8178 		},
8179 		.chained = true,
8180 		.chain_id = ALC269_FIXUP_HEADSET_MODE
8181 	},
8182 	[ALC269_FIXUP_DELL1_LIMIT_INT_MIC_BOOST] = {
8183 		.type = HDA_FIXUP_FUNC,
8184 		.v.func = alc269_fixup_limit_int_mic_boost,
8185 		.chained = true,
8186 		.chain_id = ALC269_FIXUP_DELL1_MIC_NO_PRESENCE
8187 	},
8188 	[ALC269_FIXUP_DELL2_MIC_NO_PRESENCE] = {
8189 		.type = HDA_FIXUP_PINS,
8190 		.v.pins = (const struct hda_pintbl[]) {
8191 			{ 0x16, 0x21014020 }, /* dock line out */
8192 			{ 0x19, 0x21a19030 }, /* dock mic */
8193 			{ 0x1a, 0x01a1913c }, /* use as headset mic, without its own jack detect */
8194 			{ }
8195 		},
8196 		.chained = true,
8197 		.chain_id = ALC269_FIXUP_HEADSET_MODE_NO_HP_MIC
8198 	},
8199 	[ALC269_FIXUP_DELL3_MIC_NO_PRESENCE] = {
8200 		.type = HDA_FIXUP_PINS,
8201 		.v.pins = (const struct hda_pintbl[]) {
8202 			{ 0x1a, 0x01a1913c }, /* use as headset mic, without its own jack detect */
8203 			{ }
8204 		},
8205 		.chained = true,
8206 		.chain_id = ALC269_FIXUP_HEADSET_MODE_NO_HP_MIC
8207 	},
8208 	[ALC269_FIXUP_DELL4_MIC_NO_PRESENCE] = {
8209 		.type = HDA_FIXUP_PINS,
8210 		.v.pins = (const struct hda_pintbl[]) {
8211 			{ 0x19, 0x01a1913c }, /* use as headset mic, without its own jack detect */
8212 			{ 0x1b, 0x01a1913d }, /* use as headphone mic, without its own jack detect */
8213 			{ }
8214 		},
8215 		.chained = true,
8216 		.chain_id = ALC269_FIXUP_HEADSET_MODE
8217 	},
8218 	[ALC269_FIXUP_HEADSET_MODE] = {
8219 		.type = HDA_FIXUP_FUNC,
8220 		.v.func = alc_fixup_headset_mode,
8221 		.chained = true,
8222 		.chain_id = ALC255_FIXUP_MIC_MUTE_LED
8223 	},
8224 	[ALC269_FIXUP_HEADSET_MODE_NO_HP_MIC] = {
8225 		.type = HDA_FIXUP_FUNC,
8226 		.v.func = alc_fixup_headset_mode_no_hp_mic,
8227 	},
8228 	[ALC269_FIXUP_ASPIRE_HEADSET_MIC] = {
8229 		.type = HDA_FIXUP_PINS,
8230 		.v.pins = (const struct hda_pintbl[]) {
8231 			{ 0x19, 0x01a1913c }, /* headset mic w/o jack detect */
8232 			{ }
8233 		},
8234 		.chained = true,
8235 		.chain_id = ALC269_FIXUP_HEADSET_MODE,
8236 	},
8237 	[ALC286_FIXUP_SONY_MIC_NO_PRESENCE] = {
8238 		.type = HDA_FIXUP_PINS,
8239 		.v.pins = (const struct hda_pintbl[]) {
8240 			{ 0x18, 0x01a1913c }, /* use as headset mic, without its own jack detect */
8241 			{ }
8242 		},
8243 		.chained = true,
8244 		.chain_id = ALC269_FIXUP_HEADSET_MIC
8245 	},
8246 	[ALC256_FIXUP_HUAWEI_MACH_WX9_PINS] = {
8247 		.type = HDA_FIXUP_PINS,
8248 		.v.pins = (const struct hda_pintbl[]) {
8249 			{0x12, 0x90a60130},
8250 			{0x13, 0x40000000},
8251 			{0x14, 0x90170110},
8252 			{0x18, 0x411111f0},
8253 			{0x19, 0x04a11040},
8254 			{0x1a, 0x411111f0},
8255 			{0x1b, 0x90170112},
8256 			{0x1d, 0x40759a05},
8257 			{0x1e, 0x411111f0},
8258 			{0x21, 0x04211020},
8259 			{ }
8260 		},
8261 		.chained = true,
8262 		.chain_id = ALC255_FIXUP_MIC_MUTE_LED
8263 	},
8264 	[ALC298_FIXUP_HUAWEI_MBX_STEREO] = {
8265 		.type = HDA_FIXUP_FUNC,
8266 		.v.func = alc298_fixup_huawei_mbx_stereo,
8267 		.chained = true,
8268 		.chain_id = ALC255_FIXUP_MIC_MUTE_LED
8269 	},
8270 	[ALC269_FIXUP_ASUS_X101_FUNC] = {
8271 		.type = HDA_FIXUP_FUNC,
8272 		.v.func = alc269_fixup_x101_headset_mic,
8273 	},
8274 	[ALC269_FIXUP_ASUS_X101_VERB] = {
8275 		.type = HDA_FIXUP_VERBS,
8276 		.v.verbs = (const struct hda_verb[]) {
8277 			{0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
8278 			{0x20, AC_VERB_SET_COEF_INDEX, 0x08},
8279 			{0x20, AC_VERB_SET_PROC_COEF,  0x0310},
8280 			{ }
8281 		},
8282 		.chained = true,
8283 		.chain_id = ALC269_FIXUP_ASUS_X101_FUNC
8284 	},
8285 	[ALC269_FIXUP_ASUS_X101] = {
8286 		.type = HDA_FIXUP_PINS,
8287 		.v.pins = (const struct hda_pintbl[]) {
8288 			{ 0x18, 0x04a1182c }, /* Headset mic */
8289 			{ }
8290 		},
8291 		.chained = true,
8292 		.chain_id = ALC269_FIXUP_ASUS_X101_VERB
8293 	},
8294 	[ALC271_FIXUP_AMIC_MIC2] = {
8295 		.type = HDA_FIXUP_PINS,
8296 		.v.pins = (const struct hda_pintbl[]) {
8297 			{ 0x14, 0x99130110 }, /* speaker */
8298 			{ 0x19, 0x01a19c20 }, /* mic */
8299 			{ 0x1b, 0x99a7012f }, /* int-mic */
8300 			{ 0x21, 0x0121401f }, /* HP out */
8301 			{ }
8302 		},
8303 	},
8304 	[ALC271_FIXUP_HP_GATE_MIC_JACK] = {
8305 		.type = HDA_FIXUP_FUNC,
8306 		.v.func = alc271_hp_gate_mic_jack,
8307 		.chained = true,
8308 		.chain_id = ALC271_FIXUP_AMIC_MIC2,
8309 	},
8310 	[ALC271_FIXUP_HP_GATE_MIC_JACK_E1_572] = {
8311 		.type = HDA_FIXUP_FUNC,
8312 		.v.func = alc269_fixup_limit_int_mic_boost,
8313 		.chained = true,
8314 		.chain_id = ALC271_FIXUP_HP_GATE_MIC_JACK,
8315 	},
8316 	[ALC269_FIXUP_ACER_AC700] = {
8317 		.type = HDA_FIXUP_PINS,
8318 		.v.pins = (const struct hda_pintbl[]) {
8319 			{ 0x12, 0x99a3092f }, /* int-mic */
8320 			{ 0x14, 0x99130110 }, /* speaker */
8321 			{ 0x18, 0x03a11c20 }, /* mic */
8322 			{ 0x1e, 0x0346101e }, /* SPDIF1 */
8323 			{ 0x21, 0x0321101f }, /* HP out */
8324 			{ }
8325 		},
8326 		.chained = true,
8327 		.chain_id = ALC271_FIXUP_DMIC,
8328 	},
8329 	[ALC269_FIXUP_LIMIT_INT_MIC_BOOST] = {
8330 		.type = HDA_FIXUP_FUNC,
8331 		.v.func = alc269_fixup_limit_int_mic_boost,
8332 		.chained = true,
8333 		.chain_id = ALC269_FIXUP_THINKPAD_ACPI,
8334 	},
8335 	[ALC269VB_FIXUP_ASUS_ZENBOOK] = {
8336 		.type = HDA_FIXUP_FUNC,
8337 		.v.func = alc269_fixup_limit_int_mic_boost,
8338 		.chained = true,
8339 		.chain_id = ALC269VB_FIXUP_DMIC,
8340 	},
8341 	[ALC269VB_FIXUP_ASUS_ZENBOOK_UX31A] = {
8342 		.type = HDA_FIXUP_VERBS,
8343 		.v.verbs = (const struct hda_verb[]) {
8344 			/* class-D output amp +5dB */
8345 			{ 0x20, AC_VERB_SET_COEF_INDEX, 0x12 },
8346 			{ 0x20, AC_VERB_SET_PROC_COEF, 0x2800 },
8347 			{}
8348 		},
8349 		.chained = true,
8350 		.chain_id = ALC269VB_FIXUP_ASUS_ZENBOOK,
8351 	},
8352 	[ALC269VB_FIXUP_ASUS_MIC_NO_PRESENCE] = {
8353 		.type = HDA_FIXUP_PINS,
8354 		.v.pins = (const struct hda_pintbl[]) {
8355 			{ 0x18, 0x01a110f0 },  /* use as headset mic */
8356 			{ }
8357 		},
8358 		.chained = true,
8359 		.chain_id = ALC269_FIXUP_HEADSET_MIC
8360 	},
8361 	[ALC269_FIXUP_LIMIT_INT_MIC_BOOST_MUTE_LED] = {
8362 		.type = HDA_FIXUP_FUNC,
8363 		.v.func = alc269_fixup_limit_int_mic_boost,
8364 		.chained = true,
8365 		.chain_id = ALC269_FIXUP_HP_MUTE_LED_MIC1,
8366 	},
8367 	[ALC269VB_FIXUP_ORDISSIMO_EVE2] = {
8368 		.type = HDA_FIXUP_PINS,
8369 		.v.pins = (const struct hda_pintbl[]) {
8370 			{ 0x12, 0x99a3092f }, /* int-mic */
8371 			{ 0x18, 0x03a11d20 }, /* mic */
8372 			{ 0x19, 0x411111f0 }, /* Unused bogus pin */
8373 			{ }
8374 		},
8375 	},
8376 	[ALC283_FIXUP_CHROME_BOOK] = {
8377 		.type = HDA_FIXUP_FUNC,
8378 		.v.func = alc283_fixup_chromebook,
8379 	},
8380 	[ALC283_FIXUP_SENSE_COMBO_JACK] = {
8381 		.type = HDA_FIXUP_FUNC,
8382 		.v.func = alc283_fixup_sense_combo_jack,
8383 		.chained = true,
8384 		.chain_id = ALC283_FIXUP_CHROME_BOOK,
8385 	},
8386 	[ALC282_FIXUP_ASUS_TX300] = {
8387 		.type = HDA_FIXUP_FUNC,
8388 		.v.func = alc282_fixup_asus_tx300,
8389 	},
8390 	[ALC283_FIXUP_INT_MIC] = {
8391 		.type = HDA_FIXUP_VERBS,
8392 		.v.verbs = (const struct hda_verb[]) {
8393 			{0x20, AC_VERB_SET_COEF_INDEX, 0x1a},
8394 			{0x20, AC_VERB_SET_PROC_COEF, 0x0011},
8395 			{ }
8396 		},
8397 		.chained = true,
8398 		.chain_id = ALC269_FIXUP_LIMIT_INT_MIC_BOOST
8399 	},
8400 	[ALC290_FIXUP_SUBWOOFER_HSJACK] = {
8401 		.type = HDA_FIXUP_PINS,
8402 		.v.pins = (const struct hda_pintbl[]) {
8403 			{ 0x17, 0x90170112 }, /* subwoofer */
8404 			{ }
8405 		},
8406 		.chained = true,
8407 		.chain_id = ALC290_FIXUP_MONO_SPEAKERS_HSJACK,
8408 	},
8409 	[ALC290_FIXUP_SUBWOOFER] = {
8410 		.type = HDA_FIXUP_PINS,
8411 		.v.pins = (const struct hda_pintbl[]) {
8412 			{ 0x17, 0x90170112 }, /* subwoofer */
8413 			{ }
8414 		},
8415 		.chained = true,
8416 		.chain_id = ALC290_FIXUP_MONO_SPEAKERS,
8417 	},
8418 	[ALC290_FIXUP_MONO_SPEAKERS] = {
8419 		.type = HDA_FIXUP_FUNC,
8420 		.v.func = alc290_fixup_mono_speakers,
8421 	},
8422 	[ALC290_FIXUP_MONO_SPEAKERS_HSJACK] = {
8423 		.type = HDA_FIXUP_FUNC,
8424 		.v.func = alc290_fixup_mono_speakers,
8425 		.chained = true,
8426 		.chain_id = ALC269_FIXUP_DELL3_MIC_NO_PRESENCE,
8427 	},
8428 	[ALC269_FIXUP_THINKPAD_ACPI] = {
8429 		.type = HDA_FIXUP_FUNC,
8430 		.v.func = alc_fixup_thinkpad_acpi,
8431 		.chained = true,
8432 		.chain_id = ALC269_FIXUP_SKU_IGNORE,
8433 	},
8434 	[ALC269_FIXUP_LENOVO_XPAD_ACPI] = {
8435 		.type = HDA_FIXUP_FUNC,
8436 		.v.func = alc_fixup_ideapad_acpi,
8437 		.chained = true,
8438 		.chain_id = ALC269_FIXUP_THINKPAD_ACPI,
8439 	},
8440 	[ALC269_FIXUP_DMIC_THINKPAD_ACPI] = {
8441 		.type = HDA_FIXUP_FUNC,
8442 		.v.func = alc_fixup_inv_dmic,
8443 		.chained = true,
8444 		.chain_id = ALC269_FIXUP_THINKPAD_ACPI,
8445 	},
8446 	[ALC255_FIXUP_ACER_MIC_NO_PRESENCE] = {
8447 		.type = HDA_FIXUP_PINS,
8448 		.v.pins = (const struct hda_pintbl[]) {
8449 			{ 0x19, 0x01a1913c }, /* use as headset mic, without its own jack detect */
8450 			{ }
8451 		},
8452 		.chained = true,
8453 		.chain_id = ALC255_FIXUP_HEADSET_MODE
8454 	},
8455 	[ALC255_FIXUP_ASUS_MIC_NO_PRESENCE] = {
8456 		.type = HDA_FIXUP_PINS,
8457 		.v.pins = (const struct hda_pintbl[]) {
8458 			{ 0x19, 0x01a1913c }, /* use as headset mic, without its own jack detect */
8459 			{ }
8460 		},
8461 		.chained = true,
8462 		.chain_id = ALC255_FIXUP_HEADSET_MODE
8463 	},
8464 	[ALC255_FIXUP_DELL1_MIC_NO_PRESENCE] = {
8465 		.type = HDA_FIXUP_PINS,
8466 		.v.pins = (const struct hda_pintbl[]) {
8467 			{ 0x19, 0x01a1913c }, /* use as headset mic, without its own jack detect */
8468 			{ 0x1a, 0x01a1913d }, /* use as headphone mic, without its own jack detect */
8469 			{ }
8470 		},
8471 		.chained = true,
8472 		.chain_id = ALC255_FIXUP_HEADSET_MODE
8473 	},
8474 	[ALC255_FIXUP_DELL1_LIMIT_INT_MIC_BOOST] = {
8475 		.type = HDA_FIXUP_FUNC,
8476 		.v.func = alc269_fixup_limit_int_mic_boost,
8477 		.chained = true,
8478 		.chain_id = ALC255_FIXUP_DELL1_MIC_NO_PRESENCE
8479 	},
8480 	[ALC255_FIXUP_DELL2_MIC_NO_PRESENCE] = {
8481 		.type = HDA_FIXUP_PINS,
8482 		.v.pins = (const struct hda_pintbl[]) {
8483 			{ 0x19, 0x01a1913c }, /* use as headset mic, without its own jack detect */
8484 			{ }
8485 		},
8486 		.chained = true,
8487 		.chain_id = ALC255_FIXUP_HEADSET_MODE_NO_HP_MIC
8488 	},
8489 	[ALC255_FIXUP_HEADSET_MODE] = {
8490 		.type = HDA_FIXUP_FUNC,
8491 		.v.func = alc_fixup_headset_mode_alc255,
8492 		.chained = true,
8493 		.chain_id = ALC255_FIXUP_MIC_MUTE_LED
8494 	},
8495 	[ALC255_FIXUP_HEADSET_MODE_NO_HP_MIC] = {
8496 		.type = HDA_FIXUP_FUNC,
8497 		.v.func = alc_fixup_headset_mode_alc255_no_hp_mic,
8498 	},
8499 	[ALC293_FIXUP_DELL1_MIC_NO_PRESENCE] = {
8500 		.type = HDA_FIXUP_PINS,
8501 		.v.pins = (const struct hda_pintbl[]) {
8502 			{ 0x18, 0x01a1913d }, /* use as headphone mic, without its own jack detect */
8503 			{ 0x1a, 0x01a1913c }, /* use as headset mic, without its own jack detect */
8504 			{ }
8505 		},
8506 		.chained = true,
8507 		.chain_id = ALC269_FIXUP_HEADSET_MODE
8508 	},
8509 	[ALC292_FIXUP_TPT440_DOCK] = {
8510 		.type = HDA_FIXUP_FUNC,
8511 		.v.func = alc_fixup_tpt440_dock,
8512 		.chained = true,
8513 		.chain_id = ALC269_FIXUP_LIMIT_INT_MIC_BOOST
8514 	},
8515 	[ALC292_FIXUP_TPT440] = {
8516 		.type = HDA_FIXUP_FUNC,
8517 		.v.func = alc_fixup_disable_aamix,
8518 		.chained = true,
8519 		.chain_id = ALC292_FIXUP_TPT440_DOCK,
8520 	},
8521 	[ALC283_FIXUP_HEADSET_MIC] = {
8522 		.type = HDA_FIXUP_PINS,
8523 		.v.pins = (const struct hda_pintbl[]) {
8524 			{ 0x19, 0x04a110f0 },
8525 			{ },
8526 		},
8527 	},
8528 	[ALC255_FIXUP_MIC_MUTE_LED] = {
8529 		.type = HDA_FIXUP_FUNC,
8530 		.v.func = alc_fixup_micmute_led,
8531 	},
8532 	[ALC282_FIXUP_ASPIRE_V5_PINS] = {
8533 		.type = HDA_FIXUP_PINS,
8534 		.v.pins = (const struct hda_pintbl[]) {
8535 			{ 0x12, 0x90a60130 },
8536 			{ 0x14, 0x90170110 },
8537 			{ 0x17, 0x40000008 },
8538 			{ 0x18, 0x411111f0 },
8539 			{ 0x19, 0x01a1913c },
8540 			{ 0x1a, 0x411111f0 },
8541 			{ 0x1b, 0x411111f0 },
8542 			{ 0x1d, 0x40f89b2d },
8543 			{ 0x1e, 0x411111f0 },
8544 			{ 0x21, 0x0321101f },
8545 			{ },
8546 		},
8547 	},
8548 	[ALC269VB_FIXUP_ASPIRE_E1_COEF] = {
8549 		.type = HDA_FIXUP_FUNC,
8550 		.v.func = alc269vb_fixup_aspire_e1_coef,
8551 	},
8552 	[ALC280_FIXUP_HP_GPIO4] = {
8553 		.type = HDA_FIXUP_FUNC,
8554 		.v.func = alc280_fixup_hp_gpio4,
8555 	},
8556 	[ALC286_FIXUP_HP_GPIO_LED] = {
8557 		.type = HDA_FIXUP_FUNC,
8558 		.v.func = alc286_fixup_hp_gpio_led,
8559 	},
8560 	[ALC280_FIXUP_HP_GPIO2_MIC_HOTKEY] = {
8561 		.type = HDA_FIXUP_FUNC,
8562 		.v.func = alc280_fixup_hp_gpio2_mic_hotkey,
8563 	},
8564 	[ALC280_FIXUP_HP_DOCK_PINS] = {
8565 		.type = HDA_FIXUP_PINS,
8566 		.v.pins = (const struct hda_pintbl[]) {
8567 			{ 0x1b, 0x21011020 }, /* line-out */
8568 			{ 0x1a, 0x01a1903c }, /* headset mic */
8569 			{ 0x18, 0x2181103f }, /* line-in */
8570 			{ },
8571 		},
8572 		.chained = true,
8573 		.chain_id = ALC280_FIXUP_HP_GPIO4
8574 	},
8575 	[ALC269_FIXUP_HP_DOCK_GPIO_MIC1_LED] = {
8576 		.type = HDA_FIXUP_PINS,
8577 		.v.pins = (const struct hda_pintbl[]) {
8578 			{ 0x1b, 0x21011020 }, /* line-out */
8579 			{ 0x18, 0x2181103f }, /* line-in */
8580 			{ },
8581 		},
8582 		.chained = true,
8583 		.chain_id = ALC269_FIXUP_HP_GPIO_MIC1_LED
8584 	},
8585 	[ALC280_FIXUP_HP_9480M] = {
8586 		.type = HDA_FIXUP_FUNC,
8587 		.v.func = alc280_fixup_hp_9480m,
8588 	},
8589 	[ALC245_FIXUP_HP_X360_AMP] = {
8590 		.type = HDA_FIXUP_FUNC,
8591 		.v.func = alc245_fixup_hp_x360_amp,
8592 		.chained = true,
8593 		.chain_id = ALC245_FIXUP_HP_GPIO_LED
8594 	},
8595 	[ALC288_FIXUP_DELL_HEADSET_MODE] = {
8596 		.type = HDA_FIXUP_FUNC,
8597 		.v.func = alc_fixup_headset_mode_dell_alc288,
8598 		.chained = true,
8599 		.chain_id = ALC255_FIXUP_MIC_MUTE_LED
8600 	},
8601 	[ALC288_FIXUP_DELL1_MIC_NO_PRESENCE] = {
8602 		.type = HDA_FIXUP_PINS,
8603 		.v.pins = (const struct hda_pintbl[]) {
8604 			{ 0x18, 0x01a1913c }, /* use as headset mic, without its own jack detect */
8605 			{ 0x1a, 0x01a1913d }, /* use as headphone mic, without its own jack detect */
8606 			{ }
8607 		},
8608 		.chained = true,
8609 		.chain_id = ALC288_FIXUP_DELL_HEADSET_MODE
8610 	},
8611 	[ALC288_FIXUP_DISABLE_AAMIX] = {
8612 		.type = HDA_FIXUP_FUNC,
8613 		.v.func = alc_fixup_disable_aamix,
8614 		.chained = true,
8615 		.chain_id = ALC288_FIXUP_DELL1_MIC_NO_PRESENCE
8616 	},
8617 	[ALC288_FIXUP_DELL_XPS_13] = {
8618 		.type = HDA_FIXUP_FUNC,
8619 		.v.func = alc_fixup_dell_xps13,
8620 		.chained = true,
8621 		.chain_id = ALC288_FIXUP_DISABLE_AAMIX
8622 	},
8623 	[ALC292_FIXUP_DISABLE_AAMIX] = {
8624 		.type = HDA_FIXUP_FUNC,
8625 		.v.func = alc_fixup_disable_aamix,
8626 		.chained = true,
8627 		.chain_id = ALC269_FIXUP_DELL2_MIC_NO_PRESENCE
8628 	},
8629 	[ALC293_FIXUP_DISABLE_AAMIX_MULTIJACK] = {
8630 		.type = HDA_FIXUP_FUNC,
8631 		.v.func = alc_fixup_disable_aamix,
8632 		.chained = true,
8633 		.chain_id = ALC293_FIXUP_DELL1_MIC_NO_PRESENCE
8634 	},
8635 	[ALC292_FIXUP_DELL_E7X_AAMIX] = {
8636 		.type = HDA_FIXUP_FUNC,
8637 		.v.func = alc_fixup_dell_xps13,
8638 		.chained = true,
8639 		.chain_id = ALC292_FIXUP_DISABLE_AAMIX
8640 	},
8641 	[ALC292_FIXUP_DELL_E7X] = {
8642 		.type = HDA_FIXUP_FUNC,
8643 		.v.func = alc_fixup_micmute_led,
8644 		/* micmute fixup must be applied at last */
8645 		.chained_before = true,
8646 		.chain_id = ALC292_FIXUP_DELL_E7X_AAMIX,
8647 	},
8648 	[ALC298_FIXUP_ALIENWARE_MIC_NO_PRESENCE] = {
8649 		.type = HDA_FIXUP_PINS,
8650 		.v.pins = (const struct hda_pintbl[]) {
8651 			{ 0x18, 0x01a1913c }, /* headset mic w/o jack detect */
8652 			{ }
8653 		},
8654 		.chained_before = true,
8655 		.chain_id = ALC269_FIXUP_HEADSET_MODE,
8656 	},
8657 	[ALC298_FIXUP_DELL1_MIC_NO_PRESENCE] = {
8658 		.type = HDA_FIXUP_PINS,
8659 		.v.pins = (const struct hda_pintbl[]) {
8660 			{ 0x18, 0x01a1913c }, /* use as headset mic, without its own jack detect */
8661 			{ 0x1a, 0x01a1913d }, /* use as headphone mic, without its own jack detect */
8662 			{ }
8663 		},
8664 		.chained = true,
8665 		.chain_id = ALC269_FIXUP_HEADSET_MODE
8666 	},
8667 	[ALC298_FIXUP_DELL_AIO_MIC_NO_PRESENCE] = {
8668 		.type = HDA_FIXUP_PINS,
8669 		.v.pins = (const struct hda_pintbl[]) {
8670 			{ 0x18, 0x01a1913c }, /* use as headset mic, without its own jack detect */
8671 			{ }
8672 		},
8673 		.chained = true,
8674 		.chain_id = ALC269_FIXUP_HEADSET_MODE
8675 	},
8676 	[ALC275_FIXUP_DELL_XPS] = {
8677 		.type = HDA_FIXUP_VERBS,
8678 		.v.verbs = (const struct hda_verb[]) {
8679 			/* Enables internal speaker */
8680 			{0x20, AC_VERB_SET_COEF_INDEX, 0x1f},
8681 			{0x20, AC_VERB_SET_PROC_COEF, 0x00c0},
8682 			{0x20, AC_VERB_SET_COEF_INDEX, 0x30},
8683 			{0x20, AC_VERB_SET_PROC_COEF, 0x00b1},
8684 			{}
8685 		}
8686 	},
8687 	[ALC293_FIXUP_LENOVO_SPK_NOISE] = {
8688 		.type = HDA_FIXUP_FUNC,
8689 		.v.func = alc_fixup_disable_aamix,
8690 		.chained = true,
8691 		.chain_id = ALC269_FIXUP_THINKPAD_ACPI
8692 	},
8693 	[ALC233_FIXUP_LENOVO_LINE2_MIC_HOTKEY] = {
8694 		.type = HDA_FIXUP_FUNC,
8695 		.v.func = alc233_fixup_lenovo_line2_mic_hotkey,
8696 	},
8697 	[ALC233_FIXUP_LENOVO_L2MH_LOW_ENLED] = {
8698 		.type = HDA_FIXUP_FUNC,
8699 		.v.func = alc233_fixup_lenovo_low_en_micmute_led,
8700 	},
8701 	[ALC233_FIXUP_INTEL_NUC8_DMIC] = {
8702 		.type = HDA_FIXUP_FUNC,
8703 		.v.func = alc_fixup_inv_dmic,
8704 		.chained = true,
8705 		.chain_id = ALC233_FIXUP_INTEL_NUC8_BOOST,
8706 	},
8707 	[ALC233_FIXUP_INTEL_NUC8_BOOST] = {
8708 		.type = HDA_FIXUP_FUNC,
8709 		.v.func = alc269_fixup_limit_int_mic_boost
8710 	},
8711 	[ALC255_FIXUP_DELL_SPK_NOISE] = {
8712 		.type = HDA_FIXUP_FUNC,
8713 		.v.func = alc_fixup_disable_aamix,
8714 		.chained = true,
8715 		.chain_id = ALC255_FIXUP_DELL1_MIC_NO_PRESENCE
8716 	},
8717 	[ALC225_FIXUP_DISABLE_MIC_VREF] = {
8718 		.type = HDA_FIXUP_FUNC,
8719 		.v.func = alc_fixup_disable_mic_vref,
8720 		.chained = true,
8721 		.chain_id = ALC269_FIXUP_DELL1_MIC_NO_PRESENCE
8722 	},
8723 	[ALC225_FIXUP_DELL1_MIC_NO_PRESENCE] = {
8724 		.type = HDA_FIXUP_VERBS,
8725 		.v.verbs = (const struct hda_verb[]) {
8726 			/* Disable pass-through path for FRONT 14h */
8727 			{ 0x20, AC_VERB_SET_COEF_INDEX, 0x36 },
8728 			{ 0x20, AC_VERB_SET_PROC_COEF, 0x57d7 },
8729 			{}
8730 		},
8731 		.chained = true,
8732 		.chain_id = ALC225_FIXUP_DISABLE_MIC_VREF
8733 	},
8734 	[ALC280_FIXUP_HP_HEADSET_MIC] = {
8735 		.type = HDA_FIXUP_FUNC,
8736 		.v.func = alc_fixup_disable_aamix,
8737 		.chained = true,
8738 		.chain_id = ALC269_FIXUP_HEADSET_MIC,
8739 	},
8740 	[ALC221_FIXUP_HP_FRONT_MIC] = {
8741 		.type = HDA_FIXUP_PINS,
8742 		.v.pins = (const struct hda_pintbl[]) {
8743 			{ 0x19, 0x02a19020 }, /* Front Mic */
8744 			{ }
8745 		},
8746 	},
8747 	[ALC292_FIXUP_TPT460] = {
8748 		.type = HDA_FIXUP_FUNC,
8749 		.v.func = alc_fixup_tpt440_dock,
8750 		.chained = true,
8751 		.chain_id = ALC293_FIXUP_LENOVO_SPK_NOISE,
8752 	},
8753 	[ALC298_FIXUP_SPK_VOLUME] = {
8754 		.type = HDA_FIXUP_FUNC,
8755 		.v.func = alc298_fixup_speaker_volume,
8756 		.chained = true,
8757 		.chain_id = ALC298_FIXUP_DELL_AIO_MIC_NO_PRESENCE,
8758 	},
8759 	[ALC298_FIXUP_LENOVO_SPK_VOLUME] = {
8760 		.type = HDA_FIXUP_FUNC,
8761 		.v.func = alc298_fixup_speaker_volume,
8762 	},
8763 	[ALC295_FIXUP_DISABLE_DAC3] = {
8764 		.type = HDA_FIXUP_FUNC,
8765 		.v.func = alc295_fixup_disable_dac3,
8766 	},
8767 	[ALC285_FIXUP_SPEAKER2_TO_DAC1] = {
8768 		.type = HDA_FIXUP_FUNC,
8769 		.v.func = alc285_fixup_speaker2_to_dac1,
8770 		.chained = true,
8771 		.chain_id = ALC269_FIXUP_THINKPAD_ACPI
8772 	},
8773 	[ALC285_FIXUP_ASUS_SPEAKER2_TO_DAC1] = {
8774 		.type = HDA_FIXUP_FUNC,
8775 		.v.func = alc285_fixup_speaker2_to_dac1,
8776 		.chained = true,
8777 		.chain_id = ALC245_FIXUP_CS35L41_SPI_2
8778 	},
8779 	[ALC285_FIXUP_ASUS_HEADSET_MIC] = {
8780 		.type = HDA_FIXUP_PINS,
8781 		.v.pins = (const struct hda_pintbl[]) {
8782 			{ 0x19, 0x03a11050 },
8783 			{ 0x1b, 0x03a11c30 },
8784 			{ }
8785 		},
8786 		.chained = true,
8787 		.chain_id = ALC285_FIXUP_ASUS_SPEAKER2_TO_DAC1
8788 	},
8789 	[ALC285_FIXUP_ASUS_SPI_REAR_SPEAKERS] = {
8790 		.type = HDA_FIXUP_PINS,
8791 		.v.pins = (const struct hda_pintbl[]) {
8792 			{ 0x14, 0x90170120 },
8793 			{ }
8794 		},
8795 		.chained = true,
8796 		.chain_id = ALC285_FIXUP_ASUS_HEADSET_MIC
8797 	},
8798 	[ALC285_FIXUP_ASUS_I2C_SPEAKER2_TO_DAC1] = {
8799 		.type = HDA_FIXUP_FUNC,
8800 		.v.func = alc285_fixup_speaker2_to_dac1,
8801 		.chained = true,
8802 		.chain_id = ALC287_FIXUP_CS35L41_I2C_2
8803 	},
8804 	[ALC285_FIXUP_ASUS_I2C_HEADSET_MIC] = {
8805 		.type = HDA_FIXUP_PINS,
8806 		.v.pins = (const struct hda_pintbl[]) {
8807 			{ 0x19, 0x03a11050 },
8808 			{ 0x1b, 0x03a11c30 },
8809 			{ }
8810 		},
8811 		.chained = true,
8812 		.chain_id = ALC285_FIXUP_ASUS_I2C_SPEAKER2_TO_DAC1
8813 	},
8814 	[ALC256_FIXUP_DELL_INSPIRON_7559_SUBWOOFER] = {
8815 		.type = HDA_FIXUP_PINS,
8816 		.v.pins = (const struct hda_pintbl[]) {
8817 			{ 0x1b, 0x90170151 },
8818 			{ }
8819 		},
8820 		.chained = true,
8821 		.chain_id = ALC255_FIXUP_DELL1_MIC_NO_PRESENCE
8822 	},
8823 	[ALC269_FIXUP_ATIV_BOOK_8] = {
8824 		.type = HDA_FIXUP_FUNC,
8825 		.v.func = alc_fixup_auto_mute_via_amp,
8826 		.chained = true,
8827 		.chain_id = ALC269_FIXUP_NO_SHUTUP
8828 	},
8829 	[ALC221_FIXUP_HP_288PRO_MIC_NO_PRESENCE] = {
8830 		.type = HDA_FIXUP_PINS,
8831 		.v.pins = (const struct hda_pintbl[]) {
8832 			{ 0x19, 0x01a1913c }, /* use as headset mic, without its own jack detect */
8833 			{ 0x1a, 0x01813030 }, /* use as headphone mic, without its own jack detect */
8834 			{ }
8835 		},
8836 		.chained = true,
8837 		.chain_id = ALC269_FIXUP_HEADSET_MODE
8838 	},
8839 	[ALC221_FIXUP_HP_MIC_NO_PRESENCE] = {
8840 		.type = HDA_FIXUP_PINS,
8841 		.v.pins = (const struct hda_pintbl[]) {
8842 			{ 0x18, 0x01a1913c }, /* use as headset mic, without its own jack detect */
8843 			{ 0x1a, 0x01a1913d }, /* use as headphone mic, without its own jack detect */
8844 			{ }
8845 		},
8846 		.chained = true,
8847 		.chain_id = ALC269_FIXUP_HEADSET_MODE
8848 	},
8849 	[ALC256_FIXUP_ASUS_HEADSET_MODE] = {
8850 		.type = HDA_FIXUP_FUNC,
8851 		.v.func = alc_fixup_headset_mode,
8852 	},
8853 	[ALC256_FIXUP_ASUS_MIC] = {
8854 		.type = HDA_FIXUP_PINS,
8855 		.v.pins = (const struct hda_pintbl[]) {
8856 			{ 0x13, 0x90a60160 }, /* use as internal mic */
8857 			{ 0x19, 0x04a11120 }, /* use as headset mic, without its own jack detect */
8858 			{ }
8859 		},
8860 		.chained = true,
8861 		.chain_id = ALC256_FIXUP_ASUS_HEADSET_MODE
8862 	},
8863 	[ALC256_FIXUP_ASUS_AIO_GPIO2] = {
8864 		.type = HDA_FIXUP_FUNC,
8865 		/* Set up GPIO2 for the speaker amp */
8866 		.v.func = alc_fixup_gpio4,
8867 	},
8868 	[ALC233_FIXUP_ASUS_MIC_NO_PRESENCE] = {
8869 		.type = HDA_FIXUP_PINS,
8870 		.v.pins = (const struct hda_pintbl[]) {
8871 			{ 0x19, 0x01a1913c }, /* use as headset mic, without its own jack detect */
8872 			{ }
8873 		},
8874 		.chained = true,
8875 		.chain_id = ALC269_FIXUP_HEADSET_MIC
8876 	},
8877 	[ALC233_FIXUP_EAPD_COEF_AND_MIC_NO_PRESENCE] = {
8878 		.type = HDA_FIXUP_VERBS,
8879 		.v.verbs = (const struct hda_verb[]) {
8880 			/* Enables internal speaker */
8881 			{0x20, AC_VERB_SET_COEF_INDEX, 0x40},
8882 			{0x20, AC_VERB_SET_PROC_COEF, 0x8800},
8883 			{}
8884 		},
8885 		.chained = true,
8886 		.chain_id = ALC233_FIXUP_ASUS_MIC_NO_PRESENCE
8887 	},
8888 	[ALC233_FIXUP_LENOVO_MULTI_CODECS] = {
8889 		.type = HDA_FIXUP_FUNC,
8890 		.v.func = alc233_alc662_fixup_lenovo_dual_codecs,
8891 		.chained = true,
8892 		.chain_id = ALC269_FIXUP_GPIO2
8893 	},
8894 	[ALC233_FIXUP_ACER_HEADSET_MIC] = {
8895 		.type = HDA_FIXUP_VERBS,
8896 		.v.verbs = (const struct hda_verb[]) {
8897 			{ 0x20, AC_VERB_SET_COEF_INDEX, 0x45 },
8898 			{ 0x20, AC_VERB_SET_PROC_COEF, 0x5089 },
8899 			{ }
8900 		},
8901 		.chained = true,
8902 		.chain_id = ALC233_FIXUP_ASUS_MIC_NO_PRESENCE
8903 	},
8904 	[ALC294_FIXUP_LENOVO_MIC_LOCATION] = {
8905 		.type = HDA_FIXUP_PINS,
8906 		.v.pins = (const struct hda_pintbl[]) {
8907 			/* Change the mic location from front to right, otherwise there are
8908 			   two front mics with the same name, pulseaudio can't handle them.
8909 			   This is just a temporary workaround, after applying this fixup,
8910 			   there will be one "Front Mic" and one "Mic" in this machine.
8911 			 */
8912 			{ 0x1a, 0x04a19040 },
8913 			{ }
8914 		},
8915 	},
8916 	[ALC225_FIXUP_DELL_WYSE_MIC_NO_PRESENCE] = {
8917 		.type = HDA_FIXUP_PINS,
8918 		.v.pins = (const struct hda_pintbl[]) {
8919 			{ 0x16, 0x0101102f }, /* Rear Headset HP */
8920 			{ 0x19, 0x02a1913c }, /* use as Front headset mic, without its own jack detect */
8921 			{ 0x1a, 0x01a19030 }, /* Rear Headset MIC */
8922 			{ 0x1b, 0x02011020 },
8923 			{ }
8924 		},
8925 		.chained = true,
8926 		.chain_id = ALC225_FIXUP_S3_POP_NOISE
8927 	},
8928 	[ALC225_FIXUP_S3_POP_NOISE] = {
8929 		.type = HDA_FIXUP_FUNC,
8930 		.v.func = alc225_fixup_s3_pop_noise,
8931 		.chained = true,
8932 		.chain_id = ALC269_FIXUP_HEADSET_MODE_NO_HP_MIC
8933 	},
8934 	[ALC700_FIXUP_INTEL_REFERENCE] = {
8935 		.type = HDA_FIXUP_VERBS,
8936 		.v.verbs = (const struct hda_verb[]) {
8937 			/* Enables internal speaker */
8938 			{0x20, AC_VERB_SET_COEF_INDEX, 0x45},
8939 			{0x20, AC_VERB_SET_PROC_COEF, 0x5289},
8940 			{0x20, AC_VERB_SET_COEF_INDEX, 0x4A},
8941 			{0x20, AC_VERB_SET_PROC_COEF, 0x001b},
8942 			{0x58, AC_VERB_SET_COEF_INDEX, 0x00},
8943 			{0x58, AC_VERB_SET_PROC_COEF, 0x3888},
8944 			{0x20, AC_VERB_SET_COEF_INDEX, 0x6f},
8945 			{0x20, AC_VERB_SET_PROC_COEF, 0x2c0b},
8946 			{}
8947 		}
8948 	},
8949 	[ALC274_FIXUP_DELL_BIND_DACS] = {
8950 		.type = HDA_FIXUP_FUNC,
8951 		.v.func = alc274_fixup_bind_dacs,
8952 		.chained = true,
8953 		.chain_id = ALC269_FIXUP_DELL1_MIC_NO_PRESENCE
8954 	},
8955 	[ALC274_FIXUP_DELL_AIO_LINEOUT_VERB] = {
8956 		.type = HDA_FIXUP_PINS,
8957 		.v.pins = (const struct hda_pintbl[]) {
8958 			{ 0x1b, 0x0401102f },
8959 			{ }
8960 		},
8961 		.chained = true,
8962 		.chain_id = ALC274_FIXUP_DELL_BIND_DACS
8963 	},
8964 	[ALC298_FIXUP_TPT470_DOCK_FIX] = {
8965 		.type = HDA_FIXUP_FUNC,
8966 		.v.func = alc_fixup_tpt470_dock,
8967 		.chained = true,
8968 		.chain_id = ALC293_FIXUP_LENOVO_SPK_NOISE
8969 	},
8970 	[ALC298_FIXUP_TPT470_DOCK] = {
8971 		.type = HDA_FIXUP_FUNC,
8972 		.v.func = alc_fixup_tpt470_dacs,
8973 		.chained = true,
8974 		.chain_id = ALC298_FIXUP_TPT470_DOCK_FIX
8975 	},
8976 	[ALC255_FIXUP_DUMMY_LINEOUT_VERB] = {
8977 		.type = HDA_FIXUP_PINS,
8978 		.v.pins = (const struct hda_pintbl[]) {
8979 			{ 0x14, 0x0201101f },
8980 			{ }
8981 		},
8982 		.chained = true,
8983 		.chain_id = ALC255_FIXUP_DELL1_MIC_NO_PRESENCE
8984 	},
8985 	[ALC255_FIXUP_DELL_HEADSET_MIC] = {
8986 		.type = HDA_FIXUP_PINS,
8987 		.v.pins = (const struct hda_pintbl[]) {
8988 			{ 0x19, 0x01a1913c }, /* use as headset mic, without its own jack detect */
8989 			{ }
8990 		},
8991 		.chained = true,
8992 		.chain_id = ALC269_FIXUP_HEADSET_MIC
8993 	},
8994 	[ALC295_FIXUP_HP_X360] = {
8995 		.type = HDA_FIXUP_FUNC,
8996 		.v.func = alc295_fixup_hp_top_speakers,
8997 		.chained = true,
8998 		.chain_id = ALC269_FIXUP_HP_MUTE_LED_MIC3
8999 	},
9000 	[ALC221_FIXUP_HP_HEADSET_MIC] = {
9001 		.type = HDA_FIXUP_PINS,
9002 		.v.pins = (const struct hda_pintbl[]) {
9003 			{ 0x19, 0x0181313f},
9004 			{ }
9005 		},
9006 		.chained = true,
9007 		.chain_id = ALC269_FIXUP_HEADSET_MIC
9008 	},
9009 	[ALC285_FIXUP_LENOVO_HEADPHONE_NOISE] = {
9010 		.type = HDA_FIXUP_FUNC,
9011 		.v.func = alc285_fixup_invalidate_dacs,
9012 		.chained = true,
9013 		.chain_id = ALC269_FIXUP_THINKPAD_ACPI
9014 	},
9015 	[ALC295_FIXUP_HP_AUTO_MUTE] = {
9016 		.type = HDA_FIXUP_FUNC,
9017 		.v.func = alc_fixup_auto_mute_via_amp,
9018 	},
9019 	[ALC286_FIXUP_ACER_AIO_MIC_NO_PRESENCE] = {
9020 		.type = HDA_FIXUP_PINS,
9021 		.v.pins = (const struct hda_pintbl[]) {
9022 			{ 0x18, 0x01a1913c }, /* use as headset mic, without its own jack detect */
9023 			{ }
9024 		},
9025 		.chained = true,
9026 		.chain_id = ALC269_FIXUP_HEADSET_MIC
9027 	},
9028 	[ALC294_FIXUP_ASUS_MIC] = {
9029 		.type = HDA_FIXUP_PINS,
9030 		.v.pins = (const struct hda_pintbl[]) {
9031 			{ 0x13, 0x90a60160 }, /* use as internal mic */
9032 			{ 0x19, 0x04a11120 }, /* use as headset mic, without its own jack detect */
9033 			{ }
9034 		},
9035 		.chained = true,
9036 		.chain_id = ALC269_FIXUP_HEADSET_MIC
9037 	},
9038 	[ALC294_FIXUP_ASUS_HEADSET_MIC] = {
9039 		.type = HDA_FIXUP_PINS,
9040 		.v.pins = (const struct hda_pintbl[]) {
9041 			{ 0x19, 0x01a1103c }, /* use as headset mic */
9042 			{ }
9043 		},
9044 		.chained = true,
9045 		.chain_id = ALC269_FIXUP_HEADSET_MIC
9046 	},
9047 	[ALC294_FIXUP_ASUS_SPK] = {
9048 		.type = HDA_FIXUP_VERBS,
9049 		.v.verbs = (const struct hda_verb[]) {
9050 			/* Set EAPD high */
9051 			{ 0x20, AC_VERB_SET_COEF_INDEX, 0x40 },
9052 			{ 0x20, AC_VERB_SET_PROC_COEF, 0x8800 },
9053 			{ 0x20, AC_VERB_SET_COEF_INDEX, 0x0f },
9054 			{ 0x20, AC_VERB_SET_PROC_COEF, 0x7774 },
9055 			{ }
9056 		},
9057 		.chained = true,
9058 		.chain_id = ALC294_FIXUP_ASUS_HEADSET_MIC
9059 	},
9060 	[ALC295_FIXUP_CHROME_BOOK] = {
9061 		.type = HDA_FIXUP_FUNC,
9062 		.v.func = alc295_fixup_chromebook,
9063 		.chained = true,
9064 		.chain_id = ALC225_FIXUP_HEADSET_JACK
9065 	},
9066 	[ALC225_FIXUP_HEADSET_JACK] = {
9067 		.type = HDA_FIXUP_FUNC,
9068 		.v.func = alc_fixup_headset_jack,
9069 	},
9070 	[ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE] = {
9071 		.type = HDA_FIXUP_PINS,
9072 		.v.pins = (const struct hda_pintbl[]) {
9073 			{ 0x1a, 0x01a1913c }, /* use as headset mic, without its own jack detect */
9074 			{ }
9075 		},
9076 		.chained = true,
9077 		.chain_id = ALC269_FIXUP_HEADSET_MODE_NO_HP_MIC
9078 	},
9079 	[ALC285_FIXUP_LENOVO_PC_BEEP_IN_NOISE] = {
9080 		.type = HDA_FIXUP_VERBS,
9081 		.v.verbs = (const struct hda_verb[]) {
9082 			/* Disable PCBEEP-IN passthrough */
9083 			{ 0x20, AC_VERB_SET_COEF_INDEX, 0x36 },
9084 			{ 0x20, AC_VERB_SET_PROC_COEF, 0x57d7 },
9085 			{ }
9086 		},
9087 		.chained = true,
9088 		.chain_id = ALC285_FIXUP_LENOVO_HEADPHONE_NOISE
9089 	},
9090 	[ALC255_FIXUP_ACER_HEADSET_MIC] = {
9091 		.type = HDA_FIXUP_PINS,
9092 		.v.pins = (const struct hda_pintbl[]) {
9093 			{ 0x19, 0x03a11130 },
9094 			{ 0x1a, 0x90a60140 }, /* use as internal mic */
9095 			{ }
9096 		},
9097 		.chained = true,
9098 		.chain_id = ALC255_FIXUP_HEADSET_MODE_NO_HP_MIC
9099 	},
9100 	[ALC225_FIXUP_DELL_WYSE_AIO_MIC_NO_PRESENCE] = {
9101 		.type = HDA_FIXUP_PINS,
9102 		.v.pins = (const struct hda_pintbl[]) {
9103 			{ 0x16, 0x01011020 }, /* Rear Line out */
9104 			{ 0x19, 0x01a1913c }, /* use as Front headset mic, without its own jack detect */
9105 			{ }
9106 		},
9107 		.chained = true,
9108 		.chain_id = ALC225_FIXUP_WYSE_AUTO_MUTE
9109 	},
9110 	[ALC225_FIXUP_WYSE_AUTO_MUTE] = {
9111 		.type = HDA_FIXUP_FUNC,
9112 		.v.func = alc_fixup_auto_mute_via_amp,
9113 		.chained = true,
9114 		.chain_id = ALC225_FIXUP_WYSE_DISABLE_MIC_VREF
9115 	},
9116 	[ALC225_FIXUP_WYSE_DISABLE_MIC_VREF] = {
9117 		.type = HDA_FIXUP_FUNC,
9118 		.v.func = alc_fixup_disable_mic_vref,
9119 		.chained = true,
9120 		.chain_id = ALC269_FIXUP_HEADSET_MODE_NO_HP_MIC
9121 	},
9122 	[ALC286_FIXUP_ACER_AIO_HEADSET_MIC] = {
9123 		.type = HDA_FIXUP_VERBS,
9124 		.v.verbs = (const struct hda_verb[]) {
9125 			{ 0x20, AC_VERB_SET_COEF_INDEX, 0x4f },
9126 			{ 0x20, AC_VERB_SET_PROC_COEF, 0x5029 },
9127 			{ }
9128 		},
9129 		.chained = true,
9130 		.chain_id = ALC286_FIXUP_ACER_AIO_MIC_NO_PRESENCE
9131 	},
9132 	[ALC256_FIXUP_ASUS_HEADSET_MIC] = {
9133 		.type = HDA_FIXUP_PINS,
9134 		.v.pins = (const struct hda_pintbl[]) {
9135 			{ 0x19, 0x03a11020 }, /* headset mic with jack detect */
9136 			{ }
9137 		},
9138 		.chained = true,
9139 		.chain_id = ALC256_FIXUP_ASUS_HEADSET_MODE
9140 	},
9141 	[ALC256_FIXUP_ASUS_MIC_NO_PRESENCE] = {
9142 		.type = HDA_FIXUP_PINS,
9143 		.v.pins = (const struct hda_pintbl[]) {
9144 			{ 0x19, 0x04a11120 }, /* use as headset mic, without its own jack detect */
9145 			{ }
9146 		},
9147 		.chained = true,
9148 		.chain_id = ALC256_FIXUP_ASUS_HEADSET_MODE
9149 	},
9150 	[ALC255_FIXUP_PREDATOR_SUBWOOFER] = {
9151 		.type = HDA_FIXUP_PINS,
9152 		.v.pins = (const struct hda_pintbl[]) {
9153 			{ 0x17, 0x90170151 }, /* use as internal speaker (LFE) */
9154 			{ 0x1b, 0x90170152 } /* use as internal speaker (back) */
9155 		}
9156 	},
9157 	[ALC299_FIXUP_PREDATOR_SPK] = {
9158 		.type = HDA_FIXUP_PINS,
9159 		.v.pins = (const struct hda_pintbl[]) {
9160 			{ 0x21, 0x90170150 }, /* use as headset mic, without its own jack detect */
9161 			{ }
9162 		}
9163 	},
9164 	[ALC256_FIXUP_MEDION_HEADSET_NO_PRESENCE] = {
9165 		.type = HDA_FIXUP_PINS,
9166 		.v.pins = (const struct hda_pintbl[]) {
9167 			{ 0x19, 0x04a11040 },
9168 			{ 0x21, 0x04211020 },
9169 			{ }
9170 		},
9171 		.chained = true,
9172 		.chain_id = ALC256_FIXUP_ASUS_HEADSET_MODE
9173 	},
9174 	[ALC289_FIXUP_DELL_SPK1] = {
9175 		.type = HDA_FIXUP_PINS,
9176 		.v.pins = (const struct hda_pintbl[]) {
9177 			{ 0x14, 0x90170140 },
9178 			{ }
9179 		},
9180 		.chained = true,
9181 		.chain_id = ALC269_FIXUP_DELL4_MIC_NO_PRESENCE
9182 	},
9183 	[ALC289_FIXUP_DELL_SPK2] = {
9184 		.type = HDA_FIXUP_PINS,
9185 		.v.pins = (const struct hda_pintbl[]) {
9186 			{ 0x17, 0x90170130 }, /* bass spk */
9187 			{ }
9188 		},
9189 		.chained = true,
9190 		.chain_id = ALC269_FIXUP_DELL4_MIC_NO_PRESENCE
9191 	},
9192 	[ALC289_FIXUP_DUAL_SPK] = {
9193 		.type = HDA_FIXUP_FUNC,
9194 		.v.func = alc285_fixup_speaker2_to_dac1,
9195 		.chained = true,
9196 		.chain_id = ALC289_FIXUP_DELL_SPK2
9197 	},
9198 	[ALC289_FIXUP_RTK_AMP_DUAL_SPK] = {
9199 		.type = HDA_FIXUP_FUNC,
9200 		.v.func = alc285_fixup_speaker2_to_dac1,
9201 		.chained = true,
9202 		.chain_id = ALC289_FIXUP_DELL_SPK1
9203 	},
9204 	[ALC294_FIXUP_SPK2_TO_DAC1] = {
9205 		.type = HDA_FIXUP_FUNC,
9206 		.v.func = alc285_fixup_speaker2_to_dac1,
9207 		.chained = true,
9208 		.chain_id = ALC294_FIXUP_ASUS_HEADSET_MIC
9209 	},
9210 	[ALC294_FIXUP_ASUS_DUAL_SPK] = {
9211 		.type = HDA_FIXUP_FUNC,
9212 		/* The GPIO must be pulled to initialize the AMP */
9213 		.v.func = alc_fixup_gpio4,
9214 		.chained = true,
9215 		.chain_id = ALC294_FIXUP_SPK2_TO_DAC1
9216 	},
9217 	[ALC294_FIXUP_ASUS_ALLY] = {
9218 		.type = HDA_FIXUP_FUNC,
9219 		.v.func = cs35l41_fixup_i2c_two,
9220 		.chained = true,
9221 		.chain_id = ALC294_FIXUP_ASUS_ALLY_PINS
9222 	},
9223 	[ALC294_FIXUP_ASUS_ALLY_PINS] = {
9224 		.type = HDA_FIXUP_PINS,
9225 		.v.pins = (const struct hda_pintbl[]) {
9226 			{ 0x19, 0x03a11050 },
9227 			{ 0x1a, 0x03a11c30 },
9228 			{ 0x21, 0x03211420 },
9229 			{ }
9230 		},
9231 		.chained = true,
9232 		.chain_id = ALC294_FIXUP_ASUS_ALLY_VERBS
9233 	},
9234 	[ALC294_FIXUP_ASUS_ALLY_VERBS] = {
9235 		.type = HDA_FIXUP_VERBS,
9236 		.v.verbs = (const struct hda_verb[]) {
9237 			{ 0x20, AC_VERB_SET_COEF_INDEX, 0x45 },
9238 			{ 0x20, AC_VERB_SET_PROC_COEF, 0x5089 },
9239 			{ 0x20, AC_VERB_SET_COEF_INDEX, 0x46 },
9240 			{ 0x20, AC_VERB_SET_PROC_COEF, 0x0004 },
9241 			{ 0x20, AC_VERB_SET_COEF_INDEX, 0x47 },
9242 			{ 0x20, AC_VERB_SET_PROC_COEF, 0xa47a },
9243 			{ 0x20, AC_VERB_SET_COEF_INDEX, 0x49 },
9244 			{ 0x20, AC_VERB_SET_PROC_COEF, 0x0049},
9245 			{ 0x20, AC_VERB_SET_COEF_INDEX, 0x4a },
9246 			{ 0x20, AC_VERB_SET_PROC_COEF, 0x201b },
9247 			{ 0x20, AC_VERB_SET_COEF_INDEX, 0x6b },
9248 			{ 0x20, AC_VERB_SET_PROC_COEF, 0x4278},
9249 			{ }
9250 		},
9251 		.chained = true,
9252 		.chain_id = ALC294_FIXUP_ASUS_ALLY_SPEAKER
9253 	},
9254 	[ALC294_FIXUP_ASUS_ALLY_SPEAKER] = {
9255 		.type = HDA_FIXUP_FUNC,
9256 		.v.func = alc285_fixup_speaker2_to_dac1,
9257 	},
9258 	[ALC285_FIXUP_THINKPAD_X1_GEN7] = {
9259 		.type = HDA_FIXUP_FUNC,
9260 		.v.func = alc285_fixup_thinkpad_x1_gen7,
9261 		.chained = true,
9262 		.chain_id = ALC269_FIXUP_THINKPAD_ACPI
9263 	},
9264 	[ALC285_FIXUP_THINKPAD_HEADSET_JACK] = {
9265 		.type = HDA_FIXUP_FUNC,
9266 		.v.func = alc_fixup_headset_jack,
9267 		.chained = true,
9268 		.chain_id = ALC285_FIXUP_THINKPAD_X1_GEN7
9269 	},
9270 	[ALC294_FIXUP_ASUS_HPE] = {
9271 		.type = HDA_FIXUP_VERBS,
9272 		.v.verbs = (const struct hda_verb[]) {
9273 			/* Set EAPD high */
9274 			{ 0x20, AC_VERB_SET_COEF_INDEX, 0x0f },
9275 			{ 0x20, AC_VERB_SET_PROC_COEF, 0x7774 },
9276 			{ }
9277 		},
9278 		.chained = true,
9279 		.chain_id = ALC294_FIXUP_ASUS_HEADSET_MIC
9280 	},
9281 	[ALC294_FIXUP_ASUS_GX502_PINS] = {
9282 		.type = HDA_FIXUP_PINS,
9283 		.v.pins = (const struct hda_pintbl[]) {
9284 			{ 0x19, 0x03a11050 }, /* front HP mic */
9285 			{ 0x1a, 0x01a11830 }, /* rear external mic */
9286 			{ 0x21, 0x03211020 }, /* front HP out */
9287 			{ }
9288 		},
9289 		.chained = true,
9290 		.chain_id = ALC294_FIXUP_ASUS_GX502_VERBS
9291 	},
9292 	[ALC294_FIXUP_ASUS_GX502_VERBS] = {
9293 		.type = HDA_FIXUP_VERBS,
9294 		.v.verbs = (const struct hda_verb[]) {
9295 			/* set 0x15 to HP-OUT ctrl */
9296 			{ 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0 },
9297 			/* unmute the 0x15 amp */
9298 			{ 0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000 },
9299 			{ }
9300 		},
9301 		.chained = true,
9302 		.chain_id = ALC294_FIXUP_ASUS_GX502_HP
9303 	},
9304 	[ALC294_FIXUP_ASUS_GX502_HP] = {
9305 		.type = HDA_FIXUP_FUNC,
9306 		.v.func = alc294_fixup_gx502_hp,
9307 	},
9308 	[ALC294_FIXUP_ASUS_GU502_PINS] = {
9309 		.type = HDA_FIXUP_PINS,
9310 		.v.pins = (const struct hda_pintbl[]) {
9311 			{ 0x19, 0x01a11050 }, /* rear HP mic */
9312 			{ 0x1a, 0x01a11830 }, /* rear external mic */
9313 			{ 0x21, 0x012110f0 }, /* rear HP out */
9314 			{ }
9315 		},
9316 		.chained = true,
9317 		.chain_id = ALC294_FIXUP_ASUS_GU502_VERBS
9318 	},
9319 	[ALC294_FIXUP_ASUS_GU502_VERBS] = {
9320 		.type = HDA_FIXUP_VERBS,
9321 		.v.verbs = (const struct hda_verb[]) {
9322 			/* set 0x15 to HP-OUT ctrl */
9323 			{ 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0 },
9324 			/* unmute the 0x15 amp */
9325 			{ 0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000 },
9326 			/* set 0x1b to HP-OUT */
9327 			{ 0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
9328 			{ }
9329 		},
9330 		.chained = true,
9331 		.chain_id = ALC294_FIXUP_ASUS_GU502_HP
9332 	},
9333 	[ALC294_FIXUP_ASUS_GU502_HP] = {
9334 		.type = HDA_FIXUP_FUNC,
9335 		.v.func = alc294_fixup_gu502_hp,
9336 	},
9337 	 [ALC294_FIXUP_ASUS_G513_PINS] = {
9338 		.type = HDA_FIXUP_PINS,
9339 		.v.pins = (const struct hda_pintbl[]) {
9340 				{ 0x19, 0x03a11050 }, /* front HP mic */
9341 				{ 0x1a, 0x03a11c30 }, /* rear external mic */
9342 				{ 0x21, 0x03211420 }, /* front HP out */
9343 				{ }
9344 		},
9345 	},
9346 	[ALC285_FIXUP_ASUS_G533Z_PINS] = {
9347 		.type = HDA_FIXUP_PINS,
9348 		.v.pins = (const struct hda_pintbl[]) {
9349 			{ 0x14, 0x90170152 }, /* Speaker Surround Playback Switch */
9350 			{ 0x19, 0x03a19020 }, /* Mic Boost Volume */
9351 			{ 0x1a, 0x03a11c30 }, /* Mic Boost Volume */
9352 			{ 0x1e, 0x90170151 }, /* Rear jack, IN OUT EAPD Detect */
9353 			{ 0x21, 0x03211420 },
9354 			{ }
9355 		},
9356 	},
9357 	[ALC294_FIXUP_ASUS_COEF_1B] = {
9358 		.type = HDA_FIXUP_VERBS,
9359 		.v.verbs = (const struct hda_verb[]) {
9360 			/* Set bit 10 to correct noisy output after reboot from
9361 			 * Windows 10 (due to pop noise reduction?)
9362 			 */
9363 			{ 0x20, AC_VERB_SET_COEF_INDEX, 0x1b },
9364 			{ 0x20, AC_VERB_SET_PROC_COEF, 0x4e4b },
9365 			{ }
9366 		},
9367 		.chained = true,
9368 		.chain_id = ALC289_FIXUP_ASUS_GA401,
9369 	},
9370 	[ALC285_FIXUP_HP_GPIO_LED] = {
9371 		.type = HDA_FIXUP_FUNC,
9372 		.v.func = alc285_fixup_hp_gpio_led,
9373 	},
9374 	[ALC285_FIXUP_HP_MUTE_LED] = {
9375 		.type = HDA_FIXUP_FUNC,
9376 		.v.func = alc285_fixup_hp_mute_led,
9377 	},
9378 	[ALC285_FIXUP_HP_SPECTRE_X360_MUTE_LED] = {
9379 		.type = HDA_FIXUP_FUNC,
9380 		.v.func = alc285_fixup_hp_spectre_x360_mute_led,
9381 	},
9382 	[ALC236_FIXUP_HP_MUTE_LED_COEFBIT2] = {
9383 	    .type = HDA_FIXUP_FUNC,
9384 	    .v.func = alc236_fixup_hp_mute_led_coefbit2,
9385 	},
9386 	[ALC236_FIXUP_HP_GPIO_LED] = {
9387 		.type = HDA_FIXUP_FUNC,
9388 		.v.func = alc236_fixup_hp_gpio_led,
9389 	},
9390 	[ALC236_FIXUP_HP_MUTE_LED] = {
9391 		.type = HDA_FIXUP_FUNC,
9392 		.v.func = alc236_fixup_hp_mute_led,
9393 	},
9394 	[ALC236_FIXUP_HP_MUTE_LED_MICMUTE_VREF] = {
9395 		.type = HDA_FIXUP_FUNC,
9396 		.v.func = alc236_fixup_hp_mute_led_micmute_vref,
9397 	},
9398 	[ALC236_FIXUP_LENOVO_INV_DMIC] = {
9399 		.type = HDA_FIXUP_FUNC,
9400 		.v.func = alc_fixup_inv_dmic,
9401 		.chained = true,
9402 		.chain_id = ALC283_FIXUP_INT_MIC,
9403 	},
9404 	[ALC298_FIXUP_SAMSUNG_AMP] = {
9405 		.type = HDA_FIXUP_FUNC,
9406 		.v.func = alc298_fixup_samsung_amp,
9407 		.chained = true,
9408 		.chain_id = ALC298_FIXUP_SAMSUNG_HEADPHONE_VERY_QUIET
9409 	},
9410 	[ALC298_FIXUP_SAMSUNG_AMP_V2_2_AMPS] = {
9411 		.type = HDA_FIXUP_FUNC,
9412 		.v.func = alc298_fixup_samsung_amp_v2_2_amps
9413 	},
9414 	[ALC298_FIXUP_SAMSUNG_AMP_V2_4_AMPS] = {
9415 		.type = HDA_FIXUP_FUNC,
9416 		.v.func = alc298_fixup_samsung_amp_v2_4_amps
9417 	},
9418 	[ALC298_FIXUP_SAMSUNG_HEADPHONE_VERY_QUIET] = {
9419 		.type = HDA_FIXUP_VERBS,
9420 		.v.verbs = (const struct hda_verb[]) {
9421 			{ 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc5 },
9422 			{ }
9423 		},
9424 	},
9425 	[ALC256_FIXUP_SAMSUNG_HEADPHONE_VERY_QUIET] = {
9426 		.type = HDA_FIXUP_VERBS,
9427 		.v.verbs = (const struct hda_verb[]) {
9428 			{ 0x20, AC_VERB_SET_COEF_INDEX, 0x08},
9429 			{ 0x20, AC_VERB_SET_PROC_COEF, 0x2fcf},
9430 			{ }
9431 		},
9432 	},
9433 	[ALC295_FIXUP_ASUS_MIC_NO_PRESENCE] = {
9434 		.type = HDA_FIXUP_PINS,
9435 		.v.pins = (const struct hda_pintbl[]) {
9436 			{ 0x19, 0x01a1913c }, /* use as headset mic, without its own jack detect */
9437 			{ }
9438 		},
9439 		.chained = true,
9440 		.chain_id = ALC269_FIXUP_HEADSET_MODE
9441 	},
9442 	[ALC269VC_FIXUP_ACER_VCOPPERBOX_PINS] = {
9443 		.type = HDA_FIXUP_PINS,
9444 		.v.pins = (const struct hda_pintbl[]) {
9445 			{ 0x14, 0x90100120 }, /* use as internal speaker */
9446 			{ 0x18, 0x02a111f0 }, /* use as headset mic, without its own jack detect */
9447 			{ 0x1a, 0x01011020 }, /* use as line out */
9448 			{ },
9449 		},
9450 		.chained = true,
9451 		.chain_id = ALC269_FIXUP_HEADSET_MIC
9452 	},
9453 	[ALC269VC_FIXUP_ACER_HEADSET_MIC] = {
9454 		.type = HDA_FIXUP_PINS,
9455 		.v.pins = (const struct hda_pintbl[]) {
9456 			{ 0x18, 0x02a11030 }, /* use as headset mic */
9457 			{ }
9458 		},
9459 		.chained = true,
9460 		.chain_id = ALC269_FIXUP_HEADSET_MIC
9461 	},
9462 	[ALC269VC_FIXUP_ACER_MIC_NO_PRESENCE] = {
9463 		.type = HDA_FIXUP_PINS,
9464 		.v.pins = (const struct hda_pintbl[]) {
9465 			{ 0x18, 0x01a11130 }, /* use as headset mic, without its own jack detect */
9466 			{ }
9467 		},
9468 		.chained = true,
9469 		.chain_id = ALC269_FIXUP_HEADSET_MIC
9470 	},
9471 	[ALC289_FIXUP_ASUS_GA401] = {
9472 		.type = HDA_FIXUP_FUNC,
9473 		.v.func = alc289_fixup_asus_ga401,
9474 		.chained = true,
9475 		.chain_id = ALC289_FIXUP_ASUS_GA502,
9476 	},
9477 	[ALC289_FIXUP_ASUS_GA502] = {
9478 		.type = HDA_FIXUP_PINS,
9479 		.v.pins = (const struct hda_pintbl[]) {
9480 			{ 0x19, 0x03a11020 }, /* headset mic with jack detect */
9481 			{ }
9482 		},
9483 	},
9484 	[ALC256_FIXUP_ACER_MIC_NO_PRESENCE] = {
9485 		.type = HDA_FIXUP_PINS,
9486 		.v.pins = (const struct hda_pintbl[]) {
9487 			{ 0x19, 0x02a11120 }, /* use as headset mic, without its own jack detect */
9488 			{ }
9489 		},
9490 		.chained = true,
9491 		.chain_id = ALC256_FIXUP_ASUS_HEADSET_MODE
9492 	},
9493 	[ALC285_FIXUP_HP_GPIO_AMP_INIT] = {
9494 		.type = HDA_FIXUP_FUNC,
9495 		.v.func = alc285_fixup_hp_gpio_amp_init,
9496 		.chained = true,
9497 		.chain_id = ALC285_FIXUP_HP_GPIO_LED
9498 	},
9499 	[ALC269_FIXUP_CZC_B20] = {
9500 		.type = HDA_FIXUP_PINS,
9501 		.v.pins = (const struct hda_pintbl[]) {
9502 			{ 0x12, 0x411111f0 },
9503 			{ 0x14, 0x90170110 }, /* speaker */
9504 			{ 0x15, 0x032f1020 }, /* HP out */
9505 			{ 0x17, 0x411111f0 },
9506 			{ 0x18, 0x03ab1040 }, /* mic */
9507 			{ 0x19, 0xb7a7013f },
9508 			{ 0x1a, 0x0181305f },
9509 			{ 0x1b, 0x411111f0 },
9510 			{ 0x1d, 0x411111f0 },
9511 			{ 0x1e, 0x411111f0 },
9512 			{ }
9513 		},
9514 		.chain_id = ALC269_FIXUP_DMIC,
9515 	},
9516 	[ALC269_FIXUP_CZC_TMI] = {
9517 		.type = HDA_FIXUP_PINS,
9518 		.v.pins = (const struct hda_pintbl[]) {
9519 			{ 0x12, 0x4000c000 },
9520 			{ 0x14, 0x90170110 }, /* speaker */
9521 			{ 0x15, 0x0421401f }, /* HP out */
9522 			{ 0x17, 0x411111f0 },
9523 			{ 0x18, 0x04a19020 }, /* mic */
9524 			{ 0x19, 0x411111f0 },
9525 			{ 0x1a, 0x411111f0 },
9526 			{ 0x1b, 0x411111f0 },
9527 			{ 0x1d, 0x40448505 },
9528 			{ 0x1e, 0x411111f0 },
9529 			{ 0x20, 0x8000ffff },
9530 			{ }
9531 		},
9532 		.chain_id = ALC269_FIXUP_DMIC,
9533 	},
9534 	[ALC269_FIXUP_CZC_L101] = {
9535 		.type = HDA_FIXUP_PINS,
9536 		.v.pins = (const struct hda_pintbl[]) {
9537 			{ 0x12, 0x40000000 },
9538 			{ 0x14, 0x01014010 }, /* speaker */
9539 			{ 0x15, 0x411111f0 }, /* HP out */
9540 			{ 0x16, 0x411111f0 },
9541 			{ 0x18, 0x01a19020 }, /* mic */
9542 			{ 0x19, 0x02a19021 },
9543 			{ 0x1a, 0x0181302f },
9544 			{ 0x1b, 0x0221401f },
9545 			{ 0x1c, 0x411111f0 },
9546 			{ 0x1d, 0x4044c601 },
9547 			{ 0x1e, 0x411111f0 },
9548 			{ }
9549 		},
9550 		.chain_id = ALC269_FIXUP_DMIC,
9551 	},
9552 	[ALC269_FIXUP_LEMOTE_A1802] = {
9553 		.type = HDA_FIXUP_PINS,
9554 		.v.pins = (const struct hda_pintbl[]) {
9555 			{ 0x12, 0x40000000 },
9556 			{ 0x14, 0x90170110 }, /* speaker */
9557 			{ 0x17, 0x411111f0 },
9558 			{ 0x18, 0x03a19040 }, /* mic1 */
9559 			{ 0x19, 0x90a70130 }, /* mic2 */
9560 			{ 0x1a, 0x411111f0 },
9561 			{ 0x1b, 0x411111f0 },
9562 			{ 0x1d, 0x40489d2d },
9563 			{ 0x1e, 0x411111f0 },
9564 			{ 0x20, 0x0003ffff },
9565 			{ 0x21, 0x03214020 },
9566 			{ }
9567 		},
9568 		.chain_id = ALC269_FIXUP_DMIC,
9569 	},
9570 	[ALC269_FIXUP_LEMOTE_A190X] = {
9571 		.type = HDA_FIXUP_PINS,
9572 		.v.pins = (const struct hda_pintbl[]) {
9573 			{ 0x14, 0x99130110 }, /* speaker */
9574 			{ 0x15, 0x0121401f }, /* HP out */
9575 			{ 0x18, 0x01a19c20 }, /* rear  mic */
9576 			{ 0x19, 0x99a3092f }, /* front mic */
9577 			{ 0x1b, 0x0201401f }, /* front lineout */
9578 			{ }
9579 		},
9580 		.chain_id = ALC269_FIXUP_DMIC,
9581 	},
9582 	[ALC256_FIXUP_INTEL_NUC8_RUGGED] = {
9583 		.type = HDA_FIXUP_PINS,
9584 		.v.pins = (const struct hda_pintbl[]) {
9585 			{ 0x1b, 0x01a1913c }, /* use as headset mic, without its own jack detect */
9586 			{ }
9587 		},
9588 		.chained = true,
9589 		.chain_id = ALC269_FIXUP_HEADSET_MODE
9590 	},
9591 	[ALC256_FIXUP_INTEL_NUC10] = {
9592 		.type = HDA_FIXUP_PINS,
9593 		.v.pins = (const struct hda_pintbl[]) {
9594 			{ 0x19, 0x01a1913c }, /* use as headset mic, without its own jack detect */
9595 			{ }
9596 		},
9597 		.chained = true,
9598 		.chain_id = ALC269_FIXUP_HEADSET_MODE
9599 	},
9600 	[ALC255_FIXUP_XIAOMI_HEADSET_MIC] = {
9601 		.type = HDA_FIXUP_VERBS,
9602 		.v.verbs = (const struct hda_verb[]) {
9603 			{ 0x20, AC_VERB_SET_COEF_INDEX, 0x45 },
9604 			{ 0x20, AC_VERB_SET_PROC_COEF, 0x5089 },
9605 			{ }
9606 		},
9607 		.chained = true,
9608 		.chain_id = ALC289_FIXUP_ASUS_GA502
9609 	},
9610 	[ALC274_FIXUP_HP_MIC] = {
9611 		.type = HDA_FIXUP_VERBS,
9612 		.v.verbs = (const struct hda_verb[]) {
9613 			{ 0x20, AC_VERB_SET_COEF_INDEX, 0x45 },
9614 			{ 0x20, AC_VERB_SET_PROC_COEF, 0x5089 },
9615 			{ }
9616 		},
9617 	},
9618 	[ALC274_FIXUP_HP_HEADSET_MIC] = {
9619 		.type = HDA_FIXUP_FUNC,
9620 		.v.func = alc274_fixup_hp_headset_mic,
9621 		.chained = true,
9622 		.chain_id = ALC274_FIXUP_HP_MIC
9623 	},
9624 	[ALC274_FIXUP_HP_ENVY_GPIO] = {
9625 		.type = HDA_FIXUP_FUNC,
9626 		.v.func = alc274_fixup_hp_envy_gpio,
9627 	},
9628 	[ALC274_FIXUP_ASUS_ZEN_AIO_27] = {
9629 		.type = HDA_FIXUP_VERBS,
9630 		.v.verbs = (const struct hda_verb[]) {
9631 			{ 0x20, AC_VERB_SET_COEF_INDEX, 0x10 },
9632 			{ 0x20, AC_VERB_SET_PROC_COEF, 0xc420 },
9633 			{ 0x20, AC_VERB_SET_COEF_INDEX, 0x40 },
9634 			{ 0x20, AC_VERB_SET_PROC_COEF, 0x8800 },
9635 			{ 0x20, AC_VERB_SET_COEF_INDEX, 0x49 },
9636 			{ 0x20, AC_VERB_SET_PROC_COEF, 0x0249 },
9637 			{ 0x20, AC_VERB_SET_COEF_INDEX, 0x4a },
9638 			{ 0x20, AC_VERB_SET_PROC_COEF, 0x202b },
9639 			{ 0x20, AC_VERB_SET_COEF_INDEX, 0x62 },
9640 			{ 0x20, AC_VERB_SET_PROC_COEF, 0xa007 },
9641 			{ 0x20, AC_VERB_SET_COEF_INDEX, 0x6b },
9642 			{ 0x20, AC_VERB_SET_PROC_COEF, 0x5060 },
9643 			{}
9644 		},
9645 		.chained = true,
9646 		.chain_id = ALC2XX_FIXUP_HEADSET_MIC,
9647 	},
9648 	[ALC256_FIXUP_ASUS_HPE] = {
9649 		.type = HDA_FIXUP_VERBS,
9650 		.v.verbs = (const struct hda_verb[]) {
9651 			/* Set EAPD high */
9652 			{ 0x20, AC_VERB_SET_COEF_INDEX, 0x0f },
9653 			{ 0x20, AC_VERB_SET_PROC_COEF, 0x7778 },
9654 			{ }
9655 		},
9656 		.chained = true,
9657 		.chain_id = ALC294_FIXUP_ASUS_HEADSET_MIC
9658 	},
9659 	[ALC285_FIXUP_THINKPAD_NO_BASS_SPK_HEADSET_JACK] = {
9660 		.type = HDA_FIXUP_FUNC,
9661 		.v.func = alc_fixup_headset_jack,
9662 		.chained = true,
9663 		.chain_id = ALC269_FIXUP_THINKPAD_ACPI
9664 	},
9665 	[ALC287_FIXUP_HP_GPIO_LED] = {
9666 		.type = HDA_FIXUP_FUNC,
9667 		.v.func = alc287_fixup_hp_gpio_led,
9668 	},
9669 	[ALC256_FIXUP_HP_HEADSET_MIC] = {
9670 		.type = HDA_FIXUP_FUNC,
9671 		.v.func = alc274_fixup_hp_headset_mic,
9672 	},
9673 	[ALC236_FIXUP_DELL_AIO_HEADSET_MIC] = {
9674 		.type = HDA_FIXUP_FUNC,
9675 		.v.func = alc_fixup_no_int_mic,
9676 		.chained = true,
9677 		.chain_id = ALC255_FIXUP_DELL1_MIC_NO_PRESENCE
9678 	},
9679 	[ALC282_FIXUP_ACER_DISABLE_LINEOUT] = {
9680 		.type = HDA_FIXUP_PINS,
9681 		.v.pins = (const struct hda_pintbl[]) {
9682 			{ 0x1b, 0x411111f0 },
9683 			{ 0x18, 0x01a1913c }, /* use as headset mic, without its own jack detect */
9684 			{ },
9685 		},
9686 		.chained = true,
9687 		.chain_id = ALC269_FIXUP_HEADSET_MODE
9688 	},
9689 	[ALC255_FIXUP_ACER_LIMIT_INT_MIC_BOOST] = {
9690 		.type = HDA_FIXUP_FUNC,
9691 		.v.func = alc269_fixup_limit_int_mic_boost,
9692 		.chained = true,
9693 		.chain_id = ALC255_FIXUP_ACER_MIC_NO_PRESENCE,
9694 	},
9695 	[ALC256_FIXUP_ACER_HEADSET_MIC] = {
9696 		.type = HDA_FIXUP_PINS,
9697 		.v.pins = (const struct hda_pintbl[]) {
9698 			{ 0x19, 0x02a1113c }, /* use as headset mic, without its own jack detect */
9699 			{ 0x1a, 0x90a1092f }, /* use as internal mic */
9700 			{ }
9701 		},
9702 		.chained = true,
9703 		.chain_id = ALC269_FIXUP_HEADSET_MODE_NO_HP_MIC
9704 	},
9705 	[ALC285_FIXUP_IDEAPAD_S740_COEF] = {
9706 		.type = HDA_FIXUP_FUNC,
9707 		.v.func = alc285_fixup_ideapad_s740_coef,
9708 		.chained = true,
9709 		.chain_id = ALC269_FIXUP_THINKPAD_ACPI,
9710 	},
9711 	[ALC285_FIXUP_HP_LIMIT_INT_MIC_BOOST] = {
9712 		.type = HDA_FIXUP_FUNC,
9713 		.v.func = alc269_fixup_limit_int_mic_boost,
9714 		.chained = true,
9715 		.chain_id = ALC285_FIXUP_HP_MUTE_LED,
9716 	},
9717 	[ALC295_FIXUP_ASUS_DACS] = {
9718 		.type = HDA_FIXUP_FUNC,
9719 		.v.func = alc295_fixup_asus_dacs,
9720 	},
9721 	[ALC295_FIXUP_HP_OMEN] = {
9722 		.type = HDA_FIXUP_PINS,
9723 		.v.pins = (const struct hda_pintbl[]) {
9724 			{ 0x12, 0xb7a60130 },
9725 			{ 0x13, 0x40000000 },
9726 			{ 0x14, 0x411111f0 },
9727 			{ 0x16, 0x411111f0 },
9728 			{ 0x17, 0x90170110 },
9729 			{ 0x18, 0x411111f0 },
9730 			{ 0x19, 0x02a11030 },
9731 			{ 0x1a, 0x411111f0 },
9732 			{ 0x1b, 0x04a19030 },
9733 			{ 0x1d, 0x40600001 },
9734 			{ 0x1e, 0x411111f0 },
9735 			{ 0x21, 0x03211020 },
9736 			{}
9737 		},
9738 		.chained = true,
9739 		.chain_id = ALC269_FIXUP_HP_LINE1_MIC1_LED,
9740 	},
9741 	[ALC285_FIXUP_HP_SPECTRE_X360] = {
9742 		.type = HDA_FIXUP_FUNC,
9743 		.v.func = alc285_fixup_hp_spectre_x360,
9744 	},
9745 	[ALC285_FIXUP_HP_SPECTRE_X360_EB1] = {
9746 		.type = HDA_FIXUP_FUNC,
9747 		.v.func = alc285_fixup_hp_spectre_x360_eb1
9748 	},
9749 	[ALC285_FIXUP_HP_ENVY_X360] = {
9750 		.type = HDA_FIXUP_FUNC,
9751 		.v.func = alc285_fixup_hp_envy_x360,
9752 		.chained = true,
9753 		.chain_id = ALC285_FIXUP_HP_GPIO_AMP_INIT,
9754 	},
9755 	[ALC287_FIXUP_IDEAPAD_BASS_SPK_AMP] = {
9756 		.type = HDA_FIXUP_FUNC,
9757 		.v.func = alc285_fixup_ideapad_s740_coef,
9758 		.chained = true,
9759 		.chain_id = ALC285_FIXUP_THINKPAD_HEADSET_JACK,
9760 	},
9761 	[ALC623_FIXUP_LENOVO_THINKSTATION_P340] = {
9762 		.type = HDA_FIXUP_FUNC,
9763 		.v.func = alc_fixup_no_shutup,
9764 		.chained = true,
9765 		.chain_id = ALC283_FIXUP_HEADSET_MIC,
9766 	},
9767 	[ALC255_FIXUP_ACER_HEADPHONE_AND_MIC] = {
9768 		.type = HDA_FIXUP_PINS,
9769 		.v.pins = (const struct hda_pintbl[]) {
9770 			{ 0x21, 0x03211030 }, /* Change the Headphone location to Left */
9771 			{ }
9772 		},
9773 		.chained = true,
9774 		.chain_id = ALC255_FIXUP_XIAOMI_HEADSET_MIC
9775 	},
9776 	[ALC236_FIXUP_HP_LIMIT_INT_MIC_BOOST] = {
9777 		.type = HDA_FIXUP_FUNC,
9778 		.v.func = alc269_fixup_limit_int_mic_boost,
9779 		.chained = true,
9780 		.chain_id = ALC236_FIXUP_HP_MUTE_LED_MICMUTE_VREF,
9781 	},
9782 	[ALC285_FIXUP_LEGION_Y9000X_SPEAKERS] = {
9783 		.type = HDA_FIXUP_FUNC,
9784 		.v.func = alc285_fixup_ideapad_s740_coef,
9785 		.chained = true,
9786 		.chain_id = ALC285_FIXUP_LEGION_Y9000X_AUTOMUTE,
9787 	},
9788 	[ALC285_FIXUP_LEGION_Y9000X_AUTOMUTE] = {
9789 		.type = HDA_FIXUP_FUNC,
9790 		.v.func = alc287_fixup_legion_15imhg05_speakers,
9791 		.chained = true,
9792 		.chain_id = ALC269_FIXUP_THINKPAD_ACPI,
9793 	},
9794 	[ALC287_FIXUP_LEGION_15IMHG05_SPEAKERS] = {
9795 		.type = HDA_FIXUP_VERBS,
9796 		//.v.verbs = legion_15imhg05_coefs,
9797 		.v.verbs = (const struct hda_verb[]) {
9798 			 // set left speaker Legion 7i.
9799 			 { 0x20, AC_VERB_SET_COEF_INDEX, 0x24 },
9800 			 { 0x20, AC_VERB_SET_PROC_COEF, 0x41 },
9801 
9802 			 { 0x20, AC_VERB_SET_COEF_INDEX, 0x26 },
9803 			 { 0x20, AC_VERB_SET_PROC_COEF, 0xc },
9804 			 { 0x20, AC_VERB_SET_PROC_COEF, 0x0 },
9805 			 { 0x20, AC_VERB_SET_PROC_COEF, 0x1a },
9806 			 { 0x20, AC_VERB_SET_PROC_COEF, 0xb020 },
9807 
9808 			 { 0x20, AC_VERB_SET_COEF_INDEX, 0x26 },
9809 			 { 0x20, AC_VERB_SET_PROC_COEF, 0x2 },
9810 			 { 0x20, AC_VERB_SET_PROC_COEF, 0x0 },
9811 			 { 0x20, AC_VERB_SET_PROC_COEF, 0x0 },
9812 			 { 0x20, AC_VERB_SET_PROC_COEF, 0xb020 },
9813 
9814 			 // set right speaker Legion 7i.
9815 			 { 0x20, AC_VERB_SET_COEF_INDEX, 0x24 },
9816 			 { 0x20, AC_VERB_SET_PROC_COEF, 0x42 },
9817 
9818 			 { 0x20, AC_VERB_SET_COEF_INDEX, 0x26 },
9819 			 { 0x20, AC_VERB_SET_PROC_COEF, 0xc },
9820 			 { 0x20, AC_VERB_SET_PROC_COEF, 0x0 },
9821 			 { 0x20, AC_VERB_SET_PROC_COEF, 0x2a },
9822 			 { 0x20, AC_VERB_SET_PROC_COEF, 0xb020 },
9823 
9824 			 { 0x20, AC_VERB_SET_COEF_INDEX, 0x26 },
9825 			 { 0x20, AC_VERB_SET_PROC_COEF, 0x2 },
9826 			 { 0x20, AC_VERB_SET_PROC_COEF, 0x0 },
9827 			 { 0x20, AC_VERB_SET_PROC_COEF, 0x0 },
9828 			 { 0x20, AC_VERB_SET_PROC_COEF, 0xb020 },
9829 			 {}
9830 		},
9831 		.chained = true,
9832 		.chain_id = ALC287_FIXUP_LEGION_15IMHG05_AUTOMUTE,
9833 	},
9834 	[ALC287_FIXUP_LEGION_15IMHG05_AUTOMUTE] = {
9835 		.type = HDA_FIXUP_FUNC,
9836 		.v.func = alc287_fixup_legion_15imhg05_speakers,
9837 		.chained = true,
9838 		.chain_id = ALC269_FIXUP_HEADSET_MODE,
9839 	},
9840 	[ALC287_FIXUP_YOGA7_14ITL_SPEAKERS] = {
9841 		.type = HDA_FIXUP_VERBS,
9842 		.v.verbs = (const struct hda_verb[]) {
9843 			 // set left speaker Yoga 7i.
9844 			 { 0x20, AC_VERB_SET_COEF_INDEX, 0x24 },
9845 			 { 0x20, AC_VERB_SET_PROC_COEF, 0x41 },
9846 
9847 			 { 0x20, AC_VERB_SET_COEF_INDEX, 0x26 },
9848 			 { 0x20, AC_VERB_SET_PROC_COEF, 0xc },
9849 			 { 0x20, AC_VERB_SET_PROC_COEF, 0x0 },
9850 			 { 0x20, AC_VERB_SET_PROC_COEF, 0x1a },
9851 			 { 0x20, AC_VERB_SET_PROC_COEF, 0xb020 },
9852 
9853 			 { 0x20, AC_VERB_SET_COEF_INDEX, 0x26 },
9854 			 { 0x20, AC_VERB_SET_PROC_COEF, 0x2 },
9855 			 { 0x20, AC_VERB_SET_PROC_COEF, 0x0 },
9856 			 { 0x20, AC_VERB_SET_PROC_COEF, 0x0 },
9857 			 { 0x20, AC_VERB_SET_PROC_COEF, 0xb020 },
9858 
9859 			 // set right speaker Yoga 7i.
9860 			 { 0x20, AC_VERB_SET_COEF_INDEX, 0x24 },
9861 			 { 0x20, AC_VERB_SET_PROC_COEF, 0x46 },
9862 
9863 			 { 0x20, AC_VERB_SET_COEF_INDEX, 0x26 },
9864 			 { 0x20, AC_VERB_SET_PROC_COEF, 0xc },
9865 			 { 0x20, AC_VERB_SET_PROC_COEF, 0x0 },
9866 			 { 0x20, AC_VERB_SET_PROC_COEF, 0x2a },
9867 			 { 0x20, AC_VERB_SET_PROC_COEF, 0xb020 },
9868 
9869 			 { 0x20, AC_VERB_SET_COEF_INDEX, 0x26 },
9870 			 { 0x20, AC_VERB_SET_PROC_COEF, 0x2 },
9871 			 { 0x20, AC_VERB_SET_PROC_COEF, 0x0 },
9872 			 { 0x20, AC_VERB_SET_PROC_COEF, 0x0 },
9873 			 { 0x20, AC_VERB_SET_PROC_COEF, 0xb020 },
9874 			 {}
9875 		},
9876 		.chained = true,
9877 		.chain_id = ALC269_FIXUP_HEADSET_MODE,
9878 	},
9879 	[ALC298_FIXUP_LENOVO_C940_DUET7] = {
9880 		.type = HDA_FIXUP_FUNC,
9881 		.v.func = alc298_fixup_lenovo_c940_duet7,
9882 	},
9883 	[ALC287_FIXUP_13S_GEN2_SPEAKERS] = {
9884 		.type = HDA_FIXUP_VERBS,
9885 		.v.verbs = (const struct hda_verb[]) {
9886 			{ 0x20, AC_VERB_SET_COEF_INDEX, 0x24 },
9887 			{ 0x20, AC_VERB_SET_PROC_COEF, 0x41 },
9888 			{ 0x20, AC_VERB_SET_COEF_INDEX, 0x26 },
9889 			{ 0x20, AC_VERB_SET_PROC_COEF, 0x2 },
9890 			{ 0x20, AC_VERB_SET_PROC_COEF, 0x0 },
9891 			{ 0x20, AC_VERB_SET_PROC_COEF, 0x0 },
9892 			{ 0x20, AC_VERB_SET_PROC_COEF, 0xb020 },
9893 			{ 0x20, AC_VERB_SET_COEF_INDEX, 0x24 },
9894 			{ 0x20, AC_VERB_SET_PROC_COEF, 0x42 },
9895 			{ 0x20, AC_VERB_SET_COEF_INDEX, 0x26 },
9896 			{ 0x20, AC_VERB_SET_PROC_COEF, 0x2 },
9897 			{ 0x20, AC_VERB_SET_PROC_COEF, 0x0 },
9898 			{ 0x20, AC_VERB_SET_PROC_COEF, 0x0 },
9899 			{ 0x20, AC_VERB_SET_PROC_COEF, 0xb020 },
9900 			{}
9901 		},
9902 		.chained = true,
9903 		.chain_id = ALC269_FIXUP_HEADSET_MODE,
9904 	},
9905 	[ALC256_FIXUP_SET_COEF_DEFAULTS] = {
9906 		.type = HDA_FIXUP_FUNC,
9907 		.v.func = alc256_fixup_set_coef_defaults,
9908 	},
9909 	[ALC245_FIXUP_HP_GPIO_LED] = {
9910 		.type = HDA_FIXUP_FUNC,
9911 		.v.func = alc245_fixup_hp_gpio_led,
9912 	},
9913 	[ALC256_FIXUP_SYSTEM76_MIC_NO_PRESENCE] = {
9914 		.type = HDA_FIXUP_PINS,
9915 		.v.pins = (const struct hda_pintbl[]) {
9916 			{ 0x19, 0x03a11120 }, /* use as headset mic, without its own jack detect */
9917 			{ }
9918 		},
9919 		.chained = true,
9920 		.chain_id = ALC269_FIXUP_HEADSET_MODE_NO_HP_MIC,
9921 	},
9922 	[ALC233_FIXUP_NO_AUDIO_JACK] = {
9923 		.type = HDA_FIXUP_FUNC,
9924 		.v.func = alc233_fixup_no_audio_jack,
9925 	},
9926 	[ALC256_FIXUP_MIC_NO_PRESENCE_AND_RESUME] = {
9927 		.type = HDA_FIXUP_FUNC,
9928 		.v.func = alc256_fixup_mic_no_presence_and_resume,
9929 		.chained = true,
9930 		.chain_id = ALC269_FIXUP_HEADSET_MODE_NO_HP_MIC
9931 	},
9932 	[ALC287_FIXUP_LEGION_16ACHG6] = {
9933 		.type = HDA_FIXUP_FUNC,
9934 		.v.func = alc287_fixup_legion_16achg6_speakers,
9935 	},
9936 	[ALC287_FIXUP_CS35L41_I2C_2] = {
9937 		.type = HDA_FIXUP_FUNC,
9938 		.v.func = cs35l41_fixup_i2c_two,
9939 	},
9940 	[ALC287_FIXUP_CS35L41_I2C_2_HP_GPIO_LED] = {
9941 		.type = HDA_FIXUP_FUNC,
9942 		.v.func = cs35l41_fixup_i2c_two,
9943 		.chained = true,
9944 		.chain_id = ALC285_FIXUP_HP_MUTE_LED,
9945 	},
9946 	[ALC287_FIXUP_CS35L41_I2C_4] = {
9947 		.type = HDA_FIXUP_FUNC,
9948 		.v.func = cs35l41_fixup_i2c_four,
9949 	},
9950 	[ALC245_FIXUP_CS35L41_SPI_2] = {
9951 		.type = HDA_FIXUP_FUNC,
9952 		.v.func = cs35l41_fixup_spi_two,
9953 	},
9954 	[ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED] = {
9955 		.type = HDA_FIXUP_FUNC,
9956 		.v.func = cs35l41_fixup_spi_two,
9957 		.chained = true,
9958 		.chain_id = ALC285_FIXUP_HP_GPIO_LED,
9959 	},
9960 	[ALC245_FIXUP_CS35L41_SPI_4] = {
9961 		.type = HDA_FIXUP_FUNC,
9962 		.v.func = cs35l41_fixup_spi_four,
9963 	},
9964 	[ALC245_FIXUP_CS35L41_SPI_4_HP_GPIO_LED] = {
9965 		.type = HDA_FIXUP_FUNC,
9966 		.v.func = cs35l41_fixup_spi_four,
9967 		.chained = true,
9968 		.chain_id = ALC285_FIXUP_HP_GPIO_LED,
9969 	},
9970 	[ALC285_FIXUP_HP_SPEAKERS_MICMUTE_LED] = {
9971 		.type = HDA_FIXUP_VERBS,
9972 		.v.verbs = (const struct hda_verb[]) {
9973 			 { 0x20, AC_VERB_SET_COEF_INDEX, 0x19 },
9974 			 { 0x20, AC_VERB_SET_PROC_COEF, 0x8e11 },
9975 			 { }
9976 		},
9977 		.chained = true,
9978 		.chain_id = ALC285_FIXUP_HP_MUTE_LED,
9979 	},
9980 	[ALC269_FIXUP_DELL4_MIC_NO_PRESENCE_QUIET] = {
9981 		.type = HDA_FIXUP_FUNC,
9982 		.v.func = alc_fixup_dell4_mic_no_presence_quiet,
9983 		.chained = true,
9984 		.chain_id = ALC269_FIXUP_DELL4_MIC_NO_PRESENCE,
9985 	},
9986 	[ALC295_FIXUP_FRAMEWORK_LAPTOP_MIC_NO_PRESENCE] = {
9987 		.type = HDA_FIXUP_PINS,
9988 		.v.pins = (const struct hda_pintbl[]) {
9989 			{ 0x19, 0x02a1112c }, /* use as headset mic, without its own jack detect */
9990 			{ }
9991 		},
9992 		.chained = true,
9993 		.chain_id = ALC269_FIXUP_HEADSET_MODE_NO_HP_MIC
9994 	},
9995 	[ALC287_FIXUP_LEGION_16ITHG6] = {
9996 		.type = HDA_FIXUP_FUNC,
9997 		.v.func = alc287_fixup_legion_16ithg6_speakers,
9998 	},
9999 	[ALC287_FIXUP_YOGA9_14IAP7_BASS_SPK] = {
10000 		.type = HDA_FIXUP_VERBS,
10001 		.v.verbs = (const struct hda_verb[]) {
10002 			// enable left speaker
10003 			{ 0x20, AC_VERB_SET_COEF_INDEX, 0x24 },
10004 			{ 0x20, AC_VERB_SET_PROC_COEF, 0x41 },
10005 
10006 			{ 0x20, AC_VERB_SET_COEF_INDEX, 0x26 },
10007 			{ 0x20, AC_VERB_SET_PROC_COEF, 0xc },
10008 			{ 0x20, AC_VERB_SET_PROC_COEF, 0x0 },
10009 			{ 0x20, AC_VERB_SET_PROC_COEF, 0x1a },
10010 			{ 0x20, AC_VERB_SET_PROC_COEF, 0xb020 },
10011 
10012 			{ 0x20, AC_VERB_SET_COEF_INDEX, 0x26 },
10013 			{ 0x20, AC_VERB_SET_PROC_COEF, 0xf },
10014 			{ 0x20, AC_VERB_SET_PROC_COEF, 0x0 },
10015 			{ 0x20, AC_VERB_SET_PROC_COEF, 0x42 },
10016 			{ 0x20, AC_VERB_SET_PROC_COEF, 0xb020 },
10017 
10018 			{ 0x20, AC_VERB_SET_COEF_INDEX, 0x26 },
10019 			{ 0x20, AC_VERB_SET_PROC_COEF, 0x10 },
10020 			{ 0x20, AC_VERB_SET_PROC_COEF, 0x0 },
10021 			{ 0x20, AC_VERB_SET_PROC_COEF, 0x40 },
10022 			{ 0x20, AC_VERB_SET_PROC_COEF, 0xb020 },
10023 
10024 			{ 0x20, AC_VERB_SET_COEF_INDEX, 0x26 },
10025 			{ 0x20, AC_VERB_SET_PROC_COEF, 0x2 },
10026 			{ 0x20, AC_VERB_SET_PROC_COEF, 0x0 },
10027 			{ 0x20, AC_VERB_SET_PROC_COEF, 0x0 },
10028 			{ 0x20, AC_VERB_SET_PROC_COEF, 0xb020 },
10029 
10030 			// enable right speaker
10031 			{ 0x20, AC_VERB_SET_COEF_INDEX, 0x24 },
10032 			{ 0x20, AC_VERB_SET_PROC_COEF, 0x46 },
10033 
10034 			{ 0x20, AC_VERB_SET_COEF_INDEX, 0x26 },
10035 			{ 0x20, AC_VERB_SET_PROC_COEF, 0xc },
10036 			{ 0x20, AC_VERB_SET_PROC_COEF, 0x0 },
10037 			{ 0x20, AC_VERB_SET_PROC_COEF, 0x2a },
10038 			{ 0x20, AC_VERB_SET_PROC_COEF, 0xb020 },
10039 
10040 			{ 0x20, AC_VERB_SET_COEF_INDEX, 0x26 },
10041 			{ 0x20, AC_VERB_SET_PROC_COEF, 0xf },
10042 			{ 0x20, AC_VERB_SET_PROC_COEF, 0x0 },
10043 			{ 0x20, AC_VERB_SET_PROC_COEF, 0x46 },
10044 			{ 0x20, AC_VERB_SET_PROC_COEF, 0xb020 },
10045 
10046 			{ 0x20, AC_VERB_SET_COEF_INDEX, 0x26 },
10047 			{ 0x20, AC_VERB_SET_PROC_COEF, 0x10 },
10048 			{ 0x20, AC_VERB_SET_PROC_COEF, 0x0 },
10049 			{ 0x20, AC_VERB_SET_PROC_COEF, 0x44 },
10050 			{ 0x20, AC_VERB_SET_PROC_COEF, 0xb020 },
10051 
10052 			{ 0x20, AC_VERB_SET_COEF_INDEX, 0x26 },
10053 			{ 0x20, AC_VERB_SET_PROC_COEF, 0x2 },
10054 			{ 0x20, AC_VERB_SET_PROC_COEF, 0x0 },
10055 			{ 0x20, AC_VERB_SET_PROC_COEF, 0x0 },
10056 			{ 0x20, AC_VERB_SET_PROC_COEF, 0xb020 },
10057 
10058 			{ },
10059 		},
10060 	},
10061 	[ALC287_FIXUP_YOGA9_14IAP7_BASS_SPK_PIN] = {
10062 		.type = HDA_FIXUP_FUNC,
10063 		.v.func = alc287_fixup_yoga9_14iap7_bass_spk_pin,
10064 		.chained = true,
10065 		.chain_id = ALC287_FIXUP_YOGA9_14IAP7_BASS_SPK,
10066 	},
10067 	[ALC287_FIXUP_YOGA9_14IMH9_BASS_SPK_PIN] = {
10068 		.type = HDA_FIXUP_FUNC,
10069 		.v.func = alc287_fixup_yoga9_14iap7_bass_spk_pin,
10070 		.chained = true,
10071 		.chain_id = ALC287_FIXUP_CS35L41_I2C_2,
10072 	},
10073 	[ALC295_FIXUP_DELL_INSPIRON_TOP_SPEAKERS] = {
10074 		.type = HDA_FIXUP_FUNC,
10075 		.v.func = alc295_fixup_dell_inspiron_top_speakers,
10076 		.chained = true,
10077 		.chain_id = ALC269_FIXUP_DELL4_MIC_NO_PRESENCE,
10078 	},
10079 	[ALC236_FIXUP_DELL_DUAL_CODECS] = {
10080 		.type = HDA_FIXUP_PINS,
10081 		.v.func = alc1220_fixup_gb_dual_codecs,
10082 		.chained = true,
10083 		.chain_id = ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
10084 	},
10085 	[ALC287_FIXUP_CS35L41_I2C_2_THINKPAD_ACPI] = {
10086 		.type = HDA_FIXUP_FUNC,
10087 		.v.func = cs35l41_fixup_i2c_two,
10088 		.chained = true,
10089 		.chain_id = ALC285_FIXUP_THINKPAD_NO_BASS_SPK_HEADSET_JACK,
10090 	},
10091 	[ALC287_FIXUP_TAS2781_I2C] = {
10092 		.type = HDA_FIXUP_FUNC,
10093 		.v.func = tas2781_fixup_i2c,
10094 		.chained = true,
10095 		.chain_id = ALC285_FIXUP_THINKPAD_HEADSET_JACK,
10096 	},
10097 	[ALC245_FIXUP_TAS2781_SPI_2] = {
10098 		.type = HDA_FIXUP_FUNC,
10099 		.v.func = tas2781_fixup_spi,
10100 		.chained = true,
10101 		.chain_id = ALC285_FIXUP_HP_GPIO_LED,
10102 	},
10103 	[ALC287_FIXUP_YOGA7_14ARB7_I2C] = {
10104 		.type = HDA_FIXUP_FUNC,
10105 		.v.func = yoga7_14arb7_fixup_i2c,
10106 		.chained = true,
10107 		.chain_id = ALC285_FIXUP_THINKPAD_HEADSET_JACK,
10108 	},
10109 	[ALC245_FIXUP_HP_MUTE_LED_COEFBIT] = {
10110 		.type = HDA_FIXUP_FUNC,
10111 		.v.func = alc245_fixup_hp_mute_led_coefbit,
10112 	},
10113 	[ALC245_FIXUP_HP_X360_MUTE_LEDS] = {
10114 		.type = HDA_FIXUP_FUNC,
10115 		.v.func = alc245_fixup_hp_mute_led_coefbit,
10116 		.chained = true,
10117 		.chain_id = ALC245_FIXUP_HP_GPIO_LED
10118 	},
10119 	[ALC287_FIXUP_THINKPAD_I2S_SPK] = {
10120 		.type = HDA_FIXUP_FUNC,
10121 		.v.func = alc287_fixup_bind_dacs,
10122 		.chained = true,
10123 		.chain_id = ALC285_FIXUP_THINKPAD_NO_BASS_SPK_HEADSET_JACK,
10124 	},
10125 	[ALC287_FIXUP_MG_RTKC_CSAMP_CS35L41_I2C_THINKPAD] = {
10126 		.type = HDA_FIXUP_FUNC,
10127 		.v.func = alc287_fixup_bind_dacs,
10128 		.chained = true,
10129 		.chain_id = ALC287_FIXUP_CS35L41_I2C_2_THINKPAD_ACPI,
10130 	},
10131 	[ALC2XX_FIXUP_HEADSET_MIC] = {
10132 		.type = HDA_FIXUP_FUNC,
10133 		.v.func = alc_fixup_headset_mic,
10134 	},
10135 	[ALC289_FIXUP_DELL_CS35L41_SPI_2] = {
10136 		.type = HDA_FIXUP_FUNC,
10137 		.v.func = cs35l41_fixup_spi_two,
10138 		.chained = true,
10139 		.chain_id = ALC289_FIXUP_DUAL_SPK
10140 	},
10141 	[ALC294_FIXUP_CS35L41_I2C_2] = {
10142 		.type = HDA_FIXUP_FUNC,
10143 		.v.func = cs35l41_fixup_i2c_two,
10144 	},
10145 	[ALC256_FIXUP_ACER_SFG16_MICMUTE_LED] = {
10146 		.type = HDA_FIXUP_FUNC,
10147 		.v.func = alc256_fixup_acer_sfg16_micmute_led,
10148 	},
10149 	[ALC256_FIXUP_HEADPHONE_AMP_VOL] = {
10150 		.type = HDA_FIXUP_FUNC,
10151 		.v.func = alc256_decrease_headphone_amp_val,
10152 	},
10153 	[ALC245_FIXUP_HP_SPECTRE_X360_EU0XXX] = {
10154 		.type = HDA_FIXUP_FUNC,
10155 		.v.func = alc245_fixup_hp_spectre_x360_eu0xxx,
10156 	},
10157 	[ALC245_FIXUP_HP_SPECTRE_X360_16_AA0XXX] = {
10158 		.type = HDA_FIXUP_FUNC,
10159 		.v.func = alc245_fixup_hp_spectre_x360_16_aa0xxx,
10160 	},
10161 	[ALC285_FIXUP_ASUS_GA403U] = {
10162 		.type = HDA_FIXUP_FUNC,
10163 		.v.func = alc285_fixup_asus_ga403u,
10164 	},
10165 	[ALC285_FIXUP_ASUS_GA403U_HEADSET_MIC] = {
10166 		.type = HDA_FIXUP_PINS,
10167 		.v.pins = (const struct hda_pintbl[]) {
10168 			{ 0x19, 0x03a11050 },
10169 			{ 0x1b, 0x03a11c30 },
10170 			{ }
10171 		},
10172 		.chained = true,
10173 		.chain_id = ALC285_FIXUP_ASUS_GA403U_I2C_SPEAKER2_TO_DAC1
10174 	},
10175 	[ALC285_FIXUP_ASUS_GU605_SPI_SPEAKER2_TO_DAC1] = {
10176 		.type = HDA_FIXUP_FUNC,
10177 		.v.func = alc285_fixup_speaker2_to_dac1,
10178 		.chained = true,
10179 		.chain_id = ALC285_FIXUP_ASUS_GU605_SPI_2_HEADSET_MIC,
10180 	},
10181 	[ALC285_FIXUP_ASUS_GU605_SPI_2_HEADSET_MIC] = {
10182 		.type = HDA_FIXUP_PINS,
10183 		.v.pins = (const struct hda_pintbl[]) {
10184 			{ 0x19, 0x03a11050 },
10185 			{ 0x1b, 0x03a11c30 },
10186 			{ }
10187 		},
10188 	},
10189 	[ALC285_FIXUP_ASUS_GA403U_I2C_SPEAKER2_TO_DAC1] = {
10190 		.type = HDA_FIXUP_FUNC,
10191 		.v.func = alc285_fixup_speaker2_to_dac1,
10192 		.chained = true,
10193 		.chain_id = ALC285_FIXUP_ASUS_GA403U,
10194 	},
10195 	[ALC287_FIXUP_LENOVO_THKPAD_WH_ALC1318] = {
10196 		.type = HDA_FIXUP_FUNC,
10197 		.v.func = alc287_fixup_lenovo_thinkpad_with_alc1318,
10198 		.chained = true,
10199 		.chain_id = ALC269_FIXUP_THINKPAD_ACPI
10200 	},
10201 	[ALC256_FIXUP_CHROME_BOOK] = {
10202 		.type = HDA_FIXUP_FUNC,
10203 		.v.func = alc256_fixup_chromebook,
10204 		.chained = true,
10205 		.chain_id = ALC225_FIXUP_HEADSET_JACK
10206 	},
10207 	[ALC245_FIXUP_CLEVO_NOISY_MIC] = {
10208 		.type = HDA_FIXUP_FUNC,
10209 		.v.func = alc269_fixup_limit_int_mic_boost,
10210 		.chained = true,
10211 		.chain_id = ALC256_FIXUP_SYSTEM76_MIC_NO_PRESENCE,
10212 	},
10213 	[ALC269_FIXUP_VAIO_VJFH52_MIC_NO_PRESENCE] = {
10214 		.type = HDA_FIXUP_PINS,
10215 		.v.pins = (const struct hda_pintbl[]) {
10216 			{ 0x19, 0x03a1113c }, /* use as headset mic, without its own jack detect */
10217 			{ 0x1b, 0x20a11040 }, /* dock mic */
10218 			{ }
10219 		},
10220 		.chained = true,
10221 		.chain_id = ALC269_FIXUP_LIMIT_INT_MIC_BOOST
10222 	},
10223 	[ALC233_FIXUP_MEDION_MTL_SPK] = {
10224 		.type = HDA_FIXUP_PINS,
10225 		.v.pins = (const struct hda_pintbl[]) {
10226 			{ 0x1b, 0x90170110 },
10227 			{ }
10228 		},
10229 	},
10230 	[ALC294_FIXUP_BASS_SPEAKER_15] = {
10231 		.type = HDA_FIXUP_FUNC,
10232 		.v.func = alc294_fixup_bass_speaker_15,
10233 	},
10234 	[ALC283_FIXUP_DELL_HP_RESUME] = {
10235 		.type = HDA_FIXUP_FUNC,
10236 		.v.func = alc283_fixup_dell_hp_resume,
10237 	},
10238 };
10239 
10240 static const struct hda_quirk alc269_fixup_tbl[] = {
10241 	SND_PCI_QUIRK(0x1025, 0x0283, "Acer TravelMate 8371", ALC269_FIXUP_INV_DMIC),
10242 	SND_PCI_QUIRK(0x1025, 0x029b, "Acer 1810TZ", ALC269_FIXUP_INV_DMIC),
10243 	SND_PCI_QUIRK(0x1025, 0x0349, "Acer AOD260", ALC269_FIXUP_INV_DMIC),
10244 	SND_PCI_QUIRK(0x1025, 0x047c, "Acer AC700", ALC269_FIXUP_ACER_AC700),
10245 	SND_PCI_QUIRK(0x1025, 0x072d, "Acer Aspire V5-571G", ALC269_FIXUP_ASPIRE_HEADSET_MIC),
10246 	SND_PCI_QUIRK(0x1025, 0x0740, "Acer AO725", ALC271_FIXUP_HP_GATE_MIC_JACK),
10247 	SND_PCI_QUIRK(0x1025, 0x0742, "Acer AO756", ALC271_FIXUP_HP_GATE_MIC_JACK),
10248 	SND_PCI_QUIRK(0x1025, 0x0762, "Acer Aspire E1-472", ALC271_FIXUP_HP_GATE_MIC_JACK_E1_572),
10249 	SND_PCI_QUIRK(0x1025, 0x0775, "Acer Aspire E1-572", ALC271_FIXUP_HP_GATE_MIC_JACK_E1_572),
10250 	SND_PCI_QUIRK(0x1025, 0x079b, "Acer Aspire V5-573G", ALC282_FIXUP_ASPIRE_V5_PINS),
10251 	SND_PCI_QUIRK(0x1025, 0x080d, "Acer Aspire V5-122P", ALC269_FIXUP_ASPIRE_HEADSET_MIC),
10252 	SND_PCI_QUIRK(0x1025, 0x0840, "Acer Aspire E1", ALC269VB_FIXUP_ASPIRE_E1_COEF),
10253 	SND_PCI_QUIRK(0x1025, 0x100c, "Acer Aspire E5-574G", ALC255_FIXUP_ACER_LIMIT_INT_MIC_BOOST),
10254 	SND_PCI_QUIRK(0x1025, 0x101c, "Acer Veriton N2510G", ALC269_FIXUP_LIFEBOOK),
10255 	SND_PCI_QUIRK(0x1025, 0x102b, "Acer Aspire C24-860", ALC286_FIXUP_ACER_AIO_MIC_NO_PRESENCE),
10256 	SND_PCI_QUIRK(0x1025, 0x1065, "Acer Aspire C20-820", ALC269VC_FIXUP_ACER_HEADSET_MIC),
10257 	SND_PCI_QUIRK(0x1025, 0x106d, "Acer Cloudbook 14", ALC283_FIXUP_CHROME_BOOK),
10258 	SND_PCI_QUIRK(0x1025, 0x1094, "Acer Aspire E5-575T", ALC255_FIXUP_ACER_LIMIT_INT_MIC_BOOST),
10259 	SND_PCI_QUIRK(0x1025, 0x1099, "Acer Aspire E5-523G", ALC255_FIXUP_ACER_MIC_NO_PRESENCE),
10260 	SND_PCI_QUIRK(0x1025, 0x110e, "Acer Aspire ES1-432", ALC255_FIXUP_ACER_MIC_NO_PRESENCE),
10261 	SND_PCI_QUIRK(0x1025, 0x1166, "Acer Veriton N4640G", ALC269_FIXUP_LIFEBOOK),
10262 	SND_PCI_QUIRK(0x1025, 0x1167, "Acer Veriton N6640G", ALC269_FIXUP_LIFEBOOK),
10263 	SND_PCI_QUIRK(0x1025, 0x1177, "Acer Predator G9-593", ALC255_FIXUP_PREDATOR_SUBWOOFER),
10264 	SND_PCI_QUIRK(0x1025, 0x1178, "Acer Predator G9-593", ALC255_FIXUP_PREDATOR_SUBWOOFER),
10265 	SND_PCI_QUIRK(0x1025, 0x1246, "Acer Predator Helios 500", ALC299_FIXUP_PREDATOR_SPK),
10266 	SND_PCI_QUIRK(0x1025, 0x1247, "Acer vCopperbox", ALC269VC_FIXUP_ACER_VCOPPERBOX_PINS),
10267 	SND_PCI_QUIRK(0x1025, 0x1248, "Acer Veriton N4660G", ALC269VC_FIXUP_ACER_MIC_NO_PRESENCE),
10268 	SND_PCI_QUIRK(0x1025, 0x1269, "Acer SWIFT SF314-54", ALC256_FIXUP_ACER_HEADSET_MIC),
10269 	SND_PCI_QUIRK(0x1025, 0x126a, "Acer Swift SF114-32", ALC256_FIXUP_ACER_MIC_NO_PRESENCE),
10270 	SND_PCI_QUIRK(0x1025, 0x128f, "Acer Veriton Z6860G", ALC286_FIXUP_ACER_AIO_HEADSET_MIC),
10271 	SND_PCI_QUIRK(0x1025, 0x1290, "Acer Veriton Z4860G", ALC286_FIXUP_ACER_AIO_HEADSET_MIC),
10272 	SND_PCI_QUIRK(0x1025, 0x1291, "Acer Veriton Z4660G", ALC286_FIXUP_ACER_AIO_HEADSET_MIC),
10273 	SND_PCI_QUIRK(0x1025, 0x129c, "Acer SWIFT SF314-55", ALC256_FIXUP_ACER_HEADSET_MIC),
10274 	SND_PCI_QUIRK(0x1025, 0x129d, "Acer SWIFT SF313-51", ALC256_FIXUP_ACER_MIC_NO_PRESENCE),
10275 	SND_PCI_QUIRK(0x1025, 0x1300, "Acer SWIFT SF314-56", ALC256_FIXUP_ACER_MIC_NO_PRESENCE),
10276 	SND_PCI_QUIRK(0x1025, 0x1308, "Acer Aspire Z24-890", ALC286_FIXUP_ACER_AIO_HEADSET_MIC),
10277 	SND_PCI_QUIRK(0x1025, 0x132a, "Acer TravelMate B114-21", ALC233_FIXUP_ACER_HEADSET_MIC),
10278 	SND_PCI_QUIRK(0x1025, 0x1330, "Acer TravelMate X514-51T", ALC255_FIXUP_ACER_HEADSET_MIC),
10279 	SND_PCI_QUIRK(0x1025, 0x1360, "Acer Aspire A115", ALC255_FIXUP_ACER_MIC_NO_PRESENCE),
10280 	SND_PCI_QUIRK(0x1025, 0x141f, "Acer Spin SP513-54N", ALC255_FIXUP_ACER_MIC_NO_PRESENCE),
10281 	SND_PCI_QUIRK(0x1025, 0x142b, "Acer Swift SF314-42", ALC255_FIXUP_ACER_MIC_NO_PRESENCE),
10282 	SND_PCI_QUIRK(0x1025, 0x1430, "Acer TravelMate B311R-31", ALC256_FIXUP_ACER_MIC_NO_PRESENCE),
10283 	SND_PCI_QUIRK(0x1025, 0x1466, "Acer Aspire A515-56", ALC255_FIXUP_ACER_HEADPHONE_AND_MIC),
10284 	SND_PCI_QUIRK(0x1025, 0x1534, "Acer Predator PH315-54", ALC255_FIXUP_ACER_MIC_NO_PRESENCE),
10285 	SND_PCI_QUIRK(0x1025, 0x159c, "Acer Nitro 5 AN515-58", ALC2XX_FIXUP_HEADSET_MIC),
10286 	SND_PCI_QUIRK(0x1025, 0x169a, "Acer Swift SFG16", ALC256_FIXUP_ACER_SFG16_MICMUTE_LED),
10287 	SND_PCI_QUIRK(0x1028, 0x0470, "Dell M101z", ALC269_FIXUP_DELL_M101Z),
10288 	SND_PCI_QUIRK(0x1028, 0x053c, "Dell Latitude E5430", ALC292_FIXUP_DELL_E7X),
10289 	SND_PCI_QUIRK(0x1028, 0x054b, "Dell XPS one 2710", ALC275_FIXUP_DELL_XPS),
10290 	SND_PCI_QUIRK(0x1028, 0x05bd, "Dell Latitude E6440", ALC292_FIXUP_DELL_E7X),
10291 	SND_PCI_QUIRK(0x1028, 0x05be, "Dell Latitude E6540", ALC292_FIXUP_DELL_E7X),
10292 	SND_PCI_QUIRK(0x1028, 0x05ca, "Dell Latitude E7240", ALC292_FIXUP_DELL_E7X),
10293 	SND_PCI_QUIRK(0x1028, 0x05cb, "Dell Latitude E7440", ALC292_FIXUP_DELL_E7X),
10294 	SND_PCI_QUIRK(0x1028, 0x05da, "Dell Vostro 5460", ALC290_FIXUP_SUBWOOFER),
10295 	SND_PCI_QUIRK(0x1028, 0x05f4, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE),
10296 	SND_PCI_QUIRK(0x1028, 0x05f5, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE),
10297 	SND_PCI_QUIRK(0x1028, 0x05f6, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE),
10298 	SND_PCI_QUIRK(0x1028, 0x0604, "Dell Venue 11 Pro 7130", ALC283_FIXUP_DELL_HP_RESUME),
10299 	SND_PCI_QUIRK(0x1028, 0x0615, "Dell Vostro 5470", ALC290_FIXUP_SUBWOOFER_HSJACK),
10300 	SND_PCI_QUIRK(0x1028, 0x0616, "Dell Vostro 5470", ALC290_FIXUP_SUBWOOFER_HSJACK),
10301 	SND_PCI_QUIRK(0x1028, 0x062c, "Dell Latitude E5550", ALC292_FIXUP_DELL_E7X),
10302 	SND_PCI_QUIRK(0x1028, 0x062e, "Dell Latitude E7450", ALC292_FIXUP_DELL_E7X),
10303 	SND_PCI_QUIRK(0x1028, 0x0638, "Dell Inspiron 5439", ALC290_FIXUP_MONO_SPEAKERS_HSJACK),
10304 	SND_PCI_QUIRK(0x1028, 0x064a, "Dell", ALC293_FIXUP_DELL1_MIC_NO_PRESENCE),
10305 	SND_PCI_QUIRK(0x1028, 0x064b, "Dell", ALC293_FIXUP_DELL1_MIC_NO_PRESENCE),
10306 	SND_PCI_QUIRK(0x1028, 0x0665, "Dell XPS 13", ALC288_FIXUP_DELL_XPS_13),
10307 	SND_PCI_QUIRK(0x1028, 0x0669, "Dell Optiplex 9020m", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE),
10308 	SND_PCI_QUIRK(0x1028, 0x069a, "Dell Vostro 5480", ALC290_FIXUP_SUBWOOFER_HSJACK),
10309 	SND_PCI_QUIRK(0x1028, 0x06c7, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE),
10310 	SND_PCI_QUIRK(0x1028, 0x06d9, "Dell", ALC293_FIXUP_DELL1_MIC_NO_PRESENCE),
10311 	SND_PCI_QUIRK(0x1028, 0x06da, "Dell", ALC293_FIXUP_DELL1_MIC_NO_PRESENCE),
10312 	SND_PCI_QUIRK(0x1028, 0x06db, "Dell", ALC293_FIXUP_DISABLE_AAMIX_MULTIJACK),
10313 	SND_PCI_QUIRK(0x1028, 0x06dd, "Dell", ALC293_FIXUP_DISABLE_AAMIX_MULTIJACK),
10314 	SND_PCI_QUIRK(0x1028, 0x06de, "Dell", ALC293_FIXUP_DISABLE_AAMIX_MULTIJACK),
10315 	SND_PCI_QUIRK(0x1028, 0x06df, "Dell", ALC293_FIXUP_DISABLE_AAMIX_MULTIJACK),
10316 	SND_PCI_QUIRK(0x1028, 0x06e0, "Dell", ALC293_FIXUP_DISABLE_AAMIX_MULTIJACK),
10317 	SND_PCI_QUIRK(0x1028, 0x0706, "Dell Inspiron 7559", ALC256_FIXUP_DELL_INSPIRON_7559_SUBWOOFER),
10318 	SND_PCI_QUIRK(0x1028, 0x0725, "Dell Inspiron 3162", ALC255_FIXUP_DELL_SPK_NOISE),
10319 	SND_PCI_QUIRK(0x1028, 0x0738, "Dell Precision 5820", ALC269_FIXUP_NO_SHUTUP),
10320 	SND_PCI_QUIRK(0x1028, 0x075c, "Dell XPS 27 7760", ALC298_FIXUP_SPK_VOLUME),
10321 	SND_PCI_QUIRK(0x1028, 0x075d, "Dell AIO", ALC298_FIXUP_SPK_VOLUME),
10322 	SND_PCI_QUIRK(0x1028, 0x0798, "Dell Inspiron 17 7000 Gaming", ALC256_FIXUP_DELL_INSPIRON_7559_SUBWOOFER),
10323 	SND_PCI_QUIRK(0x1028, 0x07b0, "Dell Precision 7520", ALC295_FIXUP_DISABLE_DAC3),
10324 	SND_PCI_QUIRK(0x1028, 0x080c, "Dell WYSE", ALC225_FIXUP_DELL_WYSE_MIC_NO_PRESENCE),
10325 	SND_PCI_QUIRK(0x1028, 0x084b, "Dell", ALC274_FIXUP_DELL_AIO_LINEOUT_VERB),
10326 	SND_PCI_QUIRK(0x1028, 0x084e, "Dell", ALC274_FIXUP_DELL_AIO_LINEOUT_VERB),
10327 	SND_PCI_QUIRK(0x1028, 0x0871, "Dell Precision 3630", ALC255_FIXUP_DELL_HEADSET_MIC),
10328 	SND_PCI_QUIRK(0x1028, 0x0872, "Dell Precision 3630", ALC255_FIXUP_DELL_HEADSET_MIC),
10329 	SND_PCI_QUIRK(0x1028, 0x0873, "Dell Precision 3930", ALC255_FIXUP_DUMMY_LINEOUT_VERB),
10330 	SND_PCI_QUIRK(0x1028, 0x08ad, "Dell WYSE AIO", ALC225_FIXUP_DELL_WYSE_AIO_MIC_NO_PRESENCE),
10331 	SND_PCI_QUIRK(0x1028, 0x08ae, "Dell WYSE NB", ALC225_FIXUP_DELL1_MIC_NO_PRESENCE),
10332 	SND_PCI_QUIRK(0x1028, 0x0935, "Dell", ALC274_FIXUP_DELL_AIO_LINEOUT_VERB),
10333 	SND_PCI_QUIRK(0x1028, 0x097d, "Dell Precision", ALC289_FIXUP_DUAL_SPK),
10334 	SND_PCI_QUIRK(0x1028, 0x097e, "Dell Precision", ALC289_FIXUP_DUAL_SPK),
10335 	SND_PCI_QUIRK(0x1028, 0x098d, "Dell Precision", ALC233_FIXUP_ASUS_MIC_NO_PRESENCE),
10336 	SND_PCI_QUIRK(0x1028, 0x09bf, "Dell Precision", ALC233_FIXUP_ASUS_MIC_NO_PRESENCE),
10337 	SND_PCI_QUIRK(0x1028, 0x0a2e, "Dell", ALC236_FIXUP_DELL_AIO_HEADSET_MIC),
10338 	SND_PCI_QUIRK(0x1028, 0x0a30, "Dell", ALC236_FIXUP_DELL_AIO_HEADSET_MIC),
10339 	SND_PCI_QUIRK(0x1028, 0x0a38, "Dell Latitude 7520", ALC269_FIXUP_DELL4_MIC_NO_PRESENCE_QUIET),
10340 	SND_PCI_QUIRK(0x1028, 0x0a58, "Dell", ALC255_FIXUP_DELL_HEADSET_MIC),
10341 	SND_PCI_QUIRK(0x1028, 0x0a61, "Dell XPS 15 9510", ALC289_FIXUP_DUAL_SPK),
10342 	SND_PCI_QUIRK(0x1028, 0x0a62, "Dell Precision 5560", ALC289_FIXUP_DUAL_SPK),
10343 	SND_PCI_QUIRK(0x1028, 0x0a9d, "Dell Latitude 5430", ALC269_FIXUP_DELL4_MIC_NO_PRESENCE),
10344 	SND_PCI_QUIRK(0x1028, 0x0a9e, "Dell Latitude 5430", ALC269_FIXUP_DELL4_MIC_NO_PRESENCE),
10345 	SND_PCI_QUIRK(0x1028, 0x0b19, "Dell XPS 15 9520", ALC289_FIXUP_DUAL_SPK),
10346 	SND_PCI_QUIRK(0x1028, 0x0b1a, "Dell Precision 5570", ALC289_FIXUP_DUAL_SPK),
10347 	SND_PCI_QUIRK(0x1028, 0x0b27, "Dell", ALC245_FIXUP_CS35L41_SPI_2),
10348 	SND_PCI_QUIRK(0x1028, 0x0b28, "Dell", ALC245_FIXUP_CS35L41_SPI_2),
10349 	SND_PCI_QUIRK(0x1028, 0x0b37, "Dell Inspiron 16 Plus 7620 2-in-1", ALC295_FIXUP_DELL_INSPIRON_TOP_SPEAKERS),
10350 	SND_PCI_QUIRK(0x1028, 0x0b71, "Dell Inspiron 16 Plus 7620", ALC295_FIXUP_DELL_INSPIRON_TOP_SPEAKERS),
10351 	SND_PCI_QUIRK(0x1028, 0x0beb, "Dell XPS 15 9530 (2023)", ALC289_FIXUP_DELL_CS35L41_SPI_2),
10352 	SND_PCI_QUIRK(0x1028, 0x0c03, "Dell Precision 5340", ALC269_FIXUP_DELL4_MIC_NO_PRESENCE),
10353 	SND_PCI_QUIRK(0x1028, 0x0c0b, "Dell Oasis 14 RPL-P", ALC289_FIXUP_RTK_AMP_DUAL_SPK),
10354 	SND_PCI_QUIRK(0x1028, 0x0c0d, "Dell Oasis", ALC289_FIXUP_RTK_AMP_DUAL_SPK),
10355 	SND_PCI_QUIRK(0x1028, 0x0c0e, "Dell Oasis 16", ALC289_FIXUP_RTK_AMP_DUAL_SPK),
10356 	SND_PCI_QUIRK(0x1028, 0x0c19, "Dell Precision 3340", ALC236_FIXUP_DELL_DUAL_CODECS),
10357 	SND_PCI_QUIRK(0x1028, 0x0c1a, "Dell Precision 3340", ALC236_FIXUP_DELL_DUAL_CODECS),
10358 	SND_PCI_QUIRK(0x1028, 0x0c1b, "Dell Precision 3440", ALC236_FIXUP_DELL_DUAL_CODECS),
10359 	SND_PCI_QUIRK(0x1028, 0x0c1c, "Dell Precision 3540", ALC236_FIXUP_DELL_DUAL_CODECS),
10360 	SND_PCI_QUIRK(0x1028, 0x0c1d, "Dell Precision 3440", ALC236_FIXUP_DELL_DUAL_CODECS),
10361 	SND_PCI_QUIRK(0x1028, 0x0c1e, "Dell Precision 3540", ALC236_FIXUP_DELL_DUAL_CODECS),
10362 	SND_PCI_QUIRK(0x1028, 0x0c28, "Dell Inspiron 16 Plus 7630", ALC295_FIXUP_DELL_INSPIRON_TOP_SPEAKERS),
10363 	SND_PCI_QUIRK(0x1028, 0x0c4d, "Dell", ALC287_FIXUP_CS35L41_I2C_4),
10364 	SND_PCI_QUIRK(0x1028, 0x0c94, "Dell Polaris 3 metal", ALC287_FIXUP_TAS2781_I2C),
10365 	SND_PCI_QUIRK(0x1028, 0x0c96, "Dell Polaris 2in1", ALC287_FIXUP_TAS2781_I2C),
10366 	SND_PCI_QUIRK(0x1028, 0x0cbd, "Dell Oasis 13 CS MTL-U", ALC289_FIXUP_DELL_CS35L41_SPI_2),
10367 	SND_PCI_QUIRK(0x1028, 0x0cbe, "Dell Oasis 13 2-IN-1 MTL-U", ALC289_FIXUP_DELL_CS35L41_SPI_2),
10368 	SND_PCI_QUIRK(0x1028, 0x0cbf, "Dell Oasis 13 Low Weight MTU-L", ALC289_FIXUP_DELL_CS35L41_SPI_2),
10369 	SND_PCI_QUIRK(0x1028, 0x0cc0, "Dell Oasis 13", ALC289_FIXUP_RTK_AMP_DUAL_SPK),
10370 	SND_PCI_QUIRK(0x1028, 0x0cc1, "Dell Oasis 14 MTL-H/U", ALC289_FIXUP_DELL_CS35L41_SPI_2),
10371 	SND_PCI_QUIRK(0x1028, 0x0cc2, "Dell Oasis 14 2-in-1 MTL-H/U", ALC289_FIXUP_DELL_CS35L41_SPI_2),
10372 	SND_PCI_QUIRK(0x1028, 0x0cc3, "Dell Oasis 14 Low Weight MTL-U", ALC289_FIXUP_DELL_CS35L41_SPI_2),
10373 	SND_PCI_QUIRK(0x1028, 0x0cc4, "Dell Oasis 16 MTL-H/U", ALC289_FIXUP_DELL_CS35L41_SPI_2),
10374 	SND_PCI_QUIRK(0x1028, 0x0cc5, "Dell Oasis 14", ALC289_FIXUP_RTK_AMP_DUAL_SPK),
10375 	SND_PCI_QUIRK(0x1028, 0x164a, "Dell", ALC293_FIXUP_DELL1_MIC_NO_PRESENCE),
10376 	SND_PCI_QUIRK(0x1028, 0x164b, "Dell", ALC293_FIXUP_DELL1_MIC_NO_PRESENCE),
10377 	SND_PCI_QUIRK(0x103c, 0x1586, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC2),
10378 	SND_PCI_QUIRK(0x103c, 0x18e6, "HP", ALC269_FIXUP_HP_GPIO_LED),
10379 	SND_PCI_QUIRK(0x103c, 0x218b, "HP", ALC269_FIXUP_LIMIT_INT_MIC_BOOST_MUTE_LED),
10380 	SND_PCI_QUIRK(0x103c, 0x21f9, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
10381 	SND_PCI_QUIRK(0x103c, 0x2210, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
10382 	SND_PCI_QUIRK(0x103c, 0x2214, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
10383 	SND_PCI_QUIRK(0x103c, 0x221b, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),
10384 	SND_PCI_QUIRK(0x103c, 0x221c, "HP EliteBook 755 G2", ALC280_FIXUP_HP_HEADSET_MIC),
10385 	SND_PCI_QUIRK(0x103c, 0x2221, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),
10386 	SND_PCI_QUIRK(0x103c, 0x2225, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),
10387 	SND_PCI_QUIRK(0x103c, 0x2236, "HP", ALC269_FIXUP_HP_LINE1_MIC1_LED),
10388 	SND_PCI_QUIRK(0x103c, 0x2237, "HP", ALC269_FIXUP_HP_LINE1_MIC1_LED),
10389 	SND_PCI_QUIRK(0x103c, 0x2238, "HP", ALC269_FIXUP_HP_LINE1_MIC1_LED),
10390 	SND_PCI_QUIRK(0x103c, 0x2239, "HP", ALC269_FIXUP_HP_LINE1_MIC1_LED),
10391 	SND_PCI_QUIRK(0x103c, 0x224b, "HP", ALC269_FIXUP_HP_LINE1_MIC1_LED),
10392 	SND_PCI_QUIRK(0x103c, 0x2253, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),
10393 	SND_PCI_QUIRK(0x103c, 0x2254, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),
10394 	SND_PCI_QUIRK(0x103c, 0x2255, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),
10395 	SND_PCI_QUIRK(0x103c, 0x2256, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),
10396 	SND_PCI_QUIRK(0x103c, 0x2257, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),
10397 	SND_PCI_QUIRK(0x103c, 0x2259, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),
10398 	SND_PCI_QUIRK(0x103c, 0x225a, "HP", ALC269_FIXUP_HP_DOCK_GPIO_MIC1_LED),
10399 	SND_PCI_QUIRK(0x103c, 0x225f, "HP", ALC280_FIXUP_HP_GPIO2_MIC_HOTKEY),
10400 	SND_PCI_QUIRK(0x103c, 0x2260, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
10401 	SND_PCI_QUIRK(0x103c, 0x2263, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
10402 	SND_PCI_QUIRK(0x103c, 0x2264, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
10403 	SND_PCI_QUIRK(0x103c, 0x2265, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
10404 	SND_PCI_QUIRK(0x103c, 0x2268, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
10405 	SND_PCI_QUIRK(0x103c, 0x226a, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
10406 	SND_PCI_QUIRK(0x103c, 0x226b, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
10407 	SND_PCI_QUIRK(0x103c, 0x226e, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
10408 	SND_PCI_QUIRK(0x103c, 0x2271, "HP", ALC286_FIXUP_HP_GPIO_LED),
10409 	SND_PCI_QUIRK(0x103c, 0x2272, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),
10410 	SND_PCI_QUIRK(0x103c, 0x2272, "HP", ALC280_FIXUP_HP_DOCK_PINS),
10411 	SND_PCI_QUIRK(0x103c, 0x2273, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),
10412 	SND_PCI_QUIRK(0x103c, 0x2273, "HP", ALC280_FIXUP_HP_DOCK_PINS),
10413 	SND_PCI_QUIRK(0x103c, 0x2278, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),
10414 	SND_PCI_QUIRK(0x103c, 0x227f, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
10415 	SND_PCI_QUIRK(0x103c, 0x2282, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
10416 	SND_PCI_QUIRK(0x103c, 0x228b, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
10417 	SND_PCI_QUIRK(0x103c, 0x228e, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
10418 	SND_PCI_QUIRK(0x103c, 0x229e, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
10419 	SND_PCI_QUIRK(0x103c, 0x22b2, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
10420 	SND_PCI_QUIRK(0x103c, 0x22b7, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
10421 	SND_PCI_QUIRK(0x103c, 0x22bf, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
10422 	SND_PCI_QUIRK(0x103c, 0x22c4, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
10423 	SND_PCI_QUIRK(0x103c, 0x22c5, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
10424 	SND_PCI_QUIRK(0x103c, 0x22c7, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
10425 	SND_PCI_QUIRK(0x103c, 0x22c8, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
10426 	SND_PCI_QUIRK(0x103c, 0x22cf, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
10427 	SND_PCI_QUIRK(0x103c, 0x22db, "HP", ALC280_FIXUP_HP_9480M),
10428 	SND_PCI_QUIRK(0x103c, 0x22dc, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),
10429 	SND_PCI_QUIRK(0x103c, 0x22fb, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),
10430 	SND_PCI_QUIRK(0x103c, 0x2334, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
10431 	SND_PCI_QUIRK(0x103c, 0x2335, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
10432 	SND_PCI_QUIRK(0x103c, 0x2336, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
10433 	SND_PCI_QUIRK(0x103c, 0x2337, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
10434 	SND_PCI_QUIRK(0x103c, 0x2b5e, "HP 288 Pro G2 MT", ALC221_FIXUP_HP_288PRO_MIC_NO_PRESENCE),
10435 	SND_PCI_QUIRK(0x103c, 0x802e, "HP Z240 SFF", ALC221_FIXUP_HP_MIC_NO_PRESENCE),
10436 	SND_PCI_QUIRK(0x103c, 0x802f, "HP Z240", ALC221_FIXUP_HP_MIC_NO_PRESENCE),
10437 	SND_PCI_QUIRK(0x103c, 0x8077, "HP", ALC256_FIXUP_HP_HEADSET_MIC),
10438 	SND_PCI_QUIRK(0x103c, 0x8158, "HP", ALC256_FIXUP_HP_HEADSET_MIC),
10439 	SND_PCI_QUIRK(0x103c, 0x820d, "HP Pavilion 15", ALC295_FIXUP_HP_X360),
10440 	SND_PCI_QUIRK(0x103c, 0x8256, "HP", ALC221_FIXUP_HP_FRONT_MIC),
10441 	SND_PCI_QUIRK(0x103c, 0x827e, "HP x360", ALC295_FIXUP_HP_X360),
10442 	SND_PCI_QUIRK(0x103c, 0x827f, "HP x360", ALC269_FIXUP_HP_MUTE_LED_MIC3),
10443 	SND_PCI_QUIRK(0x103c, 0x82bf, "HP G3 mini", ALC221_FIXUP_HP_MIC_NO_PRESENCE),
10444 	SND_PCI_QUIRK(0x103c, 0x82c0, "HP G3 mini premium", ALC221_FIXUP_HP_MIC_NO_PRESENCE),
10445 	SND_PCI_QUIRK(0x103c, 0x83b9, "HP Spectre x360", ALC269_FIXUP_HP_MUTE_LED_MIC3),
10446 	SND_PCI_QUIRK(0x103c, 0x841c, "HP Pavilion 15-CK0xx", ALC269_FIXUP_HP_MUTE_LED_MIC3),
10447 	SND_PCI_QUIRK(0x103c, 0x8497, "HP Envy x360", ALC269_FIXUP_HP_MUTE_LED_MIC3),
10448 	SND_PCI_QUIRK(0x103c, 0x84a6, "HP 250 G7 Notebook PC", ALC269_FIXUP_HP_LINE1_MIC1_LED),
10449 	SND_PCI_QUIRK(0x103c, 0x84ae, "HP 15-db0403ng", ALC236_FIXUP_HP_MUTE_LED_COEFBIT2),
10450 	SND_PCI_QUIRK(0x103c, 0x84da, "HP OMEN dc0019-ur", ALC295_FIXUP_HP_OMEN),
10451 	SND_PCI_QUIRK(0x103c, 0x84e7, "HP Pavilion 15", ALC269_FIXUP_HP_MUTE_LED_MIC3),
10452 	SND_PCI_QUIRK(0x103c, 0x8519, "HP Spectre x360 15-df0xxx", ALC285_FIXUP_HP_SPECTRE_X360),
10453 	SND_PCI_QUIRK(0x103c, 0x8537, "HP ProBook 440 G6", ALC236_FIXUP_HP_MUTE_LED_MICMUTE_VREF),
10454 	SND_PCI_QUIRK(0x103c, 0x85de, "HP Envy x360 13-ar0xxx", ALC285_FIXUP_HP_ENVY_X360),
10455 	SND_PCI_QUIRK(0x103c, 0x860f, "HP ZBook 15 G6", ALC285_FIXUP_HP_GPIO_AMP_INIT),
10456 	SND_PCI_QUIRK(0x103c, 0x861f, "HP Elite Dragonfly G1", ALC285_FIXUP_HP_GPIO_AMP_INIT),
10457 	SND_PCI_QUIRK(0x103c, 0x869d, "HP", ALC236_FIXUP_HP_MUTE_LED),
10458 	SND_PCI_QUIRK(0x103c, 0x86c1, "HP Laptop 15-da3001TU", ALC236_FIXUP_HP_MUTE_LED_COEFBIT2),
10459 	SND_PCI_QUIRK(0x103c, 0x86c7, "HP Envy AiO 32", ALC274_FIXUP_HP_ENVY_GPIO),
10460 	SND_PCI_QUIRK(0x103c, 0x86e7, "HP Spectre x360 15-eb0xxx", ALC285_FIXUP_HP_SPECTRE_X360_EB1),
10461 	SND_PCI_QUIRK(0x103c, 0x86e8, "HP Spectre x360 15-eb0xxx", ALC285_FIXUP_HP_SPECTRE_X360_EB1),
10462 	SND_PCI_QUIRK(0x103c, 0x86f9, "HP Spectre x360 13-aw0xxx", ALC285_FIXUP_HP_SPECTRE_X360_MUTE_LED),
10463 	SND_PCI_QUIRK(0x103c, 0x8716, "HP Elite Dragonfly G2 Notebook PC", ALC285_FIXUP_HP_GPIO_AMP_INIT),
10464 	SND_PCI_QUIRK(0x103c, 0x8720, "HP EliteBook x360 1040 G8 Notebook PC", ALC285_FIXUP_HP_GPIO_AMP_INIT),
10465 	SND_PCI_QUIRK(0x103c, 0x8724, "HP EliteBook 850 G7", ALC285_FIXUP_HP_GPIO_LED),
10466 	SND_PCI_QUIRK(0x103c, 0x8728, "HP EliteBook 840 G7", ALC285_FIXUP_HP_GPIO_LED),
10467 	SND_PCI_QUIRK(0x103c, 0x8729, "HP", ALC285_FIXUP_HP_GPIO_LED),
10468 	SND_PCI_QUIRK(0x103c, 0x8730, "HP ProBook 445 G7", ALC236_FIXUP_HP_MUTE_LED_MICMUTE_VREF),
10469 	SND_PCI_QUIRK(0x103c, 0x8735, "HP ProBook 435 G7", ALC236_FIXUP_HP_MUTE_LED_MICMUTE_VREF),
10470 	SND_PCI_QUIRK(0x103c, 0x8736, "HP", ALC285_FIXUP_HP_GPIO_AMP_INIT),
10471 	SND_PCI_QUIRK(0x103c, 0x8760, "HP", ALC285_FIXUP_HP_MUTE_LED),
10472 	SND_PCI_QUIRK(0x103c, 0x876e, "HP ENVY x360 Convertible 13-ay0xxx", ALC245_FIXUP_HP_X360_MUTE_LEDS),
10473 	SND_PCI_QUIRK(0x103c, 0x877a, "HP", ALC285_FIXUP_HP_MUTE_LED),
10474 	SND_PCI_QUIRK(0x103c, 0x877d, "HP", ALC236_FIXUP_HP_MUTE_LED),
10475 	SND_PCI_QUIRK(0x103c, 0x8780, "HP ZBook Fury 17 G7 Mobile Workstation",
10476 		      ALC285_FIXUP_HP_GPIO_AMP_INIT),
10477 	SND_PCI_QUIRK(0x103c, 0x8783, "HP ZBook Fury 15 G7 Mobile Workstation",
10478 		      ALC285_FIXUP_HP_GPIO_AMP_INIT),
10479 	SND_PCI_QUIRK(0x103c, 0x8786, "HP OMEN 15", ALC285_FIXUP_HP_MUTE_LED),
10480 	SND_PCI_QUIRK(0x103c, 0x8787, "HP OMEN 15", ALC285_FIXUP_HP_MUTE_LED),
10481 	SND_PCI_QUIRK(0x103c, 0x8788, "HP OMEN 15", ALC285_FIXUP_HP_MUTE_LED),
10482 	SND_PCI_QUIRK(0x103c, 0x87b7, "HP Laptop 14-fq0xxx", ALC236_FIXUP_HP_MUTE_LED_COEFBIT2),
10483 	SND_PCI_QUIRK(0x103c, 0x87c8, "HP", ALC287_FIXUP_HP_GPIO_LED),
10484 	SND_PCI_QUIRK(0x103c, 0x87d3, "HP Laptop 15-gw0xxx", ALC236_FIXUP_HP_MUTE_LED_COEFBIT2),
10485 	SND_PCI_QUIRK(0x103c, 0x87df, "HP ProBook 430 G8 Notebook PC", ALC236_FIXUP_HP_GPIO_LED),
10486 	SND_PCI_QUIRK(0x103c, 0x87e5, "HP ProBook 440 G8 Notebook PC", ALC236_FIXUP_HP_GPIO_LED),
10487 	SND_PCI_QUIRK(0x103c, 0x87e7, "HP ProBook 450 G8 Notebook PC", ALC236_FIXUP_HP_GPIO_LED),
10488 	SND_PCI_QUIRK(0x103c, 0x87f1, "HP ProBook 630 G8 Notebook PC", ALC236_FIXUP_HP_GPIO_LED),
10489 	SND_PCI_QUIRK(0x103c, 0x87f2, "HP ProBook 640 G8 Notebook PC", ALC236_FIXUP_HP_GPIO_LED),
10490 	SND_PCI_QUIRK(0x103c, 0x87f4, "HP", ALC287_FIXUP_HP_GPIO_LED),
10491 	SND_PCI_QUIRK(0x103c, 0x87f5, "HP", ALC287_FIXUP_HP_GPIO_LED),
10492 	SND_PCI_QUIRK(0x103c, 0x87f6, "HP Spectre x360 14", ALC245_FIXUP_HP_X360_AMP),
10493 	SND_PCI_QUIRK(0x103c, 0x87f7, "HP Spectre x360 14", ALC245_FIXUP_HP_X360_AMP),
10494 	SND_PCI_QUIRK(0x103c, 0x87fd, "HP Laptop 14-dq2xxx", ALC236_FIXUP_HP_MUTE_LED_COEFBIT2),
10495 	SND_PCI_QUIRK(0x103c, 0x87fe, "HP Laptop 15s-fq2xxx", ALC236_FIXUP_HP_MUTE_LED_COEFBIT2),
10496 	SND_PCI_QUIRK(0x103c, 0x8805, "HP ProBook 650 G8 Notebook PC", ALC236_FIXUP_HP_GPIO_LED),
10497 	SND_PCI_QUIRK(0x103c, 0x880d, "HP EliteBook 830 G8 Notebook PC", ALC285_FIXUP_HP_GPIO_LED),
10498 	SND_PCI_QUIRK(0x103c, 0x8811, "HP Spectre x360 15-eb1xxx", ALC285_FIXUP_HP_SPECTRE_X360_EB1),
10499 	SND_PCI_QUIRK(0x103c, 0x8812, "HP Spectre x360 15-eb1xxx", ALC285_FIXUP_HP_SPECTRE_X360_EB1),
10500 	SND_PCI_QUIRK(0x103c, 0x881d, "HP 250 G8 Notebook PC", ALC236_FIXUP_HP_MUTE_LED_COEFBIT2),
10501 	SND_PCI_QUIRK(0x103c, 0x8846, "HP EliteBook 850 G8 Notebook PC", ALC285_FIXUP_HP_GPIO_LED),
10502 	SND_PCI_QUIRK(0x103c, 0x8847, "HP EliteBook x360 830 G8 Notebook PC", ALC285_FIXUP_HP_GPIO_LED),
10503 	SND_PCI_QUIRK(0x103c, 0x884b, "HP EliteBook 840 Aero G8 Notebook PC", ALC285_FIXUP_HP_GPIO_LED),
10504 	SND_PCI_QUIRK(0x103c, 0x884c, "HP EliteBook 840 G8 Notebook PC", ALC285_FIXUP_HP_GPIO_LED),
10505 	SND_PCI_QUIRK(0x103c, 0x8862, "HP ProBook 445 G8 Notebook PC", ALC236_FIXUP_HP_LIMIT_INT_MIC_BOOST),
10506 	SND_PCI_QUIRK(0x103c, 0x8863, "HP ProBook 445 G8 Notebook PC", ALC236_FIXUP_HP_LIMIT_INT_MIC_BOOST),
10507 	SND_PCI_QUIRK(0x103c, 0x886d, "HP ZBook Fury 17.3 Inch G8 Mobile Workstation PC", ALC285_FIXUP_HP_GPIO_AMP_INIT),
10508 	SND_PCI_QUIRK(0x103c, 0x8870, "HP ZBook Fury 15.6 Inch G8 Mobile Workstation PC", ALC285_FIXUP_HP_GPIO_AMP_INIT),
10509 	SND_PCI_QUIRK(0x103c, 0x8873, "HP ZBook Studio 15.6 Inch G8 Mobile Workstation PC", ALC285_FIXUP_HP_GPIO_AMP_INIT),
10510 	SND_PCI_QUIRK(0x103c, 0x887a, "HP Laptop 15s-eq2xxx", ALC236_FIXUP_HP_MUTE_LED_COEFBIT2),
10511 	SND_PCI_QUIRK(0x103c, 0x887c, "HP Laptop 14s-fq1xxx", ALC236_FIXUP_HP_MUTE_LED_COEFBIT2),
10512 	SND_PCI_QUIRK(0x103c, 0x888a, "HP ENVY x360 Convertible 15-eu0xxx", ALC245_FIXUP_HP_X360_MUTE_LEDS),
10513 	SND_PCI_QUIRK(0x103c, 0x888d, "HP ZBook Power 15.6 inch G8 Mobile Workstation PC", ALC236_FIXUP_HP_GPIO_LED),
10514 	SND_PCI_QUIRK(0x103c, 0x8895, "HP EliteBook 855 G8 Notebook PC", ALC285_FIXUP_HP_SPEAKERS_MICMUTE_LED),
10515 	SND_PCI_QUIRK(0x103c, 0x8896, "HP EliteBook 855 G8 Notebook PC", ALC285_FIXUP_HP_MUTE_LED),
10516 	SND_PCI_QUIRK(0x103c, 0x8898, "HP EliteBook 845 G8 Notebook PC", ALC285_FIXUP_HP_LIMIT_INT_MIC_BOOST),
10517 	SND_PCI_QUIRK(0x103c, 0x88d0, "HP Pavilion 15-eh1xxx (mainboard 88D0)", ALC287_FIXUP_HP_GPIO_LED),
10518 	SND_PCI_QUIRK(0x103c, 0x88dd, "HP Pavilion 15z-ec200", ALC285_FIXUP_HP_MUTE_LED),
10519 	SND_PCI_QUIRK(0x103c, 0x8902, "HP OMEN 16", ALC285_FIXUP_HP_MUTE_LED),
10520 	SND_PCI_QUIRK(0x103c, 0x890e, "HP 255 G8 Notebook PC", ALC236_FIXUP_HP_MUTE_LED_COEFBIT2),
10521 	SND_PCI_QUIRK(0x103c, 0x8919, "HP Pavilion Aero Laptop 13-be0xxx", ALC287_FIXUP_HP_GPIO_LED),
10522 	SND_PCI_QUIRK(0x103c, 0x896d, "HP ZBook Firefly 16 G9", ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED),
10523 	SND_PCI_QUIRK(0x103c, 0x896e, "HP EliteBook x360 830 G9", ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED),
10524 	SND_PCI_QUIRK(0x103c, 0x8971, "HP EliteBook 830 G9", ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED),
10525 	SND_PCI_QUIRK(0x103c, 0x8972, "HP EliteBook 840 G9", ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED),
10526 	SND_PCI_QUIRK(0x103c, 0x8973, "HP EliteBook 860 G9", ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED),
10527 	SND_PCI_QUIRK(0x103c, 0x8974, "HP EliteBook 840 Aero G9", ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED),
10528 	SND_PCI_QUIRK(0x103c, 0x8975, "HP EliteBook x360 840 Aero G9", ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED),
10529 	SND_PCI_QUIRK(0x103c, 0x897d, "HP mt440 Mobile Thin Client U74", ALC236_FIXUP_HP_GPIO_LED),
10530 	SND_PCI_QUIRK(0x103c, 0x8981, "HP Elite Dragonfly G3", ALC245_FIXUP_CS35L41_SPI_4),
10531 	SND_PCI_QUIRK(0x103c, 0x898e, "HP EliteBook 835 G9", ALC287_FIXUP_CS35L41_I2C_2),
10532 	SND_PCI_QUIRK(0x103c, 0x898f, "HP EliteBook 835 G9", ALC287_FIXUP_CS35L41_I2C_2),
10533 	SND_PCI_QUIRK(0x103c, 0x8991, "HP EliteBook 845 G9", ALC287_FIXUP_CS35L41_I2C_2_HP_GPIO_LED),
10534 	SND_PCI_QUIRK(0x103c, 0x8992, "HP EliteBook 845 G9", ALC287_FIXUP_CS35L41_I2C_2),
10535 	SND_PCI_QUIRK(0x103c, 0x8994, "HP EliteBook 855 G9", ALC287_FIXUP_CS35L41_I2C_2_HP_GPIO_LED),
10536 	SND_PCI_QUIRK(0x103c, 0x8995, "HP EliteBook 855 G9", ALC287_FIXUP_CS35L41_I2C_2),
10537 	SND_PCI_QUIRK(0x103c, 0x89a4, "HP ProBook 440 G9", ALC236_FIXUP_HP_GPIO_LED),
10538 	SND_PCI_QUIRK(0x103c, 0x89a6, "HP ProBook 450 G9", ALC236_FIXUP_HP_GPIO_LED),
10539 	SND_PCI_QUIRK(0x103c, 0x89aa, "HP EliteBook 630 G9", ALC236_FIXUP_HP_GPIO_LED),
10540 	SND_PCI_QUIRK(0x103c, 0x89ac, "HP EliteBook 640 G9", ALC236_FIXUP_HP_GPIO_LED),
10541 	SND_PCI_QUIRK(0x103c, 0x89ae, "HP EliteBook 650 G9", ALC236_FIXUP_HP_GPIO_LED),
10542 	SND_PCI_QUIRK(0x103c, 0x89c0, "HP ZBook Power 15.6 G9", ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED),
10543 	SND_PCI_QUIRK(0x103c, 0x89c3, "Zbook Studio G9", ALC245_FIXUP_CS35L41_SPI_4_HP_GPIO_LED),
10544 	SND_PCI_QUIRK(0x103c, 0x89c6, "Zbook Fury 17 G9", ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED),
10545 	SND_PCI_QUIRK(0x103c, 0x89ca, "HP", ALC236_FIXUP_HP_MUTE_LED_MICMUTE_VREF),
10546 	SND_PCI_QUIRK(0x103c, 0x89d3, "HP EliteBook 645 G9 (MB 89D2)", ALC236_FIXUP_HP_MUTE_LED_MICMUTE_VREF),
10547 	SND_PCI_QUIRK(0x103c, 0x89e7, "HP Elite x2 G9", ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED),
10548 	SND_PCI_QUIRK(0x103c, 0x8a0f, "HP Pavilion 14-ec1xxx", ALC287_FIXUP_HP_GPIO_LED),
10549 	SND_PCI_QUIRK(0x103c, 0x8a20, "HP Laptop 15s-fq5xxx", ALC236_FIXUP_HP_MUTE_LED_COEFBIT2),
10550 	SND_PCI_QUIRK(0x103c, 0x8a25, "HP Victus 16-d1xxx (MB 8A25)", ALC245_FIXUP_HP_MUTE_LED_COEFBIT),
10551 	SND_PCI_QUIRK(0x103c, 0x8a28, "HP Envy 13", ALC287_FIXUP_CS35L41_I2C_2),
10552 	SND_PCI_QUIRK(0x103c, 0x8a29, "HP Envy 15", ALC287_FIXUP_CS35L41_I2C_2),
10553 	SND_PCI_QUIRK(0x103c, 0x8a2a, "HP Envy 15", ALC287_FIXUP_CS35L41_I2C_2),
10554 	SND_PCI_QUIRK(0x103c, 0x8a2b, "HP Envy 15", ALC287_FIXUP_CS35L41_I2C_2),
10555 	SND_PCI_QUIRK(0x103c, 0x8a2c, "HP Envy 16", ALC287_FIXUP_CS35L41_I2C_2),
10556 	SND_PCI_QUIRK(0x103c, 0x8a2d, "HP Envy 16", ALC287_FIXUP_CS35L41_I2C_2),
10557 	SND_PCI_QUIRK(0x103c, 0x8a2e, "HP Envy 16", ALC287_FIXUP_CS35L41_I2C_2),
10558 	SND_PCI_QUIRK(0x103c, 0x8a30, "HP Envy 17", ALC287_FIXUP_CS35L41_I2C_2),
10559 	SND_PCI_QUIRK(0x103c, 0x8a31, "HP Envy 15", ALC287_FIXUP_CS35L41_I2C_2),
10560 	SND_PCI_QUIRK(0x103c, 0x8a6e, "HP EDNA 360", ALC287_FIXUP_CS35L41_I2C_4),
10561 	SND_PCI_QUIRK(0x103c, 0x8a74, "HP ProBook 440 G8 Notebook PC", ALC236_FIXUP_HP_GPIO_LED),
10562 	SND_PCI_QUIRK(0x103c, 0x8a78, "HP Dev One", ALC285_FIXUP_HP_LIMIT_INT_MIC_BOOST),
10563 	SND_PCI_QUIRK(0x103c, 0x8aa0, "HP ProBook 440 G9 (MB 8A9E)", ALC236_FIXUP_HP_GPIO_LED),
10564 	SND_PCI_QUIRK(0x103c, 0x8aa3, "HP ProBook 450 G9 (MB 8AA1)", ALC236_FIXUP_HP_GPIO_LED),
10565 	SND_PCI_QUIRK(0x103c, 0x8aa8, "HP EliteBook 640 G9 (MB 8AA6)", ALC236_FIXUP_HP_GPIO_LED),
10566 	SND_PCI_QUIRK(0x103c, 0x8aab, "HP EliteBook 650 G9 (MB 8AA9)", ALC236_FIXUP_HP_GPIO_LED),
10567 	SND_PCI_QUIRK(0x103c, 0x8ab9, "HP EliteBook 840 G8 (MB 8AB8)", ALC285_FIXUP_HP_GPIO_LED),
10568 	SND_PCI_QUIRK(0x103c, 0x8abb, "HP ZBook Firefly 14 G9", ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED),
10569 	SND_PCI_QUIRK(0x103c, 0x8ad1, "HP EliteBook 840 14 inch G9 Notebook PC", ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED),
10570 	SND_PCI_QUIRK(0x103c, 0x8ad2, "HP EliteBook 860 16 inch G9 Notebook PC", ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED),
10571 	SND_PCI_QUIRK(0x103c, 0x8ad8, "HP 800 G9", ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED),
10572 	SND_PCI_QUIRK(0x103c, 0x8b0f, "HP Elite mt645 G7 Mobile Thin Client U81", ALC236_FIXUP_HP_MUTE_LED_MICMUTE_VREF),
10573 	SND_PCI_QUIRK(0x103c, 0x8b2f, "HP 255 15.6 inch G10 Notebook PC", ALC236_FIXUP_HP_MUTE_LED_COEFBIT2),
10574 	SND_PCI_QUIRK(0x103c, 0x8b3a, "HP Envy 15", ALC287_FIXUP_CS35L41_I2C_2),
10575 	SND_PCI_QUIRK(0x103c, 0x8b3f, "HP mt440 Mobile Thin Client U91", ALC236_FIXUP_HP_GPIO_LED),
10576 	SND_PCI_QUIRK(0x103c, 0x8b42, "HP", ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED),
10577 	SND_PCI_QUIRK(0x103c, 0x8b43, "HP", ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED),
10578 	SND_PCI_QUIRK(0x103c, 0x8b44, "HP", ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED),
10579 	SND_PCI_QUIRK(0x103c, 0x8b45, "HP", ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED),
10580 	SND_PCI_QUIRK(0x103c, 0x8b46, "HP", ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED),
10581 	SND_PCI_QUIRK(0x103c, 0x8b47, "HP", ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED),
10582 	SND_PCI_QUIRK(0x103c, 0x8b59, "HP Elite mt645 G7 Mobile Thin Client U89", ALC236_FIXUP_HP_MUTE_LED_MICMUTE_VREF),
10583 	SND_PCI_QUIRK(0x103c, 0x8b5d, "HP", ALC236_FIXUP_HP_MUTE_LED_MICMUTE_VREF),
10584 	SND_PCI_QUIRK(0x103c, 0x8b5e, "HP", ALC236_FIXUP_HP_MUTE_LED_MICMUTE_VREF),
10585 	SND_PCI_QUIRK(0x103c, 0x8b5f, "HP", ALC236_FIXUP_HP_MUTE_LED_MICMUTE_VREF),
10586 	SND_PCI_QUIRK(0x103c, 0x8b63, "HP Elite Dragonfly 13.5 inch G4", ALC245_FIXUP_CS35L41_SPI_4_HP_GPIO_LED),
10587 	SND_PCI_QUIRK(0x103c, 0x8b65, "HP ProBook 455 15.6 inch G10 Notebook PC", ALC236_FIXUP_HP_MUTE_LED_MICMUTE_VREF),
10588 	SND_PCI_QUIRK(0x103c, 0x8b66, "HP", ALC236_FIXUP_HP_MUTE_LED_MICMUTE_VREF),
10589 	SND_PCI_QUIRK(0x103c, 0x8b70, "HP EliteBook 835 G10", ALC287_FIXUP_CS35L41_I2C_2_HP_GPIO_LED),
10590 	SND_PCI_QUIRK(0x103c, 0x8b72, "HP EliteBook 845 G10", ALC287_FIXUP_CS35L41_I2C_2_HP_GPIO_LED),
10591 	SND_PCI_QUIRK(0x103c, 0x8b74, "HP EliteBook 845W G10", ALC287_FIXUP_CS35L41_I2C_2_HP_GPIO_LED),
10592 	SND_PCI_QUIRK(0x103c, 0x8b77, "HP ElieBook 865 G10", ALC287_FIXUP_CS35L41_I2C_2),
10593 	SND_PCI_QUIRK(0x103c, 0x8b7a, "HP", ALC236_FIXUP_HP_GPIO_LED),
10594 	SND_PCI_QUIRK(0x103c, 0x8b7d, "HP", ALC236_FIXUP_HP_GPIO_LED),
10595 	SND_PCI_QUIRK(0x103c, 0x8b87, "HP", ALC236_FIXUP_HP_GPIO_LED),
10596 	SND_PCI_QUIRK(0x103c, 0x8b8a, "HP", ALC236_FIXUP_HP_GPIO_LED),
10597 	SND_PCI_QUIRK(0x103c, 0x8b8b, "HP", ALC236_FIXUP_HP_GPIO_LED),
10598 	SND_PCI_QUIRK(0x103c, 0x8b8d, "HP", ALC236_FIXUP_HP_GPIO_LED),
10599 	SND_PCI_QUIRK(0x103c, 0x8b8f, "HP", ALC245_FIXUP_CS35L41_SPI_4_HP_GPIO_LED),
10600 	SND_PCI_QUIRK(0x103c, 0x8b92, "HP", ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED),
10601 	SND_PCI_QUIRK(0x103c, 0x8b96, "HP", ALC236_FIXUP_HP_MUTE_LED_MICMUTE_VREF),
10602 	SND_PCI_QUIRK(0x103c, 0x8b97, "HP", ALC236_FIXUP_HP_MUTE_LED_MICMUTE_VREF),
10603 	SND_PCI_QUIRK(0x103c, 0x8bb3, "HP Slim OMEN", ALC287_FIXUP_CS35L41_I2C_2),
10604 	SND_PCI_QUIRK(0x103c, 0x8bb4, "HP Slim OMEN", ALC287_FIXUP_CS35L41_I2C_2),
10605 	SND_PCI_QUIRK(0x103c, 0x8bdd, "HP Envy 17", ALC287_FIXUP_CS35L41_I2C_2),
10606 	SND_PCI_QUIRK(0x103c, 0x8bde, "HP Envy 17", ALC287_FIXUP_CS35L41_I2C_2),
10607 	SND_PCI_QUIRK(0x103c, 0x8bdf, "HP Envy 15", ALC287_FIXUP_CS35L41_I2C_2),
10608 	SND_PCI_QUIRK(0x103c, 0x8be0, "HP Envy 15", ALC287_FIXUP_CS35L41_I2C_2),
10609 	SND_PCI_QUIRK(0x103c, 0x8be1, "HP Envy 15", ALC287_FIXUP_CS35L41_I2C_2),
10610 	SND_PCI_QUIRK(0x103c, 0x8be2, "HP Envy 15", ALC287_FIXUP_CS35L41_I2C_2),
10611 	SND_PCI_QUIRK(0x103c, 0x8be3, "HP Envy 15", ALC287_FIXUP_CS35L41_I2C_2),
10612 	SND_PCI_QUIRK(0x103c, 0x8be5, "HP Envy 16", ALC287_FIXUP_CS35L41_I2C_2),
10613 	SND_PCI_QUIRK(0x103c, 0x8be6, "HP Envy 16", ALC287_FIXUP_CS35L41_I2C_2),
10614 	SND_PCI_QUIRK(0x103c, 0x8be7, "HP Envy 17", ALC287_FIXUP_CS35L41_I2C_2),
10615 	SND_PCI_QUIRK(0x103c, 0x8be8, "HP Envy 17", ALC287_FIXUP_CS35L41_I2C_2),
10616 	SND_PCI_QUIRK(0x103c, 0x8be9, "HP Envy 15", ALC287_FIXUP_CS35L41_I2C_2),
10617 	SND_PCI_QUIRK(0x103c, 0x8bf0, "HP", ALC236_FIXUP_HP_GPIO_LED),
10618 	SND_PCI_QUIRK(0x103c, 0x8c15, "HP Spectre x360 2-in-1 Laptop 14-eu0xxx", ALC245_FIXUP_HP_SPECTRE_X360_EU0XXX),
10619 	SND_PCI_QUIRK(0x103c, 0x8c16, "HP Spectre x360 2-in-1 Laptop 16-aa0xxx", ALC245_FIXUP_HP_SPECTRE_X360_16_AA0XXX),
10620 	SND_PCI_QUIRK(0x103c, 0x8c17, "HP Spectre 16", ALC287_FIXUP_CS35L41_I2C_2),
10621 	SND_PCI_QUIRK(0x103c, 0x8c21, "HP Pavilion Plus Laptop 14-ey0XXX", ALC245_FIXUP_HP_X360_MUTE_LEDS),
10622 	SND_PCI_QUIRK(0x103c, 0x8c30, "HP Victus 15-fb1xxx", ALC245_FIXUP_HP_MUTE_LED_COEFBIT),
10623 	SND_PCI_QUIRK(0x103c, 0x8c46, "HP EliteBook 830 G11", ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED),
10624 	SND_PCI_QUIRK(0x103c, 0x8c47, "HP EliteBook 840 G11", ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED),
10625 	SND_PCI_QUIRK(0x103c, 0x8c48, "HP EliteBook 860 G11", ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED),
10626 	SND_PCI_QUIRK(0x103c, 0x8c49, "HP Elite x360 830 2-in-1 G11", ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED),
10627 	SND_PCI_QUIRK(0x103c, 0x8c4d, "HP Omen", ALC287_FIXUP_CS35L41_I2C_2),
10628 	SND_PCI_QUIRK(0x103c, 0x8c4e, "HP Omen", ALC287_FIXUP_CS35L41_I2C_2),
10629 	SND_PCI_QUIRK(0x103c, 0x8c4f, "HP Envy 15", ALC287_FIXUP_CS35L41_I2C_2),
10630 	SND_PCI_QUIRK(0x103c, 0x8c50, "HP Envy 17", ALC287_FIXUP_CS35L41_I2C_2),
10631 	SND_PCI_QUIRK(0x103c, 0x8c51, "HP Envy 17", ALC287_FIXUP_CS35L41_I2C_2),
10632 	SND_PCI_QUIRK(0x103c, 0x8c52, "HP EliteBook 1040 G11", ALC285_FIXUP_HP_GPIO_LED),
10633 	SND_PCI_QUIRK(0x103c, 0x8c53, "HP Elite x360 1040 2-in-1 G11", ALC285_FIXUP_HP_GPIO_LED),
10634 	SND_PCI_QUIRK(0x103c, 0x8c66, "HP Envy 16", ALC287_FIXUP_CS35L41_I2C_2),
10635 	SND_PCI_QUIRK(0x103c, 0x8c67, "HP Envy 17", ALC287_FIXUP_CS35L41_I2C_2),
10636 	SND_PCI_QUIRK(0x103c, 0x8c68, "HP Envy 17", ALC287_FIXUP_CS35L41_I2C_2),
10637 	SND_PCI_QUIRK(0x103c, 0x8c6a, "HP Envy 16", ALC287_FIXUP_CS35L41_I2C_2),
10638 	SND_PCI_QUIRK(0x103c, 0x8c70, "HP EliteBook 835 G11", ALC287_FIXUP_CS35L41_I2C_2_HP_GPIO_LED),
10639 	SND_PCI_QUIRK(0x103c, 0x8c71, "HP EliteBook 845 G11", ALC287_FIXUP_CS35L41_I2C_2_HP_GPIO_LED),
10640 	SND_PCI_QUIRK(0x103c, 0x8c72, "HP EliteBook 865 G11", ALC287_FIXUP_CS35L41_I2C_2_HP_GPIO_LED),
10641 	SND_PCI_QUIRK(0x103c, 0x8c7b, "HP ProBook 445 G11", ALC236_FIXUP_HP_MUTE_LED_MICMUTE_VREF),
10642 	SND_PCI_QUIRK(0x103c, 0x8c7c, "HP ProBook 445 G11", ALC236_FIXUP_HP_MUTE_LED_MICMUTE_VREF),
10643 	SND_PCI_QUIRK(0x103c, 0x8c7d, "HP ProBook 465 G11", ALC236_FIXUP_HP_MUTE_LED_MICMUTE_VREF),
10644 	SND_PCI_QUIRK(0x103c, 0x8c7e, "HP ProBook 465 G11", ALC236_FIXUP_HP_MUTE_LED_MICMUTE_VREF),
10645 	SND_PCI_QUIRK(0x103c, 0x8c7f, "HP EliteBook 645 G11", ALC236_FIXUP_HP_MUTE_LED_MICMUTE_VREF),
10646 	SND_PCI_QUIRK(0x103c, 0x8c80, "HP EliteBook 645 G11", ALC236_FIXUP_HP_MUTE_LED_MICMUTE_VREF),
10647 	SND_PCI_QUIRK(0x103c, 0x8c81, "HP EliteBook 665 G11", ALC236_FIXUP_HP_MUTE_LED_MICMUTE_VREF),
10648 	SND_PCI_QUIRK(0x103c, 0x8c89, "HP ProBook 460 G11", ALC236_FIXUP_HP_GPIO_LED),
10649 	SND_PCI_QUIRK(0x103c, 0x8c8a, "HP EliteBook 630", ALC236_FIXUP_HP_GPIO_LED),
10650 	SND_PCI_QUIRK(0x103c, 0x8c8c, "HP EliteBook 660", ALC236_FIXUP_HP_GPIO_LED),
10651 	SND_PCI_QUIRK(0x103c, 0x8c8d, "HP ProBook 440 G11", ALC236_FIXUP_HP_GPIO_LED),
10652 	SND_PCI_QUIRK(0x103c, 0x8c8e, "HP ProBook 460 G11", ALC236_FIXUP_HP_GPIO_LED),
10653 	SND_PCI_QUIRK(0x103c, 0x8c90, "HP EliteBook 640", ALC236_FIXUP_HP_GPIO_LED),
10654 	SND_PCI_QUIRK(0x103c, 0x8c91, "HP EliteBook 660", ALC236_FIXUP_HP_GPIO_LED),
10655 	SND_PCI_QUIRK(0x103c, 0x8c96, "HP", ALC236_FIXUP_HP_MUTE_LED_MICMUTE_VREF),
10656 	SND_PCI_QUIRK(0x103c, 0x8c97, "HP ZBook", ALC236_FIXUP_HP_MUTE_LED_MICMUTE_VREF),
10657 	SND_PCI_QUIRK(0x103c, 0x8ca1, "HP ZBook Power", ALC236_FIXUP_HP_GPIO_LED),
10658 	SND_PCI_QUIRK(0x103c, 0x8ca2, "HP ZBook Power", ALC236_FIXUP_HP_GPIO_LED),
10659 	SND_PCI_QUIRK(0x103c, 0x8ca4, "HP ZBook Fury", ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED),
10660 	SND_PCI_QUIRK(0x103c, 0x8ca7, "HP ZBook Fury", ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED),
10661 	SND_PCI_QUIRK(0x103c, 0x8caf, "HP Elite mt645 G8 Mobile Thin Client", ALC236_FIXUP_HP_MUTE_LED_MICMUTE_VREF),
10662 	SND_PCI_QUIRK(0x103c, 0x8cbd, "HP Pavilion Aero Laptop 13-bg0xxx", ALC245_FIXUP_HP_X360_MUTE_LEDS),
10663 	SND_PCI_QUIRK(0x103c, 0x8cdd, "HP Spectre", ALC287_FIXUP_CS35L41_I2C_2),
10664 	SND_PCI_QUIRK(0x103c, 0x8cde, "HP Spectre", ALC287_FIXUP_CS35L41_I2C_2),
10665 	SND_PCI_QUIRK(0x103c, 0x8cdf, "HP SnowWhite", ALC287_FIXUP_CS35L41_I2C_2_HP_GPIO_LED),
10666 	SND_PCI_QUIRK(0x103c, 0x8ce0, "HP SnowWhite", ALC287_FIXUP_CS35L41_I2C_2_HP_GPIO_LED),
10667 	SND_PCI_QUIRK(0x103c, 0x8cf5, "HP ZBook Studio 16", ALC245_FIXUP_CS35L41_SPI_4_HP_GPIO_LED),
10668 	SND_PCI_QUIRK(0x103c, 0x8d01, "HP ZBook Power 14 G12", ALC285_FIXUP_HP_GPIO_LED),
10669 	SND_PCI_QUIRK(0x103c, 0x8d84, "HP EliteBook X G1i", ALC285_FIXUP_HP_GPIO_LED),
10670 	SND_PCI_QUIRK(0x103c, 0x8d91, "HP ZBook Firefly 14 G12", ALC285_FIXUP_HP_GPIO_LED),
10671 	SND_PCI_QUIRK(0x103c, 0x8d92, "HP ZBook Firefly 16 G12", ALC285_FIXUP_HP_GPIO_LED),
10672 	SND_PCI_QUIRK(0x103c, 0x8de8, "HP Gemtree", ALC245_FIXUP_TAS2781_SPI_2),
10673 	SND_PCI_QUIRK(0x103c, 0x8de9, "HP Gemtree", ALC245_FIXUP_TAS2781_SPI_2),
10674 	SND_PCI_QUIRK(0x103c, 0x8e18, "HP ZBook Firefly 14 G12A", ALC285_FIXUP_HP_GPIO_LED),
10675 	SND_PCI_QUIRK(0x103c, 0x8e19, "HP ZBook Firefly 14 G12A", ALC285_FIXUP_HP_GPIO_LED),
10676 	SND_PCI_QUIRK(0x103c, 0x8e1a, "HP ZBook Firefly 14 G12A", ALC285_FIXUP_HP_GPIO_LED),
10677 	SND_PCI_QUIRK(0x1043, 0x103e, "ASUS X540SA", ALC256_FIXUP_ASUS_MIC),
10678 	SND_PCI_QUIRK(0x1043, 0x103f, "ASUS TX300", ALC282_FIXUP_ASUS_TX300),
10679 	SND_PCI_QUIRK(0x1043, 0x1054, "ASUS G614FH/FM/FP", ALC287_FIXUP_CS35L41_I2C_2),
10680 	SND_PCI_QUIRK(0x1043, 0x106d, "Asus K53BE", ALC269_FIXUP_LIMIT_INT_MIC_BOOST),
10681 	SND_PCI_QUIRK(0x1043, 0x1074, "ASUS G614PH/PM/PP", ALC287_FIXUP_CS35L41_I2C_2),
10682 	SND_PCI_QUIRK(0x1043, 0x10a1, "ASUS UX391UA", ALC294_FIXUP_ASUS_SPK),
10683 	SND_PCI_QUIRK(0x1043, 0x10a4, "ASUS TP3407SA", ALC287_FIXUP_TAS2781_I2C),
10684 	SND_PCI_QUIRK(0x1043, 0x10c0, "ASUS X540SA", ALC256_FIXUP_ASUS_MIC),
10685 	SND_PCI_QUIRK(0x1043, 0x10d0, "ASUS X540LA/X540LJ", ALC255_FIXUP_ASUS_MIC_NO_PRESENCE),
10686 	SND_PCI_QUIRK(0x1043, 0x10d3, "ASUS K6500ZC", ALC294_FIXUP_ASUS_SPK),
10687 	SND_PCI_QUIRK(0x1043, 0x1154, "ASUS TP3607SH", ALC287_FIXUP_TAS2781_I2C),
10688 	SND_PCI_QUIRK(0x1043, 0x115d, "Asus 1015E", ALC269_FIXUP_LIMIT_INT_MIC_BOOST),
10689 	SND_PCI_QUIRK(0x1043, 0x1194, "ASUS UM3406KA", ALC287_FIXUP_CS35L41_I2C_2),
10690 	SND_PCI_QUIRK(0x1043, 0x11c0, "ASUS X556UR", ALC255_FIXUP_ASUS_MIC_NO_PRESENCE),
10691 	SND_PCI_QUIRK(0x1043, 0x1204, "ASUS Strix G615JHR_JMR_JPR", ALC287_FIXUP_TAS2781_I2C),
10692 	SND_PCI_QUIRK(0x1043, 0x1214, "ASUS Strix G615LH_LM_LP", ALC287_FIXUP_TAS2781_I2C),
10693 	SND_PCI_QUIRK(0x1043, 0x125e, "ASUS Q524UQK", ALC255_FIXUP_ASUS_MIC_NO_PRESENCE),
10694 	SND_PCI_QUIRK(0x1043, 0x1271, "ASUS X430UN", ALC256_FIXUP_ASUS_MIC_NO_PRESENCE),
10695 	SND_PCI_QUIRK(0x1043, 0x1290, "ASUS X441SA", ALC233_FIXUP_EAPD_COEF_AND_MIC_NO_PRESENCE),
10696 	SND_PCI_QUIRK(0x1043, 0x1294, "ASUS B3405CVA", ALC245_FIXUP_CS35L41_SPI_2),
10697 	SND_PCI_QUIRK(0x1043, 0x12a0, "ASUS X441UV", ALC233_FIXUP_EAPD_COEF_AND_MIC_NO_PRESENCE),
10698 	SND_PCI_QUIRK(0x1043, 0x12a3, "Asus N7691ZM", ALC269_FIXUP_ASUS_N7601ZM),
10699 	SND_PCI_QUIRK(0x1043, 0x12af, "ASUS UX582ZS", ALC245_FIXUP_CS35L41_SPI_2),
10700 	SND_PCI_QUIRK(0x1043, 0x12b4, "ASUS B3405CCA / P3405CCA", ALC245_FIXUP_CS35L41_SPI_2),
10701 	SND_PCI_QUIRK(0x1043, 0x12e0, "ASUS X541SA", ALC256_FIXUP_ASUS_MIC),
10702 	SND_PCI_QUIRK(0x1043, 0x12f0, "ASUS X541UV", ALC256_FIXUP_ASUS_MIC),
10703 	SND_PCI_QUIRK(0x1043, 0x1313, "Asus K42JZ", ALC269VB_FIXUP_ASUS_MIC_NO_PRESENCE),
10704 	SND_PCI_QUIRK(0x1043, 0x13b0, "ASUS Z550SA", ALC256_FIXUP_ASUS_MIC),
10705 	SND_PCI_QUIRK(0x1043, 0x1427, "Asus Zenbook UX31E", ALC269VB_FIXUP_ASUS_ZENBOOK),
10706 	SND_PCI_QUIRK(0x1043, 0x1433, "ASUS GX650PY/PZ/PV/PU/PYV/PZV/PIV/PVV", ALC285_FIXUP_ASUS_I2C_HEADSET_MIC),
10707 	SND_PCI_QUIRK(0x1043, 0x1460, "Asus VivoBook 15", ALC256_FIXUP_ASUS_MIC_NO_PRESENCE),
10708 	SND_PCI_QUIRK(0x1043, 0x1463, "Asus GA402X/GA402N", ALC285_FIXUP_ASUS_I2C_HEADSET_MIC),
10709 	SND_PCI_QUIRK(0x1043, 0x1473, "ASUS GU604VI/VC/VE/VG/VJ/VQ/VU/VV/VY/VZ", ALC285_FIXUP_ASUS_HEADSET_MIC),
10710 	SND_PCI_QUIRK(0x1043, 0x1483, "ASUS GU603VQ/VU/VV/VJ/VI", ALC285_FIXUP_ASUS_HEADSET_MIC),
10711 	SND_PCI_QUIRK(0x1043, 0x1493, "ASUS GV601VV/VU/VJ/VQ/VI", ALC285_FIXUP_ASUS_HEADSET_MIC),
10712 	SND_PCI_QUIRK(0x1043, 0x14d3, "ASUS G614JY/JZ/JG", ALC245_FIXUP_CS35L41_SPI_2),
10713 	SND_PCI_QUIRK(0x1043, 0x14e3, "ASUS G513PI/PU/PV", ALC287_FIXUP_CS35L41_I2C_2),
10714 	SND_PCI_QUIRK(0x1043, 0x1503, "ASUS G733PY/PZ/PZV/PYV", ALC287_FIXUP_CS35L41_I2C_2),
10715 	SND_PCI_QUIRK(0x1043, 0x1517, "Asus Zenbook UX31A", ALC269VB_FIXUP_ASUS_ZENBOOK_UX31A),
10716 	SND_PCI_QUIRK(0x1043, 0x1533, "ASUS GV302XA/XJ/XQ/XU/XV/XI", ALC287_FIXUP_CS35L41_I2C_2),
10717 	SND_PCI_QUIRK(0x1043, 0x1573, "ASUS GZ301VV/VQ/VU/VJ/VA/VC/VE/VVC/VQC/VUC/VJC/VEC/VCC", ALC285_FIXUP_ASUS_HEADSET_MIC),
10718 	SND_PCI_QUIRK(0x1043, 0x1662, "ASUS GV301QH", ALC294_FIXUP_ASUS_DUAL_SPK),
10719 	SND_PCI_QUIRK(0x1043, 0x1663, "ASUS GU603ZI/ZJ/ZQ/ZU/ZV", ALC285_FIXUP_ASUS_HEADSET_MIC),
10720 	SND_PCI_QUIRK(0x1043, 0x1683, "ASUS UM3402YAR", ALC287_FIXUP_CS35L41_I2C_2),
10721 	SND_PCI_QUIRK(0x1043, 0x16a3, "ASUS UX3402VA", ALC245_FIXUP_CS35L41_SPI_2),
10722 	SND_PCI_QUIRK(0x1043, 0x16b2, "ASUS GU603", ALC289_FIXUP_ASUS_GA401),
10723 	SND_PCI_QUIRK(0x1043, 0x16d3, "ASUS UX5304VA", ALC245_FIXUP_CS35L41_SPI_2),
10724 	SND_PCI_QUIRK(0x1043, 0x16e3, "ASUS UX50", ALC269_FIXUP_STEREO_DMIC),
10725 	SND_PCI_QUIRK(0x1043, 0x16f3, "ASUS UX7602VI/BZ", ALC245_FIXUP_CS35L41_SPI_2),
10726 	SND_PCI_QUIRK(0x1043, 0x1740, "ASUS UX430UA", ALC295_FIXUP_ASUS_DACS),
10727 	SND_PCI_QUIRK(0x1043, 0x17d1, "ASUS UX431FL", ALC294_FIXUP_ASUS_DUAL_SPK),
10728 	SND_PCI_QUIRK(0x1043, 0x17f3, "ROG Ally NR2301L/X", ALC294_FIXUP_ASUS_ALLY),
10729 	SND_PCI_QUIRK(0x1043, 0x1863, "ASUS UX6404VI/VV", ALC245_FIXUP_CS35L41_SPI_2),
10730 	SND_PCI_QUIRK(0x1043, 0x1881, "ASUS Zephyrus S/M", ALC294_FIXUP_ASUS_GX502_PINS),
10731 	SND_PCI_QUIRK(0x1043, 0x18b1, "Asus MJ401TA", ALC256_FIXUP_ASUS_HEADSET_MIC),
10732 	SND_PCI_QUIRK(0x1043, 0x18d3, "ASUS UM3504DA", ALC294_FIXUP_CS35L41_I2C_2),
10733 	SND_PCI_QUIRK(0x1043, 0x18f1, "Asus FX505DT", ALC256_FIXUP_ASUS_HEADSET_MIC),
10734 	SND_PCI_QUIRK(0x1043, 0x194e, "ASUS UX563FD", ALC294_FIXUP_ASUS_HPE),
10735 	SND_PCI_QUIRK(0x1043, 0x1970, "ASUS UX550VE", ALC289_FIXUP_ASUS_GA401),
10736 	SND_PCI_QUIRK(0x1043, 0x1982, "ASUS B1400CEPE", ALC256_FIXUP_ASUS_HPE),
10737 	SND_PCI_QUIRK(0x1043, 0x19ce, "ASUS B9450FA", ALC294_FIXUP_ASUS_HPE),
10738 	SND_PCI_QUIRK(0x1043, 0x19e1, "ASUS UX581LV", ALC295_FIXUP_ASUS_MIC_NO_PRESENCE),
10739 	SND_PCI_QUIRK(0x1043, 0x1a13, "Asus G73Jw", ALC269_FIXUP_ASUS_G73JW),
10740 	SND_PCI_QUIRK(0x1043, 0x1a63, "ASUS UX3405MA", ALC245_FIXUP_CS35L41_SPI_2),
10741 	SND_PCI_QUIRK(0x1043, 0x1a83, "ASUS UM5302LA", ALC294_FIXUP_CS35L41_I2C_2),
10742 	SND_PCI_QUIRK(0x1043, 0x1a8f, "ASUS UX582ZS", ALC245_FIXUP_CS35L41_SPI_2),
10743 	SND_PCI_QUIRK(0x1043, 0x1b11, "ASUS UX431DA", ALC294_FIXUP_ASUS_COEF_1B),
10744 	SND_PCI_QUIRK(0x1043, 0x1b13, "ASUS U41SV/GA403U", ALC285_FIXUP_ASUS_GA403U_HEADSET_MIC),
10745 	SND_PCI_QUIRK(0x1043, 0x1b93, "ASUS G614JVR/JIR", ALC245_FIXUP_CS35L41_SPI_2),
10746 	SND_PCI_QUIRK(0x1043, 0x1bbd, "ASUS Z550MA", ALC255_FIXUP_ASUS_MIC_NO_PRESENCE),
10747 	SND_PCI_QUIRK(0x1043, 0x1c03, "ASUS UM3406HA", ALC287_FIXUP_CS35L41_I2C_2),
10748 	SND_PCI_QUIRK(0x1043, 0x1c23, "Asus X55U", ALC269_FIXUP_LIMIT_INT_MIC_BOOST),
10749 	SND_PCI_QUIRK(0x1043, 0x1c33, "ASUS UX5304MA", ALC245_FIXUP_CS35L41_SPI_2),
10750 	SND_PCI_QUIRK(0x1043, 0x1c43, "ASUS UX8406MA", ALC245_FIXUP_CS35L41_SPI_2),
10751 	SND_PCI_QUIRK(0x1043, 0x1c62, "ASUS GU603", ALC289_FIXUP_ASUS_GA401),
10752 	SND_PCI_QUIRK(0x1043, 0x1c63, "ASUS GU605M", ALC285_FIXUP_ASUS_GU605_SPI_SPEAKER2_TO_DAC1),
10753 	SND_PCI_QUIRK(0x1043, 0x1c92, "ASUS ROG Strix G15", ALC285_FIXUP_ASUS_G533Z_PINS),
10754 	SND_PCI_QUIRK(0x1043, 0x1c9f, "ASUS G614JU/JV/JI", ALC285_FIXUP_ASUS_HEADSET_MIC),
10755 	SND_PCI_QUIRK(0x1043, 0x1caf, "ASUS G634JY/JZ/JI/JG", ALC285_FIXUP_ASUS_SPI_REAR_SPEAKERS),
10756 	SND_PCI_QUIRK(0x1043, 0x1ccd, "ASUS X555UB", ALC256_FIXUP_ASUS_MIC),
10757 	SND_PCI_QUIRK(0x1043, 0x1ccf, "ASUS G814JU/JV/JI", ALC245_FIXUP_CS35L41_SPI_2),
10758 	SND_PCI_QUIRK(0x1043, 0x1cdf, "ASUS G814JY/JZ/JG", ALC245_FIXUP_CS35L41_SPI_2),
10759 	SND_PCI_QUIRK(0x1043, 0x1cef, "ASUS G834JY/JZ/JI/JG", ALC285_FIXUP_ASUS_HEADSET_MIC),
10760 	SND_PCI_QUIRK(0x1043, 0x1d1f, "ASUS G713PI/PU/PV/PVN", ALC287_FIXUP_CS35L41_I2C_2),
10761 	SND_PCI_QUIRK(0x1043, 0x1d42, "ASUS Zephyrus G14 2022", ALC289_FIXUP_ASUS_GA401),
10762 	SND_PCI_QUIRK(0x1043, 0x1d4e, "ASUS TM420", ALC256_FIXUP_ASUS_HPE),
10763 	SND_PCI_QUIRK(0x1043, 0x1da2, "ASUS UP6502ZA/ZD", ALC245_FIXUP_CS35L41_SPI_2),
10764 	SND_PCI_QUIRK(0x1043, 0x1df3, "ASUS UM5606WA", ALC294_FIXUP_BASS_SPEAKER_15),
10765 	SND_PCI_QUIRK(0x1043, 0x1e02, "ASUS UX3402ZA", ALC245_FIXUP_CS35L41_SPI_2),
10766 	SND_PCI_QUIRK(0x1043, 0x1e11, "ASUS Zephyrus G15", ALC289_FIXUP_ASUS_GA502),
10767 	SND_PCI_QUIRK(0x1043, 0x1e12, "ASUS UM3402", ALC287_FIXUP_CS35L41_I2C_2),
10768 	SND_PCI_QUIRK(0x1043, 0x1e1f, "ASUS Vivobook 15 X1504VAP", ALC2XX_FIXUP_HEADSET_MIC),
10769 	SND_PCI_QUIRK(0x1043, 0x1e51, "ASUS Zephyrus M15", ALC294_FIXUP_ASUS_GU502_PINS),
10770 	SND_PCI_QUIRK(0x1043, 0x1e5e, "ASUS ROG Strix G513", ALC294_FIXUP_ASUS_G513_PINS),
10771 	SND_PCI_QUIRK(0x1043, 0x1e63, "ASUS H7606W", ALC285_FIXUP_ASUS_GU605_SPI_SPEAKER2_TO_DAC1),
10772 	SND_PCI_QUIRK(0x1043, 0x1e83, "ASUS GA605W", ALC285_FIXUP_ASUS_GU605_SPI_SPEAKER2_TO_DAC1),
10773 	SND_PCI_QUIRK(0x1043, 0x1e8e, "ASUS Zephyrus G15", ALC289_FIXUP_ASUS_GA401),
10774 	SND_PCI_QUIRK(0x1043, 0x1eb3, "ASUS Ally RCLA72", ALC287_FIXUP_TAS2781_I2C),
10775 	SND_PCI_QUIRK(0x1043, 0x1ed3, "ASUS HN7306W", ALC287_FIXUP_CS35L41_I2C_2),
10776 	SND_PCI_QUIRK(0x1043, 0x1ee2, "ASUS UM6702RA/RC", ALC287_FIXUP_CS35L41_I2C_2),
10777 	SND_PCI_QUIRK(0x1043, 0x1c52, "ASUS Zephyrus G15 2022", ALC289_FIXUP_ASUS_GA401),
10778 	SND_PCI_QUIRK(0x1043, 0x1f11, "ASUS Zephyrus G14", ALC289_FIXUP_ASUS_GA401),
10779 	SND_PCI_QUIRK(0x1043, 0x1f12, "ASUS UM5302", ALC287_FIXUP_CS35L41_I2C_2),
10780 	SND_PCI_QUIRK(0x1043, 0x1f1f, "ASUS H7604JI/JV/J3D", ALC245_FIXUP_CS35L41_SPI_2),
10781 	SND_PCI_QUIRK(0x1043, 0x1f62, "ASUS UX7602ZM", ALC245_FIXUP_CS35L41_SPI_2),
10782 	SND_PCI_QUIRK(0x1043, 0x1f63, "ASUS P5405CSA", ALC245_FIXUP_CS35L41_SPI_2),
10783 	SND_PCI_QUIRK(0x1043, 0x1f92, "ASUS ROG Flow X16", ALC289_FIXUP_ASUS_GA401),
10784 	SND_PCI_QUIRK(0x1043, 0x1fb3, "ASUS ROG Flow Z13 GZ302EA", ALC287_FIXUP_CS35L41_I2C_2),
10785 	SND_PCI_QUIRK(0x1043, 0x3011, "ASUS B5605CVA", ALC245_FIXUP_CS35L41_SPI_2),
10786 	SND_PCI_QUIRK(0x1043, 0x3030, "ASUS ZN270IE", ALC256_FIXUP_ASUS_AIO_GPIO2),
10787 	SND_PCI_QUIRK(0x1043, 0x3061, "ASUS B3405CCA", ALC245_FIXUP_CS35L41_SPI_2),
10788 	SND_PCI_QUIRK(0x1043, 0x3071, "ASUS B5405CCA", ALC245_FIXUP_CS35L41_SPI_2),
10789 	SND_PCI_QUIRK(0x1043, 0x30c1, "ASUS B3605CCA / P3605CCA", ALC245_FIXUP_CS35L41_SPI_2),
10790 	SND_PCI_QUIRK(0x1043, 0x30d1, "ASUS B5405CCA", ALC245_FIXUP_CS35L41_SPI_2),
10791 	SND_PCI_QUIRK(0x1043, 0x30e1, "ASUS B5605CCA", ALC245_FIXUP_CS35L41_SPI_2),
10792 	SND_PCI_QUIRK(0x1043, 0x31d0, "ASUS Zen AIO 27 Z272SD_A272SD", ALC274_FIXUP_ASUS_ZEN_AIO_27),
10793 	SND_PCI_QUIRK(0x1043, 0x31e1, "ASUS B5605CCA", ALC245_FIXUP_CS35L41_SPI_2),
10794 	SND_PCI_QUIRK(0x1043, 0x31f1, "ASUS B3605CCA", ALC245_FIXUP_CS35L41_SPI_2),
10795 	SND_PCI_QUIRK(0x1043, 0x3a20, "ASUS G614JZR", ALC285_FIXUP_ASUS_SPI_REAR_SPEAKERS),
10796 	SND_PCI_QUIRK(0x1043, 0x3a30, "ASUS G814JVR/JIR", ALC285_FIXUP_ASUS_SPI_REAR_SPEAKERS),
10797 	SND_PCI_QUIRK(0x1043, 0x3a40, "ASUS G814JZR", ALC285_FIXUP_ASUS_SPI_REAR_SPEAKERS),
10798 	SND_PCI_QUIRK(0x1043, 0x3a50, "ASUS G834JYR/JZR", ALC285_FIXUP_ASUS_SPI_REAR_SPEAKERS),
10799 	SND_PCI_QUIRK(0x1043, 0x3a60, "ASUS G634JYR/JZR", ALC285_FIXUP_ASUS_SPI_REAR_SPEAKERS),
10800 	SND_PCI_QUIRK(0x1043, 0x3d78, "ASUS GA603KH", ALC287_FIXUP_CS35L41_I2C_2),
10801 	SND_PCI_QUIRK(0x1043, 0x3d88, "ASUS GA603KM", ALC287_FIXUP_CS35L41_I2C_2),
10802 	SND_PCI_QUIRK(0x1043, 0x3e00, "ASUS G814FH/FM/FP", ALC287_FIXUP_CS35L41_I2C_2),
10803 	SND_PCI_QUIRK(0x1043, 0x3e20, "ASUS G814PH/PM/PP", ALC287_FIXUP_CS35L41_I2C_2),
10804 	SND_PCI_QUIRK(0x1043, 0x3e30, "ASUS TP3607SA", ALC287_FIXUP_TAS2781_I2C),
10805 	SND_PCI_QUIRK(0x1043, 0x3ee0, "ASUS Strix G815_JHR_JMR_JPR", ALC287_FIXUP_TAS2781_I2C),
10806 	SND_PCI_QUIRK(0x1043, 0x3ef0, "ASUS Strix G635LR_LW_LX", ALC287_FIXUP_TAS2781_I2C),
10807 	SND_PCI_QUIRK(0x1043, 0x3f00, "ASUS Strix G815LH_LM_LP", ALC287_FIXUP_TAS2781_I2C),
10808 	SND_PCI_QUIRK(0x1043, 0x3f10, "ASUS Strix G835LR_LW_LX", ALC287_FIXUP_TAS2781_I2C),
10809 	SND_PCI_QUIRK(0x1043, 0x3f20, "ASUS Strix G615LR_LW", ALC287_FIXUP_TAS2781_I2C),
10810 	SND_PCI_QUIRK(0x1043, 0x3f30, "ASUS Strix G815LR_LW", ALC287_FIXUP_TAS2781_I2C),
10811 	SND_PCI_QUIRK(0x1043, 0x3fd0, "ASUS B3605CVA", ALC245_FIXUP_CS35L41_SPI_2),
10812 	SND_PCI_QUIRK(0x1043, 0x3ff0, "ASUS B5405CVA", ALC245_FIXUP_CS35L41_SPI_2),
10813 	SND_PCI_QUIRK(0x1043, 0x831a, "ASUS P901", ALC269_FIXUP_STEREO_DMIC),
10814 	SND_PCI_QUIRK(0x1043, 0x834a, "ASUS S101", ALC269_FIXUP_STEREO_DMIC),
10815 	SND_PCI_QUIRK(0x1043, 0x8398, "ASUS P1005", ALC269_FIXUP_STEREO_DMIC),
10816 	SND_PCI_QUIRK(0x1043, 0x83ce, "ASUS P1005", ALC269_FIXUP_STEREO_DMIC),
10817 	SND_PCI_QUIRK(0x1043, 0x8516, "ASUS X101CH", ALC269_FIXUP_ASUS_X101),
10818 	SND_PCI_QUIRK(0x104d, 0x9073, "Sony VAIO", ALC275_FIXUP_SONY_VAIO_GPIO2),
10819 	SND_PCI_QUIRK(0x104d, 0x907b, "Sony VAIO", ALC275_FIXUP_SONY_HWEQ),
10820 	SND_PCI_QUIRK(0x104d, 0x9084, "Sony VAIO", ALC275_FIXUP_SONY_HWEQ),
10821 	SND_PCI_QUIRK(0x104d, 0x9099, "Sony VAIO S13", ALC275_FIXUP_SONY_DISABLE_AAMIX),
10822 	SND_PCI_QUIRK(0x104d, 0x90b5, "Sony VAIO Pro 11", ALC286_FIXUP_SONY_MIC_NO_PRESENCE),
10823 	SND_PCI_QUIRK(0x104d, 0x90b6, "Sony VAIO Pro 13", ALC286_FIXUP_SONY_MIC_NO_PRESENCE),
10824 	SND_PCI_QUIRK(0x10cf, 0x1475, "Lifebook", ALC269_FIXUP_LIFEBOOK),
10825 	SND_PCI_QUIRK(0x10cf, 0x159f, "Lifebook E780", ALC269_FIXUP_LIFEBOOK_NO_HP_TO_LINEOUT),
10826 	SND_PCI_QUIRK(0x10cf, 0x15dc, "Lifebook T731", ALC269_FIXUP_LIFEBOOK_HP_PIN),
10827 	SND_PCI_QUIRK(0x10cf, 0x1629, "Lifebook U7x7", ALC255_FIXUP_LIFEBOOK_U7x7_HEADSET_MIC),
10828 	SND_PCI_QUIRK(0x10cf, 0x1757, "Lifebook E752", ALC269_FIXUP_LIFEBOOK_HP_PIN),
10829 	SND_PCI_QUIRK(0x10cf, 0x1845, "Lifebook U904", ALC269_FIXUP_LIFEBOOK_EXTMIC),
10830 	SND_PCI_QUIRK(0x10ec, 0x10f2, "Intel Reference board", ALC700_FIXUP_INTEL_REFERENCE),
10831 	SND_PCI_QUIRK(0x10ec, 0x118c, "Medion EE4254 MD62100", ALC256_FIXUP_MEDION_HEADSET_NO_PRESENCE),
10832 	SND_PCI_QUIRK(0x10ec, 0x119e, "Positivo SU C1400", ALC269_FIXUP_ASPIRE_HEADSET_MIC),
10833 	SND_PCI_QUIRK(0x10ec, 0x11bc, "VAIO VJFE-IL", ALC269_FIXUP_LIMIT_INT_MIC_BOOST),
10834 	SND_PCI_QUIRK(0x10ec, 0x1230, "Intel Reference board", ALC295_FIXUP_CHROME_BOOK),
10835 	SND_PCI_QUIRK(0x10ec, 0x124c, "Intel Reference board", ALC295_FIXUP_CHROME_BOOK),
10836 	SND_PCI_QUIRK(0x10ec, 0x1252, "Intel Reference board", ALC295_FIXUP_CHROME_BOOK),
10837 	SND_PCI_QUIRK(0x10ec, 0x1254, "Intel Reference board", ALC295_FIXUP_CHROME_BOOK),
10838 	SND_PCI_QUIRK(0x10ec, 0x12cc, "Intel Reference board", ALC295_FIXUP_CHROME_BOOK),
10839 	SND_PCI_QUIRK(0x10ec, 0x12f6, "Intel Reference board", ALC295_FIXUP_CHROME_BOOK),
10840 	SND_PCI_QUIRK(0x10f7, 0x8338, "Panasonic CF-SZ6", ALC269_FIXUP_ASPIRE_HEADSET_MIC),
10841 	SND_PCI_QUIRK(0x144d, 0xc109, "Samsung Ativ book 9 (NP900X3G)", ALC269_FIXUP_INV_DMIC),
10842 	SND_PCI_QUIRK(0x144d, 0xc169, "Samsung Notebook 9 Pen (NP930SBE-K01US)", ALC298_FIXUP_SAMSUNG_AMP),
10843 	SND_PCI_QUIRK(0x144d, 0xc176, "Samsung Notebook 9 Pro (NP930MBE-K04US)", ALC298_FIXUP_SAMSUNG_AMP),
10844 	SND_PCI_QUIRK(0x144d, 0xc189, "Samsung Galaxy Flex Book (NT950QCG-X716)", ALC298_FIXUP_SAMSUNG_AMP),
10845 	SND_PCI_QUIRK(0x144d, 0xc18a, "Samsung Galaxy Book Ion (NP930XCJ-K01US)", ALC298_FIXUP_SAMSUNG_AMP),
10846 	SND_PCI_QUIRK(0x144d, 0xc1a3, "Samsung Galaxy Book Pro (NP935XDB-KC1SE)", ALC298_FIXUP_SAMSUNG_AMP),
10847 	SND_PCI_QUIRK(0x144d, 0xc1a4, "Samsung Galaxy Book Pro 360 (NT935QBD)", ALC298_FIXUP_SAMSUNG_AMP),
10848 	SND_PCI_QUIRK(0x144d, 0xc1a6, "Samsung Galaxy Book Pro 360 (NP930QBD)", ALC298_FIXUP_SAMSUNG_AMP),
10849 	SND_PCI_QUIRK(0x144d, 0xc740, "Samsung Ativ book 8 (NP870Z5G)", ALC269_FIXUP_ATIV_BOOK_8),
10850 	SND_PCI_QUIRK(0x144d, 0xc812, "Samsung Notebook Pen S (NT950SBE-X58)", ALC298_FIXUP_SAMSUNG_AMP),
10851 	SND_PCI_QUIRK(0x144d, 0xc830, "Samsung Galaxy Book Ion (NT950XCJ-X716A)", ALC298_FIXUP_SAMSUNG_AMP),
10852 	SND_PCI_QUIRK(0x144d, 0xc832, "Samsung Galaxy Book Flex Alpha (NP730QCJ)", ALC256_FIXUP_SAMSUNG_HEADPHONE_VERY_QUIET),
10853 	SND_PCI_QUIRK(0x144d, 0xca03, "Samsung Galaxy Book2 Pro 360 (NP930QED)", ALC298_FIXUP_SAMSUNG_AMP),
10854 	SND_PCI_QUIRK(0x144d, 0xca06, "Samsung Galaxy Book3 360 (NP730QFG)", ALC298_FIXUP_SAMSUNG_HEADPHONE_VERY_QUIET),
10855 	SND_PCI_QUIRK(0x144d, 0xc868, "Samsung Galaxy Book2 Pro (NP930XED)", ALC298_FIXUP_SAMSUNG_AMP),
10856 	SND_PCI_QUIRK(0x144d, 0xc870, "Samsung Galaxy Book2 Pro (NP950XED)", ALC298_FIXUP_SAMSUNG_AMP_V2_2_AMPS),
10857 	SND_PCI_QUIRK(0x144d, 0xc872, "Samsung Galaxy Book2 Pro (NP950XEE)", ALC298_FIXUP_SAMSUNG_AMP_V2_2_AMPS),
10858 	SND_PCI_QUIRK(0x144d, 0xc886, "Samsung Galaxy Book3 Pro (NP964XFG)", ALC298_FIXUP_SAMSUNG_AMP_V2_4_AMPS),
10859 	SND_PCI_QUIRK(0x144d, 0xc1ca, "Samsung Galaxy Book3 Pro 360 (NP960QFG)", ALC298_FIXUP_SAMSUNG_AMP_V2_4_AMPS),
10860 	SND_PCI_QUIRK(0x144d, 0xc1cc, "Samsung Galaxy Book3 Ultra (NT960XFH)", ALC298_FIXUP_SAMSUNG_AMP_V2_4_AMPS),
10861 	SND_PCI_QUIRK(0x1458, 0xfa53, "Gigabyte BXBT-2807", ALC283_FIXUP_HEADSET_MIC),
10862 	SND_PCI_QUIRK(0x1462, 0xb120, "MSI Cubi MS-B120", ALC283_FIXUP_HEADSET_MIC),
10863 	SND_PCI_QUIRK(0x1462, 0xb171, "Cubi N 8GL (MS-B171)", ALC283_FIXUP_HEADSET_MIC),
10864 	SND_PCI_QUIRK(0x152d, 0x1082, "Quanta NL3", ALC269_FIXUP_LIFEBOOK),
10865 	SND_PCI_QUIRK(0x152d, 0x1262, "Huawei NBLB-WAX9N", ALC2XX_FIXUP_HEADSET_MIC),
10866 	SND_PCI_QUIRK(0x1558, 0x0353, "Clevo V35[05]SN[CDE]Q", ALC256_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10867 	SND_PCI_QUIRK(0x1558, 0x1323, "Clevo N130ZU", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10868 	SND_PCI_QUIRK(0x1558, 0x1325, "Clevo N15[01][CW]U", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10869 	SND_PCI_QUIRK(0x1558, 0x1401, "Clevo L140[CZ]U", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10870 	SND_PCI_QUIRK(0x1558, 0x1403, "Clevo N140CU", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10871 	SND_PCI_QUIRK(0x1558, 0x1404, "Clevo N150CU", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10872 	SND_PCI_QUIRK(0x1558, 0x14a1, "Clevo L141MU", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10873 	SND_PCI_QUIRK(0x1558, 0x2624, "Clevo L240TU", ALC256_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10874 	SND_PCI_QUIRK(0x1558, 0x28c1, "Clevo V370VND", ALC2XX_FIXUP_HEADSET_MIC),
10875 	SND_PCI_QUIRK(0x1558, 0x4018, "Clevo NV40M[BE]", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10876 	SND_PCI_QUIRK(0x1558, 0x4019, "Clevo NV40MZ", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10877 	SND_PCI_QUIRK(0x1558, 0x4020, "Clevo NV40MB", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10878 	SND_PCI_QUIRK(0x1558, 0x4041, "Clevo NV4[15]PZ", ALC256_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10879 	SND_PCI_QUIRK(0x1558, 0x40a1, "Clevo NL40GU", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10880 	SND_PCI_QUIRK(0x1558, 0x40c1, "Clevo NL40[CZ]U", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10881 	SND_PCI_QUIRK(0x1558, 0x40d1, "Clevo NL41DU", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10882 	SND_PCI_QUIRK(0x1558, 0x5015, "Clevo NH5[58]H[HJK]Q", ALC256_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10883 	SND_PCI_QUIRK(0x1558, 0x5017, "Clevo NH7[79]H[HJK]Q", ALC256_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10884 	SND_PCI_QUIRK(0x1558, 0x50a3, "Clevo NJ51GU", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10885 	SND_PCI_QUIRK(0x1558, 0x50b3, "Clevo NK50S[BEZ]", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10886 	SND_PCI_QUIRK(0x1558, 0x50b6, "Clevo NK50S5", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10887 	SND_PCI_QUIRK(0x1558, 0x50b8, "Clevo NK50SZ", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10888 	SND_PCI_QUIRK(0x1558, 0x50d5, "Clevo NP50D5", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10889 	SND_PCI_QUIRK(0x1558, 0x50e1, "Clevo NH5[58]HPQ", ALC256_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10890 	SND_PCI_QUIRK(0x1558, 0x50e2, "Clevo NH7[79]HPQ", ALC256_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10891 	SND_PCI_QUIRK(0x1558, 0x50f0, "Clevo NH50A[CDF]", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10892 	SND_PCI_QUIRK(0x1558, 0x50f2, "Clevo NH50E[PR]", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10893 	SND_PCI_QUIRK(0x1558, 0x50f3, "Clevo NH58DPQ", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10894 	SND_PCI_QUIRK(0x1558, 0x50f5, "Clevo NH55EPY", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10895 	SND_PCI_QUIRK(0x1558, 0x50f6, "Clevo NH55DPQ", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10896 	SND_PCI_QUIRK(0x1558, 0x5101, "Clevo S510WU", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10897 	SND_PCI_QUIRK(0x1558, 0x5157, "Clevo W517GU1", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10898 	SND_PCI_QUIRK(0x1558, 0x51a1, "Clevo NS50MU", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10899 	SND_PCI_QUIRK(0x1558, 0x51b1, "Clevo NS50AU", ALC256_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10900 	SND_PCI_QUIRK(0x1558, 0x51b3, "Clevo NS70AU", ALC256_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10901 	SND_PCI_QUIRK(0x1558, 0x5630, "Clevo NP50RNJS", ALC256_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10902 	SND_PCI_QUIRK(0x1558, 0x70a1, "Clevo NB70T[HJK]", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10903 	SND_PCI_QUIRK(0x1558, 0x70b3, "Clevo NK70SB", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10904 	SND_PCI_QUIRK(0x1558, 0x70f2, "Clevo NH79EPY", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10905 	SND_PCI_QUIRK(0x1558, 0x70f3, "Clevo NH77DPQ", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10906 	SND_PCI_QUIRK(0x1558, 0x70f4, "Clevo NH77EPY", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10907 	SND_PCI_QUIRK(0x1558, 0x70f6, "Clevo NH77DPQ-Y", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10908 	SND_PCI_QUIRK(0x1558, 0x7716, "Clevo NS50PU", ALC256_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10909 	SND_PCI_QUIRK(0x1558, 0x7717, "Clevo NS70PU", ALC256_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10910 	SND_PCI_QUIRK(0x1558, 0x7718, "Clevo L140PU", ALC256_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10911 	SND_PCI_QUIRK(0x1558, 0x7724, "Clevo L140AU", ALC256_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10912 	SND_PCI_QUIRK(0x1558, 0x8228, "Clevo NR40BU", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10913 	SND_PCI_QUIRK(0x1558, 0x8520, "Clevo NH50D[CD]", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10914 	SND_PCI_QUIRK(0x1558, 0x8521, "Clevo NH77D[CD]", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10915 	SND_PCI_QUIRK(0x1558, 0x8535, "Clevo NH50D[BE]", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10916 	SND_PCI_QUIRK(0x1558, 0x8536, "Clevo NH79D[BE]", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10917 	SND_PCI_QUIRK(0x1558, 0x8550, "Clevo NH[57][0-9][ER][ACDH]Q", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10918 	SND_PCI_QUIRK(0x1558, 0x8551, "Clevo NH[57][0-9][ER][ACDH]Q", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10919 	SND_PCI_QUIRK(0x1558, 0x8560, "Clevo NH[57][0-9][ER][ACDH]Q", ALC269_FIXUP_HEADSET_MIC),
10920 	SND_PCI_QUIRK(0x1558, 0x8561, "Clevo NH[57][0-9][ER][ACDH]Q", ALC269_FIXUP_HEADSET_MIC),
10921 	SND_PCI_QUIRK(0x1558, 0x8562, "Clevo NH[57][0-9]RZ[Q]", ALC269_FIXUP_DMIC),
10922 	SND_PCI_QUIRK(0x1558, 0x8668, "Clevo NP50B[BE]", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10923 	SND_PCI_QUIRK(0x1558, 0x866d, "Clevo NP5[05]PN[HJK]", ALC256_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10924 	SND_PCI_QUIRK(0x1558, 0x867c, "Clevo NP7[01]PNP", ALC256_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10925 	SND_PCI_QUIRK(0x1558, 0x867d, "Clevo NP7[01]PN[HJK]", ALC256_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10926 	SND_PCI_QUIRK(0x1558, 0x8680, "Clevo NJ50LU", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10927 	SND_PCI_QUIRK(0x1558, 0x8686, "Clevo NH50[CZ]U", ALC256_FIXUP_MIC_NO_PRESENCE_AND_RESUME),
10928 	SND_PCI_QUIRK(0x1558, 0x8a20, "Clevo NH55DCQ-Y", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10929 	SND_PCI_QUIRK(0x1558, 0x8a51, "Clevo NH70RCQ-Y", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10930 	SND_PCI_QUIRK(0x1558, 0x8d50, "Clevo NH55RCQ-M", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10931 	SND_PCI_QUIRK(0x1558, 0x951d, "Clevo N950T[CDF]", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10932 	SND_PCI_QUIRK(0x1558, 0x9600, "Clevo N960K[PR]", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10933 	SND_PCI_QUIRK(0x1558, 0x961d, "Clevo N960S[CDF]", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10934 	SND_PCI_QUIRK(0x1558, 0x971d, "Clevo N970T[CDF]", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10935 	SND_PCI_QUIRK(0x1558, 0xa500, "Clevo NL5[03]RU", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10936 	SND_PCI_QUIRK(0x1558, 0xa554, "VAIO VJFH52", ALC269_FIXUP_VAIO_VJFH52_MIC_NO_PRESENCE),
10937 	SND_PCI_QUIRK(0x1558, 0xa600, "Clevo NL50NU", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10938 	SND_PCI_QUIRK(0x1558, 0xa650, "Clevo NP[567]0SN[CD]", ALC256_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10939 	SND_PCI_QUIRK(0x1558, 0xa671, "Clevo NP70SN[CDE]", ALC256_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10940 	SND_PCI_QUIRK(0x1558, 0xa741, "Clevo V54x_6x_TNE", ALC245_FIXUP_CLEVO_NOISY_MIC),
10941 	SND_PCI_QUIRK(0x1558, 0xa763, "Clevo V54x_6x_TU", ALC245_FIXUP_CLEVO_NOISY_MIC),
10942 	SND_PCI_QUIRK(0x1558, 0xb018, "Clevo NP50D[BE]", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10943 	SND_PCI_QUIRK(0x1558, 0xb019, "Clevo NH77D[BE]Q", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10944 	SND_PCI_QUIRK(0x1558, 0xb022, "Clevo NH77D[DC][QW]", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10945 	SND_PCI_QUIRK(0x1558, 0xc018, "Clevo NP50D[BE]", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10946 	SND_PCI_QUIRK(0x1558, 0xc019, "Clevo NH77D[BE]Q", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10947 	SND_PCI_QUIRK(0x1558, 0xc022, "Clevo NH77[DC][QW]", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10948 	SND_PCI_QUIRK(0x17aa, 0x1036, "Lenovo P520", ALC233_FIXUP_LENOVO_MULTI_CODECS),
10949 	SND_PCI_QUIRK(0x17aa, 0x1048, "ThinkCentre Station", ALC623_FIXUP_LENOVO_THINKSTATION_P340),
10950 	SND_PCI_QUIRK(0x17aa, 0x20f2, "Thinkpad SL410/510", ALC269_FIXUP_SKU_IGNORE),
10951 	SND_PCI_QUIRK(0x17aa, 0x215e, "Thinkpad L512", ALC269_FIXUP_SKU_IGNORE),
10952 	SND_PCI_QUIRK(0x17aa, 0x21b8, "Thinkpad Edge 14", ALC269_FIXUP_SKU_IGNORE),
10953 	SND_PCI_QUIRK(0x17aa, 0x21ca, "Thinkpad L412", ALC269_FIXUP_SKU_IGNORE),
10954 	SND_PCI_QUIRK(0x17aa, 0x21e9, "Thinkpad Edge 15", ALC269_FIXUP_SKU_IGNORE),
10955 	SND_PCI_QUIRK(0x17aa, 0x21f3, "Thinkpad T430", ALC269_FIXUP_LENOVO_DOCK),
10956 	SND_PCI_QUIRK(0x17aa, 0x21f6, "Thinkpad T530", ALC269_FIXUP_LENOVO_DOCK_LIMIT_BOOST),
10957 	SND_PCI_QUIRK(0x17aa, 0x21fa, "Thinkpad X230", ALC269_FIXUP_LENOVO_DOCK),
10958 	SND_PCI_QUIRK(0x17aa, 0x21fb, "Thinkpad T430s", ALC269_FIXUP_LENOVO_DOCK),
10959 	SND_PCI_QUIRK(0x17aa, 0x2203, "Thinkpad X230 Tablet", ALC269_FIXUP_LENOVO_DOCK),
10960 	SND_PCI_QUIRK(0x17aa, 0x2208, "Thinkpad T431s", ALC269_FIXUP_LENOVO_DOCK),
10961 	SND_PCI_QUIRK(0x17aa, 0x220c, "Thinkpad T440s", ALC292_FIXUP_TPT440),
10962 	SND_PCI_QUIRK(0x17aa, 0x220e, "Thinkpad T440p", ALC292_FIXUP_TPT440_DOCK),
10963 	SND_PCI_QUIRK(0x17aa, 0x2210, "Thinkpad T540p", ALC292_FIXUP_TPT440_DOCK),
10964 	SND_PCI_QUIRK(0x17aa, 0x2211, "Thinkpad W541", ALC292_FIXUP_TPT440_DOCK),
10965 	SND_PCI_QUIRK(0x17aa, 0x2212, "Thinkpad T440", ALC292_FIXUP_TPT440_DOCK),
10966 	SND_PCI_QUIRK(0x17aa, 0x2214, "Thinkpad X240", ALC292_FIXUP_TPT440_DOCK),
10967 	SND_PCI_QUIRK(0x17aa, 0x2215, "Thinkpad", ALC269_FIXUP_LIMIT_INT_MIC_BOOST),
10968 	SND_PCI_QUIRK(0x17aa, 0x2218, "Thinkpad X1 Carbon 2nd", ALC292_FIXUP_TPT440_DOCK),
10969 	SND_PCI_QUIRK(0x17aa, 0x2223, "ThinkPad T550", ALC292_FIXUP_TPT440_DOCK),
10970 	SND_PCI_QUIRK(0x17aa, 0x2226, "ThinkPad X250", ALC292_FIXUP_TPT440_DOCK),
10971 	SND_PCI_QUIRK(0x17aa, 0x222d, "Thinkpad", ALC298_FIXUP_TPT470_DOCK),
10972 	SND_PCI_QUIRK(0x17aa, 0x222e, "Thinkpad", ALC298_FIXUP_TPT470_DOCK),
10973 	SND_PCI_QUIRK(0x17aa, 0x2231, "Thinkpad T560", ALC292_FIXUP_TPT460),
10974 	SND_PCI_QUIRK(0x17aa, 0x2233, "Thinkpad", ALC292_FIXUP_TPT460),
10975 	SND_PCI_QUIRK(0x17aa, 0x2234, "Thinkpad ICE-1", ALC287_FIXUP_TAS2781_I2C),
10976 	SND_PCI_QUIRK(0x17aa, 0x2245, "Thinkpad T470", ALC298_FIXUP_TPT470_DOCK),
10977 	SND_PCI_QUIRK(0x17aa, 0x2246, "Thinkpad", ALC298_FIXUP_TPT470_DOCK),
10978 	SND_PCI_QUIRK(0x17aa, 0x2247, "Thinkpad", ALC298_FIXUP_TPT470_DOCK),
10979 	SND_PCI_QUIRK(0x17aa, 0x2249, "Thinkpad", ALC292_FIXUP_TPT460),
10980 	SND_PCI_QUIRK(0x17aa, 0x224b, "Thinkpad", ALC298_FIXUP_TPT470_DOCK),
10981 	SND_PCI_QUIRK(0x17aa, 0x224c, "Thinkpad", ALC298_FIXUP_TPT470_DOCK),
10982 	SND_PCI_QUIRK(0x17aa, 0x224d, "Thinkpad", ALC298_FIXUP_TPT470_DOCK),
10983 	SND_PCI_QUIRK(0x17aa, 0x225d, "Thinkpad T480", ALC269_FIXUP_LIMIT_INT_MIC_BOOST),
10984 	SND_PCI_QUIRK(0x17aa, 0x2292, "Thinkpad X1 Carbon 7th", ALC285_FIXUP_THINKPAD_HEADSET_JACK),
10985 	SND_PCI_QUIRK(0x17aa, 0x22be, "Thinkpad X1 Carbon 8th", ALC285_FIXUP_THINKPAD_HEADSET_JACK),
10986 	SND_PCI_QUIRK(0x17aa, 0x22c1, "Thinkpad P1 Gen 3", ALC285_FIXUP_THINKPAD_NO_BASS_SPK_HEADSET_JACK),
10987 	SND_PCI_QUIRK(0x17aa, 0x22c2, "Thinkpad X1 Extreme Gen 3", ALC285_FIXUP_THINKPAD_NO_BASS_SPK_HEADSET_JACK),
10988 	SND_PCI_QUIRK(0x17aa, 0x22f1, "Thinkpad", ALC287_FIXUP_MG_RTKC_CSAMP_CS35L41_I2C_THINKPAD),
10989 	SND_PCI_QUIRK(0x17aa, 0x22f2, "Thinkpad", ALC287_FIXUP_MG_RTKC_CSAMP_CS35L41_I2C_THINKPAD),
10990 	SND_PCI_QUIRK(0x17aa, 0x22f3, "Thinkpad", ALC287_FIXUP_MG_RTKC_CSAMP_CS35L41_I2C_THINKPAD),
10991 	SND_PCI_QUIRK(0x17aa, 0x2316, "Thinkpad P1 Gen 6", ALC287_FIXUP_MG_RTKC_CSAMP_CS35L41_I2C_THINKPAD),
10992 	SND_PCI_QUIRK(0x17aa, 0x2317, "Thinkpad P1 Gen 6", ALC287_FIXUP_MG_RTKC_CSAMP_CS35L41_I2C_THINKPAD),
10993 	SND_PCI_QUIRK(0x17aa, 0x2318, "Thinkpad Z13 Gen2", ALC287_FIXUP_MG_RTKC_CSAMP_CS35L41_I2C_THINKPAD),
10994 	SND_PCI_QUIRK(0x17aa, 0x2319, "Thinkpad Z16 Gen2", ALC287_FIXUP_MG_RTKC_CSAMP_CS35L41_I2C_THINKPAD),
10995 	SND_PCI_QUIRK(0x17aa, 0x231a, "Thinkpad Z16 Gen2", ALC287_FIXUP_MG_RTKC_CSAMP_CS35L41_I2C_THINKPAD),
10996 	SND_PCI_QUIRK(0x17aa, 0x231e, "Thinkpad", ALC287_FIXUP_LENOVO_THKPAD_WH_ALC1318),
10997 	SND_PCI_QUIRK(0x17aa, 0x231f, "Thinkpad", ALC287_FIXUP_LENOVO_THKPAD_WH_ALC1318),
10998 	SND_PCI_QUIRK(0x17aa, 0x2326, "Hera2", ALC287_FIXUP_TAS2781_I2C),
10999 	SND_PCI_QUIRK(0x17aa, 0x30bb, "ThinkCentre AIO", ALC233_FIXUP_LENOVO_LINE2_MIC_HOTKEY),
11000 	SND_PCI_QUIRK(0x17aa, 0x30e2, "ThinkCentre AIO", ALC233_FIXUP_LENOVO_LINE2_MIC_HOTKEY),
11001 	SND_PCI_QUIRK(0x17aa, 0x310c, "ThinkCentre Station", ALC294_FIXUP_LENOVO_MIC_LOCATION),
11002 	SND_PCI_QUIRK(0x17aa, 0x3111, "ThinkCentre Station", ALC294_FIXUP_LENOVO_MIC_LOCATION),
11003 	SND_PCI_QUIRK(0x17aa, 0x312a, "ThinkCentre Station", ALC294_FIXUP_LENOVO_MIC_LOCATION),
11004 	SND_PCI_QUIRK(0x17aa, 0x312f, "ThinkCentre Station", ALC294_FIXUP_LENOVO_MIC_LOCATION),
11005 	SND_PCI_QUIRK(0x17aa, 0x313c, "ThinkCentre Station", ALC294_FIXUP_LENOVO_MIC_LOCATION),
11006 	SND_PCI_QUIRK(0x17aa, 0x3151, "ThinkCentre Station", ALC283_FIXUP_HEADSET_MIC),
11007 	SND_PCI_QUIRK(0x17aa, 0x3176, "ThinkCentre Station", ALC283_FIXUP_HEADSET_MIC),
11008 	SND_PCI_QUIRK(0x17aa, 0x3178, "ThinkCentre Station", ALC283_FIXUP_HEADSET_MIC),
11009 	SND_PCI_QUIRK(0x17aa, 0x31af, "ThinkCentre Station", ALC623_FIXUP_LENOVO_THINKSTATION_P340),
11010 	SND_PCI_QUIRK(0x17aa, 0x334b, "Lenovo ThinkCentre M70 Gen5", ALC283_FIXUP_HEADSET_MIC),
11011 	SND_PCI_QUIRK(0x17aa, 0x3384, "ThinkCentre M90a PRO", ALC233_FIXUP_LENOVO_L2MH_LOW_ENLED),
11012 	SND_PCI_QUIRK(0x17aa, 0x3386, "ThinkCentre M90a Gen6", ALC233_FIXUP_LENOVO_L2MH_LOW_ENLED),
11013 	SND_PCI_QUIRK(0x17aa, 0x3387, "ThinkCentre M70a Gen6", ALC233_FIXUP_LENOVO_L2MH_LOW_ENLED),
11014 	SND_PCI_QUIRK(0x17aa, 0x3801, "Lenovo Yoga9 14IAP7", ALC287_FIXUP_YOGA9_14IAP7_BASS_SPK_PIN),
11015 	HDA_CODEC_QUIRK(0x17aa, 0x3802, "DuetITL 2021", ALC287_FIXUP_YOGA7_14ITL_SPEAKERS),
11016 	SND_PCI_QUIRK(0x17aa, 0x3802, "Lenovo Yoga Pro 9 14IRP8", ALC287_FIXUP_TAS2781_I2C),
11017 	SND_PCI_QUIRK(0x17aa, 0x3813, "Legion 7i 15IMHG05", ALC287_FIXUP_LEGION_15IMHG05_SPEAKERS),
11018 	SND_PCI_QUIRK(0x17aa, 0x3818, "Lenovo C940 / Yoga Duet 7", ALC298_FIXUP_LENOVO_C940_DUET7),
11019 	SND_PCI_QUIRK(0x17aa, 0x3819, "Lenovo 13s Gen2 ITL", ALC287_FIXUP_13S_GEN2_SPEAKERS),
11020 	HDA_CODEC_QUIRK(0x17aa, 0x3820, "IdeaPad 330-17IKB 81DM", ALC269_FIXUP_ASPIRE_HEADSET_MIC),
11021 	SND_PCI_QUIRK(0x17aa, 0x3820, "Yoga Duet 7 13ITL6", ALC287_FIXUP_YOGA7_14ITL_SPEAKERS),
11022 	SND_PCI_QUIRK(0x17aa, 0x3824, "Legion Y9000X 2020", ALC285_FIXUP_LEGION_Y9000X_SPEAKERS),
11023 	SND_PCI_QUIRK(0x17aa, 0x3827, "Ideapad S740", ALC285_FIXUP_IDEAPAD_S740_COEF),
11024 	SND_PCI_QUIRK(0x17aa, 0x3834, "Lenovo IdeaPad Slim 9i 14ITL5", ALC287_FIXUP_YOGA7_14ITL_SPEAKERS),
11025 	SND_PCI_QUIRK(0x17aa, 0x383d, "Legion Y9000X 2019", ALC285_FIXUP_LEGION_Y9000X_SPEAKERS),
11026 	SND_PCI_QUIRK(0x17aa, 0x3843, "Yoga 9i", ALC287_FIXUP_IDEAPAD_BASS_SPK_AMP),
11027 	SND_PCI_QUIRK(0x17aa, 0x3847, "Legion 7 16ACHG6", ALC287_FIXUP_LEGION_16ACHG6),
11028 	SND_PCI_QUIRK(0x17aa, 0x384a, "Lenovo Yoga 7 15ITL5", ALC287_FIXUP_YOGA7_14ITL_SPEAKERS),
11029 	SND_PCI_QUIRK(0x17aa, 0x3852, "Lenovo Yoga 7 14ITL5", ALC287_FIXUP_YOGA7_14ITL_SPEAKERS),
11030 	SND_PCI_QUIRK(0x17aa, 0x3853, "Lenovo Yoga 7 15ITL5", ALC287_FIXUP_YOGA7_14ITL_SPEAKERS),
11031 	SND_PCI_QUIRK(0x17aa, 0x3855, "Legion 7 16ITHG6", ALC287_FIXUP_LEGION_16ITHG6),
11032 	SND_PCI_QUIRK(0x17aa, 0x3865, "Lenovo 13X", ALC287_FIXUP_CS35L41_I2C_2),
11033 	SND_PCI_QUIRK(0x17aa, 0x3866, "Lenovo 13X", ALC287_FIXUP_CS35L41_I2C_2),
11034 	SND_PCI_QUIRK(0x17aa, 0x3869, "Lenovo Yoga7 14IAL7", ALC287_FIXUP_YOGA9_14IAP7_BASS_SPK_PIN),
11035 	HDA_CODEC_QUIRK(0x17aa, 0x386e, "Legion Y9000X 2022 IAH7", ALC287_FIXUP_CS35L41_I2C_2),
11036 	SND_PCI_QUIRK(0x17aa, 0x386e, "Yoga Pro 7 14ARP8", ALC285_FIXUP_SPEAKER2_TO_DAC1),
11037 	HDA_CODEC_QUIRK(0x17aa, 0x38a8, "Legion Pro 7 16ARX8H", ALC287_FIXUP_TAS2781_I2C), /* this must match before PCI SSID 17aa:386f below */
11038 	SND_PCI_QUIRK(0x17aa, 0x386f, "Legion Pro 7i 16IAX7", ALC287_FIXUP_CS35L41_I2C_2),
11039 	SND_PCI_QUIRK(0x17aa, 0x3870, "Lenovo Yoga 7 14ARB7", ALC287_FIXUP_YOGA7_14ARB7_I2C),
11040 	SND_PCI_QUIRK(0x17aa, 0x3877, "Lenovo Legion 7 Slim 16ARHA7", ALC287_FIXUP_CS35L41_I2C_2),
11041 	SND_PCI_QUIRK(0x17aa, 0x3878, "Lenovo Legion 7 Slim 16ARHA7", ALC287_FIXUP_CS35L41_I2C_2),
11042 	SND_PCI_QUIRK(0x17aa, 0x387d, "Yoga S780-16 pro Quad AAC", ALC287_FIXUP_TAS2781_I2C),
11043 	SND_PCI_QUIRK(0x17aa, 0x387e, "Yoga S780-16 pro Quad YC", ALC287_FIXUP_TAS2781_I2C),
11044 	SND_PCI_QUIRK(0x17aa, 0x387f, "Yoga S780-16 pro dual LX", ALC287_FIXUP_TAS2781_I2C),
11045 	SND_PCI_QUIRK(0x17aa, 0x3880, "Yoga S780-16 pro dual YC", ALC287_FIXUP_TAS2781_I2C),
11046 	SND_PCI_QUIRK(0x17aa, 0x3881, "YB9 dual power mode2 YC", ALC287_FIXUP_TAS2781_I2C),
11047 	SND_PCI_QUIRK(0x17aa, 0x3882, "Lenovo Yoga Pro 7 14APH8", ALC287_FIXUP_YOGA9_14IAP7_BASS_SPK_PIN),
11048 	SND_PCI_QUIRK(0x17aa, 0x3884, "Y780 YG DUAL", ALC287_FIXUP_TAS2781_I2C),
11049 	SND_PCI_QUIRK(0x17aa, 0x3886, "Y780 VECO DUAL", ALC287_FIXUP_TAS2781_I2C),
11050 	SND_PCI_QUIRK(0x17aa, 0x3891, "Lenovo Yoga Pro 7 14AHP9", ALC287_FIXUP_YOGA9_14IAP7_BASS_SPK_PIN),
11051 	SND_PCI_QUIRK(0x17aa, 0x38a5, "Y580P AMD dual", ALC287_FIXUP_TAS2781_I2C),
11052 	SND_PCI_QUIRK(0x17aa, 0x38a7, "Y780P AMD YG dual", ALC287_FIXUP_TAS2781_I2C),
11053 	SND_PCI_QUIRK(0x17aa, 0x38a8, "Y780P AMD VECO dual", ALC287_FIXUP_TAS2781_I2C),
11054 	SND_PCI_QUIRK(0x17aa, 0x38a9, "Thinkbook 16P", ALC287_FIXUP_MG_RTKC_CSAMP_CS35L41_I2C_THINKPAD),
11055 	SND_PCI_QUIRK(0x17aa, 0x38ab, "Thinkbook 16P", ALC287_FIXUP_MG_RTKC_CSAMP_CS35L41_I2C_THINKPAD),
11056 	SND_PCI_QUIRK(0x17aa, 0x38b4, "Legion Slim 7 16IRH8", ALC287_FIXUP_CS35L41_I2C_2),
11057 	SND_PCI_QUIRK(0x17aa, 0x38b5, "Legion Slim 7 16IRH8", ALC287_FIXUP_CS35L41_I2C_2),
11058 	SND_PCI_QUIRK(0x17aa, 0x38b6, "Legion Slim 7 16APH8", ALC287_FIXUP_CS35L41_I2C_2),
11059 	SND_PCI_QUIRK(0x17aa, 0x38b7, "Legion Slim 7 16APH8", ALC287_FIXUP_CS35L41_I2C_2),
11060 	SND_PCI_QUIRK(0x17aa, 0x38b8, "Yoga S780-14.5 proX AMD YC Dual", ALC287_FIXUP_TAS2781_I2C),
11061 	SND_PCI_QUIRK(0x17aa, 0x38b9, "Yoga S780-14.5 proX AMD LX Dual", ALC287_FIXUP_TAS2781_I2C),
11062 	SND_PCI_QUIRK(0x17aa, 0x38ba, "Yoga S780-14.5 Air AMD quad YC", ALC287_FIXUP_TAS2781_I2C),
11063 	SND_PCI_QUIRK(0x17aa, 0x38bb, "Yoga S780-14.5 Air AMD quad AAC", ALC287_FIXUP_TAS2781_I2C),
11064 	SND_PCI_QUIRK(0x17aa, 0x38be, "Yoga S980-14.5 proX YC Dual", ALC287_FIXUP_TAS2781_I2C),
11065 	SND_PCI_QUIRK(0x17aa, 0x38bf, "Yoga S980-14.5 proX LX Dual", ALC287_FIXUP_TAS2781_I2C),
11066 	SND_PCI_QUIRK(0x17aa, 0x38c3, "Y980 DUAL", ALC287_FIXUP_TAS2781_I2C),
11067 	SND_PCI_QUIRK(0x17aa, 0x38c7, "Thinkbook 13x Gen 4", ALC287_FIXUP_CS35L41_I2C_4),
11068 	SND_PCI_QUIRK(0x17aa, 0x38c8, "Thinkbook 13x Gen 4", ALC287_FIXUP_CS35L41_I2C_4),
11069 	SND_PCI_QUIRK(0x17aa, 0x38cb, "Y790 YG DUAL", ALC287_FIXUP_TAS2781_I2C),
11070 	SND_PCI_QUIRK(0x17aa, 0x38cd, "Y790 VECO DUAL", ALC287_FIXUP_TAS2781_I2C),
11071 	SND_PCI_QUIRK(0x17aa, 0x38d2, "Lenovo Yoga 9 14IMH9", ALC287_FIXUP_YOGA9_14IMH9_BASS_SPK_PIN),
11072 	SND_PCI_QUIRK(0x17aa, 0x38d3, "Yoga S990-16 Pro IMH YC Dual", ALC287_FIXUP_TAS2781_I2C),
11073 	SND_PCI_QUIRK(0x17aa, 0x38d4, "Yoga S990-16 Pro IMH VECO Dual", ALC287_FIXUP_TAS2781_I2C),
11074 	SND_PCI_QUIRK(0x17aa, 0x38d5, "Yoga S990-16 Pro IMH YC Quad", ALC287_FIXUP_TAS2781_I2C),
11075 	SND_PCI_QUIRK(0x17aa, 0x38d6, "Yoga S990-16 Pro IMH VECO Quad", ALC287_FIXUP_TAS2781_I2C),
11076 	SND_PCI_QUIRK(0x17aa, 0x38d7, "Lenovo Yoga 9 14IMH9", ALC287_FIXUP_YOGA9_14IMH9_BASS_SPK_PIN),
11077 	SND_PCI_QUIRK(0x17aa, 0x38df, "Yoga Y990 Intel YC Dual", ALC287_FIXUP_TAS2781_I2C),
11078 	SND_PCI_QUIRK(0x17aa, 0x38e0, "Yoga Y990 Intel VECO Dual", ALC287_FIXUP_TAS2781_I2C),
11079 	SND_PCI_QUIRK(0x17aa, 0x38f8, "Yoga Book 9i", ALC287_FIXUP_TAS2781_I2C),
11080 	SND_PCI_QUIRK(0x17aa, 0x38df, "Y990 YG DUAL", ALC287_FIXUP_TAS2781_I2C),
11081 	SND_PCI_QUIRK(0x17aa, 0x38f9, "Thinkbook 16P Gen5", ALC287_FIXUP_MG_RTKC_CSAMP_CS35L41_I2C_THINKPAD),
11082 	SND_PCI_QUIRK(0x17aa, 0x38fa, "Thinkbook 16P Gen5", ALC287_FIXUP_MG_RTKC_CSAMP_CS35L41_I2C_THINKPAD),
11083 	SND_PCI_QUIRK(0x17aa, 0x38fd, "ThinkBook plus Gen5 Hybrid", ALC287_FIXUP_TAS2781_I2C),
11084 	SND_PCI_QUIRK(0x17aa, 0x3902, "Lenovo E50-80", ALC269_FIXUP_DMIC_THINKPAD_ACPI),
11085 	SND_PCI_QUIRK(0x17aa, 0x3913, "Lenovo 145", ALC236_FIXUP_LENOVO_INV_DMIC),
11086 	SND_PCI_QUIRK(0x17aa, 0x391f, "Yoga S990-16 pro Quad YC Quad", ALC287_FIXUP_TAS2781_I2C),
11087 	SND_PCI_QUIRK(0x17aa, 0x3920, "Yoga S990-16 pro Quad VECO Quad", ALC287_FIXUP_TAS2781_I2C),
11088 	SND_PCI_QUIRK(0x17aa, 0x3977, "IdeaPad S210", ALC283_FIXUP_INT_MIC),
11089 	SND_PCI_QUIRK(0x17aa, 0x3978, "Lenovo B50-70", ALC269_FIXUP_DMIC_THINKPAD_ACPI),
11090 	SND_PCI_QUIRK(0x17aa, 0x3bf8, "Quanta FL1", ALC269_FIXUP_PCM_44K),
11091 	SND_PCI_QUIRK(0x17aa, 0x5013, "Thinkpad", ALC269_FIXUP_LIMIT_INT_MIC_BOOST),
11092 	SND_PCI_QUIRK(0x17aa, 0x501a, "Thinkpad", ALC283_FIXUP_INT_MIC),
11093 	SND_PCI_QUIRK(0x17aa, 0x501e, "Thinkpad L440", ALC292_FIXUP_TPT440_DOCK),
11094 	SND_PCI_QUIRK(0x17aa, 0x5026, "Thinkpad", ALC269_FIXUP_LIMIT_INT_MIC_BOOST),
11095 	SND_PCI_QUIRK(0x17aa, 0x5034, "Thinkpad T450", ALC292_FIXUP_TPT440_DOCK),
11096 	SND_PCI_QUIRK(0x17aa, 0x5036, "Thinkpad T450s", ALC292_FIXUP_TPT440_DOCK),
11097 	SND_PCI_QUIRK(0x17aa, 0x503c, "Thinkpad L450", ALC292_FIXUP_TPT440_DOCK),
11098 	SND_PCI_QUIRK(0x17aa, 0x504a, "ThinkPad X260", ALC292_FIXUP_TPT440_DOCK),
11099 	SND_PCI_QUIRK(0x17aa, 0x504b, "Thinkpad", ALC293_FIXUP_LENOVO_SPK_NOISE),
11100 	SND_PCI_QUIRK(0x17aa, 0x5050, "Thinkpad T560p", ALC292_FIXUP_TPT460),
11101 	SND_PCI_QUIRK(0x17aa, 0x5051, "Thinkpad L460", ALC292_FIXUP_TPT460),
11102 	SND_PCI_QUIRK(0x17aa, 0x5053, "Thinkpad T460", ALC292_FIXUP_TPT460),
11103 	SND_PCI_QUIRK(0x17aa, 0x505d, "Thinkpad", ALC298_FIXUP_TPT470_DOCK),
11104 	SND_PCI_QUIRK(0x17aa, 0x505f, "Thinkpad", ALC298_FIXUP_TPT470_DOCK),
11105 	SND_PCI_QUIRK(0x17aa, 0x5062, "Thinkpad", ALC298_FIXUP_TPT470_DOCK),
11106 	SND_PCI_QUIRK(0x17aa, 0x508b, "Thinkpad X12 Gen 1", ALC287_FIXUP_LEGION_15IMHG05_SPEAKERS),
11107 	SND_PCI_QUIRK(0x17aa, 0x5109, "Thinkpad", ALC269_FIXUP_LIMIT_INT_MIC_BOOST),
11108 	SND_PCI_QUIRK(0x17aa, 0x511e, "Thinkpad", ALC298_FIXUP_TPT470_DOCK),
11109 	SND_PCI_QUIRK(0x17aa, 0x511f, "Thinkpad", ALC298_FIXUP_TPT470_DOCK),
11110 	SND_PCI_QUIRK(0x17aa, 0x9e54, "LENOVO NB", ALC269_FIXUP_LENOVO_EAPD),
11111 	SND_PCI_QUIRK(0x17aa, 0x9e56, "Lenovo ZhaoYang CF4620Z", ALC286_FIXUP_SONY_MIC_NO_PRESENCE),
11112 	SND_PCI_QUIRK(0x1849, 0x0269, "Positivo Master C6400", ALC269VB_FIXUP_ASUS_ZENBOOK),
11113 	SND_PCI_QUIRK(0x1849, 0x1233, "ASRock NUC Box 1100", ALC233_FIXUP_NO_AUDIO_JACK),
11114 	SND_PCI_QUIRK(0x1849, 0xa233, "Positivo Master C6300", ALC269_FIXUP_HEADSET_MIC),
11115 	SND_PCI_QUIRK(0x1854, 0x0440, "LG CQ6", ALC256_FIXUP_HEADPHONE_AMP_VOL),
11116 	SND_PCI_QUIRK(0x1854, 0x0441, "LG CQ6 AIO", ALC256_FIXUP_HEADPHONE_AMP_VOL),
11117 	SND_PCI_QUIRK(0x1854, 0x0488, "LG gram 16 (16Z90R)", ALC298_FIXUP_SAMSUNG_AMP_V2_4_AMPS),
11118 	SND_PCI_QUIRK(0x1854, 0x048a, "LG gram 17 (17ZD90R)", ALC298_FIXUP_SAMSUNG_AMP_V2_4_AMPS),
11119 	SND_PCI_QUIRK(0x19e5, 0x3204, "Huawei MACH-WX9", ALC256_FIXUP_HUAWEI_MACH_WX9_PINS),
11120 	SND_PCI_QUIRK(0x19e5, 0x320f, "Huawei WRT-WX9 ", ALC256_FIXUP_ASUS_MIC_NO_PRESENCE),
11121 	SND_PCI_QUIRK(0x19e5, 0x3212, "Huawei KLV-WX9 ", ALC256_FIXUP_ACER_HEADSET_MIC),
11122 	SND_PCI_QUIRK(0x1b35, 0x1235, "CZC B20", ALC269_FIXUP_CZC_B20),
11123 	SND_PCI_QUIRK(0x1b35, 0x1236, "CZC TMI", ALC269_FIXUP_CZC_TMI),
11124 	SND_PCI_QUIRK(0x1b35, 0x1237, "CZC L101", ALC269_FIXUP_CZC_L101),
11125 	SND_PCI_QUIRK(0x1b7d, 0xa831, "Ordissimo EVE2 ", ALC269VB_FIXUP_ORDISSIMO_EVE2), /* Also known as Malata PC-B1303 */
11126 	SND_PCI_QUIRK(0x1c06, 0x2013, "Lemote A1802", ALC269_FIXUP_LEMOTE_A1802),
11127 	SND_PCI_QUIRK(0x1c06, 0x2015, "Lemote A190X", ALC269_FIXUP_LEMOTE_A190X),
11128 	SND_PCI_QUIRK(0x1c6c, 0x122a, "Positivo N14AP7", ALC269_FIXUP_LIMIT_INT_MIC_BOOST),
11129 	SND_PCI_QUIRK(0x1c6c, 0x1251, "Positivo N14KP6-TG", ALC288_FIXUP_DELL1_MIC_NO_PRESENCE),
11130 	SND_PCI_QUIRK(0x1d05, 0x1132, "TongFang PHxTxX1", ALC256_FIXUP_SET_COEF_DEFAULTS),
11131 	SND_PCI_QUIRK(0x1d05, 0x1096, "TongFang GMxMRxx", ALC269_FIXUP_NO_SHUTUP),
11132 	SND_PCI_QUIRK(0x1d05, 0x1100, "TongFang GKxNRxx", ALC269_FIXUP_NO_SHUTUP),
11133 	SND_PCI_QUIRK(0x1d05, 0x1111, "TongFang GMxZGxx", ALC269_FIXUP_NO_SHUTUP),
11134 	SND_PCI_QUIRK(0x1d05, 0x1119, "TongFang GMxZGxx", ALC269_FIXUP_NO_SHUTUP),
11135 	SND_PCI_QUIRK(0x1d05, 0x1129, "TongFang GMxZGxx", ALC269_FIXUP_NO_SHUTUP),
11136 	SND_PCI_QUIRK(0x1d05, 0x1147, "TongFang GMxTGxx", ALC269_FIXUP_NO_SHUTUP),
11137 	SND_PCI_QUIRK(0x1d05, 0x115c, "TongFang GMxTGxx", ALC269_FIXUP_NO_SHUTUP),
11138 	SND_PCI_QUIRK(0x1d05, 0x121b, "TongFang GMxAGxx", ALC269_FIXUP_NO_SHUTUP),
11139 	SND_PCI_QUIRK(0x1d05, 0x1387, "TongFang GMxIXxx", ALC2XX_FIXUP_HEADSET_MIC),
11140 	SND_PCI_QUIRK(0x1d05, 0x1409, "TongFang GMxIXxx", ALC2XX_FIXUP_HEADSET_MIC),
11141 	SND_PCI_QUIRK(0x1d17, 0x3288, "Haier Boyue G42", ALC269VC_FIXUP_ACER_VCOPPERBOX_PINS),
11142 	SND_PCI_QUIRK(0x1d72, 0x1602, "RedmiBook", ALC255_FIXUP_XIAOMI_HEADSET_MIC),
11143 	SND_PCI_QUIRK(0x1d72, 0x1701, "XiaomiNotebook Pro", ALC298_FIXUP_DELL1_MIC_NO_PRESENCE),
11144 	SND_PCI_QUIRK(0x1d72, 0x1901, "RedmiBook 14", ALC256_FIXUP_ASUS_HEADSET_MIC),
11145 	SND_PCI_QUIRK(0x1d72, 0x1945, "Redmi G", ALC256_FIXUP_ASUS_HEADSET_MIC),
11146 	SND_PCI_QUIRK(0x1d72, 0x1947, "RedmiBook Air", ALC255_FIXUP_XIAOMI_HEADSET_MIC),
11147 	SND_PCI_QUIRK(0x1f66, 0x0105, "Ayaneo Portable Game Player", ALC287_FIXUP_CS35L41_I2C_2),
11148 	SND_PCI_QUIRK(0x2014, 0x800a, "Positivo ARN50", ALC269_FIXUP_LIMIT_INT_MIC_BOOST),
11149 	SND_PCI_QUIRK(0x2782, 0x0214, "VAIO VJFE-CL", ALC269_FIXUP_LIMIT_INT_MIC_BOOST),
11150 	SND_PCI_QUIRK(0x2782, 0x0228, "Infinix ZERO BOOK 13", ALC269VB_FIXUP_INFINIX_ZERO_BOOK_13),
11151 	SND_PCI_QUIRK(0x2782, 0x0232, "CHUWI CoreBook XPro", ALC269VB_FIXUP_CHUWI_COREBOOK_XPRO),
11152 	SND_PCI_QUIRK(0x2782, 0x1701, "Infinix Y4 Max", ALC269VC_FIXUP_INFINIX_Y4_MAX),
11153 	SND_PCI_QUIRK(0x2782, 0x1705, "MEDION E15433", ALC269VC_FIXUP_INFINIX_Y4_MAX),
11154 	SND_PCI_QUIRK(0x2782, 0x1707, "Vaio VJFE-ADL", ALC298_FIXUP_SPK_VOLUME),
11155 	SND_PCI_QUIRK(0x2782, 0x4900, "MEDION E15443", ALC233_FIXUP_MEDION_MTL_SPK),
11156 	SND_PCI_QUIRK(0x8086, 0x2074, "Intel NUC 8", ALC233_FIXUP_INTEL_NUC8_DMIC),
11157 	SND_PCI_QUIRK(0x8086, 0x2080, "Intel NUC 8 Rugged", ALC256_FIXUP_INTEL_NUC8_RUGGED),
11158 	SND_PCI_QUIRK(0x8086, 0x2081, "Intel NUC 10", ALC256_FIXUP_INTEL_NUC10),
11159 	SND_PCI_QUIRK(0x8086, 0x3038, "Intel NUC 13", ALC295_FIXUP_CHROME_BOOK),
11160 	SND_PCI_QUIRK(0xf111, 0x0001, "Framework Laptop", ALC295_FIXUP_FRAMEWORK_LAPTOP_MIC_NO_PRESENCE),
11161 	SND_PCI_QUIRK(0xf111, 0x0006, "Framework Laptop", ALC295_FIXUP_FRAMEWORK_LAPTOP_MIC_NO_PRESENCE),
11162 	SND_PCI_QUIRK(0xf111, 0x0009, "Framework Laptop", ALC295_FIXUP_FRAMEWORK_LAPTOP_MIC_NO_PRESENCE),
11163 	SND_PCI_QUIRK(0xf111, 0x000c, "Framework Laptop", ALC295_FIXUP_FRAMEWORK_LAPTOP_MIC_NO_PRESENCE),
11164 
11165 #if 0
11166 	/* Below is a quirk table taken from the old code.
11167 	 * Basically the device should work as is without the fixup table.
11168 	 * If BIOS doesn't give a proper info, enable the corresponding
11169 	 * fixup entry.
11170 	 */
11171 	SND_PCI_QUIRK(0x1043, 0x8330, "ASUS Eeepc P703 P900A",
11172 		      ALC269_FIXUP_AMIC),
11173 	SND_PCI_QUIRK(0x1043, 0x1013, "ASUS N61Da", ALC269_FIXUP_AMIC),
11174 	SND_PCI_QUIRK(0x1043, 0x1143, "ASUS B53f", ALC269_FIXUP_AMIC),
11175 	SND_PCI_QUIRK(0x1043, 0x1133, "ASUS UJ20ft", ALC269_FIXUP_AMIC),
11176 	SND_PCI_QUIRK(0x1043, 0x1183, "ASUS K72DR", ALC269_FIXUP_AMIC),
11177 	SND_PCI_QUIRK(0x1043, 0x11b3, "ASUS K52DR", ALC269_FIXUP_AMIC),
11178 	SND_PCI_QUIRK(0x1043, 0x11e3, "ASUS U33Jc", ALC269_FIXUP_AMIC),
11179 	SND_PCI_QUIRK(0x1043, 0x1273, "ASUS UL80Jt", ALC269_FIXUP_AMIC),
11180 	SND_PCI_QUIRK(0x1043, 0x1283, "ASUS U53Jc", ALC269_FIXUP_AMIC),
11181 	SND_PCI_QUIRK(0x1043, 0x12b3, "ASUS N82JV", ALC269_FIXUP_AMIC),
11182 	SND_PCI_QUIRK(0x1043, 0x12d3, "ASUS N61Jv", ALC269_FIXUP_AMIC),
11183 	SND_PCI_QUIRK(0x1043, 0x13a3, "ASUS UL30Vt", ALC269_FIXUP_AMIC),
11184 	SND_PCI_QUIRK(0x1043, 0x1373, "ASUS G73JX", ALC269_FIXUP_AMIC),
11185 	SND_PCI_QUIRK(0x1043, 0x1383, "ASUS UJ30Jc", ALC269_FIXUP_AMIC),
11186 	SND_PCI_QUIRK(0x1043, 0x13d3, "ASUS N61JA", ALC269_FIXUP_AMIC),
11187 	SND_PCI_QUIRK(0x1043, 0x1413, "ASUS UL50", ALC269_FIXUP_AMIC),
11188 	SND_PCI_QUIRK(0x1043, 0x1443, "ASUS UL30", ALC269_FIXUP_AMIC),
11189 	SND_PCI_QUIRK(0x1043, 0x1453, "ASUS M60Jv", ALC269_FIXUP_AMIC),
11190 	SND_PCI_QUIRK(0x1043, 0x1483, "ASUS UL80", ALC269_FIXUP_AMIC),
11191 	SND_PCI_QUIRK(0x1043, 0x14f3, "ASUS F83Vf", ALC269_FIXUP_AMIC),
11192 	SND_PCI_QUIRK(0x1043, 0x14e3, "ASUS UL20", ALC269_FIXUP_AMIC),
11193 	SND_PCI_QUIRK(0x1043, 0x1513, "ASUS UX30", ALC269_FIXUP_AMIC),
11194 	SND_PCI_QUIRK(0x1043, 0x1593, "ASUS N51Vn", ALC269_FIXUP_AMIC),
11195 	SND_PCI_QUIRK(0x1043, 0x15a3, "ASUS N60Jv", ALC269_FIXUP_AMIC),
11196 	SND_PCI_QUIRK(0x1043, 0x15b3, "ASUS N60Dp", ALC269_FIXUP_AMIC),
11197 	SND_PCI_QUIRK(0x1043, 0x15c3, "ASUS N70De", ALC269_FIXUP_AMIC),
11198 	SND_PCI_QUIRK(0x1043, 0x15e3, "ASUS F83T", ALC269_FIXUP_AMIC),
11199 	SND_PCI_QUIRK(0x1043, 0x1643, "ASUS M60J", ALC269_FIXUP_AMIC),
11200 	SND_PCI_QUIRK(0x1043, 0x1653, "ASUS U50", ALC269_FIXUP_AMIC),
11201 	SND_PCI_QUIRK(0x1043, 0x1693, "ASUS F50N", ALC269_FIXUP_AMIC),
11202 	SND_PCI_QUIRK(0x1043, 0x16a3, "ASUS F5Q", ALC269_FIXUP_AMIC),
11203 	SND_PCI_QUIRK(0x1043, 0x1723, "ASUS P80", ALC269_FIXUP_AMIC),
11204 	SND_PCI_QUIRK(0x1043, 0x1743, "ASUS U80", ALC269_FIXUP_AMIC),
11205 	SND_PCI_QUIRK(0x1043, 0x1773, "ASUS U20A", ALC269_FIXUP_AMIC),
11206 	SND_PCI_QUIRK(0x1043, 0x1883, "ASUS F81Se", ALC269_FIXUP_AMIC),
11207 	SND_PCI_QUIRK(0x152d, 0x1778, "Quanta ON1", ALC269_FIXUP_DMIC),
11208 	SND_PCI_QUIRK(0x17aa, 0x3be9, "Quanta Wistron", ALC269_FIXUP_AMIC),
11209 	SND_PCI_QUIRK(0x17aa, 0x3bf8, "Quanta FL1", ALC269_FIXUP_AMIC),
11210 	SND_PCI_QUIRK(0x17ff, 0x059a, "Quanta EL3", ALC269_FIXUP_DMIC),
11211 	SND_PCI_QUIRK(0x17ff, 0x059b, "Quanta JR1", ALC269_FIXUP_DMIC),
11212 #endif
11213 	{}
11214 };
11215 
11216 static const struct hda_quirk alc269_fixup_vendor_tbl[] = {
11217 	SND_PCI_QUIRK_VENDOR(0x1025, "Acer Aspire", ALC271_FIXUP_DMIC),
11218 	SND_PCI_QUIRK_VENDOR(0x103c, "HP", ALC269_FIXUP_HP_MUTE_LED),
11219 	SND_PCI_QUIRK_VENDOR(0x104d, "Sony VAIO", ALC269_FIXUP_SONY_VAIO),
11220 	SND_PCI_QUIRK_VENDOR(0x17aa, "Lenovo XPAD", ALC269_FIXUP_LENOVO_XPAD_ACPI),
11221 	SND_PCI_QUIRK_VENDOR(0x19e5, "Huawei Matebook", ALC255_FIXUP_MIC_MUTE_LED),
11222 	{}
11223 };
11224 
11225 static const struct hda_model_fixup alc269_fixup_models[] = {
11226 	{.id = ALC269_FIXUP_AMIC, .name = "laptop-amic"},
11227 	{.id = ALC269_FIXUP_DMIC, .name = "laptop-dmic"},
11228 	{.id = ALC269_FIXUP_STEREO_DMIC, .name = "alc269-dmic"},
11229 	{.id = ALC271_FIXUP_DMIC, .name = "alc271-dmic"},
11230 	{.id = ALC269_FIXUP_INV_DMIC, .name = "inv-dmic"},
11231 	{.id = ALC269_FIXUP_HEADSET_MIC, .name = "headset-mic"},
11232 	{.id = ALC269_FIXUP_HEADSET_MODE, .name = "headset-mode"},
11233 	{.id = ALC269_FIXUP_HEADSET_MODE_NO_HP_MIC, .name = "headset-mode-no-hp-mic"},
11234 	{.id = ALC269_FIXUP_LENOVO_DOCK, .name = "lenovo-dock"},
11235 	{.id = ALC269_FIXUP_LENOVO_DOCK_LIMIT_BOOST, .name = "lenovo-dock-limit-boost"},
11236 	{.id = ALC269_FIXUP_HP_GPIO_LED, .name = "hp-gpio-led"},
11237 	{.id = ALC269_FIXUP_HP_DOCK_GPIO_MIC1_LED, .name = "hp-dock-gpio-mic1-led"},
11238 	{.id = ALC269_FIXUP_DELL1_MIC_NO_PRESENCE, .name = "dell-headset-multi"},
11239 	{.id = ALC269_FIXUP_DELL2_MIC_NO_PRESENCE, .name = "dell-headset-dock"},
11240 	{.id = ALC269_FIXUP_DELL3_MIC_NO_PRESENCE, .name = "dell-headset3"},
11241 	{.id = ALC269_FIXUP_DELL4_MIC_NO_PRESENCE, .name = "dell-headset4"},
11242 	{.id = ALC269_FIXUP_DELL4_MIC_NO_PRESENCE_QUIET, .name = "dell-headset4-quiet"},
11243 	{.id = ALC283_FIXUP_CHROME_BOOK, .name = "alc283-dac-wcaps"},
11244 	{.id = ALC283_FIXUP_SENSE_COMBO_JACK, .name = "alc283-sense-combo"},
11245 	{.id = ALC292_FIXUP_TPT440_DOCK, .name = "tpt440-dock"},
11246 	{.id = ALC292_FIXUP_TPT440, .name = "tpt440"},
11247 	{.id = ALC292_FIXUP_TPT460, .name = "tpt460"},
11248 	{.id = ALC298_FIXUP_TPT470_DOCK_FIX, .name = "tpt470-dock-fix"},
11249 	{.id = ALC298_FIXUP_TPT470_DOCK, .name = "tpt470-dock"},
11250 	{.id = ALC233_FIXUP_LENOVO_MULTI_CODECS, .name = "dual-codecs"},
11251 	{.id = ALC700_FIXUP_INTEL_REFERENCE, .name = "alc700-ref"},
11252 	{.id = ALC269_FIXUP_SONY_VAIO, .name = "vaio"},
11253 	{.id = ALC269_FIXUP_DELL_M101Z, .name = "dell-m101z"},
11254 	{.id = ALC269_FIXUP_ASUS_G73JW, .name = "asus-g73jw"},
11255 	{.id = ALC269_FIXUP_LENOVO_EAPD, .name = "lenovo-eapd"},
11256 	{.id = ALC275_FIXUP_SONY_HWEQ, .name = "sony-hweq"},
11257 	{.id = ALC269_FIXUP_PCM_44K, .name = "pcm44k"},
11258 	{.id = ALC269_FIXUP_LIFEBOOK, .name = "lifebook"},
11259 	{.id = ALC269_FIXUP_LIFEBOOK_EXTMIC, .name = "lifebook-extmic"},
11260 	{.id = ALC269_FIXUP_LIFEBOOK_HP_PIN, .name = "lifebook-hp-pin"},
11261 	{.id = ALC255_FIXUP_LIFEBOOK_U7x7_HEADSET_MIC, .name = "lifebook-u7x7"},
11262 	{.id = ALC269VB_FIXUP_AMIC, .name = "alc269vb-amic"},
11263 	{.id = ALC269VB_FIXUP_DMIC, .name = "alc269vb-dmic"},
11264 	{.id = ALC269_FIXUP_HP_MUTE_LED_MIC1, .name = "hp-mute-led-mic1"},
11265 	{.id = ALC269_FIXUP_HP_MUTE_LED_MIC2, .name = "hp-mute-led-mic2"},
11266 	{.id = ALC269_FIXUP_HP_MUTE_LED_MIC3, .name = "hp-mute-led-mic3"},
11267 	{.id = ALC269_FIXUP_HP_GPIO_MIC1_LED, .name = "hp-gpio-mic1"},
11268 	{.id = ALC269_FIXUP_HP_LINE1_MIC1_LED, .name = "hp-line1-mic1"},
11269 	{.id = ALC269_FIXUP_NO_SHUTUP, .name = "noshutup"},
11270 	{.id = ALC286_FIXUP_SONY_MIC_NO_PRESENCE, .name = "sony-nomic"},
11271 	{.id = ALC269_FIXUP_ASPIRE_HEADSET_MIC, .name = "aspire-headset-mic"},
11272 	{.id = ALC269_FIXUP_ASUS_X101, .name = "asus-x101"},
11273 	{.id = ALC271_FIXUP_HP_GATE_MIC_JACK, .name = "acer-ao7xx"},
11274 	{.id = ALC271_FIXUP_HP_GATE_MIC_JACK_E1_572, .name = "acer-aspire-e1"},
11275 	{.id = ALC269_FIXUP_ACER_AC700, .name = "acer-ac700"},
11276 	{.id = ALC269_FIXUP_LIMIT_INT_MIC_BOOST, .name = "limit-mic-boost"},
11277 	{.id = ALC269VB_FIXUP_ASUS_ZENBOOK, .name = "asus-zenbook"},
11278 	{.id = ALC269VB_FIXUP_ASUS_ZENBOOK_UX31A, .name = "asus-zenbook-ux31a"},
11279 	{.id = ALC269VB_FIXUP_ORDISSIMO_EVE2, .name = "ordissimo"},
11280 	{.id = ALC282_FIXUP_ASUS_TX300, .name = "asus-tx300"},
11281 	{.id = ALC283_FIXUP_INT_MIC, .name = "alc283-int-mic"},
11282 	{.id = ALC290_FIXUP_MONO_SPEAKERS_HSJACK, .name = "mono-speakers"},
11283 	{.id = ALC290_FIXUP_SUBWOOFER_HSJACK, .name = "alc290-subwoofer"},
11284 	{.id = ALC269_FIXUP_THINKPAD_ACPI, .name = "thinkpad"},
11285 	{.id = ALC269_FIXUP_LENOVO_XPAD_ACPI, .name = "lenovo-xpad-led"},
11286 	{.id = ALC269_FIXUP_DMIC_THINKPAD_ACPI, .name = "dmic-thinkpad"},
11287 	{.id = ALC255_FIXUP_ACER_MIC_NO_PRESENCE, .name = "alc255-acer"},
11288 	{.id = ALC255_FIXUP_ASUS_MIC_NO_PRESENCE, .name = "alc255-asus"},
11289 	{.id = ALC255_FIXUP_DELL1_MIC_NO_PRESENCE, .name = "alc255-dell1"},
11290 	{.id = ALC255_FIXUP_DELL2_MIC_NO_PRESENCE, .name = "alc255-dell2"},
11291 	{.id = ALC293_FIXUP_DELL1_MIC_NO_PRESENCE, .name = "alc293-dell1"},
11292 	{.id = ALC283_FIXUP_HEADSET_MIC, .name = "alc283-headset"},
11293 	{.id = ALC255_FIXUP_MIC_MUTE_LED, .name = "alc255-dell-mute"},
11294 	{.id = ALC282_FIXUP_ASPIRE_V5_PINS, .name = "aspire-v5"},
11295 	{.id = ALC269VB_FIXUP_ASPIRE_E1_COEF, .name = "aspire-e1-coef"},
11296 	{.id = ALC280_FIXUP_HP_GPIO4, .name = "hp-gpio4"},
11297 	{.id = ALC286_FIXUP_HP_GPIO_LED, .name = "hp-gpio-led"},
11298 	{.id = ALC280_FIXUP_HP_GPIO2_MIC_HOTKEY, .name = "hp-gpio2-hotkey"},
11299 	{.id = ALC280_FIXUP_HP_DOCK_PINS, .name = "hp-dock-pins"},
11300 	{.id = ALC269_FIXUP_HP_DOCK_GPIO_MIC1_LED, .name = "hp-dock-gpio-mic"},
11301 	{.id = ALC280_FIXUP_HP_9480M, .name = "hp-9480m"},
11302 	{.id = ALC288_FIXUP_DELL_HEADSET_MODE, .name = "alc288-dell-headset"},
11303 	{.id = ALC288_FIXUP_DELL1_MIC_NO_PRESENCE, .name = "alc288-dell1"},
11304 	{.id = ALC288_FIXUP_DELL_XPS_13, .name = "alc288-dell-xps13"},
11305 	{.id = ALC292_FIXUP_DELL_E7X, .name = "dell-e7x"},
11306 	{.id = ALC293_FIXUP_DISABLE_AAMIX_MULTIJACK, .name = "alc293-dell"},
11307 	{.id = ALC298_FIXUP_DELL1_MIC_NO_PRESENCE, .name = "alc298-dell1"},
11308 	{.id = ALC298_FIXUP_DELL_AIO_MIC_NO_PRESENCE, .name = "alc298-dell-aio"},
11309 	{.id = ALC275_FIXUP_DELL_XPS, .name = "alc275-dell-xps"},
11310 	{.id = ALC293_FIXUP_LENOVO_SPK_NOISE, .name = "lenovo-spk-noise"},
11311 	{.id = ALC233_FIXUP_LENOVO_LINE2_MIC_HOTKEY, .name = "lenovo-hotkey"},
11312 	{.id = ALC255_FIXUP_DELL_SPK_NOISE, .name = "dell-spk-noise"},
11313 	{.id = ALC225_FIXUP_DELL1_MIC_NO_PRESENCE, .name = "alc225-dell1"},
11314 	{.id = ALC295_FIXUP_DISABLE_DAC3, .name = "alc295-disable-dac3"},
11315 	{.id = ALC285_FIXUP_SPEAKER2_TO_DAC1, .name = "alc285-speaker2-to-dac1"},
11316 	{.id = ALC280_FIXUP_HP_HEADSET_MIC, .name = "alc280-hp-headset"},
11317 	{.id = ALC221_FIXUP_HP_FRONT_MIC, .name = "alc221-hp-mic"},
11318 	{.id = ALC298_FIXUP_SPK_VOLUME, .name = "alc298-spk-volume"},
11319 	{.id = ALC256_FIXUP_DELL_INSPIRON_7559_SUBWOOFER, .name = "dell-inspiron-7559"},
11320 	{.id = ALC269_FIXUP_ATIV_BOOK_8, .name = "ativ-book"},
11321 	{.id = ALC221_FIXUP_HP_MIC_NO_PRESENCE, .name = "alc221-hp-mic"},
11322 	{.id = ALC256_FIXUP_ASUS_HEADSET_MODE, .name = "alc256-asus-headset"},
11323 	{.id = ALC256_FIXUP_ASUS_MIC, .name = "alc256-asus-mic"},
11324 	{.id = ALC256_FIXUP_ASUS_AIO_GPIO2, .name = "alc256-asus-aio"},
11325 	{.id = ALC233_FIXUP_ASUS_MIC_NO_PRESENCE, .name = "alc233-asus"},
11326 	{.id = ALC233_FIXUP_EAPD_COEF_AND_MIC_NO_PRESENCE, .name = "alc233-eapd"},
11327 	{.id = ALC294_FIXUP_LENOVO_MIC_LOCATION, .name = "alc294-lenovo-mic"},
11328 	{.id = ALC225_FIXUP_DELL_WYSE_MIC_NO_PRESENCE, .name = "alc225-wyse"},
11329 	{.id = ALC274_FIXUP_DELL_AIO_LINEOUT_VERB, .name = "alc274-dell-aio"},
11330 	{.id = ALC255_FIXUP_DUMMY_LINEOUT_VERB, .name = "alc255-dummy-lineout"},
11331 	{.id = ALC255_FIXUP_DELL_HEADSET_MIC, .name = "alc255-dell-headset"},
11332 	{.id = ALC295_FIXUP_HP_X360, .name = "alc295-hp-x360"},
11333 	{.id = ALC225_FIXUP_HEADSET_JACK, .name = "alc-headset-jack"},
11334 	{.id = ALC295_FIXUP_CHROME_BOOK, .name = "alc-chrome-book"},
11335 	{.id = ALC256_FIXUP_CHROME_BOOK, .name = "alc-2024y-chromebook"},
11336 	{.id = ALC299_FIXUP_PREDATOR_SPK, .name = "predator-spk"},
11337 	{.id = ALC298_FIXUP_HUAWEI_MBX_STEREO, .name = "huawei-mbx-stereo"},
11338 	{.id = ALC256_FIXUP_MEDION_HEADSET_NO_PRESENCE, .name = "alc256-medion-headset"},
11339 	{.id = ALC298_FIXUP_SAMSUNG_AMP, .name = "alc298-samsung-amp"},
11340 	{.id = ALC298_FIXUP_SAMSUNG_AMP_V2_2_AMPS, .name = "alc298-samsung-amp-v2-2-amps"},
11341 	{.id = ALC298_FIXUP_SAMSUNG_AMP_V2_4_AMPS, .name = "alc298-samsung-amp-v2-4-amps"},
11342 	{.id = ALC256_FIXUP_SAMSUNG_HEADPHONE_VERY_QUIET, .name = "alc256-samsung-headphone"},
11343 	{.id = ALC255_FIXUP_XIAOMI_HEADSET_MIC, .name = "alc255-xiaomi-headset"},
11344 	{.id = ALC274_FIXUP_HP_MIC, .name = "alc274-hp-mic-detect"},
11345 	{.id = ALC245_FIXUP_HP_X360_AMP, .name = "alc245-hp-x360-amp"},
11346 	{.id = ALC295_FIXUP_HP_OMEN, .name = "alc295-hp-omen"},
11347 	{.id = ALC285_FIXUP_HP_SPECTRE_X360, .name = "alc285-hp-spectre-x360"},
11348 	{.id = ALC285_FIXUP_HP_SPECTRE_X360_EB1, .name = "alc285-hp-spectre-x360-eb1"},
11349 	{.id = ALC285_FIXUP_HP_ENVY_X360, .name = "alc285-hp-envy-x360"},
11350 	{.id = ALC287_FIXUP_IDEAPAD_BASS_SPK_AMP, .name = "alc287-ideapad-bass-spk-amp"},
11351 	{.id = ALC287_FIXUP_YOGA9_14IAP7_BASS_SPK_PIN, .name = "alc287-yoga9-bass-spk-pin"},
11352 	{.id = ALC623_FIXUP_LENOVO_THINKSTATION_P340, .name = "alc623-lenovo-thinkstation-p340"},
11353 	{.id = ALC255_FIXUP_ACER_HEADPHONE_AND_MIC, .name = "alc255-acer-headphone-and-mic"},
11354 	{.id = ALC285_FIXUP_HP_GPIO_AMP_INIT, .name = "alc285-hp-amp-init"},
11355 	{.id = ALC236_FIXUP_LENOVO_INV_DMIC, .name = "alc236-fixup-lenovo-inv-mic"},
11356 	{.id = ALC2XX_FIXUP_HEADSET_MIC, .name = "alc2xx-fixup-headset-mic"},
11357 	{}
11358 };
11359 #define ALC225_STANDARD_PINS \
11360 	{0x21, 0x04211020}
11361 
11362 #define ALC256_STANDARD_PINS \
11363 	{0x12, 0x90a60140}, \
11364 	{0x14, 0x90170110}, \
11365 	{0x21, 0x02211020}
11366 
11367 #define ALC282_STANDARD_PINS \
11368 	{0x14, 0x90170110}
11369 
11370 #define ALC290_STANDARD_PINS \
11371 	{0x12, 0x99a30130}
11372 
11373 #define ALC292_STANDARD_PINS \
11374 	{0x14, 0x90170110}, \
11375 	{0x15, 0x0221401f}
11376 
11377 #define ALC295_STANDARD_PINS \
11378 	{0x12, 0xb7a60130}, \
11379 	{0x14, 0x90170110}, \
11380 	{0x21, 0x04211020}
11381 
11382 #define ALC298_STANDARD_PINS \
11383 	{0x12, 0x90a60130}, \
11384 	{0x21, 0x03211020}
11385 
11386 static const struct snd_hda_pin_quirk alc269_pin_fixup_tbl[] = {
11387 	SND_HDA_PIN_QUIRK(0x10ec0221, 0x103c, "HP Workstation", ALC221_FIXUP_HP_HEADSET_MIC,
11388 		{0x14, 0x01014020},
11389 		{0x17, 0x90170110},
11390 		{0x18, 0x02a11030},
11391 		{0x19, 0x0181303F},
11392 		{0x21, 0x0221102f}),
11393 	SND_HDA_PIN_QUIRK(0x10ec0255, 0x1025, "Acer", ALC255_FIXUP_ACER_MIC_NO_PRESENCE,
11394 		{0x12, 0x90a601c0},
11395 		{0x14, 0x90171120},
11396 		{0x21, 0x02211030}),
11397 	SND_HDA_PIN_QUIRK(0x10ec0255, 0x1043, "ASUS", ALC255_FIXUP_ASUS_MIC_NO_PRESENCE,
11398 		{0x14, 0x90170110},
11399 		{0x1b, 0x90a70130},
11400 		{0x21, 0x03211020}),
11401 	SND_HDA_PIN_QUIRK(0x10ec0255, 0x1043, "ASUS", ALC255_FIXUP_ASUS_MIC_NO_PRESENCE,
11402 		{0x1a, 0x90a70130},
11403 		{0x1b, 0x90170110},
11404 		{0x21, 0x03211020}),
11405 	SND_HDA_PIN_QUIRK(0x10ec0225, 0x1028, "Dell", ALC225_FIXUP_DELL1_MIC_NO_PRESENCE,
11406 		ALC225_STANDARD_PINS,
11407 		{0x12, 0xb7a60130},
11408 		{0x14, 0x901701a0}),
11409 	SND_HDA_PIN_QUIRK(0x10ec0225, 0x1028, "Dell", ALC225_FIXUP_DELL1_MIC_NO_PRESENCE,
11410 		ALC225_STANDARD_PINS,
11411 		{0x12, 0xb7a60130},
11412 		{0x14, 0x901701b0}),
11413 	SND_HDA_PIN_QUIRK(0x10ec0225, 0x1028, "Dell", ALC225_FIXUP_DELL1_MIC_NO_PRESENCE,
11414 		ALC225_STANDARD_PINS,
11415 		{0x12, 0xb7a60150},
11416 		{0x14, 0x901701a0}),
11417 	SND_HDA_PIN_QUIRK(0x10ec0225, 0x1028, "Dell", ALC225_FIXUP_DELL1_MIC_NO_PRESENCE,
11418 		ALC225_STANDARD_PINS,
11419 		{0x12, 0xb7a60150},
11420 		{0x14, 0x901701b0}),
11421 	SND_HDA_PIN_QUIRK(0x10ec0225, 0x1028, "Dell", ALC225_FIXUP_DELL1_MIC_NO_PRESENCE,
11422 		ALC225_STANDARD_PINS,
11423 		{0x12, 0xb7a60130},
11424 		{0x1b, 0x90170110}),
11425 	SND_HDA_PIN_QUIRK(0x10ec0233, 0x8086, "Intel NUC Skull Canyon", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE,
11426 		{0x1b, 0x01111010},
11427 		{0x1e, 0x01451130},
11428 		{0x21, 0x02211020}),
11429 	SND_HDA_PIN_QUIRK(0x10ec0235, 0x17aa, "Lenovo", ALC233_FIXUP_LENOVO_LINE2_MIC_HOTKEY,
11430 		{0x12, 0x90a60140},
11431 		{0x14, 0x90170110},
11432 		{0x19, 0x02a11030},
11433 		{0x21, 0x02211020}),
11434 	SND_HDA_PIN_QUIRK(0x10ec0235, 0x17aa, "Lenovo", ALC294_FIXUP_LENOVO_MIC_LOCATION,
11435 		{0x14, 0x90170110},
11436 		{0x19, 0x02a11030},
11437 		{0x1a, 0x02a11040},
11438 		{0x1b, 0x01014020},
11439 		{0x21, 0x0221101f}),
11440 	SND_HDA_PIN_QUIRK(0x10ec0235, 0x17aa, "Lenovo", ALC294_FIXUP_LENOVO_MIC_LOCATION,
11441 		{0x14, 0x90170110},
11442 		{0x19, 0x02a11030},
11443 		{0x1a, 0x02a11040},
11444 		{0x1b, 0x01011020},
11445 		{0x21, 0x0221101f}),
11446 	SND_HDA_PIN_QUIRK(0x10ec0235, 0x17aa, "Lenovo", ALC294_FIXUP_LENOVO_MIC_LOCATION,
11447 		{0x14, 0x90170110},
11448 		{0x19, 0x02a11020},
11449 		{0x1a, 0x02a11030},
11450 		{0x21, 0x0221101f}),
11451 	SND_HDA_PIN_QUIRK(0x10ec0236, 0x1028, "Dell", ALC236_FIXUP_DELL_AIO_HEADSET_MIC,
11452 		{0x21, 0x02211010}),
11453 	SND_HDA_PIN_QUIRK(0x10ec0236, 0x103c, "HP", ALC256_FIXUP_HP_HEADSET_MIC,
11454 		{0x14, 0x90170110},
11455 		{0x19, 0x02a11020},
11456 		{0x21, 0x02211030}),
11457 	SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL2_MIC_NO_PRESENCE,
11458 		{0x14, 0x90170110},
11459 		{0x21, 0x02211020}),
11460 	SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
11461 		{0x14, 0x90170130},
11462 		{0x21, 0x02211040}),
11463 	SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
11464 		{0x12, 0x90a60140},
11465 		{0x14, 0x90170110},
11466 		{0x21, 0x02211020}),
11467 	SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
11468 		{0x12, 0x90a60160},
11469 		{0x14, 0x90170120},
11470 		{0x21, 0x02211030}),
11471 	SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
11472 		{0x14, 0x90170110},
11473 		{0x1b, 0x02011020},
11474 		{0x21, 0x0221101f}),
11475 	SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
11476 		{0x14, 0x90170110},
11477 		{0x1b, 0x01011020},
11478 		{0x21, 0x0221101f}),
11479 	SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
11480 		{0x14, 0x90170130},
11481 		{0x1b, 0x01014020},
11482 		{0x21, 0x0221103f}),
11483 	SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
11484 		{0x14, 0x90170130},
11485 		{0x1b, 0x01011020},
11486 		{0x21, 0x0221103f}),
11487 	SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
11488 		{0x14, 0x90170130},
11489 		{0x1b, 0x02011020},
11490 		{0x21, 0x0221103f}),
11491 	SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
11492 		{0x14, 0x90170150},
11493 		{0x1b, 0x02011020},
11494 		{0x21, 0x0221105f}),
11495 	SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
11496 		{0x14, 0x90170110},
11497 		{0x1b, 0x01014020},
11498 		{0x21, 0x0221101f}),
11499 	SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
11500 		{0x12, 0x90a60160},
11501 		{0x14, 0x90170120},
11502 		{0x17, 0x90170140},
11503 		{0x21, 0x0321102f}),
11504 	SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
11505 		{0x12, 0x90a60160},
11506 		{0x14, 0x90170130},
11507 		{0x21, 0x02211040}),
11508 	SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
11509 		{0x12, 0x90a60160},
11510 		{0x14, 0x90170140},
11511 		{0x21, 0x02211050}),
11512 	SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
11513 		{0x12, 0x90a60170},
11514 		{0x14, 0x90170120},
11515 		{0x21, 0x02211030}),
11516 	SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
11517 		{0x12, 0x90a60170},
11518 		{0x14, 0x90170130},
11519 		{0x21, 0x02211040}),
11520 	SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
11521 		{0x12, 0x90a60170},
11522 		{0x14, 0x90171130},
11523 		{0x21, 0x02211040}),
11524 	SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
11525 		{0x12, 0x90a60170},
11526 		{0x14, 0x90170140},
11527 		{0x21, 0x02211050}),
11528 	SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell Inspiron 5548", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
11529 		{0x12, 0x90a60180},
11530 		{0x14, 0x90170130},
11531 		{0x21, 0x02211040}),
11532 	SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell Inspiron 5565", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
11533 		{0x12, 0x90a60180},
11534 		{0x14, 0x90170120},
11535 		{0x21, 0x02211030}),
11536 	SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
11537 		{0x1b, 0x01011020},
11538 		{0x21, 0x02211010}),
11539 	SND_HDA_PIN_QUIRK(0x10ec0256, 0x1043, "ASUS", ALC256_FIXUP_ASUS_MIC,
11540 		{0x14, 0x90170110},
11541 		{0x1b, 0x90a70130},
11542 		{0x21, 0x04211020}),
11543 	SND_HDA_PIN_QUIRK(0x10ec0256, 0x1043, "ASUS", ALC256_FIXUP_ASUS_MIC,
11544 		{0x14, 0x90170110},
11545 		{0x1b, 0x90a70130},
11546 		{0x21, 0x03211020}),
11547 	SND_HDA_PIN_QUIRK(0x10ec0256, 0x1043, "ASUS", ALC256_FIXUP_ASUS_MIC_NO_PRESENCE,
11548 		{0x12, 0x90a60130},
11549 		{0x14, 0x90170110},
11550 		{0x21, 0x03211020}),
11551 	SND_HDA_PIN_QUIRK(0x10ec0256, 0x1043, "ASUS", ALC256_FIXUP_ASUS_MIC_NO_PRESENCE,
11552 		{0x12, 0x90a60130},
11553 		{0x14, 0x90170110},
11554 		{0x21, 0x04211020}),
11555 	SND_HDA_PIN_QUIRK(0x10ec0256, 0x1043, "ASUS", ALC256_FIXUP_ASUS_MIC_NO_PRESENCE,
11556 		{0x1a, 0x90a70130},
11557 		{0x1b, 0x90170110},
11558 		{0x21, 0x03211020}),
11559        SND_HDA_PIN_QUIRK(0x10ec0256, 0x103c, "HP", ALC256_FIXUP_HP_HEADSET_MIC,
11560 		{0x14, 0x90170110},
11561 		{0x19, 0x02a11020},
11562 		{0x21, 0x0221101f}),
11563        SND_HDA_PIN_QUIRK(0x10ec0274, 0x103c, "HP", ALC274_FIXUP_HP_HEADSET_MIC,
11564 		{0x17, 0x90170110},
11565 		{0x19, 0x03a11030},
11566 		{0x21, 0x03211020}),
11567 	SND_HDA_PIN_QUIRK(0x10ec0280, 0x103c, "HP", ALC280_FIXUP_HP_GPIO4,
11568 		{0x12, 0x90a60130},
11569 		{0x14, 0x90170110},
11570 		{0x15, 0x0421101f},
11571 		{0x1a, 0x04a11020}),
11572 	SND_HDA_PIN_QUIRK(0x10ec0280, 0x103c, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED,
11573 		{0x12, 0x90a60140},
11574 		{0x14, 0x90170110},
11575 		{0x15, 0x0421101f},
11576 		{0x18, 0x02811030},
11577 		{0x1a, 0x04a1103f},
11578 		{0x1b, 0x02011020}),
11579 	SND_HDA_PIN_QUIRK(0x10ec0282, 0x103c, "HP 15 Touchsmart", ALC269_FIXUP_HP_MUTE_LED_MIC1,
11580 		ALC282_STANDARD_PINS,
11581 		{0x12, 0x99a30130},
11582 		{0x19, 0x03a11020},
11583 		{0x21, 0x0321101f}),
11584 	SND_HDA_PIN_QUIRK(0x10ec0282, 0x103c, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1,
11585 		ALC282_STANDARD_PINS,
11586 		{0x12, 0x99a30130},
11587 		{0x19, 0x03a11020},
11588 		{0x21, 0x03211040}),
11589 	SND_HDA_PIN_QUIRK(0x10ec0282, 0x103c, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1,
11590 		ALC282_STANDARD_PINS,
11591 		{0x12, 0x99a30130},
11592 		{0x19, 0x03a11030},
11593 		{0x21, 0x03211020}),
11594 	SND_HDA_PIN_QUIRK(0x10ec0282, 0x103c, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1,
11595 		ALC282_STANDARD_PINS,
11596 		{0x12, 0x99a30130},
11597 		{0x19, 0x04a11020},
11598 		{0x21, 0x0421101f}),
11599 	SND_HDA_PIN_QUIRK(0x10ec0282, 0x103c, "HP", ALC269_FIXUP_HP_LINE1_MIC1_LED,
11600 		ALC282_STANDARD_PINS,
11601 		{0x12, 0x90a60140},
11602 		{0x19, 0x04a11030},
11603 		{0x21, 0x04211020}),
11604 	SND_HDA_PIN_QUIRK(0x10ec0282, 0x1025, "Acer", ALC282_FIXUP_ACER_DISABLE_LINEOUT,
11605 		ALC282_STANDARD_PINS,
11606 		{0x12, 0x90a609c0},
11607 		{0x18, 0x03a11830},
11608 		{0x19, 0x04a19831},
11609 		{0x1a, 0x0481303f},
11610 		{0x1b, 0x04211020},
11611 		{0x21, 0x0321101f}),
11612 	SND_HDA_PIN_QUIRK(0x10ec0282, 0x1025, "Acer", ALC282_FIXUP_ACER_DISABLE_LINEOUT,
11613 		ALC282_STANDARD_PINS,
11614 		{0x12, 0x90a60940},
11615 		{0x18, 0x03a11830},
11616 		{0x19, 0x04a19831},
11617 		{0x1a, 0x0481303f},
11618 		{0x1b, 0x04211020},
11619 		{0x21, 0x0321101f}),
11620 	SND_HDA_PIN_QUIRK(0x10ec0283, 0x1028, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE,
11621 		ALC282_STANDARD_PINS,
11622 		{0x12, 0x90a60130},
11623 		{0x21, 0x0321101f}),
11624 	SND_HDA_PIN_QUIRK(0x10ec0283, 0x1028, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE,
11625 		{0x12, 0x90a60160},
11626 		{0x14, 0x90170120},
11627 		{0x21, 0x02211030}),
11628 	SND_HDA_PIN_QUIRK(0x10ec0283, 0x1028, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE,
11629 		ALC282_STANDARD_PINS,
11630 		{0x12, 0x90a60130},
11631 		{0x19, 0x03a11020},
11632 		{0x21, 0x0321101f}),
11633 	SND_HDA_PIN_QUIRK(0x10ec0285, 0x17aa, "Lenovo", ALC285_FIXUP_LENOVO_PC_BEEP_IN_NOISE,
11634 		{0x12, 0x90a60130},
11635 		{0x14, 0x90170110},
11636 		{0x19, 0x04a11040},
11637 		{0x21, 0x04211020}),
11638 	SND_HDA_PIN_QUIRK(0x10ec0285, 0x17aa, "Lenovo", ALC285_FIXUP_LENOVO_PC_BEEP_IN_NOISE,
11639 		{0x14, 0x90170110},
11640 		{0x19, 0x04a11040},
11641 		{0x1d, 0x40600001},
11642 		{0x21, 0x04211020}),
11643 	SND_HDA_PIN_QUIRK(0x10ec0285, 0x17aa, "Lenovo", ALC285_FIXUP_THINKPAD_NO_BASS_SPK_HEADSET_JACK,
11644 		{0x14, 0x90170110},
11645 		{0x19, 0x04a11040},
11646 		{0x21, 0x04211020}),
11647 	SND_HDA_PIN_QUIRK(0x10ec0287, 0x17aa, "Lenovo", ALC285_FIXUP_THINKPAD_HEADSET_JACK,
11648 		{0x14, 0x90170110},
11649 		{0x17, 0x90170111},
11650 		{0x19, 0x03a11030},
11651 		{0x21, 0x03211020}),
11652 	SND_HDA_PIN_QUIRK(0x10ec0287, 0x17aa, "Lenovo", ALC287_FIXUP_THINKPAD_I2S_SPK,
11653 		{0x17, 0x90170110},
11654 		{0x19, 0x03a11030},
11655 		{0x21, 0x03211020}),
11656 	SND_HDA_PIN_QUIRK(0x10ec0287, 0x17aa, "Lenovo", ALC287_FIXUP_THINKPAD_I2S_SPK,
11657 		{0x17, 0x90170110}, /* 0x231f with RTK I2S AMP */
11658 		{0x19, 0x04a11040},
11659 		{0x21, 0x04211020}),
11660 	SND_HDA_PIN_QUIRK(0x10ec0286, 0x1025, "Acer", ALC286_FIXUP_ACER_AIO_MIC_NO_PRESENCE,
11661 		{0x12, 0x90a60130},
11662 		{0x17, 0x90170110},
11663 		{0x21, 0x02211020}),
11664 	SND_HDA_PIN_QUIRK(0x10ec0288, 0x1028, "Dell", ALC288_FIXUP_DELL1_MIC_NO_PRESENCE,
11665 		{0x12, 0x90a60120},
11666 		{0x14, 0x90170110},
11667 		{0x21, 0x0321101f}),
11668 	SND_HDA_PIN_QUIRK(0x10ec0290, 0x103c, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1,
11669 		ALC290_STANDARD_PINS,
11670 		{0x15, 0x04211040},
11671 		{0x18, 0x90170112},
11672 		{0x1a, 0x04a11020}),
11673 	SND_HDA_PIN_QUIRK(0x10ec0290, 0x103c, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1,
11674 		ALC290_STANDARD_PINS,
11675 		{0x15, 0x04211040},
11676 		{0x18, 0x90170110},
11677 		{0x1a, 0x04a11020}),
11678 	SND_HDA_PIN_QUIRK(0x10ec0290, 0x103c, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1,
11679 		ALC290_STANDARD_PINS,
11680 		{0x15, 0x0421101f},
11681 		{0x1a, 0x04a11020}),
11682 	SND_HDA_PIN_QUIRK(0x10ec0290, 0x103c, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1,
11683 		ALC290_STANDARD_PINS,
11684 		{0x15, 0x04211020},
11685 		{0x1a, 0x04a11040}),
11686 	SND_HDA_PIN_QUIRK(0x10ec0290, 0x103c, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1,
11687 		ALC290_STANDARD_PINS,
11688 		{0x14, 0x90170110},
11689 		{0x15, 0x04211020},
11690 		{0x1a, 0x04a11040}),
11691 	SND_HDA_PIN_QUIRK(0x10ec0290, 0x103c, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1,
11692 		ALC290_STANDARD_PINS,
11693 		{0x14, 0x90170110},
11694 		{0x15, 0x04211020},
11695 		{0x1a, 0x04a11020}),
11696 	SND_HDA_PIN_QUIRK(0x10ec0290, 0x103c, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1,
11697 		ALC290_STANDARD_PINS,
11698 		{0x14, 0x90170110},
11699 		{0x15, 0x0421101f},
11700 		{0x1a, 0x04a11020}),
11701 	SND_HDA_PIN_QUIRK(0x10ec0292, 0x1028, "Dell", ALC269_FIXUP_DELL2_MIC_NO_PRESENCE,
11702 		ALC292_STANDARD_PINS,
11703 		{0x12, 0x90a60140},
11704 		{0x16, 0x01014020},
11705 		{0x19, 0x01a19030}),
11706 	SND_HDA_PIN_QUIRK(0x10ec0292, 0x1028, "Dell", ALC269_FIXUP_DELL2_MIC_NO_PRESENCE,
11707 		ALC292_STANDARD_PINS,
11708 		{0x12, 0x90a60140},
11709 		{0x16, 0x01014020},
11710 		{0x18, 0x02a19031},
11711 		{0x19, 0x01a1903e}),
11712 	SND_HDA_PIN_QUIRK(0x10ec0292, 0x1028, "Dell", ALC269_FIXUP_DELL3_MIC_NO_PRESENCE,
11713 		ALC292_STANDARD_PINS,
11714 		{0x12, 0x90a60140}),
11715 	SND_HDA_PIN_QUIRK(0x10ec0293, 0x1028, "Dell", ALC293_FIXUP_DELL1_MIC_NO_PRESENCE,
11716 		ALC292_STANDARD_PINS,
11717 		{0x13, 0x90a60140},
11718 		{0x16, 0x21014020},
11719 		{0x19, 0x21a19030}),
11720 	SND_HDA_PIN_QUIRK(0x10ec0293, 0x1028, "Dell", ALC293_FIXUP_DELL1_MIC_NO_PRESENCE,
11721 		ALC292_STANDARD_PINS,
11722 		{0x13, 0x90a60140}),
11723 	SND_HDA_PIN_QUIRK(0x10ec0294, 0x1043, "ASUS", ALC294_FIXUP_ASUS_HPE,
11724 		{0x17, 0x90170110},
11725 		{0x21, 0x04211020}),
11726 	SND_HDA_PIN_QUIRK(0x10ec0294, 0x1043, "ASUS", ALC294_FIXUP_ASUS_MIC,
11727 		{0x14, 0x90170110},
11728 		{0x1b, 0x90a70130},
11729 		{0x21, 0x04211020}),
11730 	SND_HDA_PIN_QUIRK(0x10ec0294, 0x1043, "ASUS", ALC294_FIXUP_ASUS_SPK,
11731 		{0x12, 0x90a60130},
11732 		{0x17, 0x90170110},
11733 		{0x21, 0x03211020}),
11734 	SND_HDA_PIN_QUIRK(0x10ec0294, 0x1043, "ASUS", ALC294_FIXUP_ASUS_SPK,
11735 		{0x12, 0x90a60130},
11736 		{0x17, 0x90170110},
11737 		{0x21, 0x04211020}),
11738 	SND_HDA_PIN_QUIRK(0x10ec0295, 0x1043, "ASUS", ALC294_FIXUP_ASUS_SPK,
11739 		{0x12, 0x90a60130},
11740 		{0x17, 0x90170110},
11741 		{0x21, 0x03211020}),
11742 	SND_HDA_PIN_QUIRK(0x10ec0295, 0x1043, "ASUS", ALC295_FIXUP_ASUS_MIC_NO_PRESENCE,
11743 		{0x12, 0x90a60120},
11744 		{0x17, 0x90170110},
11745 		{0x21, 0x04211030}),
11746 	SND_HDA_PIN_QUIRK(0x10ec0295, 0x1043, "ASUS", ALC295_FIXUP_ASUS_MIC_NO_PRESENCE,
11747 		{0x12, 0x90a60130},
11748 		{0x17, 0x90170110},
11749 		{0x21, 0x03211020}),
11750 	SND_HDA_PIN_QUIRK(0x10ec0295, 0x1043, "ASUS", ALC295_FIXUP_ASUS_MIC_NO_PRESENCE,
11751 		{0x12, 0x90a60130},
11752 		{0x17, 0x90170110},
11753 		{0x21, 0x03211020}),
11754 	SND_HDA_PIN_QUIRK(0x10ec0298, 0x1028, "Dell", ALC298_FIXUP_DELL1_MIC_NO_PRESENCE,
11755 		ALC298_STANDARD_PINS,
11756 		{0x17, 0x90170110}),
11757 	SND_HDA_PIN_QUIRK(0x10ec0298, 0x1028, "Dell", ALC298_FIXUP_DELL1_MIC_NO_PRESENCE,
11758 		ALC298_STANDARD_PINS,
11759 		{0x17, 0x90170140}),
11760 	SND_HDA_PIN_QUIRK(0x10ec0298, 0x1028, "Dell", ALC298_FIXUP_DELL1_MIC_NO_PRESENCE,
11761 		ALC298_STANDARD_PINS,
11762 		{0x17, 0x90170150}),
11763 	SND_HDA_PIN_QUIRK(0x10ec0298, 0x1028, "Dell", ALC298_FIXUP_SPK_VOLUME,
11764 		{0x12, 0xb7a60140},
11765 		{0x13, 0xb7a60150},
11766 		{0x17, 0x90170110},
11767 		{0x1a, 0x03011020},
11768 		{0x21, 0x03211030}),
11769 	SND_HDA_PIN_QUIRK(0x10ec0298, 0x1028, "Dell", ALC298_FIXUP_ALIENWARE_MIC_NO_PRESENCE,
11770 		{0x12, 0xb7a60140},
11771 		{0x17, 0x90170110},
11772 		{0x1a, 0x03a11030},
11773 		{0x21, 0x03211020}),
11774 	SND_HDA_PIN_QUIRK(0x10ec0299, 0x1028, "Dell", ALC269_FIXUP_DELL4_MIC_NO_PRESENCE,
11775 		ALC225_STANDARD_PINS,
11776 		{0x12, 0xb7a60130},
11777 		{0x17, 0x90170110}),
11778 	SND_HDA_PIN_QUIRK(0x10ec0623, 0x17aa, "Lenovo", ALC283_FIXUP_HEADSET_MIC,
11779 		{0x14, 0x01014010},
11780 		{0x17, 0x90170120},
11781 		{0x18, 0x02a11030},
11782 		{0x19, 0x02a1103f},
11783 		{0x21, 0x0221101f}),
11784 	{}
11785 };
11786 
11787 /* This is the fallback pin_fixup_tbl for alc269 family, to make the tbl match
11788  * more machines, don't need to match all valid pins, just need to match
11789  * all the pins defined in the tbl. Just because of this reason, it is possible
11790  * that a single machine matches multiple tbls, so there is one limitation:
11791  *   at most one tbl is allowed to define for the same vendor and same codec
11792  */
11793 static const struct snd_hda_pin_quirk alc269_fallback_pin_fixup_tbl[] = {
11794 	SND_HDA_PIN_QUIRK(0x10ec0256, 0x1025, "Acer", ALC2XX_FIXUP_HEADSET_MIC,
11795 		{0x19, 0x40000000}),
11796 	SND_HDA_PIN_QUIRK(0x10ec0289, 0x1028, "Dell", ALC269_FIXUP_DELL4_MIC_NO_PRESENCE,
11797 		{0x19, 0x40000000},
11798 		{0x1b, 0x40000000}),
11799 	SND_HDA_PIN_QUIRK(0x10ec0295, 0x1028, "Dell", ALC269_FIXUP_DELL4_MIC_NO_PRESENCE_QUIET,
11800 		{0x19, 0x40000000},
11801 		{0x1b, 0x40000000}),
11802 	SND_HDA_PIN_QUIRK(0x10ec0256, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
11803 		{0x19, 0x40000000},
11804 		{0x1a, 0x40000000}),
11805 	SND_HDA_PIN_QUIRK(0x10ec0236, 0x1028, "Dell", ALC255_FIXUP_DELL1_LIMIT_INT_MIC_BOOST,
11806 		{0x19, 0x40000000},
11807 		{0x1a, 0x40000000}),
11808 	SND_HDA_PIN_QUIRK(0x10ec0274, 0x1028, "Dell", ALC269_FIXUP_DELL1_LIMIT_INT_MIC_BOOST,
11809 		{0x19, 0x40000000},
11810 		{0x1a, 0x40000000}),
11811 	SND_HDA_PIN_QUIRK(0x10ec0256, 0x1043, "ASUS", ALC2XX_FIXUP_HEADSET_MIC,
11812 		{0x19, 0x40000000}),
11813 	SND_HDA_PIN_QUIRK(0x10ec0255, 0x1558, "Clevo", ALC2XX_FIXUP_HEADSET_MIC,
11814 		{0x19, 0x40000000}),
11815 	{}
11816 };
11817 
alc269_fill_coef(struct hda_codec * codec)11818 static void alc269_fill_coef(struct hda_codec *codec)
11819 {
11820 	struct alc_spec *spec = codec->spec;
11821 	int val;
11822 
11823 	if (spec->codec_variant != ALC269_TYPE_ALC269VB)
11824 		return;
11825 
11826 	if ((alc_get_coef0(codec) & 0x00ff) < 0x015) {
11827 		alc_write_coef_idx(codec, 0xf, 0x960b);
11828 		alc_write_coef_idx(codec, 0xe, 0x8817);
11829 	}
11830 
11831 	if ((alc_get_coef0(codec) & 0x00ff) == 0x016) {
11832 		alc_write_coef_idx(codec, 0xf, 0x960b);
11833 		alc_write_coef_idx(codec, 0xe, 0x8814);
11834 	}
11835 
11836 	if ((alc_get_coef0(codec) & 0x00ff) == 0x017) {
11837 		/* Power up output pin */
11838 		alc_update_coef_idx(codec, 0x04, 0, 1<<11);
11839 	}
11840 
11841 	if ((alc_get_coef0(codec) & 0x00ff) == 0x018) {
11842 		val = alc_read_coef_idx(codec, 0xd);
11843 		if (val != -1 && (val & 0x0c00) >> 10 != 0x1) {
11844 			/* Capless ramp up clock control */
11845 			alc_write_coef_idx(codec, 0xd, val | (1<<10));
11846 		}
11847 		val = alc_read_coef_idx(codec, 0x17);
11848 		if (val != -1 && (val & 0x01c0) >> 6 != 0x4) {
11849 			/* Class D power on reset */
11850 			alc_write_coef_idx(codec, 0x17, val | (1<<7));
11851 		}
11852 	}
11853 
11854 	/* HP */
11855 	alc_update_coef_idx(codec, 0x4, 0, 1<<11);
11856 }
11857 
11858 /*
11859  */
patch_alc269(struct hda_codec * codec)11860 static int patch_alc269(struct hda_codec *codec)
11861 {
11862 	struct alc_spec *spec;
11863 	int err;
11864 
11865 	err = alc_alloc_spec(codec, 0x0b);
11866 	if (err < 0)
11867 		return err;
11868 
11869 	spec = codec->spec;
11870 	spec->gen.shared_mic_vref_pin = 0x18;
11871 	codec->power_save_node = 0;
11872 	spec->en_3kpull_low = true;
11873 
11874 	codec->patch_ops.suspend = alc269_suspend;
11875 	codec->patch_ops.resume = alc269_resume;
11876 	spec->shutup = alc_default_shutup;
11877 	spec->init_hook = alc_default_init;
11878 
11879 	switch (codec->core.vendor_id) {
11880 	case 0x10ec0269:
11881 		spec->codec_variant = ALC269_TYPE_ALC269VA;
11882 		switch (alc_get_coef0(codec) & 0x00f0) {
11883 		case 0x0010:
11884 			if (codec->bus->pci &&
11885 			    codec->bus->pci->subsystem_vendor == 0x1025 &&
11886 			    spec->cdefine.platform_type == 1)
11887 				err = alc_codec_rename(codec, "ALC271X");
11888 			spec->codec_variant = ALC269_TYPE_ALC269VB;
11889 			break;
11890 		case 0x0020:
11891 			if (codec->bus->pci &&
11892 			    codec->bus->pci->subsystem_vendor == 0x17aa &&
11893 			    codec->bus->pci->subsystem_device == 0x21f3)
11894 				err = alc_codec_rename(codec, "ALC3202");
11895 			spec->codec_variant = ALC269_TYPE_ALC269VC;
11896 			break;
11897 		case 0x0030:
11898 			spec->codec_variant = ALC269_TYPE_ALC269VD;
11899 			break;
11900 		default:
11901 			alc_fix_pll_init(codec, 0x20, 0x04, 15);
11902 		}
11903 		if (err < 0)
11904 			goto error;
11905 		spec->shutup = alc269_shutup;
11906 		spec->init_hook = alc269_fill_coef;
11907 		alc269_fill_coef(codec);
11908 		break;
11909 
11910 	case 0x10ec0280:
11911 	case 0x10ec0290:
11912 		spec->codec_variant = ALC269_TYPE_ALC280;
11913 		break;
11914 	case 0x10ec0282:
11915 		spec->codec_variant = ALC269_TYPE_ALC282;
11916 		spec->shutup = alc282_shutup;
11917 		spec->init_hook = alc282_init;
11918 		break;
11919 	case 0x10ec0233:
11920 	case 0x10ec0283:
11921 		spec->codec_variant = ALC269_TYPE_ALC283;
11922 		spec->shutup = alc283_shutup;
11923 		spec->init_hook = alc283_init;
11924 		break;
11925 	case 0x10ec0284:
11926 	case 0x10ec0292:
11927 		spec->codec_variant = ALC269_TYPE_ALC284;
11928 		break;
11929 	case 0x10ec0293:
11930 		spec->codec_variant = ALC269_TYPE_ALC293;
11931 		break;
11932 	case 0x10ec0286:
11933 	case 0x10ec0288:
11934 		spec->codec_variant = ALC269_TYPE_ALC286;
11935 		break;
11936 	case 0x10ec0298:
11937 		spec->codec_variant = ALC269_TYPE_ALC298;
11938 		break;
11939 	case 0x10ec0235:
11940 	case 0x10ec0255:
11941 		spec->codec_variant = ALC269_TYPE_ALC255;
11942 		spec->shutup = alc256_shutup;
11943 		spec->init_hook = alc256_init;
11944 		break;
11945 	case 0x10ec0230:
11946 	case 0x10ec0236:
11947 	case 0x10ec0256:
11948 	case 0x19e58326:
11949 		spec->codec_variant = ALC269_TYPE_ALC256;
11950 		spec->shutup = alc256_shutup;
11951 		spec->init_hook = alc256_init;
11952 		spec->gen.mixer_nid = 0; /* ALC256 does not have any loopback mixer path */
11953 		if (codec->core.vendor_id == 0x10ec0236 &&
11954 		    codec->bus->pci->vendor != PCI_VENDOR_ID_AMD)
11955 			spec->en_3kpull_low = false;
11956 		break;
11957 	case 0x10ec0257:
11958 		spec->codec_variant = ALC269_TYPE_ALC257;
11959 		spec->shutup = alc256_shutup;
11960 		spec->init_hook = alc256_init;
11961 		spec->gen.mixer_nid = 0;
11962 		spec->en_3kpull_low = false;
11963 		break;
11964 	case 0x10ec0215:
11965 	case 0x10ec0245:
11966 	case 0x10ec0285:
11967 	case 0x10ec0289:
11968 		if (alc_get_coef0(codec) & 0x0010)
11969 			spec->codec_variant = ALC269_TYPE_ALC245;
11970 		else
11971 			spec->codec_variant = ALC269_TYPE_ALC215;
11972 		spec->shutup = alc225_shutup;
11973 		spec->init_hook = alc225_init;
11974 		spec->gen.mixer_nid = 0;
11975 		break;
11976 	case 0x10ec0225:
11977 	case 0x10ec0295:
11978 	case 0x10ec0299:
11979 		spec->codec_variant = ALC269_TYPE_ALC225;
11980 		spec->shutup = alc225_shutup;
11981 		spec->init_hook = alc225_init;
11982 		spec->gen.mixer_nid = 0; /* no loopback on ALC225, ALC295 and ALC299 */
11983 		break;
11984 	case 0x10ec0287:
11985 		spec->codec_variant = ALC269_TYPE_ALC287;
11986 		spec->shutup = alc225_shutup;
11987 		spec->init_hook = alc225_init;
11988 		spec->gen.mixer_nid = 0; /* no loopback on ALC287 */
11989 		break;
11990 	case 0x10ec0234:
11991 	case 0x10ec0274:
11992 	case 0x10ec0294:
11993 		spec->codec_variant = ALC269_TYPE_ALC294;
11994 		spec->gen.mixer_nid = 0; /* ALC2x4 does not have any loopback mixer path */
11995 		alc_update_coef_idx(codec, 0x6b, 0x0018, (1<<4) | (1<<3)); /* UAJ MIC Vref control by verb */
11996 		spec->init_hook = alc294_init;
11997 		break;
11998 	case 0x10ec0300:
11999 		spec->codec_variant = ALC269_TYPE_ALC300;
12000 		spec->gen.mixer_nid = 0; /* no loopback on ALC300 */
12001 		break;
12002 	case 0x10ec0222:
12003 	case 0x10ec0623:
12004 		spec->codec_variant = ALC269_TYPE_ALC623;
12005 		spec->shutup = alc222_shutup;
12006 		spec->init_hook = alc222_init;
12007 		break;
12008 	case 0x10ec0700:
12009 	case 0x10ec0701:
12010 	case 0x10ec0703:
12011 	case 0x10ec0711:
12012 		spec->codec_variant = ALC269_TYPE_ALC700;
12013 		spec->gen.mixer_nid = 0; /* ALC700 does not have any loopback mixer path */
12014 		alc_update_coef_idx(codec, 0x4a, 1 << 15, 0); /* Combo jack auto trigger control */
12015 		spec->init_hook = alc294_init;
12016 		break;
12017 
12018 	}
12019 
12020 	if (snd_hda_codec_read(codec, 0x51, 0, AC_VERB_PARAMETERS, 0) == 0x10ec5505) {
12021 		spec->has_alc5505_dsp = 1;
12022 		spec->init_hook = alc5505_dsp_init;
12023 	}
12024 
12025 	alc_pre_init(codec);
12026 
12027 	snd_hda_pick_fixup(codec, alc269_fixup_models,
12028 		       alc269_fixup_tbl, alc269_fixups);
12029 	/* FIXME: both TX300 and ROG Strix G17 have the same SSID, and
12030 	 * the quirk breaks the latter (bko#214101).
12031 	 * Clear the wrong entry.
12032 	 */
12033 	if (codec->fixup_id == ALC282_FIXUP_ASUS_TX300 &&
12034 	    codec->core.vendor_id == 0x10ec0294) {
12035 		codec_dbg(codec, "Clear wrong fixup for ASUS ROG Strix G17\n");
12036 		codec->fixup_id = HDA_FIXUP_ID_NOT_SET;
12037 	}
12038 
12039 	snd_hda_pick_pin_fixup(codec, alc269_pin_fixup_tbl, alc269_fixups, true);
12040 	snd_hda_pick_pin_fixup(codec, alc269_fallback_pin_fixup_tbl, alc269_fixups, false);
12041 	snd_hda_pick_fixup(codec, NULL,	alc269_fixup_vendor_tbl,
12042 			   alc269_fixups);
12043 
12044 	/*
12045 	 * Check whether ACPI describes companion amplifiers that require
12046 	 * component binding
12047 	 */
12048 	find_cirrus_companion_amps(codec);
12049 
12050 	snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE);
12051 
12052 	alc_auto_parse_customize_define(codec);
12053 
12054 	if (has_cdefine_beep(codec))
12055 		spec->gen.beep_nid = 0x01;
12056 
12057 	/* automatic parse from the BIOS config */
12058 	err = alc269_parse_auto_config(codec);
12059 	if (err < 0)
12060 		goto error;
12061 
12062 	if (!spec->gen.no_analog && spec->gen.beep_nid && spec->gen.mixer_nid) {
12063 		err = set_beep_amp(spec, spec->gen.mixer_nid, 0x04, HDA_INPUT);
12064 		if (err < 0)
12065 			goto error;
12066 	}
12067 
12068 	snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE);
12069 
12070 	return 0;
12071 
12072  error:
12073 	alc_free(codec);
12074 	return err;
12075 }
12076 
12077 /*
12078  * ALC861
12079  */
12080 
alc861_parse_auto_config(struct hda_codec * codec)12081 static int alc861_parse_auto_config(struct hda_codec *codec)
12082 {
12083 	static const hda_nid_t alc861_ignore[] = { 0x1d, 0 };
12084 	static const hda_nid_t alc861_ssids[] = { 0x0e, 0x0f, 0x0b, 0 };
12085 	return alc_parse_auto_config(codec, alc861_ignore, alc861_ssids);
12086 }
12087 
12088 /* Pin config fixes */
12089 enum {
12090 	ALC861_FIXUP_FSC_AMILO_PI1505,
12091 	ALC861_FIXUP_AMP_VREF_0F,
12092 	ALC861_FIXUP_NO_JACK_DETECT,
12093 	ALC861_FIXUP_ASUS_A6RP,
12094 	ALC660_FIXUP_ASUS_W7J,
12095 };
12096 
12097 /* On some laptops, VREF of pin 0x0f is abused for controlling the main amp */
alc861_fixup_asus_amp_vref_0f(struct hda_codec * codec,const struct hda_fixup * fix,int action)12098 static void alc861_fixup_asus_amp_vref_0f(struct hda_codec *codec,
12099 			const struct hda_fixup *fix, int action)
12100 {
12101 	struct alc_spec *spec = codec->spec;
12102 	unsigned int val;
12103 
12104 	if (action != HDA_FIXUP_ACT_INIT)
12105 		return;
12106 	val = snd_hda_codec_get_pin_target(codec, 0x0f);
12107 	if (!(val & (AC_PINCTL_IN_EN | AC_PINCTL_OUT_EN)))
12108 		val |= AC_PINCTL_IN_EN;
12109 	val |= AC_PINCTL_VREF_50;
12110 	snd_hda_set_pin_ctl(codec, 0x0f, val);
12111 	spec->gen.keep_vref_in_automute = 1;
12112 }
12113 
12114 /* suppress the jack-detection */
alc_fixup_no_jack_detect(struct hda_codec * codec,const struct hda_fixup * fix,int action)12115 static void alc_fixup_no_jack_detect(struct hda_codec *codec,
12116 				     const struct hda_fixup *fix, int action)
12117 {
12118 	if (action == HDA_FIXUP_ACT_PRE_PROBE)
12119 		codec->no_jack_detect = 1;
12120 }
12121 
12122 static const struct hda_fixup alc861_fixups[] = {
12123 	[ALC861_FIXUP_FSC_AMILO_PI1505] = {
12124 		.type = HDA_FIXUP_PINS,
12125 		.v.pins = (const struct hda_pintbl[]) {
12126 			{ 0x0b, 0x0221101f }, /* HP */
12127 			{ 0x0f, 0x90170310 }, /* speaker */
12128 			{ }
12129 		}
12130 	},
12131 	[ALC861_FIXUP_AMP_VREF_0F] = {
12132 		.type = HDA_FIXUP_FUNC,
12133 		.v.func = alc861_fixup_asus_amp_vref_0f,
12134 	},
12135 	[ALC861_FIXUP_NO_JACK_DETECT] = {
12136 		.type = HDA_FIXUP_FUNC,
12137 		.v.func = alc_fixup_no_jack_detect,
12138 	},
12139 	[ALC861_FIXUP_ASUS_A6RP] = {
12140 		.type = HDA_FIXUP_FUNC,
12141 		.v.func = alc861_fixup_asus_amp_vref_0f,
12142 		.chained = true,
12143 		.chain_id = ALC861_FIXUP_NO_JACK_DETECT,
12144 	},
12145 	[ALC660_FIXUP_ASUS_W7J] = {
12146 		.type = HDA_FIXUP_VERBS,
12147 		.v.verbs = (const struct hda_verb[]) {
12148 			/* ASUS W7J needs a magic pin setup on unused NID 0x10
12149 			 * for enabling outputs
12150 			 */
12151 			{0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
12152 			{ }
12153 		},
12154 	}
12155 };
12156 
12157 static const struct hda_quirk alc861_fixup_tbl[] = {
12158 	SND_PCI_QUIRK(0x1043, 0x1253, "ASUS W7J", ALC660_FIXUP_ASUS_W7J),
12159 	SND_PCI_QUIRK(0x1043, 0x1263, "ASUS Z35HL", ALC660_FIXUP_ASUS_W7J),
12160 	SND_PCI_QUIRK(0x1043, 0x1393, "ASUS A6Rp", ALC861_FIXUP_ASUS_A6RP),
12161 	SND_PCI_QUIRK_VENDOR(0x1043, "ASUS laptop", ALC861_FIXUP_AMP_VREF_0F),
12162 	SND_PCI_QUIRK(0x1462, 0x7254, "HP DX2200", ALC861_FIXUP_NO_JACK_DETECT),
12163 	SND_PCI_QUIRK_VENDOR(0x1584, "Haier/Uniwill", ALC861_FIXUP_AMP_VREF_0F),
12164 	SND_PCI_QUIRK(0x1734, 0x10c7, "FSC Amilo Pi1505", ALC861_FIXUP_FSC_AMILO_PI1505),
12165 	{}
12166 };
12167 
12168 /*
12169  */
patch_alc861(struct hda_codec * codec)12170 static int patch_alc861(struct hda_codec *codec)
12171 {
12172 	struct alc_spec *spec;
12173 	int err;
12174 
12175 	err = alc_alloc_spec(codec, 0x15);
12176 	if (err < 0)
12177 		return err;
12178 
12179 	spec = codec->spec;
12180 	if (has_cdefine_beep(codec))
12181 		spec->gen.beep_nid = 0x23;
12182 
12183 	spec->power_hook = alc_power_eapd;
12184 
12185 	alc_pre_init(codec);
12186 
12187 	snd_hda_pick_fixup(codec, NULL, alc861_fixup_tbl, alc861_fixups);
12188 	snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE);
12189 
12190 	/* automatic parse from the BIOS config */
12191 	err = alc861_parse_auto_config(codec);
12192 	if (err < 0)
12193 		goto error;
12194 
12195 	if (!spec->gen.no_analog) {
12196 		err = set_beep_amp(spec, 0x23, 0, HDA_OUTPUT);
12197 		if (err < 0)
12198 			goto error;
12199 	}
12200 
12201 	snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE);
12202 
12203 	return 0;
12204 
12205  error:
12206 	alc_free(codec);
12207 	return err;
12208 }
12209 
12210 /*
12211  * ALC861-VD support
12212  *
12213  * Based on ALC882
12214  *
12215  * In addition, an independent DAC
12216  */
alc861vd_parse_auto_config(struct hda_codec * codec)12217 static int alc861vd_parse_auto_config(struct hda_codec *codec)
12218 {
12219 	static const hda_nid_t alc861vd_ignore[] = { 0x1d, 0 };
12220 	static const hda_nid_t alc861vd_ssids[] = { 0x15, 0x1b, 0x14, 0 };
12221 	return alc_parse_auto_config(codec, alc861vd_ignore, alc861vd_ssids);
12222 }
12223 
12224 enum {
12225 	ALC660VD_FIX_ASUS_GPIO1,
12226 	ALC861VD_FIX_DALLAS,
12227 };
12228 
12229 /* exclude VREF80 */
alc861vd_fixup_dallas(struct hda_codec * codec,const struct hda_fixup * fix,int action)12230 static void alc861vd_fixup_dallas(struct hda_codec *codec,
12231 				  const struct hda_fixup *fix, int action)
12232 {
12233 	if (action == HDA_FIXUP_ACT_PRE_PROBE) {
12234 		snd_hda_override_pin_caps(codec, 0x18, 0x00000734);
12235 		snd_hda_override_pin_caps(codec, 0x19, 0x0000073c);
12236 	}
12237 }
12238 
12239 /* reset GPIO1 */
alc660vd_fixup_asus_gpio1(struct hda_codec * codec,const struct hda_fixup * fix,int action)12240 static void alc660vd_fixup_asus_gpio1(struct hda_codec *codec,
12241 				      const struct hda_fixup *fix, int action)
12242 {
12243 	struct alc_spec *spec = codec->spec;
12244 
12245 	if (action == HDA_FIXUP_ACT_PRE_PROBE)
12246 		spec->gpio_mask |= 0x02;
12247 	alc_fixup_gpio(codec, action, 0x01);
12248 }
12249 
12250 static const struct hda_fixup alc861vd_fixups[] = {
12251 	[ALC660VD_FIX_ASUS_GPIO1] = {
12252 		.type = HDA_FIXUP_FUNC,
12253 		.v.func = alc660vd_fixup_asus_gpio1,
12254 	},
12255 	[ALC861VD_FIX_DALLAS] = {
12256 		.type = HDA_FIXUP_FUNC,
12257 		.v.func = alc861vd_fixup_dallas,
12258 	},
12259 };
12260 
12261 static const struct hda_quirk alc861vd_fixup_tbl[] = {
12262 	SND_PCI_QUIRK(0x103c, 0x30bf, "HP TX1000", ALC861VD_FIX_DALLAS),
12263 	SND_PCI_QUIRK(0x1043, 0x1339, "ASUS A7-K", ALC660VD_FIX_ASUS_GPIO1),
12264 	SND_PCI_QUIRK(0x1179, 0xff31, "Toshiba L30-149", ALC861VD_FIX_DALLAS),
12265 	{}
12266 };
12267 
12268 /*
12269  */
patch_alc861vd(struct hda_codec * codec)12270 static int patch_alc861vd(struct hda_codec *codec)
12271 {
12272 	struct alc_spec *spec;
12273 	int err;
12274 
12275 	err = alc_alloc_spec(codec, 0x0b);
12276 	if (err < 0)
12277 		return err;
12278 
12279 	spec = codec->spec;
12280 	if (has_cdefine_beep(codec))
12281 		spec->gen.beep_nid = 0x23;
12282 
12283 	spec->shutup = alc_eapd_shutup;
12284 
12285 	alc_pre_init(codec);
12286 
12287 	snd_hda_pick_fixup(codec, NULL, alc861vd_fixup_tbl, alc861vd_fixups);
12288 	snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE);
12289 
12290 	/* automatic parse from the BIOS config */
12291 	err = alc861vd_parse_auto_config(codec);
12292 	if (err < 0)
12293 		goto error;
12294 
12295 	if (!spec->gen.no_analog) {
12296 		err = set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
12297 		if (err < 0)
12298 			goto error;
12299 	}
12300 
12301 	snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE);
12302 
12303 	return 0;
12304 
12305  error:
12306 	alc_free(codec);
12307 	return err;
12308 }
12309 
12310 /*
12311  * ALC662 support
12312  *
12313  * ALC662 is almost identical with ALC880 but has cleaner and more flexible
12314  * configuration.  Each pin widget can choose any input DACs and a mixer.
12315  * Each ADC is connected from a mixer of all inputs.  This makes possible
12316  * 6-channel independent captures.
12317  *
12318  * In addition, an independent DAC for the multi-playback (not used in this
12319  * driver yet).
12320  */
12321 
12322 /*
12323  * BIOS auto configuration
12324  */
12325 
alc662_parse_auto_config(struct hda_codec * codec)12326 static int alc662_parse_auto_config(struct hda_codec *codec)
12327 {
12328 	static const hda_nid_t alc662_ignore[] = { 0x1d, 0 };
12329 	static const hda_nid_t alc663_ssids[] = { 0x15, 0x1b, 0x14, 0x21 };
12330 	static const hda_nid_t alc662_ssids[] = { 0x15, 0x1b, 0x14, 0 };
12331 	const hda_nid_t *ssids;
12332 
12333 	if (codec->core.vendor_id == 0x10ec0272 || codec->core.vendor_id == 0x10ec0663 ||
12334 	    codec->core.vendor_id == 0x10ec0665 || codec->core.vendor_id == 0x10ec0670 ||
12335 	    codec->core.vendor_id == 0x10ec0671)
12336 		ssids = alc663_ssids;
12337 	else
12338 		ssids = alc662_ssids;
12339 	return alc_parse_auto_config(codec, alc662_ignore, ssids);
12340 }
12341 
alc272_fixup_mario(struct hda_codec * codec,const struct hda_fixup * fix,int action)12342 static void alc272_fixup_mario(struct hda_codec *codec,
12343 			       const struct hda_fixup *fix, int action)
12344 {
12345 	if (action != HDA_FIXUP_ACT_PRE_PROBE)
12346 		return;
12347 	if (snd_hda_override_amp_caps(codec, 0x2, HDA_OUTPUT,
12348 				      (0x3b << AC_AMPCAP_OFFSET_SHIFT) |
12349 				      (0x3b << AC_AMPCAP_NUM_STEPS_SHIFT) |
12350 				      (0x03 << AC_AMPCAP_STEP_SIZE_SHIFT) |
12351 				      (0 << AC_AMPCAP_MUTE_SHIFT)))
12352 		codec_warn(codec, "failed to override amp caps for NID 0x2\n");
12353 }
12354 
12355 static const struct snd_pcm_chmap_elem asus_pcm_2_1_chmaps[] = {
12356 	{ .channels = 2,
12357 	  .map = { SNDRV_CHMAP_FL, SNDRV_CHMAP_FR } },
12358 	{ .channels = 4,
12359 	  .map = { SNDRV_CHMAP_FL, SNDRV_CHMAP_FR,
12360 		   SNDRV_CHMAP_NA, SNDRV_CHMAP_LFE } }, /* LFE only on right */
12361 	{ }
12362 };
12363 
12364 /* override the 2.1 chmap */
alc_fixup_bass_chmap(struct hda_codec * codec,const struct hda_fixup * fix,int action)12365 static void alc_fixup_bass_chmap(struct hda_codec *codec,
12366 				    const struct hda_fixup *fix, int action)
12367 {
12368 	if (action == HDA_FIXUP_ACT_BUILD) {
12369 		struct alc_spec *spec = codec->spec;
12370 		spec->gen.pcm_rec[0]->stream[0].chmap = asus_pcm_2_1_chmaps;
12371 	}
12372 }
12373 
12374 /* avoid D3 for keeping GPIO up */
gpio_led_power_filter(struct hda_codec * codec,hda_nid_t nid,unsigned int power_state)12375 static unsigned int gpio_led_power_filter(struct hda_codec *codec,
12376 					  hda_nid_t nid,
12377 					  unsigned int power_state)
12378 {
12379 	struct alc_spec *spec = codec->spec;
12380 	if (nid == codec->core.afg && power_state == AC_PWRST_D3 && spec->gpio_data)
12381 		return AC_PWRST_D0;
12382 	return power_state;
12383 }
12384 
alc662_fixup_led_gpio1(struct hda_codec * codec,const struct hda_fixup * fix,int action)12385 static void alc662_fixup_led_gpio1(struct hda_codec *codec,
12386 				   const struct hda_fixup *fix, int action)
12387 {
12388 	struct alc_spec *spec = codec->spec;
12389 
12390 	alc_fixup_hp_gpio_led(codec, action, 0x01, 0);
12391 	if (action == HDA_FIXUP_ACT_PRE_PROBE) {
12392 		spec->mute_led_polarity = 1;
12393 		codec->power_filter = gpio_led_power_filter;
12394 	}
12395 }
12396 
alc662_usi_automute_hook(struct hda_codec * codec,struct hda_jack_callback * jack)12397 static void alc662_usi_automute_hook(struct hda_codec *codec,
12398 					 struct hda_jack_callback *jack)
12399 {
12400 	struct alc_spec *spec = codec->spec;
12401 	int vref;
12402 	msleep(200);
12403 	snd_hda_gen_hp_automute(codec, jack);
12404 
12405 	vref = spec->gen.hp_jack_present ? PIN_VREF80 : 0;
12406 	msleep(100);
12407 	snd_hda_codec_write(codec, 0x19, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
12408 			    vref);
12409 }
12410 
alc662_fixup_usi_headset_mic(struct hda_codec * codec,const struct hda_fixup * fix,int action)12411 static void alc662_fixup_usi_headset_mic(struct hda_codec *codec,
12412 				     const struct hda_fixup *fix, int action)
12413 {
12414 	struct alc_spec *spec = codec->spec;
12415 	if (action == HDA_FIXUP_ACT_PRE_PROBE) {
12416 		spec->parse_flags |= HDA_PINCFG_HEADSET_MIC;
12417 		spec->gen.hp_automute_hook = alc662_usi_automute_hook;
12418 	}
12419 }
12420 
alc662_aspire_ethos_mute_speakers(struct hda_codec * codec,struct hda_jack_callback * cb)12421 static void alc662_aspire_ethos_mute_speakers(struct hda_codec *codec,
12422 					struct hda_jack_callback *cb)
12423 {
12424 	/* surround speakers at 0x1b already get muted automatically when
12425 	 * headphones are plugged in, but we have to mute/unmute the remaining
12426 	 * channels manually:
12427 	 * 0x15 - front left/front right
12428 	 * 0x18 - front center/ LFE
12429 	 */
12430 	if (snd_hda_jack_detect_state(codec, 0x1b) == HDA_JACK_PRESENT) {
12431 		snd_hda_set_pin_ctl_cache(codec, 0x15, 0);
12432 		snd_hda_set_pin_ctl_cache(codec, 0x18, 0);
12433 	} else {
12434 		snd_hda_set_pin_ctl_cache(codec, 0x15, PIN_OUT);
12435 		snd_hda_set_pin_ctl_cache(codec, 0x18, PIN_OUT);
12436 	}
12437 }
12438 
alc662_fixup_aspire_ethos_hp(struct hda_codec * codec,const struct hda_fixup * fix,int action)12439 static void alc662_fixup_aspire_ethos_hp(struct hda_codec *codec,
12440 					const struct hda_fixup *fix, int action)
12441 {
12442     /* Pin 0x1b: shared headphones jack and surround speakers */
12443 	if (!is_jack_detectable(codec, 0x1b))
12444 		return;
12445 
12446 	switch (action) {
12447 	case HDA_FIXUP_ACT_PRE_PROBE:
12448 		snd_hda_jack_detect_enable_callback(codec, 0x1b,
12449 				alc662_aspire_ethos_mute_speakers);
12450 		/* subwoofer needs an extra GPIO setting to become audible */
12451 		alc_setup_gpio(codec, 0x02);
12452 		break;
12453 	case HDA_FIXUP_ACT_INIT:
12454 		/* Make sure to start in a correct state, i.e. if
12455 		 * headphones have been plugged in before powering up the system
12456 		 */
12457 		alc662_aspire_ethos_mute_speakers(codec, NULL);
12458 		break;
12459 	}
12460 }
12461 
alc671_fixup_hp_headset_mic2(struct hda_codec * codec,const struct hda_fixup * fix,int action)12462 static void alc671_fixup_hp_headset_mic2(struct hda_codec *codec,
12463 					     const struct hda_fixup *fix, int action)
12464 {
12465 	struct alc_spec *spec = codec->spec;
12466 
12467 	static const struct hda_pintbl pincfgs[] = {
12468 		{ 0x19, 0x02a11040 }, /* use as headset mic, with its own jack detect */
12469 		{ 0x1b, 0x0181304f },
12470 		{ }
12471 	};
12472 
12473 	switch (action) {
12474 	case HDA_FIXUP_ACT_PRE_PROBE:
12475 		spec->gen.mixer_nid = 0;
12476 		spec->parse_flags |= HDA_PINCFG_HEADSET_MIC;
12477 		snd_hda_apply_pincfgs(codec, pincfgs);
12478 		break;
12479 	case HDA_FIXUP_ACT_INIT:
12480 		alc_write_coef_idx(codec, 0x19, 0xa054);
12481 		break;
12482 	}
12483 }
12484 
alc897_hp_automute_hook(struct hda_codec * codec,struct hda_jack_callback * jack)12485 static void alc897_hp_automute_hook(struct hda_codec *codec,
12486 					 struct hda_jack_callback *jack)
12487 {
12488 	struct alc_spec *spec = codec->spec;
12489 	int vref;
12490 
12491 	snd_hda_gen_hp_automute(codec, jack);
12492 	vref = spec->gen.hp_jack_present ? (PIN_HP | AC_PINCTL_VREF_100) : PIN_HP;
12493 	snd_hda_set_pin_ctl(codec, 0x1b, vref);
12494 }
12495 
alc897_fixup_lenovo_headset_mic(struct hda_codec * codec,const struct hda_fixup * fix,int action)12496 static void alc897_fixup_lenovo_headset_mic(struct hda_codec *codec,
12497 				     const struct hda_fixup *fix, int action)
12498 {
12499 	struct alc_spec *spec = codec->spec;
12500 	if (action == HDA_FIXUP_ACT_PRE_PROBE) {
12501 		spec->gen.hp_automute_hook = alc897_hp_automute_hook;
12502 		spec->no_shutup_pins = 1;
12503 	}
12504 	if (action == HDA_FIXUP_ACT_PROBE) {
12505 		snd_hda_set_pin_ctl_cache(codec, 0x1a, PIN_IN | AC_PINCTL_VREF_100);
12506 	}
12507 }
12508 
alc897_fixup_lenovo_headset_mode(struct hda_codec * codec,const struct hda_fixup * fix,int action)12509 static void alc897_fixup_lenovo_headset_mode(struct hda_codec *codec,
12510 				     const struct hda_fixup *fix, int action)
12511 {
12512 	struct alc_spec *spec = codec->spec;
12513 
12514 	if (action == HDA_FIXUP_ACT_PRE_PROBE) {
12515 		spec->parse_flags |= HDA_PINCFG_HEADSET_MIC;
12516 		spec->gen.hp_automute_hook = alc897_hp_automute_hook;
12517 	}
12518 }
12519 
12520 static const struct coef_fw alc668_coefs[] = {
12521 	WRITE_COEF(0x01, 0xbebe), WRITE_COEF(0x02, 0xaaaa), WRITE_COEF(0x03,    0x0),
12522 	WRITE_COEF(0x04, 0x0180), WRITE_COEF(0x06,    0x0), WRITE_COEF(0x07, 0x0f80),
12523 	WRITE_COEF(0x08, 0x0031), WRITE_COEF(0x0a, 0x0060), WRITE_COEF(0x0b,    0x0),
12524 	WRITE_COEF(0x0c, 0x7cf7), WRITE_COEF(0x0d, 0x1080), WRITE_COEF(0x0e, 0x7f7f),
12525 	WRITE_COEF(0x0f, 0xcccc), WRITE_COEF(0x10, 0xddcc), WRITE_COEF(0x11, 0x0001),
12526 	WRITE_COEF(0x13,    0x0), WRITE_COEF(0x14, 0x2aa0), WRITE_COEF(0x17, 0xa940),
12527 	WRITE_COEF(0x19,    0x0), WRITE_COEF(0x1a,    0x0), WRITE_COEF(0x1b,    0x0),
12528 	WRITE_COEF(0x1c,    0x0), WRITE_COEF(0x1d,    0x0), WRITE_COEF(0x1e, 0x7418),
12529 	WRITE_COEF(0x1f, 0x0804), WRITE_COEF(0x20, 0x4200), WRITE_COEF(0x21, 0x0468),
12530 	WRITE_COEF(0x22, 0x8ccc), WRITE_COEF(0x23, 0x0250), WRITE_COEF(0x24, 0x7418),
12531 	WRITE_COEF(0x27,    0x0), WRITE_COEF(0x28, 0x8ccc), WRITE_COEF(0x2a, 0xff00),
12532 	WRITE_COEF(0x2b, 0x8000), WRITE_COEF(0xa7, 0xff00), WRITE_COEF(0xa8, 0x8000),
12533 	WRITE_COEF(0xaa, 0x2e17), WRITE_COEF(0xab, 0xa0c0), WRITE_COEF(0xac,    0x0),
12534 	WRITE_COEF(0xad,    0x0), WRITE_COEF(0xae, 0x2ac6), WRITE_COEF(0xaf, 0xa480),
12535 	WRITE_COEF(0xb0,    0x0), WRITE_COEF(0xb1,    0x0), WRITE_COEF(0xb2,    0x0),
12536 	WRITE_COEF(0xb3,    0x0), WRITE_COEF(0xb4,    0x0), WRITE_COEF(0xb5, 0x1040),
12537 	WRITE_COEF(0xb6, 0xd697), WRITE_COEF(0xb7, 0x902b), WRITE_COEF(0xb8, 0xd697),
12538 	WRITE_COEF(0xb9, 0x902b), WRITE_COEF(0xba, 0xb8ba), WRITE_COEF(0xbb, 0xaaab),
12539 	WRITE_COEF(0xbc, 0xaaaf), WRITE_COEF(0xbd, 0x6aaa), WRITE_COEF(0xbe, 0x1c02),
12540 	WRITE_COEF(0xc0, 0x00ff), WRITE_COEF(0xc1, 0x0fa6),
12541 	{}
12542 };
12543 
alc668_restore_default_value(struct hda_codec * codec)12544 static void alc668_restore_default_value(struct hda_codec *codec)
12545 {
12546 	alc_process_coef_fw(codec, alc668_coefs);
12547 }
12548 
12549 enum {
12550 	ALC662_FIXUP_ASPIRE,
12551 	ALC662_FIXUP_LED_GPIO1,
12552 	ALC662_FIXUP_IDEAPAD,
12553 	ALC272_FIXUP_MARIO,
12554 	ALC662_FIXUP_CZC_ET26,
12555 	ALC662_FIXUP_CZC_P10T,
12556 	ALC662_FIXUP_SKU_IGNORE,
12557 	ALC662_FIXUP_HP_RP5800,
12558 	ALC662_FIXUP_ASUS_MODE1,
12559 	ALC662_FIXUP_ASUS_MODE2,
12560 	ALC662_FIXUP_ASUS_MODE3,
12561 	ALC662_FIXUP_ASUS_MODE4,
12562 	ALC662_FIXUP_ASUS_MODE5,
12563 	ALC662_FIXUP_ASUS_MODE6,
12564 	ALC662_FIXUP_ASUS_MODE7,
12565 	ALC662_FIXUP_ASUS_MODE8,
12566 	ALC662_FIXUP_NO_JACK_DETECT,
12567 	ALC662_FIXUP_ZOTAC_Z68,
12568 	ALC662_FIXUP_INV_DMIC,
12569 	ALC662_FIXUP_DELL_MIC_NO_PRESENCE,
12570 	ALC668_FIXUP_DELL_MIC_NO_PRESENCE,
12571 	ALC662_FIXUP_HEADSET_MODE,
12572 	ALC668_FIXUP_HEADSET_MODE,
12573 	ALC662_FIXUP_BASS_MODE4_CHMAP,
12574 	ALC662_FIXUP_BASS_16,
12575 	ALC662_FIXUP_BASS_1A,
12576 	ALC662_FIXUP_BASS_CHMAP,
12577 	ALC668_FIXUP_AUTO_MUTE,
12578 	ALC668_FIXUP_DELL_DISABLE_AAMIX,
12579 	ALC668_FIXUP_DELL_XPS13,
12580 	ALC662_FIXUP_ASUS_Nx50,
12581 	ALC668_FIXUP_ASUS_Nx51_HEADSET_MODE,
12582 	ALC668_FIXUP_ASUS_Nx51,
12583 	ALC668_FIXUP_MIC_COEF,
12584 	ALC668_FIXUP_ASUS_G751,
12585 	ALC891_FIXUP_HEADSET_MODE,
12586 	ALC891_FIXUP_DELL_MIC_NO_PRESENCE,
12587 	ALC662_FIXUP_ACER_VERITON,
12588 	ALC892_FIXUP_ASROCK_MOBO,
12589 	ALC662_FIXUP_USI_FUNC,
12590 	ALC662_FIXUP_USI_HEADSET_MODE,
12591 	ALC662_FIXUP_LENOVO_MULTI_CODECS,
12592 	ALC669_FIXUP_ACER_ASPIRE_ETHOS,
12593 	ALC669_FIXUP_ACER_ASPIRE_ETHOS_HEADSET,
12594 	ALC671_FIXUP_HP_HEADSET_MIC2,
12595 	ALC662_FIXUP_ACER_X2660G_HEADSET_MODE,
12596 	ALC662_FIXUP_ACER_NITRO_HEADSET_MODE,
12597 	ALC668_FIXUP_ASUS_NO_HEADSET_MIC,
12598 	ALC668_FIXUP_HEADSET_MIC,
12599 	ALC668_FIXUP_MIC_DET_COEF,
12600 	ALC897_FIXUP_LENOVO_HEADSET_MIC,
12601 	ALC897_FIXUP_HEADSET_MIC_PIN,
12602 	ALC897_FIXUP_HP_HSMIC_VERB,
12603 	ALC897_FIXUP_LENOVO_HEADSET_MODE,
12604 	ALC897_FIXUP_HEADSET_MIC_PIN2,
12605 	ALC897_FIXUP_UNIS_H3C_X500S,
12606 	ALC897_FIXUP_HEADSET_MIC_PIN3,
12607 };
12608 
12609 static const struct hda_fixup alc662_fixups[] = {
12610 	[ALC662_FIXUP_ASPIRE] = {
12611 		.type = HDA_FIXUP_PINS,
12612 		.v.pins = (const struct hda_pintbl[]) {
12613 			{ 0x15, 0x99130112 }, /* subwoofer */
12614 			{ }
12615 		}
12616 	},
12617 	[ALC662_FIXUP_LED_GPIO1] = {
12618 		.type = HDA_FIXUP_FUNC,
12619 		.v.func = alc662_fixup_led_gpio1,
12620 	},
12621 	[ALC662_FIXUP_IDEAPAD] = {
12622 		.type = HDA_FIXUP_PINS,
12623 		.v.pins = (const struct hda_pintbl[]) {
12624 			{ 0x17, 0x99130112 }, /* subwoofer */
12625 			{ }
12626 		},
12627 		.chained = true,
12628 		.chain_id = ALC662_FIXUP_LED_GPIO1,
12629 	},
12630 	[ALC272_FIXUP_MARIO] = {
12631 		.type = HDA_FIXUP_FUNC,
12632 		.v.func = alc272_fixup_mario,
12633 	},
12634 	[ALC662_FIXUP_CZC_ET26] = {
12635 		.type = HDA_FIXUP_PINS,
12636 		.v.pins = (const struct hda_pintbl[]) {
12637 			{0x12, 0x403cc000},
12638 			{0x14, 0x90170110}, /* speaker */
12639 			{0x15, 0x411111f0},
12640 			{0x16, 0x411111f0},
12641 			{0x18, 0x01a19030}, /* mic */
12642 			{0x19, 0x90a7013f}, /* int-mic */
12643 			{0x1a, 0x01014020},
12644 			{0x1b, 0x0121401f},
12645 			{0x1c, 0x411111f0},
12646 			{0x1d, 0x411111f0},
12647 			{0x1e, 0x40478e35},
12648 			{}
12649 		},
12650 		.chained = true,
12651 		.chain_id = ALC662_FIXUP_SKU_IGNORE
12652 	},
12653 	[ALC662_FIXUP_CZC_P10T] = {
12654 		.type = HDA_FIXUP_VERBS,
12655 		.v.verbs = (const struct hda_verb[]) {
12656 			{0x14, AC_VERB_SET_EAPD_BTLENABLE, 0},
12657 			{}
12658 		}
12659 	},
12660 	[ALC662_FIXUP_SKU_IGNORE] = {
12661 		.type = HDA_FIXUP_FUNC,
12662 		.v.func = alc_fixup_sku_ignore,
12663 	},
12664 	[ALC662_FIXUP_HP_RP5800] = {
12665 		.type = HDA_FIXUP_PINS,
12666 		.v.pins = (const struct hda_pintbl[]) {
12667 			{ 0x14, 0x0221201f }, /* HP out */
12668 			{ }
12669 		},
12670 		.chained = true,
12671 		.chain_id = ALC662_FIXUP_SKU_IGNORE
12672 	},
12673 	[ALC662_FIXUP_ASUS_MODE1] = {
12674 		.type = HDA_FIXUP_PINS,
12675 		.v.pins = (const struct hda_pintbl[]) {
12676 			{ 0x14, 0x99130110 }, /* speaker */
12677 			{ 0x18, 0x01a19c20 }, /* mic */
12678 			{ 0x19, 0x99a3092f }, /* int-mic */
12679 			{ 0x21, 0x0121401f }, /* HP out */
12680 			{ }
12681 		},
12682 		.chained = true,
12683 		.chain_id = ALC662_FIXUP_SKU_IGNORE
12684 	},
12685 	[ALC662_FIXUP_ASUS_MODE2] = {
12686 		.type = HDA_FIXUP_PINS,
12687 		.v.pins = (const struct hda_pintbl[]) {
12688 			{ 0x14, 0x99130110 }, /* speaker */
12689 			{ 0x18, 0x01a19820 }, /* mic */
12690 			{ 0x19, 0x99a3092f }, /* int-mic */
12691 			{ 0x1b, 0x0121401f }, /* HP out */
12692 			{ }
12693 		},
12694 		.chained = true,
12695 		.chain_id = ALC662_FIXUP_SKU_IGNORE
12696 	},
12697 	[ALC662_FIXUP_ASUS_MODE3] = {
12698 		.type = HDA_FIXUP_PINS,
12699 		.v.pins = (const struct hda_pintbl[]) {
12700 			{ 0x14, 0x99130110 }, /* speaker */
12701 			{ 0x15, 0x0121441f }, /* HP */
12702 			{ 0x18, 0x01a19840 }, /* mic */
12703 			{ 0x19, 0x99a3094f }, /* int-mic */
12704 			{ 0x21, 0x01211420 }, /* HP2 */
12705 			{ }
12706 		},
12707 		.chained = true,
12708 		.chain_id = ALC662_FIXUP_SKU_IGNORE
12709 	},
12710 	[ALC662_FIXUP_ASUS_MODE4] = {
12711 		.type = HDA_FIXUP_PINS,
12712 		.v.pins = (const struct hda_pintbl[]) {
12713 			{ 0x14, 0x99130110 }, /* speaker */
12714 			{ 0x16, 0x99130111 }, /* speaker */
12715 			{ 0x18, 0x01a19840 }, /* mic */
12716 			{ 0x19, 0x99a3094f }, /* int-mic */
12717 			{ 0x21, 0x0121441f }, /* HP */
12718 			{ }
12719 		},
12720 		.chained = true,
12721 		.chain_id = ALC662_FIXUP_SKU_IGNORE
12722 	},
12723 	[ALC662_FIXUP_ASUS_MODE5] = {
12724 		.type = HDA_FIXUP_PINS,
12725 		.v.pins = (const struct hda_pintbl[]) {
12726 			{ 0x14, 0x99130110 }, /* speaker */
12727 			{ 0x15, 0x0121441f }, /* HP */
12728 			{ 0x16, 0x99130111 }, /* speaker */
12729 			{ 0x18, 0x01a19840 }, /* mic */
12730 			{ 0x19, 0x99a3094f }, /* int-mic */
12731 			{ }
12732 		},
12733 		.chained = true,
12734 		.chain_id = ALC662_FIXUP_SKU_IGNORE
12735 	},
12736 	[ALC662_FIXUP_ASUS_MODE6] = {
12737 		.type = HDA_FIXUP_PINS,
12738 		.v.pins = (const struct hda_pintbl[]) {
12739 			{ 0x14, 0x99130110 }, /* speaker */
12740 			{ 0x15, 0x01211420 }, /* HP2 */
12741 			{ 0x18, 0x01a19840 }, /* mic */
12742 			{ 0x19, 0x99a3094f }, /* int-mic */
12743 			{ 0x1b, 0x0121441f }, /* HP */
12744 			{ }
12745 		},
12746 		.chained = true,
12747 		.chain_id = ALC662_FIXUP_SKU_IGNORE
12748 	},
12749 	[ALC662_FIXUP_ASUS_MODE7] = {
12750 		.type = HDA_FIXUP_PINS,
12751 		.v.pins = (const struct hda_pintbl[]) {
12752 			{ 0x14, 0x99130110 }, /* speaker */
12753 			{ 0x17, 0x99130111 }, /* speaker */
12754 			{ 0x18, 0x01a19840 }, /* mic */
12755 			{ 0x19, 0x99a3094f }, /* int-mic */
12756 			{ 0x1b, 0x01214020 }, /* HP */
12757 			{ 0x21, 0x0121401f }, /* HP */
12758 			{ }
12759 		},
12760 		.chained = true,
12761 		.chain_id = ALC662_FIXUP_SKU_IGNORE
12762 	},
12763 	[ALC662_FIXUP_ASUS_MODE8] = {
12764 		.type = HDA_FIXUP_PINS,
12765 		.v.pins = (const struct hda_pintbl[]) {
12766 			{ 0x14, 0x99130110 }, /* speaker */
12767 			{ 0x12, 0x99a30970 }, /* int-mic */
12768 			{ 0x15, 0x01214020 }, /* HP */
12769 			{ 0x17, 0x99130111 }, /* speaker */
12770 			{ 0x18, 0x01a19840 }, /* mic */
12771 			{ 0x21, 0x0121401f }, /* HP */
12772 			{ }
12773 		},
12774 		.chained = true,
12775 		.chain_id = ALC662_FIXUP_SKU_IGNORE
12776 	},
12777 	[ALC662_FIXUP_NO_JACK_DETECT] = {
12778 		.type = HDA_FIXUP_FUNC,
12779 		.v.func = alc_fixup_no_jack_detect,
12780 	},
12781 	[ALC662_FIXUP_ZOTAC_Z68] = {
12782 		.type = HDA_FIXUP_PINS,
12783 		.v.pins = (const struct hda_pintbl[]) {
12784 			{ 0x1b, 0x02214020 }, /* Front HP */
12785 			{ }
12786 		}
12787 	},
12788 	[ALC662_FIXUP_INV_DMIC] = {
12789 		.type = HDA_FIXUP_FUNC,
12790 		.v.func = alc_fixup_inv_dmic,
12791 	},
12792 	[ALC668_FIXUP_DELL_XPS13] = {
12793 		.type = HDA_FIXUP_FUNC,
12794 		.v.func = alc_fixup_dell_xps13,
12795 		.chained = true,
12796 		.chain_id = ALC668_FIXUP_DELL_DISABLE_AAMIX
12797 	},
12798 	[ALC668_FIXUP_DELL_DISABLE_AAMIX] = {
12799 		.type = HDA_FIXUP_FUNC,
12800 		.v.func = alc_fixup_disable_aamix,
12801 		.chained = true,
12802 		.chain_id = ALC668_FIXUP_DELL_MIC_NO_PRESENCE
12803 	},
12804 	[ALC668_FIXUP_AUTO_MUTE] = {
12805 		.type = HDA_FIXUP_FUNC,
12806 		.v.func = alc_fixup_auto_mute_via_amp,
12807 		.chained = true,
12808 		.chain_id = ALC668_FIXUP_DELL_MIC_NO_PRESENCE
12809 	},
12810 	[ALC662_FIXUP_DELL_MIC_NO_PRESENCE] = {
12811 		.type = HDA_FIXUP_PINS,
12812 		.v.pins = (const struct hda_pintbl[]) {
12813 			{ 0x19, 0x03a1113c }, /* use as headset mic, without its own jack detect */
12814 			/* headphone mic by setting pin control of 0x1b (headphone out) to in + vref_50 */
12815 			{ }
12816 		},
12817 		.chained = true,
12818 		.chain_id = ALC662_FIXUP_HEADSET_MODE
12819 	},
12820 	[ALC662_FIXUP_HEADSET_MODE] = {
12821 		.type = HDA_FIXUP_FUNC,
12822 		.v.func = alc_fixup_headset_mode_alc662,
12823 	},
12824 	[ALC668_FIXUP_DELL_MIC_NO_PRESENCE] = {
12825 		.type = HDA_FIXUP_PINS,
12826 		.v.pins = (const struct hda_pintbl[]) {
12827 			{ 0x19, 0x03a1913d }, /* use as headphone mic, without its own jack detect */
12828 			{ 0x1b, 0x03a1113c }, /* use as headset mic, without its own jack detect */
12829 			{ }
12830 		},
12831 		.chained = true,
12832 		.chain_id = ALC668_FIXUP_HEADSET_MODE
12833 	},
12834 	[ALC668_FIXUP_HEADSET_MODE] = {
12835 		.type = HDA_FIXUP_FUNC,
12836 		.v.func = alc_fixup_headset_mode_alc668,
12837 	},
12838 	[ALC662_FIXUP_BASS_MODE4_CHMAP] = {
12839 		.type = HDA_FIXUP_FUNC,
12840 		.v.func = alc_fixup_bass_chmap,
12841 		.chained = true,
12842 		.chain_id = ALC662_FIXUP_ASUS_MODE4
12843 	},
12844 	[ALC662_FIXUP_BASS_16] = {
12845 		.type = HDA_FIXUP_PINS,
12846 		.v.pins = (const struct hda_pintbl[]) {
12847 			{0x16, 0x80106111}, /* bass speaker */
12848 			{}
12849 		},
12850 		.chained = true,
12851 		.chain_id = ALC662_FIXUP_BASS_CHMAP,
12852 	},
12853 	[ALC662_FIXUP_BASS_1A] = {
12854 		.type = HDA_FIXUP_PINS,
12855 		.v.pins = (const struct hda_pintbl[]) {
12856 			{0x1a, 0x80106111}, /* bass speaker */
12857 			{}
12858 		},
12859 		.chained = true,
12860 		.chain_id = ALC662_FIXUP_BASS_CHMAP,
12861 	},
12862 	[ALC662_FIXUP_BASS_CHMAP] = {
12863 		.type = HDA_FIXUP_FUNC,
12864 		.v.func = alc_fixup_bass_chmap,
12865 	},
12866 	[ALC662_FIXUP_ASUS_Nx50] = {
12867 		.type = HDA_FIXUP_FUNC,
12868 		.v.func = alc_fixup_auto_mute_via_amp,
12869 		.chained = true,
12870 		.chain_id = ALC662_FIXUP_BASS_1A
12871 	},
12872 	[ALC668_FIXUP_ASUS_Nx51_HEADSET_MODE] = {
12873 		.type = HDA_FIXUP_FUNC,
12874 		.v.func = alc_fixup_headset_mode_alc668,
12875 		.chain_id = ALC662_FIXUP_BASS_CHMAP
12876 	},
12877 	[ALC668_FIXUP_ASUS_Nx51] = {
12878 		.type = HDA_FIXUP_PINS,
12879 		.v.pins = (const struct hda_pintbl[]) {
12880 			{ 0x19, 0x03a1913d }, /* use as headphone mic, without its own jack detect */
12881 			{ 0x1a, 0x90170151 }, /* bass speaker */
12882 			{ 0x1b, 0x03a1113c }, /* use as headset mic, without its own jack detect */
12883 			{}
12884 		},
12885 		.chained = true,
12886 		.chain_id = ALC668_FIXUP_ASUS_Nx51_HEADSET_MODE,
12887 	},
12888 	[ALC668_FIXUP_MIC_COEF] = {
12889 		.type = HDA_FIXUP_VERBS,
12890 		.v.verbs = (const struct hda_verb[]) {
12891 			{ 0x20, AC_VERB_SET_COEF_INDEX, 0xc3 },
12892 			{ 0x20, AC_VERB_SET_PROC_COEF, 0x4000 },
12893 			{}
12894 		},
12895 	},
12896 	[ALC668_FIXUP_ASUS_G751] = {
12897 		.type = HDA_FIXUP_PINS,
12898 		.v.pins = (const struct hda_pintbl[]) {
12899 			{ 0x16, 0x0421101f }, /* HP */
12900 			{}
12901 		},
12902 		.chained = true,
12903 		.chain_id = ALC668_FIXUP_MIC_COEF
12904 	},
12905 	[ALC891_FIXUP_HEADSET_MODE] = {
12906 		.type = HDA_FIXUP_FUNC,
12907 		.v.func = alc_fixup_headset_mode,
12908 	},
12909 	[ALC891_FIXUP_DELL_MIC_NO_PRESENCE] = {
12910 		.type = HDA_FIXUP_PINS,
12911 		.v.pins = (const struct hda_pintbl[]) {
12912 			{ 0x19, 0x03a1913d }, /* use as headphone mic, without its own jack detect */
12913 			{ 0x1b, 0x03a1113c }, /* use as headset mic, without its own jack detect */
12914 			{ }
12915 		},
12916 		.chained = true,
12917 		.chain_id = ALC891_FIXUP_HEADSET_MODE
12918 	},
12919 	[ALC662_FIXUP_ACER_VERITON] = {
12920 		.type = HDA_FIXUP_PINS,
12921 		.v.pins = (const struct hda_pintbl[]) {
12922 			{ 0x15, 0x50170120 }, /* no internal speaker */
12923 			{ }
12924 		}
12925 	},
12926 	[ALC892_FIXUP_ASROCK_MOBO] = {
12927 		.type = HDA_FIXUP_PINS,
12928 		.v.pins = (const struct hda_pintbl[]) {
12929 			{ 0x15, 0x40f000f0 }, /* disabled */
12930 			{ 0x16, 0x40f000f0 }, /* disabled */
12931 			{ }
12932 		}
12933 	},
12934 	[ALC662_FIXUP_USI_FUNC] = {
12935 		.type = HDA_FIXUP_FUNC,
12936 		.v.func = alc662_fixup_usi_headset_mic,
12937 	},
12938 	[ALC662_FIXUP_USI_HEADSET_MODE] = {
12939 		.type = HDA_FIXUP_PINS,
12940 		.v.pins = (const struct hda_pintbl[]) {
12941 			{ 0x19, 0x02a1913c }, /* use as headset mic, without its own jack detect */
12942 			{ 0x18, 0x01a1903d },
12943 			{ }
12944 		},
12945 		.chained = true,
12946 		.chain_id = ALC662_FIXUP_USI_FUNC
12947 	},
12948 	[ALC662_FIXUP_LENOVO_MULTI_CODECS] = {
12949 		.type = HDA_FIXUP_FUNC,
12950 		.v.func = alc233_alc662_fixup_lenovo_dual_codecs,
12951 	},
12952 	[ALC669_FIXUP_ACER_ASPIRE_ETHOS_HEADSET] = {
12953 		.type = HDA_FIXUP_FUNC,
12954 		.v.func = alc662_fixup_aspire_ethos_hp,
12955 	},
12956 	[ALC669_FIXUP_ACER_ASPIRE_ETHOS] = {
12957 		.type = HDA_FIXUP_PINS,
12958 		.v.pins = (const struct hda_pintbl[]) {
12959 			{ 0x15, 0x92130110 }, /* front speakers */
12960 			{ 0x18, 0x99130111 }, /* center/subwoofer */
12961 			{ 0x1b, 0x11130012 }, /* surround plus jack for HP */
12962 			{ }
12963 		},
12964 		.chained = true,
12965 		.chain_id = ALC669_FIXUP_ACER_ASPIRE_ETHOS_HEADSET
12966 	},
12967 	[ALC671_FIXUP_HP_HEADSET_MIC2] = {
12968 		.type = HDA_FIXUP_FUNC,
12969 		.v.func = alc671_fixup_hp_headset_mic2,
12970 	},
12971 	[ALC662_FIXUP_ACER_X2660G_HEADSET_MODE] = {
12972 		.type = HDA_FIXUP_PINS,
12973 		.v.pins = (const struct hda_pintbl[]) {
12974 			{ 0x1a, 0x02a1113c }, /* use as headset mic, without its own jack detect */
12975 			{ }
12976 		},
12977 		.chained = true,
12978 		.chain_id = ALC662_FIXUP_USI_FUNC
12979 	},
12980 	[ALC662_FIXUP_ACER_NITRO_HEADSET_MODE] = {
12981 		.type = HDA_FIXUP_PINS,
12982 		.v.pins = (const struct hda_pintbl[]) {
12983 			{ 0x1a, 0x01a11140 }, /* use as headset mic, without its own jack detect */
12984 			{ 0x1b, 0x0221144f },
12985 			{ }
12986 		},
12987 		.chained = true,
12988 		.chain_id = ALC662_FIXUP_USI_FUNC
12989 	},
12990 	[ALC668_FIXUP_ASUS_NO_HEADSET_MIC] = {
12991 		.type = HDA_FIXUP_PINS,
12992 		.v.pins = (const struct hda_pintbl[]) {
12993 			{ 0x1b, 0x04a1112c },
12994 			{ }
12995 		},
12996 		.chained = true,
12997 		.chain_id = ALC668_FIXUP_HEADSET_MIC
12998 	},
12999 	[ALC668_FIXUP_HEADSET_MIC] = {
13000 		.type = HDA_FIXUP_FUNC,
13001 		.v.func = alc269_fixup_headset_mic,
13002 		.chained = true,
13003 		.chain_id = ALC668_FIXUP_MIC_DET_COEF
13004 	},
13005 	[ALC668_FIXUP_MIC_DET_COEF] = {
13006 		.type = HDA_FIXUP_VERBS,
13007 		.v.verbs = (const struct hda_verb[]) {
13008 			{ 0x20, AC_VERB_SET_COEF_INDEX, 0x15 },
13009 			{ 0x20, AC_VERB_SET_PROC_COEF, 0x0d60 },
13010 			{}
13011 		},
13012 	},
13013 	[ALC897_FIXUP_LENOVO_HEADSET_MIC] = {
13014 		.type = HDA_FIXUP_FUNC,
13015 		.v.func = alc897_fixup_lenovo_headset_mic,
13016 	},
13017 	[ALC897_FIXUP_HEADSET_MIC_PIN] = {
13018 		.type = HDA_FIXUP_PINS,
13019 		.v.pins = (const struct hda_pintbl[]) {
13020 			{ 0x1a, 0x03a11050 },
13021 			{ }
13022 		},
13023 		.chained = true,
13024 		.chain_id = ALC897_FIXUP_LENOVO_HEADSET_MIC
13025 	},
13026 	[ALC897_FIXUP_HP_HSMIC_VERB] = {
13027 		.type = HDA_FIXUP_PINS,
13028 		.v.pins = (const struct hda_pintbl[]) {
13029 			{ 0x19, 0x01a1913c }, /* use as headset mic, without its own jack detect */
13030 			{ }
13031 		},
13032 	},
13033 	[ALC897_FIXUP_LENOVO_HEADSET_MODE] = {
13034 		.type = HDA_FIXUP_FUNC,
13035 		.v.func = alc897_fixup_lenovo_headset_mode,
13036 	},
13037 	[ALC897_FIXUP_HEADSET_MIC_PIN2] = {
13038 		.type = HDA_FIXUP_PINS,
13039 		.v.pins = (const struct hda_pintbl[]) {
13040 			{ 0x1a, 0x01a11140 }, /* use as headset mic, without its own jack detect */
13041 			{ }
13042 		},
13043 		.chained = true,
13044 		.chain_id = ALC897_FIXUP_LENOVO_HEADSET_MODE
13045 	},
13046 	[ALC897_FIXUP_UNIS_H3C_X500S] = {
13047 		.type = HDA_FIXUP_VERBS,
13048 		.v.verbs = (const struct hda_verb[]) {
13049 			{ 0x14, AC_VERB_SET_EAPD_BTLENABLE, 0 },
13050 			{}
13051 		},
13052 	},
13053 	[ALC897_FIXUP_HEADSET_MIC_PIN3] = {
13054 		.type = HDA_FIXUP_PINS,
13055 		.v.pins = (const struct hda_pintbl[]) {
13056 			{ 0x19, 0x03a11050 }, /* use as headset mic */
13057 			{ }
13058 		},
13059 	},
13060 };
13061 
13062 static const struct hda_quirk alc662_fixup_tbl[] = {
13063 	SND_PCI_QUIRK(0x1019, 0x9087, "ECS", ALC662_FIXUP_ASUS_MODE2),
13064 	SND_PCI_QUIRK(0x1019, 0x9859, "JP-IK LEAP W502", ALC897_FIXUP_HEADSET_MIC_PIN3),
13065 	SND_PCI_QUIRK(0x1025, 0x022f, "Acer Aspire One", ALC662_FIXUP_INV_DMIC),
13066 	SND_PCI_QUIRK(0x1025, 0x0241, "Packard Bell DOTS", ALC662_FIXUP_INV_DMIC),
13067 	SND_PCI_QUIRK(0x1025, 0x0308, "Acer Aspire 8942G", ALC662_FIXUP_ASPIRE),
13068 	SND_PCI_QUIRK(0x1025, 0x031c, "Gateway NV79", ALC662_FIXUP_SKU_IGNORE),
13069 	SND_PCI_QUIRK(0x1025, 0x0349, "eMachines eM250", ALC662_FIXUP_INV_DMIC),
13070 	SND_PCI_QUIRK(0x1025, 0x034a, "Gateway LT27", ALC662_FIXUP_INV_DMIC),
13071 	SND_PCI_QUIRK(0x1025, 0x038b, "Acer Aspire 8943G", ALC662_FIXUP_ASPIRE),
13072 	SND_PCI_QUIRK(0x1025, 0x0566, "Acer Aspire Ethos 8951G", ALC669_FIXUP_ACER_ASPIRE_ETHOS),
13073 	SND_PCI_QUIRK(0x1025, 0x123c, "Acer Nitro N50-600", ALC662_FIXUP_ACER_NITRO_HEADSET_MODE),
13074 	SND_PCI_QUIRK(0x1025, 0x124e, "Acer 2660G", ALC662_FIXUP_ACER_X2660G_HEADSET_MODE),
13075 	SND_PCI_QUIRK(0x1028, 0x05d8, "Dell", ALC668_FIXUP_DELL_MIC_NO_PRESENCE),
13076 	SND_PCI_QUIRK(0x1028, 0x05db, "Dell", ALC668_FIXUP_DELL_MIC_NO_PRESENCE),
13077 	SND_PCI_QUIRK(0x1028, 0x05fe, "Dell XPS 15", ALC668_FIXUP_DELL_XPS13),
13078 	SND_PCI_QUIRK(0x1028, 0x060a, "Dell XPS 13", ALC668_FIXUP_DELL_XPS13),
13079 	SND_PCI_QUIRK(0x1028, 0x060d, "Dell M3800", ALC668_FIXUP_DELL_XPS13),
13080 	SND_PCI_QUIRK(0x1028, 0x0625, "Dell", ALC668_FIXUP_DELL_MIC_NO_PRESENCE),
13081 	SND_PCI_QUIRK(0x1028, 0x0626, "Dell", ALC668_FIXUP_DELL_MIC_NO_PRESENCE),
13082 	SND_PCI_QUIRK(0x1028, 0x0696, "Dell", ALC668_FIXUP_DELL_MIC_NO_PRESENCE),
13083 	SND_PCI_QUIRK(0x1028, 0x0698, "Dell", ALC668_FIXUP_DELL_MIC_NO_PRESENCE),
13084 	SND_PCI_QUIRK(0x1028, 0x069f, "Dell", ALC668_FIXUP_DELL_MIC_NO_PRESENCE),
13085 	SND_PCI_QUIRK(0x103c, 0x1632, "HP RP5800", ALC662_FIXUP_HP_RP5800),
13086 	SND_PCI_QUIRK(0x103c, 0x870c, "HP", ALC897_FIXUP_HP_HSMIC_VERB),
13087 	SND_PCI_QUIRK(0x103c, 0x8719, "HP", ALC897_FIXUP_HP_HSMIC_VERB),
13088 	SND_PCI_QUIRK(0x103c, 0x872b, "HP", ALC897_FIXUP_HP_HSMIC_VERB),
13089 	SND_PCI_QUIRK(0x103c, 0x873e, "HP", ALC671_FIXUP_HP_HEADSET_MIC2),
13090 	SND_PCI_QUIRK(0x103c, 0x8768, "HP Slim Desktop S01", ALC671_FIXUP_HP_HEADSET_MIC2),
13091 	SND_PCI_QUIRK(0x103c, 0x877e, "HP 288 Pro G6", ALC671_FIXUP_HP_HEADSET_MIC2),
13092 	SND_PCI_QUIRK(0x103c, 0x885f, "HP 288 Pro G8", ALC671_FIXUP_HP_HEADSET_MIC2),
13093 	SND_PCI_QUIRK(0x1043, 0x1080, "Asus UX501VW", ALC668_FIXUP_HEADSET_MODE),
13094 	SND_PCI_QUIRK(0x1043, 0x11cd, "Asus N550", ALC662_FIXUP_ASUS_Nx50),
13095 	SND_PCI_QUIRK(0x1043, 0x129d, "Asus N750", ALC662_FIXUP_ASUS_Nx50),
13096 	SND_PCI_QUIRK(0x1043, 0x12ff, "ASUS G751", ALC668_FIXUP_ASUS_G751),
13097 	SND_PCI_QUIRK(0x1043, 0x13df, "Asus N550JX", ALC662_FIXUP_BASS_1A),
13098 	SND_PCI_QUIRK(0x1043, 0x1477, "ASUS N56VZ", ALC662_FIXUP_BASS_MODE4_CHMAP),
13099 	SND_PCI_QUIRK(0x1043, 0x15a7, "ASUS UX51VZH", ALC662_FIXUP_BASS_16),
13100 	SND_PCI_QUIRK(0x1043, 0x177d, "ASUS N551", ALC668_FIXUP_ASUS_Nx51),
13101 	SND_PCI_QUIRK(0x1043, 0x17bd, "ASUS N751", ALC668_FIXUP_ASUS_Nx51),
13102 	SND_PCI_QUIRK(0x1043, 0x185d, "ASUS G551JW", ALC668_FIXUP_ASUS_NO_HEADSET_MIC),
13103 	SND_PCI_QUIRK(0x1043, 0x1963, "ASUS X71SL", ALC662_FIXUP_ASUS_MODE8),
13104 	SND_PCI_QUIRK(0x1043, 0x1b73, "ASUS N55SF", ALC662_FIXUP_BASS_16),
13105 	SND_PCI_QUIRK(0x1043, 0x1bf3, "ASUS N76VZ", ALC662_FIXUP_BASS_MODE4_CHMAP),
13106 	SND_PCI_QUIRK(0x1043, 0x8469, "ASUS mobo", ALC662_FIXUP_NO_JACK_DETECT),
13107 	SND_PCI_QUIRK(0x105b, 0x0cd6, "Foxconn", ALC662_FIXUP_ASUS_MODE2),
13108 	SND_PCI_QUIRK(0x144d, 0xc051, "Samsung R720", ALC662_FIXUP_IDEAPAD),
13109 	SND_PCI_QUIRK(0x14cd, 0x5003, "USI", ALC662_FIXUP_USI_HEADSET_MODE),
13110 	SND_PCI_QUIRK(0x17aa, 0x1036, "Lenovo P520", ALC662_FIXUP_LENOVO_MULTI_CODECS),
13111 	SND_PCI_QUIRK(0x17aa, 0x1057, "Lenovo P360", ALC897_FIXUP_HEADSET_MIC_PIN),
13112 	SND_PCI_QUIRK(0x17aa, 0x1064, "Lenovo P3 Tower", ALC897_FIXUP_HEADSET_MIC_PIN),
13113 	SND_PCI_QUIRK(0x17aa, 0x32ca, "Lenovo ThinkCentre M80", ALC897_FIXUP_HEADSET_MIC_PIN),
13114 	SND_PCI_QUIRK(0x17aa, 0x32cb, "Lenovo ThinkCentre M70", ALC897_FIXUP_HEADSET_MIC_PIN),
13115 	SND_PCI_QUIRK(0x17aa, 0x32cf, "Lenovo ThinkCentre M950", ALC897_FIXUP_HEADSET_MIC_PIN),
13116 	SND_PCI_QUIRK(0x17aa, 0x32f7, "Lenovo ThinkCentre M90", ALC897_FIXUP_HEADSET_MIC_PIN),
13117 	SND_PCI_QUIRK(0x17aa, 0x3321, "Lenovo ThinkCentre M70 Gen4", ALC897_FIXUP_HEADSET_MIC_PIN),
13118 	SND_PCI_QUIRK(0x17aa, 0x331b, "Lenovo ThinkCentre M90 Gen4", ALC897_FIXUP_HEADSET_MIC_PIN),
13119 	SND_PCI_QUIRK(0x17aa, 0x3364, "Lenovo ThinkCentre M90 Gen5", ALC897_FIXUP_HEADSET_MIC_PIN),
13120 	SND_PCI_QUIRK(0x17aa, 0x3742, "Lenovo TianYi510Pro-14IOB", ALC897_FIXUP_HEADSET_MIC_PIN2),
13121 	SND_PCI_QUIRK(0x17aa, 0x38af, "Lenovo Ideapad Y550P", ALC662_FIXUP_IDEAPAD),
13122 	SND_PCI_QUIRK(0x17aa, 0x3a0d, "Lenovo Ideapad Y550", ALC662_FIXUP_IDEAPAD),
13123 	SND_PCI_QUIRK(0x1849, 0x5892, "ASRock B150M", ALC892_FIXUP_ASROCK_MOBO),
13124 	SND_PCI_QUIRK(0x19da, 0xa130, "Zotac Z68", ALC662_FIXUP_ZOTAC_Z68),
13125 	SND_PCI_QUIRK(0x1b0a, 0x01b8, "ACER Veriton", ALC662_FIXUP_ACER_VERITON),
13126 	SND_PCI_QUIRK(0x1b35, 0x1234, "CZC ET26", ALC662_FIXUP_CZC_ET26),
13127 	SND_PCI_QUIRK(0x1b35, 0x2206, "CZC P10T", ALC662_FIXUP_CZC_P10T),
13128 	SND_PCI_QUIRK(0x1c6c, 0x1239, "Compaq N14JP6-V2", ALC897_FIXUP_HP_HSMIC_VERB),
13129 
13130 #if 0
13131 	/* Below is a quirk table taken from the old code.
13132 	 * Basically the device should work as is without the fixup table.
13133 	 * If BIOS doesn't give a proper info, enable the corresponding
13134 	 * fixup entry.
13135 	 */
13136 	SND_PCI_QUIRK(0x1043, 0x1000, "ASUS N50Vm", ALC662_FIXUP_ASUS_MODE1),
13137 	SND_PCI_QUIRK(0x1043, 0x1092, "ASUS NB", ALC662_FIXUP_ASUS_MODE3),
13138 	SND_PCI_QUIRK(0x1043, 0x1173, "ASUS K73Jn", ALC662_FIXUP_ASUS_MODE1),
13139 	SND_PCI_QUIRK(0x1043, 0x11c3, "ASUS M70V", ALC662_FIXUP_ASUS_MODE3),
13140 	SND_PCI_QUIRK(0x1043, 0x11d3, "ASUS NB", ALC662_FIXUP_ASUS_MODE1),
13141 	SND_PCI_QUIRK(0x1043, 0x11f3, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),
13142 	SND_PCI_QUIRK(0x1043, 0x1203, "ASUS NB", ALC662_FIXUP_ASUS_MODE1),
13143 	SND_PCI_QUIRK(0x1043, 0x1303, "ASUS G60J", ALC662_FIXUP_ASUS_MODE1),
13144 	SND_PCI_QUIRK(0x1043, 0x1333, "ASUS G60Jx", ALC662_FIXUP_ASUS_MODE1),
13145 	SND_PCI_QUIRK(0x1043, 0x1339, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),
13146 	SND_PCI_QUIRK(0x1043, 0x13e3, "ASUS N71JA", ALC662_FIXUP_ASUS_MODE7),
13147 	SND_PCI_QUIRK(0x1043, 0x1463, "ASUS N71", ALC662_FIXUP_ASUS_MODE7),
13148 	SND_PCI_QUIRK(0x1043, 0x14d3, "ASUS G72", ALC662_FIXUP_ASUS_MODE8),
13149 	SND_PCI_QUIRK(0x1043, 0x1563, "ASUS N90", ALC662_FIXUP_ASUS_MODE3),
13150 	SND_PCI_QUIRK(0x1043, 0x15d3, "ASUS N50SF F50SF", ALC662_FIXUP_ASUS_MODE1),
13151 	SND_PCI_QUIRK(0x1043, 0x16c3, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),
13152 	SND_PCI_QUIRK(0x1043, 0x16f3, "ASUS K40C K50C", ALC662_FIXUP_ASUS_MODE2),
13153 	SND_PCI_QUIRK(0x1043, 0x1733, "ASUS N81De", ALC662_FIXUP_ASUS_MODE1),
13154 	SND_PCI_QUIRK(0x1043, 0x1753, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),
13155 	SND_PCI_QUIRK(0x1043, 0x1763, "ASUS NB", ALC662_FIXUP_ASUS_MODE6),
13156 	SND_PCI_QUIRK(0x1043, 0x1765, "ASUS NB", ALC662_FIXUP_ASUS_MODE6),
13157 	SND_PCI_QUIRK(0x1043, 0x1783, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),
13158 	SND_PCI_QUIRK(0x1043, 0x1793, "ASUS F50GX", ALC662_FIXUP_ASUS_MODE1),
13159 	SND_PCI_QUIRK(0x1043, 0x17b3, "ASUS F70SL", ALC662_FIXUP_ASUS_MODE3),
13160 	SND_PCI_QUIRK(0x1043, 0x17f3, "ASUS X58LE", ALC662_FIXUP_ASUS_MODE2),
13161 	SND_PCI_QUIRK(0x1043, 0x1813, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),
13162 	SND_PCI_QUIRK(0x1043, 0x1823, "ASUS NB", ALC662_FIXUP_ASUS_MODE5),
13163 	SND_PCI_QUIRK(0x1043, 0x1833, "ASUS NB", ALC662_FIXUP_ASUS_MODE6),
13164 	SND_PCI_QUIRK(0x1043, 0x1843, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),
13165 	SND_PCI_QUIRK(0x1043, 0x1853, "ASUS F50Z", ALC662_FIXUP_ASUS_MODE1),
13166 	SND_PCI_QUIRK(0x1043, 0x1864, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),
13167 	SND_PCI_QUIRK(0x1043, 0x1876, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),
13168 	SND_PCI_QUIRK(0x1043, 0x1893, "ASUS M50Vm", ALC662_FIXUP_ASUS_MODE3),
13169 	SND_PCI_QUIRK(0x1043, 0x1894, "ASUS X55", ALC662_FIXUP_ASUS_MODE3),
13170 	SND_PCI_QUIRK(0x1043, 0x18b3, "ASUS N80Vc", ALC662_FIXUP_ASUS_MODE1),
13171 	SND_PCI_QUIRK(0x1043, 0x18c3, "ASUS VX5", ALC662_FIXUP_ASUS_MODE1),
13172 	SND_PCI_QUIRK(0x1043, 0x18d3, "ASUS N81Te", ALC662_FIXUP_ASUS_MODE1),
13173 	SND_PCI_QUIRK(0x1043, 0x18f3, "ASUS N505Tp", ALC662_FIXUP_ASUS_MODE1),
13174 	SND_PCI_QUIRK(0x1043, 0x1903, "ASUS F5GL", ALC662_FIXUP_ASUS_MODE1),
13175 	SND_PCI_QUIRK(0x1043, 0x1913, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),
13176 	SND_PCI_QUIRK(0x1043, 0x1933, "ASUS F80Q", ALC662_FIXUP_ASUS_MODE2),
13177 	SND_PCI_QUIRK(0x1043, 0x1943, "ASUS Vx3V", ALC662_FIXUP_ASUS_MODE1),
13178 	SND_PCI_QUIRK(0x1043, 0x1953, "ASUS NB", ALC662_FIXUP_ASUS_MODE1),
13179 	SND_PCI_QUIRK(0x1043, 0x1963, "ASUS X71C", ALC662_FIXUP_ASUS_MODE3),
13180 	SND_PCI_QUIRK(0x1043, 0x1983, "ASUS N5051A", ALC662_FIXUP_ASUS_MODE1),
13181 	SND_PCI_QUIRK(0x1043, 0x1993, "ASUS N20", ALC662_FIXUP_ASUS_MODE1),
13182 	SND_PCI_QUIRK(0x1043, 0x19b3, "ASUS F7Z", ALC662_FIXUP_ASUS_MODE1),
13183 	SND_PCI_QUIRK(0x1043, 0x19c3, "ASUS F5Z/F6x", ALC662_FIXUP_ASUS_MODE2),
13184 	SND_PCI_QUIRK(0x1043, 0x19e3, "ASUS NB", ALC662_FIXUP_ASUS_MODE1),
13185 	SND_PCI_QUIRK(0x1043, 0x19f3, "ASUS NB", ALC662_FIXUP_ASUS_MODE4),
13186 #endif
13187 	{}
13188 };
13189 
13190 static const struct hda_model_fixup alc662_fixup_models[] = {
13191 	{.id = ALC662_FIXUP_ASPIRE, .name = "aspire"},
13192 	{.id = ALC662_FIXUP_IDEAPAD, .name = "ideapad"},
13193 	{.id = ALC272_FIXUP_MARIO, .name = "mario"},
13194 	{.id = ALC662_FIXUP_HP_RP5800, .name = "hp-rp5800"},
13195 	{.id = ALC662_FIXUP_ASUS_MODE1, .name = "asus-mode1"},
13196 	{.id = ALC662_FIXUP_ASUS_MODE2, .name = "asus-mode2"},
13197 	{.id = ALC662_FIXUP_ASUS_MODE3, .name = "asus-mode3"},
13198 	{.id = ALC662_FIXUP_ASUS_MODE4, .name = "asus-mode4"},
13199 	{.id = ALC662_FIXUP_ASUS_MODE5, .name = "asus-mode5"},
13200 	{.id = ALC662_FIXUP_ASUS_MODE6, .name = "asus-mode6"},
13201 	{.id = ALC662_FIXUP_ASUS_MODE7, .name = "asus-mode7"},
13202 	{.id = ALC662_FIXUP_ASUS_MODE8, .name = "asus-mode8"},
13203 	{.id = ALC662_FIXUP_ZOTAC_Z68, .name = "zotac-z68"},
13204 	{.id = ALC662_FIXUP_INV_DMIC, .name = "inv-dmic"},
13205 	{.id = ALC662_FIXUP_DELL_MIC_NO_PRESENCE, .name = "alc662-headset-multi"},
13206 	{.id = ALC668_FIXUP_DELL_MIC_NO_PRESENCE, .name = "dell-headset-multi"},
13207 	{.id = ALC662_FIXUP_HEADSET_MODE, .name = "alc662-headset"},
13208 	{.id = ALC668_FIXUP_HEADSET_MODE, .name = "alc668-headset"},
13209 	{.id = ALC662_FIXUP_BASS_16, .name = "bass16"},
13210 	{.id = ALC662_FIXUP_BASS_1A, .name = "bass1a"},
13211 	{.id = ALC668_FIXUP_AUTO_MUTE, .name = "automute"},
13212 	{.id = ALC668_FIXUP_DELL_XPS13, .name = "dell-xps13"},
13213 	{.id = ALC662_FIXUP_ASUS_Nx50, .name = "asus-nx50"},
13214 	{.id = ALC668_FIXUP_ASUS_Nx51, .name = "asus-nx51"},
13215 	{.id = ALC668_FIXUP_ASUS_G751, .name = "asus-g751"},
13216 	{.id = ALC891_FIXUP_HEADSET_MODE, .name = "alc891-headset"},
13217 	{.id = ALC891_FIXUP_DELL_MIC_NO_PRESENCE, .name = "alc891-headset-multi"},
13218 	{.id = ALC662_FIXUP_ACER_VERITON, .name = "acer-veriton"},
13219 	{.id = ALC892_FIXUP_ASROCK_MOBO, .name = "asrock-mobo"},
13220 	{.id = ALC662_FIXUP_USI_HEADSET_MODE, .name = "usi-headset"},
13221 	{.id = ALC662_FIXUP_LENOVO_MULTI_CODECS, .name = "dual-codecs"},
13222 	{.id = ALC669_FIXUP_ACER_ASPIRE_ETHOS, .name = "aspire-ethos"},
13223 	{.id = ALC897_FIXUP_UNIS_H3C_X500S, .name = "unis-h3c-x500s"},
13224 	{}
13225 };
13226 
13227 static const struct snd_hda_pin_quirk alc662_pin_fixup_tbl[] = {
13228 	SND_HDA_PIN_QUIRK(0x10ec0867, 0x1028, "Dell", ALC891_FIXUP_DELL_MIC_NO_PRESENCE,
13229 		{0x17, 0x02211010},
13230 		{0x18, 0x01a19030},
13231 		{0x1a, 0x01813040},
13232 		{0x21, 0x01014020}),
13233 	SND_HDA_PIN_QUIRK(0x10ec0867, 0x1028, "Dell", ALC891_FIXUP_DELL_MIC_NO_PRESENCE,
13234 		{0x16, 0x01813030},
13235 		{0x17, 0x02211010},
13236 		{0x18, 0x01a19040},
13237 		{0x21, 0x01014020}),
13238 	SND_HDA_PIN_QUIRK(0x10ec0662, 0x1028, "Dell", ALC662_FIXUP_DELL_MIC_NO_PRESENCE,
13239 		{0x14, 0x01014010},
13240 		{0x18, 0x01a19020},
13241 		{0x1a, 0x0181302f},
13242 		{0x1b, 0x0221401f}),
13243 	SND_HDA_PIN_QUIRK(0x10ec0668, 0x1028, "Dell", ALC668_FIXUP_AUTO_MUTE,
13244 		{0x12, 0x99a30130},
13245 		{0x14, 0x90170110},
13246 		{0x15, 0x0321101f},
13247 		{0x16, 0x03011020}),
13248 	SND_HDA_PIN_QUIRK(0x10ec0668, 0x1028, "Dell", ALC668_FIXUP_AUTO_MUTE,
13249 		{0x12, 0x99a30140},
13250 		{0x14, 0x90170110},
13251 		{0x15, 0x0321101f},
13252 		{0x16, 0x03011020}),
13253 	SND_HDA_PIN_QUIRK(0x10ec0668, 0x1028, "Dell", ALC668_FIXUP_AUTO_MUTE,
13254 		{0x12, 0x99a30150},
13255 		{0x14, 0x90170110},
13256 		{0x15, 0x0321101f},
13257 		{0x16, 0x03011020}),
13258 	SND_HDA_PIN_QUIRK(0x10ec0668, 0x1028, "Dell", ALC668_FIXUP_AUTO_MUTE,
13259 		{0x14, 0x90170110},
13260 		{0x15, 0x0321101f},
13261 		{0x16, 0x03011020}),
13262 	SND_HDA_PIN_QUIRK(0x10ec0668, 0x1028, "Dell XPS 15", ALC668_FIXUP_AUTO_MUTE,
13263 		{0x12, 0x90a60130},
13264 		{0x14, 0x90170110},
13265 		{0x15, 0x0321101f}),
13266 	SND_HDA_PIN_QUIRK(0x10ec0671, 0x103c, "HP cPC", ALC671_FIXUP_HP_HEADSET_MIC2,
13267 		{0x14, 0x01014010},
13268 		{0x17, 0x90170150},
13269 		{0x19, 0x02a11060},
13270 		{0x1b, 0x01813030},
13271 		{0x21, 0x02211020}),
13272 	SND_HDA_PIN_QUIRK(0x10ec0671, 0x103c, "HP cPC", ALC671_FIXUP_HP_HEADSET_MIC2,
13273 		{0x14, 0x01014010},
13274 		{0x18, 0x01a19040},
13275 		{0x1b, 0x01813030},
13276 		{0x21, 0x02211020}),
13277 	SND_HDA_PIN_QUIRK(0x10ec0671, 0x103c, "HP cPC", ALC671_FIXUP_HP_HEADSET_MIC2,
13278 		{0x14, 0x01014020},
13279 		{0x17, 0x90170110},
13280 		{0x18, 0x01a19050},
13281 		{0x1b, 0x01813040},
13282 		{0x21, 0x02211030}),
13283 	{}
13284 };
13285 
13286 /*
13287  */
patch_alc662(struct hda_codec * codec)13288 static int patch_alc662(struct hda_codec *codec)
13289 {
13290 	struct alc_spec *spec;
13291 	int err;
13292 
13293 	err = alc_alloc_spec(codec, 0x0b);
13294 	if (err < 0)
13295 		return err;
13296 
13297 	spec = codec->spec;
13298 
13299 	spec->shutup = alc_eapd_shutup;
13300 
13301 	/* handle multiple HPs as is */
13302 	spec->parse_flags = HDA_PINCFG_NO_HP_FIXUP;
13303 
13304 	alc_fix_pll_init(codec, 0x20, 0x04, 15);
13305 
13306 	switch (codec->core.vendor_id) {
13307 	case 0x10ec0668:
13308 		spec->init_hook = alc668_restore_default_value;
13309 		break;
13310 	}
13311 
13312 	alc_pre_init(codec);
13313 
13314 	snd_hda_pick_fixup(codec, alc662_fixup_models,
13315 		       alc662_fixup_tbl, alc662_fixups);
13316 	snd_hda_pick_pin_fixup(codec, alc662_pin_fixup_tbl, alc662_fixups, true);
13317 	snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE);
13318 
13319 	alc_auto_parse_customize_define(codec);
13320 
13321 	if (has_cdefine_beep(codec))
13322 		spec->gen.beep_nid = 0x01;
13323 
13324 	if ((alc_get_coef0(codec) & (1 << 14)) &&
13325 	    codec->bus->pci && codec->bus->pci->subsystem_vendor == 0x1025 &&
13326 	    spec->cdefine.platform_type == 1) {
13327 		err = alc_codec_rename(codec, "ALC272X");
13328 		if (err < 0)
13329 			goto error;
13330 	}
13331 
13332 	/* automatic parse from the BIOS config */
13333 	err = alc662_parse_auto_config(codec);
13334 	if (err < 0)
13335 		goto error;
13336 
13337 	if (!spec->gen.no_analog && spec->gen.beep_nid) {
13338 		switch (codec->core.vendor_id) {
13339 		case 0x10ec0662:
13340 			err = set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
13341 			break;
13342 		case 0x10ec0272:
13343 		case 0x10ec0663:
13344 		case 0x10ec0665:
13345 		case 0x10ec0668:
13346 			err = set_beep_amp(spec, 0x0b, 0x04, HDA_INPUT);
13347 			break;
13348 		case 0x10ec0273:
13349 			err = set_beep_amp(spec, 0x0b, 0x03, HDA_INPUT);
13350 			break;
13351 		}
13352 		if (err < 0)
13353 			goto error;
13354 	}
13355 
13356 	snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE);
13357 
13358 	return 0;
13359 
13360  error:
13361 	alc_free(codec);
13362 	return err;
13363 }
13364 
13365 /*
13366  * ALC680 support
13367  */
13368 
alc680_parse_auto_config(struct hda_codec * codec)13369 static int alc680_parse_auto_config(struct hda_codec *codec)
13370 {
13371 	return alc_parse_auto_config(codec, NULL, NULL);
13372 }
13373 
13374 /*
13375  */
patch_alc680(struct hda_codec * codec)13376 static int patch_alc680(struct hda_codec *codec)
13377 {
13378 	int err;
13379 
13380 	/* ALC680 has no aa-loopback mixer */
13381 	err = alc_alloc_spec(codec, 0);
13382 	if (err < 0)
13383 		return err;
13384 
13385 	/* automatic parse from the BIOS config */
13386 	err = alc680_parse_auto_config(codec);
13387 	if (err < 0) {
13388 		alc_free(codec);
13389 		return err;
13390 	}
13391 
13392 	return 0;
13393 }
13394 
13395 /*
13396  * patch entries
13397  */
13398 static const struct hda_device_id snd_hda_id_realtek[] = {
13399 	HDA_CODEC_ENTRY(0x10ec0215, "ALC215", patch_alc269),
13400 	HDA_CODEC_ENTRY(0x10ec0221, "ALC221", patch_alc269),
13401 	HDA_CODEC_ENTRY(0x10ec0222, "ALC222", patch_alc269),
13402 	HDA_CODEC_ENTRY(0x10ec0225, "ALC225", patch_alc269),
13403 	HDA_CODEC_ENTRY(0x10ec0230, "ALC236", patch_alc269),
13404 	HDA_CODEC_ENTRY(0x10ec0231, "ALC231", patch_alc269),
13405 	HDA_CODEC_ENTRY(0x10ec0233, "ALC233", patch_alc269),
13406 	HDA_CODEC_ENTRY(0x10ec0234, "ALC234", patch_alc269),
13407 	HDA_CODEC_ENTRY(0x10ec0235, "ALC233", patch_alc269),
13408 	HDA_CODEC_ENTRY(0x10ec0236, "ALC236", patch_alc269),
13409 	HDA_CODEC_ENTRY(0x10ec0245, "ALC245", patch_alc269),
13410 	HDA_CODEC_ENTRY(0x10ec0255, "ALC255", patch_alc269),
13411 	HDA_CODEC_ENTRY(0x10ec0256, "ALC256", patch_alc269),
13412 	HDA_CODEC_ENTRY(0x10ec0257, "ALC257", patch_alc269),
13413 	HDA_CODEC_ENTRY(0x10ec0260, "ALC260", patch_alc260),
13414 	HDA_CODEC_ENTRY(0x10ec0262, "ALC262", patch_alc262),
13415 	HDA_CODEC_ENTRY(0x10ec0267, "ALC267", patch_alc268),
13416 	HDA_CODEC_ENTRY(0x10ec0268, "ALC268", patch_alc268),
13417 	HDA_CODEC_ENTRY(0x10ec0269, "ALC269", patch_alc269),
13418 	HDA_CODEC_ENTRY(0x10ec0270, "ALC270", patch_alc269),
13419 	HDA_CODEC_ENTRY(0x10ec0272, "ALC272", patch_alc662),
13420 	HDA_CODEC_ENTRY(0x10ec0274, "ALC274", patch_alc269),
13421 	HDA_CODEC_ENTRY(0x10ec0275, "ALC275", patch_alc269),
13422 	HDA_CODEC_ENTRY(0x10ec0276, "ALC276", patch_alc269),
13423 	HDA_CODEC_ENTRY(0x10ec0280, "ALC280", patch_alc269),
13424 	HDA_CODEC_ENTRY(0x10ec0282, "ALC282", patch_alc269),
13425 	HDA_CODEC_ENTRY(0x10ec0283, "ALC283", patch_alc269),
13426 	HDA_CODEC_ENTRY(0x10ec0284, "ALC284", patch_alc269),
13427 	HDA_CODEC_ENTRY(0x10ec0285, "ALC285", patch_alc269),
13428 	HDA_CODEC_ENTRY(0x10ec0286, "ALC286", patch_alc269),
13429 	HDA_CODEC_ENTRY(0x10ec0287, "ALC287", patch_alc269),
13430 	HDA_CODEC_ENTRY(0x10ec0288, "ALC288", patch_alc269),
13431 	HDA_CODEC_ENTRY(0x10ec0289, "ALC289", patch_alc269),
13432 	HDA_CODEC_ENTRY(0x10ec0290, "ALC290", patch_alc269),
13433 	HDA_CODEC_ENTRY(0x10ec0292, "ALC292", patch_alc269),
13434 	HDA_CODEC_ENTRY(0x10ec0293, "ALC293", patch_alc269),
13435 	HDA_CODEC_ENTRY(0x10ec0294, "ALC294", patch_alc269),
13436 	HDA_CODEC_ENTRY(0x10ec0295, "ALC295", patch_alc269),
13437 	HDA_CODEC_ENTRY(0x10ec0298, "ALC298", patch_alc269),
13438 	HDA_CODEC_ENTRY(0x10ec0299, "ALC299", patch_alc269),
13439 	HDA_CODEC_ENTRY(0x10ec0300, "ALC300", patch_alc269),
13440 	HDA_CODEC_ENTRY(0x10ec0623, "ALC623", patch_alc269),
13441 	HDA_CODEC_REV_ENTRY(0x10ec0861, 0x100340, "ALC660", patch_alc861),
13442 	HDA_CODEC_ENTRY(0x10ec0660, "ALC660-VD", patch_alc861vd),
13443 	HDA_CODEC_ENTRY(0x10ec0861, "ALC861", patch_alc861),
13444 	HDA_CODEC_ENTRY(0x10ec0862, "ALC861-VD", patch_alc861vd),
13445 	HDA_CODEC_REV_ENTRY(0x10ec0662, 0x100002, "ALC662 rev2", patch_alc882),
13446 	HDA_CODEC_REV_ENTRY(0x10ec0662, 0x100101, "ALC662 rev1", patch_alc662),
13447 	HDA_CODEC_REV_ENTRY(0x10ec0662, 0x100300, "ALC662 rev3", patch_alc662),
13448 	HDA_CODEC_ENTRY(0x10ec0663, "ALC663", patch_alc662),
13449 	HDA_CODEC_ENTRY(0x10ec0665, "ALC665", patch_alc662),
13450 	HDA_CODEC_ENTRY(0x10ec0667, "ALC667", patch_alc662),
13451 	HDA_CODEC_ENTRY(0x10ec0668, "ALC668", patch_alc662),
13452 	HDA_CODEC_ENTRY(0x10ec0670, "ALC670", patch_alc662),
13453 	HDA_CODEC_ENTRY(0x10ec0671, "ALC671", patch_alc662),
13454 	HDA_CODEC_ENTRY(0x10ec0680, "ALC680", patch_alc680),
13455 	HDA_CODEC_ENTRY(0x10ec0700, "ALC700", patch_alc269),
13456 	HDA_CODEC_ENTRY(0x10ec0701, "ALC701", patch_alc269),
13457 	HDA_CODEC_ENTRY(0x10ec0703, "ALC703", patch_alc269),
13458 	HDA_CODEC_ENTRY(0x10ec0711, "ALC711", patch_alc269),
13459 	HDA_CODEC_ENTRY(0x10ec0867, "ALC891", patch_alc662),
13460 	HDA_CODEC_ENTRY(0x10ec0880, "ALC880", patch_alc880),
13461 	HDA_CODEC_ENTRY(0x10ec0882, "ALC882", patch_alc882),
13462 	HDA_CODEC_ENTRY(0x10ec0883, "ALC883", patch_alc882),
13463 	HDA_CODEC_REV_ENTRY(0x10ec0885, 0x100101, "ALC889A", patch_alc882),
13464 	HDA_CODEC_REV_ENTRY(0x10ec0885, 0x100103, "ALC889A", patch_alc882),
13465 	HDA_CODEC_ENTRY(0x10ec0885, "ALC885", patch_alc882),
13466 	HDA_CODEC_ENTRY(0x10ec0887, "ALC887", patch_alc882),
13467 	HDA_CODEC_REV_ENTRY(0x10ec0888, 0x100101, "ALC1200", patch_alc882),
13468 	HDA_CODEC_ENTRY(0x10ec0888, "ALC888", patch_alc882),
13469 	HDA_CODEC_ENTRY(0x10ec0889, "ALC889", patch_alc882),
13470 	HDA_CODEC_ENTRY(0x10ec0892, "ALC892", patch_alc662),
13471 	HDA_CODEC_ENTRY(0x10ec0897, "ALC897", patch_alc662),
13472 	HDA_CODEC_ENTRY(0x10ec0899, "ALC898", patch_alc882),
13473 	HDA_CODEC_ENTRY(0x10ec0900, "ALC1150", patch_alc882),
13474 	HDA_CODEC_ENTRY(0x10ec0b00, "ALCS1200A", patch_alc882),
13475 	HDA_CODEC_ENTRY(0x10ec1168, "ALC1220", patch_alc882),
13476 	HDA_CODEC_ENTRY(0x10ec1220, "ALC1220", patch_alc882),
13477 	HDA_CODEC_ENTRY(0x19e58326, "HW8326", patch_alc269),
13478 	{} /* terminator */
13479 };
13480 MODULE_DEVICE_TABLE(hdaudio, snd_hda_id_realtek);
13481 
13482 MODULE_LICENSE("GPL");
13483 MODULE_DESCRIPTION("Realtek HD-audio codec");
13484 MODULE_IMPORT_NS("SND_HDA_SCODEC_COMPONENT");
13485 
13486 static struct hda_codec_driver realtek_driver = {
13487 	.id = snd_hda_id_realtek,
13488 };
13489 
13490 module_hda_codec_driver(realtek_driver);
13491