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/init.h>
14 #include <linux/delay.h>
15 #include <linux/slab.h>
16 #include <linux/pci.h>
17 #include <linux/dmi.h>
18 #include <linux/module.h>
19 #include <linux/input.h>
20 #include <linux/leds.h>
21 #include <linux/ctype.h>
22 #include <sound/core.h>
23 #include <sound/jack.h>
24 #include <sound/hda_codec.h>
25 #include "hda_local.h"
26 #include "hda_auto_parser.h"
27 #include "hda_jack.h"
28 #include "hda_generic.h"
29 #include "hda_component.h"
30 
31 /* keep halting ALC5505 DSP, for power saving */
32 #define HALT_REALTEK_ALC5505
33 
34 /* extra amp-initialization sequence types */
35 enum {
36 	ALC_INIT_UNDEFINED,
37 	ALC_INIT_NONE,
38 	ALC_INIT_DEFAULT,
39 };
40 
41 enum {
42 	ALC_HEADSET_MODE_UNKNOWN,
43 	ALC_HEADSET_MODE_UNPLUGGED,
44 	ALC_HEADSET_MODE_HEADSET,
45 	ALC_HEADSET_MODE_MIC,
46 	ALC_HEADSET_MODE_HEADPHONE,
47 };
48 
49 enum {
50 	ALC_HEADSET_TYPE_UNKNOWN,
51 	ALC_HEADSET_TYPE_CTIA,
52 	ALC_HEADSET_TYPE_OMTP,
53 };
54 
55 enum {
56 	ALC_KEY_MICMUTE_INDEX,
57 };
58 
59 struct alc_customize_define {
60 	unsigned int  sku_cfg;
61 	unsigned char port_connectivity;
62 	unsigned char check_sum;
63 	unsigned char customization;
64 	unsigned char external_amp;
65 	unsigned int  enable_pcbeep:1;
66 	unsigned int  platform_type:1;
67 	unsigned int  swap:1;
68 	unsigned int  override:1;
69 	unsigned int  fixup:1; /* Means that this sku is set by driver, not read from hw */
70 };
71 
72 struct alc_coef_led {
73 	unsigned int idx;
74 	unsigned int mask;
75 	unsigned int on;
76 	unsigned int off;
77 };
78 
79 struct alc_spec {
80 	struct hda_gen_spec gen; /* must be at head */
81 
82 	/* codec parameterization */
83 	struct alc_customize_define cdefine;
84 	unsigned int parse_flags; /* flag for snd_hda_parse_pin_defcfg() */
85 
86 	/* GPIO bits */
87 	unsigned int gpio_mask;
88 	unsigned int gpio_dir;
89 	unsigned int gpio_data;
90 	bool gpio_write_delay;	/* add a delay before writing gpio_data */
91 
92 	/* mute LED for HP laptops, see vref_mute_led_set() */
93 	int mute_led_polarity;
94 	int micmute_led_polarity;
95 	hda_nid_t mute_led_nid;
96 	hda_nid_t cap_mute_led_nid;
97 
98 	unsigned int gpio_mute_led_mask;
99 	unsigned int gpio_mic_led_mask;
100 	struct alc_coef_led mute_led_coef;
101 	struct alc_coef_led mic_led_coef;
102 	struct mutex coef_mutex;
103 
104 	hda_nid_t headset_mic_pin;
105 	hda_nid_t headphone_mic_pin;
106 	int current_headset_mode;
107 	int current_headset_type;
108 
109 	/* hooks */
110 	void (*init_hook)(struct hda_codec *codec);
111 #ifdef CONFIG_PM
112 	void (*power_hook)(struct hda_codec *codec);
113 #endif
114 	void (*shutup)(struct hda_codec *codec);
115 
116 	int init_amp;
117 	int codec_variant;	/* flag for other variants */
118 	unsigned int has_alc5505_dsp:1;
119 	unsigned int no_depop_delay:1;
120 	unsigned int done_hp_init:1;
121 	unsigned int no_shutup_pins:1;
122 	unsigned int ultra_low_power:1;
123 	unsigned int has_hs_key:1;
124 	unsigned int no_internal_mic_pin:1;
125 	unsigned int en_3kpull_low:1;
126 
127 	/* for PLL fix */
128 	hda_nid_t pll_nid;
129 	unsigned int pll_coef_idx, pll_coef_bit;
130 	unsigned int coef0;
131 	struct input_dev *kb_dev;
132 	u8 alc_mute_keycode_map[1];
133 
134 	/* component binding */
135 	struct component_match *match;
136 	struct hda_component comps[HDA_MAX_COMPONENTS];
137 };
138 
139 /*
140  * COEF access helper functions
141  */
142 
coef_mutex_lock(struct hda_codec * codec)143 static void coef_mutex_lock(struct hda_codec *codec)
144 {
145 	struct alc_spec *spec = codec->spec;
146 
147 	snd_hda_power_up_pm(codec);
148 	mutex_lock(&spec->coef_mutex);
149 }
150 
coef_mutex_unlock(struct hda_codec * codec)151 static void coef_mutex_unlock(struct hda_codec *codec)
152 {
153 	struct alc_spec *spec = codec->spec;
154 
155 	mutex_unlock(&spec->coef_mutex);
156 	snd_hda_power_down_pm(codec);
157 }
158 
__alc_read_coefex_idx(struct hda_codec * codec,hda_nid_t nid,unsigned int coef_idx)159 static int __alc_read_coefex_idx(struct hda_codec *codec, hda_nid_t nid,
160 				 unsigned int coef_idx)
161 {
162 	unsigned int val;
163 
164 	snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_COEF_INDEX, coef_idx);
165 	val = snd_hda_codec_read(codec, nid, 0, AC_VERB_GET_PROC_COEF, 0);
166 	return val;
167 }
168 
alc_read_coefex_idx(struct hda_codec * codec,hda_nid_t nid,unsigned int coef_idx)169 static int alc_read_coefex_idx(struct hda_codec *codec, hda_nid_t nid,
170 			       unsigned int coef_idx)
171 {
172 	unsigned int val;
173 
174 	coef_mutex_lock(codec);
175 	val = __alc_read_coefex_idx(codec, nid, coef_idx);
176 	coef_mutex_unlock(codec);
177 	return val;
178 }
179 
180 #define alc_read_coef_idx(codec, coef_idx) \
181 	alc_read_coefex_idx(codec, 0x20, coef_idx)
182 
__alc_write_coefex_idx(struct hda_codec * codec,hda_nid_t nid,unsigned int coef_idx,unsigned int coef_val)183 static void __alc_write_coefex_idx(struct hda_codec *codec, hda_nid_t nid,
184 				   unsigned int coef_idx, unsigned int coef_val)
185 {
186 	snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_COEF_INDEX, coef_idx);
187 	snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_PROC_COEF, coef_val);
188 }
189 
alc_write_coefex_idx(struct hda_codec * codec,hda_nid_t nid,unsigned int coef_idx,unsigned int coef_val)190 static void alc_write_coefex_idx(struct hda_codec *codec, hda_nid_t nid,
191 				 unsigned int coef_idx, unsigned int coef_val)
192 {
193 	coef_mutex_lock(codec);
194 	__alc_write_coefex_idx(codec, nid, coef_idx, coef_val);
195 	coef_mutex_unlock(codec);
196 }
197 
198 #define alc_write_coef_idx(codec, coef_idx, coef_val) \
199 	alc_write_coefex_idx(codec, 0x20, coef_idx, coef_val)
200 
__alc_update_coefex_idx(struct hda_codec * codec,hda_nid_t nid,unsigned int coef_idx,unsigned int mask,unsigned int bits_set)201 static void __alc_update_coefex_idx(struct hda_codec *codec, hda_nid_t nid,
202 				    unsigned int coef_idx, unsigned int mask,
203 				    unsigned int bits_set)
204 {
205 	unsigned int val = __alc_read_coefex_idx(codec, nid, coef_idx);
206 
207 	if (val != -1)
208 		__alc_write_coefex_idx(codec, nid, coef_idx,
209 				       (val & ~mask) | bits_set);
210 }
211 
alc_update_coefex_idx(struct hda_codec * codec,hda_nid_t nid,unsigned int coef_idx,unsigned int mask,unsigned int bits_set)212 static void alc_update_coefex_idx(struct hda_codec *codec, hda_nid_t nid,
213 				  unsigned int coef_idx, unsigned int mask,
214 				  unsigned int bits_set)
215 {
216 	coef_mutex_lock(codec);
217 	__alc_update_coefex_idx(codec, nid, coef_idx, mask, bits_set);
218 	coef_mutex_unlock(codec);
219 }
220 
221 #define alc_update_coef_idx(codec, coef_idx, mask, bits_set)	\
222 	alc_update_coefex_idx(codec, 0x20, coef_idx, mask, bits_set)
223 
224 /* a special bypass for COEF 0; read the cached value at the second time */
alc_get_coef0(struct hda_codec * codec)225 static unsigned int alc_get_coef0(struct hda_codec *codec)
226 {
227 	struct alc_spec *spec = codec->spec;
228 
229 	if (!spec->coef0)
230 		spec->coef0 = alc_read_coef_idx(codec, 0);
231 	return spec->coef0;
232 }
233 
234 /* coef writes/updates batch */
235 struct coef_fw {
236 	unsigned char nid;
237 	unsigned char idx;
238 	unsigned short mask;
239 	unsigned short val;
240 };
241 
242 #define UPDATE_COEFEX(_nid, _idx, _mask, _val) \
243 	{ .nid = (_nid), .idx = (_idx), .mask = (_mask), .val = (_val) }
244 #define WRITE_COEFEX(_nid, _idx, _val) UPDATE_COEFEX(_nid, _idx, -1, _val)
245 #define WRITE_COEF(_idx, _val) WRITE_COEFEX(0x20, _idx, _val)
246 #define UPDATE_COEF(_idx, _mask, _val) UPDATE_COEFEX(0x20, _idx, _mask, _val)
247 
alc_process_coef_fw(struct hda_codec * codec,const struct coef_fw * fw)248 static void alc_process_coef_fw(struct hda_codec *codec,
249 				const struct coef_fw *fw)
250 {
251 	coef_mutex_lock(codec);
252 	for (; fw->nid; fw++) {
253 		if (fw->mask == (unsigned short)-1)
254 			__alc_write_coefex_idx(codec, fw->nid, fw->idx, fw->val);
255 		else
256 			__alc_update_coefex_idx(codec, fw->nid, fw->idx,
257 						fw->mask, fw->val);
258 	}
259 	coef_mutex_unlock(codec);
260 }
261 
262 /*
263  * GPIO setup tables, used in initialization
264  */
265 
266 /* Enable GPIO mask and set output */
alc_setup_gpio(struct hda_codec * codec,unsigned int mask)267 static void alc_setup_gpio(struct hda_codec *codec, unsigned int mask)
268 {
269 	struct alc_spec *spec = codec->spec;
270 
271 	spec->gpio_mask |= mask;
272 	spec->gpio_dir |= mask;
273 	spec->gpio_data |= mask;
274 }
275 
alc_write_gpio_data(struct hda_codec * codec)276 static void alc_write_gpio_data(struct hda_codec *codec)
277 {
278 	struct alc_spec *spec = codec->spec;
279 
280 	snd_hda_codec_write(codec, 0x01, 0, AC_VERB_SET_GPIO_DATA,
281 			    spec->gpio_data);
282 }
283 
alc_update_gpio_data(struct hda_codec * codec,unsigned int mask,bool on)284 static void alc_update_gpio_data(struct hda_codec *codec, unsigned int mask,
285 				 bool on)
286 {
287 	struct alc_spec *spec = codec->spec;
288 	unsigned int oldval = spec->gpio_data;
289 
290 	if (on)
291 		spec->gpio_data |= mask;
292 	else
293 		spec->gpio_data &= ~mask;
294 	if (oldval != spec->gpio_data)
295 		alc_write_gpio_data(codec);
296 }
297 
alc_write_gpio(struct hda_codec * codec)298 static void alc_write_gpio(struct hda_codec *codec)
299 {
300 	struct alc_spec *spec = codec->spec;
301 
302 	if (!spec->gpio_mask)
303 		return;
304 
305 	snd_hda_codec_write(codec, codec->core.afg, 0,
306 			    AC_VERB_SET_GPIO_MASK, spec->gpio_mask);
307 	snd_hda_codec_write(codec, codec->core.afg, 0,
308 			    AC_VERB_SET_GPIO_DIRECTION, spec->gpio_dir);
309 	if (spec->gpio_write_delay)
310 		msleep(1);
311 	alc_write_gpio_data(codec);
312 }
313 
alc_fixup_gpio(struct hda_codec * codec,int action,unsigned int mask)314 static void alc_fixup_gpio(struct hda_codec *codec, int action,
315 			   unsigned int mask)
316 {
317 	if (action == HDA_FIXUP_ACT_PRE_PROBE)
318 		alc_setup_gpio(codec, mask);
319 }
320 
alc_fixup_gpio1(struct hda_codec * codec,const struct hda_fixup * fix,int action)321 static void alc_fixup_gpio1(struct hda_codec *codec,
322 			    const struct hda_fixup *fix, int action)
323 {
324 	alc_fixup_gpio(codec, action, 0x01);
325 }
326 
alc_fixup_gpio2(struct hda_codec * codec,const struct hda_fixup * fix,int action)327 static void alc_fixup_gpio2(struct hda_codec *codec,
328 			    const struct hda_fixup *fix, int action)
329 {
330 	alc_fixup_gpio(codec, action, 0x02);
331 }
332 
alc_fixup_gpio3(struct hda_codec * codec,const struct hda_fixup * fix,int action)333 static void alc_fixup_gpio3(struct hda_codec *codec,
334 			    const struct hda_fixup *fix, int action)
335 {
336 	alc_fixup_gpio(codec, action, 0x03);
337 }
338 
alc_fixup_gpio4(struct hda_codec * codec,const struct hda_fixup * fix,int action)339 static void alc_fixup_gpio4(struct hda_codec *codec,
340 			    const struct hda_fixup *fix, int action)
341 {
342 	alc_fixup_gpio(codec, action, 0x04);
343 }
344 
alc_fixup_micmute_led(struct hda_codec * codec,const struct hda_fixup * fix,int action)345 static void alc_fixup_micmute_led(struct hda_codec *codec,
346 				  const struct hda_fixup *fix, int action)
347 {
348 	if (action == HDA_FIXUP_ACT_PRE_PROBE)
349 		snd_hda_gen_add_micmute_led_cdev(codec, NULL);
350 }
351 
352 /*
353  * Fix hardware PLL issue
354  * On some codecs, the analog PLL gating control must be off while
355  * the default value is 1.
356  */
alc_fix_pll(struct hda_codec * codec)357 static void alc_fix_pll(struct hda_codec *codec)
358 {
359 	struct alc_spec *spec = codec->spec;
360 
361 	if (spec->pll_nid)
362 		alc_update_coefex_idx(codec, spec->pll_nid, spec->pll_coef_idx,
363 				      1 << spec->pll_coef_bit, 0);
364 }
365 
alc_fix_pll_init(struct hda_codec * codec,hda_nid_t nid,unsigned int coef_idx,unsigned int coef_bit)366 static void alc_fix_pll_init(struct hda_codec *codec, hda_nid_t nid,
367 			     unsigned int coef_idx, unsigned int coef_bit)
368 {
369 	struct alc_spec *spec = codec->spec;
370 	spec->pll_nid = nid;
371 	spec->pll_coef_idx = coef_idx;
372 	spec->pll_coef_bit = coef_bit;
373 	alc_fix_pll(codec);
374 }
375 
376 /* update the master volume per volume-knob's unsol event */
alc_update_knob_master(struct hda_codec * codec,struct hda_jack_callback * jack)377 static void alc_update_knob_master(struct hda_codec *codec,
378 				   struct hda_jack_callback *jack)
379 {
380 	unsigned int val;
381 	struct snd_kcontrol *kctl;
382 	struct snd_ctl_elem_value *uctl;
383 
384 	kctl = snd_hda_find_mixer_ctl(codec, "Master Playback Volume");
385 	if (!kctl)
386 		return;
387 	uctl = kzalloc(sizeof(*uctl), GFP_KERNEL);
388 	if (!uctl)
389 		return;
390 	val = snd_hda_codec_read(codec, jack->nid, 0,
391 				 AC_VERB_GET_VOLUME_KNOB_CONTROL, 0);
392 	val &= HDA_AMP_VOLMASK;
393 	uctl->value.integer.value[0] = val;
394 	uctl->value.integer.value[1] = val;
395 	kctl->put(kctl, uctl);
396 	kfree(uctl);
397 }
398 
alc880_unsol_event(struct hda_codec * codec,unsigned int res)399 static void alc880_unsol_event(struct hda_codec *codec, unsigned int res)
400 {
401 	/* For some reason, the res given from ALC880 is broken.
402 	   Here we adjust it properly. */
403 	snd_hda_jack_unsol_event(codec, res >> 2);
404 }
405 
406 /* Change EAPD to verb control */
alc_fill_eapd_coef(struct hda_codec * codec)407 static void alc_fill_eapd_coef(struct hda_codec *codec)
408 {
409 	int coef;
410 
411 	coef = alc_get_coef0(codec);
412 
413 	switch (codec->core.vendor_id) {
414 	case 0x10ec0262:
415 		alc_update_coef_idx(codec, 0x7, 0, 1<<5);
416 		break;
417 	case 0x10ec0267:
418 	case 0x10ec0268:
419 		alc_update_coef_idx(codec, 0x7, 0, 1<<13);
420 		break;
421 	case 0x10ec0269:
422 		if ((coef & 0x00f0) == 0x0010)
423 			alc_update_coef_idx(codec, 0xd, 0, 1<<14);
424 		if ((coef & 0x00f0) == 0x0020)
425 			alc_update_coef_idx(codec, 0x4, 1<<15, 0);
426 		if ((coef & 0x00f0) == 0x0030)
427 			alc_update_coef_idx(codec, 0x10, 1<<9, 0);
428 		break;
429 	case 0x10ec0280:
430 	case 0x10ec0284:
431 	case 0x10ec0290:
432 	case 0x10ec0292:
433 		alc_update_coef_idx(codec, 0x4, 1<<15, 0);
434 		break;
435 	case 0x10ec0225:
436 	case 0x10ec0295:
437 	case 0x10ec0299:
438 		alc_update_coef_idx(codec, 0x67, 0xf000, 0x3000);
439 		fallthrough;
440 	case 0x10ec0215:
441 	case 0x10ec0230:
442 	case 0x10ec0233:
443 	case 0x10ec0235:
444 	case 0x10ec0236:
445 	case 0x10ec0245:
446 	case 0x10ec0255:
447 	case 0x10ec0256:
448 	case 0x19e58326:
449 	case 0x10ec0257:
450 	case 0x10ec0282:
451 	case 0x10ec0283:
452 	case 0x10ec0286:
453 	case 0x10ec0288:
454 	case 0x10ec0285:
455 	case 0x10ec0298:
456 	case 0x10ec0289:
457 	case 0x10ec0300:
458 		alc_update_coef_idx(codec, 0x10, 1<<9, 0);
459 		break;
460 	case 0x10ec0275:
461 		alc_update_coef_idx(codec, 0xe, 0, 1<<0);
462 		break;
463 	case 0x10ec0287:
464 		alc_update_coef_idx(codec, 0x10, 1<<9, 0);
465 		alc_write_coef_idx(codec, 0x8, 0x4ab7);
466 		break;
467 	case 0x10ec0293:
468 		alc_update_coef_idx(codec, 0xa, 1<<13, 0);
469 		break;
470 	case 0x10ec0234:
471 	case 0x10ec0274:
472 	case 0x10ec0294:
473 	case 0x10ec0700:
474 	case 0x10ec0701:
475 	case 0x10ec0703:
476 	case 0x10ec0711:
477 		alc_update_coef_idx(codec, 0x10, 1<<15, 0);
478 		break;
479 	case 0x10ec0662:
480 		if ((coef & 0x00f0) == 0x0030)
481 			alc_update_coef_idx(codec, 0x4, 1<<10, 0); /* EAPD Ctrl */
482 		break;
483 	case 0x10ec0272:
484 	case 0x10ec0273:
485 	case 0x10ec0663:
486 	case 0x10ec0665:
487 	case 0x10ec0670:
488 	case 0x10ec0671:
489 	case 0x10ec0672:
490 		alc_update_coef_idx(codec, 0xd, 0, 1<<14); /* EAPD Ctrl */
491 		break;
492 	case 0x10ec0222:
493 	case 0x10ec0623:
494 		alc_update_coef_idx(codec, 0x19, 1<<13, 0);
495 		break;
496 	case 0x10ec0668:
497 		alc_update_coef_idx(codec, 0x7, 3<<13, 0);
498 		break;
499 	case 0x10ec0867:
500 		alc_update_coef_idx(codec, 0x4, 1<<10, 0);
501 		break;
502 	case 0x10ec0888:
503 		if ((coef & 0x00f0) == 0x0020 || (coef & 0x00f0) == 0x0030)
504 			alc_update_coef_idx(codec, 0x7, 1<<5, 0);
505 		break;
506 	case 0x10ec0892:
507 	case 0x10ec0897:
508 		alc_update_coef_idx(codec, 0x7, 1<<5, 0);
509 		break;
510 	case 0x10ec0899:
511 	case 0x10ec0900:
512 	case 0x10ec0b00:
513 	case 0x10ec1168:
514 	case 0x10ec1220:
515 		alc_update_coef_idx(codec, 0x7, 1<<1, 0);
516 		break;
517 	}
518 }
519 
520 /* additional initialization for ALC888 variants */
alc888_coef_init(struct hda_codec * codec)521 static void alc888_coef_init(struct hda_codec *codec)
522 {
523 	switch (alc_get_coef0(codec) & 0x00f0) {
524 	/* alc888-VA */
525 	case 0x00:
526 	/* alc888-VB */
527 	case 0x10:
528 		alc_update_coef_idx(codec, 7, 0, 0x2030); /* Turn EAPD to High */
529 		break;
530 	}
531 }
532 
533 /* turn on/off EAPD control (only if available) */
set_eapd(struct hda_codec * codec,hda_nid_t nid,int on)534 static void set_eapd(struct hda_codec *codec, hda_nid_t nid, int on)
535 {
536 	if (get_wcaps_type(get_wcaps(codec, nid)) != AC_WID_PIN)
537 		return;
538 	if (snd_hda_query_pin_caps(codec, nid) & AC_PINCAP_EAPD)
539 		snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_EAPD_BTLENABLE,
540 				    on ? 2 : 0);
541 }
542 
543 /* turn on/off EAPD controls of the codec */
alc_auto_setup_eapd(struct hda_codec * codec,bool on)544 static void alc_auto_setup_eapd(struct hda_codec *codec, bool on)
545 {
546 	/* We currently only handle front, HP */
547 	static const hda_nid_t pins[] = {
548 		0x0f, 0x10, 0x14, 0x15, 0x17, 0
549 	};
550 	const hda_nid_t *p;
551 	for (p = pins; *p; p++)
552 		set_eapd(codec, *p, on);
553 }
554 
555 static int find_ext_mic_pin(struct hda_codec *codec);
556 
alc_headset_mic_no_shutup(struct hda_codec * codec)557 static void alc_headset_mic_no_shutup(struct hda_codec *codec)
558 {
559 	const struct hda_pincfg *pin;
560 	int mic_pin = find_ext_mic_pin(codec);
561 	int i;
562 
563 	/* don't shut up pins when unloading the driver; otherwise it breaks
564 	 * the default pin setup at the next load of the driver
565 	 */
566 	if (codec->bus->shutdown)
567 		return;
568 
569 	snd_array_for_each(&codec->init_pins, i, pin) {
570 		/* use read here for syncing after issuing each verb */
571 		if (pin->nid != mic_pin)
572 			snd_hda_codec_read(codec, pin->nid, 0,
573 					AC_VERB_SET_PIN_WIDGET_CONTROL, 0);
574 	}
575 
576 	codec->pins_shutup = 1;
577 }
578 
alc_shutup_pins(struct hda_codec * codec)579 static void alc_shutup_pins(struct hda_codec *codec)
580 {
581 	struct alc_spec *spec = codec->spec;
582 
583 	switch (codec->core.vendor_id) {
584 	case 0x10ec0236:
585 	case 0x10ec0256:
586 	case 0x19e58326:
587 	case 0x10ec0283:
588 	case 0x10ec0286:
589 	case 0x10ec0288:
590 	case 0x10ec0298:
591 		alc_headset_mic_no_shutup(codec);
592 		break;
593 	default:
594 		if (!spec->no_shutup_pins)
595 			snd_hda_shutup_pins(codec);
596 		break;
597 	}
598 }
599 
600 /* generic shutup callback;
601  * just turning off EAPD and a little pause for avoiding pop-noise
602  */
alc_eapd_shutup(struct hda_codec * codec)603 static void alc_eapd_shutup(struct hda_codec *codec)
604 {
605 	struct alc_spec *spec = codec->spec;
606 
607 	alc_auto_setup_eapd(codec, false);
608 	if (!spec->no_depop_delay)
609 		msleep(200);
610 	alc_shutup_pins(codec);
611 }
612 
613 /* generic EAPD initialization */
alc_auto_init_amp(struct hda_codec * codec,int type)614 static void alc_auto_init_amp(struct hda_codec *codec, int type)
615 {
616 	alc_auto_setup_eapd(codec, true);
617 	alc_write_gpio(codec);
618 	switch (type) {
619 	case ALC_INIT_DEFAULT:
620 		switch (codec->core.vendor_id) {
621 		case 0x10ec0260:
622 			alc_update_coefex_idx(codec, 0x1a, 7, 0, 0x2010);
623 			break;
624 		case 0x10ec0880:
625 		case 0x10ec0882:
626 		case 0x10ec0883:
627 		case 0x10ec0885:
628 			alc_update_coef_idx(codec, 7, 0, 0x2030);
629 			break;
630 		case 0x10ec0888:
631 			alc888_coef_init(codec);
632 			break;
633 		}
634 		break;
635 	}
636 }
637 
638 /* get a primary headphone pin if available */
alc_get_hp_pin(struct alc_spec * spec)639 static hda_nid_t alc_get_hp_pin(struct alc_spec *spec)
640 {
641 	if (spec->gen.autocfg.hp_pins[0])
642 		return spec->gen.autocfg.hp_pins[0];
643 	if (spec->gen.autocfg.line_out_type == AC_JACK_HP_OUT)
644 		return spec->gen.autocfg.line_out_pins[0];
645 	return 0;
646 }
647 
648 /*
649  * Realtek SSID verification
650  */
651 
652 /* Could be any non-zero and even value. When used as fixup, tells
653  * the driver to ignore any present sku defines.
654  */
655 #define ALC_FIXUP_SKU_IGNORE (2)
656 
alc_fixup_sku_ignore(struct hda_codec * codec,const struct hda_fixup * fix,int action)657 static void alc_fixup_sku_ignore(struct hda_codec *codec,
658 				 const struct hda_fixup *fix, int action)
659 {
660 	struct alc_spec *spec = codec->spec;
661 	if (action == HDA_FIXUP_ACT_PRE_PROBE) {
662 		spec->cdefine.fixup = 1;
663 		spec->cdefine.sku_cfg = ALC_FIXUP_SKU_IGNORE;
664 	}
665 }
666 
alc_fixup_no_depop_delay(struct hda_codec * codec,const struct hda_fixup * fix,int action)667 static void alc_fixup_no_depop_delay(struct hda_codec *codec,
668 				    const struct hda_fixup *fix, int action)
669 {
670 	struct alc_spec *spec = codec->spec;
671 
672 	if (action == HDA_FIXUP_ACT_PROBE) {
673 		spec->no_depop_delay = 1;
674 		codec->depop_delay = 0;
675 	}
676 }
677 
alc_auto_parse_customize_define(struct hda_codec * codec)678 static int alc_auto_parse_customize_define(struct hda_codec *codec)
679 {
680 	unsigned int ass, tmp, i;
681 	unsigned nid = 0;
682 	struct alc_spec *spec = codec->spec;
683 
684 	spec->cdefine.enable_pcbeep = 1; /* assume always enabled */
685 
686 	if (spec->cdefine.fixup) {
687 		ass = spec->cdefine.sku_cfg;
688 		if (ass == ALC_FIXUP_SKU_IGNORE)
689 			return -1;
690 		goto do_sku;
691 	}
692 
693 	if (!codec->bus->pci)
694 		return -1;
695 	ass = codec->core.subsystem_id & 0xffff;
696 	if (ass != codec->bus->pci->subsystem_device && (ass & 1))
697 		goto do_sku;
698 
699 	nid = 0x1d;
700 	if (codec->core.vendor_id == 0x10ec0260)
701 		nid = 0x17;
702 	ass = snd_hda_codec_get_pincfg(codec, nid);
703 
704 	if (!(ass & 1)) {
705 		codec_info(codec, "%s: SKU not ready 0x%08x\n",
706 			   codec->core.chip_name, ass);
707 		return -1;
708 	}
709 
710 	/* check sum */
711 	tmp = 0;
712 	for (i = 1; i < 16; i++) {
713 		if ((ass >> i) & 1)
714 			tmp++;
715 	}
716 	if (((ass >> 16) & 0xf) != tmp)
717 		return -1;
718 
719 	spec->cdefine.port_connectivity = ass >> 30;
720 	spec->cdefine.enable_pcbeep = (ass & 0x100000) >> 20;
721 	spec->cdefine.check_sum = (ass >> 16) & 0xf;
722 	spec->cdefine.customization = ass >> 8;
723 do_sku:
724 	spec->cdefine.sku_cfg = ass;
725 	spec->cdefine.external_amp = (ass & 0x38) >> 3;
726 	spec->cdefine.platform_type = (ass & 0x4) >> 2;
727 	spec->cdefine.swap = (ass & 0x2) >> 1;
728 	spec->cdefine.override = ass & 0x1;
729 
730 	codec_dbg(codec, "SKU: Nid=0x%x sku_cfg=0x%08x\n",
731 		   nid, spec->cdefine.sku_cfg);
732 	codec_dbg(codec, "SKU: port_connectivity=0x%x\n",
733 		   spec->cdefine.port_connectivity);
734 	codec_dbg(codec, "SKU: enable_pcbeep=0x%x\n", spec->cdefine.enable_pcbeep);
735 	codec_dbg(codec, "SKU: check_sum=0x%08x\n", spec->cdefine.check_sum);
736 	codec_dbg(codec, "SKU: customization=0x%08x\n", spec->cdefine.customization);
737 	codec_dbg(codec, "SKU: external_amp=0x%x\n", spec->cdefine.external_amp);
738 	codec_dbg(codec, "SKU: platform_type=0x%x\n", spec->cdefine.platform_type);
739 	codec_dbg(codec, "SKU: swap=0x%x\n", spec->cdefine.swap);
740 	codec_dbg(codec, "SKU: override=0x%x\n", spec->cdefine.override);
741 
742 	return 0;
743 }
744 
745 /* return the position of NID in the list, or -1 if not found */
find_idx_in_nid_list(hda_nid_t nid,const hda_nid_t * list,int nums)746 static int find_idx_in_nid_list(hda_nid_t nid, const hda_nid_t *list, int nums)
747 {
748 	int i;
749 	for (i = 0; i < nums; i++)
750 		if (list[i] == nid)
751 			return i;
752 	return -1;
753 }
754 /* return true if the given NID is found in the list */
found_in_nid_list(hda_nid_t nid,const hda_nid_t * list,int nums)755 static bool found_in_nid_list(hda_nid_t nid, const hda_nid_t *list, int nums)
756 {
757 	return find_idx_in_nid_list(nid, list, nums) >= 0;
758 }
759 
760 /* check subsystem ID and set up device-specific initialization;
761  * return 1 if initialized, 0 if invalid SSID
762  */
763 /* 32-bit subsystem ID for BIOS loading in HD Audio codec.
764  *	31 ~ 16 :	Manufacture ID
765  *	15 ~ 8	:	SKU ID
766  *	7  ~ 0	:	Assembly ID
767  *	port-A --> pin 39/41, port-E --> pin 14/15, port-D --> pin 35/36
768  */
alc_subsystem_id(struct hda_codec * codec,const hda_nid_t * ports)769 static int alc_subsystem_id(struct hda_codec *codec, const hda_nid_t *ports)
770 {
771 	unsigned int ass, tmp, i;
772 	unsigned nid;
773 	struct alc_spec *spec = codec->spec;
774 
775 	if (spec->cdefine.fixup) {
776 		ass = spec->cdefine.sku_cfg;
777 		if (ass == ALC_FIXUP_SKU_IGNORE)
778 			return 0;
779 		goto do_sku;
780 	}
781 
782 	ass = codec->core.subsystem_id & 0xffff;
783 	if (codec->bus->pci &&
784 	    ass != codec->bus->pci->subsystem_device && (ass & 1))
785 		goto do_sku;
786 
787 	/* invalid SSID, check the special NID pin defcfg instead */
788 	/*
789 	 * 31~30	: port connectivity
790 	 * 29~21	: reserve
791 	 * 20		: PCBEEP input
792 	 * 19~16	: Check sum (15:1)
793 	 * 15~1		: Custom
794 	 * 0		: override
795 	*/
796 	nid = 0x1d;
797 	if (codec->core.vendor_id == 0x10ec0260)
798 		nid = 0x17;
799 	ass = snd_hda_codec_get_pincfg(codec, nid);
800 	codec_dbg(codec,
801 		  "realtek: No valid SSID, checking pincfg 0x%08x for NID 0x%x\n",
802 		   ass, nid);
803 	if (!(ass & 1))
804 		return 0;
805 	if ((ass >> 30) != 1)	/* no physical connection */
806 		return 0;
807 
808 	/* check sum */
809 	tmp = 0;
810 	for (i = 1; i < 16; i++) {
811 		if ((ass >> i) & 1)
812 			tmp++;
813 	}
814 	if (((ass >> 16) & 0xf) != tmp)
815 		return 0;
816 do_sku:
817 	codec_dbg(codec, "realtek: Enabling init ASM_ID=0x%04x CODEC_ID=%08x\n",
818 		   ass & 0xffff, codec->core.vendor_id);
819 	/*
820 	 * 0 : override
821 	 * 1 :	Swap Jack
822 	 * 2 : 0 --> Desktop, 1 --> Laptop
823 	 * 3~5 : External Amplifier control
824 	 * 7~6 : Reserved
825 	*/
826 	tmp = (ass & 0x38) >> 3;	/* external Amp control */
827 	if (spec->init_amp == ALC_INIT_UNDEFINED) {
828 		switch (tmp) {
829 		case 1:
830 			alc_setup_gpio(codec, 0x01);
831 			break;
832 		case 3:
833 			alc_setup_gpio(codec, 0x02);
834 			break;
835 		case 7:
836 			alc_setup_gpio(codec, 0x04);
837 			break;
838 		case 5:
839 		default:
840 			spec->init_amp = ALC_INIT_DEFAULT;
841 			break;
842 		}
843 	}
844 
845 	/* is laptop or Desktop and enable the function "Mute internal speaker
846 	 * when the external headphone out jack is plugged"
847 	 */
848 	if (!(ass & 0x8000))
849 		return 1;
850 	/*
851 	 * 10~8 : Jack location
852 	 * 12~11: Headphone out -> 00: PortA, 01: PortE, 02: PortD, 03: Resvered
853 	 * 14~13: Resvered
854 	 * 15   : 1 --> enable the function "Mute internal speaker
855 	 *	        when the external headphone out jack is plugged"
856 	 */
857 	if (!alc_get_hp_pin(spec)) {
858 		hda_nid_t nid;
859 		tmp = (ass >> 11) & 0x3;	/* HP to chassis */
860 		nid = ports[tmp];
861 		if (found_in_nid_list(nid, spec->gen.autocfg.line_out_pins,
862 				      spec->gen.autocfg.line_outs))
863 			return 1;
864 		spec->gen.autocfg.hp_pins[0] = nid;
865 	}
866 	return 1;
867 }
868 
869 /* Check the validity of ALC subsystem-id
870  * ports contains an array of 4 pin NIDs for port-A, E, D and I */
alc_ssid_check(struct hda_codec * codec,const hda_nid_t * ports)871 static void alc_ssid_check(struct hda_codec *codec, const hda_nid_t *ports)
872 {
873 	if (!alc_subsystem_id(codec, ports)) {
874 		struct alc_spec *spec = codec->spec;
875 		if (spec->init_amp == ALC_INIT_UNDEFINED) {
876 			codec_dbg(codec,
877 				  "realtek: Enable default setup for auto mode as fallback\n");
878 			spec->init_amp = ALC_INIT_DEFAULT;
879 		}
880 	}
881 }
882 
883 /*
884  */
885 
alc_fixup_inv_dmic(struct hda_codec * codec,const struct hda_fixup * fix,int action)886 static void alc_fixup_inv_dmic(struct hda_codec *codec,
887 			       const struct hda_fixup *fix, int action)
888 {
889 	struct alc_spec *spec = codec->spec;
890 
891 	spec->gen.inv_dmic_split = 1;
892 }
893 
894 
alc_build_controls(struct hda_codec * codec)895 static int alc_build_controls(struct hda_codec *codec)
896 {
897 	int err;
898 
899 	err = snd_hda_gen_build_controls(codec);
900 	if (err < 0)
901 		return err;
902 
903 	snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_BUILD);
904 	return 0;
905 }
906 
907 
908 /*
909  * Common callbacks
910  */
911 
alc_pre_init(struct hda_codec * codec)912 static void alc_pre_init(struct hda_codec *codec)
913 {
914 	alc_fill_eapd_coef(codec);
915 }
916 
917 #define is_s3_resume(codec) \
918 	((codec)->core.dev.power.power_state.event == PM_EVENT_RESUME)
919 #define is_s4_resume(codec) \
920 	((codec)->core.dev.power.power_state.event == PM_EVENT_RESTORE)
921 
alc_init(struct hda_codec * codec)922 static int alc_init(struct hda_codec *codec)
923 {
924 	struct alc_spec *spec = codec->spec;
925 
926 	/* hibernation resume needs the full chip initialization */
927 	if (is_s4_resume(codec))
928 		alc_pre_init(codec);
929 
930 	if (spec->init_hook)
931 		spec->init_hook(codec);
932 
933 	spec->gen.skip_verbs = 1; /* applied in below */
934 	snd_hda_gen_init(codec);
935 	alc_fix_pll(codec);
936 	alc_auto_init_amp(codec, spec->init_amp);
937 	snd_hda_apply_verbs(codec); /* apply verbs here after own init */
938 
939 	snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_INIT);
940 
941 	return 0;
942 }
943 
944 #define alc_free	snd_hda_gen_free
945 
946 #ifdef CONFIG_PM
alc_shutup(struct hda_codec * codec)947 static inline void alc_shutup(struct hda_codec *codec)
948 {
949 	struct alc_spec *spec = codec->spec;
950 
951 	if (!snd_hda_get_bool_hint(codec, "shutup"))
952 		return; /* disabled explicitly by hints */
953 
954 	if (spec && spec->shutup)
955 		spec->shutup(codec);
956 	else
957 		alc_shutup_pins(codec);
958 }
959 
alc_power_eapd(struct hda_codec * codec)960 static void alc_power_eapd(struct hda_codec *codec)
961 {
962 	alc_auto_setup_eapd(codec, false);
963 }
964 
alc_suspend(struct hda_codec * codec)965 static int alc_suspend(struct hda_codec *codec)
966 {
967 	struct alc_spec *spec = codec->spec;
968 	alc_shutup(codec);
969 	if (spec && spec->power_hook)
970 		spec->power_hook(codec);
971 	return 0;
972 }
973 
alc_resume(struct hda_codec * codec)974 static int alc_resume(struct hda_codec *codec)
975 {
976 	struct alc_spec *spec = codec->spec;
977 
978 	if (!spec->no_depop_delay)
979 		msleep(150); /* to avoid pop noise */
980 	codec->patch_ops.init(codec);
981 	snd_hda_regmap_sync(codec);
982 	hda_call_check_power_status(codec, 0x01);
983 	return 0;
984 }
985 #endif
986 
987 /*
988  */
989 static const struct hda_codec_ops alc_patch_ops = {
990 	.build_controls = alc_build_controls,
991 	.build_pcms = snd_hda_gen_build_pcms,
992 	.init = alc_init,
993 	.free = alc_free,
994 	.unsol_event = snd_hda_jack_unsol_event,
995 #ifdef CONFIG_PM
996 	.resume = alc_resume,
997 	.suspend = alc_suspend,
998 	.check_power_status = snd_hda_gen_check_power_status,
999 #endif
1000 };
1001 
1002 
1003 #define alc_codec_rename(codec, name) snd_hda_codec_set_name(codec, name)
1004 
1005 /*
1006  * Rename codecs appropriately from COEF value or subvendor id
1007  */
1008 struct alc_codec_rename_table {
1009 	unsigned int vendor_id;
1010 	unsigned short coef_mask;
1011 	unsigned short coef_bits;
1012 	const char *name;
1013 };
1014 
1015 struct alc_codec_rename_pci_table {
1016 	unsigned int codec_vendor_id;
1017 	unsigned short pci_subvendor;
1018 	unsigned short pci_subdevice;
1019 	const char *name;
1020 };
1021 
1022 static const struct alc_codec_rename_table rename_tbl[] = {
1023 	{ 0x10ec0221, 0xf00f, 0x1003, "ALC231" },
1024 	{ 0x10ec0269, 0xfff0, 0x3010, "ALC277" },
1025 	{ 0x10ec0269, 0xf0f0, 0x2010, "ALC259" },
1026 	{ 0x10ec0269, 0xf0f0, 0x3010, "ALC258" },
1027 	{ 0x10ec0269, 0x00f0, 0x0010, "ALC269VB" },
1028 	{ 0x10ec0269, 0xffff, 0xa023, "ALC259" },
1029 	{ 0x10ec0269, 0xffff, 0x6023, "ALC281X" },
1030 	{ 0x10ec0269, 0x00f0, 0x0020, "ALC269VC" },
1031 	{ 0x10ec0269, 0x00f0, 0x0030, "ALC269VD" },
1032 	{ 0x10ec0662, 0xffff, 0x4020, "ALC656" },
1033 	{ 0x10ec0887, 0x00f0, 0x0030, "ALC887-VD" },
1034 	{ 0x10ec0888, 0x00f0, 0x0030, "ALC888-VD" },
1035 	{ 0x10ec0888, 0xf0f0, 0x3020, "ALC886" },
1036 	{ 0x10ec0899, 0x2000, 0x2000, "ALC899" },
1037 	{ 0x10ec0892, 0xffff, 0x8020, "ALC661" },
1038 	{ 0x10ec0892, 0xffff, 0x8011, "ALC661" },
1039 	{ 0x10ec0892, 0xffff, 0x4011, "ALC656" },
1040 	{ } /* terminator */
1041 };
1042 
1043 static const struct alc_codec_rename_pci_table rename_pci_tbl[] = {
1044 	{ 0x10ec0280, 0x1028, 0, "ALC3220" },
1045 	{ 0x10ec0282, 0x1028, 0, "ALC3221" },
1046 	{ 0x10ec0283, 0x1028, 0, "ALC3223" },
1047 	{ 0x10ec0288, 0x1028, 0, "ALC3263" },
1048 	{ 0x10ec0292, 0x1028, 0, "ALC3226" },
1049 	{ 0x10ec0293, 0x1028, 0, "ALC3235" },
1050 	{ 0x10ec0255, 0x1028, 0, "ALC3234" },
1051 	{ 0x10ec0668, 0x1028, 0, "ALC3661" },
1052 	{ 0x10ec0275, 0x1028, 0, "ALC3260" },
1053 	{ 0x10ec0899, 0x1028, 0, "ALC3861" },
1054 	{ 0x10ec0298, 0x1028, 0, "ALC3266" },
1055 	{ 0x10ec0236, 0x1028, 0, "ALC3204" },
1056 	{ 0x10ec0256, 0x1028, 0, "ALC3246" },
1057 	{ 0x10ec0225, 0x1028, 0, "ALC3253" },
1058 	{ 0x10ec0295, 0x1028, 0, "ALC3254" },
1059 	{ 0x10ec0299, 0x1028, 0, "ALC3271" },
1060 	{ 0x10ec0670, 0x1025, 0, "ALC669X" },
1061 	{ 0x10ec0676, 0x1025, 0, "ALC679X" },
1062 	{ 0x10ec0282, 0x1043, 0, "ALC3229" },
1063 	{ 0x10ec0233, 0x1043, 0, "ALC3236" },
1064 	{ 0x10ec0280, 0x103c, 0, "ALC3228" },
1065 	{ 0x10ec0282, 0x103c, 0, "ALC3227" },
1066 	{ 0x10ec0286, 0x103c, 0, "ALC3242" },
1067 	{ 0x10ec0290, 0x103c, 0, "ALC3241" },
1068 	{ 0x10ec0668, 0x103c, 0, "ALC3662" },
1069 	{ 0x10ec0283, 0x17aa, 0, "ALC3239" },
1070 	{ 0x10ec0292, 0x17aa, 0, "ALC3232" },
1071 	{ } /* terminator */
1072 };
1073 
alc_codec_rename_from_preset(struct hda_codec * codec)1074 static int alc_codec_rename_from_preset(struct hda_codec *codec)
1075 {
1076 	const struct alc_codec_rename_table *p;
1077 	const struct alc_codec_rename_pci_table *q;
1078 
1079 	for (p = rename_tbl; p->vendor_id; p++) {
1080 		if (p->vendor_id != codec->core.vendor_id)
1081 			continue;
1082 		if ((alc_get_coef0(codec) & p->coef_mask) == p->coef_bits)
1083 			return alc_codec_rename(codec, p->name);
1084 	}
1085 
1086 	if (!codec->bus->pci)
1087 		return 0;
1088 	for (q = rename_pci_tbl; q->codec_vendor_id; q++) {
1089 		if (q->codec_vendor_id != codec->core.vendor_id)
1090 			continue;
1091 		if (q->pci_subvendor != codec->bus->pci->subsystem_vendor)
1092 			continue;
1093 		if (!q->pci_subdevice ||
1094 		    q->pci_subdevice == codec->bus->pci->subsystem_device)
1095 			return alc_codec_rename(codec, q->name);
1096 	}
1097 
1098 	return 0;
1099 }
1100 
1101 
1102 /*
1103  * Digital-beep handlers
1104  */
1105 #ifdef CONFIG_SND_HDA_INPUT_BEEP
1106 
1107 /* additional beep mixers; private_value will be overwritten */
1108 static const struct snd_kcontrol_new alc_beep_mixer[] = {
1109 	HDA_CODEC_VOLUME("Beep Playback Volume", 0, 0, HDA_INPUT),
1110 	HDA_CODEC_MUTE_BEEP("Beep Playback Switch", 0, 0, HDA_INPUT),
1111 };
1112 
1113 /* set up and create beep controls */
set_beep_amp(struct alc_spec * spec,hda_nid_t nid,int idx,int dir)1114 static int set_beep_amp(struct alc_spec *spec, hda_nid_t nid,
1115 			int idx, int dir)
1116 {
1117 	struct snd_kcontrol_new *knew;
1118 	unsigned int beep_amp = HDA_COMPOSE_AMP_VAL(nid, 3, idx, dir);
1119 	int i;
1120 
1121 	for (i = 0; i < ARRAY_SIZE(alc_beep_mixer); i++) {
1122 		knew = snd_hda_gen_add_kctl(&spec->gen, NULL,
1123 					    &alc_beep_mixer[i]);
1124 		if (!knew)
1125 			return -ENOMEM;
1126 		knew->private_value = beep_amp;
1127 	}
1128 	return 0;
1129 }
1130 
1131 static const struct snd_pci_quirk beep_allow_list[] = {
1132 	SND_PCI_QUIRK(0x1043, 0x103c, "ASUS", 1),
1133 	SND_PCI_QUIRK(0x1043, 0x115d, "ASUS", 1),
1134 	SND_PCI_QUIRK(0x1043, 0x829f, "ASUS", 1),
1135 	SND_PCI_QUIRK(0x1043, 0x8376, "EeePC", 1),
1136 	SND_PCI_QUIRK(0x1043, 0x83ce, "EeePC", 1),
1137 	SND_PCI_QUIRK(0x1043, 0x831a, "EeePC", 1),
1138 	SND_PCI_QUIRK(0x1043, 0x834a, "EeePC", 1),
1139 	SND_PCI_QUIRK(0x1458, 0xa002, "GA-MA790X", 1),
1140 	SND_PCI_QUIRK(0x8086, 0xd613, "Intel", 1),
1141 	/* denylist -- no beep available */
1142 	SND_PCI_QUIRK(0x17aa, 0x309e, "Lenovo ThinkCentre M73", 0),
1143 	SND_PCI_QUIRK(0x17aa, 0x30a3, "Lenovo ThinkCentre M93", 0),
1144 	{}
1145 };
1146 
has_cdefine_beep(struct hda_codec * codec)1147 static inline int has_cdefine_beep(struct hda_codec *codec)
1148 {
1149 	struct alc_spec *spec = codec->spec;
1150 	const struct snd_pci_quirk *q;
1151 	q = snd_pci_quirk_lookup(codec->bus->pci, beep_allow_list);
1152 	if (q)
1153 		return q->value;
1154 	return spec->cdefine.enable_pcbeep;
1155 }
1156 #else
1157 #define set_beep_amp(spec, nid, idx, dir)	0
1158 #define has_cdefine_beep(codec)		0
1159 #endif
1160 
1161 /* parse the BIOS configuration and set up the alc_spec */
1162 /* return 1 if successful, 0 if the proper config is not found,
1163  * or a negative error code
1164  */
alc_parse_auto_config(struct hda_codec * codec,const hda_nid_t * ignore_nids,const hda_nid_t * ssid_nids)1165 static int alc_parse_auto_config(struct hda_codec *codec,
1166 				 const hda_nid_t *ignore_nids,
1167 				 const hda_nid_t *ssid_nids)
1168 {
1169 	struct alc_spec *spec = codec->spec;
1170 	struct auto_pin_cfg *cfg = &spec->gen.autocfg;
1171 	int err;
1172 
1173 	err = snd_hda_parse_pin_defcfg(codec, cfg, ignore_nids,
1174 				       spec->parse_flags);
1175 	if (err < 0)
1176 		return err;
1177 
1178 	if (ssid_nids)
1179 		alc_ssid_check(codec, ssid_nids);
1180 
1181 	err = snd_hda_gen_parse_auto_config(codec, cfg);
1182 	if (err < 0)
1183 		return err;
1184 
1185 	return 1;
1186 }
1187 
1188 /* common preparation job for alc_spec */
alc_alloc_spec(struct hda_codec * codec,hda_nid_t mixer_nid)1189 static int alc_alloc_spec(struct hda_codec *codec, hda_nid_t mixer_nid)
1190 {
1191 	struct alc_spec *spec = kzalloc(sizeof(*spec), GFP_KERNEL);
1192 	int err;
1193 
1194 	if (!spec)
1195 		return -ENOMEM;
1196 	codec->spec = spec;
1197 	snd_hda_gen_spec_init(&spec->gen);
1198 	spec->gen.mixer_nid = mixer_nid;
1199 	spec->gen.own_eapd_ctl = 1;
1200 	codec->single_adc_amp = 1;
1201 	/* FIXME: do we need this for all Realtek codec models? */
1202 	codec->spdif_status_reset = 1;
1203 	codec->forced_resume = 1;
1204 	codec->patch_ops = alc_patch_ops;
1205 	mutex_init(&spec->coef_mutex);
1206 
1207 	err = alc_codec_rename_from_preset(codec);
1208 	if (err < 0) {
1209 		kfree(spec);
1210 		return err;
1211 	}
1212 	return 0;
1213 }
1214 
alc880_parse_auto_config(struct hda_codec * codec)1215 static int alc880_parse_auto_config(struct hda_codec *codec)
1216 {
1217 	static const hda_nid_t alc880_ignore[] = { 0x1d, 0 };
1218 	static const hda_nid_t alc880_ssids[] = { 0x15, 0x1b, 0x14, 0 };
1219 	return alc_parse_auto_config(codec, alc880_ignore, alc880_ssids);
1220 }
1221 
1222 /*
1223  * ALC880 fix-ups
1224  */
1225 enum {
1226 	ALC880_FIXUP_GPIO1,
1227 	ALC880_FIXUP_GPIO2,
1228 	ALC880_FIXUP_MEDION_RIM,
1229 	ALC880_FIXUP_LG,
1230 	ALC880_FIXUP_LG_LW25,
1231 	ALC880_FIXUP_W810,
1232 	ALC880_FIXUP_EAPD_COEF,
1233 	ALC880_FIXUP_TCL_S700,
1234 	ALC880_FIXUP_VOL_KNOB,
1235 	ALC880_FIXUP_FUJITSU,
1236 	ALC880_FIXUP_F1734,
1237 	ALC880_FIXUP_UNIWILL,
1238 	ALC880_FIXUP_UNIWILL_DIG,
1239 	ALC880_FIXUP_Z71V,
1240 	ALC880_FIXUP_ASUS_W5A,
1241 	ALC880_FIXUP_3ST_BASE,
1242 	ALC880_FIXUP_3ST,
1243 	ALC880_FIXUP_3ST_DIG,
1244 	ALC880_FIXUP_5ST_BASE,
1245 	ALC880_FIXUP_5ST,
1246 	ALC880_FIXUP_5ST_DIG,
1247 	ALC880_FIXUP_6ST_BASE,
1248 	ALC880_FIXUP_6ST,
1249 	ALC880_FIXUP_6ST_DIG,
1250 	ALC880_FIXUP_6ST_AUTOMUTE,
1251 };
1252 
1253 /* enable the volume-knob widget support on NID 0x21 */
alc880_fixup_vol_knob(struct hda_codec * codec,const struct hda_fixup * fix,int action)1254 static void alc880_fixup_vol_knob(struct hda_codec *codec,
1255 				  const struct hda_fixup *fix, int action)
1256 {
1257 	if (action == HDA_FIXUP_ACT_PROBE)
1258 		snd_hda_jack_detect_enable_callback(codec, 0x21,
1259 						    alc_update_knob_master);
1260 }
1261 
1262 static const struct hda_fixup alc880_fixups[] = {
1263 	[ALC880_FIXUP_GPIO1] = {
1264 		.type = HDA_FIXUP_FUNC,
1265 		.v.func = alc_fixup_gpio1,
1266 	},
1267 	[ALC880_FIXUP_GPIO2] = {
1268 		.type = HDA_FIXUP_FUNC,
1269 		.v.func = alc_fixup_gpio2,
1270 	},
1271 	[ALC880_FIXUP_MEDION_RIM] = {
1272 		.type = HDA_FIXUP_VERBS,
1273 		.v.verbs = (const struct hda_verb[]) {
1274 			{ 0x20, AC_VERB_SET_COEF_INDEX, 0x07 },
1275 			{ 0x20, AC_VERB_SET_PROC_COEF,  0x3060 },
1276 			{ }
1277 		},
1278 		.chained = true,
1279 		.chain_id = ALC880_FIXUP_GPIO2,
1280 	},
1281 	[ALC880_FIXUP_LG] = {
1282 		.type = HDA_FIXUP_PINS,
1283 		.v.pins = (const struct hda_pintbl[]) {
1284 			/* disable bogus unused pins */
1285 			{ 0x16, 0x411111f0 },
1286 			{ 0x18, 0x411111f0 },
1287 			{ 0x1a, 0x411111f0 },
1288 			{ }
1289 		}
1290 	},
1291 	[ALC880_FIXUP_LG_LW25] = {
1292 		.type = HDA_FIXUP_PINS,
1293 		.v.pins = (const struct hda_pintbl[]) {
1294 			{ 0x1a, 0x0181344f }, /* line-in */
1295 			{ 0x1b, 0x0321403f }, /* headphone */
1296 			{ }
1297 		}
1298 	},
1299 	[ALC880_FIXUP_W810] = {
1300 		.type = HDA_FIXUP_PINS,
1301 		.v.pins = (const struct hda_pintbl[]) {
1302 			/* disable bogus unused pins */
1303 			{ 0x17, 0x411111f0 },
1304 			{ }
1305 		},
1306 		.chained = true,
1307 		.chain_id = ALC880_FIXUP_GPIO2,
1308 	},
1309 	[ALC880_FIXUP_EAPD_COEF] = {
1310 		.type = HDA_FIXUP_VERBS,
1311 		.v.verbs = (const struct hda_verb[]) {
1312 			/* change to EAPD mode */
1313 			{ 0x20, AC_VERB_SET_COEF_INDEX, 0x07 },
1314 			{ 0x20, AC_VERB_SET_PROC_COEF,  0x3060 },
1315 			{}
1316 		},
1317 	},
1318 	[ALC880_FIXUP_TCL_S700] = {
1319 		.type = HDA_FIXUP_VERBS,
1320 		.v.verbs = (const struct hda_verb[]) {
1321 			/* change to EAPD mode */
1322 			{ 0x20, AC_VERB_SET_COEF_INDEX, 0x07 },
1323 			{ 0x20, AC_VERB_SET_PROC_COEF,  0x3070 },
1324 			{}
1325 		},
1326 		.chained = true,
1327 		.chain_id = ALC880_FIXUP_GPIO2,
1328 	},
1329 	[ALC880_FIXUP_VOL_KNOB] = {
1330 		.type = HDA_FIXUP_FUNC,
1331 		.v.func = alc880_fixup_vol_knob,
1332 	},
1333 	[ALC880_FIXUP_FUJITSU] = {
1334 		/* override all pins as BIOS on old Amilo is broken */
1335 		.type = HDA_FIXUP_PINS,
1336 		.v.pins = (const struct hda_pintbl[]) {
1337 			{ 0x14, 0x0121401f }, /* HP */
1338 			{ 0x15, 0x99030120 }, /* speaker */
1339 			{ 0x16, 0x99030130 }, /* bass speaker */
1340 			{ 0x17, 0x411111f0 }, /* N/A */
1341 			{ 0x18, 0x411111f0 }, /* N/A */
1342 			{ 0x19, 0x01a19950 }, /* mic-in */
1343 			{ 0x1a, 0x411111f0 }, /* N/A */
1344 			{ 0x1b, 0x411111f0 }, /* N/A */
1345 			{ 0x1c, 0x411111f0 }, /* N/A */
1346 			{ 0x1d, 0x411111f0 }, /* N/A */
1347 			{ 0x1e, 0x01454140 }, /* SPDIF out */
1348 			{ }
1349 		},
1350 		.chained = true,
1351 		.chain_id = ALC880_FIXUP_VOL_KNOB,
1352 	},
1353 	[ALC880_FIXUP_F1734] = {
1354 		/* almost compatible with FUJITSU, but no bass and SPDIF */
1355 		.type = HDA_FIXUP_PINS,
1356 		.v.pins = (const struct hda_pintbl[]) {
1357 			{ 0x14, 0x0121401f }, /* HP */
1358 			{ 0x15, 0x99030120 }, /* speaker */
1359 			{ 0x16, 0x411111f0 }, /* N/A */
1360 			{ 0x17, 0x411111f0 }, /* N/A */
1361 			{ 0x18, 0x411111f0 }, /* N/A */
1362 			{ 0x19, 0x01a19950 }, /* mic-in */
1363 			{ 0x1a, 0x411111f0 }, /* N/A */
1364 			{ 0x1b, 0x411111f0 }, /* N/A */
1365 			{ 0x1c, 0x411111f0 }, /* N/A */
1366 			{ 0x1d, 0x411111f0 }, /* N/A */
1367 			{ 0x1e, 0x411111f0 }, /* N/A */
1368 			{ }
1369 		},
1370 		.chained = true,
1371 		.chain_id = ALC880_FIXUP_VOL_KNOB,
1372 	},
1373 	[ALC880_FIXUP_UNIWILL] = {
1374 		/* need to fix HP and speaker pins to be parsed correctly */
1375 		.type = HDA_FIXUP_PINS,
1376 		.v.pins = (const struct hda_pintbl[]) {
1377 			{ 0x14, 0x0121411f }, /* HP */
1378 			{ 0x15, 0x99030120 }, /* speaker */
1379 			{ 0x16, 0x99030130 }, /* bass speaker */
1380 			{ }
1381 		},
1382 	},
1383 	[ALC880_FIXUP_UNIWILL_DIG] = {
1384 		.type = HDA_FIXUP_PINS,
1385 		.v.pins = (const struct hda_pintbl[]) {
1386 			/* disable bogus unused pins */
1387 			{ 0x17, 0x411111f0 },
1388 			{ 0x19, 0x411111f0 },
1389 			{ 0x1b, 0x411111f0 },
1390 			{ 0x1f, 0x411111f0 },
1391 			{ }
1392 		}
1393 	},
1394 	[ALC880_FIXUP_Z71V] = {
1395 		.type = HDA_FIXUP_PINS,
1396 		.v.pins = (const struct hda_pintbl[]) {
1397 			/* set up the whole pins as BIOS is utterly broken */
1398 			{ 0x14, 0x99030120 }, /* speaker */
1399 			{ 0x15, 0x0121411f }, /* HP */
1400 			{ 0x16, 0x411111f0 }, /* N/A */
1401 			{ 0x17, 0x411111f0 }, /* N/A */
1402 			{ 0x18, 0x01a19950 }, /* mic-in */
1403 			{ 0x19, 0x411111f0 }, /* N/A */
1404 			{ 0x1a, 0x01813031 }, /* line-in */
1405 			{ 0x1b, 0x411111f0 }, /* N/A */
1406 			{ 0x1c, 0x411111f0 }, /* N/A */
1407 			{ 0x1d, 0x411111f0 }, /* N/A */
1408 			{ 0x1e, 0x0144111e }, /* SPDIF */
1409 			{ }
1410 		}
1411 	},
1412 	[ALC880_FIXUP_ASUS_W5A] = {
1413 		.type = HDA_FIXUP_PINS,
1414 		.v.pins = (const struct hda_pintbl[]) {
1415 			/* set up the whole pins as BIOS is utterly broken */
1416 			{ 0x14, 0x0121411f }, /* HP */
1417 			{ 0x15, 0x411111f0 }, /* N/A */
1418 			{ 0x16, 0x411111f0 }, /* N/A */
1419 			{ 0x17, 0x411111f0 }, /* N/A */
1420 			{ 0x18, 0x90a60160 }, /* mic */
1421 			{ 0x19, 0x411111f0 }, /* N/A */
1422 			{ 0x1a, 0x411111f0 }, /* N/A */
1423 			{ 0x1b, 0x411111f0 }, /* N/A */
1424 			{ 0x1c, 0x411111f0 }, /* N/A */
1425 			{ 0x1d, 0x411111f0 }, /* N/A */
1426 			{ 0x1e, 0xb743111e }, /* SPDIF out */
1427 			{ }
1428 		},
1429 		.chained = true,
1430 		.chain_id = ALC880_FIXUP_GPIO1,
1431 	},
1432 	[ALC880_FIXUP_3ST_BASE] = {
1433 		.type = HDA_FIXUP_PINS,
1434 		.v.pins = (const struct hda_pintbl[]) {
1435 			{ 0x14, 0x01014010 }, /* line-out */
1436 			{ 0x15, 0x411111f0 }, /* N/A */
1437 			{ 0x16, 0x411111f0 }, /* N/A */
1438 			{ 0x17, 0x411111f0 }, /* N/A */
1439 			{ 0x18, 0x01a19c30 }, /* mic-in */
1440 			{ 0x19, 0x0121411f }, /* HP */
1441 			{ 0x1a, 0x01813031 }, /* line-in */
1442 			{ 0x1b, 0x02a19c40 }, /* front-mic */
1443 			{ 0x1c, 0x411111f0 }, /* N/A */
1444 			{ 0x1d, 0x411111f0 }, /* N/A */
1445 			/* 0x1e is filled in below */
1446 			{ 0x1f, 0x411111f0 }, /* N/A */
1447 			{ }
1448 		}
1449 	},
1450 	[ALC880_FIXUP_3ST] = {
1451 		.type = HDA_FIXUP_PINS,
1452 		.v.pins = (const struct hda_pintbl[]) {
1453 			{ 0x1e, 0x411111f0 }, /* N/A */
1454 			{ }
1455 		},
1456 		.chained = true,
1457 		.chain_id = ALC880_FIXUP_3ST_BASE,
1458 	},
1459 	[ALC880_FIXUP_3ST_DIG] = {
1460 		.type = HDA_FIXUP_PINS,
1461 		.v.pins = (const struct hda_pintbl[]) {
1462 			{ 0x1e, 0x0144111e }, /* SPDIF */
1463 			{ }
1464 		},
1465 		.chained = true,
1466 		.chain_id = ALC880_FIXUP_3ST_BASE,
1467 	},
1468 	[ALC880_FIXUP_5ST_BASE] = {
1469 		.type = HDA_FIXUP_PINS,
1470 		.v.pins = (const struct hda_pintbl[]) {
1471 			{ 0x14, 0x01014010 }, /* front */
1472 			{ 0x15, 0x411111f0 }, /* N/A */
1473 			{ 0x16, 0x01011411 }, /* CLFE */
1474 			{ 0x17, 0x01016412 }, /* surr */
1475 			{ 0x18, 0x01a19c30 }, /* mic-in */
1476 			{ 0x19, 0x0121411f }, /* HP */
1477 			{ 0x1a, 0x01813031 }, /* line-in */
1478 			{ 0x1b, 0x02a19c40 }, /* front-mic */
1479 			{ 0x1c, 0x411111f0 }, /* N/A */
1480 			{ 0x1d, 0x411111f0 }, /* N/A */
1481 			/* 0x1e is filled in below */
1482 			{ 0x1f, 0x411111f0 }, /* N/A */
1483 			{ }
1484 		}
1485 	},
1486 	[ALC880_FIXUP_5ST] = {
1487 		.type = HDA_FIXUP_PINS,
1488 		.v.pins = (const struct hda_pintbl[]) {
1489 			{ 0x1e, 0x411111f0 }, /* N/A */
1490 			{ }
1491 		},
1492 		.chained = true,
1493 		.chain_id = ALC880_FIXUP_5ST_BASE,
1494 	},
1495 	[ALC880_FIXUP_5ST_DIG] = {
1496 		.type = HDA_FIXUP_PINS,
1497 		.v.pins = (const struct hda_pintbl[]) {
1498 			{ 0x1e, 0x0144111e }, /* SPDIF */
1499 			{ }
1500 		},
1501 		.chained = true,
1502 		.chain_id = ALC880_FIXUP_5ST_BASE,
1503 	},
1504 	[ALC880_FIXUP_6ST_BASE] = {
1505 		.type = HDA_FIXUP_PINS,
1506 		.v.pins = (const struct hda_pintbl[]) {
1507 			{ 0x14, 0x01014010 }, /* front */
1508 			{ 0x15, 0x01016412 }, /* surr */
1509 			{ 0x16, 0x01011411 }, /* CLFE */
1510 			{ 0x17, 0x01012414 }, /* side */
1511 			{ 0x18, 0x01a19c30 }, /* mic-in */
1512 			{ 0x19, 0x02a19c40 }, /* front-mic */
1513 			{ 0x1a, 0x01813031 }, /* line-in */
1514 			{ 0x1b, 0x0121411f }, /* HP */
1515 			{ 0x1c, 0x411111f0 }, /* N/A */
1516 			{ 0x1d, 0x411111f0 }, /* N/A */
1517 			/* 0x1e is filled in below */
1518 			{ 0x1f, 0x411111f0 }, /* N/A */
1519 			{ }
1520 		}
1521 	},
1522 	[ALC880_FIXUP_6ST] = {
1523 		.type = HDA_FIXUP_PINS,
1524 		.v.pins = (const struct hda_pintbl[]) {
1525 			{ 0x1e, 0x411111f0 }, /* N/A */
1526 			{ }
1527 		},
1528 		.chained = true,
1529 		.chain_id = ALC880_FIXUP_6ST_BASE,
1530 	},
1531 	[ALC880_FIXUP_6ST_DIG] = {
1532 		.type = HDA_FIXUP_PINS,
1533 		.v.pins = (const struct hda_pintbl[]) {
1534 			{ 0x1e, 0x0144111e }, /* SPDIF */
1535 			{ }
1536 		},
1537 		.chained = true,
1538 		.chain_id = ALC880_FIXUP_6ST_BASE,
1539 	},
1540 	[ALC880_FIXUP_6ST_AUTOMUTE] = {
1541 		.type = HDA_FIXUP_PINS,
1542 		.v.pins = (const struct hda_pintbl[]) {
1543 			{ 0x1b, 0x0121401f }, /* HP with jack detect */
1544 			{ }
1545 		},
1546 		.chained_before = true,
1547 		.chain_id = ALC880_FIXUP_6ST_BASE,
1548 	},
1549 };
1550 
1551 static const struct snd_pci_quirk alc880_fixup_tbl[] = {
1552 	SND_PCI_QUIRK(0x1019, 0x0f69, "Coeus G610P", ALC880_FIXUP_W810),
1553 	SND_PCI_QUIRK(0x1043, 0x10c3, "ASUS W5A", ALC880_FIXUP_ASUS_W5A),
1554 	SND_PCI_QUIRK(0x1043, 0x1964, "ASUS Z71V", ALC880_FIXUP_Z71V),
1555 	SND_PCI_QUIRK_VENDOR(0x1043, "ASUS", ALC880_FIXUP_GPIO1),
1556 	SND_PCI_QUIRK(0x147b, 0x1045, "ABit AA8XE", ALC880_FIXUP_6ST_AUTOMUTE),
1557 	SND_PCI_QUIRK(0x1558, 0x5401, "Clevo GPIO2", ALC880_FIXUP_GPIO2),
1558 	SND_PCI_QUIRK_VENDOR(0x1558, "Clevo", ALC880_FIXUP_EAPD_COEF),
1559 	SND_PCI_QUIRK(0x1584, 0x9050, "Uniwill", ALC880_FIXUP_UNIWILL_DIG),
1560 	SND_PCI_QUIRK(0x1584, 0x9054, "Uniwill", ALC880_FIXUP_F1734),
1561 	SND_PCI_QUIRK(0x1584, 0x9070, "Uniwill", ALC880_FIXUP_UNIWILL),
1562 	SND_PCI_QUIRK(0x1584, 0x9077, "Uniwill P53", ALC880_FIXUP_VOL_KNOB),
1563 	SND_PCI_QUIRK(0x161f, 0x203d, "W810", ALC880_FIXUP_W810),
1564 	SND_PCI_QUIRK(0x161f, 0x205d, "Medion Rim 2150", ALC880_FIXUP_MEDION_RIM),
1565 	SND_PCI_QUIRK(0x1631, 0xe011, "PB 13201056", ALC880_FIXUP_6ST_AUTOMUTE),
1566 	SND_PCI_QUIRK(0x1734, 0x107c, "FSC Amilo M1437", ALC880_FIXUP_FUJITSU),
1567 	SND_PCI_QUIRK(0x1734, 0x1094, "FSC Amilo M1451G", ALC880_FIXUP_FUJITSU),
1568 	SND_PCI_QUIRK(0x1734, 0x10ac, "FSC AMILO Xi 1526", ALC880_FIXUP_F1734),
1569 	SND_PCI_QUIRK(0x1734, 0x10b0, "FSC Amilo Pi1556", ALC880_FIXUP_FUJITSU),
1570 	SND_PCI_QUIRK(0x1854, 0x003b, "LG", ALC880_FIXUP_LG),
1571 	SND_PCI_QUIRK(0x1854, 0x005f, "LG P1 Express", ALC880_FIXUP_LG),
1572 	SND_PCI_QUIRK(0x1854, 0x0068, "LG w1", ALC880_FIXUP_LG),
1573 	SND_PCI_QUIRK(0x1854, 0x0077, "LG LW25", ALC880_FIXUP_LG_LW25),
1574 	SND_PCI_QUIRK(0x19db, 0x4188, "TCL S700", ALC880_FIXUP_TCL_S700),
1575 
1576 	/* Below is the copied entries from alc880_quirks.c.
1577 	 * It's not quite sure whether BIOS sets the correct pin-config table
1578 	 * on these machines, thus they are kept to be compatible with
1579 	 * the old static quirks.  Once when it's confirmed to work without
1580 	 * these overrides, it'd be better to remove.
1581 	 */
1582 	SND_PCI_QUIRK(0x1019, 0xa880, "ECS", ALC880_FIXUP_5ST_DIG),
1583 	SND_PCI_QUIRK(0x1019, 0xa884, "Acer APFV", ALC880_FIXUP_6ST),
1584 	SND_PCI_QUIRK(0x1025, 0x0070, "ULI", ALC880_FIXUP_3ST_DIG),
1585 	SND_PCI_QUIRK(0x1025, 0x0077, "ULI", ALC880_FIXUP_6ST_DIG),
1586 	SND_PCI_QUIRK(0x1025, 0x0078, "ULI", ALC880_FIXUP_6ST_DIG),
1587 	SND_PCI_QUIRK(0x1025, 0x0087, "ULI", ALC880_FIXUP_6ST_DIG),
1588 	SND_PCI_QUIRK(0x1025, 0xe309, "ULI", ALC880_FIXUP_3ST_DIG),
1589 	SND_PCI_QUIRK(0x1025, 0xe310, "ULI", ALC880_FIXUP_3ST),
1590 	SND_PCI_QUIRK(0x1039, 0x1234, NULL, ALC880_FIXUP_6ST_DIG),
1591 	SND_PCI_QUIRK(0x104d, 0x81a0, "Sony", ALC880_FIXUP_3ST),
1592 	SND_PCI_QUIRK(0x104d, 0x81d6, "Sony", ALC880_FIXUP_3ST),
1593 	SND_PCI_QUIRK(0x107b, 0x3032, "Gateway", ALC880_FIXUP_5ST),
1594 	SND_PCI_QUIRK(0x107b, 0x3033, "Gateway", ALC880_FIXUP_5ST),
1595 	SND_PCI_QUIRK(0x107b, 0x4039, "Gateway", ALC880_FIXUP_5ST),
1596 	SND_PCI_QUIRK(0x1297, 0xc790, "Shuttle ST20G5", ALC880_FIXUP_6ST_DIG),
1597 	SND_PCI_QUIRK(0x1458, 0xa102, "Gigabyte K8", ALC880_FIXUP_6ST_DIG),
1598 	SND_PCI_QUIRK(0x1462, 0x1150, "MSI", ALC880_FIXUP_6ST_DIG),
1599 	SND_PCI_QUIRK(0x1509, 0x925d, "FIC P4M", ALC880_FIXUP_6ST_DIG),
1600 	SND_PCI_QUIRK(0x1565, 0x8202, "Biostar", ALC880_FIXUP_5ST_DIG),
1601 	SND_PCI_QUIRK(0x1695, 0x400d, "EPoX", ALC880_FIXUP_5ST_DIG),
1602 	SND_PCI_QUIRK(0x1695, 0x4012, "EPox EP-5LDA", ALC880_FIXUP_5ST_DIG),
1603 	SND_PCI_QUIRK(0x2668, 0x8086, NULL, ALC880_FIXUP_6ST_DIG), /* broken BIOS */
1604 	SND_PCI_QUIRK(0x8086, 0x2668, NULL, ALC880_FIXUP_6ST_DIG),
1605 	SND_PCI_QUIRK(0x8086, 0xa100, "Intel mobo", ALC880_FIXUP_5ST_DIG),
1606 	SND_PCI_QUIRK(0x8086, 0xd400, "Intel mobo", ALC880_FIXUP_5ST_DIG),
1607 	SND_PCI_QUIRK(0x8086, 0xd401, "Intel mobo", ALC880_FIXUP_5ST_DIG),
1608 	SND_PCI_QUIRK(0x8086, 0xd402, "Intel mobo", ALC880_FIXUP_3ST_DIG),
1609 	SND_PCI_QUIRK(0x8086, 0xe224, "Intel mobo", ALC880_FIXUP_5ST_DIG),
1610 	SND_PCI_QUIRK(0x8086, 0xe305, "Intel mobo", ALC880_FIXUP_3ST_DIG),
1611 	SND_PCI_QUIRK(0x8086, 0xe308, "Intel mobo", ALC880_FIXUP_3ST_DIG),
1612 	SND_PCI_QUIRK(0x8086, 0xe400, "Intel mobo", ALC880_FIXUP_5ST_DIG),
1613 	SND_PCI_QUIRK(0x8086, 0xe401, "Intel mobo", ALC880_FIXUP_5ST_DIG),
1614 	SND_PCI_QUIRK(0x8086, 0xe402, "Intel mobo", ALC880_FIXUP_5ST_DIG),
1615 	/* default Intel */
1616 	SND_PCI_QUIRK_VENDOR(0x8086, "Intel mobo", ALC880_FIXUP_3ST),
1617 	SND_PCI_QUIRK(0xa0a0, 0x0560, "AOpen i915GMm-HFS", ALC880_FIXUP_5ST_DIG),
1618 	SND_PCI_QUIRK(0xe803, 0x1019, NULL, ALC880_FIXUP_6ST_DIG),
1619 	{}
1620 };
1621 
1622 static const struct hda_model_fixup alc880_fixup_models[] = {
1623 	{.id = ALC880_FIXUP_3ST, .name = "3stack"},
1624 	{.id = ALC880_FIXUP_3ST_DIG, .name = "3stack-digout"},
1625 	{.id = ALC880_FIXUP_5ST, .name = "5stack"},
1626 	{.id = ALC880_FIXUP_5ST_DIG, .name = "5stack-digout"},
1627 	{.id = ALC880_FIXUP_6ST, .name = "6stack"},
1628 	{.id = ALC880_FIXUP_6ST_DIG, .name = "6stack-digout"},
1629 	{.id = ALC880_FIXUP_6ST_AUTOMUTE, .name = "6stack-automute"},
1630 	{}
1631 };
1632 
1633 
1634 /*
1635  * OK, here we have finally the patch for ALC880
1636  */
patch_alc880(struct hda_codec * codec)1637 static int patch_alc880(struct hda_codec *codec)
1638 {
1639 	struct alc_spec *spec;
1640 	int err;
1641 
1642 	err = alc_alloc_spec(codec, 0x0b);
1643 	if (err < 0)
1644 		return err;
1645 
1646 	spec = codec->spec;
1647 	spec->gen.need_dac_fix = 1;
1648 	spec->gen.beep_nid = 0x01;
1649 
1650 	codec->patch_ops.unsol_event = alc880_unsol_event;
1651 
1652 	alc_pre_init(codec);
1653 
1654 	snd_hda_pick_fixup(codec, alc880_fixup_models, alc880_fixup_tbl,
1655 		       alc880_fixups);
1656 	snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE);
1657 
1658 	/* automatic parse from the BIOS config */
1659 	err = alc880_parse_auto_config(codec);
1660 	if (err < 0)
1661 		goto error;
1662 
1663 	if (!spec->gen.no_analog) {
1664 		err = set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
1665 		if (err < 0)
1666 			goto error;
1667 	}
1668 
1669 	snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE);
1670 
1671 	return 0;
1672 
1673  error:
1674 	alc_free(codec);
1675 	return err;
1676 }
1677 
1678 
1679 /*
1680  * ALC260 support
1681  */
alc260_parse_auto_config(struct hda_codec * codec)1682 static int alc260_parse_auto_config(struct hda_codec *codec)
1683 {
1684 	static const hda_nid_t alc260_ignore[] = { 0x17, 0 };
1685 	static const hda_nid_t alc260_ssids[] = { 0x10, 0x15, 0x0f, 0 };
1686 	return alc_parse_auto_config(codec, alc260_ignore, alc260_ssids);
1687 }
1688 
1689 /*
1690  * Pin config fixes
1691  */
1692 enum {
1693 	ALC260_FIXUP_HP_DC5750,
1694 	ALC260_FIXUP_HP_PIN_0F,
1695 	ALC260_FIXUP_COEF,
1696 	ALC260_FIXUP_GPIO1,
1697 	ALC260_FIXUP_GPIO1_TOGGLE,
1698 	ALC260_FIXUP_REPLACER,
1699 	ALC260_FIXUP_HP_B1900,
1700 	ALC260_FIXUP_KN1,
1701 	ALC260_FIXUP_FSC_S7020,
1702 	ALC260_FIXUP_FSC_S7020_JWSE,
1703 	ALC260_FIXUP_VAIO_PINS,
1704 };
1705 
alc260_gpio1_automute(struct hda_codec * codec)1706 static void alc260_gpio1_automute(struct hda_codec *codec)
1707 {
1708 	struct alc_spec *spec = codec->spec;
1709 
1710 	alc_update_gpio_data(codec, 0x01, spec->gen.hp_jack_present);
1711 }
1712 
alc260_fixup_gpio1_toggle(struct hda_codec * codec,const struct hda_fixup * fix,int action)1713 static void alc260_fixup_gpio1_toggle(struct hda_codec *codec,
1714 				      const struct hda_fixup *fix, int action)
1715 {
1716 	struct alc_spec *spec = codec->spec;
1717 	if (action == HDA_FIXUP_ACT_PROBE) {
1718 		/* although the machine has only one output pin, we need to
1719 		 * toggle GPIO1 according to the jack state
1720 		 */
1721 		spec->gen.automute_hook = alc260_gpio1_automute;
1722 		spec->gen.detect_hp = 1;
1723 		spec->gen.automute_speaker = 1;
1724 		spec->gen.autocfg.hp_pins[0] = 0x0f; /* copy it for automute */
1725 		snd_hda_jack_detect_enable_callback(codec, 0x0f,
1726 						    snd_hda_gen_hp_automute);
1727 		alc_setup_gpio(codec, 0x01);
1728 	}
1729 }
1730 
alc260_fixup_kn1(struct hda_codec * codec,const struct hda_fixup * fix,int action)1731 static void alc260_fixup_kn1(struct hda_codec *codec,
1732 			     const struct hda_fixup *fix, int action)
1733 {
1734 	struct alc_spec *spec = codec->spec;
1735 	static const struct hda_pintbl pincfgs[] = {
1736 		{ 0x0f, 0x02214000 }, /* HP/speaker */
1737 		{ 0x12, 0x90a60160 }, /* int mic */
1738 		{ 0x13, 0x02a19000 }, /* ext mic */
1739 		{ 0x18, 0x01446000 }, /* SPDIF out */
1740 		/* disable bogus I/O pins */
1741 		{ 0x10, 0x411111f0 },
1742 		{ 0x11, 0x411111f0 },
1743 		{ 0x14, 0x411111f0 },
1744 		{ 0x15, 0x411111f0 },
1745 		{ 0x16, 0x411111f0 },
1746 		{ 0x17, 0x411111f0 },
1747 		{ 0x19, 0x411111f0 },
1748 		{ }
1749 	};
1750 
1751 	switch (action) {
1752 	case HDA_FIXUP_ACT_PRE_PROBE:
1753 		snd_hda_apply_pincfgs(codec, pincfgs);
1754 		spec->init_amp = ALC_INIT_NONE;
1755 		break;
1756 	}
1757 }
1758 
alc260_fixup_fsc_s7020(struct hda_codec * codec,const struct hda_fixup * fix,int action)1759 static void alc260_fixup_fsc_s7020(struct hda_codec *codec,
1760 				   const struct hda_fixup *fix, int action)
1761 {
1762 	struct alc_spec *spec = codec->spec;
1763 	if (action == HDA_FIXUP_ACT_PRE_PROBE)
1764 		spec->init_amp = ALC_INIT_NONE;
1765 }
1766 
alc260_fixup_fsc_s7020_jwse(struct hda_codec * codec,const struct hda_fixup * fix,int action)1767 static void alc260_fixup_fsc_s7020_jwse(struct hda_codec *codec,
1768 				   const struct hda_fixup *fix, int action)
1769 {
1770 	struct alc_spec *spec = codec->spec;
1771 	if (action == HDA_FIXUP_ACT_PRE_PROBE) {
1772 		spec->gen.add_jack_modes = 1;
1773 		spec->gen.hp_mic = 1;
1774 	}
1775 }
1776 
1777 static const struct hda_fixup alc260_fixups[] = {
1778 	[ALC260_FIXUP_HP_DC5750] = {
1779 		.type = HDA_FIXUP_PINS,
1780 		.v.pins = (const struct hda_pintbl[]) {
1781 			{ 0x11, 0x90130110 }, /* speaker */
1782 			{ }
1783 		}
1784 	},
1785 	[ALC260_FIXUP_HP_PIN_0F] = {
1786 		.type = HDA_FIXUP_PINS,
1787 		.v.pins = (const struct hda_pintbl[]) {
1788 			{ 0x0f, 0x01214000 }, /* HP */
1789 			{ }
1790 		}
1791 	},
1792 	[ALC260_FIXUP_COEF] = {
1793 		.type = HDA_FIXUP_VERBS,
1794 		.v.verbs = (const struct hda_verb[]) {
1795 			{ 0x1a, AC_VERB_SET_COEF_INDEX, 0x07 },
1796 			{ 0x1a, AC_VERB_SET_PROC_COEF,  0x3040 },
1797 			{ }
1798 		},
1799 	},
1800 	[ALC260_FIXUP_GPIO1] = {
1801 		.type = HDA_FIXUP_FUNC,
1802 		.v.func = alc_fixup_gpio1,
1803 	},
1804 	[ALC260_FIXUP_GPIO1_TOGGLE] = {
1805 		.type = HDA_FIXUP_FUNC,
1806 		.v.func = alc260_fixup_gpio1_toggle,
1807 		.chained = true,
1808 		.chain_id = ALC260_FIXUP_HP_PIN_0F,
1809 	},
1810 	[ALC260_FIXUP_REPLACER] = {
1811 		.type = HDA_FIXUP_VERBS,
1812 		.v.verbs = (const struct hda_verb[]) {
1813 			{ 0x1a, AC_VERB_SET_COEF_INDEX, 0x07 },
1814 			{ 0x1a, AC_VERB_SET_PROC_COEF,  0x3050 },
1815 			{ }
1816 		},
1817 		.chained = true,
1818 		.chain_id = ALC260_FIXUP_GPIO1_TOGGLE,
1819 	},
1820 	[ALC260_FIXUP_HP_B1900] = {
1821 		.type = HDA_FIXUP_FUNC,
1822 		.v.func = alc260_fixup_gpio1_toggle,
1823 		.chained = true,
1824 		.chain_id = ALC260_FIXUP_COEF,
1825 	},
1826 	[ALC260_FIXUP_KN1] = {
1827 		.type = HDA_FIXUP_FUNC,
1828 		.v.func = alc260_fixup_kn1,
1829 	},
1830 	[ALC260_FIXUP_FSC_S7020] = {
1831 		.type = HDA_FIXUP_FUNC,
1832 		.v.func = alc260_fixup_fsc_s7020,
1833 	},
1834 	[ALC260_FIXUP_FSC_S7020_JWSE] = {
1835 		.type = HDA_FIXUP_FUNC,
1836 		.v.func = alc260_fixup_fsc_s7020_jwse,
1837 		.chained = true,
1838 		.chain_id = ALC260_FIXUP_FSC_S7020,
1839 	},
1840 	[ALC260_FIXUP_VAIO_PINS] = {
1841 		.type = HDA_FIXUP_PINS,
1842 		.v.pins = (const struct hda_pintbl[]) {
1843 			/* Pin configs are missing completely on some VAIOs */
1844 			{ 0x0f, 0x01211020 },
1845 			{ 0x10, 0x0001003f },
1846 			{ 0x11, 0x411111f0 },
1847 			{ 0x12, 0x01a15930 },
1848 			{ 0x13, 0x411111f0 },
1849 			{ 0x14, 0x411111f0 },
1850 			{ 0x15, 0x411111f0 },
1851 			{ 0x16, 0x411111f0 },
1852 			{ 0x17, 0x411111f0 },
1853 			{ 0x18, 0x411111f0 },
1854 			{ 0x19, 0x411111f0 },
1855 			{ }
1856 		}
1857 	},
1858 };
1859 
1860 static const struct snd_pci_quirk alc260_fixup_tbl[] = {
1861 	SND_PCI_QUIRK(0x1025, 0x007b, "Acer C20x", ALC260_FIXUP_GPIO1),
1862 	SND_PCI_QUIRK(0x1025, 0x007f, "Acer Aspire 9500", ALC260_FIXUP_COEF),
1863 	SND_PCI_QUIRK(0x1025, 0x008f, "Acer", ALC260_FIXUP_GPIO1),
1864 	SND_PCI_QUIRK(0x103c, 0x280a, "HP dc5750", ALC260_FIXUP_HP_DC5750),
1865 	SND_PCI_QUIRK(0x103c, 0x30ba, "HP Presario B1900", ALC260_FIXUP_HP_B1900),
1866 	SND_PCI_QUIRK(0x104d, 0x81bb, "Sony VAIO", ALC260_FIXUP_VAIO_PINS),
1867 	SND_PCI_QUIRK(0x104d, 0x81e2, "Sony VAIO TX", ALC260_FIXUP_HP_PIN_0F),
1868 	SND_PCI_QUIRK(0x10cf, 0x1326, "FSC LifeBook S7020", ALC260_FIXUP_FSC_S7020),
1869 	SND_PCI_QUIRK(0x1509, 0x4540, "Favorit 100XS", ALC260_FIXUP_GPIO1),
1870 	SND_PCI_QUIRK(0x152d, 0x0729, "Quanta KN1", ALC260_FIXUP_KN1),
1871 	SND_PCI_QUIRK(0x161f, 0x2057, "Replacer 672V", ALC260_FIXUP_REPLACER),
1872 	SND_PCI_QUIRK(0x1631, 0xc017, "PB V7900", ALC260_FIXUP_COEF),
1873 	{}
1874 };
1875 
1876 static const struct hda_model_fixup alc260_fixup_models[] = {
1877 	{.id = ALC260_FIXUP_GPIO1, .name = "gpio1"},
1878 	{.id = ALC260_FIXUP_COEF, .name = "coef"},
1879 	{.id = ALC260_FIXUP_FSC_S7020, .name = "fujitsu"},
1880 	{.id = ALC260_FIXUP_FSC_S7020_JWSE, .name = "fujitsu-jwse"},
1881 	{}
1882 };
1883 
1884 /*
1885  */
patch_alc260(struct hda_codec * codec)1886 static int patch_alc260(struct hda_codec *codec)
1887 {
1888 	struct alc_spec *spec;
1889 	int err;
1890 
1891 	err = alc_alloc_spec(codec, 0x07);
1892 	if (err < 0)
1893 		return err;
1894 
1895 	spec = codec->spec;
1896 	/* as quite a few machines require HP amp for speaker outputs,
1897 	 * it's easier to enable it unconditionally; even if it's unneeded,
1898 	 * it's almost harmless.
1899 	 */
1900 	spec->gen.prefer_hp_amp = 1;
1901 	spec->gen.beep_nid = 0x01;
1902 
1903 	spec->shutup = alc_eapd_shutup;
1904 
1905 	alc_pre_init(codec);
1906 
1907 	snd_hda_pick_fixup(codec, alc260_fixup_models, alc260_fixup_tbl,
1908 			   alc260_fixups);
1909 	snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE);
1910 
1911 	/* automatic parse from the BIOS config */
1912 	err = alc260_parse_auto_config(codec);
1913 	if (err < 0)
1914 		goto error;
1915 
1916 	if (!spec->gen.no_analog) {
1917 		err = set_beep_amp(spec, 0x07, 0x05, HDA_INPUT);
1918 		if (err < 0)
1919 			goto error;
1920 	}
1921 
1922 	snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE);
1923 
1924 	return 0;
1925 
1926  error:
1927 	alc_free(codec);
1928 	return err;
1929 }
1930 
1931 
1932 /*
1933  * ALC882/883/885/888/889 support
1934  *
1935  * ALC882 is almost identical with ALC880 but has cleaner and more flexible
1936  * configuration.  Each pin widget can choose any input DACs and a mixer.
1937  * Each ADC is connected from a mixer of all inputs.  This makes possible
1938  * 6-channel independent captures.
1939  *
1940  * In addition, an independent DAC for the multi-playback (not used in this
1941  * driver yet).
1942  */
1943 
1944 /*
1945  * Pin config fixes
1946  */
1947 enum {
1948 	ALC882_FIXUP_ABIT_AW9D_MAX,
1949 	ALC882_FIXUP_LENOVO_Y530,
1950 	ALC882_FIXUP_PB_M5210,
1951 	ALC882_FIXUP_ACER_ASPIRE_7736,
1952 	ALC882_FIXUP_ASUS_W90V,
1953 	ALC889_FIXUP_CD,
1954 	ALC889_FIXUP_FRONT_HP_NO_PRESENCE,
1955 	ALC889_FIXUP_VAIO_TT,
1956 	ALC888_FIXUP_EEE1601,
1957 	ALC886_FIXUP_EAPD,
1958 	ALC882_FIXUP_EAPD,
1959 	ALC883_FIXUP_EAPD,
1960 	ALC883_FIXUP_ACER_EAPD,
1961 	ALC882_FIXUP_GPIO1,
1962 	ALC882_FIXUP_GPIO2,
1963 	ALC882_FIXUP_GPIO3,
1964 	ALC889_FIXUP_COEF,
1965 	ALC882_FIXUP_ASUS_W2JC,
1966 	ALC882_FIXUP_ACER_ASPIRE_4930G,
1967 	ALC882_FIXUP_ACER_ASPIRE_8930G,
1968 	ALC882_FIXUP_ASPIRE_8930G_VERBS,
1969 	ALC885_FIXUP_MACPRO_GPIO,
1970 	ALC889_FIXUP_DAC_ROUTE,
1971 	ALC889_FIXUP_MBP_VREF,
1972 	ALC889_FIXUP_IMAC91_VREF,
1973 	ALC889_FIXUP_MBA11_VREF,
1974 	ALC889_FIXUP_MBA21_VREF,
1975 	ALC889_FIXUP_MP11_VREF,
1976 	ALC889_FIXUP_MP41_VREF,
1977 	ALC882_FIXUP_INV_DMIC,
1978 	ALC882_FIXUP_NO_PRIMARY_HP,
1979 	ALC887_FIXUP_ASUS_BASS,
1980 	ALC887_FIXUP_BASS_CHMAP,
1981 	ALC1220_FIXUP_GB_DUAL_CODECS,
1982 	ALC1220_FIXUP_GB_X570,
1983 	ALC1220_FIXUP_CLEVO_P950,
1984 	ALC1220_FIXUP_CLEVO_PB51ED,
1985 	ALC1220_FIXUP_CLEVO_PB51ED_PINS,
1986 	ALC887_FIXUP_ASUS_AUDIO,
1987 	ALC887_FIXUP_ASUS_HMIC,
1988 	ALCS1200A_FIXUP_MIC_VREF,
1989 };
1990 
alc889_fixup_coef(struct hda_codec * codec,const struct hda_fixup * fix,int action)1991 static void alc889_fixup_coef(struct hda_codec *codec,
1992 			      const struct hda_fixup *fix, int action)
1993 {
1994 	if (action != HDA_FIXUP_ACT_INIT)
1995 		return;
1996 	alc_update_coef_idx(codec, 7, 0, 0x2030);
1997 }
1998 
1999 /* set up GPIO at initialization */
alc885_fixup_macpro_gpio(struct hda_codec * codec,const struct hda_fixup * fix,int action)2000 static void alc885_fixup_macpro_gpio(struct hda_codec *codec,
2001 				     const struct hda_fixup *fix, int action)
2002 {
2003 	struct alc_spec *spec = codec->spec;
2004 
2005 	spec->gpio_write_delay = true;
2006 	alc_fixup_gpio3(codec, fix, action);
2007 }
2008 
2009 /* Fix the connection of some pins for ALC889:
2010  * At least, Acer Aspire 5935 shows the connections to DAC3/4 don't
2011  * work correctly (bko#42740)
2012  */
alc889_fixup_dac_route(struct hda_codec * codec,const struct hda_fixup * fix,int action)2013 static void alc889_fixup_dac_route(struct hda_codec *codec,
2014 				   const struct hda_fixup *fix, int action)
2015 {
2016 	if (action == HDA_FIXUP_ACT_PRE_PROBE) {
2017 		/* fake the connections during parsing the tree */
2018 		static const hda_nid_t conn1[] = { 0x0c, 0x0d };
2019 		static const hda_nid_t conn2[] = { 0x0e, 0x0f };
2020 		snd_hda_override_conn_list(codec, 0x14, ARRAY_SIZE(conn1), conn1);
2021 		snd_hda_override_conn_list(codec, 0x15, ARRAY_SIZE(conn1), conn1);
2022 		snd_hda_override_conn_list(codec, 0x18, ARRAY_SIZE(conn2), conn2);
2023 		snd_hda_override_conn_list(codec, 0x1a, ARRAY_SIZE(conn2), conn2);
2024 	} else if (action == HDA_FIXUP_ACT_PROBE) {
2025 		/* restore the connections */
2026 		static const hda_nid_t conn[] = { 0x0c, 0x0d, 0x0e, 0x0f, 0x26 };
2027 		snd_hda_override_conn_list(codec, 0x14, ARRAY_SIZE(conn), conn);
2028 		snd_hda_override_conn_list(codec, 0x15, ARRAY_SIZE(conn), conn);
2029 		snd_hda_override_conn_list(codec, 0x18, ARRAY_SIZE(conn), conn);
2030 		snd_hda_override_conn_list(codec, 0x1a, ARRAY_SIZE(conn), conn);
2031 	}
2032 }
2033 
2034 /* Set VREF on HP pin */
alc889_fixup_mbp_vref(struct hda_codec * codec,const struct hda_fixup * fix,int action)2035 static void alc889_fixup_mbp_vref(struct hda_codec *codec,
2036 				  const struct hda_fixup *fix, int action)
2037 {
2038 	static const hda_nid_t nids[] = { 0x14, 0x15, 0x19 };
2039 	struct alc_spec *spec = codec->spec;
2040 	int i;
2041 
2042 	if (action != HDA_FIXUP_ACT_INIT)
2043 		return;
2044 	for (i = 0; i < ARRAY_SIZE(nids); i++) {
2045 		unsigned int val = snd_hda_codec_get_pincfg(codec, nids[i]);
2046 		if (get_defcfg_device(val) != AC_JACK_HP_OUT)
2047 			continue;
2048 		val = snd_hda_codec_get_pin_target(codec, nids[i]);
2049 		val |= AC_PINCTL_VREF_80;
2050 		snd_hda_set_pin_ctl(codec, nids[i], val);
2051 		spec->gen.keep_vref_in_automute = 1;
2052 		break;
2053 	}
2054 }
2055 
alc889_fixup_mac_pins(struct hda_codec * codec,const hda_nid_t * nids,int num_nids)2056 static void alc889_fixup_mac_pins(struct hda_codec *codec,
2057 				  const hda_nid_t *nids, int num_nids)
2058 {
2059 	struct alc_spec *spec = codec->spec;
2060 	int i;
2061 
2062 	for (i = 0; i < num_nids; i++) {
2063 		unsigned int val;
2064 		val = snd_hda_codec_get_pin_target(codec, nids[i]);
2065 		val |= AC_PINCTL_VREF_50;
2066 		snd_hda_set_pin_ctl(codec, nids[i], val);
2067 	}
2068 	spec->gen.keep_vref_in_automute = 1;
2069 }
2070 
2071 /* Set VREF on speaker pins on imac91 */
alc889_fixup_imac91_vref(struct hda_codec * codec,const struct hda_fixup * fix,int action)2072 static void alc889_fixup_imac91_vref(struct hda_codec *codec,
2073 				     const struct hda_fixup *fix, int action)
2074 {
2075 	static const hda_nid_t nids[] = { 0x18, 0x1a };
2076 
2077 	if (action == HDA_FIXUP_ACT_INIT)
2078 		alc889_fixup_mac_pins(codec, nids, ARRAY_SIZE(nids));
2079 }
2080 
2081 /* Set VREF on speaker pins on mba11 */
alc889_fixup_mba11_vref(struct hda_codec * codec,const struct hda_fixup * fix,int action)2082 static void alc889_fixup_mba11_vref(struct hda_codec *codec,
2083 				    const struct hda_fixup *fix, int action)
2084 {
2085 	static const hda_nid_t nids[] = { 0x18 };
2086 
2087 	if (action == HDA_FIXUP_ACT_INIT)
2088 		alc889_fixup_mac_pins(codec, nids, ARRAY_SIZE(nids));
2089 }
2090 
2091 /* Set VREF on speaker pins on mba21 */
alc889_fixup_mba21_vref(struct hda_codec * codec,const struct hda_fixup * fix,int action)2092 static void alc889_fixup_mba21_vref(struct hda_codec *codec,
2093 				    const struct hda_fixup *fix, int action)
2094 {
2095 	static const hda_nid_t nids[] = { 0x18, 0x19 };
2096 
2097 	if (action == HDA_FIXUP_ACT_INIT)
2098 		alc889_fixup_mac_pins(codec, nids, ARRAY_SIZE(nids));
2099 }
2100 
2101 /* Don't take HP output as primary
2102  * Strangely, the speaker output doesn't work on Vaio Z and some Vaio
2103  * all-in-one desktop PCs (for example VGC-LN51JGB) through DAC 0x05
2104  */
alc882_fixup_no_primary_hp(struct hda_codec * codec,const struct hda_fixup * fix,int action)2105 static void alc882_fixup_no_primary_hp(struct hda_codec *codec,
2106 				       const struct hda_fixup *fix, int action)
2107 {
2108 	struct alc_spec *spec = codec->spec;
2109 	if (action == HDA_FIXUP_ACT_PRE_PROBE) {
2110 		spec->gen.no_primary_hp = 1;
2111 		spec->gen.no_multi_io = 1;
2112 	}
2113 }
2114 
2115 static void alc_fixup_bass_chmap(struct hda_codec *codec,
2116 				 const struct hda_fixup *fix, int action);
2117 
2118 /* For dual-codec configuration, we need to disable some features to avoid
2119  * conflicts of kctls and PCM streams
2120  */
alc_fixup_dual_codecs(struct hda_codec * codec,const struct hda_fixup * fix,int action)2121 static void alc_fixup_dual_codecs(struct hda_codec *codec,
2122 				  const struct hda_fixup *fix, int action)
2123 {
2124 	struct alc_spec *spec = codec->spec;
2125 
2126 	if (action != HDA_FIXUP_ACT_PRE_PROBE)
2127 		return;
2128 	/* disable vmaster */
2129 	spec->gen.suppress_vmaster = 1;
2130 	/* auto-mute and auto-mic switch don't work with multiple codecs */
2131 	spec->gen.suppress_auto_mute = 1;
2132 	spec->gen.suppress_auto_mic = 1;
2133 	/* disable aamix as well */
2134 	spec->gen.mixer_nid = 0;
2135 	/* add location prefix to avoid conflicts */
2136 	codec->force_pin_prefix = 1;
2137 }
2138 
rename_ctl(struct hda_codec * codec,const char * oldname,const char * newname)2139 static void rename_ctl(struct hda_codec *codec, const char *oldname,
2140 		       const char *newname)
2141 {
2142 	struct snd_kcontrol *kctl;
2143 
2144 	kctl = snd_hda_find_mixer_ctl(codec, oldname);
2145 	if (kctl)
2146 		snd_ctl_rename(codec->card, kctl, newname);
2147 }
2148 
alc1220_fixup_gb_dual_codecs(struct hda_codec * codec,const struct hda_fixup * fix,int action)2149 static void alc1220_fixup_gb_dual_codecs(struct hda_codec *codec,
2150 					 const struct hda_fixup *fix,
2151 					 int action)
2152 {
2153 	alc_fixup_dual_codecs(codec, fix, action);
2154 	switch (action) {
2155 	case HDA_FIXUP_ACT_PRE_PROBE:
2156 		/* override card longname to provide a unique UCM profile */
2157 		strcpy(codec->card->longname, "HDAudio-Gigabyte-ALC1220DualCodecs");
2158 		break;
2159 	case HDA_FIXUP_ACT_BUILD:
2160 		/* rename Capture controls depending on the codec */
2161 		rename_ctl(codec, "Capture Volume",
2162 			   codec->addr == 0 ?
2163 			   "Rear-Panel Capture Volume" :
2164 			   "Front-Panel Capture Volume");
2165 		rename_ctl(codec, "Capture Switch",
2166 			   codec->addr == 0 ?
2167 			   "Rear-Panel Capture Switch" :
2168 			   "Front-Panel Capture Switch");
2169 		break;
2170 	}
2171 }
2172 
alc1220_fixup_gb_x570(struct hda_codec * codec,const struct hda_fixup * fix,int action)2173 static void alc1220_fixup_gb_x570(struct hda_codec *codec,
2174 				     const struct hda_fixup *fix,
2175 				     int action)
2176 {
2177 	static const hda_nid_t conn1[] = { 0x0c };
2178 	static const struct coef_fw gb_x570_coefs[] = {
2179 		WRITE_COEF(0x07, 0x03c0),
2180 		WRITE_COEF(0x1a, 0x01c1),
2181 		WRITE_COEF(0x1b, 0x0202),
2182 		WRITE_COEF(0x43, 0x3005),
2183 		{}
2184 	};
2185 
2186 	switch (action) {
2187 	case HDA_FIXUP_ACT_PRE_PROBE:
2188 		snd_hda_override_conn_list(codec, 0x14, ARRAY_SIZE(conn1), conn1);
2189 		snd_hda_override_conn_list(codec, 0x1b, ARRAY_SIZE(conn1), conn1);
2190 		break;
2191 	case HDA_FIXUP_ACT_INIT:
2192 		alc_process_coef_fw(codec, gb_x570_coefs);
2193 		break;
2194 	}
2195 }
2196 
alc1220_fixup_clevo_p950(struct hda_codec * codec,const struct hda_fixup * fix,int action)2197 static void alc1220_fixup_clevo_p950(struct hda_codec *codec,
2198 				     const struct hda_fixup *fix,
2199 				     int action)
2200 {
2201 	static const hda_nid_t conn1[] = { 0x0c };
2202 
2203 	if (action != HDA_FIXUP_ACT_PRE_PROBE)
2204 		return;
2205 
2206 	alc_update_coef_idx(codec, 0x7, 0, 0x3c3);
2207 	/* We therefore want to make sure 0x14 (front headphone) and
2208 	 * 0x1b (speakers) use the stereo DAC 0x02
2209 	 */
2210 	snd_hda_override_conn_list(codec, 0x14, ARRAY_SIZE(conn1), conn1);
2211 	snd_hda_override_conn_list(codec, 0x1b, ARRAY_SIZE(conn1), conn1);
2212 }
2213 
2214 static void alc_fixup_headset_mode_no_hp_mic(struct hda_codec *codec,
2215 				const struct hda_fixup *fix, int action);
2216 
alc1220_fixup_clevo_pb51ed(struct hda_codec * codec,const struct hda_fixup * fix,int action)2217 static void alc1220_fixup_clevo_pb51ed(struct hda_codec *codec,
2218 				     const struct hda_fixup *fix,
2219 				     int action)
2220 {
2221 	alc1220_fixup_clevo_p950(codec, fix, action);
2222 	alc_fixup_headset_mode_no_hp_mic(codec, fix, action);
2223 }
2224 
alc887_asus_hp_automute_hook(struct hda_codec * codec,struct hda_jack_callback * jack)2225 static void alc887_asus_hp_automute_hook(struct hda_codec *codec,
2226 					 struct hda_jack_callback *jack)
2227 {
2228 	struct alc_spec *spec = codec->spec;
2229 	unsigned int vref;
2230 
2231 	snd_hda_gen_hp_automute(codec, jack);
2232 
2233 	if (spec->gen.hp_jack_present)
2234 		vref = AC_PINCTL_VREF_80;
2235 	else
2236 		vref = AC_PINCTL_VREF_HIZ;
2237 	snd_hda_set_pin_ctl(codec, 0x19, PIN_HP | vref);
2238 }
2239 
alc887_fixup_asus_jack(struct hda_codec * codec,const struct hda_fixup * fix,int action)2240 static void alc887_fixup_asus_jack(struct hda_codec *codec,
2241 				     const struct hda_fixup *fix, int action)
2242 {
2243 	struct alc_spec *spec = codec->spec;
2244 	if (action != HDA_FIXUP_ACT_PROBE)
2245 		return;
2246 	snd_hda_set_pin_ctl_cache(codec, 0x1b, PIN_HP);
2247 	spec->gen.hp_automute_hook = alc887_asus_hp_automute_hook;
2248 }
2249 
2250 static const struct hda_fixup alc882_fixups[] = {
2251 	[ALC882_FIXUP_ABIT_AW9D_MAX] = {
2252 		.type = HDA_FIXUP_PINS,
2253 		.v.pins = (const struct hda_pintbl[]) {
2254 			{ 0x15, 0x01080104 }, /* side */
2255 			{ 0x16, 0x01011012 }, /* rear */
2256 			{ 0x17, 0x01016011 }, /* clfe */
2257 			{ }
2258 		}
2259 	},
2260 	[ALC882_FIXUP_LENOVO_Y530] = {
2261 		.type = HDA_FIXUP_PINS,
2262 		.v.pins = (const struct hda_pintbl[]) {
2263 			{ 0x15, 0x99130112 }, /* rear int speakers */
2264 			{ 0x16, 0x99130111 }, /* subwoofer */
2265 			{ }
2266 		}
2267 	},
2268 	[ALC882_FIXUP_PB_M5210] = {
2269 		.type = HDA_FIXUP_PINCTLS,
2270 		.v.pins = (const struct hda_pintbl[]) {
2271 			{ 0x19, PIN_VREF50 },
2272 			{}
2273 		}
2274 	},
2275 	[ALC882_FIXUP_ACER_ASPIRE_7736] = {
2276 		.type = HDA_FIXUP_FUNC,
2277 		.v.func = alc_fixup_sku_ignore,
2278 	},
2279 	[ALC882_FIXUP_ASUS_W90V] = {
2280 		.type = HDA_FIXUP_PINS,
2281 		.v.pins = (const struct hda_pintbl[]) {
2282 			{ 0x16, 0x99130110 }, /* fix sequence for CLFE */
2283 			{ }
2284 		}
2285 	},
2286 	[ALC889_FIXUP_CD] = {
2287 		.type = HDA_FIXUP_PINS,
2288 		.v.pins = (const struct hda_pintbl[]) {
2289 			{ 0x1c, 0x993301f0 }, /* CD */
2290 			{ }
2291 		}
2292 	},
2293 	[ALC889_FIXUP_FRONT_HP_NO_PRESENCE] = {
2294 		.type = HDA_FIXUP_PINS,
2295 		.v.pins = (const struct hda_pintbl[]) {
2296 			{ 0x1b, 0x02214120 }, /* Front HP jack is flaky, disable jack detect */
2297 			{ }
2298 		},
2299 		.chained = true,
2300 		.chain_id = ALC889_FIXUP_CD,
2301 	},
2302 	[ALC889_FIXUP_VAIO_TT] = {
2303 		.type = HDA_FIXUP_PINS,
2304 		.v.pins = (const struct hda_pintbl[]) {
2305 			{ 0x17, 0x90170111 }, /* hidden surround speaker */
2306 			{ }
2307 		}
2308 	},
2309 	[ALC888_FIXUP_EEE1601] = {
2310 		.type = HDA_FIXUP_VERBS,
2311 		.v.verbs = (const struct hda_verb[]) {
2312 			{ 0x20, AC_VERB_SET_COEF_INDEX, 0x0b },
2313 			{ 0x20, AC_VERB_SET_PROC_COEF,  0x0838 },
2314 			{ }
2315 		}
2316 	},
2317 	[ALC886_FIXUP_EAPD] = {
2318 		.type = HDA_FIXUP_VERBS,
2319 		.v.verbs = (const struct hda_verb[]) {
2320 			/* change to EAPD mode */
2321 			{ 0x20, AC_VERB_SET_COEF_INDEX, 0x07 },
2322 			{ 0x20, AC_VERB_SET_PROC_COEF, 0x0068 },
2323 			{ }
2324 		}
2325 	},
2326 	[ALC882_FIXUP_EAPD] = {
2327 		.type = HDA_FIXUP_VERBS,
2328 		.v.verbs = (const struct hda_verb[]) {
2329 			/* change to EAPD mode */
2330 			{ 0x20, AC_VERB_SET_COEF_INDEX, 0x07 },
2331 			{ 0x20, AC_VERB_SET_PROC_COEF, 0x3060 },
2332 			{ }
2333 		}
2334 	},
2335 	[ALC883_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, 0x3070 },
2341 			{ }
2342 		}
2343 	},
2344 	[ALC883_FIXUP_ACER_EAPD] = {
2345 		.type = HDA_FIXUP_VERBS,
2346 		.v.verbs = (const struct hda_verb[]) {
2347 			/* eanable EAPD on Acer laptops */
2348 			{ 0x20, AC_VERB_SET_COEF_INDEX, 0x07 },
2349 			{ 0x20, AC_VERB_SET_PROC_COEF, 0x3050 },
2350 			{ }
2351 		}
2352 	},
2353 	[ALC882_FIXUP_GPIO1] = {
2354 		.type = HDA_FIXUP_FUNC,
2355 		.v.func = alc_fixup_gpio1,
2356 	},
2357 	[ALC882_FIXUP_GPIO2] = {
2358 		.type = HDA_FIXUP_FUNC,
2359 		.v.func = alc_fixup_gpio2,
2360 	},
2361 	[ALC882_FIXUP_GPIO3] = {
2362 		.type = HDA_FIXUP_FUNC,
2363 		.v.func = alc_fixup_gpio3,
2364 	},
2365 	[ALC882_FIXUP_ASUS_W2JC] = {
2366 		.type = HDA_FIXUP_FUNC,
2367 		.v.func = alc_fixup_gpio1,
2368 		.chained = true,
2369 		.chain_id = ALC882_FIXUP_EAPD,
2370 	},
2371 	[ALC889_FIXUP_COEF] = {
2372 		.type = HDA_FIXUP_FUNC,
2373 		.v.func = alc889_fixup_coef,
2374 	},
2375 	[ALC882_FIXUP_ACER_ASPIRE_4930G] = {
2376 		.type = HDA_FIXUP_PINS,
2377 		.v.pins = (const struct hda_pintbl[]) {
2378 			{ 0x16, 0x99130111 }, /* CLFE speaker */
2379 			{ 0x17, 0x99130112 }, /* surround speaker */
2380 			{ }
2381 		},
2382 		.chained = true,
2383 		.chain_id = ALC882_FIXUP_GPIO1,
2384 	},
2385 	[ALC882_FIXUP_ACER_ASPIRE_8930G] = {
2386 		.type = HDA_FIXUP_PINS,
2387 		.v.pins = (const struct hda_pintbl[]) {
2388 			{ 0x16, 0x99130111 }, /* CLFE speaker */
2389 			{ 0x1b, 0x99130112 }, /* surround speaker */
2390 			{ }
2391 		},
2392 		.chained = true,
2393 		.chain_id = ALC882_FIXUP_ASPIRE_8930G_VERBS,
2394 	},
2395 	[ALC882_FIXUP_ASPIRE_8930G_VERBS] = {
2396 		/* additional init verbs for Acer Aspire 8930G */
2397 		.type = HDA_FIXUP_VERBS,
2398 		.v.verbs = (const struct hda_verb[]) {
2399 			/* Enable all DACs */
2400 			/* DAC DISABLE/MUTE 1? */
2401 			/*  setting bits 1-5 disables DAC nids 0x02-0x06
2402 			 *  apparently. Init=0x38 */
2403 			{ 0x20, AC_VERB_SET_COEF_INDEX, 0x03 },
2404 			{ 0x20, AC_VERB_SET_PROC_COEF, 0x0000 },
2405 			/* DAC DISABLE/MUTE 2? */
2406 			/*  some bit here disables the other DACs.
2407 			 *  Init=0x4900 */
2408 			{ 0x20, AC_VERB_SET_COEF_INDEX, 0x08 },
2409 			{ 0x20, AC_VERB_SET_PROC_COEF, 0x0000 },
2410 			/* DMIC fix
2411 			 * This laptop has a stereo digital microphone.
2412 			 * The mics are only 1cm apart which makes the stereo
2413 			 * useless. However, either the mic or the ALC889
2414 			 * makes the signal become a difference/sum signal
2415 			 * instead of standard stereo, which is annoying.
2416 			 * So instead we flip this bit which makes the
2417 			 * codec replicate the sum signal to both channels,
2418 			 * turning it into a normal mono mic.
2419 			 */
2420 			/* DMIC_CONTROL? Init value = 0x0001 */
2421 			{ 0x20, AC_VERB_SET_COEF_INDEX, 0x0b },
2422 			{ 0x20, AC_VERB_SET_PROC_COEF, 0x0003 },
2423 			{ 0x20, AC_VERB_SET_COEF_INDEX, 0x07 },
2424 			{ 0x20, AC_VERB_SET_PROC_COEF, 0x3050 },
2425 			{ }
2426 		},
2427 		.chained = true,
2428 		.chain_id = ALC882_FIXUP_GPIO1,
2429 	},
2430 	[ALC885_FIXUP_MACPRO_GPIO] = {
2431 		.type = HDA_FIXUP_FUNC,
2432 		.v.func = alc885_fixup_macpro_gpio,
2433 	},
2434 	[ALC889_FIXUP_DAC_ROUTE] = {
2435 		.type = HDA_FIXUP_FUNC,
2436 		.v.func = alc889_fixup_dac_route,
2437 	},
2438 	[ALC889_FIXUP_MBP_VREF] = {
2439 		.type = HDA_FIXUP_FUNC,
2440 		.v.func = alc889_fixup_mbp_vref,
2441 		.chained = true,
2442 		.chain_id = ALC882_FIXUP_GPIO1,
2443 	},
2444 	[ALC889_FIXUP_IMAC91_VREF] = {
2445 		.type = HDA_FIXUP_FUNC,
2446 		.v.func = alc889_fixup_imac91_vref,
2447 		.chained = true,
2448 		.chain_id = ALC882_FIXUP_GPIO1,
2449 	},
2450 	[ALC889_FIXUP_MBA11_VREF] = {
2451 		.type = HDA_FIXUP_FUNC,
2452 		.v.func = alc889_fixup_mba11_vref,
2453 		.chained = true,
2454 		.chain_id = ALC889_FIXUP_MBP_VREF,
2455 	},
2456 	[ALC889_FIXUP_MBA21_VREF] = {
2457 		.type = HDA_FIXUP_FUNC,
2458 		.v.func = alc889_fixup_mba21_vref,
2459 		.chained = true,
2460 		.chain_id = ALC889_FIXUP_MBP_VREF,
2461 	},
2462 	[ALC889_FIXUP_MP11_VREF] = {
2463 		.type = HDA_FIXUP_FUNC,
2464 		.v.func = alc889_fixup_mba11_vref,
2465 		.chained = true,
2466 		.chain_id = ALC885_FIXUP_MACPRO_GPIO,
2467 	},
2468 	[ALC889_FIXUP_MP41_VREF] = {
2469 		.type = HDA_FIXUP_FUNC,
2470 		.v.func = alc889_fixup_mbp_vref,
2471 		.chained = true,
2472 		.chain_id = ALC885_FIXUP_MACPRO_GPIO,
2473 	},
2474 	[ALC882_FIXUP_INV_DMIC] = {
2475 		.type = HDA_FIXUP_FUNC,
2476 		.v.func = alc_fixup_inv_dmic,
2477 	},
2478 	[ALC882_FIXUP_NO_PRIMARY_HP] = {
2479 		.type = HDA_FIXUP_FUNC,
2480 		.v.func = alc882_fixup_no_primary_hp,
2481 	},
2482 	[ALC887_FIXUP_ASUS_BASS] = {
2483 		.type = HDA_FIXUP_PINS,
2484 		.v.pins = (const struct hda_pintbl[]) {
2485 			{0x16, 0x99130130}, /* bass speaker */
2486 			{}
2487 		},
2488 		.chained = true,
2489 		.chain_id = ALC887_FIXUP_BASS_CHMAP,
2490 	},
2491 	[ALC887_FIXUP_BASS_CHMAP] = {
2492 		.type = HDA_FIXUP_FUNC,
2493 		.v.func = alc_fixup_bass_chmap,
2494 	},
2495 	[ALC1220_FIXUP_GB_DUAL_CODECS] = {
2496 		.type = HDA_FIXUP_FUNC,
2497 		.v.func = alc1220_fixup_gb_dual_codecs,
2498 	},
2499 	[ALC1220_FIXUP_GB_X570] = {
2500 		.type = HDA_FIXUP_FUNC,
2501 		.v.func = alc1220_fixup_gb_x570,
2502 	},
2503 	[ALC1220_FIXUP_CLEVO_P950] = {
2504 		.type = HDA_FIXUP_FUNC,
2505 		.v.func = alc1220_fixup_clevo_p950,
2506 	},
2507 	[ALC1220_FIXUP_CLEVO_PB51ED] = {
2508 		.type = HDA_FIXUP_FUNC,
2509 		.v.func = alc1220_fixup_clevo_pb51ed,
2510 	},
2511 	[ALC1220_FIXUP_CLEVO_PB51ED_PINS] = {
2512 		.type = HDA_FIXUP_PINS,
2513 		.v.pins = (const struct hda_pintbl[]) {
2514 			{ 0x19, 0x01a1913c }, /* use as headset mic, without its own jack detect */
2515 			{}
2516 		},
2517 		.chained = true,
2518 		.chain_id = ALC1220_FIXUP_CLEVO_PB51ED,
2519 	},
2520 	[ALC887_FIXUP_ASUS_AUDIO] = {
2521 		.type = HDA_FIXUP_PINS,
2522 		.v.pins = (const struct hda_pintbl[]) {
2523 			{ 0x15, 0x02a14150 }, /* use as headset mic, without its own jack detect */
2524 			{ 0x19, 0x22219420 },
2525 			{}
2526 		},
2527 	},
2528 	[ALC887_FIXUP_ASUS_HMIC] = {
2529 		.type = HDA_FIXUP_FUNC,
2530 		.v.func = alc887_fixup_asus_jack,
2531 		.chained = true,
2532 		.chain_id = ALC887_FIXUP_ASUS_AUDIO,
2533 	},
2534 	[ALCS1200A_FIXUP_MIC_VREF] = {
2535 		.type = HDA_FIXUP_PINCTLS,
2536 		.v.pins = (const struct hda_pintbl[]) {
2537 			{ 0x18, PIN_VREF50 }, /* rear mic */
2538 			{ 0x19, PIN_VREF50 }, /* front mic */
2539 			{}
2540 		}
2541 	},
2542 };
2543 
2544 static const struct snd_pci_quirk alc882_fixup_tbl[] = {
2545 	SND_PCI_QUIRK(0x1025, 0x006c, "Acer Aspire 9810", ALC883_FIXUP_ACER_EAPD),
2546 	SND_PCI_QUIRK(0x1025, 0x0090, "Acer Aspire", ALC883_FIXUP_ACER_EAPD),
2547 	SND_PCI_QUIRK(0x1025, 0x0107, "Acer Aspire", ALC883_FIXUP_ACER_EAPD),
2548 	SND_PCI_QUIRK(0x1025, 0x010a, "Acer Ferrari 5000", ALC883_FIXUP_ACER_EAPD),
2549 	SND_PCI_QUIRK(0x1025, 0x0110, "Acer Aspire", ALC883_FIXUP_ACER_EAPD),
2550 	SND_PCI_QUIRK(0x1025, 0x0112, "Acer Aspire 9303", ALC883_FIXUP_ACER_EAPD),
2551 	SND_PCI_QUIRK(0x1025, 0x0121, "Acer Aspire 5920G", ALC883_FIXUP_ACER_EAPD),
2552 	SND_PCI_QUIRK(0x1025, 0x013e, "Acer Aspire 4930G",
2553 		      ALC882_FIXUP_ACER_ASPIRE_4930G),
2554 	SND_PCI_QUIRK(0x1025, 0x013f, "Acer Aspire 5930G",
2555 		      ALC882_FIXUP_ACER_ASPIRE_4930G),
2556 	SND_PCI_QUIRK(0x1025, 0x0145, "Acer Aspire 8930G",
2557 		      ALC882_FIXUP_ACER_ASPIRE_8930G),
2558 	SND_PCI_QUIRK(0x1025, 0x0146, "Acer Aspire 6935G",
2559 		      ALC882_FIXUP_ACER_ASPIRE_8930G),
2560 	SND_PCI_QUIRK(0x1025, 0x0142, "Acer Aspire 7730G",
2561 		      ALC882_FIXUP_ACER_ASPIRE_4930G),
2562 	SND_PCI_QUIRK(0x1025, 0x0155, "Packard-Bell M5120", ALC882_FIXUP_PB_M5210),
2563 	SND_PCI_QUIRK(0x1025, 0x015e, "Acer Aspire 6930G",
2564 		      ALC882_FIXUP_ACER_ASPIRE_4930G),
2565 	SND_PCI_QUIRK(0x1025, 0x0166, "Acer Aspire 6530G",
2566 		      ALC882_FIXUP_ACER_ASPIRE_4930G),
2567 	SND_PCI_QUIRK(0x1025, 0x021e, "Acer Aspire 5739G",
2568 		      ALC882_FIXUP_ACER_ASPIRE_4930G),
2569 	SND_PCI_QUIRK(0x1025, 0x0259, "Acer Aspire 5935", ALC889_FIXUP_DAC_ROUTE),
2570 	SND_PCI_QUIRK(0x1025, 0x026b, "Acer Aspire 8940G", ALC882_FIXUP_ACER_ASPIRE_8930G),
2571 	SND_PCI_QUIRK(0x1025, 0x0296, "Acer Aspire 7736z", ALC882_FIXUP_ACER_ASPIRE_7736),
2572 	SND_PCI_QUIRK(0x1043, 0x13c2, "Asus A7M", ALC882_FIXUP_EAPD),
2573 	SND_PCI_QUIRK(0x1043, 0x1873, "ASUS W90V", ALC882_FIXUP_ASUS_W90V),
2574 	SND_PCI_QUIRK(0x1043, 0x1971, "Asus W2JC", ALC882_FIXUP_ASUS_W2JC),
2575 	SND_PCI_QUIRK(0x1043, 0x2390, "Asus D700SA", ALC887_FIXUP_ASUS_HMIC),
2576 	SND_PCI_QUIRK(0x1043, 0x835f, "Asus Eee 1601", ALC888_FIXUP_EEE1601),
2577 	SND_PCI_QUIRK(0x1043, 0x84bc, "ASUS ET2700", ALC887_FIXUP_ASUS_BASS),
2578 	SND_PCI_QUIRK(0x1043, 0x8691, "ASUS ROG Ranger VIII", ALC882_FIXUP_GPIO3),
2579 	SND_PCI_QUIRK(0x1043, 0x8797, "ASUS TUF B550M-PLUS", ALCS1200A_FIXUP_MIC_VREF),
2580 	SND_PCI_QUIRK(0x104d, 0x9043, "Sony Vaio VGC-LN51JGB", ALC882_FIXUP_NO_PRIMARY_HP),
2581 	SND_PCI_QUIRK(0x104d, 0x9044, "Sony VAIO AiO", ALC882_FIXUP_NO_PRIMARY_HP),
2582 	SND_PCI_QUIRK(0x104d, 0x9047, "Sony Vaio TT", ALC889_FIXUP_VAIO_TT),
2583 	SND_PCI_QUIRK(0x104d, 0x905a, "Sony Vaio Z", ALC882_FIXUP_NO_PRIMARY_HP),
2584 	SND_PCI_QUIRK(0x104d, 0x9060, "Sony Vaio VPCL14M1R", ALC882_FIXUP_NO_PRIMARY_HP),
2585 
2586 	/* All Apple entries are in codec SSIDs */
2587 	SND_PCI_QUIRK(0x106b, 0x00a0, "MacBookPro 3,1", ALC889_FIXUP_MBP_VREF),
2588 	SND_PCI_QUIRK(0x106b, 0x00a1, "Macbook", ALC889_FIXUP_MBP_VREF),
2589 	SND_PCI_QUIRK(0x106b, 0x00a4, "MacbookPro 4,1", ALC889_FIXUP_MBP_VREF),
2590 	SND_PCI_QUIRK(0x106b, 0x0c00, "Mac Pro", ALC889_FIXUP_MP11_VREF),
2591 	SND_PCI_QUIRK(0x106b, 0x1000, "iMac 24", ALC885_FIXUP_MACPRO_GPIO),
2592 	SND_PCI_QUIRK(0x106b, 0x2800, "AppleTV", ALC885_FIXUP_MACPRO_GPIO),
2593 	SND_PCI_QUIRK(0x106b, 0x2c00, "MacbookPro rev3", ALC889_FIXUP_MBP_VREF),
2594 	SND_PCI_QUIRK(0x106b, 0x3000, "iMac", ALC889_FIXUP_MBP_VREF),
2595 	SND_PCI_QUIRK(0x106b, 0x3200, "iMac 7,1 Aluminum", ALC882_FIXUP_EAPD),
2596 	SND_PCI_QUIRK(0x106b, 0x3400, "MacBookAir 1,1", ALC889_FIXUP_MBA11_VREF),
2597 	SND_PCI_QUIRK(0x106b, 0x3500, "MacBookAir 2,1", ALC889_FIXUP_MBA21_VREF),
2598 	SND_PCI_QUIRK(0x106b, 0x3600, "Macbook 3,1", ALC889_FIXUP_MBP_VREF),
2599 	SND_PCI_QUIRK(0x106b, 0x3800, "MacbookPro 4,1", ALC889_FIXUP_MBP_VREF),
2600 	SND_PCI_QUIRK(0x106b, 0x3e00, "iMac 24 Aluminum", ALC885_FIXUP_MACPRO_GPIO),
2601 	SND_PCI_QUIRK(0x106b, 0x3f00, "Macbook 5,1", ALC889_FIXUP_IMAC91_VREF),
2602 	SND_PCI_QUIRK(0x106b, 0x4000, "MacbookPro 5,1", ALC889_FIXUP_IMAC91_VREF),
2603 	SND_PCI_QUIRK(0x106b, 0x4100, "Macmini 3,1", ALC889_FIXUP_IMAC91_VREF),
2604 	SND_PCI_QUIRK(0x106b, 0x4200, "Mac Pro 4,1/5,1", ALC889_FIXUP_MP41_VREF),
2605 	SND_PCI_QUIRK(0x106b, 0x4300, "iMac 9,1", ALC889_FIXUP_IMAC91_VREF),
2606 	SND_PCI_QUIRK(0x106b, 0x4600, "MacbookPro 5,2", ALC889_FIXUP_IMAC91_VREF),
2607 	SND_PCI_QUIRK(0x106b, 0x4900, "iMac 9,1 Aluminum", ALC889_FIXUP_IMAC91_VREF),
2608 	SND_PCI_QUIRK(0x106b, 0x4a00, "Macbook 5,2", ALC889_FIXUP_MBA11_VREF),
2609 
2610 	SND_PCI_QUIRK(0x1071, 0x8258, "Evesham Voyaeger", ALC882_FIXUP_EAPD),
2611 	SND_PCI_QUIRK(0x13fe, 0x1009, "Advantech MIT-W101", ALC886_FIXUP_EAPD),
2612 	SND_PCI_QUIRK(0x1458, 0xa002, "Gigabyte EP45-DS3/Z87X-UD3H", ALC889_FIXUP_FRONT_HP_NO_PRESENCE),
2613 	SND_PCI_QUIRK(0x1458, 0xa0b8, "Gigabyte AZ370-Gaming", ALC1220_FIXUP_GB_DUAL_CODECS),
2614 	SND_PCI_QUIRK(0x1458, 0xa0cd, "Gigabyte X570 Aorus Master", ALC1220_FIXUP_GB_X570),
2615 	SND_PCI_QUIRK(0x1458, 0xa0ce, "Gigabyte X570 Aorus Xtreme", ALC1220_FIXUP_GB_X570),
2616 	SND_PCI_QUIRK(0x1458, 0xa0d5, "Gigabyte X570S Aorus Master", ALC1220_FIXUP_GB_X570),
2617 	SND_PCI_QUIRK(0x1462, 0x11f7, "MSI-GE63", ALC1220_FIXUP_CLEVO_P950),
2618 	SND_PCI_QUIRK(0x1462, 0x1228, "MSI-GP63", ALC1220_FIXUP_CLEVO_P950),
2619 	SND_PCI_QUIRK(0x1462, 0x1229, "MSI-GP73", ALC1220_FIXUP_CLEVO_P950),
2620 	SND_PCI_QUIRK(0x1462, 0x1275, "MSI-GL63", ALC1220_FIXUP_CLEVO_P950),
2621 	SND_PCI_QUIRK(0x1462, 0x1276, "MSI-GL73", ALC1220_FIXUP_CLEVO_P950),
2622 	SND_PCI_QUIRK(0x1462, 0x1293, "MSI-GP65", ALC1220_FIXUP_CLEVO_P950),
2623 	SND_PCI_QUIRK(0x1462, 0x7350, "MSI-7350", ALC889_FIXUP_CD),
2624 	SND_PCI_QUIRK(0x1462, 0xcc34, "MSI Godlike X570", ALC1220_FIXUP_GB_DUAL_CODECS),
2625 	SND_PCI_QUIRK(0x1462, 0xda57, "MSI Z270-Gaming", ALC1220_FIXUP_GB_DUAL_CODECS),
2626 	SND_PCI_QUIRK_VENDOR(0x1462, "MSI", ALC882_FIXUP_GPIO3),
2627 	SND_PCI_QUIRK(0x147b, 0x107a, "Abit AW9D-MAX", ALC882_FIXUP_ABIT_AW9D_MAX),
2628 	SND_PCI_QUIRK(0x1558, 0x3702, "Clevo X370SN[VW]", ALC1220_FIXUP_CLEVO_PB51ED_PINS),
2629 	SND_PCI_QUIRK(0x1558, 0x50d3, "Clevo PC50[ER][CDF]", ALC1220_FIXUP_CLEVO_PB51ED_PINS),
2630 	SND_PCI_QUIRK(0x1558, 0x65d1, "Clevo PB51[ER][CDF]", ALC1220_FIXUP_CLEVO_PB51ED_PINS),
2631 	SND_PCI_QUIRK(0x1558, 0x65d2, "Clevo PB51R[CDF]", ALC1220_FIXUP_CLEVO_PB51ED_PINS),
2632 	SND_PCI_QUIRK(0x1558, 0x65e1, "Clevo PB51[ED][DF]", ALC1220_FIXUP_CLEVO_PB51ED_PINS),
2633 	SND_PCI_QUIRK(0x1558, 0x65e5, "Clevo PC50D[PRS](?:-D|-G)?", ALC1220_FIXUP_CLEVO_PB51ED_PINS),
2634 	SND_PCI_QUIRK(0x1558, 0x65f1, "Clevo PC50HS", ALC1220_FIXUP_CLEVO_PB51ED_PINS),
2635 	SND_PCI_QUIRK(0x1558, 0x65f5, "Clevo PD50PN[NRT]", ALC1220_FIXUP_CLEVO_PB51ED_PINS),
2636 	SND_PCI_QUIRK(0x1558, 0x66a2, "Clevo PE60RNE", ALC1220_FIXUP_CLEVO_PB51ED_PINS),
2637 	SND_PCI_QUIRK(0x1558, 0x67d1, "Clevo PB71[ER][CDF]", ALC1220_FIXUP_CLEVO_PB51ED_PINS),
2638 	SND_PCI_QUIRK(0x1558, 0x67e1, "Clevo PB71[DE][CDF]", ALC1220_FIXUP_CLEVO_PB51ED_PINS),
2639 	SND_PCI_QUIRK(0x1558, 0x67e5, "Clevo PC70D[PRS](?:-D|-G)?", ALC1220_FIXUP_CLEVO_PB51ED_PINS),
2640 	SND_PCI_QUIRK(0x1558, 0x67f1, "Clevo PC70H[PRS]", ALC1220_FIXUP_CLEVO_PB51ED_PINS),
2641 	SND_PCI_QUIRK(0x1558, 0x67f5, "Clevo PD70PN[NRT]", ALC1220_FIXUP_CLEVO_PB51ED_PINS),
2642 	SND_PCI_QUIRK(0x1558, 0x70d1, "Clevo PC70[ER][CDF]", ALC1220_FIXUP_CLEVO_PB51ED_PINS),
2643 	SND_PCI_QUIRK(0x1558, 0x7714, "Clevo X170SM", ALC1220_FIXUP_CLEVO_PB51ED_PINS),
2644 	SND_PCI_QUIRK(0x1558, 0x7715, "Clevo X170KM-G", ALC1220_FIXUP_CLEVO_PB51ED),
2645 	SND_PCI_QUIRK(0x1558, 0x9501, "Clevo P950HR", ALC1220_FIXUP_CLEVO_P950),
2646 	SND_PCI_QUIRK(0x1558, 0x9506, "Clevo P955HQ", ALC1220_FIXUP_CLEVO_P950),
2647 	SND_PCI_QUIRK(0x1558, 0x950a, "Clevo P955H[PR]", ALC1220_FIXUP_CLEVO_P950),
2648 	SND_PCI_QUIRK(0x1558, 0x95e1, "Clevo P95xER", ALC1220_FIXUP_CLEVO_P950),
2649 	SND_PCI_QUIRK(0x1558, 0x95e2, "Clevo P950ER", ALC1220_FIXUP_CLEVO_P950),
2650 	SND_PCI_QUIRK(0x1558, 0x95e3, "Clevo P955[ER]T", ALC1220_FIXUP_CLEVO_P950),
2651 	SND_PCI_QUIRK(0x1558, 0x95e4, "Clevo P955ER", ALC1220_FIXUP_CLEVO_P950),
2652 	SND_PCI_QUIRK(0x1558, 0x95e5, "Clevo P955EE6", ALC1220_FIXUP_CLEVO_P950),
2653 	SND_PCI_QUIRK(0x1558, 0x95e6, "Clevo P950R[CDF]", ALC1220_FIXUP_CLEVO_P950),
2654 	SND_PCI_QUIRK(0x1558, 0x96e1, "Clevo P960[ER][CDFN]-K", ALC1220_FIXUP_CLEVO_P950),
2655 	SND_PCI_QUIRK(0x1558, 0x97e1, "Clevo P970[ER][CDFN]", ALC1220_FIXUP_CLEVO_P950),
2656 	SND_PCI_QUIRK(0x1558, 0x97e2, "Clevo P970RC-M", ALC1220_FIXUP_CLEVO_P950),
2657 	SND_PCI_QUIRK(0x1558, 0xd502, "Clevo PD50SNE", ALC1220_FIXUP_CLEVO_PB51ED_PINS),
2658 	SND_PCI_QUIRK_VENDOR(0x1558, "Clevo laptop", ALC882_FIXUP_EAPD),
2659 	SND_PCI_QUIRK(0x161f, 0x2054, "Medion laptop", ALC883_FIXUP_EAPD),
2660 	SND_PCI_QUIRK(0x17aa, 0x3a0d, "Lenovo Y530", ALC882_FIXUP_LENOVO_Y530),
2661 	SND_PCI_QUIRK(0x8086, 0x0022, "DX58SO", ALC889_FIXUP_COEF),
2662 	{}
2663 };
2664 
2665 static const struct hda_model_fixup alc882_fixup_models[] = {
2666 	{.id = ALC882_FIXUP_ABIT_AW9D_MAX, .name = "abit-aw9d"},
2667 	{.id = ALC882_FIXUP_LENOVO_Y530, .name = "lenovo-y530"},
2668 	{.id = ALC882_FIXUP_ACER_ASPIRE_7736, .name = "acer-aspire-7736"},
2669 	{.id = ALC882_FIXUP_ASUS_W90V, .name = "asus-w90v"},
2670 	{.id = ALC889_FIXUP_CD, .name = "cd"},
2671 	{.id = ALC889_FIXUP_FRONT_HP_NO_PRESENCE, .name = "no-front-hp"},
2672 	{.id = ALC889_FIXUP_VAIO_TT, .name = "vaio-tt"},
2673 	{.id = ALC888_FIXUP_EEE1601, .name = "eee1601"},
2674 	{.id = ALC882_FIXUP_EAPD, .name = "alc882-eapd"},
2675 	{.id = ALC883_FIXUP_EAPD, .name = "alc883-eapd"},
2676 	{.id = ALC882_FIXUP_GPIO1, .name = "gpio1"},
2677 	{.id = ALC882_FIXUP_GPIO2, .name = "gpio2"},
2678 	{.id = ALC882_FIXUP_GPIO3, .name = "gpio3"},
2679 	{.id = ALC889_FIXUP_COEF, .name = "alc889-coef"},
2680 	{.id = ALC882_FIXUP_ASUS_W2JC, .name = "asus-w2jc"},
2681 	{.id = ALC882_FIXUP_ACER_ASPIRE_4930G, .name = "acer-aspire-4930g"},
2682 	{.id = ALC882_FIXUP_ACER_ASPIRE_8930G, .name = "acer-aspire-8930g"},
2683 	{.id = ALC883_FIXUP_ACER_EAPD, .name = "acer-aspire"},
2684 	{.id = ALC885_FIXUP_MACPRO_GPIO, .name = "macpro-gpio"},
2685 	{.id = ALC889_FIXUP_DAC_ROUTE, .name = "dac-route"},
2686 	{.id = ALC889_FIXUP_MBP_VREF, .name = "mbp-vref"},
2687 	{.id = ALC889_FIXUP_IMAC91_VREF, .name = "imac91-vref"},
2688 	{.id = ALC889_FIXUP_MBA11_VREF, .name = "mba11-vref"},
2689 	{.id = ALC889_FIXUP_MBA21_VREF, .name = "mba21-vref"},
2690 	{.id = ALC889_FIXUP_MP11_VREF, .name = "mp11-vref"},
2691 	{.id = ALC889_FIXUP_MP41_VREF, .name = "mp41-vref"},
2692 	{.id = ALC882_FIXUP_INV_DMIC, .name = "inv-dmic"},
2693 	{.id = ALC882_FIXUP_NO_PRIMARY_HP, .name = "no-primary-hp"},
2694 	{.id = ALC887_FIXUP_ASUS_BASS, .name = "asus-bass"},
2695 	{.id = ALC1220_FIXUP_GB_DUAL_CODECS, .name = "dual-codecs"},
2696 	{.id = ALC1220_FIXUP_GB_X570, .name = "gb-x570"},
2697 	{.id = ALC1220_FIXUP_CLEVO_P950, .name = "clevo-p950"},
2698 	{}
2699 };
2700 
2701 static const struct snd_hda_pin_quirk alc882_pin_fixup_tbl[] = {
2702 	SND_HDA_PIN_QUIRK(0x10ec1220, 0x1043, "ASUS", ALC1220_FIXUP_CLEVO_P950,
2703 		{0x14, 0x01014010},
2704 		{0x15, 0x01011012},
2705 		{0x16, 0x01016011},
2706 		{0x18, 0x01a19040},
2707 		{0x19, 0x02a19050},
2708 		{0x1a, 0x0181304f},
2709 		{0x1b, 0x0221401f},
2710 		{0x1e, 0x01456130}),
2711 	SND_HDA_PIN_QUIRK(0x10ec1220, 0x1462, "MS-7C35", ALC1220_FIXUP_CLEVO_P950,
2712 		{0x14, 0x01015010},
2713 		{0x15, 0x01011012},
2714 		{0x16, 0x01011011},
2715 		{0x18, 0x01a11040},
2716 		{0x19, 0x02a19050},
2717 		{0x1a, 0x0181104f},
2718 		{0x1b, 0x0221401f},
2719 		{0x1e, 0x01451130}),
2720 	{}
2721 };
2722 
2723 /*
2724  * BIOS auto configuration
2725  */
2726 /* almost identical with ALC880 parser... */
alc882_parse_auto_config(struct hda_codec * codec)2727 static int alc882_parse_auto_config(struct hda_codec *codec)
2728 {
2729 	static const hda_nid_t alc882_ignore[] = { 0x1d, 0 };
2730 	static const hda_nid_t alc882_ssids[] = { 0x15, 0x1b, 0x14, 0 };
2731 	return alc_parse_auto_config(codec, alc882_ignore, alc882_ssids);
2732 }
2733 
2734 /*
2735  */
patch_alc882(struct hda_codec * codec)2736 static int patch_alc882(struct hda_codec *codec)
2737 {
2738 	struct alc_spec *spec;
2739 	int err;
2740 
2741 	err = alc_alloc_spec(codec, 0x0b);
2742 	if (err < 0)
2743 		return err;
2744 
2745 	spec = codec->spec;
2746 
2747 	switch (codec->core.vendor_id) {
2748 	case 0x10ec0882:
2749 	case 0x10ec0885:
2750 	case 0x10ec0900:
2751 	case 0x10ec0b00:
2752 	case 0x10ec1220:
2753 		break;
2754 	default:
2755 		/* ALC883 and variants */
2756 		alc_fix_pll_init(codec, 0x20, 0x0a, 10);
2757 		break;
2758 	}
2759 
2760 	alc_pre_init(codec);
2761 
2762 	snd_hda_pick_fixup(codec, alc882_fixup_models, alc882_fixup_tbl,
2763 		       alc882_fixups);
2764 	snd_hda_pick_pin_fixup(codec, alc882_pin_fixup_tbl, alc882_fixups, true);
2765 	snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE);
2766 
2767 	alc_auto_parse_customize_define(codec);
2768 
2769 	if (has_cdefine_beep(codec))
2770 		spec->gen.beep_nid = 0x01;
2771 
2772 	/* automatic parse from the BIOS config */
2773 	err = alc882_parse_auto_config(codec);
2774 	if (err < 0)
2775 		goto error;
2776 
2777 	if (!spec->gen.no_analog && spec->gen.beep_nid) {
2778 		err = set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
2779 		if (err < 0)
2780 			goto error;
2781 	}
2782 
2783 	snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE);
2784 
2785 	return 0;
2786 
2787  error:
2788 	alc_free(codec);
2789 	return err;
2790 }
2791 
2792 
2793 /*
2794  * ALC262 support
2795  */
alc262_parse_auto_config(struct hda_codec * codec)2796 static int alc262_parse_auto_config(struct hda_codec *codec)
2797 {
2798 	static const hda_nid_t alc262_ignore[] = { 0x1d, 0 };
2799 	static const hda_nid_t alc262_ssids[] = { 0x15, 0x1b, 0x14, 0 };
2800 	return alc_parse_auto_config(codec, alc262_ignore, alc262_ssids);
2801 }
2802 
2803 /*
2804  * Pin config fixes
2805  */
2806 enum {
2807 	ALC262_FIXUP_FSC_H270,
2808 	ALC262_FIXUP_FSC_S7110,
2809 	ALC262_FIXUP_HP_Z200,
2810 	ALC262_FIXUP_TYAN,
2811 	ALC262_FIXUP_LENOVO_3000,
2812 	ALC262_FIXUP_BENQ,
2813 	ALC262_FIXUP_BENQ_T31,
2814 	ALC262_FIXUP_INV_DMIC,
2815 	ALC262_FIXUP_INTEL_BAYLEYBAY,
2816 };
2817 
2818 static const struct hda_fixup alc262_fixups[] = {
2819 	[ALC262_FIXUP_FSC_H270] = {
2820 		.type = HDA_FIXUP_PINS,
2821 		.v.pins = (const struct hda_pintbl[]) {
2822 			{ 0x14, 0x99130110 }, /* speaker */
2823 			{ 0x15, 0x0221142f }, /* front HP */
2824 			{ 0x1b, 0x0121141f }, /* rear HP */
2825 			{ }
2826 		}
2827 	},
2828 	[ALC262_FIXUP_FSC_S7110] = {
2829 		.type = HDA_FIXUP_PINS,
2830 		.v.pins = (const struct hda_pintbl[]) {
2831 			{ 0x15, 0x90170110 }, /* speaker */
2832 			{ }
2833 		},
2834 		.chained = true,
2835 		.chain_id = ALC262_FIXUP_BENQ,
2836 	},
2837 	[ALC262_FIXUP_HP_Z200] = {
2838 		.type = HDA_FIXUP_PINS,
2839 		.v.pins = (const struct hda_pintbl[]) {
2840 			{ 0x16, 0x99130120 }, /* internal speaker */
2841 			{ }
2842 		}
2843 	},
2844 	[ALC262_FIXUP_TYAN] = {
2845 		.type = HDA_FIXUP_PINS,
2846 		.v.pins = (const struct hda_pintbl[]) {
2847 			{ 0x14, 0x1993e1f0 }, /* int AUX */
2848 			{ }
2849 		}
2850 	},
2851 	[ALC262_FIXUP_LENOVO_3000] = {
2852 		.type = HDA_FIXUP_PINCTLS,
2853 		.v.pins = (const struct hda_pintbl[]) {
2854 			{ 0x19, PIN_VREF50 },
2855 			{}
2856 		},
2857 		.chained = true,
2858 		.chain_id = ALC262_FIXUP_BENQ,
2859 	},
2860 	[ALC262_FIXUP_BENQ] = {
2861 		.type = HDA_FIXUP_VERBS,
2862 		.v.verbs = (const struct hda_verb[]) {
2863 			{ 0x20, AC_VERB_SET_COEF_INDEX, 0x07 },
2864 			{ 0x20, AC_VERB_SET_PROC_COEF, 0x3070 },
2865 			{}
2866 		}
2867 	},
2868 	[ALC262_FIXUP_BENQ_T31] = {
2869 		.type = HDA_FIXUP_VERBS,
2870 		.v.verbs = (const struct hda_verb[]) {
2871 			{ 0x20, AC_VERB_SET_COEF_INDEX, 0x07 },
2872 			{ 0x20, AC_VERB_SET_PROC_COEF, 0x3050 },
2873 			{}
2874 		}
2875 	},
2876 	[ALC262_FIXUP_INV_DMIC] = {
2877 		.type = HDA_FIXUP_FUNC,
2878 		.v.func = alc_fixup_inv_dmic,
2879 	},
2880 	[ALC262_FIXUP_INTEL_BAYLEYBAY] = {
2881 		.type = HDA_FIXUP_FUNC,
2882 		.v.func = alc_fixup_no_depop_delay,
2883 	},
2884 };
2885 
2886 static const struct snd_pci_quirk alc262_fixup_tbl[] = {
2887 	SND_PCI_QUIRK(0x103c, 0x170b, "HP Z200", ALC262_FIXUP_HP_Z200),
2888 	SND_PCI_QUIRK(0x10cf, 0x1397, "Fujitsu Lifebook S7110", ALC262_FIXUP_FSC_S7110),
2889 	SND_PCI_QUIRK(0x10cf, 0x142d, "Fujitsu Lifebook E8410", ALC262_FIXUP_BENQ),
2890 	SND_PCI_QUIRK(0x10f1, 0x2915, "Tyan Thunder n6650W", ALC262_FIXUP_TYAN),
2891 	SND_PCI_QUIRK(0x1734, 0x1141, "FSC ESPRIMO U9210", ALC262_FIXUP_FSC_H270),
2892 	SND_PCI_QUIRK(0x1734, 0x1147, "FSC Celsius H270", ALC262_FIXUP_FSC_H270),
2893 	SND_PCI_QUIRK(0x17aa, 0x384e, "Lenovo 3000", ALC262_FIXUP_LENOVO_3000),
2894 	SND_PCI_QUIRK(0x17ff, 0x0560, "Benq ED8", ALC262_FIXUP_BENQ),
2895 	SND_PCI_QUIRK(0x17ff, 0x058d, "Benq T31-16", ALC262_FIXUP_BENQ_T31),
2896 	SND_PCI_QUIRK(0x8086, 0x7270, "BayleyBay", ALC262_FIXUP_INTEL_BAYLEYBAY),
2897 	{}
2898 };
2899 
2900 static const struct hda_model_fixup alc262_fixup_models[] = {
2901 	{.id = ALC262_FIXUP_INV_DMIC, .name = "inv-dmic"},
2902 	{.id = ALC262_FIXUP_FSC_H270, .name = "fsc-h270"},
2903 	{.id = ALC262_FIXUP_FSC_S7110, .name = "fsc-s7110"},
2904 	{.id = ALC262_FIXUP_HP_Z200, .name = "hp-z200"},
2905 	{.id = ALC262_FIXUP_TYAN, .name = "tyan"},
2906 	{.id = ALC262_FIXUP_LENOVO_3000, .name = "lenovo-3000"},
2907 	{.id = ALC262_FIXUP_BENQ, .name = "benq"},
2908 	{.id = ALC262_FIXUP_BENQ_T31, .name = "benq-t31"},
2909 	{.id = ALC262_FIXUP_INTEL_BAYLEYBAY, .name = "bayleybay"},
2910 	{}
2911 };
2912 
2913 /*
2914  */
patch_alc262(struct hda_codec * codec)2915 static int patch_alc262(struct hda_codec *codec)
2916 {
2917 	struct alc_spec *spec;
2918 	int err;
2919 
2920 	err = alc_alloc_spec(codec, 0x0b);
2921 	if (err < 0)
2922 		return err;
2923 
2924 	spec = codec->spec;
2925 	spec->gen.shared_mic_vref_pin = 0x18;
2926 
2927 	spec->shutup = alc_eapd_shutup;
2928 
2929 #if 0
2930 	/* pshou 07/11/05  set a zero PCM sample to DAC when FIFO is
2931 	 * under-run
2932 	 */
2933 	alc_update_coefex_idx(codec, 0x1a, 7, 0, 0x80);
2934 #endif
2935 	alc_fix_pll_init(codec, 0x20, 0x0a, 10);
2936 
2937 	alc_pre_init(codec);
2938 
2939 	snd_hda_pick_fixup(codec, alc262_fixup_models, alc262_fixup_tbl,
2940 		       alc262_fixups);
2941 	snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE);
2942 
2943 	alc_auto_parse_customize_define(codec);
2944 
2945 	if (has_cdefine_beep(codec))
2946 		spec->gen.beep_nid = 0x01;
2947 
2948 	/* automatic parse from the BIOS config */
2949 	err = alc262_parse_auto_config(codec);
2950 	if (err < 0)
2951 		goto error;
2952 
2953 	if (!spec->gen.no_analog && spec->gen.beep_nid) {
2954 		err = set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
2955 		if (err < 0)
2956 			goto error;
2957 	}
2958 
2959 	snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE);
2960 
2961 	return 0;
2962 
2963  error:
2964 	alc_free(codec);
2965 	return err;
2966 }
2967 
2968 /*
2969  *  ALC268
2970  */
2971 /* bind Beep switches of both NID 0x0f and 0x10 */
alc268_beep_switch_put(struct snd_kcontrol * kcontrol,struct snd_ctl_elem_value * ucontrol)2972 static int alc268_beep_switch_put(struct snd_kcontrol *kcontrol,
2973 				  struct snd_ctl_elem_value *ucontrol)
2974 {
2975 	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2976 	unsigned long pval;
2977 	int err;
2978 
2979 	mutex_lock(&codec->control_mutex);
2980 	pval = kcontrol->private_value;
2981 	kcontrol->private_value = (pval & ~0xff) | 0x0f;
2982 	err = snd_hda_mixer_amp_switch_put(kcontrol, ucontrol);
2983 	if (err >= 0) {
2984 		kcontrol->private_value = (pval & ~0xff) | 0x10;
2985 		err = snd_hda_mixer_amp_switch_put(kcontrol, ucontrol);
2986 	}
2987 	kcontrol->private_value = pval;
2988 	mutex_unlock(&codec->control_mutex);
2989 	return err;
2990 }
2991 
2992 static const struct snd_kcontrol_new alc268_beep_mixer[] = {
2993 	HDA_CODEC_VOLUME("Beep Playback Volume", 0x1d, 0x0, HDA_INPUT),
2994 	{
2995 		.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2996 		.name = "Beep Playback Switch",
2997 		.subdevice = HDA_SUBDEV_AMP_FLAG,
2998 		.info = snd_hda_mixer_amp_switch_info,
2999 		.get = snd_hda_mixer_amp_switch_get,
3000 		.put = alc268_beep_switch_put,
3001 		.private_value = HDA_COMPOSE_AMP_VAL(0x0f, 3, 1, HDA_INPUT)
3002 	},
3003 };
3004 
3005 /* set PCBEEP vol = 0, mute connections */
3006 static const struct hda_verb alc268_beep_init_verbs[] = {
3007 	{0x1d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
3008 	{0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
3009 	{0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
3010 	{ }
3011 };
3012 
3013 enum {
3014 	ALC268_FIXUP_INV_DMIC,
3015 	ALC268_FIXUP_HP_EAPD,
3016 	ALC268_FIXUP_SPDIF,
3017 };
3018 
3019 static const struct hda_fixup alc268_fixups[] = {
3020 	[ALC268_FIXUP_INV_DMIC] = {
3021 		.type = HDA_FIXUP_FUNC,
3022 		.v.func = alc_fixup_inv_dmic,
3023 	},
3024 	[ALC268_FIXUP_HP_EAPD] = {
3025 		.type = HDA_FIXUP_VERBS,
3026 		.v.verbs = (const struct hda_verb[]) {
3027 			{0x15, AC_VERB_SET_EAPD_BTLENABLE, 0},
3028 			{}
3029 		}
3030 	},
3031 	[ALC268_FIXUP_SPDIF] = {
3032 		.type = HDA_FIXUP_PINS,
3033 		.v.pins = (const struct hda_pintbl[]) {
3034 			{ 0x1e, 0x014b1180 }, /* enable SPDIF out */
3035 			{}
3036 		}
3037 	},
3038 };
3039 
3040 static const struct hda_model_fixup alc268_fixup_models[] = {
3041 	{.id = ALC268_FIXUP_INV_DMIC, .name = "inv-dmic"},
3042 	{.id = ALC268_FIXUP_HP_EAPD, .name = "hp-eapd"},
3043 	{.id = ALC268_FIXUP_SPDIF, .name = "spdif"},
3044 	{}
3045 };
3046 
3047 static const struct snd_pci_quirk alc268_fixup_tbl[] = {
3048 	SND_PCI_QUIRK(0x1025, 0x0139, "Acer TravelMate 6293", ALC268_FIXUP_SPDIF),
3049 	SND_PCI_QUIRK(0x1025, 0x015b, "Acer AOA 150 (ZG5)", ALC268_FIXUP_INV_DMIC),
3050 	/* below is codec SSID since multiple Toshiba laptops have the
3051 	 * same PCI SSID 1179:ff00
3052 	 */
3053 	SND_PCI_QUIRK(0x1179, 0xff06, "Toshiba P200", ALC268_FIXUP_HP_EAPD),
3054 	{}
3055 };
3056 
3057 /*
3058  * BIOS auto configuration
3059  */
alc268_parse_auto_config(struct hda_codec * codec)3060 static int alc268_parse_auto_config(struct hda_codec *codec)
3061 {
3062 	static const hda_nid_t alc268_ssids[] = { 0x15, 0x1b, 0x14, 0 };
3063 	return alc_parse_auto_config(codec, NULL, alc268_ssids);
3064 }
3065 
3066 /*
3067  */
patch_alc268(struct hda_codec * codec)3068 static int patch_alc268(struct hda_codec *codec)
3069 {
3070 	struct alc_spec *spec;
3071 	int i, err;
3072 
3073 	/* ALC268 has no aa-loopback mixer */
3074 	err = alc_alloc_spec(codec, 0);
3075 	if (err < 0)
3076 		return err;
3077 
3078 	spec = codec->spec;
3079 	if (has_cdefine_beep(codec))
3080 		spec->gen.beep_nid = 0x01;
3081 
3082 	spec->shutup = alc_eapd_shutup;
3083 
3084 	alc_pre_init(codec);
3085 
3086 	snd_hda_pick_fixup(codec, alc268_fixup_models, alc268_fixup_tbl, alc268_fixups);
3087 	snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE);
3088 
3089 	/* automatic parse from the BIOS config */
3090 	err = alc268_parse_auto_config(codec);
3091 	if (err < 0)
3092 		goto error;
3093 
3094 	if (err > 0 && !spec->gen.no_analog &&
3095 	    spec->gen.autocfg.speaker_pins[0] != 0x1d) {
3096 		for (i = 0; i < ARRAY_SIZE(alc268_beep_mixer); i++) {
3097 			if (!snd_hda_gen_add_kctl(&spec->gen, NULL,
3098 						  &alc268_beep_mixer[i])) {
3099 				err = -ENOMEM;
3100 				goto error;
3101 			}
3102 		}
3103 		snd_hda_add_verbs(codec, alc268_beep_init_verbs);
3104 		if (!query_amp_caps(codec, 0x1d, HDA_INPUT))
3105 			/* override the amp caps for beep generator */
3106 			snd_hda_override_amp_caps(codec, 0x1d, HDA_INPUT,
3107 					  (0x0c << AC_AMPCAP_OFFSET_SHIFT) |
3108 					  (0x0c << AC_AMPCAP_NUM_STEPS_SHIFT) |
3109 					  (0x07 << AC_AMPCAP_STEP_SIZE_SHIFT) |
3110 					  (0 << AC_AMPCAP_MUTE_SHIFT));
3111 	}
3112 
3113 	snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE);
3114 
3115 	return 0;
3116 
3117  error:
3118 	alc_free(codec);
3119 	return err;
3120 }
3121 
3122 /*
3123  * ALC269
3124  */
3125 
3126 static const struct hda_pcm_stream alc269_44k_pcm_analog_playback = {
3127 	.rates = SNDRV_PCM_RATE_44100, /* fixed rate */
3128 };
3129 
3130 static const struct hda_pcm_stream alc269_44k_pcm_analog_capture = {
3131 	.rates = SNDRV_PCM_RATE_44100, /* fixed rate */
3132 };
3133 
3134 /* different alc269-variants */
3135 enum {
3136 	ALC269_TYPE_ALC269VA,
3137 	ALC269_TYPE_ALC269VB,
3138 	ALC269_TYPE_ALC269VC,
3139 	ALC269_TYPE_ALC269VD,
3140 	ALC269_TYPE_ALC280,
3141 	ALC269_TYPE_ALC282,
3142 	ALC269_TYPE_ALC283,
3143 	ALC269_TYPE_ALC284,
3144 	ALC269_TYPE_ALC293,
3145 	ALC269_TYPE_ALC286,
3146 	ALC269_TYPE_ALC298,
3147 	ALC269_TYPE_ALC255,
3148 	ALC269_TYPE_ALC256,
3149 	ALC269_TYPE_ALC257,
3150 	ALC269_TYPE_ALC215,
3151 	ALC269_TYPE_ALC225,
3152 	ALC269_TYPE_ALC245,
3153 	ALC269_TYPE_ALC287,
3154 	ALC269_TYPE_ALC294,
3155 	ALC269_TYPE_ALC300,
3156 	ALC269_TYPE_ALC623,
3157 	ALC269_TYPE_ALC700,
3158 };
3159 
3160 /*
3161  * BIOS auto configuration
3162  */
alc269_parse_auto_config(struct hda_codec * codec)3163 static int alc269_parse_auto_config(struct hda_codec *codec)
3164 {
3165 	static const hda_nid_t alc269_ignore[] = { 0x1d, 0 };
3166 	static const hda_nid_t alc269_ssids[] = { 0, 0x1b, 0x14, 0x21 };
3167 	static const hda_nid_t alc269va_ssids[] = { 0x15, 0x1b, 0x14, 0 };
3168 	struct alc_spec *spec = codec->spec;
3169 	const hda_nid_t *ssids;
3170 
3171 	switch (spec->codec_variant) {
3172 	case ALC269_TYPE_ALC269VA:
3173 	case ALC269_TYPE_ALC269VC:
3174 	case ALC269_TYPE_ALC280:
3175 	case ALC269_TYPE_ALC284:
3176 	case ALC269_TYPE_ALC293:
3177 		ssids = alc269va_ssids;
3178 		break;
3179 	case ALC269_TYPE_ALC269VB:
3180 	case ALC269_TYPE_ALC269VD:
3181 	case ALC269_TYPE_ALC282:
3182 	case ALC269_TYPE_ALC283:
3183 	case ALC269_TYPE_ALC286:
3184 	case ALC269_TYPE_ALC298:
3185 	case ALC269_TYPE_ALC255:
3186 	case ALC269_TYPE_ALC256:
3187 	case ALC269_TYPE_ALC257:
3188 	case ALC269_TYPE_ALC215:
3189 	case ALC269_TYPE_ALC225:
3190 	case ALC269_TYPE_ALC245:
3191 	case ALC269_TYPE_ALC287:
3192 	case ALC269_TYPE_ALC294:
3193 	case ALC269_TYPE_ALC300:
3194 	case ALC269_TYPE_ALC623:
3195 	case ALC269_TYPE_ALC700:
3196 		ssids = alc269_ssids;
3197 		break;
3198 	default:
3199 		ssids = alc269_ssids;
3200 		break;
3201 	}
3202 
3203 	return alc_parse_auto_config(codec, alc269_ignore, ssids);
3204 }
3205 
3206 static const struct hda_jack_keymap alc_headset_btn_keymap[] = {
3207 	{ SND_JACK_BTN_0, KEY_PLAYPAUSE },
3208 	{ SND_JACK_BTN_1, KEY_VOICECOMMAND },
3209 	{ SND_JACK_BTN_2, KEY_VOLUMEUP },
3210 	{ SND_JACK_BTN_3, KEY_VOLUMEDOWN },
3211 	{}
3212 };
3213 
alc_headset_btn_callback(struct hda_codec * codec,struct hda_jack_callback * jack)3214 static void alc_headset_btn_callback(struct hda_codec *codec,
3215 				     struct hda_jack_callback *jack)
3216 {
3217 	int report = 0;
3218 
3219 	if (jack->unsol_res & (7 << 13))
3220 		report |= SND_JACK_BTN_0;
3221 
3222 	if (jack->unsol_res  & (1 << 16 | 3 << 8))
3223 		report |= SND_JACK_BTN_1;
3224 
3225 	/* Volume up key */
3226 	if (jack->unsol_res & (7 << 23))
3227 		report |= SND_JACK_BTN_2;
3228 
3229 	/* Volume down key */
3230 	if (jack->unsol_res & (7 << 10))
3231 		report |= SND_JACK_BTN_3;
3232 
3233 	snd_hda_jack_set_button_state(codec, jack->nid, report);
3234 }
3235 
alc_disable_headset_jack_key(struct hda_codec * codec)3236 static void alc_disable_headset_jack_key(struct hda_codec *codec)
3237 {
3238 	struct alc_spec *spec = codec->spec;
3239 
3240 	if (!spec->has_hs_key)
3241 		return;
3242 
3243 	switch (codec->core.vendor_id) {
3244 	case 0x10ec0215:
3245 	case 0x10ec0225:
3246 	case 0x10ec0285:
3247 	case 0x10ec0287:
3248 	case 0x10ec0295:
3249 	case 0x10ec0289:
3250 	case 0x10ec0299:
3251 		alc_write_coef_idx(codec, 0x48, 0x0);
3252 		alc_update_coef_idx(codec, 0x49, 0x0045, 0x0);
3253 		alc_update_coef_idx(codec, 0x44, 0x0045 << 8, 0x0);
3254 		break;
3255 	case 0x10ec0230:
3256 	case 0x10ec0236:
3257 	case 0x10ec0256:
3258 	case 0x19e58326:
3259 		alc_write_coef_idx(codec, 0x48, 0x0);
3260 		alc_update_coef_idx(codec, 0x49, 0x0045, 0x0);
3261 		break;
3262 	}
3263 }
3264 
alc_enable_headset_jack_key(struct hda_codec * codec)3265 static void alc_enable_headset_jack_key(struct hda_codec *codec)
3266 {
3267 	struct alc_spec *spec = codec->spec;
3268 
3269 	if (!spec->has_hs_key)
3270 		return;
3271 
3272 	switch (codec->core.vendor_id) {
3273 	case 0x10ec0215:
3274 	case 0x10ec0225:
3275 	case 0x10ec0285:
3276 	case 0x10ec0287:
3277 	case 0x10ec0295:
3278 	case 0x10ec0289:
3279 	case 0x10ec0299:
3280 		alc_write_coef_idx(codec, 0x48, 0xd011);
3281 		alc_update_coef_idx(codec, 0x49, 0x007f, 0x0045);
3282 		alc_update_coef_idx(codec, 0x44, 0x007f << 8, 0x0045 << 8);
3283 		break;
3284 	case 0x10ec0230:
3285 	case 0x10ec0236:
3286 	case 0x10ec0256:
3287 	case 0x19e58326:
3288 		alc_write_coef_idx(codec, 0x48, 0xd011);
3289 		alc_update_coef_idx(codec, 0x49, 0x007f, 0x0045);
3290 		break;
3291 	}
3292 }
3293 
alc_fixup_headset_jack(struct hda_codec * codec,const struct hda_fixup * fix,int action)3294 static void alc_fixup_headset_jack(struct hda_codec *codec,
3295 				    const struct hda_fixup *fix, int action)
3296 {
3297 	struct alc_spec *spec = codec->spec;
3298 	hda_nid_t hp_pin;
3299 
3300 	switch (action) {
3301 	case HDA_FIXUP_ACT_PRE_PROBE:
3302 		spec->has_hs_key = 1;
3303 		snd_hda_jack_detect_enable_callback(codec, 0x55,
3304 						    alc_headset_btn_callback);
3305 		break;
3306 	case HDA_FIXUP_ACT_BUILD:
3307 		hp_pin = alc_get_hp_pin(spec);
3308 		if (!hp_pin || snd_hda_jack_bind_keymap(codec, 0x55,
3309 							alc_headset_btn_keymap,
3310 							hp_pin))
3311 			snd_hda_jack_add_kctl(codec, 0x55, "Headset Jack",
3312 					      false, SND_JACK_HEADSET,
3313 					      alc_headset_btn_keymap);
3314 
3315 		alc_enable_headset_jack_key(codec);
3316 		break;
3317 	}
3318 }
3319 
alc269vb_toggle_power_output(struct hda_codec * codec,int power_up)3320 static void alc269vb_toggle_power_output(struct hda_codec *codec, int power_up)
3321 {
3322 	alc_update_coef_idx(codec, 0x04, 1 << 11, power_up ? (1 << 11) : 0);
3323 }
3324 
alc269_shutup(struct hda_codec * codec)3325 static void alc269_shutup(struct hda_codec *codec)
3326 {
3327 	struct alc_spec *spec = codec->spec;
3328 
3329 	if (spec->codec_variant == ALC269_TYPE_ALC269VB)
3330 		alc269vb_toggle_power_output(codec, 0);
3331 	if (spec->codec_variant == ALC269_TYPE_ALC269VB &&
3332 			(alc_get_coef0(codec) & 0x00ff) == 0x018) {
3333 		msleep(150);
3334 	}
3335 	alc_shutup_pins(codec);
3336 }
3337 
3338 static const struct coef_fw alc282_coefs[] = {
3339 	WRITE_COEF(0x03, 0x0002), /* Power Down Control */
3340 	UPDATE_COEF(0x05, 0xff3f, 0x0700), /* FIFO and filter clock */
3341 	WRITE_COEF(0x07, 0x0200), /* DMIC control */
3342 	UPDATE_COEF(0x06, 0x00f0, 0), /* Analog clock */
3343 	UPDATE_COEF(0x08, 0xfffc, 0x0c2c), /* JD */
3344 	WRITE_COEF(0x0a, 0xcccc), /* JD offset1 */
3345 	WRITE_COEF(0x0b, 0xcccc), /* JD offset2 */
3346 	WRITE_COEF(0x0e, 0x6e00), /* LDO1/2/3, DAC/ADC */
3347 	UPDATE_COEF(0x0f, 0xf800, 0x1000), /* JD */
3348 	UPDATE_COEF(0x10, 0xfc00, 0x0c00), /* Capless */
3349 	WRITE_COEF(0x6f, 0x0), /* Class D test 4 */
3350 	UPDATE_COEF(0x0c, 0xfe00, 0), /* IO power down directly */
3351 	WRITE_COEF(0x34, 0xa0c0), /* ANC */
3352 	UPDATE_COEF(0x16, 0x0008, 0), /* AGC MUX */
3353 	UPDATE_COEF(0x1d, 0x00e0, 0), /* DAC simple content protection */
3354 	UPDATE_COEF(0x1f, 0x00e0, 0), /* ADC simple content protection */
3355 	WRITE_COEF(0x21, 0x8804), /* DAC ADC Zero Detection */
3356 	WRITE_COEF(0x63, 0x2902), /* PLL */
3357 	WRITE_COEF(0x68, 0xa080), /* capless control 2 */
3358 	WRITE_COEF(0x69, 0x3400), /* capless control 3 */
3359 	WRITE_COEF(0x6a, 0x2f3e), /* capless control 4 */
3360 	WRITE_COEF(0x6b, 0x0), /* capless control 5 */
3361 	UPDATE_COEF(0x6d, 0x0fff, 0x0900), /* class D test 2 */
3362 	WRITE_COEF(0x6e, 0x110a), /* class D test 3 */
3363 	UPDATE_COEF(0x70, 0x00f8, 0x00d8), /* class D test 5 */
3364 	WRITE_COEF(0x71, 0x0014), /* class D test 6 */
3365 	WRITE_COEF(0x72, 0xc2ba), /* classD OCP */
3366 	UPDATE_COEF(0x77, 0x0f80, 0), /* classD pure DC test */
3367 	WRITE_COEF(0x6c, 0xfc06), /* Class D amp control */
3368 	{}
3369 };
3370 
alc282_restore_default_value(struct hda_codec * codec)3371 static void alc282_restore_default_value(struct hda_codec *codec)
3372 {
3373 	alc_process_coef_fw(codec, alc282_coefs);
3374 }
3375 
alc282_init(struct hda_codec * codec)3376 static void alc282_init(struct hda_codec *codec)
3377 {
3378 	struct alc_spec *spec = codec->spec;
3379 	hda_nid_t hp_pin = alc_get_hp_pin(spec);
3380 	bool hp_pin_sense;
3381 	int coef78;
3382 
3383 	alc282_restore_default_value(codec);
3384 
3385 	if (!hp_pin)
3386 		return;
3387 	hp_pin_sense = snd_hda_jack_detect(codec, hp_pin);
3388 	coef78 = alc_read_coef_idx(codec, 0x78);
3389 
3390 	/* Index 0x78 Direct Drive HP AMP LPM Control 1 */
3391 	/* Headphone capless set to high power mode */
3392 	alc_write_coef_idx(codec, 0x78, 0x9004);
3393 
3394 	if (hp_pin_sense)
3395 		msleep(2);
3396 
3397 	snd_hda_codec_write(codec, hp_pin, 0,
3398 			    AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);
3399 
3400 	if (hp_pin_sense)
3401 		msleep(85);
3402 
3403 	snd_hda_codec_write(codec, hp_pin, 0,
3404 			    AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT);
3405 
3406 	if (hp_pin_sense)
3407 		msleep(100);
3408 
3409 	/* Headphone capless set to normal mode */
3410 	alc_write_coef_idx(codec, 0x78, coef78);
3411 }
3412 
alc282_shutup(struct hda_codec * codec)3413 static void alc282_shutup(struct hda_codec *codec)
3414 {
3415 	struct alc_spec *spec = codec->spec;
3416 	hda_nid_t hp_pin = alc_get_hp_pin(spec);
3417 	bool hp_pin_sense;
3418 	int coef78;
3419 
3420 	if (!hp_pin) {
3421 		alc269_shutup(codec);
3422 		return;
3423 	}
3424 
3425 	hp_pin_sense = snd_hda_jack_detect(codec, hp_pin);
3426 	coef78 = alc_read_coef_idx(codec, 0x78);
3427 	alc_write_coef_idx(codec, 0x78, 0x9004);
3428 
3429 	if (hp_pin_sense)
3430 		msleep(2);
3431 
3432 	snd_hda_codec_write(codec, hp_pin, 0,
3433 			    AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);
3434 
3435 	if (hp_pin_sense)
3436 		msleep(85);
3437 
3438 	if (!spec->no_shutup_pins)
3439 		snd_hda_codec_write(codec, hp_pin, 0,
3440 				    AC_VERB_SET_PIN_WIDGET_CONTROL, 0x0);
3441 
3442 	if (hp_pin_sense)
3443 		msleep(100);
3444 
3445 	alc_auto_setup_eapd(codec, false);
3446 	alc_shutup_pins(codec);
3447 	alc_write_coef_idx(codec, 0x78, coef78);
3448 }
3449 
3450 static const struct coef_fw alc283_coefs[] = {
3451 	WRITE_COEF(0x03, 0x0002), /* Power Down Control */
3452 	UPDATE_COEF(0x05, 0xff3f, 0x0700), /* FIFO and filter clock */
3453 	WRITE_COEF(0x07, 0x0200), /* DMIC control */
3454 	UPDATE_COEF(0x06, 0x00f0, 0), /* Analog clock */
3455 	UPDATE_COEF(0x08, 0xfffc, 0x0c2c), /* JD */
3456 	WRITE_COEF(0x0a, 0xcccc), /* JD offset1 */
3457 	WRITE_COEF(0x0b, 0xcccc), /* JD offset2 */
3458 	WRITE_COEF(0x0e, 0x6fc0), /* LDO1/2/3, DAC/ADC */
3459 	UPDATE_COEF(0x0f, 0xf800, 0x1000), /* JD */
3460 	UPDATE_COEF(0x10, 0xfc00, 0x0c00), /* Capless */
3461 	WRITE_COEF(0x3a, 0x0), /* Class D test 4 */
3462 	UPDATE_COEF(0x0c, 0xfe00, 0x0), /* IO power down directly */
3463 	WRITE_COEF(0x22, 0xa0c0), /* ANC */
3464 	UPDATE_COEFEX(0x53, 0x01, 0x000f, 0x0008), /* AGC MUX */
3465 	UPDATE_COEF(0x1d, 0x00e0, 0), /* DAC simple content protection */
3466 	UPDATE_COEF(0x1f, 0x00e0, 0), /* ADC simple content protection */
3467 	WRITE_COEF(0x21, 0x8804), /* DAC ADC Zero Detection */
3468 	WRITE_COEF(0x2e, 0x2902), /* PLL */
3469 	WRITE_COEF(0x33, 0xa080), /* capless control 2 */
3470 	WRITE_COEF(0x34, 0x3400), /* capless control 3 */
3471 	WRITE_COEF(0x35, 0x2f3e), /* capless control 4 */
3472 	WRITE_COEF(0x36, 0x0), /* capless control 5 */
3473 	UPDATE_COEF(0x38, 0x0fff, 0x0900), /* class D test 2 */
3474 	WRITE_COEF(0x39, 0x110a), /* class D test 3 */
3475 	UPDATE_COEF(0x3b, 0x00f8, 0x00d8), /* class D test 5 */
3476 	WRITE_COEF(0x3c, 0x0014), /* class D test 6 */
3477 	WRITE_COEF(0x3d, 0xc2ba), /* classD OCP */
3478 	UPDATE_COEF(0x42, 0x0f80, 0x0), /* classD pure DC test */
3479 	WRITE_COEF(0x49, 0x0), /* test mode */
3480 	UPDATE_COEF(0x40, 0xf800, 0x9800), /* Class D DC enable */
3481 	UPDATE_COEF(0x42, 0xf000, 0x2000), /* DC offset */
3482 	WRITE_COEF(0x37, 0xfc06), /* Class D amp control */
3483 	UPDATE_COEF(0x1b, 0x8000, 0), /* HP JD control */
3484 	{}
3485 };
3486 
alc283_restore_default_value(struct hda_codec * codec)3487 static void alc283_restore_default_value(struct hda_codec *codec)
3488 {
3489 	alc_process_coef_fw(codec, alc283_coefs);
3490 }
3491 
alc283_init(struct hda_codec * codec)3492 static void alc283_init(struct hda_codec *codec)
3493 {
3494 	struct alc_spec *spec = codec->spec;
3495 	hda_nid_t hp_pin = alc_get_hp_pin(spec);
3496 	bool hp_pin_sense;
3497 
3498 	alc283_restore_default_value(codec);
3499 
3500 	if (!hp_pin)
3501 		return;
3502 
3503 	msleep(30);
3504 	hp_pin_sense = snd_hda_jack_detect(codec, hp_pin);
3505 
3506 	/* Index 0x43 Direct Drive HP AMP LPM Control 1 */
3507 	/* Headphone capless set to high power mode */
3508 	alc_write_coef_idx(codec, 0x43, 0x9004);
3509 
3510 	snd_hda_codec_write(codec, hp_pin, 0,
3511 			    AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);
3512 
3513 	if (hp_pin_sense)
3514 		msleep(85);
3515 
3516 	snd_hda_codec_write(codec, hp_pin, 0,
3517 			    AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT);
3518 
3519 	if (hp_pin_sense)
3520 		msleep(85);
3521 	/* Index 0x46 Combo jack auto switch control 2 */
3522 	/* 3k pull low control for Headset jack. */
3523 	alc_update_coef_idx(codec, 0x46, 3 << 12, 0);
3524 	/* Headphone capless set to normal mode */
3525 	alc_write_coef_idx(codec, 0x43, 0x9614);
3526 }
3527 
alc283_shutup(struct hda_codec * codec)3528 static void alc283_shutup(struct hda_codec *codec)
3529 {
3530 	struct alc_spec *spec = codec->spec;
3531 	hda_nid_t hp_pin = alc_get_hp_pin(spec);
3532 	bool hp_pin_sense;
3533 
3534 	if (!hp_pin) {
3535 		alc269_shutup(codec);
3536 		return;
3537 	}
3538 
3539 	hp_pin_sense = snd_hda_jack_detect(codec, hp_pin);
3540 
3541 	alc_write_coef_idx(codec, 0x43, 0x9004);
3542 
3543 	/*depop hp during suspend*/
3544 	alc_write_coef_idx(codec, 0x06, 0x2100);
3545 
3546 	snd_hda_codec_write(codec, hp_pin, 0,
3547 			    AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);
3548 
3549 	if (hp_pin_sense)
3550 		msleep(100);
3551 
3552 	if (!spec->no_shutup_pins)
3553 		snd_hda_codec_write(codec, hp_pin, 0,
3554 				    AC_VERB_SET_PIN_WIDGET_CONTROL, 0x0);
3555 
3556 	alc_update_coef_idx(codec, 0x46, 0, 3 << 12);
3557 
3558 	if (hp_pin_sense)
3559 		msleep(100);
3560 	alc_auto_setup_eapd(codec, false);
3561 	alc_shutup_pins(codec);
3562 	alc_write_coef_idx(codec, 0x43, 0x9614);
3563 }
3564 
alc256_init(struct hda_codec * codec)3565 static void alc256_init(struct hda_codec *codec)
3566 {
3567 	struct alc_spec *spec = codec->spec;
3568 	hda_nid_t hp_pin = alc_get_hp_pin(spec);
3569 	bool hp_pin_sense;
3570 
3571 	if (spec->ultra_low_power) {
3572 		alc_update_coef_idx(codec, 0x03, 1<<1, 1<<1);
3573 		alc_update_coef_idx(codec, 0x08, 3<<2, 3<<2);
3574 		alc_update_coef_idx(codec, 0x08, 7<<4, 0);
3575 		alc_update_coef_idx(codec, 0x3b, 1<<15, 0);
3576 		alc_update_coef_idx(codec, 0x0e, 7<<6, 7<<6);
3577 		msleep(30);
3578 	}
3579 
3580 	if (!hp_pin)
3581 		hp_pin = 0x21;
3582 
3583 	msleep(30);
3584 
3585 	hp_pin_sense = snd_hda_jack_detect(codec, hp_pin);
3586 
3587 	if (hp_pin_sense)
3588 		msleep(2);
3589 
3590 	alc_update_coefex_idx(codec, 0x57, 0x04, 0x0007, 0x1); /* Low power */
3591 
3592 	snd_hda_codec_write(codec, hp_pin, 0,
3593 			    AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);
3594 
3595 	if (hp_pin_sense || spec->ultra_low_power)
3596 		msleep(85);
3597 
3598 	snd_hda_codec_write(codec, hp_pin, 0,
3599 			    AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT);
3600 
3601 	if (hp_pin_sense || spec->ultra_low_power)
3602 		msleep(100);
3603 
3604 	alc_update_coef_idx(codec, 0x46, 3 << 12, 0);
3605 	alc_update_coefex_idx(codec, 0x57, 0x04, 0x0007, 0x4); /* Hight power */
3606 	alc_update_coefex_idx(codec, 0x53, 0x02, 0x8000, 1 << 15); /* Clear bit */
3607 	alc_update_coefex_idx(codec, 0x53, 0x02, 0x8000, 0 << 15);
3608 	/*
3609 	 * Expose headphone mic (or possibly Line In on some machines) instead
3610 	 * of PC Beep on 1Ah, and disable 1Ah loopback for all outputs. See
3611 	 * Documentation/sound/hd-audio/realtek-pc-beep.rst for details of
3612 	 * this register.
3613 	 */
3614 	alc_write_coef_idx(codec, 0x36, 0x5757);
3615 }
3616 
alc256_shutup(struct hda_codec * codec)3617 static void alc256_shutup(struct hda_codec *codec)
3618 {
3619 	struct alc_spec *spec = codec->spec;
3620 	hda_nid_t hp_pin = alc_get_hp_pin(spec);
3621 	bool hp_pin_sense;
3622 
3623 	if (!hp_pin)
3624 		hp_pin = 0x21;
3625 
3626 	alc_update_coefex_idx(codec, 0x57, 0x04, 0x0007, 0x1); /* Low power */
3627 	hp_pin_sense = snd_hda_jack_detect(codec, hp_pin);
3628 
3629 	if (hp_pin_sense)
3630 		msleep(2);
3631 
3632 	snd_hda_codec_write(codec, hp_pin, 0,
3633 			    AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);
3634 
3635 	if (hp_pin_sense || spec->ultra_low_power)
3636 		msleep(85);
3637 
3638 	/* 3k pull low control for Headset jack. */
3639 	/* NOTE: call this before clearing the pin, otherwise codec stalls */
3640 	/* If disable 3k pulldown control for alc257, the Mic detection will not work correctly
3641 	 * when booting with headset plugged. So skip setting it for the codec alc257
3642 	 */
3643 	if (spec->en_3kpull_low)
3644 		alc_update_coef_idx(codec, 0x46, 0, 3 << 12);
3645 
3646 	if (!spec->no_shutup_pins)
3647 		snd_hda_codec_write(codec, hp_pin, 0,
3648 				    AC_VERB_SET_PIN_WIDGET_CONTROL, 0x0);
3649 
3650 	if (hp_pin_sense || spec->ultra_low_power)
3651 		msleep(100);
3652 
3653 	alc_auto_setup_eapd(codec, false);
3654 	alc_shutup_pins(codec);
3655 	if (spec->ultra_low_power) {
3656 		msleep(50);
3657 		alc_update_coef_idx(codec, 0x03, 1<<1, 0);
3658 		alc_update_coef_idx(codec, 0x08, 7<<4, 7<<4);
3659 		alc_update_coef_idx(codec, 0x08, 3<<2, 0);
3660 		alc_update_coef_idx(codec, 0x3b, 1<<15, 1<<15);
3661 		alc_update_coef_idx(codec, 0x0e, 7<<6, 0);
3662 		msleep(30);
3663 	}
3664 }
3665 
alc285_hp_init(struct hda_codec * codec)3666 static void alc285_hp_init(struct hda_codec *codec)
3667 {
3668 	struct alc_spec *spec = codec->spec;
3669 	hda_nid_t hp_pin = alc_get_hp_pin(spec);
3670 	int i, val;
3671 	int coef38, coef0d, coef36;
3672 
3673 	alc_update_coef_idx(codec, 0x4a, 1<<15, 1<<15); /* Reset HP JD */
3674 	coef38 = alc_read_coef_idx(codec, 0x38); /* Amp control */
3675 	coef0d = alc_read_coef_idx(codec, 0x0d); /* Digital Misc control */
3676 	coef36 = alc_read_coef_idx(codec, 0x36); /* Passthrough Control */
3677 	alc_update_coef_idx(codec, 0x38, 1<<4, 0x0);
3678 	alc_update_coef_idx(codec, 0x0d, 0x110, 0x0);
3679 
3680 	alc_update_coef_idx(codec, 0x67, 0xf000, 0x3000);
3681 
3682 	if (hp_pin)
3683 		snd_hda_codec_write(codec, hp_pin, 0,
3684 			    AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);
3685 
3686 	msleep(130);
3687 	alc_update_coef_idx(codec, 0x36, 1<<14, 1<<14);
3688 	alc_update_coef_idx(codec, 0x36, 1<<13, 0x0);
3689 
3690 	if (hp_pin)
3691 		snd_hda_codec_write(codec, hp_pin, 0,
3692 			    AC_VERB_SET_PIN_WIDGET_CONTROL, 0x0);
3693 	msleep(10);
3694 	alc_write_coef_idx(codec, 0x67, 0x0); /* Set HP depop to manual mode */
3695 	alc_write_coefex_idx(codec, 0x58, 0x00, 0x7880);
3696 	alc_write_coefex_idx(codec, 0x58, 0x0f, 0xf049);
3697 	alc_update_coefex_idx(codec, 0x58, 0x03, 0x00f0, 0x00c0);
3698 
3699 	alc_write_coefex_idx(codec, 0x58, 0x00, 0xf888); /* HP depop procedure start */
3700 	val = alc_read_coefex_idx(codec, 0x58, 0x00);
3701 	for (i = 0; i < 20 && val & 0x8000; i++) {
3702 		msleep(50);
3703 		val = alc_read_coefex_idx(codec, 0x58, 0x00);
3704 	} /* Wait for depop procedure finish  */
3705 
3706 	alc_write_coefex_idx(codec, 0x58, 0x00, val); /* write back the result */
3707 	alc_update_coef_idx(codec, 0x38, 1<<4, coef38);
3708 	alc_update_coef_idx(codec, 0x0d, 0x110, coef0d);
3709 	alc_update_coef_idx(codec, 0x36, 3<<13, coef36);
3710 
3711 	msleep(50);
3712 	alc_update_coef_idx(codec, 0x4a, 1<<15, 0);
3713 }
3714 
alc225_init(struct hda_codec * codec)3715 static void alc225_init(struct hda_codec *codec)
3716 {
3717 	struct alc_spec *spec = codec->spec;
3718 	hda_nid_t hp_pin = alc_get_hp_pin(spec);
3719 	bool hp1_pin_sense, hp2_pin_sense;
3720 
3721 	if (spec->ultra_low_power) {
3722 		alc_update_coef_idx(codec, 0x08, 0x0f << 2, 3<<2);
3723 		alc_update_coef_idx(codec, 0x0e, 7<<6, 7<<6);
3724 		alc_update_coef_idx(codec, 0x33, 1<<11, 0);
3725 		msleep(30);
3726 	}
3727 
3728 	if (spec->codec_variant != ALC269_TYPE_ALC287 &&
3729 		spec->codec_variant != ALC269_TYPE_ALC245)
3730 		/* required only at boot or S3 and S4 resume time */
3731 		if (!spec->done_hp_init ||
3732 			is_s3_resume(codec) ||
3733 			is_s4_resume(codec)) {
3734 			alc285_hp_init(codec);
3735 			spec->done_hp_init = true;
3736 		}
3737 
3738 	if (!hp_pin)
3739 		hp_pin = 0x21;
3740 	msleep(30);
3741 
3742 	hp1_pin_sense = snd_hda_jack_detect(codec, hp_pin);
3743 	hp2_pin_sense = snd_hda_jack_detect(codec, 0x16);
3744 
3745 	if (hp1_pin_sense || hp2_pin_sense)
3746 		msleep(2);
3747 
3748 	alc_update_coefex_idx(codec, 0x57, 0x04, 0x0007, 0x1); /* Low power */
3749 
3750 	if (hp1_pin_sense || spec->ultra_low_power)
3751 		snd_hda_codec_write(codec, hp_pin, 0,
3752 			    AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);
3753 	if (hp2_pin_sense)
3754 		snd_hda_codec_write(codec, 0x16, 0,
3755 			    AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);
3756 
3757 	if (hp1_pin_sense || hp2_pin_sense || spec->ultra_low_power)
3758 		msleep(85);
3759 
3760 	if (hp1_pin_sense || spec->ultra_low_power)
3761 		snd_hda_codec_write(codec, hp_pin, 0,
3762 			    AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT);
3763 	if (hp2_pin_sense)
3764 		snd_hda_codec_write(codec, 0x16, 0,
3765 			    AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT);
3766 
3767 	if (hp1_pin_sense || hp2_pin_sense || spec->ultra_low_power)
3768 		msleep(100);
3769 
3770 	alc_update_coef_idx(codec, 0x4a, 3 << 10, 0);
3771 	alc_update_coefex_idx(codec, 0x57, 0x04, 0x0007, 0x4); /* Hight power */
3772 }
3773 
alc225_shutup(struct hda_codec * codec)3774 static void alc225_shutup(struct hda_codec *codec)
3775 {
3776 	struct alc_spec *spec = codec->spec;
3777 	hda_nid_t hp_pin = alc_get_hp_pin(spec);
3778 	bool hp1_pin_sense, hp2_pin_sense;
3779 
3780 	if (!hp_pin)
3781 		hp_pin = 0x21;
3782 
3783 	alc_disable_headset_jack_key(codec);
3784 	/* 3k pull low control for Headset jack. */
3785 	alc_update_coef_idx(codec, 0x4a, 0, 3 << 10);
3786 
3787 	hp1_pin_sense = snd_hda_jack_detect(codec, hp_pin);
3788 	hp2_pin_sense = snd_hda_jack_detect(codec, 0x16);
3789 
3790 	if (hp1_pin_sense || hp2_pin_sense)
3791 		msleep(2);
3792 
3793 	if (hp1_pin_sense || spec->ultra_low_power)
3794 		snd_hda_codec_write(codec, hp_pin, 0,
3795 			    AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);
3796 	if (hp2_pin_sense)
3797 		snd_hda_codec_write(codec, 0x16, 0,
3798 			    AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);
3799 
3800 	if (hp1_pin_sense || hp2_pin_sense || spec->ultra_low_power)
3801 		msleep(85);
3802 
3803 	if (hp1_pin_sense || spec->ultra_low_power)
3804 		snd_hda_codec_write(codec, hp_pin, 0,
3805 			    AC_VERB_SET_PIN_WIDGET_CONTROL, 0x0);
3806 	if (hp2_pin_sense)
3807 		snd_hda_codec_write(codec, 0x16, 0,
3808 			    AC_VERB_SET_PIN_WIDGET_CONTROL, 0x0);
3809 
3810 	if (hp1_pin_sense || hp2_pin_sense || spec->ultra_low_power)
3811 		msleep(100);
3812 
3813 	alc_auto_setup_eapd(codec, false);
3814 	alc_shutup_pins(codec);
3815 	if (spec->ultra_low_power) {
3816 		msleep(50);
3817 		alc_update_coef_idx(codec, 0x08, 0x0f << 2, 0x0c << 2);
3818 		alc_update_coef_idx(codec, 0x0e, 7<<6, 0);
3819 		alc_update_coef_idx(codec, 0x33, 1<<11, 1<<11);
3820 		alc_update_coef_idx(codec, 0x4a, 3<<4, 2<<4);
3821 		msleep(30);
3822 	}
3823 
3824 	alc_update_coef_idx(codec, 0x4a, 3 << 10, 0);
3825 	alc_enable_headset_jack_key(codec);
3826 }
3827 
alc_default_init(struct hda_codec * codec)3828 static void alc_default_init(struct hda_codec *codec)
3829 {
3830 	struct alc_spec *spec = codec->spec;
3831 	hda_nid_t hp_pin = alc_get_hp_pin(spec);
3832 	bool hp_pin_sense;
3833 
3834 	if (!hp_pin)
3835 		return;
3836 
3837 	msleep(30);
3838 
3839 	hp_pin_sense = snd_hda_jack_detect(codec, hp_pin);
3840 
3841 	if (hp_pin_sense)
3842 		msleep(2);
3843 
3844 	snd_hda_codec_write(codec, hp_pin, 0,
3845 			    AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);
3846 
3847 	if (hp_pin_sense)
3848 		msleep(85);
3849 
3850 	snd_hda_codec_write(codec, hp_pin, 0,
3851 			    AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT);
3852 
3853 	if (hp_pin_sense)
3854 		msleep(100);
3855 }
3856 
alc_default_shutup(struct hda_codec * codec)3857 static void alc_default_shutup(struct hda_codec *codec)
3858 {
3859 	struct alc_spec *spec = codec->spec;
3860 	hda_nid_t hp_pin = alc_get_hp_pin(spec);
3861 	bool hp_pin_sense;
3862 
3863 	if (!hp_pin) {
3864 		alc269_shutup(codec);
3865 		return;
3866 	}
3867 
3868 	hp_pin_sense = snd_hda_jack_detect(codec, hp_pin);
3869 
3870 	if (hp_pin_sense)
3871 		msleep(2);
3872 
3873 	snd_hda_codec_write(codec, hp_pin, 0,
3874 			    AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);
3875 
3876 	if (hp_pin_sense)
3877 		msleep(85);
3878 
3879 	if (!spec->no_shutup_pins)
3880 		snd_hda_codec_write(codec, hp_pin, 0,
3881 				    AC_VERB_SET_PIN_WIDGET_CONTROL, 0x0);
3882 
3883 	if (hp_pin_sense)
3884 		msleep(100);
3885 
3886 	alc_auto_setup_eapd(codec, false);
3887 	alc_shutup_pins(codec);
3888 }
3889 
alc294_hp_init(struct hda_codec * codec)3890 static void alc294_hp_init(struct hda_codec *codec)
3891 {
3892 	struct alc_spec *spec = codec->spec;
3893 	hda_nid_t hp_pin = alc_get_hp_pin(spec);
3894 	int i, val;
3895 
3896 	if (!hp_pin)
3897 		return;
3898 
3899 	snd_hda_codec_write(codec, hp_pin, 0,
3900 			    AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);
3901 
3902 	msleep(100);
3903 
3904 	if (!spec->no_shutup_pins)
3905 		snd_hda_codec_write(codec, hp_pin, 0,
3906 				    AC_VERB_SET_PIN_WIDGET_CONTROL, 0x0);
3907 
3908 	alc_update_coef_idx(codec, 0x6f, 0x000f, 0);/* Set HP depop to manual mode */
3909 	alc_update_coefex_idx(codec, 0x58, 0x00, 0x8000, 0x8000); /* HP depop procedure start */
3910 
3911 	/* Wait for depop procedure finish  */
3912 	val = alc_read_coefex_idx(codec, 0x58, 0x01);
3913 	for (i = 0; i < 20 && val & 0x0080; i++) {
3914 		msleep(50);
3915 		val = alc_read_coefex_idx(codec, 0x58, 0x01);
3916 	}
3917 	/* Set HP depop to auto mode */
3918 	alc_update_coef_idx(codec, 0x6f, 0x000f, 0x000b);
3919 	msleep(50);
3920 }
3921 
alc294_init(struct hda_codec * codec)3922 static void alc294_init(struct hda_codec *codec)
3923 {
3924 	struct alc_spec *spec = codec->spec;
3925 
3926 	/* required only at boot or S4 resume time */
3927 	if (!spec->done_hp_init ||
3928 	    codec->core.dev.power.power_state.event == PM_EVENT_RESTORE) {
3929 		alc294_hp_init(codec);
3930 		spec->done_hp_init = true;
3931 	}
3932 	alc_default_init(codec);
3933 }
3934 
alc5505_coef_set(struct hda_codec * codec,unsigned int index_reg,unsigned int val)3935 static void alc5505_coef_set(struct hda_codec *codec, unsigned int index_reg,
3936 			     unsigned int val)
3937 {
3938 	snd_hda_codec_write(codec, 0x51, 0, AC_VERB_SET_COEF_INDEX, index_reg >> 1);
3939 	snd_hda_codec_write(codec, 0x51, 0, AC_VERB_SET_PROC_COEF, val & 0xffff); /* LSB */
3940 	snd_hda_codec_write(codec, 0x51, 0, AC_VERB_SET_PROC_COEF, val >> 16); /* MSB */
3941 }
3942 
alc5505_coef_get(struct hda_codec * codec,unsigned int index_reg)3943 static int alc5505_coef_get(struct hda_codec *codec, unsigned int index_reg)
3944 {
3945 	unsigned int val;
3946 
3947 	snd_hda_codec_write(codec, 0x51, 0, AC_VERB_SET_COEF_INDEX, index_reg >> 1);
3948 	val = snd_hda_codec_read(codec, 0x51, 0, AC_VERB_GET_PROC_COEF, 0)
3949 		& 0xffff;
3950 	val |= snd_hda_codec_read(codec, 0x51, 0, AC_VERB_GET_PROC_COEF, 0)
3951 		<< 16;
3952 	return val;
3953 }
3954 
alc5505_dsp_halt(struct hda_codec * codec)3955 static void alc5505_dsp_halt(struct hda_codec *codec)
3956 {
3957 	unsigned int val;
3958 
3959 	alc5505_coef_set(codec, 0x3000, 0x000c); /* DSP CPU stop */
3960 	alc5505_coef_set(codec, 0x880c, 0x0008); /* DDR enter self refresh */
3961 	alc5505_coef_set(codec, 0x61c0, 0x11110080); /* Clock control for PLL and CPU */
3962 	alc5505_coef_set(codec, 0x6230, 0xfc0d4011); /* Disable Input OP */
3963 	alc5505_coef_set(codec, 0x61b4, 0x040a2b03); /* Stop PLL2 */
3964 	alc5505_coef_set(codec, 0x61b0, 0x00005b17); /* Stop PLL1 */
3965 	alc5505_coef_set(codec, 0x61b8, 0x04133303); /* Stop PLL3 */
3966 	val = alc5505_coef_get(codec, 0x6220);
3967 	alc5505_coef_set(codec, 0x6220, (val | 0x3000)); /* switch Ringbuffer clock to DBUS clock */
3968 }
3969 
alc5505_dsp_back_from_halt(struct hda_codec * codec)3970 static void alc5505_dsp_back_from_halt(struct hda_codec *codec)
3971 {
3972 	alc5505_coef_set(codec, 0x61b8, 0x04133302);
3973 	alc5505_coef_set(codec, 0x61b0, 0x00005b16);
3974 	alc5505_coef_set(codec, 0x61b4, 0x040a2b02);
3975 	alc5505_coef_set(codec, 0x6230, 0xf80d4011);
3976 	alc5505_coef_set(codec, 0x6220, 0x2002010f);
3977 	alc5505_coef_set(codec, 0x880c, 0x00000004);
3978 }
3979 
alc5505_dsp_init(struct hda_codec * codec)3980 static void alc5505_dsp_init(struct hda_codec *codec)
3981 {
3982 	unsigned int val;
3983 
3984 	alc5505_dsp_halt(codec);
3985 	alc5505_dsp_back_from_halt(codec);
3986 	alc5505_coef_set(codec, 0x61b0, 0x5b14); /* PLL1 control */
3987 	alc5505_coef_set(codec, 0x61b0, 0x5b16);
3988 	alc5505_coef_set(codec, 0x61b4, 0x04132b00); /* PLL2 control */
3989 	alc5505_coef_set(codec, 0x61b4, 0x04132b02);
3990 	alc5505_coef_set(codec, 0x61b8, 0x041f3300); /* PLL3 control*/
3991 	alc5505_coef_set(codec, 0x61b8, 0x041f3302);
3992 	snd_hda_codec_write(codec, 0x51, 0, AC_VERB_SET_CODEC_RESET, 0); /* Function reset */
3993 	alc5505_coef_set(codec, 0x61b8, 0x041b3302);
3994 	alc5505_coef_set(codec, 0x61b8, 0x04173302);
3995 	alc5505_coef_set(codec, 0x61b8, 0x04163302);
3996 	alc5505_coef_set(codec, 0x8800, 0x348b328b); /* DRAM control */
3997 	alc5505_coef_set(codec, 0x8808, 0x00020022); /* DRAM control */
3998 	alc5505_coef_set(codec, 0x8818, 0x00000400); /* DRAM control */
3999 
4000 	val = alc5505_coef_get(codec, 0x6200) >> 16; /* Read revision ID */
4001 	if (val <= 3)
4002 		alc5505_coef_set(codec, 0x6220, 0x2002010f); /* I/O PAD Configuration */
4003 	else
4004 		alc5505_coef_set(codec, 0x6220, 0x6002018f);
4005 
4006 	alc5505_coef_set(codec, 0x61ac, 0x055525f0); /**/
4007 	alc5505_coef_set(codec, 0x61c0, 0x12230080); /* Clock control */
4008 	alc5505_coef_set(codec, 0x61b4, 0x040e2b02); /* PLL2 control */
4009 	alc5505_coef_set(codec, 0x61bc, 0x010234f8); /* OSC Control */
4010 	alc5505_coef_set(codec, 0x880c, 0x00000004); /* DRAM Function control */
4011 	alc5505_coef_set(codec, 0x880c, 0x00000003);
4012 	alc5505_coef_set(codec, 0x880c, 0x00000010);
4013 
4014 #ifdef HALT_REALTEK_ALC5505
4015 	alc5505_dsp_halt(codec);
4016 #endif
4017 }
4018 
4019 #ifdef HALT_REALTEK_ALC5505
4020 #define alc5505_dsp_suspend(codec)	do { } while (0) /* NOP */
4021 #define alc5505_dsp_resume(codec)	do { } while (0) /* NOP */
4022 #else
4023 #define alc5505_dsp_suspend(codec)	alc5505_dsp_halt(codec)
4024 #define alc5505_dsp_resume(codec)	alc5505_dsp_back_from_halt(codec)
4025 #endif
4026 
4027 #ifdef CONFIG_PM
alc269_suspend(struct hda_codec * codec)4028 static int alc269_suspend(struct hda_codec *codec)
4029 {
4030 	struct alc_spec *spec = codec->spec;
4031 
4032 	if (spec->has_alc5505_dsp)
4033 		alc5505_dsp_suspend(codec);
4034 
4035 	return alc_suspend(codec);
4036 }
4037 
alc269_resume(struct hda_codec * codec)4038 static int alc269_resume(struct hda_codec *codec)
4039 {
4040 	struct alc_spec *spec = codec->spec;
4041 
4042 	if (spec->codec_variant == ALC269_TYPE_ALC269VB)
4043 		alc269vb_toggle_power_output(codec, 0);
4044 	if (spec->codec_variant == ALC269_TYPE_ALC269VB &&
4045 			(alc_get_coef0(codec) & 0x00ff) == 0x018) {
4046 		msleep(150);
4047 	}
4048 
4049 	codec->patch_ops.init(codec);
4050 
4051 	if (spec->codec_variant == ALC269_TYPE_ALC269VB)
4052 		alc269vb_toggle_power_output(codec, 1);
4053 	if (spec->codec_variant == ALC269_TYPE_ALC269VB &&
4054 			(alc_get_coef0(codec) & 0x00ff) == 0x017) {
4055 		msleep(200);
4056 	}
4057 
4058 	snd_hda_regmap_sync(codec);
4059 	hda_call_check_power_status(codec, 0x01);
4060 
4061 	/* on some machine, the BIOS will clear the codec gpio data when enter
4062 	 * suspend, and won't restore the data after resume, so we restore it
4063 	 * in the driver.
4064 	 */
4065 	if (spec->gpio_data)
4066 		alc_write_gpio_data(codec);
4067 
4068 	if (spec->has_alc5505_dsp)
4069 		alc5505_dsp_resume(codec);
4070 
4071 	return 0;
4072 }
4073 #endif /* CONFIG_PM */
4074 
alc269_fixup_pincfg_no_hp_to_lineout(struct hda_codec * codec,const struct hda_fixup * fix,int action)4075 static void alc269_fixup_pincfg_no_hp_to_lineout(struct hda_codec *codec,
4076 						 const struct hda_fixup *fix, int action)
4077 {
4078 	struct alc_spec *spec = codec->spec;
4079 
4080 	if (action == HDA_FIXUP_ACT_PRE_PROBE)
4081 		spec->parse_flags = HDA_PINCFG_NO_HP_FIXUP;
4082 }
4083 
alc269_fixup_pincfg_U7x7_headset_mic(struct hda_codec * codec,const struct hda_fixup * fix,int action)4084 static void alc269_fixup_pincfg_U7x7_headset_mic(struct hda_codec *codec,
4085 						 const struct hda_fixup *fix,
4086 						 int action)
4087 {
4088 	unsigned int cfg_headphone = snd_hda_codec_get_pincfg(codec, 0x21);
4089 	unsigned int cfg_headset_mic = snd_hda_codec_get_pincfg(codec, 0x19);
4090 
4091 	if (cfg_headphone && cfg_headset_mic == 0x411111f0)
4092 		snd_hda_codec_set_pincfg(codec, 0x19,
4093 			(cfg_headphone & ~AC_DEFCFG_DEVICE) |
4094 			(AC_JACK_MIC_IN << AC_DEFCFG_DEVICE_SHIFT));
4095 }
4096 
alc269_fixup_hweq(struct hda_codec * codec,const struct hda_fixup * fix,int action)4097 static void alc269_fixup_hweq(struct hda_codec *codec,
4098 			       const struct hda_fixup *fix, int action)
4099 {
4100 	if (action == HDA_FIXUP_ACT_INIT)
4101 		alc_update_coef_idx(codec, 0x1e, 0, 0x80);
4102 }
4103 
alc269_fixup_headset_mic(struct hda_codec * codec,const struct hda_fixup * fix,int action)4104 static void alc269_fixup_headset_mic(struct hda_codec *codec,
4105 				       const struct hda_fixup *fix, int action)
4106 {
4107 	struct alc_spec *spec = codec->spec;
4108 
4109 	if (action == HDA_FIXUP_ACT_PRE_PROBE)
4110 		spec->parse_flags |= HDA_PINCFG_HEADSET_MIC;
4111 }
4112 
alc271_fixup_dmic(struct hda_codec * codec,const struct hda_fixup * fix,int action)4113 static void alc271_fixup_dmic(struct hda_codec *codec,
4114 			      const struct hda_fixup *fix, int action)
4115 {
4116 	static const struct hda_verb verbs[] = {
4117 		{0x20, AC_VERB_SET_COEF_INDEX, 0x0d},
4118 		{0x20, AC_VERB_SET_PROC_COEF, 0x4000},
4119 		{}
4120 	};
4121 	unsigned int cfg;
4122 
4123 	if (strcmp(codec->core.chip_name, "ALC271X") &&
4124 	    strcmp(codec->core.chip_name, "ALC269VB"))
4125 		return;
4126 	cfg = snd_hda_codec_get_pincfg(codec, 0x12);
4127 	if (get_defcfg_connect(cfg) == AC_JACK_PORT_FIXED)
4128 		snd_hda_sequence_write(codec, verbs);
4129 }
4130 
4131 /* Fix the speaker amp after resume, etc */
alc269vb_fixup_aspire_e1_coef(struct hda_codec * codec,const struct hda_fixup * fix,int action)4132 static void alc269vb_fixup_aspire_e1_coef(struct hda_codec *codec,
4133 					  const struct hda_fixup *fix,
4134 					  int action)
4135 {
4136 	if (action == HDA_FIXUP_ACT_INIT)
4137 		alc_update_coef_idx(codec, 0x0d, 0x6000, 0x6000);
4138 }
4139 
alc269_fixup_pcm_44k(struct hda_codec * codec,const struct hda_fixup * fix,int action)4140 static void alc269_fixup_pcm_44k(struct hda_codec *codec,
4141 				 const struct hda_fixup *fix, int action)
4142 {
4143 	struct alc_spec *spec = codec->spec;
4144 
4145 	if (action != HDA_FIXUP_ACT_PROBE)
4146 		return;
4147 
4148 	/* Due to a hardware problem on Lenovo Ideadpad, we need to
4149 	 * fix the sample rate of analog I/O to 44.1kHz
4150 	 */
4151 	spec->gen.stream_analog_playback = &alc269_44k_pcm_analog_playback;
4152 	spec->gen.stream_analog_capture = &alc269_44k_pcm_analog_capture;
4153 }
4154 
alc269_fixup_stereo_dmic(struct hda_codec * codec,const struct hda_fixup * fix,int action)4155 static void alc269_fixup_stereo_dmic(struct hda_codec *codec,
4156 				     const struct hda_fixup *fix, int action)
4157 {
4158 	/* The digital-mic unit sends PDM (differential signal) instead of
4159 	 * the standard PCM, thus you can't record a valid mono stream as is.
4160 	 * Below is a workaround specific to ALC269 to control the dmic
4161 	 * signal source as mono.
4162 	 */
4163 	if (action == HDA_FIXUP_ACT_INIT)
4164 		alc_update_coef_idx(codec, 0x07, 0, 0x80);
4165 }
4166 
alc269_quanta_automute(struct hda_codec * codec)4167 static void alc269_quanta_automute(struct hda_codec *codec)
4168 {
4169 	snd_hda_gen_update_outputs(codec);
4170 
4171 	alc_write_coef_idx(codec, 0x0c, 0x680);
4172 	alc_write_coef_idx(codec, 0x0c, 0x480);
4173 }
4174 
alc269_fixup_quanta_mute(struct hda_codec * codec,const struct hda_fixup * fix,int action)4175 static void alc269_fixup_quanta_mute(struct hda_codec *codec,
4176 				     const struct hda_fixup *fix, int action)
4177 {
4178 	struct alc_spec *spec = codec->spec;
4179 	if (action != HDA_FIXUP_ACT_PROBE)
4180 		return;
4181 	spec->gen.automute_hook = alc269_quanta_automute;
4182 }
4183 
alc269_x101_hp_automute_hook(struct hda_codec * codec,struct hda_jack_callback * jack)4184 static void alc269_x101_hp_automute_hook(struct hda_codec *codec,
4185 					 struct hda_jack_callback *jack)
4186 {
4187 	struct alc_spec *spec = codec->spec;
4188 	int vref;
4189 	msleep(200);
4190 	snd_hda_gen_hp_automute(codec, jack);
4191 
4192 	vref = spec->gen.hp_jack_present ? PIN_VREF80 : 0;
4193 	msleep(100);
4194 	snd_hda_codec_write(codec, 0x18, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
4195 			    vref);
4196 	msleep(500);
4197 	snd_hda_codec_write(codec, 0x18, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
4198 			    vref);
4199 }
4200 
4201 /*
4202  * Magic sequence to make Huawei Matebook X right speaker working (bko#197801)
4203  */
4204 struct hda_alc298_mbxinit {
4205 	unsigned char value_0x23;
4206 	unsigned char value_0x25;
4207 };
4208 
alc298_huawei_mbx_stereo_seq(struct hda_codec * codec,const struct hda_alc298_mbxinit * initval,bool first)4209 static void alc298_huawei_mbx_stereo_seq(struct hda_codec *codec,
4210 					 const struct hda_alc298_mbxinit *initval,
4211 					 bool first)
4212 {
4213 	snd_hda_codec_write(codec, 0x06, 0, AC_VERB_SET_DIGI_CONVERT_3, 0x0);
4214 	alc_write_coef_idx(codec, 0x26, 0xb000);
4215 
4216 	if (first)
4217 		snd_hda_codec_write(codec, 0x21, 0, AC_VERB_GET_PIN_SENSE, 0x0);
4218 
4219 	snd_hda_codec_write(codec, 0x6, 0, AC_VERB_SET_DIGI_CONVERT_3, 0x80);
4220 	alc_write_coef_idx(codec, 0x26, 0xf000);
4221 	alc_write_coef_idx(codec, 0x23, initval->value_0x23);
4222 
4223 	if (initval->value_0x23 != 0x1e)
4224 		alc_write_coef_idx(codec, 0x25, initval->value_0x25);
4225 
4226 	snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_COEF_INDEX, 0x26);
4227 	snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_PROC_COEF, 0xb010);
4228 }
4229 
alc298_fixup_huawei_mbx_stereo(struct hda_codec * codec,const struct hda_fixup * fix,int action)4230 static void alc298_fixup_huawei_mbx_stereo(struct hda_codec *codec,
4231 					   const struct hda_fixup *fix,
4232 					   int action)
4233 {
4234 	/* Initialization magic */
4235 	static const struct hda_alc298_mbxinit dac_init[] = {
4236 		{0x0c, 0x00}, {0x0d, 0x00}, {0x0e, 0x00}, {0x0f, 0x00},
4237 		{0x10, 0x00}, {0x1a, 0x40}, {0x1b, 0x82}, {0x1c, 0x00},
4238 		{0x1d, 0x00}, {0x1e, 0x00}, {0x1f, 0x00},
4239 		{0x20, 0xc2}, {0x21, 0xc8}, {0x22, 0x26}, {0x23, 0x24},
4240 		{0x27, 0xff}, {0x28, 0xff}, {0x29, 0xff}, {0x2a, 0x8f},
4241 		{0x2b, 0x02}, {0x2c, 0x48}, {0x2d, 0x34}, {0x2e, 0x00},
4242 		{0x2f, 0x00},
4243 		{0x30, 0x00}, {0x31, 0x00}, {0x32, 0x00}, {0x33, 0x00},
4244 		{0x34, 0x00}, {0x35, 0x01}, {0x36, 0x93}, {0x37, 0x0c},
4245 		{0x38, 0x00}, {0x39, 0x00}, {0x3a, 0xf8}, {0x38, 0x80},
4246 		{}
4247 	};
4248 	const struct hda_alc298_mbxinit *seq;
4249 
4250 	if (action != HDA_FIXUP_ACT_INIT)
4251 		return;
4252 
4253 	/* Start */
4254 	snd_hda_codec_write(codec, 0x06, 0, AC_VERB_SET_DIGI_CONVERT_3, 0x00);
4255 	snd_hda_codec_write(codec, 0x06, 0, AC_VERB_SET_DIGI_CONVERT_3, 0x80);
4256 	alc_write_coef_idx(codec, 0x26, 0xf000);
4257 	alc_write_coef_idx(codec, 0x22, 0x31);
4258 	alc_write_coef_idx(codec, 0x23, 0x0b);
4259 	alc_write_coef_idx(codec, 0x25, 0x00);
4260 	snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_COEF_INDEX, 0x26);
4261 	snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_PROC_COEF, 0xb010);
4262 
4263 	for (seq = dac_init; seq->value_0x23; seq++)
4264 		alc298_huawei_mbx_stereo_seq(codec, seq, seq == dac_init);
4265 }
4266 
alc269_fixup_x101_headset_mic(struct hda_codec * codec,const struct hda_fixup * fix,int action)4267 static void alc269_fixup_x101_headset_mic(struct hda_codec *codec,
4268 				     const struct hda_fixup *fix, int action)
4269 {
4270 	struct alc_spec *spec = codec->spec;
4271 	if (action == HDA_FIXUP_ACT_PRE_PROBE) {
4272 		spec->parse_flags |= HDA_PINCFG_HEADSET_MIC;
4273 		spec->gen.hp_automute_hook = alc269_x101_hp_automute_hook;
4274 	}
4275 }
4276 
alc_update_vref_led(struct hda_codec * codec,hda_nid_t pin,bool polarity,bool on)4277 static void alc_update_vref_led(struct hda_codec *codec, hda_nid_t pin,
4278 				bool polarity, bool on)
4279 {
4280 	unsigned int pinval;
4281 
4282 	if (!pin)
4283 		return;
4284 	if (polarity)
4285 		on = !on;
4286 	pinval = snd_hda_codec_get_pin_target(codec, pin);
4287 	pinval &= ~AC_PINCTL_VREFEN;
4288 	pinval |= on ? AC_PINCTL_VREF_80 : AC_PINCTL_VREF_HIZ;
4289 	/* temporarily power up/down for setting VREF */
4290 	snd_hda_power_up_pm(codec);
4291 	snd_hda_set_pin_ctl_cache(codec, pin, pinval);
4292 	snd_hda_power_down_pm(codec);
4293 }
4294 
4295 /* 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)4296 static int vref_mute_led_set(struct led_classdev *led_cdev,
4297 			     enum led_brightness brightness)
4298 {
4299 	struct hda_codec *codec = dev_to_hda_codec(led_cdev->dev->parent);
4300 	struct alc_spec *spec = codec->spec;
4301 
4302 	alc_update_vref_led(codec, spec->mute_led_nid,
4303 			    spec->mute_led_polarity, brightness);
4304 	return 0;
4305 }
4306 
4307 /* Make sure the led works even in runtime suspend */
led_power_filter(struct hda_codec * codec,hda_nid_t nid,unsigned int power_state)4308 static unsigned int led_power_filter(struct hda_codec *codec,
4309 						  hda_nid_t nid,
4310 						  unsigned int power_state)
4311 {
4312 	struct alc_spec *spec = codec->spec;
4313 
4314 	if (power_state != AC_PWRST_D3 || nid == 0 ||
4315 	    (nid != spec->mute_led_nid && nid != spec->cap_mute_led_nid))
4316 		return power_state;
4317 
4318 	/* Set pin ctl again, it might have just been set to 0 */
4319 	snd_hda_set_pin_ctl(codec, nid,
4320 			    snd_hda_codec_get_pin_target(codec, nid));
4321 
4322 	return snd_hda_gen_path_power_filter(codec, nid, power_state);
4323 }
4324 
alc269_fixup_hp_mute_led(struct hda_codec * codec,const struct hda_fixup * fix,int action)4325 static void alc269_fixup_hp_mute_led(struct hda_codec *codec,
4326 				     const struct hda_fixup *fix, int action)
4327 {
4328 	struct alc_spec *spec = codec->spec;
4329 	const struct dmi_device *dev = NULL;
4330 
4331 	if (action != HDA_FIXUP_ACT_PRE_PROBE)
4332 		return;
4333 
4334 	while ((dev = dmi_find_device(DMI_DEV_TYPE_OEM_STRING, NULL, dev))) {
4335 		int pol, pin;
4336 		if (sscanf(dev->name, "HP_Mute_LED_%d_%x", &pol, &pin) != 2)
4337 			continue;
4338 		if (pin < 0x0a || pin >= 0x10)
4339 			break;
4340 		spec->mute_led_polarity = pol;
4341 		spec->mute_led_nid = pin - 0x0a + 0x18;
4342 		snd_hda_gen_add_mute_led_cdev(codec, vref_mute_led_set);
4343 		codec->power_filter = led_power_filter;
4344 		codec_dbg(codec,
4345 			  "Detected mute LED for %x:%d\n", spec->mute_led_nid,
4346 			   spec->mute_led_polarity);
4347 		break;
4348 	}
4349 }
4350 
alc269_fixup_hp_mute_led_micx(struct hda_codec * codec,const struct hda_fixup * fix,int action,hda_nid_t pin)4351 static void alc269_fixup_hp_mute_led_micx(struct hda_codec *codec,
4352 					  const struct hda_fixup *fix,
4353 					  int action, hda_nid_t pin)
4354 {
4355 	struct alc_spec *spec = codec->spec;
4356 
4357 	if (action == HDA_FIXUP_ACT_PRE_PROBE) {
4358 		spec->mute_led_polarity = 0;
4359 		spec->mute_led_nid = pin;
4360 		snd_hda_gen_add_mute_led_cdev(codec, vref_mute_led_set);
4361 		codec->power_filter = led_power_filter;
4362 	}
4363 }
4364 
alc269_fixup_hp_mute_led_mic1(struct hda_codec * codec,const struct hda_fixup * fix,int action)4365 static void alc269_fixup_hp_mute_led_mic1(struct hda_codec *codec,
4366 				const struct hda_fixup *fix, int action)
4367 {
4368 	alc269_fixup_hp_mute_led_micx(codec, fix, action, 0x18);
4369 }
4370 
alc269_fixup_hp_mute_led_mic2(struct hda_codec * codec,const struct hda_fixup * fix,int action)4371 static void alc269_fixup_hp_mute_led_mic2(struct hda_codec *codec,
4372 				const struct hda_fixup *fix, int action)
4373 {
4374 	alc269_fixup_hp_mute_led_micx(codec, fix, action, 0x19);
4375 }
4376 
alc269_fixup_hp_mute_led_mic3(struct hda_codec * codec,const struct hda_fixup * fix,int action)4377 static void alc269_fixup_hp_mute_led_mic3(struct hda_codec *codec,
4378 				const struct hda_fixup *fix, int action)
4379 {
4380 	alc269_fixup_hp_mute_led_micx(codec, fix, action, 0x1b);
4381 }
4382 
4383 /* update LED status via GPIO */
alc_update_gpio_led(struct hda_codec * codec,unsigned int mask,int polarity,bool enabled)4384 static void alc_update_gpio_led(struct hda_codec *codec, unsigned int mask,
4385 				int polarity, bool enabled)
4386 {
4387 	if (polarity)
4388 		enabled = !enabled;
4389 	alc_update_gpio_data(codec, mask, !enabled); /* muted -> LED on */
4390 }
4391 
4392 /* turn on/off mute LED via GPIO per vmaster hook */
gpio_mute_led_set(struct led_classdev * led_cdev,enum led_brightness brightness)4393 static int gpio_mute_led_set(struct led_classdev *led_cdev,
4394 			     enum led_brightness brightness)
4395 {
4396 	struct hda_codec *codec = dev_to_hda_codec(led_cdev->dev->parent);
4397 	struct alc_spec *spec = codec->spec;
4398 
4399 	alc_update_gpio_led(codec, spec->gpio_mute_led_mask,
4400 			    spec->mute_led_polarity, !brightness);
4401 	return 0;
4402 }
4403 
4404 /* turn on/off mic-mute LED via GPIO per capture hook */
micmute_led_set(struct led_classdev * led_cdev,enum led_brightness brightness)4405 static int micmute_led_set(struct led_classdev *led_cdev,
4406 			   enum led_brightness brightness)
4407 {
4408 	struct hda_codec *codec = dev_to_hda_codec(led_cdev->dev->parent);
4409 	struct alc_spec *spec = codec->spec;
4410 
4411 	alc_update_gpio_led(codec, spec->gpio_mic_led_mask,
4412 			    spec->micmute_led_polarity, !brightness);
4413 	return 0;
4414 }
4415 
4416 /* 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)4417 static void alc_fixup_hp_gpio_led(struct hda_codec *codec,
4418 				  int action,
4419 				  unsigned int mute_mask,
4420 				  unsigned int micmute_mask)
4421 {
4422 	struct alc_spec *spec = codec->spec;
4423 
4424 	alc_fixup_gpio(codec, action, mute_mask | micmute_mask);
4425 
4426 	if (action != HDA_FIXUP_ACT_PRE_PROBE)
4427 		return;
4428 	if (mute_mask) {
4429 		spec->gpio_mute_led_mask = mute_mask;
4430 		snd_hda_gen_add_mute_led_cdev(codec, gpio_mute_led_set);
4431 	}
4432 	if (micmute_mask) {
4433 		spec->gpio_mic_led_mask = micmute_mask;
4434 		snd_hda_gen_add_micmute_led_cdev(codec, micmute_led_set);
4435 	}
4436 }
4437 
alc236_fixup_hp_gpio_led(struct hda_codec * codec,const struct hda_fixup * fix,int action)4438 static void alc236_fixup_hp_gpio_led(struct hda_codec *codec,
4439 				const struct hda_fixup *fix, int action)
4440 {
4441 	alc_fixup_hp_gpio_led(codec, action, 0x02, 0x01);
4442 }
4443 
alc269_fixup_hp_gpio_led(struct hda_codec * codec,const struct hda_fixup * fix,int action)4444 static void alc269_fixup_hp_gpio_led(struct hda_codec *codec,
4445 				const struct hda_fixup *fix, int action)
4446 {
4447 	alc_fixup_hp_gpio_led(codec, action, 0x08, 0x10);
4448 }
4449 
alc285_fixup_hp_gpio_led(struct hda_codec * codec,const struct hda_fixup * fix,int action)4450 static void alc285_fixup_hp_gpio_led(struct hda_codec *codec,
4451 				const struct hda_fixup *fix, int action)
4452 {
4453 	alc_fixup_hp_gpio_led(codec, action, 0x04, 0x01);
4454 }
4455 
alc286_fixup_hp_gpio_led(struct hda_codec * codec,const struct hda_fixup * fix,int action)4456 static void alc286_fixup_hp_gpio_led(struct hda_codec *codec,
4457 				const struct hda_fixup *fix, int action)
4458 {
4459 	alc_fixup_hp_gpio_led(codec, action, 0x02, 0x20);
4460 }
4461 
alc287_fixup_hp_gpio_led(struct hda_codec * codec,const struct hda_fixup * fix,int action)4462 static void alc287_fixup_hp_gpio_led(struct hda_codec *codec,
4463 				const struct hda_fixup *fix, int action)
4464 {
4465 	alc_fixup_hp_gpio_led(codec, action, 0x10, 0);
4466 }
4467 
alc245_fixup_hp_gpio_led(struct hda_codec * codec,const struct hda_fixup * fix,int action)4468 static void alc245_fixup_hp_gpio_led(struct hda_codec *codec,
4469 				const struct hda_fixup *fix, int action)
4470 {
4471 	struct alc_spec *spec = codec->spec;
4472 
4473 	if (action == HDA_FIXUP_ACT_PRE_PROBE)
4474 		spec->micmute_led_polarity = 1;
4475 	alc_fixup_hp_gpio_led(codec, action, 0, 0x04);
4476 }
4477 
4478 /* 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)4479 static int vref_micmute_led_set(struct led_classdev *led_cdev,
4480 				enum led_brightness brightness)
4481 {
4482 	struct hda_codec *codec = dev_to_hda_codec(led_cdev->dev->parent);
4483 	struct alc_spec *spec = codec->spec;
4484 
4485 	alc_update_vref_led(codec, spec->cap_mute_led_nid,
4486 			    spec->micmute_led_polarity, brightness);
4487 	return 0;
4488 }
4489 
alc269_fixup_hp_gpio_mic1_led(struct hda_codec * codec,const struct hda_fixup * fix,int action)4490 static void alc269_fixup_hp_gpio_mic1_led(struct hda_codec *codec,
4491 				const struct hda_fixup *fix, int action)
4492 {
4493 	struct alc_spec *spec = codec->spec;
4494 
4495 	alc_fixup_hp_gpio_led(codec, action, 0x08, 0);
4496 	if (action == HDA_FIXUP_ACT_PRE_PROBE) {
4497 		/* Like hp_gpio_mic1_led, but also needs GPIO4 low to
4498 		 * enable headphone amp
4499 		 */
4500 		spec->gpio_mask |= 0x10;
4501 		spec->gpio_dir |= 0x10;
4502 		spec->cap_mute_led_nid = 0x18;
4503 		snd_hda_gen_add_micmute_led_cdev(codec, vref_micmute_led_set);
4504 		codec->power_filter = led_power_filter;
4505 	}
4506 }
4507 
alc280_fixup_hp_gpio4(struct hda_codec * codec,const struct hda_fixup * fix,int action)4508 static void alc280_fixup_hp_gpio4(struct hda_codec *codec,
4509 				   const struct hda_fixup *fix, int action)
4510 {
4511 	struct alc_spec *spec = codec->spec;
4512 
4513 	alc_fixup_hp_gpio_led(codec, action, 0x08, 0);
4514 	if (action == HDA_FIXUP_ACT_PRE_PROBE) {
4515 		spec->cap_mute_led_nid = 0x18;
4516 		snd_hda_gen_add_micmute_led_cdev(codec, vref_micmute_led_set);
4517 		codec->power_filter = led_power_filter;
4518 	}
4519 }
4520 
4521 /* HP Spectre x360 14 model needs a unique workaround for enabling the amp;
4522  * it needs to toggle the GPIO0 once on and off at each time (bko#210633)
4523  */
alc245_fixup_hp_x360_amp(struct hda_codec * codec,const struct hda_fixup * fix,int action)4524 static void alc245_fixup_hp_x360_amp(struct hda_codec *codec,
4525 				     const struct hda_fixup *fix, int action)
4526 {
4527 	struct alc_spec *spec = codec->spec;
4528 
4529 	switch (action) {
4530 	case HDA_FIXUP_ACT_PRE_PROBE:
4531 		spec->gpio_mask |= 0x01;
4532 		spec->gpio_dir |= 0x01;
4533 		break;
4534 	case HDA_FIXUP_ACT_INIT:
4535 		/* need to toggle GPIO to enable the amp */
4536 		alc_update_gpio_data(codec, 0x01, true);
4537 		msleep(100);
4538 		alc_update_gpio_data(codec, 0x01, false);
4539 		break;
4540 	}
4541 }
4542 
4543 /* 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)4544 static void alc274_hp_envy_pcm_hook(struct hda_pcm_stream *hinfo,
4545 				    struct hda_codec *codec,
4546 				    struct snd_pcm_substream *substream,
4547 				    int action)
4548 {
4549 	switch (action) {
4550 	case HDA_GEN_PCM_ACT_PREPARE:
4551 		alc_update_gpio_data(codec, 0x04, true);
4552 		break;
4553 	case HDA_GEN_PCM_ACT_CLEANUP:
4554 		alc_update_gpio_data(codec, 0x04, false);
4555 		break;
4556 	}
4557 }
4558 
alc274_fixup_hp_envy_gpio(struct hda_codec * codec,const struct hda_fixup * fix,int action)4559 static void alc274_fixup_hp_envy_gpio(struct hda_codec *codec,
4560 				      const struct hda_fixup *fix,
4561 				      int action)
4562 {
4563 	struct alc_spec *spec = codec->spec;
4564 
4565 	if (action == HDA_FIXUP_ACT_PROBE) {
4566 		spec->gpio_mask |= 0x04;
4567 		spec->gpio_dir |= 0x04;
4568 		spec->gen.pcm_playback_hook = alc274_hp_envy_pcm_hook;
4569 	}
4570 }
4571 
alc_update_coef_led(struct hda_codec * codec,struct alc_coef_led * led,bool polarity,bool on)4572 static void alc_update_coef_led(struct hda_codec *codec,
4573 				struct alc_coef_led *led,
4574 				bool polarity, bool on)
4575 {
4576 	if (polarity)
4577 		on = !on;
4578 	/* temporarily power up/down for setting COEF bit */
4579 	alc_update_coef_idx(codec, led->idx, led->mask,
4580 			    on ? led->on : led->off);
4581 }
4582 
4583 /* 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)4584 static int coef_mute_led_set(struct led_classdev *led_cdev,
4585 			     enum led_brightness brightness)
4586 {
4587 	struct hda_codec *codec = dev_to_hda_codec(led_cdev->dev->parent);
4588 	struct alc_spec *spec = codec->spec;
4589 
4590 	alc_update_coef_led(codec, &spec->mute_led_coef,
4591 			    spec->mute_led_polarity, brightness);
4592 	return 0;
4593 }
4594 
alc285_fixup_hp_mute_led_coefbit(struct hda_codec * codec,const struct hda_fixup * fix,int action)4595 static void alc285_fixup_hp_mute_led_coefbit(struct hda_codec *codec,
4596 					  const struct hda_fixup *fix,
4597 					  int action)
4598 {
4599 	struct alc_spec *spec = codec->spec;
4600 
4601 	if (action == HDA_FIXUP_ACT_PRE_PROBE) {
4602 		spec->mute_led_polarity = 0;
4603 		spec->mute_led_coef.idx = 0x0b;
4604 		spec->mute_led_coef.mask = 1 << 3;
4605 		spec->mute_led_coef.on = 1 << 3;
4606 		spec->mute_led_coef.off = 0;
4607 		snd_hda_gen_add_mute_led_cdev(codec, coef_mute_led_set);
4608 	}
4609 }
4610 
alc236_fixup_hp_mute_led_coefbit(struct hda_codec * codec,const struct hda_fixup * fix,int action)4611 static void alc236_fixup_hp_mute_led_coefbit(struct hda_codec *codec,
4612 					  const struct hda_fixup *fix,
4613 					  int action)
4614 {
4615 	struct alc_spec *spec = codec->spec;
4616 
4617 	if (action == HDA_FIXUP_ACT_PRE_PROBE) {
4618 		spec->mute_led_polarity = 0;
4619 		spec->mute_led_coef.idx = 0x34;
4620 		spec->mute_led_coef.mask = 1 << 5;
4621 		spec->mute_led_coef.on = 0;
4622 		spec->mute_led_coef.off = 1 << 5;
4623 		snd_hda_gen_add_mute_led_cdev(codec, coef_mute_led_set);
4624 	}
4625 }
4626 
alc236_fixup_hp_mute_led_coefbit2(struct hda_codec * codec,const struct hda_fixup * fix,int action)4627 static void alc236_fixup_hp_mute_led_coefbit2(struct hda_codec *codec,
4628 					  const struct hda_fixup *fix, int action)
4629 {
4630 	struct alc_spec *spec = codec->spec;
4631 
4632 	if (action == HDA_FIXUP_ACT_PRE_PROBE) {
4633 		spec->mute_led_polarity = 0;
4634 		spec->mute_led_coef.idx = 0x07;
4635 		spec->mute_led_coef.mask = 1;
4636 		spec->mute_led_coef.on = 1;
4637 		spec->mute_led_coef.off = 0;
4638 		snd_hda_gen_add_mute_led_cdev(codec, coef_mute_led_set);
4639 	}
4640 }
4641 
alc245_fixup_hp_mute_led_coefbit(struct hda_codec * codec,const struct hda_fixup * fix,int action)4642 static void alc245_fixup_hp_mute_led_coefbit(struct hda_codec *codec,
4643 					  const struct hda_fixup *fix,
4644 					  int action)
4645 {
4646 	struct alc_spec *spec = codec->spec;
4647 
4648 	if (action == HDA_FIXUP_ACT_PRE_PROBE) {
4649 		spec->mute_led_polarity = 0;
4650 		spec->mute_led_coef.idx = 0x0b;
4651 		spec->mute_led_coef.mask = 3 << 2;
4652 		spec->mute_led_coef.on = 2 << 2;
4653 		spec->mute_led_coef.off = 1 << 2;
4654 		snd_hda_gen_add_mute_led_cdev(codec, coef_mute_led_set);
4655 	}
4656 }
4657 
4658 /* 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)4659 static int coef_micmute_led_set(struct led_classdev *led_cdev,
4660 				enum led_brightness brightness)
4661 {
4662 	struct hda_codec *codec = dev_to_hda_codec(led_cdev->dev->parent);
4663 	struct alc_spec *spec = codec->spec;
4664 
4665 	alc_update_coef_led(codec, &spec->mic_led_coef,
4666 			    spec->micmute_led_polarity, brightness);
4667 	return 0;
4668 }
4669 
alc285_fixup_hp_coef_micmute_led(struct hda_codec * codec,const struct hda_fixup * fix,int action)4670 static void alc285_fixup_hp_coef_micmute_led(struct hda_codec *codec,
4671 				const struct hda_fixup *fix, int action)
4672 {
4673 	struct alc_spec *spec = codec->spec;
4674 
4675 	if (action == HDA_FIXUP_ACT_PRE_PROBE) {
4676 		spec->mic_led_coef.idx = 0x19;
4677 		spec->mic_led_coef.mask = 1 << 13;
4678 		spec->mic_led_coef.on = 1 << 13;
4679 		spec->mic_led_coef.off = 0;
4680 		snd_hda_gen_add_micmute_led_cdev(codec, coef_micmute_led_set);
4681 	}
4682 }
4683 
alc285_fixup_hp_gpio_micmute_led(struct hda_codec * codec,const struct hda_fixup * fix,int action)4684 static void alc285_fixup_hp_gpio_micmute_led(struct hda_codec *codec,
4685 				const struct hda_fixup *fix, int action)
4686 {
4687 	struct alc_spec *spec = codec->spec;
4688 
4689 	if (action == HDA_FIXUP_ACT_PRE_PROBE)
4690 		spec->micmute_led_polarity = 1;
4691 	alc_fixup_hp_gpio_led(codec, action, 0, 0x04);
4692 }
4693 
alc236_fixup_hp_coef_micmute_led(struct hda_codec * codec,const struct hda_fixup * fix,int action)4694 static void alc236_fixup_hp_coef_micmute_led(struct hda_codec *codec,
4695 				const struct hda_fixup *fix, int action)
4696 {
4697 	struct alc_spec *spec = codec->spec;
4698 
4699 	if (action == HDA_FIXUP_ACT_PRE_PROBE) {
4700 		spec->mic_led_coef.idx = 0x35;
4701 		spec->mic_led_coef.mask = 3 << 2;
4702 		spec->mic_led_coef.on = 2 << 2;
4703 		spec->mic_led_coef.off = 1 << 2;
4704 		snd_hda_gen_add_micmute_led_cdev(codec, coef_micmute_led_set);
4705 	}
4706 }
4707 
alc285_fixup_hp_mute_led(struct hda_codec * codec,const struct hda_fixup * fix,int action)4708 static void alc285_fixup_hp_mute_led(struct hda_codec *codec,
4709 				const struct hda_fixup *fix, int action)
4710 {
4711 	alc285_fixup_hp_mute_led_coefbit(codec, fix, action);
4712 	alc285_fixup_hp_coef_micmute_led(codec, fix, action);
4713 }
4714 
alc285_fixup_hp_spectre_x360_mute_led(struct hda_codec * codec,const struct hda_fixup * fix,int action)4715 static void alc285_fixup_hp_spectre_x360_mute_led(struct hda_codec *codec,
4716 				const struct hda_fixup *fix, int action)
4717 {
4718 	alc285_fixup_hp_mute_led_coefbit(codec, fix, action);
4719 	alc285_fixup_hp_gpio_micmute_led(codec, fix, action);
4720 }
4721 
alc236_fixup_hp_mute_led(struct hda_codec * codec,const struct hda_fixup * fix,int action)4722 static void alc236_fixup_hp_mute_led(struct hda_codec *codec,
4723 				const struct hda_fixup *fix, int action)
4724 {
4725 	alc236_fixup_hp_mute_led_coefbit(codec, fix, action);
4726 	alc236_fixup_hp_coef_micmute_led(codec, fix, action);
4727 }
4728 
alc236_fixup_hp_micmute_led_vref(struct hda_codec * codec,const struct hda_fixup * fix,int action)4729 static void alc236_fixup_hp_micmute_led_vref(struct hda_codec *codec,
4730 				const struct hda_fixup *fix, int action)
4731 {
4732 	struct alc_spec *spec = codec->spec;
4733 
4734 	if (action == HDA_FIXUP_ACT_PRE_PROBE) {
4735 		spec->cap_mute_led_nid = 0x1a;
4736 		snd_hda_gen_add_micmute_led_cdev(codec, vref_micmute_led_set);
4737 		codec->power_filter = led_power_filter;
4738 	}
4739 }
4740 
alc236_fixup_hp_mute_led_micmute_vref(struct hda_codec * codec,const struct hda_fixup * fix,int action)4741 static void alc236_fixup_hp_mute_led_micmute_vref(struct hda_codec *codec,
4742 				const struct hda_fixup *fix, int action)
4743 {
4744 	alc236_fixup_hp_mute_led_coefbit(codec, fix, action);
4745 	alc236_fixup_hp_micmute_led_vref(codec, fix, action);
4746 }
4747 
alc298_samsung_write_coef_pack(struct hda_codec * codec,const unsigned short coefs[2])4748 static inline void alc298_samsung_write_coef_pack(struct hda_codec *codec,
4749 						  const unsigned short coefs[2])
4750 {
4751 	alc_write_coef_idx(codec, 0x23, coefs[0]);
4752 	alc_write_coef_idx(codec, 0x25, coefs[1]);
4753 	alc_write_coef_idx(codec, 0x26, 0xb011);
4754 }
4755 
4756 struct alc298_samsung_amp_desc {
4757 	unsigned char nid;
4758 	unsigned short init_seq[2][2];
4759 };
4760 
alc298_fixup_samsung_amp(struct hda_codec * codec,const struct hda_fixup * fix,int action)4761 static void alc298_fixup_samsung_amp(struct hda_codec *codec,
4762 				     const struct hda_fixup *fix, int action)
4763 {
4764 	int i, j;
4765 	static const unsigned short init_seq[][2] = {
4766 		{ 0x19, 0x00 }, { 0x20, 0xc0 }, { 0x22, 0x44 }, { 0x23, 0x08 },
4767 		{ 0x24, 0x85 }, { 0x25, 0x41 }, { 0x35, 0x40 }, { 0x36, 0x01 },
4768 		{ 0x38, 0x81 }, { 0x3a, 0x03 }, { 0x3b, 0x81 }, { 0x40, 0x3e },
4769 		{ 0x41, 0x07 }, { 0x400, 0x1 }
4770 	};
4771 	static const struct alc298_samsung_amp_desc amps[] = {
4772 		{ 0x3a, { { 0x18, 0x1 }, { 0x26, 0x0 } } },
4773 		{ 0x39, { { 0x18, 0x2 }, { 0x26, 0x1 } } }
4774 	};
4775 
4776 	if (action != HDA_FIXUP_ACT_INIT)
4777 		return;
4778 
4779 	for (i = 0; i < ARRAY_SIZE(amps); i++) {
4780 		alc_write_coef_idx(codec, 0x22, amps[i].nid);
4781 
4782 		for (j = 0; j < ARRAY_SIZE(amps[i].init_seq); j++)
4783 			alc298_samsung_write_coef_pack(codec, amps[i].init_seq[j]);
4784 
4785 		for (j = 0; j < ARRAY_SIZE(init_seq); j++)
4786 			alc298_samsung_write_coef_pack(codec, init_seq[j]);
4787 	}
4788 }
4789 
4790 #if IS_REACHABLE(CONFIG_INPUT)
gpio2_mic_hotkey_event(struct hda_codec * codec,struct hda_jack_callback * event)4791 static void gpio2_mic_hotkey_event(struct hda_codec *codec,
4792 				   struct hda_jack_callback *event)
4793 {
4794 	struct alc_spec *spec = codec->spec;
4795 
4796 	/* GPIO2 just toggles on a keypress/keyrelease cycle. Therefore
4797 	   send both key on and key off event for every interrupt. */
4798 	input_report_key(spec->kb_dev, spec->alc_mute_keycode_map[ALC_KEY_MICMUTE_INDEX], 1);
4799 	input_sync(spec->kb_dev);
4800 	input_report_key(spec->kb_dev, spec->alc_mute_keycode_map[ALC_KEY_MICMUTE_INDEX], 0);
4801 	input_sync(spec->kb_dev);
4802 }
4803 
alc_register_micmute_input_device(struct hda_codec * codec)4804 static int alc_register_micmute_input_device(struct hda_codec *codec)
4805 {
4806 	struct alc_spec *spec = codec->spec;
4807 	int i;
4808 
4809 	spec->kb_dev = input_allocate_device();
4810 	if (!spec->kb_dev) {
4811 		codec_err(codec, "Out of memory (input_allocate_device)\n");
4812 		return -ENOMEM;
4813 	}
4814 
4815 	spec->alc_mute_keycode_map[ALC_KEY_MICMUTE_INDEX] = KEY_MICMUTE;
4816 
4817 	spec->kb_dev->name = "Microphone Mute Button";
4818 	spec->kb_dev->evbit[0] = BIT_MASK(EV_KEY);
4819 	spec->kb_dev->keycodesize = sizeof(spec->alc_mute_keycode_map[0]);
4820 	spec->kb_dev->keycodemax = ARRAY_SIZE(spec->alc_mute_keycode_map);
4821 	spec->kb_dev->keycode = spec->alc_mute_keycode_map;
4822 	for (i = 0; i < ARRAY_SIZE(spec->alc_mute_keycode_map); i++)
4823 		set_bit(spec->alc_mute_keycode_map[i], spec->kb_dev->keybit);
4824 
4825 	if (input_register_device(spec->kb_dev)) {
4826 		codec_err(codec, "input_register_device failed\n");
4827 		input_free_device(spec->kb_dev);
4828 		spec->kb_dev = NULL;
4829 		return -ENOMEM;
4830 	}
4831 
4832 	return 0;
4833 }
4834 
4835 /* GPIO1 = set according to SKU external amp
4836  * GPIO2 = mic mute hotkey
4837  * GPIO3 = mute LED
4838  * GPIO4 = mic mute LED
4839  */
alc280_fixup_hp_gpio2_mic_hotkey(struct hda_codec * codec,const struct hda_fixup * fix,int action)4840 static void alc280_fixup_hp_gpio2_mic_hotkey(struct hda_codec *codec,
4841 					     const struct hda_fixup *fix, int action)
4842 {
4843 	struct alc_spec *spec = codec->spec;
4844 
4845 	alc_fixup_hp_gpio_led(codec, action, 0x08, 0x10);
4846 	if (action == HDA_FIXUP_ACT_PRE_PROBE) {
4847 		spec->init_amp = ALC_INIT_DEFAULT;
4848 		if (alc_register_micmute_input_device(codec) != 0)
4849 			return;
4850 
4851 		spec->gpio_mask |= 0x06;
4852 		spec->gpio_dir |= 0x02;
4853 		spec->gpio_data |= 0x02;
4854 		snd_hda_codec_write_cache(codec, codec->core.afg, 0,
4855 					  AC_VERB_SET_GPIO_UNSOLICITED_RSP_MASK, 0x04);
4856 		snd_hda_jack_detect_enable_callback(codec, codec->core.afg,
4857 						    gpio2_mic_hotkey_event);
4858 		return;
4859 	}
4860 
4861 	if (!spec->kb_dev)
4862 		return;
4863 
4864 	switch (action) {
4865 	case HDA_FIXUP_ACT_FREE:
4866 		input_unregister_device(spec->kb_dev);
4867 		spec->kb_dev = NULL;
4868 	}
4869 }
4870 
4871 /* Line2 = mic mute hotkey
4872  * GPIO2 = mic mute LED
4873  */
alc233_fixup_lenovo_line2_mic_hotkey(struct hda_codec * codec,const struct hda_fixup * fix,int action)4874 static void alc233_fixup_lenovo_line2_mic_hotkey(struct hda_codec *codec,
4875 					     const struct hda_fixup *fix, int action)
4876 {
4877 	struct alc_spec *spec = codec->spec;
4878 
4879 	alc_fixup_hp_gpio_led(codec, action, 0, 0x04);
4880 	if (action == HDA_FIXUP_ACT_PRE_PROBE) {
4881 		spec->init_amp = ALC_INIT_DEFAULT;
4882 		if (alc_register_micmute_input_device(codec) != 0)
4883 			return;
4884 
4885 		snd_hda_jack_detect_enable_callback(codec, 0x1b,
4886 						    gpio2_mic_hotkey_event);
4887 		return;
4888 	}
4889 
4890 	if (!spec->kb_dev)
4891 		return;
4892 
4893 	switch (action) {
4894 	case HDA_FIXUP_ACT_FREE:
4895 		input_unregister_device(spec->kb_dev);
4896 		spec->kb_dev = NULL;
4897 	}
4898 }
4899 #else /* INPUT */
4900 #define alc280_fixup_hp_gpio2_mic_hotkey	NULL
4901 #define alc233_fixup_lenovo_line2_mic_hotkey	NULL
4902 #endif /* INPUT */
4903 
alc269_fixup_hp_line1_mic1_led(struct hda_codec * codec,const struct hda_fixup * fix,int action)4904 static void alc269_fixup_hp_line1_mic1_led(struct hda_codec *codec,
4905 				const struct hda_fixup *fix, int action)
4906 {
4907 	struct alc_spec *spec = codec->spec;
4908 
4909 	alc269_fixup_hp_mute_led_micx(codec, fix, action, 0x1a);
4910 	if (action == HDA_FIXUP_ACT_PRE_PROBE) {
4911 		spec->cap_mute_led_nid = 0x18;
4912 		snd_hda_gen_add_micmute_led_cdev(codec, vref_micmute_led_set);
4913 	}
4914 }
4915 
4916 static const struct coef_fw alc225_pre_hsmode[] = {
4917 	UPDATE_COEF(0x4a, 1<<8, 0),
4918 	UPDATE_COEFEX(0x57, 0x05, 1<<14, 0),
4919 	UPDATE_COEF(0x63, 3<<14, 3<<14),
4920 	UPDATE_COEF(0x4a, 3<<4, 2<<4),
4921 	UPDATE_COEF(0x4a, 3<<10, 3<<10),
4922 	UPDATE_COEF(0x45, 0x3f<<10, 0x34<<10),
4923 	UPDATE_COEF(0x4a, 3<<10, 0),
4924 	{}
4925 };
4926 
alc_headset_mode_unplugged(struct hda_codec * codec)4927 static void alc_headset_mode_unplugged(struct hda_codec *codec)
4928 {
4929 	struct alc_spec *spec = codec->spec;
4930 	static const struct coef_fw coef0255[] = {
4931 		WRITE_COEF(0x1b, 0x0c0b), /* LDO and MISC control */
4932 		WRITE_COEF(0x45, 0xd089), /* UAJ function set to menual mode */
4933 		UPDATE_COEFEX(0x57, 0x05, 1<<14, 0), /* Direct Drive HP Amp control(Set to verb control)*/
4934 		WRITE_COEF(0x06, 0x6104), /* Set MIC2 Vref gate with HP */
4935 		WRITE_COEFEX(0x57, 0x03, 0x8aa6), /* Direct Drive HP Amp control */
4936 		{}
4937 	};
4938 	static const struct coef_fw coef0256[] = {
4939 		WRITE_COEF(0x1b, 0x0c4b), /* LDO and MISC control */
4940 		WRITE_COEF(0x45, 0xd089), /* UAJ function set to menual mode */
4941 		WRITE_COEF(0x06, 0x6104), /* Set MIC2 Vref gate with HP */
4942 		WRITE_COEFEX(0x57, 0x03, 0x09a3), /* Direct Drive HP Amp control */
4943 		UPDATE_COEFEX(0x57, 0x05, 1<<14, 0), /* Direct Drive HP Amp control(Set to verb control)*/
4944 		{}
4945 	};
4946 	static const struct coef_fw coef0233[] = {
4947 		WRITE_COEF(0x1b, 0x0c0b),
4948 		WRITE_COEF(0x45, 0xc429),
4949 		UPDATE_COEF(0x35, 0x4000, 0),
4950 		WRITE_COEF(0x06, 0x2104),
4951 		WRITE_COEF(0x1a, 0x0001),
4952 		WRITE_COEF(0x26, 0x0004),
4953 		WRITE_COEF(0x32, 0x42a3),
4954 		{}
4955 	};
4956 	static const struct coef_fw coef0288[] = {
4957 		UPDATE_COEF(0x4f, 0xfcc0, 0xc400),
4958 		UPDATE_COEF(0x50, 0x2000, 0x2000),
4959 		UPDATE_COEF(0x56, 0x0006, 0x0006),
4960 		UPDATE_COEF(0x66, 0x0008, 0),
4961 		UPDATE_COEF(0x67, 0x2000, 0),
4962 		{}
4963 	};
4964 	static const struct coef_fw coef0298[] = {
4965 		UPDATE_COEF(0x19, 0x1300, 0x0300),
4966 		{}
4967 	};
4968 	static const struct coef_fw coef0292[] = {
4969 		WRITE_COEF(0x76, 0x000e),
4970 		WRITE_COEF(0x6c, 0x2400),
4971 		WRITE_COEF(0x18, 0x7308),
4972 		WRITE_COEF(0x6b, 0xc429),
4973 		{}
4974 	};
4975 	static const struct coef_fw coef0293[] = {
4976 		UPDATE_COEF(0x10, 7<<8, 6<<8), /* SET Line1 JD to 0 */
4977 		UPDATE_COEFEX(0x57, 0x05, 1<<15|1<<13, 0x0), /* SET charge pump by verb */
4978 		UPDATE_COEFEX(0x57, 0x03, 1<<10, 1<<10), /* SET EN_OSW to 1 */
4979 		UPDATE_COEF(0x1a, 1<<3, 1<<3), /* Combo JD gating with LINE1-VREFO */
4980 		WRITE_COEF(0x45, 0xc429), /* Set to TRS type */
4981 		UPDATE_COEF(0x4a, 0x000f, 0x000e), /* Combo Jack auto detect */
4982 		{}
4983 	};
4984 	static const struct coef_fw coef0668[] = {
4985 		WRITE_COEF(0x15, 0x0d40),
4986 		WRITE_COEF(0xb7, 0x802b),
4987 		{}
4988 	};
4989 	static const struct coef_fw coef0225[] = {
4990 		UPDATE_COEF(0x63, 3<<14, 0),
4991 		{}
4992 	};
4993 	static const struct coef_fw coef0274[] = {
4994 		UPDATE_COEF(0x4a, 0x0100, 0),
4995 		UPDATE_COEFEX(0x57, 0x05, 0x4000, 0),
4996 		UPDATE_COEF(0x6b, 0xf000, 0x5000),
4997 		UPDATE_COEF(0x4a, 0x0010, 0),
4998 		UPDATE_COEF(0x4a, 0x0c00, 0x0c00),
4999 		WRITE_COEF(0x45, 0x5289),
5000 		UPDATE_COEF(0x4a, 0x0c00, 0),
5001 		{}
5002 	};
5003 
5004 	if (spec->no_internal_mic_pin) {
5005 		alc_update_coef_idx(codec, 0x45, 0xf<<12 | 1<<10, 5<<12);
5006 		return;
5007 	}
5008 
5009 	switch (codec->core.vendor_id) {
5010 	case 0x10ec0255:
5011 		alc_process_coef_fw(codec, coef0255);
5012 		break;
5013 	case 0x10ec0230:
5014 	case 0x10ec0236:
5015 	case 0x10ec0256:
5016 	case 0x19e58326:
5017 		alc_process_coef_fw(codec, coef0256);
5018 		break;
5019 	case 0x10ec0234:
5020 	case 0x10ec0274:
5021 	case 0x10ec0294:
5022 		alc_process_coef_fw(codec, coef0274);
5023 		break;
5024 	case 0x10ec0233:
5025 	case 0x10ec0283:
5026 		alc_process_coef_fw(codec, coef0233);
5027 		break;
5028 	case 0x10ec0286:
5029 	case 0x10ec0288:
5030 		alc_process_coef_fw(codec, coef0288);
5031 		break;
5032 	case 0x10ec0298:
5033 		alc_process_coef_fw(codec, coef0298);
5034 		alc_process_coef_fw(codec, coef0288);
5035 		break;
5036 	case 0x10ec0292:
5037 		alc_process_coef_fw(codec, coef0292);
5038 		break;
5039 	case 0x10ec0293:
5040 		alc_process_coef_fw(codec, coef0293);
5041 		break;
5042 	case 0x10ec0668:
5043 		alc_process_coef_fw(codec, coef0668);
5044 		break;
5045 	case 0x10ec0215:
5046 	case 0x10ec0225:
5047 	case 0x10ec0285:
5048 	case 0x10ec0295:
5049 	case 0x10ec0289:
5050 	case 0x10ec0299:
5051 		alc_process_coef_fw(codec, alc225_pre_hsmode);
5052 		alc_process_coef_fw(codec, coef0225);
5053 		break;
5054 	case 0x10ec0867:
5055 		alc_update_coefex_idx(codec, 0x57, 0x5, 1<<14, 0);
5056 		break;
5057 	}
5058 	codec_dbg(codec, "Headset jack set to unplugged mode.\n");
5059 }
5060 
5061 
alc_headset_mode_mic_in(struct hda_codec * codec,hda_nid_t hp_pin,hda_nid_t mic_pin)5062 static void alc_headset_mode_mic_in(struct hda_codec *codec, hda_nid_t hp_pin,
5063 				    hda_nid_t mic_pin)
5064 {
5065 	static const struct coef_fw coef0255[] = {
5066 		WRITE_COEFEX(0x57, 0x03, 0x8aa6),
5067 		WRITE_COEF(0x06, 0x6100), /* Set MIC2 Vref gate to normal */
5068 		{}
5069 	};
5070 	static const struct coef_fw coef0256[] = {
5071 		UPDATE_COEFEX(0x57, 0x05, 1<<14, 1<<14), /* Direct Drive HP Amp control(Set to verb control)*/
5072 		WRITE_COEFEX(0x57, 0x03, 0x09a3),
5073 		WRITE_COEF(0x06, 0x6100), /* Set MIC2 Vref gate to normal */
5074 		{}
5075 	};
5076 	static const struct coef_fw coef0233[] = {
5077 		UPDATE_COEF(0x35, 0, 1<<14),
5078 		WRITE_COEF(0x06, 0x2100),
5079 		WRITE_COEF(0x1a, 0x0021),
5080 		WRITE_COEF(0x26, 0x008c),
5081 		{}
5082 	};
5083 	static const struct coef_fw coef0288[] = {
5084 		UPDATE_COEF(0x4f, 0x00c0, 0),
5085 		UPDATE_COEF(0x50, 0x2000, 0),
5086 		UPDATE_COEF(0x56, 0x0006, 0),
5087 		UPDATE_COEF(0x4f, 0xfcc0, 0xc400),
5088 		UPDATE_COEF(0x66, 0x0008, 0x0008),
5089 		UPDATE_COEF(0x67, 0x2000, 0x2000),
5090 		{}
5091 	};
5092 	static const struct coef_fw coef0292[] = {
5093 		WRITE_COEF(0x19, 0xa208),
5094 		WRITE_COEF(0x2e, 0xacf0),
5095 		{}
5096 	};
5097 	static const struct coef_fw coef0293[] = {
5098 		UPDATE_COEFEX(0x57, 0x05, 0, 1<<15|1<<13), /* SET charge pump by verb */
5099 		UPDATE_COEFEX(0x57, 0x03, 1<<10, 0), /* SET EN_OSW to 0 */
5100 		UPDATE_COEF(0x1a, 1<<3, 0), /* Combo JD gating without LINE1-VREFO */
5101 		{}
5102 	};
5103 	static const struct coef_fw coef0688[] = {
5104 		WRITE_COEF(0xb7, 0x802b),
5105 		WRITE_COEF(0xb5, 0x1040),
5106 		UPDATE_COEF(0xc3, 0, 1<<12),
5107 		{}
5108 	};
5109 	static const struct coef_fw coef0225[] = {
5110 		UPDATE_COEFEX(0x57, 0x05, 1<<14, 1<<14),
5111 		UPDATE_COEF(0x4a, 3<<4, 2<<4),
5112 		UPDATE_COEF(0x63, 3<<14, 0),
5113 		{}
5114 	};
5115 	static const struct coef_fw coef0274[] = {
5116 		UPDATE_COEFEX(0x57, 0x05, 0x4000, 0x4000),
5117 		UPDATE_COEF(0x4a, 0x0010, 0),
5118 		UPDATE_COEF(0x6b, 0xf000, 0),
5119 		{}
5120 	};
5121 
5122 	switch (codec->core.vendor_id) {
5123 	case 0x10ec0255:
5124 		alc_write_coef_idx(codec, 0x45, 0xc489);
5125 		snd_hda_set_pin_ctl_cache(codec, hp_pin, 0);
5126 		alc_process_coef_fw(codec, coef0255);
5127 		snd_hda_set_pin_ctl_cache(codec, mic_pin, PIN_VREF50);
5128 		break;
5129 	case 0x10ec0230:
5130 	case 0x10ec0236:
5131 	case 0x10ec0256:
5132 	case 0x19e58326:
5133 		alc_write_coef_idx(codec, 0x45, 0xc489);
5134 		snd_hda_set_pin_ctl_cache(codec, hp_pin, 0);
5135 		alc_process_coef_fw(codec, coef0256);
5136 		snd_hda_set_pin_ctl_cache(codec, mic_pin, PIN_VREF50);
5137 		break;
5138 	case 0x10ec0234:
5139 	case 0x10ec0274:
5140 	case 0x10ec0294:
5141 		alc_write_coef_idx(codec, 0x45, 0x4689);
5142 		snd_hda_set_pin_ctl_cache(codec, hp_pin, 0);
5143 		alc_process_coef_fw(codec, coef0274);
5144 		snd_hda_set_pin_ctl_cache(codec, mic_pin, PIN_VREF50);
5145 		break;
5146 	case 0x10ec0233:
5147 	case 0x10ec0283:
5148 		alc_write_coef_idx(codec, 0x45, 0xc429);
5149 		snd_hda_set_pin_ctl_cache(codec, hp_pin, 0);
5150 		alc_process_coef_fw(codec, coef0233);
5151 		snd_hda_set_pin_ctl_cache(codec, mic_pin, PIN_VREF50);
5152 		break;
5153 	case 0x10ec0286:
5154 	case 0x10ec0288:
5155 	case 0x10ec0298:
5156 		snd_hda_set_pin_ctl_cache(codec, hp_pin, 0);
5157 		alc_process_coef_fw(codec, coef0288);
5158 		snd_hda_set_pin_ctl_cache(codec, mic_pin, PIN_VREF50);
5159 		break;
5160 	case 0x10ec0292:
5161 		snd_hda_set_pin_ctl_cache(codec, hp_pin, 0);
5162 		alc_process_coef_fw(codec, coef0292);
5163 		break;
5164 	case 0x10ec0293:
5165 		/* Set to TRS mode */
5166 		alc_write_coef_idx(codec, 0x45, 0xc429);
5167 		snd_hda_set_pin_ctl_cache(codec, hp_pin, 0);
5168 		alc_process_coef_fw(codec, coef0293);
5169 		snd_hda_set_pin_ctl_cache(codec, mic_pin, PIN_VREF50);
5170 		break;
5171 	case 0x10ec0867:
5172 		alc_update_coefex_idx(codec, 0x57, 0x5, 0, 1<<14);
5173 		fallthrough;
5174 	case 0x10ec0221:
5175 	case 0x10ec0662:
5176 		snd_hda_set_pin_ctl_cache(codec, hp_pin, 0);
5177 		snd_hda_set_pin_ctl_cache(codec, mic_pin, PIN_VREF50);
5178 		break;
5179 	case 0x10ec0668:
5180 		alc_write_coef_idx(codec, 0x11, 0x0001);
5181 		snd_hda_set_pin_ctl_cache(codec, hp_pin, 0);
5182 		alc_process_coef_fw(codec, coef0688);
5183 		snd_hda_set_pin_ctl_cache(codec, mic_pin, PIN_VREF50);
5184 		break;
5185 	case 0x10ec0215:
5186 	case 0x10ec0225:
5187 	case 0x10ec0285:
5188 	case 0x10ec0295:
5189 	case 0x10ec0289:
5190 	case 0x10ec0299:
5191 		alc_process_coef_fw(codec, alc225_pre_hsmode);
5192 		alc_update_coef_idx(codec, 0x45, 0x3f<<10, 0x31<<10);
5193 		snd_hda_set_pin_ctl_cache(codec, hp_pin, 0);
5194 		alc_process_coef_fw(codec, coef0225);
5195 		snd_hda_set_pin_ctl_cache(codec, mic_pin, PIN_VREF50);
5196 		break;
5197 	}
5198 	codec_dbg(codec, "Headset jack set to mic-in mode.\n");
5199 }
5200 
alc_headset_mode_default(struct hda_codec * codec)5201 static void alc_headset_mode_default(struct hda_codec *codec)
5202 {
5203 	static const struct coef_fw coef0225[] = {
5204 		UPDATE_COEF(0x45, 0x3f<<10, 0x30<<10),
5205 		UPDATE_COEF(0x45, 0x3f<<10, 0x31<<10),
5206 		UPDATE_COEF(0x49, 3<<8, 0<<8),
5207 		UPDATE_COEF(0x4a, 3<<4, 3<<4),
5208 		UPDATE_COEF(0x63, 3<<14, 0),
5209 		UPDATE_COEF(0x67, 0xf000, 0x3000),
5210 		{}
5211 	};
5212 	static const struct coef_fw coef0255[] = {
5213 		WRITE_COEF(0x45, 0xc089),
5214 		WRITE_COEF(0x45, 0xc489),
5215 		WRITE_COEFEX(0x57, 0x03, 0x8ea6),
5216 		WRITE_COEF(0x49, 0x0049),
5217 		{}
5218 	};
5219 	static const struct coef_fw coef0256[] = {
5220 		WRITE_COEF(0x45, 0xc489),
5221 		WRITE_COEFEX(0x57, 0x03, 0x0da3),
5222 		WRITE_COEF(0x49, 0x0049),
5223 		UPDATE_COEFEX(0x57, 0x05, 1<<14, 0), /* Direct Drive HP Amp control(Set to verb control)*/
5224 		WRITE_COEF(0x06, 0x6100),
5225 		{}
5226 	};
5227 	static const struct coef_fw coef0233[] = {
5228 		WRITE_COEF(0x06, 0x2100),
5229 		WRITE_COEF(0x32, 0x4ea3),
5230 		{}
5231 	};
5232 	static const struct coef_fw coef0288[] = {
5233 		UPDATE_COEF(0x4f, 0xfcc0, 0xc400), /* Set to TRS type */
5234 		UPDATE_COEF(0x50, 0x2000, 0x2000),
5235 		UPDATE_COEF(0x56, 0x0006, 0x0006),
5236 		UPDATE_COEF(0x66, 0x0008, 0),
5237 		UPDATE_COEF(0x67, 0x2000, 0),
5238 		{}
5239 	};
5240 	static const struct coef_fw coef0292[] = {
5241 		WRITE_COEF(0x76, 0x000e),
5242 		WRITE_COEF(0x6c, 0x2400),
5243 		WRITE_COEF(0x6b, 0xc429),
5244 		WRITE_COEF(0x18, 0x7308),
5245 		{}
5246 	};
5247 	static const struct coef_fw coef0293[] = {
5248 		UPDATE_COEF(0x4a, 0x000f, 0x000e), /* Combo Jack auto detect */
5249 		WRITE_COEF(0x45, 0xC429), /* Set to TRS type */
5250 		UPDATE_COEF(0x1a, 1<<3, 0), /* Combo JD gating without LINE1-VREFO */
5251 		{}
5252 	};
5253 	static const struct coef_fw coef0688[] = {
5254 		WRITE_COEF(0x11, 0x0041),
5255 		WRITE_COEF(0x15, 0x0d40),
5256 		WRITE_COEF(0xb7, 0x802b),
5257 		{}
5258 	};
5259 	static const struct coef_fw coef0274[] = {
5260 		WRITE_COEF(0x45, 0x4289),
5261 		UPDATE_COEF(0x4a, 0x0010, 0x0010),
5262 		UPDATE_COEF(0x6b, 0x0f00, 0),
5263 		UPDATE_COEF(0x49, 0x0300, 0x0300),
5264 		{}
5265 	};
5266 
5267 	switch (codec->core.vendor_id) {
5268 	case 0x10ec0215:
5269 	case 0x10ec0225:
5270 	case 0x10ec0285:
5271 	case 0x10ec0295:
5272 	case 0x10ec0289:
5273 	case 0x10ec0299:
5274 		alc_process_coef_fw(codec, alc225_pre_hsmode);
5275 		alc_process_coef_fw(codec, coef0225);
5276 		break;
5277 	case 0x10ec0255:
5278 		alc_process_coef_fw(codec, coef0255);
5279 		break;
5280 	case 0x10ec0230:
5281 	case 0x10ec0236:
5282 	case 0x10ec0256:
5283 	case 0x19e58326:
5284 		alc_write_coef_idx(codec, 0x1b, 0x0e4b);
5285 		alc_write_coef_idx(codec, 0x45, 0xc089);
5286 		msleep(50);
5287 		alc_process_coef_fw(codec, coef0256);
5288 		break;
5289 	case 0x10ec0234:
5290 	case 0x10ec0274:
5291 	case 0x10ec0294:
5292 		alc_process_coef_fw(codec, coef0274);
5293 		break;
5294 	case 0x10ec0233:
5295 	case 0x10ec0283:
5296 		alc_process_coef_fw(codec, coef0233);
5297 		break;
5298 	case 0x10ec0286:
5299 	case 0x10ec0288:
5300 	case 0x10ec0298:
5301 		alc_process_coef_fw(codec, coef0288);
5302 		break;
5303 	case 0x10ec0292:
5304 		alc_process_coef_fw(codec, coef0292);
5305 		break;
5306 	case 0x10ec0293:
5307 		alc_process_coef_fw(codec, coef0293);
5308 		break;
5309 	case 0x10ec0668:
5310 		alc_process_coef_fw(codec, coef0688);
5311 		break;
5312 	case 0x10ec0867:
5313 		alc_update_coefex_idx(codec, 0x57, 0x5, 1<<14, 0);
5314 		break;
5315 	}
5316 	codec_dbg(codec, "Headset jack set to headphone (default) mode.\n");
5317 }
5318 
5319 /* Iphone type */
alc_headset_mode_ctia(struct hda_codec * codec)5320 static void alc_headset_mode_ctia(struct hda_codec *codec)
5321 {
5322 	int val;
5323 
5324 	static const struct coef_fw coef0255[] = {
5325 		WRITE_COEF(0x45, 0xd489), /* Set to CTIA type */
5326 		WRITE_COEF(0x1b, 0x0c2b),
5327 		WRITE_COEFEX(0x57, 0x03, 0x8ea6),
5328 		{}
5329 	};
5330 	static const struct coef_fw coef0256[] = {
5331 		WRITE_COEF(0x45, 0xd489), /* Set to CTIA type */
5332 		WRITE_COEF(0x1b, 0x0e6b),
5333 		{}
5334 	};
5335 	static const struct coef_fw coef0233[] = {
5336 		WRITE_COEF(0x45, 0xd429),
5337 		WRITE_COEF(0x1b, 0x0c2b),
5338 		WRITE_COEF(0x32, 0x4ea3),
5339 		{}
5340 	};
5341 	static const struct coef_fw coef0288[] = {
5342 		UPDATE_COEF(0x50, 0x2000, 0x2000),
5343 		UPDATE_COEF(0x56, 0x0006, 0x0006),
5344 		UPDATE_COEF(0x66, 0x0008, 0),
5345 		UPDATE_COEF(0x67, 0x2000, 0),
5346 		{}
5347 	};
5348 	static const struct coef_fw coef0292[] = {
5349 		WRITE_COEF(0x6b, 0xd429),
5350 		WRITE_COEF(0x76, 0x0008),
5351 		WRITE_COEF(0x18, 0x7388),
5352 		{}
5353 	};
5354 	static const struct coef_fw coef0293[] = {
5355 		WRITE_COEF(0x45, 0xd429), /* Set to ctia type */
5356 		UPDATE_COEF(0x10, 7<<8, 7<<8), /* SET Line1 JD to 1 */
5357 		{}
5358 	};
5359 	static const struct coef_fw coef0688[] = {
5360 		WRITE_COEF(0x11, 0x0001),
5361 		WRITE_COEF(0x15, 0x0d60),
5362 		WRITE_COEF(0xc3, 0x0000),
5363 		{}
5364 	};
5365 	static const struct coef_fw coef0225_1[] = {
5366 		UPDATE_COEF(0x45, 0x3f<<10, 0x35<<10),
5367 		UPDATE_COEF(0x63, 3<<14, 2<<14),
5368 		{}
5369 	};
5370 	static const struct coef_fw coef0225_2[] = {
5371 		UPDATE_COEF(0x45, 0x3f<<10, 0x35<<10),
5372 		UPDATE_COEF(0x63, 3<<14, 1<<14),
5373 		{}
5374 	};
5375 
5376 	switch (codec->core.vendor_id) {
5377 	case 0x10ec0255:
5378 		alc_process_coef_fw(codec, coef0255);
5379 		break;
5380 	case 0x10ec0230:
5381 	case 0x10ec0236:
5382 	case 0x10ec0256:
5383 	case 0x19e58326:
5384 		alc_process_coef_fw(codec, coef0256);
5385 		break;
5386 	case 0x10ec0234:
5387 	case 0x10ec0274:
5388 	case 0x10ec0294:
5389 		alc_write_coef_idx(codec, 0x45, 0xd689);
5390 		break;
5391 	case 0x10ec0233:
5392 	case 0x10ec0283:
5393 		alc_process_coef_fw(codec, coef0233);
5394 		break;
5395 	case 0x10ec0298:
5396 		val = alc_read_coef_idx(codec, 0x50);
5397 		if (val & (1 << 12)) {
5398 			alc_update_coef_idx(codec, 0x8e, 0x0070, 0x0020);
5399 			alc_update_coef_idx(codec, 0x4f, 0xfcc0, 0xd400);
5400 			msleep(300);
5401 		} else {
5402 			alc_update_coef_idx(codec, 0x8e, 0x0070, 0x0010);
5403 			alc_update_coef_idx(codec, 0x4f, 0xfcc0, 0xd400);
5404 			msleep(300);
5405 		}
5406 		break;
5407 	case 0x10ec0286:
5408 	case 0x10ec0288:
5409 		alc_update_coef_idx(codec, 0x4f, 0xfcc0, 0xd400);
5410 		msleep(300);
5411 		alc_process_coef_fw(codec, coef0288);
5412 		break;
5413 	case 0x10ec0292:
5414 		alc_process_coef_fw(codec, coef0292);
5415 		break;
5416 	case 0x10ec0293:
5417 		alc_process_coef_fw(codec, coef0293);
5418 		break;
5419 	case 0x10ec0668:
5420 		alc_process_coef_fw(codec, coef0688);
5421 		break;
5422 	case 0x10ec0215:
5423 	case 0x10ec0225:
5424 	case 0x10ec0285:
5425 	case 0x10ec0295:
5426 	case 0x10ec0289:
5427 	case 0x10ec0299:
5428 		val = alc_read_coef_idx(codec, 0x45);
5429 		if (val & (1 << 9))
5430 			alc_process_coef_fw(codec, coef0225_2);
5431 		else
5432 			alc_process_coef_fw(codec, coef0225_1);
5433 		break;
5434 	case 0x10ec0867:
5435 		alc_update_coefex_idx(codec, 0x57, 0x5, 1<<14, 0);
5436 		break;
5437 	}
5438 	codec_dbg(codec, "Headset jack set to iPhone-style headset mode.\n");
5439 }
5440 
5441 /* Nokia type */
alc_headset_mode_omtp(struct hda_codec * codec)5442 static void alc_headset_mode_omtp(struct hda_codec *codec)
5443 {
5444 	static const struct coef_fw coef0255[] = {
5445 		WRITE_COEF(0x45, 0xe489), /* Set to OMTP Type */
5446 		WRITE_COEF(0x1b, 0x0c2b),
5447 		WRITE_COEFEX(0x57, 0x03, 0x8ea6),
5448 		{}
5449 	};
5450 	static const struct coef_fw coef0256[] = {
5451 		WRITE_COEF(0x45, 0xe489), /* Set to OMTP Type */
5452 		WRITE_COEF(0x1b, 0x0e6b),
5453 		{}
5454 	};
5455 	static const struct coef_fw coef0233[] = {
5456 		WRITE_COEF(0x45, 0xe429),
5457 		WRITE_COEF(0x1b, 0x0c2b),
5458 		WRITE_COEF(0x32, 0x4ea3),
5459 		{}
5460 	};
5461 	static const struct coef_fw coef0288[] = {
5462 		UPDATE_COEF(0x50, 0x2000, 0x2000),
5463 		UPDATE_COEF(0x56, 0x0006, 0x0006),
5464 		UPDATE_COEF(0x66, 0x0008, 0),
5465 		UPDATE_COEF(0x67, 0x2000, 0),
5466 		{}
5467 	};
5468 	static const struct coef_fw coef0292[] = {
5469 		WRITE_COEF(0x6b, 0xe429),
5470 		WRITE_COEF(0x76, 0x0008),
5471 		WRITE_COEF(0x18, 0x7388),
5472 		{}
5473 	};
5474 	static const struct coef_fw coef0293[] = {
5475 		WRITE_COEF(0x45, 0xe429), /* Set to omtp type */
5476 		UPDATE_COEF(0x10, 7<<8, 7<<8), /* SET Line1 JD to 1 */
5477 		{}
5478 	};
5479 	static const struct coef_fw coef0688[] = {
5480 		WRITE_COEF(0x11, 0x0001),
5481 		WRITE_COEF(0x15, 0x0d50),
5482 		WRITE_COEF(0xc3, 0x0000),
5483 		{}
5484 	};
5485 	static const struct coef_fw coef0225[] = {
5486 		UPDATE_COEF(0x45, 0x3f<<10, 0x39<<10),
5487 		UPDATE_COEF(0x63, 3<<14, 2<<14),
5488 		{}
5489 	};
5490 
5491 	switch (codec->core.vendor_id) {
5492 	case 0x10ec0255:
5493 		alc_process_coef_fw(codec, coef0255);
5494 		break;
5495 	case 0x10ec0230:
5496 	case 0x10ec0236:
5497 	case 0x10ec0256:
5498 	case 0x19e58326:
5499 		alc_process_coef_fw(codec, coef0256);
5500 		break;
5501 	case 0x10ec0234:
5502 	case 0x10ec0274:
5503 	case 0x10ec0294:
5504 		alc_write_coef_idx(codec, 0x45, 0xe689);
5505 		break;
5506 	case 0x10ec0233:
5507 	case 0x10ec0283:
5508 		alc_process_coef_fw(codec, coef0233);
5509 		break;
5510 	case 0x10ec0298:
5511 		alc_update_coef_idx(codec, 0x8e, 0x0070, 0x0010);/* Headset output enable */
5512 		alc_update_coef_idx(codec, 0x4f, 0xfcc0, 0xe400);
5513 		msleep(300);
5514 		break;
5515 	case 0x10ec0286:
5516 	case 0x10ec0288:
5517 		alc_update_coef_idx(codec, 0x4f, 0xfcc0, 0xe400);
5518 		msleep(300);
5519 		alc_process_coef_fw(codec, coef0288);
5520 		break;
5521 	case 0x10ec0292:
5522 		alc_process_coef_fw(codec, coef0292);
5523 		break;
5524 	case 0x10ec0293:
5525 		alc_process_coef_fw(codec, coef0293);
5526 		break;
5527 	case 0x10ec0668:
5528 		alc_process_coef_fw(codec, coef0688);
5529 		break;
5530 	case 0x10ec0215:
5531 	case 0x10ec0225:
5532 	case 0x10ec0285:
5533 	case 0x10ec0295:
5534 	case 0x10ec0289:
5535 	case 0x10ec0299:
5536 		alc_process_coef_fw(codec, coef0225);
5537 		break;
5538 	}
5539 	codec_dbg(codec, "Headset jack set to Nokia-style headset mode.\n");
5540 }
5541 
alc_determine_headset_type(struct hda_codec * codec)5542 static void alc_determine_headset_type(struct hda_codec *codec)
5543 {
5544 	int val;
5545 	bool is_ctia = false;
5546 	struct alc_spec *spec = codec->spec;
5547 	static const struct coef_fw coef0255[] = {
5548 		WRITE_COEF(0x45, 0xd089), /* combo jack auto switch control(Check type)*/
5549 		WRITE_COEF(0x49, 0x0149), /* combo jack auto switch control(Vref
5550  conteol) */
5551 		{}
5552 	};
5553 	static const struct coef_fw coef0288[] = {
5554 		UPDATE_COEF(0x4f, 0xfcc0, 0xd400), /* Check Type */
5555 		{}
5556 	};
5557 	static const struct coef_fw coef0298[] = {
5558 		UPDATE_COEF(0x50, 0x2000, 0x2000),
5559 		UPDATE_COEF(0x56, 0x0006, 0x0006),
5560 		UPDATE_COEF(0x66, 0x0008, 0),
5561 		UPDATE_COEF(0x67, 0x2000, 0),
5562 		UPDATE_COEF(0x19, 0x1300, 0x1300),
5563 		{}
5564 	};
5565 	static const struct coef_fw coef0293[] = {
5566 		UPDATE_COEF(0x4a, 0x000f, 0x0008), /* Combo Jack auto detect */
5567 		WRITE_COEF(0x45, 0xD429), /* Set to ctia type */
5568 		{}
5569 	};
5570 	static const struct coef_fw coef0688[] = {
5571 		WRITE_COEF(0x11, 0x0001),
5572 		WRITE_COEF(0xb7, 0x802b),
5573 		WRITE_COEF(0x15, 0x0d60),
5574 		WRITE_COEF(0xc3, 0x0c00),
5575 		{}
5576 	};
5577 	static const struct coef_fw coef0274[] = {
5578 		UPDATE_COEF(0x4a, 0x0010, 0),
5579 		UPDATE_COEF(0x4a, 0x8000, 0),
5580 		WRITE_COEF(0x45, 0xd289),
5581 		UPDATE_COEF(0x49, 0x0300, 0x0300),
5582 		{}
5583 	};
5584 
5585 	if (spec->no_internal_mic_pin) {
5586 		alc_update_coef_idx(codec, 0x45, 0xf<<12 | 1<<10, 5<<12);
5587 		return;
5588 	}
5589 
5590 	switch (codec->core.vendor_id) {
5591 	case 0x10ec0255:
5592 		alc_process_coef_fw(codec, coef0255);
5593 		msleep(300);
5594 		val = alc_read_coef_idx(codec, 0x46);
5595 		is_ctia = (val & 0x0070) == 0x0070;
5596 		break;
5597 	case 0x10ec0230:
5598 	case 0x10ec0236:
5599 	case 0x10ec0256:
5600 	case 0x19e58326:
5601 		alc_write_coef_idx(codec, 0x1b, 0x0e4b);
5602 		alc_write_coef_idx(codec, 0x06, 0x6104);
5603 		alc_write_coefex_idx(codec, 0x57, 0x3, 0x09a3);
5604 
5605 		snd_hda_codec_write(codec, 0x21, 0,
5606 			    AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);
5607 		msleep(80);
5608 		snd_hda_codec_write(codec, 0x21, 0,
5609 			    AC_VERB_SET_PIN_WIDGET_CONTROL, 0x0);
5610 
5611 		alc_process_coef_fw(codec, coef0255);
5612 		msleep(300);
5613 		val = alc_read_coef_idx(codec, 0x46);
5614 		is_ctia = (val & 0x0070) == 0x0070;
5615 
5616 		alc_write_coefex_idx(codec, 0x57, 0x3, 0x0da3);
5617 		alc_update_coefex_idx(codec, 0x57, 0x5, 1<<14, 0);
5618 
5619 		snd_hda_codec_write(codec, 0x21, 0,
5620 			    AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT);
5621 		msleep(80);
5622 		snd_hda_codec_write(codec, 0x21, 0,
5623 			    AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE);
5624 		break;
5625 	case 0x10ec0234:
5626 	case 0x10ec0274:
5627 	case 0x10ec0294:
5628 		alc_process_coef_fw(codec, coef0274);
5629 		msleep(850);
5630 		val = alc_read_coef_idx(codec, 0x46);
5631 		is_ctia = (val & 0x00f0) == 0x00f0;
5632 		break;
5633 	case 0x10ec0233:
5634 	case 0x10ec0283:
5635 		alc_write_coef_idx(codec, 0x45, 0xd029);
5636 		msleep(300);
5637 		val = alc_read_coef_idx(codec, 0x46);
5638 		is_ctia = (val & 0x0070) == 0x0070;
5639 		break;
5640 	case 0x10ec0298:
5641 		snd_hda_codec_write(codec, 0x21, 0,
5642 			    AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);
5643 		msleep(100);
5644 		snd_hda_codec_write(codec, 0x21, 0,
5645 			    AC_VERB_SET_PIN_WIDGET_CONTROL, 0x0);
5646 		msleep(200);
5647 
5648 		val = alc_read_coef_idx(codec, 0x50);
5649 		if (val & (1 << 12)) {
5650 			alc_update_coef_idx(codec, 0x8e, 0x0070, 0x0020);
5651 			alc_process_coef_fw(codec, coef0288);
5652 			msleep(350);
5653 			val = alc_read_coef_idx(codec, 0x50);
5654 			is_ctia = (val & 0x0070) == 0x0070;
5655 		} else {
5656 			alc_update_coef_idx(codec, 0x8e, 0x0070, 0x0010);
5657 			alc_process_coef_fw(codec, coef0288);
5658 			msleep(350);
5659 			val = alc_read_coef_idx(codec, 0x50);
5660 			is_ctia = (val & 0x0070) == 0x0070;
5661 		}
5662 		alc_process_coef_fw(codec, coef0298);
5663 		snd_hda_codec_write(codec, 0x21, 0,
5664 			    AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP);
5665 		msleep(75);
5666 		snd_hda_codec_write(codec, 0x21, 0,
5667 			    AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE);
5668 		break;
5669 	case 0x10ec0286:
5670 	case 0x10ec0288:
5671 		alc_process_coef_fw(codec, coef0288);
5672 		msleep(350);
5673 		val = alc_read_coef_idx(codec, 0x50);
5674 		is_ctia = (val & 0x0070) == 0x0070;
5675 		break;
5676 	case 0x10ec0292:
5677 		alc_write_coef_idx(codec, 0x6b, 0xd429);
5678 		msleep(300);
5679 		val = alc_read_coef_idx(codec, 0x6c);
5680 		is_ctia = (val & 0x001c) == 0x001c;
5681 		break;
5682 	case 0x10ec0293:
5683 		alc_process_coef_fw(codec, coef0293);
5684 		msleep(300);
5685 		val = alc_read_coef_idx(codec, 0x46);
5686 		is_ctia = (val & 0x0070) == 0x0070;
5687 		break;
5688 	case 0x10ec0668:
5689 		alc_process_coef_fw(codec, coef0688);
5690 		msleep(300);
5691 		val = alc_read_coef_idx(codec, 0xbe);
5692 		is_ctia = (val & 0x1c02) == 0x1c02;
5693 		break;
5694 	case 0x10ec0215:
5695 	case 0x10ec0225:
5696 	case 0x10ec0285:
5697 	case 0x10ec0295:
5698 	case 0x10ec0289:
5699 	case 0x10ec0299:
5700 		snd_hda_codec_write(codec, 0x21, 0,
5701 			    AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);
5702 		msleep(80);
5703 		snd_hda_codec_write(codec, 0x21, 0,
5704 			    AC_VERB_SET_PIN_WIDGET_CONTROL, 0x0);
5705 
5706 		alc_process_coef_fw(codec, alc225_pre_hsmode);
5707 		alc_update_coef_idx(codec, 0x67, 0xf000, 0x1000);
5708 		val = alc_read_coef_idx(codec, 0x45);
5709 		if (val & (1 << 9)) {
5710 			alc_update_coef_idx(codec, 0x45, 0x3f<<10, 0x34<<10);
5711 			alc_update_coef_idx(codec, 0x49, 3<<8, 2<<8);
5712 			msleep(800);
5713 			val = alc_read_coef_idx(codec, 0x46);
5714 			is_ctia = (val & 0x00f0) == 0x00f0;
5715 		} else {
5716 			alc_update_coef_idx(codec, 0x45, 0x3f<<10, 0x34<<10);
5717 			alc_update_coef_idx(codec, 0x49, 3<<8, 1<<8);
5718 			msleep(800);
5719 			val = alc_read_coef_idx(codec, 0x46);
5720 			is_ctia = (val & 0x00f0) == 0x00f0;
5721 		}
5722 		alc_update_coef_idx(codec, 0x4a, 7<<6, 7<<6);
5723 		alc_update_coef_idx(codec, 0x4a, 3<<4, 3<<4);
5724 		alc_update_coef_idx(codec, 0x67, 0xf000, 0x3000);
5725 
5726 		snd_hda_codec_write(codec, 0x21, 0,
5727 			    AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT);
5728 		msleep(80);
5729 		snd_hda_codec_write(codec, 0x21, 0,
5730 			    AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE);
5731 		break;
5732 	case 0x10ec0867:
5733 		is_ctia = true;
5734 		break;
5735 	}
5736 
5737 	codec_dbg(codec, "Headset jack detected iPhone-style headset: %s\n",
5738 		    is_ctia ? "yes" : "no");
5739 	spec->current_headset_type = is_ctia ? ALC_HEADSET_TYPE_CTIA : ALC_HEADSET_TYPE_OMTP;
5740 }
5741 
alc_update_headset_mode(struct hda_codec * codec)5742 static void alc_update_headset_mode(struct hda_codec *codec)
5743 {
5744 	struct alc_spec *spec = codec->spec;
5745 
5746 	hda_nid_t mux_pin = spec->gen.imux_pins[spec->gen.cur_mux[0]];
5747 	hda_nid_t hp_pin = alc_get_hp_pin(spec);
5748 
5749 	int new_headset_mode;
5750 
5751 	if (!snd_hda_jack_detect(codec, hp_pin))
5752 		new_headset_mode = ALC_HEADSET_MODE_UNPLUGGED;
5753 	else if (mux_pin == spec->headset_mic_pin)
5754 		new_headset_mode = ALC_HEADSET_MODE_HEADSET;
5755 	else if (mux_pin == spec->headphone_mic_pin)
5756 		new_headset_mode = ALC_HEADSET_MODE_MIC;
5757 	else
5758 		new_headset_mode = ALC_HEADSET_MODE_HEADPHONE;
5759 
5760 	if (new_headset_mode == spec->current_headset_mode) {
5761 		snd_hda_gen_update_outputs(codec);
5762 		return;
5763 	}
5764 
5765 	switch (new_headset_mode) {
5766 	case ALC_HEADSET_MODE_UNPLUGGED:
5767 		alc_headset_mode_unplugged(codec);
5768 		spec->current_headset_mode = ALC_HEADSET_MODE_UNKNOWN;
5769 		spec->current_headset_type = ALC_HEADSET_TYPE_UNKNOWN;
5770 		spec->gen.hp_jack_present = false;
5771 		break;
5772 	case ALC_HEADSET_MODE_HEADSET:
5773 		if (spec->current_headset_type == ALC_HEADSET_TYPE_UNKNOWN)
5774 			alc_determine_headset_type(codec);
5775 		if (spec->current_headset_type == ALC_HEADSET_TYPE_CTIA)
5776 			alc_headset_mode_ctia(codec);
5777 		else if (spec->current_headset_type == ALC_HEADSET_TYPE_OMTP)
5778 			alc_headset_mode_omtp(codec);
5779 		spec->gen.hp_jack_present = true;
5780 		break;
5781 	case ALC_HEADSET_MODE_MIC:
5782 		alc_headset_mode_mic_in(codec, hp_pin, spec->headphone_mic_pin);
5783 		spec->gen.hp_jack_present = false;
5784 		break;
5785 	case ALC_HEADSET_MODE_HEADPHONE:
5786 		alc_headset_mode_default(codec);
5787 		spec->gen.hp_jack_present = true;
5788 		break;
5789 	}
5790 	if (new_headset_mode != ALC_HEADSET_MODE_MIC) {
5791 		snd_hda_set_pin_ctl_cache(codec, hp_pin,
5792 					  AC_PINCTL_OUT_EN | AC_PINCTL_HP_EN);
5793 		if (spec->headphone_mic_pin && spec->headphone_mic_pin != hp_pin)
5794 			snd_hda_set_pin_ctl_cache(codec, spec->headphone_mic_pin,
5795 						  PIN_VREFHIZ);
5796 	}
5797 	spec->current_headset_mode = new_headset_mode;
5798 
5799 	snd_hda_gen_update_outputs(codec);
5800 }
5801 
alc_update_headset_mode_hook(struct hda_codec * codec,struct snd_kcontrol * kcontrol,struct snd_ctl_elem_value * ucontrol)5802 static void alc_update_headset_mode_hook(struct hda_codec *codec,
5803 					 struct snd_kcontrol *kcontrol,
5804 					 struct snd_ctl_elem_value *ucontrol)
5805 {
5806 	alc_update_headset_mode(codec);
5807 }
5808 
alc_update_headset_jack_cb(struct hda_codec * codec,struct hda_jack_callback * jack)5809 static void alc_update_headset_jack_cb(struct hda_codec *codec,
5810 				       struct hda_jack_callback *jack)
5811 {
5812 	snd_hda_gen_hp_automute(codec, jack);
5813 	alc_update_headset_mode(codec);
5814 }
5815 
alc_probe_headset_mode(struct hda_codec * codec)5816 static void alc_probe_headset_mode(struct hda_codec *codec)
5817 {
5818 	int i;
5819 	struct alc_spec *spec = codec->spec;
5820 	struct auto_pin_cfg *cfg = &spec->gen.autocfg;
5821 
5822 	/* Find mic pins */
5823 	for (i = 0; i < cfg->num_inputs; i++) {
5824 		if (cfg->inputs[i].is_headset_mic && !spec->headset_mic_pin)
5825 			spec->headset_mic_pin = cfg->inputs[i].pin;
5826 		if (cfg->inputs[i].is_headphone_mic && !spec->headphone_mic_pin)
5827 			spec->headphone_mic_pin = cfg->inputs[i].pin;
5828 	}
5829 
5830 	WARN_ON(spec->gen.cap_sync_hook);
5831 	spec->gen.cap_sync_hook = alc_update_headset_mode_hook;
5832 	spec->gen.automute_hook = alc_update_headset_mode;
5833 	spec->gen.hp_automute_hook = alc_update_headset_jack_cb;
5834 }
5835 
alc_fixup_headset_mode(struct hda_codec * codec,const struct hda_fixup * fix,int action)5836 static void alc_fixup_headset_mode(struct hda_codec *codec,
5837 				const struct hda_fixup *fix, int action)
5838 {
5839 	struct alc_spec *spec = codec->spec;
5840 
5841 	switch (action) {
5842 	case HDA_FIXUP_ACT_PRE_PROBE:
5843 		spec->parse_flags |= HDA_PINCFG_HEADSET_MIC | HDA_PINCFG_HEADPHONE_MIC;
5844 		break;
5845 	case HDA_FIXUP_ACT_PROBE:
5846 		alc_probe_headset_mode(codec);
5847 		break;
5848 	case HDA_FIXUP_ACT_INIT:
5849 		if (is_s3_resume(codec) || is_s4_resume(codec)) {
5850 			spec->current_headset_mode = ALC_HEADSET_MODE_UNKNOWN;
5851 			spec->current_headset_type = ALC_HEADSET_TYPE_UNKNOWN;
5852 		}
5853 		alc_update_headset_mode(codec);
5854 		break;
5855 	}
5856 }
5857 
alc_fixup_headset_mode_no_hp_mic(struct hda_codec * codec,const struct hda_fixup * fix,int action)5858 static void alc_fixup_headset_mode_no_hp_mic(struct hda_codec *codec,
5859 				const struct hda_fixup *fix, int action)
5860 {
5861 	if (action == HDA_FIXUP_ACT_PRE_PROBE) {
5862 		struct alc_spec *spec = codec->spec;
5863 		spec->parse_flags |= HDA_PINCFG_HEADSET_MIC;
5864 	}
5865 	else
5866 		alc_fixup_headset_mode(codec, fix, action);
5867 }
5868 
alc255_set_default_jack_type(struct hda_codec * codec)5869 static void alc255_set_default_jack_type(struct hda_codec *codec)
5870 {
5871 	/* Set to iphone type */
5872 	static const struct coef_fw alc255fw[] = {
5873 		WRITE_COEF(0x1b, 0x880b),
5874 		WRITE_COEF(0x45, 0xd089),
5875 		WRITE_COEF(0x1b, 0x080b),
5876 		WRITE_COEF(0x46, 0x0004),
5877 		WRITE_COEF(0x1b, 0x0c0b),
5878 		{}
5879 	};
5880 	static const struct coef_fw alc256fw[] = {
5881 		WRITE_COEF(0x1b, 0x884b),
5882 		WRITE_COEF(0x45, 0xd089),
5883 		WRITE_COEF(0x1b, 0x084b),
5884 		WRITE_COEF(0x46, 0x0004),
5885 		WRITE_COEF(0x1b, 0x0c4b),
5886 		{}
5887 	};
5888 	switch (codec->core.vendor_id) {
5889 	case 0x10ec0255:
5890 		alc_process_coef_fw(codec, alc255fw);
5891 		break;
5892 	case 0x10ec0230:
5893 	case 0x10ec0236:
5894 	case 0x10ec0256:
5895 	case 0x19e58326:
5896 		alc_process_coef_fw(codec, alc256fw);
5897 		break;
5898 	}
5899 	msleep(30);
5900 }
5901 
alc_fixup_headset_mode_alc255(struct hda_codec * codec,const struct hda_fixup * fix,int action)5902 static void alc_fixup_headset_mode_alc255(struct hda_codec *codec,
5903 				const struct hda_fixup *fix, int action)
5904 {
5905 	if (action == HDA_FIXUP_ACT_PRE_PROBE) {
5906 		alc255_set_default_jack_type(codec);
5907 	}
5908 	alc_fixup_headset_mode(codec, fix, action);
5909 }
5910 
alc_fixup_headset_mode_alc255_no_hp_mic(struct hda_codec * codec,const struct hda_fixup * fix,int action)5911 static void alc_fixup_headset_mode_alc255_no_hp_mic(struct hda_codec *codec,
5912 				const struct hda_fixup *fix, int action)
5913 {
5914 	if (action == HDA_FIXUP_ACT_PRE_PROBE) {
5915 		struct alc_spec *spec = codec->spec;
5916 		spec->parse_flags |= HDA_PINCFG_HEADSET_MIC;
5917 		alc255_set_default_jack_type(codec);
5918 	}
5919 	else
5920 		alc_fixup_headset_mode(codec, fix, action);
5921 }
5922 
alc288_update_headset_jack_cb(struct hda_codec * codec,struct hda_jack_callback * jack)5923 static void alc288_update_headset_jack_cb(struct hda_codec *codec,
5924 				       struct hda_jack_callback *jack)
5925 {
5926 	struct alc_spec *spec = codec->spec;
5927 
5928 	alc_update_headset_jack_cb(codec, jack);
5929 	/* Headset Mic enable or disable, only for Dell Dino */
5930 	alc_update_gpio_data(codec, 0x40, spec->gen.hp_jack_present);
5931 }
5932 
alc_fixup_headset_mode_dell_alc288(struct hda_codec * codec,const struct hda_fixup * fix,int action)5933 static void alc_fixup_headset_mode_dell_alc288(struct hda_codec *codec,
5934 				const struct hda_fixup *fix, int action)
5935 {
5936 	alc_fixup_headset_mode(codec, fix, action);
5937 	if (action == HDA_FIXUP_ACT_PROBE) {
5938 		struct alc_spec *spec = codec->spec;
5939 		/* toggled via hp_automute_hook */
5940 		spec->gpio_mask |= 0x40;
5941 		spec->gpio_dir |= 0x40;
5942 		spec->gen.hp_automute_hook = alc288_update_headset_jack_cb;
5943 	}
5944 }
5945 
alc_fixup_auto_mute_via_amp(struct hda_codec * codec,const struct hda_fixup * fix,int action)5946 static void alc_fixup_auto_mute_via_amp(struct hda_codec *codec,
5947 					const struct hda_fixup *fix, int action)
5948 {
5949 	if (action == HDA_FIXUP_ACT_PRE_PROBE) {
5950 		struct alc_spec *spec = codec->spec;
5951 		spec->gen.auto_mute_via_amp = 1;
5952 	}
5953 }
5954 
alc_fixup_no_shutup(struct hda_codec * codec,const struct hda_fixup * fix,int action)5955 static void alc_fixup_no_shutup(struct hda_codec *codec,
5956 				const struct hda_fixup *fix, int action)
5957 {
5958 	if (action == HDA_FIXUP_ACT_PRE_PROBE) {
5959 		struct alc_spec *spec = codec->spec;
5960 		spec->no_shutup_pins = 1;
5961 	}
5962 }
5963 
alc_fixup_disable_aamix(struct hda_codec * codec,const struct hda_fixup * fix,int action)5964 static void alc_fixup_disable_aamix(struct hda_codec *codec,
5965 				    const struct hda_fixup *fix, int action)
5966 {
5967 	if (action == HDA_FIXUP_ACT_PRE_PROBE) {
5968 		struct alc_spec *spec = codec->spec;
5969 		/* Disable AA-loopback as it causes white noise */
5970 		spec->gen.mixer_nid = 0;
5971 	}
5972 }
5973 
5974 /* 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)5975 static void alc_fixup_tpt440_dock(struct hda_codec *codec,
5976 				  const struct hda_fixup *fix, int action)
5977 {
5978 	static const struct hda_pintbl pincfgs[] = {
5979 		{ 0x16, 0x21211010 }, /* dock headphone */
5980 		{ 0x19, 0x21a11010 }, /* dock mic */
5981 		{ }
5982 	};
5983 	struct alc_spec *spec = codec->spec;
5984 
5985 	if (action == HDA_FIXUP_ACT_PRE_PROBE) {
5986 		spec->parse_flags = HDA_PINCFG_NO_HP_FIXUP;
5987 		codec->power_save_node = 0; /* avoid click noises */
5988 		snd_hda_apply_pincfgs(codec, pincfgs);
5989 	}
5990 }
5991 
alc_fixup_tpt470_dock(struct hda_codec * codec,const struct hda_fixup * fix,int action)5992 static void alc_fixup_tpt470_dock(struct hda_codec *codec,
5993 				  const struct hda_fixup *fix, int action)
5994 {
5995 	static const struct hda_pintbl pincfgs[] = {
5996 		{ 0x17, 0x21211010 }, /* dock headphone */
5997 		{ 0x19, 0x21a11010 }, /* dock mic */
5998 		{ }
5999 	};
6000 	struct alc_spec *spec = codec->spec;
6001 
6002 	if (action == HDA_FIXUP_ACT_PRE_PROBE) {
6003 		spec->parse_flags = HDA_PINCFG_NO_HP_FIXUP;
6004 		snd_hda_apply_pincfgs(codec, pincfgs);
6005 	} else if (action == HDA_FIXUP_ACT_INIT) {
6006 		/* Enable DOCK device */
6007 		snd_hda_codec_write(codec, 0x17, 0,
6008 			    AC_VERB_SET_CONFIG_DEFAULT_BYTES_3, 0);
6009 		/* Enable DOCK device */
6010 		snd_hda_codec_write(codec, 0x19, 0,
6011 			    AC_VERB_SET_CONFIG_DEFAULT_BYTES_3, 0);
6012 	}
6013 }
6014 
alc_fixup_tpt470_dacs(struct hda_codec * codec,const struct hda_fixup * fix,int action)6015 static void alc_fixup_tpt470_dacs(struct hda_codec *codec,
6016 				  const struct hda_fixup *fix, int action)
6017 {
6018 	/* Assure the speaker pin to be coupled with DAC NID 0x03; otherwise
6019 	 * the speaker output becomes too low by some reason on Thinkpads with
6020 	 * ALC298 codec
6021 	 */
6022 	static const hda_nid_t preferred_pairs[] = {
6023 		0x14, 0x03, 0x17, 0x02, 0x21, 0x02,
6024 		0
6025 	};
6026 	struct alc_spec *spec = codec->spec;
6027 
6028 	if (action == HDA_FIXUP_ACT_PRE_PROBE)
6029 		spec->gen.preferred_dacs = preferred_pairs;
6030 }
6031 
alc295_fixup_asus_dacs(struct hda_codec * codec,const struct hda_fixup * fix,int action)6032 static void alc295_fixup_asus_dacs(struct hda_codec *codec,
6033 				   const struct hda_fixup *fix, int action)
6034 {
6035 	static const hda_nid_t preferred_pairs[] = {
6036 		0x17, 0x02, 0x21, 0x03, 0
6037 	};
6038 	struct alc_spec *spec = codec->spec;
6039 
6040 	if (action == HDA_FIXUP_ACT_PRE_PROBE)
6041 		spec->gen.preferred_dacs = preferred_pairs;
6042 }
6043 
alc_shutup_dell_xps13(struct hda_codec * codec)6044 static void alc_shutup_dell_xps13(struct hda_codec *codec)
6045 {
6046 	struct alc_spec *spec = codec->spec;
6047 	int hp_pin = alc_get_hp_pin(spec);
6048 
6049 	/* Prevent pop noises when headphones are plugged in */
6050 	snd_hda_codec_write(codec, hp_pin, 0,
6051 			    AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);
6052 	msleep(20);
6053 }
6054 
alc_fixup_dell_xps13(struct hda_codec * codec,const struct hda_fixup * fix,int action)6055 static void alc_fixup_dell_xps13(struct hda_codec *codec,
6056 				const struct hda_fixup *fix, int action)
6057 {
6058 	struct alc_spec *spec = codec->spec;
6059 	struct hda_input_mux *imux = &spec->gen.input_mux;
6060 	int i;
6061 
6062 	switch (action) {
6063 	case HDA_FIXUP_ACT_PRE_PROBE:
6064 		/* mic pin 0x19 must be initialized with Vref Hi-Z, otherwise
6065 		 * it causes a click noise at start up
6066 		 */
6067 		snd_hda_codec_set_pin_target(codec, 0x19, PIN_VREFHIZ);
6068 		spec->shutup = alc_shutup_dell_xps13;
6069 		break;
6070 	case HDA_FIXUP_ACT_PROBE:
6071 		/* Make the internal mic the default input source. */
6072 		for (i = 0; i < imux->num_items; i++) {
6073 			if (spec->gen.imux_pins[i] == 0x12) {
6074 				spec->gen.cur_mux[0] = i;
6075 				break;
6076 			}
6077 		}
6078 		break;
6079 	}
6080 }
6081 
alc_fixup_headset_mode_alc662(struct hda_codec * codec,const struct hda_fixup * fix,int action)6082 static void alc_fixup_headset_mode_alc662(struct hda_codec *codec,
6083 				const struct hda_fixup *fix, int action)
6084 {
6085 	struct alc_spec *spec = codec->spec;
6086 
6087 	if (action == HDA_FIXUP_ACT_PRE_PROBE) {
6088 		spec->parse_flags |= HDA_PINCFG_HEADSET_MIC;
6089 		spec->gen.hp_mic = 1; /* Mic-in is same pin as headphone */
6090 
6091 		/* Disable boost for mic-in permanently. (This code is only called
6092 		   from quirks that guarantee that the headphone is at NID 0x1b.) */
6093 		snd_hda_codec_write(codec, 0x1b, 0, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000);
6094 		snd_hda_override_wcaps(codec, 0x1b, get_wcaps(codec, 0x1b) & ~AC_WCAP_IN_AMP);
6095 	} else
6096 		alc_fixup_headset_mode(codec, fix, action);
6097 }
6098 
alc_fixup_headset_mode_alc668(struct hda_codec * codec,const struct hda_fixup * fix,int action)6099 static void alc_fixup_headset_mode_alc668(struct hda_codec *codec,
6100 				const struct hda_fixup *fix, int action)
6101 {
6102 	if (action == HDA_FIXUP_ACT_PRE_PROBE) {
6103 		alc_write_coef_idx(codec, 0xc4, 0x8000);
6104 		alc_update_coef_idx(codec, 0xc2, ~0xfe, 0);
6105 		snd_hda_set_pin_ctl_cache(codec, 0x18, 0);
6106 	}
6107 	alc_fixup_headset_mode(codec, fix, action);
6108 }
6109 
6110 /* Returns the nid of the external mic input pin, or 0 if it cannot be found. */
find_ext_mic_pin(struct hda_codec * codec)6111 static int find_ext_mic_pin(struct hda_codec *codec)
6112 {
6113 	struct alc_spec *spec = codec->spec;
6114 	struct auto_pin_cfg *cfg = &spec->gen.autocfg;
6115 	hda_nid_t nid;
6116 	unsigned int defcfg;
6117 	int i;
6118 
6119 	for (i = 0; i < cfg->num_inputs; i++) {
6120 		if (cfg->inputs[i].type != AUTO_PIN_MIC)
6121 			continue;
6122 		nid = cfg->inputs[i].pin;
6123 		defcfg = snd_hda_codec_get_pincfg(codec, nid);
6124 		if (snd_hda_get_input_pin_attr(defcfg) == INPUT_PIN_ATTR_INT)
6125 			continue;
6126 		return nid;
6127 	}
6128 
6129 	return 0;
6130 }
6131 
alc271_hp_gate_mic_jack(struct hda_codec * codec,const struct hda_fixup * fix,int action)6132 static void alc271_hp_gate_mic_jack(struct hda_codec *codec,
6133 				    const struct hda_fixup *fix,
6134 				    int action)
6135 {
6136 	struct alc_spec *spec = codec->spec;
6137 
6138 	if (action == HDA_FIXUP_ACT_PROBE) {
6139 		int mic_pin = find_ext_mic_pin(codec);
6140 		int hp_pin = alc_get_hp_pin(spec);
6141 
6142 		if (snd_BUG_ON(!mic_pin || !hp_pin))
6143 			return;
6144 		snd_hda_jack_set_gating_jack(codec, mic_pin, hp_pin);
6145 	}
6146 }
6147 
alc269_fixup_limit_int_mic_boost(struct hda_codec * codec,const struct hda_fixup * fix,int action)6148 static void alc269_fixup_limit_int_mic_boost(struct hda_codec *codec,
6149 					     const struct hda_fixup *fix,
6150 					     int action)
6151 {
6152 	struct alc_spec *spec = codec->spec;
6153 	struct auto_pin_cfg *cfg = &spec->gen.autocfg;
6154 	int i;
6155 
6156 	/* The mic boosts on level 2 and 3 are too noisy
6157 	   on the internal mic input.
6158 	   Therefore limit the boost to 0 or 1. */
6159 
6160 	if (action != HDA_FIXUP_ACT_PROBE)
6161 		return;
6162 
6163 	for (i = 0; i < cfg->num_inputs; i++) {
6164 		hda_nid_t nid = cfg->inputs[i].pin;
6165 		unsigned int defcfg;
6166 		if (cfg->inputs[i].type != AUTO_PIN_MIC)
6167 			continue;
6168 		defcfg = snd_hda_codec_get_pincfg(codec, nid);
6169 		if (snd_hda_get_input_pin_attr(defcfg) != INPUT_PIN_ATTR_INT)
6170 			continue;
6171 
6172 		snd_hda_override_amp_caps(codec, nid, HDA_INPUT,
6173 					  (0x00 << AC_AMPCAP_OFFSET_SHIFT) |
6174 					  (0x01 << AC_AMPCAP_NUM_STEPS_SHIFT) |
6175 					  (0x2f << AC_AMPCAP_STEP_SIZE_SHIFT) |
6176 					  (0 << AC_AMPCAP_MUTE_SHIFT));
6177 	}
6178 }
6179 
alc283_hp_automute_hook(struct hda_codec * codec,struct hda_jack_callback * jack)6180 static void alc283_hp_automute_hook(struct hda_codec *codec,
6181 				    struct hda_jack_callback *jack)
6182 {
6183 	struct alc_spec *spec = codec->spec;
6184 	int vref;
6185 
6186 	msleep(200);
6187 	snd_hda_gen_hp_automute(codec, jack);
6188 
6189 	vref = spec->gen.hp_jack_present ? PIN_VREF80 : 0;
6190 
6191 	msleep(600);
6192 	snd_hda_codec_write(codec, 0x19, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
6193 			    vref);
6194 }
6195 
alc283_fixup_chromebook(struct hda_codec * codec,const struct hda_fixup * fix,int action)6196 static void alc283_fixup_chromebook(struct hda_codec *codec,
6197 				    const struct hda_fixup *fix, int action)
6198 {
6199 	struct alc_spec *spec = codec->spec;
6200 
6201 	switch (action) {
6202 	case HDA_FIXUP_ACT_PRE_PROBE:
6203 		snd_hda_override_wcaps(codec, 0x03, 0);
6204 		/* Disable AA-loopback as it causes white noise */
6205 		spec->gen.mixer_nid = 0;
6206 		break;
6207 	case HDA_FIXUP_ACT_INIT:
6208 		/* MIC2-VREF control */
6209 		/* Set to manual mode */
6210 		alc_update_coef_idx(codec, 0x06, 0x000c, 0);
6211 		/* Enable Line1 input control by verb */
6212 		alc_update_coef_idx(codec, 0x1a, 0, 1 << 4);
6213 		break;
6214 	}
6215 }
6216 
alc283_fixup_sense_combo_jack(struct hda_codec * codec,const struct hda_fixup * fix,int action)6217 static void alc283_fixup_sense_combo_jack(struct hda_codec *codec,
6218 				    const struct hda_fixup *fix, int action)
6219 {
6220 	struct alc_spec *spec = codec->spec;
6221 
6222 	switch (action) {
6223 	case HDA_FIXUP_ACT_PRE_PROBE:
6224 		spec->gen.hp_automute_hook = alc283_hp_automute_hook;
6225 		break;
6226 	case HDA_FIXUP_ACT_INIT:
6227 		/* MIC2-VREF control */
6228 		/* Set to manual mode */
6229 		alc_update_coef_idx(codec, 0x06, 0x000c, 0);
6230 		break;
6231 	}
6232 }
6233 
6234 /* mute tablet speaker pin (0x14) via dock plugging in addition */
asus_tx300_automute(struct hda_codec * codec)6235 static void asus_tx300_automute(struct hda_codec *codec)
6236 {
6237 	struct alc_spec *spec = codec->spec;
6238 	snd_hda_gen_update_outputs(codec);
6239 	if (snd_hda_jack_detect(codec, 0x1b))
6240 		spec->gen.mute_bits |= (1ULL << 0x14);
6241 }
6242 
alc282_fixup_asus_tx300(struct hda_codec * codec,const struct hda_fixup * fix,int action)6243 static void alc282_fixup_asus_tx300(struct hda_codec *codec,
6244 				    const struct hda_fixup *fix, int action)
6245 {
6246 	struct alc_spec *spec = codec->spec;
6247 	static const struct hda_pintbl dock_pins[] = {
6248 		{ 0x1b, 0x21114000 }, /* dock speaker pin */
6249 		{}
6250 	};
6251 
6252 	switch (action) {
6253 	case HDA_FIXUP_ACT_PRE_PROBE:
6254 		spec->init_amp = ALC_INIT_DEFAULT;
6255 		/* TX300 needs to set up GPIO2 for the speaker amp */
6256 		alc_setup_gpio(codec, 0x04);
6257 		snd_hda_apply_pincfgs(codec, dock_pins);
6258 		spec->gen.auto_mute_via_amp = 1;
6259 		spec->gen.automute_hook = asus_tx300_automute;
6260 		snd_hda_jack_detect_enable_callback(codec, 0x1b,
6261 						    snd_hda_gen_hp_automute);
6262 		break;
6263 	case HDA_FIXUP_ACT_PROBE:
6264 		spec->init_amp = ALC_INIT_DEFAULT;
6265 		break;
6266 	case HDA_FIXUP_ACT_BUILD:
6267 		/* this is a bit tricky; give more sane names for the main
6268 		 * (tablet) speaker and the dock speaker, respectively
6269 		 */
6270 		rename_ctl(codec, "Speaker Playback Switch",
6271 			   "Dock Speaker Playback Switch");
6272 		rename_ctl(codec, "Bass Speaker Playback Switch",
6273 			   "Speaker Playback Switch");
6274 		break;
6275 	}
6276 }
6277 
alc290_fixup_mono_speakers(struct hda_codec * codec,const struct hda_fixup * fix,int action)6278 static void alc290_fixup_mono_speakers(struct hda_codec *codec,
6279 				       const struct hda_fixup *fix, int action)
6280 {
6281 	if (action == HDA_FIXUP_ACT_PRE_PROBE) {
6282 		/* DAC node 0x03 is giving mono output. We therefore want to
6283 		   make sure 0x14 (front speaker) and 0x15 (headphones) use the
6284 		   stereo DAC, while leaving 0x17 (bass speaker) for node 0x03. */
6285 		static const hda_nid_t conn1[] = { 0x0c };
6286 		snd_hda_override_conn_list(codec, 0x14, ARRAY_SIZE(conn1), conn1);
6287 		snd_hda_override_conn_list(codec, 0x15, ARRAY_SIZE(conn1), conn1);
6288 	}
6289 }
6290 
alc298_fixup_speaker_volume(struct hda_codec * codec,const struct hda_fixup * fix,int action)6291 static void alc298_fixup_speaker_volume(struct hda_codec *codec,
6292 					const struct hda_fixup *fix, int action)
6293 {
6294 	if (action == HDA_FIXUP_ACT_PRE_PROBE) {
6295 		/* The speaker is routed to the Node 0x06 by a mistake, as a result
6296 		   we can't adjust the speaker's volume since this node does not has
6297 		   Amp-out capability. we change the speaker's route to:
6298 		   Node 0x02 (Audio Output) -> Node 0x0c (Audio Mixer) -> Node 0x17 (
6299 		   Pin Complex), since Node 0x02 has Amp-out caps, we can adjust
6300 		   speaker's volume now. */
6301 
6302 		static const hda_nid_t conn1[] = { 0x0c };
6303 		snd_hda_override_conn_list(codec, 0x17, ARRAY_SIZE(conn1), conn1);
6304 	}
6305 }
6306 
6307 /* 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)6308 static void alc295_fixup_disable_dac3(struct hda_codec *codec,
6309 				      const struct hda_fixup *fix, int action)
6310 {
6311 	if (action == HDA_FIXUP_ACT_PRE_PROBE) {
6312 		static const hda_nid_t conn[] = { 0x02, 0x03 };
6313 		snd_hda_override_conn_list(codec, 0x17, ARRAY_SIZE(conn), conn);
6314 	}
6315 }
6316 
6317 /* 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)6318 static void alc285_fixup_speaker2_to_dac1(struct hda_codec *codec,
6319 					  const struct hda_fixup *fix, int action)
6320 {
6321 	if (action == HDA_FIXUP_ACT_PRE_PROBE) {
6322 		static const hda_nid_t conn[] = { 0x02 };
6323 		snd_hda_override_conn_list(codec, 0x17, ARRAY_SIZE(conn), conn);
6324 	}
6325 }
6326 
6327 /* Hook to update amp GPIO4 for automute */
alc280_hp_gpio4_automute_hook(struct hda_codec * codec,struct hda_jack_callback * jack)6328 static void alc280_hp_gpio4_automute_hook(struct hda_codec *codec,
6329 					  struct hda_jack_callback *jack)
6330 {
6331 	struct alc_spec *spec = codec->spec;
6332 
6333 	snd_hda_gen_hp_automute(codec, jack);
6334 	/* mute_led_polarity is set to 0, so we pass inverted value here */
6335 	alc_update_gpio_led(codec, 0x10, spec->mute_led_polarity,
6336 			    !spec->gen.hp_jack_present);
6337 }
6338 
6339 /* Manage GPIOs for HP EliteBook Folio 9480m.
6340  *
6341  * GPIO4 is the headphone amplifier power control
6342  * GPIO3 is the audio output mute indicator LED
6343  */
6344 
alc280_fixup_hp_9480m(struct hda_codec * codec,const struct hda_fixup * fix,int action)6345 static void alc280_fixup_hp_9480m(struct hda_codec *codec,
6346 				  const struct hda_fixup *fix,
6347 				  int action)
6348 {
6349 	struct alc_spec *spec = codec->spec;
6350 
6351 	alc_fixup_hp_gpio_led(codec, action, 0x08, 0);
6352 	if (action == HDA_FIXUP_ACT_PRE_PROBE) {
6353 		/* amp at GPIO4; toggled via alc280_hp_gpio4_automute_hook() */
6354 		spec->gpio_mask |= 0x10;
6355 		spec->gpio_dir |= 0x10;
6356 		spec->gen.hp_automute_hook = alc280_hp_gpio4_automute_hook;
6357 	}
6358 }
6359 
alc275_fixup_gpio4_off(struct hda_codec * codec,const struct hda_fixup * fix,int action)6360 static void alc275_fixup_gpio4_off(struct hda_codec *codec,
6361 				   const struct hda_fixup *fix,
6362 				   int action)
6363 {
6364 	struct alc_spec *spec = codec->spec;
6365 
6366 	if (action == HDA_FIXUP_ACT_PRE_PROBE) {
6367 		spec->gpio_mask |= 0x04;
6368 		spec->gpio_dir |= 0x04;
6369 		/* set data bit low */
6370 	}
6371 }
6372 
6373 /* Quirk for Thinkpad X1 7th and 8th Gen
6374  * The following fixed routing needed
6375  * DAC1 (NID 0x02) -> Speaker (NID 0x14); some eq applied secretly
6376  * DAC2 (NID 0x03) -> Bass (NID 0x17) & Headphone (NID 0x21); sharing a DAC
6377  * DAC3 (NID 0x06) -> Unused, due to the lack of volume amp
6378  */
alc285_fixup_thinkpad_x1_gen7(struct hda_codec * codec,const struct hda_fixup * fix,int action)6379 static void alc285_fixup_thinkpad_x1_gen7(struct hda_codec *codec,
6380 					  const struct hda_fixup *fix, int action)
6381 {
6382 	static const hda_nid_t conn[] = { 0x02, 0x03 }; /* exclude 0x06 */
6383 	static const hda_nid_t preferred_pairs[] = {
6384 		0x14, 0x02, 0x17, 0x03, 0x21, 0x03, 0
6385 	};
6386 	struct alc_spec *spec = codec->spec;
6387 
6388 	switch (action) {
6389 	case HDA_FIXUP_ACT_PRE_PROBE:
6390 		snd_hda_override_conn_list(codec, 0x17, ARRAY_SIZE(conn), conn);
6391 		spec->gen.preferred_dacs = preferred_pairs;
6392 		break;
6393 	case HDA_FIXUP_ACT_BUILD:
6394 		/* The generic parser creates somewhat unintuitive volume ctls
6395 		 * with the fixed routing above, and the shared DAC2 may be
6396 		 * confusing for PA.
6397 		 * Rename those to unique names so that PA doesn't touch them
6398 		 * and use only Master volume.
6399 		 */
6400 		rename_ctl(codec, "Front Playback Volume", "DAC1 Playback Volume");
6401 		rename_ctl(codec, "Bass Speaker Playback Volume", "DAC2 Playback Volume");
6402 		break;
6403 	}
6404 }
6405 
alc233_alc662_fixup_lenovo_dual_codecs(struct hda_codec * codec,const struct hda_fixup * fix,int action)6406 static void alc233_alc662_fixup_lenovo_dual_codecs(struct hda_codec *codec,
6407 					 const struct hda_fixup *fix,
6408 					 int action)
6409 {
6410 	alc_fixup_dual_codecs(codec, fix, action);
6411 	switch (action) {
6412 	case HDA_FIXUP_ACT_PRE_PROBE:
6413 		/* override card longname to provide a unique UCM profile */
6414 		strcpy(codec->card->longname, "HDAudio-Lenovo-DualCodecs");
6415 		break;
6416 	case HDA_FIXUP_ACT_BUILD:
6417 		/* rename Capture controls depending on the codec */
6418 		rename_ctl(codec, "Capture Volume",
6419 			   codec->addr == 0 ?
6420 			   "Rear-Panel Capture Volume" :
6421 			   "Front-Panel Capture Volume");
6422 		rename_ctl(codec, "Capture Switch",
6423 			   codec->addr == 0 ?
6424 			   "Rear-Panel Capture Switch" :
6425 			   "Front-Panel Capture Switch");
6426 		break;
6427 	}
6428 }
6429 
alc225_fixup_s3_pop_noise(struct hda_codec * codec,const struct hda_fixup * fix,int action)6430 static void alc225_fixup_s3_pop_noise(struct hda_codec *codec,
6431 				      const struct hda_fixup *fix, int action)
6432 {
6433 	if (action != HDA_FIXUP_ACT_PRE_PROBE)
6434 		return;
6435 
6436 	codec->power_save_node = 1;
6437 }
6438 
6439 /* 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)6440 static void alc274_fixup_bind_dacs(struct hda_codec *codec,
6441 				    const struct hda_fixup *fix, int action)
6442 {
6443 	struct alc_spec *spec = codec->spec;
6444 	static const hda_nid_t preferred_pairs[] = {
6445 		0x21, 0x03, 0x1b, 0x03, 0x16, 0x02,
6446 		0
6447 	};
6448 
6449 	if (action != HDA_FIXUP_ACT_PRE_PROBE)
6450 		return;
6451 
6452 	spec->gen.preferred_dacs = preferred_pairs;
6453 	spec->gen.auto_mute_via_amp = 1;
6454 	codec->power_save_node = 0;
6455 }
6456 
6457 /* 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)6458 static void alc289_fixup_asus_ga401(struct hda_codec *codec,
6459 				    const struct hda_fixup *fix, int action)
6460 {
6461 	static const hda_nid_t preferred_pairs[] = {
6462 		0x14, 0x02, 0x17, 0x02, 0x21, 0x03, 0
6463 	};
6464 	struct alc_spec *spec = codec->spec;
6465 
6466 	if (action == HDA_FIXUP_ACT_PRE_PROBE) {
6467 		spec->gen.preferred_dacs = preferred_pairs;
6468 		spec->gen.obey_preferred_dacs = 1;
6469 	}
6470 }
6471 
6472 /* 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)6473 static void alc285_fixup_invalidate_dacs(struct hda_codec *codec,
6474 			      const struct hda_fixup *fix, int action)
6475 {
6476 	if (action != HDA_FIXUP_ACT_PRE_PROBE)
6477 		return;
6478 
6479 	snd_hda_override_wcaps(codec, 0x03, 0);
6480 }
6481 
alc_combo_jack_hp_jd_restart(struct hda_codec * codec)6482 static void alc_combo_jack_hp_jd_restart(struct hda_codec *codec)
6483 {
6484 	switch (codec->core.vendor_id) {
6485 	case 0x10ec0274:
6486 	case 0x10ec0294:
6487 	case 0x10ec0225:
6488 	case 0x10ec0295:
6489 	case 0x10ec0299:
6490 		alc_update_coef_idx(codec, 0x4a, 0x8000, 1 << 15); /* Reset HP JD */
6491 		alc_update_coef_idx(codec, 0x4a, 0x8000, 0 << 15);
6492 		break;
6493 	case 0x10ec0230:
6494 	case 0x10ec0235:
6495 	case 0x10ec0236:
6496 	case 0x10ec0255:
6497 	case 0x10ec0256:
6498 	case 0x19e58326:
6499 		alc_update_coef_idx(codec, 0x1b, 0x8000, 1 << 15); /* Reset HP JD */
6500 		alc_update_coef_idx(codec, 0x1b, 0x8000, 0 << 15);
6501 		break;
6502 	}
6503 }
6504 
alc295_fixup_chromebook(struct hda_codec * codec,const struct hda_fixup * fix,int action)6505 static void alc295_fixup_chromebook(struct hda_codec *codec,
6506 				    const struct hda_fixup *fix, int action)
6507 {
6508 	struct alc_spec *spec = codec->spec;
6509 
6510 	switch (action) {
6511 	case HDA_FIXUP_ACT_PRE_PROBE:
6512 		spec->ultra_low_power = true;
6513 		break;
6514 	case HDA_FIXUP_ACT_INIT:
6515 		alc_combo_jack_hp_jd_restart(codec);
6516 		break;
6517 	}
6518 }
6519 
alc_fixup_disable_mic_vref(struct hda_codec * codec,const struct hda_fixup * fix,int action)6520 static void alc_fixup_disable_mic_vref(struct hda_codec *codec,
6521 				  const struct hda_fixup *fix, int action)
6522 {
6523 	if (action == HDA_FIXUP_ACT_PRE_PROBE)
6524 		snd_hda_codec_set_pin_target(codec, 0x19, PIN_VREFHIZ);
6525 }
6526 
6527 
alc294_gx502_toggle_output(struct hda_codec * codec,struct hda_jack_callback * cb)6528 static void alc294_gx502_toggle_output(struct hda_codec *codec,
6529 					struct hda_jack_callback *cb)
6530 {
6531 	/* The Windows driver sets the codec up in a very different way where
6532 	 * it appears to leave 0x10 = 0x8a20 set. For Linux we need to toggle it
6533 	 */
6534 	if (snd_hda_jack_detect_state(codec, 0x21) == HDA_JACK_PRESENT)
6535 		alc_write_coef_idx(codec, 0x10, 0x8a20);
6536 	else
6537 		alc_write_coef_idx(codec, 0x10, 0x0a20);
6538 }
6539 
alc294_fixup_gx502_hp(struct hda_codec * codec,const struct hda_fixup * fix,int action)6540 static void alc294_fixup_gx502_hp(struct hda_codec *codec,
6541 					const struct hda_fixup *fix, int action)
6542 {
6543 	/* Pin 0x21: headphones/headset mic */
6544 	if (!is_jack_detectable(codec, 0x21))
6545 		return;
6546 
6547 	switch (action) {
6548 	case HDA_FIXUP_ACT_PRE_PROBE:
6549 		snd_hda_jack_detect_enable_callback(codec, 0x21,
6550 				alc294_gx502_toggle_output);
6551 		break;
6552 	case HDA_FIXUP_ACT_INIT:
6553 		/* Make sure to start in a correct state, i.e. if
6554 		 * headphones have been plugged in before powering up the system
6555 		 */
6556 		alc294_gx502_toggle_output(codec, NULL);
6557 		break;
6558 	}
6559 }
6560 
alc294_gu502_toggle_output(struct hda_codec * codec,struct hda_jack_callback * cb)6561 static void alc294_gu502_toggle_output(struct hda_codec *codec,
6562 				       struct hda_jack_callback *cb)
6563 {
6564 	/* Windows sets 0x10 to 0x8420 for Node 0x20 which is
6565 	 * responsible from changes between speakers and headphones
6566 	 */
6567 	if (snd_hda_jack_detect_state(codec, 0x21) == HDA_JACK_PRESENT)
6568 		alc_write_coef_idx(codec, 0x10, 0x8420);
6569 	else
6570 		alc_write_coef_idx(codec, 0x10, 0x0a20);
6571 }
6572 
alc294_fixup_gu502_hp(struct hda_codec * codec,const struct hda_fixup * fix,int action)6573 static void alc294_fixup_gu502_hp(struct hda_codec *codec,
6574 				  const struct hda_fixup *fix, int action)
6575 {
6576 	if (!is_jack_detectable(codec, 0x21))
6577 		return;
6578 
6579 	switch (action) {
6580 	case HDA_FIXUP_ACT_PRE_PROBE:
6581 		snd_hda_jack_detect_enable_callback(codec, 0x21,
6582 				alc294_gu502_toggle_output);
6583 		break;
6584 	case HDA_FIXUP_ACT_INIT:
6585 		alc294_gu502_toggle_output(codec, NULL);
6586 		break;
6587 	}
6588 }
6589 
alc285_fixup_hp_gpio_amp_init(struct hda_codec * codec,const struct hda_fixup * fix,int action)6590 static void  alc285_fixup_hp_gpio_amp_init(struct hda_codec *codec,
6591 			      const struct hda_fixup *fix, int action)
6592 {
6593 	if (action != HDA_FIXUP_ACT_INIT)
6594 		return;
6595 
6596 	msleep(100);
6597 	alc_write_coef_idx(codec, 0x65, 0x0);
6598 }
6599 
alc274_fixup_hp_headset_mic(struct hda_codec * codec,const struct hda_fixup * fix,int action)6600 static void alc274_fixup_hp_headset_mic(struct hda_codec *codec,
6601 				    const struct hda_fixup *fix, int action)
6602 {
6603 	switch (action) {
6604 	case HDA_FIXUP_ACT_INIT:
6605 		alc_combo_jack_hp_jd_restart(codec);
6606 		break;
6607 	}
6608 }
6609 
alc_fixup_no_int_mic(struct hda_codec * codec,const struct hda_fixup * fix,int action)6610 static void alc_fixup_no_int_mic(struct hda_codec *codec,
6611 				    const struct hda_fixup *fix, int action)
6612 {
6613 	struct alc_spec *spec = codec->spec;
6614 
6615 	switch (action) {
6616 	case HDA_FIXUP_ACT_PRE_PROBE:
6617 		/* Mic RING SLEEVE swap for combo jack */
6618 		alc_update_coef_idx(codec, 0x45, 0xf<<12 | 1<<10, 5<<12);
6619 		spec->no_internal_mic_pin = true;
6620 		break;
6621 	case HDA_FIXUP_ACT_INIT:
6622 		alc_combo_jack_hp_jd_restart(codec);
6623 		break;
6624 	}
6625 }
6626 
6627 /* GPIO1 = amplifier on/off
6628  * GPIO3 = mic mute LED
6629  */
alc285_fixup_hp_spectre_x360_eb1(struct hda_codec * codec,const struct hda_fixup * fix,int action)6630 static void alc285_fixup_hp_spectre_x360_eb1(struct hda_codec *codec,
6631 					  const struct hda_fixup *fix, int action)
6632 {
6633 	static const hda_nid_t conn[] = { 0x02 };
6634 
6635 	struct alc_spec *spec = codec->spec;
6636 	static const struct hda_pintbl pincfgs[] = {
6637 		{ 0x14, 0x90170110 },  /* front/high speakers */
6638 		{ 0x17, 0x90170130 },  /* back/bass speakers */
6639 		{ }
6640 	};
6641 
6642 	//enable micmute led
6643 	alc_fixup_hp_gpio_led(codec, action, 0x00, 0x04);
6644 
6645 	switch (action) {
6646 	case HDA_FIXUP_ACT_PRE_PROBE:
6647 		spec->micmute_led_polarity = 1;
6648 		/* needed for amp of back speakers */
6649 		spec->gpio_mask |= 0x01;
6650 		spec->gpio_dir |= 0x01;
6651 		snd_hda_apply_pincfgs(codec, pincfgs);
6652 		/* share DAC to have unified volume control */
6653 		snd_hda_override_conn_list(codec, 0x14, ARRAY_SIZE(conn), conn);
6654 		snd_hda_override_conn_list(codec, 0x17, ARRAY_SIZE(conn), conn);
6655 		break;
6656 	case HDA_FIXUP_ACT_INIT:
6657 		/* need to toggle GPIO to enable the amp of back speakers */
6658 		alc_update_gpio_data(codec, 0x01, true);
6659 		msleep(100);
6660 		alc_update_gpio_data(codec, 0x01, false);
6661 		break;
6662 	}
6663 }
6664 
alc285_fixup_hp_spectre_x360(struct hda_codec * codec,const struct hda_fixup * fix,int action)6665 static void alc285_fixup_hp_spectre_x360(struct hda_codec *codec,
6666 					  const struct hda_fixup *fix, int action)
6667 {
6668 	static const hda_nid_t conn[] = { 0x02 };
6669 	static const struct hda_pintbl pincfgs[] = {
6670 		{ 0x14, 0x90170110 },  /* rear speaker */
6671 		{ }
6672 	};
6673 
6674 	switch (action) {
6675 	case HDA_FIXUP_ACT_PRE_PROBE:
6676 		snd_hda_apply_pincfgs(codec, pincfgs);
6677 		/* force front speaker to DAC1 */
6678 		snd_hda_override_conn_list(codec, 0x17, ARRAY_SIZE(conn), conn);
6679 		break;
6680 	}
6681 }
6682 
6683 /* for hda_fixup_thinkpad_acpi() */
6684 #include "thinkpad_helper.c"
6685 
alc_fixup_thinkpad_acpi(struct hda_codec * codec,const struct hda_fixup * fix,int action)6686 static void alc_fixup_thinkpad_acpi(struct hda_codec *codec,
6687 				    const struct hda_fixup *fix, int action)
6688 {
6689 	alc_fixup_no_shutup(codec, fix, action); /* reduce click noise */
6690 	hda_fixup_thinkpad_acpi(codec, fix, action);
6691 }
6692 
6693 /* 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)6694 static void alc287_fixup_legion_15imhg05_speakers(struct hda_codec *codec,
6695 						  const struct hda_fixup *fix,
6696 						  int action)
6697 {
6698 	struct alc_spec *spec = codec->spec;
6699 
6700 	switch (action) {
6701 	case HDA_FIXUP_ACT_PRE_PROBE:
6702 		spec->gen.suppress_auto_mute = 1;
6703 		break;
6704 	}
6705 }
6706 
comp_bind(struct device * dev)6707 static int comp_bind(struct device *dev)
6708 {
6709 	struct hda_codec *cdc = dev_to_hda_codec(dev);
6710 	struct alc_spec *spec = cdc->spec;
6711 
6712 	return component_bind_all(dev, spec->comps);
6713 }
6714 
comp_unbind(struct device * dev)6715 static void comp_unbind(struct device *dev)
6716 {
6717 	struct hda_codec *cdc = dev_to_hda_codec(dev);
6718 	struct alc_spec *spec = cdc->spec;
6719 
6720 	component_unbind_all(dev, spec->comps);
6721 }
6722 
6723 static const struct component_master_ops comp_master_ops = {
6724 	.bind = comp_bind,
6725 	.unbind = comp_unbind,
6726 };
6727 
comp_generic_playback_hook(struct hda_pcm_stream * hinfo,struct hda_codec * cdc,struct snd_pcm_substream * sub,int action)6728 static void comp_generic_playback_hook(struct hda_pcm_stream *hinfo, struct hda_codec *cdc,
6729 				       struct snd_pcm_substream *sub, int action)
6730 {
6731 	struct alc_spec *spec = cdc->spec;
6732 	int i;
6733 
6734 	for (i = 0; i < HDA_MAX_COMPONENTS; i++) {
6735 		if (spec->comps[i].dev && spec->comps[i].pre_playback_hook)
6736 			spec->comps[i].pre_playback_hook(spec->comps[i].dev, action);
6737 	}
6738 	for (i = 0; i < HDA_MAX_COMPONENTS; i++) {
6739 		if (spec->comps[i].dev && spec->comps[i].playback_hook)
6740 			spec->comps[i].playback_hook(spec->comps[i].dev, action);
6741 	}
6742 	for (i = 0; i < HDA_MAX_COMPONENTS; i++) {
6743 		if (spec->comps[i].dev && spec->comps[i].post_playback_hook)
6744 			spec->comps[i].post_playback_hook(spec->comps[i].dev, action);
6745 	}
6746 }
6747 
6748 struct scodec_dev_name {
6749 	const char *bus;
6750 	const char *hid;
6751 	int index;
6752 };
6753 
6754 /* match the device name in a slightly relaxed manner */
comp_match_cs35l41_dev_name(struct device * dev,void * data)6755 static int comp_match_cs35l41_dev_name(struct device *dev, void *data)
6756 {
6757 	struct scodec_dev_name *p = data;
6758 	const char *d = dev_name(dev);
6759 	int n = strlen(p->bus);
6760 	char tmp[32];
6761 
6762 	/* check the bus name */
6763 	if (strncmp(d, p->bus, n))
6764 		return 0;
6765 	/* skip the bus number */
6766 	if (isdigit(d[n]))
6767 		n++;
6768 	/* the rest must be exact matching */
6769 	snprintf(tmp, sizeof(tmp), "-%s:00-cs35l41-hda.%d", p->hid, p->index);
6770 	return !strcmp(d + n, tmp);
6771 }
6772 
comp_match_tas2781_dev_name(struct device * dev,void * data)6773 static int comp_match_tas2781_dev_name(struct device *dev,
6774 	void *data)
6775 {
6776 	struct scodec_dev_name *p = data;
6777 	const char *d = dev_name(dev);
6778 	int n = strlen(p->bus);
6779 	char tmp[32];
6780 
6781 	/* check the bus name */
6782 	if (strncmp(d, p->bus, n))
6783 		return 0;
6784 	/* skip the bus number */
6785 	if (isdigit(d[n]))
6786 		n++;
6787 	/* the rest must be exact matching */
6788 	snprintf(tmp, sizeof(tmp), "-%s:00", p->hid);
6789 
6790 	return !strcmp(d + n, tmp);
6791 }
6792 
cs35l41_generic_fixup(struct hda_codec * cdc,int action,const char * bus,const char * hid,int count)6793 static void cs35l41_generic_fixup(struct hda_codec *cdc, int action, const char *bus,
6794 				  const char *hid, int count)
6795 {
6796 	struct device *dev = hda_codec_dev(cdc);
6797 	struct alc_spec *spec = cdc->spec;
6798 	struct scodec_dev_name *rec;
6799 	int ret, i;
6800 
6801 	switch (action) {
6802 	case HDA_FIXUP_ACT_PRE_PROBE:
6803 		for (i = 0; i < count; i++) {
6804 			rec = devm_kmalloc(dev, sizeof(*rec), GFP_KERNEL);
6805 			if (!rec)
6806 				return;
6807 			rec->bus = bus;
6808 			rec->hid = hid;
6809 			rec->index = i;
6810 			spec->comps[i].codec = cdc;
6811 			component_match_add(dev, &spec->match,
6812 					    comp_match_cs35l41_dev_name, rec);
6813 		}
6814 		ret = component_master_add_with_match(dev, &comp_master_ops, spec->match);
6815 		if (ret)
6816 			codec_err(cdc, "Fail to register component aggregator %d\n", ret);
6817 		else
6818 			spec->gen.pcm_playback_hook = comp_generic_playback_hook;
6819 		break;
6820 	case HDA_FIXUP_ACT_FREE:
6821 		component_master_del(dev, &comp_master_ops);
6822 		break;
6823 	}
6824 }
6825 
tas2781_generic_fixup(struct hda_codec * cdc,int action,const char * bus,const char * hid)6826 static void tas2781_generic_fixup(struct hda_codec *cdc, int action,
6827 	const char *bus, const char *hid)
6828 {
6829 	struct device *dev = hda_codec_dev(cdc);
6830 	struct alc_spec *spec = cdc->spec;
6831 	struct scodec_dev_name *rec;
6832 	int ret;
6833 
6834 	switch (action) {
6835 	case HDA_FIXUP_ACT_PRE_PROBE:
6836 		rec = devm_kmalloc(dev, sizeof(*rec), GFP_KERNEL);
6837 		if (!rec)
6838 			return;
6839 		rec->bus = bus;
6840 		rec->hid = hid;
6841 		rec->index = 0;
6842 		spec->comps[0].codec = cdc;
6843 		component_match_add(dev, &spec->match,
6844 			comp_match_tas2781_dev_name, rec);
6845 		ret = component_master_add_with_match(dev, &comp_master_ops,
6846 			spec->match);
6847 		if (ret)
6848 			codec_err(cdc,
6849 				"Fail to register component aggregator %d\n",
6850 				ret);
6851 		else
6852 			spec->gen.pcm_playback_hook =
6853 				comp_generic_playback_hook;
6854 		break;
6855 	case HDA_FIXUP_ACT_FREE:
6856 		component_master_del(dev, &comp_master_ops);
6857 		break;
6858 	}
6859 }
6860 
cs35l41_fixup_i2c_two(struct hda_codec * cdc,const struct hda_fixup * fix,int action)6861 static void cs35l41_fixup_i2c_two(struct hda_codec *cdc, const struct hda_fixup *fix, int action)
6862 {
6863 	cs35l41_generic_fixup(cdc, action, "i2c", "CSC3551", 2);
6864 }
6865 
cs35l41_fixup_spi_two(struct hda_codec * codec,const struct hda_fixup * fix,int action)6866 static void cs35l41_fixup_spi_two(struct hda_codec *codec, const struct hda_fixup *fix, int action)
6867 {
6868 	cs35l41_generic_fixup(codec, action, "spi", "CSC3551", 2);
6869 }
6870 
cs35l41_fixup_spi_four(struct hda_codec * codec,const struct hda_fixup * fix,int action)6871 static void cs35l41_fixup_spi_four(struct hda_codec *codec, const struct hda_fixup *fix, int action)
6872 {
6873 	cs35l41_generic_fixup(codec, action, "spi", "CSC3551", 4);
6874 }
6875 
alc287_fixup_legion_16achg6_speakers(struct hda_codec * cdc,const struct hda_fixup * fix,int action)6876 static void alc287_fixup_legion_16achg6_speakers(struct hda_codec *cdc, const struct hda_fixup *fix,
6877 						 int action)
6878 {
6879 	cs35l41_generic_fixup(cdc, action, "i2c", "CLSA0100", 2);
6880 }
6881 
alc287_fixup_legion_16ithg6_speakers(struct hda_codec * cdc,const struct hda_fixup * fix,int action)6882 static void alc287_fixup_legion_16ithg6_speakers(struct hda_codec *cdc, const struct hda_fixup *fix,
6883 						 int action)
6884 {
6885 	cs35l41_generic_fixup(cdc, action, "i2c", "CLSA0101", 2);
6886 }
6887 
tas2781_fixup_i2c(struct hda_codec * cdc,const struct hda_fixup * fix,int action)6888 static void tas2781_fixup_i2c(struct hda_codec *cdc,
6889 	const struct hda_fixup *fix, int action)
6890 {
6891 	 tas2781_generic_fixup(cdc, action, "i2c", "TIAS2781");
6892 }
6893 
6894 /* for alc295_fixup_hp_top_speakers */
6895 #include "hp_x360_helper.c"
6896 
6897 /* for alc285_fixup_ideapad_s740_coef() */
6898 #include "ideapad_s740_helper.c"
6899 
6900 static const struct coef_fw alc256_fixup_set_coef_defaults_coefs[] = {
6901 	WRITE_COEF(0x10, 0x0020), WRITE_COEF(0x24, 0x0000),
6902 	WRITE_COEF(0x26, 0x0000), WRITE_COEF(0x29, 0x3000),
6903 	WRITE_COEF(0x37, 0xfe05), WRITE_COEF(0x45, 0x5089),
6904 	{}
6905 };
6906 
alc256_fixup_set_coef_defaults(struct hda_codec * codec,const struct hda_fixup * fix,int action)6907 static void alc256_fixup_set_coef_defaults(struct hda_codec *codec,
6908 					   const struct hda_fixup *fix,
6909 					   int action)
6910 {
6911 	/*
6912 	 * A certain other OS sets these coeffs to different values. On at least
6913 	 * one TongFang barebone these settings might survive even a cold
6914 	 * reboot. So to restore a clean slate the values are explicitly reset
6915 	 * to default here. Without this, the external microphone is always in a
6916 	 * plugged-in state, while the internal microphone is always in an
6917 	 * unplugged state, breaking the ability to use the internal microphone.
6918 	 */
6919 	alc_process_coef_fw(codec, alc256_fixup_set_coef_defaults_coefs);
6920 }
6921 
6922 static const struct coef_fw alc233_fixup_no_audio_jack_coefs[] = {
6923 	WRITE_COEF(0x1a, 0x9003), WRITE_COEF(0x1b, 0x0e2b), WRITE_COEF(0x37, 0xfe06),
6924 	WRITE_COEF(0x38, 0x4981), WRITE_COEF(0x45, 0xd489), WRITE_COEF(0x46, 0x0074),
6925 	WRITE_COEF(0x49, 0x0149),
6926 	{}
6927 };
6928 
alc233_fixup_no_audio_jack(struct hda_codec * codec,const struct hda_fixup * fix,int action)6929 static void alc233_fixup_no_audio_jack(struct hda_codec *codec,
6930 				       const struct hda_fixup *fix,
6931 				       int action)
6932 {
6933 	/*
6934 	 * The audio jack input and output is not detected on the ASRock NUC Box
6935 	 * 1100 series when cold booting without this fix. Warm rebooting from a
6936 	 * certain other OS makes the audio functional, as COEF settings are
6937 	 * preserved in this case. This fix sets these altered COEF values as
6938 	 * the default.
6939 	 */
6940 	alc_process_coef_fw(codec, alc233_fixup_no_audio_jack_coefs);
6941 }
6942 
alc256_fixup_mic_no_presence_and_resume(struct hda_codec * codec,const struct hda_fixup * fix,int action)6943 static void alc256_fixup_mic_no_presence_and_resume(struct hda_codec *codec,
6944 						    const struct hda_fixup *fix,
6945 						    int action)
6946 {
6947 	/*
6948 	 * The Clevo NJ51CU comes either with the ALC293 or the ALC256 codec,
6949 	 * but uses the 0x8686 subproduct id in both cases. The ALC256 codec
6950 	 * needs an additional quirk for sound working after suspend and resume.
6951 	 */
6952 	if (codec->core.vendor_id == 0x10ec0256) {
6953 		alc_update_coef_idx(codec, 0x10, 1<<9, 0);
6954 		snd_hda_codec_set_pincfg(codec, 0x19, 0x04a11120);
6955 	} else {
6956 		snd_hda_codec_set_pincfg(codec, 0x1a, 0x04a1113c);
6957 	}
6958 }
6959 
alc_fixup_dell4_mic_no_presence_quiet(struct hda_codec * codec,const struct hda_fixup * fix,int action)6960 static void alc_fixup_dell4_mic_no_presence_quiet(struct hda_codec *codec,
6961 						  const struct hda_fixup *fix,
6962 						  int action)
6963 {
6964 	struct alc_spec *spec = codec->spec;
6965 	struct hda_input_mux *imux = &spec->gen.input_mux;
6966 	int i;
6967 
6968 	alc269_fixup_limit_int_mic_boost(codec, fix, action);
6969 
6970 	switch (action) {
6971 	case HDA_FIXUP_ACT_PRE_PROBE:
6972 		/**
6973 		 * Set the vref of pin 0x19 (Headset Mic) and pin 0x1b (Headphone Mic)
6974 		 * to Hi-Z to avoid pop noises at startup and when plugging and
6975 		 * unplugging headphones.
6976 		 */
6977 		snd_hda_codec_set_pin_target(codec, 0x19, PIN_VREFHIZ);
6978 		snd_hda_codec_set_pin_target(codec, 0x1b, PIN_VREFHIZ);
6979 		break;
6980 	case HDA_FIXUP_ACT_PROBE:
6981 		/**
6982 		 * Make the internal mic (0x12) the default input source to
6983 		 * prevent pop noises on cold boot.
6984 		 */
6985 		for (i = 0; i < imux->num_items; i++) {
6986 			if (spec->gen.imux_pins[i] == 0x12) {
6987 				spec->gen.cur_mux[0] = i;
6988 				break;
6989 			}
6990 		}
6991 		break;
6992 	}
6993 }
6994 
alc287_fixup_yoga9_14iap7_bass_spk_pin(struct hda_codec * codec,const struct hda_fixup * fix,int action)6995 static void alc287_fixup_yoga9_14iap7_bass_spk_pin(struct hda_codec *codec,
6996 					  const struct hda_fixup *fix, int action)
6997 {
6998 	/*
6999 	 * The Pin Complex 0x17 for the bass speakers is wrongly reported as
7000 	 * unconnected.
7001 	 */
7002 	static const struct hda_pintbl pincfgs[] = {
7003 		{ 0x17, 0x90170121 },
7004 		{ }
7005 	};
7006 	/*
7007 	 * Avoid DAC 0x06 and 0x08, as they have no volume controls.
7008 	 * DAC 0x02 and 0x03 would be fine.
7009 	 */
7010 	static const hda_nid_t conn[] = { 0x02, 0x03 };
7011 	/*
7012 	 * Prefer both speakerbar (0x14) and bass speakers (0x17) connected to DAC 0x02.
7013 	 * Headphones (0x21) are connected to DAC 0x03.
7014 	 */
7015 	static const hda_nid_t preferred_pairs[] = {
7016 		0x14, 0x02,
7017 		0x17, 0x02,
7018 		0x21, 0x03,
7019 		0
7020 	};
7021 	struct alc_spec *spec = codec->spec;
7022 
7023 	switch (action) {
7024 	case HDA_FIXUP_ACT_PRE_PROBE:
7025 		snd_hda_apply_pincfgs(codec, pincfgs);
7026 		snd_hda_override_conn_list(codec, 0x17, ARRAY_SIZE(conn), conn);
7027 		spec->gen.preferred_dacs = preferred_pairs;
7028 		break;
7029 	}
7030 }
7031 
alc295_fixup_dell_inspiron_top_speakers(struct hda_codec * codec,const struct hda_fixup * fix,int action)7032 static void alc295_fixup_dell_inspiron_top_speakers(struct hda_codec *codec,
7033 					  const struct hda_fixup *fix, int action)
7034 {
7035 	static const struct hda_pintbl pincfgs[] = {
7036 		{ 0x14, 0x90170151 },
7037 		{ 0x17, 0x90170150 },
7038 		{ }
7039 	};
7040 	static const hda_nid_t conn[] = { 0x02, 0x03 };
7041 	static const hda_nid_t preferred_pairs[] = {
7042 		0x14, 0x02,
7043 		0x17, 0x03,
7044 		0x21, 0x02,
7045 		0
7046 	};
7047 	struct alc_spec *spec = codec->spec;
7048 
7049 	alc_fixup_no_shutup(codec, fix, action);
7050 
7051 	switch (action) {
7052 	case HDA_FIXUP_ACT_PRE_PROBE:
7053 		snd_hda_apply_pincfgs(codec, pincfgs);
7054 		snd_hda_override_conn_list(codec, 0x17, ARRAY_SIZE(conn), conn);
7055 		spec->gen.preferred_dacs = preferred_pairs;
7056 		break;
7057 	}
7058 }
7059 
7060 /* 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)7061 static void alc287_fixup_bind_dacs(struct hda_codec *codec,
7062 				    const struct hda_fixup *fix, int action)
7063 {
7064 	struct alc_spec *spec = codec->spec;
7065 	static const hda_nid_t conn[] = { 0x02, 0x03 }; /* exclude 0x06 */
7066 	static const hda_nid_t preferred_pairs[] = {
7067 		0x17, 0x02, 0x21, 0x03, 0
7068 	};
7069 
7070 	if (action != HDA_FIXUP_ACT_PRE_PROBE)
7071 		return;
7072 
7073 	snd_hda_override_conn_list(codec, 0x17, ARRAY_SIZE(conn), conn);
7074 	spec->gen.preferred_dacs = preferred_pairs;
7075 	spec->gen.auto_mute_via_amp = 1;
7076 	if (spec->gen.autocfg.speaker_pins[0] != 0x14) {
7077 		snd_hda_codec_write_cache(codec, 0x14, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
7078 					0x0); /* Make sure 0x14 was disable */
7079 	}
7080 }
7081 /* Fix none verb table of Headset Mic pin */
alc_fixup_headset_mic(struct hda_codec * codec,const struct hda_fixup * fix,int action)7082 static void alc_fixup_headset_mic(struct hda_codec *codec,
7083 				   const struct hda_fixup *fix, int action)
7084 {
7085 	struct alc_spec *spec = codec->spec;
7086 	static const struct hda_pintbl pincfgs[] = {
7087 		{ 0x19, 0x03a1103c },
7088 		{ }
7089 	};
7090 
7091 	switch (action) {
7092 	case HDA_FIXUP_ACT_PRE_PROBE:
7093 		snd_hda_apply_pincfgs(codec, pincfgs);
7094 		alc_update_coef_idx(codec, 0x45, 0xf<<12 | 1<<10, 5<<12);
7095 		spec->parse_flags |= HDA_PINCFG_HEADSET_MIC;
7096 		break;
7097 	}
7098 }
7099 
7100 
7101 enum {
7102 	ALC269_FIXUP_GPIO2,
7103 	ALC269_FIXUP_SONY_VAIO,
7104 	ALC275_FIXUP_SONY_VAIO_GPIO2,
7105 	ALC269_FIXUP_DELL_M101Z,
7106 	ALC269_FIXUP_SKU_IGNORE,
7107 	ALC269_FIXUP_ASUS_G73JW,
7108 	ALC269_FIXUP_ASUS_N7601ZM_PINS,
7109 	ALC269_FIXUP_ASUS_N7601ZM,
7110 	ALC269_FIXUP_LENOVO_EAPD,
7111 	ALC275_FIXUP_SONY_HWEQ,
7112 	ALC275_FIXUP_SONY_DISABLE_AAMIX,
7113 	ALC271_FIXUP_DMIC,
7114 	ALC269_FIXUP_PCM_44K,
7115 	ALC269_FIXUP_STEREO_DMIC,
7116 	ALC269_FIXUP_HEADSET_MIC,
7117 	ALC269_FIXUP_QUANTA_MUTE,
7118 	ALC269_FIXUP_LIFEBOOK,
7119 	ALC269_FIXUP_LIFEBOOK_EXTMIC,
7120 	ALC269_FIXUP_LIFEBOOK_HP_PIN,
7121 	ALC269_FIXUP_LIFEBOOK_NO_HP_TO_LINEOUT,
7122 	ALC255_FIXUP_LIFEBOOK_U7x7_HEADSET_MIC,
7123 	ALC269_FIXUP_AMIC,
7124 	ALC269_FIXUP_DMIC,
7125 	ALC269VB_FIXUP_AMIC,
7126 	ALC269VB_FIXUP_DMIC,
7127 	ALC269_FIXUP_HP_MUTE_LED,
7128 	ALC269_FIXUP_HP_MUTE_LED_MIC1,
7129 	ALC269_FIXUP_HP_MUTE_LED_MIC2,
7130 	ALC269_FIXUP_HP_MUTE_LED_MIC3,
7131 	ALC269_FIXUP_HP_GPIO_LED,
7132 	ALC269_FIXUP_HP_GPIO_MIC1_LED,
7133 	ALC269_FIXUP_HP_LINE1_MIC1_LED,
7134 	ALC269_FIXUP_INV_DMIC,
7135 	ALC269_FIXUP_LENOVO_DOCK,
7136 	ALC269_FIXUP_LENOVO_DOCK_LIMIT_BOOST,
7137 	ALC269_FIXUP_NO_SHUTUP,
7138 	ALC286_FIXUP_SONY_MIC_NO_PRESENCE,
7139 	ALC269_FIXUP_PINCFG_NO_HP_TO_LINEOUT,
7140 	ALC269_FIXUP_DELL1_MIC_NO_PRESENCE,
7141 	ALC269_FIXUP_DELL2_MIC_NO_PRESENCE,
7142 	ALC269_FIXUP_DELL3_MIC_NO_PRESENCE,
7143 	ALC269_FIXUP_DELL4_MIC_NO_PRESENCE,
7144 	ALC269_FIXUP_DELL4_MIC_NO_PRESENCE_QUIET,
7145 	ALC269_FIXUP_HEADSET_MODE,
7146 	ALC269_FIXUP_HEADSET_MODE_NO_HP_MIC,
7147 	ALC269_FIXUP_ASPIRE_HEADSET_MIC,
7148 	ALC269_FIXUP_ASUS_X101_FUNC,
7149 	ALC269_FIXUP_ASUS_X101_VERB,
7150 	ALC269_FIXUP_ASUS_X101,
7151 	ALC271_FIXUP_AMIC_MIC2,
7152 	ALC271_FIXUP_HP_GATE_MIC_JACK,
7153 	ALC271_FIXUP_HP_GATE_MIC_JACK_E1_572,
7154 	ALC269_FIXUP_ACER_AC700,
7155 	ALC269_FIXUP_LIMIT_INT_MIC_BOOST,
7156 	ALC269VB_FIXUP_ASUS_ZENBOOK,
7157 	ALC269VB_FIXUP_ASUS_ZENBOOK_UX31A,
7158 	ALC269VB_FIXUP_ASUS_MIC_NO_PRESENCE,
7159 	ALC269_FIXUP_LIMIT_INT_MIC_BOOST_MUTE_LED,
7160 	ALC269VB_FIXUP_ORDISSIMO_EVE2,
7161 	ALC283_FIXUP_CHROME_BOOK,
7162 	ALC283_FIXUP_SENSE_COMBO_JACK,
7163 	ALC282_FIXUP_ASUS_TX300,
7164 	ALC283_FIXUP_INT_MIC,
7165 	ALC290_FIXUP_MONO_SPEAKERS,
7166 	ALC290_FIXUP_MONO_SPEAKERS_HSJACK,
7167 	ALC290_FIXUP_SUBWOOFER,
7168 	ALC290_FIXUP_SUBWOOFER_HSJACK,
7169 	ALC269_FIXUP_THINKPAD_ACPI,
7170 	ALC269_FIXUP_DMIC_THINKPAD_ACPI,
7171 	ALC255_FIXUP_ACER_MIC_NO_PRESENCE,
7172 	ALC255_FIXUP_ASUS_MIC_NO_PRESENCE,
7173 	ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
7174 	ALC255_FIXUP_DELL2_MIC_NO_PRESENCE,
7175 	ALC255_FIXUP_HEADSET_MODE,
7176 	ALC255_FIXUP_HEADSET_MODE_NO_HP_MIC,
7177 	ALC293_FIXUP_DELL1_MIC_NO_PRESENCE,
7178 	ALC292_FIXUP_TPT440_DOCK,
7179 	ALC292_FIXUP_TPT440,
7180 	ALC283_FIXUP_HEADSET_MIC,
7181 	ALC255_FIXUP_MIC_MUTE_LED,
7182 	ALC282_FIXUP_ASPIRE_V5_PINS,
7183 	ALC269VB_FIXUP_ASPIRE_E1_COEF,
7184 	ALC280_FIXUP_HP_GPIO4,
7185 	ALC286_FIXUP_HP_GPIO_LED,
7186 	ALC280_FIXUP_HP_GPIO2_MIC_HOTKEY,
7187 	ALC280_FIXUP_HP_DOCK_PINS,
7188 	ALC269_FIXUP_HP_DOCK_GPIO_MIC1_LED,
7189 	ALC280_FIXUP_HP_9480M,
7190 	ALC245_FIXUP_HP_X360_AMP,
7191 	ALC285_FIXUP_HP_SPECTRE_X360_EB1,
7192 	ALC288_FIXUP_DELL_HEADSET_MODE,
7193 	ALC288_FIXUP_DELL1_MIC_NO_PRESENCE,
7194 	ALC288_FIXUP_DELL_XPS_13,
7195 	ALC288_FIXUP_DISABLE_AAMIX,
7196 	ALC292_FIXUP_DELL_E7X_AAMIX,
7197 	ALC292_FIXUP_DELL_E7X,
7198 	ALC292_FIXUP_DISABLE_AAMIX,
7199 	ALC293_FIXUP_DISABLE_AAMIX_MULTIJACK,
7200 	ALC298_FIXUP_ALIENWARE_MIC_NO_PRESENCE,
7201 	ALC298_FIXUP_DELL1_MIC_NO_PRESENCE,
7202 	ALC298_FIXUP_DELL_AIO_MIC_NO_PRESENCE,
7203 	ALC275_FIXUP_DELL_XPS,
7204 	ALC293_FIXUP_LENOVO_SPK_NOISE,
7205 	ALC233_FIXUP_LENOVO_LINE2_MIC_HOTKEY,
7206 	ALC255_FIXUP_DELL_SPK_NOISE,
7207 	ALC225_FIXUP_DISABLE_MIC_VREF,
7208 	ALC225_FIXUP_DELL1_MIC_NO_PRESENCE,
7209 	ALC295_FIXUP_DISABLE_DAC3,
7210 	ALC285_FIXUP_SPEAKER2_TO_DAC1,
7211 	ALC285_FIXUP_ASUS_SPEAKER2_TO_DAC1,
7212 	ALC285_FIXUP_ASUS_HEADSET_MIC,
7213 	ALC285_FIXUP_ASUS_SPI_REAR_SPEAKERS,
7214 	ALC285_FIXUP_ASUS_I2C_SPEAKER2_TO_DAC1,
7215 	ALC285_FIXUP_ASUS_I2C_HEADSET_MIC,
7216 	ALC280_FIXUP_HP_HEADSET_MIC,
7217 	ALC221_FIXUP_HP_FRONT_MIC,
7218 	ALC292_FIXUP_TPT460,
7219 	ALC298_FIXUP_SPK_VOLUME,
7220 	ALC298_FIXUP_LENOVO_SPK_VOLUME,
7221 	ALC256_FIXUP_DELL_INSPIRON_7559_SUBWOOFER,
7222 	ALC269_FIXUP_ATIV_BOOK_8,
7223 	ALC221_FIXUP_HP_288PRO_MIC_NO_PRESENCE,
7224 	ALC221_FIXUP_HP_MIC_NO_PRESENCE,
7225 	ALC256_FIXUP_ASUS_HEADSET_MODE,
7226 	ALC256_FIXUP_ASUS_MIC,
7227 	ALC256_FIXUP_ASUS_AIO_GPIO2,
7228 	ALC233_FIXUP_ASUS_MIC_NO_PRESENCE,
7229 	ALC233_FIXUP_EAPD_COEF_AND_MIC_NO_PRESENCE,
7230 	ALC233_FIXUP_LENOVO_MULTI_CODECS,
7231 	ALC233_FIXUP_ACER_HEADSET_MIC,
7232 	ALC294_FIXUP_LENOVO_MIC_LOCATION,
7233 	ALC225_FIXUP_DELL_WYSE_MIC_NO_PRESENCE,
7234 	ALC225_FIXUP_S3_POP_NOISE,
7235 	ALC700_FIXUP_INTEL_REFERENCE,
7236 	ALC274_FIXUP_DELL_BIND_DACS,
7237 	ALC274_FIXUP_DELL_AIO_LINEOUT_VERB,
7238 	ALC298_FIXUP_TPT470_DOCK_FIX,
7239 	ALC298_FIXUP_TPT470_DOCK,
7240 	ALC255_FIXUP_DUMMY_LINEOUT_VERB,
7241 	ALC255_FIXUP_DELL_HEADSET_MIC,
7242 	ALC256_FIXUP_HUAWEI_MACH_WX9_PINS,
7243 	ALC298_FIXUP_HUAWEI_MBX_STEREO,
7244 	ALC295_FIXUP_HP_X360,
7245 	ALC221_FIXUP_HP_HEADSET_MIC,
7246 	ALC285_FIXUP_LENOVO_HEADPHONE_NOISE,
7247 	ALC295_FIXUP_HP_AUTO_MUTE,
7248 	ALC286_FIXUP_ACER_AIO_MIC_NO_PRESENCE,
7249 	ALC294_FIXUP_ASUS_MIC,
7250 	ALC294_FIXUP_ASUS_HEADSET_MIC,
7251 	ALC294_FIXUP_ASUS_SPK,
7252 	ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE,
7253 	ALC285_FIXUP_LENOVO_PC_BEEP_IN_NOISE,
7254 	ALC255_FIXUP_ACER_HEADSET_MIC,
7255 	ALC295_FIXUP_CHROME_BOOK,
7256 	ALC225_FIXUP_HEADSET_JACK,
7257 	ALC225_FIXUP_DELL_WYSE_AIO_MIC_NO_PRESENCE,
7258 	ALC225_FIXUP_WYSE_AUTO_MUTE,
7259 	ALC225_FIXUP_WYSE_DISABLE_MIC_VREF,
7260 	ALC286_FIXUP_ACER_AIO_HEADSET_MIC,
7261 	ALC256_FIXUP_ASUS_HEADSET_MIC,
7262 	ALC256_FIXUP_ASUS_MIC_NO_PRESENCE,
7263 	ALC299_FIXUP_PREDATOR_SPK,
7264 	ALC256_FIXUP_MEDION_HEADSET_NO_PRESENCE,
7265 	ALC289_FIXUP_DELL_SPK2,
7266 	ALC289_FIXUP_DUAL_SPK,
7267 	ALC294_FIXUP_SPK2_TO_DAC1,
7268 	ALC294_FIXUP_ASUS_DUAL_SPK,
7269 	ALC285_FIXUP_THINKPAD_X1_GEN7,
7270 	ALC285_FIXUP_THINKPAD_HEADSET_JACK,
7271 	ALC294_FIXUP_ASUS_ALLY,
7272 	ALC294_FIXUP_ASUS_ALLY_PINS,
7273 	ALC294_FIXUP_ASUS_ALLY_VERBS,
7274 	ALC294_FIXUP_ASUS_ALLY_SPEAKER,
7275 	ALC294_FIXUP_ASUS_HPE,
7276 	ALC294_FIXUP_ASUS_COEF_1B,
7277 	ALC294_FIXUP_ASUS_GX502_HP,
7278 	ALC294_FIXUP_ASUS_GX502_PINS,
7279 	ALC294_FIXUP_ASUS_GX502_VERBS,
7280 	ALC294_FIXUP_ASUS_GU502_HP,
7281 	ALC294_FIXUP_ASUS_GU502_PINS,
7282 	ALC294_FIXUP_ASUS_GU502_VERBS,
7283 	ALC294_FIXUP_ASUS_G513_PINS,
7284 	ALC285_FIXUP_ASUS_G533Z_PINS,
7285 	ALC285_FIXUP_HP_GPIO_LED,
7286 	ALC285_FIXUP_HP_MUTE_LED,
7287 	ALC285_FIXUP_HP_SPECTRE_X360_MUTE_LED,
7288 	ALC236_FIXUP_HP_MUTE_LED_COEFBIT2,
7289 	ALC236_FIXUP_HP_GPIO_LED,
7290 	ALC236_FIXUP_HP_MUTE_LED,
7291 	ALC236_FIXUP_HP_MUTE_LED_MICMUTE_VREF,
7292 	ALC298_FIXUP_SAMSUNG_AMP,
7293 	ALC298_FIXUP_SAMSUNG_HEADPHONE_VERY_QUIET,
7294 	ALC256_FIXUP_SAMSUNG_HEADPHONE_VERY_QUIET,
7295 	ALC295_FIXUP_ASUS_MIC_NO_PRESENCE,
7296 	ALC269VC_FIXUP_ACER_VCOPPERBOX_PINS,
7297 	ALC269VC_FIXUP_ACER_HEADSET_MIC,
7298 	ALC269VC_FIXUP_ACER_MIC_NO_PRESENCE,
7299 	ALC289_FIXUP_ASUS_GA401,
7300 	ALC289_FIXUP_ASUS_GA502,
7301 	ALC256_FIXUP_ACER_MIC_NO_PRESENCE,
7302 	ALC285_FIXUP_HP_GPIO_AMP_INIT,
7303 	ALC269_FIXUP_CZC_B20,
7304 	ALC269_FIXUP_CZC_TMI,
7305 	ALC269_FIXUP_CZC_L101,
7306 	ALC269_FIXUP_LEMOTE_A1802,
7307 	ALC269_FIXUP_LEMOTE_A190X,
7308 	ALC256_FIXUP_INTEL_NUC8_RUGGED,
7309 	ALC233_FIXUP_INTEL_NUC8_DMIC,
7310 	ALC233_FIXUP_INTEL_NUC8_BOOST,
7311 	ALC256_FIXUP_INTEL_NUC10,
7312 	ALC255_FIXUP_XIAOMI_HEADSET_MIC,
7313 	ALC274_FIXUP_HP_MIC,
7314 	ALC274_FIXUP_HP_HEADSET_MIC,
7315 	ALC274_FIXUP_HP_ENVY_GPIO,
7316 	ALC256_FIXUP_ASUS_HPE,
7317 	ALC285_FIXUP_THINKPAD_NO_BASS_SPK_HEADSET_JACK,
7318 	ALC287_FIXUP_HP_GPIO_LED,
7319 	ALC256_FIXUP_HP_HEADSET_MIC,
7320 	ALC245_FIXUP_HP_GPIO_LED,
7321 	ALC236_FIXUP_DELL_AIO_HEADSET_MIC,
7322 	ALC282_FIXUP_ACER_DISABLE_LINEOUT,
7323 	ALC255_FIXUP_ACER_LIMIT_INT_MIC_BOOST,
7324 	ALC256_FIXUP_ACER_HEADSET_MIC,
7325 	ALC285_FIXUP_IDEAPAD_S740_COEF,
7326 	ALC285_FIXUP_HP_LIMIT_INT_MIC_BOOST,
7327 	ALC295_FIXUP_ASUS_DACS,
7328 	ALC295_FIXUP_HP_OMEN,
7329 	ALC285_FIXUP_HP_SPECTRE_X360,
7330 	ALC287_FIXUP_IDEAPAD_BASS_SPK_AMP,
7331 	ALC623_FIXUP_LENOVO_THINKSTATION_P340,
7332 	ALC255_FIXUP_ACER_HEADPHONE_AND_MIC,
7333 	ALC236_FIXUP_HP_LIMIT_INT_MIC_BOOST,
7334 	ALC287_FIXUP_LEGION_15IMHG05_SPEAKERS,
7335 	ALC287_FIXUP_LEGION_15IMHG05_AUTOMUTE,
7336 	ALC287_FIXUP_YOGA7_14ITL_SPEAKERS,
7337 	ALC298_FIXUP_LENOVO_C940_DUET7,
7338 	ALC287_FIXUP_13S_GEN2_SPEAKERS,
7339 	ALC256_FIXUP_SET_COEF_DEFAULTS,
7340 	ALC256_FIXUP_SYSTEM76_MIC_NO_PRESENCE,
7341 	ALC233_FIXUP_NO_AUDIO_JACK,
7342 	ALC256_FIXUP_MIC_NO_PRESENCE_AND_RESUME,
7343 	ALC285_FIXUP_LEGION_Y9000X_SPEAKERS,
7344 	ALC285_FIXUP_LEGION_Y9000X_AUTOMUTE,
7345 	ALC287_FIXUP_LEGION_16ACHG6,
7346 	ALC287_FIXUP_CS35L41_I2C_2,
7347 	ALC287_FIXUP_CS35L41_I2C_2_HP_GPIO_LED,
7348 	ALC245_FIXUP_CS35L41_SPI_2,
7349 	ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED,
7350 	ALC245_FIXUP_CS35L41_SPI_4,
7351 	ALC245_FIXUP_CS35L41_SPI_4_HP_GPIO_LED,
7352 	ALC285_FIXUP_HP_SPEAKERS_MICMUTE_LED,
7353 	ALC295_FIXUP_FRAMEWORK_LAPTOP_MIC_NO_PRESENCE,
7354 	ALC287_FIXUP_LEGION_16ITHG6,
7355 	ALC287_FIXUP_YOGA9_14IAP7_BASS_SPK,
7356 	ALC287_FIXUP_YOGA9_14IAP7_BASS_SPK_PIN,
7357 	ALC295_FIXUP_DELL_INSPIRON_TOP_SPEAKERS,
7358 	ALC236_FIXUP_DELL_DUAL_CODECS,
7359 	ALC287_FIXUP_CS35L41_I2C_2_THINKPAD_ACPI,
7360 	ALC287_FIXUP_TAS2781_I2C,
7361 	ALC245_FIXUP_HP_MUTE_LED_COEFBIT,
7362 	ALC245_FIXUP_HP_X360_MUTE_LEDS,
7363 	ALC287_FIXUP_THINKPAD_I2S_SPK,
7364 	ALC287_FIXUP_MG_RTKC_CSAMP_CS35L41_I2C_THINKPAD,
7365 	ALC2XX_FIXUP_HEADSET_MIC,
7366 };
7367 
7368 /* A special fixup for Lenovo C940 and Yoga Duet 7;
7369  * both have the very same PCI SSID, and we need to apply different fixups
7370  * depending on the codec ID
7371  */
alc298_fixup_lenovo_c940_duet7(struct hda_codec * codec,const struct hda_fixup * fix,int action)7372 static void alc298_fixup_lenovo_c940_duet7(struct hda_codec *codec,
7373 					   const struct hda_fixup *fix,
7374 					   int action)
7375 {
7376 	int id;
7377 
7378 	if (codec->core.vendor_id == 0x10ec0298)
7379 		id = ALC298_FIXUP_LENOVO_SPK_VOLUME; /* C940 */
7380 	else
7381 		id = ALC287_FIXUP_YOGA7_14ITL_SPEAKERS; /* Duet 7 */
7382 	__snd_hda_apply_fixup(codec, id, action, 0);
7383 }
7384 
7385 static const struct hda_fixup alc269_fixups[] = {
7386 	[ALC269_FIXUP_GPIO2] = {
7387 		.type = HDA_FIXUP_FUNC,
7388 		.v.func = alc_fixup_gpio2,
7389 	},
7390 	[ALC269_FIXUP_SONY_VAIO] = {
7391 		.type = HDA_FIXUP_PINCTLS,
7392 		.v.pins = (const struct hda_pintbl[]) {
7393 			{0x19, PIN_VREFGRD},
7394 			{}
7395 		}
7396 	},
7397 	[ALC275_FIXUP_SONY_VAIO_GPIO2] = {
7398 		.type = HDA_FIXUP_FUNC,
7399 		.v.func = alc275_fixup_gpio4_off,
7400 		.chained = true,
7401 		.chain_id = ALC269_FIXUP_SONY_VAIO
7402 	},
7403 	[ALC269_FIXUP_DELL_M101Z] = {
7404 		.type = HDA_FIXUP_VERBS,
7405 		.v.verbs = (const struct hda_verb[]) {
7406 			/* Enables internal speaker */
7407 			{0x20, AC_VERB_SET_COEF_INDEX, 13},
7408 			{0x20, AC_VERB_SET_PROC_COEF, 0x4040},
7409 			{}
7410 		}
7411 	},
7412 	[ALC269_FIXUP_SKU_IGNORE] = {
7413 		.type = HDA_FIXUP_FUNC,
7414 		.v.func = alc_fixup_sku_ignore,
7415 	},
7416 	[ALC269_FIXUP_ASUS_G73JW] = {
7417 		.type = HDA_FIXUP_PINS,
7418 		.v.pins = (const struct hda_pintbl[]) {
7419 			{ 0x17, 0x99130111 }, /* subwoofer */
7420 			{ }
7421 		}
7422 	},
7423 	[ALC269_FIXUP_ASUS_N7601ZM_PINS] = {
7424 		.type = HDA_FIXUP_PINS,
7425 		.v.pins = (const struct hda_pintbl[]) {
7426 			{ 0x19, 0x03A11050 },
7427 			{ 0x1a, 0x03A11C30 },
7428 			{ 0x21, 0x03211420 },
7429 			{ }
7430 		}
7431 	},
7432 	[ALC269_FIXUP_ASUS_N7601ZM] = {
7433 		.type = HDA_FIXUP_VERBS,
7434 		.v.verbs = (const struct hda_verb[]) {
7435 			{0x20, AC_VERB_SET_COEF_INDEX, 0x62},
7436 			{0x20, AC_VERB_SET_PROC_COEF, 0xa007},
7437 			{0x20, AC_VERB_SET_COEF_INDEX, 0x10},
7438 			{0x20, AC_VERB_SET_PROC_COEF, 0x8420},
7439 			{0x20, AC_VERB_SET_COEF_INDEX, 0x0f},
7440 			{0x20, AC_VERB_SET_PROC_COEF, 0x7774},
7441 			{ }
7442 		},
7443 		.chained = true,
7444 		.chain_id = ALC269_FIXUP_ASUS_N7601ZM_PINS,
7445 	},
7446 	[ALC269_FIXUP_LENOVO_EAPD] = {
7447 		.type = HDA_FIXUP_VERBS,
7448 		.v.verbs = (const struct hda_verb[]) {
7449 			{0x14, AC_VERB_SET_EAPD_BTLENABLE, 0},
7450 			{}
7451 		}
7452 	},
7453 	[ALC275_FIXUP_SONY_HWEQ] = {
7454 		.type = HDA_FIXUP_FUNC,
7455 		.v.func = alc269_fixup_hweq,
7456 		.chained = true,
7457 		.chain_id = ALC275_FIXUP_SONY_VAIO_GPIO2
7458 	},
7459 	[ALC275_FIXUP_SONY_DISABLE_AAMIX] = {
7460 		.type = HDA_FIXUP_FUNC,
7461 		.v.func = alc_fixup_disable_aamix,
7462 		.chained = true,
7463 		.chain_id = ALC269_FIXUP_SONY_VAIO
7464 	},
7465 	[ALC271_FIXUP_DMIC] = {
7466 		.type = HDA_FIXUP_FUNC,
7467 		.v.func = alc271_fixup_dmic,
7468 	},
7469 	[ALC269_FIXUP_PCM_44K] = {
7470 		.type = HDA_FIXUP_FUNC,
7471 		.v.func = alc269_fixup_pcm_44k,
7472 		.chained = true,
7473 		.chain_id = ALC269_FIXUP_QUANTA_MUTE
7474 	},
7475 	[ALC269_FIXUP_STEREO_DMIC] = {
7476 		.type = HDA_FIXUP_FUNC,
7477 		.v.func = alc269_fixup_stereo_dmic,
7478 	},
7479 	[ALC269_FIXUP_HEADSET_MIC] = {
7480 		.type = HDA_FIXUP_FUNC,
7481 		.v.func = alc269_fixup_headset_mic,
7482 	},
7483 	[ALC269_FIXUP_QUANTA_MUTE] = {
7484 		.type = HDA_FIXUP_FUNC,
7485 		.v.func = alc269_fixup_quanta_mute,
7486 	},
7487 	[ALC269_FIXUP_LIFEBOOK] = {
7488 		.type = HDA_FIXUP_PINS,
7489 		.v.pins = (const struct hda_pintbl[]) {
7490 			{ 0x1a, 0x2101103f }, /* dock line-out */
7491 			{ 0x1b, 0x23a11040 }, /* dock mic-in */
7492 			{ }
7493 		},
7494 		.chained = true,
7495 		.chain_id = ALC269_FIXUP_QUANTA_MUTE
7496 	},
7497 	[ALC269_FIXUP_LIFEBOOK_EXTMIC] = {
7498 		.type = HDA_FIXUP_PINS,
7499 		.v.pins = (const struct hda_pintbl[]) {
7500 			{ 0x19, 0x01a1903c }, /* headset mic, with jack detect */
7501 			{ }
7502 		},
7503 	},
7504 	[ALC269_FIXUP_LIFEBOOK_HP_PIN] = {
7505 		.type = HDA_FIXUP_PINS,
7506 		.v.pins = (const struct hda_pintbl[]) {
7507 			{ 0x21, 0x0221102f }, /* HP out */
7508 			{ }
7509 		},
7510 	},
7511 	[ALC269_FIXUP_LIFEBOOK_NO_HP_TO_LINEOUT] = {
7512 		.type = HDA_FIXUP_FUNC,
7513 		.v.func = alc269_fixup_pincfg_no_hp_to_lineout,
7514 	},
7515 	[ALC255_FIXUP_LIFEBOOK_U7x7_HEADSET_MIC] = {
7516 		.type = HDA_FIXUP_FUNC,
7517 		.v.func = alc269_fixup_pincfg_U7x7_headset_mic,
7518 	},
7519 	[ALC269_FIXUP_AMIC] = {
7520 		.type = HDA_FIXUP_PINS,
7521 		.v.pins = (const struct hda_pintbl[]) {
7522 			{ 0x14, 0x99130110 }, /* speaker */
7523 			{ 0x15, 0x0121401f }, /* HP out */
7524 			{ 0x18, 0x01a19c20 }, /* mic */
7525 			{ 0x19, 0x99a3092f }, /* int-mic */
7526 			{ }
7527 		},
7528 	},
7529 	[ALC269_FIXUP_DMIC] = {
7530 		.type = HDA_FIXUP_PINS,
7531 		.v.pins = (const struct hda_pintbl[]) {
7532 			{ 0x12, 0x99a3092f }, /* int-mic */
7533 			{ 0x14, 0x99130110 }, /* speaker */
7534 			{ 0x15, 0x0121401f }, /* HP out */
7535 			{ 0x18, 0x01a19c20 }, /* mic */
7536 			{ }
7537 		},
7538 	},
7539 	[ALC269VB_FIXUP_AMIC] = {
7540 		.type = HDA_FIXUP_PINS,
7541 		.v.pins = (const struct hda_pintbl[]) {
7542 			{ 0x14, 0x99130110 }, /* speaker */
7543 			{ 0x18, 0x01a19c20 }, /* mic */
7544 			{ 0x19, 0x99a3092f }, /* int-mic */
7545 			{ 0x21, 0x0121401f }, /* HP out */
7546 			{ }
7547 		},
7548 	},
7549 	[ALC269VB_FIXUP_DMIC] = {
7550 		.type = HDA_FIXUP_PINS,
7551 		.v.pins = (const struct hda_pintbl[]) {
7552 			{ 0x12, 0x99a3092f }, /* int-mic */
7553 			{ 0x14, 0x99130110 }, /* speaker */
7554 			{ 0x18, 0x01a19c20 }, /* mic */
7555 			{ 0x21, 0x0121401f }, /* HP out */
7556 			{ }
7557 		},
7558 	},
7559 	[ALC269_FIXUP_HP_MUTE_LED] = {
7560 		.type = HDA_FIXUP_FUNC,
7561 		.v.func = alc269_fixup_hp_mute_led,
7562 	},
7563 	[ALC269_FIXUP_HP_MUTE_LED_MIC1] = {
7564 		.type = HDA_FIXUP_FUNC,
7565 		.v.func = alc269_fixup_hp_mute_led_mic1,
7566 	},
7567 	[ALC269_FIXUP_HP_MUTE_LED_MIC2] = {
7568 		.type = HDA_FIXUP_FUNC,
7569 		.v.func = alc269_fixup_hp_mute_led_mic2,
7570 	},
7571 	[ALC269_FIXUP_HP_MUTE_LED_MIC3] = {
7572 		.type = HDA_FIXUP_FUNC,
7573 		.v.func = alc269_fixup_hp_mute_led_mic3,
7574 		.chained = true,
7575 		.chain_id = ALC295_FIXUP_HP_AUTO_MUTE
7576 	},
7577 	[ALC269_FIXUP_HP_GPIO_LED] = {
7578 		.type = HDA_FIXUP_FUNC,
7579 		.v.func = alc269_fixup_hp_gpio_led,
7580 	},
7581 	[ALC269_FIXUP_HP_GPIO_MIC1_LED] = {
7582 		.type = HDA_FIXUP_FUNC,
7583 		.v.func = alc269_fixup_hp_gpio_mic1_led,
7584 	},
7585 	[ALC269_FIXUP_HP_LINE1_MIC1_LED] = {
7586 		.type = HDA_FIXUP_FUNC,
7587 		.v.func = alc269_fixup_hp_line1_mic1_led,
7588 	},
7589 	[ALC269_FIXUP_INV_DMIC] = {
7590 		.type = HDA_FIXUP_FUNC,
7591 		.v.func = alc_fixup_inv_dmic,
7592 	},
7593 	[ALC269_FIXUP_NO_SHUTUP] = {
7594 		.type = HDA_FIXUP_FUNC,
7595 		.v.func = alc_fixup_no_shutup,
7596 	},
7597 	[ALC269_FIXUP_LENOVO_DOCK] = {
7598 		.type = HDA_FIXUP_PINS,
7599 		.v.pins = (const struct hda_pintbl[]) {
7600 			{ 0x19, 0x23a11040 }, /* dock mic */
7601 			{ 0x1b, 0x2121103f }, /* dock headphone */
7602 			{ }
7603 		},
7604 		.chained = true,
7605 		.chain_id = ALC269_FIXUP_PINCFG_NO_HP_TO_LINEOUT
7606 	},
7607 	[ALC269_FIXUP_LENOVO_DOCK_LIMIT_BOOST] = {
7608 		.type = HDA_FIXUP_FUNC,
7609 		.v.func = alc269_fixup_limit_int_mic_boost,
7610 		.chained = true,
7611 		.chain_id = ALC269_FIXUP_LENOVO_DOCK,
7612 	},
7613 	[ALC269_FIXUP_PINCFG_NO_HP_TO_LINEOUT] = {
7614 		.type = HDA_FIXUP_FUNC,
7615 		.v.func = alc269_fixup_pincfg_no_hp_to_lineout,
7616 		.chained = true,
7617 		.chain_id = ALC269_FIXUP_THINKPAD_ACPI,
7618 	},
7619 	[ALC269_FIXUP_DELL1_MIC_NO_PRESENCE] = {
7620 		.type = HDA_FIXUP_PINS,
7621 		.v.pins = (const struct hda_pintbl[]) {
7622 			{ 0x19, 0x01a1913c }, /* use as headset mic, without its own jack detect */
7623 			{ 0x1a, 0x01a1913d }, /* use as headphone mic, without its own jack detect */
7624 			{ }
7625 		},
7626 		.chained = true,
7627 		.chain_id = ALC269_FIXUP_HEADSET_MODE
7628 	},
7629 	[ALC269_FIXUP_DELL2_MIC_NO_PRESENCE] = {
7630 		.type = HDA_FIXUP_PINS,
7631 		.v.pins = (const struct hda_pintbl[]) {
7632 			{ 0x16, 0x21014020 }, /* dock line out */
7633 			{ 0x19, 0x21a19030 }, /* dock mic */
7634 			{ 0x1a, 0x01a1913c }, /* use as headset mic, without its own jack detect */
7635 			{ }
7636 		},
7637 		.chained = true,
7638 		.chain_id = ALC269_FIXUP_HEADSET_MODE_NO_HP_MIC
7639 	},
7640 	[ALC269_FIXUP_DELL3_MIC_NO_PRESENCE] = {
7641 		.type = HDA_FIXUP_PINS,
7642 		.v.pins = (const struct hda_pintbl[]) {
7643 			{ 0x1a, 0x01a1913c }, /* use as headset mic, without its own jack detect */
7644 			{ }
7645 		},
7646 		.chained = true,
7647 		.chain_id = ALC269_FIXUP_HEADSET_MODE_NO_HP_MIC
7648 	},
7649 	[ALC269_FIXUP_DELL4_MIC_NO_PRESENCE] = {
7650 		.type = HDA_FIXUP_PINS,
7651 		.v.pins = (const struct hda_pintbl[]) {
7652 			{ 0x19, 0x01a1913c }, /* use as headset mic, without its own jack detect */
7653 			{ 0x1b, 0x01a1913d }, /* use as headphone mic, without its own jack detect */
7654 			{ }
7655 		},
7656 		.chained = true,
7657 		.chain_id = ALC269_FIXUP_HEADSET_MODE
7658 	},
7659 	[ALC269_FIXUP_HEADSET_MODE] = {
7660 		.type = HDA_FIXUP_FUNC,
7661 		.v.func = alc_fixup_headset_mode,
7662 		.chained = true,
7663 		.chain_id = ALC255_FIXUP_MIC_MUTE_LED
7664 	},
7665 	[ALC269_FIXUP_HEADSET_MODE_NO_HP_MIC] = {
7666 		.type = HDA_FIXUP_FUNC,
7667 		.v.func = alc_fixup_headset_mode_no_hp_mic,
7668 	},
7669 	[ALC269_FIXUP_ASPIRE_HEADSET_MIC] = {
7670 		.type = HDA_FIXUP_PINS,
7671 		.v.pins = (const struct hda_pintbl[]) {
7672 			{ 0x19, 0x01a1913c }, /* headset mic w/o jack detect */
7673 			{ }
7674 		},
7675 		.chained = true,
7676 		.chain_id = ALC269_FIXUP_HEADSET_MODE,
7677 	},
7678 	[ALC286_FIXUP_SONY_MIC_NO_PRESENCE] = {
7679 		.type = HDA_FIXUP_PINS,
7680 		.v.pins = (const struct hda_pintbl[]) {
7681 			{ 0x18, 0x01a1913c }, /* use as headset mic, without its own jack detect */
7682 			{ }
7683 		},
7684 		.chained = true,
7685 		.chain_id = ALC269_FIXUP_HEADSET_MIC
7686 	},
7687 	[ALC256_FIXUP_HUAWEI_MACH_WX9_PINS] = {
7688 		.type = HDA_FIXUP_PINS,
7689 		.v.pins = (const struct hda_pintbl[]) {
7690 			{0x12, 0x90a60130},
7691 			{0x13, 0x40000000},
7692 			{0x14, 0x90170110},
7693 			{0x18, 0x411111f0},
7694 			{0x19, 0x04a11040},
7695 			{0x1a, 0x411111f0},
7696 			{0x1b, 0x90170112},
7697 			{0x1d, 0x40759a05},
7698 			{0x1e, 0x411111f0},
7699 			{0x21, 0x04211020},
7700 			{ }
7701 		},
7702 		.chained = true,
7703 		.chain_id = ALC255_FIXUP_MIC_MUTE_LED
7704 	},
7705 	[ALC298_FIXUP_HUAWEI_MBX_STEREO] = {
7706 		.type = HDA_FIXUP_FUNC,
7707 		.v.func = alc298_fixup_huawei_mbx_stereo,
7708 		.chained = true,
7709 		.chain_id = ALC255_FIXUP_MIC_MUTE_LED
7710 	},
7711 	[ALC269_FIXUP_ASUS_X101_FUNC] = {
7712 		.type = HDA_FIXUP_FUNC,
7713 		.v.func = alc269_fixup_x101_headset_mic,
7714 	},
7715 	[ALC269_FIXUP_ASUS_X101_VERB] = {
7716 		.type = HDA_FIXUP_VERBS,
7717 		.v.verbs = (const struct hda_verb[]) {
7718 			{0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
7719 			{0x20, AC_VERB_SET_COEF_INDEX, 0x08},
7720 			{0x20, AC_VERB_SET_PROC_COEF,  0x0310},
7721 			{ }
7722 		},
7723 		.chained = true,
7724 		.chain_id = ALC269_FIXUP_ASUS_X101_FUNC
7725 	},
7726 	[ALC269_FIXUP_ASUS_X101] = {
7727 		.type = HDA_FIXUP_PINS,
7728 		.v.pins = (const struct hda_pintbl[]) {
7729 			{ 0x18, 0x04a1182c }, /* Headset mic */
7730 			{ }
7731 		},
7732 		.chained = true,
7733 		.chain_id = ALC269_FIXUP_ASUS_X101_VERB
7734 	},
7735 	[ALC271_FIXUP_AMIC_MIC2] = {
7736 		.type = HDA_FIXUP_PINS,
7737 		.v.pins = (const struct hda_pintbl[]) {
7738 			{ 0x14, 0x99130110 }, /* speaker */
7739 			{ 0x19, 0x01a19c20 }, /* mic */
7740 			{ 0x1b, 0x99a7012f }, /* int-mic */
7741 			{ 0x21, 0x0121401f }, /* HP out */
7742 			{ }
7743 		},
7744 	},
7745 	[ALC271_FIXUP_HP_GATE_MIC_JACK] = {
7746 		.type = HDA_FIXUP_FUNC,
7747 		.v.func = alc271_hp_gate_mic_jack,
7748 		.chained = true,
7749 		.chain_id = ALC271_FIXUP_AMIC_MIC2,
7750 	},
7751 	[ALC271_FIXUP_HP_GATE_MIC_JACK_E1_572] = {
7752 		.type = HDA_FIXUP_FUNC,
7753 		.v.func = alc269_fixup_limit_int_mic_boost,
7754 		.chained = true,
7755 		.chain_id = ALC271_FIXUP_HP_GATE_MIC_JACK,
7756 	},
7757 	[ALC269_FIXUP_ACER_AC700] = {
7758 		.type = HDA_FIXUP_PINS,
7759 		.v.pins = (const struct hda_pintbl[]) {
7760 			{ 0x12, 0x99a3092f }, /* int-mic */
7761 			{ 0x14, 0x99130110 }, /* speaker */
7762 			{ 0x18, 0x03a11c20 }, /* mic */
7763 			{ 0x1e, 0x0346101e }, /* SPDIF1 */
7764 			{ 0x21, 0x0321101f }, /* HP out */
7765 			{ }
7766 		},
7767 		.chained = true,
7768 		.chain_id = ALC271_FIXUP_DMIC,
7769 	},
7770 	[ALC269_FIXUP_LIMIT_INT_MIC_BOOST] = {
7771 		.type = HDA_FIXUP_FUNC,
7772 		.v.func = alc269_fixup_limit_int_mic_boost,
7773 		.chained = true,
7774 		.chain_id = ALC269_FIXUP_THINKPAD_ACPI,
7775 	},
7776 	[ALC269VB_FIXUP_ASUS_ZENBOOK] = {
7777 		.type = HDA_FIXUP_FUNC,
7778 		.v.func = alc269_fixup_limit_int_mic_boost,
7779 		.chained = true,
7780 		.chain_id = ALC269VB_FIXUP_DMIC,
7781 	},
7782 	[ALC269VB_FIXUP_ASUS_ZENBOOK_UX31A] = {
7783 		.type = HDA_FIXUP_VERBS,
7784 		.v.verbs = (const struct hda_verb[]) {
7785 			/* class-D output amp +5dB */
7786 			{ 0x20, AC_VERB_SET_COEF_INDEX, 0x12 },
7787 			{ 0x20, AC_VERB_SET_PROC_COEF, 0x2800 },
7788 			{}
7789 		},
7790 		.chained = true,
7791 		.chain_id = ALC269VB_FIXUP_ASUS_ZENBOOK,
7792 	},
7793 	[ALC269VB_FIXUP_ASUS_MIC_NO_PRESENCE] = {
7794 		.type = HDA_FIXUP_PINS,
7795 		.v.pins = (const struct hda_pintbl[]) {
7796 			{ 0x18, 0x01a110f0 },  /* use as headset mic */
7797 			{ }
7798 		},
7799 		.chained = true,
7800 		.chain_id = ALC269_FIXUP_HEADSET_MIC
7801 	},
7802 	[ALC269_FIXUP_LIMIT_INT_MIC_BOOST_MUTE_LED] = {
7803 		.type = HDA_FIXUP_FUNC,
7804 		.v.func = alc269_fixup_limit_int_mic_boost,
7805 		.chained = true,
7806 		.chain_id = ALC269_FIXUP_HP_MUTE_LED_MIC1,
7807 	},
7808 	[ALC269VB_FIXUP_ORDISSIMO_EVE2] = {
7809 		.type = HDA_FIXUP_PINS,
7810 		.v.pins = (const struct hda_pintbl[]) {
7811 			{ 0x12, 0x99a3092f }, /* int-mic */
7812 			{ 0x18, 0x03a11d20 }, /* mic */
7813 			{ 0x19, 0x411111f0 }, /* Unused bogus pin */
7814 			{ }
7815 		},
7816 	},
7817 	[ALC283_FIXUP_CHROME_BOOK] = {
7818 		.type = HDA_FIXUP_FUNC,
7819 		.v.func = alc283_fixup_chromebook,
7820 	},
7821 	[ALC283_FIXUP_SENSE_COMBO_JACK] = {
7822 		.type = HDA_FIXUP_FUNC,
7823 		.v.func = alc283_fixup_sense_combo_jack,
7824 		.chained = true,
7825 		.chain_id = ALC283_FIXUP_CHROME_BOOK,
7826 	},
7827 	[ALC282_FIXUP_ASUS_TX300] = {
7828 		.type = HDA_FIXUP_FUNC,
7829 		.v.func = alc282_fixup_asus_tx300,
7830 	},
7831 	[ALC283_FIXUP_INT_MIC] = {
7832 		.type = HDA_FIXUP_VERBS,
7833 		.v.verbs = (const struct hda_verb[]) {
7834 			{0x20, AC_VERB_SET_COEF_INDEX, 0x1a},
7835 			{0x20, AC_VERB_SET_PROC_COEF, 0x0011},
7836 			{ }
7837 		},
7838 		.chained = true,
7839 		.chain_id = ALC269_FIXUP_LIMIT_INT_MIC_BOOST
7840 	},
7841 	[ALC290_FIXUP_SUBWOOFER_HSJACK] = {
7842 		.type = HDA_FIXUP_PINS,
7843 		.v.pins = (const struct hda_pintbl[]) {
7844 			{ 0x17, 0x90170112 }, /* subwoofer */
7845 			{ }
7846 		},
7847 		.chained = true,
7848 		.chain_id = ALC290_FIXUP_MONO_SPEAKERS_HSJACK,
7849 	},
7850 	[ALC290_FIXUP_SUBWOOFER] = {
7851 		.type = HDA_FIXUP_PINS,
7852 		.v.pins = (const struct hda_pintbl[]) {
7853 			{ 0x17, 0x90170112 }, /* subwoofer */
7854 			{ }
7855 		},
7856 		.chained = true,
7857 		.chain_id = ALC290_FIXUP_MONO_SPEAKERS,
7858 	},
7859 	[ALC290_FIXUP_MONO_SPEAKERS] = {
7860 		.type = HDA_FIXUP_FUNC,
7861 		.v.func = alc290_fixup_mono_speakers,
7862 	},
7863 	[ALC290_FIXUP_MONO_SPEAKERS_HSJACK] = {
7864 		.type = HDA_FIXUP_FUNC,
7865 		.v.func = alc290_fixup_mono_speakers,
7866 		.chained = true,
7867 		.chain_id = ALC269_FIXUP_DELL3_MIC_NO_PRESENCE,
7868 	},
7869 	[ALC269_FIXUP_THINKPAD_ACPI] = {
7870 		.type = HDA_FIXUP_FUNC,
7871 		.v.func = alc_fixup_thinkpad_acpi,
7872 		.chained = true,
7873 		.chain_id = ALC269_FIXUP_SKU_IGNORE,
7874 	},
7875 	[ALC269_FIXUP_DMIC_THINKPAD_ACPI] = {
7876 		.type = HDA_FIXUP_FUNC,
7877 		.v.func = alc_fixup_inv_dmic,
7878 		.chained = true,
7879 		.chain_id = ALC269_FIXUP_THINKPAD_ACPI,
7880 	},
7881 	[ALC255_FIXUP_ACER_MIC_NO_PRESENCE] = {
7882 		.type = HDA_FIXUP_PINS,
7883 		.v.pins = (const struct hda_pintbl[]) {
7884 			{ 0x19, 0x01a1913c }, /* use as headset mic, without its own jack detect */
7885 			{ }
7886 		},
7887 		.chained = true,
7888 		.chain_id = ALC255_FIXUP_HEADSET_MODE
7889 	},
7890 	[ALC255_FIXUP_ASUS_MIC_NO_PRESENCE] = {
7891 		.type = HDA_FIXUP_PINS,
7892 		.v.pins = (const struct hda_pintbl[]) {
7893 			{ 0x19, 0x01a1913c }, /* use as headset mic, without its own jack detect */
7894 			{ }
7895 		},
7896 		.chained = true,
7897 		.chain_id = ALC255_FIXUP_HEADSET_MODE
7898 	},
7899 	[ALC255_FIXUP_DELL1_MIC_NO_PRESENCE] = {
7900 		.type = HDA_FIXUP_PINS,
7901 		.v.pins = (const struct hda_pintbl[]) {
7902 			{ 0x19, 0x01a1913c }, /* use as headset mic, without its own jack detect */
7903 			{ 0x1a, 0x01a1913d }, /* use as headphone mic, without its own jack detect */
7904 			{ }
7905 		},
7906 		.chained = true,
7907 		.chain_id = ALC255_FIXUP_HEADSET_MODE
7908 	},
7909 	[ALC255_FIXUP_DELL2_MIC_NO_PRESENCE] = {
7910 		.type = HDA_FIXUP_PINS,
7911 		.v.pins = (const struct hda_pintbl[]) {
7912 			{ 0x19, 0x01a1913c }, /* use as headset mic, without its own jack detect */
7913 			{ }
7914 		},
7915 		.chained = true,
7916 		.chain_id = ALC255_FIXUP_HEADSET_MODE_NO_HP_MIC
7917 	},
7918 	[ALC255_FIXUP_HEADSET_MODE] = {
7919 		.type = HDA_FIXUP_FUNC,
7920 		.v.func = alc_fixup_headset_mode_alc255,
7921 		.chained = true,
7922 		.chain_id = ALC255_FIXUP_MIC_MUTE_LED
7923 	},
7924 	[ALC255_FIXUP_HEADSET_MODE_NO_HP_MIC] = {
7925 		.type = HDA_FIXUP_FUNC,
7926 		.v.func = alc_fixup_headset_mode_alc255_no_hp_mic,
7927 	},
7928 	[ALC293_FIXUP_DELL1_MIC_NO_PRESENCE] = {
7929 		.type = HDA_FIXUP_PINS,
7930 		.v.pins = (const struct hda_pintbl[]) {
7931 			{ 0x18, 0x01a1913d }, /* use as headphone mic, without its own jack detect */
7932 			{ 0x1a, 0x01a1913c }, /* use as headset mic, without its own jack detect */
7933 			{ }
7934 		},
7935 		.chained = true,
7936 		.chain_id = ALC269_FIXUP_HEADSET_MODE
7937 	},
7938 	[ALC292_FIXUP_TPT440_DOCK] = {
7939 		.type = HDA_FIXUP_FUNC,
7940 		.v.func = alc_fixup_tpt440_dock,
7941 		.chained = true,
7942 		.chain_id = ALC269_FIXUP_LIMIT_INT_MIC_BOOST
7943 	},
7944 	[ALC292_FIXUP_TPT440] = {
7945 		.type = HDA_FIXUP_FUNC,
7946 		.v.func = alc_fixup_disable_aamix,
7947 		.chained = true,
7948 		.chain_id = ALC292_FIXUP_TPT440_DOCK,
7949 	},
7950 	[ALC283_FIXUP_HEADSET_MIC] = {
7951 		.type = HDA_FIXUP_PINS,
7952 		.v.pins = (const struct hda_pintbl[]) {
7953 			{ 0x19, 0x04a110f0 },
7954 			{ },
7955 		},
7956 	},
7957 	[ALC255_FIXUP_MIC_MUTE_LED] = {
7958 		.type = HDA_FIXUP_FUNC,
7959 		.v.func = alc_fixup_micmute_led,
7960 	},
7961 	[ALC282_FIXUP_ASPIRE_V5_PINS] = {
7962 		.type = HDA_FIXUP_PINS,
7963 		.v.pins = (const struct hda_pintbl[]) {
7964 			{ 0x12, 0x90a60130 },
7965 			{ 0x14, 0x90170110 },
7966 			{ 0x17, 0x40000008 },
7967 			{ 0x18, 0x411111f0 },
7968 			{ 0x19, 0x01a1913c },
7969 			{ 0x1a, 0x411111f0 },
7970 			{ 0x1b, 0x411111f0 },
7971 			{ 0x1d, 0x40f89b2d },
7972 			{ 0x1e, 0x411111f0 },
7973 			{ 0x21, 0x0321101f },
7974 			{ },
7975 		},
7976 	},
7977 	[ALC269VB_FIXUP_ASPIRE_E1_COEF] = {
7978 		.type = HDA_FIXUP_FUNC,
7979 		.v.func = alc269vb_fixup_aspire_e1_coef,
7980 	},
7981 	[ALC280_FIXUP_HP_GPIO4] = {
7982 		.type = HDA_FIXUP_FUNC,
7983 		.v.func = alc280_fixup_hp_gpio4,
7984 	},
7985 	[ALC286_FIXUP_HP_GPIO_LED] = {
7986 		.type = HDA_FIXUP_FUNC,
7987 		.v.func = alc286_fixup_hp_gpio_led,
7988 	},
7989 	[ALC280_FIXUP_HP_GPIO2_MIC_HOTKEY] = {
7990 		.type = HDA_FIXUP_FUNC,
7991 		.v.func = alc280_fixup_hp_gpio2_mic_hotkey,
7992 	},
7993 	[ALC280_FIXUP_HP_DOCK_PINS] = {
7994 		.type = HDA_FIXUP_PINS,
7995 		.v.pins = (const struct hda_pintbl[]) {
7996 			{ 0x1b, 0x21011020 }, /* line-out */
7997 			{ 0x1a, 0x01a1903c }, /* headset mic */
7998 			{ 0x18, 0x2181103f }, /* line-in */
7999 			{ },
8000 		},
8001 		.chained = true,
8002 		.chain_id = ALC280_FIXUP_HP_GPIO4
8003 	},
8004 	[ALC269_FIXUP_HP_DOCK_GPIO_MIC1_LED] = {
8005 		.type = HDA_FIXUP_PINS,
8006 		.v.pins = (const struct hda_pintbl[]) {
8007 			{ 0x1b, 0x21011020 }, /* line-out */
8008 			{ 0x18, 0x2181103f }, /* line-in */
8009 			{ },
8010 		},
8011 		.chained = true,
8012 		.chain_id = ALC269_FIXUP_HP_GPIO_MIC1_LED
8013 	},
8014 	[ALC280_FIXUP_HP_9480M] = {
8015 		.type = HDA_FIXUP_FUNC,
8016 		.v.func = alc280_fixup_hp_9480m,
8017 	},
8018 	[ALC245_FIXUP_HP_X360_AMP] = {
8019 		.type = HDA_FIXUP_FUNC,
8020 		.v.func = alc245_fixup_hp_x360_amp,
8021 		.chained = true,
8022 		.chain_id = ALC245_FIXUP_HP_GPIO_LED
8023 	},
8024 	[ALC288_FIXUP_DELL_HEADSET_MODE] = {
8025 		.type = HDA_FIXUP_FUNC,
8026 		.v.func = alc_fixup_headset_mode_dell_alc288,
8027 		.chained = true,
8028 		.chain_id = ALC255_FIXUP_MIC_MUTE_LED
8029 	},
8030 	[ALC288_FIXUP_DELL1_MIC_NO_PRESENCE] = {
8031 		.type = HDA_FIXUP_PINS,
8032 		.v.pins = (const struct hda_pintbl[]) {
8033 			{ 0x18, 0x01a1913c }, /* use as headset mic, without its own jack detect */
8034 			{ 0x1a, 0x01a1913d }, /* use as headphone mic, without its own jack detect */
8035 			{ }
8036 		},
8037 		.chained = true,
8038 		.chain_id = ALC288_FIXUP_DELL_HEADSET_MODE
8039 	},
8040 	[ALC288_FIXUP_DISABLE_AAMIX] = {
8041 		.type = HDA_FIXUP_FUNC,
8042 		.v.func = alc_fixup_disable_aamix,
8043 		.chained = true,
8044 		.chain_id = ALC288_FIXUP_DELL1_MIC_NO_PRESENCE
8045 	},
8046 	[ALC288_FIXUP_DELL_XPS_13] = {
8047 		.type = HDA_FIXUP_FUNC,
8048 		.v.func = alc_fixup_dell_xps13,
8049 		.chained = true,
8050 		.chain_id = ALC288_FIXUP_DISABLE_AAMIX
8051 	},
8052 	[ALC292_FIXUP_DISABLE_AAMIX] = {
8053 		.type = HDA_FIXUP_FUNC,
8054 		.v.func = alc_fixup_disable_aamix,
8055 		.chained = true,
8056 		.chain_id = ALC269_FIXUP_DELL2_MIC_NO_PRESENCE
8057 	},
8058 	[ALC293_FIXUP_DISABLE_AAMIX_MULTIJACK] = {
8059 		.type = HDA_FIXUP_FUNC,
8060 		.v.func = alc_fixup_disable_aamix,
8061 		.chained = true,
8062 		.chain_id = ALC293_FIXUP_DELL1_MIC_NO_PRESENCE
8063 	},
8064 	[ALC292_FIXUP_DELL_E7X_AAMIX] = {
8065 		.type = HDA_FIXUP_FUNC,
8066 		.v.func = alc_fixup_dell_xps13,
8067 		.chained = true,
8068 		.chain_id = ALC292_FIXUP_DISABLE_AAMIX
8069 	},
8070 	[ALC292_FIXUP_DELL_E7X] = {
8071 		.type = HDA_FIXUP_FUNC,
8072 		.v.func = alc_fixup_micmute_led,
8073 		/* micmute fixup must be applied at last */
8074 		.chained_before = true,
8075 		.chain_id = ALC292_FIXUP_DELL_E7X_AAMIX,
8076 	},
8077 	[ALC298_FIXUP_ALIENWARE_MIC_NO_PRESENCE] = {
8078 		.type = HDA_FIXUP_PINS,
8079 		.v.pins = (const struct hda_pintbl[]) {
8080 			{ 0x18, 0x01a1913c }, /* headset mic w/o jack detect */
8081 			{ }
8082 		},
8083 		.chained_before = true,
8084 		.chain_id = ALC269_FIXUP_HEADSET_MODE,
8085 	},
8086 	[ALC298_FIXUP_DELL1_MIC_NO_PRESENCE] = {
8087 		.type = HDA_FIXUP_PINS,
8088 		.v.pins = (const struct hda_pintbl[]) {
8089 			{ 0x18, 0x01a1913c }, /* use as headset mic, without its own jack detect */
8090 			{ 0x1a, 0x01a1913d }, /* use as headphone mic, without its own jack detect */
8091 			{ }
8092 		},
8093 		.chained = true,
8094 		.chain_id = ALC269_FIXUP_HEADSET_MODE
8095 	},
8096 	[ALC298_FIXUP_DELL_AIO_MIC_NO_PRESENCE] = {
8097 		.type = HDA_FIXUP_PINS,
8098 		.v.pins = (const struct hda_pintbl[]) {
8099 			{ 0x18, 0x01a1913c }, /* use as headset mic, without its own jack detect */
8100 			{ }
8101 		},
8102 		.chained = true,
8103 		.chain_id = ALC269_FIXUP_HEADSET_MODE
8104 	},
8105 	[ALC275_FIXUP_DELL_XPS] = {
8106 		.type = HDA_FIXUP_VERBS,
8107 		.v.verbs = (const struct hda_verb[]) {
8108 			/* Enables internal speaker */
8109 			{0x20, AC_VERB_SET_COEF_INDEX, 0x1f},
8110 			{0x20, AC_VERB_SET_PROC_COEF, 0x00c0},
8111 			{0x20, AC_VERB_SET_COEF_INDEX, 0x30},
8112 			{0x20, AC_VERB_SET_PROC_COEF, 0x00b1},
8113 			{}
8114 		}
8115 	},
8116 	[ALC293_FIXUP_LENOVO_SPK_NOISE] = {
8117 		.type = HDA_FIXUP_FUNC,
8118 		.v.func = alc_fixup_disable_aamix,
8119 		.chained = true,
8120 		.chain_id = ALC269_FIXUP_THINKPAD_ACPI
8121 	},
8122 	[ALC233_FIXUP_LENOVO_LINE2_MIC_HOTKEY] = {
8123 		.type = HDA_FIXUP_FUNC,
8124 		.v.func = alc233_fixup_lenovo_line2_mic_hotkey,
8125 	},
8126 	[ALC233_FIXUP_INTEL_NUC8_DMIC] = {
8127 		.type = HDA_FIXUP_FUNC,
8128 		.v.func = alc_fixup_inv_dmic,
8129 		.chained = true,
8130 		.chain_id = ALC233_FIXUP_INTEL_NUC8_BOOST,
8131 	},
8132 	[ALC233_FIXUP_INTEL_NUC8_BOOST] = {
8133 		.type = HDA_FIXUP_FUNC,
8134 		.v.func = alc269_fixup_limit_int_mic_boost
8135 	},
8136 	[ALC255_FIXUP_DELL_SPK_NOISE] = {
8137 		.type = HDA_FIXUP_FUNC,
8138 		.v.func = alc_fixup_disable_aamix,
8139 		.chained = true,
8140 		.chain_id = ALC255_FIXUP_DELL1_MIC_NO_PRESENCE
8141 	},
8142 	[ALC225_FIXUP_DISABLE_MIC_VREF] = {
8143 		.type = HDA_FIXUP_FUNC,
8144 		.v.func = alc_fixup_disable_mic_vref,
8145 		.chained = true,
8146 		.chain_id = ALC269_FIXUP_DELL1_MIC_NO_PRESENCE
8147 	},
8148 	[ALC225_FIXUP_DELL1_MIC_NO_PRESENCE] = {
8149 		.type = HDA_FIXUP_VERBS,
8150 		.v.verbs = (const struct hda_verb[]) {
8151 			/* Disable pass-through path for FRONT 14h */
8152 			{ 0x20, AC_VERB_SET_COEF_INDEX, 0x36 },
8153 			{ 0x20, AC_VERB_SET_PROC_COEF, 0x57d7 },
8154 			{}
8155 		},
8156 		.chained = true,
8157 		.chain_id = ALC225_FIXUP_DISABLE_MIC_VREF
8158 	},
8159 	[ALC280_FIXUP_HP_HEADSET_MIC] = {
8160 		.type = HDA_FIXUP_FUNC,
8161 		.v.func = alc_fixup_disable_aamix,
8162 		.chained = true,
8163 		.chain_id = ALC269_FIXUP_HEADSET_MIC,
8164 	},
8165 	[ALC221_FIXUP_HP_FRONT_MIC] = {
8166 		.type = HDA_FIXUP_PINS,
8167 		.v.pins = (const struct hda_pintbl[]) {
8168 			{ 0x19, 0x02a19020 }, /* Front Mic */
8169 			{ }
8170 		},
8171 	},
8172 	[ALC292_FIXUP_TPT460] = {
8173 		.type = HDA_FIXUP_FUNC,
8174 		.v.func = alc_fixup_tpt440_dock,
8175 		.chained = true,
8176 		.chain_id = ALC293_FIXUP_LENOVO_SPK_NOISE,
8177 	},
8178 	[ALC298_FIXUP_SPK_VOLUME] = {
8179 		.type = HDA_FIXUP_FUNC,
8180 		.v.func = alc298_fixup_speaker_volume,
8181 		.chained = true,
8182 		.chain_id = ALC298_FIXUP_DELL_AIO_MIC_NO_PRESENCE,
8183 	},
8184 	[ALC298_FIXUP_LENOVO_SPK_VOLUME] = {
8185 		.type = HDA_FIXUP_FUNC,
8186 		.v.func = alc298_fixup_speaker_volume,
8187 	},
8188 	[ALC295_FIXUP_DISABLE_DAC3] = {
8189 		.type = HDA_FIXUP_FUNC,
8190 		.v.func = alc295_fixup_disable_dac3,
8191 	},
8192 	[ALC285_FIXUP_SPEAKER2_TO_DAC1] = {
8193 		.type = HDA_FIXUP_FUNC,
8194 		.v.func = alc285_fixup_speaker2_to_dac1,
8195 		.chained = true,
8196 		.chain_id = ALC269_FIXUP_THINKPAD_ACPI
8197 	},
8198 	[ALC285_FIXUP_ASUS_SPEAKER2_TO_DAC1] = {
8199 		.type = HDA_FIXUP_FUNC,
8200 		.v.func = alc285_fixup_speaker2_to_dac1,
8201 		.chained = true,
8202 		.chain_id = ALC245_FIXUP_CS35L41_SPI_2
8203 	},
8204 	[ALC285_FIXUP_ASUS_HEADSET_MIC] = {
8205 		.type = HDA_FIXUP_PINS,
8206 		.v.pins = (const struct hda_pintbl[]) {
8207 			{ 0x19, 0x03a11050 },
8208 			{ 0x1b, 0x03a11c30 },
8209 			{ }
8210 		},
8211 		.chained = true,
8212 		.chain_id = ALC285_FIXUP_ASUS_SPEAKER2_TO_DAC1
8213 	},
8214 	[ALC285_FIXUP_ASUS_SPI_REAR_SPEAKERS] = {
8215 		.type = HDA_FIXUP_PINS,
8216 		.v.pins = (const struct hda_pintbl[]) {
8217 			{ 0x14, 0x90170120 },
8218 			{ }
8219 		},
8220 		.chained = true,
8221 		.chain_id = ALC285_FIXUP_ASUS_HEADSET_MIC
8222 	},
8223 	[ALC285_FIXUP_ASUS_I2C_SPEAKER2_TO_DAC1] = {
8224 		.type = HDA_FIXUP_FUNC,
8225 		.v.func = alc285_fixup_speaker2_to_dac1,
8226 		.chained = true,
8227 		.chain_id = ALC287_FIXUP_CS35L41_I2C_2
8228 	},
8229 	[ALC285_FIXUP_ASUS_I2C_HEADSET_MIC] = {
8230 		.type = HDA_FIXUP_PINS,
8231 		.v.pins = (const struct hda_pintbl[]) {
8232 			{ 0x19, 0x03a11050 },
8233 			{ 0x1b, 0x03a11c30 },
8234 			{ }
8235 		},
8236 		.chained = true,
8237 		.chain_id = ALC285_FIXUP_ASUS_I2C_SPEAKER2_TO_DAC1
8238 	},
8239 	[ALC256_FIXUP_DELL_INSPIRON_7559_SUBWOOFER] = {
8240 		.type = HDA_FIXUP_PINS,
8241 		.v.pins = (const struct hda_pintbl[]) {
8242 			{ 0x1b, 0x90170151 },
8243 			{ }
8244 		},
8245 		.chained = true,
8246 		.chain_id = ALC255_FIXUP_DELL1_MIC_NO_PRESENCE
8247 	},
8248 	[ALC269_FIXUP_ATIV_BOOK_8] = {
8249 		.type = HDA_FIXUP_FUNC,
8250 		.v.func = alc_fixup_auto_mute_via_amp,
8251 		.chained = true,
8252 		.chain_id = ALC269_FIXUP_NO_SHUTUP
8253 	},
8254 	[ALC221_FIXUP_HP_288PRO_MIC_NO_PRESENCE] = {
8255 		.type = HDA_FIXUP_PINS,
8256 		.v.pins = (const struct hda_pintbl[]) {
8257 			{ 0x19, 0x01a1913c }, /* use as headset mic, without its own jack detect */
8258 			{ 0x1a, 0x01813030 }, /* use as headphone mic, without its own jack detect */
8259 			{ }
8260 		},
8261 		.chained = true,
8262 		.chain_id = ALC269_FIXUP_HEADSET_MODE
8263 	},
8264 	[ALC221_FIXUP_HP_MIC_NO_PRESENCE] = {
8265 		.type = HDA_FIXUP_PINS,
8266 		.v.pins = (const struct hda_pintbl[]) {
8267 			{ 0x18, 0x01a1913c }, /* use as headset mic, without its own jack detect */
8268 			{ 0x1a, 0x01a1913d }, /* use as headphone mic, without its own jack detect */
8269 			{ }
8270 		},
8271 		.chained = true,
8272 		.chain_id = ALC269_FIXUP_HEADSET_MODE
8273 	},
8274 	[ALC256_FIXUP_ASUS_HEADSET_MODE] = {
8275 		.type = HDA_FIXUP_FUNC,
8276 		.v.func = alc_fixup_headset_mode,
8277 	},
8278 	[ALC256_FIXUP_ASUS_MIC] = {
8279 		.type = HDA_FIXUP_PINS,
8280 		.v.pins = (const struct hda_pintbl[]) {
8281 			{ 0x13, 0x90a60160 }, /* use as internal mic */
8282 			{ 0x19, 0x04a11120 }, /* use as headset mic, without its own jack detect */
8283 			{ }
8284 		},
8285 		.chained = true,
8286 		.chain_id = ALC256_FIXUP_ASUS_HEADSET_MODE
8287 	},
8288 	[ALC256_FIXUP_ASUS_AIO_GPIO2] = {
8289 		.type = HDA_FIXUP_FUNC,
8290 		/* Set up GPIO2 for the speaker amp */
8291 		.v.func = alc_fixup_gpio4,
8292 	},
8293 	[ALC233_FIXUP_ASUS_MIC_NO_PRESENCE] = {
8294 		.type = HDA_FIXUP_PINS,
8295 		.v.pins = (const struct hda_pintbl[]) {
8296 			{ 0x19, 0x01a1913c }, /* use as headset mic, without its own jack detect */
8297 			{ }
8298 		},
8299 		.chained = true,
8300 		.chain_id = ALC269_FIXUP_HEADSET_MIC
8301 	},
8302 	[ALC233_FIXUP_EAPD_COEF_AND_MIC_NO_PRESENCE] = {
8303 		.type = HDA_FIXUP_VERBS,
8304 		.v.verbs = (const struct hda_verb[]) {
8305 			/* Enables internal speaker */
8306 			{0x20, AC_VERB_SET_COEF_INDEX, 0x40},
8307 			{0x20, AC_VERB_SET_PROC_COEF, 0x8800},
8308 			{}
8309 		},
8310 		.chained = true,
8311 		.chain_id = ALC233_FIXUP_ASUS_MIC_NO_PRESENCE
8312 	},
8313 	[ALC233_FIXUP_LENOVO_MULTI_CODECS] = {
8314 		.type = HDA_FIXUP_FUNC,
8315 		.v.func = alc233_alc662_fixup_lenovo_dual_codecs,
8316 		.chained = true,
8317 		.chain_id = ALC269_FIXUP_GPIO2
8318 	},
8319 	[ALC233_FIXUP_ACER_HEADSET_MIC] = {
8320 		.type = HDA_FIXUP_VERBS,
8321 		.v.verbs = (const struct hda_verb[]) {
8322 			{ 0x20, AC_VERB_SET_COEF_INDEX, 0x45 },
8323 			{ 0x20, AC_VERB_SET_PROC_COEF, 0x5089 },
8324 			{ }
8325 		},
8326 		.chained = true,
8327 		.chain_id = ALC233_FIXUP_ASUS_MIC_NO_PRESENCE
8328 	},
8329 	[ALC294_FIXUP_LENOVO_MIC_LOCATION] = {
8330 		.type = HDA_FIXUP_PINS,
8331 		.v.pins = (const struct hda_pintbl[]) {
8332 			/* Change the mic location from front to right, otherwise there are
8333 			   two front mics with the same name, pulseaudio can't handle them.
8334 			   This is just a temporary workaround, after applying this fixup,
8335 			   there will be one "Front Mic" and one "Mic" in this machine.
8336 			 */
8337 			{ 0x1a, 0x04a19040 },
8338 			{ }
8339 		},
8340 	},
8341 	[ALC225_FIXUP_DELL_WYSE_MIC_NO_PRESENCE] = {
8342 		.type = HDA_FIXUP_PINS,
8343 		.v.pins = (const struct hda_pintbl[]) {
8344 			{ 0x16, 0x0101102f }, /* Rear Headset HP */
8345 			{ 0x19, 0x02a1913c }, /* use as Front headset mic, without its own jack detect */
8346 			{ 0x1a, 0x01a19030 }, /* Rear Headset MIC */
8347 			{ 0x1b, 0x02011020 },
8348 			{ }
8349 		},
8350 		.chained = true,
8351 		.chain_id = ALC225_FIXUP_S3_POP_NOISE
8352 	},
8353 	[ALC225_FIXUP_S3_POP_NOISE] = {
8354 		.type = HDA_FIXUP_FUNC,
8355 		.v.func = alc225_fixup_s3_pop_noise,
8356 		.chained = true,
8357 		.chain_id = ALC269_FIXUP_HEADSET_MODE_NO_HP_MIC
8358 	},
8359 	[ALC700_FIXUP_INTEL_REFERENCE] = {
8360 		.type = HDA_FIXUP_VERBS,
8361 		.v.verbs = (const struct hda_verb[]) {
8362 			/* Enables internal speaker */
8363 			{0x20, AC_VERB_SET_COEF_INDEX, 0x45},
8364 			{0x20, AC_VERB_SET_PROC_COEF, 0x5289},
8365 			{0x20, AC_VERB_SET_COEF_INDEX, 0x4A},
8366 			{0x20, AC_VERB_SET_PROC_COEF, 0x001b},
8367 			{0x58, AC_VERB_SET_COEF_INDEX, 0x00},
8368 			{0x58, AC_VERB_SET_PROC_COEF, 0x3888},
8369 			{0x20, AC_VERB_SET_COEF_INDEX, 0x6f},
8370 			{0x20, AC_VERB_SET_PROC_COEF, 0x2c0b},
8371 			{}
8372 		}
8373 	},
8374 	[ALC274_FIXUP_DELL_BIND_DACS] = {
8375 		.type = HDA_FIXUP_FUNC,
8376 		.v.func = alc274_fixup_bind_dacs,
8377 		.chained = true,
8378 		.chain_id = ALC269_FIXUP_DELL1_MIC_NO_PRESENCE
8379 	},
8380 	[ALC274_FIXUP_DELL_AIO_LINEOUT_VERB] = {
8381 		.type = HDA_FIXUP_PINS,
8382 		.v.pins = (const struct hda_pintbl[]) {
8383 			{ 0x1b, 0x0401102f },
8384 			{ }
8385 		},
8386 		.chained = true,
8387 		.chain_id = ALC274_FIXUP_DELL_BIND_DACS
8388 	},
8389 	[ALC298_FIXUP_TPT470_DOCK_FIX] = {
8390 		.type = HDA_FIXUP_FUNC,
8391 		.v.func = alc_fixup_tpt470_dock,
8392 		.chained = true,
8393 		.chain_id = ALC293_FIXUP_LENOVO_SPK_NOISE
8394 	},
8395 	[ALC298_FIXUP_TPT470_DOCK] = {
8396 		.type = HDA_FIXUP_FUNC,
8397 		.v.func = alc_fixup_tpt470_dacs,
8398 		.chained = true,
8399 		.chain_id = ALC298_FIXUP_TPT470_DOCK_FIX
8400 	},
8401 	[ALC255_FIXUP_DUMMY_LINEOUT_VERB] = {
8402 		.type = HDA_FIXUP_PINS,
8403 		.v.pins = (const struct hda_pintbl[]) {
8404 			{ 0x14, 0x0201101f },
8405 			{ }
8406 		},
8407 		.chained = true,
8408 		.chain_id = ALC255_FIXUP_DELL1_MIC_NO_PRESENCE
8409 	},
8410 	[ALC255_FIXUP_DELL_HEADSET_MIC] = {
8411 		.type = HDA_FIXUP_PINS,
8412 		.v.pins = (const struct hda_pintbl[]) {
8413 			{ 0x19, 0x01a1913c }, /* use as headset mic, without its own jack detect */
8414 			{ }
8415 		},
8416 		.chained = true,
8417 		.chain_id = ALC269_FIXUP_HEADSET_MIC
8418 	},
8419 	[ALC295_FIXUP_HP_X360] = {
8420 		.type = HDA_FIXUP_FUNC,
8421 		.v.func = alc295_fixup_hp_top_speakers,
8422 		.chained = true,
8423 		.chain_id = ALC269_FIXUP_HP_MUTE_LED_MIC3
8424 	},
8425 	[ALC221_FIXUP_HP_HEADSET_MIC] = {
8426 		.type = HDA_FIXUP_PINS,
8427 		.v.pins = (const struct hda_pintbl[]) {
8428 			{ 0x19, 0x0181313f},
8429 			{ }
8430 		},
8431 		.chained = true,
8432 		.chain_id = ALC269_FIXUP_HEADSET_MIC
8433 	},
8434 	[ALC285_FIXUP_LENOVO_HEADPHONE_NOISE] = {
8435 		.type = HDA_FIXUP_FUNC,
8436 		.v.func = alc285_fixup_invalidate_dacs,
8437 		.chained = true,
8438 		.chain_id = ALC269_FIXUP_THINKPAD_ACPI
8439 	},
8440 	[ALC295_FIXUP_HP_AUTO_MUTE] = {
8441 		.type = HDA_FIXUP_FUNC,
8442 		.v.func = alc_fixup_auto_mute_via_amp,
8443 	},
8444 	[ALC286_FIXUP_ACER_AIO_MIC_NO_PRESENCE] = {
8445 		.type = HDA_FIXUP_PINS,
8446 		.v.pins = (const struct hda_pintbl[]) {
8447 			{ 0x18, 0x01a1913c }, /* use as headset mic, without its own jack detect */
8448 			{ }
8449 		},
8450 		.chained = true,
8451 		.chain_id = ALC269_FIXUP_HEADSET_MIC
8452 	},
8453 	[ALC294_FIXUP_ASUS_MIC] = {
8454 		.type = HDA_FIXUP_PINS,
8455 		.v.pins = (const struct hda_pintbl[]) {
8456 			{ 0x13, 0x90a60160 }, /* use as internal mic */
8457 			{ 0x19, 0x04a11120 }, /* use as headset mic, without its own jack detect */
8458 			{ }
8459 		},
8460 		.chained = true,
8461 		.chain_id = ALC269_FIXUP_HEADSET_MIC
8462 	},
8463 	[ALC294_FIXUP_ASUS_HEADSET_MIC] = {
8464 		.type = HDA_FIXUP_PINS,
8465 		.v.pins = (const struct hda_pintbl[]) {
8466 			{ 0x19, 0x01a1103c }, /* use as headset mic */
8467 			{ }
8468 		},
8469 		.chained = true,
8470 		.chain_id = ALC269_FIXUP_HEADSET_MIC
8471 	},
8472 	[ALC294_FIXUP_ASUS_SPK] = {
8473 		.type = HDA_FIXUP_VERBS,
8474 		.v.verbs = (const struct hda_verb[]) {
8475 			/* Set EAPD high */
8476 			{ 0x20, AC_VERB_SET_COEF_INDEX, 0x40 },
8477 			{ 0x20, AC_VERB_SET_PROC_COEF, 0x8800 },
8478 			{ 0x20, AC_VERB_SET_COEF_INDEX, 0x0f },
8479 			{ 0x20, AC_VERB_SET_PROC_COEF, 0x7774 },
8480 			{ }
8481 		},
8482 		.chained = true,
8483 		.chain_id = ALC294_FIXUP_ASUS_HEADSET_MIC
8484 	},
8485 	[ALC295_FIXUP_CHROME_BOOK] = {
8486 		.type = HDA_FIXUP_FUNC,
8487 		.v.func = alc295_fixup_chromebook,
8488 		.chained = true,
8489 		.chain_id = ALC225_FIXUP_HEADSET_JACK
8490 	},
8491 	[ALC225_FIXUP_HEADSET_JACK] = {
8492 		.type = HDA_FIXUP_FUNC,
8493 		.v.func = alc_fixup_headset_jack,
8494 	},
8495 	[ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE] = {
8496 		.type = HDA_FIXUP_PINS,
8497 		.v.pins = (const struct hda_pintbl[]) {
8498 			{ 0x1a, 0x01a1913c }, /* use as headset mic, without its own jack detect */
8499 			{ }
8500 		},
8501 		.chained = true,
8502 		.chain_id = ALC269_FIXUP_HEADSET_MODE_NO_HP_MIC
8503 	},
8504 	[ALC285_FIXUP_LENOVO_PC_BEEP_IN_NOISE] = {
8505 		.type = HDA_FIXUP_VERBS,
8506 		.v.verbs = (const struct hda_verb[]) {
8507 			/* Disable PCBEEP-IN passthrough */
8508 			{ 0x20, AC_VERB_SET_COEF_INDEX, 0x36 },
8509 			{ 0x20, AC_VERB_SET_PROC_COEF, 0x57d7 },
8510 			{ }
8511 		},
8512 		.chained = true,
8513 		.chain_id = ALC285_FIXUP_LENOVO_HEADPHONE_NOISE
8514 	},
8515 	[ALC255_FIXUP_ACER_HEADSET_MIC] = {
8516 		.type = HDA_FIXUP_PINS,
8517 		.v.pins = (const struct hda_pintbl[]) {
8518 			{ 0x19, 0x03a11130 },
8519 			{ 0x1a, 0x90a60140 }, /* use as internal mic */
8520 			{ }
8521 		},
8522 		.chained = true,
8523 		.chain_id = ALC255_FIXUP_HEADSET_MODE_NO_HP_MIC
8524 	},
8525 	[ALC225_FIXUP_DELL_WYSE_AIO_MIC_NO_PRESENCE] = {
8526 		.type = HDA_FIXUP_PINS,
8527 		.v.pins = (const struct hda_pintbl[]) {
8528 			{ 0x16, 0x01011020 }, /* Rear Line out */
8529 			{ 0x19, 0x01a1913c }, /* use as Front headset mic, without its own jack detect */
8530 			{ }
8531 		},
8532 		.chained = true,
8533 		.chain_id = ALC225_FIXUP_WYSE_AUTO_MUTE
8534 	},
8535 	[ALC225_FIXUP_WYSE_AUTO_MUTE] = {
8536 		.type = HDA_FIXUP_FUNC,
8537 		.v.func = alc_fixup_auto_mute_via_amp,
8538 		.chained = true,
8539 		.chain_id = ALC225_FIXUP_WYSE_DISABLE_MIC_VREF
8540 	},
8541 	[ALC225_FIXUP_WYSE_DISABLE_MIC_VREF] = {
8542 		.type = HDA_FIXUP_FUNC,
8543 		.v.func = alc_fixup_disable_mic_vref,
8544 		.chained = true,
8545 		.chain_id = ALC269_FIXUP_HEADSET_MODE_NO_HP_MIC
8546 	},
8547 	[ALC286_FIXUP_ACER_AIO_HEADSET_MIC] = {
8548 		.type = HDA_FIXUP_VERBS,
8549 		.v.verbs = (const struct hda_verb[]) {
8550 			{ 0x20, AC_VERB_SET_COEF_INDEX, 0x4f },
8551 			{ 0x20, AC_VERB_SET_PROC_COEF, 0x5029 },
8552 			{ }
8553 		},
8554 		.chained = true,
8555 		.chain_id = ALC286_FIXUP_ACER_AIO_MIC_NO_PRESENCE
8556 	},
8557 	[ALC256_FIXUP_ASUS_HEADSET_MIC] = {
8558 		.type = HDA_FIXUP_PINS,
8559 		.v.pins = (const struct hda_pintbl[]) {
8560 			{ 0x19, 0x03a11020 }, /* headset mic with jack detect */
8561 			{ }
8562 		},
8563 		.chained = true,
8564 		.chain_id = ALC256_FIXUP_ASUS_HEADSET_MODE
8565 	},
8566 	[ALC256_FIXUP_ASUS_MIC_NO_PRESENCE] = {
8567 		.type = HDA_FIXUP_PINS,
8568 		.v.pins = (const struct hda_pintbl[]) {
8569 			{ 0x19, 0x04a11120 }, /* use as headset mic, without its own jack detect */
8570 			{ }
8571 		},
8572 		.chained = true,
8573 		.chain_id = ALC256_FIXUP_ASUS_HEADSET_MODE
8574 	},
8575 	[ALC299_FIXUP_PREDATOR_SPK] = {
8576 		.type = HDA_FIXUP_PINS,
8577 		.v.pins = (const struct hda_pintbl[]) {
8578 			{ 0x21, 0x90170150 }, /* use as headset mic, without its own jack detect */
8579 			{ }
8580 		}
8581 	},
8582 	[ALC256_FIXUP_MEDION_HEADSET_NO_PRESENCE] = {
8583 		.type = HDA_FIXUP_PINS,
8584 		.v.pins = (const struct hda_pintbl[]) {
8585 			{ 0x19, 0x04a11040 },
8586 			{ 0x21, 0x04211020 },
8587 			{ }
8588 		},
8589 		.chained = true,
8590 		.chain_id = ALC256_FIXUP_ASUS_HEADSET_MODE
8591 	},
8592 	[ALC289_FIXUP_DELL_SPK2] = {
8593 		.type = HDA_FIXUP_PINS,
8594 		.v.pins = (const struct hda_pintbl[]) {
8595 			{ 0x17, 0x90170130 }, /* bass spk */
8596 			{ }
8597 		},
8598 		.chained = true,
8599 		.chain_id = ALC269_FIXUP_DELL4_MIC_NO_PRESENCE
8600 	},
8601 	[ALC289_FIXUP_DUAL_SPK] = {
8602 		.type = HDA_FIXUP_FUNC,
8603 		.v.func = alc285_fixup_speaker2_to_dac1,
8604 		.chained = true,
8605 		.chain_id = ALC289_FIXUP_DELL_SPK2
8606 	},
8607 	[ALC294_FIXUP_SPK2_TO_DAC1] = {
8608 		.type = HDA_FIXUP_FUNC,
8609 		.v.func = alc285_fixup_speaker2_to_dac1,
8610 		.chained = true,
8611 		.chain_id = ALC294_FIXUP_ASUS_HEADSET_MIC
8612 	},
8613 	[ALC294_FIXUP_ASUS_DUAL_SPK] = {
8614 		.type = HDA_FIXUP_FUNC,
8615 		/* The GPIO must be pulled to initialize the AMP */
8616 		.v.func = alc_fixup_gpio4,
8617 		.chained = true,
8618 		.chain_id = ALC294_FIXUP_SPK2_TO_DAC1
8619 	},
8620 	[ALC294_FIXUP_ASUS_ALLY] = {
8621 		.type = HDA_FIXUP_FUNC,
8622 		.v.func = cs35l41_fixup_i2c_two,
8623 		.chained = true,
8624 		.chain_id = ALC294_FIXUP_ASUS_ALLY_PINS
8625 	},
8626 	[ALC294_FIXUP_ASUS_ALLY_PINS] = {
8627 		.type = HDA_FIXUP_PINS,
8628 		.v.pins = (const struct hda_pintbl[]) {
8629 			{ 0x19, 0x03a11050 },
8630 			{ 0x1a, 0x03a11c30 },
8631 			{ 0x21, 0x03211420 },
8632 			{ }
8633 		},
8634 		.chained = true,
8635 		.chain_id = ALC294_FIXUP_ASUS_ALLY_VERBS
8636 	},
8637 	[ALC294_FIXUP_ASUS_ALLY_VERBS] = {
8638 		.type = HDA_FIXUP_VERBS,
8639 		.v.verbs = (const struct hda_verb[]) {
8640 			{ 0x20, AC_VERB_SET_COEF_INDEX, 0x45 },
8641 			{ 0x20, AC_VERB_SET_PROC_COEF, 0x5089 },
8642 			{ 0x20, AC_VERB_SET_COEF_INDEX, 0x46 },
8643 			{ 0x20, AC_VERB_SET_PROC_COEF, 0x0004 },
8644 			{ 0x20, AC_VERB_SET_COEF_INDEX, 0x47 },
8645 			{ 0x20, AC_VERB_SET_PROC_COEF, 0xa47a },
8646 			{ 0x20, AC_VERB_SET_COEF_INDEX, 0x49 },
8647 			{ 0x20, AC_VERB_SET_PROC_COEF, 0x0049},
8648 			{ 0x20, AC_VERB_SET_COEF_INDEX, 0x4a },
8649 			{ 0x20, AC_VERB_SET_PROC_COEF, 0x201b },
8650 			{ 0x20, AC_VERB_SET_COEF_INDEX, 0x6b },
8651 			{ 0x20, AC_VERB_SET_PROC_COEF, 0x4278},
8652 			{ }
8653 		},
8654 		.chained = true,
8655 		.chain_id = ALC294_FIXUP_ASUS_ALLY_SPEAKER
8656 	},
8657 	[ALC294_FIXUP_ASUS_ALLY_SPEAKER] = {
8658 		.type = HDA_FIXUP_FUNC,
8659 		.v.func = alc285_fixup_speaker2_to_dac1,
8660 	},
8661 	[ALC285_FIXUP_THINKPAD_X1_GEN7] = {
8662 		.type = HDA_FIXUP_FUNC,
8663 		.v.func = alc285_fixup_thinkpad_x1_gen7,
8664 		.chained = true,
8665 		.chain_id = ALC269_FIXUP_THINKPAD_ACPI
8666 	},
8667 	[ALC285_FIXUP_THINKPAD_HEADSET_JACK] = {
8668 		.type = HDA_FIXUP_FUNC,
8669 		.v.func = alc_fixup_headset_jack,
8670 		.chained = true,
8671 		.chain_id = ALC285_FIXUP_THINKPAD_X1_GEN7
8672 	},
8673 	[ALC294_FIXUP_ASUS_HPE] = {
8674 		.type = HDA_FIXUP_VERBS,
8675 		.v.verbs = (const struct hda_verb[]) {
8676 			/* Set EAPD high */
8677 			{ 0x20, AC_VERB_SET_COEF_INDEX, 0x0f },
8678 			{ 0x20, AC_VERB_SET_PROC_COEF, 0x7774 },
8679 			{ }
8680 		},
8681 		.chained = true,
8682 		.chain_id = ALC294_FIXUP_ASUS_HEADSET_MIC
8683 	},
8684 	[ALC294_FIXUP_ASUS_GX502_PINS] = {
8685 		.type = HDA_FIXUP_PINS,
8686 		.v.pins = (const struct hda_pintbl[]) {
8687 			{ 0x19, 0x03a11050 }, /* front HP mic */
8688 			{ 0x1a, 0x01a11830 }, /* rear external mic */
8689 			{ 0x21, 0x03211020 }, /* front HP out */
8690 			{ }
8691 		},
8692 		.chained = true,
8693 		.chain_id = ALC294_FIXUP_ASUS_GX502_VERBS
8694 	},
8695 	[ALC294_FIXUP_ASUS_GX502_VERBS] = {
8696 		.type = HDA_FIXUP_VERBS,
8697 		.v.verbs = (const struct hda_verb[]) {
8698 			/* set 0x15 to HP-OUT ctrl */
8699 			{ 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0 },
8700 			/* unmute the 0x15 amp */
8701 			{ 0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000 },
8702 			{ }
8703 		},
8704 		.chained = true,
8705 		.chain_id = ALC294_FIXUP_ASUS_GX502_HP
8706 	},
8707 	[ALC294_FIXUP_ASUS_GX502_HP] = {
8708 		.type = HDA_FIXUP_FUNC,
8709 		.v.func = alc294_fixup_gx502_hp,
8710 	},
8711 	[ALC294_FIXUP_ASUS_GU502_PINS] = {
8712 		.type = HDA_FIXUP_PINS,
8713 		.v.pins = (const struct hda_pintbl[]) {
8714 			{ 0x19, 0x01a11050 }, /* rear HP mic */
8715 			{ 0x1a, 0x01a11830 }, /* rear external mic */
8716 			{ 0x21, 0x012110f0 }, /* rear HP out */
8717 			{ }
8718 		},
8719 		.chained = true,
8720 		.chain_id = ALC294_FIXUP_ASUS_GU502_VERBS
8721 	},
8722 	[ALC294_FIXUP_ASUS_GU502_VERBS] = {
8723 		.type = HDA_FIXUP_VERBS,
8724 		.v.verbs = (const struct hda_verb[]) {
8725 			/* set 0x15 to HP-OUT ctrl */
8726 			{ 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0 },
8727 			/* unmute the 0x15 amp */
8728 			{ 0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000 },
8729 			/* set 0x1b to HP-OUT */
8730 			{ 0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
8731 			{ }
8732 		},
8733 		.chained = true,
8734 		.chain_id = ALC294_FIXUP_ASUS_GU502_HP
8735 	},
8736 	[ALC294_FIXUP_ASUS_GU502_HP] = {
8737 		.type = HDA_FIXUP_FUNC,
8738 		.v.func = alc294_fixup_gu502_hp,
8739 	},
8740 	 [ALC294_FIXUP_ASUS_G513_PINS] = {
8741 		.type = HDA_FIXUP_PINS,
8742 		.v.pins = (const struct hda_pintbl[]) {
8743 				{ 0x19, 0x03a11050 }, /* front HP mic */
8744 				{ 0x1a, 0x03a11c30 }, /* rear external mic */
8745 				{ 0x21, 0x03211420 }, /* front HP out */
8746 				{ }
8747 		},
8748 	},
8749 	[ALC285_FIXUP_ASUS_G533Z_PINS] = {
8750 		.type = HDA_FIXUP_PINS,
8751 		.v.pins = (const struct hda_pintbl[]) {
8752 			{ 0x14, 0x90170152 }, /* Speaker Surround Playback Switch */
8753 			{ 0x19, 0x03a19020 }, /* Mic Boost Volume */
8754 			{ 0x1a, 0x03a11c30 }, /* Mic Boost Volume */
8755 			{ 0x1e, 0x90170151 }, /* Rear jack, IN OUT EAPD Detect */
8756 			{ 0x21, 0x03211420 },
8757 			{ }
8758 		},
8759 	},
8760 	[ALC294_FIXUP_ASUS_COEF_1B] = {
8761 		.type = HDA_FIXUP_VERBS,
8762 		.v.verbs = (const struct hda_verb[]) {
8763 			/* Set bit 10 to correct noisy output after reboot from
8764 			 * Windows 10 (due to pop noise reduction?)
8765 			 */
8766 			{ 0x20, AC_VERB_SET_COEF_INDEX, 0x1b },
8767 			{ 0x20, AC_VERB_SET_PROC_COEF, 0x4e4b },
8768 			{ }
8769 		},
8770 		.chained = true,
8771 		.chain_id = ALC289_FIXUP_ASUS_GA401,
8772 	},
8773 	[ALC285_FIXUP_HP_GPIO_LED] = {
8774 		.type = HDA_FIXUP_FUNC,
8775 		.v.func = alc285_fixup_hp_gpio_led,
8776 	},
8777 	[ALC285_FIXUP_HP_MUTE_LED] = {
8778 		.type = HDA_FIXUP_FUNC,
8779 		.v.func = alc285_fixup_hp_mute_led,
8780 	},
8781 	[ALC285_FIXUP_HP_SPECTRE_X360_MUTE_LED] = {
8782 		.type = HDA_FIXUP_FUNC,
8783 		.v.func = alc285_fixup_hp_spectre_x360_mute_led,
8784 	},
8785 	[ALC236_FIXUP_HP_MUTE_LED_COEFBIT2] = {
8786 	    .type = HDA_FIXUP_FUNC,
8787 	    .v.func = alc236_fixup_hp_mute_led_coefbit2,
8788 	},
8789 	[ALC236_FIXUP_HP_GPIO_LED] = {
8790 		.type = HDA_FIXUP_FUNC,
8791 		.v.func = alc236_fixup_hp_gpio_led,
8792 	},
8793 	[ALC236_FIXUP_HP_MUTE_LED] = {
8794 		.type = HDA_FIXUP_FUNC,
8795 		.v.func = alc236_fixup_hp_mute_led,
8796 	},
8797 	[ALC236_FIXUP_HP_MUTE_LED_MICMUTE_VREF] = {
8798 		.type = HDA_FIXUP_FUNC,
8799 		.v.func = alc236_fixup_hp_mute_led_micmute_vref,
8800 	},
8801 	[ALC298_FIXUP_SAMSUNG_AMP] = {
8802 		.type = HDA_FIXUP_FUNC,
8803 		.v.func = alc298_fixup_samsung_amp,
8804 		.chained = true,
8805 		.chain_id = ALC298_FIXUP_SAMSUNG_HEADPHONE_VERY_QUIET
8806 	},
8807 	[ALC298_FIXUP_SAMSUNG_HEADPHONE_VERY_QUIET] = {
8808 		.type = HDA_FIXUP_VERBS,
8809 		.v.verbs = (const struct hda_verb[]) {
8810 			{ 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc5 },
8811 			{ }
8812 		},
8813 	},
8814 	[ALC256_FIXUP_SAMSUNG_HEADPHONE_VERY_QUIET] = {
8815 		.type = HDA_FIXUP_VERBS,
8816 		.v.verbs = (const struct hda_verb[]) {
8817 			{ 0x20, AC_VERB_SET_COEF_INDEX, 0x08},
8818 			{ 0x20, AC_VERB_SET_PROC_COEF, 0x2fcf},
8819 			{ }
8820 		},
8821 	},
8822 	[ALC295_FIXUP_ASUS_MIC_NO_PRESENCE] = {
8823 		.type = HDA_FIXUP_PINS,
8824 		.v.pins = (const struct hda_pintbl[]) {
8825 			{ 0x19, 0x01a1913c }, /* use as headset mic, without its own jack detect */
8826 			{ }
8827 		},
8828 		.chained = true,
8829 		.chain_id = ALC269_FIXUP_HEADSET_MODE
8830 	},
8831 	[ALC269VC_FIXUP_ACER_VCOPPERBOX_PINS] = {
8832 		.type = HDA_FIXUP_PINS,
8833 		.v.pins = (const struct hda_pintbl[]) {
8834 			{ 0x14, 0x90100120 }, /* use as internal speaker */
8835 			{ 0x18, 0x02a111f0 }, /* use as headset mic, without its own jack detect */
8836 			{ 0x1a, 0x01011020 }, /* use as line out */
8837 			{ },
8838 		},
8839 		.chained = true,
8840 		.chain_id = ALC269_FIXUP_HEADSET_MIC
8841 	},
8842 	[ALC269VC_FIXUP_ACER_HEADSET_MIC] = {
8843 		.type = HDA_FIXUP_PINS,
8844 		.v.pins = (const struct hda_pintbl[]) {
8845 			{ 0x18, 0x02a11030 }, /* use as headset mic */
8846 			{ }
8847 		},
8848 		.chained = true,
8849 		.chain_id = ALC269_FIXUP_HEADSET_MIC
8850 	},
8851 	[ALC269VC_FIXUP_ACER_MIC_NO_PRESENCE] = {
8852 		.type = HDA_FIXUP_PINS,
8853 		.v.pins = (const struct hda_pintbl[]) {
8854 			{ 0x18, 0x01a11130 }, /* use as headset mic, without its own jack detect */
8855 			{ }
8856 		},
8857 		.chained = true,
8858 		.chain_id = ALC269_FIXUP_HEADSET_MIC
8859 	},
8860 	[ALC289_FIXUP_ASUS_GA401] = {
8861 		.type = HDA_FIXUP_FUNC,
8862 		.v.func = alc289_fixup_asus_ga401,
8863 		.chained = true,
8864 		.chain_id = ALC289_FIXUP_ASUS_GA502,
8865 	},
8866 	[ALC289_FIXUP_ASUS_GA502] = {
8867 		.type = HDA_FIXUP_PINS,
8868 		.v.pins = (const struct hda_pintbl[]) {
8869 			{ 0x19, 0x03a11020 }, /* headset mic with jack detect */
8870 			{ }
8871 		},
8872 	},
8873 	[ALC256_FIXUP_ACER_MIC_NO_PRESENCE] = {
8874 		.type = HDA_FIXUP_PINS,
8875 		.v.pins = (const struct hda_pintbl[]) {
8876 			{ 0x19, 0x02a11120 }, /* use as headset mic, without its own jack detect */
8877 			{ }
8878 		},
8879 		.chained = true,
8880 		.chain_id = ALC256_FIXUP_ASUS_HEADSET_MODE
8881 	},
8882 	[ALC285_FIXUP_HP_GPIO_AMP_INIT] = {
8883 		.type = HDA_FIXUP_FUNC,
8884 		.v.func = alc285_fixup_hp_gpio_amp_init,
8885 		.chained = true,
8886 		.chain_id = ALC285_FIXUP_HP_GPIO_LED
8887 	},
8888 	[ALC269_FIXUP_CZC_B20] = {
8889 		.type = HDA_FIXUP_PINS,
8890 		.v.pins = (const struct hda_pintbl[]) {
8891 			{ 0x12, 0x411111f0 },
8892 			{ 0x14, 0x90170110 }, /* speaker */
8893 			{ 0x15, 0x032f1020 }, /* HP out */
8894 			{ 0x17, 0x411111f0 },
8895 			{ 0x18, 0x03ab1040 }, /* mic */
8896 			{ 0x19, 0xb7a7013f },
8897 			{ 0x1a, 0x0181305f },
8898 			{ 0x1b, 0x411111f0 },
8899 			{ 0x1d, 0x411111f0 },
8900 			{ 0x1e, 0x411111f0 },
8901 			{ }
8902 		},
8903 		.chain_id = ALC269_FIXUP_DMIC,
8904 	},
8905 	[ALC269_FIXUP_CZC_TMI] = {
8906 		.type = HDA_FIXUP_PINS,
8907 		.v.pins = (const struct hda_pintbl[]) {
8908 			{ 0x12, 0x4000c000 },
8909 			{ 0x14, 0x90170110 }, /* speaker */
8910 			{ 0x15, 0x0421401f }, /* HP out */
8911 			{ 0x17, 0x411111f0 },
8912 			{ 0x18, 0x04a19020 }, /* mic */
8913 			{ 0x19, 0x411111f0 },
8914 			{ 0x1a, 0x411111f0 },
8915 			{ 0x1b, 0x411111f0 },
8916 			{ 0x1d, 0x40448505 },
8917 			{ 0x1e, 0x411111f0 },
8918 			{ 0x20, 0x8000ffff },
8919 			{ }
8920 		},
8921 		.chain_id = ALC269_FIXUP_DMIC,
8922 	},
8923 	[ALC269_FIXUP_CZC_L101] = {
8924 		.type = HDA_FIXUP_PINS,
8925 		.v.pins = (const struct hda_pintbl[]) {
8926 			{ 0x12, 0x40000000 },
8927 			{ 0x14, 0x01014010 }, /* speaker */
8928 			{ 0x15, 0x411111f0 }, /* HP out */
8929 			{ 0x16, 0x411111f0 },
8930 			{ 0x18, 0x01a19020 }, /* mic */
8931 			{ 0x19, 0x02a19021 },
8932 			{ 0x1a, 0x0181302f },
8933 			{ 0x1b, 0x0221401f },
8934 			{ 0x1c, 0x411111f0 },
8935 			{ 0x1d, 0x4044c601 },
8936 			{ 0x1e, 0x411111f0 },
8937 			{ }
8938 		},
8939 		.chain_id = ALC269_FIXUP_DMIC,
8940 	},
8941 	[ALC269_FIXUP_LEMOTE_A1802] = {
8942 		.type = HDA_FIXUP_PINS,
8943 		.v.pins = (const struct hda_pintbl[]) {
8944 			{ 0x12, 0x40000000 },
8945 			{ 0x14, 0x90170110 }, /* speaker */
8946 			{ 0x17, 0x411111f0 },
8947 			{ 0x18, 0x03a19040 }, /* mic1 */
8948 			{ 0x19, 0x90a70130 }, /* mic2 */
8949 			{ 0x1a, 0x411111f0 },
8950 			{ 0x1b, 0x411111f0 },
8951 			{ 0x1d, 0x40489d2d },
8952 			{ 0x1e, 0x411111f0 },
8953 			{ 0x20, 0x0003ffff },
8954 			{ 0x21, 0x03214020 },
8955 			{ }
8956 		},
8957 		.chain_id = ALC269_FIXUP_DMIC,
8958 	},
8959 	[ALC269_FIXUP_LEMOTE_A190X] = {
8960 		.type = HDA_FIXUP_PINS,
8961 		.v.pins = (const struct hda_pintbl[]) {
8962 			{ 0x14, 0x99130110 }, /* speaker */
8963 			{ 0x15, 0x0121401f }, /* HP out */
8964 			{ 0x18, 0x01a19c20 }, /* rear  mic */
8965 			{ 0x19, 0x99a3092f }, /* front mic */
8966 			{ 0x1b, 0x0201401f }, /* front lineout */
8967 			{ }
8968 		},
8969 		.chain_id = ALC269_FIXUP_DMIC,
8970 	},
8971 	[ALC256_FIXUP_INTEL_NUC8_RUGGED] = {
8972 		.type = HDA_FIXUP_PINS,
8973 		.v.pins = (const struct hda_pintbl[]) {
8974 			{ 0x1b, 0x01a1913c }, /* use as headset mic, without its own jack detect */
8975 			{ }
8976 		},
8977 		.chained = true,
8978 		.chain_id = ALC269_FIXUP_HEADSET_MODE
8979 	},
8980 	[ALC256_FIXUP_INTEL_NUC10] = {
8981 		.type = HDA_FIXUP_PINS,
8982 		.v.pins = (const struct hda_pintbl[]) {
8983 			{ 0x19, 0x01a1913c }, /* use as headset mic, without its own jack detect */
8984 			{ }
8985 		},
8986 		.chained = true,
8987 		.chain_id = ALC269_FIXUP_HEADSET_MODE
8988 	},
8989 	[ALC255_FIXUP_XIAOMI_HEADSET_MIC] = {
8990 		.type = HDA_FIXUP_VERBS,
8991 		.v.verbs = (const struct hda_verb[]) {
8992 			{ 0x20, AC_VERB_SET_COEF_INDEX, 0x45 },
8993 			{ 0x20, AC_VERB_SET_PROC_COEF, 0x5089 },
8994 			{ }
8995 		},
8996 		.chained = true,
8997 		.chain_id = ALC289_FIXUP_ASUS_GA502
8998 	},
8999 	[ALC274_FIXUP_HP_MIC] = {
9000 		.type = HDA_FIXUP_VERBS,
9001 		.v.verbs = (const struct hda_verb[]) {
9002 			{ 0x20, AC_VERB_SET_COEF_INDEX, 0x45 },
9003 			{ 0x20, AC_VERB_SET_PROC_COEF, 0x5089 },
9004 			{ }
9005 		},
9006 	},
9007 	[ALC274_FIXUP_HP_HEADSET_MIC] = {
9008 		.type = HDA_FIXUP_FUNC,
9009 		.v.func = alc274_fixup_hp_headset_mic,
9010 		.chained = true,
9011 		.chain_id = ALC274_FIXUP_HP_MIC
9012 	},
9013 	[ALC274_FIXUP_HP_ENVY_GPIO] = {
9014 		.type = HDA_FIXUP_FUNC,
9015 		.v.func = alc274_fixup_hp_envy_gpio,
9016 	},
9017 	[ALC256_FIXUP_ASUS_HPE] = {
9018 		.type = HDA_FIXUP_VERBS,
9019 		.v.verbs = (const struct hda_verb[]) {
9020 			/* Set EAPD high */
9021 			{ 0x20, AC_VERB_SET_COEF_INDEX, 0x0f },
9022 			{ 0x20, AC_VERB_SET_PROC_COEF, 0x7778 },
9023 			{ }
9024 		},
9025 		.chained = true,
9026 		.chain_id = ALC294_FIXUP_ASUS_HEADSET_MIC
9027 	},
9028 	[ALC285_FIXUP_THINKPAD_NO_BASS_SPK_HEADSET_JACK] = {
9029 		.type = HDA_FIXUP_FUNC,
9030 		.v.func = alc_fixup_headset_jack,
9031 		.chained = true,
9032 		.chain_id = ALC269_FIXUP_THINKPAD_ACPI
9033 	},
9034 	[ALC287_FIXUP_HP_GPIO_LED] = {
9035 		.type = HDA_FIXUP_FUNC,
9036 		.v.func = alc287_fixup_hp_gpio_led,
9037 	},
9038 	[ALC256_FIXUP_HP_HEADSET_MIC] = {
9039 		.type = HDA_FIXUP_FUNC,
9040 		.v.func = alc274_fixup_hp_headset_mic,
9041 	},
9042 	[ALC236_FIXUP_DELL_AIO_HEADSET_MIC] = {
9043 		.type = HDA_FIXUP_FUNC,
9044 		.v.func = alc_fixup_no_int_mic,
9045 		.chained = true,
9046 		.chain_id = ALC255_FIXUP_DELL1_MIC_NO_PRESENCE
9047 	},
9048 	[ALC282_FIXUP_ACER_DISABLE_LINEOUT] = {
9049 		.type = HDA_FIXUP_PINS,
9050 		.v.pins = (const struct hda_pintbl[]) {
9051 			{ 0x1b, 0x411111f0 },
9052 			{ 0x18, 0x01a1913c }, /* use as headset mic, without its own jack detect */
9053 			{ },
9054 		},
9055 		.chained = true,
9056 		.chain_id = ALC269_FIXUP_HEADSET_MODE
9057 	},
9058 	[ALC255_FIXUP_ACER_LIMIT_INT_MIC_BOOST] = {
9059 		.type = HDA_FIXUP_FUNC,
9060 		.v.func = alc269_fixup_limit_int_mic_boost,
9061 		.chained = true,
9062 		.chain_id = ALC255_FIXUP_ACER_MIC_NO_PRESENCE,
9063 	},
9064 	[ALC256_FIXUP_ACER_HEADSET_MIC] = {
9065 		.type = HDA_FIXUP_PINS,
9066 		.v.pins = (const struct hda_pintbl[]) {
9067 			{ 0x19, 0x02a1113c }, /* use as headset mic, without its own jack detect */
9068 			{ 0x1a, 0x90a1092f }, /* use as internal mic */
9069 			{ }
9070 		},
9071 		.chained = true,
9072 		.chain_id = ALC269_FIXUP_HEADSET_MODE_NO_HP_MIC
9073 	},
9074 	[ALC285_FIXUP_IDEAPAD_S740_COEF] = {
9075 		.type = HDA_FIXUP_FUNC,
9076 		.v.func = alc285_fixup_ideapad_s740_coef,
9077 		.chained = true,
9078 		.chain_id = ALC269_FIXUP_THINKPAD_ACPI,
9079 	},
9080 	[ALC285_FIXUP_HP_LIMIT_INT_MIC_BOOST] = {
9081 		.type = HDA_FIXUP_FUNC,
9082 		.v.func = alc269_fixup_limit_int_mic_boost,
9083 		.chained = true,
9084 		.chain_id = ALC285_FIXUP_HP_MUTE_LED,
9085 	},
9086 	[ALC295_FIXUP_ASUS_DACS] = {
9087 		.type = HDA_FIXUP_FUNC,
9088 		.v.func = alc295_fixup_asus_dacs,
9089 	},
9090 	[ALC295_FIXUP_HP_OMEN] = {
9091 		.type = HDA_FIXUP_PINS,
9092 		.v.pins = (const struct hda_pintbl[]) {
9093 			{ 0x12, 0xb7a60130 },
9094 			{ 0x13, 0x40000000 },
9095 			{ 0x14, 0x411111f0 },
9096 			{ 0x16, 0x411111f0 },
9097 			{ 0x17, 0x90170110 },
9098 			{ 0x18, 0x411111f0 },
9099 			{ 0x19, 0x02a11030 },
9100 			{ 0x1a, 0x411111f0 },
9101 			{ 0x1b, 0x04a19030 },
9102 			{ 0x1d, 0x40600001 },
9103 			{ 0x1e, 0x411111f0 },
9104 			{ 0x21, 0x03211020 },
9105 			{}
9106 		},
9107 		.chained = true,
9108 		.chain_id = ALC269_FIXUP_HP_LINE1_MIC1_LED,
9109 	},
9110 	[ALC285_FIXUP_HP_SPECTRE_X360] = {
9111 		.type = HDA_FIXUP_FUNC,
9112 		.v.func = alc285_fixup_hp_spectre_x360,
9113 	},
9114 	[ALC285_FIXUP_HP_SPECTRE_X360_EB1] = {
9115 		.type = HDA_FIXUP_FUNC,
9116 		.v.func = alc285_fixup_hp_spectre_x360_eb1
9117 	},
9118 	[ALC287_FIXUP_IDEAPAD_BASS_SPK_AMP] = {
9119 		.type = HDA_FIXUP_FUNC,
9120 		.v.func = alc285_fixup_ideapad_s740_coef,
9121 		.chained = true,
9122 		.chain_id = ALC285_FIXUP_THINKPAD_HEADSET_JACK,
9123 	},
9124 	[ALC623_FIXUP_LENOVO_THINKSTATION_P340] = {
9125 		.type = HDA_FIXUP_FUNC,
9126 		.v.func = alc_fixup_no_shutup,
9127 		.chained = true,
9128 		.chain_id = ALC283_FIXUP_HEADSET_MIC,
9129 	},
9130 	[ALC255_FIXUP_ACER_HEADPHONE_AND_MIC] = {
9131 		.type = HDA_FIXUP_PINS,
9132 		.v.pins = (const struct hda_pintbl[]) {
9133 			{ 0x21, 0x03211030 }, /* Change the Headphone location to Left */
9134 			{ }
9135 		},
9136 		.chained = true,
9137 		.chain_id = ALC255_FIXUP_XIAOMI_HEADSET_MIC
9138 	},
9139 	[ALC236_FIXUP_HP_LIMIT_INT_MIC_BOOST] = {
9140 		.type = HDA_FIXUP_FUNC,
9141 		.v.func = alc269_fixup_limit_int_mic_boost,
9142 		.chained = true,
9143 		.chain_id = ALC236_FIXUP_HP_MUTE_LED_MICMUTE_VREF,
9144 	},
9145 	[ALC285_FIXUP_LEGION_Y9000X_SPEAKERS] = {
9146 		.type = HDA_FIXUP_FUNC,
9147 		.v.func = alc285_fixup_ideapad_s740_coef,
9148 		.chained = true,
9149 		.chain_id = ALC285_FIXUP_LEGION_Y9000X_AUTOMUTE,
9150 	},
9151 	[ALC285_FIXUP_LEGION_Y9000X_AUTOMUTE] = {
9152 		.type = HDA_FIXUP_FUNC,
9153 		.v.func = alc287_fixup_legion_15imhg05_speakers,
9154 		.chained = true,
9155 		.chain_id = ALC269_FIXUP_THINKPAD_ACPI,
9156 	},
9157 	[ALC287_FIXUP_LEGION_15IMHG05_SPEAKERS] = {
9158 		.type = HDA_FIXUP_VERBS,
9159 		//.v.verbs = legion_15imhg05_coefs,
9160 		.v.verbs = (const struct hda_verb[]) {
9161 			 // set left speaker Legion 7i.
9162 			 { 0x20, AC_VERB_SET_COEF_INDEX, 0x24 },
9163 			 { 0x20, AC_VERB_SET_PROC_COEF, 0x41 },
9164 
9165 			 { 0x20, AC_VERB_SET_COEF_INDEX, 0x26 },
9166 			 { 0x20, AC_VERB_SET_PROC_COEF, 0xc },
9167 			 { 0x20, AC_VERB_SET_PROC_COEF, 0x0 },
9168 			 { 0x20, AC_VERB_SET_PROC_COEF, 0x1a },
9169 			 { 0x20, AC_VERB_SET_PROC_COEF, 0xb020 },
9170 
9171 			 { 0x20, AC_VERB_SET_COEF_INDEX, 0x26 },
9172 			 { 0x20, AC_VERB_SET_PROC_COEF, 0x2 },
9173 			 { 0x20, AC_VERB_SET_PROC_COEF, 0x0 },
9174 			 { 0x20, AC_VERB_SET_PROC_COEF, 0x0 },
9175 			 { 0x20, AC_VERB_SET_PROC_COEF, 0xb020 },
9176 
9177 			 // set right speaker Legion 7i.
9178 			 { 0x20, AC_VERB_SET_COEF_INDEX, 0x24 },
9179 			 { 0x20, AC_VERB_SET_PROC_COEF, 0x42 },
9180 
9181 			 { 0x20, AC_VERB_SET_COEF_INDEX, 0x26 },
9182 			 { 0x20, AC_VERB_SET_PROC_COEF, 0xc },
9183 			 { 0x20, AC_VERB_SET_PROC_COEF, 0x0 },
9184 			 { 0x20, AC_VERB_SET_PROC_COEF, 0x2a },
9185 			 { 0x20, AC_VERB_SET_PROC_COEF, 0xb020 },
9186 
9187 			 { 0x20, AC_VERB_SET_COEF_INDEX, 0x26 },
9188 			 { 0x20, AC_VERB_SET_PROC_COEF, 0x2 },
9189 			 { 0x20, AC_VERB_SET_PROC_COEF, 0x0 },
9190 			 { 0x20, AC_VERB_SET_PROC_COEF, 0x0 },
9191 			 { 0x20, AC_VERB_SET_PROC_COEF, 0xb020 },
9192 			 {}
9193 		},
9194 		.chained = true,
9195 		.chain_id = ALC287_FIXUP_LEGION_15IMHG05_AUTOMUTE,
9196 	},
9197 	[ALC287_FIXUP_LEGION_15IMHG05_AUTOMUTE] = {
9198 		.type = HDA_FIXUP_FUNC,
9199 		.v.func = alc287_fixup_legion_15imhg05_speakers,
9200 		.chained = true,
9201 		.chain_id = ALC269_FIXUP_HEADSET_MODE,
9202 	},
9203 	[ALC287_FIXUP_YOGA7_14ITL_SPEAKERS] = {
9204 		.type = HDA_FIXUP_VERBS,
9205 		.v.verbs = (const struct hda_verb[]) {
9206 			 // set left speaker Yoga 7i.
9207 			 { 0x20, AC_VERB_SET_COEF_INDEX, 0x24 },
9208 			 { 0x20, AC_VERB_SET_PROC_COEF, 0x41 },
9209 
9210 			 { 0x20, AC_VERB_SET_COEF_INDEX, 0x26 },
9211 			 { 0x20, AC_VERB_SET_PROC_COEF, 0xc },
9212 			 { 0x20, AC_VERB_SET_PROC_COEF, 0x0 },
9213 			 { 0x20, AC_VERB_SET_PROC_COEF, 0x1a },
9214 			 { 0x20, AC_VERB_SET_PROC_COEF, 0xb020 },
9215 
9216 			 { 0x20, AC_VERB_SET_COEF_INDEX, 0x26 },
9217 			 { 0x20, AC_VERB_SET_PROC_COEF, 0x2 },
9218 			 { 0x20, AC_VERB_SET_PROC_COEF, 0x0 },
9219 			 { 0x20, AC_VERB_SET_PROC_COEF, 0x0 },
9220 			 { 0x20, AC_VERB_SET_PROC_COEF, 0xb020 },
9221 
9222 			 // set right speaker Yoga 7i.
9223 			 { 0x20, AC_VERB_SET_COEF_INDEX, 0x24 },
9224 			 { 0x20, AC_VERB_SET_PROC_COEF, 0x46 },
9225 
9226 			 { 0x20, AC_VERB_SET_COEF_INDEX, 0x26 },
9227 			 { 0x20, AC_VERB_SET_PROC_COEF, 0xc },
9228 			 { 0x20, AC_VERB_SET_PROC_COEF, 0x0 },
9229 			 { 0x20, AC_VERB_SET_PROC_COEF, 0x2a },
9230 			 { 0x20, AC_VERB_SET_PROC_COEF, 0xb020 },
9231 
9232 			 { 0x20, AC_VERB_SET_COEF_INDEX, 0x26 },
9233 			 { 0x20, AC_VERB_SET_PROC_COEF, 0x2 },
9234 			 { 0x20, AC_VERB_SET_PROC_COEF, 0x0 },
9235 			 { 0x20, AC_VERB_SET_PROC_COEF, 0x0 },
9236 			 { 0x20, AC_VERB_SET_PROC_COEF, 0xb020 },
9237 			 {}
9238 		},
9239 		.chained = true,
9240 		.chain_id = ALC269_FIXUP_HEADSET_MODE,
9241 	},
9242 	[ALC298_FIXUP_LENOVO_C940_DUET7] = {
9243 		.type = HDA_FIXUP_FUNC,
9244 		.v.func = alc298_fixup_lenovo_c940_duet7,
9245 	},
9246 	[ALC287_FIXUP_13S_GEN2_SPEAKERS] = {
9247 		.type = HDA_FIXUP_VERBS,
9248 		.v.verbs = (const struct hda_verb[]) {
9249 			{ 0x20, AC_VERB_SET_COEF_INDEX, 0x24 },
9250 			{ 0x20, AC_VERB_SET_PROC_COEF, 0x41 },
9251 			{ 0x20, AC_VERB_SET_COEF_INDEX, 0x26 },
9252 			{ 0x20, AC_VERB_SET_PROC_COEF, 0x2 },
9253 			{ 0x20, AC_VERB_SET_PROC_COEF, 0x0 },
9254 			{ 0x20, AC_VERB_SET_PROC_COEF, 0x0 },
9255 			{ 0x20, AC_VERB_SET_PROC_COEF, 0xb020 },
9256 			{ 0x20, AC_VERB_SET_COEF_INDEX, 0x24 },
9257 			{ 0x20, AC_VERB_SET_PROC_COEF, 0x42 },
9258 			{ 0x20, AC_VERB_SET_COEF_INDEX, 0x26 },
9259 			{ 0x20, AC_VERB_SET_PROC_COEF, 0x2 },
9260 			{ 0x20, AC_VERB_SET_PROC_COEF, 0x0 },
9261 			{ 0x20, AC_VERB_SET_PROC_COEF, 0x0 },
9262 			{ 0x20, AC_VERB_SET_PROC_COEF, 0xb020 },
9263 			{}
9264 		},
9265 		.chained = true,
9266 		.chain_id = ALC269_FIXUP_HEADSET_MODE,
9267 	},
9268 	[ALC256_FIXUP_SET_COEF_DEFAULTS] = {
9269 		.type = HDA_FIXUP_FUNC,
9270 		.v.func = alc256_fixup_set_coef_defaults,
9271 	},
9272 	[ALC245_FIXUP_HP_GPIO_LED] = {
9273 		.type = HDA_FIXUP_FUNC,
9274 		.v.func = alc245_fixup_hp_gpio_led,
9275 	},
9276 	[ALC256_FIXUP_SYSTEM76_MIC_NO_PRESENCE] = {
9277 		.type = HDA_FIXUP_PINS,
9278 		.v.pins = (const struct hda_pintbl[]) {
9279 			{ 0x19, 0x03a11120 }, /* use as headset mic, without its own jack detect */
9280 			{ }
9281 		},
9282 		.chained = true,
9283 		.chain_id = ALC269_FIXUP_HEADSET_MODE_NO_HP_MIC,
9284 	},
9285 	[ALC233_FIXUP_NO_AUDIO_JACK] = {
9286 		.type = HDA_FIXUP_FUNC,
9287 		.v.func = alc233_fixup_no_audio_jack,
9288 	},
9289 	[ALC256_FIXUP_MIC_NO_PRESENCE_AND_RESUME] = {
9290 		.type = HDA_FIXUP_FUNC,
9291 		.v.func = alc256_fixup_mic_no_presence_and_resume,
9292 		.chained = true,
9293 		.chain_id = ALC269_FIXUP_HEADSET_MODE_NO_HP_MIC
9294 	},
9295 	[ALC287_FIXUP_LEGION_16ACHG6] = {
9296 		.type = HDA_FIXUP_FUNC,
9297 		.v.func = alc287_fixup_legion_16achg6_speakers,
9298 	},
9299 	[ALC287_FIXUP_CS35L41_I2C_2] = {
9300 		.type = HDA_FIXUP_FUNC,
9301 		.v.func = cs35l41_fixup_i2c_two,
9302 	},
9303 	[ALC287_FIXUP_CS35L41_I2C_2_HP_GPIO_LED] = {
9304 		.type = HDA_FIXUP_FUNC,
9305 		.v.func = cs35l41_fixup_i2c_two,
9306 		.chained = true,
9307 		.chain_id = ALC285_FIXUP_HP_MUTE_LED,
9308 	},
9309 	[ALC245_FIXUP_CS35L41_SPI_2] = {
9310 		.type = HDA_FIXUP_FUNC,
9311 		.v.func = cs35l41_fixup_spi_two,
9312 	},
9313 	[ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED] = {
9314 		.type = HDA_FIXUP_FUNC,
9315 		.v.func = cs35l41_fixup_spi_two,
9316 		.chained = true,
9317 		.chain_id = ALC285_FIXUP_HP_GPIO_LED,
9318 	},
9319 	[ALC245_FIXUP_CS35L41_SPI_4] = {
9320 		.type = HDA_FIXUP_FUNC,
9321 		.v.func = cs35l41_fixup_spi_four,
9322 	},
9323 	[ALC245_FIXUP_CS35L41_SPI_4_HP_GPIO_LED] = {
9324 		.type = HDA_FIXUP_FUNC,
9325 		.v.func = cs35l41_fixup_spi_four,
9326 		.chained = true,
9327 		.chain_id = ALC285_FIXUP_HP_GPIO_LED,
9328 	},
9329 	[ALC285_FIXUP_HP_SPEAKERS_MICMUTE_LED] = {
9330 		.type = HDA_FIXUP_VERBS,
9331 		.v.verbs = (const struct hda_verb[]) {
9332 			 { 0x20, AC_VERB_SET_COEF_INDEX, 0x19 },
9333 			 { 0x20, AC_VERB_SET_PROC_COEF, 0x8e11 },
9334 			 { }
9335 		},
9336 		.chained = true,
9337 		.chain_id = ALC285_FIXUP_HP_MUTE_LED,
9338 	},
9339 	[ALC269_FIXUP_DELL4_MIC_NO_PRESENCE_QUIET] = {
9340 		.type = HDA_FIXUP_FUNC,
9341 		.v.func = alc_fixup_dell4_mic_no_presence_quiet,
9342 		.chained = true,
9343 		.chain_id = ALC269_FIXUP_DELL4_MIC_NO_PRESENCE,
9344 	},
9345 	[ALC295_FIXUP_FRAMEWORK_LAPTOP_MIC_NO_PRESENCE] = {
9346 		.type = HDA_FIXUP_PINS,
9347 		.v.pins = (const struct hda_pintbl[]) {
9348 			{ 0x19, 0x02a1112c }, /* use as headset mic, without its own jack detect */
9349 			{ }
9350 		},
9351 		.chained = true,
9352 		.chain_id = ALC269_FIXUP_HEADSET_MODE_NO_HP_MIC
9353 	},
9354 	[ALC287_FIXUP_LEGION_16ITHG6] = {
9355 		.type = HDA_FIXUP_FUNC,
9356 		.v.func = alc287_fixup_legion_16ithg6_speakers,
9357 	},
9358 	[ALC287_FIXUP_YOGA9_14IAP7_BASS_SPK] = {
9359 		.type = HDA_FIXUP_VERBS,
9360 		.v.verbs = (const struct hda_verb[]) {
9361 			// enable left speaker
9362 			{ 0x20, AC_VERB_SET_COEF_INDEX, 0x24 },
9363 			{ 0x20, AC_VERB_SET_PROC_COEF, 0x41 },
9364 
9365 			{ 0x20, AC_VERB_SET_COEF_INDEX, 0x26 },
9366 			{ 0x20, AC_VERB_SET_PROC_COEF, 0xc },
9367 			{ 0x20, AC_VERB_SET_PROC_COEF, 0x0 },
9368 			{ 0x20, AC_VERB_SET_PROC_COEF, 0x1a },
9369 			{ 0x20, AC_VERB_SET_PROC_COEF, 0xb020 },
9370 
9371 			{ 0x20, AC_VERB_SET_COEF_INDEX, 0x26 },
9372 			{ 0x20, AC_VERB_SET_PROC_COEF, 0xf },
9373 			{ 0x20, AC_VERB_SET_PROC_COEF, 0x0 },
9374 			{ 0x20, AC_VERB_SET_PROC_COEF, 0x42 },
9375 			{ 0x20, AC_VERB_SET_PROC_COEF, 0xb020 },
9376 
9377 			{ 0x20, AC_VERB_SET_COEF_INDEX, 0x26 },
9378 			{ 0x20, AC_VERB_SET_PROC_COEF, 0x10 },
9379 			{ 0x20, AC_VERB_SET_PROC_COEF, 0x0 },
9380 			{ 0x20, AC_VERB_SET_PROC_COEF, 0x40 },
9381 			{ 0x20, AC_VERB_SET_PROC_COEF, 0xb020 },
9382 
9383 			{ 0x20, AC_VERB_SET_COEF_INDEX, 0x26 },
9384 			{ 0x20, AC_VERB_SET_PROC_COEF, 0x2 },
9385 			{ 0x20, AC_VERB_SET_PROC_COEF, 0x0 },
9386 			{ 0x20, AC_VERB_SET_PROC_COEF, 0x0 },
9387 			{ 0x20, AC_VERB_SET_PROC_COEF, 0xb020 },
9388 
9389 			// enable right speaker
9390 			{ 0x20, AC_VERB_SET_COEF_INDEX, 0x24 },
9391 			{ 0x20, AC_VERB_SET_PROC_COEF, 0x46 },
9392 
9393 			{ 0x20, AC_VERB_SET_COEF_INDEX, 0x26 },
9394 			{ 0x20, AC_VERB_SET_PROC_COEF, 0xc },
9395 			{ 0x20, AC_VERB_SET_PROC_COEF, 0x0 },
9396 			{ 0x20, AC_VERB_SET_PROC_COEF, 0x2a },
9397 			{ 0x20, AC_VERB_SET_PROC_COEF, 0xb020 },
9398 
9399 			{ 0x20, AC_VERB_SET_COEF_INDEX, 0x26 },
9400 			{ 0x20, AC_VERB_SET_PROC_COEF, 0xf },
9401 			{ 0x20, AC_VERB_SET_PROC_COEF, 0x0 },
9402 			{ 0x20, AC_VERB_SET_PROC_COEF, 0x46 },
9403 			{ 0x20, AC_VERB_SET_PROC_COEF, 0xb020 },
9404 
9405 			{ 0x20, AC_VERB_SET_COEF_INDEX, 0x26 },
9406 			{ 0x20, AC_VERB_SET_PROC_COEF, 0x10 },
9407 			{ 0x20, AC_VERB_SET_PROC_COEF, 0x0 },
9408 			{ 0x20, AC_VERB_SET_PROC_COEF, 0x44 },
9409 			{ 0x20, AC_VERB_SET_PROC_COEF, 0xb020 },
9410 
9411 			{ 0x20, AC_VERB_SET_COEF_INDEX, 0x26 },
9412 			{ 0x20, AC_VERB_SET_PROC_COEF, 0x2 },
9413 			{ 0x20, AC_VERB_SET_PROC_COEF, 0x0 },
9414 			{ 0x20, AC_VERB_SET_PROC_COEF, 0x0 },
9415 			{ 0x20, AC_VERB_SET_PROC_COEF, 0xb020 },
9416 
9417 			{ },
9418 		},
9419 	},
9420 	[ALC287_FIXUP_YOGA9_14IAP7_BASS_SPK_PIN] = {
9421 		.type = HDA_FIXUP_FUNC,
9422 		.v.func = alc287_fixup_yoga9_14iap7_bass_spk_pin,
9423 		.chained = true,
9424 		.chain_id = ALC287_FIXUP_YOGA9_14IAP7_BASS_SPK,
9425 	},
9426 	[ALC295_FIXUP_DELL_INSPIRON_TOP_SPEAKERS] = {
9427 		.type = HDA_FIXUP_FUNC,
9428 		.v.func = alc295_fixup_dell_inspiron_top_speakers,
9429 		.chained = true,
9430 		.chain_id = ALC269_FIXUP_DELL4_MIC_NO_PRESENCE,
9431 	},
9432 	[ALC236_FIXUP_DELL_DUAL_CODECS] = {
9433 		.type = HDA_FIXUP_PINS,
9434 		.v.func = alc1220_fixup_gb_dual_codecs,
9435 		.chained = true,
9436 		.chain_id = ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
9437 	},
9438 	[ALC287_FIXUP_CS35L41_I2C_2_THINKPAD_ACPI] = {
9439 		.type = HDA_FIXUP_FUNC,
9440 		.v.func = cs35l41_fixup_i2c_two,
9441 		.chained = true,
9442 		.chain_id = ALC269_FIXUP_THINKPAD_ACPI,
9443 	},
9444 	[ALC287_FIXUP_TAS2781_I2C] = {
9445 		.type = HDA_FIXUP_FUNC,
9446 		.v.func = tas2781_fixup_i2c,
9447 		.chained = true,
9448 		.chain_id = ALC269_FIXUP_THINKPAD_ACPI,
9449 	},
9450 	[ALC245_FIXUP_HP_MUTE_LED_COEFBIT] = {
9451 		.type = HDA_FIXUP_FUNC,
9452 		.v.func = alc245_fixup_hp_mute_led_coefbit,
9453 	},
9454 	[ALC245_FIXUP_HP_X360_MUTE_LEDS] = {
9455 		.type = HDA_FIXUP_FUNC,
9456 		.v.func = alc245_fixup_hp_mute_led_coefbit,
9457 		.chained = true,
9458 		.chain_id = ALC245_FIXUP_HP_GPIO_LED
9459 	},
9460 	[ALC287_FIXUP_THINKPAD_I2S_SPK] = {
9461 		.type = HDA_FIXUP_FUNC,
9462 		.v.func = alc287_fixup_bind_dacs,
9463 	},
9464 	[ALC287_FIXUP_MG_RTKC_CSAMP_CS35L41_I2C_THINKPAD] = {
9465 		.type = HDA_FIXUP_FUNC,
9466 		.v.func = alc287_fixup_bind_dacs,
9467 		.chained = true,
9468 		.chain_id = ALC287_FIXUP_CS35L41_I2C_2_THINKPAD_ACPI,
9469 	},
9470 	[ALC2XX_FIXUP_HEADSET_MIC] = {
9471 		.type = HDA_FIXUP_FUNC,
9472 		.v.func = alc_fixup_headset_mic,
9473 	},
9474 };
9475 
9476 static const struct snd_pci_quirk alc269_fixup_tbl[] = {
9477 	SND_PCI_QUIRK(0x1025, 0x0283, "Acer TravelMate 8371", ALC269_FIXUP_INV_DMIC),
9478 	SND_PCI_QUIRK(0x1025, 0x029b, "Acer 1810TZ", ALC269_FIXUP_INV_DMIC),
9479 	SND_PCI_QUIRK(0x1025, 0x0349, "Acer AOD260", ALC269_FIXUP_INV_DMIC),
9480 	SND_PCI_QUIRK(0x1025, 0x047c, "Acer AC700", ALC269_FIXUP_ACER_AC700),
9481 	SND_PCI_QUIRK(0x1025, 0x072d, "Acer Aspire V5-571G", ALC269_FIXUP_ASPIRE_HEADSET_MIC),
9482 	SND_PCI_QUIRK(0x1025, 0x0740, "Acer AO725", ALC271_FIXUP_HP_GATE_MIC_JACK),
9483 	SND_PCI_QUIRK(0x1025, 0x0742, "Acer AO756", ALC271_FIXUP_HP_GATE_MIC_JACK),
9484 	SND_PCI_QUIRK(0x1025, 0x0762, "Acer Aspire E1-472", ALC271_FIXUP_HP_GATE_MIC_JACK_E1_572),
9485 	SND_PCI_QUIRK(0x1025, 0x0775, "Acer Aspire E1-572", ALC271_FIXUP_HP_GATE_MIC_JACK_E1_572),
9486 	SND_PCI_QUIRK(0x1025, 0x079b, "Acer Aspire V5-573G", ALC282_FIXUP_ASPIRE_V5_PINS),
9487 	SND_PCI_QUIRK(0x1025, 0x080d, "Acer Aspire V5-122P", ALC269_FIXUP_ASPIRE_HEADSET_MIC),
9488 	SND_PCI_QUIRK(0x1025, 0x0840, "Acer Aspire E1", ALC269VB_FIXUP_ASPIRE_E1_COEF),
9489 	SND_PCI_QUIRK(0x1025, 0x101c, "Acer Veriton N2510G", ALC269_FIXUP_LIFEBOOK),
9490 	SND_PCI_QUIRK(0x1025, 0x102b, "Acer Aspire C24-860", ALC286_FIXUP_ACER_AIO_MIC_NO_PRESENCE),
9491 	SND_PCI_QUIRK(0x1025, 0x1065, "Acer Aspire C20-820", ALC269VC_FIXUP_ACER_HEADSET_MIC),
9492 	SND_PCI_QUIRK(0x1025, 0x106d, "Acer Cloudbook 14", ALC283_FIXUP_CHROME_BOOK),
9493 	SND_PCI_QUIRK(0x1025, 0x1094, "Acer Aspire E5-575T", ALC255_FIXUP_ACER_LIMIT_INT_MIC_BOOST),
9494 	SND_PCI_QUIRK(0x1025, 0x1099, "Acer Aspire E5-523G", ALC255_FIXUP_ACER_MIC_NO_PRESENCE),
9495 	SND_PCI_QUIRK(0x1025, 0x110e, "Acer Aspire ES1-432", ALC255_FIXUP_ACER_MIC_NO_PRESENCE),
9496 	SND_PCI_QUIRK(0x1025, 0x1166, "Acer Veriton N4640G", ALC269_FIXUP_LIFEBOOK),
9497 	SND_PCI_QUIRK(0x1025, 0x1167, "Acer Veriton N6640G", ALC269_FIXUP_LIFEBOOK),
9498 	SND_PCI_QUIRK(0x1025, 0x1246, "Acer Predator Helios 500", ALC299_FIXUP_PREDATOR_SPK),
9499 	SND_PCI_QUIRK(0x1025, 0x1247, "Acer vCopperbox", ALC269VC_FIXUP_ACER_VCOPPERBOX_PINS),
9500 	SND_PCI_QUIRK(0x1025, 0x1248, "Acer Veriton N4660G", ALC269VC_FIXUP_ACER_MIC_NO_PRESENCE),
9501 	SND_PCI_QUIRK(0x1025, 0x1269, "Acer SWIFT SF314-54", ALC256_FIXUP_ACER_HEADSET_MIC),
9502 	SND_PCI_QUIRK(0x1025, 0x128f, "Acer Veriton Z6860G", ALC286_FIXUP_ACER_AIO_HEADSET_MIC),
9503 	SND_PCI_QUIRK(0x1025, 0x1290, "Acer Veriton Z4860G", ALC286_FIXUP_ACER_AIO_HEADSET_MIC),
9504 	SND_PCI_QUIRK(0x1025, 0x1291, "Acer Veriton Z4660G", ALC286_FIXUP_ACER_AIO_HEADSET_MIC),
9505 	SND_PCI_QUIRK(0x1025, 0x129c, "Acer SWIFT SF314-55", ALC256_FIXUP_ACER_HEADSET_MIC),
9506 	SND_PCI_QUIRK(0x1025, 0x129d, "Acer SWIFT SF313-51", ALC256_FIXUP_ACER_MIC_NO_PRESENCE),
9507 	SND_PCI_QUIRK(0x1025, 0x1300, "Acer SWIFT SF314-56", ALC256_FIXUP_ACER_MIC_NO_PRESENCE),
9508 	SND_PCI_QUIRK(0x1025, 0x1308, "Acer Aspire Z24-890", ALC286_FIXUP_ACER_AIO_HEADSET_MIC),
9509 	SND_PCI_QUIRK(0x1025, 0x132a, "Acer TravelMate B114-21", ALC233_FIXUP_ACER_HEADSET_MIC),
9510 	SND_PCI_QUIRK(0x1025, 0x1330, "Acer TravelMate X514-51T", ALC255_FIXUP_ACER_HEADSET_MIC),
9511 	SND_PCI_QUIRK(0x1025, 0x141f, "Acer Spin SP513-54N", ALC255_FIXUP_ACER_MIC_NO_PRESENCE),
9512 	SND_PCI_QUIRK(0x1025, 0x142b, "Acer Swift SF314-42", ALC255_FIXUP_ACER_MIC_NO_PRESENCE),
9513 	SND_PCI_QUIRK(0x1025, 0x1430, "Acer TravelMate B311R-31", ALC256_FIXUP_ACER_MIC_NO_PRESENCE),
9514 	SND_PCI_QUIRK(0x1025, 0x1466, "Acer Aspire A515-56", ALC255_FIXUP_ACER_HEADPHONE_AND_MIC),
9515 	SND_PCI_QUIRK(0x1025, 0x1534, "Acer Predator PH315-54", ALC255_FIXUP_ACER_MIC_NO_PRESENCE),
9516 	SND_PCI_QUIRK(0x1028, 0x0470, "Dell M101z", ALC269_FIXUP_DELL_M101Z),
9517 	SND_PCI_QUIRK(0x1028, 0x053c, "Dell Latitude E5430", ALC292_FIXUP_DELL_E7X),
9518 	SND_PCI_QUIRK(0x1028, 0x054b, "Dell XPS one 2710", ALC275_FIXUP_DELL_XPS),
9519 	SND_PCI_QUIRK(0x1028, 0x05bd, "Dell Latitude E6440", ALC292_FIXUP_DELL_E7X),
9520 	SND_PCI_QUIRK(0x1028, 0x05be, "Dell Latitude E6540", ALC292_FIXUP_DELL_E7X),
9521 	SND_PCI_QUIRK(0x1028, 0x05ca, "Dell Latitude E7240", ALC292_FIXUP_DELL_E7X),
9522 	SND_PCI_QUIRK(0x1028, 0x05cb, "Dell Latitude E7440", ALC292_FIXUP_DELL_E7X),
9523 	SND_PCI_QUIRK(0x1028, 0x05da, "Dell Vostro 5460", ALC290_FIXUP_SUBWOOFER),
9524 	SND_PCI_QUIRK(0x1028, 0x05f4, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE),
9525 	SND_PCI_QUIRK(0x1028, 0x05f5, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE),
9526 	SND_PCI_QUIRK(0x1028, 0x05f6, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE),
9527 	SND_PCI_QUIRK(0x1028, 0x0615, "Dell Vostro 5470", ALC290_FIXUP_SUBWOOFER_HSJACK),
9528 	SND_PCI_QUIRK(0x1028, 0x0616, "Dell Vostro 5470", ALC290_FIXUP_SUBWOOFER_HSJACK),
9529 	SND_PCI_QUIRK(0x1028, 0x062c, "Dell Latitude E5550", ALC292_FIXUP_DELL_E7X),
9530 	SND_PCI_QUIRK(0x1028, 0x062e, "Dell Latitude E7450", ALC292_FIXUP_DELL_E7X),
9531 	SND_PCI_QUIRK(0x1028, 0x0638, "Dell Inspiron 5439", ALC290_FIXUP_MONO_SPEAKERS_HSJACK),
9532 	SND_PCI_QUIRK(0x1028, 0x064a, "Dell", ALC293_FIXUP_DELL1_MIC_NO_PRESENCE),
9533 	SND_PCI_QUIRK(0x1028, 0x064b, "Dell", ALC293_FIXUP_DELL1_MIC_NO_PRESENCE),
9534 	SND_PCI_QUIRK(0x1028, 0x0665, "Dell XPS 13", ALC288_FIXUP_DELL_XPS_13),
9535 	SND_PCI_QUIRK(0x1028, 0x0669, "Dell Optiplex 9020m", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE),
9536 	SND_PCI_QUIRK(0x1028, 0x069a, "Dell Vostro 5480", ALC290_FIXUP_SUBWOOFER_HSJACK),
9537 	SND_PCI_QUIRK(0x1028, 0x06c7, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE),
9538 	SND_PCI_QUIRK(0x1028, 0x06d9, "Dell", ALC293_FIXUP_DELL1_MIC_NO_PRESENCE),
9539 	SND_PCI_QUIRK(0x1028, 0x06da, "Dell", ALC293_FIXUP_DELL1_MIC_NO_PRESENCE),
9540 	SND_PCI_QUIRK(0x1028, 0x06db, "Dell", ALC293_FIXUP_DISABLE_AAMIX_MULTIJACK),
9541 	SND_PCI_QUIRK(0x1028, 0x06dd, "Dell", ALC293_FIXUP_DISABLE_AAMIX_MULTIJACK),
9542 	SND_PCI_QUIRK(0x1028, 0x06de, "Dell", ALC293_FIXUP_DISABLE_AAMIX_MULTIJACK),
9543 	SND_PCI_QUIRK(0x1028, 0x06df, "Dell", ALC293_FIXUP_DISABLE_AAMIX_MULTIJACK),
9544 	SND_PCI_QUIRK(0x1028, 0x06e0, "Dell", ALC293_FIXUP_DISABLE_AAMIX_MULTIJACK),
9545 	SND_PCI_QUIRK(0x1028, 0x0706, "Dell Inspiron 7559", ALC256_FIXUP_DELL_INSPIRON_7559_SUBWOOFER),
9546 	SND_PCI_QUIRK(0x1028, 0x0725, "Dell Inspiron 3162", ALC255_FIXUP_DELL_SPK_NOISE),
9547 	SND_PCI_QUIRK(0x1028, 0x0738, "Dell Precision 5820", ALC269_FIXUP_NO_SHUTUP),
9548 	SND_PCI_QUIRK(0x1028, 0x075c, "Dell XPS 27 7760", ALC298_FIXUP_SPK_VOLUME),
9549 	SND_PCI_QUIRK(0x1028, 0x075d, "Dell AIO", ALC298_FIXUP_SPK_VOLUME),
9550 	SND_PCI_QUIRK(0x1028, 0x0798, "Dell Inspiron 17 7000 Gaming", ALC256_FIXUP_DELL_INSPIRON_7559_SUBWOOFER),
9551 	SND_PCI_QUIRK(0x1028, 0x07b0, "Dell Precision 7520", ALC295_FIXUP_DISABLE_DAC3),
9552 	SND_PCI_QUIRK(0x1028, 0x080c, "Dell WYSE", ALC225_FIXUP_DELL_WYSE_MIC_NO_PRESENCE),
9553 	SND_PCI_QUIRK(0x1028, 0x084b, "Dell", ALC274_FIXUP_DELL_AIO_LINEOUT_VERB),
9554 	SND_PCI_QUIRK(0x1028, 0x084e, "Dell", ALC274_FIXUP_DELL_AIO_LINEOUT_VERB),
9555 	SND_PCI_QUIRK(0x1028, 0x0871, "Dell Precision 3630", ALC255_FIXUP_DELL_HEADSET_MIC),
9556 	SND_PCI_QUIRK(0x1028, 0x0872, "Dell Precision 3630", ALC255_FIXUP_DELL_HEADSET_MIC),
9557 	SND_PCI_QUIRK(0x1028, 0x0873, "Dell Precision 3930", ALC255_FIXUP_DUMMY_LINEOUT_VERB),
9558 	SND_PCI_QUIRK(0x1028, 0x08ad, "Dell WYSE AIO", ALC225_FIXUP_DELL_WYSE_AIO_MIC_NO_PRESENCE),
9559 	SND_PCI_QUIRK(0x1028, 0x08ae, "Dell WYSE NB", ALC225_FIXUP_DELL1_MIC_NO_PRESENCE),
9560 	SND_PCI_QUIRK(0x1028, 0x0935, "Dell", ALC274_FIXUP_DELL_AIO_LINEOUT_VERB),
9561 	SND_PCI_QUIRK(0x1028, 0x097d, "Dell Precision", ALC289_FIXUP_DUAL_SPK),
9562 	SND_PCI_QUIRK(0x1028, 0x097e, "Dell Precision", ALC289_FIXUP_DUAL_SPK),
9563 	SND_PCI_QUIRK(0x1028, 0x098d, "Dell Precision", ALC233_FIXUP_ASUS_MIC_NO_PRESENCE),
9564 	SND_PCI_QUIRK(0x1028, 0x09bf, "Dell Precision", ALC233_FIXUP_ASUS_MIC_NO_PRESENCE),
9565 	SND_PCI_QUIRK(0x1028, 0x0a2e, "Dell", ALC236_FIXUP_DELL_AIO_HEADSET_MIC),
9566 	SND_PCI_QUIRK(0x1028, 0x0a30, "Dell", ALC236_FIXUP_DELL_AIO_HEADSET_MIC),
9567 	SND_PCI_QUIRK(0x1028, 0x0a38, "Dell Latitude 7520", ALC269_FIXUP_DELL4_MIC_NO_PRESENCE_QUIET),
9568 	SND_PCI_QUIRK(0x1028, 0x0a58, "Dell", ALC255_FIXUP_DELL_HEADSET_MIC),
9569 	SND_PCI_QUIRK(0x1028, 0x0a61, "Dell XPS 15 9510", ALC289_FIXUP_DUAL_SPK),
9570 	SND_PCI_QUIRK(0x1028, 0x0a62, "Dell Precision 5560", ALC289_FIXUP_DUAL_SPK),
9571 	SND_PCI_QUIRK(0x1028, 0x0a9d, "Dell Latitude 5430", ALC269_FIXUP_DELL4_MIC_NO_PRESENCE),
9572 	SND_PCI_QUIRK(0x1028, 0x0a9e, "Dell Latitude 5430", ALC269_FIXUP_DELL4_MIC_NO_PRESENCE),
9573 	SND_PCI_QUIRK(0x1028, 0x0b19, "Dell XPS 15 9520", ALC289_FIXUP_DUAL_SPK),
9574 	SND_PCI_QUIRK(0x1028, 0x0b1a, "Dell Precision 5570", ALC289_FIXUP_DUAL_SPK),
9575 	SND_PCI_QUIRK(0x1028, 0x0b37, "Dell Inspiron 16 Plus 7620 2-in-1", ALC295_FIXUP_DELL_INSPIRON_TOP_SPEAKERS),
9576 	SND_PCI_QUIRK(0x1028, 0x0b71, "Dell Inspiron 16 Plus 7620", ALC295_FIXUP_DELL_INSPIRON_TOP_SPEAKERS),
9577 	SND_PCI_QUIRK(0x1028, 0x0c03, "Dell Precision 5340", ALC269_FIXUP_DELL4_MIC_NO_PRESENCE),
9578 	SND_PCI_QUIRK(0x1028, 0x0c19, "Dell Precision 3340", ALC236_FIXUP_DELL_DUAL_CODECS),
9579 	SND_PCI_QUIRK(0x1028, 0x0c1a, "Dell Precision 3340", ALC236_FIXUP_DELL_DUAL_CODECS),
9580 	SND_PCI_QUIRK(0x1028, 0x0c1b, "Dell Precision 3440", ALC236_FIXUP_DELL_DUAL_CODECS),
9581 	SND_PCI_QUIRK(0x1028, 0x0c1c, "Dell Precision 3540", ALC236_FIXUP_DELL_DUAL_CODECS),
9582 	SND_PCI_QUIRK(0x1028, 0x0c1d, "Dell Precision 3440", ALC236_FIXUP_DELL_DUAL_CODECS),
9583 	SND_PCI_QUIRK(0x1028, 0x0c1e, "Dell Precision 3540", ALC236_FIXUP_DELL_DUAL_CODECS),
9584 	SND_PCI_QUIRK(0x1028, 0x0cbd, "Dell Oasis 13 CS MTL-U", ALC245_FIXUP_CS35L41_SPI_2),
9585 	SND_PCI_QUIRK(0x1028, 0x0cbe, "Dell Oasis 13 2-IN-1 MTL-U", ALC245_FIXUP_CS35L41_SPI_2),
9586 	SND_PCI_QUIRK(0x1028, 0x0cbf, "Dell Oasis 13 Low Weight MTU-L", ALC245_FIXUP_CS35L41_SPI_2),
9587 	SND_PCI_QUIRK(0x1028, 0x0cc1, "Dell Oasis 14 MTL-H/U", ALC245_FIXUP_CS35L41_SPI_2),
9588 	SND_PCI_QUIRK(0x1028, 0x0cc2, "Dell Oasis 14 2-in-1 MTL-H/U", ALC245_FIXUP_CS35L41_SPI_2),
9589 	SND_PCI_QUIRK(0x1028, 0x0cc3, "Dell Oasis 14 Low Weight MTL-U", ALC245_FIXUP_CS35L41_SPI_2),
9590 	SND_PCI_QUIRK(0x1028, 0x0cc4, "Dell Oasis 16 MTL-H/U", ALC245_FIXUP_CS35L41_SPI_2),
9591 	SND_PCI_QUIRK(0x1028, 0x164a, "Dell", ALC293_FIXUP_DELL1_MIC_NO_PRESENCE),
9592 	SND_PCI_QUIRK(0x1028, 0x164b, "Dell", ALC293_FIXUP_DELL1_MIC_NO_PRESENCE),
9593 	SND_PCI_QUIRK(0x103c, 0x1586, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC2),
9594 	SND_PCI_QUIRK(0x103c, 0x18e6, "HP", ALC269_FIXUP_HP_GPIO_LED),
9595 	SND_PCI_QUIRK(0x103c, 0x218b, "HP", ALC269_FIXUP_LIMIT_INT_MIC_BOOST_MUTE_LED),
9596 	SND_PCI_QUIRK(0x103c, 0x21f9, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
9597 	SND_PCI_QUIRK(0x103c, 0x2210, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
9598 	SND_PCI_QUIRK(0x103c, 0x2214, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
9599 	SND_PCI_QUIRK(0x103c, 0x221b, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),
9600 	SND_PCI_QUIRK(0x103c, 0x221c, "HP EliteBook 755 G2", ALC280_FIXUP_HP_HEADSET_MIC),
9601 	SND_PCI_QUIRK(0x103c, 0x2221, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),
9602 	SND_PCI_QUIRK(0x103c, 0x2225, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),
9603 	SND_PCI_QUIRK(0x103c, 0x2236, "HP", ALC269_FIXUP_HP_LINE1_MIC1_LED),
9604 	SND_PCI_QUIRK(0x103c, 0x2237, "HP", ALC269_FIXUP_HP_LINE1_MIC1_LED),
9605 	SND_PCI_QUIRK(0x103c, 0x2238, "HP", ALC269_FIXUP_HP_LINE1_MIC1_LED),
9606 	SND_PCI_QUIRK(0x103c, 0x2239, "HP", ALC269_FIXUP_HP_LINE1_MIC1_LED),
9607 	SND_PCI_QUIRK(0x103c, 0x224b, "HP", ALC269_FIXUP_HP_LINE1_MIC1_LED),
9608 	SND_PCI_QUIRK(0x103c, 0x2253, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),
9609 	SND_PCI_QUIRK(0x103c, 0x2254, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),
9610 	SND_PCI_QUIRK(0x103c, 0x2255, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),
9611 	SND_PCI_QUIRK(0x103c, 0x2256, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),
9612 	SND_PCI_QUIRK(0x103c, 0x2257, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),
9613 	SND_PCI_QUIRK(0x103c, 0x2259, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),
9614 	SND_PCI_QUIRK(0x103c, 0x225a, "HP", ALC269_FIXUP_HP_DOCK_GPIO_MIC1_LED),
9615 	SND_PCI_QUIRK(0x103c, 0x225f, "HP", ALC280_FIXUP_HP_GPIO2_MIC_HOTKEY),
9616 	SND_PCI_QUIRK(0x103c, 0x2260, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
9617 	SND_PCI_QUIRK(0x103c, 0x2263, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
9618 	SND_PCI_QUIRK(0x103c, 0x2264, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
9619 	SND_PCI_QUIRK(0x103c, 0x2265, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
9620 	SND_PCI_QUIRK(0x103c, 0x2268, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
9621 	SND_PCI_QUIRK(0x103c, 0x226a, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
9622 	SND_PCI_QUIRK(0x103c, 0x226b, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
9623 	SND_PCI_QUIRK(0x103c, 0x226e, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
9624 	SND_PCI_QUIRK(0x103c, 0x2271, "HP", ALC286_FIXUP_HP_GPIO_LED),
9625 	SND_PCI_QUIRK(0x103c, 0x2272, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),
9626 	SND_PCI_QUIRK(0x103c, 0x2272, "HP", ALC280_FIXUP_HP_DOCK_PINS),
9627 	SND_PCI_QUIRK(0x103c, 0x2273, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),
9628 	SND_PCI_QUIRK(0x103c, 0x2273, "HP", ALC280_FIXUP_HP_DOCK_PINS),
9629 	SND_PCI_QUIRK(0x103c, 0x2278, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),
9630 	SND_PCI_QUIRK(0x103c, 0x227f, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
9631 	SND_PCI_QUIRK(0x103c, 0x2282, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
9632 	SND_PCI_QUIRK(0x103c, 0x228b, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
9633 	SND_PCI_QUIRK(0x103c, 0x228e, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
9634 	SND_PCI_QUIRK(0x103c, 0x229e, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
9635 	SND_PCI_QUIRK(0x103c, 0x22b2, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
9636 	SND_PCI_QUIRK(0x103c, 0x22b7, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
9637 	SND_PCI_QUIRK(0x103c, 0x22bf, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
9638 	SND_PCI_QUIRK(0x103c, 0x22c4, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
9639 	SND_PCI_QUIRK(0x103c, 0x22c5, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
9640 	SND_PCI_QUIRK(0x103c, 0x22c7, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
9641 	SND_PCI_QUIRK(0x103c, 0x22c8, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
9642 	SND_PCI_QUIRK(0x103c, 0x22cf, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
9643 	SND_PCI_QUIRK(0x103c, 0x22db, "HP", ALC280_FIXUP_HP_9480M),
9644 	SND_PCI_QUIRK(0x103c, 0x22dc, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),
9645 	SND_PCI_QUIRK(0x103c, 0x22fb, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),
9646 	SND_PCI_QUIRK(0x103c, 0x2334, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
9647 	SND_PCI_QUIRK(0x103c, 0x2335, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
9648 	SND_PCI_QUIRK(0x103c, 0x2336, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
9649 	SND_PCI_QUIRK(0x103c, 0x2337, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
9650 	SND_PCI_QUIRK(0x103c, 0x2b5e, "HP 288 Pro G2 MT", ALC221_FIXUP_HP_288PRO_MIC_NO_PRESENCE),
9651 	SND_PCI_QUIRK(0x103c, 0x802e, "HP Z240 SFF", ALC221_FIXUP_HP_MIC_NO_PRESENCE),
9652 	SND_PCI_QUIRK(0x103c, 0x802f, "HP Z240", ALC221_FIXUP_HP_MIC_NO_PRESENCE),
9653 	SND_PCI_QUIRK(0x103c, 0x8077, "HP", ALC256_FIXUP_HP_HEADSET_MIC),
9654 	SND_PCI_QUIRK(0x103c, 0x8158, "HP", ALC256_FIXUP_HP_HEADSET_MIC),
9655 	SND_PCI_QUIRK(0x103c, 0x820d, "HP Pavilion 15", ALC295_FIXUP_HP_X360),
9656 	SND_PCI_QUIRK(0x103c, 0x8256, "HP", ALC221_FIXUP_HP_FRONT_MIC),
9657 	SND_PCI_QUIRK(0x103c, 0x827e, "HP x360", ALC295_FIXUP_HP_X360),
9658 	SND_PCI_QUIRK(0x103c, 0x827f, "HP x360", ALC269_FIXUP_HP_MUTE_LED_MIC3),
9659 	SND_PCI_QUIRK(0x103c, 0x82bf, "HP G3 mini", ALC221_FIXUP_HP_MIC_NO_PRESENCE),
9660 	SND_PCI_QUIRK(0x103c, 0x82c0, "HP G3 mini premium", ALC221_FIXUP_HP_MIC_NO_PRESENCE),
9661 	SND_PCI_QUIRK(0x103c, 0x83b9, "HP Spectre x360", ALC269_FIXUP_HP_MUTE_LED_MIC3),
9662 	SND_PCI_QUIRK(0x103c, 0x841c, "HP Pavilion 15-CK0xx", ALC269_FIXUP_HP_MUTE_LED_MIC3),
9663 	SND_PCI_QUIRK(0x103c, 0x8497, "HP Envy x360", ALC269_FIXUP_HP_MUTE_LED_MIC3),
9664 	SND_PCI_QUIRK(0x103c, 0x84da, "HP OMEN dc0019-ur", ALC295_FIXUP_HP_OMEN),
9665 	SND_PCI_QUIRK(0x103c, 0x84e7, "HP Pavilion 15", ALC269_FIXUP_HP_MUTE_LED_MIC3),
9666 	SND_PCI_QUIRK(0x103c, 0x8519, "HP Spectre x360 15-df0xxx", ALC285_FIXUP_HP_SPECTRE_X360),
9667 	SND_PCI_QUIRK(0x103c, 0x860f, "HP ZBook 15 G6", ALC285_FIXUP_HP_GPIO_AMP_INIT),
9668 	SND_PCI_QUIRK(0x103c, 0x861f, "HP Elite Dragonfly G1", ALC285_FIXUP_HP_GPIO_AMP_INIT),
9669 	SND_PCI_QUIRK(0x103c, 0x869d, "HP", ALC236_FIXUP_HP_MUTE_LED),
9670 	SND_PCI_QUIRK(0x103c, 0x86c7, "HP Envy AiO 32", ALC274_FIXUP_HP_ENVY_GPIO),
9671 	SND_PCI_QUIRK(0x103c, 0x86e7, "HP Spectre x360 15-eb0xxx", ALC285_FIXUP_HP_SPECTRE_X360_EB1),
9672 	SND_PCI_QUIRK(0x103c, 0x86e8, "HP Spectre x360 15-eb0xxx", ALC285_FIXUP_HP_SPECTRE_X360_EB1),
9673 	SND_PCI_QUIRK(0x103c, 0x86f9, "HP Spectre x360 13-aw0xxx", ALC285_FIXUP_HP_SPECTRE_X360_MUTE_LED),
9674 	SND_PCI_QUIRK(0x103c, 0x8716, "HP Elite Dragonfly G2 Notebook PC", ALC285_FIXUP_HP_GPIO_AMP_INIT),
9675 	SND_PCI_QUIRK(0x103c, 0x8720, "HP EliteBook x360 1040 G8 Notebook PC", ALC285_FIXUP_HP_GPIO_AMP_INIT),
9676 	SND_PCI_QUIRK(0x103c, 0x8724, "HP EliteBook 850 G7", ALC285_FIXUP_HP_GPIO_LED),
9677 	SND_PCI_QUIRK(0x103c, 0x8728, "HP EliteBook 840 G7", ALC285_FIXUP_HP_GPIO_LED),
9678 	SND_PCI_QUIRK(0x103c, 0x8729, "HP", ALC285_FIXUP_HP_GPIO_LED),
9679 	SND_PCI_QUIRK(0x103c, 0x8730, "HP ProBook 445 G7", ALC236_FIXUP_HP_MUTE_LED_MICMUTE_VREF),
9680 	SND_PCI_QUIRK(0x103c, 0x8735, "HP ProBook 435 G7", ALC236_FIXUP_HP_MUTE_LED_MICMUTE_VREF),
9681 	SND_PCI_QUIRK(0x103c, 0x8736, "HP", ALC285_FIXUP_HP_GPIO_AMP_INIT),
9682 	SND_PCI_QUIRK(0x103c, 0x8760, "HP", ALC285_FIXUP_HP_MUTE_LED),
9683 	SND_PCI_QUIRK(0x103c, 0x877a, "HP", ALC285_FIXUP_HP_MUTE_LED),
9684 	SND_PCI_QUIRK(0x103c, 0x877d, "HP", ALC236_FIXUP_HP_MUTE_LED),
9685 	SND_PCI_QUIRK(0x103c, 0x8780, "HP ZBook Fury 17 G7 Mobile Workstation",
9686 		      ALC285_FIXUP_HP_GPIO_AMP_INIT),
9687 	SND_PCI_QUIRK(0x103c, 0x8783, "HP ZBook Fury 15 G7 Mobile Workstation",
9688 		      ALC285_FIXUP_HP_GPIO_AMP_INIT),
9689 	SND_PCI_QUIRK(0x103c, 0x8786, "HP OMEN 15", ALC285_FIXUP_HP_MUTE_LED),
9690 	SND_PCI_QUIRK(0x103c, 0x8787, "HP OMEN 15", ALC285_FIXUP_HP_MUTE_LED),
9691 	SND_PCI_QUIRK(0x103c, 0x8788, "HP OMEN 15", ALC285_FIXUP_HP_MUTE_LED),
9692 	SND_PCI_QUIRK(0x103c, 0x87c8, "HP", ALC287_FIXUP_HP_GPIO_LED),
9693 	SND_PCI_QUIRK(0x103c, 0x87e5, "HP ProBook 440 G8 Notebook PC", ALC236_FIXUP_HP_GPIO_LED),
9694 	SND_PCI_QUIRK(0x103c, 0x87e7, "HP ProBook 450 G8 Notebook PC", ALC236_FIXUP_HP_GPIO_LED),
9695 	SND_PCI_QUIRK(0x103c, 0x87f1, "HP ProBook 630 G8 Notebook PC", ALC236_FIXUP_HP_GPIO_LED),
9696 	SND_PCI_QUIRK(0x103c, 0x87f2, "HP ProBook 640 G8 Notebook PC", ALC236_FIXUP_HP_GPIO_LED),
9697 	SND_PCI_QUIRK(0x103c, 0x87f4, "HP", ALC287_FIXUP_HP_GPIO_LED),
9698 	SND_PCI_QUIRK(0x103c, 0x87f5, "HP", ALC287_FIXUP_HP_GPIO_LED),
9699 	SND_PCI_QUIRK(0x103c, 0x87f6, "HP Spectre x360 14", ALC245_FIXUP_HP_X360_AMP),
9700 	SND_PCI_QUIRK(0x103c, 0x87f7, "HP Spectre x360 14", ALC245_FIXUP_HP_X360_AMP),
9701 	SND_PCI_QUIRK(0x103c, 0x8805, "HP ProBook 650 G8 Notebook PC", ALC236_FIXUP_HP_GPIO_LED),
9702 	SND_PCI_QUIRK(0x103c, 0x880d, "HP EliteBook 830 G8 Notebook PC", ALC285_FIXUP_HP_GPIO_LED),
9703 	SND_PCI_QUIRK(0x103c, 0x8811, "HP Spectre x360 15-eb1xxx", ALC285_FIXUP_HP_SPECTRE_X360_EB1),
9704 	SND_PCI_QUIRK(0x103c, 0x8812, "HP Spectre x360 15-eb1xxx", ALC285_FIXUP_HP_SPECTRE_X360_EB1),
9705 	SND_PCI_QUIRK(0x103c, 0x881d, "HP 250 G8 Notebook PC", ALC236_FIXUP_HP_MUTE_LED_COEFBIT2),
9706 	SND_PCI_QUIRK(0x103c, 0x8846, "HP EliteBook 850 G8 Notebook PC", ALC285_FIXUP_HP_GPIO_LED),
9707 	SND_PCI_QUIRK(0x103c, 0x8847, "HP EliteBook x360 830 G8 Notebook PC", ALC285_FIXUP_HP_GPIO_LED),
9708 	SND_PCI_QUIRK(0x103c, 0x884b, "HP EliteBook 840 Aero G8 Notebook PC", ALC285_FIXUP_HP_GPIO_LED),
9709 	SND_PCI_QUIRK(0x103c, 0x884c, "HP EliteBook 840 G8 Notebook PC", ALC285_FIXUP_HP_GPIO_LED),
9710 	SND_PCI_QUIRK(0x103c, 0x8862, "HP ProBook 445 G8 Notebook PC", ALC236_FIXUP_HP_LIMIT_INT_MIC_BOOST),
9711 	SND_PCI_QUIRK(0x103c, 0x8863, "HP ProBook 445 G8 Notebook PC", ALC236_FIXUP_HP_LIMIT_INT_MIC_BOOST),
9712 	SND_PCI_QUIRK(0x103c, 0x886d, "HP ZBook Fury 17.3 Inch G8 Mobile Workstation PC", ALC285_FIXUP_HP_GPIO_AMP_INIT),
9713 	SND_PCI_QUIRK(0x103c, 0x8870, "HP ZBook Fury 15.6 Inch G8 Mobile Workstation PC", ALC285_FIXUP_HP_GPIO_AMP_INIT),
9714 	SND_PCI_QUIRK(0x103c, 0x8873, "HP ZBook Studio 15.6 Inch G8 Mobile Workstation PC", ALC285_FIXUP_HP_GPIO_AMP_INIT),
9715 	SND_PCI_QUIRK(0x103c, 0x887a, "HP Laptop 15s-eq2xxx", ALC236_FIXUP_HP_MUTE_LED_COEFBIT2),
9716 	SND_PCI_QUIRK(0x103c, 0x888a, "HP ENVY x360 Convertible 15-eu0xxx", ALC245_FIXUP_HP_X360_MUTE_LEDS),
9717 	SND_PCI_QUIRK(0x103c, 0x888d, "HP ZBook Power 15.6 inch G8 Mobile Workstation PC", ALC236_FIXUP_HP_GPIO_LED),
9718 	SND_PCI_QUIRK(0x103c, 0x8895, "HP EliteBook 855 G8 Notebook PC", ALC285_FIXUP_HP_SPEAKERS_MICMUTE_LED),
9719 	SND_PCI_QUIRK(0x103c, 0x8896, "HP EliteBook 855 G8 Notebook PC", ALC285_FIXUP_HP_MUTE_LED),
9720 	SND_PCI_QUIRK(0x103c, 0x8898, "HP EliteBook 845 G8 Notebook PC", ALC285_FIXUP_HP_LIMIT_INT_MIC_BOOST),
9721 	SND_PCI_QUIRK(0x103c, 0x88d0, "HP Pavilion 15-eh1xxx (mainboard 88D0)", ALC287_FIXUP_HP_GPIO_LED),
9722 	SND_PCI_QUIRK(0x103c, 0x8902, "HP OMEN 16", ALC285_FIXUP_HP_MUTE_LED),
9723 	SND_PCI_QUIRK(0x103c, 0x8919, "HP Pavilion Aero Laptop 13-be0xxx", ALC287_FIXUP_HP_GPIO_LED),
9724 	SND_PCI_QUIRK(0x103c, 0x896d, "HP ZBook Firefly 16 G9", ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED),
9725 	SND_PCI_QUIRK(0x103c, 0x896e, "HP EliteBook x360 830 G9", ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED),
9726 	SND_PCI_QUIRK(0x103c, 0x8971, "HP EliteBook 830 G9", ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED),
9727 	SND_PCI_QUIRK(0x103c, 0x8972, "HP EliteBook 840 G9", ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED),
9728 	SND_PCI_QUIRK(0x103c, 0x8973, "HP EliteBook 860 G9", ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED),
9729 	SND_PCI_QUIRK(0x103c, 0x8974, "HP EliteBook 840 Aero G9", ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED),
9730 	SND_PCI_QUIRK(0x103c, 0x8975, "HP EliteBook x360 840 Aero G9", ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED),
9731 	SND_PCI_QUIRK(0x103c, 0x8981, "HP Elite Dragonfly G3", ALC245_FIXUP_CS35L41_SPI_4),
9732 	SND_PCI_QUIRK(0x103c, 0x898e, "HP EliteBook 835 G9", ALC287_FIXUP_CS35L41_I2C_2),
9733 	SND_PCI_QUIRK(0x103c, 0x898f, "HP EliteBook 835 G9", ALC287_FIXUP_CS35L41_I2C_2),
9734 	SND_PCI_QUIRK(0x103c, 0x8991, "HP EliteBook 845 G9", ALC287_FIXUP_CS35L41_I2C_2_HP_GPIO_LED),
9735 	SND_PCI_QUIRK(0x103c, 0x8992, "HP EliteBook 845 G9", ALC287_FIXUP_CS35L41_I2C_2),
9736 	SND_PCI_QUIRK(0x103c, 0x8994, "HP EliteBook 855 G9", ALC287_FIXUP_CS35L41_I2C_2_HP_GPIO_LED),
9737 	SND_PCI_QUIRK(0x103c, 0x8995, "HP EliteBook 855 G9", ALC287_FIXUP_CS35L41_I2C_2),
9738 	SND_PCI_QUIRK(0x103c, 0x89a4, "HP ProBook 440 G9", ALC236_FIXUP_HP_GPIO_LED),
9739 	SND_PCI_QUIRK(0x103c, 0x89a6, "HP ProBook 450 G9", ALC236_FIXUP_HP_GPIO_LED),
9740 	SND_PCI_QUIRK(0x103c, 0x89aa, "HP EliteBook 630 G9", ALC236_FIXUP_HP_GPIO_LED),
9741 	SND_PCI_QUIRK(0x103c, 0x89ac, "HP EliteBook 640 G9", ALC236_FIXUP_HP_GPIO_LED),
9742 	SND_PCI_QUIRK(0x103c, 0x89ae, "HP EliteBook 650 G9", ALC236_FIXUP_HP_GPIO_LED),
9743 	SND_PCI_QUIRK(0x103c, 0x89c0, "HP ZBook Power 15.6 G9", ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED),
9744 	SND_PCI_QUIRK(0x103c, 0x89c3, "Zbook Studio G9", ALC245_FIXUP_CS35L41_SPI_4_HP_GPIO_LED),
9745 	SND_PCI_QUIRK(0x103c, 0x89c6, "Zbook Fury 17 G9", ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED),
9746 	SND_PCI_QUIRK(0x103c, 0x89ca, "HP", ALC236_FIXUP_HP_MUTE_LED_MICMUTE_VREF),
9747 	SND_PCI_QUIRK(0x103c, 0x89d3, "HP EliteBook 645 G9 (MB 89D2)", ALC236_FIXUP_HP_MUTE_LED_MICMUTE_VREF),
9748 	SND_PCI_QUIRK(0x103c, 0x8a20, "HP Laptop 15s-fq5xxx", ALC236_FIXUP_HP_MUTE_LED_COEFBIT2),
9749 	SND_PCI_QUIRK(0x103c, 0x8a25, "HP Victus 16-d1xxx (MB 8A25)", ALC245_FIXUP_HP_MUTE_LED_COEFBIT),
9750 	SND_PCI_QUIRK(0x103c, 0x8a78, "HP Dev One", ALC285_FIXUP_HP_LIMIT_INT_MIC_BOOST),
9751 	SND_PCI_QUIRK(0x103c, 0x8aa0, "HP ProBook 440 G9 (MB 8A9E)", ALC236_FIXUP_HP_GPIO_LED),
9752 	SND_PCI_QUIRK(0x103c, 0x8aa3, "HP ProBook 450 G9 (MB 8AA1)", ALC236_FIXUP_HP_GPIO_LED),
9753 	SND_PCI_QUIRK(0x103c, 0x8aa8, "HP EliteBook 640 G9 (MB 8AA6)", ALC236_FIXUP_HP_GPIO_LED),
9754 	SND_PCI_QUIRK(0x103c, 0x8aab, "HP EliteBook 650 G9 (MB 8AA9)", ALC236_FIXUP_HP_GPIO_LED),
9755 	SND_PCI_QUIRK(0x103c, 0x8abb, "HP ZBook Firefly 14 G9", ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED),
9756 	SND_PCI_QUIRK(0x103c, 0x8ad1, "HP EliteBook 840 14 inch G9 Notebook PC", ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED),
9757 	SND_PCI_QUIRK(0x103c, 0x8ad2, "HP EliteBook 860 16 inch G9 Notebook PC", ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED),
9758 	SND_PCI_QUIRK(0x103c, 0x8b42, "HP", ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED),
9759 	SND_PCI_QUIRK(0x103c, 0x8b43, "HP", ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED),
9760 	SND_PCI_QUIRK(0x103c, 0x8b44, "HP", ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED),
9761 	SND_PCI_QUIRK(0x103c, 0x8b45, "HP", ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED),
9762 	SND_PCI_QUIRK(0x103c, 0x8b46, "HP", ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED),
9763 	SND_PCI_QUIRK(0x103c, 0x8b47, "HP", ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED),
9764 	SND_PCI_QUIRK(0x103c, 0x8b5d, "HP", ALC236_FIXUP_HP_MUTE_LED_MICMUTE_VREF),
9765 	SND_PCI_QUIRK(0x103c, 0x8b5e, "HP", ALC236_FIXUP_HP_MUTE_LED_MICMUTE_VREF),
9766 	SND_PCI_QUIRK(0x103c, 0x8b63, "HP Elite Dragonfly 13.5 inch G4", ALC245_FIXUP_CS35L41_SPI_4_HP_GPIO_LED),
9767 	SND_PCI_QUIRK(0x103c, 0x8b65, "HP ProBook 455 15.6 inch G10 Notebook PC", ALC236_FIXUP_HP_MUTE_LED_MICMUTE_VREF),
9768 	SND_PCI_QUIRK(0x103c, 0x8b66, "HP", ALC236_FIXUP_HP_MUTE_LED_MICMUTE_VREF),
9769 	SND_PCI_QUIRK(0x103c, 0x8b70, "HP EliteBook 835 G10", ALC287_FIXUP_CS35L41_I2C_2_HP_GPIO_LED),
9770 	SND_PCI_QUIRK(0x103c, 0x8b72, "HP EliteBook 845 G10", ALC287_FIXUP_CS35L41_I2C_2_HP_GPIO_LED),
9771 	SND_PCI_QUIRK(0x103c, 0x8b74, "HP EliteBook 845W G10", ALC287_FIXUP_CS35L41_I2C_2_HP_GPIO_LED),
9772 	SND_PCI_QUIRK(0x103c, 0x8b77, "HP ElieBook 865 G10", ALC287_FIXUP_CS35L41_I2C_2),
9773 	SND_PCI_QUIRK(0x103c, 0x8b7a, "HP", ALC236_FIXUP_HP_GPIO_LED),
9774 	SND_PCI_QUIRK(0x103c, 0x8b7d, "HP", ALC236_FIXUP_HP_GPIO_LED),
9775 	SND_PCI_QUIRK(0x103c, 0x8b87, "HP", ALC236_FIXUP_HP_GPIO_LED),
9776 	SND_PCI_QUIRK(0x103c, 0x8b8a, "HP", ALC236_FIXUP_HP_GPIO_LED),
9777 	SND_PCI_QUIRK(0x103c, 0x8b8b, "HP", ALC236_FIXUP_HP_GPIO_LED),
9778 	SND_PCI_QUIRK(0x103c, 0x8b8d, "HP", ALC236_FIXUP_HP_GPIO_LED),
9779 	SND_PCI_QUIRK(0x103c, 0x8b8f, "HP", ALC245_FIXUP_CS35L41_SPI_4_HP_GPIO_LED),
9780 	SND_PCI_QUIRK(0x103c, 0x8b92, "HP", ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED),
9781 	SND_PCI_QUIRK(0x103c, 0x8b96, "HP", ALC236_FIXUP_HP_MUTE_LED_MICMUTE_VREF),
9782 	SND_PCI_QUIRK(0x103c, 0x8b97, "HP", ALC236_FIXUP_HP_MUTE_LED_MICMUTE_VREF),
9783 	SND_PCI_QUIRK(0x103c, 0x8bf0, "HP", ALC236_FIXUP_HP_GPIO_LED),
9784 	SND_PCI_QUIRK(0x103c, 0x8c46, "HP EliteBook 830 G11", ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED),
9785 	SND_PCI_QUIRK(0x103c, 0x8c47, "HP EliteBook 840 G11", ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED),
9786 	SND_PCI_QUIRK(0x103c, 0x8c48, "HP EliteBook 860 G11", ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED),
9787 	SND_PCI_QUIRK(0x103c, 0x8c49, "HP Elite x360 830 2-in-1 G11", ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED),
9788 	SND_PCI_QUIRK(0x103c, 0x8c70, "HP EliteBook 835 G11", ALC287_FIXUP_CS35L41_I2C_2_HP_GPIO_LED),
9789 	SND_PCI_QUIRK(0x103c, 0x8c71, "HP EliteBook 845 G11", ALC287_FIXUP_CS35L41_I2C_2_HP_GPIO_LED),
9790 	SND_PCI_QUIRK(0x103c, 0x8c72, "HP EliteBook 865 G11", ALC287_FIXUP_CS35L41_I2C_2_HP_GPIO_LED),
9791 	SND_PCI_QUIRK(0x1043, 0x103e, "ASUS X540SA", ALC256_FIXUP_ASUS_MIC),
9792 	SND_PCI_QUIRK(0x1043, 0x103f, "ASUS TX300", ALC282_FIXUP_ASUS_TX300),
9793 	SND_PCI_QUIRK(0x1043, 0x106d, "Asus K53BE", ALC269_FIXUP_LIMIT_INT_MIC_BOOST),
9794 	SND_PCI_QUIRK(0x1043, 0x10a1, "ASUS UX391UA", ALC294_FIXUP_ASUS_SPK),
9795 	SND_PCI_QUIRK(0x1043, 0x10c0, "ASUS X540SA", ALC256_FIXUP_ASUS_MIC),
9796 	SND_PCI_QUIRK(0x1043, 0x10d0, "ASUS X540LA/X540LJ", ALC255_FIXUP_ASUS_MIC_NO_PRESENCE),
9797 	SND_PCI_QUIRK(0x1043, 0x115d, "Asus 1015E", ALC269_FIXUP_LIMIT_INT_MIC_BOOST),
9798 	SND_PCI_QUIRK(0x1043, 0x11c0, "ASUS X556UR", ALC255_FIXUP_ASUS_MIC_NO_PRESENCE),
9799 	SND_PCI_QUIRK(0x1043, 0x125e, "ASUS Q524UQK", ALC255_FIXUP_ASUS_MIC_NO_PRESENCE),
9800 	SND_PCI_QUIRK(0x1043, 0x1271, "ASUS X430UN", ALC256_FIXUP_ASUS_MIC_NO_PRESENCE),
9801 	SND_PCI_QUIRK(0x1043, 0x1290, "ASUS X441SA", ALC233_FIXUP_EAPD_COEF_AND_MIC_NO_PRESENCE),
9802 	SND_PCI_QUIRK(0x1043, 0x12a0, "ASUS X441UV", ALC233_FIXUP_EAPD_COEF_AND_MIC_NO_PRESENCE),
9803 	SND_PCI_QUIRK(0x1043, 0x12a3, "Asus N7691ZM", ALC269_FIXUP_ASUS_N7601ZM),
9804 	SND_PCI_QUIRK(0x1043, 0x12af, "ASUS UX582ZS", ALC245_FIXUP_CS35L41_SPI_2),
9805 	SND_PCI_QUIRK(0x1043, 0x12e0, "ASUS X541SA", ALC256_FIXUP_ASUS_MIC),
9806 	SND_PCI_QUIRK(0x1043, 0x12f0, "ASUS X541UV", ALC256_FIXUP_ASUS_MIC),
9807 	SND_PCI_QUIRK(0x1043, 0x1313, "Asus K42JZ", ALC269VB_FIXUP_ASUS_MIC_NO_PRESENCE),
9808 	SND_PCI_QUIRK(0x1043, 0x13b0, "ASUS Z550SA", ALC256_FIXUP_ASUS_MIC),
9809 	SND_PCI_QUIRK(0x1043, 0x1427, "Asus Zenbook UX31E", ALC269VB_FIXUP_ASUS_ZENBOOK),
9810 	SND_PCI_QUIRK(0x1043, 0x1433, "ASUS GX650P", ALC285_FIXUP_ASUS_I2C_HEADSET_MIC),
9811 	SND_PCI_QUIRK(0x1043, 0x1463, "Asus GA402X", ALC285_FIXUP_ASUS_I2C_HEADSET_MIC),
9812 	SND_PCI_QUIRK(0x1043, 0x1473, "ASUS GU604V", ALC285_FIXUP_ASUS_HEADSET_MIC),
9813 	SND_PCI_QUIRK(0x1043, 0x1483, "ASUS GU603V", ALC285_FIXUP_ASUS_HEADSET_MIC),
9814 	SND_PCI_QUIRK(0x1043, 0x1493, "ASUS GV601V", ALC285_FIXUP_ASUS_HEADSET_MIC),
9815 	SND_PCI_QUIRK(0x1043, 0x1517, "Asus Zenbook UX31A", ALC269VB_FIXUP_ASUS_ZENBOOK_UX31A),
9816 	SND_PCI_QUIRK(0x1043, 0x1573, "ASUS GZ301V", ALC285_FIXUP_ASUS_HEADSET_MIC),
9817 	SND_PCI_QUIRK(0x1043, 0x1662, "ASUS GV301QH", ALC294_FIXUP_ASUS_DUAL_SPK),
9818 	SND_PCI_QUIRK(0x1043, 0x1663, "ASUS GU603ZV", ALC285_FIXUP_ASUS_HEADSET_MIC),
9819 	SND_PCI_QUIRK(0x1043, 0x1683, "ASUS UM3402YAR", ALC287_FIXUP_CS35L41_I2C_2),
9820 	SND_PCI_QUIRK(0x1043, 0x16b2, "ASUS GU603", ALC289_FIXUP_ASUS_GA401),
9821 	SND_PCI_QUIRK(0x1043, 0x16e3, "ASUS UX50", ALC269_FIXUP_STEREO_DMIC),
9822 	SND_PCI_QUIRK(0x1043, 0x1740, "ASUS UX430UA", ALC295_FIXUP_ASUS_DACS),
9823 	SND_PCI_QUIRK(0x1043, 0x17d1, "ASUS UX431FL", ALC294_FIXUP_ASUS_DUAL_SPK),
9824 	SND_PCI_QUIRK(0x1043, 0x17f3, "ROG Ally RC71L_RC71L", ALC294_FIXUP_ASUS_ALLY),
9825 	SND_PCI_QUIRK(0x1043, 0x1881, "ASUS Zephyrus S/M", ALC294_FIXUP_ASUS_GX502_PINS),
9826 	SND_PCI_QUIRK(0x1043, 0x18b1, "Asus MJ401TA", ALC256_FIXUP_ASUS_HEADSET_MIC),
9827 	SND_PCI_QUIRK(0x1043, 0x18f1, "Asus FX505DT", ALC256_FIXUP_ASUS_HEADSET_MIC),
9828 	SND_PCI_QUIRK(0x1043, 0x194e, "ASUS UX563FD", ALC294_FIXUP_ASUS_HPE),
9829 	SND_PCI_QUIRK(0x1043, 0x1970, "ASUS UX550VE", ALC289_FIXUP_ASUS_GA401),
9830 	SND_PCI_QUIRK(0x1043, 0x1982, "ASUS B1400CEPE", ALC256_FIXUP_ASUS_HPE),
9831 	SND_PCI_QUIRK(0x1043, 0x19ce, "ASUS B9450FA", ALC294_FIXUP_ASUS_HPE),
9832 	SND_PCI_QUIRK(0x1043, 0x19e1, "ASUS UX581LV", ALC295_FIXUP_ASUS_MIC_NO_PRESENCE),
9833 	SND_PCI_QUIRK(0x1043, 0x1a13, "Asus G73Jw", ALC269_FIXUP_ASUS_G73JW),
9834 	SND_PCI_QUIRK(0x1043, 0x1a30, "ASUS X705UD", ALC256_FIXUP_ASUS_MIC),
9835 	SND_PCI_QUIRK(0x1043, 0x1a8f, "ASUS UX582ZS", ALC245_FIXUP_CS35L41_SPI_2),
9836 	SND_PCI_QUIRK(0x1043, 0x1b11, "ASUS UX431DA", ALC294_FIXUP_ASUS_COEF_1B),
9837 	SND_PCI_QUIRK(0x1043, 0x1b13, "Asus U41SV", ALC269_FIXUP_INV_DMIC),
9838 	SND_PCI_QUIRK(0x1043, 0x1b93, "ASUS G614JVR/JIR", ALC245_FIXUP_CS35L41_SPI_2),
9839 	SND_PCI_QUIRK(0x1043, 0x1bbd, "ASUS Z550MA", ALC255_FIXUP_ASUS_MIC_NO_PRESENCE),
9840 	SND_PCI_QUIRK(0x1043, 0x1c23, "Asus X55U", ALC269_FIXUP_LIMIT_INT_MIC_BOOST),
9841 	SND_PCI_QUIRK(0x1043, 0x1c62, "ASUS GU603", ALC289_FIXUP_ASUS_GA401),
9842 	SND_PCI_QUIRK(0x1043, 0x1c92, "ASUS ROG Strix G15", ALC285_FIXUP_ASUS_G533Z_PINS),
9843 	SND_PCI_QUIRK(0x1043, 0x1c9f, "ASUS G614JI", ALC285_FIXUP_ASUS_HEADSET_MIC),
9844 	SND_PCI_QUIRK(0x1043, 0x1caf, "ASUS G634JYR/JZR", ALC285_FIXUP_ASUS_SPI_REAR_SPEAKERS),
9845 	SND_PCI_QUIRK(0x1043, 0x1ccd, "ASUS X555UB", ALC256_FIXUP_ASUS_MIC),
9846 	SND_PCI_QUIRK(0x1043, 0x1d1f, "ASUS ROG Strix G17 2023 (G713PV)", ALC287_FIXUP_CS35L41_I2C_2),
9847 	SND_PCI_QUIRK(0x1043, 0x1d42, "ASUS Zephyrus G14 2022", ALC289_FIXUP_ASUS_GA401),
9848 	SND_PCI_QUIRK(0x1043, 0x1d4e, "ASUS TM420", ALC256_FIXUP_ASUS_HPE),
9849 	SND_PCI_QUIRK(0x1043, 0x1e02, "ASUS UX3402ZA", ALC245_FIXUP_CS35L41_SPI_2),
9850 	SND_PCI_QUIRK(0x1043, 0x16a3, "ASUS UX3402VA", ALC245_FIXUP_CS35L41_SPI_2),
9851 	SND_PCI_QUIRK(0x1043, 0x1e11, "ASUS Zephyrus G15", ALC289_FIXUP_ASUS_GA502),
9852 	SND_PCI_QUIRK(0x1043, 0x1e12, "ASUS UM3402", ALC287_FIXUP_CS35L41_I2C_2),
9853 	SND_PCI_QUIRK(0x1043, 0x1e51, "ASUS Zephyrus M15", ALC294_FIXUP_ASUS_GU502_PINS),
9854 	SND_PCI_QUIRK(0x1043, 0x1e5e, "ASUS ROG Strix G513", ALC294_FIXUP_ASUS_G513_PINS),
9855 	SND_PCI_QUIRK(0x1043, 0x1e8e, "ASUS Zephyrus G15", ALC289_FIXUP_ASUS_GA401),
9856 	SND_PCI_QUIRK(0x1043, 0x1c52, "ASUS Zephyrus G15 2022", ALC289_FIXUP_ASUS_GA401),
9857 	SND_PCI_QUIRK(0x1043, 0x1f11, "ASUS Zephyrus G14", ALC289_FIXUP_ASUS_GA401),
9858 	SND_PCI_QUIRK(0x1043, 0x1f12, "ASUS UM5302", ALC287_FIXUP_CS35L41_I2C_2),
9859 	SND_PCI_QUIRK(0x1043, 0x1f92, "ASUS ROG Flow X16", ALC289_FIXUP_ASUS_GA401),
9860 	SND_PCI_QUIRK(0x1043, 0x3030, "ASUS ZN270IE", ALC256_FIXUP_ASUS_AIO_GPIO2),
9861 	SND_PCI_QUIRK(0x1043, 0x3a20, "ASUS G614JZR", ALC245_FIXUP_CS35L41_SPI_2),
9862 	SND_PCI_QUIRK(0x1043, 0x3a30, "ASUS G814JVR/JIR", ALC245_FIXUP_CS35L41_SPI_2),
9863 	SND_PCI_QUIRK(0x1043, 0x3a40, "ASUS G814JZR", ALC245_FIXUP_CS35L41_SPI_2),
9864 	SND_PCI_QUIRK(0x1043, 0x3a50, "ASUS G834JYR/JZR", ALC245_FIXUP_CS35L41_SPI_2),
9865 	SND_PCI_QUIRK(0x1043, 0x3a60, "ASUS G634JYR/JZR", ALC245_FIXUP_CS35L41_SPI_2),
9866 	SND_PCI_QUIRK(0x1043, 0x831a, "ASUS P901", ALC269_FIXUP_STEREO_DMIC),
9867 	SND_PCI_QUIRK(0x1043, 0x834a, "ASUS S101", ALC269_FIXUP_STEREO_DMIC),
9868 	SND_PCI_QUIRK(0x1043, 0x8398, "ASUS P1005", ALC269_FIXUP_STEREO_DMIC),
9869 	SND_PCI_QUIRK(0x1043, 0x83ce, "ASUS P1005", ALC269_FIXUP_STEREO_DMIC),
9870 	SND_PCI_QUIRK(0x1043, 0x8516, "ASUS X101CH", ALC269_FIXUP_ASUS_X101),
9871 	SND_PCI_QUIRK(0x104d, 0x9073, "Sony VAIO", ALC275_FIXUP_SONY_VAIO_GPIO2),
9872 	SND_PCI_QUIRK(0x104d, 0x907b, "Sony VAIO", ALC275_FIXUP_SONY_HWEQ),
9873 	SND_PCI_QUIRK(0x104d, 0x9084, "Sony VAIO", ALC275_FIXUP_SONY_HWEQ),
9874 	SND_PCI_QUIRK(0x104d, 0x9099, "Sony VAIO S13", ALC275_FIXUP_SONY_DISABLE_AAMIX),
9875 	SND_PCI_QUIRK(0x104d, 0x90b5, "Sony VAIO Pro 11", ALC286_FIXUP_SONY_MIC_NO_PRESENCE),
9876 	SND_PCI_QUIRK(0x104d, 0x90b6, "Sony VAIO Pro 13", ALC286_FIXUP_SONY_MIC_NO_PRESENCE),
9877 	SND_PCI_QUIRK(0x10cf, 0x1475, "Lifebook", ALC269_FIXUP_LIFEBOOK),
9878 	SND_PCI_QUIRK(0x10cf, 0x159f, "Lifebook E780", ALC269_FIXUP_LIFEBOOK_NO_HP_TO_LINEOUT),
9879 	SND_PCI_QUIRK(0x10cf, 0x15dc, "Lifebook T731", ALC269_FIXUP_LIFEBOOK_HP_PIN),
9880 	SND_PCI_QUIRK(0x10cf, 0x1629, "Lifebook U7x7", ALC255_FIXUP_LIFEBOOK_U7x7_HEADSET_MIC),
9881 	SND_PCI_QUIRK(0x10cf, 0x1757, "Lifebook E752", ALC269_FIXUP_LIFEBOOK_HP_PIN),
9882 	SND_PCI_QUIRK(0x10cf, 0x1845, "Lifebook U904", ALC269_FIXUP_LIFEBOOK_EXTMIC),
9883 	SND_PCI_QUIRK(0x10ec, 0x10f2, "Intel Reference board", ALC700_FIXUP_INTEL_REFERENCE),
9884 	SND_PCI_QUIRK(0x10ec, 0x118c, "Medion EE4254 MD62100", ALC256_FIXUP_MEDION_HEADSET_NO_PRESENCE),
9885 	SND_PCI_QUIRK(0x10ec, 0x1230, "Intel Reference board", ALC295_FIXUP_CHROME_BOOK),
9886 	SND_PCI_QUIRK(0x10ec, 0x124c, "Intel Reference board", ALC295_FIXUP_CHROME_BOOK),
9887 	SND_PCI_QUIRK(0x10ec, 0x1252, "Intel Reference board", ALC295_FIXUP_CHROME_BOOK),
9888 	SND_PCI_QUIRK(0x10ec, 0x1254, "Intel Reference board", ALC295_FIXUP_CHROME_BOOK),
9889 	SND_PCI_QUIRK(0x10ec, 0x12cc, "Intel Reference board", ALC295_FIXUP_CHROME_BOOK),
9890 	SND_PCI_QUIRK(0x10f7, 0x8338, "Panasonic CF-SZ6", ALC269_FIXUP_HEADSET_MODE),
9891 	SND_PCI_QUIRK(0x144d, 0xc109, "Samsung Ativ book 9 (NP900X3G)", ALC269_FIXUP_INV_DMIC),
9892 	SND_PCI_QUIRK(0x144d, 0xc169, "Samsung Notebook 9 Pen (NP930SBE-K01US)", ALC298_FIXUP_SAMSUNG_AMP),
9893 	SND_PCI_QUIRK(0x144d, 0xc176, "Samsung Notebook 9 Pro (NP930MBE-K04US)", ALC298_FIXUP_SAMSUNG_AMP),
9894 	SND_PCI_QUIRK(0x144d, 0xc189, "Samsung Galaxy Flex Book (NT950QCG-X716)", ALC298_FIXUP_SAMSUNG_AMP),
9895 	SND_PCI_QUIRK(0x144d, 0xc18a, "Samsung Galaxy Book Ion (NP930XCJ-K01US)", ALC298_FIXUP_SAMSUNG_AMP),
9896 	SND_PCI_QUIRK(0x144d, 0xc1a3, "Samsung Galaxy Book Pro (NP935XDB-KC1SE)", ALC298_FIXUP_SAMSUNG_AMP),
9897 	SND_PCI_QUIRK(0x144d, 0xc1a6, "Samsung Galaxy Book Pro 360 (NP930QBD)", ALC298_FIXUP_SAMSUNG_AMP),
9898 	SND_PCI_QUIRK(0x144d, 0xc740, "Samsung Ativ book 8 (NP870Z5G)", ALC269_FIXUP_ATIV_BOOK_8),
9899 	SND_PCI_QUIRK(0x144d, 0xc812, "Samsung Notebook Pen S (NT950SBE-X58)", ALC298_FIXUP_SAMSUNG_AMP),
9900 	SND_PCI_QUIRK(0x144d, 0xc830, "Samsung Galaxy Book Ion (NT950XCJ-X716A)", ALC298_FIXUP_SAMSUNG_AMP),
9901 	SND_PCI_QUIRK(0x144d, 0xc832, "Samsung Galaxy Book Flex Alpha (NP730QCJ)", ALC256_FIXUP_SAMSUNG_HEADPHONE_VERY_QUIET),
9902 	SND_PCI_QUIRK(0x144d, 0xca03, "Samsung Galaxy Book2 Pro 360 (NP930QED)", ALC298_FIXUP_SAMSUNG_AMP),
9903 	SND_PCI_QUIRK(0x144d, 0xc868, "Samsung Galaxy Book2 Pro (NP930XED)", ALC298_FIXUP_SAMSUNG_AMP),
9904 	SND_PCI_QUIRK(0x1458, 0xfa53, "Gigabyte BXBT-2807", ALC283_FIXUP_HEADSET_MIC),
9905 	SND_PCI_QUIRK(0x1462, 0xb120, "MSI Cubi MS-B120", ALC283_FIXUP_HEADSET_MIC),
9906 	SND_PCI_QUIRK(0x1462, 0xb171, "Cubi N 8GL (MS-B171)", ALC283_FIXUP_HEADSET_MIC),
9907 	SND_PCI_QUIRK(0x152d, 0x1082, "Quanta NL3", ALC269_FIXUP_LIFEBOOK),
9908 	SND_PCI_QUIRK(0x1558, 0x1323, "Clevo N130ZU", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
9909 	SND_PCI_QUIRK(0x1558, 0x1325, "Clevo N15[01][CW]U", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
9910 	SND_PCI_QUIRK(0x1558, 0x1401, "Clevo L140[CZ]U", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
9911 	SND_PCI_QUIRK(0x1558, 0x1403, "Clevo N140CU", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
9912 	SND_PCI_QUIRK(0x1558, 0x1404, "Clevo N150CU", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
9913 	SND_PCI_QUIRK(0x1558, 0x14a1, "Clevo L141MU", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
9914 	SND_PCI_QUIRK(0x1558, 0x4018, "Clevo NV40M[BE]", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
9915 	SND_PCI_QUIRK(0x1558, 0x4019, "Clevo NV40MZ", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
9916 	SND_PCI_QUIRK(0x1558, 0x4020, "Clevo NV40MB", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
9917 	SND_PCI_QUIRK(0x1558, 0x4041, "Clevo NV4[15]PZ", ALC256_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
9918 	SND_PCI_QUIRK(0x1558, 0x40a1, "Clevo NL40GU", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
9919 	SND_PCI_QUIRK(0x1558, 0x40c1, "Clevo NL40[CZ]U", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
9920 	SND_PCI_QUIRK(0x1558, 0x40d1, "Clevo NL41DU", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
9921 	SND_PCI_QUIRK(0x1558, 0x5015, "Clevo NH5[58]H[HJK]Q", ALC256_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
9922 	SND_PCI_QUIRK(0x1558, 0x5017, "Clevo NH7[79]H[HJK]Q", ALC256_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
9923 	SND_PCI_QUIRK(0x1558, 0x50a3, "Clevo NJ51GU", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
9924 	SND_PCI_QUIRK(0x1558, 0x50b3, "Clevo NK50S[BEZ]", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
9925 	SND_PCI_QUIRK(0x1558, 0x50b6, "Clevo NK50S5", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
9926 	SND_PCI_QUIRK(0x1558, 0x50b8, "Clevo NK50SZ", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
9927 	SND_PCI_QUIRK(0x1558, 0x50d5, "Clevo NP50D5", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
9928 	SND_PCI_QUIRK(0x1558, 0x50e1, "Clevo NH5[58]HPQ", ALC256_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
9929 	SND_PCI_QUIRK(0x1558, 0x50e2, "Clevo NH7[79]HPQ", ALC256_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
9930 	SND_PCI_QUIRK(0x1558, 0x50f0, "Clevo NH50A[CDF]", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
9931 	SND_PCI_QUIRK(0x1558, 0x50f2, "Clevo NH50E[PR]", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
9932 	SND_PCI_QUIRK(0x1558, 0x50f3, "Clevo NH58DPQ", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
9933 	SND_PCI_QUIRK(0x1558, 0x50f5, "Clevo NH55EPY", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
9934 	SND_PCI_QUIRK(0x1558, 0x50f6, "Clevo NH55DPQ", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
9935 	SND_PCI_QUIRK(0x1558, 0x5101, "Clevo S510WU", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
9936 	SND_PCI_QUIRK(0x1558, 0x5157, "Clevo W517GU1", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
9937 	SND_PCI_QUIRK(0x1558, 0x51a1, "Clevo NS50MU", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
9938 	SND_PCI_QUIRK(0x1558, 0x51b1, "Clevo NS50AU", ALC256_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
9939 	SND_PCI_QUIRK(0x1558, 0x51b3, "Clevo NS70AU", ALC256_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
9940 	SND_PCI_QUIRK(0x1558, 0x5630, "Clevo NP50RNJS", ALC256_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
9941 	SND_PCI_QUIRK(0x1558, 0x70a1, "Clevo NB70T[HJK]", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
9942 	SND_PCI_QUIRK(0x1558, 0x70b3, "Clevo NK70SB", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
9943 	SND_PCI_QUIRK(0x1558, 0x70f2, "Clevo NH79EPY", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
9944 	SND_PCI_QUIRK(0x1558, 0x70f3, "Clevo NH77DPQ", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
9945 	SND_PCI_QUIRK(0x1558, 0x70f4, "Clevo NH77EPY", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
9946 	SND_PCI_QUIRK(0x1558, 0x70f6, "Clevo NH77DPQ-Y", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
9947 	SND_PCI_QUIRK(0x1558, 0x7716, "Clevo NS50PU", ALC256_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
9948 	SND_PCI_QUIRK(0x1558, 0x7717, "Clevo NS70PU", ALC256_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
9949 	SND_PCI_QUIRK(0x1558, 0x7718, "Clevo L140PU", ALC256_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
9950 	SND_PCI_QUIRK(0x1558, 0x7724, "Clevo L140AU", ALC256_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
9951 	SND_PCI_QUIRK(0x1558, 0x8228, "Clevo NR40BU", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
9952 	SND_PCI_QUIRK(0x1558, 0x8520, "Clevo NH50D[CD]", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
9953 	SND_PCI_QUIRK(0x1558, 0x8521, "Clevo NH77D[CD]", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
9954 	SND_PCI_QUIRK(0x1558, 0x8535, "Clevo NH50D[BE]", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
9955 	SND_PCI_QUIRK(0x1558, 0x8536, "Clevo NH79D[BE]", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
9956 	SND_PCI_QUIRK(0x1558, 0x8550, "Clevo NH[57][0-9][ER][ACDH]Q", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
9957 	SND_PCI_QUIRK(0x1558, 0x8551, "Clevo NH[57][0-9][ER][ACDH]Q", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
9958 	SND_PCI_QUIRK(0x1558, 0x8560, "Clevo NH[57][0-9][ER][ACDH]Q", ALC269_FIXUP_HEADSET_MIC),
9959 	SND_PCI_QUIRK(0x1558, 0x8561, "Clevo NH[57][0-9][ER][ACDH]Q", ALC269_FIXUP_HEADSET_MIC),
9960 	SND_PCI_QUIRK(0x1558, 0x8562, "Clevo NH[57][0-9]RZ[Q]", ALC269_FIXUP_DMIC),
9961 	SND_PCI_QUIRK(0x1558, 0x8668, "Clevo NP50B[BE]", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
9962 	SND_PCI_QUIRK(0x1558, 0x866d, "Clevo NP5[05]PN[HJK]", ALC256_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
9963 	SND_PCI_QUIRK(0x1558, 0x867c, "Clevo NP7[01]PNP", ALC256_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
9964 	SND_PCI_QUIRK(0x1558, 0x867d, "Clevo NP7[01]PN[HJK]", ALC256_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
9965 	SND_PCI_QUIRK(0x1558, 0x8680, "Clevo NJ50LU", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
9966 	SND_PCI_QUIRK(0x1558, 0x8686, "Clevo NH50[CZ]U", ALC256_FIXUP_MIC_NO_PRESENCE_AND_RESUME),
9967 	SND_PCI_QUIRK(0x1558, 0x8a20, "Clevo NH55DCQ-Y", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
9968 	SND_PCI_QUIRK(0x1558, 0x8a51, "Clevo NH70RCQ-Y", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
9969 	SND_PCI_QUIRK(0x1558, 0x8d50, "Clevo NH55RCQ-M", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
9970 	SND_PCI_QUIRK(0x1558, 0x951d, "Clevo N950T[CDF]", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
9971 	SND_PCI_QUIRK(0x1558, 0x9600, "Clevo N960K[PR]", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
9972 	SND_PCI_QUIRK(0x1558, 0x961d, "Clevo N960S[CDF]", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
9973 	SND_PCI_QUIRK(0x1558, 0x971d, "Clevo N970T[CDF]", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
9974 	SND_PCI_QUIRK(0x1558, 0xa500, "Clevo NL5[03]RU", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
9975 	SND_PCI_QUIRK(0x1558, 0xa600, "Clevo NL50NU", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
9976 	SND_PCI_QUIRK(0x1558, 0xa650, "Clevo NP[567]0SN[CD]", ALC256_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
9977 	SND_PCI_QUIRK(0x1558, 0xa671, "Clevo NP70SN[CDE]", ALC256_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
9978 	SND_PCI_QUIRK(0x1558, 0xb018, "Clevo NP50D[BE]", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
9979 	SND_PCI_QUIRK(0x1558, 0xb019, "Clevo NH77D[BE]Q", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
9980 	SND_PCI_QUIRK(0x1558, 0xb022, "Clevo NH77D[DC][QW]", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
9981 	SND_PCI_QUIRK(0x1558, 0xc018, "Clevo NP50D[BE]", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
9982 	SND_PCI_QUIRK(0x1558, 0xc019, "Clevo NH77D[BE]Q", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
9983 	SND_PCI_QUIRK(0x1558, 0xc022, "Clevo NH77[DC][QW]", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
9984 	SND_PCI_QUIRK(0x17aa, 0x1036, "Lenovo P520", ALC233_FIXUP_LENOVO_MULTI_CODECS),
9985 	SND_PCI_QUIRK(0x17aa, 0x1048, "ThinkCentre Station", ALC623_FIXUP_LENOVO_THINKSTATION_P340),
9986 	SND_PCI_QUIRK(0x17aa, 0x20f2, "Thinkpad SL410/510", ALC269_FIXUP_SKU_IGNORE),
9987 	SND_PCI_QUIRK(0x17aa, 0x215e, "Thinkpad L512", ALC269_FIXUP_SKU_IGNORE),
9988 	SND_PCI_QUIRK(0x17aa, 0x21b8, "Thinkpad Edge 14", ALC269_FIXUP_SKU_IGNORE),
9989 	SND_PCI_QUIRK(0x17aa, 0x21ca, "Thinkpad L412", ALC269_FIXUP_SKU_IGNORE),
9990 	SND_PCI_QUIRK(0x17aa, 0x21e9, "Thinkpad Edge 15", ALC269_FIXUP_SKU_IGNORE),
9991 	SND_PCI_QUIRK(0x17aa, 0x21f3, "Thinkpad T430", ALC269_FIXUP_LENOVO_DOCK),
9992 	SND_PCI_QUIRK(0x17aa, 0x21f6, "Thinkpad T530", ALC269_FIXUP_LENOVO_DOCK_LIMIT_BOOST),
9993 	SND_PCI_QUIRK(0x17aa, 0x21fa, "Thinkpad X230", ALC269_FIXUP_LENOVO_DOCK),
9994 	SND_PCI_QUIRK(0x17aa, 0x21fb, "Thinkpad T430s", ALC269_FIXUP_LENOVO_DOCK),
9995 	SND_PCI_QUIRK(0x17aa, 0x2203, "Thinkpad X230 Tablet", ALC269_FIXUP_LENOVO_DOCK),
9996 	SND_PCI_QUIRK(0x17aa, 0x2208, "Thinkpad T431s", ALC269_FIXUP_LENOVO_DOCK),
9997 	SND_PCI_QUIRK(0x17aa, 0x220c, "Thinkpad T440s", ALC292_FIXUP_TPT440),
9998 	SND_PCI_QUIRK(0x17aa, 0x220e, "Thinkpad T440p", ALC292_FIXUP_TPT440_DOCK),
9999 	SND_PCI_QUIRK(0x17aa, 0x2210, "Thinkpad T540p", ALC292_FIXUP_TPT440_DOCK),
10000 	SND_PCI_QUIRK(0x17aa, 0x2211, "Thinkpad W541", ALC292_FIXUP_TPT440_DOCK),
10001 	SND_PCI_QUIRK(0x17aa, 0x2212, "Thinkpad T440", ALC292_FIXUP_TPT440_DOCK),
10002 	SND_PCI_QUIRK(0x17aa, 0x2214, "Thinkpad X240", ALC292_FIXUP_TPT440_DOCK),
10003 	SND_PCI_QUIRK(0x17aa, 0x2215, "Thinkpad", ALC269_FIXUP_LIMIT_INT_MIC_BOOST),
10004 	SND_PCI_QUIRK(0x17aa, 0x2218, "Thinkpad X1 Carbon 2nd", ALC292_FIXUP_TPT440_DOCK),
10005 	SND_PCI_QUIRK(0x17aa, 0x2223, "ThinkPad T550", ALC292_FIXUP_TPT440_DOCK),
10006 	SND_PCI_QUIRK(0x17aa, 0x2226, "ThinkPad X250", ALC292_FIXUP_TPT440_DOCK),
10007 	SND_PCI_QUIRK(0x17aa, 0x222d, "Thinkpad", ALC298_FIXUP_TPT470_DOCK),
10008 	SND_PCI_QUIRK(0x17aa, 0x222e, "Thinkpad", ALC298_FIXUP_TPT470_DOCK),
10009 	SND_PCI_QUIRK(0x17aa, 0x2231, "Thinkpad T560", ALC292_FIXUP_TPT460),
10010 	SND_PCI_QUIRK(0x17aa, 0x2233, "Thinkpad", ALC292_FIXUP_TPT460),
10011 	SND_PCI_QUIRK(0x17aa, 0x2245, "Thinkpad T470", ALC298_FIXUP_TPT470_DOCK),
10012 	SND_PCI_QUIRK(0x17aa, 0x2246, "Thinkpad", ALC298_FIXUP_TPT470_DOCK),
10013 	SND_PCI_QUIRK(0x17aa, 0x2247, "Thinkpad", ALC298_FIXUP_TPT470_DOCK),
10014 	SND_PCI_QUIRK(0x17aa, 0x2249, "Thinkpad", ALC292_FIXUP_TPT460),
10015 	SND_PCI_QUIRK(0x17aa, 0x224b, "Thinkpad", ALC298_FIXUP_TPT470_DOCK),
10016 	SND_PCI_QUIRK(0x17aa, 0x224c, "Thinkpad", ALC298_FIXUP_TPT470_DOCK),
10017 	SND_PCI_QUIRK(0x17aa, 0x224d, "Thinkpad", ALC298_FIXUP_TPT470_DOCK),
10018 	SND_PCI_QUIRK(0x17aa, 0x225d, "Thinkpad T480", ALC269_FIXUP_LIMIT_INT_MIC_BOOST),
10019 	SND_PCI_QUIRK(0x17aa, 0x2292, "Thinkpad X1 Carbon 7th", ALC285_FIXUP_THINKPAD_HEADSET_JACK),
10020 	SND_PCI_QUIRK(0x17aa, 0x22be, "Thinkpad X1 Carbon 8th", ALC285_FIXUP_THINKPAD_HEADSET_JACK),
10021 	SND_PCI_QUIRK(0x17aa, 0x22c1, "Thinkpad P1 Gen 3", ALC285_FIXUP_THINKPAD_NO_BASS_SPK_HEADSET_JACK),
10022 	SND_PCI_QUIRK(0x17aa, 0x22c2, "Thinkpad X1 Extreme Gen 3", ALC285_FIXUP_THINKPAD_NO_BASS_SPK_HEADSET_JACK),
10023 	SND_PCI_QUIRK(0x17aa, 0x22f1, "Thinkpad", ALC287_FIXUP_MG_RTKC_CSAMP_CS35L41_I2C_THINKPAD),
10024 	SND_PCI_QUIRK(0x17aa, 0x22f2, "Thinkpad", ALC287_FIXUP_MG_RTKC_CSAMP_CS35L41_I2C_THINKPAD),
10025 	SND_PCI_QUIRK(0x17aa, 0x22f3, "Thinkpad", ALC287_FIXUP_MG_RTKC_CSAMP_CS35L41_I2C_THINKPAD),
10026 	SND_PCI_QUIRK(0x17aa, 0x2316, "Thinkpad P1 Gen 6", ALC287_FIXUP_MG_RTKC_CSAMP_CS35L41_I2C_THINKPAD),
10027 	SND_PCI_QUIRK(0x17aa, 0x2317, "Thinkpad P1 Gen 6", ALC287_FIXUP_MG_RTKC_CSAMP_CS35L41_I2C_THINKPAD),
10028 	SND_PCI_QUIRK(0x17aa, 0x2318, "Thinkpad Z13 Gen2", ALC287_FIXUP_MG_RTKC_CSAMP_CS35L41_I2C_THINKPAD),
10029 	SND_PCI_QUIRK(0x17aa, 0x2319, "Thinkpad Z16 Gen2", ALC287_FIXUP_MG_RTKC_CSAMP_CS35L41_I2C_THINKPAD),
10030 	SND_PCI_QUIRK(0x17aa, 0x231a, "Thinkpad Z16 Gen2", ALC287_FIXUP_MG_RTKC_CSAMP_CS35L41_I2C_THINKPAD),
10031 	SND_PCI_QUIRK(0x17aa, 0x30bb, "ThinkCentre AIO", ALC233_FIXUP_LENOVO_LINE2_MIC_HOTKEY),
10032 	SND_PCI_QUIRK(0x17aa, 0x30e2, "ThinkCentre AIO", ALC233_FIXUP_LENOVO_LINE2_MIC_HOTKEY),
10033 	SND_PCI_QUIRK(0x17aa, 0x310c, "ThinkCentre Station", ALC294_FIXUP_LENOVO_MIC_LOCATION),
10034 	SND_PCI_QUIRK(0x17aa, 0x3111, "ThinkCentre Station", ALC294_FIXUP_LENOVO_MIC_LOCATION),
10035 	SND_PCI_QUIRK(0x17aa, 0x312a, "ThinkCentre Station", ALC294_FIXUP_LENOVO_MIC_LOCATION),
10036 	SND_PCI_QUIRK(0x17aa, 0x312f, "ThinkCentre Station", ALC294_FIXUP_LENOVO_MIC_LOCATION),
10037 	SND_PCI_QUIRK(0x17aa, 0x313c, "ThinkCentre Station", ALC294_FIXUP_LENOVO_MIC_LOCATION),
10038 	SND_PCI_QUIRK(0x17aa, 0x3151, "ThinkCentre Station", ALC283_FIXUP_HEADSET_MIC),
10039 	SND_PCI_QUIRK(0x17aa, 0x3176, "ThinkCentre Station", ALC283_FIXUP_HEADSET_MIC),
10040 	SND_PCI_QUIRK(0x17aa, 0x3178, "ThinkCentre Station", ALC283_FIXUP_HEADSET_MIC),
10041 	SND_PCI_QUIRK(0x17aa, 0x31af, "ThinkCentre Station", ALC623_FIXUP_LENOVO_THINKSTATION_P340),
10042 	SND_PCI_QUIRK(0x17aa, 0x3801, "Lenovo Yoga9 14IAP7", ALC287_FIXUP_YOGA9_14IAP7_BASS_SPK_PIN),
10043 	SND_PCI_QUIRK(0x17aa, 0x3802, "Lenovo Yoga DuetITL 2021", ALC287_FIXUP_YOGA7_14ITL_SPEAKERS),
10044 	SND_PCI_QUIRK(0x17aa, 0x3813, "Legion 7i 15IMHG05", ALC287_FIXUP_LEGION_15IMHG05_SPEAKERS),
10045 	SND_PCI_QUIRK(0x17aa, 0x3818, "Lenovo C940 / Yoga Duet 7", ALC298_FIXUP_LENOVO_C940_DUET7),
10046 	SND_PCI_QUIRK(0x17aa, 0x3819, "Lenovo 13s Gen2 ITL", ALC287_FIXUP_13S_GEN2_SPEAKERS),
10047 	SND_PCI_QUIRK(0x17aa, 0x3820, "Yoga Duet 7 13ITL6", ALC287_FIXUP_YOGA7_14ITL_SPEAKERS),
10048 	SND_PCI_QUIRK(0x17aa, 0x3824, "Legion Y9000X 2020", ALC285_FIXUP_LEGION_Y9000X_SPEAKERS),
10049 	SND_PCI_QUIRK(0x17aa, 0x3827, "Ideapad S740", ALC285_FIXUP_IDEAPAD_S740_COEF),
10050 	SND_PCI_QUIRK(0x17aa, 0x3834, "Lenovo IdeaPad Slim 9i 14ITL5", ALC287_FIXUP_YOGA7_14ITL_SPEAKERS),
10051 	SND_PCI_QUIRK(0x17aa, 0x383d, "Legion Y9000X 2019", ALC285_FIXUP_LEGION_Y9000X_SPEAKERS),
10052 	SND_PCI_QUIRK(0x17aa, 0x3843, "Yoga 9i", ALC287_FIXUP_IDEAPAD_BASS_SPK_AMP),
10053 	SND_PCI_QUIRK(0x17aa, 0x3847, "Legion 7 16ACHG6", ALC287_FIXUP_LEGION_16ACHG6),
10054 	SND_PCI_QUIRK(0x17aa, 0x384a, "Lenovo Yoga 7 15ITL5", ALC287_FIXUP_YOGA7_14ITL_SPEAKERS),
10055 	SND_PCI_QUIRK(0x17aa, 0x3852, "Lenovo Yoga 7 14ITL5", ALC287_FIXUP_YOGA7_14ITL_SPEAKERS),
10056 	SND_PCI_QUIRK(0x17aa, 0x3853, "Lenovo Yoga 7 15ITL5", ALC287_FIXUP_YOGA7_14ITL_SPEAKERS),
10057 	SND_PCI_QUIRK(0x17aa, 0x3855, "Legion 7 16ITHG6", ALC287_FIXUP_LEGION_16ITHG6),
10058 	SND_PCI_QUIRK(0x17aa, 0x3869, "Lenovo Yoga7 14IAL7", ALC287_FIXUP_YOGA9_14IAP7_BASS_SPK_PIN),
10059 	SND_PCI_QUIRK(0x17aa, 0x387d, "Yoga S780-16 pro Quad AAC", ALC287_FIXUP_TAS2781_I2C),
10060 	SND_PCI_QUIRK(0x17aa, 0x387e, "Yoga S780-16 pro Quad YC", ALC287_FIXUP_TAS2781_I2C),
10061 	SND_PCI_QUIRK(0x17aa, 0x3881, "YB9 dual power mode2 YC", ALC287_FIXUP_TAS2781_I2C),
10062 	SND_PCI_QUIRK(0x17aa, 0x3884, "Y780 YG DUAL", ALC287_FIXUP_TAS2781_I2C),
10063 	SND_PCI_QUIRK(0x17aa, 0x3886, "Y780 VECO DUAL", ALC287_FIXUP_TAS2781_I2C),
10064 	SND_PCI_QUIRK(0x17aa, 0x38a7, "Y780P AMD YG dual", ALC287_FIXUP_TAS2781_I2C),
10065 	SND_PCI_QUIRK(0x17aa, 0x38a8, "Y780P AMD VECO dual", ALC287_FIXUP_TAS2781_I2C),
10066 	SND_PCI_QUIRK(0x17aa, 0x38ba, "Yoga S780-14.5 Air AMD quad YC", ALC287_FIXUP_TAS2781_I2C),
10067 	SND_PCI_QUIRK(0x17aa, 0x38bb, "Yoga S780-14.5 Air AMD quad AAC", ALC287_FIXUP_TAS2781_I2C),
10068 	SND_PCI_QUIRK(0x17aa, 0x38be, "Yoga S980-14.5 proX YC Dual", ALC287_FIXUP_TAS2781_I2C),
10069 	SND_PCI_QUIRK(0x17aa, 0x38bf, "Yoga S980-14.5 proX LX Dual", ALC287_FIXUP_TAS2781_I2C),
10070 	SND_PCI_QUIRK(0x17aa, 0x38c3, "Y980 DUAL", ALC287_FIXUP_TAS2781_I2C),
10071 	SND_PCI_QUIRK(0x17aa, 0x38cb, "Y790 YG DUAL", ALC287_FIXUP_TAS2781_I2C),
10072 	SND_PCI_QUIRK(0x17aa, 0x38cd, "Y790 VECO DUAL", ALC287_FIXUP_TAS2781_I2C),
10073 	SND_PCI_QUIRK(0x17aa, 0x3902, "Lenovo E50-80", ALC269_FIXUP_DMIC_THINKPAD_ACPI),
10074 	SND_PCI_QUIRK(0x17aa, 0x3977, "IdeaPad S210", ALC283_FIXUP_INT_MIC),
10075 	SND_PCI_QUIRK(0x17aa, 0x3978, "Lenovo B50-70", ALC269_FIXUP_DMIC_THINKPAD_ACPI),
10076 	SND_PCI_QUIRK(0x17aa, 0x3bf8, "Quanta FL1", ALC269_FIXUP_PCM_44K),
10077 	SND_PCI_QUIRK(0x17aa, 0x5013, "Thinkpad", ALC269_FIXUP_LIMIT_INT_MIC_BOOST),
10078 	SND_PCI_QUIRK(0x17aa, 0x501a, "Thinkpad", ALC283_FIXUP_INT_MIC),
10079 	SND_PCI_QUIRK(0x17aa, 0x501e, "Thinkpad L440", ALC292_FIXUP_TPT440_DOCK),
10080 	SND_PCI_QUIRK(0x17aa, 0x5026, "Thinkpad", ALC269_FIXUP_LIMIT_INT_MIC_BOOST),
10081 	SND_PCI_QUIRK(0x17aa, 0x5034, "Thinkpad T450", ALC292_FIXUP_TPT440_DOCK),
10082 	SND_PCI_QUIRK(0x17aa, 0x5036, "Thinkpad T450s", ALC292_FIXUP_TPT440_DOCK),
10083 	SND_PCI_QUIRK(0x17aa, 0x503c, "Thinkpad L450", ALC292_FIXUP_TPT440_DOCK),
10084 	SND_PCI_QUIRK(0x17aa, 0x504a, "ThinkPad X260", ALC292_FIXUP_TPT440_DOCK),
10085 	SND_PCI_QUIRK(0x17aa, 0x504b, "Thinkpad", ALC293_FIXUP_LENOVO_SPK_NOISE),
10086 	SND_PCI_QUIRK(0x17aa, 0x5050, "Thinkpad T560p", ALC292_FIXUP_TPT460),
10087 	SND_PCI_QUIRK(0x17aa, 0x5051, "Thinkpad L460", ALC292_FIXUP_TPT460),
10088 	SND_PCI_QUIRK(0x17aa, 0x5053, "Thinkpad T460", ALC292_FIXUP_TPT460),
10089 	SND_PCI_QUIRK(0x17aa, 0x505d, "Thinkpad", ALC298_FIXUP_TPT470_DOCK),
10090 	SND_PCI_QUIRK(0x17aa, 0x505f, "Thinkpad", ALC298_FIXUP_TPT470_DOCK),
10091 	SND_PCI_QUIRK(0x17aa, 0x5062, "Thinkpad", ALC298_FIXUP_TPT470_DOCK),
10092 	SND_PCI_QUIRK(0x17aa, 0x508b, "Thinkpad X12 Gen 1", ALC287_FIXUP_LEGION_15IMHG05_SPEAKERS),
10093 	SND_PCI_QUIRK(0x17aa, 0x5109, "Thinkpad", ALC269_FIXUP_LIMIT_INT_MIC_BOOST),
10094 	SND_PCI_QUIRK(0x17aa, 0x511e, "Thinkpad", ALC298_FIXUP_TPT470_DOCK),
10095 	SND_PCI_QUIRK(0x17aa, 0x511f, "Thinkpad", ALC298_FIXUP_TPT470_DOCK),
10096 	SND_PCI_QUIRK(0x17aa, 0x9e54, "LENOVO NB", ALC269_FIXUP_LENOVO_EAPD),
10097 	SND_PCI_QUIRK(0x17aa, 0x9e56, "Lenovo ZhaoYang CF4620Z", ALC286_FIXUP_SONY_MIC_NO_PRESENCE),
10098 	SND_PCI_QUIRK(0x1849, 0x1233, "ASRock NUC Box 1100", ALC233_FIXUP_NO_AUDIO_JACK),
10099 	SND_PCI_QUIRK(0x1849, 0xa233, "Positivo Master C6300", ALC269_FIXUP_HEADSET_MIC),
10100 	SND_PCI_QUIRK(0x19e5, 0x3204, "Huawei MACH-WX9", ALC256_FIXUP_HUAWEI_MACH_WX9_PINS),
10101 	SND_PCI_QUIRK(0x19e5, 0x320f, "Huawei WRT-WX9 ", ALC256_FIXUP_ASUS_MIC_NO_PRESENCE),
10102 	SND_PCI_QUIRK(0x1b35, 0x1235, "CZC B20", ALC269_FIXUP_CZC_B20),
10103 	SND_PCI_QUIRK(0x1b35, 0x1236, "CZC TMI", ALC269_FIXUP_CZC_TMI),
10104 	SND_PCI_QUIRK(0x1b35, 0x1237, "CZC L101", ALC269_FIXUP_CZC_L101),
10105 	SND_PCI_QUIRK(0x1b7d, 0xa831, "Ordissimo EVE2 ", ALC269VB_FIXUP_ORDISSIMO_EVE2), /* Also known as Malata PC-B1303 */
10106 	SND_PCI_QUIRK(0x1c06, 0x2013, "Lemote A1802", ALC269_FIXUP_LEMOTE_A1802),
10107 	SND_PCI_QUIRK(0x1c06, 0x2015, "Lemote A190X", ALC269_FIXUP_LEMOTE_A190X),
10108 	SND_PCI_QUIRK(0x1c6c, 0x1251, "Positivo N14KP6-TG", ALC288_FIXUP_DELL1_MIC_NO_PRESENCE),
10109 	SND_PCI_QUIRK(0x1d05, 0x1132, "TongFang PHxTxX1", ALC256_FIXUP_SET_COEF_DEFAULTS),
10110 	SND_PCI_QUIRK(0x1d05, 0x1096, "TongFang GMxMRxx", ALC269_FIXUP_NO_SHUTUP),
10111 	SND_PCI_QUIRK(0x1d05, 0x1100, "TongFang GKxNRxx", ALC269_FIXUP_NO_SHUTUP),
10112 	SND_PCI_QUIRK(0x1d05, 0x1111, "TongFang GMxZGxx", ALC269_FIXUP_NO_SHUTUP),
10113 	SND_PCI_QUIRK(0x1d05, 0x1119, "TongFang GMxZGxx", ALC269_FIXUP_NO_SHUTUP),
10114 	SND_PCI_QUIRK(0x1d05, 0x1129, "TongFang GMxZGxx", ALC269_FIXUP_NO_SHUTUP),
10115 	SND_PCI_QUIRK(0x1d05, 0x1147, "TongFang GMxTGxx", ALC269_FIXUP_NO_SHUTUP),
10116 	SND_PCI_QUIRK(0x1d05, 0x115c, "TongFang GMxTGxx", ALC269_FIXUP_NO_SHUTUP),
10117 	SND_PCI_QUIRK(0x1d05, 0x121b, "TongFang GMxAGxx", ALC269_FIXUP_NO_SHUTUP),
10118 	SND_PCI_QUIRK(0x1d72, 0x1602, "RedmiBook", ALC255_FIXUP_XIAOMI_HEADSET_MIC),
10119 	SND_PCI_QUIRK(0x1d72, 0x1701, "XiaomiNotebook Pro", ALC298_FIXUP_DELL1_MIC_NO_PRESENCE),
10120 	SND_PCI_QUIRK(0x1d72, 0x1901, "RedmiBook 14", ALC256_FIXUP_ASUS_HEADSET_MIC),
10121 	SND_PCI_QUIRK(0x1d72, 0x1945, "Redmi G", ALC256_FIXUP_ASUS_HEADSET_MIC),
10122 	SND_PCI_QUIRK(0x1d72, 0x1947, "RedmiBook Air", ALC255_FIXUP_XIAOMI_HEADSET_MIC),
10123 	SND_PCI_QUIRK(0x8086, 0x2074, "Intel NUC 8", ALC233_FIXUP_INTEL_NUC8_DMIC),
10124 	SND_PCI_QUIRK(0x8086, 0x2080, "Intel NUC 8 Rugged", ALC256_FIXUP_INTEL_NUC8_RUGGED),
10125 	SND_PCI_QUIRK(0x8086, 0x2081, "Intel NUC 10", ALC256_FIXUP_INTEL_NUC10),
10126 	SND_PCI_QUIRK(0x8086, 0x3038, "Intel NUC 13", ALC295_FIXUP_CHROME_BOOK),
10127 	SND_PCI_QUIRK(0xf111, 0x0001, "Framework Laptop", ALC295_FIXUP_FRAMEWORK_LAPTOP_MIC_NO_PRESENCE),
10128 
10129 #if 0
10130 	/* Below is a quirk table taken from the old code.
10131 	 * Basically the device should work as is without the fixup table.
10132 	 * If BIOS doesn't give a proper info, enable the corresponding
10133 	 * fixup entry.
10134 	 */
10135 	SND_PCI_QUIRK(0x1043, 0x8330, "ASUS Eeepc P703 P900A",
10136 		      ALC269_FIXUP_AMIC),
10137 	SND_PCI_QUIRK(0x1043, 0x1013, "ASUS N61Da", ALC269_FIXUP_AMIC),
10138 	SND_PCI_QUIRK(0x1043, 0x1143, "ASUS B53f", ALC269_FIXUP_AMIC),
10139 	SND_PCI_QUIRK(0x1043, 0x1133, "ASUS UJ20ft", ALC269_FIXUP_AMIC),
10140 	SND_PCI_QUIRK(0x1043, 0x1183, "ASUS K72DR", ALC269_FIXUP_AMIC),
10141 	SND_PCI_QUIRK(0x1043, 0x11b3, "ASUS K52DR", ALC269_FIXUP_AMIC),
10142 	SND_PCI_QUIRK(0x1043, 0x11e3, "ASUS U33Jc", ALC269_FIXUP_AMIC),
10143 	SND_PCI_QUIRK(0x1043, 0x1273, "ASUS UL80Jt", ALC269_FIXUP_AMIC),
10144 	SND_PCI_QUIRK(0x1043, 0x1283, "ASUS U53Jc", ALC269_FIXUP_AMIC),
10145 	SND_PCI_QUIRK(0x1043, 0x12b3, "ASUS N82JV", ALC269_FIXUP_AMIC),
10146 	SND_PCI_QUIRK(0x1043, 0x12d3, "ASUS N61Jv", ALC269_FIXUP_AMIC),
10147 	SND_PCI_QUIRK(0x1043, 0x13a3, "ASUS UL30Vt", ALC269_FIXUP_AMIC),
10148 	SND_PCI_QUIRK(0x1043, 0x1373, "ASUS G73JX", ALC269_FIXUP_AMIC),
10149 	SND_PCI_QUIRK(0x1043, 0x1383, "ASUS UJ30Jc", ALC269_FIXUP_AMIC),
10150 	SND_PCI_QUIRK(0x1043, 0x13d3, "ASUS N61JA", ALC269_FIXUP_AMIC),
10151 	SND_PCI_QUIRK(0x1043, 0x1413, "ASUS UL50", ALC269_FIXUP_AMIC),
10152 	SND_PCI_QUIRK(0x1043, 0x1443, "ASUS UL30", ALC269_FIXUP_AMIC),
10153 	SND_PCI_QUIRK(0x1043, 0x1453, "ASUS M60Jv", ALC269_FIXUP_AMIC),
10154 	SND_PCI_QUIRK(0x1043, 0x1483, "ASUS UL80", ALC269_FIXUP_AMIC),
10155 	SND_PCI_QUIRK(0x1043, 0x14f3, "ASUS F83Vf", ALC269_FIXUP_AMIC),
10156 	SND_PCI_QUIRK(0x1043, 0x14e3, "ASUS UL20", ALC269_FIXUP_AMIC),
10157 	SND_PCI_QUIRK(0x1043, 0x1513, "ASUS UX30", ALC269_FIXUP_AMIC),
10158 	SND_PCI_QUIRK(0x1043, 0x1593, "ASUS N51Vn", ALC269_FIXUP_AMIC),
10159 	SND_PCI_QUIRK(0x1043, 0x15a3, "ASUS N60Jv", ALC269_FIXUP_AMIC),
10160 	SND_PCI_QUIRK(0x1043, 0x15b3, "ASUS N60Dp", ALC269_FIXUP_AMIC),
10161 	SND_PCI_QUIRK(0x1043, 0x15c3, "ASUS N70De", ALC269_FIXUP_AMIC),
10162 	SND_PCI_QUIRK(0x1043, 0x15e3, "ASUS F83T", ALC269_FIXUP_AMIC),
10163 	SND_PCI_QUIRK(0x1043, 0x1643, "ASUS M60J", ALC269_FIXUP_AMIC),
10164 	SND_PCI_QUIRK(0x1043, 0x1653, "ASUS U50", ALC269_FIXUP_AMIC),
10165 	SND_PCI_QUIRK(0x1043, 0x1693, "ASUS F50N", ALC269_FIXUP_AMIC),
10166 	SND_PCI_QUIRK(0x1043, 0x16a3, "ASUS F5Q", ALC269_FIXUP_AMIC),
10167 	SND_PCI_QUIRK(0x1043, 0x1723, "ASUS P80", ALC269_FIXUP_AMIC),
10168 	SND_PCI_QUIRK(0x1043, 0x1743, "ASUS U80", ALC269_FIXUP_AMIC),
10169 	SND_PCI_QUIRK(0x1043, 0x1773, "ASUS U20A", ALC269_FIXUP_AMIC),
10170 	SND_PCI_QUIRK(0x1043, 0x1883, "ASUS F81Se", ALC269_FIXUP_AMIC),
10171 	SND_PCI_QUIRK(0x152d, 0x1778, "Quanta ON1", ALC269_FIXUP_DMIC),
10172 	SND_PCI_QUIRK(0x17aa, 0x3be9, "Quanta Wistron", ALC269_FIXUP_AMIC),
10173 	SND_PCI_QUIRK(0x17aa, 0x3bf8, "Quanta FL1", ALC269_FIXUP_AMIC),
10174 	SND_PCI_QUIRK(0x17ff, 0x059a, "Quanta EL3", ALC269_FIXUP_DMIC),
10175 	SND_PCI_QUIRK(0x17ff, 0x059b, "Quanta JR1", ALC269_FIXUP_DMIC),
10176 #endif
10177 	{}
10178 };
10179 
10180 static const struct snd_pci_quirk alc269_fixup_vendor_tbl[] = {
10181 	SND_PCI_QUIRK_VENDOR(0x1025, "Acer Aspire", ALC271_FIXUP_DMIC),
10182 	SND_PCI_QUIRK_VENDOR(0x103c, "HP", ALC269_FIXUP_HP_MUTE_LED),
10183 	SND_PCI_QUIRK_VENDOR(0x104d, "Sony VAIO", ALC269_FIXUP_SONY_VAIO),
10184 	SND_PCI_QUIRK_VENDOR(0x17aa, "Thinkpad", ALC269_FIXUP_THINKPAD_ACPI),
10185 	SND_PCI_QUIRK_VENDOR(0x19e5, "Huawei Matebook", ALC255_FIXUP_MIC_MUTE_LED),
10186 	{}
10187 };
10188 
10189 static const struct hda_model_fixup alc269_fixup_models[] = {
10190 	{.id = ALC269_FIXUP_AMIC, .name = "laptop-amic"},
10191 	{.id = ALC269_FIXUP_DMIC, .name = "laptop-dmic"},
10192 	{.id = ALC269_FIXUP_STEREO_DMIC, .name = "alc269-dmic"},
10193 	{.id = ALC271_FIXUP_DMIC, .name = "alc271-dmic"},
10194 	{.id = ALC269_FIXUP_INV_DMIC, .name = "inv-dmic"},
10195 	{.id = ALC269_FIXUP_HEADSET_MIC, .name = "headset-mic"},
10196 	{.id = ALC269_FIXUP_HEADSET_MODE, .name = "headset-mode"},
10197 	{.id = ALC269_FIXUP_HEADSET_MODE_NO_HP_MIC, .name = "headset-mode-no-hp-mic"},
10198 	{.id = ALC269_FIXUP_LENOVO_DOCK, .name = "lenovo-dock"},
10199 	{.id = ALC269_FIXUP_LENOVO_DOCK_LIMIT_BOOST, .name = "lenovo-dock-limit-boost"},
10200 	{.id = ALC269_FIXUP_HP_GPIO_LED, .name = "hp-gpio-led"},
10201 	{.id = ALC269_FIXUP_HP_DOCK_GPIO_MIC1_LED, .name = "hp-dock-gpio-mic1-led"},
10202 	{.id = ALC269_FIXUP_DELL1_MIC_NO_PRESENCE, .name = "dell-headset-multi"},
10203 	{.id = ALC269_FIXUP_DELL2_MIC_NO_PRESENCE, .name = "dell-headset-dock"},
10204 	{.id = ALC269_FIXUP_DELL3_MIC_NO_PRESENCE, .name = "dell-headset3"},
10205 	{.id = ALC269_FIXUP_DELL4_MIC_NO_PRESENCE, .name = "dell-headset4"},
10206 	{.id = ALC283_FIXUP_CHROME_BOOK, .name = "alc283-dac-wcaps"},
10207 	{.id = ALC283_FIXUP_SENSE_COMBO_JACK, .name = "alc283-sense-combo"},
10208 	{.id = ALC292_FIXUP_TPT440_DOCK, .name = "tpt440-dock"},
10209 	{.id = ALC292_FIXUP_TPT440, .name = "tpt440"},
10210 	{.id = ALC292_FIXUP_TPT460, .name = "tpt460"},
10211 	{.id = ALC298_FIXUP_TPT470_DOCK_FIX, .name = "tpt470-dock-fix"},
10212 	{.id = ALC298_FIXUP_TPT470_DOCK, .name = "tpt470-dock"},
10213 	{.id = ALC233_FIXUP_LENOVO_MULTI_CODECS, .name = "dual-codecs"},
10214 	{.id = ALC700_FIXUP_INTEL_REFERENCE, .name = "alc700-ref"},
10215 	{.id = ALC269_FIXUP_SONY_VAIO, .name = "vaio"},
10216 	{.id = ALC269_FIXUP_DELL_M101Z, .name = "dell-m101z"},
10217 	{.id = ALC269_FIXUP_ASUS_G73JW, .name = "asus-g73jw"},
10218 	{.id = ALC269_FIXUP_LENOVO_EAPD, .name = "lenovo-eapd"},
10219 	{.id = ALC275_FIXUP_SONY_HWEQ, .name = "sony-hweq"},
10220 	{.id = ALC269_FIXUP_PCM_44K, .name = "pcm44k"},
10221 	{.id = ALC269_FIXUP_LIFEBOOK, .name = "lifebook"},
10222 	{.id = ALC269_FIXUP_LIFEBOOK_EXTMIC, .name = "lifebook-extmic"},
10223 	{.id = ALC269_FIXUP_LIFEBOOK_HP_PIN, .name = "lifebook-hp-pin"},
10224 	{.id = ALC255_FIXUP_LIFEBOOK_U7x7_HEADSET_MIC, .name = "lifebook-u7x7"},
10225 	{.id = ALC269VB_FIXUP_AMIC, .name = "alc269vb-amic"},
10226 	{.id = ALC269VB_FIXUP_DMIC, .name = "alc269vb-dmic"},
10227 	{.id = ALC269_FIXUP_HP_MUTE_LED_MIC1, .name = "hp-mute-led-mic1"},
10228 	{.id = ALC269_FIXUP_HP_MUTE_LED_MIC2, .name = "hp-mute-led-mic2"},
10229 	{.id = ALC269_FIXUP_HP_MUTE_LED_MIC3, .name = "hp-mute-led-mic3"},
10230 	{.id = ALC269_FIXUP_HP_GPIO_MIC1_LED, .name = "hp-gpio-mic1"},
10231 	{.id = ALC269_FIXUP_HP_LINE1_MIC1_LED, .name = "hp-line1-mic1"},
10232 	{.id = ALC269_FIXUP_NO_SHUTUP, .name = "noshutup"},
10233 	{.id = ALC286_FIXUP_SONY_MIC_NO_PRESENCE, .name = "sony-nomic"},
10234 	{.id = ALC269_FIXUP_ASPIRE_HEADSET_MIC, .name = "aspire-headset-mic"},
10235 	{.id = ALC269_FIXUP_ASUS_X101, .name = "asus-x101"},
10236 	{.id = ALC271_FIXUP_HP_GATE_MIC_JACK, .name = "acer-ao7xx"},
10237 	{.id = ALC271_FIXUP_HP_GATE_MIC_JACK_E1_572, .name = "acer-aspire-e1"},
10238 	{.id = ALC269_FIXUP_ACER_AC700, .name = "acer-ac700"},
10239 	{.id = ALC269_FIXUP_LIMIT_INT_MIC_BOOST, .name = "limit-mic-boost"},
10240 	{.id = ALC269VB_FIXUP_ASUS_ZENBOOK, .name = "asus-zenbook"},
10241 	{.id = ALC269VB_FIXUP_ASUS_ZENBOOK_UX31A, .name = "asus-zenbook-ux31a"},
10242 	{.id = ALC269VB_FIXUP_ORDISSIMO_EVE2, .name = "ordissimo"},
10243 	{.id = ALC282_FIXUP_ASUS_TX300, .name = "asus-tx300"},
10244 	{.id = ALC283_FIXUP_INT_MIC, .name = "alc283-int-mic"},
10245 	{.id = ALC290_FIXUP_MONO_SPEAKERS_HSJACK, .name = "mono-speakers"},
10246 	{.id = ALC290_FIXUP_SUBWOOFER_HSJACK, .name = "alc290-subwoofer"},
10247 	{.id = ALC269_FIXUP_THINKPAD_ACPI, .name = "thinkpad"},
10248 	{.id = ALC269_FIXUP_DMIC_THINKPAD_ACPI, .name = "dmic-thinkpad"},
10249 	{.id = ALC255_FIXUP_ACER_MIC_NO_PRESENCE, .name = "alc255-acer"},
10250 	{.id = ALC255_FIXUP_ASUS_MIC_NO_PRESENCE, .name = "alc255-asus"},
10251 	{.id = ALC255_FIXUP_DELL1_MIC_NO_PRESENCE, .name = "alc255-dell1"},
10252 	{.id = ALC255_FIXUP_DELL2_MIC_NO_PRESENCE, .name = "alc255-dell2"},
10253 	{.id = ALC293_FIXUP_DELL1_MIC_NO_PRESENCE, .name = "alc293-dell1"},
10254 	{.id = ALC283_FIXUP_HEADSET_MIC, .name = "alc283-headset"},
10255 	{.id = ALC255_FIXUP_MIC_MUTE_LED, .name = "alc255-dell-mute"},
10256 	{.id = ALC282_FIXUP_ASPIRE_V5_PINS, .name = "aspire-v5"},
10257 	{.id = ALC269VB_FIXUP_ASPIRE_E1_COEF, .name = "aspire-e1-coef"},
10258 	{.id = ALC280_FIXUP_HP_GPIO4, .name = "hp-gpio4"},
10259 	{.id = ALC286_FIXUP_HP_GPIO_LED, .name = "hp-gpio-led"},
10260 	{.id = ALC280_FIXUP_HP_GPIO2_MIC_HOTKEY, .name = "hp-gpio2-hotkey"},
10261 	{.id = ALC280_FIXUP_HP_DOCK_PINS, .name = "hp-dock-pins"},
10262 	{.id = ALC269_FIXUP_HP_DOCK_GPIO_MIC1_LED, .name = "hp-dock-gpio-mic"},
10263 	{.id = ALC280_FIXUP_HP_9480M, .name = "hp-9480m"},
10264 	{.id = ALC288_FIXUP_DELL_HEADSET_MODE, .name = "alc288-dell-headset"},
10265 	{.id = ALC288_FIXUP_DELL1_MIC_NO_PRESENCE, .name = "alc288-dell1"},
10266 	{.id = ALC288_FIXUP_DELL_XPS_13, .name = "alc288-dell-xps13"},
10267 	{.id = ALC292_FIXUP_DELL_E7X, .name = "dell-e7x"},
10268 	{.id = ALC293_FIXUP_DISABLE_AAMIX_MULTIJACK, .name = "alc293-dell"},
10269 	{.id = ALC298_FIXUP_DELL1_MIC_NO_PRESENCE, .name = "alc298-dell1"},
10270 	{.id = ALC298_FIXUP_DELL_AIO_MIC_NO_PRESENCE, .name = "alc298-dell-aio"},
10271 	{.id = ALC275_FIXUP_DELL_XPS, .name = "alc275-dell-xps"},
10272 	{.id = ALC293_FIXUP_LENOVO_SPK_NOISE, .name = "lenovo-spk-noise"},
10273 	{.id = ALC233_FIXUP_LENOVO_LINE2_MIC_HOTKEY, .name = "lenovo-hotkey"},
10274 	{.id = ALC255_FIXUP_DELL_SPK_NOISE, .name = "dell-spk-noise"},
10275 	{.id = ALC225_FIXUP_DELL1_MIC_NO_PRESENCE, .name = "alc225-dell1"},
10276 	{.id = ALC295_FIXUP_DISABLE_DAC3, .name = "alc295-disable-dac3"},
10277 	{.id = ALC285_FIXUP_SPEAKER2_TO_DAC1, .name = "alc285-speaker2-to-dac1"},
10278 	{.id = ALC280_FIXUP_HP_HEADSET_MIC, .name = "alc280-hp-headset"},
10279 	{.id = ALC221_FIXUP_HP_FRONT_MIC, .name = "alc221-hp-mic"},
10280 	{.id = ALC298_FIXUP_SPK_VOLUME, .name = "alc298-spk-volume"},
10281 	{.id = ALC256_FIXUP_DELL_INSPIRON_7559_SUBWOOFER, .name = "dell-inspiron-7559"},
10282 	{.id = ALC269_FIXUP_ATIV_BOOK_8, .name = "ativ-book"},
10283 	{.id = ALC221_FIXUP_HP_MIC_NO_PRESENCE, .name = "alc221-hp-mic"},
10284 	{.id = ALC256_FIXUP_ASUS_HEADSET_MODE, .name = "alc256-asus-headset"},
10285 	{.id = ALC256_FIXUP_ASUS_MIC, .name = "alc256-asus-mic"},
10286 	{.id = ALC256_FIXUP_ASUS_AIO_GPIO2, .name = "alc256-asus-aio"},
10287 	{.id = ALC233_FIXUP_ASUS_MIC_NO_PRESENCE, .name = "alc233-asus"},
10288 	{.id = ALC233_FIXUP_EAPD_COEF_AND_MIC_NO_PRESENCE, .name = "alc233-eapd"},
10289 	{.id = ALC294_FIXUP_LENOVO_MIC_LOCATION, .name = "alc294-lenovo-mic"},
10290 	{.id = ALC225_FIXUP_DELL_WYSE_MIC_NO_PRESENCE, .name = "alc225-wyse"},
10291 	{.id = ALC274_FIXUP_DELL_AIO_LINEOUT_VERB, .name = "alc274-dell-aio"},
10292 	{.id = ALC255_FIXUP_DUMMY_LINEOUT_VERB, .name = "alc255-dummy-lineout"},
10293 	{.id = ALC255_FIXUP_DELL_HEADSET_MIC, .name = "alc255-dell-headset"},
10294 	{.id = ALC295_FIXUP_HP_X360, .name = "alc295-hp-x360"},
10295 	{.id = ALC225_FIXUP_HEADSET_JACK, .name = "alc-headset-jack"},
10296 	{.id = ALC295_FIXUP_CHROME_BOOK, .name = "alc-chrome-book"},
10297 	{.id = ALC299_FIXUP_PREDATOR_SPK, .name = "predator-spk"},
10298 	{.id = ALC298_FIXUP_HUAWEI_MBX_STEREO, .name = "huawei-mbx-stereo"},
10299 	{.id = ALC256_FIXUP_MEDION_HEADSET_NO_PRESENCE, .name = "alc256-medion-headset"},
10300 	{.id = ALC298_FIXUP_SAMSUNG_AMP, .name = "alc298-samsung-amp"},
10301 	{.id = ALC256_FIXUP_SAMSUNG_HEADPHONE_VERY_QUIET, .name = "alc256-samsung-headphone"},
10302 	{.id = ALC255_FIXUP_XIAOMI_HEADSET_MIC, .name = "alc255-xiaomi-headset"},
10303 	{.id = ALC274_FIXUP_HP_MIC, .name = "alc274-hp-mic-detect"},
10304 	{.id = ALC245_FIXUP_HP_X360_AMP, .name = "alc245-hp-x360-amp"},
10305 	{.id = ALC295_FIXUP_HP_OMEN, .name = "alc295-hp-omen"},
10306 	{.id = ALC285_FIXUP_HP_SPECTRE_X360, .name = "alc285-hp-spectre-x360"},
10307 	{.id = ALC285_FIXUP_HP_SPECTRE_X360_EB1, .name = "alc285-hp-spectre-x360-eb1"},
10308 	{.id = ALC287_FIXUP_IDEAPAD_BASS_SPK_AMP, .name = "alc287-ideapad-bass-spk-amp"},
10309 	{.id = ALC287_FIXUP_YOGA9_14IAP7_BASS_SPK_PIN, .name = "alc287-yoga9-bass-spk-pin"},
10310 	{.id = ALC623_FIXUP_LENOVO_THINKSTATION_P340, .name = "alc623-lenovo-thinkstation-p340"},
10311 	{.id = ALC255_FIXUP_ACER_HEADPHONE_AND_MIC, .name = "alc255-acer-headphone-and-mic"},
10312 	{.id = ALC285_FIXUP_HP_GPIO_AMP_INIT, .name = "alc285-hp-amp-init"},
10313 	{}
10314 };
10315 #define ALC225_STANDARD_PINS \
10316 	{0x21, 0x04211020}
10317 
10318 #define ALC256_STANDARD_PINS \
10319 	{0x12, 0x90a60140}, \
10320 	{0x14, 0x90170110}, \
10321 	{0x21, 0x02211020}
10322 
10323 #define ALC282_STANDARD_PINS \
10324 	{0x14, 0x90170110}
10325 
10326 #define ALC290_STANDARD_PINS \
10327 	{0x12, 0x99a30130}
10328 
10329 #define ALC292_STANDARD_PINS \
10330 	{0x14, 0x90170110}, \
10331 	{0x15, 0x0221401f}
10332 
10333 #define ALC295_STANDARD_PINS \
10334 	{0x12, 0xb7a60130}, \
10335 	{0x14, 0x90170110}, \
10336 	{0x21, 0x04211020}
10337 
10338 #define ALC298_STANDARD_PINS \
10339 	{0x12, 0x90a60130}, \
10340 	{0x21, 0x03211020}
10341 
10342 static const struct snd_hda_pin_quirk alc269_pin_fixup_tbl[] = {
10343 	SND_HDA_PIN_QUIRK(0x10ec0221, 0x103c, "HP Workstation", ALC221_FIXUP_HP_HEADSET_MIC,
10344 		{0x14, 0x01014020},
10345 		{0x17, 0x90170110},
10346 		{0x18, 0x02a11030},
10347 		{0x19, 0x0181303F},
10348 		{0x21, 0x0221102f}),
10349 	SND_HDA_PIN_QUIRK(0x10ec0255, 0x1025, "Acer", ALC255_FIXUP_ACER_MIC_NO_PRESENCE,
10350 		{0x12, 0x90a601c0},
10351 		{0x14, 0x90171120},
10352 		{0x21, 0x02211030}),
10353 	SND_HDA_PIN_QUIRK(0x10ec0255, 0x1043, "ASUS", ALC255_FIXUP_ASUS_MIC_NO_PRESENCE,
10354 		{0x14, 0x90170110},
10355 		{0x1b, 0x90a70130},
10356 		{0x21, 0x03211020}),
10357 	SND_HDA_PIN_QUIRK(0x10ec0255, 0x1043, "ASUS", ALC255_FIXUP_ASUS_MIC_NO_PRESENCE,
10358 		{0x1a, 0x90a70130},
10359 		{0x1b, 0x90170110},
10360 		{0x21, 0x03211020}),
10361 	SND_HDA_PIN_QUIRK(0x10ec0225, 0x1028, "Dell", ALC225_FIXUP_DELL1_MIC_NO_PRESENCE,
10362 		ALC225_STANDARD_PINS,
10363 		{0x12, 0xb7a60130},
10364 		{0x14, 0x901701a0}),
10365 	SND_HDA_PIN_QUIRK(0x10ec0225, 0x1028, "Dell", ALC225_FIXUP_DELL1_MIC_NO_PRESENCE,
10366 		ALC225_STANDARD_PINS,
10367 		{0x12, 0xb7a60130},
10368 		{0x14, 0x901701b0}),
10369 	SND_HDA_PIN_QUIRK(0x10ec0225, 0x1028, "Dell", ALC225_FIXUP_DELL1_MIC_NO_PRESENCE,
10370 		ALC225_STANDARD_PINS,
10371 		{0x12, 0xb7a60150},
10372 		{0x14, 0x901701a0}),
10373 	SND_HDA_PIN_QUIRK(0x10ec0225, 0x1028, "Dell", ALC225_FIXUP_DELL1_MIC_NO_PRESENCE,
10374 		ALC225_STANDARD_PINS,
10375 		{0x12, 0xb7a60150},
10376 		{0x14, 0x901701b0}),
10377 	SND_HDA_PIN_QUIRK(0x10ec0225, 0x1028, "Dell", ALC225_FIXUP_DELL1_MIC_NO_PRESENCE,
10378 		ALC225_STANDARD_PINS,
10379 		{0x12, 0xb7a60130},
10380 		{0x1b, 0x90170110}),
10381 	SND_HDA_PIN_QUIRK(0x10ec0233, 0x8086, "Intel NUC Skull Canyon", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE,
10382 		{0x1b, 0x01111010},
10383 		{0x1e, 0x01451130},
10384 		{0x21, 0x02211020}),
10385 	SND_HDA_PIN_QUIRK(0x10ec0235, 0x17aa, "Lenovo", ALC233_FIXUP_LENOVO_LINE2_MIC_HOTKEY,
10386 		{0x12, 0x90a60140},
10387 		{0x14, 0x90170110},
10388 		{0x19, 0x02a11030},
10389 		{0x21, 0x02211020}),
10390 	SND_HDA_PIN_QUIRK(0x10ec0235, 0x17aa, "Lenovo", ALC294_FIXUP_LENOVO_MIC_LOCATION,
10391 		{0x14, 0x90170110},
10392 		{0x19, 0x02a11030},
10393 		{0x1a, 0x02a11040},
10394 		{0x1b, 0x01014020},
10395 		{0x21, 0x0221101f}),
10396 	SND_HDA_PIN_QUIRK(0x10ec0235, 0x17aa, "Lenovo", ALC294_FIXUP_LENOVO_MIC_LOCATION,
10397 		{0x14, 0x90170110},
10398 		{0x19, 0x02a11030},
10399 		{0x1a, 0x02a11040},
10400 		{0x1b, 0x01011020},
10401 		{0x21, 0x0221101f}),
10402 	SND_HDA_PIN_QUIRK(0x10ec0235, 0x17aa, "Lenovo", ALC294_FIXUP_LENOVO_MIC_LOCATION,
10403 		{0x14, 0x90170110},
10404 		{0x19, 0x02a11020},
10405 		{0x1a, 0x02a11030},
10406 		{0x21, 0x0221101f}),
10407 	SND_HDA_PIN_QUIRK(0x10ec0236, 0x1028, "Dell", ALC236_FIXUP_DELL_AIO_HEADSET_MIC,
10408 		{0x21, 0x02211010}),
10409 	SND_HDA_PIN_QUIRK(0x10ec0236, 0x103c, "HP", ALC256_FIXUP_HP_HEADSET_MIC,
10410 		{0x14, 0x90170110},
10411 		{0x19, 0x02a11020},
10412 		{0x21, 0x02211030}),
10413 	SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL2_MIC_NO_PRESENCE,
10414 		{0x14, 0x90170110},
10415 		{0x21, 0x02211020}),
10416 	SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
10417 		{0x14, 0x90170130},
10418 		{0x21, 0x02211040}),
10419 	SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
10420 		{0x12, 0x90a60140},
10421 		{0x14, 0x90170110},
10422 		{0x21, 0x02211020}),
10423 	SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
10424 		{0x12, 0x90a60160},
10425 		{0x14, 0x90170120},
10426 		{0x21, 0x02211030}),
10427 	SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
10428 		{0x14, 0x90170110},
10429 		{0x1b, 0x02011020},
10430 		{0x21, 0x0221101f}),
10431 	SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
10432 		{0x14, 0x90170110},
10433 		{0x1b, 0x01011020},
10434 		{0x21, 0x0221101f}),
10435 	SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
10436 		{0x14, 0x90170130},
10437 		{0x1b, 0x01014020},
10438 		{0x21, 0x0221103f}),
10439 	SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
10440 		{0x14, 0x90170130},
10441 		{0x1b, 0x01011020},
10442 		{0x21, 0x0221103f}),
10443 	SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
10444 		{0x14, 0x90170130},
10445 		{0x1b, 0x02011020},
10446 		{0x21, 0x0221103f}),
10447 	SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
10448 		{0x14, 0x90170150},
10449 		{0x1b, 0x02011020},
10450 		{0x21, 0x0221105f}),
10451 	SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
10452 		{0x14, 0x90170110},
10453 		{0x1b, 0x01014020},
10454 		{0x21, 0x0221101f}),
10455 	SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
10456 		{0x12, 0x90a60160},
10457 		{0x14, 0x90170120},
10458 		{0x17, 0x90170140},
10459 		{0x21, 0x0321102f}),
10460 	SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
10461 		{0x12, 0x90a60160},
10462 		{0x14, 0x90170130},
10463 		{0x21, 0x02211040}),
10464 	SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
10465 		{0x12, 0x90a60160},
10466 		{0x14, 0x90170140},
10467 		{0x21, 0x02211050}),
10468 	SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
10469 		{0x12, 0x90a60170},
10470 		{0x14, 0x90170120},
10471 		{0x21, 0x02211030}),
10472 	SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
10473 		{0x12, 0x90a60170},
10474 		{0x14, 0x90170130},
10475 		{0x21, 0x02211040}),
10476 	SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
10477 		{0x12, 0x90a60170},
10478 		{0x14, 0x90171130},
10479 		{0x21, 0x02211040}),
10480 	SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
10481 		{0x12, 0x90a60170},
10482 		{0x14, 0x90170140},
10483 		{0x21, 0x02211050}),
10484 	SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell Inspiron 5548", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
10485 		{0x12, 0x90a60180},
10486 		{0x14, 0x90170130},
10487 		{0x21, 0x02211040}),
10488 	SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell Inspiron 5565", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
10489 		{0x12, 0x90a60180},
10490 		{0x14, 0x90170120},
10491 		{0x21, 0x02211030}),
10492 	SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
10493 		{0x1b, 0x01011020},
10494 		{0x21, 0x02211010}),
10495 	SND_HDA_PIN_QUIRK(0x10ec0256, 0x1043, "ASUS", ALC256_FIXUP_ASUS_MIC,
10496 		{0x14, 0x90170110},
10497 		{0x1b, 0x90a70130},
10498 		{0x21, 0x04211020}),
10499 	SND_HDA_PIN_QUIRK(0x10ec0256, 0x1043, "ASUS", ALC256_FIXUP_ASUS_MIC,
10500 		{0x14, 0x90170110},
10501 		{0x1b, 0x90a70130},
10502 		{0x21, 0x03211020}),
10503 	SND_HDA_PIN_QUIRK(0x10ec0256, 0x1043, "ASUS", ALC256_FIXUP_ASUS_MIC_NO_PRESENCE,
10504 		{0x12, 0x90a60130},
10505 		{0x14, 0x90170110},
10506 		{0x21, 0x03211020}),
10507 	SND_HDA_PIN_QUIRK(0x10ec0256, 0x1043, "ASUS", ALC256_FIXUP_ASUS_MIC_NO_PRESENCE,
10508 		{0x12, 0x90a60130},
10509 		{0x14, 0x90170110},
10510 		{0x21, 0x04211020}),
10511 	SND_HDA_PIN_QUIRK(0x10ec0256, 0x1043, "ASUS", ALC256_FIXUP_ASUS_MIC_NO_PRESENCE,
10512 		{0x1a, 0x90a70130},
10513 		{0x1b, 0x90170110},
10514 		{0x21, 0x03211020}),
10515        SND_HDA_PIN_QUIRK(0x10ec0256, 0x103c, "HP", ALC256_FIXUP_HP_HEADSET_MIC,
10516 		{0x14, 0x90170110},
10517 		{0x19, 0x02a11020},
10518 		{0x21, 0x0221101f}),
10519        SND_HDA_PIN_QUIRK(0x10ec0274, 0x103c, "HP", ALC274_FIXUP_HP_HEADSET_MIC,
10520 		{0x17, 0x90170110},
10521 		{0x19, 0x03a11030},
10522 		{0x21, 0x03211020}),
10523 	SND_HDA_PIN_QUIRK(0x10ec0280, 0x103c, "HP", ALC280_FIXUP_HP_GPIO4,
10524 		{0x12, 0x90a60130},
10525 		{0x14, 0x90170110},
10526 		{0x15, 0x0421101f},
10527 		{0x1a, 0x04a11020}),
10528 	SND_HDA_PIN_QUIRK(0x10ec0280, 0x103c, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED,
10529 		{0x12, 0x90a60140},
10530 		{0x14, 0x90170110},
10531 		{0x15, 0x0421101f},
10532 		{0x18, 0x02811030},
10533 		{0x1a, 0x04a1103f},
10534 		{0x1b, 0x02011020}),
10535 	SND_HDA_PIN_QUIRK(0x10ec0282, 0x103c, "HP 15 Touchsmart", ALC269_FIXUP_HP_MUTE_LED_MIC1,
10536 		ALC282_STANDARD_PINS,
10537 		{0x12, 0x99a30130},
10538 		{0x19, 0x03a11020},
10539 		{0x21, 0x0321101f}),
10540 	SND_HDA_PIN_QUIRK(0x10ec0282, 0x103c, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1,
10541 		ALC282_STANDARD_PINS,
10542 		{0x12, 0x99a30130},
10543 		{0x19, 0x03a11020},
10544 		{0x21, 0x03211040}),
10545 	SND_HDA_PIN_QUIRK(0x10ec0282, 0x103c, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1,
10546 		ALC282_STANDARD_PINS,
10547 		{0x12, 0x99a30130},
10548 		{0x19, 0x03a11030},
10549 		{0x21, 0x03211020}),
10550 	SND_HDA_PIN_QUIRK(0x10ec0282, 0x103c, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1,
10551 		ALC282_STANDARD_PINS,
10552 		{0x12, 0x99a30130},
10553 		{0x19, 0x04a11020},
10554 		{0x21, 0x0421101f}),
10555 	SND_HDA_PIN_QUIRK(0x10ec0282, 0x103c, "HP", ALC269_FIXUP_HP_LINE1_MIC1_LED,
10556 		ALC282_STANDARD_PINS,
10557 		{0x12, 0x90a60140},
10558 		{0x19, 0x04a11030},
10559 		{0x21, 0x04211020}),
10560 	SND_HDA_PIN_QUIRK(0x10ec0282, 0x1025, "Acer", ALC282_FIXUP_ACER_DISABLE_LINEOUT,
10561 		ALC282_STANDARD_PINS,
10562 		{0x12, 0x90a609c0},
10563 		{0x18, 0x03a11830},
10564 		{0x19, 0x04a19831},
10565 		{0x1a, 0x0481303f},
10566 		{0x1b, 0x04211020},
10567 		{0x21, 0x0321101f}),
10568 	SND_HDA_PIN_QUIRK(0x10ec0282, 0x1025, "Acer", ALC282_FIXUP_ACER_DISABLE_LINEOUT,
10569 		ALC282_STANDARD_PINS,
10570 		{0x12, 0x90a60940},
10571 		{0x18, 0x03a11830},
10572 		{0x19, 0x04a19831},
10573 		{0x1a, 0x0481303f},
10574 		{0x1b, 0x04211020},
10575 		{0x21, 0x0321101f}),
10576 	SND_HDA_PIN_QUIRK(0x10ec0283, 0x1028, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE,
10577 		ALC282_STANDARD_PINS,
10578 		{0x12, 0x90a60130},
10579 		{0x21, 0x0321101f}),
10580 	SND_HDA_PIN_QUIRK(0x10ec0283, 0x1028, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE,
10581 		{0x12, 0x90a60160},
10582 		{0x14, 0x90170120},
10583 		{0x21, 0x02211030}),
10584 	SND_HDA_PIN_QUIRK(0x10ec0283, 0x1028, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE,
10585 		ALC282_STANDARD_PINS,
10586 		{0x12, 0x90a60130},
10587 		{0x19, 0x03a11020},
10588 		{0x21, 0x0321101f}),
10589 	SND_HDA_PIN_QUIRK(0x10ec0285, 0x17aa, "Lenovo", ALC285_FIXUP_LENOVO_PC_BEEP_IN_NOISE,
10590 		{0x12, 0x90a60130},
10591 		{0x14, 0x90170110},
10592 		{0x19, 0x04a11040},
10593 		{0x21, 0x04211020}),
10594 	SND_HDA_PIN_QUIRK(0x10ec0285, 0x17aa, "Lenovo", ALC285_FIXUP_LENOVO_PC_BEEP_IN_NOISE,
10595 		{0x14, 0x90170110},
10596 		{0x19, 0x04a11040},
10597 		{0x1d, 0x40600001},
10598 		{0x21, 0x04211020}),
10599 	SND_HDA_PIN_QUIRK(0x10ec0285, 0x17aa, "Lenovo", ALC285_FIXUP_THINKPAD_NO_BASS_SPK_HEADSET_JACK,
10600 		{0x14, 0x90170110},
10601 		{0x19, 0x04a11040},
10602 		{0x21, 0x04211020}),
10603 	SND_HDA_PIN_QUIRK(0x10ec0287, 0x17aa, "Lenovo", ALC285_FIXUP_THINKPAD_HEADSET_JACK,
10604 		{0x14, 0x90170110},
10605 		{0x17, 0x90170111},
10606 		{0x19, 0x03a11030},
10607 		{0x21, 0x03211020}),
10608 	SND_HDA_PIN_QUIRK(0x10ec0287, 0x17aa, "Lenovo", ALC287_FIXUP_THINKPAD_I2S_SPK,
10609 		{0x17, 0x90170110},
10610 		{0x19, 0x03a11030},
10611 		{0x21, 0x03211020}),
10612 	SND_HDA_PIN_QUIRK(0x10ec0287, 0x17aa, "Lenovo", ALC287_FIXUP_THINKPAD_I2S_SPK,
10613 		{0x17, 0x90170110}, /* 0x231f with RTK I2S AMP */
10614 		{0x19, 0x04a11040},
10615 		{0x21, 0x04211020}),
10616 	SND_HDA_PIN_QUIRK(0x10ec0286, 0x1025, "Acer", ALC286_FIXUP_ACER_AIO_MIC_NO_PRESENCE,
10617 		{0x12, 0x90a60130},
10618 		{0x17, 0x90170110},
10619 		{0x21, 0x02211020}),
10620 	SND_HDA_PIN_QUIRK(0x10ec0288, 0x1028, "Dell", ALC288_FIXUP_DELL1_MIC_NO_PRESENCE,
10621 		{0x12, 0x90a60120},
10622 		{0x14, 0x90170110},
10623 		{0x21, 0x0321101f}),
10624 	SND_HDA_PIN_QUIRK(0x10ec0290, 0x103c, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1,
10625 		ALC290_STANDARD_PINS,
10626 		{0x15, 0x04211040},
10627 		{0x18, 0x90170112},
10628 		{0x1a, 0x04a11020}),
10629 	SND_HDA_PIN_QUIRK(0x10ec0290, 0x103c, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1,
10630 		ALC290_STANDARD_PINS,
10631 		{0x15, 0x04211040},
10632 		{0x18, 0x90170110},
10633 		{0x1a, 0x04a11020}),
10634 	SND_HDA_PIN_QUIRK(0x10ec0290, 0x103c, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1,
10635 		ALC290_STANDARD_PINS,
10636 		{0x15, 0x0421101f},
10637 		{0x1a, 0x04a11020}),
10638 	SND_HDA_PIN_QUIRK(0x10ec0290, 0x103c, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1,
10639 		ALC290_STANDARD_PINS,
10640 		{0x15, 0x04211020},
10641 		{0x1a, 0x04a11040}),
10642 	SND_HDA_PIN_QUIRK(0x10ec0290, 0x103c, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1,
10643 		ALC290_STANDARD_PINS,
10644 		{0x14, 0x90170110},
10645 		{0x15, 0x04211020},
10646 		{0x1a, 0x04a11040}),
10647 	SND_HDA_PIN_QUIRK(0x10ec0290, 0x103c, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1,
10648 		ALC290_STANDARD_PINS,
10649 		{0x14, 0x90170110},
10650 		{0x15, 0x04211020},
10651 		{0x1a, 0x04a11020}),
10652 	SND_HDA_PIN_QUIRK(0x10ec0290, 0x103c, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1,
10653 		ALC290_STANDARD_PINS,
10654 		{0x14, 0x90170110},
10655 		{0x15, 0x0421101f},
10656 		{0x1a, 0x04a11020}),
10657 	SND_HDA_PIN_QUIRK(0x10ec0292, 0x1028, "Dell", ALC269_FIXUP_DELL2_MIC_NO_PRESENCE,
10658 		ALC292_STANDARD_PINS,
10659 		{0x12, 0x90a60140},
10660 		{0x16, 0x01014020},
10661 		{0x19, 0x01a19030}),
10662 	SND_HDA_PIN_QUIRK(0x10ec0292, 0x1028, "Dell", ALC269_FIXUP_DELL2_MIC_NO_PRESENCE,
10663 		ALC292_STANDARD_PINS,
10664 		{0x12, 0x90a60140},
10665 		{0x16, 0x01014020},
10666 		{0x18, 0x02a19031},
10667 		{0x19, 0x01a1903e}),
10668 	SND_HDA_PIN_QUIRK(0x10ec0292, 0x1028, "Dell", ALC269_FIXUP_DELL3_MIC_NO_PRESENCE,
10669 		ALC292_STANDARD_PINS,
10670 		{0x12, 0x90a60140}),
10671 	SND_HDA_PIN_QUIRK(0x10ec0293, 0x1028, "Dell", ALC293_FIXUP_DELL1_MIC_NO_PRESENCE,
10672 		ALC292_STANDARD_PINS,
10673 		{0x13, 0x90a60140},
10674 		{0x16, 0x21014020},
10675 		{0x19, 0x21a19030}),
10676 	SND_HDA_PIN_QUIRK(0x10ec0293, 0x1028, "Dell", ALC293_FIXUP_DELL1_MIC_NO_PRESENCE,
10677 		ALC292_STANDARD_PINS,
10678 		{0x13, 0x90a60140}),
10679 	SND_HDA_PIN_QUIRK(0x10ec0294, 0x1043, "ASUS", ALC294_FIXUP_ASUS_HPE,
10680 		{0x17, 0x90170110},
10681 		{0x21, 0x04211020}),
10682 	SND_HDA_PIN_QUIRK(0x10ec0294, 0x1043, "ASUS", ALC294_FIXUP_ASUS_MIC,
10683 		{0x14, 0x90170110},
10684 		{0x1b, 0x90a70130},
10685 		{0x21, 0x04211020}),
10686 	SND_HDA_PIN_QUIRK(0x10ec0294, 0x1043, "ASUS", ALC294_FIXUP_ASUS_SPK,
10687 		{0x12, 0x90a60130},
10688 		{0x17, 0x90170110},
10689 		{0x21, 0x03211020}),
10690 	SND_HDA_PIN_QUIRK(0x10ec0294, 0x1043, "ASUS", ALC294_FIXUP_ASUS_SPK,
10691 		{0x12, 0x90a60130},
10692 		{0x17, 0x90170110},
10693 		{0x21, 0x04211020}),
10694 	SND_HDA_PIN_QUIRK(0x10ec0295, 0x1043, "ASUS", ALC294_FIXUP_ASUS_SPK,
10695 		{0x12, 0x90a60130},
10696 		{0x17, 0x90170110},
10697 		{0x21, 0x03211020}),
10698 	SND_HDA_PIN_QUIRK(0x10ec0295, 0x1043, "ASUS", ALC295_FIXUP_ASUS_MIC_NO_PRESENCE,
10699 		{0x12, 0x90a60120},
10700 		{0x17, 0x90170110},
10701 		{0x21, 0x04211030}),
10702 	SND_HDA_PIN_QUIRK(0x10ec0295, 0x1043, "ASUS", ALC295_FIXUP_ASUS_MIC_NO_PRESENCE,
10703 		{0x12, 0x90a60130},
10704 		{0x17, 0x90170110},
10705 		{0x21, 0x03211020}),
10706 	SND_HDA_PIN_QUIRK(0x10ec0295, 0x1043, "ASUS", ALC295_FIXUP_ASUS_MIC_NO_PRESENCE,
10707 		{0x12, 0x90a60130},
10708 		{0x17, 0x90170110},
10709 		{0x21, 0x03211020}),
10710 	SND_HDA_PIN_QUIRK(0x10ec0295, 0x1028, "Dell", ALC269_FIXUP_DELL4_MIC_NO_PRESENCE,
10711 		{0x14, 0x90170110},
10712 		{0x21, 0x04211020}),
10713 	SND_HDA_PIN_QUIRK(0x10ec0295, 0x1028, "Dell", ALC269_FIXUP_DELL4_MIC_NO_PRESENCE,
10714 		{0x14, 0x90170110},
10715 		{0x21, 0x04211030}),
10716 	SND_HDA_PIN_QUIRK(0x10ec0295, 0x1028, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE,
10717 		ALC295_STANDARD_PINS,
10718 		{0x17, 0x21014020},
10719 		{0x18, 0x21a19030}),
10720 	SND_HDA_PIN_QUIRK(0x10ec0295, 0x1028, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE,
10721 		ALC295_STANDARD_PINS,
10722 		{0x17, 0x21014040},
10723 		{0x18, 0x21a19050}),
10724 	SND_HDA_PIN_QUIRK(0x10ec0295, 0x1028, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE,
10725 		ALC295_STANDARD_PINS),
10726 	SND_HDA_PIN_QUIRK(0x10ec0298, 0x1028, "Dell", ALC298_FIXUP_DELL1_MIC_NO_PRESENCE,
10727 		ALC298_STANDARD_PINS,
10728 		{0x17, 0x90170110}),
10729 	SND_HDA_PIN_QUIRK(0x10ec0298, 0x1028, "Dell", ALC298_FIXUP_DELL1_MIC_NO_PRESENCE,
10730 		ALC298_STANDARD_PINS,
10731 		{0x17, 0x90170140}),
10732 	SND_HDA_PIN_QUIRK(0x10ec0298, 0x1028, "Dell", ALC298_FIXUP_DELL1_MIC_NO_PRESENCE,
10733 		ALC298_STANDARD_PINS,
10734 		{0x17, 0x90170150}),
10735 	SND_HDA_PIN_QUIRK(0x10ec0298, 0x1028, "Dell", ALC298_FIXUP_SPK_VOLUME,
10736 		{0x12, 0xb7a60140},
10737 		{0x13, 0xb7a60150},
10738 		{0x17, 0x90170110},
10739 		{0x1a, 0x03011020},
10740 		{0x21, 0x03211030}),
10741 	SND_HDA_PIN_QUIRK(0x10ec0298, 0x1028, "Dell", ALC298_FIXUP_ALIENWARE_MIC_NO_PRESENCE,
10742 		{0x12, 0xb7a60140},
10743 		{0x17, 0x90170110},
10744 		{0x1a, 0x03a11030},
10745 		{0x21, 0x03211020}),
10746 	SND_HDA_PIN_QUIRK(0x10ec0299, 0x1028, "Dell", ALC269_FIXUP_DELL4_MIC_NO_PRESENCE,
10747 		ALC225_STANDARD_PINS,
10748 		{0x12, 0xb7a60130},
10749 		{0x17, 0x90170110}),
10750 	SND_HDA_PIN_QUIRK(0x10ec0623, 0x17aa, "Lenovo", ALC283_FIXUP_HEADSET_MIC,
10751 		{0x14, 0x01014010},
10752 		{0x17, 0x90170120},
10753 		{0x18, 0x02a11030},
10754 		{0x19, 0x02a1103f},
10755 		{0x21, 0x0221101f}),
10756 	{}
10757 };
10758 
10759 /* This is the fallback pin_fixup_tbl for alc269 family, to make the tbl match
10760  * more machines, don't need to match all valid pins, just need to match
10761  * all the pins defined in the tbl. Just because of this reason, it is possible
10762  * that a single machine matches multiple tbls, so there is one limitation:
10763  *   at most one tbl is allowed to define for the same vendor and same codec
10764  */
10765 static const struct snd_hda_pin_quirk alc269_fallback_pin_fixup_tbl[] = {
10766 	SND_HDA_PIN_QUIRK(0x10ec0289, 0x1028, "Dell", ALC269_FIXUP_DELL4_MIC_NO_PRESENCE,
10767 		{0x19, 0x40000000},
10768 		{0x1b, 0x40000000}),
10769 	SND_HDA_PIN_QUIRK(0x10ec0256, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
10770 		{0x19, 0x40000000},
10771 		{0x1a, 0x40000000}),
10772 	SND_HDA_PIN_QUIRK(0x10ec0236, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
10773 		{0x19, 0x40000000},
10774 		{0x1a, 0x40000000}),
10775 	SND_HDA_PIN_QUIRK(0x10ec0274, 0x1028, "Dell", ALC274_FIXUP_DELL_AIO_LINEOUT_VERB,
10776 		{0x19, 0x40000000},
10777 		{0x1a, 0x40000000}),
10778 	SND_HDA_PIN_QUIRK(0x10ec0256, 0x1043, "ASUS", ALC2XX_FIXUP_HEADSET_MIC,
10779 		{0x19, 0x40000000}),
10780 	{}
10781 };
10782 
alc269_fill_coef(struct hda_codec * codec)10783 static void alc269_fill_coef(struct hda_codec *codec)
10784 {
10785 	struct alc_spec *spec = codec->spec;
10786 	int val;
10787 
10788 	if (spec->codec_variant != ALC269_TYPE_ALC269VB)
10789 		return;
10790 
10791 	if ((alc_get_coef0(codec) & 0x00ff) < 0x015) {
10792 		alc_write_coef_idx(codec, 0xf, 0x960b);
10793 		alc_write_coef_idx(codec, 0xe, 0x8817);
10794 	}
10795 
10796 	if ((alc_get_coef0(codec) & 0x00ff) == 0x016) {
10797 		alc_write_coef_idx(codec, 0xf, 0x960b);
10798 		alc_write_coef_idx(codec, 0xe, 0x8814);
10799 	}
10800 
10801 	if ((alc_get_coef0(codec) & 0x00ff) == 0x017) {
10802 		/* Power up output pin */
10803 		alc_update_coef_idx(codec, 0x04, 0, 1<<11);
10804 	}
10805 
10806 	if ((alc_get_coef0(codec) & 0x00ff) == 0x018) {
10807 		val = alc_read_coef_idx(codec, 0xd);
10808 		if (val != -1 && (val & 0x0c00) >> 10 != 0x1) {
10809 			/* Capless ramp up clock control */
10810 			alc_write_coef_idx(codec, 0xd, val | (1<<10));
10811 		}
10812 		val = alc_read_coef_idx(codec, 0x17);
10813 		if (val != -1 && (val & 0x01c0) >> 6 != 0x4) {
10814 			/* Class D power on reset */
10815 			alc_write_coef_idx(codec, 0x17, val | (1<<7));
10816 		}
10817 	}
10818 
10819 	/* HP */
10820 	alc_update_coef_idx(codec, 0x4, 0, 1<<11);
10821 }
10822 
10823 /*
10824  */
patch_alc269(struct hda_codec * codec)10825 static int patch_alc269(struct hda_codec *codec)
10826 {
10827 	struct alc_spec *spec;
10828 	int err;
10829 
10830 	err = alc_alloc_spec(codec, 0x0b);
10831 	if (err < 0)
10832 		return err;
10833 
10834 	spec = codec->spec;
10835 	spec->gen.shared_mic_vref_pin = 0x18;
10836 	codec->power_save_node = 0;
10837 	spec->en_3kpull_low = true;
10838 
10839 #ifdef CONFIG_PM
10840 	codec->patch_ops.suspend = alc269_suspend;
10841 	codec->patch_ops.resume = alc269_resume;
10842 #endif
10843 	spec->shutup = alc_default_shutup;
10844 	spec->init_hook = alc_default_init;
10845 
10846 	switch (codec->core.vendor_id) {
10847 	case 0x10ec0269:
10848 		spec->codec_variant = ALC269_TYPE_ALC269VA;
10849 		switch (alc_get_coef0(codec) & 0x00f0) {
10850 		case 0x0010:
10851 			if (codec->bus->pci &&
10852 			    codec->bus->pci->subsystem_vendor == 0x1025 &&
10853 			    spec->cdefine.platform_type == 1)
10854 				err = alc_codec_rename(codec, "ALC271X");
10855 			spec->codec_variant = ALC269_TYPE_ALC269VB;
10856 			break;
10857 		case 0x0020:
10858 			if (codec->bus->pci &&
10859 			    codec->bus->pci->subsystem_vendor == 0x17aa &&
10860 			    codec->bus->pci->subsystem_device == 0x21f3)
10861 				err = alc_codec_rename(codec, "ALC3202");
10862 			spec->codec_variant = ALC269_TYPE_ALC269VC;
10863 			break;
10864 		case 0x0030:
10865 			spec->codec_variant = ALC269_TYPE_ALC269VD;
10866 			break;
10867 		default:
10868 			alc_fix_pll_init(codec, 0x20, 0x04, 15);
10869 		}
10870 		if (err < 0)
10871 			goto error;
10872 		spec->shutup = alc269_shutup;
10873 		spec->init_hook = alc269_fill_coef;
10874 		alc269_fill_coef(codec);
10875 		break;
10876 
10877 	case 0x10ec0280:
10878 	case 0x10ec0290:
10879 		spec->codec_variant = ALC269_TYPE_ALC280;
10880 		break;
10881 	case 0x10ec0282:
10882 		spec->codec_variant = ALC269_TYPE_ALC282;
10883 		spec->shutup = alc282_shutup;
10884 		spec->init_hook = alc282_init;
10885 		break;
10886 	case 0x10ec0233:
10887 	case 0x10ec0283:
10888 		spec->codec_variant = ALC269_TYPE_ALC283;
10889 		spec->shutup = alc283_shutup;
10890 		spec->init_hook = alc283_init;
10891 		break;
10892 	case 0x10ec0284:
10893 	case 0x10ec0292:
10894 		spec->codec_variant = ALC269_TYPE_ALC284;
10895 		break;
10896 	case 0x10ec0293:
10897 		spec->codec_variant = ALC269_TYPE_ALC293;
10898 		break;
10899 	case 0x10ec0286:
10900 	case 0x10ec0288:
10901 		spec->codec_variant = ALC269_TYPE_ALC286;
10902 		break;
10903 	case 0x10ec0298:
10904 		spec->codec_variant = ALC269_TYPE_ALC298;
10905 		break;
10906 	case 0x10ec0235:
10907 	case 0x10ec0255:
10908 		spec->codec_variant = ALC269_TYPE_ALC255;
10909 		spec->shutup = alc256_shutup;
10910 		spec->init_hook = alc256_init;
10911 		break;
10912 	case 0x10ec0230:
10913 	case 0x10ec0236:
10914 	case 0x10ec0256:
10915 	case 0x19e58326:
10916 		spec->codec_variant = ALC269_TYPE_ALC256;
10917 		spec->shutup = alc256_shutup;
10918 		spec->init_hook = alc256_init;
10919 		spec->gen.mixer_nid = 0; /* ALC256 does not have any loopback mixer path */
10920 		if (codec->core.vendor_id == 0x10ec0236 &&
10921 		    codec->bus->pci->vendor != PCI_VENDOR_ID_AMD)
10922 			spec->en_3kpull_low = false;
10923 		break;
10924 	case 0x10ec0257:
10925 		spec->codec_variant = ALC269_TYPE_ALC257;
10926 		spec->shutup = alc256_shutup;
10927 		spec->init_hook = alc256_init;
10928 		spec->gen.mixer_nid = 0;
10929 		spec->en_3kpull_low = false;
10930 		break;
10931 	case 0x10ec0215:
10932 	case 0x10ec0245:
10933 	case 0x10ec0285:
10934 	case 0x10ec0289:
10935 		if (alc_get_coef0(codec) & 0x0010)
10936 			spec->codec_variant = ALC269_TYPE_ALC245;
10937 		else
10938 			spec->codec_variant = ALC269_TYPE_ALC215;
10939 		spec->shutup = alc225_shutup;
10940 		spec->init_hook = alc225_init;
10941 		spec->gen.mixer_nid = 0;
10942 		break;
10943 	case 0x10ec0225:
10944 	case 0x10ec0295:
10945 	case 0x10ec0299:
10946 		spec->codec_variant = ALC269_TYPE_ALC225;
10947 		spec->shutup = alc225_shutup;
10948 		spec->init_hook = alc225_init;
10949 		spec->gen.mixer_nid = 0; /* no loopback on ALC225, ALC295 and ALC299 */
10950 		break;
10951 	case 0x10ec0287:
10952 		spec->codec_variant = ALC269_TYPE_ALC287;
10953 		spec->shutup = alc225_shutup;
10954 		spec->init_hook = alc225_init;
10955 		spec->gen.mixer_nid = 0; /* no loopback on ALC287 */
10956 		break;
10957 	case 0x10ec0234:
10958 	case 0x10ec0274:
10959 	case 0x10ec0294:
10960 		spec->codec_variant = ALC269_TYPE_ALC294;
10961 		spec->gen.mixer_nid = 0; /* ALC2x4 does not have any loopback mixer path */
10962 		alc_update_coef_idx(codec, 0x6b, 0x0018, (1<<4) | (1<<3)); /* UAJ MIC Vref control by verb */
10963 		spec->init_hook = alc294_init;
10964 		break;
10965 	case 0x10ec0300:
10966 		spec->codec_variant = ALC269_TYPE_ALC300;
10967 		spec->gen.mixer_nid = 0; /* no loopback on ALC300 */
10968 		break;
10969 	case 0x10ec0623:
10970 		spec->codec_variant = ALC269_TYPE_ALC623;
10971 		break;
10972 	case 0x10ec0700:
10973 	case 0x10ec0701:
10974 	case 0x10ec0703:
10975 	case 0x10ec0711:
10976 		spec->codec_variant = ALC269_TYPE_ALC700;
10977 		spec->gen.mixer_nid = 0; /* ALC700 does not have any loopback mixer path */
10978 		alc_update_coef_idx(codec, 0x4a, 1 << 15, 0); /* Combo jack auto trigger control */
10979 		spec->init_hook = alc294_init;
10980 		break;
10981 
10982 	}
10983 
10984 	if (snd_hda_codec_read(codec, 0x51, 0, AC_VERB_PARAMETERS, 0) == 0x10ec5505) {
10985 		spec->has_alc5505_dsp = 1;
10986 		spec->init_hook = alc5505_dsp_init;
10987 	}
10988 
10989 	alc_pre_init(codec);
10990 
10991 	snd_hda_pick_fixup(codec, alc269_fixup_models,
10992 		       alc269_fixup_tbl, alc269_fixups);
10993 	/* FIXME: both TX300 and ROG Strix G17 have the same SSID, and
10994 	 * the quirk breaks the latter (bko#214101).
10995 	 * Clear the wrong entry.
10996 	 */
10997 	if (codec->fixup_id == ALC282_FIXUP_ASUS_TX300 &&
10998 	    codec->core.vendor_id == 0x10ec0294) {
10999 		codec_dbg(codec, "Clear wrong fixup for ASUS ROG Strix G17\n");
11000 		codec->fixup_id = HDA_FIXUP_ID_NOT_SET;
11001 	}
11002 
11003 	snd_hda_pick_pin_fixup(codec, alc269_pin_fixup_tbl, alc269_fixups, true);
11004 	snd_hda_pick_pin_fixup(codec, alc269_fallback_pin_fixup_tbl, alc269_fixups, false);
11005 	snd_hda_pick_fixup(codec, NULL,	alc269_fixup_vendor_tbl,
11006 			   alc269_fixups);
11007 	snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE);
11008 
11009 	alc_auto_parse_customize_define(codec);
11010 
11011 	if (has_cdefine_beep(codec))
11012 		spec->gen.beep_nid = 0x01;
11013 
11014 	/* automatic parse from the BIOS config */
11015 	err = alc269_parse_auto_config(codec);
11016 	if (err < 0)
11017 		goto error;
11018 
11019 	if (!spec->gen.no_analog && spec->gen.beep_nid && spec->gen.mixer_nid) {
11020 		err = set_beep_amp(spec, spec->gen.mixer_nid, 0x04, HDA_INPUT);
11021 		if (err < 0)
11022 			goto error;
11023 	}
11024 
11025 	snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE);
11026 
11027 	return 0;
11028 
11029  error:
11030 	alc_free(codec);
11031 	return err;
11032 }
11033 
11034 /*
11035  * ALC861
11036  */
11037 
alc861_parse_auto_config(struct hda_codec * codec)11038 static int alc861_parse_auto_config(struct hda_codec *codec)
11039 {
11040 	static const hda_nid_t alc861_ignore[] = { 0x1d, 0 };
11041 	static const hda_nid_t alc861_ssids[] = { 0x0e, 0x0f, 0x0b, 0 };
11042 	return alc_parse_auto_config(codec, alc861_ignore, alc861_ssids);
11043 }
11044 
11045 /* Pin config fixes */
11046 enum {
11047 	ALC861_FIXUP_FSC_AMILO_PI1505,
11048 	ALC861_FIXUP_AMP_VREF_0F,
11049 	ALC861_FIXUP_NO_JACK_DETECT,
11050 	ALC861_FIXUP_ASUS_A6RP,
11051 	ALC660_FIXUP_ASUS_W7J,
11052 };
11053 
11054 /* 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)11055 static void alc861_fixup_asus_amp_vref_0f(struct hda_codec *codec,
11056 			const struct hda_fixup *fix, int action)
11057 {
11058 	struct alc_spec *spec = codec->spec;
11059 	unsigned int val;
11060 
11061 	if (action != HDA_FIXUP_ACT_INIT)
11062 		return;
11063 	val = snd_hda_codec_get_pin_target(codec, 0x0f);
11064 	if (!(val & (AC_PINCTL_IN_EN | AC_PINCTL_OUT_EN)))
11065 		val |= AC_PINCTL_IN_EN;
11066 	val |= AC_PINCTL_VREF_50;
11067 	snd_hda_set_pin_ctl(codec, 0x0f, val);
11068 	spec->gen.keep_vref_in_automute = 1;
11069 }
11070 
11071 /* suppress the jack-detection */
alc_fixup_no_jack_detect(struct hda_codec * codec,const struct hda_fixup * fix,int action)11072 static void alc_fixup_no_jack_detect(struct hda_codec *codec,
11073 				     const struct hda_fixup *fix, int action)
11074 {
11075 	if (action == HDA_FIXUP_ACT_PRE_PROBE)
11076 		codec->no_jack_detect = 1;
11077 }
11078 
11079 static const struct hda_fixup alc861_fixups[] = {
11080 	[ALC861_FIXUP_FSC_AMILO_PI1505] = {
11081 		.type = HDA_FIXUP_PINS,
11082 		.v.pins = (const struct hda_pintbl[]) {
11083 			{ 0x0b, 0x0221101f }, /* HP */
11084 			{ 0x0f, 0x90170310 }, /* speaker */
11085 			{ }
11086 		}
11087 	},
11088 	[ALC861_FIXUP_AMP_VREF_0F] = {
11089 		.type = HDA_FIXUP_FUNC,
11090 		.v.func = alc861_fixup_asus_amp_vref_0f,
11091 	},
11092 	[ALC861_FIXUP_NO_JACK_DETECT] = {
11093 		.type = HDA_FIXUP_FUNC,
11094 		.v.func = alc_fixup_no_jack_detect,
11095 	},
11096 	[ALC861_FIXUP_ASUS_A6RP] = {
11097 		.type = HDA_FIXUP_FUNC,
11098 		.v.func = alc861_fixup_asus_amp_vref_0f,
11099 		.chained = true,
11100 		.chain_id = ALC861_FIXUP_NO_JACK_DETECT,
11101 	},
11102 	[ALC660_FIXUP_ASUS_W7J] = {
11103 		.type = HDA_FIXUP_VERBS,
11104 		.v.verbs = (const struct hda_verb[]) {
11105 			/* ASUS W7J needs a magic pin setup on unused NID 0x10
11106 			 * for enabling outputs
11107 			 */
11108 			{0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
11109 			{ }
11110 		},
11111 	}
11112 };
11113 
11114 static const struct snd_pci_quirk alc861_fixup_tbl[] = {
11115 	SND_PCI_QUIRK(0x1043, 0x1253, "ASUS W7J", ALC660_FIXUP_ASUS_W7J),
11116 	SND_PCI_QUIRK(0x1043, 0x1263, "ASUS Z35HL", ALC660_FIXUP_ASUS_W7J),
11117 	SND_PCI_QUIRK(0x1043, 0x1393, "ASUS A6Rp", ALC861_FIXUP_ASUS_A6RP),
11118 	SND_PCI_QUIRK_VENDOR(0x1043, "ASUS laptop", ALC861_FIXUP_AMP_VREF_0F),
11119 	SND_PCI_QUIRK(0x1462, 0x7254, "HP DX2200", ALC861_FIXUP_NO_JACK_DETECT),
11120 	SND_PCI_QUIRK_VENDOR(0x1584, "Haier/Uniwill", ALC861_FIXUP_AMP_VREF_0F),
11121 	SND_PCI_QUIRK(0x1734, 0x10c7, "FSC Amilo Pi1505", ALC861_FIXUP_FSC_AMILO_PI1505),
11122 	{}
11123 };
11124 
11125 /*
11126  */
patch_alc861(struct hda_codec * codec)11127 static int patch_alc861(struct hda_codec *codec)
11128 {
11129 	struct alc_spec *spec;
11130 	int err;
11131 
11132 	err = alc_alloc_spec(codec, 0x15);
11133 	if (err < 0)
11134 		return err;
11135 
11136 	spec = codec->spec;
11137 	if (has_cdefine_beep(codec))
11138 		spec->gen.beep_nid = 0x23;
11139 
11140 #ifdef CONFIG_PM
11141 	spec->power_hook = alc_power_eapd;
11142 #endif
11143 
11144 	alc_pre_init(codec);
11145 
11146 	snd_hda_pick_fixup(codec, NULL, alc861_fixup_tbl, alc861_fixups);
11147 	snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE);
11148 
11149 	/* automatic parse from the BIOS config */
11150 	err = alc861_parse_auto_config(codec);
11151 	if (err < 0)
11152 		goto error;
11153 
11154 	if (!spec->gen.no_analog) {
11155 		err = set_beep_amp(spec, 0x23, 0, HDA_OUTPUT);
11156 		if (err < 0)
11157 			goto error;
11158 	}
11159 
11160 	snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE);
11161 
11162 	return 0;
11163 
11164  error:
11165 	alc_free(codec);
11166 	return err;
11167 }
11168 
11169 /*
11170  * ALC861-VD support
11171  *
11172  * Based on ALC882
11173  *
11174  * In addition, an independent DAC
11175  */
alc861vd_parse_auto_config(struct hda_codec * codec)11176 static int alc861vd_parse_auto_config(struct hda_codec *codec)
11177 {
11178 	static const hda_nid_t alc861vd_ignore[] = { 0x1d, 0 };
11179 	static const hda_nid_t alc861vd_ssids[] = { 0x15, 0x1b, 0x14, 0 };
11180 	return alc_parse_auto_config(codec, alc861vd_ignore, alc861vd_ssids);
11181 }
11182 
11183 enum {
11184 	ALC660VD_FIX_ASUS_GPIO1,
11185 	ALC861VD_FIX_DALLAS,
11186 };
11187 
11188 /* exclude VREF80 */
alc861vd_fixup_dallas(struct hda_codec * codec,const struct hda_fixup * fix,int action)11189 static void alc861vd_fixup_dallas(struct hda_codec *codec,
11190 				  const struct hda_fixup *fix, int action)
11191 {
11192 	if (action == HDA_FIXUP_ACT_PRE_PROBE) {
11193 		snd_hda_override_pin_caps(codec, 0x18, 0x00000734);
11194 		snd_hda_override_pin_caps(codec, 0x19, 0x0000073c);
11195 	}
11196 }
11197 
11198 /* reset GPIO1 */
alc660vd_fixup_asus_gpio1(struct hda_codec * codec,const struct hda_fixup * fix,int action)11199 static void alc660vd_fixup_asus_gpio1(struct hda_codec *codec,
11200 				      const struct hda_fixup *fix, int action)
11201 {
11202 	struct alc_spec *spec = codec->spec;
11203 
11204 	if (action == HDA_FIXUP_ACT_PRE_PROBE)
11205 		spec->gpio_mask |= 0x02;
11206 	alc_fixup_gpio(codec, action, 0x01);
11207 }
11208 
11209 static const struct hda_fixup alc861vd_fixups[] = {
11210 	[ALC660VD_FIX_ASUS_GPIO1] = {
11211 		.type = HDA_FIXUP_FUNC,
11212 		.v.func = alc660vd_fixup_asus_gpio1,
11213 	},
11214 	[ALC861VD_FIX_DALLAS] = {
11215 		.type = HDA_FIXUP_FUNC,
11216 		.v.func = alc861vd_fixup_dallas,
11217 	},
11218 };
11219 
11220 static const struct snd_pci_quirk alc861vd_fixup_tbl[] = {
11221 	SND_PCI_QUIRK(0x103c, 0x30bf, "HP TX1000", ALC861VD_FIX_DALLAS),
11222 	SND_PCI_QUIRK(0x1043, 0x1339, "ASUS A7-K", ALC660VD_FIX_ASUS_GPIO1),
11223 	SND_PCI_QUIRK(0x1179, 0xff31, "Toshiba L30-149", ALC861VD_FIX_DALLAS),
11224 	{}
11225 };
11226 
11227 /*
11228  */
patch_alc861vd(struct hda_codec * codec)11229 static int patch_alc861vd(struct hda_codec *codec)
11230 {
11231 	struct alc_spec *spec;
11232 	int err;
11233 
11234 	err = alc_alloc_spec(codec, 0x0b);
11235 	if (err < 0)
11236 		return err;
11237 
11238 	spec = codec->spec;
11239 	if (has_cdefine_beep(codec))
11240 		spec->gen.beep_nid = 0x23;
11241 
11242 	spec->shutup = alc_eapd_shutup;
11243 
11244 	alc_pre_init(codec);
11245 
11246 	snd_hda_pick_fixup(codec, NULL, alc861vd_fixup_tbl, alc861vd_fixups);
11247 	snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE);
11248 
11249 	/* automatic parse from the BIOS config */
11250 	err = alc861vd_parse_auto_config(codec);
11251 	if (err < 0)
11252 		goto error;
11253 
11254 	if (!spec->gen.no_analog) {
11255 		err = set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
11256 		if (err < 0)
11257 			goto error;
11258 	}
11259 
11260 	snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE);
11261 
11262 	return 0;
11263 
11264  error:
11265 	alc_free(codec);
11266 	return err;
11267 }
11268 
11269 /*
11270  * ALC662 support
11271  *
11272  * ALC662 is almost identical with ALC880 but has cleaner and more flexible
11273  * configuration.  Each pin widget can choose any input DACs and a mixer.
11274  * Each ADC is connected from a mixer of all inputs.  This makes possible
11275  * 6-channel independent captures.
11276  *
11277  * In addition, an independent DAC for the multi-playback (not used in this
11278  * driver yet).
11279  */
11280 
11281 /*
11282  * BIOS auto configuration
11283  */
11284 
alc662_parse_auto_config(struct hda_codec * codec)11285 static int alc662_parse_auto_config(struct hda_codec *codec)
11286 {
11287 	static const hda_nid_t alc662_ignore[] = { 0x1d, 0 };
11288 	static const hda_nid_t alc663_ssids[] = { 0x15, 0x1b, 0x14, 0x21 };
11289 	static const hda_nid_t alc662_ssids[] = { 0x15, 0x1b, 0x14, 0 };
11290 	const hda_nid_t *ssids;
11291 
11292 	if (codec->core.vendor_id == 0x10ec0272 || codec->core.vendor_id == 0x10ec0663 ||
11293 	    codec->core.vendor_id == 0x10ec0665 || codec->core.vendor_id == 0x10ec0670 ||
11294 	    codec->core.vendor_id == 0x10ec0671)
11295 		ssids = alc663_ssids;
11296 	else
11297 		ssids = alc662_ssids;
11298 	return alc_parse_auto_config(codec, alc662_ignore, ssids);
11299 }
11300 
alc272_fixup_mario(struct hda_codec * codec,const struct hda_fixup * fix,int action)11301 static void alc272_fixup_mario(struct hda_codec *codec,
11302 			       const struct hda_fixup *fix, int action)
11303 {
11304 	if (action != HDA_FIXUP_ACT_PRE_PROBE)
11305 		return;
11306 	if (snd_hda_override_amp_caps(codec, 0x2, HDA_OUTPUT,
11307 				      (0x3b << AC_AMPCAP_OFFSET_SHIFT) |
11308 				      (0x3b << AC_AMPCAP_NUM_STEPS_SHIFT) |
11309 				      (0x03 << AC_AMPCAP_STEP_SIZE_SHIFT) |
11310 				      (0 << AC_AMPCAP_MUTE_SHIFT)))
11311 		codec_warn(codec, "failed to override amp caps for NID 0x2\n");
11312 }
11313 
11314 static const struct snd_pcm_chmap_elem asus_pcm_2_1_chmaps[] = {
11315 	{ .channels = 2,
11316 	  .map = { SNDRV_CHMAP_FL, SNDRV_CHMAP_FR } },
11317 	{ .channels = 4,
11318 	  .map = { SNDRV_CHMAP_FL, SNDRV_CHMAP_FR,
11319 		   SNDRV_CHMAP_NA, SNDRV_CHMAP_LFE } }, /* LFE only on right */
11320 	{ }
11321 };
11322 
11323 /* override the 2.1 chmap */
alc_fixup_bass_chmap(struct hda_codec * codec,const struct hda_fixup * fix,int action)11324 static void alc_fixup_bass_chmap(struct hda_codec *codec,
11325 				    const struct hda_fixup *fix, int action)
11326 {
11327 	if (action == HDA_FIXUP_ACT_BUILD) {
11328 		struct alc_spec *spec = codec->spec;
11329 		spec->gen.pcm_rec[0]->stream[0].chmap = asus_pcm_2_1_chmaps;
11330 	}
11331 }
11332 
11333 /* avoid D3 for keeping GPIO up */
gpio_led_power_filter(struct hda_codec * codec,hda_nid_t nid,unsigned int power_state)11334 static unsigned int gpio_led_power_filter(struct hda_codec *codec,
11335 					  hda_nid_t nid,
11336 					  unsigned int power_state)
11337 {
11338 	struct alc_spec *spec = codec->spec;
11339 	if (nid == codec->core.afg && power_state == AC_PWRST_D3 && spec->gpio_data)
11340 		return AC_PWRST_D0;
11341 	return power_state;
11342 }
11343 
alc662_fixup_led_gpio1(struct hda_codec * codec,const struct hda_fixup * fix,int action)11344 static void alc662_fixup_led_gpio1(struct hda_codec *codec,
11345 				   const struct hda_fixup *fix, int action)
11346 {
11347 	struct alc_spec *spec = codec->spec;
11348 
11349 	alc_fixup_hp_gpio_led(codec, action, 0x01, 0);
11350 	if (action == HDA_FIXUP_ACT_PRE_PROBE) {
11351 		spec->mute_led_polarity = 1;
11352 		codec->power_filter = gpio_led_power_filter;
11353 	}
11354 }
11355 
alc662_usi_automute_hook(struct hda_codec * codec,struct hda_jack_callback * jack)11356 static void alc662_usi_automute_hook(struct hda_codec *codec,
11357 					 struct hda_jack_callback *jack)
11358 {
11359 	struct alc_spec *spec = codec->spec;
11360 	int vref;
11361 	msleep(200);
11362 	snd_hda_gen_hp_automute(codec, jack);
11363 
11364 	vref = spec->gen.hp_jack_present ? PIN_VREF80 : 0;
11365 	msleep(100);
11366 	snd_hda_codec_write(codec, 0x19, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
11367 			    vref);
11368 }
11369 
alc662_fixup_usi_headset_mic(struct hda_codec * codec,const struct hda_fixup * fix,int action)11370 static void alc662_fixup_usi_headset_mic(struct hda_codec *codec,
11371 				     const struct hda_fixup *fix, int action)
11372 {
11373 	struct alc_spec *spec = codec->spec;
11374 	if (action == HDA_FIXUP_ACT_PRE_PROBE) {
11375 		spec->parse_flags |= HDA_PINCFG_HEADSET_MIC;
11376 		spec->gen.hp_automute_hook = alc662_usi_automute_hook;
11377 	}
11378 }
11379 
alc662_aspire_ethos_mute_speakers(struct hda_codec * codec,struct hda_jack_callback * cb)11380 static void alc662_aspire_ethos_mute_speakers(struct hda_codec *codec,
11381 					struct hda_jack_callback *cb)
11382 {
11383 	/* surround speakers at 0x1b already get muted automatically when
11384 	 * headphones are plugged in, but we have to mute/unmute the remaining
11385 	 * channels manually:
11386 	 * 0x15 - front left/front right
11387 	 * 0x18 - front center/ LFE
11388 	 */
11389 	if (snd_hda_jack_detect_state(codec, 0x1b) == HDA_JACK_PRESENT) {
11390 		snd_hda_set_pin_ctl_cache(codec, 0x15, 0);
11391 		snd_hda_set_pin_ctl_cache(codec, 0x18, 0);
11392 	} else {
11393 		snd_hda_set_pin_ctl_cache(codec, 0x15, PIN_OUT);
11394 		snd_hda_set_pin_ctl_cache(codec, 0x18, PIN_OUT);
11395 	}
11396 }
11397 
alc662_fixup_aspire_ethos_hp(struct hda_codec * codec,const struct hda_fixup * fix,int action)11398 static void alc662_fixup_aspire_ethos_hp(struct hda_codec *codec,
11399 					const struct hda_fixup *fix, int action)
11400 {
11401     /* Pin 0x1b: shared headphones jack and surround speakers */
11402 	if (!is_jack_detectable(codec, 0x1b))
11403 		return;
11404 
11405 	switch (action) {
11406 	case HDA_FIXUP_ACT_PRE_PROBE:
11407 		snd_hda_jack_detect_enable_callback(codec, 0x1b,
11408 				alc662_aspire_ethos_mute_speakers);
11409 		/* subwoofer needs an extra GPIO setting to become audible */
11410 		alc_setup_gpio(codec, 0x02);
11411 		break;
11412 	case HDA_FIXUP_ACT_INIT:
11413 		/* Make sure to start in a correct state, i.e. if
11414 		 * headphones have been plugged in before powering up the system
11415 		 */
11416 		alc662_aspire_ethos_mute_speakers(codec, NULL);
11417 		break;
11418 	}
11419 }
11420 
alc671_fixup_hp_headset_mic2(struct hda_codec * codec,const struct hda_fixup * fix,int action)11421 static void alc671_fixup_hp_headset_mic2(struct hda_codec *codec,
11422 					     const struct hda_fixup *fix, int action)
11423 {
11424 	struct alc_spec *spec = codec->spec;
11425 
11426 	static const struct hda_pintbl pincfgs[] = {
11427 		{ 0x19, 0x02a11040 }, /* use as headset mic, with its own jack detect */
11428 		{ 0x1b, 0x0181304f },
11429 		{ }
11430 	};
11431 
11432 	switch (action) {
11433 	case HDA_FIXUP_ACT_PRE_PROBE:
11434 		spec->gen.mixer_nid = 0;
11435 		spec->parse_flags |= HDA_PINCFG_HEADSET_MIC;
11436 		snd_hda_apply_pincfgs(codec, pincfgs);
11437 		break;
11438 	case HDA_FIXUP_ACT_INIT:
11439 		alc_write_coef_idx(codec, 0x19, 0xa054);
11440 		break;
11441 	}
11442 }
11443 
alc897_hp_automute_hook(struct hda_codec * codec,struct hda_jack_callback * jack)11444 static void alc897_hp_automute_hook(struct hda_codec *codec,
11445 					 struct hda_jack_callback *jack)
11446 {
11447 	struct alc_spec *spec = codec->spec;
11448 	int vref;
11449 
11450 	snd_hda_gen_hp_automute(codec, jack);
11451 	vref = spec->gen.hp_jack_present ? (PIN_HP | AC_PINCTL_VREF_100) : PIN_HP;
11452 	snd_hda_codec_write(codec, 0x1b, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
11453 			    vref);
11454 }
11455 
alc897_fixup_lenovo_headset_mic(struct hda_codec * codec,const struct hda_fixup * fix,int action)11456 static void alc897_fixup_lenovo_headset_mic(struct hda_codec *codec,
11457 				     const struct hda_fixup *fix, int action)
11458 {
11459 	struct alc_spec *spec = codec->spec;
11460 	if (action == HDA_FIXUP_ACT_PRE_PROBE) {
11461 		spec->gen.hp_automute_hook = alc897_hp_automute_hook;
11462 	}
11463 }
11464 
alc897_fixup_lenovo_headset_mode(struct hda_codec * codec,const struct hda_fixup * fix,int action)11465 static void alc897_fixup_lenovo_headset_mode(struct hda_codec *codec,
11466 				     const struct hda_fixup *fix, int action)
11467 {
11468 	struct alc_spec *spec = codec->spec;
11469 
11470 	if (action == HDA_FIXUP_ACT_PRE_PROBE) {
11471 		spec->parse_flags |= HDA_PINCFG_HEADSET_MIC;
11472 		spec->gen.hp_automute_hook = alc897_hp_automute_hook;
11473 	}
11474 }
11475 
11476 static const struct coef_fw alc668_coefs[] = {
11477 	WRITE_COEF(0x01, 0xbebe), WRITE_COEF(0x02, 0xaaaa), WRITE_COEF(0x03,    0x0),
11478 	WRITE_COEF(0x04, 0x0180), WRITE_COEF(0x06,    0x0), WRITE_COEF(0x07, 0x0f80),
11479 	WRITE_COEF(0x08, 0x0031), WRITE_COEF(0x0a, 0x0060), WRITE_COEF(0x0b,    0x0),
11480 	WRITE_COEF(0x0c, 0x7cf7), WRITE_COEF(0x0d, 0x1080), WRITE_COEF(0x0e, 0x7f7f),
11481 	WRITE_COEF(0x0f, 0xcccc), WRITE_COEF(0x10, 0xddcc), WRITE_COEF(0x11, 0x0001),
11482 	WRITE_COEF(0x13,    0x0), WRITE_COEF(0x14, 0x2aa0), WRITE_COEF(0x17, 0xa940),
11483 	WRITE_COEF(0x19,    0x0), WRITE_COEF(0x1a,    0x0), WRITE_COEF(0x1b,    0x0),
11484 	WRITE_COEF(0x1c,    0x0), WRITE_COEF(0x1d,    0x0), WRITE_COEF(0x1e, 0x7418),
11485 	WRITE_COEF(0x1f, 0x0804), WRITE_COEF(0x20, 0x4200), WRITE_COEF(0x21, 0x0468),
11486 	WRITE_COEF(0x22, 0x8ccc), WRITE_COEF(0x23, 0x0250), WRITE_COEF(0x24, 0x7418),
11487 	WRITE_COEF(0x27,    0x0), WRITE_COEF(0x28, 0x8ccc), WRITE_COEF(0x2a, 0xff00),
11488 	WRITE_COEF(0x2b, 0x8000), WRITE_COEF(0xa7, 0xff00), WRITE_COEF(0xa8, 0x8000),
11489 	WRITE_COEF(0xaa, 0x2e17), WRITE_COEF(0xab, 0xa0c0), WRITE_COEF(0xac,    0x0),
11490 	WRITE_COEF(0xad,    0x0), WRITE_COEF(0xae, 0x2ac6), WRITE_COEF(0xaf, 0xa480),
11491 	WRITE_COEF(0xb0,    0x0), WRITE_COEF(0xb1,    0x0), WRITE_COEF(0xb2,    0x0),
11492 	WRITE_COEF(0xb3,    0x0), WRITE_COEF(0xb4,    0x0), WRITE_COEF(0xb5, 0x1040),
11493 	WRITE_COEF(0xb6, 0xd697), WRITE_COEF(0xb7, 0x902b), WRITE_COEF(0xb8, 0xd697),
11494 	WRITE_COEF(0xb9, 0x902b), WRITE_COEF(0xba, 0xb8ba), WRITE_COEF(0xbb, 0xaaab),
11495 	WRITE_COEF(0xbc, 0xaaaf), WRITE_COEF(0xbd, 0x6aaa), WRITE_COEF(0xbe, 0x1c02),
11496 	WRITE_COEF(0xc0, 0x00ff), WRITE_COEF(0xc1, 0x0fa6),
11497 	{}
11498 };
11499 
alc668_restore_default_value(struct hda_codec * codec)11500 static void alc668_restore_default_value(struct hda_codec *codec)
11501 {
11502 	alc_process_coef_fw(codec, alc668_coefs);
11503 }
11504 
11505 enum {
11506 	ALC662_FIXUP_ASPIRE,
11507 	ALC662_FIXUP_LED_GPIO1,
11508 	ALC662_FIXUP_IDEAPAD,
11509 	ALC272_FIXUP_MARIO,
11510 	ALC662_FIXUP_CZC_ET26,
11511 	ALC662_FIXUP_CZC_P10T,
11512 	ALC662_FIXUP_SKU_IGNORE,
11513 	ALC662_FIXUP_HP_RP5800,
11514 	ALC662_FIXUP_ASUS_MODE1,
11515 	ALC662_FIXUP_ASUS_MODE2,
11516 	ALC662_FIXUP_ASUS_MODE3,
11517 	ALC662_FIXUP_ASUS_MODE4,
11518 	ALC662_FIXUP_ASUS_MODE5,
11519 	ALC662_FIXUP_ASUS_MODE6,
11520 	ALC662_FIXUP_ASUS_MODE7,
11521 	ALC662_FIXUP_ASUS_MODE8,
11522 	ALC662_FIXUP_NO_JACK_DETECT,
11523 	ALC662_FIXUP_ZOTAC_Z68,
11524 	ALC662_FIXUP_INV_DMIC,
11525 	ALC662_FIXUP_DELL_MIC_NO_PRESENCE,
11526 	ALC668_FIXUP_DELL_MIC_NO_PRESENCE,
11527 	ALC662_FIXUP_HEADSET_MODE,
11528 	ALC668_FIXUP_HEADSET_MODE,
11529 	ALC662_FIXUP_BASS_MODE4_CHMAP,
11530 	ALC662_FIXUP_BASS_16,
11531 	ALC662_FIXUP_BASS_1A,
11532 	ALC662_FIXUP_BASS_CHMAP,
11533 	ALC668_FIXUP_AUTO_MUTE,
11534 	ALC668_FIXUP_DELL_DISABLE_AAMIX,
11535 	ALC668_FIXUP_DELL_XPS13,
11536 	ALC662_FIXUP_ASUS_Nx50,
11537 	ALC668_FIXUP_ASUS_Nx51_HEADSET_MODE,
11538 	ALC668_FIXUP_ASUS_Nx51,
11539 	ALC668_FIXUP_MIC_COEF,
11540 	ALC668_FIXUP_ASUS_G751,
11541 	ALC891_FIXUP_HEADSET_MODE,
11542 	ALC891_FIXUP_DELL_MIC_NO_PRESENCE,
11543 	ALC662_FIXUP_ACER_VERITON,
11544 	ALC892_FIXUP_ASROCK_MOBO,
11545 	ALC662_FIXUP_USI_FUNC,
11546 	ALC662_FIXUP_USI_HEADSET_MODE,
11547 	ALC662_FIXUP_LENOVO_MULTI_CODECS,
11548 	ALC669_FIXUP_ACER_ASPIRE_ETHOS,
11549 	ALC669_FIXUP_ACER_ASPIRE_ETHOS_HEADSET,
11550 	ALC671_FIXUP_HP_HEADSET_MIC2,
11551 	ALC662_FIXUP_ACER_X2660G_HEADSET_MODE,
11552 	ALC662_FIXUP_ACER_NITRO_HEADSET_MODE,
11553 	ALC668_FIXUP_ASUS_NO_HEADSET_MIC,
11554 	ALC668_FIXUP_HEADSET_MIC,
11555 	ALC668_FIXUP_MIC_DET_COEF,
11556 	ALC897_FIXUP_LENOVO_HEADSET_MIC,
11557 	ALC897_FIXUP_HEADSET_MIC_PIN,
11558 	ALC897_FIXUP_HP_HSMIC_VERB,
11559 	ALC897_FIXUP_LENOVO_HEADSET_MODE,
11560 	ALC897_FIXUP_HEADSET_MIC_PIN2,
11561 	ALC897_FIXUP_UNIS_H3C_X500S,
11562 };
11563 
11564 static const struct hda_fixup alc662_fixups[] = {
11565 	[ALC662_FIXUP_ASPIRE] = {
11566 		.type = HDA_FIXUP_PINS,
11567 		.v.pins = (const struct hda_pintbl[]) {
11568 			{ 0x15, 0x99130112 }, /* subwoofer */
11569 			{ }
11570 		}
11571 	},
11572 	[ALC662_FIXUP_LED_GPIO1] = {
11573 		.type = HDA_FIXUP_FUNC,
11574 		.v.func = alc662_fixup_led_gpio1,
11575 	},
11576 	[ALC662_FIXUP_IDEAPAD] = {
11577 		.type = HDA_FIXUP_PINS,
11578 		.v.pins = (const struct hda_pintbl[]) {
11579 			{ 0x17, 0x99130112 }, /* subwoofer */
11580 			{ }
11581 		},
11582 		.chained = true,
11583 		.chain_id = ALC662_FIXUP_LED_GPIO1,
11584 	},
11585 	[ALC272_FIXUP_MARIO] = {
11586 		.type = HDA_FIXUP_FUNC,
11587 		.v.func = alc272_fixup_mario,
11588 	},
11589 	[ALC662_FIXUP_CZC_ET26] = {
11590 		.type = HDA_FIXUP_PINS,
11591 		.v.pins = (const struct hda_pintbl[]) {
11592 			{0x12, 0x403cc000},
11593 			{0x14, 0x90170110}, /* speaker */
11594 			{0x15, 0x411111f0},
11595 			{0x16, 0x411111f0},
11596 			{0x18, 0x01a19030}, /* mic */
11597 			{0x19, 0x90a7013f}, /* int-mic */
11598 			{0x1a, 0x01014020},
11599 			{0x1b, 0x0121401f},
11600 			{0x1c, 0x411111f0},
11601 			{0x1d, 0x411111f0},
11602 			{0x1e, 0x40478e35},
11603 			{}
11604 		},
11605 		.chained = true,
11606 		.chain_id = ALC662_FIXUP_SKU_IGNORE
11607 	},
11608 	[ALC662_FIXUP_CZC_P10T] = {
11609 		.type = HDA_FIXUP_VERBS,
11610 		.v.verbs = (const struct hda_verb[]) {
11611 			{0x14, AC_VERB_SET_EAPD_BTLENABLE, 0},
11612 			{}
11613 		}
11614 	},
11615 	[ALC662_FIXUP_SKU_IGNORE] = {
11616 		.type = HDA_FIXUP_FUNC,
11617 		.v.func = alc_fixup_sku_ignore,
11618 	},
11619 	[ALC662_FIXUP_HP_RP5800] = {
11620 		.type = HDA_FIXUP_PINS,
11621 		.v.pins = (const struct hda_pintbl[]) {
11622 			{ 0x14, 0x0221201f }, /* HP out */
11623 			{ }
11624 		},
11625 		.chained = true,
11626 		.chain_id = ALC662_FIXUP_SKU_IGNORE
11627 	},
11628 	[ALC662_FIXUP_ASUS_MODE1] = {
11629 		.type = HDA_FIXUP_PINS,
11630 		.v.pins = (const struct hda_pintbl[]) {
11631 			{ 0x14, 0x99130110 }, /* speaker */
11632 			{ 0x18, 0x01a19c20 }, /* mic */
11633 			{ 0x19, 0x99a3092f }, /* int-mic */
11634 			{ 0x21, 0x0121401f }, /* HP out */
11635 			{ }
11636 		},
11637 		.chained = true,
11638 		.chain_id = ALC662_FIXUP_SKU_IGNORE
11639 	},
11640 	[ALC662_FIXUP_ASUS_MODE2] = {
11641 		.type = HDA_FIXUP_PINS,
11642 		.v.pins = (const struct hda_pintbl[]) {
11643 			{ 0x14, 0x99130110 }, /* speaker */
11644 			{ 0x18, 0x01a19820 }, /* mic */
11645 			{ 0x19, 0x99a3092f }, /* int-mic */
11646 			{ 0x1b, 0x0121401f }, /* HP out */
11647 			{ }
11648 		},
11649 		.chained = true,
11650 		.chain_id = ALC662_FIXUP_SKU_IGNORE
11651 	},
11652 	[ALC662_FIXUP_ASUS_MODE3] = {
11653 		.type = HDA_FIXUP_PINS,
11654 		.v.pins = (const struct hda_pintbl[]) {
11655 			{ 0x14, 0x99130110 }, /* speaker */
11656 			{ 0x15, 0x0121441f }, /* HP */
11657 			{ 0x18, 0x01a19840 }, /* mic */
11658 			{ 0x19, 0x99a3094f }, /* int-mic */
11659 			{ 0x21, 0x01211420 }, /* HP2 */
11660 			{ }
11661 		},
11662 		.chained = true,
11663 		.chain_id = ALC662_FIXUP_SKU_IGNORE
11664 	},
11665 	[ALC662_FIXUP_ASUS_MODE4] = {
11666 		.type = HDA_FIXUP_PINS,
11667 		.v.pins = (const struct hda_pintbl[]) {
11668 			{ 0x14, 0x99130110 }, /* speaker */
11669 			{ 0x16, 0x99130111 }, /* speaker */
11670 			{ 0x18, 0x01a19840 }, /* mic */
11671 			{ 0x19, 0x99a3094f }, /* int-mic */
11672 			{ 0x21, 0x0121441f }, /* HP */
11673 			{ }
11674 		},
11675 		.chained = true,
11676 		.chain_id = ALC662_FIXUP_SKU_IGNORE
11677 	},
11678 	[ALC662_FIXUP_ASUS_MODE5] = {
11679 		.type = HDA_FIXUP_PINS,
11680 		.v.pins = (const struct hda_pintbl[]) {
11681 			{ 0x14, 0x99130110 }, /* speaker */
11682 			{ 0x15, 0x0121441f }, /* HP */
11683 			{ 0x16, 0x99130111 }, /* speaker */
11684 			{ 0x18, 0x01a19840 }, /* mic */
11685 			{ 0x19, 0x99a3094f }, /* int-mic */
11686 			{ }
11687 		},
11688 		.chained = true,
11689 		.chain_id = ALC662_FIXUP_SKU_IGNORE
11690 	},
11691 	[ALC662_FIXUP_ASUS_MODE6] = {
11692 		.type = HDA_FIXUP_PINS,
11693 		.v.pins = (const struct hda_pintbl[]) {
11694 			{ 0x14, 0x99130110 }, /* speaker */
11695 			{ 0x15, 0x01211420 }, /* HP2 */
11696 			{ 0x18, 0x01a19840 }, /* mic */
11697 			{ 0x19, 0x99a3094f }, /* int-mic */
11698 			{ 0x1b, 0x0121441f }, /* HP */
11699 			{ }
11700 		},
11701 		.chained = true,
11702 		.chain_id = ALC662_FIXUP_SKU_IGNORE
11703 	},
11704 	[ALC662_FIXUP_ASUS_MODE7] = {
11705 		.type = HDA_FIXUP_PINS,
11706 		.v.pins = (const struct hda_pintbl[]) {
11707 			{ 0x14, 0x99130110 }, /* speaker */
11708 			{ 0x17, 0x99130111 }, /* speaker */
11709 			{ 0x18, 0x01a19840 }, /* mic */
11710 			{ 0x19, 0x99a3094f }, /* int-mic */
11711 			{ 0x1b, 0x01214020 }, /* HP */
11712 			{ 0x21, 0x0121401f }, /* HP */
11713 			{ }
11714 		},
11715 		.chained = true,
11716 		.chain_id = ALC662_FIXUP_SKU_IGNORE
11717 	},
11718 	[ALC662_FIXUP_ASUS_MODE8] = {
11719 		.type = HDA_FIXUP_PINS,
11720 		.v.pins = (const struct hda_pintbl[]) {
11721 			{ 0x14, 0x99130110 }, /* speaker */
11722 			{ 0x12, 0x99a30970 }, /* int-mic */
11723 			{ 0x15, 0x01214020 }, /* HP */
11724 			{ 0x17, 0x99130111 }, /* speaker */
11725 			{ 0x18, 0x01a19840 }, /* mic */
11726 			{ 0x21, 0x0121401f }, /* HP */
11727 			{ }
11728 		},
11729 		.chained = true,
11730 		.chain_id = ALC662_FIXUP_SKU_IGNORE
11731 	},
11732 	[ALC662_FIXUP_NO_JACK_DETECT] = {
11733 		.type = HDA_FIXUP_FUNC,
11734 		.v.func = alc_fixup_no_jack_detect,
11735 	},
11736 	[ALC662_FIXUP_ZOTAC_Z68] = {
11737 		.type = HDA_FIXUP_PINS,
11738 		.v.pins = (const struct hda_pintbl[]) {
11739 			{ 0x1b, 0x02214020 }, /* Front HP */
11740 			{ }
11741 		}
11742 	},
11743 	[ALC662_FIXUP_INV_DMIC] = {
11744 		.type = HDA_FIXUP_FUNC,
11745 		.v.func = alc_fixup_inv_dmic,
11746 	},
11747 	[ALC668_FIXUP_DELL_XPS13] = {
11748 		.type = HDA_FIXUP_FUNC,
11749 		.v.func = alc_fixup_dell_xps13,
11750 		.chained = true,
11751 		.chain_id = ALC668_FIXUP_DELL_DISABLE_AAMIX
11752 	},
11753 	[ALC668_FIXUP_DELL_DISABLE_AAMIX] = {
11754 		.type = HDA_FIXUP_FUNC,
11755 		.v.func = alc_fixup_disable_aamix,
11756 		.chained = true,
11757 		.chain_id = ALC668_FIXUP_DELL_MIC_NO_PRESENCE
11758 	},
11759 	[ALC668_FIXUP_AUTO_MUTE] = {
11760 		.type = HDA_FIXUP_FUNC,
11761 		.v.func = alc_fixup_auto_mute_via_amp,
11762 		.chained = true,
11763 		.chain_id = ALC668_FIXUP_DELL_MIC_NO_PRESENCE
11764 	},
11765 	[ALC662_FIXUP_DELL_MIC_NO_PRESENCE] = {
11766 		.type = HDA_FIXUP_PINS,
11767 		.v.pins = (const struct hda_pintbl[]) {
11768 			{ 0x19, 0x03a1113c }, /* use as headset mic, without its own jack detect */
11769 			/* headphone mic by setting pin control of 0x1b (headphone out) to in + vref_50 */
11770 			{ }
11771 		},
11772 		.chained = true,
11773 		.chain_id = ALC662_FIXUP_HEADSET_MODE
11774 	},
11775 	[ALC662_FIXUP_HEADSET_MODE] = {
11776 		.type = HDA_FIXUP_FUNC,
11777 		.v.func = alc_fixup_headset_mode_alc662,
11778 	},
11779 	[ALC668_FIXUP_DELL_MIC_NO_PRESENCE] = {
11780 		.type = HDA_FIXUP_PINS,
11781 		.v.pins = (const struct hda_pintbl[]) {
11782 			{ 0x19, 0x03a1913d }, /* use as headphone mic, without its own jack detect */
11783 			{ 0x1b, 0x03a1113c }, /* use as headset mic, without its own jack detect */
11784 			{ }
11785 		},
11786 		.chained = true,
11787 		.chain_id = ALC668_FIXUP_HEADSET_MODE
11788 	},
11789 	[ALC668_FIXUP_HEADSET_MODE] = {
11790 		.type = HDA_FIXUP_FUNC,
11791 		.v.func = alc_fixup_headset_mode_alc668,
11792 	},
11793 	[ALC662_FIXUP_BASS_MODE4_CHMAP] = {
11794 		.type = HDA_FIXUP_FUNC,
11795 		.v.func = alc_fixup_bass_chmap,
11796 		.chained = true,
11797 		.chain_id = ALC662_FIXUP_ASUS_MODE4
11798 	},
11799 	[ALC662_FIXUP_BASS_16] = {
11800 		.type = HDA_FIXUP_PINS,
11801 		.v.pins = (const struct hda_pintbl[]) {
11802 			{0x16, 0x80106111}, /* bass speaker */
11803 			{}
11804 		},
11805 		.chained = true,
11806 		.chain_id = ALC662_FIXUP_BASS_CHMAP,
11807 	},
11808 	[ALC662_FIXUP_BASS_1A] = {
11809 		.type = HDA_FIXUP_PINS,
11810 		.v.pins = (const struct hda_pintbl[]) {
11811 			{0x1a, 0x80106111}, /* bass speaker */
11812 			{}
11813 		},
11814 		.chained = true,
11815 		.chain_id = ALC662_FIXUP_BASS_CHMAP,
11816 	},
11817 	[ALC662_FIXUP_BASS_CHMAP] = {
11818 		.type = HDA_FIXUP_FUNC,
11819 		.v.func = alc_fixup_bass_chmap,
11820 	},
11821 	[ALC662_FIXUP_ASUS_Nx50] = {
11822 		.type = HDA_FIXUP_FUNC,
11823 		.v.func = alc_fixup_auto_mute_via_amp,
11824 		.chained = true,
11825 		.chain_id = ALC662_FIXUP_BASS_1A
11826 	},
11827 	[ALC668_FIXUP_ASUS_Nx51_HEADSET_MODE] = {
11828 		.type = HDA_FIXUP_FUNC,
11829 		.v.func = alc_fixup_headset_mode_alc668,
11830 		.chain_id = ALC662_FIXUP_BASS_CHMAP
11831 	},
11832 	[ALC668_FIXUP_ASUS_Nx51] = {
11833 		.type = HDA_FIXUP_PINS,
11834 		.v.pins = (const struct hda_pintbl[]) {
11835 			{ 0x19, 0x03a1913d }, /* use as headphone mic, without its own jack detect */
11836 			{ 0x1a, 0x90170151 }, /* bass speaker */
11837 			{ 0x1b, 0x03a1113c }, /* use as headset mic, without its own jack detect */
11838 			{}
11839 		},
11840 		.chained = true,
11841 		.chain_id = ALC668_FIXUP_ASUS_Nx51_HEADSET_MODE,
11842 	},
11843 	[ALC668_FIXUP_MIC_COEF] = {
11844 		.type = HDA_FIXUP_VERBS,
11845 		.v.verbs = (const struct hda_verb[]) {
11846 			{ 0x20, AC_VERB_SET_COEF_INDEX, 0xc3 },
11847 			{ 0x20, AC_VERB_SET_PROC_COEF, 0x4000 },
11848 			{}
11849 		},
11850 	},
11851 	[ALC668_FIXUP_ASUS_G751] = {
11852 		.type = HDA_FIXUP_PINS,
11853 		.v.pins = (const struct hda_pintbl[]) {
11854 			{ 0x16, 0x0421101f }, /* HP */
11855 			{}
11856 		},
11857 		.chained = true,
11858 		.chain_id = ALC668_FIXUP_MIC_COEF
11859 	},
11860 	[ALC891_FIXUP_HEADSET_MODE] = {
11861 		.type = HDA_FIXUP_FUNC,
11862 		.v.func = alc_fixup_headset_mode,
11863 	},
11864 	[ALC891_FIXUP_DELL_MIC_NO_PRESENCE] = {
11865 		.type = HDA_FIXUP_PINS,
11866 		.v.pins = (const struct hda_pintbl[]) {
11867 			{ 0x19, 0x03a1913d }, /* use as headphone mic, without its own jack detect */
11868 			{ 0x1b, 0x03a1113c }, /* use as headset mic, without its own jack detect */
11869 			{ }
11870 		},
11871 		.chained = true,
11872 		.chain_id = ALC891_FIXUP_HEADSET_MODE
11873 	},
11874 	[ALC662_FIXUP_ACER_VERITON] = {
11875 		.type = HDA_FIXUP_PINS,
11876 		.v.pins = (const struct hda_pintbl[]) {
11877 			{ 0x15, 0x50170120 }, /* no internal speaker */
11878 			{ }
11879 		}
11880 	},
11881 	[ALC892_FIXUP_ASROCK_MOBO] = {
11882 		.type = HDA_FIXUP_PINS,
11883 		.v.pins = (const struct hda_pintbl[]) {
11884 			{ 0x15, 0x40f000f0 }, /* disabled */
11885 			{ 0x16, 0x40f000f0 }, /* disabled */
11886 			{ }
11887 		}
11888 	},
11889 	[ALC662_FIXUP_USI_FUNC] = {
11890 		.type = HDA_FIXUP_FUNC,
11891 		.v.func = alc662_fixup_usi_headset_mic,
11892 	},
11893 	[ALC662_FIXUP_USI_HEADSET_MODE] = {
11894 		.type = HDA_FIXUP_PINS,
11895 		.v.pins = (const struct hda_pintbl[]) {
11896 			{ 0x19, 0x02a1913c }, /* use as headset mic, without its own jack detect */
11897 			{ 0x18, 0x01a1903d },
11898 			{ }
11899 		},
11900 		.chained = true,
11901 		.chain_id = ALC662_FIXUP_USI_FUNC
11902 	},
11903 	[ALC662_FIXUP_LENOVO_MULTI_CODECS] = {
11904 		.type = HDA_FIXUP_FUNC,
11905 		.v.func = alc233_alc662_fixup_lenovo_dual_codecs,
11906 	},
11907 	[ALC669_FIXUP_ACER_ASPIRE_ETHOS_HEADSET] = {
11908 		.type = HDA_FIXUP_FUNC,
11909 		.v.func = alc662_fixup_aspire_ethos_hp,
11910 	},
11911 	[ALC669_FIXUP_ACER_ASPIRE_ETHOS] = {
11912 		.type = HDA_FIXUP_PINS,
11913 		.v.pins = (const struct hda_pintbl[]) {
11914 			{ 0x15, 0x92130110 }, /* front speakers */
11915 			{ 0x18, 0x99130111 }, /* center/subwoofer */
11916 			{ 0x1b, 0x11130012 }, /* surround plus jack for HP */
11917 			{ }
11918 		},
11919 		.chained = true,
11920 		.chain_id = ALC669_FIXUP_ACER_ASPIRE_ETHOS_HEADSET
11921 	},
11922 	[ALC671_FIXUP_HP_HEADSET_MIC2] = {
11923 		.type = HDA_FIXUP_FUNC,
11924 		.v.func = alc671_fixup_hp_headset_mic2,
11925 	},
11926 	[ALC662_FIXUP_ACER_X2660G_HEADSET_MODE] = {
11927 		.type = HDA_FIXUP_PINS,
11928 		.v.pins = (const struct hda_pintbl[]) {
11929 			{ 0x1a, 0x02a1113c }, /* use as headset mic, without its own jack detect */
11930 			{ }
11931 		},
11932 		.chained = true,
11933 		.chain_id = ALC662_FIXUP_USI_FUNC
11934 	},
11935 	[ALC662_FIXUP_ACER_NITRO_HEADSET_MODE] = {
11936 		.type = HDA_FIXUP_PINS,
11937 		.v.pins = (const struct hda_pintbl[]) {
11938 			{ 0x1a, 0x01a11140 }, /* use as headset mic, without its own jack detect */
11939 			{ 0x1b, 0x0221144f },
11940 			{ }
11941 		},
11942 		.chained = true,
11943 		.chain_id = ALC662_FIXUP_USI_FUNC
11944 	},
11945 	[ALC668_FIXUP_ASUS_NO_HEADSET_MIC] = {
11946 		.type = HDA_FIXUP_PINS,
11947 		.v.pins = (const struct hda_pintbl[]) {
11948 			{ 0x1b, 0x04a1112c },
11949 			{ }
11950 		},
11951 		.chained = true,
11952 		.chain_id = ALC668_FIXUP_HEADSET_MIC
11953 	},
11954 	[ALC668_FIXUP_HEADSET_MIC] = {
11955 		.type = HDA_FIXUP_FUNC,
11956 		.v.func = alc269_fixup_headset_mic,
11957 		.chained = true,
11958 		.chain_id = ALC668_FIXUP_MIC_DET_COEF
11959 	},
11960 	[ALC668_FIXUP_MIC_DET_COEF] = {
11961 		.type = HDA_FIXUP_VERBS,
11962 		.v.verbs = (const struct hda_verb[]) {
11963 			{ 0x20, AC_VERB_SET_COEF_INDEX, 0x15 },
11964 			{ 0x20, AC_VERB_SET_PROC_COEF, 0x0d60 },
11965 			{}
11966 		},
11967 	},
11968 	[ALC897_FIXUP_LENOVO_HEADSET_MIC] = {
11969 		.type = HDA_FIXUP_FUNC,
11970 		.v.func = alc897_fixup_lenovo_headset_mic,
11971 	},
11972 	[ALC897_FIXUP_HEADSET_MIC_PIN] = {
11973 		.type = HDA_FIXUP_PINS,
11974 		.v.pins = (const struct hda_pintbl[]) {
11975 			{ 0x1a, 0x03a11050 },
11976 			{ }
11977 		},
11978 		.chained = true,
11979 		.chain_id = ALC897_FIXUP_LENOVO_HEADSET_MIC
11980 	},
11981 	[ALC897_FIXUP_HP_HSMIC_VERB] = {
11982 		.type = HDA_FIXUP_PINS,
11983 		.v.pins = (const struct hda_pintbl[]) {
11984 			{ 0x19, 0x01a1913c }, /* use as headset mic, without its own jack detect */
11985 			{ }
11986 		},
11987 	},
11988 	[ALC897_FIXUP_LENOVO_HEADSET_MODE] = {
11989 		.type = HDA_FIXUP_FUNC,
11990 		.v.func = alc897_fixup_lenovo_headset_mode,
11991 	},
11992 	[ALC897_FIXUP_HEADSET_MIC_PIN2] = {
11993 		.type = HDA_FIXUP_PINS,
11994 		.v.pins = (const struct hda_pintbl[]) {
11995 			{ 0x1a, 0x01a11140 }, /* use as headset mic, without its own jack detect */
11996 			{ }
11997 		},
11998 		.chained = true,
11999 		.chain_id = ALC897_FIXUP_LENOVO_HEADSET_MODE
12000 	},
12001 	[ALC897_FIXUP_UNIS_H3C_X500S] = {
12002 		.type = HDA_FIXUP_VERBS,
12003 		.v.verbs = (const struct hda_verb[]) {
12004 			{ 0x14, AC_VERB_SET_EAPD_BTLENABLE, 0 },
12005 			{}
12006 		},
12007 	},
12008 };
12009 
12010 static const struct snd_pci_quirk alc662_fixup_tbl[] = {
12011 	SND_PCI_QUIRK(0x1019, 0x9087, "ECS", ALC662_FIXUP_ASUS_MODE2),
12012 	SND_PCI_QUIRK(0x1025, 0x022f, "Acer Aspire One", ALC662_FIXUP_INV_DMIC),
12013 	SND_PCI_QUIRK(0x1025, 0x0241, "Packard Bell DOTS", ALC662_FIXUP_INV_DMIC),
12014 	SND_PCI_QUIRK(0x1025, 0x0308, "Acer Aspire 8942G", ALC662_FIXUP_ASPIRE),
12015 	SND_PCI_QUIRK(0x1025, 0x031c, "Gateway NV79", ALC662_FIXUP_SKU_IGNORE),
12016 	SND_PCI_QUIRK(0x1025, 0x0349, "eMachines eM250", ALC662_FIXUP_INV_DMIC),
12017 	SND_PCI_QUIRK(0x1025, 0x034a, "Gateway LT27", ALC662_FIXUP_INV_DMIC),
12018 	SND_PCI_QUIRK(0x1025, 0x038b, "Acer Aspire 8943G", ALC662_FIXUP_ASPIRE),
12019 	SND_PCI_QUIRK(0x1025, 0x0566, "Acer Aspire Ethos 8951G", ALC669_FIXUP_ACER_ASPIRE_ETHOS),
12020 	SND_PCI_QUIRK(0x1025, 0x123c, "Acer Nitro N50-600", ALC662_FIXUP_ACER_NITRO_HEADSET_MODE),
12021 	SND_PCI_QUIRK(0x1025, 0x124e, "Acer 2660G", ALC662_FIXUP_ACER_X2660G_HEADSET_MODE),
12022 	SND_PCI_QUIRK(0x1028, 0x05d8, "Dell", ALC668_FIXUP_DELL_MIC_NO_PRESENCE),
12023 	SND_PCI_QUIRK(0x1028, 0x05db, "Dell", ALC668_FIXUP_DELL_MIC_NO_PRESENCE),
12024 	SND_PCI_QUIRK(0x1028, 0x05fe, "Dell XPS 15", ALC668_FIXUP_DELL_XPS13),
12025 	SND_PCI_QUIRK(0x1028, 0x060a, "Dell XPS 13", ALC668_FIXUP_DELL_XPS13),
12026 	SND_PCI_QUIRK(0x1028, 0x060d, "Dell M3800", ALC668_FIXUP_DELL_XPS13),
12027 	SND_PCI_QUIRK(0x1028, 0x0625, "Dell", ALC668_FIXUP_DELL_MIC_NO_PRESENCE),
12028 	SND_PCI_QUIRK(0x1028, 0x0626, "Dell", ALC668_FIXUP_DELL_MIC_NO_PRESENCE),
12029 	SND_PCI_QUIRK(0x1028, 0x0696, "Dell", ALC668_FIXUP_DELL_MIC_NO_PRESENCE),
12030 	SND_PCI_QUIRK(0x1028, 0x0698, "Dell", ALC668_FIXUP_DELL_MIC_NO_PRESENCE),
12031 	SND_PCI_QUIRK(0x1028, 0x069f, "Dell", ALC668_FIXUP_DELL_MIC_NO_PRESENCE),
12032 	SND_PCI_QUIRK(0x103c, 0x1632, "HP RP5800", ALC662_FIXUP_HP_RP5800),
12033 	SND_PCI_QUIRK(0x103c, 0x870c, "HP", ALC897_FIXUP_HP_HSMIC_VERB),
12034 	SND_PCI_QUIRK(0x103c, 0x8719, "HP", ALC897_FIXUP_HP_HSMIC_VERB),
12035 	SND_PCI_QUIRK(0x103c, 0x872b, "HP", ALC897_FIXUP_HP_HSMIC_VERB),
12036 	SND_PCI_QUIRK(0x103c, 0x873e, "HP", ALC671_FIXUP_HP_HEADSET_MIC2),
12037 	SND_PCI_QUIRK(0x103c, 0x8768, "HP Slim Desktop S01", ALC671_FIXUP_HP_HEADSET_MIC2),
12038 	SND_PCI_QUIRK(0x103c, 0x877e, "HP 288 Pro G6", ALC671_FIXUP_HP_HEADSET_MIC2),
12039 	SND_PCI_QUIRK(0x103c, 0x885f, "HP 288 Pro G8", ALC671_FIXUP_HP_HEADSET_MIC2),
12040 	SND_PCI_QUIRK(0x1043, 0x1080, "Asus UX501VW", ALC668_FIXUP_HEADSET_MODE),
12041 	SND_PCI_QUIRK(0x1043, 0x11cd, "Asus N550", ALC662_FIXUP_ASUS_Nx50),
12042 	SND_PCI_QUIRK(0x1043, 0x129d, "Asus N750", ALC662_FIXUP_ASUS_Nx50),
12043 	SND_PCI_QUIRK(0x1043, 0x12ff, "ASUS G751", ALC668_FIXUP_ASUS_G751),
12044 	SND_PCI_QUIRK(0x1043, 0x13df, "Asus N550JX", ALC662_FIXUP_BASS_1A),
12045 	SND_PCI_QUIRK(0x1043, 0x1477, "ASUS N56VZ", ALC662_FIXUP_BASS_MODE4_CHMAP),
12046 	SND_PCI_QUIRK(0x1043, 0x15a7, "ASUS UX51VZH", ALC662_FIXUP_BASS_16),
12047 	SND_PCI_QUIRK(0x1043, 0x177d, "ASUS N551", ALC668_FIXUP_ASUS_Nx51),
12048 	SND_PCI_QUIRK(0x1043, 0x17bd, "ASUS N751", ALC668_FIXUP_ASUS_Nx51),
12049 	SND_PCI_QUIRK(0x1043, 0x185d, "ASUS G551JW", ALC668_FIXUP_ASUS_NO_HEADSET_MIC),
12050 	SND_PCI_QUIRK(0x1043, 0x1963, "ASUS X71SL", ALC662_FIXUP_ASUS_MODE8),
12051 	SND_PCI_QUIRK(0x1043, 0x1b73, "ASUS N55SF", ALC662_FIXUP_BASS_16),
12052 	SND_PCI_QUIRK(0x1043, 0x1bf3, "ASUS N76VZ", ALC662_FIXUP_BASS_MODE4_CHMAP),
12053 	SND_PCI_QUIRK(0x1043, 0x8469, "ASUS mobo", ALC662_FIXUP_NO_JACK_DETECT),
12054 	SND_PCI_QUIRK(0x105b, 0x0cd6, "Foxconn", ALC662_FIXUP_ASUS_MODE2),
12055 	SND_PCI_QUIRK(0x144d, 0xc051, "Samsung R720", ALC662_FIXUP_IDEAPAD),
12056 	SND_PCI_QUIRK(0x14cd, 0x5003, "USI", ALC662_FIXUP_USI_HEADSET_MODE),
12057 	SND_PCI_QUIRK(0x17aa, 0x1036, "Lenovo P520", ALC662_FIXUP_LENOVO_MULTI_CODECS),
12058 	SND_PCI_QUIRK(0x17aa, 0x1057, "Lenovo P360", ALC897_FIXUP_HEADSET_MIC_PIN),
12059 	SND_PCI_QUIRK(0x17aa, 0x1064, "Lenovo P3 Tower", ALC897_FIXUP_HEADSET_MIC_PIN),
12060 	SND_PCI_QUIRK(0x17aa, 0x32ca, "Lenovo ThinkCentre M80", ALC897_FIXUP_HEADSET_MIC_PIN),
12061 	SND_PCI_QUIRK(0x17aa, 0x32cb, "Lenovo ThinkCentre M70", ALC897_FIXUP_HEADSET_MIC_PIN),
12062 	SND_PCI_QUIRK(0x17aa, 0x32cf, "Lenovo ThinkCentre M950", ALC897_FIXUP_HEADSET_MIC_PIN),
12063 	SND_PCI_QUIRK(0x17aa, 0x32f7, "Lenovo ThinkCentre M90", ALC897_FIXUP_HEADSET_MIC_PIN),
12064 	SND_PCI_QUIRK(0x17aa, 0x3321, "Lenovo ThinkCentre M70 Gen4", ALC897_FIXUP_HEADSET_MIC_PIN),
12065 	SND_PCI_QUIRK(0x17aa, 0x331b, "Lenovo ThinkCentre M90 Gen4", ALC897_FIXUP_HEADSET_MIC_PIN),
12066 	SND_PCI_QUIRK(0x17aa, 0x3742, "Lenovo TianYi510Pro-14IOB", ALC897_FIXUP_HEADSET_MIC_PIN2),
12067 	SND_PCI_QUIRK(0x17aa, 0x38af, "Lenovo Ideapad Y550P", ALC662_FIXUP_IDEAPAD),
12068 	SND_PCI_QUIRK(0x17aa, 0x3a0d, "Lenovo Ideapad Y550", ALC662_FIXUP_IDEAPAD),
12069 	SND_PCI_QUIRK(0x1849, 0x5892, "ASRock B150M", ALC892_FIXUP_ASROCK_MOBO),
12070 	SND_PCI_QUIRK(0x19da, 0xa130, "Zotac Z68", ALC662_FIXUP_ZOTAC_Z68),
12071 	SND_PCI_QUIRK(0x1b0a, 0x01b8, "ACER Veriton", ALC662_FIXUP_ACER_VERITON),
12072 	SND_PCI_QUIRK(0x1b35, 0x1234, "CZC ET26", ALC662_FIXUP_CZC_ET26),
12073 	SND_PCI_QUIRK(0x1b35, 0x2206, "CZC P10T", ALC662_FIXUP_CZC_P10T),
12074 	SND_PCI_QUIRK(0x1c6c, 0x1239, "Compaq N14JP6-V2", ALC897_FIXUP_HP_HSMIC_VERB),
12075 
12076 #if 0
12077 	/* Below is a quirk table taken from the old code.
12078 	 * Basically the device should work as is without the fixup table.
12079 	 * If BIOS doesn't give a proper info, enable the corresponding
12080 	 * fixup entry.
12081 	 */
12082 	SND_PCI_QUIRK(0x1043, 0x1000, "ASUS N50Vm", ALC662_FIXUP_ASUS_MODE1),
12083 	SND_PCI_QUIRK(0x1043, 0x1092, "ASUS NB", ALC662_FIXUP_ASUS_MODE3),
12084 	SND_PCI_QUIRK(0x1043, 0x1173, "ASUS K73Jn", ALC662_FIXUP_ASUS_MODE1),
12085 	SND_PCI_QUIRK(0x1043, 0x11c3, "ASUS M70V", ALC662_FIXUP_ASUS_MODE3),
12086 	SND_PCI_QUIRK(0x1043, 0x11d3, "ASUS NB", ALC662_FIXUP_ASUS_MODE1),
12087 	SND_PCI_QUIRK(0x1043, 0x11f3, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),
12088 	SND_PCI_QUIRK(0x1043, 0x1203, "ASUS NB", ALC662_FIXUP_ASUS_MODE1),
12089 	SND_PCI_QUIRK(0x1043, 0x1303, "ASUS G60J", ALC662_FIXUP_ASUS_MODE1),
12090 	SND_PCI_QUIRK(0x1043, 0x1333, "ASUS G60Jx", ALC662_FIXUP_ASUS_MODE1),
12091 	SND_PCI_QUIRK(0x1043, 0x1339, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),
12092 	SND_PCI_QUIRK(0x1043, 0x13e3, "ASUS N71JA", ALC662_FIXUP_ASUS_MODE7),
12093 	SND_PCI_QUIRK(0x1043, 0x1463, "ASUS N71", ALC662_FIXUP_ASUS_MODE7),
12094 	SND_PCI_QUIRK(0x1043, 0x14d3, "ASUS G72", ALC662_FIXUP_ASUS_MODE8),
12095 	SND_PCI_QUIRK(0x1043, 0x1563, "ASUS N90", ALC662_FIXUP_ASUS_MODE3),
12096 	SND_PCI_QUIRK(0x1043, 0x15d3, "ASUS N50SF F50SF", ALC662_FIXUP_ASUS_MODE1),
12097 	SND_PCI_QUIRK(0x1043, 0x16c3, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),
12098 	SND_PCI_QUIRK(0x1043, 0x16f3, "ASUS K40C K50C", ALC662_FIXUP_ASUS_MODE2),
12099 	SND_PCI_QUIRK(0x1043, 0x1733, "ASUS N81De", ALC662_FIXUP_ASUS_MODE1),
12100 	SND_PCI_QUIRK(0x1043, 0x1753, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),
12101 	SND_PCI_QUIRK(0x1043, 0x1763, "ASUS NB", ALC662_FIXUP_ASUS_MODE6),
12102 	SND_PCI_QUIRK(0x1043, 0x1765, "ASUS NB", ALC662_FIXUP_ASUS_MODE6),
12103 	SND_PCI_QUIRK(0x1043, 0x1783, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),
12104 	SND_PCI_QUIRK(0x1043, 0x1793, "ASUS F50GX", ALC662_FIXUP_ASUS_MODE1),
12105 	SND_PCI_QUIRK(0x1043, 0x17b3, "ASUS F70SL", ALC662_FIXUP_ASUS_MODE3),
12106 	SND_PCI_QUIRK(0x1043, 0x17f3, "ASUS X58LE", ALC662_FIXUP_ASUS_MODE2),
12107 	SND_PCI_QUIRK(0x1043, 0x1813, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),
12108 	SND_PCI_QUIRK(0x1043, 0x1823, "ASUS NB", ALC662_FIXUP_ASUS_MODE5),
12109 	SND_PCI_QUIRK(0x1043, 0x1833, "ASUS NB", ALC662_FIXUP_ASUS_MODE6),
12110 	SND_PCI_QUIRK(0x1043, 0x1843, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),
12111 	SND_PCI_QUIRK(0x1043, 0x1853, "ASUS F50Z", ALC662_FIXUP_ASUS_MODE1),
12112 	SND_PCI_QUIRK(0x1043, 0x1864, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),
12113 	SND_PCI_QUIRK(0x1043, 0x1876, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),
12114 	SND_PCI_QUIRK(0x1043, 0x1893, "ASUS M50Vm", ALC662_FIXUP_ASUS_MODE3),
12115 	SND_PCI_QUIRK(0x1043, 0x1894, "ASUS X55", ALC662_FIXUP_ASUS_MODE3),
12116 	SND_PCI_QUIRK(0x1043, 0x18b3, "ASUS N80Vc", ALC662_FIXUP_ASUS_MODE1),
12117 	SND_PCI_QUIRK(0x1043, 0x18c3, "ASUS VX5", ALC662_FIXUP_ASUS_MODE1),
12118 	SND_PCI_QUIRK(0x1043, 0x18d3, "ASUS N81Te", ALC662_FIXUP_ASUS_MODE1),
12119 	SND_PCI_QUIRK(0x1043, 0x18f3, "ASUS N505Tp", ALC662_FIXUP_ASUS_MODE1),
12120 	SND_PCI_QUIRK(0x1043, 0x1903, "ASUS F5GL", ALC662_FIXUP_ASUS_MODE1),
12121 	SND_PCI_QUIRK(0x1043, 0x1913, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),
12122 	SND_PCI_QUIRK(0x1043, 0x1933, "ASUS F80Q", ALC662_FIXUP_ASUS_MODE2),
12123 	SND_PCI_QUIRK(0x1043, 0x1943, "ASUS Vx3V", ALC662_FIXUP_ASUS_MODE1),
12124 	SND_PCI_QUIRK(0x1043, 0x1953, "ASUS NB", ALC662_FIXUP_ASUS_MODE1),
12125 	SND_PCI_QUIRK(0x1043, 0x1963, "ASUS X71C", ALC662_FIXUP_ASUS_MODE3),
12126 	SND_PCI_QUIRK(0x1043, 0x1983, "ASUS N5051A", ALC662_FIXUP_ASUS_MODE1),
12127 	SND_PCI_QUIRK(0x1043, 0x1993, "ASUS N20", ALC662_FIXUP_ASUS_MODE1),
12128 	SND_PCI_QUIRK(0x1043, 0x19b3, "ASUS F7Z", ALC662_FIXUP_ASUS_MODE1),
12129 	SND_PCI_QUIRK(0x1043, 0x19c3, "ASUS F5Z/F6x", ALC662_FIXUP_ASUS_MODE2),
12130 	SND_PCI_QUIRK(0x1043, 0x19e3, "ASUS NB", ALC662_FIXUP_ASUS_MODE1),
12131 	SND_PCI_QUIRK(0x1043, 0x19f3, "ASUS NB", ALC662_FIXUP_ASUS_MODE4),
12132 #endif
12133 	{}
12134 };
12135 
12136 static const struct hda_model_fixup alc662_fixup_models[] = {
12137 	{.id = ALC662_FIXUP_ASPIRE, .name = "aspire"},
12138 	{.id = ALC662_FIXUP_IDEAPAD, .name = "ideapad"},
12139 	{.id = ALC272_FIXUP_MARIO, .name = "mario"},
12140 	{.id = ALC662_FIXUP_HP_RP5800, .name = "hp-rp5800"},
12141 	{.id = ALC662_FIXUP_ASUS_MODE1, .name = "asus-mode1"},
12142 	{.id = ALC662_FIXUP_ASUS_MODE2, .name = "asus-mode2"},
12143 	{.id = ALC662_FIXUP_ASUS_MODE3, .name = "asus-mode3"},
12144 	{.id = ALC662_FIXUP_ASUS_MODE4, .name = "asus-mode4"},
12145 	{.id = ALC662_FIXUP_ASUS_MODE5, .name = "asus-mode5"},
12146 	{.id = ALC662_FIXUP_ASUS_MODE6, .name = "asus-mode6"},
12147 	{.id = ALC662_FIXUP_ASUS_MODE7, .name = "asus-mode7"},
12148 	{.id = ALC662_FIXUP_ASUS_MODE8, .name = "asus-mode8"},
12149 	{.id = ALC662_FIXUP_ZOTAC_Z68, .name = "zotac-z68"},
12150 	{.id = ALC662_FIXUP_INV_DMIC, .name = "inv-dmic"},
12151 	{.id = ALC662_FIXUP_DELL_MIC_NO_PRESENCE, .name = "alc662-headset-multi"},
12152 	{.id = ALC668_FIXUP_DELL_MIC_NO_PRESENCE, .name = "dell-headset-multi"},
12153 	{.id = ALC662_FIXUP_HEADSET_MODE, .name = "alc662-headset"},
12154 	{.id = ALC668_FIXUP_HEADSET_MODE, .name = "alc668-headset"},
12155 	{.id = ALC662_FIXUP_BASS_16, .name = "bass16"},
12156 	{.id = ALC662_FIXUP_BASS_1A, .name = "bass1a"},
12157 	{.id = ALC668_FIXUP_AUTO_MUTE, .name = "automute"},
12158 	{.id = ALC668_FIXUP_DELL_XPS13, .name = "dell-xps13"},
12159 	{.id = ALC662_FIXUP_ASUS_Nx50, .name = "asus-nx50"},
12160 	{.id = ALC668_FIXUP_ASUS_Nx51, .name = "asus-nx51"},
12161 	{.id = ALC668_FIXUP_ASUS_G751, .name = "asus-g751"},
12162 	{.id = ALC891_FIXUP_HEADSET_MODE, .name = "alc891-headset"},
12163 	{.id = ALC891_FIXUP_DELL_MIC_NO_PRESENCE, .name = "alc891-headset-multi"},
12164 	{.id = ALC662_FIXUP_ACER_VERITON, .name = "acer-veriton"},
12165 	{.id = ALC892_FIXUP_ASROCK_MOBO, .name = "asrock-mobo"},
12166 	{.id = ALC662_FIXUP_USI_HEADSET_MODE, .name = "usi-headset"},
12167 	{.id = ALC662_FIXUP_LENOVO_MULTI_CODECS, .name = "dual-codecs"},
12168 	{.id = ALC669_FIXUP_ACER_ASPIRE_ETHOS, .name = "aspire-ethos"},
12169 	{.id = ALC897_FIXUP_UNIS_H3C_X500S, .name = "unis-h3c-x500s"},
12170 	{}
12171 };
12172 
12173 static const struct snd_hda_pin_quirk alc662_pin_fixup_tbl[] = {
12174 	SND_HDA_PIN_QUIRK(0x10ec0867, 0x1028, "Dell", ALC891_FIXUP_DELL_MIC_NO_PRESENCE,
12175 		{0x17, 0x02211010},
12176 		{0x18, 0x01a19030},
12177 		{0x1a, 0x01813040},
12178 		{0x21, 0x01014020}),
12179 	SND_HDA_PIN_QUIRK(0x10ec0867, 0x1028, "Dell", ALC891_FIXUP_DELL_MIC_NO_PRESENCE,
12180 		{0x16, 0x01813030},
12181 		{0x17, 0x02211010},
12182 		{0x18, 0x01a19040},
12183 		{0x21, 0x01014020}),
12184 	SND_HDA_PIN_QUIRK(0x10ec0662, 0x1028, "Dell", ALC662_FIXUP_DELL_MIC_NO_PRESENCE,
12185 		{0x14, 0x01014010},
12186 		{0x18, 0x01a19020},
12187 		{0x1a, 0x0181302f},
12188 		{0x1b, 0x0221401f}),
12189 	SND_HDA_PIN_QUIRK(0x10ec0668, 0x1028, "Dell", ALC668_FIXUP_AUTO_MUTE,
12190 		{0x12, 0x99a30130},
12191 		{0x14, 0x90170110},
12192 		{0x15, 0x0321101f},
12193 		{0x16, 0x03011020}),
12194 	SND_HDA_PIN_QUIRK(0x10ec0668, 0x1028, "Dell", ALC668_FIXUP_AUTO_MUTE,
12195 		{0x12, 0x99a30140},
12196 		{0x14, 0x90170110},
12197 		{0x15, 0x0321101f},
12198 		{0x16, 0x03011020}),
12199 	SND_HDA_PIN_QUIRK(0x10ec0668, 0x1028, "Dell", ALC668_FIXUP_AUTO_MUTE,
12200 		{0x12, 0x99a30150},
12201 		{0x14, 0x90170110},
12202 		{0x15, 0x0321101f},
12203 		{0x16, 0x03011020}),
12204 	SND_HDA_PIN_QUIRK(0x10ec0668, 0x1028, "Dell", ALC668_FIXUP_AUTO_MUTE,
12205 		{0x14, 0x90170110},
12206 		{0x15, 0x0321101f},
12207 		{0x16, 0x03011020}),
12208 	SND_HDA_PIN_QUIRK(0x10ec0668, 0x1028, "Dell XPS 15", ALC668_FIXUP_AUTO_MUTE,
12209 		{0x12, 0x90a60130},
12210 		{0x14, 0x90170110},
12211 		{0x15, 0x0321101f}),
12212 	SND_HDA_PIN_QUIRK(0x10ec0671, 0x103c, "HP cPC", ALC671_FIXUP_HP_HEADSET_MIC2,
12213 		{0x14, 0x01014010},
12214 		{0x17, 0x90170150},
12215 		{0x19, 0x02a11060},
12216 		{0x1b, 0x01813030},
12217 		{0x21, 0x02211020}),
12218 	SND_HDA_PIN_QUIRK(0x10ec0671, 0x103c, "HP cPC", ALC671_FIXUP_HP_HEADSET_MIC2,
12219 		{0x14, 0x01014010},
12220 		{0x18, 0x01a19040},
12221 		{0x1b, 0x01813030},
12222 		{0x21, 0x02211020}),
12223 	SND_HDA_PIN_QUIRK(0x10ec0671, 0x103c, "HP cPC", ALC671_FIXUP_HP_HEADSET_MIC2,
12224 		{0x14, 0x01014020},
12225 		{0x17, 0x90170110},
12226 		{0x18, 0x01a19050},
12227 		{0x1b, 0x01813040},
12228 		{0x21, 0x02211030}),
12229 	{}
12230 };
12231 
12232 /*
12233  */
patch_alc662(struct hda_codec * codec)12234 static int patch_alc662(struct hda_codec *codec)
12235 {
12236 	struct alc_spec *spec;
12237 	int err;
12238 
12239 	err = alc_alloc_spec(codec, 0x0b);
12240 	if (err < 0)
12241 		return err;
12242 
12243 	spec = codec->spec;
12244 
12245 	spec->shutup = alc_eapd_shutup;
12246 
12247 	/* handle multiple HPs as is */
12248 	spec->parse_flags = HDA_PINCFG_NO_HP_FIXUP;
12249 
12250 	alc_fix_pll_init(codec, 0x20, 0x04, 15);
12251 
12252 	switch (codec->core.vendor_id) {
12253 	case 0x10ec0668:
12254 		spec->init_hook = alc668_restore_default_value;
12255 		break;
12256 	}
12257 
12258 	alc_pre_init(codec);
12259 
12260 	snd_hda_pick_fixup(codec, alc662_fixup_models,
12261 		       alc662_fixup_tbl, alc662_fixups);
12262 	snd_hda_pick_pin_fixup(codec, alc662_pin_fixup_tbl, alc662_fixups, true);
12263 	snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE);
12264 
12265 	alc_auto_parse_customize_define(codec);
12266 
12267 	if (has_cdefine_beep(codec))
12268 		spec->gen.beep_nid = 0x01;
12269 
12270 	if ((alc_get_coef0(codec) & (1 << 14)) &&
12271 	    codec->bus->pci && codec->bus->pci->subsystem_vendor == 0x1025 &&
12272 	    spec->cdefine.platform_type == 1) {
12273 		err = alc_codec_rename(codec, "ALC272X");
12274 		if (err < 0)
12275 			goto error;
12276 	}
12277 
12278 	/* automatic parse from the BIOS config */
12279 	err = alc662_parse_auto_config(codec);
12280 	if (err < 0)
12281 		goto error;
12282 
12283 	if (!spec->gen.no_analog && spec->gen.beep_nid) {
12284 		switch (codec->core.vendor_id) {
12285 		case 0x10ec0662:
12286 			err = set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
12287 			break;
12288 		case 0x10ec0272:
12289 		case 0x10ec0663:
12290 		case 0x10ec0665:
12291 		case 0x10ec0668:
12292 			err = set_beep_amp(spec, 0x0b, 0x04, HDA_INPUT);
12293 			break;
12294 		case 0x10ec0273:
12295 			err = set_beep_amp(spec, 0x0b, 0x03, HDA_INPUT);
12296 			break;
12297 		}
12298 		if (err < 0)
12299 			goto error;
12300 	}
12301 
12302 	snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE);
12303 
12304 	return 0;
12305 
12306  error:
12307 	alc_free(codec);
12308 	return err;
12309 }
12310 
12311 /*
12312  * ALC680 support
12313  */
12314 
alc680_parse_auto_config(struct hda_codec * codec)12315 static int alc680_parse_auto_config(struct hda_codec *codec)
12316 {
12317 	return alc_parse_auto_config(codec, NULL, NULL);
12318 }
12319 
12320 /*
12321  */
patch_alc680(struct hda_codec * codec)12322 static int patch_alc680(struct hda_codec *codec)
12323 {
12324 	int err;
12325 
12326 	/* ALC680 has no aa-loopback mixer */
12327 	err = alc_alloc_spec(codec, 0);
12328 	if (err < 0)
12329 		return err;
12330 
12331 	/* automatic parse from the BIOS config */
12332 	err = alc680_parse_auto_config(codec);
12333 	if (err < 0) {
12334 		alc_free(codec);
12335 		return err;
12336 	}
12337 
12338 	return 0;
12339 }
12340 
12341 /*
12342  * patch entries
12343  */
12344 static const struct hda_device_id snd_hda_id_realtek[] = {
12345 	HDA_CODEC_ENTRY(0x10ec0215, "ALC215", patch_alc269),
12346 	HDA_CODEC_ENTRY(0x10ec0221, "ALC221", patch_alc269),
12347 	HDA_CODEC_ENTRY(0x10ec0222, "ALC222", patch_alc269),
12348 	HDA_CODEC_ENTRY(0x10ec0225, "ALC225", patch_alc269),
12349 	HDA_CODEC_ENTRY(0x10ec0230, "ALC236", patch_alc269),
12350 	HDA_CODEC_ENTRY(0x10ec0231, "ALC231", patch_alc269),
12351 	HDA_CODEC_ENTRY(0x10ec0233, "ALC233", patch_alc269),
12352 	HDA_CODEC_ENTRY(0x10ec0234, "ALC234", patch_alc269),
12353 	HDA_CODEC_ENTRY(0x10ec0235, "ALC233", patch_alc269),
12354 	HDA_CODEC_ENTRY(0x10ec0236, "ALC236", patch_alc269),
12355 	HDA_CODEC_ENTRY(0x10ec0245, "ALC245", patch_alc269),
12356 	HDA_CODEC_ENTRY(0x10ec0255, "ALC255", patch_alc269),
12357 	HDA_CODEC_ENTRY(0x10ec0256, "ALC256", patch_alc269),
12358 	HDA_CODEC_ENTRY(0x10ec0257, "ALC257", patch_alc269),
12359 	HDA_CODEC_ENTRY(0x10ec0260, "ALC260", patch_alc260),
12360 	HDA_CODEC_ENTRY(0x10ec0262, "ALC262", patch_alc262),
12361 	HDA_CODEC_ENTRY(0x10ec0267, "ALC267", patch_alc268),
12362 	HDA_CODEC_ENTRY(0x10ec0268, "ALC268", patch_alc268),
12363 	HDA_CODEC_ENTRY(0x10ec0269, "ALC269", patch_alc269),
12364 	HDA_CODEC_ENTRY(0x10ec0270, "ALC270", patch_alc269),
12365 	HDA_CODEC_ENTRY(0x10ec0272, "ALC272", patch_alc662),
12366 	HDA_CODEC_ENTRY(0x10ec0274, "ALC274", patch_alc269),
12367 	HDA_CODEC_ENTRY(0x10ec0275, "ALC275", patch_alc269),
12368 	HDA_CODEC_ENTRY(0x10ec0276, "ALC276", patch_alc269),
12369 	HDA_CODEC_ENTRY(0x10ec0280, "ALC280", patch_alc269),
12370 	HDA_CODEC_ENTRY(0x10ec0282, "ALC282", patch_alc269),
12371 	HDA_CODEC_ENTRY(0x10ec0283, "ALC283", patch_alc269),
12372 	HDA_CODEC_ENTRY(0x10ec0284, "ALC284", patch_alc269),
12373 	HDA_CODEC_ENTRY(0x10ec0285, "ALC285", patch_alc269),
12374 	HDA_CODEC_ENTRY(0x10ec0286, "ALC286", patch_alc269),
12375 	HDA_CODEC_ENTRY(0x10ec0287, "ALC287", patch_alc269),
12376 	HDA_CODEC_ENTRY(0x10ec0288, "ALC288", patch_alc269),
12377 	HDA_CODEC_ENTRY(0x10ec0289, "ALC289", patch_alc269),
12378 	HDA_CODEC_ENTRY(0x10ec0290, "ALC290", patch_alc269),
12379 	HDA_CODEC_ENTRY(0x10ec0292, "ALC292", patch_alc269),
12380 	HDA_CODEC_ENTRY(0x10ec0293, "ALC293", patch_alc269),
12381 	HDA_CODEC_ENTRY(0x10ec0294, "ALC294", patch_alc269),
12382 	HDA_CODEC_ENTRY(0x10ec0295, "ALC295", patch_alc269),
12383 	HDA_CODEC_ENTRY(0x10ec0298, "ALC298", patch_alc269),
12384 	HDA_CODEC_ENTRY(0x10ec0299, "ALC299", patch_alc269),
12385 	HDA_CODEC_ENTRY(0x10ec0300, "ALC300", patch_alc269),
12386 	HDA_CODEC_ENTRY(0x10ec0623, "ALC623", patch_alc269),
12387 	HDA_CODEC_REV_ENTRY(0x10ec0861, 0x100340, "ALC660", patch_alc861),
12388 	HDA_CODEC_ENTRY(0x10ec0660, "ALC660-VD", patch_alc861vd),
12389 	HDA_CODEC_ENTRY(0x10ec0861, "ALC861", patch_alc861),
12390 	HDA_CODEC_ENTRY(0x10ec0862, "ALC861-VD", patch_alc861vd),
12391 	HDA_CODEC_REV_ENTRY(0x10ec0662, 0x100002, "ALC662 rev2", patch_alc882),
12392 	HDA_CODEC_REV_ENTRY(0x10ec0662, 0x100101, "ALC662 rev1", patch_alc662),
12393 	HDA_CODEC_REV_ENTRY(0x10ec0662, 0x100300, "ALC662 rev3", patch_alc662),
12394 	HDA_CODEC_ENTRY(0x10ec0663, "ALC663", patch_alc662),
12395 	HDA_CODEC_ENTRY(0x10ec0665, "ALC665", patch_alc662),
12396 	HDA_CODEC_ENTRY(0x10ec0667, "ALC667", patch_alc662),
12397 	HDA_CODEC_ENTRY(0x10ec0668, "ALC668", patch_alc662),
12398 	HDA_CODEC_ENTRY(0x10ec0670, "ALC670", patch_alc662),
12399 	HDA_CODEC_ENTRY(0x10ec0671, "ALC671", patch_alc662),
12400 	HDA_CODEC_ENTRY(0x10ec0680, "ALC680", patch_alc680),
12401 	HDA_CODEC_ENTRY(0x10ec0700, "ALC700", patch_alc269),
12402 	HDA_CODEC_ENTRY(0x10ec0701, "ALC701", patch_alc269),
12403 	HDA_CODEC_ENTRY(0x10ec0703, "ALC703", patch_alc269),
12404 	HDA_CODEC_ENTRY(0x10ec0711, "ALC711", patch_alc269),
12405 	HDA_CODEC_ENTRY(0x10ec0867, "ALC891", patch_alc662),
12406 	HDA_CODEC_ENTRY(0x10ec0880, "ALC880", patch_alc880),
12407 	HDA_CODEC_ENTRY(0x10ec0882, "ALC882", patch_alc882),
12408 	HDA_CODEC_ENTRY(0x10ec0883, "ALC883", patch_alc882),
12409 	HDA_CODEC_REV_ENTRY(0x10ec0885, 0x100101, "ALC889A", patch_alc882),
12410 	HDA_CODEC_REV_ENTRY(0x10ec0885, 0x100103, "ALC889A", patch_alc882),
12411 	HDA_CODEC_ENTRY(0x10ec0885, "ALC885", patch_alc882),
12412 	HDA_CODEC_ENTRY(0x10ec0887, "ALC887", patch_alc882),
12413 	HDA_CODEC_REV_ENTRY(0x10ec0888, 0x100101, "ALC1200", patch_alc882),
12414 	HDA_CODEC_ENTRY(0x10ec0888, "ALC888", patch_alc882),
12415 	HDA_CODEC_ENTRY(0x10ec0889, "ALC889", patch_alc882),
12416 	HDA_CODEC_ENTRY(0x10ec0892, "ALC892", patch_alc662),
12417 	HDA_CODEC_ENTRY(0x10ec0897, "ALC897", patch_alc662),
12418 	HDA_CODEC_ENTRY(0x10ec0899, "ALC898", patch_alc882),
12419 	HDA_CODEC_ENTRY(0x10ec0900, "ALC1150", patch_alc882),
12420 	HDA_CODEC_ENTRY(0x10ec0b00, "ALCS1200A", patch_alc882),
12421 	HDA_CODEC_ENTRY(0x10ec1168, "ALC1220", patch_alc882),
12422 	HDA_CODEC_ENTRY(0x10ec1220, "ALC1220", patch_alc882),
12423 	HDA_CODEC_ENTRY(0x19e58326, "HW8326", patch_alc269),
12424 	{} /* terminator */
12425 };
12426 MODULE_DEVICE_TABLE(hdaudio, snd_hda_id_realtek);
12427 
12428 MODULE_LICENSE("GPL");
12429 MODULE_DESCRIPTION("Realtek HD-audio codec");
12430 
12431 static struct hda_codec_driver realtek_driver = {
12432 	.id = snd_hda_id_realtek,
12433 };
12434 
12435 module_hda_codec_driver(realtek_driver);
12436