1 // SPDX-License-Identifier: GPL-2.0-or-later
2 /*
3 * Universal Interface for Intel High Definition Audio Codec
4 *
5 * HD audio interface patch for Realtek ALC codecs
6 *
7 * Copyright (c) 2004 Kailang Yang <kailang@realtek.com.tw>
8 * PeiSen Hou <pshou@realtek.com.tw>
9 * Takashi Iwai <tiwai@suse.de>
10 * Jonathan Woithe <jwoithe@just42.net>
11 */
12
13 #include <linux/acpi.h>
14 #include <linux/cleanup.h>
15 #include <linux/init.h>
16 #include <linux/delay.h>
17 #include <linux/slab.h>
18 #include <linux/pci.h>
19 #include <linux/dmi.h>
20 #include <linux/module.h>
21 #include <linux/i2c.h>
22 #include <linux/input.h>
23 #include <linux/leds.h>
24 #include <linux/ctype.h>
25 #include <linux/spi/spi.h>
26 #include <sound/core.h>
27 #include <sound/jack.h>
28 #include <sound/hda_codec.h>
29 #include "hda_local.h"
30 #include "hda_auto_parser.h"
31 #include "hda_jack.h"
32 #include "hda_generic.h"
33 #include "hda_component.h"
34
35 /* keep halting ALC5505 DSP, for power saving */
36 #define HALT_REALTEK_ALC5505
37
38 /* extra amp-initialization sequence types */
39 enum {
40 ALC_INIT_UNDEFINED,
41 ALC_INIT_NONE,
42 ALC_INIT_DEFAULT,
43 };
44
45 enum {
46 ALC_HEADSET_MODE_UNKNOWN,
47 ALC_HEADSET_MODE_UNPLUGGED,
48 ALC_HEADSET_MODE_HEADSET,
49 ALC_HEADSET_MODE_MIC,
50 ALC_HEADSET_MODE_HEADPHONE,
51 };
52
53 enum {
54 ALC_HEADSET_TYPE_UNKNOWN,
55 ALC_HEADSET_TYPE_CTIA,
56 ALC_HEADSET_TYPE_OMTP,
57 };
58
59 enum {
60 ALC_KEY_MICMUTE_INDEX,
61 };
62
63 struct alc_customize_define {
64 unsigned int sku_cfg;
65 unsigned char port_connectivity;
66 unsigned char check_sum;
67 unsigned char customization;
68 unsigned char external_amp;
69 unsigned int enable_pcbeep:1;
70 unsigned int platform_type:1;
71 unsigned int swap:1;
72 unsigned int override:1;
73 unsigned int fixup:1; /* Means that this sku is set by driver, not read from hw */
74 };
75
76 struct alc_coef_led {
77 unsigned int idx;
78 unsigned int mask;
79 unsigned int on;
80 unsigned int off;
81 };
82
83 struct alc_spec {
84 struct hda_gen_spec gen; /* must be at head */
85
86 /* codec parameterization */
87 struct alc_customize_define cdefine;
88 unsigned int parse_flags; /* flag for snd_hda_parse_pin_defcfg() */
89
90 /* GPIO bits */
91 unsigned int gpio_mask;
92 unsigned int gpio_dir;
93 unsigned int gpio_data;
94 bool gpio_write_delay; /* add a delay before writing gpio_data */
95
96 /* mute LED for HP laptops, see vref_mute_led_set() */
97 int mute_led_polarity;
98 int micmute_led_polarity;
99 hda_nid_t mute_led_nid;
100 hda_nid_t cap_mute_led_nid;
101
102 unsigned int gpio_mute_led_mask;
103 unsigned int gpio_mic_led_mask;
104 struct alc_coef_led mute_led_coef;
105 struct alc_coef_led mic_led_coef;
106 struct mutex coef_mutex;
107
108 hda_nid_t headset_mic_pin;
109 hda_nid_t headphone_mic_pin;
110 int current_headset_mode;
111 int current_headset_type;
112
113 /* hooks */
114 void (*init_hook)(struct hda_codec *codec);
115 void (*power_hook)(struct hda_codec *codec);
116 void (*shutup)(struct hda_codec *codec);
117
118 int init_amp;
119 int codec_variant; /* flag for other variants */
120 unsigned int has_alc5505_dsp:1;
121 unsigned int no_depop_delay:1;
122 unsigned int done_hp_init:1;
123 unsigned int no_shutup_pins:1;
124 unsigned int ultra_low_power:1;
125 unsigned int has_hs_key:1;
126 unsigned int no_internal_mic_pin:1;
127 unsigned int en_3kpull_low:1;
128 int num_speaker_amps;
129
130 /* for PLL fix */
131 hda_nid_t pll_nid;
132 unsigned int pll_coef_idx, pll_coef_bit;
133 unsigned int coef0;
134 struct input_dev *kb_dev;
135 u8 alc_mute_keycode_map[1];
136
137 /* component binding */
138 struct hda_component_parent comps;
139 };
140
141 /*
142 * COEF access helper functions
143 */
144
coef_mutex_lock(struct hda_codec * codec)145 static void coef_mutex_lock(struct hda_codec *codec)
146 {
147 struct alc_spec *spec = codec->spec;
148
149 snd_hda_power_up_pm(codec);
150 mutex_lock(&spec->coef_mutex);
151 }
152
coef_mutex_unlock(struct hda_codec * codec)153 static void coef_mutex_unlock(struct hda_codec *codec)
154 {
155 struct alc_spec *spec = codec->spec;
156
157 mutex_unlock(&spec->coef_mutex);
158 snd_hda_power_down_pm(codec);
159 }
160
__alc_read_coefex_idx(struct hda_codec * codec,hda_nid_t nid,unsigned int coef_idx)161 static int __alc_read_coefex_idx(struct hda_codec *codec, hda_nid_t nid,
162 unsigned int coef_idx)
163 {
164 unsigned int val;
165
166 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_COEF_INDEX, coef_idx);
167 val = snd_hda_codec_read(codec, nid, 0, AC_VERB_GET_PROC_COEF, 0);
168 return val;
169 }
170
alc_read_coefex_idx(struct hda_codec * codec,hda_nid_t nid,unsigned int coef_idx)171 static int alc_read_coefex_idx(struct hda_codec *codec, hda_nid_t nid,
172 unsigned int coef_idx)
173 {
174 unsigned int val;
175
176 coef_mutex_lock(codec);
177 val = __alc_read_coefex_idx(codec, nid, coef_idx);
178 coef_mutex_unlock(codec);
179 return val;
180 }
181
182 #define alc_read_coef_idx(codec, coef_idx) \
183 alc_read_coefex_idx(codec, 0x20, coef_idx)
184
__alc_write_coefex_idx(struct hda_codec * codec,hda_nid_t nid,unsigned int coef_idx,unsigned int coef_val)185 static void __alc_write_coefex_idx(struct hda_codec *codec, hda_nid_t nid,
186 unsigned int coef_idx, unsigned int coef_val)
187 {
188 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_COEF_INDEX, coef_idx);
189 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_PROC_COEF, coef_val);
190 }
191
alc_write_coefex_idx(struct hda_codec * codec,hda_nid_t nid,unsigned int coef_idx,unsigned int coef_val)192 static void alc_write_coefex_idx(struct hda_codec *codec, hda_nid_t nid,
193 unsigned int coef_idx, unsigned int coef_val)
194 {
195 coef_mutex_lock(codec);
196 __alc_write_coefex_idx(codec, nid, coef_idx, coef_val);
197 coef_mutex_unlock(codec);
198 }
199
200 #define alc_write_coef_idx(codec, coef_idx, coef_val) \
201 alc_write_coefex_idx(codec, 0x20, coef_idx, coef_val)
202
__alc_update_coefex_idx(struct hda_codec * codec,hda_nid_t nid,unsigned int coef_idx,unsigned int mask,unsigned int bits_set)203 static void __alc_update_coefex_idx(struct hda_codec *codec, hda_nid_t nid,
204 unsigned int coef_idx, unsigned int mask,
205 unsigned int bits_set)
206 {
207 unsigned int val = __alc_read_coefex_idx(codec, nid, coef_idx);
208
209 if (val != -1)
210 __alc_write_coefex_idx(codec, nid, coef_idx,
211 (val & ~mask) | bits_set);
212 }
213
alc_update_coefex_idx(struct hda_codec * codec,hda_nid_t nid,unsigned int coef_idx,unsigned int mask,unsigned int bits_set)214 static void alc_update_coefex_idx(struct hda_codec *codec, hda_nid_t nid,
215 unsigned int coef_idx, unsigned int mask,
216 unsigned int bits_set)
217 {
218 coef_mutex_lock(codec);
219 __alc_update_coefex_idx(codec, nid, coef_idx, mask, bits_set);
220 coef_mutex_unlock(codec);
221 }
222
223 #define alc_update_coef_idx(codec, coef_idx, mask, bits_set) \
224 alc_update_coefex_idx(codec, 0x20, coef_idx, mask, bits_set)
225
226 /* a special bypass for COEF 0; read the cached value at the second time */
alc_get_coef0(struct hda_codec * codec)227 static unsigned int alc_get_coef0(struct hda_codec *codec)
228 {
229 struct alc_spec *spec = codec->spec;
230
231 if (!spec->coef0)
232 spec->coef0 = alc_read_coef_idx(codec, 0);
233 return spec->coef0;
234 }
235
236 /* coef writes/updates batch */
237 struct coef_fw {
238 unsigned char nid;
239 unsigned char idx;
240 unsigned short mask;
241 unsigned short val;
242 };
243
244 #define UPDATE_COEFEX(_nid, _idx, _mask, _val) \
245 { .nid = (_nid), .idx = (_idx), .mask = (_mask), .val = (_val) }
246 #define WRITE_COEFEX(_nid, _idx, _val) UPDATE_COEFEX(_nid, _idx, -1, _val)
247 #define WRITE_COEF(_idx, _val) WRITE_COEFEX(0x20, _idx, _val)
248 #define UPDATE_COEF(_idx, _mask, _val) UPDATE_COEFEX(0x20, _idx, _mask, _val)
249
alc_process_coef_fw(struct hda_codec * codec,const struct coef_fw * fw)250 static void alc_process_coef_fw(struct hda_codec *codec,
251 const struct coef_fw *fw)
252 {
253 coef_mutex_lock(codec);
254 for (; fw->nid; fw++) {
255 if (fw->mask == (unsigned short)-1)
256 __alc_write_coefex_idx(codec, fw->nid, fw->idx, fw->val);
257 else
258 __alc_update_coefex_idx(codec, fw->nid, fw->idx,
259 fw->mask, fw->val);
260 }
261 coef_mutex_unlock(codec);
262 }
263
264 /*
265 * GPIO setup tables, used in initialization
266 */
267
268 /* Enable GPIO mask and set output */
alc_setup_gpio(struct hda_codec * codec,unsigned int mask)269 static void alc_setup_gpio(struct hda_codec *codec, unsigned int mask)
270 {
271 struct alc_spec *spec = codec->spec;
272
273 spec->gpio_mask |= mask;
274 spec->gpio_dir |= mask;
275 spec->gpio_data |= mask;
276 }
277
alc_write_gpio_data(struct hda_codec * codec)278 static void alc_write_gpio_data(struct hda_codec *codec)
279 {
280 struct alc_spec *spec = codec->spec;
281
282 snd_hda_codec_write(codec, 0x01, 0, AC_VERB_SET_GPIO_DATA,
283 spec->gpio_data);
284 }
285
alc_update_gpio_data(struct hda_codec * codec,unsigned int mask,bool on)286 static void alc_update_gpio_data(struct hda_codec *codec, unsigned int mask,
287 bool on)
288 {
289 struct alc_spec *spec = codec->spec;
290 unsigned int oldval = spec->gpio_data;
291
292 if (on)
293 spec->gpio_data |= mask;
294 else
295 spec->gpio_data &= ~mask;
296 if (oldval != spec->gpio_data)
297 alc_write_gpio_data(codec);
298 }
299
alc_write_gpio(struct hda_codec * codec)300 static void alc_write_gpio(struct hda_codec *codec)
301 {
302 struct alc_spec *spec = codec->spec;
303
304 if (!spec->gpio_mask)
305 return;
306
307 snd_hda_codec_write(codec, codec->core.afg, 0,
308 AC_VERB_SET_GPIO_MASK, spec->gpio_mask);
309 snd_hda_codec_write(codec, codec->core.afg, 0,
310 AC_VERB_SET_GPIO_DIRECTION, spec->gpio_dir);
311 if (spec->gpio_write_delay)
312 msleep(1);
313 alc_write_gpio_data(codec);
314 }
315
alc_fixup_gpio(struct hda_codec * codec,int action,unsigned int mask)316 static void alc_fixup_gpio(struct hda_codec *codec, int action,
317 unsigned int mask)
318 {
319 if (action == HDA_FIXUP_ACT_PRE_PROBE)
320 alc_setup_gpio(codec, mask);
321 }
322
alc_fixup_gpio1(struct hda_codec * codec,const struct hda_fixup * fix,int action)323 static void alc_fixup_gpio1(struct hda_codec *codec,
324 const struct hda_fixup *fix, int action)
325 {
326 alc_fixup_gpio(codec, action, 0x01);
327 }
328
alc_fixup_gpio2(struct hda_codec * codec,const struct hda_fixup * fix,int action)329 static void alc_fixup_gpio2(struct hda_codec *codec,
330 const struct hda_fixup *fix, int action)
331 {
332 alc_fixup_gpio(codec, action, 0x02);
333 }
334
alc_fixup_gpio3(struct hda_codec * codec,const struct hda_fixup * fix,int action)335 static void alc_fixup_gpio3(struct hda_codec *codec,
336 const struct hda_fixup *fix, int action)
337 {
338 alc_fixup_gpio(codec, action, 0x03);
339 }
340
alc_fixup_gpio4(struct hda_codec * codec,const struct hda_fixup * fix,int action)341 static void alc_fixup_gpio4(struct hda_codec *codec,
342 const struct hda_fixup *fix, int action)
343 {
344 alc_fixup_gpio(codec, action, 0x04);
345 }
346
alc_fixup_micmute_led(struct hda_codec * codec,const struct hda_fixup * fix,int action)347 static void alc_fixup_micmute_led(struct hda_codec *codec,
348 const struct hda_fixup *fix, int action)
349 {
350 if (action == HDA_FIXUP_ACT_PRE_PROBE)
351 snd_hda_gen_add_micmute_led_cdev(codec, NULL);
352 }
353
354 /*
355 * Fix hardware PLL issue
356 * On some codecs, the analog PLL gating control must be off while
357 * the default value is 1.
358 */
alc_fix_pll(struct hda_codec * codec)359 static void alc_fix_pll(struct hda_codec *codec)
360 {
361 struct alc_spec *spec = codec->spec;
362
363 if (spec->pll_nid)
364 alc_update_coefex_idx(codec, spec->pll_nid, spec->pll_coef_idx,
365 1 << spec->pll_coef_bit, 0);
366 }
367
alc_fix_pll_init(struct hda_codec * codec,hda_nid_t nid,unsigned int coef_idx,unsigned int coef_bit)368 static void alc_fix_pll_init(struct hda_codec *codec, hda_nid_t nid,
369 unsigned int coef_idx, unsigned int coef_bit)
370 {
371 struct alc_spec *spec = codec->spec;
372 spec->pll_nid = nid;
373 spec->pll_coef_idx = coef_idx;
374 spec->pll_coef_bit = coef_bit;
375 alc_fix_pll(codec);
376 }
377
378 /* update the master volume per volume-knob's unsol event */
alc_update_knob_master(struct hda_codec * codec,struct hda_jack_callback * jack)379 static void alc_update_knob_master(struct hda_codec *codec,
380 struct hda_jack_callback *jack)
381 {
382 unsigned int val;
383 struct snd_kcontrol *kctl;
384 struct snd_ctl_elem_value *uctl;
385
386 kctl = snd_hda_find_mixer_ctl(codec, "Master Playback Volume");
387 if (!kctl)
388 return;
389 uctl = kzalloc(sizeof(*uctl), GFP_KERNEL);
390 if (!uctl)
391 return;
392 val = snd_hda_codec_read(codec, jack->nid, 0,
393 AC_VERB_GET_VOLUME_KNOB_CONTROL, 0);
394 val &= HDA_AMP_VOLMASK;
395 uctl->value.integer.value[0] = val;
396 uctl->value.integer.value[1] = val;
397 kctl->put(kctl, uctl);
398 kfree(uctl);
399 }
400
alc880_unsol_event(struct hda_codec * codec,unsigned int res)401 static void alc880_unsol_event(struct hda_codec *codec, unsigned int res)
402 {
403 /* For some reason, the res given from ALC880 is broken.
404 Here we adjust it properly. */
405 snd_hda_jack_unsol_event(codec, res >> 2);
406 }
407
408 /* Change EAPD to verb control */
alc_fill_eapd_coef(struct hda_codec * codec)409 static void alc_fill_eapd_coef(struct hda_codec *codec)
410 {
411 int coef;
412
413 coef = alc_get_coef0(codec);
414
415 switch (codec->core.vendor_id) {
416 case 0x10ec0262:
417 alc_update_coef_idx(codec, 0x7, 0, 1<<5);
418 break;
419 case 0x10ec0267:
420 case 0x10ec0268:
421 alc_update_coef_idx(codec, 0x7, 0, 1<<13);
422 break;
423 case 0x10ec0269:
424 if ((coef & 0x00f0) == 0x0010)
425 alc_update_coef_idx(codec, 0xd, 0, 1<<14);
426 if ((coef & 0x00f0) == 0x0020)
427 alc_update_coef_idx(codec, 0x4, 1<<15, 0);
428 if ((coef & 0x00f0) == 0x0030)
429 alc_update_coef_idx(codec, 0x10, 1<<9, 0);
430 break;
431 case 0x10ec0280:
432 case 0x10ec0284:
433 case 0x10ec0290:
434 case 0x10ec0292:
435 alc_update_coef_idx(codec, 0x4, 1<<15, 0);
436 break;
437 case 0x10ec0225:
438 case 0x10ec0295:
439 case 0x10ec0299:
440 alc_update_coef_idx(codec, 0x67, 0xf000, 0x3000);
441 fallthrough;
442 case 0x10ec0215:
443 case 0x10ec0285:
444 case 0x10ec0289:
445 alc_update_coef_idx(codec, 0x36, 1<<13, 0);
446 fallthrough;
447 case 0x10ec0230:
448 case 0x10ec0233:
449 case 0x10ec0235:
450 case 0x10ec0236:
451 case 0x10ec0245:
452 case 0x10ec0255:
453 case 0x10ec0256:
454 case 0x19e58326:
455 case 0x10ec0257:
456 case 0x10ec0282:
457 case 0x10ec0283:
458 case 0x10ec0286:
459 case 0x10ec0288:
460 case 0x10ec0298:
461 case 0x10ec0300:
462 alc_update_coef_idx(codec, 0x10, 1<<9, 0);
463 break;
464 case 0x10ec0275:
465 alc_update_coef_idx(codec, 0xe, 0, 1<<0);
466 break;
467 case 0x10ec0287:
468 alc_update_coef_idx(codec, 0x10, 1<<9, 0);
469 alc_write_coef_idx(codec, 0x8, 0x4ab7);
470 break;
471 case 0x10ec0293:
472 alc_update_coef_idx(codec, 0xa, 1<<13, 0);
473 break;
474 case 0x10ec0234:
475 case 0x10ec0274:
476 case 0x10ec0294:
477 case 0x10ec0700:
478 case 0x10ec0701:
479 case 0x10ec0703:
480 case 0x10ec0711:
481 alc_update_coef_idx(codec, 0x10, 1<<15, 0);
482 break;
483 case 0x10ec0662:
484 if ((coef & 0x00f0) == 0x0030)
485 alc_update_coef_idx(codec, 0x4, 1<<10, 0); /* EAPD Ctrl */
486 break;
487 case 0x10ec0272:
488 case 0x10ec0273:
489 case 0x10ec0663:
490 case 0x10ec0665:
491 case 0x10ec0670:
492 case 0x10ec0671:
493 case 0x10ec0672:
494 alc_update_coef_idx(codec, 0xd, 0, 1<<14); /* EAPD Ctrl */
495 break;
496 case 0x10ec0222:
497 case 0x10ec0623:
498 alc_update_coef_idx(codec, 0x19, 1<<13, 0);
499 break;
500 case 0x10ec0668:
501 alc_update_coef_idx(codec, 0x7, 3<<13, 0);
502 break;
503 case 0x10ec0867:
504 alc_update_coef_idx(codec, 0x4, 1<<10, 0);
505 break;
506 case 0x10ec0888:
507 if ((coef & 0x00f0) == 0x0020 || (coef & 0x00f0) == 0x0030)
508 alc_update_coef_idx(codec, 0x7, 1<<5, 0);
509 break;
510 case 0x10ec0892:
511 case 0x10ec0897:
512 alc_update_coef_idx(codec, 0x7, 1<<5, 0);
513 break;
514 case 0x10ec0899:
515 case 0x10ec0900:
516 case 0x10ec0b00:
517 case 0x10ec1168:
518 case 0x10ec1220:
519 alc_update_coef_idx(codec, 0x7, 1<<1, 0);
520 break;
521 }
522 }
523
524 /* additional initialization for ALC888 variants */
alc888_coef_init(struct hda_codec * codec)525 static void alc888_coef_init(struct hda_codec *codec)
526 {
527 switch (alc_get_coef0(codec) & 0x00f0) {
528 /* alc888-VA */
529 case 0x00:
530 /* alc888-VB */
531 case 0x10:
532 alc_update_coef_idx(codec, 7, 0, 0x2030); /* Turn EAPD to High */
533 break;
534 }
535 }
536
537 /* turn on/off EAPD control (only if available) */
set_eapd(struct hda_codec * codec,hda_nid_t nid,int on)538 static void set_eapd(struct hda_codec *codec, hda_nid_t nid, int on)
539 {
540 if (get_wcaps_type(get_wcaps(codec, nid)) != AC_WID_PIN)
541 return;
542 if (snd_hda_query_pin_caps(codec, nid) & AC_PINCAP_EAPD)
543 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_EAPD_BTLENABLE,
544 on ? 2 : 0);
545 }
546
547 /* turn on/off EAPD controls of the codec */
alc_auto_setup_eapd(struct hda_codec * codec,bool on)548 static void alc_auto_setup_eapd(struct hda_codec *codec, bool on)
549 {
550 /* We currently only handle front, HP */
551 static const hda_nid_t pins[] = {
552 0x0f, 0x10, 0x14, 0x15, 0x17, 0
553 };
554 const hda_nid_t *p;
555 for (p = pins; *p; p++)
556 set_eapd(codec, *p, on);
557 }
558
559 static int find_ext_mic_pin(struct hda_codec *codec);
560
alc_headset_mic_no_shutup(struct hda_codec * codec)561 static void alc_headset_mic_no_shutup(struct hda_codec *codec)
562 {
563 const struct hda_pincfg *pin;
564 int mic_pin = find_ext_mic_pin(codec);
565 int i;
566
567 /* don't shut up pins when unloading the driver; otherwise it breaks
568 * the default pin setup at the next load of the driver
569 */
570 if (codec->bus->shutdown)
571 return;
572
573 snd_array_for_each(&codec->init_pins, i, pin) {
574 /* use read here for syncing after issuing each verb */
575 if (pin->nid != mic_pin)
576 snd_hda_codec_read(codec, pin->nid, 0,
577 AC_VERB_SET_PIN_WIDGET_CONTROL, 0);
578 }
579
580 codec->pins_shutup = 1;
581 }
582
alc_shutup_pins(struct hda_codec * codec)583 static void alc_shutup_pins(struct hda_codec *codec)
584 {
585 struct alc_spec *spec = codec->spec;
586
587 switch (codec->core.vendor_id) {
588 case 0x10ec0236:
589 case 0x10ec0256:
590 case 0x10ec0257:
591 case 0x19e58326:
592 case 0x10ec0283:
593 case 0x10ec0285:
594 case 0x10ec0286:
595 case 0x10ec0287:
596 case 0x10ec0288:
597 case 0x10ec0295:
598 case 0x10ec0298:
599 alc_headset_mic_no_shutup(codec);
600 break;
601 default:
602 if (!spec->no_shutup_pins)
603 snd_hda_shutup_pins(codec);
604 break;
605 }
606 }
607
608 /* generic shutup callback;
609 * just turning off EAPD and a little pause for avoiding pop-noise
610 */
alc_eapd_shutup(struct hda_codec * codec)611 static void alc_eapd_shutup(struct hda_codec *codec)
612 {
613 struct alc_spec *spec = codec->spec;
614
615 alc_auto_setup_eapd(codec, false);
616 if (!spec->no_depop_delay)
617 msleep(200);
618 alc_shutup_pins(codec);
619 }
620
621 /* generic EAPD initialization */
alc_auto_init_amp(struct hda_codec * codec,int type)622 static void alc_auto_init_amp(struct hda_codec *codec, int type)
623 {
624 alc_auto_setup_eapd(codec, true);
625 alc_write_gpio(codec);
626 switch (type) {
627 case ALC_INIT_DEFAULT:
628 switch (codec->core.vendor_id) {
629 case 0x10ec0260:
630 alc_update_coefex_idx(codec, 0x1a, 7, 0, 0x2010);
631 break;
632 case 0x10ec0880:
633 case 0x10ec0882:
634 case 0x10ec0883:
635 case 0x10ec0885:
636 alc_update_coef_idx(codec, 7, 0, 0x2030);
637 break;
638 case 0x10ec0888:
639 alc888_coef_init(codec);
640 break;
641 }
642 break;
643 }
644 }
645
646 /* get a primary headphone pin if available */
alc_get_hp_pin(struct alc_spec * spec)647 static hda_nid_t alc_get_hp_pin(struct alc_spec *spec)
648 {
649 if (spec->gen.autocfg.hp_pins[0])
650 return spec->gen.autocfg.hp_pins[0];
651 if (spec->gen.autocfg.line_out_type == AC_JACK_HP_OUT)
652 return spec->gen.autocfg.line_out_pins[0];
653 return 0;
654 }
655
656 /*
657 * Realtek SSID verification
658 */
659
660 /* Could be any non-zero and even value. When used as fixup, tells
661 * the driver to ignore any present sku defines.
662 */
663 #define ALC_FIXUP_SKU_IGNORE (2)
664
alc_fixup_sku_ignore(struct hda_codec * codec,const struct hda_fixup * fix,int action)665 static void alc_fixup_sku_ignore(struct hda_codec *codec,
666 const struct hda_fixup *fix, int action)
667 {
668 struct alc_spec *spec = codec->spec;
669 if (action == HDA_FIXUP_ACT_PRE_PROBE) {
670 spec->cdefine.fixup = 1;
671 spec->cdefine.sku_cfg = ALC_FIXUP_SKU_IGNORE;
672 }
673 }
674
alc_fixup_no_depop_delay(struct hda_codec * codec,const struct hda_fixup * fix,int action)675 static void alc_fixup_no_depop_delay(struct hda_codec *codec,
676 const struct hda_fixup *fix, int action)
677 {
678 struct alc_spec *spec = codec->spec;
679
680 if (action == HDA_FIXUP_ACT_PROBE) {
681 spec->no_depop_delay = 1;
682 codec->depop_delay = 0;
683 }
684 }
685
alc_auto_parse_customize_define(struct hda_codec * codec)686 static int alc_auto_parse_customize_define(struct hda_codec *codec)
687 {
688 unsigned int ass, tmp, i;
689 unsigned nid = 0;
690 struct alc_spec *spec = codec->spec;
691
692 spec->cdefine.enable_pcbeep = 1; /* assume always enabled */
693
694 if (spec->cdefine.fixup) {
695 ass = spec->cdefine.sku_cfg;
696 if (ass == ALC_FIXUP_SKU_IGNORE)
697 return -1;
698 goto do_sku;
699 }
700
701 if (!codec->bus->pci)
702 return -1;
703 ass = codec->core.subsystem_id & 0xffff;
704 if (ass != codec->bus->pci->subsystem_device && (ass & 1))
705 goto do_sku;
706
707 nid = 0x1d;
708 if (codec->core.vendor_id == 0x10ec0260)
709 nid = 0x17;
710 ass = snd_hda_codec_get_pincfg(codec, nid);
711
712 if (!(ass & 1)) {
713 codec_info(codec, "%s: SKU not ready 0x%08x\n",
714 codec->core.chip_name, ass);
715 return -1;
716 }
717
718 /* check sum */
719 tmp = 0;
720 for (i = 1; i < 16; i++) {
721 if ((ass >> i) & 1)
722 tmp++;
723 }
724 if (((ass >> 16) & 0xf) != tmp)
725 return -1;
726
727 spec->cdefine.port_connectivity = ass >> 30;
728 spec->cdefine.enable_pcbeep = (ass & 0x100000) >> 20;
729 spec->cdefine.check_sum = (ass >> 16) & 0xf;
730 spec->cdefine.customization = ass >> 8;
731 do_sku:
732 spec->cdefine.sku_cfg = ass;
733 spec->cdefine.external_amp = (ass & 0x38) >> 3;
734 spec->cdefine.platform_type = (ass & 0x4) >> 2;
735 spec->cdefine.swap = (ass & 0x2) >> 1;
736 spec->cdefine.override = ass & 0x1;
737
738 codec_dbg(codec, "SKU: Nid=0x%x sku_cfg=0x%08x\n",
739 nid, spec->cdefine.sku_cfg);
740 codec_dbg(codec, "SKU: port_connectivity=0x%x\n",
741 spec->cdefine.port_connectivity);
742 codec_dbg(codec, "SKU: enable_pcbeep=0x%x\n", spec->cdefine.enable_pcbeep);
743 codec_dbg(codec, "SKU: check_sum=0x%08x\n", spec->cdefine.check_sum);
744 codec_dbg(codec, "SKU: customization=0x%08x\n", spec->cdefine.customization);
745 codec_dbg(codec, "SKU: external_amp=0x%x\n", spec->cdefine.external_amp);
746 codec_dbg(codec, "SKU: platform_type=0x%x\n", spec->cdefine.platform_type);
747 codec_dbg(codec, "SKU: swap=0x%x\n", spec->cdefine.swap);
748 codec_dbg(codec, "SKU: override=0x%x\n", spec->cdefine.override);
749
750 return 0;
751 }
752
753 /* return the position of NID in the list, or -1 if not found */
find_idx_in_nid_list(hda_nid_t nid,const hda_nid_t * list,int nums)754 static int find_idx_in_nid_list(hda_nid_t nid, const hda_nid_t *list, int nums)
755 {
756 int i;
757 for (i = 0; i < nums; i++)
758 if (list[i] == nid)
759 return i;
760 return -1;
761 }
762 /* return true if the given NID is found in the list */
found_in_nid_list(hda_nid_t nid,const hda_nid_t * list,int nums)763 static bool found_in_nid_list(hda_nid_t nid, const hda_nid_t *list, int nums)
764 {
765 return find_idx_in_nid_list(nid, list, nums) >= 0;
766 }
767
768 /* check subsystem ID and set up device-specific initialization;
769 * return 1 if initialized, 0 if invalid SSID
770 */
771 /* 32-bit subsystem ID for BIOS loading in HD Audio codec.
772 * 31 ~ 16 : Manufacture ID
773 * 15 ~ 8 : SKU ID
774 * 7 ~ 0 : Assembly ID
775 * port-A --> pin 39/41, port-E --> pin 14/15, port-D --> pin 35/36
776 */
alc_subsystem_id(struct hda_codec * codec,const hda_nid_t * ports)777 static int alc_subsystem_id(struct hda_codec *codec, const hda_nid_t *ports)
778 {
779 unsigned int ass, tmp, i;
780 unsigned nid;
781 struct alc_spec *spec = codec->spec;
782
783 if (spec->cdefine.fixup) {
784 ass = spec->cdefine.sku_cfg;
785 if (ass == ALC_FIXUP_SKU_IGNORE)
786 return 0;
787 goto do_sku;
788 }
789
790 ass = codec->core.subsystem_id & 0xffff;
791 if (codec->bus->pci &&
792 ass != codec->bus->pci->subsystem_device && (ass & 1))
793 goto do_sku;
794
795 /* invalid SSID, check the special NID pin defcfg instead */
796 /*
797 * 31~30 : port connectivity
798 * 29~21 : reserve
799 * 20 : PCBEEP input
800 * 19~16 : Check sum (15:1)
801 * 15~1 : Custom
802 * 0 : override
803 */
804 nid = 0x1d;
805 if (codec->core.vendor_id == 0x10ec0260)
806 nid = 0x17;
807 ass = snd_hda_codec_get_pincfg(codec, nid);
808 codec_dbg(codec,
809 "realtek: No valid SSID, checking pincfg 0x%08x for NID 0x%x\n",
810 ass, nid);
811 if (!(ass & 1))
812 return 0;
813 if ((ass >> 30) != 1) /* no physical connection */
814 return 0;
815
816 /* check sum */
817 tmp = 0;
818 for (i = 1; i < 16; i++) {
819 if ((ass >> i) & 1)
820 tmp++;
821 }
822 if (((ass >> 16) & 0xf) != tmp)
823 return 0;
824 do_sku:
825 codec_dbg(codec, "realtek: Enabling init ASM_ID=0x%04x CODEC_ID=%08x\n",
826 ass & 0xffff, codec->core.vendor_id);
827 /*
828 * 0 : override
829 * 1 : Swap Jack
830 * 2 : 0 --> Desktop, 1 --> Laptop
831 * 3~5 : External Amplifier control
832 * 7~6 : Reserved
833 */
834 tmp = (ass & 0x38) >> 3; /* external Amp control */
835 if (spec->init_amp == ALC_INIT_UNDEFINED) {
836 switch (tmp) {
837 case 1:
838 alc_setup_gpio(codec, 0x01);
839 break;
840 case 3:
841 alc_setup_gpio(codec, 0x02);
842 break;
843 case 7:
844 alc_setup_gpio(codec, 0x04);
845 break;
846 case 5:
847 default:
848 spec->init_amp = ALC_INIT_DEFAULT;
849 break;
850 }
851 }
852
853 /* is laptop or Desktop and enable the function "Mute internal speaker
854 * when the external headphone out jack is plugged"
855 */
856 if (!(ass & 0x8000))
857 return 1;
858 /*
859 * 10~8 : Jack location
860 * 12~11: Headphone out -> 00: PortA, 01: PortE, 02: PortD, 03: Resvered
861 * 14~13: Resvered
862 * 15 : 1 --> enable the function "Mute internal speaker
863 * when the external headphone out jack is plugged"
864 */
865 if (!alc_get_hp_pin(spec)) {
866 hda_nid_t nid;
867 tmp = (ass >> 11) & 0x3; /* HP to chassis */
868 nid = ports[tmp];
869 if (found_in_nid_list(nid, spec->gen.autocfg.line_out_pins,
870 spec->gen.autocfg.line_outs))
871 return 1;
872 spec->gen.autocfg.hp_pins[0] = nid;
873 }
874 return 1;
875 }
876
877 /* Check the validity of ALC subsystem-id
878 * ports contains an array of 4 pin NIDs for port-A, E, D and I */
alc_ssid_check(struct hda_codec * codec,const hda_nid_t * ports)879 static void alc_ssid_check(struct hda_codec *codec, const hda_nid_t *ports)
880 {
881 if (!alc_subsystem_id(codec, ports)) {
882 struct alc_spec *spec = codec->spec;
883 if (spec->init_amp == ALC_INIT_UNDEFINED) {
884 codec_dbg(codec,
885 "realtek: Enable default setup for auto mode as fallback\n");
886 spec->init_amp = ALC_INIT_DEFAULT;
887 }
888 }
889 }
890
891 /*
892 */
893
alc_fixup_inv_dmic(struct hda_codec * codec,const struct hda_fixup * fix,int action)894 static void alc_fixup_inv_dmic(struct hda_codec *codec,
895 const struct hda_fixup *fix, int action)
896 {
897 struct alc_spec *spec = codec->spec;
898
899 spec->gen.inv_dmic_split = 1;
900 }
901
902
alc_build_controls(struct hda_codec * codec)903 static int alc_build_controls(struct hda_codec *codec)
904 {
905 int err;
906
907 err = snd_hda_gen_build_controls(codec);
908 if (err < 0)
909 return err;
910
911 snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_BUILD);
912 return 0;
913 }
914
915
916 /*
917 * Common callbacks
918 */
919
alc_pre_init(struct hda_codec * codec)920 static void alc_pre_init(struct hda_codec *codec)
921 {
922 alc_fill_eapd_coef(codec);
923 }
924
925 #define is_s3_resume(codec) \
926 ((codec)->core.dev.power.power_state.event == PM_EVENT_RESUME)
927 #define is_s4_resume(codec) \
928 ((codec)->core.dev.power.power_state.event == PM_EVENT_RESTORE)
929 #define is_s4_suspend(codec) \
930 ((codec)->core.dev.power.power_state.event == PM_EVENT_FREEZE)
931
alc_init(struct hda_codec * codec)932 static int alc_init(struct hda_codec *codec)
933 {
934 struct alc_spec *spec = codec->spec;
935
936 /* hibernation resume needs the full chip initialization */
937 if (is_s4_resume(codec))
938 alc_pre_init(codec);
939
940 if (spec->init_hook)
941 spec->init_hook(codec);
942
943 spec->gen.skip_verbs = 1; /* applied in below */
944 snd_hda_gen_init(codec);
945 alc_fix_pll(codec);
946 alc_auto_init_amp(codec, spec->init_amp);
947 snd_hda_apply_verbs(codec); /* apply verbs here after own init */
948
949 snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_INIT);
950
951 return 0;
952 }
953
954 /* forward declaration */
955 static const struct component_master_ops comp_master_ops;
956
alc_free(struct hda_codec * codec)957 static void alc_free(struct hda_codec *codec)
958 {
959 struct alc_spec *spec = codec->spec;
960
961 if (spec)
962 hda_component_manager_free(&spec->comps, &comp_master_ops);
963
964 snd_hda_gen_free(codec);
965 }
966
alc_shutup(struct hda_codec * codec)967 static inline void alc_shutup(struct hda_codec *codec)
968 {
969 struct alc_spec *spec = codec->spec;
970
971 if (!snd_hda_get_bool_hint(codec, "shutup"))
972 return; /* disabled explicitly by hints */
973
974 if (spec && spec->shutup)
975 spec->shutup(codec);
976 else
977 alc_shutup_pins(codec);
978 }
979
alc_power_eapd(struct hda_codec * codec)980 static void alc_power_eapd(struct hda_codec *codec)
981 {
982 alc_auto_setup_eapd(codec, false);
983 }
984
alc_suspend(struct hda_codec * codec)985 static int alc_suspend(struct hda_codec *codec)
986 {
987 struct alc_spec *spec = codec->spec;
988 alc_shutup(codec);
989 if (spec && spec->power_hook)
990 spec->power_hook(codec);
991 return 0;
992 }
993
alc_resume(struct hda_codec * codec)994 static int alc_resume(struct hda_codec *codec)
995 {
996 struct alc_spec *spec = codec->spec;
997
998 if (!spec->no_depop_delay)
999 msleep(150); /* to avoid pop noise */
1000 codec->patch_ops.init(codec);
1001 snd_hda_regmap_sync(codec);
1002 hda_call_check_power_status(codec, 0x01);
1003 return 0;
1004 }
1005
1006 /*
1007 */
1008 static const struct hda_codec_ops alc_patch_ops = {
1009 .build_controls = alc_build_controls,
1010 .build_pcms = snd_hda_gen_build_pcms,
1011 .init = alc_init,
1012 .free = alc_free,
1013 .unsol_event = snd_hda_jack_unsol_event,
1014 .resume = alc_resume,
1015 .suspend = alc_suspend,
1016 .check_power_status = snd_hda_gen_check_power_status,
1017 };
1018
1019
1020 #define alc_codec_rename(codec, name) snd_hda_codec_set_name(codec, name)
1021
1022 /*
1023 * Rename codecs appropriately from COEF value or subvendor id
1024 */
1025 struct alc_codec_rename_table {
1026 unsigned int vendor_id;
1027 unsigned short coef_mask;
1028 unsigned short coef_bits;
1029 const char *name;
1030 };
1031
1032 struct alc_codec_rename_pci_table {
1033 unsigned int codec_vendor_id;
1034 unsigned short pci_subvendor;
1035 unsigned short pci_subdevice;
1036 const char *name;
1037 };
1038
1039 static const struct alc_codec_rename_table rename_tbl[] = {
1040 { 0x10ec0221, 0xf00f, 0x1003, "ALC231" },
1041 { 0x10ec0269, 0xfff0, 0x3010, "ALC277" },
1042 { 0x10ec0269, 0xf0f0, 0x2010, "ALC259" },
1043 { 0x10ec0269, 0xf0f0, 0x3010, "ALC258" },
1044 { 0x10ec0269, 0x00f0, 0x0010, "ALC269VB" },
1045 { 0x10ec0269, 0xffff, 0xa023, "ALC259" },
1046 { 0x10ec0269, 0xffff, 0x6023, "ALC281X" },
1047 { 0x10ec0269, 0x00f0, 0x0020, "ALC269VC" },
1048 { 0x10ec0269, 0x00f0, 0x0030, "ALC269VD" },
1049 { 0x10ec0662, 0xffff, 0x4020, "ALC656" },
1050 { 0x10ec0887, 0x00f0, 0x0030, "ALC887-VD" },
1051 { 0x10ec0888, 0x00f0, 0x0030, "ALC888-VD" },
1052 { 0x10ec0888, 0xf0f0, 0x3020, "ALC886" },
1053 { 0x10ec0899, 0x2000, 0x2000, "ALC899" },
1054 { 0x10ec0892, 0xffff, 0x8020, "ALC661" },
1055 { 0x10ec0892, 0xffff, 0x8011, "ALC661" },
1056 { 0x10ec0892, 0xffff, 0x4011, "ALC656" },
1057 { } /* terminator */
1058 };
1059
1060 static const struct alc_codec_rename_pci_table rename_pci_tbl[] = {
1061 { 0x10ec0280, 0x1028, 0, "ALC3220" },
1062 { 0x10ec0282, 0x1028, 0, "ALC3221" },
1063 { 0x10ec0283, 0x1028, 0, "ALC3223" },
1064 { 0x10ec0288, 0x1028, 0, "ALC3263" },
1065 { 0x10ec0292, 0x1028, 0, "ALC3226" },
1066 { 0x10ec0293, 0x1028, 0, "ALC3235" },
1067 { 0x10ec0255, 0x1028, 0, "ALC3234" },
1068 { 0x10ec0668, 0x1028, 0, "ALC3661" },
1069 { 0x10ec0275, 0x1028, 0, "ALC3260" },
1070 { 0x10ec0899, 0x1028, 0, "ALC3861" },
1071 { 0x10ec0298, 0x1028, 0, "ALC3266" },
1072 { 0x10ec0236, 0x1028, 0, "ALC3204" },
1073 { 0x10ec0256, 0x1028, 0, "ALC3246" },
1074 { 0x10ec0225, 0x1028, 0, "ALC3253" },
1075 { 0x10ec0295, 0x1028, 0, "ALC3254" },
1076 { 0x10ec0299, 0x1028, 0, "ALC3271" },
1077 { 0x10ec0670, 0x1025, 0, "ALC669X" },
1078 { 0x10ec0676, 0x1025, 0, "ALC679X" },
1079 { 0x10ec0282, 0x1043, 0, "ALC3229" },
1080 { 0x10ec0233, 0x1043, 0, "ALC3236" },
1081 { 0x10ec0280, 0x103c, 0, "ALC3228" },
1082 { 0x10ec0282, 0x103c, 0, "ALC3227" },
1083 { 0x10ec0286, 0x103c, 0, "ALC3242" },
1084 { 0x10ec0290, 0x103c, 0, "ALC3241" },
1085 { 0x10ec0668, 0x103c, 0, "ALC3662" },
1086 { 0x10ec0283, 0x17aa, 0, "ALC3239" },
1087 { 0x10ec0292, 0x17aa, 0, "ALC3232" },
1088 { } /* terminator */
1089 };
1090
alc_codec_rename_from_preset(struct hda_codec * codec)1091 static int alc_codec_rename_from_preset(struct hda_codec *codec)
1092 {
1093 const struct alc_codec_rename_table *p;
1094 const struct alc_codec_rename_pci_table *q;
1095
1096 for (p = rename_tbl; p->vendor_id; p++) {
1097 if (p->vendor_id != codec->core.vendor_id)
1098 continue;
1099 if ((alc_get_coef0(codec) & p->coef_mask) == p->coef_bits)
1100 return alc_codec_rename(codec, p->name);
1101 }
1102
1103 if (!codec->bus->pci)
1104 return 0;
1105 for (q = rename_pci_tbl; q->codec_vendor_id; q++) {
1106 if (q->codec_vendor_id != codec->core.vendor_id)
1107 continue;
1108 if (q->pci_subvendor != codec->bus->pci->subsystem_vendor)
1109 continue;
1110 if (!q->pci_subdevice ||
1111 q->pci_subdevice == codec->bus->pci->subsystem_device)
1112 return alc_codec_rename(codec, q->name);
1113 }
1114
1115 return 0;
1116 }
1117
1118
1119 /*
1120 * Digital-beep handlers
1121 */
1122 #ifdef CONFIG_SND_HDA_INPUT_BEEP
1123
1124 /* additional beep mixers; private_value will be overwritten */
1125 static const struct snd_kcontrol_new alc_beep_mixer[] = {
1126 HDA_CODEC_VOLUME("Beep Playback Volume", 0, 0, HDA_INPUT),
1127 HDA_CODEC_MUTE_BEEP("Beep Playback Switch", 0, 0, HDA_INPUT),
1128 };
1129
1130 /* set up and create beep controls */
set_beep_amp(struct alc_spec * spec,hda_nid_t nid,int idx,int dir)1131 static int set_beep_amp(struct alc_spec *spec, hda_nid_t nid,
1132 int idx, int dir)
1133 {
1134 struct snd_kcontrol_new *knew;
1135 unsigned int beep_amp = HDA_COMPOSE_AMP_VAL(nid, 3, idx, dir);
1136 int i;
1137
1138 for (i = 0; i < ARRAY_SIZE(alc_beep_mixer); i++) {
1139 knew = snd_hda_gen_add_kctl(&spec->gen, NULL,
1140 &alc_beep_mixer[i]);
1141 if (!knew)
1142 return -ENOMEM;
1143 knew->private_value = beep_amp;
1144 }
1145 return 0;
1146 }
1147
1148 static const struct snd_pci_quirk beep_allow_list[] = {
1149 SND_PCI_QUIRK(0x1043, 0x103c, "ASUS", 1),
1150 SND_PCI_QUIRK(0x1043, 0x115d, "ASUS", 1),
1151 SND_PCI_QUIRK(0x1043, 0x829f, "ASUS", 1),
1152 SND_PCI_QUIRK(0x1043, 0x8376, "EeePC", 1),
1153 SND_PCI_QUIRK(0x1043, 0x83ce, "EeePC", 1),
1154 SND_PCI_QUIRK(0x1043, 0x831a, "EeePC", 1),
1155 SND_PCI_QUIRK(0x1043, 0x834a, "EeePC", 1),
1156 SND_PCI_QUIRK(0x1458, 0xa002, "GA-MA790X", 1),
1157 SND_PCI_QUIRK(0x8086, 0xd613, "Intel", 1),
1158 /* denylist -- no beep available */
1159 SND_PCI_QUIRK(0x17aa, 0x309e, "Lenovo ThinkCentre M73", 0),
1160 SND_PCI_QUIRK(0x17aa, 0x30a3, "Lenovo ThinkCentre M93", 0),
1161 {}
1162 };
1163
has_cdefine_beep(struct hda_codec * codec)1164 static inline int has_cdefine_beep(struct hda_codec *codec)
1165 {
1166 struct alc_spec *spec = codec->spec;
1167 const struct snd_pci_quirk *q;
1168 q = snd_pci_quirk_lookup(codec->bus->pci, beep_allow_list);
1169 if (q)
1170 return q->value;
1171 return spec->cdefine.enable_pcbeep;
1172 }
1173 #else
1174 #define set_beep_amp(spec, nid, idx, dir) 0
1175 #define has_cdefine_beep(codec) 0
1176 #endif
1177
1178 /* parse the BIOS configuration and set up the alc_spec */
1179 /* return 1 if successful, 0 if the proper config is not found,
1180 * or a negative error code
1181 */
alc_parse_auto_config(struct hda_codec * codec,const hda_nid_t * ignore_nids,const hda_nid_t * ssid_nids)1182 static int alc_parse_auto_config(struct hda_codec *codec,
1183 const hda_nid_t *ignore_nids,
1184 const hda_nid_t *ssid_nids)
1185 {
1186 struct alc_spec *spec = codec->spec;
1187 struct auto_pin_cfg *cfg = &spec->gen.autocfg;
1188 int err;
1189
1190 err = snd_hda_parse_pin_defcfg(codec, cfg, ignore_nids,
1191 spec->parse_flags);
1192 if (err < 0)
1193 return err;
1194
1195 if (ssid_nids)
1196 alc_ssid_check(codec, ssid_nids);
1197
1198 err = snd_hda_gen_parse_auto_config(codec, cfg);
1199 if (err < 0)
1200 return err;
1201
1202 return 1;
1203 }
1204
1205 /* common preparation job for alc_spec */
alc_alloc_spec(struct hda_codec * codec,hda_nid_t mixer_nid)1206 static int alc_alloc_spec(struct hda_codec *codec, hda_nid_t mixer_nid)
1207 {
1208 struct alc_spec *spec = kzalloc(sizeof(*spec), GFP_KERNEL);
1209 int err;
1210
1211 if (!spec)
1212 return -ENOMEM;
1213 codec->spec = spec;
1214 snd_hda_gen_spec_init(&spec->gen);
1215 spec->gen.mixer_nid = mixer_nid;
1216 spec->gen.own_eapd_ctl = 1;
1217 codec->single_adc_amp = 1;
1218 /* FIXME: do we need this for all Realtek codec models? */
1219 codec->spdif_status_reset = 1;
1220 codec->forced_resume = 1;
1221 codec->patch_ops = alc_patch_ops;
1222 mutex_init(&spec->coef_mutex);
1223
1224 err = alc_codec_rename_from_preset(codec);
1225 if (err < 0) {
1226 kfree(spec);
1227 return err;
1228 }
1229 return 0;
1230 }
1231
alc880_parse_auto_config(struct hda_codec * codec)1232 static int alc880_parse_auto_config(struct hda_codec *codec)
1233 {
1234 static const hda_nid_t alc880_ignore[] = { 0x1d, 0 };
1235 static const hda_nid_t alc880_ssids[] = { 0x15, 0x1b, 0x14, 0 };
1236 return alc_parse_auto_config(codec, alc880_ignore, alc880_ssids);
1237 }
1238
1239 /*
1240 * ALC880 fix-ups
1241 */
1242 enum {
1243 ALC880_FIXUP_GPIO1,
1244 ALC880_FIXUP_GPIO2,
1245 ALC880_FIXUP_MEDION_RIM,
1246 ALC880_FIXUP_LG,
1247 ALC880_FIXUP_LG_LW25,
1248 ALC880_FIXUP_W810,
1249 ALC880_FIXUP_EAPD_COEF,
1250 ALC880_FIXUP_TCL_S700,
1251 ALC880_FIXUP_VOL_KNOB,
1252 ALC880_FIXUP_FUJITSU,
1253 ALC880_FIXUP_F1734,
1254 ALC880_FIXUP_UNIWILL,
1255 ALC880_FIXUP_UNIWILL_DIG,
1256 ALC880_FIXUP_Z71V,
1257 ALC880_FIXUP_ASUS_W5A,
1258 ALC880_FIXUP_3ST_BASE,
1259 ALC880_FIXUP_3ST,
1260 ALC880_FIXUP_3ST_DIG,
1261 ALC880_FIXUP_5ST_BASE,
1262 ALC880_FIXUP_5ST,
1263 ALC880_FIXUP_5ST_DIG,
1264 ALC880_FIXUP_6ST_BASE,
1265 ALC880_FIXUP_6ST,
1266 ALC880_FIXUP_6ST_DIG,
1267 ALC880_FIXUP_6ST_AUTOMUTE,
1268 };
1269
1270 /* enable the volume-knob widget support on NID 0x21 */
alc880_fixup_vol_knob(struct hda_codec * codec,const struct hda_fixup * fix,int action)1271 static void alc880_fixup_vol_knob(struct hda_codec *codec,
1272 const struct hda_fixup *fix, int action)
1273 {
1274 if (action == HDA_FIXUP_ACT_PROBE)
1275 snd_hda_jack_detect_enable_callback(codec, 0x21,
1276 alc_update_knob_master);
1277 }
1278
1279 static const struct hda_fixup alc880_fixups[] = {
1280 [ALC880_FIXUP_GPIO1] = {
1281 .type = HDA_FIXUP_FUNC,
1282 .v.func = alc_fixup_gpio1,
1283 },
1284 [ALC880_FIXUP_GPIO2] = {
1285 .type = HDA_FIXUP_FUNC,
1286 .v.func = alc_fixup_gpio2,
1287 },
1288 [ALC880_FIXUP_MEDION_RIM] = {
1289 .type = HDA_FIXUP_VERBS,
1290 .v.verbs = (const struct hda_verb[]) {
1291 { 0x20, AC_VERB_SET_COEF_INDEX, 0x07 },
1292 { 0x20, AC_VERB_SET_PROC_COEF, 0x3060 },
1293 { }
1294 },
1295 .chained = true,
1296 .chain_id = ALC880_FIXUP_GPIO2,
1297 },
1298 [ALC880_FIXUP_LG] = {
1299 .type = HDA_FIXUP_PINS,
1300 .v.pins = (const struct hda_pintbl[]) {
1301 /* disable bogus unused pins */
1302 { 0x16, 0x411111f0 },
1303 { 0x18, 0x411111f0 },
1304 { 0x1a, 0x411111f0 },
1305 { }
1306 }
1307 },
1308 [ALC880_FIXUP_LG_LW25] = {
1309 .type = HDA_FIXUP_PINS,
1310 .v.pins = (const struct hda_pintbl[]) {
1311 { 0x1a, 0x0181344f }, /* line-in */
1312 { 0x1b, 0x0321403f }, /* headphone */
1313 { }
1314 }
1315 },
1316 [ALC880_FIXUP_W810] = {
1317 .type = HDA_FIXUP_PINS,
1318 .v.pins = (const struct hda_pintbl[]) {
1319 /* disable bogus unused pins */
1320 { 0x17, 0x411111f0 },
1321 { }
1322 },
1323 .chained = true,
1324 .chain_id = ALC880_FIXUP_GPIO2,
1325 },
1326 [ALC880_FIXUP_EAPD_COEF] = {
1327 .type = HDA_FIXUP_VERBS,
1328 .v.verbs = (const struct hda_verb[]) {
1329 /* change to EAPD mode */
1330 { 0x20, AC_VERB_SET_COEF_INDEX, 0x07 },
1331 { 0x20, AC_VERB_SET_PROC_COEF, 0x3060 },
1332 {}
1333 },
1334 },
1335 [ALC880_FIXUP_TCL_S700] = {
1336 .type = HDA_FIXUP_VERBS,
1337 .v.verbs = (const struct hda_verb[]) {
1338 /* change to EAPD mode */
1339 { 0x20, AC_VERB_SET_COEF_INDEX, 0x07 },
1340 { 0x20, AC_VERB_SET_PROC_COEF, 0x3070 },
1341 {}
1342 },
1343 .chained = true,
1344 .chain_id = ALC880_FIXUP_GPIO2,
1345 },
1346 [ALC880_FIXUP_VOL_KNOB] = {
1347 .type = HDA_FIXUP_FUNC,
1348 .v.func = alc880_fixup_vol_knob,
1349 },
1350 [ALC880_FIXUP_FUJITSU] = {
1351 /* override all pins as BIOS on old Amilo is broken */
1352 .type = HDA_FIXUP_PINS,
1353 .v.pins = (const struct hda_pintbl[]) {
1354 { 0x14, 0x0121401f }, /* HP */
1355 { 0x15, 0x99030120 }, /* speaker */
1356 { 0x16, 0x99030130 }, /* bass speaker */
1357 { 0x17, 0x411111f0 }, /* N/A */
1358 { 0x18, 0x411111f0 }, /* N/A */
1359 { 0x19, 0x01a19950 }, /* mic-in */
1360 { 0x1a, 0x411111f0 }, /* N/A */
1361 { 0x1b, 0x411111f0 }, /* N/A */
1362 { 0x1c, 0x411111f0 }, /* N/A */
1363 { 0x1d, 0x411111f0 }, /* N/A */
1364 { 0x1e, 0x01454140 }, /* SPDIF out */
1365 { }
1366 },
1367 .chained = true,
1368 .chain_id = ALC880_FIXUP_VOL_KNOB,
1369 },
1370 [ALC880_FIXUP_F1734] = {
1371 /* almost compatible with FUJITSU, but no bass and SPDIF */
1372 .type = HDA_FIXUP_PINS,
1373 .v.pins = (const struct hda_pintbl[]) {
1374 { 0x14, 0x0121401f }, /* HP */
1375 { 0x15, 0x99030120 }, /* speaker */
1376 { 0x16, 0x411111f0 }, /* N/A */
1377 { 0x17, 0x411111f0 }, /* N/A */
1378 { 0x18, 0x411111f0 }, /* N/A */
1379 { 0x19, 0x01a19950 }, /* mic-in */
1380 { 0x1a, 0x411111f0 }, /* N/A */
1381 { 0x1b, 0x411111f0 }, /* N/A */
1382 { 0x1c, 0x411111f0 }, /* N/A */
1383 { 0x1d, 0x411111f0 }, /* N/A */
1384 { 0x1e, 0x411111f0 }, /* N/A */
1385 { }
1386 },
1387 .chained = true,
1388 .chain_id = ALC880_FIXUP_VOL_KNOB,
1389 },
1390 [ALC880_FIXUP_UNIWILL] = {
1391 /* need to fix HP and speaker pins to be parsed correctly */
1392 .type = HDA_FIXUP_PINS,
1393 .v.pins = (const struct hda_pintbl[]) {
1394 { 0x14, 0x0121411f }, /* HP */
1395 { 0x15, 0x99030120 }, /* speaker */
1396 { 0x16, 0x99030130 }, /* bass speaker */
1397 { }
1398 },
1399 },
1400 [ALC880_FIXUP_UNIWILL_DIG] = {
1401 .type = HDA_FIXUP_PINS,
1402 .v.pins = (const struct hda_pintbl[]) {
1403 /* disable bogus unused pins */
1404 { 0x17, 0x411111f0 },
1405 { 0x19, 0x411111f0 },
1406 { 0x1b, 0x411111f0 },
1407 { 0x1f, 0x411111f0 },
1408 { }
1409 }
1410 },
1411 [ALC880_FIXUP_Z71V] = {
1412 .type = HDA_FIXUP_PINS,
1413 .v.pins = (const struct hda_pintbl[]) {
1414 /* set up the whole pins as BIOS is utterly broken */
1415 { 0x14, 0x99030120 }, /* speaker */
1416 { 0x15, 0x0121411f }, /* HP */
1417 { 0x16, 0x411111f0 }, /* N/A */
1418 { 0x17, 0x411111f0 }, /* N/A */
1419 { 0x18, 0x01a19950 }, /* mic-in */
1420 { 0x19, 0x411111f0 }, /* N/A */
1421 { 0x1a, 0x01813031 }, /* line-in */
1422 { 0x1b, 0x411111f0 }, /* N/A */
1423 { 0x1c, 0x411111f0 }, /* N/A */
1424 { 0x1d, 0x411111f0 }, /* N/A */
1425 { 0x1e, 0x0144111e }, /* SPDIF */
1426 { }
1427 }
1428 },
1429 [ALC880_FIXUP_ASUS_W5A] = {
1430 .type = HDA_FIXUP_PINS,
1431 .v.pins = (const struct hda_pintbl[]) {
1432 /* set up the whole pins as BIOS is utterly broken */
1433 { 0x14, 0x0121411f }, /* HP */
1434 { 0x15, 0x411111f0 }, /* N/A */
1435 { 0x16, 0x411111f0 }, /* N/A */
1436 { 0x17, 0x411111f0 }, /* N/A */
1437 { 0x18, 0x90a60160 }, /* mic */
1438 { 0x19, 0x411111f0 }, /* N/A */
1439 { 0x1a, 0x411111f0 }, /* N/A */
1440 { 0x1b, 0x411111f0 }, /* N/A */
1441 { 0x1c, 0x411111f0 }, /* N/A */
1442 { 0x1d, 0x411111f0 }, /* N/A */
1443 { 0x1e, 0xb743111e }, /* SPDIF out */
1444 { }
1445 },
1446 .chained = true,
1447 .chain_id = ALC880_FIXUP_GPIO1,
1448 },
1449 [ALC880_FIXUP_3ST_BASE] = {
1450 .type = HDA_FIXUP_PINS,
1451 .v.pins = (const struct hda_pintbl[]) {
1452 { 0x14, 0x01014010 }, /* line-out */
1453 { 0x15, 0x411111f0 }, /* N/A */
1454 { 0x16, 0x411111f0 }, /* N/A */
1455 { 0x17, 0x411111f0 }, /* N/A */
1456 { 0x18, 0x01a19c30 }, /* mic-in */
1457 { 0x19, 0x0121411f }, /* HP */
1458 { 0x1a, 0x01813031 }, /* line-in */
1459 { 0x1b, 0x02a19c40 }, /* front-mic */
1460 { 0x1c, 0x411111f0 }, /* N/A */
1461 { 0x1d, 0x411111f0 }, /* N/A */
1462 /* 0x1e is filled in below */
1463 { 0x1f, 0x411111f0 }, /* N/A */
1464 { }
1465 }
1466 },
1467 [ALC880_FIXUP_3ST] = {
1468 .type = HDA_FIXUP_PINS,
1469 .v.pins = (const struct hda_pintbl[]) {
1470 { 0x1e, 0x411111f0 }, /* N/A */
1471 { }
1472 },
1473 .chained = true,
1474 .chain_id = ALC880_FIXUP_3ST_BASE,
1475 },
1476 [ALC880_FIXUP_3ST_DIG] = {
1477 .type = HDA_FIXUP_PINS,
1478 .v.pins = (const struct hda_pintbl[]) {
1479 { 0x1e, 0x0144111e }, /* SPDIF */
1480 { }
1481 },
1482 .chained = true,
1483 .chain_id = ALC880_FIXUP_3ST_BASE,
1484 },
1485 [ALC880_FIXUP_5ST_BASE] = {
1486 .type = HDA_FIXUP_PINS,
1487 .v.pins = (const struct hda_pintbl[]) {
1488 { 0x14, 0x01014010 }, /* front */
1489 { 0x15, 0x411111f0 }, /* N/A */
1490 { 0x16, 0x01011411 }, /* CLFE */
1491 { 0x17, 0x01016412 }, /* surr */
1492 { 0x18, 0x01a19c30 }, /* mic-in */
1493 { 0x19, 0x0121411f }, /* HP */
1494 { 0x1a, 0x01813031 }, /* line-in */
1495 { 0x1b, 0x02a19c40 }, /* front-mic */
1496 { 0x1c, 0x411111f0 }, /* N/A */
1497 { 0x1d, 0x411111f0 }, /* N/A */
1498 /* 0x1e is filled in below */
1499 { 0x1f, 0x411111f0 }, /* N/A */
1500 { }
1501 }
1502 },
1503 [ALC880_FIXUP_5ST] = {
1504 .type = HDA_FIXUP_PINS,
1505 .v.pins = (const struct hda_pintbl[]) {
1506 { 0x1e, 0x411111f0 }, /* N/A */
1507 { }
1508 },
1509 .chained = true,
1510 .chain_id = ALC880_FIXUP_5ST_BASE,
1511 },
1512 [ALC880_FIXUP_5ST_DIG] = {
1513 .type = HDA_FIXUP_PINS,
1514 .v.pins = (const struct hda_pintbl[]) {
1515 { 0x1e, 0x0144111e }, /* SPDIF */
1516 { }
1517 },
1518 .chained = true,
1519 .chain_id = ALC880_FIXUP_5ST_BASE,
1520 },
1521 [ALC880_FIXUP_6ST_BASE] = {
1522 .type = HDA_FIXUP_PINS,
1523 .v.pins = (const struct hda_pintbl[]) {
1524 { 0x14, 0x01014010 }, /* front */
1525 { 0x15, 0x01016412 }, /* surr */
1526 { 0x16, 0x01011411 }, /* CLFE */
1527 { 0x17, 0x01012414 }, /* side */
1528 { 0x18, 0x01a19c30 }, /* mic-in */
1529 { 0x19, 0x02a19c40 }, /* front-mic */
1530 { 0x1a, 0x01813031 }, /* line-in */
1531 { 0x1b, 0x0121411f }, /* HP */
1532 { 0x1c, 0x411111f0 }, /* N/A */
1533 { 0x1d, 0x411111f0 }, /* N/A */
1534 /* 0x1e is filled in below */
1535 { 0x1f, 0x411111f0 }, /* N/A */
1536 { }
1537 }
1538 },
1539 [ALC880_FIXUP_6ST] = {
1540 .type = HDA_FIXUP_PINS,
1541 .v.pins = (const struct hda_pintbl[]) {
1542 { 0x1e, 0x411111f0 }, /* N/A */
1543 { }
1544 },
1545 .chained = true,
1546 .chain_id = ALC880_FIXUP_6ST_BASE,
1547 },
1548 [ALC880_FIXUP_6ST_DIG] = {
1549 .type = HDA_FIXUP_PINS,
1550 .v.pins = (const struct hda_pintbl[]) {
1551 { 0x1e, 0x0144111e }, /* SPDIF */
1552 { }
1553 },
1554 .chained = true,
1555 .chain_id = ALC880_FIXUP_6ST_BASE,
1556 },
1557 [ALC880_FIXUP_6ST_AUTOMUTE] = {
1558 .type = HDA_FIXUP_PINS,
1559 .v.pins = (const struct hda_pintbl[]) {
1560 { 0x1b, 0x0121401f }, /* HP with jack detect */
1561 { }
1562 },
1563 .chained_before = true,
1564 .chain_id = ALC880_FIXUP_6ST_BASE,
1565 },
1566 };
1567
1568 static const struct snd_pci_quirk alc880_fixup_tbl[] = {
1569 SND_PCI_QUIRK(0x1019, 0x0f69, "Coeus G610P", ALC880_FIXUP_W810),
1570 SND_PCI_QUIRK(0x1043, 0x10c3, "ASUS W5A", ALC880_FIXUP_ASUS_W5A),
1571 SND_PCI_QUIRK(0x1043, 0x1964, "ASUS Z71V", ALC880_FIXUP_Z71V),
1572 SND_PCI_QUIRK_VENDOR(0x1043, "ASUS", ALC880_FIXUP_GPIO1),
1573 SND_PCI_QUIRK(0x147b, 0x1045, "ABit AA8XE", ALC880_FIXUP_6ST_AUTOMUTE),
1574 SND_PCI_QUIRK(0x1558, 0x5401, "Clevo GPIO2", ALC880_FIXUP_GPIO2),
1575 SND_PCI_QUIRK_VENDOR(0x1558, "Clevo", ALC880_FIXUP_EAPD_COEF),
1576 SND_PCI_QUIRK(0x1584, 0x9050, "Uniwill", ALC880_FIXUP_UNIWILL_DIG),
1577 SND_PCI_QUIRK(0x1584, 0x9054, "Uniwill", ALC880_FIXUP_F1734),
1578 SND_PCI_QUIRK(0x1584, 0x9070, "Uniwill", ALC880_FIXUP_UNIWILL),
1579 SND_PCI_QUIRK(0x1584, 0x9077, "Uniwill P53", ALC880_FIXUP_VOL_KNOB),
1580 SND_PCI_QUIRK(0x161f, 0x203d, "W810", ALC880_FIXUP_W810),
1581 SND_PCI_QUIRK(0x161f, 0x205d, "Medion Rim 2150", ALC880_FIXUP_MEDION_RIM),
1582 SND_PCI_QUIRK(0x1631, 0xe011, "PB 13201056", ALC880_FIXUP_6ST_AUTOMUTE),
1583 SND_PCI_QUIRK(0x1734, 0x107c, "FSC Amilo M1437", ALC880_FIXUP_FUJITSU),
1584 SND_PCI_QUIRK(0x1734, 0x1094, "FSC Amilo M1451G", ALC880_FIXUP_FUJITSU),
1585 SND_PCI_QUIRK(0x1734, 0x10ac, "FSC AMILO Xi 1526", ALC880_FIXUP_F1734),
1586 SND_PCI_QUIRK(0x1734, 0x10b0, "FSC Amilo Pi1556", ALC880_FIXUP_FUJITSU),
1587 SND_PCI_QUIRK(0x1854, 0x003b, "LG", ALC880_FIXUP_LG),
1588 SND_PCI_QUIRK(0x1854, 0x005f, "LG P1 Express", ALC880_FIXUP_LG),
1589 SND_PCI_QUIRK(0x1854, 0x0068, "LG w1", ALC880_FIXUP_LG),
1590 SND_PCI_QUIRK(0x1854, 0x0077, "LG LW25", ALC880_FIXUP_LG_LW25),
1591 SND_PCI_QUIRK(0x19db, 0x4188, "TCL S700", ALC880_FIXUP_TCL_S700),
1592
1593 /* Below is the copied entries from alc880_quirks.c.
1594 * It's not quite sure whether BIOS sets the correct pin-config table
1595 * on these machines, thus they are kept to be compatible with
1596 * the old static quirks. Once when it's confirmed to work without
1597 * these overrides, it'd be better to remove.
1598 */
1599 SND_PCI_QUIRK(0x1019, 0xa880, "ECS", ALC880_FIXUP_5ST_DIG),
1600 SND_PCI_QUIRK(0x1019, 0xa884, "Acer APFV", ALC880_FIXUP_6ST),
1601 SND_PCI_QUIRK(0x1025, 0x0070, "ULI", ALC880_FIXUP_3ST_DIG),
1602 SND_PCI_QUIRK(0x1025, 0x0077, "ULI", ALC880_FIXUP_6ST_DIG),
1603 SND_PCI_QUIRK(0x1025, 0x0078, "ULI", ALC880_FIXUP_6ST_DIG),
1604 SND_PCI_QUIRK(0x1025, 0x0087, "ULI", ALC880_FIXUP_6ST_DIG),
1605 SND_PCI_QUIRK(0x1025, 0xe309, "ULI", ALC880_FIXUP_3ST_DIG),
1606 SND_PCI_QUIRK(0x1025, 0xe310, "ULI", ALC880_FIXUP_3ST),
1607 SND_PCI_QUIRK(0x1039, 0x1234, NULL, ALC880_FIXUP_6ST_DIG),
1608 SND_PCI_QUIRK(0x104d, 0x81a0, "Sony", ALC880_FIXUP_3ST),
1609 SND_PCI_QUIRK(0x104d, 0x81d6, "Sony", ALC880_FIXUP_3ST),
1610 SND_PCI_QUIRK(0x107b, 0x3032, "Gateway", ALC880_FIXUP_5ST),
1611 SND_PCI_QUIRK(0x107b, 0x3033, "Gateway", ALC880_FIXUP_5ST),
1612 SND_PCI_QUIRK(0x107b, 0x4039, "Gateway", ALC880_FIXUP_5ST),
1613 SND_PCI_QUIRK(0x1297, 0xc790, "Shuttle ST20G5", ALC880_FIXUP_6ST_DIG),
1614 SND_PCI_QUIRK(0x1458, 0xa102, "Gigabyte K8", ALC880_FIXUP_6ST_DIG),
1615 SND_PCI_QUIRK(0x1462, 0x1150, "MSI", ALC880_FIXUP_6ST_DIG),
1616 SND_PCI_QUIRK(0x1509, 0x925d, "FIC P4M", ALC880_FIXUP_6ST_DIG),
1617 SND_PCI_QUIRK(0x1565, 0x8202, "Biostar", ALC880_FIXUP_5ST_DIG),
1618 SND_PCI_QUIRK(0x1695, 0x400d, "EPoX", ALC880_FIXUP_5ST_DIG),
1619 SND_PCI_QUIRK(0x1695, 0x4012, "EPox EP-5LDA", ALC880_FIXUP_5ST_DIG),
1620 SND_PCI_QUIRK(0x2668, 0x8086, NULL, ALC880_FIXUP_6ST_DIG), /* broken BIOS */
1621 SND_PCI_QUIRK(0x8086, 0x2668, NULL, ALC880_FIXUP_6ST_DIG),
1622 SND_PCI_QUIRK(0x8086, 0xa100, "Intel mobo", ALC880_FIXUP_5ST_DIG),
1623 SND_PCI_QUIRK(0x8086, 0xd400, "Intel mobo", ALC880_FIXUP_5ST_DIG),
1624 SND_PCI_QUIRK(0x8086, 0xd401, "Intel mobo", ALC880_FIXUP_5ST_DIG),
1625 SND_PCI_QUIRK(0x8086, 0xd402, "Intel mobo", ALC880_FIXUP_3ST_DIG),
1626 SND_PCI_QUIRK(0x8086, 0xe224, "Intel mobo", ALC880_FIXUP_5ST_DIG),
1627 SND_PCI_QUIRK(0x8086, 0xe305, "Intel mobo", ALC880_FIXUP_3ST_DIG),
1628 SND_PCI_QUIRK(0x8086, 0xe308, "Intel mobo", ALC880_FIXUP_3ST_DIG),
1629 SND_PCI_QUIRK(0x8086, 0xe400, "Intel mobo", ALC880_FIXUP_5ST_DIG),
1630 SND_PCI_QUIRK(0x8086, 0xe401, "Intel mobo", ALC880_FIXUP_5ST_DIG),
1631 SND_PCI_QUIRK(0x8086, 0xe402, "Intel mobo", ALC880_FIXUP_5ST_DIG),
1632 /* default Intel */
1633 SND_PCI_QUIRK_VENDOR(0x8086, "Intel mobo", ALC880_FIXUP_3ST),
1634 SND_PCI_QUIRK(0xa0a0, 0x0560, "AOpen i915GMm-HFS", ALC880_FIXUP_5ST_DIG),
1635 SND_PCI_QUIRK(0xe803, 0x1019, NULL, ALC880_FIXUP_6ST_DIG),
1636 {}
1637 };
1638
1639 static const struct hda_model_fixup alc880_fixup_models[] = {
1640 {.id = ALC880_FIXUP_3ST, .name = "3stack"},
1641 {.id = ALC880_FIXUP_3ST_DIG, .name = "3stack-digout"},
1642 {.id = ALC880_FIXUP_5ST, .name = "5stack"},
1643 {.id = ALC880_FIXUP_5ST_DIG, .name = "5stack-digout"},
1644 {.id = ALC880_FIXUP_6ST, .name = "6stack"},
1645 {.id = ALC880_FIXUP_6ST_DIG, .name = "6stack-digout"},
1646 {.id = ALC880_FIXUP_6ST_AUTOMUTE, .name = "6stack-automute"},
1647 {}
1648 };
1649
1650
1651 /*
1652 * OK, here we have finally the patch for ALC880
1653 */
patch_alc880(struct hda_codec * codec)1654 static int patch_alc880(struct hda_codec *codec)
1655 {
1656 struct alc_spec *spec;
1657 int err;
1658
1659 err = alc_alloc_spec(codec, 0x0b);
1660 if (err < 0)
1661 return err;
1662
1663 spec = codec->spec;
1664 spec->gen.need_dac_fix = 1;
1665 spec->gen.beep_nid = 0x01;
1666
1667 codec->patch_ops.unsol_event = alc880_unsol_event;
1668
1669 alc_pre_init(codec);
1670
1671 snd_hda_pick_fixup(codec, alc880_fixup_models, alc880_fixup_tbl,
1672 alc880_fixups);
1673 snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE);
1674
1675 /* automatic parse from the BIOS config */
1676 err = alc880_parse_auto_config(codec);
1677 if (err < 0)
1678 goto error;
1679
1680 if (!spec->gen.no_analog) {
1681 err = set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
1682 if (err < 0)
1683 goto error;
1684 }
1685
1686 snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE);
1687
1688 return 0;
1689
1690 error:
1691 alc_free(codec);
1692 return err;
1693 }
1694
1695
1696 /*
1697 * ALC260 support
1698 */
alc260_parse_auto_config(struct hda_codec * codec)1699 static int alc260_parse_auto_config(struct hda_codec *codec)
1700 {
1701 static const hda_nid_t alc260_ignore[] = { 0x17, 0 };
1702 static const hda_nid_t alc260_ssids[] = { 0x10, 0x15, 0x0f, 0 };
1703 return alc_parse_auto_config(codec, alc260_ignore, alc260_ssids);
1704 }
1705
1706 /*
1707 * Pin config fixes
1708 */
1709 enum {
1710 ALC260_FIXUP_HP_DC5750,
1711 ALC260_FIXUP_HP_PIN_0F,
1712 ALC260_FIXUP_COEF,
1713 ALC260_FIXUP_GPIO1,
1714 ALC260_FIXUP_GPIO1_TOGGLE,
1715 ALC260_FIXUP_REPLACER,
1716 ALC260_FIXUP_HP_B1900,
1717 ALC260_FIXUP_KN1,
1718 ALC260_FIXUP_FSC_S7020,
1719 ALC260_FIXUP_FSC_S7020_JWSE,
1720 ALC260_FIXUP_VAIO_PINS,
1721 };
1722
alc260_gpio1_automute(struct hda_codec * codec)1723 static void alc260_gpio1_automute(struct hda_codec *codec)
1724 {
1725 struct alc_spec *spec = codec->spec;
1726
1727 alc_update_gpio_data(codec, 0x01, spec->gen.hp_jack_present);
1728 }
1729
alc260_fixup_gpio1_toggle(struct hda_codec * codec,const struct hda_fixup * fix,int action)1730 static void alc260_fixup_gpio1_toggle(struct hda_codec *codec,
1731 const struct hda_fixup *fix, int action)
1732 {
1733 struct alc_spec *spec = codec->spec;
1734 if (action == HDA_FIXUP_ACT_PROBE) {
1735 /* although the machine has only one output pin, we need to
1736 * toggle GPIO1 according to the jack state
1737 */
1738 spec->gen.automute_hook = alc260_gpio1_automute;
1739 spec->gen.detect_hp = 1;
1740 spec->gen.automute_speaker = 1;
1741 spec->gen.autocfg.hp_pins[0] = 0x0f; /* copy it for automute */
1742 snd_hda_jack_detect_enable_callback(codec, 0x0f,
1743 snd_hda_gen_hp_automute);
1744 alc_setup_gpio(codec, 0x01);
1745 }
1746 }
1747
alc260_fixup_kn1(struct hda_codec * codec,const struct hda_fixup * fix,int action)1748 static void alc260_fixup_kn1(struct hda_codec *codec,
1749 const struct hda_fixup *fix, int action)
1750 {
1751 struct alc_spec *spec = codec->spec;
1752 static const struct hda_pintbl pincfgs[] = {
1753 { 0x0f, 0x02214000 }, /* HP/speaker */
1754 { 0x12, 0x90a60160 }, /* int mic */
1755 { 0x13, 0x02a19000 }, /* ext mic */
1756 { 0x18, 0x01446000 }, /* SPDIF out */
1757 /* disable bogus I/O pins */
1758 { 0x10, 0x411111f0 },
1759 { 0x11, 0x411111f0 },
1760 { 0x14, 0x411111f0 },
1761 { 0x15, 0x411111f0 },
1762 { 0x16, 0x411111f0 },
1763 { 0x17, 0x411111f0 },
1764 { 0x19, 0x411111f0 },
1765 { }
1766 };
1767
1768 switch (action) {
1769 case HDA_FIXUP_ACT_PRE_PROBE:
1770 snd_hda_apply_pincfgs(codec, pincfgs);
1771 spec->init_amp = ALC_INIT_NONE;
1772 break;
1773 }
1774 }
1775
alc260_fixup_fsc_s7020(struct hda_codec * codec,const struct hda_fixup * fix,int action)1776 static void alc260_fixup_fsc_s7020(struct hda_codec *codec,
1777 const struct hda_fixup *fix, int action)
1778 {
1779 struct alc_spec *spec = codec->spec;
1780 if (action == HDA_FIXUP_ACT_PRE_PROBE)
1781 spec->init_amp = ALC_INIT_NONE;
1782 }
1783
alc260_fixup_fsc_s7020_jwse(struct hda_codec * codec,const struct hda_fixup * fix,int action)1784 static void alc260_fixup_fsc_s7020_jwse(struct hda_codec *codec,
1785 const struct hda_fixup *fix, int action)
1786 {
1787 struct alc_spec *spec = codec->spec;
1788 if (action == HDA_FIXUP_ACT_PRE_PROBE) {
1789 spec->gen.add_jack_modes = 1;
1790 spec->gen.hp_mic = 1;
1791 }
1792 }
1793
1794 static const struct hda_fixup alc260_fixups[] = {
1795 [ALC260_FIXUP_HP_DC5750] = {
1796 .type = HDA_FIXUP_PINS,
1797 .v.pins = (const struct hda_pintbl[]) {
1798 { 0x11, 0x90130110 }, /* speaker */
1799 { }
1800 }
1801 },
1802 [ALC260_FIXUP_HP_PIN_0F] = {
1803 .type = HDA_FIXUP_PINS,
1804 .v.pins = (const struct hda_pintbl[]) {
1805 { 0x0f, 0x01214000 }, /* HP */
1806 { }
1807 }
1808 },
1809 [ALC260_FIXUP_COEF] = {
1810 .type = HDA_FIXUP_VERBS,
1811 .v.verbs = (const struct hda_verb[]) {
1812 { 0x1a, AC_VERB_SET_COEF_INDEX, 0x07 },
1813 { 0x1a, AC_VERB_SET_PROC_COEF, 0x3040 },
1814 { }
1815 },
1816 },
1817 [ALC260_FIXUP_GPIO1] = {
1818 .type = HDA_FIXUP_FUNC,
1819 .v.func = alc_fixup_gpio1,
1820 },
1821 [ALC260_FIXUP_GPIO1_TOGGLE] = {
1822 .type = HDA_FIXUP_FUNC,
1823 .v.func = alc260_fixup_gpio1_toggle,
1824 .chained = true,
1825 .chain_id = ALC260_FIXUP_HP_PIN_0F,
1826 },
1827 [ALC260_FIXUP_REPLACER] = {
1828 .type = HDA_FIXUP_VERBS,
1829 .v.verbs = (const struct hda_verb[]) {
1830 { 0x1a, AC_VERB_SET_COEF_INDEX, 0x07 },
1831 { 0x1a, AC_VERB_SET_PROC_COEF, 0x3050 },
1832 { }
1833 },
1834 .chained = true,
1835 .chain_id = ALC260_FIXUP_GPIO1_TOGGLE,
1836 },
1837 [ALC260_FIXUP_HP_B1900] = {
1838 .type = HDA_FIXUP_FUNC,
1839 .v.func = alc260_fixup_gpio1_toggle,
1840 .chained = true,
1841 .chain_id = ALC260_FIXUP_COEF,
1842 },
1843 [ALC260_FIXUP_KN1] = {
1844 .type = HDA_FIXUP_FUNC,
1845 .v.func = alc260_fixup_kn1,
1846 },
1847 [ALC260_FIXUP_FSC_S7020] = {
1848 .type = HDA_FIXUP_FUNC,
1849 .v.func = alc260_fixup_fsc_s7020,
1850 },
1851 [ALC260_FIXUP_FSC_S7020_JWSE] = {
1852 .type = HDA_FIXUP_FUNC,
1853 .v.func = alc260_fixup_fsc_s7020_jwse,
1854 .chained = true,
1855 .chain_id = ALC260_FIXUP_FSC_S7020,
1856 },
1857 [ALC260_FIXUP_VAIO_PINS] = {
1858 .type = HDA_FIXUP_PINS,
1859 .v.pins = (const struct hda_pintbl[]) {
1860 /* Pin configs are missing completely on some VAIOs */
1861 { 0x0f, 0x01211020 },
1862 { 0x10, 0x0001003f },
1863 { 0x11, 0x411111f0 },
1864 { 0x12, 0x01a15930 },
1865 { 0x13, 0x411111f0 },
1866 { 0x14, 0x411111f0 },
1867 { 0x15, 0x411111f0 },
1868 { 0x16, 0x411111f0 },
1869 { 0x17, 0x411111f0 },
1870 { 0x18, 0x411111f0 },
1871 { 0x19, 0x411111f0 },
1872 { }
1873 }
1874 },
1875 };
1876
1877 static const struct snd_pci_quirk alc260_fixup_tbl[] = {
1878 SND_PCI_QUIRK(0x1025, 0x007b, "Acer C20x", ALC260_FIXUP_GPIO1),
1879 SND_PCI_QUIRK(0x1025, 0x007f, "Acer Aspire 9500", ALC260_FIXUP_COEF),
1880 SND_PCI_QUIRK(0x1025, 0x008f, "Acer", ALC260_FIXUP_GPIO1),
1881 SND_PCI_QUIRK(0x103c, 0x280a, "HP dc5750", ALC260_FIXUP_HP_DC5750),
1882 SND_PCI_QUIRK(0x103c, 0x30ba, "HP Presario B1900", ALC260_FIXUP_HP_B1900),
1883 SND_PCI_QUIRK(0x104d, 0x81bb, "Sony VAIO", ALC260_FIXUP_VAIO_PINS),
1884 SND_PCI_QUIRK(0x104d, 0x81e2, "Sony VAIO TX", ALC260_FIXUP_HP_PIN_0F),
1885 SND_PCI_QUIRK(0x10cf, 0x1326, "FSC LifeBook S7020", ALC260_FIXUP_FSC_S7020),
1886 SND_PCI_QUIRK(0x1509, 0x4540, "Favorit 100XS", ALC260_FIXUP_GPIO1),
1887 SND_PCI_QUIRK(0x152d, 0x0729, "Quanta KN1", ALC260_FIXUP_KN1),
1888 SND_PCI_QUIRK(0x161f, 0x2057, "Replacer 672V", ALC260_FIXUP_REPLACER),
1889 SND_PCI_QUIRK(0x1631, 0xc017, "PB V7900", ALC260_FIXUP_COEF),
1890 {}
1891 };
1892
1893 static const struct hda_model_fixup alc260_fixup_models[] = {
1894 {.id = ALC260_FIXUP_GPIO1, .name = "gpio1"},
1895 {.id = ALC260_FIXUP_COEF, .name = "coef"},
1896 {.id = ALC260_FIXUP_FSC_S7020, .name = "fujitsu"},
1897 {.id = ALC260_FIXUP_FSC_S7020_JWSE, .name = "fujitsu-jwse"},
1898 {}
1899 };
1900
1901 /*
1902 */
patch_alc260(struct hda_codec * codec)1903 static int patch_alc260(struct hda_codec *codec)
1904 {
1905 struct alc_spec *spec;
1906 int err;
1907
1908 err = alc_alloc_spec(codec, 0x07);
1909 if (err < 0)
1910 return err;
1911
1912 spec = codec->spec;
1913 /* as quite a few machines require HP amp for speaker outputs,
1914 * it's easier to enable it unconditionally; even if it's unneeded,
1915 * it's almost harmless.
1916 */
1917 spec->gen.prefer_hp_amp = 1;
1918 spec->gen.beep_nid = 0x01;
1919
1920 spec->shutup = alc_eapd_shutup;
1921
1922 alc_pre_init(codec);
1923
1924 snd_hda_pick_fixup(codec, alc260_fixup_models, alc260_fixup_tbl,
1925 alc260_fixups);
1926 snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE);
1927
1928 /* automatic parse from the BIOS config */
1929 err = alc260_parse_auto_config(codec);
1930 if (err < 0)
1931 goto error;
1932
1933 if (!spec->gen.no_analog) {
1934 err = set_beep_amp(spec, 0x07, 0x05, HDA_INPUT);
1935 if (err < 0)
1936 goto error;
1937 }
1938
1939 snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE);
1940
1941 return 0;
1942
1943 error:
1944 alc_free(codec);
1945 return err;
1946 }
1947
1948
1949 /*
1950 * ALC882/883/885/888/889 support
1951 *
1952 * ALC882 is almost identical with ALC880 but has cleaner and more flexible
1953 * configuration. Each pin widget can choose any input DACs and a mixer.
1954 * Each ADC is connected from a mixer of all inputs. This makes possible
1955 * 6-channel independent captures.
1956 *
1957 * In addition, an independent DAC for the multi-playback (not used in this
1958 * driver yet).
1959 */
1960
1961 /*
1962 * Pin config fixes
1963 */
1964 enum {
1965 ALC882_FIXUP_ABIT_AW9D_MAX,
1966 ALC882_FIXUP_LENOVO_Y530,
1967 ALC882_FIXUP_PB_M5210,
1968 ALC882_FIXUP_ACER_ASPIRE_7736,
1969 ALC882_FIXUP_ASUS_W90V,
1970 ALC889_FIXUP_CD,
1971 ALC889_FIXUP_FRONT_HP_NO_PRESENCE,
1972 ALC889_FIXUP_VAIO_TT,
1973 ALC888_FIXUP_EEE1601,
1974 ALC886_FIXUP_EAPD,
1975 ALC882_FIXUP_EAPD,
1976 ALC883_FIXUP_EAPD,
1977 ALC883_FIXUP_ACER_EAPD,
1978 ALC882_FIXUP_GPIO1,
1979 ALC882_FIXUP_GPIO2,
1980 ALC882_FIXUP_GPIO3,
1981 ALC889_FIXUP_COEF,
1982 ALC882_FIXUP_ASUS_W2JC,
1983 ALC882_FIXUP_ACER_ASPIRE_4930G,
1984 ALC882_FIXUP_ACER_ASPIRE_8930G,
1985 ALC882_FIXUP_ASPIRE_8930G_VERBS,
1986 ALC885_FIXUP_MACPRO_GPIO,
1987 ALC889_FIXUP_DAC_ROUTE,
1988 ALC889_FIXUP_MBP_VREF,
1989 ALC889_FIXUP_IMAC91_VREF,
1990 ALC889_FIXUP_MBA11_VREF,
1991 ALC889_FIXUP_MBA21_VREF,
1992 ALC889_FIXUP_MP11_VREF,
1993 ALC889_FIXUP_MP41_VREF,
1994 ALC882_FIXUP_INV_DMIC,
1995 ALC882_FIXUP_NO_PRIMARY_HP,
1996 ALC887_FIXUP_ASUS_BASS,
1997 ALC887_FIXUP_BASS_CHMAP,
1998 ALC1220_FIXUP_GB_DUAL_CODECS,
1999 ALC1220_FIXUP_GB_X570,
2000 ALC1220_FIXUP_CLEVO_P950,
2001 ALC1220_FIXUP_CLEVO_PB51ED,
2002 ALC1220_FIXUP_CLEVO_PB51ED_PINS,
2003 ALC887_FIXUP_ASUS_AUDIO,
2004 ALC887_FIXUP_ASUS_HMIC,
2005 ALCS1200A_FIXUP_MIC_VREF,
2006 ALC888VD_FIXUP_MIC_100VREF,
2007 };
2008
alc889_fixup_coef(struct hda_codec * codec,const struct hda_fixup * fix,int action)2009 static void alc889_fixup_coef(struct hda_codec *codec,
2010 const struct hda_fixup *fix, int action)
2011 {
2012 if (action != HDA_FIXUP_ACT_INIT)
2013 return;
2014 alc_update_coef_idx(codec, 7, 0, 0x2030);
2015 }
2016
2017 /* set up GPIO at initialization */
alc885_fixup_macpro_gpio(struct hda_codec * codec,const struct hda_fixup * fix,int action)2018 static void alc885_fixup_macpro_gpio(struct hda_codec *codec,
2019 const struct hda_fixup *fix, int action)
2020 {
2021 struct alc_spec *spec = codec->spec;
2022
2023 spec->gpio_write_delay = true;
2024 alc_fixup_gpio3(codec, fix, action);
2025 }
2026
2027 /* Fix the connection of some pins for ALC889:
2028 * At least, Acer Aspire 5935 shows the connections to DAC3/4 don't
2029 * work correctly (bko#42740)
2030 */
alc889_fixup_dac_route(struct hda_codec * codec,const struct hda_fixup * fix,int action)2031 static void alc889_fixup_dac_route(struct hda_codec *codec,
2032 const struct hda_fixup *fix, int action)
2033 {
2034 if (action == HDA_FIXUP_ACT_PRE_PROBE) {
2035 /* fake the connections during parsing the tree */
2036 static const hda_nid_t conn1[] = { 0x0c, 0x0d };
2037 static const hda_nid_t conn2[] = { 0x0e, 0x0f };
2038 snd_hda_override_conn_list(codec, 0x14, ARRAY_SIZE(conn1), conn1);
2039 snd_hda_override_conn_list(codec, 0x15, ARRAY_SIZE(conn1), conn1);
2040 snd_hda_override_conn_list(codec, 0x18, ARRAY_SIZE(conn2), conn2);
2041 snd_hda_override_conn_list(codec, 0x1a, ARRAY_SIZE(conn2), conn2);
2042 } else if (action == HDA_FIXUP_ACT_PROBE) {
2043 /* restore the connections */
2044 static const hda_nid_t conn[] = { 0x0c, 0x0d, 0x0e, 0x0f, 0x26 };
2045 snd_hda_override_conn_list(codec, 0x14, ARRAY_SIZE(conn), conn);
2046 snd_hda_override_conn_list(codec, 0x15, ARRAY_SIZE(conn), conn);
2047 snd_hda_override_conn_list(codec, 0x18, ARRAY_SIZE(conn), conn);
2048 snd_hda_override_conn_list(codec, 0x1a, ARRAY_SIZE(conn), conn);
2049 }
2050 }
2051
2052 /* Set VREF on HP pin */
alc889_fixup_mbp_vref(struct hda_codec * codec,const struct hda_fixup * fix,int action)2053 static void alc889_fixup_mbp_vref(struct hda_codec *codec,
2054 const struct hda_fixup *fix, int action)
2055 {
2056 static const hda_nid_t nids[] = { 0x14, 0x15, 0x19 };
2057 struct alc_spec *spec = codec->spec;
2058 int i;
2059
2060 if (action != HDA_FIXUP_ACT_INIT)
2061 return;
2062 for (i = 0; i < ARRAY_SIZE(nids); i++) {
2063 unsigned int val = snd_hda_codec_get_pincfg(codec, nids[i]);
2064 if (get_defcfg_device(val) != AC_JACK_HP_OUT)
2065 continue;
2066 val = snd_hda_codec_get_pin_target(codec, nids[i]);
2067 val |= AC_PINCTL_VREF_80;
2068 snd_hda_set_pin_ctl(codec, nids[i], val);
2069 spec->gen.keep_vref_in_automute = 1;
2070 break;
2071 }
2072 }
2073
alc889_fixup_mac_pins(struct hda_codec * codec,const hda_nid_t * nids,int num_nids)2074 static void alc889_fixup_mac_pins(struct hda_codec *codec,
2075 const hda_nid_t *nids, int num_nids)
2076 {
2077 struct alc_spec *spec = codec->spec;
2078 int i;
2079
2080 for (i = 0; i < num_nids; i++) {
2081 unsigned int val;
2082 val = snd_hda_codec_get_pin_target(codec, nids[i]);
2083 val |= AC_PINCTL_VREF_50;
2084 snd_hda_set_pin_ctl(codec, nids[i], val);
2085 }
2086 spec->gen.keep_vref_in_automute = 1;
2087 }
2088
2089 /* Set VREF on speaker pins on imac91 */
alc889_fixup_imac91_vref(struct hda_codec * codec,const struct hda_fixup * fix,int action)2090 static void alc889_fixup_imac91_vref(struct hda_codec *codec,
2091 const struct hda_fixup *fix, int action)
2092 {
2093 static const hda_nid_t nids[] = { 0x18, 0x1a };
2094
2095 if (action == HDA_FIXUP_ACT_INIT)
2096 alc889_fixup_mac_pins(codec, nids, ARRAY_SIZE(nids));
2097 }
2098
2099 /* Set VREF on speaker pins on mba11 */
alc889_fixup_mba11_vref(struct hda_codec * codec,const struct hda_fixup * fix,int action)2100 static void alc889_fixup_mba11_vref(struct hda_codec *codec,
2101 const struct hda_fixup *fix, int action)
2102 {
2103 static const hda_nid_t nids[] = { 0x18 };
2104
2105 if (action == HDA_FIXUP_ACT_INIT)
2106 alc889_fixup_mac_pins(codec, nids, ARRAY_SIZE(nids));
2107 }
2108
2109 /* Set VREF on speaker pins on mba21 */
alc889_fixup_mba21_vref(struct hda_codec * codec,const struct hda_fixup * fix,int action)2110 static void alc889_fixup_mba21_vref(struct hda_codec *codec,
2111 const struct hda_fixup *fix, int action)
2112 {
2113 static const hda_nid_t nids[] = { 0x18, 0x19 };
2114
2115 if (action == HDA_FIXUP_ACT_INIT)
2116 alc889_fixup_mac_pins(codec, nids, ARRAY_SIZE(nids));
2117 }
2118
2119 /* Don't take HP output as primary
2120 * Strangely, the speaker output doesn't work on Vaio Z and some Vaio
2121 * all-in-one desktop PCs (for example VGC-LN51JGB) through DAC 0x05
2122 */
alc882_fixup_no_primary_hp(struct hda_codec * codec,const struct hda_fixup * fix,int action)2123 static void alc882_fixup_no_primary_hp(struct hda_codec *codec,
2124 const struct hda_fixup *fix, int action)
2125 {
2126 struct alc_spec *spec = codec->spec;
2127 if (action == HDA_FIXUP_ACT_PRE_PROBE) {
2128 spec->gen.no_primary_hp = 1;
2129 spec->gen.no_multi_io = 1;
2130 }
2131 }
2132
2133 static void alc_fixup_bass_chmap(struct hda_codec *codec,
2134 const struct hda_fixup *fix, int action);
2135
2136 /* For dual-codec configuration, we need to disable some features to avoid
2137 * conflicts of kctls and PCM streams
2138 */
alc_fixup_dual_codecs(struct hda_codec * codec,const struct hda_fixup * fix,int action)2139 static void alc_fixup_dual_codecs(struct hda_codec *codec,
2140 const struct hda_fixup *fix, int action)
2141 {
2142 struct alc_spec *spec = codec->spec;
2143
2144 if (action != HDA_FIXUP_ACT_PRE_PROBE)
2145 return;
2146 /* disable vmaster */
2147 spec->gen.suppress_vmaster = 1;
2148 /* auto-mute and auto-mic switch don't work with multiple codecs */
2149 spec->gen.suppress_auto_mute = 1;
2150 spec->gen.suppress_auto_mic = 1;
2151 /* disable aamix as well */
2152 spec->gen.mixer_nid = 0;
2153 /* add location prefix to avoid conflicts */
2154 codec->force_pin_prefix = 1;
2155 }
2156
rename_ctl(struct hda_codec * codec,const char * oldname,const char * newname)2157 static void rename_ctl(struct hda_codec *codec, const char *oldname,
2158 const char *newname)
2159 {
2160 struct snd_kcontrol *kctl;
2161
2162 kctl = snd_hda_find_mixer_ctl(codec, oldname);
2163 if (kctl)
2164 snd_ctl_rename(codec->card, kctl, newname);
2165 }
2166
alc1220_fixup_gb_dual_codecs(struct hda_codec * codec,const struct hda_fixup * fix,int action)2167 static void alc1220_fixup_gb_dual_codecs(struct hda_codec *codec,
2168 const struct hda_fixup *fix,
2169 int action)
2170 {
2171 alc_fixup_dual_codecs(codec, fix, action);
2172 switch (action) {
2173 case HDA_FIXUP_ACT_PRE_PROBE:
2174 /* override card longname to provide a unique UCM profile */
2175 strcpy(codec->card->longname, "HDAudio-Gigabyte-ALC1220DualCodecs");
2176 break;
2177 case HDA_FIXUP_ACT_BUILD:
2178 /* rename Capture controls depending on the codec */
2179 rename_ctl(codec, "Capture Volume",
2180 codec->addr == 0 ?
2181 "Rear-Panel Capture Volume" :
2182 "Front-Panel Capture Volume");
2183 rename_ctl(codec, "Capture Switch",
2184 codec->addr == 0 ?
2185 "Rear-Panel Capture Switch" :
2186 "Front-Panel Capture Switch");
2187 break;
2188 }
2189 }
2190
alc1220_fixup_gb_x570(struct hda_codec * codec,const struct hda_fixup * fix,int action)2191 static void alc1220_fixup_gb_x570(struct hda_codec *codec,
2192 const struct hda_fixup *fix,
2193 int action)
2194 {
2195 static const hda_nid_t conn1[] = { 0x0c };
2196 static const struct coef_fw gb_x570_coefs[] = {
2197 WRITE_COEF(0x07, 0x03c0),
2198 WRITE_COEF(0x1a, 0x01c1),
2199 WRITE_COEF(0x1b, 0x0202),
2200 WRITE_COEF(0x43, 0x3005),
2201 {}
2202 };
2203
2204 switch (action) {
2205 case HDA_FIXUP_ACT_PRE_PROBE:
2206 snd_hda_override_conn_list(codec, 0x14, ARRAY_SIZE(conn1), conn1);
2207 snd_hda_override_conn_list(codec, 0x1b, ARRAY_SIZE(conn1), conn1);
2208 break;
2209 case HDA_FIXUP_ACT_INIT:
2210 alc_process_coef_fw(codec, gb_x570_coefs);
2211 break;
2212 }
2213 }
2214
alc1220_fixup_clevo_p950(struct hda_codec * codec,const struct hda_fixup * fix,int action)2215 static void alc1220_fixup_clevo_p950(struct hda_codec *codec,
2216 const struct hda_fixup *fix,
2217 int action)
2218 {
2219 static const hda_nid_t conn1[] = { 0x0c };
2220
2221 if (action != HDA_FIXUP_ACT_PRE_PROBE)
2222 return;
2223
2224 alc_update_coef_idx(codec, 0x7, 0, 0x3c3);
2225 /* We therefore want to make sure 0x14 (front headphone) and
2226 * 0x1b (speakers) use the stereo DAC 0x02
2227 */
2228 snd_hda_override_conn_list(codec, 0x14, ARRAY_SIZE(conn1), conn1);
2229 snd_hda_override_conn_list(codec, 0x1b, ARRAY_SIZE(conn1), conn1);
2230 }
2231
2232 static void alc_fixup_headset_mode_no_hp_mic(struct hda_codec *codec,
2233 const struct hda_fixup *fix, int action);
2234
alc1220_fixup_clevo_pb51ed(struct hda_codec * codec,const struct hda_fixup * fix,int action)2235 static void alc1220_fixup_clevo_pb51ed(struct hda_codec *codec,
2236 const struct hda_fixup *fix,
2237 int action)
2238 {
2239 alc1220_fixup_clevo_p950(codec, fix, action);
2240 alc_fixup_headset_mode_no_hp_mic(codec, fix, action);
2241 }
2242
alc887_asus_hp_automute_hook(struct hda_codec * codec,struct hda_jack_callback * jack)2243 static void alc887_asus_hp_automute_hook(struct hda_codec *codec,
2244 struct hda_jack_callback *jack)
2245 {
2246 struct alc_spec *spec = codec->spec;
2247 unsigned int vref;
2248
2249 snd_hda_gen_hp_automute(codec, jack);
2250
2251 if (spec->gen.hp_jack_present)
2252 vref = AC_PINCTL_VREF_80;
2253 else
2254 vref = AC_PINCTL_VREF_HIZ;
2255 snd_hda_set_pin_ctl(codec, 0x19, PIN_HP | vref);
2256 }
2257
alc887_fixup_asus_jack(struct hda_codec * codec,const struct hda_fixup * fix,int action)2258 static void alc887_fixup_asus_jack(struct hda_codec *codec,
2259 const struct hda_fixup *fix, int action)
2260 {
2261 struct alc_spec *spec = codec->spec;
2262 if (action != HDA_FIXUP_ACT_PROBE)
2263 return;
2264 snd_hda_set_pin_ctl_cache(codec, 0x1b, PIN_HP);
2265 spec->gen.hp_automute_hook = alc887_asus_hp_automute_hook;
2266 }
2267
2268 static const struct hda_fixup alc882_fixups[] = {
2269 [ALC882_FIXUP_ABIT_AW9D_MAX] = {
2270 .type = HDA_FIXUP_PINS,
2271 .v.pins = (const struct hda_pintbl[]) {
2272 { 0x15, 0x01080104 }, /* side */
2273 { 0x16, 0x01011012 }, /* rear */
2274 { 0x17, 0x01016011 }, /* clfe */
2275 { }
2276 }
2277 },
2278 [ALC882_FIXUP_LENOVO_Y530] = {
2279 .type = HDA_FIXUP_PINS,
2280 .v.pins = (const struct hda_pintbl[]) {
2281 { 0x15, 0x99130112 }, /* rear int speakers */
2282 { 0x16, 0x99130111 }, /* subwoofer */
2283 { }
2284 }
2285 },
2286 [ALC882_FIXUP_PB_M5210] = {
2287 .type = HDA_FIXUP_PINCTLS,
2288 .v.pins = (const struct hda_pintbl[]) {
2289 { 0x19, PIN_VREF50 },
2290 {}
2291 }
2292 },
2293 [ALC882_FIXUP_ACER_ASPIRE_7736] = {
2294 .type = HDA_FIXUP_FUNC,
2295 .v.func = alc_fixup_sku_ignore,
2296 },
2297 [ALC882_FIXUP_ASUS_W90V] = {
2298 .type = HDA_FIXUP_PINS,
2299 .v.pins = (const struct hda_pintbl[]) {
2300 { 0x16, 0x99130110 }, /* fix sequence for CLFE */
2301 { }
2302 }
2303 },
2304 [ALC889_FIXUP_CD] = {
2305 .type = HDA_FIXUP_PINS,
2306 .v.pins = (const struct hda_pintbl[]) {
2307 { 0x1c, 0x993301f0 }, /* CD */
2308 { }
2309 }
2310 },
2311 [ALC889_FIXUP_FRONT_HP_NO_PRESENCE] = {
2312 .type = HDA_FIXUP_PINS,
2313 .v.pins = (const struct hda_pintbl[]) {
2314 { 0x1b, 0x02214120 }, /* Front HP jack is flaky, disable jack detect */
2315 { }
2316 },
2317 .chained = true,
2318 .chain_id = ALC889_FIXUP_CD,
2319 },
2320 [ALC889_FIXUP_VAIO_TT] = {
2321 .type = HDA_FIXUP_PINS,
2322 .v.pins = (const struct hda_pintbl[]) {
2323 { 0x17, 0x90170111 }, /* hidden surround speaker */
2324 { }
2325 }
2326 },
2327 [ALC888_FIXUP_EEE1601] = {
2328 .type = HDA_FIXUP_VERBS,
2329 .v.verbs = (const struct hda_verb[]) {
2330 { 0x20, AC_VERB_SET_COEF_INDEX, 0x0b },
2331 { 0x20, AC_VERB_SET_PROC_COEF, 0x0838 },
2332 { }
2333 }
2334 },
2335 [ALC886_FIXUP_EAPD] = {
2336 .type = HDA_FIXUP_VERBS,
2337 .v.verbs = (const struct hda_verb[]) {
2338 /* change to EAPD mode */
2339 { 0x20, AC_VERB_SET_COEF_INDEX, 0x07 },
2340 { 0x20, AC_VERB_SET_PROC_COEF, 0x0068 },
2341 { }
2342 }
2343 },
2344 [ALC882_FIXUP_EAPD] = {
2345 .type = HDA_FIXUP_VERBS,
2346 .v.verbs = (const struct hda_verb[]) {
2347 /* change to EAPD mode */
2348 { 0x20, AC_VERB_SET_COEF_INDEX, 0x07 },
2349 { 0x20, AC_VERB_SET_PROC_COEF, 0x3060 },
2350 { }
2351 }
2352 },
2353 [ALC883_FIXUP_EAPD] = {
2354 .type = HDA_FIXUP_VERBS,
2355 .v.verbs = (const struct hda_verb[]) {
2356 /* change to EAPD mode */
2357 { 0x20, AC_VERB_SET_COEF_INDEX, 0x07 },
2358 { 0x20, AC_VERB_SET_PROC_COEF, 0x3070 },
2359 { }
2360 }
2361 },
2362 [ALC883_FIXUP_ACER_EAPD] = {
2363 .type = HDA_FIXUP_VERBS,
2364 .v.verbs = (const struct hda_verb[]) {
2365 /* eanable EAPD on Acer laptops */
2366 { 0x20, AC_VERB_SET_COEF_INDEX, 0x07 },
2367 { 0x20, AC_VERB_SET_PROC_COEF, 0x3050 },
2368 { }
2369 }
2370 },
2371 [ALC882_FIXUP_GPIO1] = {
2372 .type = HDA_FIXUP_FUNC,
2373 .v.func = alc_fixup_gpio1,
2374 },
2375 [ALC882_FIXUP_GPIO2] = {
2376 .type = HDA_FIXUP_FUNC,
2377 .v.func = alc_fixup_gpio2,
2378 },
2379 [ALC882_FIXUP_GPIO3] = {
2380 .type = HDA_FIXUP_FUNC,
2381 .v.func = alc_fixup_gpio3,
2382 },
2383 [ALC882_FIXUP_ASUS_W2JC] = {
2384 .type = HDA_FIXUP_FUNC,
2385 .v.func = alc_fixup_gpio1,
2386 .chained = true,
2387 .chain_id = ALC882_FIXUP_EAPD,
2388 },
2389 [ALC889_FIXUP_COEF] = {
2390 .type = HDA_FIXUP_FUNC,
2391 .v.func = alc889_fixup_coef,
2392 },
2393 [ALC882_FIXUP_ACER_ASPIRE_4930G] = {
2394 .type = HDA_FIXUP_PINS,
2395 .v.pins = (const struct hda_pintbl[]) {
2396 { 0x16, 0x99130111 }, /* CLFE speaker */
2397 { 0x17, 0x99130112 }, /* surround speaker */
2398 { }
2399 },
2400 .chained = true,
2401 .chain_id = ALC882_FIXUP_GPIO1,
2402 },
2403 [ALC882_FIXUP_ACER_ASPIRE_8930G] = {
2404 .type = HDA_FIXUP_PINS,
2405 .v.pins = (const struct hda_pintbl[]) {
2406 { 0x16, 0x99130111 }, /* CLFE speaker */
2407 { 0x1b, 0x99130112 }, /* surround speaker */
2408 { }
2409 },
2410 .chained = true,
2411 .chain_id = ALC882_FIXUP_ASPIRE_8930G_VERBS,
2412 },
2413 [ALC882_FIXUP_ASPIRE_8930G_VERBS] = {
2414 /* additional init verbs for Acer Aspire 8930G */
2415 .type = HDA_FIXUP_VERBS,
2416 .v.verbs = (const struct hda_verb[]) {
2417 /* Enable all DACs */
2418 /* DAC DISABLE/MUTE 1? */
2419 /* setting bits 1-5 disables DAC nids 0x02-0x06
2420 * apparently. Init=0x38 */
2421 { 0x20, AC_VERB_SET_COEF_INDEX, 0x03 },
2422 { 0x20, AC_VERB_SET_PROC_COEF, 0x0000 },
2423 /* DAC DISABLE/MUTE 2? */
2424 /* some bit here disables the other DACs.
2425 * Init=0x4900 */
2426 { 0x20, AC_VERB_SET_COEF_INDEX, 0x08 },
2427 { 0x20, AC_VERB_SET_PROC_COEF, 0x0000 },
2428 /* DMIC fix
2429 * This laptop has a stereo digital microphone.
2430 * The mics are only 1cm apart which makes the stereo
2431 * useless. However, either the mic or the ALC889
2432 * makes the signal become a difference/sum signal
2433 * instead of standard stereo, which is annoying.
2434 * So instead we flip this bit which makes the
2435 * codec replicate the sum signal to both channels,
2436 * turning it into a normal mono mic.
2437 */
2438 /* DMIC_CONTROL? Init value = 0x0001 */
2439 { 0x20, AC_VERB_SET_COEF_INDEX, 0x0b },
2440 { 0x20, AC_VERB_SET_PROC_COEF, 0x0003 },
2441 { 0x20, AC_VERB_SET_COEF_INDEX, 0x07 },
2442 { 0x20, AC_VERB_SET_PROC_COEF, 0x3050 },
2443 { }
2444 },
2445 .chained = true,
2446 .chain_id = ALC882_FIXUP_GPIO1,
2447 },
2448 [ALC885_FIXUP_MACPRO_GPIO] = {
2449 .type = HDA_FIXUP_FUNC,
2450 .v.func = alc885_fixup_macpro_gpio,
2451 },
2452 [ALC889_FIXUP_DAC_ROUTE] = {
2453 .type = HDA_FIXUP_FUNC,
2454 .v.func = alc889_fixup_dac_route,
2455 },
2456 [ALC889_FIXUP_MBP_VREF] = {
2457 .type = HDA_FIXUP_FUNC,
2458 .v.func = alc889_fixup_mbp_vref,
2459 .chained = true,
2460 .chain_id = ALC882_FIXUP_GPIO1,
2461 },
2462 [ALC889_FIXUP_IMAC91_VREF] = {
2463 .type = HDA_FIXUP_FUNC,
2464 .v.func = alc889_fixup_imac91_vref,
2465 .chained = true,
2466 .chain_id = ALC882_FIXUP_GPIO1,
2467 },
2468 [ALC889_FIXUP_MBA11_VREF] = {
2469 .type = HDA_FIXUP_FUNC,
2470 .v.func = alc889_fixup_mba11_vref,
2471 .chained = true,
2472 .chain_id = ALC889_FIXUP_MBP_VREF,
2473 },
2474 [ALC889_FIXUP_MBA21_VREF] = {
2475 .type = HDA_FIXUP_FUNC,
2476 .v.func = alc889_fixup_mba21_vref,
2477 .chained = true,
2478 .chain_id = ALC889_FIXUP_MBP_VREF,
2479 },
2480 [ALC889_FIXUP_MP11_VREF] = {
2481 .type = HDA_FIXUP_FUNC,
2482 .v.func = alc889_fixup_mba11_vref,
2483 .chained = true,
2484 .chain_id = ALC885_FIXUP_MACPRO_GPIO,
2485 },
2486 [ALC889_FIXUP_MP41_VREF] = {
2487 .type = HDA_FIXUP_FUNC,
2488 .v.func = alc889_fixup_mbp_vref,
2489 .chained = true,
2490 .chain_id = ALC885_FIXUP_MACPRO_GPIO,
2491 },
2492 [ALC882_FIXUP_INV_DMIC] = {
2493 .type = HDA_FIXUP_FUNC,
2494 .v.func = alc_fixup_inv_dmic,
2495 },
2496 [ALC882_FIXUP_NO_PRIMARY_HP] = {
2497 .type = HDA_FIXUP_FUNC,
2498 .v.func = alc882_fixup_no_primary_hp,
2499 },
2500 [ALC887_FIXUP_ASUS_BASS] = {
2501 .type = HDA_FIXUP_PINS,
2502 .v.pins = (const struct hda_pintbl[]) {
2503 {0x16, 0x99130130}, /* bass speaker */
2504 {}
2505 },
2506 .chained = true,
2507 .chain_id = ALC887_FIXUP_BASS_CHMAP,
2508 },
2509 [ALC887_FIXUP_BASS_CHMAP] = {
2510 .type = HDA_FIXUP_FUNC,
2511 .v.func = alc_fixup_bass_chmap,
2512 },
2513 [ALC1220_FIXUP_GB_DUAL_CODECS] = {
2514 .type = HDA_FIXUP_FUNC,
2515 .v.func = alc1220_fixup_gb_dual_codecs,
2516 },
2517 [ALC1220_FIXUP_GB_X570] = {
2518 .type = HDA_FIXUP_FUNC,
2519 .v.func = alc1220_fixup_gb_x570,
2520 },
2521 [ALC1220_FIXUP_CLEVO_P950] = {
2522 .type = HDA_FIXUP_FUNC,
2523 .v.func = alc1220_fixup_clevo_p950,
2524 },
2525 [ALC1220_FIXUP_CLEVO_PB51ED] = {
2526 .type = HDA_FIXUP_FUNC,
2527 .v.func = alc1220_fixup_clevo_pb51ed,
2528 },
2529 [ALC1220_FIXUP_CLEVO_PB51ED_PINS] = {
2530 .type = HDA_FIXUP_PINS,
2531 .v.pins = (const struct hda_pintbl[]) {
2532 { 0x19, 0x01a1913c }, /* use as headset mic, without its own jack detect */
2533 {}
2534 },
2535 .chained = true,
2536 .chain_id = ALC1220_FIXUP_CLEVO_PB51ED,
2537 },
2538 [ALC887_FIXUP_ASUS_AUDIO] = {
2539 .type = HDA_FIXUP_PINS,
2540 .v.pins = (const struct hda_pintbl[]) {
2541 { 0x15, 0x02a14150 }, /* use as headset mic, without its own jack detect */
2542 { 0x19, 0x22219420 },
2543 {}
2544 },
2545 },
2546 [ALC887_FIXUP_ASUS_HMIC] = {
2547 .type = HDA_FIXUP_FUNC,
2548 .v.func = alc887_fixup_asus_jack,
2549 .chained = true,
2550 .chain_id = ALC887_FIXUP_ASUS_AUDIO,
2551 },
2552 [ALCS1200A_FIXUP_MIC_VREF] = {
2553 .type = HDA_FIXUP_PINCTLS,
2554 .v.pins = (const struct hda_pintbl[]) {
2555 { 0x18, PIN_VREF50 }, /* rear mic */
2556 { 0x19, PIN_VREF50 }, /* front mic */
2557 {}
2558 }
2559 },
2560 [ALC888VD_FIXUP_MIC_100VREF] = {
2561 .type = HDA_FIXUP_PINCTLS,
2562 .v.pins = (const struct hda_pintbl[]) {
2563 { 0x18, PIN_VREF100 }, /* headset mic */
2564 {}
2565 }
2566 },
2567 };
2568
2569 static const struct snd_pci_quirk alc882_fixup_tbl[] = {
2570 SND_PCI_QUIRK(0x1025, 0x006c, "Acer Aspire 9810", ALC883_FIXUP_ACER_EAPD),
2571 SND_PCI_QUIRK(0x1025, 0x0090, "Acer Aspire", ALC883_FIXUP_ACER_EAPD),
2572 SND_PCI_QUIRK(0x1025, 0x0107, "Acer Aspire", ALC883_FIXUP_ACER_EAPD),
2573 SND_PCI_QUIRK(0x1025, 0x010a, "Acer Ferrari 5000", ALC883_FIXUP_ACER_EAPD),
2574 SND_PCI_QUIRK(0x1025, 0x0110, "Acer Aspire", ALC883_FIXUP_ACER_EAPD),
2575 SND_PCI_QUIRK(0x1025, 0x0112, "Acer Aspire 9303", ALC883_FIXUP_ACER_EAPD),
2576 SND_PCI_QUIRK(0x1025, 0x0121, "Acer Aspire 5920G", ALC883_FIXUP_ACER_EAPD),
2577 SND_PCI_QUIRK(0x1025, 0x013e, "Acer Aspire 4930G",
2578 ALC882_FIXUP_ACER_ASPIRE_4930G),
2579 SND_PCI_QUIRK(0x1025, 0x013f, "Acer Aspire 5930G",
2580 ALC882_FIXUP_ACER_ASPIRE_4930G),
2581 SND_PCI_QUIRK(0x1025, 0x0145, "Acer Aspire 8930G",
2582 ALC882_FIXUP_ACER_ASPIRE_8930G),
2583 SND_PCI_QUIRK(0x1025, 0x0146, "Acer Aspire 6935G",
2584 ALC882_FIXUP_ACER_ASPIRE_8930G),
2585 SND_PCI_QUIRK(0x1025, 0x0142, "Acer Aspire 7730G",
2586 ALC882_FIXUP_ACER_ASPIRE_4930G),
2587 SND_PCI_QUIRK(0x1025, 0x0155, "Packard-Bell M5120", ALC882_FIXUP_PB_M5210),
2588 SND_PCI_QUIRK(0x1025, 0x015e, "Acer Aspire 6930G",
2589 ALC882_FIXUP_ACER_ASPIRE_4930G),
2590 SND_PCI_QUIRK(0x1025, 0x0166, "Acer Aspire 6530G",
2591 ALC882_FIXUP_ACER_ASPIRE_4930G),
2592 SND_PCI_QUIRK(0x1025, 0x021e, "Acer Aspire 5739G",
2593 ALC882_FIXUP_ACER_ASPIRE_4930G),
2594 SND_PCI_QUIRK(0x1025, 0x0259, "Acer Aspire 5935", ALC889_FIXUP_DAC_ROUTE),
2595 SND_PCI_QUIRK(0x1025, 0x026b, "Acer Aspire 8940G", ALC882_FIXUP_ACER_ASPIRE_8930G),
2596 SND_PCI_QUIRK(0x1025, 0x0296, "Acer Aspire 7736z", ALC882_FIXUP_ACER_ASPIRE_7736),
2597 SND_PCI_QUIRK(0x1043, 0x13c2, "Asus A7M", ALC882_FIXUP_EAPD),
2598 SND_PCI_QUIRK(0x1043, 0x1873, "ASUS W90V", ALC882_FIXUP_ASUS_W90V),
2599 SND_PCI_QUIRK(0x1043, 0x1971, "Asus W2JC", ALC882_FIXUP_ASUS_W2JC),
2600 SND_PCI_QUIRK(0x1043, 0x2390, "Asus D700SA", ALC887_FIXUP_ASUS_HMIC),
2601 SND_PCI_QUIRK(0x1043, 0x835f, "Asus Eee 1601", ALC888_FIXUP_EEE1601),
2602 SND_PCI_QUIRK(0x1043, 0x84bc, "ASUS ET2700", ALC887_FIXUP_ASUS_BASS),
2603 SND_PCI_QUIRK(0x1043, 0x8691, "ASUS ROG Ranger VIII", ALC882_FIXUP_GPIO3),
2604 SND_PCI_QUIRK(0x1043, 0x8797, "ASUS TUF B550M-PLUS", ALCS1200A_FIXUP_MIC_VREF),
2605 SND_PCI_QUIRK(0x104d, 0x9043, "Sony Vaio VGC-LN51JGB", ALC882_FIXUP_NO_PRIMARY_HP),
2606 SND_PCI_QUIRK(0x104d, 0x9044, "Sony VAIO AiO", ALC882_FIXUP_NO_PRIMARY_HP),
2607 SND_PCI_QUIRK(0x104d, 0x9047, "Sony Vaio TT", ALC889_FIXUP_VAIO_TT),
2608 SND_PCI_QUIRK(0x104d, 0x905a, "Sony Vaio Z", ALC882_FIXUP_NO_PRIMARY_HP),
2609 SND_PCI_QUIRK(0x104d, 0x9060, "Sony Vaio VPCL14M1R", ALC882_FIXUP_NO_PRIMARY_HP),
2610
2611 /* All Apple entries are in codec SSIDs */
2612 SND_PCI_QUIRK(0x106b, 0x00a0, "MacBookPro 3,1", ALC889_FIXUP_MBP_VREF),
2613 SND_PCI_QUIRK(0x106b, 0x00a1, "Macbook", ALC889_FIXUP_MBP_VREF),
2614 SND_PCI_QUIRK(0x106b, 0x00a4, "MacbookPro 4,1", ALC889_FIXUP_MBP_VREF),
2615 SND_PCI_QUIRK(0x106b, 0x0c00, "Mac Pro", ALC889_FIXUP_MP11_VREF),
2616 SND_PCI_QUIRK(0x106b, 0x1000, "iMac 24", ALC885_FIXUP_MACPRO_GPIO),
2617 SND_PCI_QUIRK(0x106b, 0x2800, "AppleTV", ALC885_FIXUP_MACPRO_GPIO),
2618 SND_PCI_QUIRK(0x106b, 0x2c00, "MacbookPro rev3", ALC889_FIXUP_MBP_VREF),
2619 SND_PCI_QUIRK(0x106b, 0x3000, "iMac", ALC889_FIXUP_MBP_VREF),
2620 SND_PCI_QUIRK(0x106b, 0x3200, "iMac 7,1 Aluminum", ALC882_FIXUP_EAPD),
2621 SND_PCI_QUIRK(0x106b, 0x3400, "MacBookAir 1,1", ALC889_FIXUP_MBA11_VREF),
2622 SND_PCI_QUIRK(0x106b, 0x3500, "MacBookAir 2,1", ALC889_FIXUP_MBA21_VREF),
2623 SND_PCI_QUIRK(0x106b, 0x3600, "Macbook 3,1", ALC889_FIXUP_MBP_VREF),
2624 SND_PCI_QUIRK(0x106b, 0x3800, "MacbookPro 4,1", ALC889_FIXUP_MBP_VREF),
2625 SND_PCI_QUIRK(0x106b, 0x3e00, "iMac 24 Aluminum", ALC885_FIXUP_MACPRO_GPIO),
2626 SND_PCI_QUIRK(0x106b, 0x3f00, "Macbook 5,1", ALC889_FIXUP_IMAC91_VREF),
2627 SND_PCI_QUIRK(0x106b, 0x4000, "MacbookPro 5,1", ALC889_FIXUP_IMAC91_VREF),
2628 SND_PCI_QUIRK(0x106b, 0x4100, "Macmini 3,1", ALC889_FIXUP_IMAC91_VREF),
2629 SND_PCI_QUIRK(0x106b, 0x4200, "Mac Pro 4,1/5,1", ALC889_FIXUP_MP41_VREF),
2630 SND_PCI_QUIRK(0x106b, 0x4300, "iMac 9,1", ALC889_FIXUP_IMAC91_VREF),
2631 SND_PCI_QUIRK(0x106b, 0x4600, "MacbookPro 5,2", ALC889_FIXUP_IMAC91_VREF),
2632 SND_PCI_QUIRK(0x106b, 0x4900, "iMac 9,1 Aluminum", ALC889_FIXUP_IMAC91_VREF),
2633 SND_PCI_QUIRK(0x106b, 0x4a00, "Macbook 5,2", ALC889_FIXUP_MBA11_VREF),
2634
2635 SND_PCI_QUIRK(0x1071, 0x8258, "Evesham Voyaeger", ALC882_FIXUP_EAPD),
2636 SND_PCI_QUIRK(0x10ec, 0x12d8, "iBase Elo Touch", ALC888VD_FIXUP_MIC_100VREF),
2637 SND_PCI_QUIRK(0x13fe, 0x1009, "Advantech MIT-W101", ALC886_FIXUP_EAPD),
2638 SND_PCI_QUIRK(0x1458, 0xa002, "Gigabyte EP45-DS3/Z87X-UD3H", ALC889_FIXUP_FRONT_HP_NO_PRESENCE),
2639 SND_PCI_QUIRK(0x1458, 0xa0b8, "Gigabyte AZ370-Gaming", ALC1220_FIXUP_GB_DUAL_CODECS),
2640 SND_PCI_QUIRK(0x1458, 0xa0cd, "Gigabyte X570 Aorus Master", ALC1220_FIXUP_GB_X570),
2641 SND_PCI_QUIRK(0x1458, 0xa0ce, "Gigabyte X570 Aorus Xtreme", ALC1220_FIXUP_GB_X570),
2642 SND_PCI_QUIRK(0x1458, 0xa0d5, "Gigabyte X570S Aorus Master", ALC1220_FIXUP_GB_X570),
2643 SND_PCI_QUIRK(0x1462, 0x11f7, "MSI-GE63", ALC1220_FIXUP_CLEVO_P950),
2644 SND_PCI_QUIRK(0x1462, 0x1228, "MSI-GP63", ALC1220_FIXUP_CLEVO_P950),
2645 SND_PCI_QUIRK(0x1462, 0x1229, "MSI-GP73", ALC1220_FIXUP_CLEVO_P950),
2646 SND_PCI_QUIRK(0x1462, 0x1275, "MSI-GL63", ALC1220_FIXUP_CLEVO_P950),
2647 SND_PCI_QUIRK(0x1462, 0x1276, "MSI-GL73", ALC1220_FIXUP_CLEVO_P950),
2648 SND_PCI_QUIRK(0x1462, 0x1293, "MSI-GP65", ALC1220_FIXUP_CLEVO_P950),
2649 SND_PCI_QUIRK(0x1462, 0x7350, "MSI-7350", ALC889_FIXUP_CD),
2650 SND_PCI_QUIRK(0x1462, 0xcc34, "MSI Godlike X570", ALC1220_FIXUP_GB_DUAL_CODECS),
2651 SND_PCI_QUIRK(0x1462, 0xda57, "MSI Z270-Gaming", ALC1220_FIXUP_GB_DUAL_CODECS),
2652 SND_PCI_QUIRK_VENDOR(0x1462, "MSI", ALC882_FIXUP_GPIO3),
2653 SND_PCI_QUIRK(0x147b, 0x107a, "Abit AW9D-MAX", ALC882_FIXUP_ABIT_AW9D_MAX),
2654 SND_PCI_QUIRK(0x1558, 0x3702, "Clevo X370SN[VW]", ALC1220_FIXUP_CLEVO_PB51ED_PINS),
2655 SND_PCI_QUIRK(0x1558, 0x50d3, "Clevo PC50[ER][CDF]", ALC1220_FIXUP_CLEVO_PB51ED_PINS),
2656 SND_PCI_QUIRK(0x1558, 0x65d1, "Clevo PB51[ER][CDF]", ALC1220_FIXUP_CLEVO_PB51ED_PINS),
2657 SND_PCI_QUIRK(0x1558, 0x65d2, "Clevo PB51R[CDF]", ALC1220_FIXUP_CLEVO_PB51ED_PINS),
2658 SND_PCI_QUIRK(0x1558, 0x65e1, "Clevo PB51[ED][DF]", ALC1220_FIXUP_CLEVO_PB51ED_PINS),
2659 SND_PCI_QUIRK(0x1558, 0x65e5, "Clevo PC50D[PRS](?:-D|-G)?", ALC1220_FIXUP_CLEVO_PB51ED_PINS),
2660 SND_PCI_QUIRK(0x1558, 0x65f1, "Clevo PC50HS", ALC1220_FIXUP_CLEVO_PB51ED_PINS),
2661 SND_PCI_QUIRK(0x1558, 0x65f5, "Clevo PD50PN[NRT]", ALC1220_FIXUP_CLEVO_PB51ED_PINS),
2662 SND_PCI_QUIRK(0x1558, 0x66a2, "Clevo PE60RNE", ALC1220_FIXUP_CLEVO_PB51ED_PINS),
2663 SND_PCI_QUIRK(0x1558, 0x66a6, "Clevo PE60SN[CDE]-[GS]", ALC1220_FIXUP_CLEVO_PB51ED_PINS),
2664 SND_PCI_QUIRK(0x1558, 0x67d1, "Clevo PB71[ER][CDF]", ALC1220_FIXUP_CLEVO_PB51ED_PINS),
2665 SND_PCI_QUIRK(0x1558, 0x67e1, "Clevo PB71[DE][CDF]", ALC1220_FIXUP_CLEVO_PB51ED_PINS),
2666 SND_PCI_QUIRK(0x1558, 0x67e5, "Clevo PC70D[PRS](?:-D|-G)?", ALC1220_FIXUP_CLEVO_PB51ED_PINS),
2667 SND_PCI_QUIRK(0x1558, 0x67f1, "Clevo PC70H[PRS]", ALC1220_FIXUP_CLEVO_PB51ED_PINS),
2668 SND_PCI_QUIRK(0x1558, 0x67f5, "Clevo PD70PN[NRT]", ALC1220_FIXUP_CLEVO_PB51ED_PINS),
2669 SND_PCI_QUIRK(0x1558, 0x70d1, "Clevo PC70[ER][CDF]", ALC1220_FIXUP_CLEVO_PB51ED_PINS),
2670 SND_PCI_QUIRK(0x1558, 0x7714, "Clevo X170SM", ALC1220_FIXUP_CLEVO_PB51ED_PINS),
2671 SND_PCI_QUIRK(0x1558, 0x7715, "Clevo X170KM-G", ALC1220_FIXUP_CLEVO_PB51ED),
2672 SND_PCI_QUIRK(0x1558, 0x9501, "Clevo P950HR", ALC1220_FIXUP_CLEVO_P950),
2673 SND_PCI_QUIRK(0x1558, 0x9506, "Clevo P955HQ", ALC1220_FIXUP_CLEVO_P950),
2674 SND_PCI_QUIRK(0x1558, 0x950a, "Clevo P955H[PR]", ALC1220_FIXUP_CLEVO_P950),
2675 SND_PCI_QUIRK(0x1558, 0x95e1, "Clevo P95xER", ALC1220_FIXUP_CLEVO_P950),
2676 SND_PCI_QUIRK(0x1558, 0x95e2, "Clevo P950ER", ALC1220_FIXUP_CLEVO_P950),
2677 SND_PCI_QUIRK(0x1558, 0x95e3, "Clevo P955[ER]T", ALC1220_FIXUP_CLEVO_P950),
2678 SND_PCI_QUIRK(0x1558, 0x95e4, "Clevo P955ER", ALC1220_FIXUP_CLEVO_P950),
2679 SND_PCI_QUIRK(0x1558, 0x95e5, "Clevo P955EE6", ALC1220_FIXUP_CLEVO_P950),
2680 SND_PCI_QUIRK(0x1558, 0x95e6, "Clevo P950R[CDF]", ALC1220_FIXUP_CLEVO_P950),
2681 SND_PCI_QUIRK(0x1558, 0x96e1, "Clevo P960[ER][CDFN]-K", ALC1220_FIXUP_CLEVO_P950),
2682 SND_PCI_QUIRK(0x1558, 0x97e1, "Clevo P970[ER][CDFN]", ALC1220_FIXUP_CLEVO_P950),
2683 SND_PCI_QUIRK(0x1558, 0x97e2, "Clevo P970RC-M", ALC1220_FIXUP_CLEVO_P950),
2684 SND_PCI_QUIRK(0x1558, 0xd502, "Clevo PD50SNE", ALC1220_FIXUP_CLEVO_PB51ED_PINS),
2685 SND_PCI_QUIRK_VENDOR(0x1558, "Clevo laptop", ALC882_FIXUP_EAPD),
2686 SND_PCI_QUIRK(0x161f, 0x2054, "Medion laptop", ALC883_FIXUP_EAPD),
2687 SND_PCI_QUIRK(0x17aa, 0x3a0d, "Lenovo Y530", ALC882_FIXUP_LENOVO_Y530),
2688 SND_PCI_QUIRK(0x8086, 0x0022, "DX58SO", ALC889_FIXUP_COEF),
2689 {}
2690 };
2691
2692 static const struct hda_model_fixup alc882_fixup_models[] = {
2693 {.id = ALC882_FIXUP_ABIT_AW9D_MAX, .name = "abit-aw9d"},
2694 {.id = ALC882_FIXUP_LENOVO_Y530, .name = "lenovo-y530"},
2695 {.id = ALC882_FIXUP_ACER_ASPIRE_7736, .name = "acer-aspire-7736"},
2696 {.id = ALC882_FIXUP_ASUS_W90V, .name = "asus-w90v"},
2697 {.id = ALC889_FIXUP_CD, .name = "cd"},
2698 {.id = ALC889_FIXUP_FRONT_HP_NO_PRESENCE, .name = "no-front-hp"},
2699 {.id = ALC889_FIXUP_VAIO_TT, .name = "vaio-tt"},
2700 {.id = ALC888_FIXUP_EEE1601, .name = "eee1601"},
2701 {.id = ALC882_FIXUP_EAPD, .name = "alc882-eapd"},
2702 {.id = ALC883_FIXUP_EAPD, .name = "alc883-eapd"},
2703 {.id = ALC882_FIXUP_GPIO1, .name = "gpio1"},
2704 {.id = ALC882_FIXUP_GPIO2, .name = "gpio2"},
2705 {.id = ALC882_FIXUP_GPIO3, .name = "gpio3"},
2706 {.id = ALC889_FIXUP_COEF, .name = "alc889-coef"},
2707 {.id = ALC882_FIXUP_ASUS_W2JC, .name = "asus-w2jc"},
2708 {.id = ALC882_FIXUP_ACER_ASPIRE_4930G, .name = "acer-aspire-4930g"},
2709 {.id = ALC882_FIXUP_ACER_ASPIRE_8930G, .name = "acer-aspire-8930g"},
2710 {.id = ALC883_FIXUP_ACER_EAPD, .name = "acer-aspire"},
2711 {.id = ALC885_FIXUP_MACPRO_GPIO, .name = "macpro-gpio"},
2712 {.id = ALC889_FIXUP_DAC_ROUTE, .name = "dac-route"},
2713 {.id = ALC889_FIXUP_MBP_VREF, .name = "mbp-vref"},
2714 {.id = ALC889_FIXUP_IMAC91_VREF, .name = "imac91-vref"},
2715 {.id = ALC889_FIXUP_MBA11_VREF, .name = "mba11-vref"},
2716 {.id = ALC889_FIXUP_MBA21_VREF, .name = "mba21-vref"},
2717 {.id = ALC889_FIXUP_MP11_VREF, .name = "mp11-vref"},
2718 {.id = ALC889_FIXUP_MP41_VREF, .name = "mp41-vref"},
2719 {.id = ALC882_FIXUP_INV_DMIC, .name = "inv-dmic"},
2720 {.id = ALC882_FIXUP_NO_PRIMARY_HP, .name = "no-primary-hp"},
2721 {.id = ALC887_FIXUP_ASUS_BASS, .name = "asus-bass"},
2722 {.id = ALC1220_FIXUP_GB_DUAL_CODECS, .name = "dual-codecs"},
2723 {.id = ALC1220_FIXUP_GB_X570, .name = "gb-x570"},
2724 {.id = ALC1220_FIXUP_CLEVO_P950, .name = "clevo-p950"},
2725 {}
2726 };
2727
2728 static const struct snd_hda_pin_quirk alc882_pin_fixup_tbl[] = {
2729 SND_HDA_PIN_QUIRK(0x10ec1220, 0x1043, "ASUS", ALC1220_FIXUP_CLEVO_P950,
2730 {0x14, 0x01014010},
2731 {0x15, 0x01011012},
2732 {0x16, 0x01016011},
2733 {0x18, 0x01a19040},
2734 {0x19, 0x02a19050},
2735 {0x1a, 0x0181304f},
2736 {0x1b, 0x0221401f},
2737 {0x1e, 0x01456130}),
2738 SND_HDA_PIN_QUIRK(0x10ec1220, 0x1462, "MS-7C35", ALC1220_FIXUP_CLEVO_P950,
2739 {0x14, 0x01015010},
2740 {0x15, 0x01011012},
2741 {0x16, 0x01011011},
2742 {0x18, 0x01a11040},
2743 {0x19, 0x02a19050},
2744 {0x1a, 0x0181104f},
2745 {0x1b, 0x0221401f},
2746 {0x1e, 0x01451130}),
2747 {}
2748 };
2749
2750 /*
2751 * BIOS auto configuration
2752 */
2753 /* almost identical with ALC880 parser... */
alc882_parse_auto_config(struct hda_codec * codec)2754 static int alc882_parse_auto_config(struct hda_codec *codec)
2755 {
2756 static const hda_nid_t alc882_ignore[] = { 0x1d, 0 };
2757 static const hda_nid_t alc882_ssids[] = { 0x15, 0x1b, 0x14, 0 };
2758 return alc_parse_auto_config(codec, alc882_ignore, alc882_ssids);
2759 }
2760
2761 /*
2762 */
patch_alc882(struct hda_codec * codec)2763 static int patch_alc882(struct hda_codec *codec)
2764 {
2765 struct alc_spec *spec;
2766 int err;
2767
2768 err = alc_alloc_spec(codec, 0x0b);
2769 if (err < 0)
2770 return err;
2771
2772 spec = codec->spec;
2773
2774 switch (codec->core.vendor_id) {
2775 case 0x10ec0882:
2776 case 0x10ec0885:
2777 case 0x10ec0900:
2778 case 0x10ec0b00:
2779 case 0x10ec1220:
2780 break;
2781 default:
2782 /* ALC883 and variants */
2783 alc_fix_pll_init(codec, 0x20, 0x0a, 10);
2784 break;
2785 }
2786
2787 alc_pre_init(codec);
2788
2789 snd_hda_pick_fixup(codec, alc882_fixup_models, alc882_fixup_tbl,
2790 alc882_fixups);
2791 snd_hda_pick_pin_fixup(codec, alc882_pin_fixup_tbl, alc882_fixups, true);
2792 snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE);
2793
2794 alc_auto_parse_customize_define(codec);
2795
2796 if (has_cdefine_beep(codec))
2797 spec->gen.beep_nid = 0x01;
2798
2799 /* automatic parse from the BIOS config */
2800 err = alc882_parse_auto_config(codec);
2801 if (err < 0)
2802 goto error;
2803
2804 if (!spec->gen.no_analog && spec->gen.beep_nid) {
2805 err = set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
2806 if (err < 0)
2807 goto error;
2808 }
2809
2810 snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE);
2811
2812 return 0;
2813
2814 error:
2815 alc_free(codec);
2816 return err;
2817 }
2818
2819
2820 /*
2821 * ALC262 support
2822 */
alc262_parse_auto_config(struct hda_codec * codec)2823 static int alc262_parse_auto_config(struct hda_codec *codec)
2824 {
2825 static const hda_nid_t alc262_ignore[] = { 0x1d, 0 };
2826 static const hda_nid_t alc262_ssids[] = { 0x15, 0x1b, 0x14, 0 };
2827 return alc_parse_auto_config(codec, alc262_ignore, alc262_ssids);
2828 }
2829
2830 /*
2831 * Pin config fixes
2832 */
2833 enum {
2834 ALC262_FIXUP_FSC_H270,
2835 ALC262_FIXUP_FSC_S7110,
2836 ALC262_FIXUP_HP_Z200,
2837 ALC262_FIXUP_TYAN,
2838 ALC262_FIXUP_LENOVO_3000,
2839 ALC262_FIXUP_BENQ,
2840 ALC262_FIXUP_BENQ_T31,
2841 ALC262_FIXUP_INV_DMIC,
2842 ALC262_FIXUP_INTEL_BAYLEYBAY,
2843 };
2844
2845 static const struct hda_fixup alc262_fixups[] = {
2846 [ALC262_FIXUP_FSC_H270] = {
2847 .type = HDA_FIXUP_PINS,
2848 .v.pins = (const struct hda_pintbl[]) {
2849 { 0x14, 0x99130110 }, /* speaker */
2850 { 0x15, 0x0221142f }, /* front HP */
2851 { 0x1b, 0x0121141f }, /* rear HP */
2852 { }
2853 }
2854 },
2855 [ALC262_FIXUP_FSC_S7110] = {
2856 .type = HDA_FIXUP_PINS,
2857 .v.pins = (const struct hda_pintbl[]) {
2858 { 0x15, 0x90170110 }, /* speaker */
2859 { }
2860 },
2861 .chained = true,
2862 .chain_id = ALC262_FIXUP_BENQ,
2863 },
2864 [ALC262_FIXUP_HP_Z200] = {
2865 .type = HDA_FIXUP_PINS,
2866 .v.pins = (const struct hda_pintbl[]) {
2867 { 0x16, 0x99130120 }, /* internal speaker */
2868 { }
2869 }
2870 },
2871 [ALC262_FIXUP_TYAN] = {
2872 .type = HDA_FIXUP_PINS,
2873 .v.pins = (const struct hda_pintbl[]) {
2874 { 0x14, 0x1993e1f0 }, /* int AUX */
2875 { }
2876 }
2877 },
2878 [ALC262_FIXUP_LENOVO_3000] = {
2879 .type = HDA_FIXUP_PINCTLS,
2880 .v.pins = (const struct hda_pintbl[]) {
2881 { 0x19, PIN_VREF50 },
2882 {}
2883 },
2884 .chained = true,
2885 .chain_id = ALC262_FIXUP_BENQ,
2886 },
2887 [ALC262_FIXUP_BENQ] = {
2888 .type = HDA_FIXUP_VERBS,
2889 .v.verbs = (const struct hda_verb[]) {
2890 { 0x20, AC_VERB_SET_COEF_INDEX, 0x07 },
2891 { 0x20, AC_VERB_SET_PROC_COEF, 0x3070 },
2892 {}
2893 }
2894 },
2895 [ALC262_FIXUP_BENQ_T31] = {
2896 .type = HDA_FIXUP_VERBS,
2897 .v.verbs = (const struct hda_verb[]) {
2898 { 0x20, AC_VERB_SET_COEF_INDEX, 0x07 },
2899 { 0x20, AC_VERB_SET_PROC_COEF, 0x3050 },
2900 {}
2901 }
2902 },
2903 [ALC262_FIXUP_INV_DMIC] = {
2904 .type = HDA_FIXUP_FUNC,
2905 .v.func = alc_fixup_inv_dmic,
2906 },
2907 [ALC262_FIXUP_INTEL_BAYLEYBAY] = {
2908 .type = HDA_FIXUP_FUNC,
2909 .v.func = alc_fixup_no_depop_delay,
2910 },
2911 };
2912
2913 static const struct snd_pci_quirk alc262_fixup_tbl[] = {
2914 SND_PCI_QUIRK(0x103c, 0x170b, "HP Z200", ALC262_FIXUP_HP_Z200),
2915 SND_PCI_QUIRK(0x10cf, 0x1397, "Fujitsu Lifebook S7110", ALC262_FIXUP_FSC_S7110),
2916 SND_PCI_QUIRK(0x10cf, 0x142d, "Fujitsu Lifebook E8410", ALC262_FIXUP_BENQ),
2917 SND_PCI_QUIRK(0x10f1, 0x2915, "Tyan Thunder n6650W", ALC262_FIXUP_TYAN),
2918 SND_PCI_QUIRK(0x1734, 0x1141, "FSC ESPRIMO U9210", ALC262_FIXUP_FSC_H270),
2919 SND_PCI_QUIRK(0x1734, 0x1147, "FSC Celsius H270", ALC262_FIXUP_FSC_H270),
2920 SND_PCI_QUIRK(0x17aa, 0x384e, "Lenovo 3000", ALC262_FIXUP_LENOVO_3000),
2921 SND_PCI_QUIRK(0x17ff, 0x0560, "Benq ED8", ALC262_FIXUP_BENQ),
2922 SND_PCI_QUIRK(0x17ff, 0x058d, "Benq T31-16", ALC262_FIXUP_BENQ_T31),
2923 SND_PCI_QUIRK(0x8086, 0x7270, "BayleyBay", ALC262_FIXUP_INTEL_BAYLEYBAY),
2924 {}
2925 };
2926
2927 static const struct hda_model_fixup alc262_fixup_models[] = {
2928 {.id = ALC262_FIXUP_INV_DMIC, .name = "inv-dmic"},
2929 {.id = ALC262_FIXUP_FSC_H270, .name = "fsc-h270"},
2930 {.id = ALC262_FIXUP_FSC_S7110, .name = "fsc-s7110"},
2931 {.id = ALC262_FIXUP_HP_Z200, .name = "hp-z200"},
2932 {.id = ALC262_FIXUP_TYAN, .name = "tyan"},
2933 {.id = ALC262_FIXUP_LENOVO_3000, .name = "lenovo-3000"},
2934 {.id = ALC262_FIXUP_BENQ, .name = "benq"},
2935 {.id = ALC262_FIXUP_BENQ_T31, .name = "benq-t31"},
2936 {.id = ALC262_FIXUP_INTEL_BAYLEYBAY, .name = "bayleybay"},
2937 {}
2938 };
2939
2940 /*
2941 */
patch_alc262(struct hda_codec * codec)2942 static int patch_alc262(struct hda_codec *codec)
2943 {
2944 struct alc_spec *spec;
2945 int err;
2946
2947 err = alc_alloc_spec(codec, 0x0b);
2948 if (err < 0)
2949 return err;
2950
2951 spec = codec->spec;
2952 spec->gen.shared_mic_vref_pin = 0x18;
2953
2954 spec->shutup = alc_eapd_shutup;
2955
2956 #if 0
2957 /* pshou 07/11/05 set a zero PCM sample to DAC when FIFO is
2958 * under-run
2959 */
2960 alc_update_coefex_idx(codec, 0x1a, 7, 0, 0x80);
2961 #endif
2962 alc_fix_pll_init(codec, 0x20, 0x0a, 10);
2963
2964 alc_pre_init(codec);
2965
2966 snd_hda_pick_fixup(codec, alc262_fixup_models, alc262_fixup_tbl,
2967 alc262_fixups);
2968 snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE);
2969
2970 alc_auto_parse_customize_define(codec);
2971
2972 if (has_cdefine_beep(codec))
2973 spec->gen.beep_nid = 0x01;
2974
2975 /* automatic parse from the BIOS config */
2976 err = alc262_parse_auto_config(codec);
2977 if (err < 0)
2978 goto error;
2979
2980 if (!spec->gen.no_analog && spec->gen.beep_nid) {
2981 err = set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
2982 if (err < 0)
2983 goto error;
2984 }
2985
2986 snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE);
2987
2988 return 0;
2989
2990 error:
2991 alc_free(codec);
2992 return err;
2993 }
2994
2995 /*
2996 * ALC268
2997 */
2998 /* bind Beep switches of both NID 0x0f and 0x10 */
alc268_beep_switch_put(struct snd_kcontrol * kcontrol,struct snd_ctl_elem_value * ucontrol)2999 static int alc268_beep_switch_put(struct snd_kcontrol *kcontrol,
3000 struct snd_ctl_elem_value *ucontrol)
3001 {
3002 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3003 unsigned long pval;
3004 int err;
3005
3006 mutex_lock(&codec->control_mutex);
3007 pval = kcontrol->private_value;
3008 kcontrol->private_value = (pval & ~0xff) | 0x0f;
3009 err = snd_hda_mixer_amp_switch_put(kcontrol, ucontrol);
3010 if (err >= 0) {
3011 kcontrol->private_value = (pval & ~0xff) | 0x10;
3012 err = snd_hda_mixer_amp_switch_put(kcontrol, ucontrol);
3013 }
3014 kcontrol->private_value = pval;
3015 mutex_unlock(&codec->control_mutex);
3016 return err;
3017 }
3018
3019 static const struct snd_kcontrol_new alc268_beep_mixer[] = {
3020 HDA_CODEC_VOLUME("Beep Playback Volume", 0x1d, 0x0, HDA_INPUT),
3021 {
3022 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3023 .name = "Beep Playback Switch",
3024 .subdevice = HDA_SUBDEV_AMP_FLAG,
3025 .info = snd_hda_mixer_amp_switch_info,
3026 .get = snd_hda_mixer_amp_switch_get,
3027 .put = alc268_beep_switch_put,
3028 .private_value = HDA_COMPOSE_AMP_VAL(0x0f, 3, 1, HDA_INPUT)
3029 },
3030 };
3031
3032 /* set PCBEEP vol = 0, mute connections */
3033 static const struct hda_verb alc268_beep_init_verbs[] = {
3034 {0x1d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
3035 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
3036 {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
3037 { }
3038 };
3039
3040 enum {
3041 ALC268_FIXUP_INV_DMIC,
3042 ALC268_FIXUP_HP_EAPD,
3043 ALC268_FIXUP_SPDIF,
3044 };
3045
3046 static const struct hda_fixup alc268_fixups[] = {
3047 [ALC268_FIXUP_INV_DMIC] = {
3048 .type = HDA_FIXUP_FUNC,
3049 .v.func = alc_fixup_inv_dmic,
3050 },
3051 [ALC268_FIXUP_HP_EAPD] = {
3052 .type = HDA_FIXUP_VERBS,
3053 .v.verbs = (const struct hda_verb[]) {
3054 {0x15, AC_VERB_SET_EAPD_BTLENABLE, 0},
3055 {}
3056 }
3057 },
3058 [ALC268_FIXUP_SPDIF] = {
3059 .type = HDA_FIXUP_PINS,
3060 .v.pins = (const struct hda_pintbl[]) {
3061 { 0x1e, 0x014b1180 }, /* enable SPDIF out */
3062 {}
3063 }
3064 },
3065 };
3066
3067 static const struct hda_model_fixup alc268_fixup_models[] = {
3068 {.id = ALC268_FIXUP_INV_DMIC, .name = "inv-dmic"},
3069 {.id = ALC268_FIXUP_HP_EAPD, .name = "hp-eapd"},
3070 {.id = ALC268_FIXUP_SPDIF, .name = "spdif"},
3071 {}
3072 };
3073
3074 static const struct snd_pci_quirk alc268_fixup_tbl[] = {
3075 SND_PCI_QUIRK(0x1025, 0x0139, "Acer TravelMate 6293", ALC268_FIXUP_SPDIF),
3076 SND_PCI_QUIRK(0x1025, 0x015b, "Acer AOA 150 (ZG5)", ALC268_FIXUP_INV_DMIC),
3077 /* below is codec SSID since multiple Toshiba laptops have the
3078 * same PCI SSID 1179:ff00
3079 */
3080 SND_PCI_QUIRK(0x1179, 0xff06, "Toshiba P200", ALC268_FIXUP_HP_EAPD),
3081 {}
3082 };
3083
3084 /*
3085 * BIOS auto configuration
3086 */
alc268_parse_auto_config(struct hda_codec * codec)3087 static int alc268_parse_auto_config(struct hda_codec *codec)
3088 {
3089 static const hda_nid_t alc268_ssids[] = { 0x15, 0x1b, 0x14, 0 };
3090 return alc_parse_auto_config(codec, NULL, alc268_ssids);
3091 }
3092
3093 /*
3094 */
patch_alc268(struct hda_codec * codec)3095 static int patch_alc268(struct hda_codec *codec)
3096 {
3097 struct alc_spec *spec;
3098 int i, err;
3099
3100 /* ALC268 has no aa-loopback mixer */
3101 err = alc_alloc_spec(codec, 0);
3102 if (err < 0)
3103 return err;
3104
3105 spec = codec->spec;
3106 if (has_cdefine_beep(codec))
3107 spec->gen.beep_nid = 0x01;
3108
3109 spec->shutup = alc_eapd_shutup;
3110
3111 alc_pre_init(codec);
3112
3113 snd_hda_pick_fixup(codec, alc268_fixup_models, alc268_fixup_tbl, alc268_fixups);
3114 snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE);
3115
3116 /* automatic parse from the BIOS config */
3117 err = alc268_parse_auto_config(codec);
3118 if (err < 0)
3119 goto error;
3120
3121 if (err > 0 && !spec->gen.no_analog &&
3122 spec->gen.autocfg.speaker_pins[0] != 0x1d) {
3123 for (i = 0; i < ARRAY_SIZE(alc268_beep_mixer); i++) {
3124 if (!snd_hda_gen_add_kctl(&spec->gen, NULL,
3125 &alc268_beep_mixer[i])) {
3126 err = -ENOMEM;
3127 goto error;
3128 }
3129 }
3130 snd_hda_add_verbs(codec, alc268_beep_init_verbs);
3131 if (!query_amp_caps(codec, 0x1d, HDA_INPUT))
3132 /* override the amp caps for beep generator */
3133 snd_hda_override_amp_caps(codec, 0x1d, HDA_INPUT,
3134 (0x0c << AC_AMPCAP_OFFSET_SHIFT) |
3135 (0x0c << AC_AMPCAP_NUM_STEPS_SHIFT) |
3136 (0x07 << AC_AMPCAP_STEP_SIZE_SHIFT) |
3137 (0 << AC_AMPCAP_MUTE_SHIFT));
3138 }
3139
3140 snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE);
3141
3142 return 0;
3143
3144 error:
3145 alc_free(codec);
3146 return err;
3147 }
3148
3149 /*
3150 * ALC269
3151 */
3152
3153 static const struct hda_pcm_stream alc269_44k_pcm_analog_playback = {
3154 .rates = SNDRV_PCM_RATE_44100, /* fixed rate */
3155 };
3156
3157 static const struct hda_pcm_stream alc269_44k_pcm_analog_capture = {
3158 .rates = SNDRV_PCM_RATE_44100, /* fixed rate */
3159 };
3160
3161 /* different alc269-variants */
3162 enum {
3163 ALC269_TYPE_ALC269VA,
3164 ALC269_TYPE_ALC269VB,
3165 ALC269_TYPE_ALC269VC,
3166 ALC269_TYPE_ALC269VD,
3167 ALC269_TYPE_ALC280,
3168 ALC269_TYPE_ALC282,
3169 ALC269_TYPE_ALC283,
3170 ALC269_TYPE_ALC284,
3171 ALC269_TYPE_ALC293,
3172 ALC269_TYPE_ALC286,
3173 ALC269_TYPE_ALC298,
3174 ALC269_TYPE_ALC255,
3175 ALC269_TYPE_ALC256,
3176 ALC269_TYPE_ALC257,
3177 ALC269_TYPE_ALC215,
3178 ALC269_TYPE_ALC225,
3179 ALC269_TYPE_ALC245,
3180 ALC269_TYPE_ALC287,
3181 ALC269_TYPE_ALC294,
3182 ALC269_TYPE_ALC300,
3183 ALC269_TYPE_ALC623,
3184 ALC269_TYPE_ALC700,
3185 };
3186
3187 /*
3188 * BIOS auto configuration
3189 */
alc269_parse_auto_config(struct hda_codec * codec)3190 static int alc269_parse_auto_config(struct hda_codec *codec)
3191 {
3192 static const hda_nid_t alc269_ignore[] = { 0x1d, 0 };
3193 static const hda_nid_t alc269_ssids[] = { 0, 0x1b, 0x14, 0x21 };
3194 static const hda_nid_t alc269va_ssids[] = { 0x15, 0x1b, 0x14, 0 };
3195 struct alc_spec *spec = codec->spec;
3196 const hda_nid_t *ssids;
3197
3198 switch (spec->codec_variant) {
3199 case ALC269_TYPE_ALC269VA:
3200 case ALC269_TYPE_ALC269VC:
3201 case ALC269_TYPE_ALC280:
3202 case ALC269_TYPE_ALC284:
3203 case ALC269_TYPE_ALC293:
3204 ssids = alc269va_ssids;
3205 break;
3206 case ALC269_TYPE_ALC269VB:
3207 case ALC269_TYPE_ALC269VD:
3208 case ALC269_TYPE_ALC282:
3209 case ALC269_TYPE_ALC283:
3210 case ALC269_TYPE_ALC286:
3211 case ALC269_TYPE_ALC298:
3212 case ALC269_TYPE_ALC255:
3213 case ALC269_TYPE_ALC256:
3214 case ALC269_TYPE_ALC257:
3215 case ALC269_TYPE_ALC215:
3216 case ALC269_TYPE_ALC225:
3217 case ALC269_TYPE_ALC245:
3218 case ALC269_TYPE_ALC287:
3219 case ALC269_TYPE_ALC294:
3220 case ALC269_TYPE_ALC300:
3221 case ALC269_TYPE_ALC623:
3222 case ALC269_TYPE_ALC700:
3223 ssids = alc269_ssids;
3224 break;
3225 default:
3226 ssids = alc269_ssids;
3227 break;
3228 }
3229
3230 return alc_parse_auto_config(codec, alc269_ignore, ssids);
3231 }
3232
3233 static const struct hda_jack_keymap alc_headset_btn_keymap[] = {
3234 { SND_JACK_BTN_0, KEY_PLAYPAUSE },
3235 { SND_JACK_BTN_1, KEY_VOICECOMMAND },
3236 { SND_JACK_BTN_2, KEY_VOLUMEUP },
3237 { SND_JACK_BTN_3, KEY_VOLUMEDOWN },
3238 {}
3239 };
3240
alc_headset_btn_callback(struct hda_codec * codec,struct hda_jack_callback * jack)3241 static void alc_headset_btn_callback(struct hda_codec *codec,
3242 struct hda_jack_callback *jack)
3243 {
3244 int report = 0;
3245
3246 if (jack->unsol_res & (7 << 13))
3247 report |= SND_JACK_BTN_0;
3248
3249 if (jack->unsol_res & (1 << 16 | 3 << 8))
3250 report |= SND_JACK_BTN_1;
3251
3252 /* Volume up key */
3253 if (jack->unsol_res & (7 << 23))
3254 report |= SND_JACK_BTN_2;
3255
3256 /* Volume down key */
3257 if (jack->unsol_res & (7 << 10))
3258 report |= SND_JACK_BTN_3;
3259
3260 snd_hda_jack_set_button_state(codec, jack->nid, report);
3261 }
3262
alc_disable_headset_jack_key(struct hda_codec * codec)3263 static void alc_disable_headset_jack_key(struct hda_codec *codec)
3264 {
3265 struct alc_spec *spec = codec->spec;
3266
3267 if (!spec->has_hs_key)
3268 return;
3269
3270 switch (codec->core.vendor_id) {
3271 case 0x10ec0215:
3272 case 0x10ec0225:
3273 case 0x10ec0285:
3274 case 0x10ec0287:
3275 case 0x10ec0295:
3276 case 0x10ec0289:
3277 case 0x10ec0299:
3278 alc_write_coef_idx(codec, 0x48, 0x0);
3279 alc_update_coef_idx(codec, 0x49, 0x0045, 0x0);
3280 alc_update_coef_idx(codec, 0x44, 0x0045 << 8, 0x0);
3281 break;
3282 case 0x10ec0230:
3283 case 0x10ec0236:
3284 case 0x10ec0256:
3285 case 0x10ec0257:
3286 case 0x19e58326:
3287 alc_write_coef_idx(codec, 0x48, 0x0);
3288 alc_update_coef_idx(codec, 0x49, 0x0045, 0x0);
3289 break;
3290 }
3291 }
3292
alc_enable_headset_jack_key(struct hda_codec * codec)3293 static void alc_enable_headset_jack_key(struct hda_codec *codec)
3294 {
3295 struct alc_spec *spec = codec->spec;
3296
3297 if (!spec->has_hs_key)
3298 return;
3299
3300 switch (codec->core.vendor_id) {
3301 case 0x10ec0215:
3302 case 0x10ec0225:
3303 case 0x10ec0285:
3304 case 0x10ec0287:
3305 case 0x10ec0295:
3306 case 0x10ec0289:
3307 case 0x10ec0299:
3308 alc_write_coef_idx(codec, 0x48, 0xd011);
3309 alc_update_coef_idx(codec, 0x49, 0x007f, 0x0045);
3310 alc_update_coef_idx(codec, 0x44, 0x007f << 8, 0x0045 << 8);
3311 break;
3312 case 0x10ec0230:
3313 case 0x10ec0236:
3314 case 0x10ec0256:
3315 case 0x10ec0257:
3316 case 0x19e58326:
3317 alc_write_coef_idx(codec, 0x48, 0xd011);
3318 alc_update_coef_idx(codec, 0x49, 0x007f, 0x0045);
3319 break;
3320 }
3321 }
3322
alc_fixup_headset_jack(struct hda_codec * codec,const struct hda_fixup * fix,int action)3323 static void alc_fixup_headset_jack(struct hda_codec *codec,
3324 const struct hda_fixup *fix, int action)
3325 {
3326 struct alc_spec *spec = codec->spec;
3327 hda_nid_t hp_pin;
3328
3329 switch (action) {
3330 case HDA_FIXUP_ACT_PRE_PROBE:
3331 spec->has_hs_key = 1;
3332 snd_hda_jack_detect_enable_callback(codec, 0x55,
3333 alc_headset_btn_callback);
3334 break;
3335 case HDA_FIXUP_ACT_BUILD:
3336 hp_pin = alc_get_hp_pin(spec);
3337 if (!hp_pin || snd_hda_jack_bind_keymap(codec, 0x55,
3338 alc_headset_btn_keymap,
3339 hp_pin))
3340 snd_hda_jack_add_kctl(codec, 0x55, "Headset Jack",
3341 false, SND_JACK_HEADSET,
3342 alc_headset_btn_keymap);
3343
3344 alc_enable_headset_jack_key(codec);
3345 break;
3346 }
3347 }
3348
alc269vb_toggle_power_output(struct hda_codec * codec,int power_up)3349 static void alc269vb_toggle_power_output(struct hda_codec *codec, int power_up)
3350 {
3351 alc_update_coef_idx(codec, 0x04, 1 << 11, power_up ? (1 << 11) : 0);
3352 }
3353
alc269_shutup(struct hda_codec * codec)3354 static void alc269_shutup(struct hda_codec *codec)
3355 {
3356 struct alc_spec *spec = codec->spec;
3357
3358 if (spec->codec_variant == ALC269_TYPE_ALC269VB)
3359 alc269vb_toggle_power_output(codec, 0);
3360 if (spec->codec_variant == ALC269_TYPE_ALC269VB &&
3361 (alc_get_coef0(codec) & 0x00ff) == 0x018) {
3362 msleep(150);
3363 }
3364 alc_shutup_pins(codec);
3365 }
3366
3367 static const struct coef_fw alc282_coefs[] = {
3368 WRITE_COEF(0x03, 0x0002), /* Power Down Control */
3369 UPDATE_COEF(0x05, 0xff3f, 0x0700), /* FIFO and filter clock */
3370 WRITE_COEF(0x07, 0x0200), /* DMIC control */
3371 UPDATE_COEF(0x06, 0x00f0, 0), /* Analog clock */
3372 UPDATE_COEF(0x08, 0xfffc, 0x0c2c), /* JD */
3373 WRITE_COEF(0x0a, 0xcccc), /* JD offset1 */
3374 WRITE_COEF(0x0b, 0xcccc), /* JD offset2 */
3375 WRITE_COEF(0x0e, 0x6e00), /* LDO1/2/3, DAC/ADC */
3376 UPDATE_COEF(0x0f, 0xf800, 0x1000), /* JD */
3377 UPDATE_COEF(0x10, 0xfc00, 0x0c00), /* Capless */
3378 WRITE_COEF(0x6f, 0x0), /* Class D test 4 */
3379 UPDATE_COEF(0x0c, 0xfe00, 0), /* IO power down directly */
3380 WRITE_COEF(0x34, 0xa0c0), /* ANC */
3381 UPDATE_COEF(0x16, 0x0008, 0), /* AGC MUX */
3382 UPDATE_COEF(0x1d, 0x00e0, 0), /* DAC simple content protection */
3383 UPDATE_COEF(0x1f, 0x00e0, 0), /* ADC simple content protection */
3384 WRITE_COEF(0x21, 0x8804), /* DAC ADC Zero Detection */
3385 WRITE_COEF(0x63, 0x2902), /* PLL */
3386 WRITE_COEF(0x68, 0xa080), /* capless control 2 */
3387 WRITE_COEF(0x69, 0x3400), /* capless control 3 */
3388 WRITE_COEF(0x6a, 0x2f3e), /* capless control 4 */
3389 WRITE_COEF(0x6b, 0x0), /* capless control 5 */
3390 UPDATE_COEF(0x6d, 0x0fff, 0x0900), /* class D test 2 */
3391 WRITE_COEF(0x6e, 0x110a), /* class D test 3 */
3392 UPDATE_COEF(0x70, 0x00f8, 0x00d8), /* class D test 5 */
3393 WRITE_COEF(0x71, 0x0014), /* class D test 6 */
3394 WRITE_COEF(0x72, 0xc2ba), /* classD OCP */
3395 UPDATE_COEF(0x77, 0x0f80, 0), /* classD pure DC test */
3396 WRITE_COEF(0x6c, 0xfc06), /* Class D amp control */
3397 {}
3398 };
3399
alc282_restore_default_value(struct hda_codec * codec)3400 static void alc282_restore_default_value(struct hda_codec *codec)
3401 {
3402 alc_process_coef_fw(codec, alc282_coefs);
3403 }
3404
alc282_init(struct hda_codec * codec)3405 static void alc282_init(struct hda_codec *codec)
3406 {
3407 struct alc_spec *spec = codec->spec;
3408 hda_nid_t hp_pin = alc_get_hp_pin(spec);
3409 bool hp_pin_sense;
3410 int coef78;
3411
3412 alc282_restore_default_value(codec);
3413
3414 if (!hp_pin)
3415 return;
3416 hp_pin_sense = snd_hda_jack_detect(codec, hp_pin);
3417 coef78 = alc_read_coef_idx(codec, 0x78);
3418
3419 /* Index 0x78 Direct Drive HP AMP LPM Control 1 */
3420 /* Headphone capless set to high power mode */
3421 alc_write_coef_idx(codec, 0x78, 0x9004);
3422
3423 if (hp_pin_sense)
3424 msleep(2);
3425
3426 snd_hda_codec_write(codec, hp_pin, 0,
3427 AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);
3428
3429 if (hp_pin_sense)
3430 msleep(85);
3431
3432 snd_hda_codec_write(codec, hp_pin, 0,
3433 AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT);
3434
3435 if (hp_pin_sense)
3436 msleep(100);
3437
3438 /* Headphone capless set to normal mode */
3439 alc_write_coef_idx(codec, 0x78, coef78);
3440 }
3441
alc282_shutup(struct hda_codec * codec)3442 static void alc282_shutup(struct hda_codec *codec)
3443 {
3444 struct alc_spec *spec = codec->spec;
3445 hda_nid_t hp_pin = alc_get_hp_pin(spec);
3446 bool hp_pin_sense;
3447 int coef78;
3448
3449 if (!hp_pin) {
3450 alc269_shutup(codec);
3451 return;
3452 }
3453
3454 hp_pin_sense = snd_hda_jack_detect(codec, hp_pin);
3455 coef78 = alc_read_coef_idx(codec, 0x78);
3456 alc_write_coef_idx(codec, 0x78, 0x9004);
3457
3458 if (hp_pin_sense)
3459 msleep(2);
3460
3461 snd_hda_codec_write(codec, hp_pin, 0,
3462 AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);
3463
3464 if (hp_pin_sense)
3465 msleep(85);
3466
3467 if (!spec->no_shutup_pins)
3468 snd_hda_codec_write(codec, hp_pin, 0,
3469 AC_VERB_SET_PIN_WIDGET_CONTROL, 0x0);
3470
3471 if (hp_pin_sense)
3472 msleep(100);
3473
3474 alc_auto_setup_eapd(codec, false);
3475 alc_shutup_pins(codec);
3476 alc_write_coef_idx(codec, 0x78, coef78);
3477 }
3478
3479 static const struct coef_fw alc283_coefs[] = {
3480 WRITE_COEF(0x03, 0x0002), /* Power Down Control */
3481 UPDATE_COEF(0x05, 0xff3f, 0x0700), /* FIFO and filter clock */
3482 WRITE_COEF(0x07, 0x0200), /* DMIC control */
3483 UPDATE_COEF(0x06, 0x00f0, 0), /* Analog clock */
3484 UPDATE_COEF(0x08, 0xfffc, 0x0c2c), /* JD */
3485 WRITE_COEF(0x0a, 0xcccc), /* JD offset1 */
3486 WRITE_COEF(0x0b, 0xcccc), /* JD offset2 */
3487 WRITE_COEF(0x0e, 0x6fc0), /* LDO1/2/3, DAC/ADC */
3488 UPDATE_COEF(0x0f, 0xf800, 0x1000), /* JD */
3489 UPDATE_COEF(0x10, 0xfc00, 0x0c00), /* Capless */
3490 WRITE_COEF(0x3a, 0x0), /* Class D test 4 */
3491 UPDATE_COEF(0x0c, 0xfe00, 0x0), /* IO power down directly */
3492 WRITE_COEF(0x22, 0xa0c0), /* ANC */
3493 UPDATE_COEFEX(0x53, 0x01, 0x000f, 0x0008), /* AGC MUX */
3494 UPDATE_COEF(0x1d, 0x00e0, 0), /* DAC simple content protection */
3495 UPDATE_COEF(0x1f, 0x00e0, 0), /* ADC simple content protection */
3496 WRITE_COEF(0x21, 0x8804), /* DAC ADC Zero Detection */
3497 WRITE_COEF(0x2e, 0x2902), /* PLL */
3498 WRITE_COEF(0x33, 0xa080), /* capless control 2 */
3499 WRITE_COEF(0x34, 0x3400), /* capless control 3 */
3500 WRITE_COEF(0x35, 0x2f3e), /* capless control 4 */
3501 WRITE_COEF(0x36, 0x0), /* capless control 5 */
3502 UPDATE_COEF(0x38, 0x0fff, 0x0900), /* class D test 2 */
3503 WRITE_COEF(0x39, 0x110a), /* class D test 3 */
3504 UPDATE_COEF(0x3b, 0x00f8, 0x00d8), /* class D test 5 */
3505 WRITE_COEF(0x3c, 0x0014), /* class D test 6 */
3506 WRITE_COEF(0x3d, 0xc2ba), /* classD OCP */
3507 UPDATE_COEF(0x42, 0x0f80, 0x0), /* classD pure DC test */
3508 WRITE_COEF(0x49, 0x0), /* test mode */
3509 UPDATE_COEF(0x40, 0xf800, 0x9800), /* Class D DC enable */
3510 UPDATE_COEF(0x42, 0xf000, 0x2000), /* DC offset */
3511 WRITE_COEF(0x37, 0xfc06), /* Class D amp control */
3512 UPDATE_COEF(0x1b, 0x8000, 0), /* HP JD control */
3513 {}
3514 };
3515
alc283_restore_default_value(struct hda_codec * codec)3516 static void alc283_restore_default_value(struct hda_codec *codec)
3517 {
3518 alc_process_coef_fw(codec, alc283_coefs);
3519 }
3520
alc283_init(struct hda_codec * codec)3521 static void alc283_init(struct hda_codec *codec)
3522 {
3523 struct alc_spec *spec = codec->spec;
3524 hda_nid_t hp_pin = alc_get_hp_pin(spec);
3525 bool hp_pin_sense;
3526
3527 alc283_restore_default_value(codec);
3528
3529 if (!hp_pin)
3530 return;
3531
3532 msleep(30);
3533 hp_pin_sense = snd_hda_jack_detect(codec, hp_pin);
3534
3535 /* Index 0x43 Direct Drive HP AMP LPM Control 1 */
3536 /* Headphone capless set to high power mode */
3537 alc_write_coef_idx(codec, 0x43, 0x9004);
3538
3539 snd_hda_codec_write(codec, hp_pin, 0,
3540 AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);
3541
3542 if (hp_pin_sense)
3543 msleep(85);
3544
3545 snd_hda_codec_write(codec, hp_pin, 0,
3546 AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT);
3547
3548 if (hp_pin_sense)
3549 msleep(85);
3550 /* Index 0x46 Combo jack auto switch control 2 */
3551 /* 3k pull low control for Headset jack. */
3552 alc_update_coef_idx(codec, 0x46, 3 << 12, 0);
3553 /* Headphone capless set to normal mode */
3554 alc_write_coef_idx(codec, 0x43, 0x9614);
3555 }
3556
alc283_shutup(struct hda_codec * codec)3557 static void alc283_shutup(struct hda_codec *codec)
3558 {
3559 struct alc_spec *spec = codec->spec;
3560 hda_nid_t hp_pin = alc_get_hp_pin(spec);
3561 bool hp_pin_sense;
3562
3563 if (!hp_pin) {
3564 alc269_shutup(codec);
3565 return;
3566 }
3567
3568 hp_pin_sense = snd_hda_jack_detect(codec, hp_pin);
3569
3570 alc_write_coef_idx(codec, 0x43, 0x9004);
3571
3572 /*depop hp during suspend*/
3573 alc_write_coef_idx(codec, 0x06, 0x2100);
3574
3575 snd_hda_codec_write(codec, hp_pin, 0,
3576 AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);
3577
3578 if (hp_pin_sense)
3579 msleep(100);
3580
3581 if (!spec->no_shutup_pins)
3582 snd_hda_codec_write(codec, hp_pin, 0,
3583 AC_VERB_SET_PIN_WIDGET_CONTROL, 0x0);
3584
3585 alc_update_coef_idx(codec, 0x46, 0, 3 << 12);
3586
3587 if (hp_pin_sense)
3588 msleep(100);
3589 alc_auto_setup_eapd(codec, false);
3590 alc_shutup_pins(codec);
3591 alc_write_coef_idx(codec, 0x43, 0x9614);
3592 }
3593
alc256_init(struct hda_codec * codec)3594 static void alc256_init(struct hda_codec *codec)
3595 {
3596 struct alc_spec *spec = codec->spec;
3597 hda_nid_t hp_pin = alc_get_hp_pin(spec);
3598 bool hp_pin_sense;
3599
3600 if (spec->ultra_low_power) {
3601 alc_update_coef_idx(codec, 0x03, 1<<1, 1<<1);
3602 alc_update_coef_idx(codec, 0x08, 3<<2, 3<<2);
3603 alc_update_coef_idx(codec, 0x08, 7<<4, 0);
3604 alc_update_coef_idx(codec, 0x3b, 1<<15, 0);
3605 alc_update_coef_idx(codec, 0x0e, 7<<6, 7<<6);
3606 msleep(30);
3607 }
3608
3609 if (!hp_pin)
3610 hp_pin = 0x21;
3611
3612 msleep(30);
3613
3614 hp_pin_sense = snd_hda_jack_detect(codec, hp_pin);
3615
3616 if (hp_pin_sense)
3617 msleep(2);
3618
3619 alc_update_coefex_idx(codec, 0x57, 0x04, 0x0007, 0x1); /* Low power */
3620
3621 snd_hda_codec_write(codec, hp_pin, 0,
3622 AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);
3623
3624 if (hp_pin_sense || spec->ultra_low_power)
3625 msleep(85);
3626
3627 snd_hda_codec_write(codec, hp_pin, 0,
3628 AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT);
3629
3630 if (hp_pin_sense || spec->ultra_low_power)
3631 msleep(100);
3632
3633 alc_update_coef_idx(codec, 0x46, 3 << 12, 0);
3634 alc_update_coefex_idx(codec, 0x57, 0x04, 0x0007, 0x4); /* Hight power */
3635 alc_update_coefex_idx(codec, 0x53, 0x02, 0x8000, 1 << 15); /* Clear bit */
3636 alc_update_coefex_idx(codec, 0x53, 0x02, 0x8000, 0 << 15);
3637 /*
3638 * Expose headphone mic (or possibly Line In on some machines) instead
3639 * of PC Beep on 1Ah, and disable 1Ah loopback for all outputs. See
3640 * Documentation/sound/hd-audio/realtek-pc-beep.rst for details of
3641 * this register.
3642 */
3643 alc_write_coef_idx(codec, 0x36, 0x5757);
3644 }
3645
alc256_shutup(struct hda_codec * codec)3646 static void alc256_shutup(struct hda_codec *codec)
3647 {
3648 struct alc_spec *spec = codec->spec;
3649 hda_nid_t hp_pin = alc_get_hp_pin(spec);
3650 bool hp_pin_sense;
3651
3652 if (!hp_pin)
3653 hp_pin = 0x21;
3654
3655 alc_update_coefex_idx(codec, 0x57, 0x04, 0x0007, 0x1); /* Low power */
3656 hp_pin_sense = snd_hda_jack_detect(codec, hp_pin);
3657
3658 if (hp_pin_sense)
3659 msleep(2);
3660
3661 snd_hda_codec_write(codec, hp_pin, 0,
3662 AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);
3663
3664 if (hp_pin_sense || spec->ultra_low_power)
3665 msleep(85);
3666
3667 /* 3k pull low control for Headset jack. */
3668 /* NOTE: call this before clearing the pin, otherwise codec stalls */
3669 /* If disable 3k pulldown control for alc257, the Mic detection will not work correctly
3670 * when booting with headset plugged. So skip setting it for the codec alc257
3671 */
3672 if (spec->en_3kpull_low)
3673 alc_update_coef_idx(codec, 0x46, 0, 3 << 12);
3674
3675 if (!spec->no_shutup_pins)
3676 snd_hda_codec_write(codec, hp_pin, 0,
3677 AC_VERB_SET_PIN_WIDGET_CONTROL, 0x0);
3678
3679 if (hp_pin_sense || spec->ultra_low_power)
3680 msleep(100);
3681
3682 alc_auto_setup_eapd(codec, false);
3683 alc_shutup_pins(codec);
3684 if (spec->ultra_low_power) {
3685 msleep(50);
3686 alc_update_coef_idx(codec, 0x03, 1<<1, 0);
3687 alc_update_coef_idx(codec, 0x08, 7<<4, 7<<4);
3688 alc_update_coef_idx(codec, 0x08, 3<<2, 0);
3689 alc_update_coef_idx(codec, 0x3b, 1<<15, 1<<15);
3690 alc_update_coef_idx(codec, 0x0e, 7<<6, 0);
3691 msleep(30);
3692 }
3693 }
3694
alc285_hp_init(struct hda_codec * codec)3695 static void alc285_hp_init(struct hda_codec *codec)
3696 {
3697 struct alc_spec *spec = codec->spec;
3698 hda_nid_t hp_pin = alc_get_hp_pin(spec);
3699 int i, val;
3700 int coef38, coef0d, coef36;
3701
3702 alc_write_coefex_idx(codec, 0x58, 0x00, 0x1888); /* write default value */
3703 alc_update_coef_idx(codec, 0x4a, 1<<15, 1<<15); /* Reset HP JD */
3704 coef38 = alc_read_coef_idx(codec, 0x38); /* Amp control */
3705 coef0d = alc_read_coef_idx(codec, 0x0d); /* Digital Misc control */
3706 coef36 = alc_read_coef_idx(codec, 0x36); /* Passthrough Control */
3707 alc_update_coef_idx(codec, 0x38, 1<<4, 0x0);
3708 alc_update_coef_idx(codec, 0x0d, 0x110, 0x0);
3709
3710 alc_update_coef_idx(codec, 0x67, 0xf000, 0x3000);
3711
3712 if (hp_pin)
3713 snd_hda_codec_write(codec, hp_pin, 0,
3714 AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);
3715
3716 msleep(130);
3717 alc_update_coef_idx(codec, 0x36, 1<<14, 1<<14);
3718 alc_update_coef_idx(codec, 0x36, 1<<13, 0x0);
3719
3720 if (hp_pin)
3721 snd_hda_codec_write(codec, hp_pin, 0,
3722 AC_VERB_SET_PIN_WIDGET_CONTROL, 0x0);
3723 msleep(10);
3724 alc_write_coef_idx(codec, 0x67, 0x0); /* Set HP depop to manual mode */
3725 alc_write_coefex_idx(codec, 0x58, 0x00, 0x7880);
3726 alc_write_coefex_idx(codec, 0x58, 0x0f, 0xf049);
3727 alc_update_coefex_idx(codec, 0x58, 0x03, 0x00f0, 0x00c0);
3728
3729 alc_write_coefex_idx(codec, 0x58, 0x00, 0xf888); /* HP depop procedure start */
3730 val = alc_read_coefex_idx(codec, 0x58, 0x00);
3731 for (i = 0; i < 20 && val & 0x8000; i++) {
3732 msleep(50);
3733 val = alc_read_coefex_idx(codec, 0x58, 0x00);
3734 } /* Wait for depop procedure finish */
3735
3736 alc_write_coefex_idx(codec, 0x58, 0x00, val); /* write back the result */
3737 alc_update_coef_idx(codec, 0x38, 1<<4, coef38);
3738 alc_update_coef_idx(codec, 0x0d, 0x110, coef0d);
3739 alc_update_coef_idx(codec, 0x36, 3<<13, coef36);
3740
3741 msleep(50);
3742 alc_update_coef_idx(codec, 0x4a, 1<<15, 0);
3743 }
3744
alc225_init(struct hda_codec * codec)3745 static void alc225_init(struct hda_codec *codec)
3746 {
3747 struct alc_spec *spec = codec->spec;
3748 hda_nid_t hp_pin = alc_get_hp_pin(spec);
3749 bool hp1_pin_sense, hp2_pin_sense;
3750
3751 if (spec->ultra_low_power) {
3752 alc_update_coef_idx(codec, 0x08, 0x0f << 2, 3<<2);
3753 alc_update_coef_idx(codec, 0x0e, 7<<6, 7<<6);
3754 alc_update_coef_idx(codec, 0x33, 1<<11, 0);
3755 msleep(30);
3756 }
3757
3758 if (spec->codec_variant != ALC269_TYPE_ALC287 &&
3759 spec->codec_variant != ALC269_TYPE_ALC245)
3760 /* required only at boot or S3 and S4 resume time */
3761 if (!spec->done_hp_init ||
3762 is_s3_resume(codec) ||
3763 is_s4_resume(codec)) {
3764 alc285_hp_init(codec);
3765 spec->done_hp_init = true;
3766 }
3767
3768 if (!hp_pin)
3769 hp_pin = 0x21;
3770 msleep(30);
3771
3772 hp1_pin_sense = snd_hda_jack_detect(codec, hp_pin);
3773 hp2_pin_sense = snd_hda_jack_detect(codec, 0x16);
3774
3775 if (hp1_pin_sense || hp2_pin_sense)
3776 msleep(2);
3777
3778 alc_update_coefex_idx(codec, 0x57, 0x04, 0x0007, 0x1); /* Low power */
3779
3780 if (hp1_pin_sense || spec->ultra_low_power)
3781 snd_hda_codec_write(codec, hp_pin, 0,
3782 AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);
3783 if (hp2_pin_sense)
3784 snd_hda_codec_write(codec, 0x16, 0,
3785 AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);
3786
3787 if (hp1_pin_sense || hp2_pin_sense || spec->ultra_low_power)
3788 msleep(85);
3789
3790 if (hp1_pin_sense || spec->ultra_low_power)
3791 snd_hda_codec_write(codec, hp_pin, 0,
3792 AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT);
3793 if (hp2_pin_sense)
3794 snd_hda_codec_write(codec, 0x16, 0,
3795 AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT);
3796
3797 if (hp1_pin_sense || hp2_pin_sense || spec->ultra_low_power)
3798 msleep(100);
3799
3800 alc_update_coef_idx(codec, 0x4a, 3 << 10, 0);
3801 alc_update_coefex_idx(codec, 0x57, 0x04, 0x0007, 0x4); /* Hight power */
3802 }
3803
alc225_shutup(struct hda_codec * codec)3804 static void alc225_shutup(struct hda_codec *codec)
3805 {
3806 struct alc_spec *spec = codec->spec;
3807 hda_nid_t hp_pin = alc_get_hp_pin(spec);
3808 bool hp1_pin_sense, hp2_pin_sense;
3809
3810 if (!hp_pin)
3811 hp_pin = 0x21;
3812
3813 alc_disable_headset_jack_key(codec);
3814 /* 3k pull low control for Headset jack. */
3815 alc_update_coef_idx(codec, 0x4a, 0, 3 << 10);
3816
3817 hp1_pin_sense = snd_hda_jack_detect(codec, hp_pin);
3818 hp2_pin_sense = snd_hda_jack_detect(codec, 0x16);
3819
3820 if (hp1_pin_sense || hp2_pin_sense)
3821 msleep(2);
3822
3823 if (hp1_pin_sense || spec->ultra_low_power)
3824 snd_hda_codec_write(codec, hp_pin, 0,
3825 AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);
3826 if (hp2_pin_sense)
3827 snd_hda_codec_write(codec, 0x16, 0,
3828 AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);
3829
3830 if (hp1_pin_sense || hp2_pin_sense || spec->ultra_low_power)
3831 msleep(85);
3832
3833 if (hp1_pin_sense || spec->ultra_low_power)
3834 snd_hda_codec_write(codec, hp_pin, 0,
3835 AC_VERB_SET_PIN_WIDGET_CONTROL, 0x0);
3836 if (hp2_pin_sense)
3837 snd_hda_codec_write(codec, 0x16, 0,
3838 AC_VERB_SET_PIN_WIDGET_CONTROL, 0x0);
3839
3840 if (hp1_pin_sense || hp2_pin_sense || spec->ultra_low_power)
3841 msleep(100);
3842
3843 alc_auto_setup_eapd(codec, false);
3844 alc_shutup_pins(codec);
3845 if (spec->ultra_low_power) {
3846 msleep(50);
3847 alc_update_coef_idx(codec, 0x08, 0x0f << 2, 0x0c << 2);
3848 alc_update_coef_idx(codec, 0x0e, 7<<6, 0);
3849 alc_update_coef_idx(codec, 0x33, 1<<11, 1<<11);
3850 alc_update_coef_idx(codec, 0x4a, 3<<4, 2<<4);
3851 msleep(30);
3852 }
3853
3854 alc_update_coef_idx(codec, 0x4a, 3 << 10, 0);
3855 alc_enable_headset_jack_key(codec);
3856 }
3857
alc_default_init(struct hda_codec * codec)3858 static void alc_default_init(struct hda_codec *codec)
3859 {
3860 struct alc_spec *spec = codec->spec;
3861 hda_nid_t hp_pin = alc_get_hp_pin(spec);
3862 bool hp_pin_sense;
3863
3864 if (!hp_pin)
3865 return;
3866
3867 msleep(30);
3868
3869 hp_pin_sense = snd_hda_jack_detect(codec, hp_pin);
3870
3871 if (hp_pin_sense) {
3872 msleep(2);
3873
3874 snd_hda_codec_write(codec, hp_pin, 0,
3875 AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT);
3876
3877 msleep(75);
3878
3879 snd_hda_codec_write(codec, hp_pin, 0,
3880 AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE);
3881 msleep(75);
3882 }
3883 }
3884
alc_default_shutup(struct hda_codec * codec)3885 static void alc_default_shutup(struct hda_codec *codec)
3886 {
3887 struct alc_spec *spec = codec->spec;
3888 hda_nid_t hp_pin = alc_get_hp_pin(spec);
3889 bool hp_pin_sense;
3890
3891 if (!hp_pin) {
3892 alc269_shutup(codec);
3893 return;
3894 }
3895
3896 hp_pin_sense = snd_hda_jack_detect(codec, hp_pin);
3897
3898 if (hp_pin_sense) {
3899 msleep(2);
3900
3901 snd_hda_codec_write(codec, hp_pin, 0,
3902 AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);
3903
3904 msleep(75);
3905
3906 if (!spec->no_shutup_pins)
3907 snd_hda_codec_write(codec, hp_pin, 0,
3908 AC_VERB_SET_PIN_WIDGET_CONTROL, 0x0);
3909
3910 msleep(75);
3911 }
3912 alc_auto_setup_eapd(codec, false);
3913 alc_shutup_pins(codec);
3914 }
3915
alc294_hp_init(struct hda_codec * codec)3916 static void alc294_hp_init(struct hda_codec *codec)
3917 {
3918 struct alc_spec *spec = codec->spec;
3919 hda_nid_t hp_pin = alc_get_hp_pin(spec);
3920 int i, val;
3921
3922 if (!hp_pin)
3923 return;
3924
3925 snd_hda_codec_write(codec, hp_pin, 0,
3926 AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);
3927
3928 msleep(100);
3929
3930 if (!spec->no_shutup_pins)
3931 snd_hda_codec_write(codec, hp_pin, 0,
3932 AC_VERB_SET_PIN_WIDGET_CONTROL, 0x0);
3933
3934 alc_update_coef_idx(codec, 0x6f, 0x000f, 0);/* Set HP depop to manual mode */
3935 alc_update_coefex_idx(codec, 0x58, 0x00, 0x8000, 0x8000); /* HP depop procedure start */
3936
3937 /* Wait for depop procedure finish */
3938 val = alc_read_coefex_idx(codec, 0x58, 0x01);
3939 for (i = 0; i < 20 && val & 0x0080; i++) {
3940 msleep(50);
3941 val = alc_read_coefex_idx(codec, 0x58, 0x01);
3942 }
3943 /* Set HP depop to auto mode */
3944 alc_update_coef_idx(codec, 0x6f, 0x000f, 0x000b);
3945 msleep(50);
3946 }
3947
alc294_init(struct hda_codec * codec)3948 static void alc294_init(struct hda_codec *codec)
3949 {
3950 struct alc_spec *spec = codec->spec;
3951
3952 /* required only at boot or S4 resume time */
3953 if (!spec->done_hp_init ||
3954 codec->core.dev.power.power_state.event == PM_EVENT_RESTORE) {
3955 alc294_hp_init(codec);
3956 spec->done_hp_init = true;
3957 }
3958 alc_default_init(codec);
3959 }
3960
alc5505_coef_set(struct hda_codec * codec,unsigned int index_reg,unsigned int val)3961 static void alc5505_coef_set(struct hda_codec *codec, unsigned int index_reg,
3962 unsigned int val)
3963 {
3964 snd_hda_codec_write(codec, 0x51, 0, AC_VERB_SET_COEF_INDEX, index_reg >> 1);
3965 snd_hda_codec_write(codec, 0x51, 0, AC_VERB_SET_PROC_COEF, val & 0xffff); /* LSB */
3966 snd_hda_codec_write(codec, 0x51, 0, AC_VERB_SET_PROC_COEF, val >> 16); /* MSB */
3967 }
3968
alc5505_coef_get(struct hda_codec * codec,unsigned int index_reg)3969 static int alc5505_coef_get(struct hda_codec *codec, unsigned int index_reg)
3970 {
3971 unsigned int val;
3972
3973 snd_hda_codec_write(codec, 0x51, 0, AC_VERB_SET_COEF_INDEX, index_reg >> 1);
3974 val = snd_hda_codec_read(codec, 0x51, 0, AC_VERB_GET_PROC_COEF, 0)
3975 & 0xffff;
3976 val |= snd_hda_codec_read(codec, 0x51, 0, AC_VERB_GET_PROC_COEF, 0)
3977 << 16;
3978 return val;
3979 }
3980
alc5505_dsp_halt(struct hda_codec * codec)3981 static void alc5505_dsp_halt(struct hda_codec *codec)
3982 {
3983 unsigned int val;
3984
3985 alc5505_coef_set(codec, 0x3000, 0x000c); /* DSP CPU stop */
3986 alc5505_coef_set(codec, 0x880c, 0x0008); /* DDR enter self refresh */
3987 alc5505_coef_set(codec, 0x61c0, 0x11110080); /* Clock control for PLL and CPU */
3988 alc5505_coef_set(codec, 0x6230, 0xfc0d4011); /* Disable Input OP */
3989 alc5505_coef_set(codec, 0x61b4, 0x040a2b03); /* Stop PLL2 */
3990 alc5505_coef_set(codec, 0x61b0, 0x00005b17); /* Stop PLL1 */
3991 alc5505_coef_set(codec, 0x61b8, 0x04133303); /* Stop PLL3 */
3992 val = alc5505_coef_get(codec, 0x6220);
3993 alc5505_coef_set(codec, 0x6220, (val | 0x3000)); /* switch Ringbuffer clock to DBUS clock */
3994 }
3995
alc5505_dsp_back_from_halt(struct hda_codec * codec)3996 static void alc5505_dsp_back_from_halt(struct hda_codec *codec)
3997 {
3998 alc5505_coef_set(codec, 0x61b8, 0x04133302);
3999 alc5505_coef_set(codec, 0x61b0, 0x00005b16);
4000 alc5505_coef_set(codec, 0x61b4, 0x040a2b02);
4001 alc5505_coef_set(codec, 0x6230, 0xf80d4011);
4002 alc5505_coef_set(codec, 0x6220, 0x2002010f);
4003 alc5505_coef_set(codec, 0x880c, 0x00000004);
4004 }
4005
alc5505_dsp_init(struct hda_codec * codec)4006 static void alc5505_dsp_init(struct hda_codec *codec)
4007 {
4008 unsigned int val;
4009
4010 alc5505_dsp_halt(codec);
4011 alc5505_dsp_back_from_halt(codec);
4012 alc5505_coef_set(codec, 0x61b0, 0x5b14); /* PLL1 control */
4013 alc5505_coef_set(codec, 0x61b0, 0x5b16);
4014 alc5505_coef_set(codec, 0x61b4, 0x04132b00); /* PLL2 control */
4015 alc5505_coef_set(codec, 0x61b4, 0x04132b02);
4016 alc5505_coef_set(codec, 0x61b8, 0x041f3300); /* PLL3 control*/
4017 alc5505_coef_set(codec, 0x61b8, 0x041f3302);
4018 snd_hda_codec_write(codec, 0x51, 0, AC_VERB_SET_CODEC_RESET, 0); /* Function reset */
4019 alc5505_coef_set(codec, 0x61b8, 0x041b3302);
4020 alc5505_coef_set(codec, 0x61b8, 0x04173302);
4021 alc5505_coef_set(codec, 0x61b8, 0x04163302);
4022 alc5505_coef_set(codec, 0x8800, 0x348b328b); /* DRAM control */
4023 alc5505_coef_set(codec, 0x8808, 0x00020022); /* DRAM control */
4024 alc5505_coef_set(codec, 0x8818, 0x00000400); /* DRAM control */
4025
4026 val = alc5505_coef_get(codec, 0x6200) >> 16; /* Read revision ID */
4027 if (val <= 3)
4028 alc5505_coef_set(codec, 0x6220, 0x2002010f); /* I/O PAD Configuration */
4029 else
4030 alc5505_coef_set(codec, 0x6220, 0x6002018f);
4031
4032 alc5505_coef_set(codec, 0x61ac, 0x055525f0); /**/
4033 alc5505_coef_set(codec, 0x61c0, 0x12230080); /* Clock control */
4034 alc5505_coef_set(codec, 0x61b4, 0x040e2b02); /* PLL2 control */
4035 alc5505_coef_set(codec, 0x61bc, 0x010234f8); /* OSC Control */
4036 alc5505_coef_set(codec, 0x880c, 0x00000004); /* DRAM Function control */
4037 alc5505_coef_set(codec, 0x880c, 0x00000003);
4038 alc5505_coef_set(codec, 0x880c, 0x00000010);
4039
4040 #ifdef HALT_REALTEK_ALC5505
4041 alc5505_dsp_halt(codec);
4042 #endif
4043 }
4044
4045 #ifdef HALT_REALTEK_ALC5505
4046 #define alc5505_dsp_suspend(codec) do { } while (0) /* NOP */
4047 #define alc5505_dsp_resume(codec) do { } while (0) /* NOP */
4048 #else
4049 #define alc5505_dsp_suspend(codec) alc5505_dsp_halt(codec)
4050 #define alc5505_dsp_resume(codec) alc5505_dsp_back_from_halt(codec)
4051 #endif
4052
alc269_suspend(struct hda_codec * codec)4053 static int alc269_suspend(struct hda_codec *codec)
4054 {
4055 struct alc_spec *spec = codec->spec;
4056
4057 if (spec->has_alc5505_dsp)
4058 alc5505_dsp_suspend(codec);
4059
4060 return alc_suspend(codec);
4061 }
4062
alc269_resume(struct hda_codec * codec)4063 static int alc269_resume(struct hda_codec *codec)
4064 {
4065 struct alc_spec *spec = codec->spec;
4066
4067 if (spec->codec_variant == ALC269_TYPE_ALC269VB)
4068 alc269vb_toggle_power_output(codec, 0);
4069 if (spec->codec_variant == ALC269_TYPE_ALC269VB &&
4070 (alc_get_coef0(codec) & 0x00ff) == 0x018) {
4071 msleep(150);
4072 }
4073
4074 codec->patch_ops.init(codec);
4075
4076 if (spec->codec_variant == ALC269_TYPE_ALC269VB)
4077 alc269vb_toggle_power_output(codec, 1);
4078 if (spec->codec_variant == ALC269_TYPE_ALC269VB &&
4079 (alc_get_coef0(codec) & 0x00ff) == 0x017) {
4080 msleep(200);
4081 }
4082
4083 snd_hda_regmap_sync(codec);
4084 hda_call_check_power_status(codec, 0x01);
4085
4086 /* on some machine, the BIOS will clear the codec gpio data when enter
4087 * suspend, and won't restore the data after resume, so we restore it
4088 * in the driver.
4089 */
4090 if (spec->gpio_data)
4091 alc_write_gpio_data(codec);
4092
4093 if (spec->has_alc5505_dsp)
4094 alc5505_dsp_resume(codec);
4095
4096 return 0;
4097 }
4098
alc269_fixup_pincfg_no_hp_to_lineout(struct hda_codec * codec,const struct hda_fixup * fix,int action)4099 static void alc269_fixup_pincfg_no_hp_to_lineout(struct hda_codec *codec,
4100 const struct hda_fixup *fix, int action)
4101 {
4102 struct alc_spec *spec = codec->spec;
4103
4104 if (action == HDA_FIXUP_ACT_PRE_PROBE)
4105 spec->parse_flags = HDA_PINCFG_NO_HP_FIXUP;
4106 }
4107
alc269_fixup_pincfg_U7x7_headset_mic(struct hda_codec * codec,const struct hda_fixup * fix,int action)4108 static void alc269_fixup_pincfg_U7x7_headset_mic(struct hda_codec *codec,
4109 const struct hda_fixup *fix,
4110 int action)
4111 {
4112 unsigned int cfg_headphone = snd_hda_codec_get_pincfg(codec, 0x21);
4113 unsigned int cfg_headset_mic = snd_hda_codec_get_pincfg(codec, 0x19);
4114
4115 if (cfg_headphone && cfg_headset_mic == 0x411111f0)
4116 snd_hda_codec_set_pincfg(codec, 0x19,
4117 (cfg_headphone & ~AC_DEFCFG_DEVICE) |
4118 (AC_JACK_MIC_IN << AC_DEFCFG_DEVICE_SHIFT));
4119 }
4120
alc269_fixup_hweq(struct hda_codec * codec,const struct hda_fixup * fix,int action)4121 static void alc269_fixup_hweq(struct hda_codec *codec,
4122 const struct hda_fixup *fix, int action)
4123 {
4124 if (action == HDA_FIXUP_ACT_INIT)
4125 alc_update_coef_idx(codec, 0x1e, 0, 0x80);
4126 }
4127
alc269_fixup_headset_mic(struct hda_codec * codec,const struct hda_fixup * fix,int action)4128 static void alc269_fixup_headset_mic(struct hda_codec *codec,
4129 const struct hda_fixup *fix, int action)
4130 {
4131 struct alc_spec *spec = codec->spec;
4132
4133 if (action == HDA_FIXUP_ACT_PRE_PROBE)
4134 spec->parse_flags |= HDA_PINCFG_HEADSET_MIC;
4135 }
4136
alc271_fixup_dmic(struct hda_codec * codec,const struct hda_fixup * fix,int action)4137 static void alc271_fixup_dmic(struct hda_codec *codec,
4138 const struct hda_fixup *fix, int action)
4139 {
4140 static const struct hda_verb verbs[] = {
4141 {0x20, AC_VERB_SET_COEF_INDEX, 0x0d},
4142 {0x20, AC_VERB_SET_PROC_COEF, 0x4000},
4143 {}
4144 };
4145 unsigned int cfg;
4146
4147 if (strcmp(codec->core.chip_name, "ALC271X") &&
4148 strcmp(codec->core.chip_name, "ALC269VB"))
4149 return;
4150 cfg = snd_hda_codec_get_pincfg(codec, 0x12);
4151 if (get_defcfg_connect(cfg) == AC_JACK_PORT_FIXED)
4152 snd_hda_sequence_write(codec, verbs);
4153 }
4154
4155 /* Fix the speaker amp after resume, etc */
alc269vb_fixup_aspire_e1_coef(struct hda_codec * codec,const struct hda_fixup * fix,int action)4156 static void alc269vb_fixup_aspire_e1_coef(struct hda_codec *codec,
4157 const struct hda_fixup *fix,
4158 int action)
4159 {
4160 if (action == HDA_FIXUP_ACT_INIT)
4161 alc_update_coef_idx(codec, 0x0d, 0x6000, 0x6000);
4162 }
4163
alc269_fixup_pcm_44k(struct hda_codec * codec,const struct hda_fixup * fix,int action)4164 static void alc269_fixup_pcm_44k(struct hda_codec *codec,
4165 const struct hda_fixup *fix, int action)
4166 {
4167 struct alc_spec *spec = codec->spec;
4168
4169 if (action != HDA_FIXUP_ACT_PROBE)
4170 return;
4171
4172 /* Due to a hardware problem on Lenovo Ideadpad, we need to
4173 * fix the sample rate of analog I/O to 44.1kHz
4174 */
4175 spec->gen.stream_analog_playback = &alc269_44k_pcm_analog_playback;
4176 spec->gen.stream_analog_capture = &alc269_44k_pcm_analog_capture;
4177 }
4178
alc269_fixup_stereo_dmic(struct hda_codec * codec,const struct hda_fixup * fix,int action)4179 static void alc269_fixup_stereo_dmic(struct hda_codec *codec,
4180 const struct hda_fixup *fix, int action)
4181 {
4182 /* The digital-mic unit sends PDM (differential signal) instead of
4183 * the standard PCM, thus you can't record a valid mono stream as is.
4184 * Below is a workaround specific to ALC269 to control the dmic
4185 * signal source as mono.
4186 */
4187 if (action == HDA_FIXUP_ACT_INIT)
4188 alc_update_coef_idx(codec, 0x07, 0, 0x80);
4189 }
4190
alc269_quanta_automute(struct hda_codec * codec)4191 static void alc269_quanta_automute(struct hda_codec *codec)
4192 {
4193 snd_hda_gen_update_outputs(codec);
4194
4195 alc_write_coef_idx(codec, 0x0c, 0x680);
4196 alc_write_coef_idx(codec, 0x0c, 0x480);
4197 }
4198
alc269_fixup_quanta_mute(struct hda_codec * codec,const struct hda_fixup * fix,int action)4199 static void alc269_fixup_quanta_mute(struct hda_codec *codec,
4200 const struct hda_fixup *fix, int action)
4201 {
4202 struct alc_spec *spec = codec->spec;
4203 if (action != HDA_FIXUP_ACT_PROBE)
4204 return;
4205 spec->gen.automute_hook = alc269_quanta_automute;
4206 }
4207
alc269_x101_hp_automute_hook(struct hda_codec * codec,struct hda_jack_callback * jack)4208 static void alc269_x101_hp_automute_hook(struct hda_codec *codec,
4209 struct hda_jack_callback *jack)
4210 {
4211 struct alc_spec *spec = codec->spec;
4212 int vref;
4213 msleep(200);
4214 snd_hda_gen_hp_automute(codec, jack);
4215
4216 vref = spec->gen.hp_jack_present ? PIN_VREF80 : 0;
4217 msleep(100);
4218 snd_hda_codec_write(codec, 0x18, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
4219 vref);
4220 msleep(500);
4221 snd_hda_codec_write(codec, 0x18, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
4222 vref);
4223 }
4224
4225 /*
4226 * Magic sequence to make Huawei Matebook X right speaker working (bko#197801)
4227 */
4228 struct hda_alc298_mbxinit {
4229 unsigned char value_0x23;
4230 unsigned char value_0x25;
4231 };
4232
alc298_huawei_mbx_stereo_seq(struct hda_codec * codec,const struct hda_alc298_mbxinit * initval,bool first)4233 static void alc298_huawei_mbx_stereo_seq(struct hda_codec *codec,
4234 const struct hda_alc298_mbxinit *initval,
4235 bool first)
4236 {
4237 snd_hda_codec_write(codec, 0x06, 0, AC_VERB_SET_DIGI_CONVERT_3, 0x0);
4238 alc_write_coef_idx(codec, 0x26, 0xb000);
4239
4240 if (first)
4241 snd_hda_codec_write(codec, 0x21, 0, AC_VERB_GET_PIN_SENSE, 0x0);
4242
4243 snd_hda_codec_write(codec, 0x6, 0, AC_VERB_SET_DIGI_CONVERT_3, 0x80);
4244 alc_write_coef_idx(codec, 0x26, 0xf000);
4245 alc_write_coef_idx(codec, 0x23, initval->value_0x23);
4246
4247 if (initval->value_0x23 != 0x1e)
4248 alc_write_coef_idx(codec, 0x25, initval->value_0x25);
4249
4250 snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_COEF_INDEX, 0x26);
4251 snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_PROC_COEF, 0xb010);
4252 }
4253
alc298_fixup_huawei_mbx_stereo(struct hda_codec * codec,const struct hda_fixup * fix,int action)4254 static void alc298_fixup_huawei_mbx_stereo(struct hda_codec *codec,
4255 const struct hda_fixup *fix,
4256 int action)
4257 {
4258 /* Initialization magic */
4259 static const struct hda_alc298_mbxinit dac_init[] = {
4260 {0x0c, 0x00}, {0x0d, 0x00}, {0x0e, 0x00}, {0x0f, 0x00},
4261 {0x10, 0x00}, {0x1a, 0x40}, {0x1b, 0x82}, {0x1c, 0x00},
4262 {0x1d, 0x00}, {0x1e, 0x00}, {0x1f, 0x00},
4263 {0x20, 0xc2}, {0x21, 0xc8}, {0x22, 0x26}, {0x23, 0x24},
4264 {0x27, 0xff}, {0x28, 0xff}, {0x29, 0xff}, {0x2a, 0x8f},
4265 {0x2b, 0x02}, {0x2c, 0x48}, {0x2d, 0x34}, {0x2e, 0x00},
4266 {0x2f, 0x00},
4267 {0x30, 0x00}, {0x31, 0x00}, {0x32, 0x00}, {0x33, 0x00},
4268 {0x34, 0x00}, {0x35, 0x01}, {0x36, 0x93}, {0x37, 0x0c},
4269 {0x38, 0x00}, {0x39, 0x00}, {0x3a, 0xf8}, {0x38, 0x80},
4270 {}
4271 };
4272 const struct hda_alc298_mbxinit *seq;
4273
4274 if (action != HDA_FIXUP_ACT_INIT)
4275 return;
4276
4277 /* Start */
4278 snd_hda_codec_write(codec, 0x06, 0, AC_VERB_SET_DIGI_CONVERT_3, 0x00);
4279 snd_hda_codec_write(codec, 0x06, 0, AC_VERB_SET_DIGI_CONVERT_3, 0x80);
4280 alc_write_coef_idx(codec, 0x26, 0xf000);
4281 alc_write_coef_idx(codec, 0x22, 0x31);
4282 alc_write_coef_idx(codec, 0x23, 0x0b);
4283 alc_write_coef_idx(codec, 0x25, 0x00);
4284 snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_COEF_INDEX, 0x26);
4285 snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_PROC_COEF, 0xb010);
4286
4287 for (seq = dac_init; seq->value_0x23; seq++)
4288 alc298_huawei_mbx_stereo_seq(codec, seq, seq == dac_init);
4289 }
4290
alc269_fixup_x101_headset_mic(struct hda_codec * codec,const struct hda_fixup * fix,int action)4291 static void alc269_fixup_x101_headset_mic(struct hda_codec *codec,
4292 const struct hda_fixup *fix, int action)
4293 {
4294 struct alc_spec *spec = codec->spec;
4295 if (action == HDA_FIXUP_ACT_PRE_PROBE) {
4296 spec->parse_flags |= HDA_PINCFG_HEADSET_MIC;
4297 spec->gen.hp_automute_hook = alc269_x101_hp_automute_hook;
4298 }
4299 }
4300
alc_update_vref_led(struct hda_codec * codec,hda_nid_t pin,bool polarity,bool on)4301 static void alc_update_vref_led(struct hda_codec *codec, hda_nid_t pin,
4302 bool polarity, bool on)
4303 {
4304 unsigned int pinval;
4305
4306 if (!pin)
4307 return;
4308 if (polarity)
4309 on = !on;
4310 pinval = snd_hda_codec_get_pin_target(codec, pin);
4311 pinval &= ~AC_PINCTL_VREFEN;
4312 pinval |= on ? AC_PINCTL_VREF_80 : AC_PINCTL_VREF_HIZ;
4313 /* temporarily power up/down for setting VREF */
4314 snd_hda_power_up_pm(codec);
4315 snd_hda_set_pin_ctl_cache(codec, pin, pinval);
4316 snd_hda_power_down_pm(codec);
4317 }
4318
4319 /* update mute-LED according to the speaker mute state via mic VREF pin */
vref_mute_led_set(struct led_classdev * led_cdev,enum led_brightness brightness)4320 static int vref_mute_led_set(struct led_classdev *led_cdev,
4321 enum led_brightness brightness)
4322 {
4323 struct hda_codec *codec = dev_to_hda_codec(led_cdev->dev->parent);
4324 struct alc_spec *spec = codec->spec;
4325
4326 alc_update_vref_led(codec, spec->mute_led_nid,
4327 spec->mute_led_polarity, brightness);
4328 return 0;
4329 }
4330
4331 /* Make sure the led works even in runtime suspend */
led_power_filter(struct hda_codec * codec,hda_nid_t nid,unsigned int power_state)4332 static unsigned int led_power_filter(struct hda_codec *codec,
4333 hda_nid_t nid,
4334 unsigned int power_state)
4335 {
4336 struct alc_spec *spec = codec->spec;
4337
4338 if (power_state != AC_PWRST_D3 || nid == 0 ||
4339 (nid != spec->mute_led_nid && nid != spec->cap_mute_led_nid))
4340 return power_state;
4341
4342 /* Set pin ctl again, it might have just been set to 0 */
4343 snd_hda_set_pin_ctl(codec, nid,
4344 snd_hda_codec_get_pin_target(codec, nid));
4345
4346 return snd_hda_gen_path_power_filter(codec, nid, power_state);
4347 }
4348
alc269_fixup_hp_mute_led(struct hda_codec * codec,const struct hda_fixup * fix,int action)4349 static void alc269_fixup_hp_mute_led(struct hda_codec *codec,
4350 const struct hda_fixup *fix, int action)
4351 {
4352 struct alc_spec *spec = codec->spec;
4353 const struct dmi_device *dev = NULL;
4354
4355 if (action != HDA_FIXUP_ACT_PRE_PROBE)
4356 return;
4357
4358 while ((dev = dmi_find_device(DMI_DEV_TYPE_OEM_STRING, NULL, dev))) {
4359 int pol, pin;
4360 if (sscanf(dev->name, "HP_Mute_LED_%d_%x", &pol, &pin) != 2)
4361 continue;
4362 if (pin < 0x0a || pin >= 0x10)
4363 break;
4364 spec->mute_led_polarity = pol;
4365 spec->mute_led_nid = pin - 0x0a + 0x18;
4366 snd_hda_gen_add_mute_led_cdev(codec, vref_mute_led_set);
4367 codec->power_filter = led_power_filter;
4368 codec_dbg(codec,
4369 "Detected mute LED for %x:%d\n", spec->mute_led_nid,
4370 spec->mute_led_polarity);
4371 break;
4372 }
4373 }
4374
alc269_fixup_hp_mute_led_micx(struct hda_codec * codec,const struct hda_fixup * fix,int action,hda_nid_t pin)4375 static void alc269_fixup_hp_mute_led_micx(struct hda_codec *codec,
4376 const struct hda_fixup *fix,
4377 int action, hda_nid_t pin)
4378 {
4379 struct alc_spec *spec = codec->spec;
4380
4381 if (action == HDA_FIXUP_ACT_PRE_PROBE) {
4382 spec->mute_led_polarity = 0;
4383 spec->mute_led_nid = pin;
4384 snd_hda_gen_add_mute_led_cdev(codec, vref_mute_led_set);
4385 codec->power_filter = led_power_filter;
4386 }
4387 }
4388
alc269_fixup_hp_mute_led_mic1(struct hda_codec * codec,const struct hda_fixup * fix,int action)4389 static void alc269_fixup_hp_mute_led_mic1(struct hda_codec *codec,
4390 const struct hda_fixup *fix, int action)
4391 {
4392 alc269_fixup_hp_mute_led_micx(codec, fix, action, 0x18);
4393 }
4394
alc269_fixup_hp_mute_led_mic2(struct hda_codec * codec,const struct hda_fixup * fix,int action)4395 static void alc269_fixup_hp_mute_led_mic2(struct hda_codec *codec,
4396 const struct hda_fixup *fix, int action)
4397 {
4398 alc269_fixup_hp_mute_led_micx(codec, fix, action, 0x19);
4399 }
4400
alc269_fixup_hp_mute_led_mic3(struct hda_codec * codec,const struct hda_fixup * fix,int action)4401 static void alc269_fixup_hp_mute_led_mic3(struct hda_codec *codec,
4402 const struct hda_fixup *fix, int action)
4403 {
4404 alc269_fixup_hp_mute_led_micx(codec, fix, action, 0x1b);
4405 }
4406
4407 /* update LED status via GPIO */
alc_update_gpio_led(struct hda_codec * codec,unsigned int mask,int polarity,bool enabled)4408 static void alc_update_gpio_led(struct hda_codec *codec, unsigned int mask,
4409 int polarity, bool enabled)
4410 {
4411 if (polarity)
4412 enabled = !enabled;
4413 alc_update_gpio_data(codec, mask, !enabled); /* muted -> LED on */
4414 }
4415
4416 /* turn on/off mute LED via GPIO per vmaster hook */
gpio_mute_led_set(struct led_classdev * led_cdev,enum led_brightness brightness)4417 static int gpio_mute_led_set(struct led_classdev *led_cdev,
4418 enum led_brightness brightness)
4419 {
4420 struct hda_codec *codec = dev_to_hda_codec(led_cdev->dev->parent);
4421 struct alc_spec *spec = codec->spec;
4422
4423 alc_update_gpio_led(codec, spec->gpio_mute_led_mask,
4424 spec->mute_led_polarity, !brightness);
4425 return 0;
4426 }
4427
4428 /* turn on/off mic-mute LED via GPIO per capture hook */
micmute_led_set(struct led_classdev * led_cdev,enum led_brightness brightness)4429 static int micmute_led_set(struct led_classdev *led_cdev,
4430 enum led_brightness brightness)
4431 {
4432 struct hda_codec *codec = dev_to_hda_codec(led_cdev->dev->parent);
4433 struct alc_spec *spec = codec->spec;
4434
4435 alc_update_gpio_led(codec, spec->gpio_mic_led_mask,
4436 spec->micmute_led_polarity, !brightness);
4437 return 0;
4438 }
4439
4440 /* setup mute and mic-mute GPIO bits, add hooks appropriately */
alc_fixup_hp_gpio_led(struct hda_codec * codec,int action,unsigned int mute_mask,unsigned int micmute_mask)4441 static void alc_fixup_hp_gpio_led(struct hda_codec *codec,
4442 int action,
4443 unsigned int mute_mask,
4444 unsigned int micmute_mask)
4445 {
4446 struct alc_spec *spec = codec->spec;
4447
4448 alc_fixup_gpio(codec, action, mute_mask | micmute_mask);
4449
4450 if (action != HDA_FIXUP_ACT_PRE_PROBE)
4451 return;
4452 if (mute_mask) {
4453 spec->gpio_mute_led_mask = mute_mask;
4454 snd_hda_gen_add_mute_led_cdev(codec, gpio_mute_led_set);
4455 }
4456 if (micmute_mask) {
4457 spec->gpio_mic_led_mask = micmute_mask;
4458 snd_hda_gen_add_micmute_led_cdev(codec, micmute_led_set);
4459 }
4460 }
4461
alc236_fixup_hp_gpio_led(struct hda_codec * codec,const struct hda_fixup * fix,int action)4462 static void alc236_fixup_hp_gpio_led(struct hda_codec *codec,
4463 const struct hda_fixup *fix, int action)
4464 {
4465 alc_fixup_hp_gpio_led(codec, action, 0x02, 0x01);
4466 }
4467
alc269_fixup_hp_gpio_led(struct hda_codec * codec,const struct hda_fixup * fix,int action)4468 static void alc269_fixup_hp_gpio_led(struct hda_codec *codec,
4469 const struct hda_fixup *fix, int action)
4470 {
4471 alc_fixup_hp_gpio_led(codec, action, 0x08, 0x10);
4472 }
4473
alc285_fixup_hp_gpio_led(struct hda_codec * codec,const struct hda_fixup * fix,int action)4474 static void alc285_fixup_hp_gpio_led(struct hda_codec *codec,
4475 const struct hda_fixup *fix, int action)
4476 {
4477 alc_fixup_hp_gpio_led(codec, action, 0x04, 0x01);
4478 }
4479
alc286_fixup_hp_gpio_led(struct hda_codec * codec,const struct hda_fixup * fix,int action)4480 static void alc286_fixup_hp_gpio_led(struct hda_codec *codec,
4481 const struct hda_fixup *fix, int action)
4482 {
4483 alc_fixup_hp_gpio_led(codec, action, 0x02, 0x20);
4484 }
4485
alc287_fixup_hp_gpio_led(struct hda_codec * codec,const struct hda_fixup * fix,int action)4486 static void alc287_fixup_hp_gpio_led(struct hda_codec *codec,
4487 const struct hda_fixup *fix, int action)
4488 {
4489 alc_fixup_hp_gpio_led(codec, action, 0x10, 0);
4490 }
4491
alc245_fixup_hp_gpio_led(struct hda_codec * codec,const struct hda_fixup * fix,int action)4492 static void alc245_fixup_hp_gpio_led(struct hda_codec *codec,
4493 const struct hda_fixup *fix, int action)
4494 {
4495 struct alc_spec *spec = codec->spec;
4496
4497 if (action == HDA_FIXUP_ACT_PRE_PROBE)
4498 spec->micmute_led_polarity = 1;
4499 alc_fixup_hp_gpio_led(codec, action, 0, 0x04);
4500 }
4501
4502 /* turn on/off mic-mute LED per capture hook via VREF change */
vref_micmute_led_set(struct led_classdev * led_cdev,enum led_brightness brightness)4503 static int vref_micmute_led_set(struct led_classdev *led_cdev,
4504 enum led_brightness brightness)
4505 {
4506 struct hda_codec *codec = dev_to_hda_codec(led_cdev->dev->parent);
4507 struct alc_spec *spec = codec->spec;
4508
4509 alc_update_vref_led(codec, spec->cap_mute_led_nid,
4510 spec->micmute_led_polarity, brightness);
4511 return 0;
4512 }
4513
alc269_fixup_hp_gpio_mic1_led(struct hda_codec * codec,const struct hda_fixup * fix,int action)4514 static void alc269_fixup_hp_gpio_mic1_led(struct hda_codec *codec,
4515 const struct hda_fixup *fix, int action)
4516 {
4517 struct alc_spec *spec = codec->spec;
4518
4519 alc_fixup_hp_gpio_led(codec, action, 0x08, 0);
4520 if (action == HDA_FIXUP_ACT_PRE_PROBE) {
4521 /* Like hp_gpio_mic1_led, but also needs GPIO4 low to
4522 * enable headphone amp
4523 */
4524 spec->gpio_mask |= 0x10;
4525 spec->gpio_dir |= 0x10;
4526 spec->cap_mute_led_nid = 0x18;
4527 snd_hda_gen_add_micmute_led_cdev(codec, vref_micmute_led_set);
4528 codec->power_filter = led_power_filter;
4529 }
4530 }
4531
alc280_fixup_hp_gpio4(struct hda_codec * codec,const struct hda_fixup * fix,int action)4532 static void alc280_fixup_hp_gpio4(struct hda_codec *codec,
4533 const struct hda_fixup *fix, int action)
4534 {
4535 struct alc_spec *spec = codec->spec;
4536
4537 alc_fixup_hp_gpio_led(codec, action, 0x08, 0);
4538 if (action == HDA_FIXUP_ACT_PRE_PROBE) {
4539 spec->cap_mute_led_nid = 0x18;
4540 snd_hda_gen_add_micmute_led_cdev(codec, vref_micmute_led_set);
4541 codec->power_filter = led_power_filter;
4542 }
4543 }
4544
4545 /* HP Spectre x360 14 model needs a unique workaround for enabling the amp;
4546 * it needs to toggle the GPIO0 once on and off at each time (bko#210633)
4547 */
alc245_fixup_hp_x360_amp(struct hda_codec * codec,const struct hda_fixup * fix,int action)4548 static void alc245_fixup_hp_x360_amp(struct hda_codec *codec,
4549 const struct hda_fixup *fix, int action)
4550 {
4551 struct alc_spec *spec = codec->spec;
4552
4553 switch (action) {
4554 case HDA_FIXUP_ACT_PRE_PROBE:
4555 spec->gpio_mask |= 0x01;
4556 spec->gpio_dir |= 0x01;
4557 break;
4558 case HDA_FIXUP_ACT_INIT:
4559 /* need to toggle GPIO to enable the amp */
4560 alc_update_gpio_data(codec, 0x01, true);
4561 msleep(100);
4562 alc_update_gpio_data(codec, 0x01, false);
4563 break;
4564 }
4565 }
4566
4567 /* toggle GPIO2 at each time stream is started; we use PREPARE state instead */
alc274_hp_envy_pcm_hook(struct hda_pcm_stream * hinfo,struct hda_codec * codec,struct snd_pcm_substream * substream,int action)4568 static void alc274_hp_envy_pcm_hook(struct hda_pcm_stream *hinfo,
4569 struct hda_codec *codec,
4570 struct snd_pcm_substream *substream,
4571 int action)
4572 {
4573 switch (action) {
4574 case HDA_GEN_PCM_ACT_PREPARE:
4575 alc_update_gpio_data(codec, 0x04, true);
4576 break;
4577 case HDA_GEN_PCM_ACT_CLEANUP:
4578 alc_update_gpio_data(codec, 0x04, false);
4579 break;
4580 }
4581 }
4582
alc274_fixup_hp_envy_gpio(struct hda_codec * codec,const struct hda_fixup * fix,int action)4583 static void alc274_fixup_hp_envy_gpio(struct hda_codec *codec,
4584 const struct hda_fixup *fix,
4585 int action)
4586 {
4587 struct alc_spec *spec = codec->spec;
4588
4589 if (action == HDA_FIXUP_ACT_PROBE) {
4590 spec->gpio_mask |= 0x04;
4591 spec->gpio_dir |= 0x04;
4592 spec->gen.pcm_playback_hook = alc274_hp_envy_pcm_hook;
4593 }
4594 }
4595
alc_update_coef_led(struct hda_codec * codec,struct alc_coef_led * led,bool polarity,bool on)4596 static void alc_update_coef_led(struct hda_codec *codec,
4597 struct alc_coef_led *led,
4598 bool polarity, bool on)
4599 {
4600 if (polarity)
4601 on = !on;
4602 /* temporarily power up/down for setting COEF bit */
4603 alc_update_coef_idx(codec, led->idx, led->mask,
4604 on ? led->on : led->off);
4605 }
4606
4607 /* update mute-LED according to the speaker mute state via COEF bit */
coef_mute_led_set(struct led_classdev * led_cdev,enum led_brightness brightness)4608 static int coef_mute_led_set(struct led_classdev *led_cdev,
4609 enum led_brightness brightness)
4610 {
4611 struct hda_codec *codec = dev_to_hda_codec(led_cdev->dev->parent);
4612 struct alc_spec *spec = codec->spec;
4613
4614 alc_update_coef_led(codec, &spec->mute_led_coef,
4615 spec->mute_led_polarity, brightness);
4616 return 0;
4617 }
4618
alc285_fixup_hp_mute_led_coefbit(struct hda_codec * codec,const struct hda_fixup * fix,int action)4619 static void alc285_fixup_hp_mute_led_coefbit(struct hda_codec *codec,
4620 const struct hda_fixup *fix,
4621 int action)
4622 {
4623 struct alc_spec *spec = codec->spec;
4624
4625 if (action == HDA_FIXUP_ACT_PRE_PROBE) {
4626 spec->mute_led_polarity = 0;
4627 spec->mute_led_coef.idx = 0x0b;
4628 spec->mute_led_coef.mask = 1 << 3;
4629 spec->mute_led_coef.on = 1 << 3;
4630 spec->mute_led_coef.off = 0;
4631 snd_hda_gen_add_mute_led_cdev(codec, coef_mute_led_set);
4632 }
4633 }
4634
alc236_fixup_hp_mute_led_coefbit(struct hda_codec * codec,const struct hda_fixup * fix,int action)4635 static void alc236_fixup_hp_mute_led_coefbit(struct hda_codec *codec,
4636 const struct hda_fixup *fix,
4637 int action)
4638 {
4639 struct alc_spec *spec = codec->spec;
4640
4641 if (action == HDA_FIXUP_ACT_PRE_PROBE) {
4642 spec->mute_led_polarity = 0;
4643 spec->mute_led_coef.idx = 0x34;
4644 spec->mute_led_coef.mask = 1 << 5;
4645 spec->mute_led_coef.on = 0;
4646 spec->mute_led_coef.off = 1 << 5;
4647 snd_hda_gen_add_mute_led_cdev(codec, coef_mute_led_set);
4648 }
4649 }
4650
alc236_fixup_hp_mute_led_coefbit2(struct hda_codec * codec,const struct hda_fixup * fix,int action)4651 static void alc236_fixup_hp_mute_led_coefbit2(struct hda_codec *codec,
4652 const struct hda_fixup *fix, int action)
4653 {
4654 struct alc_spec *spec = codec->spec;
4655
4656 if (action == HDA_FIXUP_ACT_PRE_PROBE) {
4657 spec->mute_led_polarity = 0;
4658 spec->mute_led_coef.idx = 0x07;
4659 spec->mute_led_coef.mask = 1;
4660 spec->mute_led_coef.on = 1;
4661 spec->mute_led_coef.off = 0;
4662 snd_hda_gen_add_mute_led_cdev(codec, coef_mute_led_set);
4663 }
4664 }
4665
alc245_fixup_hp_mute_led_coefbit(struct hda_codec * codec,const struct hda_fixup * fix,int action)4666 static void alc245_fixup_hp_mute_led_coefbit(struct hda_codec *codec,
4667 const struct hda_fixup *fix,
4668 int action)
4669 {
4670 struct alc_spec *spec = codec->spec;
4671
4672 if (action == HDA_FIXUP_ACT_PRE_PROBE) {
4673 spec->mute_led_polarity = 0;
4674 spec->mute_led_coef.idx = 0x0b;
4675 spec->mute_led_coef.mask = 3 << 2;
4676 spec->mute_led_coef.on = 2 << 2;
4677 spec->mute_led_coef.off = 1 << 2;
4678 snd_hda_gen_add_mute_led_cdev(codec, coef_mute_led_set);
4679 }
4680 }
4681
4682 /* turn on/off mic-mute LED per capture hook by coef bit */
coef_micmute_led_set(struct led_classdev * led_cdev,enum led_brightness brightness)4683 static int coef_micmute_led_set(struct led_classdev *led_cdev,
4684 enum led_brightness brightness)
4685 {
4686 struct hda_codec *codec = dev_to_hda_codec(led_cdev->dev->parent);
4687 struct alc_spec *spec = codec->spec;
4688
4689 alc_update_coef_led(codec, &spec->mic_led_coef,
4690 spec->micmute_led_polarity, brightness);
4691 return 0;
4692 }
4693
alc285_fixup_hp_coef_micmute_led(struct hda_codec * codec,const struct hda_fixup * fix,int action)4694 static void alc285_fixup_hp_coef_micmute_led(struct hda_codec *codec,
4695 const struct hda_fixup *fix, int action)
4696 {
4697 struct alc_spec *spec = codec->spec;
4698
4699 if (action == HDA_FIXUP_ACT_PRE_PROBE) {
4700 spec->mic_led_coef.idx = 0x19;
4701 spec->mic_led_coef.mask = 1 << 13;
4702 spec->mic_led_coef.on = 1 << 13;
4703 spec->mic_led_coef.off = 0;
4704 snd_hda_gen_add_micmute_led_cdev(codec, coef_micmute_led_set);
4705 }
4706 }
4707
alc285_fixup_hp_gpio_micmute_led(struct hda_codec * codec,const struct hda_fixup * fix,int action)4708 static void alc285_fixup_hp_gpio_micmute_led(struct hda_codec *codec,
4709 const struct hda_fixup *fix, int action)
4710 {
4711 struct alc_spec *spec = codec->spec;
4712
4713 if (action == HDA_FIXUP_ACT_PRE_PROBE)
4714 spec->micmute_led_polarity = 1;
4715 alc_fixup_hp_gpio_led(codec, action, 0, 0x04);
4716 }
4717
alc236_fixup_hp_coef_micmute_led(struct hda_codec * codec,const struct hda_fixup * fix,int action)4718 static void alc236_fixup_hp_coef_micmute_led(struct hda_codec *codec,
4719 const struct hda_fixup *fix, int action)
4720 {
4721 struct alc_spec *spec = codec->spec;
4722
4723 if (action == HDA_FIXUP_ACT_PRE_PROBE) {
4724 spec->mic_led_coef.idx = 0x35;
4725 spec->mic_led_coef.mask = 3 << 2;
4726 spec->mic_led_coef.on = 2 << 2;
4727 spec->mic_led_coef.off = 1 << 2;
4728 snd_hda_gen_add_micmute_led_cdev(codec, coef_micmute_led_set);
4729 }
4730 }
4731
alc285_fixup_hp_mute_led(struct hda_codec * codec,const struct hda_fixup * fix,int action)4732 static void alc285_fixup_hp_mute_led(struct hda_codec *codec,
4733 const struct hda_fixup *fix, int action)
4734 {
4735 alc285_fixup_hp_mute_led_coefbit(codec, fix, action);
4736 alc285_fixup_hp_coef_micmute_led(codec, fix, action);
4737 }
4738
alc285_fixup_hp_spectre_x360_mute_led(struct hda_codec * codec,const struct hda_fixup * fix,int action)4739 static void alc285_fixup_hp_spectre_x360_mute_led(struct hda_codec *codec,
4740 const struct hda_fixup *fix, int action)
4741 {
4742 alc285_fixup_hp_mute_led_coefbit(codec, fix, action);
4743 alc285_fixup_hp_gpio_micmute_led(codec, fix, action);
4744 }
4745
alc236_fixup_hp_mute_led(struct hda_codec * codec,const struct hda_fixup * fix,int action)4746 static void alc236_fixup_hp_mute_led(struct hda_codec *codec,
4747 const struct hda_fixup *fix, int action)
4748 {
4749 alc236_fixup_hp_mute_led_coefbit(codec, fix, action);
4750 alc236_fixup_hp_coef_micmute_led(codec, fix, action);
4751 }
4752
alc236_fixup_hp_micmute_led_vref(struct hda_codec * codec,const struct hda_fixup * fix,int action)4753 static void alc236_fixup_hp_micmute_led_vref(struct hda_codec *codec,
4754 const struct hda_fixup *fix, int action)
4755 {
4756 struct alc_spec *spec = codec->spec;
4757
4758 if (action == HDA_FIXUP_ACT_PRE_PROBE) {
4759 spec->cap_mute_led_nid = 0x1a;
4760 snd_hda_gen_add_micmute_led_cdev(codec, vref_micmute_led_set);
4761 codec->power_filter = led_power_filter;
4762 }
4763 }
4764
alc236_fixup_hp_mute_led_micmute_vref(struct hda_codec * codec,const struct hda_fixup * fix,int action)4765 static void alc236_fixup_hp_mute_led_micmute_vref(struct hda_codec *codec,
4766 const struct hda_fixup *fix, int action)
4767 {
4768 alc236_fixup_hp_mute_led_coefbit(codec, fix, action);
4769 alc236_fixup_hp_micmute_led_vref(codec, fix, action);
4770 }
4771
alc298_samsung_write_coef_pack(struct hda_codec * codec,const unsigned short coefs[2])4772 static inline void alc298_samsung_write_coef_pack(struct hda_codec *codec,
4773 const unsigned short coefs[2])
4774 {
4775 alc_write_coef_idx(codec, 0x23, coefs[0]);
4776 alc_write_coef_idx(codec, 0x25, coefs[1]);
4777 alc_write_coef_idx(codec, 0x26, 0xb011);
4778 }
4779
4780 struct alc298_samsung_amp_desc {
4781 unsigned char nid;
4782 unsigned short init_seq[2][2];
4783 };
4784
alc298_fixup_samsung_amp(struct hda_codec * codec,const struct hda_fixup * fix,int action)4785 static void alc298_fixup_samsung_amp(struct hda_codec *codec,
4786 const struct hda_fixup *fix, int action)
4787 {
4788 int i, j;
4789 static const unsigned short init_seq[][2] = {
4790 { 0x19, 0x00 }, { 0x20, 0xc0 }, { 0x22, 0x44 }, { 0x23, 0x08 },
4791 { 0x24, 0x85 }, { 0x25, 0x41 }, { 0x35, 0x40 }, { 0x36, 0x01 },
4792 { 0x38, 0x81 }, { 0x3a, 0x03 }, { 0x3b, 0x81 }, { 0x40, 0x3e },
4793 { 0x41, 0x07 }, { 0x400, 0x1 }
4794 };
4795 static const struct alc298_samsung_amp_desc amps[] = {
4796 { 0x3a, { { 0x18, 0x1 }, { 0x26, 0x0 } } },
4797 { 0x39, { { 0x18, 0x2 }, { 0x26, 0x1 } } }
4798 };
4799
4800 if (action != HDA_FIXUP_ACT_INIT)
4801 return;
4802
4803 for (i = 0; i < ARRAY_SIZE(amps); i++) {
4804 alc_write_coef_idx(codec, 0x22, amps[i].nid);
4805
4806 for (j = 0; j < ARRAY_SIZE(amps[i].init_seq); j++)
4807 alc298_samsung_write_coef_pack(codec, amps[i].init_seq[j]);
4808
4809 for (j = 0; j < ARRAY_SIZE(init_seq); j++)
4810 alc298_samsung_write_coef_pack(codec, init_seq[j]);
4811 }
4812 }
4813
4814 struct alc298_samsung_v2_amp_desc {
4815 unsigned short nid;
4816 int init_seq_size;
4817 unsigned short init_seq[18][2];
4818 };
4819
4820 static const struct alc298_samsung_v2_amp_desc
4821 alc298_samsung_v2_amp_desc_tbl[] = {
4822 { 0x38, 18, {
4823 { 0x23e1, 0x0000 }, { 0x2012, 0x006f }, { 0x2014, 0x0000 },
4824 { 0x201b, 0x0001 }, { 0x201d, 0x0001 }, { 0x201f, 0x00fe },
4825 { 0x2021, 0x0000 }, { 0x2022, 0x0010 }, { 0x203d, 0x0005 },
4826 { 0x203f, 0x0003 }, { 0x2050, 0x002c }, { 0x2076, 0x000e },
4827 { 0x207c, 0x004a }, { 0x2081, 0x0003 }, { 0x2399, 0x0003 },
4828 { 0x23a4, 0x00b5 }, { 0x23a5, 0x0001 }, { 0x23ba, 0x0094 }
4829 }},
4830 { 0x39, 18, {
4831 { 0x23e1, 0x0000 }, { 0x2012, 0x006f }, { 0x2014, 0x0000 },
4832 { 0x201b, 0x0002 }, { 0x201d, 0x0002 }, { 0x201f, 0x00fd },
4833 { 0x2021, 0x0001 }, { 0x2022, 0x0010 }, { 0x203d, 0x0005 },
4834 { 0x203f, 0x0003 }, { 0x2050, 0x002c }, { 0x2076, 0x000e },
4835 { 0x207c, 0x004a }, { 0x2081, 0x0003 }, { 0x2399, 0x0003 },
4836 { 0x23a4, 0x00b5 }, { 0x23a5, 0x0001 }, { 0x23ba, 0x0094 }
4837 }},
4838 { 0x3c, 15, {
4839 { 0x23e1, 0x0000 }, { 0x2012, 0x006f }, { 0x2014, 0x0000 },
4840 { 0x201b, 0x0001 }, { 0x201d, 0x0001 }, { 0x201f, 0x00fe },
4841 { 0x2021, 0x0000 }, { 0x2022, 0x0010 }, { 0x203d, 0x0005 },
4842 { 0x203f, 0x0003 }, { 0x2050, 0x002c }, { 0x2076, 0x000e },
4843 { 0x207c, 0x004a }, { 0x2081, 0x0003 }, { 0x23ba, 0x008d }
4844 }},
4845 { 0x3d, 15, {
4846 { 0x23e1, 0x0000 }, { 0x2012, 0x006f }, { 0x2014, 0x0000 },
4847 { 0x201b, 0x0002 }, { 0x201d, 0x0002 }, { 0x201f, 0x00fd },
4848 { 0x2021, 0x0001 }, { 0x2022, 0x0010 }, { 0x203d, 0x0005 },
4849 { 0x203f, 0x0003 }, { 0x2050, 0x002c }, { 0x2076, 0x000e },
4850 { 0x207c, 0x004a }, { 0x2081, 0x0003 }, { 0x23ba, 0x008d }
4851 }}
4852 };
4853
alc298_samsung_v2_enable_amps(struct hda_codec * codec)4854 static void alc298_samsung_v2_enable_amps(struct hda_codec *codec)
4855 {
4856 struct alc_spec *spec = codec->spec;
4857 static const unsigned short enable_seq[][2] = {
4858 { 0x203a, 0x0081 }, { 0x23ff, 0x0001 },
4859 };
4860 int i, j;
4861
4862 for (i = 0; i < spec->num_speaker_amps; i++) {
4863 alc_write_coef_idx(codec, 0x22, alc298_samsung_v2_amp_desc_tbl[i].nid);
4864 for (j = 0; j < ARRAY_SIZE(enable_seq); j++)
4865 alc298_samsung_write_coef_pack(codec, enable_seq[j]);
4866 codec_dbg(codec, "alc298_samsung_v2: Enabled speaker amp 0x%02x\n",
4867 alc298_samsung_v2_amp_desc_tbl[i].nid);
4868 }
4869 }
4870
alc298_samsung_v2_disable_amps(struct hda_codec * codec)4871 static void alc298_samsung_v2_disable_amps(struct hda_codec *codec)
4872 {
4873 struct alc_spec *spec = codec->spec;
4874 static const unsigned short disable_seq[][2] = {
4875 { 0x23ff, 0x0000 }, { 0x203a, 0x0080 },
4876 };
4877 int i, j;
4878
4879 for (i = 0; i < spec->num_speaker_amps; i++) {
4880 alc_write_coef_idx(codec, 0x22, alc298_samsung_v2_amp_desc_tbl[i].nid);
4881 for (j = 0; j < ARRAY_SIZE(disable_seq); j++)
4882 alc298_samsung_write_coef_pack(codec, disable_seq[j]);
4883 codec_dbg(codec, "alc298_samsung_v2: Disabled speaker amp 0x%02x\n",
4884 alc298_samsung_v2_amp_desc_tbl[i].nid);
4885 }
4886 }
4887
alc298_samsung_v2_playback_hook(struct hda_pcm_stream * hinfo,struct hda_codec * codec,struct snd_pcm_substream * substream,int action)4888 static void alc298_samsung_v2_playback_hook(struct hda_pcm_stream *hinfo,
4889 struct hda_codec *codec,
4890 struct snd_pcm_substream *substream,
4891 int action)
4892 {
4893 /* Dynamically enable/disable speaker amps before and after playback */
4894 if (action == HDA_GEN_PCM_ACT_OPEN)
4895 alc298_samsung_v2_enable_amps(codec);
4896 if (action == HDA_GEN_PCM_ACT_CLOSE)
4897 alc298_samsung_v2_disable_amps(codec);
4898 }
4899
alc298_samsung_v2_init_amps(struct hda_codec * codec,int num_speaker_amps)4900 static void alc298_samsung_v2_init_amps(struct hda_codec *codec,
4901 int num_speaker_amps)
4902 {
4903 struct alc_spec *spec = codec->spec;
4904 int i, j;
4905
4906 /* Set spec's num_speaker_amps before doing anything else */
4907 spec->num_speaker_amps = num_speaker_amps;
4908
4909 /* Disable speaker amps before init to prevent any physical damage */
4910 alc298_samsung_v2_disable_amps(codec);
4911
4912 /* Initialize the speaker amps */
4913 for (i = 0; i < spec->num_speaker_amps; i++) {
4914 alc_write_coef_idx(codec, 0x22, alc298_samsung_v2_amp_desc_tbl[i].nid);
4915 for (j = 0; j < alc298_samsung_v2_amp_desc_tbl[i].init_seq_size; j++) {
4916 alc298_samsung_write_coef_pack(codec,
4917 alc298_samsung_v2_amp_desc_tbl[i].init_seq[j]);
4918 }
4919 alc_write_coef_idx(codec, 0x89, 0x0);
4920 codec_dbg(codec, "alc298_samsung_v2: Initialized speaker amp 0x%02x\n",
4921 alc298_samsung_v2_amp_desc_tbl[i].nid);
4922 }
4923
4924 /* register hook to enable speaker amps only when they are needed */
4925 spec->gen.pcm_playback_hook = alc298_samsung_v2_playback_hook;
4926 }
4927
alc298_fixup_samsung_amp_v2_2_amps(struct hda_codec * codec,const struct hda_fixup * fix,int action)4928 static void alc298_fixup_samsung_amp_v2_2_amps(struct hda_codec *codec,
4929 const struct hda_fixup *fix, int action)
4930 {
4931 if (action == HDA_FIXUP_ACT_PROBE)
4932 alc298_samsung_v2_init_amps(codec, 2);
4933 }
4934
alc298_fixup_samsung_amp_v2_4_amps(struct hda_codec * codec,const struct hda_fixup * fix,int action)4935 static void alc298_fixup_samsung_amp_v2_4_amps(struct hda_codec *codec,
4936 const struct hda_fixup *fix, int action)
4937 {
4938 if (action == HDA_FIXUP_ACT_PROBE)
4939 alc298_samsung_v2_init_amps(codec, 4);
4940 }
4941
4942 #if IS_REACHABLE(CONFIG_INPUT)
gpio2_mic_hotkey_event(struct hda_codec * codec,struct hda_jack_callback * event)4943 static void gpio2_mic_hotkey_event(struct hda_codec *codec,
4944 struct hda_jack_callback *event)
4945 {
4946 struct alc_spec *spec = codec->spec;
4947
4948 /* GPIO2 just toggles on a keypress/keyrelease cycle. Therefore
4949 send both key on and key off event for every interrupt. */
4950 input_report_key(spec->kb_dev, spec->alc_mute_keycode_map[ALC_KEY_MICMUTE_INDEX], 1);
4951 input_sync(spec->kb_dev);
4952 input_report_key(spec->kb_dev, spec->alc_mute_keycode_map[ALC_KEY_MICMUTE_INDEX], 0);
4953 input_sync(spec->kb_dev);
4954 }
4955
alc_register_micmute_input_device(struct hda_codec * codec)4956 static int alc_register_micmute_input_device(struct hda_codec *codec)
4957 {
4958 struct alc_spec *spec = codec->spec;
4959 int i;
4960
4961 spec->kb_dev = input_allocate_device();
4962 if (!spec->kb_dev) {
4963 codec_err(codec, "Out of memory (input_allocate_device)\n");
4964 return -ENOMEM;
4965 }
4966
4967 spec->alc_mute_keycode_map[ALC_KEY_MICMUTE_INDEX] = KEY_MICMUTE;
4968
4969 spec->kb_dev->name = "Microphone Mute Button";
4970 spec->kb_dev->evbit[0] = BIT_MASK(EV_KEY);
4971 spec->kb_dev->keycodesize = sizeof(spec->alc_mute_keycode_map[0]);
4972 spec->kb_dev->keycodemax = ARRAY_SIZE(spec->alc_mute_keycode_map);
4973 spec->kb_dev->keycode = spec->alc_mute_keycode_map;
4974 for (i = 0; i < ARRAY_SIZE(spec->alc_mute_keycode_map); i++)
4975 set_bit(spec->alc_mute_keycode_map[i], spec->kb_dev->keybit);
4976
4977 if (input_register_device(spec->kb_dev)) {
4978 codec_err(codec, "input_register_device failed\n");
4979 input_free_device(spec->kb_dev);
4980 spec->kb_dev = NULL;
4981 return -ENOMEM;
4982 }
4983
4984 return 0;
4985 }
4986
4987 /* GPIO1 = set according to SKU external amp
4988 * GPIO2 = mic mute hotkey
4989 * GPIO3 = mute LED
4990 * GPIO4 = mic mute LED
4991 */
alc280_fixup_hp_gpio2_mic_hotkey(struct hda_codec * codec,const struct hda_fixup * fix,int action)4992 static void alc280_fixup_hp_gpio2_mic_hotkey(struct hda_codec *codec,
4993 const struct hda_fixup *fix, int action)
4994 {
4995 struct alc_spec *spec = codec->spec;
4996
4997 alc_fixup_hp_gpio_led(codec, action, 0x08, 0x10);
4998 if (action == HDA_FIXUP_ACT_PRE_PROBE) {
4999 spec->init_amp = ALC_INIT_DEFAULT;
5000 if (alc_register_micmute_input_device(codec) != 0)
5001 return;
5002
5003 spec->gpio_mask |= 0x06;
5004 spec->gpio_dir |= 0x02;
5005 spec->gpio_data |= 0x02;
5006 snd_hda_codec_write_cache(codec, codec->core.afg, 0,
5007 AC_VERB_SET_GPIO_UNSOLICITED_RSP_MASK, 0x04);
5008 snd_hda_jack_detect_enable_callback(codec, codec->core.afg,
5009 gpio2_mic_hotkey_event);
5010 return;
5011 }
5012
5013 if (!spec->kb_dev)
5014 return;
5015
5016 switch (action) {
5017 case HDA_FIXUP_ACT_FREE:
5018 input_unregister_device(spec->kb_dev);
5019 spec->kb_dev = NULL;
5020 }
5021 }
5022
5023 /* Line2 = mic mute hotkey
5024 * GPIO2 = mic mute LED
5025 */
alc233_fixup_lenovo_line2_mic_hotkey(struct hda_codec * codec,const struct hda_fixup * fix,int action)5026 static void alc233_fixup_lenovo_line2_mic_hotkey(struct hda_codec *codec,
5027 const struct hda_fixup *fix, int action)
5028 {
5029 struct alc_spec *spec = codec->spec;
5030
5031 alc_fixup_hp_gpio_led(codec, action, 0, 0x04);
5032 if (action == HDA_FIXUP_ACT_PRE_PROBE) {
5033 spec->init_amp = ALC_INIT_DEFAULT;
5034 if (alc_register_micmute_input_device(codec) != 0)
5035 return;
5036
5037 snd_hda_jack_detect_enable_callback(codec, 0x1b,
5038 gpio2_mic_hotkey_event);
5039 return;
5040 }
5041
5042 if (!spec->kb_dev)
5043 return;
5044
5045 switch (action) {
5046 case HDA_FIXUP_ACT_FREE:
5047 input_unregister_device(spec->kb_dev);
5048 spec->kb_dev = NULL;
5049 }
5050 }
5051 #else /* INPUT */
5052 #define alc280_fixup_hp_gpio2_mic_hotkey NULL
5053 #define alc233_fixup_lenovo_line2_mic_hotkey NULL
5054 #endif /* INPUT */
5055
alc269_fixup_hp_line1_mic1_led(struct hda_codec * codec,const struct hda_fixup * fix,int action)5056 static void alc269_fixup_hp_line1_mic1_led(struct hda_codec *codec,
5057 const struct hda_fixup *fix, int action)
5058 {
5059 struct alc_spec *spec = codec->spec;
5060
5061 alc269_fixup_hp_mute_led_micx(codec, fix, action, 0x1a);
5062 if (action == HDA_FIXUP_ACT_PRE_PROBE) {
5063 spec->cap_mute_led_nid = 0x18;
5064 snd_hda_gen_add_micmute_led_cdev(codec, vref_micmute_led_set);
5065 }
5066 }
5067
alc_hp_mute_disable(struct hda_codec * codec,unsigned int delay)5068 static void alc_hp_mute_disable(struct hda_codec *codec, unsigned int delay)
5069 {
5070 if (delay <= 0)
5071 delay = 75;
5072 snd_hda_codec_write(codec, 0x21, 0,
5073 AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);
5074 msleep(delay);
5075 snd_hda_codec_write(codec, 0x21, 0,
5076 AC_VERB_SET_PIN_WIDGET_CONTROL, 0x0);
5077 msleep(delay);
5078 }
5079
alc_hp_enable_unmute(struct hda_codec * codec,unsigned int delay)5080 static void alc_hp_enable_unmute(struct hda_codec *codec, unsigned int delay)
5081 {
5082 if (delay <= 0)
5083 delay = 75;
5084 snd_hda_codec_write(codec, 0x21, 0,
5085 AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT);
5086 msleep(delay);
5087 snd_hda_codec_write(codec, 0x21, 0,
5088 AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE);
5089 msleep(delay);
5090 }
5091
5092 static const struct coef_fw alc225_pre_hsmode[] = {
5093 UPDATE_COEF(0x4a, 1<<8, 0),
5094 UPDATE_COEFEX(0x57, 0x05, 1<<14, 0),
5095 UPDATE_COEF(0x63, 3<<14, 3<<14),
5096 UPDATE_COEF(0x4a, 3<<4, 2<<4),
5097 UPDATE_COEF(0x4a, 3<<10, 3<<10),
5098 UPDATE_COEF(0x45, 0x3f<<10, 0x34<<10),
5099 UPDATE_COEF(0x4a, 3<<10, 0),
5100 {}
5101 };
5102
alc_headset_mode_unplugged(struct hda_codec * codec)5103 static void alc_headset_mode_unplugged(struct hda_codec *codec)
5104 {
5105 struct alc_spec *spec = codec->spec;
5106 static const struct coef_fw coef0255[] = {
5107 WRITE_COEF(0x1b, 0x0c0b), /* LDO and MISC control */
5108 WRITE_COEF(0x45, 0xd089), /* UAJ function set to menual mode */
5109 UPDATE_COEFEX(0x57, 0x05, 1<<14, 0), /* Direct Drive HP Amp control(Set to verb control)*/
5110 WRITE_COEF(0x06, 0x6104), /* Set MIC2 Vref gate with HP */
5111 WRITE_COEFEX(0x57, 0x03, 0x8aa6), /* Direct Drive HP Amp control */
5112 {}
5113 };
5114 static const struct coef_fw coef0256[] = {
5115 WRITE_COEF(0x1b, 0x0c4b), /* LDO and MISC control */
5116 WRITE_COEF(0x45, 0xd089), /* UAJ function set to menual mode */
5117 WRITE_COEF(0x06, 0x6104), /* Set MIC2 Vref gate with HP */
5118 WRITE_COEFEX(0x57, 0x03, 0x09a3), /* Direct Drive HP Amp control */
5119 UPDATE_COEFEX(0x57, 0x05, 1<<14, 0), /* Direct Drive HP Amp control(Set to verb control)*/
5120 {}
5121 };
5122 static const struct coef_fw coef0233[] = {
5123 WRITE_COEF(0x1b, 0x0c0b),
5124 WRITE_COEF(0x45, 0xc429),
5125 UPDATE_COEF(0x35, 0x4000, 0),
5126 WRITE_COEF(0x06, 0x2104),
5127 WRITE_COEF(0x1a, 0x0001),
5128 WRITE_COEF(0x26, 0x0004),
5129 WRITE_COEF(0x32, 0x42a3),
5130 {}
5131 };
5132 static const struct coef_fw coef0288[] = {
5133 UPDATE_COEF(0x4f, 0xfcc0, 0xc400),
5134 UPDATE_COEF(0x50, 0x2000, 0x2000),
5135 UPDATE_COEF(0x56, 0x0006, 0x0006),
5136 UPDATE_COEF(0x66, 0x0008, 0),
5137 UPDATE_COEF(0x67, 0x2000, 0),
5138 {}
5139 };
5140 static const struct coef_fw coef0298[] = {
5141 UPDATE_COEF(0x19, 0x1300, 0x0300),
5142 {}
5143 };
5144 static const struct coef_fw coef0292[] = {
5145 WRITE_COEF(0x76, 0x000e),
5146 WRITE_COEF(0x6c, 0x2400),
5147 WRITE_COEF(0x18, 0x7308),
5148 WRITE_COEF(0x6b, 0xc429),
5149 {}
5150 };
5151 static const struct coef_fw coef0293[] = {
5152 UPDATE_COEF(0x10, 7<<8, 6<<8), /* SET Line1 JD to 0 */
5153 UPDATE_COEFEX(0x57, 0x05, 1<<15|1<<13, 0x0), /* SET charge pump by verb */
5154 UPDATE_COEFEX(0x57, 0x03, 1<<10, 1<<10), /* SET EN_OSW to 1 */
5155 UPDATE_COEF(0x1a, 1<<3, 1<<3), /* Combo JD gating with LINE1-VREFO */
5156 WRITE_COEF(0x45, 0xc429), /* Set to TRS type */
5157 UPDATE_COEF(0x4a, 0x000f, 0x000e), /* Combo Jack auto detect */
5158 {}
5159 };
5160 static const struct coef_fw coef0668[] = {
5161 WRITE_COEF(0x15, 0x0d40),
5162 WRITE_COEF(0xb7, 0x802b),
5163 {}
5164 };
5165 static const struct coef_fw coef0225[] = {
5166 UPDATE_COEF(0x63, 3<<14, 0),
5167 {}
5168 };
5169 static const struct coef_fw coef0274[] = {
5170 UPDATE_COEF(0x4a, 0x0100, 0),
5171 UPDATE_COEFEX(0x57, 0x05, 0x4000, 0),
5172 UPDATE_COEF(0x6b, 0xf000, 0x5000),
5173 UPDATE_COEF(0x4a, 0x0010, 0),
5174 UPDATE_COEF(0x4a, 0x0c00, 0x0c00),
5175 WRITE_COEF(0x45, 0x5289),
5176 UPDATE_COEF(0x4a, 0x0c00, 0),
5177 {}
5178 };
5179
5180 if (spec->no_internal_mic_pin) {
5181 alc_update_coef_idx(codec, 0x45, 0xf<<12 | 1<<10, 5<<12);
5182 return;
5183 }
5184
5185 switch (codec->core.vendor_id) {
5186 case 0x10ec0255:
5187 alc_process_coef_fw(codec, coef0255);
5188 break;
5189 case 0x10ec0230:
5190 case 0x10ec0236:
5191 case 0x10ec0256:
5192 case 0x19e58326:
5193 alc_hp_mute_disable(codec, 75);
5194 alc_process_coef_fw(codec, coef0256);
5195 break;
5196 case 0x10ec0234:
5197 case 0x10ec0274:
5198 case 0x10ec0294:
5199 alc_process_coef_fw(codec, coef0274);
5200 break;
5201 case 0x10ec0233:
5202 case 0x10ec0283:
5203 alc_process_coef_fw(codec, coef0233);
5204 break;
5205 case 0x10ec0286:
5206 case 0x10ec0288:
5207 alc_process_coef_fw(codec, coef0288);
5208 break;
5209 case 0x10ec0298:
5210 alc_process_coef_fw(codec, coef0298);
5211 alc_process_coef_fw(codec, coef0288);
5212 break;
5213 case 0x10ec0292:
5214 alc_process_coef_fw(codec, coef0292);
5215 break;
5216 case 0x10ec0293:
5217 alc_process_coef_fw(codec, coef0293);
5218 break;
5219 case 0x10ec0668:
5220 alc_process_coef_fw(codec, coef0668);
5221 break;
5222 case 0x10ec0215:
5223 case 0x10ec0225:
5224 case 0x10ec0285:
5225 case 0x10ec0295:
5226 case 0x10ec0289:
5227 case 0x10ec0299:
5228 alc_hp_mute_disable(codec, 75);
5229 alc_process_coef_fw(codec, alc225_pre_hsmode);
5230 alc_process_coef_fw(codec, coef0225);
5231 break;
5232 case 0x10ec0867:
5233 alc_update_coefex_idx(codec, 0x57, 0x5, 1<<14, 0);
5234 break;
5235 }
5236 codec_dbg(codec, "Headset jack set to unplugged mode.\n");
5237 }
5238
5239
alc_headset_mode_mic_in(struct hda_codec * codec,hda_nid_t hp_pin,hda_nid_t mic_pin)5240 static void alc_headset_mode_mic_in(struct hda_codec *codec, hda_nid_t hp_pin,
5241 hda_nid_t mic_pin)
5242 {
5243 static const struct coef_fw coef0255[] = {
5244 WRITE_COEFEX(0x57, 0x03, 0x8aa6),
5245 WRITE_COEF(0x06, 0x6100), /* Set MIC2 Vref gate to normal */
5246 {}
5247 };
5248 static const struct coef_fw coef0256[] = {
5249 UPDATE_COEFEX(0x57, 0x05, 1<<14, 1<<14), /* Direct Drive HP Amp control(Set to verb control)*/
5250 WRITE_COEFEX(0x57, 0x03, 0x09a3),
5251 WRITE_COEF(0x06, 0x6100), /* Set MIC2 Vref gate to normal */
5252 {}
5253 };
5254 static const struct coef_fw coef0233[] = {
5255 UPDATE_COEF(0x35, 0, 1<<14),
5256 WRITE_COEF(0x06, 0x2100),
5257 WRITE_COEF(0x1a, 0x0021),
5258 WRITE_COEF(0x26, 0x008c),
5259 {}
5260 };
5261 static const struct coef_fw coef0288[] = {
5262 UPDATE_COEF(0x4f, 0x00c0, 0),
5263 UPDATE_COEF(0x50, 0x2000, 0),
5264 UPDATE_COEF(0x56, 0x0006, 0),
5265 UPDATE_COEF(0x4f, 0xfcc0, 0xc400),
5266 UPDATE_COEF(0x66, 0x0008, 0x0008),
5267 UPDATE_COEF(0x67, 0x2000, 0x2000),
5268 {}
5269 };
5270 static const struct coef_fw coef0292[] = {
5271 WRITE_COEF(0x19, 0xa208),
5272 WRITE_COEF(0x2e, 0xacf0),
5273 {}
5274 };
5275 static const struct coef_fw coef0293[] = {
5276 UPDATE_COEFEX(0x57, 0x05, 0, 1<<15|1<<13), /* SET charge pump by verb */
5277 UPDATE_COEFEX(0x57, 0x03, 1<<10, 0), /* SET EN_OSW to 0 */
5278 UPDATE_COEF(0x1a, 1<<3, 0), /* Combo JD gating without LINE1-VREFO */
5279 {}
5280 };
5281 static const struct coef_fw coef0688[] = {
5282 WRITE_COEF(0xb7, 0x802b),
5283 WRITE_COEF(0xb5, 0x1040),
5284 UPDATE_COEF(0xc3, 0, 1<<12),
5285 {}
5286 };
5287 static const struct coef_fw coef0225[] = {
5288 UPDATE_COEFEX(0x57, 0x05, 1<<14, 1<<14),
5289 UPDATE_COEF(0x4a, 3<<4, 2<<4),
5290 UPDATE_COEF(0x63, 3<<14, 0),
5291 {}
5292 };
5293 static const struct coef_fw coef0274[] = {
5294 UPDATE_COEFEX(0x57, 0x05, 0x4000, 0x4000),
5295 UPDATE_COEF(0x4a, 0x0010, 0),
5296 UPDATE_COEF(0x6b, 0xf000, 0),
5297 {}
5298 };
5299
5300 switch (codec->core.vendor_id) {
5301 case 0x10ec0255:
5302 alc_write_coef_idx(codec, 0x45, 0xc489);
5303 snd_hda_set_pin_ctl_cache(codec, hp_pin, 0);
5304 alc_process_coef_fw(codec, coef0255);
5305 snd_hda_set_pin_ctl_cache(codec, mic_pin, PIN_VREF50);
5306 break;
5307 case 0x10ec0230:
5308 case 0x10ec0236:
5309 case 0x10ec0256:
5310 case 0x19e58326:
5311 alc_write_coef_idx(codec, 0x45, 0xc489);
5312 snd_hda_set_pin_ctl_cache(codec, hp_pin, 0);
5313 alc_process_coef_fw(codec, coef0256);
5314 snd_hda_set_pin_ctl_cache(codec, mic_pin, PIN_VREF50);
5315 break;
5316 case 0x10ec0234:
5317 case 0x10ec0274:
5318 case 0x10ec0294:
5319 alc_write_coef_idx(codec, 0x45, 0x4689);
5320 snd_hda_set_pin_ctl_cache(codec, hp_pin, 0);
5321 alc_process_coef_fw(codec, coef0274);
5322 snd_hda_set_pin_ctl_cache(codec, mic_pin, PIN_VREF50);
5323 break;
5324 case 0x10ec0233:
5325 case 0x10ec0283:
5326 alc_write_coef_idx(codec, 0x45, 0xc429);
5327 snd_hda_set_pin_ctl_cache(codec, hp_pin, 0);
5328 alc_process_coef_fw(codec, coef0233);
5329 snd_hda_set_pin_ctl_cache(codec, mic_pin, PIN_VREF50);
5330 break;
5331 case 0x10ec0286:
5332 case 0x10ec0288:
5333 case 0x10ec0298:
5334 snd_hda_set_pin_ctl_cache(codec, hp_pin, 0);
5335 alc_process_coef_fw(codec, coef0288);
5336 snd_hda_set_pin_ctl_cache(codec, mic_pin, PIN_VREF50);
5337 break;
5338 case 0x10ec0292:
5339 snd_hda_set_pin_ctl_cache(codec, hp_pin, 0);
5340 alc_process_coef_fw(codec, coef0292);
5341 break;
5342 case 0x10ec0293:
5343 /* Set to TRS mode */
5344 alc_write_coef_idx(codec, 0x45, 0xc429);
5345 snd_hda_set_pin_ctl_cache(codec, hp_pin, 0);
5346 alc_process_coef_fw(codec, coef0293);
5347 snd_hda_set_pin_ctl_cache(codec, mic_pin, PIN_VREF50);
5348 break;
5349 case 0x10ec0867:
5350 alc_update_coefex_idx(codec, 0x57, 0x5, 0, 1<<14);
5351 fallthrough;
5352 case 0x10ec0221:
5353 case 0x10ec0662:
5354 snd_hda_set_pin_ctl_cache(codec, hp_pin, 0);
5355 snd_hda_set_pin_ctl_cache(codec, mic_pin, PIN_VREF50);
5356 break;
5357 case 0x10ec0668:
5358 alc_write_coef_idx(codec, 0x11, 0x0001);
5359 snd_hda_set_pin_ctl_cache(codec, hp_pin, 0);
5360 alc_process_coef_fw(codec, coef0688);
5361 snd_hda_set_pin_ctl_cache(codec, mic_pin, PIN_VREF50);
5362 break;
5363 case 0x10ec0215:
5364 case 0x10ec0225:
5365 case 0x10ec0285:
5366 case 0x10ec0295:
5367 case 0x10ec0289:
5368 case 0x10ec0299:
5369 alc_process_coef_fw(codec, alc225_pre_hsmode);
5370 alc_update_coef_idx(codec, 0x45, 0x3f<<10, 0x31<<10);
5371 snd_hda_set_pin_ctl_cache(codec, hp_pin, 0);
5372 alc_process_coef_fw(codec, coef0225);
5373 snd_hda_set_pin_ctl_cache(codec, mic_pin, PIN_VREF50);
5374 break;
5375 }
5376 codec_dbg(codec, "Headset jack set to mic-in mode.\n");
5377 }
5378
alc_headset_mode_default(struct hda_codec * codec)5379 static void alc_headset_mode_default(struct hda_codec *codec)
5380 {
5381 static const struct coef_fw coef0225[] = {
5382 UPDATE_COEF(0x45, 0x3f<<10, 0x30<<10),
5383 UPDATE_COEF(0x45, 0x3f<<10, 0x31<<10),
5384 UPDATE_COEF(0x49, 3<<8, 0<<8),
5385 UPDATE_COEF(0x4a, 3<<4, 3<<4),
5386 UPDATE_COEF(0x63, 3<<14, 0),
5387 UPDATE_COEF(0x67, 0xf000, 0x3000),
5388 {}
5389 };
5390 static const struct coef_fw coef0255[] = {
5391 WRITE_COEF(0x45, 0xc089),
5392 WRITE_COEF(0x45, 0xc489),
5393 WRITE_COEFEX(0x57, 0x03, 0x8ea6),
5394 WRITE_COEF(0x49, 0x0049),
5395 {}
5396 };
5397 static const struct coef_fw coef0256[] = {
5398 WRITE_COEF(0x45, 0xc489),
5399 WRITE_COEFEX(0x57, 0x03, 0x0da3),
5400 WRITE_COEF(0x49, 0x0049),
5401 UPDATE_COEFEX(0x57, 0x05, 1<<14, 0), /* Direct Drive HP Amp control(Set to verb control)*/
5402 WRITE_COEF(0x06, 0x6100),
5403 {}
5404 };
5405 static const struct coef_fw coef0233[] = {
5406 WRITE_COEF(0x06, 0x2100),
5407 WRITE_COEF(0x32, 0x4ea3),
5408 {}
5409 };
5410 static const struct coef_fw coef0288[] = {
5411 UPDATE_COEF(0x4f, 0xfcc0, 0xc400), /* Set to TRS type */
5412 UPDATE_COEF(0x50, 0x2000, 0x2000),
5413 UPDATE_COEF(0x56, 0x0006, 0x0006),
5414 UPDATE_COEF(0x66, 0x0008, 0),
5415 UPDATE_COEF(0x67, 0x2000, 0),
5416 {}
5417 };
5418 static const struct coef_fw coef0292[] = {
5419 WRITE_COEF(0x76, 0x000e),
5420 WRITE_COEF(0x6c, 0x2400),
5421 WRITE_COEF(0x6b, 0xc429),
5422 WRITE_COEF(0x18, 0x7308),
5423 {}
5424 };
5425 static const struct coef_fw coef0293[] = {
5426 UPDATE_COEF(0x4a, 0x000f, 0x000e), /* Combo Jack auto detect */
5427 WRITE_COEF(0x45, 0xC429), /* Set to TRS type */
5428 UPDATE_COEF(0x1a, 1<<3, 0), /* Combo JD gating without LINE1-VREFO */
5429 {}
5430 };
5431 static const struct coef_fw coef0688[] = {
5432 WRITE_COEF(0x11, 0x0041),
5433 WRITE_COEF(0x15, 0x0d40),
5434 WRITE_COEF(0xb7, 0x802b),
5435 {}
5436 };
5437 static const struct coef_fw coef0274[] = {
5438 WRITE_COEF(0x45, 0x4289),
5439 UPDATE_COEF(0x4a, 0x0010, 0x0010),
5440 UPDATE_COEF(0x6b, 0x0f00, 0),
5441 UPDATE_COEF(0x49, 0x0300, 0x0300),
5442 {}
5443 };
5444
5445 switch (codec->core.vendor_id) {
5446 case 0x10ec0215:
5447 case 0x10ec0225:
5448 case 0x10ec0285:
5449 case 0x10ec0295:
5450 case 0x10ec0289:
5451 case 0x10ec0299:
5452 alc_process_coef_fw(codec, alc225_pre_hsmode);
5453 alc_process_coef_fw(codec, coef0225);
5454 alc_hp_enable_unmute(codec, 75);
5455 break;
5456 case 0x10ec0255:
5457 alc_process_coef_fw(codec, coef0255);
5458 break;
5459 case 0x10ec0230:
5460 case 0x10ec0236:
5461 case 0x10ec0256:
5462 case 0x19e58326:
5463 alc_write_coef_idx(codec, 0x1b, 0x0e4b);
5464 alc_write_coef_idx(codec, 0x45, 0xc089);
5465 msleep(50);
5466 alc_process_coef_fw(codec, coef0256);
5467 alc_hp_enable_unmute(codec, 75);
5468 break;
5469 case 0x10ec0234:
5470 case 0x10ec0274:
5471 case 0x10ec0294:
5472 alc_process_coef_fw(codec, coef0274);
5473 break;
5474 case 0x10ec0233:
5475 case 0x10ec0283:
5476 alc_process_coef_fw(codec, coef0233);
5477 break;
5478 case 0x10ec0286:
5479 case 0x10ec0288:
5480 case 0x10ec0298:
5481 alc_process_coef_fw(codec, coef0288);
5482 break;
5483 case 0x10ec0292:
5484 alc_process_coef_fw(codec, coef0292);
5485 break;
5486 case 0x10ec0293:
5487 alc_process_coef_fw(codec, coef0293);
5488 break;
5489 case 0x10ec0668:
5490 alc_process_coef_fw(codec, coef0688);
5491 break;
5492 case 0x10ec0867:
5493 alc_update_coefex_idx(codec, 0x57, 0x5, 1<<14, 0);
5494 break;
5495 }
5496 codec_dbg(codec, "Headset jack set to headphone (default) mode.\n");
5497 }
5498
5499 /* Iphone type */
alc_headset_mode_ctia(struct hda_codec * codec)5500 static void alc_headset_mode_ctia(struct hda_codec *codec)
5501 {
5502 int val;
5503
5504 static const struct coef_fw coef0255[] = {
5505 WRITE_COEF(0x45, 0xd489), /* Set to CTIA type */
5506 WRITE_COEF(0x1b, 0x0c2b),
5507 WRITE_COEFEX(0x57, 0x03, 0x8ea6),
5508 {}
5509 };
5510 static const struct coef_fw coef0256[] = {
5511 WRITE_COEF(0x45, 0xd489), /* Set to CTIA type */
5512 WRITE_COEF(0x1b, 0x0e6b),
5513 {}
5514 };
5515 static const struct coef_fw coef0233[] = {
5516 WRITE_COEF(0x45, 0xd429),
5517 WRITE_COEF(0x1b, 0x0c2b),
5518 WRITE_COEF(0x32, 0x4ea3),
5519 {}
5520 };
5521 static const struct coef_fw coef0288[] = {
5522 UPDATE_COEF(0x50, 0x2000, 0x2000),
5523 UPDATE_COEF(0x56, 0x0006, 0x0006),
5524 UPDATE_COEF(0x66, 0x0008, 0),
5525 UPDATE_COEF(0x67, 0x2000, 0),
5526 {}
5527 };
5528 static const struct coef_fw coef0292[] = {
5529 WRITE_COEF(0x6b, 0xd429),
5530 WRITE_COEF(0x76, 0x0008),
5531 WRITE_COEF(0x18, 0x7388),
5532 {}
5533 };
5534 static const struct coef_fw coef0293[] = {
5535 WRITE_COEF(0x45, 0xd429), /* Set to ctia type */
5536 UPDATE_COEF(0x10, 7<<8, 7<<8), /* SET Line1 JD to 1 */
5537 {}
5538 };
5539 static const struct coef_fw coef0688[] = {
5540 WRITE_COEF(0x11, 0x0001),
5541 WRITE_COEF(0x15, 0x0d60),
5542 WRITE_COEF(0xc3, 0x0000),
5543 {}
5544 };
5545 static const struct coef_fw coef0225_1[] = {
5546 UPDATE_COEF(0x45, 0x3f<<10, 0x35<<10),
5547 UPDATE_COEF(0x63, 3<<14, 2<<14),
5548 {}
5549 };
5550 static const struct coef_fw coef0225_2[] = {
5551 UPDATE_COEF(0x45, 0x3f<<10, 0x35<<10),
5552 UPDATE_COEF(0x63, 3<<14, 1<<14),
5553 {}
5554 };
5555
5556 switch (codec->core.vendor_id) {
5557 case 0x10ec0255:
5558 alc_process_coef_fw(codec, coef0255);
5559 break;
5560 case 0x10ec0230:
5561 case 0x10ec0236:
5562 case 0x10ec0256:
5563 case 0x19e58326:
5564 alc_process_coef_fw(codec, coef0256);
5565 alc_hp_enable_unmute(codec, 75);
5566 break;
5567 case 0x10ec0234:
5568 case 0x10ec0274:
5569 case 0x10ec0294:
5570 alc_write_coef_idx(codec, 0x45, 0xd689);
5571 break;
5572 case 0x10ec0233:
5573 case 0x10ec0283:
5574 alc_process_coef_fw(codec, coef0233);
5575 break;
5576 case 0x10ec0298:
5577 val = alc_read_coef_idx(codec, 0x50);
5578 if (val & (1 << 12)) {
5579 alc_update_coef_idx(codec, 0x8e, 0x0070, 0x0020);
5580 alc_update_coef_idx(codec, 0x4f, 0xfcc0, 0xd400);
5581 msleep(300);
5582 } else {
5583 alc_update_coef_idx(codec, 0x8e, 0x0070, 0x0010);
5584 alc_update_coef_idx(codec, 0x4f, 0xfcc0, 0xd400);
5585 msleep(300);
5586 }
5587 break;
5588 case 0x10ec0286:
5589 case 0x10ec0288:
5590 alc_update_coef_idx(codec, 0x4f, 0xfcc0, 0xd400);
5591 msleep(300);
5592 alc_process_coef_fw(codec, coef0288);
5593 break;
5594 case 0x10ec0292:
5595 alc_process_coef_fw(codec, coef0292);
5596 break;
5597 case 0x10ec0293:
5598 alc_process_coef_fw(codec, coef0293);
5599 break;
5600 case 0x10ec0668:
5601 alc_process_coef_fw(codec, coef0688);
5602 break;
5603 case 0x10ec0215:
5604 case 0x10ec0225:
5605 case 0x10ec0285:
5606 case 0x10ec0295:
5607 case 0x10ec0289:
5608 case 0x10ec0299:
5609 val = alc_read_coef_idx(codec, 0x45);
5610 if (val & (1 << 9))
5611 alc_process_coef_fw(codec, coef0225_2);
5612 else
5613 alc_process_coef_fw(codec, coef0225_1);
5614 alc_hp_enable_unmute(codec, 75);
5615 break;
5616 case 0x10ec0867:
5617 alc_update_coefex_idx(codec, 0x57, 0x5, 1<<14, 0);
5618 break;
5619 }
5620 codec_dbg(codec, "Headset jack set to iPhone-style headset mode.\n");
5621 }
5622
5623 /* Nokia type */
alc_headset_mode_omtp(struct hda_codec * codec)5624 static void alc_headset_mode_omtp(struct hda_codec *codec)
5625 {
5626 static const struct coef_fw coef0255[] = {
5627 WRITE_COEF(0x45, 0xe489), /* Set to OMTP Type */
5628 WRITE_COEF(0x1b, 0x0c2b),
5629 WRITE_COEFEX(0x57, 0x03, 0x8ea6),
5630 {}
5631 };
5632 static const struct coef_fw coef0256[] = {
5633 WRITE_COEF(0x45, 0xe489), /* Set to OMTP Type */
5634 WRITE_COEF(0x1b, 0x0e6b),
5635 {}
5636 };
5637 static const struct coef_fw coef0233[] = {
5638 WRITE_COEF(0x45, 0xe429),
5639 WRITE_COEF(0x1b, 0x0c2b),
5640 WRITE_COEF(0x32, 0x4ea3),
5641 {}
5642 };
5643 static const struct coef_fw coef0288[] = {
5644 UPDATE_COEF(0x50, 0x2000, 0x2000),
5645 UPDATE_COEF(0x56, 0x0006, 0x0006),
5646 UPDATE_COEF(0x66, 0x0008, 0),
5647 UPDATE_COEF(0x67, 0x2000, 0),
5648 {}
5649 };
5650 static const struct coef_fw coef0292[] = {
5651 WRITE_COEF(0x6b, 0xe429),
5652 WRITE_COEF(0x76, 0x0008),
5653 WRITE_COEF(0x18, 0x7388),
5654 {}
5655 };
5656 static const struct coef_fw coef0293[] = {
5657 WRITE_COEF(0x45, 0xe429), /* Set to omtp type */
5658 UPDATE_COEF(0x10, 7<<8, 7<<8), /* SET Line1 JD to 1 */
5659 {}
5660 };
5661 static const struct coef_fw coef0688[] = {
5662 WRITE_COEF(0x11, 0x0001),
5663 WRITE_COEF(0x15, 0x0d50),
5664 WRITE_COEF(0xc3, 0x0000),
5665 {}
5666 };
5667 static const struct coef_fw coef0225[] = {
5668 UPDATE_COEF(0x45, 0x3f<<10, 0x39<<10),
5669 UPDATE_COEF(0x63, 3<<14, 2<<14),
5670 {}
5671 };
5672
5673 switch (codec->core.vendor_id) {
5674 case 0x10ec0255:
5675 alc_process_coef_fw(codec, coef0255);
5676 break;
5677 case 0x10ec0230:
5678 case 0x10ec0236:
5679 case 0x10ec0256:
5680 case 0x19e58326:
5681 alc_process_coef_fw(codec, coef0256);
5682 alc_hp_enable_unmute(codec, 75);
5683 break;
5684 case 0x10ec0234:
5685 case 0x10ec0274:
5686 case 0x10ec0294:
5687 alc_write_coef_idx(codec, 0x45, 0xe689);
5688 break;
5689 case 0x10ec0233:
5690 case 0x10ec0283:
5691 alc_process_coef_fw(codec, coef0233);
5692 break;
5693 case 0x10ec0298:
5694 alc_update_coef_idx(codec, 0x8e, 0x0070, 0x0010);/* Headset output enable */
5695 alc_update_coef_idx(codec, 0x4f, 0xfcc0, 0xe400);
5696 msleep(300);
5697 break;
5698 case 0x10ec0286:
5699 case 0x10ec0288:
5700 alc_update_coef_idx(codec, 0x4f, 0xfcc0, 0xe400);
5701 msleep(300);
5702 alc_process_coef_fw(codec, coef0288);
5703 break;
5704 case 0x10ec0292:
5705 alc_process_coef_fw(codec, coef0292);
5706 break;
5707 case 0x10ec0293:
5708 alc_process_coef_fw(codec, coef0293);
5709 break;
5710 case 0x10ec0668:
5711 alc_process_coef_fw(codec, coef0688);
5712 break;
5713 case 0x10ec0215:
5714 case 0x10ec0225:
5715 case 0x10ec0285:
5716 case 0x10ec0295:
5717 case 0x10ec0289:
5718 case 0x10ec0299:
5719 alc_process_coef_fw(codec, coef0225);
5720 alc_hp_enable_unmute(codec, 75);
5721 break;
5722 }
5723 codec_dbg(codec, "Headset jack set to Nokia-style headset mode.\n");
5724 }
5725
alc_determine_headset_type(struct hda_codec * codec)5726 static void alc_determine_headset_type(struct hda_codec *codec)
5727 {
5728 int val;
5729 bool is_ctia = false;
5730 struct alc_spec *spec = codec->spec;
5731 static const struct coef_fw coef0255[] = {
5732 WRITE_COEF(0x45, 0xd089), /* combo jack auto switch control(Check type)*/
5733 WRITE_COEF(0x49, 0x0149), /* combo jack auto switch control(Vref
5734 conteol) */
5735 {}
5736 };
5737 static const struct coef_fw coef0288[] = {
5738 UPDATE_COEF(0x4f, 0xfcc0, 0xd400), /* Check Type */
5739 {}
5740 };
5741 static const struct coef_fw coef0298[] = {
5742 UPDATE_COEF(0x50, 0x2000, 0x2000),
5743 UPDATE_COEF(0x56, 0x0006, 0x0006),
5744 UPDATE_COEF(0x66, 0x0008, 0),
5745 UPDATE_COEF(0x67, 0x2000, 0),
5746 UPDATE_COEF(0x19, 0x1300, 0x1300),
5747 {}
5748 };
5749 static const struct coef_fw coef0293[] = {
5750 UPDATE_COEF(0x4a, 0x000f, 0x0008), /* Combo Jack auto detect */
5751 WRITE_COEF(0x45, 0xD429), /* Set to ctia type */
5752 {}
5753 };
5754 static const struct coef_fw coef0688[] = {
5755 WRITE_COEF(0x11, 0x0001),
5756 WRITE_COEF(0xb7, 0x802b),
5757 WRITE_COEF(0x15, 0x0d60),
5758 WRITE_COEF(0xc3, 0x0c00),
5759 {}
5760 };
5761 static const struct coef_fw coef0274[] = {
5762 UPDATE_COEF(0x4a, 0x0010, 0),
5763 UPDATE_COEF(0x4a, 0x8000, 0),
5764 WRITE_COEF(0x45, 0xd289),
5765 UPDATE_COEF(0x49, 0x0300, 0x0300),
5766 {}
5767 };
5768
5769 if (spec->no_internal_mic_pin) {
5770 alc_update_coef_idx(codec, 0x45, 0xf<<12 | 1<<10, 5<<12);
5771 return;
5772 }
5773
5774 switch (codec->core.vendor_id) {
5775 case 0x10ec0255:
5776 alc_process_coef_fw(codec, coef0255);
5777 msleep(300);
5778 val = alc_read_coef_idx(codec, 0x46);
5779 is_ctia = (val & 0x0070) == 0x0070;
5780 break;
5781 case 0x10ec0230:
5782 case 0x10ec0236:
5783 case 0x10ec0256:
5784 case 0x19e58326:
5785 alc_write_coef_idx(codec, 0x1b, 0x0e4b);
5786 alc_write_coef_idx(codec, 0x06, 0x6104);
5787 alc_write_coefex_idx(codec, 0x57, 0x3, 0x09a3);
5788
5789 alc_process_coef_fw(codec, coef0255);
5790 msleep(300);
5791 val = alc_read_coef_idx(codec, 0x46);
5792 is_ctia = (val & 0x0070) == 0x0070;
5793 if (!is_ctia) {
5794 alc_write_coef_idx(codec, 0x45, 0xe089);
5795 msleep(100);
5796 val = alc_read_coef_idx(codec, 0x46);
5797 if ((val & 0x0070) == 0x0070)
5798 is_ctia = false;
5799 else
5800 is_ctia = true;
5801 }
5802 alc_write_coefex_idx(codec, 0x57, 0x3, 0x0da3);
5803 alc_update_coefex_idx(codec, 0x57, 0x5, 1<<14, 0);
5804 break;
5805 case 0x10ec0234:
5806 case 0x10ec0274:
5807 case 0x10ec0294:
5808 alc_process_coef_fw(codec, coef0274);
5809 msleep(850);
5810 val = alc_read_coef_idx(codec, 0x46);
5811 is_ctia = (val & 0x00f0) == 0x00f0;
5812 break;
5813 case 0x10ec0233:
5814 case 0x10ec0283:
5815 alc_write_coef_idx(codec, 0x45, 0xd029);
5816 msleep(300);
5817 val = alc_read_coef_idx(codec, 0x46);
5818 is_ctia = (val & 0x0070) == 0x0070;
5819 break;
5820 case 0x10ec0298:
5821 snd_hda_codec_write(codec, 0x21, 0,
5822 AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);
5823 msleep(100);
5824 snd_hda_codec_write(codec, 0x21, 0,
5825 AC_VERB_SET_PIN_WIDGET_CONTROL, 0x0);
5826 msleep(200);
5827
5828 val = alc_read_coef_idx(codec, 0x50);
5829 if (val & (1 << 12)) {
5830 alc_update_coef_idx(codec, 0x8e, 0x0070, 0x0020);
5831 alc_process_coef_fw(codec, coef0288);
5832 msleep(350);
5833 val = alc_read_coef_idx(codec, 0x50);
5834 is_ctia = (val & 0x0070) == 0x0070;
5835 } else {
5836 alc_update_coef_idx(codec, 0x8e, 0x0070, 0x0010);
5837 alc_process_coef_fw(codec, coef0288);
5838 msleep(350);
5839 val = alc_read_coef_idx(codec, 0x50);
5840 is_ctia = (val & 0x0070) == 0x0070;
5841 }
5842 alc_process_coef_fw(codec, coef0298);
5843 snd_hda_codec_write(codec, 0x21, 0,
5844 AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP);
5845 msleep(75);
5846 snd_hda_codec_write(codec, 0x21, 0,
5847 AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE);
5848 break;
5849 case 0x10ec0286:
5850 case 0x10ec0288:
5851 alc_process_coef_fw(codec, coef0288);
5852 msleep(350);
5853 val = alc_read_coef_idx(codec, 0x50);
5854 is_ctia = (val & 0x0070) == 0x0070;
5855 break;
5856 case 0x10ec0292:
5857 alc_write_coef_idx(codec, 0x6b, 0xd429);
5858 msleep(300);
5859 val = alc_read_coef_idx(codec, 0x6c);
5860 is_ctia = (val & 0x001c) == 0x001c;
5861 break;
5862 case 0x10ec0293:
5863 alc_process_coef_fw(codec, coef0293);
5864 msleep(300);
5865 val = alc_read_coef_idx(codec, 0x46);
5866 is_ctia = (val & 0x0070) == 0x0070;
5867 break;
5868 case 0x10ec0668:
5869 alc_process_coef_fw(codec, coef0688);
5870 msleep(300);
5871 val = alc_read_coef_idx(codec, 0xbe);
5872 is_ctia = (val & 0x1c02) == 0x1c02;
5873 break;
5874 case 0x10ec0215:
5875 case 0x10ec0225:
5876 case 0x10ec0285:
5877 case 0x10ec0295:
5878 case 0x10ec0289:
5879 case 0x10ec0299:
5880 alc_process_coef_fw(codec, alc225_pre_hsmode);
5881 alc_update_coef_idx(codec, 0x67, 0xf000, 0x1000);
5882 val = alc_read_coef_idx(codec, 0x45);
5883 if (val & (1 << 9)) {
5884 alc_update_coef_idx(codec, 0x45, 0x3f<<10, 0x34<<10);
5885 alc_update_coef_idx(codec, 0x49, 3<<8, 2<<8);
5886 msleep(800);
5887 val = alc_read_coef_idx(codec, 0x46);
5888 is_ctia = (val & 0x00f0) == 0x00f0;
5889 } else {
5890 alc_update_coef_idx(codec, 0x45, 0x3f<<10, 0x34<<10);
5891 alc_update_coef_idx(codec, 0x49, 3<<8, 1<<8);
5892 msleep(800);
5893 val = alc_read_coef_idx(codec, 0x46);
5894 is_ctia = (val & 0x00f0) == 0x00f0;
5895 }
5896 if (!is_ctia) {
5897 alc_update_coef_idx(codec, 0x45, 0x3f<<10, 0x38<<10);
5898 alc_update_coef_idx(codec, 0x49, 3<<8, 1<<8);
5899 msleep(100);
5900 val = alc_read_coef_idx(codec, 0x46);
5901 if ((val & 0x00f0) == 0x00f0)
5902 is_ctia = false;
5903 else
5904 is_ctia = true;
5905 }
5906 alc_update_coef_idx(codec, 0x4a, 7<<6, 7<<6);
5907 alc_update_coef_idx(codec, 0x4a, 3<<4, 3<<4);
5908 alc_update_coef_idx(codec, 0x67, 0xf000, 0x3000);
5909 break;
5910 case 0x10ec0867:
5911 is_ctia = true;
5912 break;
5913 }
5914
5915 codec_dbg(codec, "Headset jack detected iPhone-style headset: %s\n",
5916 is_ctia ? "yes" : "no");
5917 spec->current_headset_type = is_ctia ? ALC_HEADSET_TYPE_CTIA : ALC_HEADSET_TYPE_OMTP;
5918 }
5919
alc_update_headset_mode(struct hda_codec * codec)5920 static void alc_update_headset_mode(struct hda_codec *codec)
5921 {
5922 struct alc_spec *spec = codec->spec;
5923
5924 hda_nid_t mux_pin = spec->gen.imux_pins[spec->gen.cur_mux[0]];
5925 hda_nid_t hp_pin = alc_get_hp_pin(spec);
5926
5927 int new_headset_mode;
5928
5929 if (!snd_hda_jack_detect(codec, hp_pin))
5930 new_headset_mode = ALC_HEADSET_MODE_UNPLUGGED;
5931 else if (mux_pin == spec->headset_mic_pin)
5932 new_headset_mode = ALC_HEADSET_MODE_HEADSET;
5933 else if (mux_pin == spec->headphone_mic_pin)
5934 new_headset_mode = ALC_HEADSET_MODE_MIC;
5935 else
5936 new_headset_mode = ALC_HEADSET_MODE_HEADPHONE;
5937
5938 if (new_headset_mode == spec->current_headset_mode) {
5939 snd_hda_gen_update_outputs(codec);
5940 return;
5941 }
5942
5943 switch (new_headset_mode) {
5944 case ALC_HEADSET_MODE_UNPLUGGED:
5945 alc_headset_mode_unplugged(codec);
5946 spec->current_headset_mode = ALC_HEADSET_MODE_UNKNOWN;
5947 spec->current_headset_type = ALC_HEADSET_TYPE_UNKNOWN;
5948 spec->gen.hp_jack_present = false;
5949 break;
5950 case ALC_HEADSET_MODE_HEADSET:
5951 if (spec->current_headset_type == ALC_HEADSET_TYPE_UNKNOWN)
5952 alc_determine_headset_type(codec);
5953 if (spec->current_headset_type == ALC_HEADSET_TYPE_CTIA)
5954 alc_headset_mode_ctia(codec);
5955 else if (spec->current_headset_type == ALC_HEADSET_TYPE_OMTP)
5956 alc_headset_mode_omtp(codec);
5957 spec->gen.hp_jack_present = true;
5958 break;
5959 case ALC_HEADSET_MODE_MIC:
5960 alc_headset_mode_mic_in(codec, hp_pin, spec->headphone_mic_pin);
5961 spec->gen.hp_jack_present = false;
5962 break;
5963 case ALC_HEADSET_MODE_HEADPHONE:
5964 alc_headset_mode_default(codec);
5965 spec->gen.hp_jack_present = true;
5966 break;
5967 }
5968 if (new_headset_mode != ALC_HEADSET_MODE_MIC) {
5969 snd_hda_set_pin_ctl_cache(codec, hp_pin,
5970 AC_PINCTL_OUT_EN | AC_PINCTL_HP_EN);
5971 if (spec->headphone_mic_pin && spec->headphone_mic_pin != hp_pin)
5972 snd_hda_set_pin_ctl_cache(codec, spec->headphone_mic_pin,
5973 PIN_VREFHIZ);
5974 }
5975 spec->current_headset_mode = new_headset_mode;
5976
5977 snd_hda_gen_update_outputs(codec);
5978 }
5979
alc_update_headset_mode_hook(struct hda_codec * codec,struct snd_kcontrol * kcontrol,struct snd_ctl_elem_value * ucontrol)5980 static void alc_update_headset_mode_hook(struct hda_codec *codec,
5981 struct snd_kcontrol *kcontrol,
5982 struct snd_ctl_elem_value *ucontrol)
5983 {
5984 alc_update_headset_mode(codec);
5985 }
5986
alc_update_headset_jack_cb(struct hda_codec * codec,struct hda_jack_callback * jack)5987 static void alc_update_headset_jack_cb(struct hda_codec *codec,
5988 struct hda_jack_callback *jack)
5989 {
5990 snd_hda_gen_hp_automute(codec, jack);
5991 alc_update_headset_mode(codec);
5992 }
5993
alc_probe_headset_mode(struct hda_codec * codec)5994 static void alc_probe_headset_mode(struct hda_codec *codec)
5995 {
5996 int i;
5997 struct alc_spec *spec = codec->spec;
5998 struct auto_pin_cfg *cfg = &spec->gen.autocfg;
5999
6000 /* Find mic pins */
6001 for (i = 0; i < cfg->num_inputs; i++) {
6002 if (cfg->inputs[i].is_headset_mic && !spec->headset_mic_pin)
6003 spec->headset_mic_pin = cfg->inputs[i].pin;
6004 if (cfg->inputs[i].is_headphone_mic && !spec->headphone_mic_pin)
6005 spec->headphone_mic_pin = cfg->inputs[i].pin;
6006 }
6007
6008 WARN_ON(spec->gen.cap_sync_hook);
6009 spec->gen.cap_sync_hook = alc_update_headset_mode_hook;
6010 spec->gen.automute_hook = alc_update_headset_mode;
6011 spec->gen.hp_automute_hook = alc_update_headset_jack_cb;
6012 }
6013
alc_fixup_headset_mode(struct hda_codec * codec,const struct hda_fixup * fix,int action)6014 static void alc_fixup_headset_mode(struct hda_codec *codec,
6015 const struct hda_fixup *fix, int action)
6016 {
6017 struct alc_spec *spec = codec->spec;
6018
6019 switch (action) {
6020 case HDA_FIXUP_ACT_PRE_PROBE:
6021 spec->parse_flags |= HDA_PINCFG_HEADSET_MIC | HDA_PINCFG_HEADPHONE_MIC;
6022 break;
6023 case HDA_FIXUP_ACT_PROBE:
6024 alc_probe_headset_mode(codec);
6025 break;
6026 case HDA_FIXUP_ACT_INIT:
6027 if (is_s3_resume(codec) || is_s4_resume(codec)) {
6028 spec->current_headset_mode = ALC_HEADSET_MODE_UNKNOWN;
6029 spec->current_headset_type = ALC_HEADSET_TYPE_UNKNOWN;
6030 }
6031 alc_update_headset_mode(codec);
6032 break;
6033 }
6034 }
6035
alc_fixup_headset_mode_no_hp_mic(struct hda_codec * codec,const struct hda_fixup * fix,int action)6036 static void alc_fixup_headset_mode_no_hp_mic(struct hda_codec *codec,
6037 const struct hda_fixup *fix, int action)
6038 {
6039 if (action == HDA_FIXUP_ACT_PRE_PROBE) {
6040 struct alc_spec *spec = codec->spec;
6041 spec->parse_flags |= HDA_PINCFG_HEADSET_MIC;
6042 }
6043 else
6044 alc_fixup_headset_mode(codec, fix, action);
6045 }
6046
alc255_set_default_jack_type(struct hda_codec * codec)6047 static void alc255_set_default_jack_type(struct hda_codec *codec)
6048 {
6049 /* Set to iphone type */
6050 static const struct coef_fw alc255fw[] = {
6051 WRITE_COEF(0x1b, 0x880b),
6052 WRITE_COEF(0x45, 0xd089),
6053 WRITE_COEF(0x1b, 0x080b),
6054 WRITE_COEF(0x46, 0x0004),
6055 WRITE_COEF(0x1b, 0x0c0b),
6056 {}
6057 };
6058 static const struct coef_fw alc256fw[] = {
6059 WRITE_COEF(0x1b, 0x884b),
6060 WRITE_COEF(0x45, 0xd089),
6061 WRITE_COEF(0x1b, 0x084b),
6062 WRITE_COEF(0x46, 0x0004),
6063 WRITE_COEF(0x1b, 0x0c4b),
6064 {}
6065 };
6066 switch (codec->core.vendor_id) {
6067 case 0x10ec0255:
6068 alc_process_coef_fw(codec, alc255fw);
6069 break;
6070 case 0x10ec0230:
6071 case 0x10ec0236:
6072 case 0x10ec0256:
6073 case 0x19e58326:
6074 alc_process_coef_fw(codec, alc256fw);
6075 break;
6076 }
6077 msleep(30);
6078 }
6079
alc_fixup_headset_mode_alc255(struct hda_codec * codec,const struct hda_fixup * fix,int action)6080 static void alc_fixup_headset_mode_alc255(struct hda_codec *codec,
6081 const struct hda_fixup *fix, int action)
6082 {
6083 if (action == HDA_FIXUP_ACT_PRE_PROBE) {
6084 alc255_set_default_jack_type(codec);
6085 }
6086 alc_fixup_headset_mode(codec, fix, action);
6087 }
6088
alc_fixup_headset_mode_alc255_no_hp_mic(struct hda_codec * codec,const struct hda_fixup * fix,int action)6089 static void alc_fixup_headset_mode_alc255_no_hp_mic(struct hda_codec *codec,
6090 const struct hda_fixup *fix, int action)
6091 {
6092 if (action == HDA_FIXUP_ACT_PRE_PROBE) {
6093 struct alc_spec *spec = codec->spec;
6094 spec->parse_flags |= HDA_PINCFG_HEADSET_MIC;
6095 alc255_set_default_jack_type(codec);
6096 }
6097 else
6098 alc_fixup_headset_mode(codec, fix, action);
6099 }
6100
alc288_update_headset_jack_cb(struct hda_codec * codec,struct hda_jack_callback * jack)6101 static void alc288_update_headset_jack_cb(struct hda_codec *codec,
6102 struct hda_jack_callback *jack)
6103 {
6104 struct alc_spec *spec = codec->spec;
6105
6106 alc_update_headset_jack_cb(codec, jack);
6107 /* Headset Mic enable or disable, only for Dell Dino */
6108 alc_update_gpio_data(codec, 0x40, spec->gen.hp_jack_present);
6109 }
6110
alc_fixup_headset_mode_dell_alc288(struct hda_codec * codec,const struct hda_fixup * fix,int action)6111 static void alc_fixup_headset_mode_dell_alc288(struct hda_codec *codec,
6112 const struct hda_fixup *fix, int action)
6113 {
6114 alc_fixup_headset_mode(codec, fix, action);
6115 if (action == HDA_FIXUP_ACT_PROBE) {
6116 struct alc_spec *spec = codec->spec;
6117 /* toggled via hp_automute_hook */
6118 spec->gpio_mask |= 0x40;
6119 spec->gpio_dir |= 0x40;
6120 spec->gen.hp_automute_hook = alc288_update_headset_jack_cb;
6121 }
6122 }
6123
alc_fixup_auto_mute_via_amp(struct hda_codec * codec,const struct hda_fixup * fix,int action)6124 static void alc_fixup_auto_mute_via_amp(struct hda_codec *codec,
6125 const struct hda_fixup *fix, int action)
6126 {
6127 if (action == HDA_FIXUP_ACT_PRE_PROBE) {
6128 struct alc_spec *spec = codec->spec;
6129 spec->gen.auto_mute_via_amp = 1;
6130 }
6131 }
6132
alc_fixup_no_shutup(struct hda_codec * codec,const struct hda_fixup * fix,int action)6133 static void alc_fixup_no_shutup(struct hda_codec *codec,
6134 const struct hda_fixup *fix, int action)
6135 {
6136 if (action == HDA_FIXUP_ACT_PRE_PROBE) {
6137 struct alc_spec *spec = codec->spec;
6138 spec->no_shutup_pins = 1;
6139 }
6140 }
6141
alc_fixup_disable_aamix(struct hda_codec * codec,const struct hda_fixup * fix,int action)6142 static void alc_fixup_disable_aamix(struct hda_codec *codec,
6143 const struct hda_fixup *fix, int action)
6144 {
6145 if (action == HDA_FIXUP_ACT_PRE_PROBE) {
6146 struct alc_spec *spec = codec->spec;
6147 /* Disable AA-loopback as it causes white noise */
6148 spec->gen.mixer_nid = 0;
6149 }
6150 }
6151
6152 /* fixup for Thinkpad docks: add dock pins, avoid HP parser fixup */
alc_fixup_tpt440_dock(struct hda_codec * codec,const struct hda_fixup * fix,int action)6153 static void alc_fixup_tpt440_dock(struct hda_codec *codec,
6154 const struct hda_fixup *fix, int action)
6155 {
6156 static const struct hda_pintbl pincfgs[] = {
6157 { 0x16, 0x21211010 }, /* dock headphone */
6158 { 0x19, 0x21a11010 }, /* dock mic */
6159 { }
6160 };
6161 struct alc_spec *spec = codec->spec;
6162
6163 if (action == HDA_FIXUP_ACT_PRE_PROBE) {
6164 spec->parse_flags = HDA_PINCFG_NO_HP_FIXUP;
6165 codec->power_save_node = 0; /* avoid click noises */
6166 snd_hda_apply_pincfgs(codec, pincfgs);
6167 }
6168 }
6169
alc_fixup_tpt470_dock(struct hda_codec * codec,const struct hda_fixup * fix,int action)6170 static void alc_fixup_tpt470_dock(struct hda_codec *codec,
6171 const struct hda_fixup *fix, int action)
6172 {
6173 static const struct hda_pintbl pincfgs[] = {
6174 { 0x17, 0x21211010 }, /* dock headphone */
6175 { 0x19, 0x21a11010 }, /* dock mic */
6176 { }
6177 };
6178 struct alc_spec *spec = codec->spec;
6179
6180 if (action == HDA_FIXUP_ACT_PRE_PROBE) {
6181 spec->parse_flags = HDA_PINCFG_NO_HP_FIXUP;
6182 snd_hda_apply_pincfgs(codec, pincfgs);
6183 } else if (action == HDA_FIXUP_ACT_INIT) {
6184 /* Enable DOCK device */
6185 snd_hda_codec_write(codec, 0x17, 0,
6186 AC_VERB_SET_CONFIG_DEFAULT_BYTES_3, 0);
6187 /* Enable DOCK device */
6188 snd_hda_codec_write(codec, 0x19, 0,
6189 AC_VERB_SET_CONFIG_DEFAULT_BYTES_3, 0);
6190 }
6191 }
6192
alc_fixup_tpt470_dacs(struct hda_codec * codec,const struct hda_fixup * fix,int action)6193 static void alc_fixup_tpt470_dacs(struct hda_codec *codec,
6194 const struct hda_fixup *fix, int action)
6195 {
6196 /* Assure the speaker pin to be coupled with DAC NID 0x03; otherwise
6197 * the speaker output becomes too low by some reason on Thinkpads with
6198 * ALC298 codec
6199 */
6200 static const hda_nid_t preferred_pairs[] = {
6201 0x14, 0x03, 0x17, 0x02, 0x21, 0x02,
6202 0
6203 };
6204 struct alc_spec *spec = codec->spec;
6205
6206 if (action == HDA_FIXUP_ACT_PRE_PROBE)
6207 spec->gen.preferred_dacs = preferred_pairs;
6208 }
6209
alc295_fixup_asus_dacs(struct hda_codec * codec,const struct hda_fixup * fix,int action)6210 static void alc295_fixup_asus_dacs(struct hda_codec *codec,
6211 const struct hda_fixup *fix, int action)
6212 {
6213 static const hda_nid_t preferred_pairs[] = {
6214 0x17, 0x02, 0x21, 0x03, 0
6215 };
6216 struct alc_spec *spec = codec->spec;
6217
6218 if (action == HDA_FIXUP_ACT_PRE_PROBE)
6219 spec->gen.preferred_dacs = preferred_pairs;
6220 }
6221
alc_shutup_dell_xps13(struct hda_codec * codec)6222 static void alc_shutup_dell_xps13(struct hda_codec *codec)
6223 {
6224 struct alc_spec *spec = codec->spec;
6225 int hp_pin = alc_get_hp_pin(spec);
6226
6227 /* Prevent pop noises when headphones are plugged in */
6228 snd_hda_codec_write(codec, hp_pin, 0,
6229 AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);
6230 msleep(20);
6231 }
6232
alc_fixup_dell_xps13(struct hda_codec * codec,const struct hda_fixup * fix,int action)6233 static void alc_fixup_dell_xps13(struct hda_codec *codec,
6234 const struct hda_fixup *fix, int action)
6235 {
6236 struct alc_spec *spec = codec->spec;
6237 struct hda_input_mux *imux = &spec->gen.input_mux;
6238 int i;
6239
6240 switch (action) {
6241 case HDA_FIXUP_ACT_PRE_PROBE:
6242 /* mic pin 0x19 must be initialized with Vref Hi-Z, otherwise
6243 * it causes a click noise at start up
6244 */
6245 snd_hda_codec_set_pin_target(codec, 0x19, PIN_VREFHIZ);
6246 spec->shutup = alc_shutup_dell_xps13;
6247 break;
6248 case HDA_FIXUP_ACT_PROBE:
6249 /* Make the internal mic the default input source. */
6250 for (i = 0; i < imux->num_items; i++) {
6251 if (spec->gen.imux_pins[i] == 0x12) {
6252 spec->gen.cur_mux[0] = i;
6253 break;
6254 }
6255 }
6256 break;
6257 }
6258 }
6259
alc_fixup_headset_mode_alc662(struct hda_codec * codec,const struct hda_fixup * fix,int action)6260 static void alc_fixup_headset_mode_alc662(struct hda_codec *codec,
6261 const struct hda_fixup *fix, int action)
6262 {
6263 struct alc_spec *spec = codec->spec;
6264
6265 if (action == HDA_FIXUP_ACT_PRE_PROBE) {
6266 spec->parse_flags |= HDA_PINCFG_HEADSET_MIC;
6267 spec->gen.hp_mic = 1; /* Mic-in is same pin as headphone */
6268
6269 /* Disable boost for mic-in permanently. (This code is only called
6270 from quirks that guarantee that the headphone is at NID 0x1b.) */
6271 snd_hda_codec_write(codec, 0x1b, 0, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000);
6272 snd_hda_override_wcaps(codec, 0x1b, get_wcaps(codec, 0x1b) & ~AC_WCAP_IN_AMP);
6273 } else
6274 alc_fixup_headset_mode(codec, fix, action);
6275 }
6276
alc_fixup_headset_mode_alc668(struct hda_codec * codec,const struct hda_fixup * fix,int action)6277 static void alc_fixup_headset_mode_alc668(struct hda_codec *codec,
6278 const struct hda_fixup *fix, int action)
6279 {
6280 if (action == HDA_FIXUP_ACT_PRE_PROBE) {
6281 alc_write_coef_idx(codec, 0xc4, 0x8000);
6282 alc_update_coef_idx(codec, 0xc2, ~0xfe, 0);
6283 snd_hda_set_pin_ctl_cache(codec, 0x18, 0);
6284 }
6285 alc_fixup_headset_mode(codec, fix, action);
6286 }
6287
6288 /* Returns the nid of the external mic input pin, or 0 if it cannot be found. */
find_ext_mic_pin(struct hda_codec * codec)6289 static int find_ext_mic_pin(struct hda_codec *codec)
6290 {
6291 struct alc_spec *spec = codec->spec;
6292 struct auto_pin_cfg *cfg = &spec->gen.autocfg;
6293 hda_nid_t nid;
6294 unsigned int defcfg;
6295 int i;
6296
6297 for (i = 0; i < cfg->num_inputs; i++) {
6298 if (cfg->inputs[i].type != AUTO_PIN_MIC)
6299 continue;
6300 nid = cfg->inputs[i].pin;
6301 defcfg = snd_hda_codec_get_pincfg(codec, nid);
6302 if (snd_hda_get_input_pin_attr(defcfg) == INPUT_PIN_ATTR_INT)
6303 continue;
6304 return nid;
6305 }
6306
6307 return 0;
6308 }
6309
alc271_hp_gate_mic_jack(struct hda_codec * codec,const struct hda_fixup * fix,int action)6310 static void alc271_hp_gate_mic_jack(struct hda_codec *codec,
6311 const struct hda_fixup *fix,
6312 int action)
6313 {
6314 struct alc_spec *spec = codec->spec;
6315
6316 if (action == HDA_FIXUP_ACT_PROBE) {
6317 int mic_pin = find_ext_mic_pin(codec);
6318 int hp_pin = alc_get_hp_pin(spec);
6319
6320 if (snd_BUG_ON(!mic_pin || !hp_pin))
6321 return;
6322 snd_hda_jack_set_gating_jack(codec, mic_pin, hp_pin);
6323 }
6324 }
6325
alc269_fixup_limit_int_mic_boost(struct hda_codec * codec,const struct hda_fixup * fix,int action)6326 static void alc269_fixup_limit_int_mic_boost(struct hda_codec *codec,
6327 const struct hda_fixup *fix,
6328 int action)
6329 {
6330 struct alc_spec *spec = codec->spec;
6331 struct auto_pin_cfg *cfg = &spec->gen.autocfg;
6332 int i;
6333
6334 /* The mic boosts on level 2 and 3 are too noisy
6335 on the internal mic input.
6336 Therefore limit the boost to 0 or 1. */
6337
6338 if (action != HDA_FIXUP_ACT_PROBE)
6339 return;
6340
6341 for (i = 0; i < cfg->num_inputs; i++) {
6342 hda_nid_t nid = cfg->inputs[i].pin;
6343 unsigned int defcfg;
6344 if (cfg->inputs[i].type != AUTO_PIN_MIC)
6345 continue;
6346 defcfg = snd_hda_codec_get_pincfg(codec, nid);
6347 if (snd_hda_get_input_pin_attr(defcfg) != INPUT_PIN_ATTR_INT)
6348 continue;
6349
6350 snd_hda_override_amp_caps(codec, nid, HDA_INPUT,
6351 (0x00 << AC_AMPCAP_OFFSET_SHIFT) |
6352 (0x01 << AC_AMPCAP_NUM_STEPS_SHIFT) |
6353 (0x2f << AC_AMPCAP_STEP_SIZE_SHIFT) |
6354 (0 << AC_AMPCAP_MUTE_SHIFT));
6355 }
6356 }
6357
alc283_hp_automute_hook(struct hda_codec * codec,struct hda_jack_callback * jack)6358 static void alc283_hp_automute_hook(struct hda_codec *codec,
6359 struct hda_jack_callback *jack)
6360 {
6361 struct alc_spec *spec = codec->spec;
6362 int vref;
6363
6364 msleep(200);
6365 snd_hda_gen_hp_automute(codec, jack);
6366
6367 vref = spec->gen.hp_jack_present ? PIN_VREF80 : 0;
6368
6369 msleep(600);
6370 snd_hda_codec_write(codec, 0x19, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
6371 vref);
6372 }
6373
alc283_fixup_chromebook(struct hda_codec * codec,const struct hda_fixup * fix,int action)6374 static void alc283_fixup_chromebook(struct hda_codec *codec,
6375 const struct hda_fixup *fix, int action)
6376 {
6377 struct alc_spec *spec = codec->spec;
6378
6379 switch (action) {
6380 case HDA_FIXUP_ACT_PRE_PROBE:
6381 snd_hda_override_wcaps(codec, 0x03, 0);
6382 /* Disable AA-loopback as it causes white noise */
6383 spec->gen.mixer_nid = 0;
6384 break;
6385 case HDA_FIXUP_ACT_INIT:
6386 /* MIC2-VREF control */
6387 /* Set to manual mode */
6388 alc_update_coef_idx(codec, 0x06, 0x000c, 0);
6389 /* Enable Line1 input control by verb */
6390 alc_update_coef_idx(codec, 0x1a, 0, 1 << 4);
6391 break;
6392 }
6393 }
6394
alc283_fixup_sense_combo_jack(struct hda_codec * codec,const struct hda_fixup * fix,int action)6395 static void alc283_fixup_sense_combo_jack(struct hda_codec *codec,
6396 const struct hda_fixup *fix, int action)
6397 {
6398 struct alc_spec *spec = codec->spec;
6399
6400 switch (action) {
6401 case HDA_FIXUP_ACT_PRE_PROBE:
6402 spec->gen.hp_automute_hook = alc283_hp_automute_hook;
6403 break;
6404 case HDA_FIXUP_ACT_INIT:
6405 /* MIC2-VREF control */
6406 /* Set to manual mode */
6407 alc_update_coef_idx(codec, 0x06, 0x000c, 0);
6408 break;
6409 }
6410 }
6411
6412 /* mute tablet speaker pin (0x14) via dock plugging in addition */
asus_tx300_automute(struct hda_codec * codec)6413 static void asus_tx300_automute(struct hda_codec *codec)
6414 {
6415 struct alc_spec *spec = codec->spec;
6416 snd_hda_gen_update_outputs(codec);
6417 if (snd_hda_jack_detect(codec, 0x1b))
6418 spec->gen.mute_bits |= (1ULL << 0x14);
6419 }
6420
alc282_fixup_asus_tx300(struct hda_codec * codec,const struct hda_fixup * fix,int action)6421 static void alc282_fixup_asus_tx300(struct hda_codec *codec,
6422 const struct hda_fixup *fix, int action)
6423 {
6424 struct alc_spec *spec = codec->spec;
6425 static const struct hda_pintbl dock_pins[] = {
6426 { 0x1b, 0x21114000 }, /* dock speaker pin */
6427 {}
6428 };
6429
6430 switch (action) {
6431 case HDA_FIXUP_ACT_PRE_PROBE:
6432 spec->init_amp = ALC_INIT_DEFAULT;
6433 /* TX300 needs to set up GPIO2 for the speaker amp */
6434 alc_setup_gpio(codec, 0x04);
6435 snd_hda_apply_pincfgs(codec, dock_pins);
6436 spec->gen.auto_mute_via_amp = 1;
6437 spec->gen.automute_hook = asus_tx300_automute;
6438 snd_hda_jack_detect_enable_callback(codec, 0x1b,
6439 snd_hda_gen_hp_automute);
6440 break;
6441 case HDA_FIXUP_ACT_PROBE:
6442 spec->init_amp = ALC_INIT_DEFAULT;
6443 break;
6444 case HDA_FIXUP_ACT_BUILD:
6445 /* this is a bit tricky; give more sane names for the main
6446 * (tablet) speaker and the dock speaker, respectively
6447 */
6448 rename_ctl(codec, "Speaker Playback Switch",
6449 "Dock Speaker Playback Switch");
6450 rename_ctl(codec, "Bass Speaker Playback Switch",
6451 "Speaker Playback Switch");
6452 break;
6453 }
6454 }
6455
alc290_fixup_mono_speakers(struct hda_codec * codec,const struct hda_fixup * fix,int action)6456 static void alc290_fixup_mono_speakers(struct hda_codec *codec,
6457 const struct hda_fixup *fix, int action)
6458 {
6459 if (action == HDA_FIXUP_ACT_PRE_PROBE) {
6460 /* DAC node 0x03 is giving mono output. We therefore want to
6461 make sure 0x14 (front speaker) and 0x15 (headphones) use the
6462 stereo DAC, while leaving 0x17 (bass speaker) for node 0x03. */
6463 static const hda_nid_t conn1[] = { 0x0c };
6464 snd_hda_override_conn_list(codec, 0x14, ARRAY_SIZE(conn1), conn1);
6465 snd_hda_override_conn_list(codec, 0x15, ARRAY_SIZE(conn1), conn1);
6466 }
6467 }
6468
alc298_fixup_speaker_volume(struct hda_codec * codec,const struct hda_fixup * fix,int action)6469 static void alc298_fixup_speaker_volume(struct hda_codec *codec,
6470 const struct hda_fixup *fix, int action)
6471 {
6472 if (action == HDA_FIXUP_ACT_PRE_PROBE) {
6473 /* The speaker is routed to the Node 0x06 by a mistake, as a result
6474 we can't adjust the speaker's volume since this node does not has
6475 Amp-out capability. we change the speaker's route to:
6476 Node 0x02 (Audio Output) -> Node 0x0c (Audio Mixer) -> Node 0x17 (
6477 Pin Complex), since Node 0x02 has Amp-out caps, we can adjust
6478 speaker's volume now. */
6479
6480 static const hda_nid_t conn1[] = { 0x0c };
6481 snd_hda_override_conn_list(codec, 0x17, ARRAY_SIZE(conn1), conn1);
6482 }
6483 }
6484
6485 /* disable DAC3 (0x06) selection on NID 0x17 as it has no volume amp control */
alc295_fixup_disable_dac3(struct hda_codec * codec,const struct hda_fixup * fix,int action)6486 static void alc295_fixup_disable_dac3(struct hda_codec *codec,
6487 const struct hda_fixup *fix, int action)
6488 {
6489 if (action == HDA_FIXUP_ACT_PRE_PROBE) {
6490 static const hda_nid_t conn[] = { 0x02, 0x03 };
6491 snd_hda_override_conn_list(codec, 0x17, ARRAY_SIZE(conn), conn);
6492 }
6493 }
6494
6495 /* force NID 0x17 (Bass Speaker) to DAC1 to share it with the main speaker */
alc285_fixup_speaker2_to_dac1(struct hda_codec * codec,const struct hda_fixup * fix,int action)6496 static void alc285_fixup_speaker2_to_dac1(struct hda_codec *codec,
6497 const struct hda_fixup *fix, int action)
6498 {
6499 if (action == HDA_FIXUP_ACT_PRE_PROBE) {
6500 static const hda_nid_t conn[] = { 0x02 };
6501 snd_hda_override_conn_list(codec, 0x17, ARRAY_SIZE(conn), conn);
6502 }
6503 }
6504
6505 /* Hook to update amp GPIO4 for automute */
alc280_hp_gpio4_automute_hook(struct hda_codec * codec,struct hda_jack_callback * jack)6506 static void alc280_hp_gpio4_automute_hook(struct hda_codec *codec,
6507 struct hda_jack_callback *jack)
6508 {
6509 struct alc_spec *spec = codec->spec;
6510
6511 snd_hda_gen_hp_automute(codec, jack);
6512 /* mute_led_polarity is set to 0, so we pass inverted value here */
6513 alc_update_gpio_led(codec, 0x10, spec->mute_led_polarity,
6514 !spec->gen.hp_jack_present);
6515 }
6516
6517 /* Manage GPIOs for HP EliteBook Folio 9480m.
6518 *
6519 * GPIO4 is the headphone amplifier power control
6520 * GPIO3 is the audio output mute indicator LED
6521 */
6522
alc280_fixup_hp_9480m(struct hda_codec * codec,const struct hda_fixup * fix,int action)6523 static void alc280_fixup_hp_9480m(struct hda_codec *codec,
6524 const struct hda_fixup *fix,
6525 int action)
6526 {
6527 struct alc_spec *spec = codec->spec;
6528
6529 alc_fixup_hp_gpio_led(codec, action, 0x08, 0);
6530 if (action == HDA_FIXUP_ACT_PRE_PROBE) {
6531 /* amp at GPIO4; toggled via alc280_hp_gpio4_automute_hook() */
6532 spec->gpio_mask |= 0x10;
6533 spec->gpio_dir |= 0x10;
6534 spec->gen.hp_automute_hook = alc280_hp_gpio4_automute_hook;
6535 }
6536 }
6537
alc275_fixup_gpio4_off(struct hda_codec * codec,const struct hda_fixup * fix,int action)6538 static void alc275_fixup_gpio4_off(struct hda_codec *codec,
6539 const struct hda_fixup *fix,
6540 int action)
6541 {
6542 struct alc_spec *spec = codec->spec;
6543
6544 if (action == HDA_FIXUP_ACT_PRE_PROBE) {
6545 spec->gpio_mask |= 0x04;
6546 spec->gpio_dir |= 0x04;
6547 /* set data bit low */
6548 }
6549 }
6550
6551 /* Quirk for Thinkpad X1 7th and 8th Gen
6552 * The following fixed routing needed
6553 * DAC1 (NID 0x02) -> Speaker (NID 0x14); some eq applied secretly
6554 * DAC2 (NID 0x03) -> Bass (NID 0x17) & Headphone (NID 0x21); sharing a DAC
6555 * DAC3 (NID 0x06) -> Unused, due to the lack of volume amp
6556 */
alc285_fixup_thinkpad_x1_gen7(struct hda_codec * codec,const struct hda_fixup * fix,int action)6557 static void alc285_fixup_thinkpad_x1_gen7(struct hda_codec *codec,
6558 const struct hda_fixup *fix, int action)
6559 {
6560 static const hda_nid_t conn[] = { 0x02, 0x03 }; /* exclude 0x06 */
6561 static const hda_nid_t preferred_pairs[] = {
6562 0x14, 0x02, 0x17, 0x03, 0x21, 0x03, 0
6563 };
6564 struct alc_spec *spec = codec->spec;
6565
6566 switch (action) {
6567 case HDA_FIXUP_ACT_PRE_PROBE:
6568 snd_hda_override_conn_list(codec, 0x17, ARRAY_SIZE(conn), conn);
6569 spec->gen.preferred_dacs = preferred_pairs;
6570 break;
6571 case HDA_FIXUP_ACT_BUILD:
6572 /* The generic parser creates somewhat unintuitive volume ctls
6573 * with the fixed routing above, and the shared DAC2 may be
6574 * confusing for PA.
6575 * Rename those to unique names so that PA doesn't touch them
6576 * and use only Master volume.
6577 */
6578 rename_ctl(codec, "Front Playback Volume", "DAC1 Playback Volume");
6579 rename_ctl(codec, "Bass Speaker Playback Volume", "DAC2 Playback Volume");
6580 break;
6581 }
6582 }
6583
alc233_alc662_fixup_lenovo_dual_codecs(struct hda_codec * codec,const struct hda_fixup * fix,int action)6584 static void alc233_alc662_fixup_lenovo_dual_codecs(struct hda_codec *codec,
6585 const struct hda_fixup *fix,
6586 int action)
6587 {
6588 alc_fixup_dual_codecs(codec, fix, action);
6589 switch (action) {
6590 case HDA_FIXUP_ACT_PRE_PROBE:
6591 /* override card longname to provide a unique UCM profile */
6592 strcpy(codec->card->longname, "HDAudio-Lenovo-DualCodecs");
6593 break;
6594 case HDA_FIXUP_ACT_BUILD:
6595 /* rename Capture controls depending on the codec */
6596 rename_ctl(codec, "Capture Volume",
6597 codec->addr == 0 ?
6598 "Rear-Panel Capture Volume" :
6599 "Front-Panel Capture Volume");
6600 rename_ctl(codec, "Capture Switch",
6601 codec->addr == 0 ?
6602 "Rear-Panel Capture Switch" :
6603 "Front-Panel Capture Switch");
6604 break;
6605 }
6606 }
6607
alc225_fixup_s3_pop_noise(struct hda_codec * codec,const struct hda_fixup * fix,int action)6608 static void alc225_fixup_s3_pop_noise(struct hda_codec *codec,
6609 const struct hda_fixup *fix, int action)
6610 {
6611 if (action != HDA_FIXUP_ACT_PRE_PROBE)
6612 return;
6613
6614 codec->power_save_node = 1;
6615 }
6616
6617 /* Forcibly assign NID 0x03 to HP/LO while NID 0x02 to SPK for EQ */
alc274_fixup_bind_dacs(struct hda_codec * codec,const struct hda_fixup * fix,int action)6618 static void alc274_fixup_bind_dacs(struct hda_codec *codec,
6619 const struct hda_fixup *fix, int action)
6620 {
6621 struct alc_spec *spec = codec->spec;
6622 static const hda_nid_t preferred_pairs[] = {
6623 0x21, 0x03, 0x1b, 0x03, 0x16, 0x02,
6624 0
6625 };
6626
6627 if (action != HDA_FIXUP_ACT_PRE_PROBE)
6628 return;
6629
6630 spec->gen.preferred_dacs = preferred_pairs;
6631 spec->gen.auto_mute_via_amp = 1;
6632 codec->power_save_node = 0;
6633 }
6634
6635 /* avoid DAC 0x06 for bass speaker 0x17; it has no volume control */
alc289_fixup_asus_ga401(struct hda_codec * codec,const struct hda_fixup * fix,int action)6636 static void alc289_fixup_asus_ga401(struct hda_codec *codec,
6637 const struct hda_fixup *fix, int action)
6638 {
6639 static const hda_nid_t preferred_pairs[] = {
6640 0x14, 0x02, 0x17, 0x02, 0x21, 0x03, 0
6641 };
6642 struct alc_spec *spec = codec->spec;
6643
6644 if (action == HDA_FIXUP_ACT_PRE_PROBE)
6645 spec->gen.preferred_dacs = preferred_pairs;
6646 }
6647
6648 /* The DAC of NID 0x3 will introduce click/pop noise on headphones, so invalidate it */
alc285_fixup_invalidate_dacs(struct hda_codec * codec,const struct hda_fixup * fix,int action)6649 static void alc285_fixup_invalidate_dacs(struct hda_codec *codec,
6650 const struct hda_fixup *fix, int action)
6651 {
6652 if (action != HDA_FIXUP_ACT_PRE_PROBE)
6653 return;
6654
6655 snd_hda_override_wcaps(codec, 0x03, 0);
6656 }
6657
alc_combo_jack_hp_jd_restart(struct hda_codec * codec)6658 static void alc_combo_jack_hp_jd_restart(struct hda_codec *codec)
6659 {
6660 switch (codec->core.vendor_id) {
6661 case 0x10ec0274:
6662 case 0x10ec0294:
6663 case 0x10ec0225:
6664 case 0x10ec0295:
6665 case 0x10ec0299:
6666 alc_update_coef_idx(codec, 0x4a, 0x8000, 1 << 15); /* Reset HP JD */
6667 alc_update_coef_idx(codec, 0x4a, 0x8000, 0 << 15);
6668 break;
6669 case 0x10ec0230:
6670 case 0x10ec0235:
6671 case 0x10ec0236:
6672 case 0x10ec0255:
6673 case 0x10ec0256:
6674 case 0x10ec0257:
6675 case 0x19e58326:
6676 alc_update_coef_idx(codec, 0x1b, 0x8000, 1 << 15); /* Reset HP JD */
6677 alc_update_coef_idx(codec, 0x1b, 0x8000, 0 << 15);
6678 break;
6679 }
6680 }
6681
alc295_fixup_chromebook(struct hda_codec * codec,const struct hda_fixup * fix,int action)6682 static void alc295_fixup_chromebook(struct hda_codec *codec,
6683 const struct hda_fixup *fix, int action)
6684 {
6685 struct alc_spec *spec = codec->spec;
6686
6687 switch (action) {
6688 case HDA_FIXUP_ACT_PRE_PROBE:
6689 spec->ultra_low_power = true;
6690 break;
6691 case HDA_FIXUP_ACT_INIT:
6692 alc_combo_jack_hp_jd_restart(codec);
6693 break;
6694 }
6695 }
6696
alc256_fixup_chromebook(struct hda_codec * codec,const struct hda_fixup * fix,int action)6697 static void alc256_fixup_chromebook(struct hda_codec *codec,
6698 const struct hda_fixup *fix, int action)
6699 {
6700 struct alc_spec *spec = codec->spec;
6701
6702 switch (action) {
6703 case HDA_FIXUP_ACT_PRE_PROBE:
6704 spec->gen.suppress_auto_mute = 1;
6705 spec->gen.suppress_auto_mic = 1;
6706 spec->en_3kpull_low = false;
6707 break;
6708 }
6709 }
6710
alc_fixup_disable_mic_vref(struct hda_codec * codec,const struct hda_fixup * fix,int action)6711 static void alc_fixup_disable_mic_vref(struct hda_codec *codec,
6712 const struct hda_fixup *fix, int action)
6713 {
6714 if (action == HDA_FIXUP_ACT_PRE_PROBE)
6715 snd_hda_codec_set_pin_target(codec, 0x19, PIN_VREFHIZ);
6716 }
6717
6718
alc294_gx502_toggle_output(struct hda_codec * codec,struct hda_jack_callback * cb)6719 static void alc294_gx502_toggle_output(struct hda_codec *codec,
6720 struct hda_jack_callback *cb)
6721 {
6722 /* The Windows driver sets the codec up in a very different way where
6723 * it appears to leave 0x10 = 0x8a20 set. For Linux we need to toggle it
6724 */
6725 if (snd_hda_jack_detect_state(codec, 0x21) == HDA_JACK_PRESENT)
6726 alc_write_coef_idx(codec, 0x10, 0x8a20);
6727 else
6728 alc_write_coef_idx(codec, 0x10, 0x0a20);
6729 }
6730
alc294_fixup_gx502_hp(struct hda_codec * codec,const struct hda_fixup * fix,int action)6731 static void alc294_fixup_gx502_hp(struct hda_codec *codec,
6732 const struct hda_fixup *fix, int action)
6733 {
6734 /* Pin 0x21: headphones/headset mic */
6735 if (!is_jack_detectable(codec, 0x21))
6736 return;
6737
6738 switch (action) {
6739 case HDA_FIXUP_ACT_PRE_PROBE:
6740 snd_hda_jack_detect_enable_callback(codec, 0x21,
6741 alc294_gx502_toggle_output);
6742 break;
6743 case HDA_FIXUP_ACT_INIT:
6744 /* Make sure to start in a correct state, i.e. if
6745 * headphones have been plugged in before powering up the system
6746 */
6747 alc294_gx502_toggle_output(codec, NULL);
6748 break;
6749 }
6750 }
6751
alc294_gu502_toggle_output(struct hda_codec * codec,struct hda_jack_callback * cb)6752 static void alc294_gu502_toggle_output(struct hda_codec *codec,
6753 struct hda_jack_callback *cb)
6754 {
6755 /* Windows sets 0x10 to 0x8420 for Node 0x20 which is
6756 * responsible from changes between speakers and headphones
6757 */
6758 if (snd_hda_jack_detect_state(codec, 0x21) == HDA_JACK_PRESENT)
6759 alc_write_coef_idx(codec, 0x10, 0x8420);
6760 else
6761 alc_write_coef_idx(codec, 0x10, 0x0a20);
6762 }
6763
alc294_fixup_gu502_hp(struct hda_codec * codec,const struct hda_fixup * fix,int action)6764 static void alc294_fixup_gu502_hp(struct hda_codec *codec,
6765 const struct hda_fixup *fix, int action)
6766 {
6767 if (!is_jack_detectable(codec, 0x21))
6768 return;
6769
6770 switch (action) {
6771 case HDA_FIXUP_ACT_PRE_PROBE:
6772 snd_hda_jack_detect_enable_callback(codec, 0x21,
6773 alc294_gu502_toggle_output);
6774 break;
6775 case HDA_FIXUP_ACT_INIT:
6776 alc294_gu502_toggle_output(codec, NULL);
6777 break;
6778 }
6779 }
6780
alc285_fixup_hp_gpio_amp_init(struct hda_codec * codec,const struct hda_fixup * fix,int action)6781 static void alc285_fixup_hp_gpio_amp_init(struct hda_codec *codec,
6782 const struct hda_fixup *fix, int action)
6783 {
6784 if (action != HDA_FIXUP_ACT_INIT)
6785 return;
6786
6787 msleep(100);
6788 alc_write_coef_idx(codec, 0x65, 0x0);
6789 }
6790
alc274_fixup_hp_headset_mic(struct hda_codec * codec,const struct hda_fixup * fix,int action)6791 static void alc274_fixup_hp_headset_mic(struct hda_codec *codec,
6792 const struct hda_fixup *fix, int action)
6793 {
6794 switch (action) {
6795 case HDA_FIXUP_ACT_INIT:
6796 alc_combo_jack_hp_jd_restart(codec);
6797 break;
6798 }
6799 }
6800
alc_fixup_no_int_mic(struct hda_codec * codec,const struct hda_fixup * fix,int action)6801 static void alc_fixup_no_int_mic(struct hda_codec *codec,
6802 const struct hda_fixup *fix, int action)
6803 {
6804 struct alc_spec *spec = codec->spec;
6805
6806 switch (action) {
6807 case HDA_FIXUP_ACT_PRE_PROBE:
6808 /* Mic RING SLEEVE swap for combo jack */
6809 alc_update_coef_idx(codec, 0x45, 0xf<<12 | 1<<10, 5<<12);
6810 spec->no_internal_mic_pin = true;
6811 break;
6812 case HDA_FIXUP_ACT_INIT:
6813 alc_combo_jack_hp_jd_restart(codec);
6814 break;
6815 }
6816 }
6817
6818 /* GPIO1 = amplifier on/off
6819 * GPIO3 = mic mute LED
6820 */
alc285_fixup_hp_spectre_x360_eb1(struct hda_codec * codec,const struct hda_fixup * fix,int action)6821 static void alc285_fixup_hp_spectre_x360_eb1(struct hda_codec *codec,
6822 const struct hda_fixup *fix, int action)
6823 {
6824 static const hda_nid_t conn[] = { 0x02 };
6825
6826 struct alc_spec *spec = codec->spec;
6827 static const struct hda_pintbl pincfgs[] = {
6828 { 0x14, 0x90170110 }, /* front/high speakers */
6829 { 0x17, 0x90170130 }, /* back/bass speakers */
6830 { }
6831 };
6832
6833 //enable micmute led
6834 alc_fixup_hp_gpio_led(codec, action, 0x00, 0x04);
6835
6836 switch (action) {
6837 case HDA_FIXUP_ACT_PRE_PROBE:
6838 spec->micmute_led_polarity = 1;
6839 /* needed for amp of back speakers */
6840 spec->gpio_mask |= 0x01;
6841 spec->gpio_dir |= 0x01;
6842 snd_hda_apply_pincfgs(codec, pincfgs);
6843 /* share DAC to have unified volume control */
6844 snd_hda_override_conn_list(codec, 0x14, ARRAY_SIZE(conn), conn);
6845 snd_hda_override_conn_list(codec, 0x17, ARRAY_SIZE(conn), conn);
6846 break;
6847 case HDA_FIXUP_ACT_INIT:
6848 /* need to toggle GPIO to enable the amp of back speakers */
6849 alc_update_gpio_data(codec, 0x01, true);
6850 msleep(100);
6851 alc_update_gpio_data(codec, 0x01, false);
6852 break;
6853 }
6854 }
6855
alc285_fixup_hp_spectre_x360(struct hda_codec * codec,const struct hda_fixup * fix,int action)6856 static void alc285_fixup_hp_spectre_x360(struct hda_codec *codec,
6857 const struct hda_fixup *fix, int action)
6858 {
6859 static const hda_nid_t conn[] = { 0x02 };
6860 static const struct hda_pintbl pincfgs[] = {
6861 { 0x14, 0x90170110 }, /* rear speaker */
6862 { }
6863 };
6864
6865 switch (action) {
6866 case HDA_FIXUP_ACT_PRE_PROBE:
6867 snd_hda_apply_pincfgs(codec, pincfgs);
6868 /* force front speaker to DAC1 */
6869 snd_hda_override_conn_list(codec, 0x17, ARRAY_SIZE(conn), conn);
6870 break;
6871 }
6872 }
6873
alc285_fixup_hp_envy_x360(struct hda_codec * codec,const struct hda_fixup * fix,int action)6874 static void alc285_fixup_hp_envy_x360(struct hda_codec *codec,
6875 const struct hda_fixup *fix,
6876 int action)
6877 {
6878 static const struct coef_fw coefs[] = {
6879 WRITE_COEF(0x08, 0x6a0c), WRITE_COEF(0x0d, 0xa023),
6880 WRITE_COEF(0x10, 0x0320), WRITE_COEF(0x1a, 0x8c03),
6881 WRITE_COEF(0x25, 0x1800), WRITE_COEF(0x26, 0x003a),
6882 WRITE_COEF(0x28, 0x1dfe), WRITE_COEF(0x29, 0xb014),
6883 WRITE_COEF(0x2b, 0x1dfe), WRITE_COEF(0x37, 0xfe15),
6884 WRITE_COEF(0x38, 0x7909), WRITE_COEF(0x45, 0xd489),
6885 WRITE_COEF(0x46, 0x00f4), WRITE_COEF(0x4a, 0x21e0),
6886 WRITE_COEF(0x66, 0x03f0), WRITE_COEF(0x67, 0x1000),
6887 WRITE_COEF(0x6e, 0x1005), { }
6888 };
6889
6890 static const struct hda_pintbl pincfgs[] = {
6891 { 0x12, 0xb7a60130 }, /* Internal microphone*/
6892 { 0x14, 0x90170150 }, /* B&O soundbar speakers */
6893 { 0x17, 0x90170153 }, /* Side speakers */
6894 { 0x19, 0x03a11040 }, /* Headset microphone */
6895 { }
6896 };
6897
6898 switch (action) {
6899 case HDA_FIXUP_ACT_PRE_PROBE:
6900 snd_hda_apply_pincfgs(codec, pincfgs);
6901
6902 /* Fixes volume control problem for side speakers */
6903 alc295_fixup_disable_dac3(codec, fix, action);
6904
6905 /* Fixes no sound from headset speaker */
6906 snd_hda_codec_amp_stereo(codec, 0x21, HDA_OUTPUT, 0, -1, 0);
6907
6908 /* Auto-enable headset mic when plugged */
6909 snd_hda_jack_set_gating_jack(codec, 0x19, 0x21);
6910
6911 /* Headset mic volume enhancement */
6912 snd_hda_codec_set_pin_target(codec, 0x19, PIN_VREF50);
6913 break;
6914 case HDA_FIXUP_ACT_INIT:
6915 alc_process_coef_fw(codec, coefs);
6916 break;
6917 case HDA_FIXUP_ACT_BUILD:
6918 rename_ctl(codec, "Bass Speaker Playback Volume",
6919 "B&O-Tuned Playback Volume");
6920 rename_ctl(codec, "Front Playback Switch",
6921 "B&O Soundbar Playback Switch");
6922 rename_ctl(codec, "Bass Speaker Playback Switch",
6923 "Side Speaker Playback Switch");
6924 break;
6925 }
6926 }
6927
6928 /* for hda_fixup_thinkpad_acpi() */
6929 #include "thinkpad_helper.c"
6930
alc_fixup_thinkpad_acpi(struct hda_codec * codec,const struct hda_fixup * fix,int action)6931 static void alc_fixup_thinkpad_acpi(struct hda_codec *codec,
6932 const struct hda_fixup *fix, int action)
6933 {
6934 alc_fixup_no_shutup(codec, fix, action); /* reduce click noise */
6935 hda_fixup_thinkpad_acpi(codec, fix, action);
6936 }
6937
6938 /* Fixup for Lenovo Legion 15IMHg05 speaker output on headset removal. */
alc287_fixup_legion_15imhg05_speakers(struct hda_codec * codec,const struct hda_fixup * fix,int action)6939 static void alc287_fixup_legion_15imhg05_speakers(struct hda_codec *codec,
6940 const struct hda_fixup *fix,
6941 int action)
6942 {
6943 struct alc_spec *spec = codec->spec;
6944
6945 switch (action) {
6946 case HDA_FIXUP_ACT_PRE_PROBE:
6947 spec->gen.suppress_auto_mute = 1;
6948 break;
6949 }
6950 }
6951
comp_acpi_device_notify(acpi_handle handle,u32 event,void * data)6952 static void comp_acpi_device_notify(acpi_handle handle, u32 event, void *data)
6953 {
6954 struct hda_codec *cdc = data;
6955 struct alc_spec *spec = cdc->spec;
6956
6957 codec_info(cdc, "ACPI Notification %d\n", event);
6958
6959 hda_component_acpi_device_notify(&spec->comps, handle, event, data);
6960 }
6961
comp_bind(struct device * dev)6962 static int comp_bind(struct device *dev)
6963 {
6964 struct hda_codec *cdc = dev_to_hda_codec(dev);
6965 struct alc_spec *spec = cdc->spec;
6966 int ret;
6967
6968 ret = hda_component_manager_bind(cdc, &spec->comps);
6969 if (ret)
6970 return ret;
6971
6972 return hda_component_manager_bind_acpi_notifications(cdc,
6973 &spec->comps,
6974 comp_acpi_device_notify, cdc);
6975 }
6976
comp_unbind(struct device * dev)6977 static void comp_unbind(struct device *dev)
6978 {
6979 struct hda_codec *cdc = dev_to_hda_codec(dev);
6980 struct alc_spec *spec = cdc->spec;
6981
6982 hda_component_manager_unbind_acpi_notifications(cdc, &spec->comps, comp_acpi_device_notify);
6983 hda_component_manager_unbind(cdc, &spec->comps);
6984 }
6985
6986 static const struct component_master_ops comp_master_ops = {
6987 .bind = comp_bind,
6988 .unbind = comp_unbind,
6989 };
6990
comp_generic_playback_hook(struct hda_pcm_stream * hinfo,struct hda_codec * cdc,struct snd_pcm_substream * sub,int action)6991 static void comp_generic_playback_hook(struct hda_pcm_stream *hinfo, struct hda_codec *cdc,
6992 struct snd_pcm_substream *sub, int action)
6993 {
6994 struct alc_spec *spec = cdc->spec;
6995
6996 hda_component_manager_playback_hook(&spec->comps, action);
6997 }
6998
comp_generic_fixup(struct hda_codec * cdc,int action,const char * bus,const char * hid,const char * match_str,int count)6999 static void comp_generic_fixup(struct hda_codec *cdc, int action, const char *bus,
7000 const char *hid, const char *match_str, int count)
7001 {
7002 struct alc_spec *spec = cdc->spec;
7003 int ret;
7004
7005 switch (action) {
7006 case HDA_FIXUP_ACT_PRE_PROBE:
7007 ret = hda_component_manager_init(cdc, &spec->comps, count, bus, hid,
7008 match_str, &comp_master_ops);
7009 if (ret)
7010 return;
7011
7012 spec->gen.pcm_playback_hook = comp_generic_playback_hook;
7013 break;
7014 case HDA_FIXUP_ACT_FREE:
7015 hda_component_manager_free(&spec->comps, &comp_master_ops);
7016 break;
7017 }
7018 }
7019
find_cirrus_companion_amps(struct hda_codec * cdc)7020 static void find_cirrus_companion_amps(struct hda_codec *cdc)
7021 {
7022 struct device *dev = hda_codec_dev(cdc);
7023 struct acpi_device *adev;
7024 struct fwnode_handle *fwnode __free(fwnode_handle) = NULL;
7025 const char *bus = NULL;
7026 static const struct {
7027 const char *hid;
7028 const char *name;
7029 } acpi_ids[] = {{ "CSC3554", "cs35l54-hda" },
7030 { "CSC3556", "cs35l56-hda" },
7031 { "CSC3557", "cs35l57-hda" }};
7032 char *match;
7033 int i, count = 0, count_devindex = 0;
7034
7035 for (i = 0; i < ARRAY_SIZE(acpi_ids); ++i) {
7036 adev = acpi_dev_get_first_match_dev(acpi_ids[i].hid, NULL, -1);
7037 if (adev)
7038 break;
7039 }
7040 if (!adev) {
7041 codec_dbg(cdc, "Did not find ACPI entry for a Cirrus Amp\n");
7042 return;
7043 }
7044
7045 count = i2c_acpi_client_count(adev);
7046 if (count > 0) {
7047 bus = "i2c";
7048 } else {
7049 count = acpi_spi_count_resources(adev);
7050 if (count > 0)
7051 bus = "spi";
7052 }
7053
7054 fwnode = fwnode_handle_get(acpi_fwnode_handle(adev));
7055 acpi_dev_put(adev);
7056
7057 if (!bus) {
7058 codec_err(cdc, "Did not find any buses for %s\n", acpi_ids[i].hid);
7059 return;
7060 }
7061
7062 if (!fwnode) {
7063 codec_err(cdc, "Could not get fwnode for %s\n", acpi_ids[i].hid);
7064 return;
7065 }
7066
7067 /*
7068 * When available the cirrus,dev-index property is an accurate
7069 * count of the amps in a system and is used in preference to
7070 * the count of bus devices that can contain additional address
7071 * alias entries.
7072 */
7073 count_devindex = fwnode_property_count_u32(fwnode, "cirrus,dev-index");
7074 if (count_devindex > 0)
7075 count = count_devindex;
7076
7077 match = devm_kasprintf(dev, GFP_KERNEL, "-%%s:00-%s.%%d", acpi_ids[i].name);
7078 if (!match)
7079 return;
7080 codec_info(cdc, "Found %d %s on %s (%s)\n", count, acpi_ids[i].hid, bus, match);
7081 comp_generic_fixup(cdc, HDA_FIXUP_ACT_PRE_PROBE, bus, acpi_ids[i].hid, match, count);
7082 }
7083
cs35l41_fixup_i2c_two(struct hda_codec * cdc,const struct hda_fixup * fix,int action)7084 static void cs35l41_fixup_i2c_two(struct hda_codec *cdc, const struct hda_fixup *fix, int action)
7085 {
7086 comp_generic_fixup(cdc, action, "i2c", "CSC3551", "-%s:00-cs35l41-hda.%d", 2);
7087 }
7088
cs35l41_fixup_i2c_four(struct hda_codec * cdc,const struct hda_fixup * fix,int action)7089 static void cs35l41_fixup_i2c_four(struct hda_codec *cdc, const struct hda_fixup *fix, int action)
7090 {
7091 comp_generic_fixup(cdc, action, "i2c", "CSC3551", "-%s:00-cs35l41-hda.%d", 4);
7092 }
7093
cs35l41_fixup_spi_two(struct hda_codec * codec,const struct hda_fixup * fix,int action)7094 static void cs35l41_fixup_spi_two(struct hda_codec *codec, const struct hda_fixup *fix, int action)
7095 {
7096 comp_generic_fixup(codec, action, "spi", "CSC3551", "-%s:00-cs35l41-hda.%d", 2);
7097 }
7098
cs35l41_fixup_spi_four(struct hda_codec * codec,const struct hda_fixup * fix,int action)7099 static void cs35l41_fixup_spi_four(struct hda_codec *codec, const struct hda_fixup *fix, int action)
7100 {
7101 comp_generic_fixup(codec, action, "spi", "CSC3551", "-%s:00-cs35l41-hda.%d", 4);
7102 }
7103
alc287_fixup_legion_16achg6_speakers(struct hda_codec * cdc,const struct hda_fixup * fix,int action)7104 static void alc287_fixup_legion_16achg6_speakers(struct hda_codec *cdc, const struct hda_fixup *fix,
7105 int action)
7106 {
7107 comp_generic_fixup(cdc, action, "i2c", "CLSA0100", "-%s:00-cs35l41-hda.%d", 2);
7108 }
7109
alc287_fixup_legion_16ithg6_speakers(struct hda_codec * cdc,const struct hda_fixup * fix,int action)7110 static void alc287_fixup_legion_16ithg6_speakers(struct hda_codec *cdc, const struct hda_fixup *fix,
7111 int action)
7112 {
7113 comp_generic_fixup(cdc, action, "i2c", "CLSA0101", "-%s:00-cs35l41-hda.%d", 2);
7114 }
7115
alc285_fixup_asus_ga403u(struct hda_codec * cdc,const struct hda_fixup * fix,int action)7116 static void alc285_fixup_asus_ga403u(struct hda_codec *cdc, const struct hda_fixup *fix, int action)
7117 {
7118 /*
7119 * The same SSID has been re-used in different hardware, they have
7120 * different codecs and the newer GA403U has a ALC285.
7121 */
7122 if (cdc->core.vendor_id != 0x10ec0285)
7123 alc_fixup_inv_dmic(cdc, fix, action);
7124 }
7125
tas2781_fixup_i2c(struct hda_codec * cdc,const struct hda_fixup * fix,int action)7126 static void tas2781_fixup_i2c(struct hda_codec *cdc,
7127 const struct hda_fixup *fix, int action)
7128 {
7129 comp_generic_fixup(cdc, action, "i2c", "TIAS2781", "-%s:00", 1);
7130 }
7131
yoga7_14arb7_fixup_i2c(struct hda_codec * cdc,const struct hda_fixup * fix,int action)7132 static void yoga7_14arb7_fixup_i2c(struct hda_codec *cdc,
7133 const struct hda_fixup *fix, int action)
7134 {
7135 comp_generic_fixup(cdc, action, "i2c", "INT8866", "-%s:00", 1);
7136 }
7137
alc256_fixup_acer_sfg16_micmute_led(struct hda_codec * codec,const struct hda_fixup * fix,int action)7138 static void alc256_fixup_acer_sfg16_micmute_led(struct hda_codec *codec,
7139 const struct hda_fixup *fix, int action)
7140 {
7141 alc_fixup_hp_gpio_led(codec, action, 0, 0x04);
7142 }
7143
7144
7145 /* for alc295_fixup_hp_top_speakers */
7146 #include "hp_x360_helper.c"
7147
7148 /* for alc285_fixup_ideapad_s740_coef() */
7149 #include "ideapad_s740_helper.c"
7150
7151 static const struct coef_fw alc256_fixup_set_coef_defaults_coefs[] = {
7152 WRITE_COEF(0x10, 0x0020), WRITE_COEF(0x24, 0x0000),
7153 WRITE_COEF(0x26, 0x0000), WRITE_COEF(0x29, 0x3000),
7154 WRITE_COEF(0x37, 0xfe05), WRITE_COEF(0x45, 0x5089),
7155 {}
7156 };
7157
alc256_fixup_set_coef_defaults(struct hda_codec * codec,const struct hda_fixup * fix,int action)7158 static void alc256_fixup_set_coef_defaults(struct hda_codec *codec,
7159 const struct hda_fixup *fix,
7160 int action)
7161 {
7162 /*
7163 * A certain other OS sets these coeffs to different values. On at least
7164 * one TongFang barebone these settings might survive even a cold
7165 * reboot. So to restore a clean slate the values are explicitly reset
7166 * to default here. Without this, the external microphone is always in a
7167 * plugged-in state, while the internal microphone is always in an
7168 * unplugged state, breaking the ability to use the internal microphone.
7169 */
7170 alc_process_coef_fw(codec, alc256_fixup_set_coef_defaults_coefs);
7171 }
7172
7173 static const struct coef_fw alc233_fixup_no_audio_jack_coefs[] = {
7174 WRITE_COEF(0x1a, 0x9003), WRITE_COEF(0x1b, 0x0e2b), WRITE_COEF(0x37, 0xfe06),
7175 WRITE_COEF(0x38, 0x4981), WRITE_COEF(0x45, 0xd489), WRITE_COEF(0x46, 0x0074),
7176 WRITE_COEF(0x49, 0x0149),
7177 {}
7178 };
7179
alc233_fixup_no_audio_jack(struct hda_codec * codec,const struct hda_fixup * fix,int action)7180 static void alc233_fixup_no_audio_jack(struct hda_codec *codec,
7181 const struct hda_fixup *fix,
7182 int action)
7183 {
7184 /*
7185 * The audio jack input and output is not detected on the ASRock NUC Box
7186 * 1100 series when cold booting without this fix. Warm rebooting from a
7187 * certain other OS makes the audio functional, as COEF settings are
7188 * preserved in this case. This fix sets these altered COEF values as
7189 * the default.
7190 */
7191 alc_process_coef_fw(codec, alc233_fixup_no_audio_jack_coefs);
7192 }
7193
alc256_fixup_mic_no_presence_and_resume(struct hda_codec * codec,const struct hda_fixup * fix,int action)7194 static void alc256_fixup_mic_no_presence_and_resume(struct hda_codec *codec,
7195 const struct hda_fixup *fix,
7196 int action)
7197 {
7198 /*
7199 * The Clevo NJ51CU comes either with the ALC293 or the ALC256 codec,
7200 * but uses the 0x8686 subproduct id in both cases. The ALC256 codec
7201 * needs an additional quirk for sound working after suspend and resume.
7202 */
7203 if (codec->core.vendor_id == 0x10ec0256) {
7204 alc_update_coef_idx(codec, 0x10, 1<<9, 0);
7205 snd_hda_codec_set_pincfg(codec, 0x19, 0x04a11120);
7206 } else {
7207 snd_hda_codec_set_pincfg(codec, 0x1a, 0x04a1113c);
7208 }
7209 }
7210
alc256_decrease_headphone_amp_val(struct hda_codec * codec,const struct hda_fixup * fix,int action)7211 static void alc256_decrease_headphone_amp_val(struct hda_codec *codec,
7212 const struct hda_fixup *fix, int action)
7213 {
7214 u32 caps;
7215 u8 nsteps, offs;
7216
7217 if (action != HDA_FIXUP_ACT_PRE_PROBE)
7218 return;
7219
7220 caps = query_amp_caps(codec, 0x3, HDA_OUTPUT);
7221 nsteps = ((caps & AC_AMPCAP_NUM_STEPS) >> AC_AMPCAP_NUM_STEPS_SHIFT) - 10;
7222 offs = ((caps & AC_AMPCAP_OFFSET) >> AC_AMPCAP_OFFSET_SHIFT) - 10;
7223 caps &= ~AC_AMPCAP_NUM_STEPS & ~AC_AMPCAP_OFFSET;
7224 caps |= (nsteps << AC_AMPCAP_NUM_STEPS_SHIFT) | (offs << AC_AMPCAP_OFFSET_SHIFT);
7225
7226 if (snd_hda_override_amp_caps(codec, 0x3, HDA_OUTPUT, caps))
7227 codec_warn(codec, "failed to override amp caps for NID 0x3\n");
7228 }
7229
alc_fixup_dell4_mic_no_presence_quiet(struct hda_codec * codec,const struct hda_fixup * fix,int action)7230 static void alc_fixup_dell4_mic_no_presence_quiet(struct hda_codec *codec,
7231 const struct hda_fixup *fix,
7232 int action)
7233 {
7234 struct alc_spec *spec = codec->spec;
7235 struct hda_input_mux *imux = &spec->gen.input_mux;
7236 int i;
7237
7238 alc269_fixup_limit_int_mic_boost(codec, fix, action);
7239
7240 switch (action) {
7241 case HDA_FIXUP_ACT_PRE_PROBE:
7242 /**
7243 * Set the vref of pin 0x19 (Headset Mic) and pin 0x1b (Headphone Mic)
7244 * to Hi-Z to avoid pop noises at startup and when plugging and
7245 * unplugging headphones.
7246 */
7247 snd_hda_codec_set_pin_target(codec, 0x19, PIN_VREFHIZ);
7248 snd_hda_codec_set_pin_target(codec, 0x1b, PIN_VREFHIZ);
7249 break;
7250 case HDA_FIXUP_ACT_PROBE:
7251 /**
7252 * Make the internal mic (0x12) the default input source to
7253 * prevent pop noises on cold boot.
7254 */
7255 for (i = 0; i < imux->num_items; i++) {
7256 if (spec->gen.imux_pins[i] == 0x12) {
7257 spec->gen.cur_mux[0] = i;
7258 break;
7259 }
7260 }
7261 break;
7262 }
7263 }
7264
alc287_fixup_yoga9_14iap7_bass_spk_pin(struct hda_codec * codec,const struct hda_fixup * fix,int action)7265 static void alc287_fixup_yoga9_14iap7_bass_spk_pin(struct hda_codec *codec,
7266 const struct hda_fixup *fix, int action)
7267 {
7268 /*
7269 * The Pin Complex 0x17 for the bass speakers is wrongly reported as
7270 * unconnected.
7271 */
7272 static const struct hda_pintbl pincfgs[] = {
7273 { 0x17, 0x90170121 },
7274 { }
7275 };
7276 /*
7277 * Avoid DAC 0x06 and 0x08, as they have no volume controls.
7278 * DAC 0x02 and 0x03 would be fine.
7279 */
7280 static const hda_nid_t conn[] = { 0x02, 0x03 };
7281 /*
7282 * Prefer both speakerbar (0x14) and bass speakers (0x17) connected to DAC 0x02.
7283 * Headphones (0x21) are connected to DAC 0x03.
7284 */
7285 static const hda_nid_t preferred_pairs[] = {
7286 0x14, 0x02,
7287 0x17, 0x02,
7288 0x21, 0x03,
7289 0
7290 };
7291 struct alc_spec *spec = codec->spec;
7292
7293 switch (action) {
7294 case HDA_FIXUP_ACT_PRE_PROBE:
7295 snd_hda_apply_pincfgs(codec, pincfgs);
7296 snd_hda_override_conn_list(codec, 0x17, ARRAY_SIZE(conn), conn);
7297 spec->gen.preferred_dacs = preferred_pairs;
7298 break;
7299 }
7300 }
7301
alc295_fixup_dell_inspiron_top_speakers(struct hda_codec * codec,const struct hda_fixup * fix,int action)7302 static void alc295_fixup_dell_inspiron_top_speakers(struct hda_codec *codec,
7303 const struct hda_fixup *fix, int action)
7304 {
7305 static const struct hda_pintbl pincfgs[] = {
7306 { 0x14, 0x90170151 },
7307 { 0x17, 0x90170150 },
7308 { }
7309 };
7310 static const hda_nid_t conn[] = { 0x02, 0x03 };
7311 static const hda_nid_t preferred_pairs[] = {
7312 0x14, 0x02,
7313 0x17, 0x03,
7314 0x21, 0x02,
7315 0
7316 };
7317 struct alc_spec *spec = codec->spec;
7318
7319 alc_fixup_no_shutup(codec, fix, action);
7320
7321 switch (action) {
7322 case HDA_FIXUP_ACT_PRE_PROBE:
7323 snd_hda_apply_pincfgs(codec, pincfgs);
7324 snd_hda_override_conn_list(codec, 0x17, ARRAY_SIZE(conn), conn);
7325 spec->gen.preferred_dacs = preferred_pairs;
7326 break;
7327 }
7328 }
7329
7330 /* Forcibly assign NID 0x03 to HP while NID 0x02 to SPK */
alc287_fixup_bind_dacs(struct hda_codec * codec,const struct hda_fixup * fix,int action)7331 static void alc287_fixup_bind_dacs(struct hda_codec *codec,
7332 const struct hda_fixup *fix, int action)
7333 {
7334 struct alc_spec *spec = codec->spec;
7335 static const hda_nid_t conn[] = { 0x02, 0x03 }; /* exclude 0x06 */
7336 static const hda_nid_t preferred_pairs[] = {
7337 0x17, 0x02, 0x21, 0x03, 0
7338 };
7339
7340 if (action != HDA_FIXUP_ACT_PRE_PROBE)
7341 return;
7342
7343 snd_hda_override_conn_list(codec, 0x17, ARRAY_SIZE(conn), conn);
7344 spec->gen.preferred_dacs = preferred_pairs;
7345 spec->gen.auto_mute_via_amp = 1;
7346 if (spec->gen.autocfg.speaker_pins[0] != 0x14) {
7347 snd_hda_codec_write_cache(codec, 0x14, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
7348 0x0); /* Make sure 0x14 was disable */
7349 }
7350 }
7351 /* Fix none verb table of Headset Mic pin */
alc_fixup_headset_mic(struct hda_codec * codec,const struct hda_fixup * fix,int action)7352 static void alc_fixup_headset_mic(struct hda_codec *codec,
7353 const struct hda_fixup *fix, int action)
7354 {
7355 struct alc_spec *spec = codec->spec;
7356 static const struct hda_pintbl pincfgs[] = {
7357 { 0x19, 0x03a1103c },
7358 { }
7359 };
7360
7361 switch (action) {
7362 case HDA_FIXUP_ACT_PRE_PROBE:
7363 snd_hda_apply_pincfgs(codec, pincfgs);
7364 alc_update_coef_idx(codec, 0x45, 0xf<<12 | 1<<10, 5<<12);
7365 spec->parse_flags |= HDA_PINCFG_HEADSET_MIC;
7366 break;
7367 }
7368 }
7369
alc245_fixup_hp_spectre_x360_eu0xxx(struct hda_codec * codec,const struct hda_fixup * fix,int action)7370 static void alc245_fixup_hp_spectre_x360_eu0xxx(struct hda_codec *codec,
7371 const struct hda_fixup *fix, int action)
7372 {
7373 /*
7374 * The Pin Complex 0x14 for the treble speakers is wrongly reported as
7375 * unconnected.
7376 * The Pin Complex 0x17 for the bass speakers has the lowest association
7377 * and sequence values so shift it up a bit to squeeze 0x14 in.
7378 */
7379 static const struct hda_pintbl pincfgs[] = {
7380 { 0x14, 0x90170110 }, // top/treble
7381 { 0x17, 0x90170111 }, // bottom/bass
7382 { }
7383 };
7384
7385 /*
7386 * Force DAC 0x02 for the bass speakers 0x17.
7387 */
7388 static const hda_nid_t conn[] = { 0x02 };
7389
7390 switch (action) {
7391 case HDA_FIXUP_ACT_PRE_PROBE:
7392 snd_hda_apply_pincfgs(codec, pincfgs);
7393 snd_hda_override_conn_list(codec, 0x17, ARRAY_SIZE(conn), conn);
7394 break;
7395 }
7396
7397 cs35l41_fixup_i2c_two(codec, fix, action);
7398 alc245_fixup_hp_mute_led_coefbit(codec, fix, action);
7399 alc245_fixup_hp_gpio_led(codec, fix, action);
7400 }
7401
7402 /* some changes for Spectre x360 16, 2024 model */
alc245_fixup_hp_spectre_x360_16_aa0xxx(struct hda_codec * codec,const struct hda_fixup * fix,int action)7403 static void alc245_fixup_hp_spectre_x360_16_aa0xxx(struct hda_codec *codec,
7404 const struct hda_fixup *fix, int action)
7405 {
7406 /*
7407 * The Pin Complex 0x14 for the treble speakers is wrongly reported as
7408 * unconnected.
7409 * The Pin Complex 0x17 for the bass speakers has the lowest association
7410 * and sequence values so shift it up a bit to squeeze 0x14 in.
7411 */
7412 struct alc_spec *spec = codec->spec;
7413 static const struct hda_pintbl pincfgs[] = {
7414 { 0x14, 0x90170110 }, // top/treble
7415 { 0x17, 0x90170111 }, // bottom/bass
7416 { }
7417 };
7418
7419 /*
7420 * Force DAC 0x02 for the bass speakers 0x17.
7421 */
7422 static const hda_nid_t conn[] = { 0x02 };
7423
7424 switch (action) {
7425 case HDA_FIXUP_ACT_PRE_PROBE:
7426 /* needed for amp of back speakers */
7427 spec->gpio_mask |= 0x01;
7428 spec->gpio_dir |= 0x01;
7429 snd_hda_apply_pincfgs(codec, pincfgs);
7430 snd_hda_override_conn_list(codec, 0x17, ARRAY_SIZE(conn), conn);
7431 break;
7432 case HDA_FIXUP_ACT_INIT:
7433 /* need to toggle GPIO to enable the amp of back speakers */
7434 alc_update_gpio_data(codec, 0x01, true);
7435 msleep(100);
7436 alc_update_gpio_data(codec, 0x01, false);
7437 break;
7438 }
7439
7440 cs35l41_fixup_i2c_two(codec, fix, action);
7441 alc245_fixup_hp_mute_led_coefbit(codec, fix, action);
7442 alc245_fixup_hp_gpio_led(codec, fix, action);
7443 }
7444
7445 /*
7446 * ALC287 PCM hooks
7447 */
alc287_alc1318_playback_pcm_hook(struct hda_pcm_stream * hinfo,struct hda_codec * codec,struct snd_pcm_substream * substream,int action)7448 static void alc287_alc1318_playback_pcm_hook(struct hda_pcm_stream *hinfo,
7449 struct hda_codec *codec,
7450 struct snd_pcm_substream *substream,
7451 int action)
7452 {
7453 alc_write_coef_idx(codec, 0x10, 0x8806); /* Change MLK to GPIO3 */
7454 switch (action) {
7455 case HDA_GEN_PCM_ACT_OPEN:
7456 alc_write_coefex_idx(codec, 0x5a, 0x00, 0x954f); /* write gpio3 to high */
7457 break;
7458 case HDA_GEN_PCM_ACT_CLOSE:
7459 alc_write_coefex_idx(codec, 0x5a, 0x00, 0x554f); /* write gpio3 as default value */
7460 break;
7461 }
7462 }
7463
alc287_s4_power_gpio3_default(struct hda_codec * codec)7464 static void alc287_s4_power_gpio3_default(struct hda_codec *codec)
7465 {
7466 if (is_s4_suspend(codec)) {
7467 alc_write_coef_idx(codec, 0x10, 0x8806); /* Change MLK to GPIO3 */
7468 alc_write_coefex_idx(codec, 0x5a, 0x00, 0x554f); /* write gpio3 as default value */
7469 }
7470 }
7471
alc287_fixup_lenovo_thinkpad_with_alc1318(struct hda_codec * codec,const struct hda_fixup * fix,int action)7472 static void alc287_fixup_lenovo_thinkpad_with_alc1318(struct hda_codec *codec,
7473 const struct hda_fixup *fix, int action)
7474 {
7475 struct alc_spec *spec = codec->spec;
7476
7477 if (action != HDA_FIXUP_ACT_PRE_PROBE)
7478 return;
7479 spec->power_hook = alc287_s4_power_gpio3_default;
7480 spec->gen.pcm_playback_hook = alc287_alc1318_playback_pcm_hook;
7481 }
7482
7483
7484 enum {
7485 ALC269_FIXUP_GPIO2,
7486 ALC269_FIXUP_SONY_VAIO,
7487 ALC275_FIXUP_SONY_VAIO_GPIO2,
7488 ALC269_FIXUP_DELL_M101Z,
7489 ALC269_FIXUP_SKU_IGNORE,
7490 ALC269_FIXUP_ASUS_G73JW,
7491 ALC269_FIXUP_ASUS_N7601ZM_PINS,
7492 ALC269_FIXUP_ASUS_N7601ZM,
7493 ALC269_FIXUP_LENOVO_EAPD,
7494 ALC275_FIXUP_SONY_HWEQ,
7495 ALC275_FIXUP_SONY_DISABLE_AAMIX,
7496 ALC271_FIXUP_DMIC,
7497 ALC269_FIXUP_PCM_44K,
7498 ALC269_FIXUP_STEREO_DMIC,
7499 ALC269_FIXUP_HEADSET_MIC,
7500 ALC269_FIXUP_QUANTA_MUTE,
7501 ALC269_FIXUP_LIFEBOOK,
7502 ALC269_FIXUP_LIFEBOOK_EXTMIC,
7503 ALC269_FIXUP_LIFEBOOK_HP_PIN,
7504 ALC269_FIXUP_LIFEBOOK_NO_HP_TO_LINEOUT,
7505 ALC255_FIXUP_LIFEBOOK_U7x7_HEADSET_MIC,
7506 ALC269_FIXUP_AMIC,
7507 ALC269_FIXUP_DMIC,
7508 ALC269VB_FIXUP_AMIC,
7509 ALC269VB_FIXUP_DMIC,
7510 ALC269_FIXUP_HP_MUTE_LED,
7511 ALC269_FIXUP_HP_MUTE_LED_MIC1,
7512 ALC269_FIXUP_HP_MUTE_LED_MIC2,
7513 ALC269_FIXUP_HP_MUTE_LED_MIC3,
7514 ALC269_FIXUP_HP_GPIO_LED,
7515 ALC269_FIXUP_HP_GPIO_MIC1_LED,
7516 ALC269_FIXUP_HP_LINE1_MIC1_LED,
7517 ALC269_FIXUP_INV_DMIC,
7518 ALC269_FIXUP_LENOVO_DOCK,
7519 ALC269_FIXUP_LENOVO_DOCK_LIMIT_BOOST,
7520 ALC269_FIXUP_NO_SHUTUP,
7521 ALC286_FIXUP_SONY_MIC_NO_PRESENCE,
7522 ALC269_FIXUP_PINCFG_NO_HP_TO_LINEOUT,
7523 ALC269_FIXUP_DELL1_MIC_NO_PRESENCE,
7524 ALC269_FIXUP_DELL1_LIMIT_INT_MIC_BOOST,
7525 ALC269_FIXUP_DELL2_MIC_NO_PRESENCE,
7526 ALC269_FIXUP_DELL3_MIC_NO_PRESENCE,
7527 ALC269_FIXUP_DELL4_MIC_NO_PRESENCE,
7528 ALC269_FIXUP_DELL4_MIC_NO_PRESENCE_QUIET,
7529 ALC269_FIXUP_HEADSET_MODE,
7530 ALC269_FIXUP_HEADSET_MODE_NO_HP_MIC,
7531 ALC269_FIXUP_ASPIRE_HEADSET_MIC,
7532 ALC269_FIXUP_ASUS_X101_FUNC,
7533 ALC269_FIXUP_ASUS_X101_VERB,
7534 ALC269_FIXUP_ASUS_X101,
7535 ALC271_FIXUP_AMIC_MIC2,
7536 ALC271_FIXUP_HP_GATE_MIC_JACK,
7537 ALC271_FIXUP_HP_GATE_MIC_JACK_E1_572,
7538 ALC269_FIXUP_ACER_AC700,
7539 ALC269_FIXUP_LIMIT_INT_MIC_BOOST,
7540 ALC269VB_FIXUP_ASUS_ZENBOOK,
7541 ALC269VB_FIXUP_ASUS_ZENBOOK_UX31A,
7542 ALC269VB_FIXUP_ASUS_MIC_NO_PRESENCE,
7543 ALC269_FIXUP_LIMIT_INT_MIC_BOOST_MUTE_LED,
7544 ALC269VB_FIXUP_ORDISSIMO_EVE2,
7545 ALC283_FIXUP_CHROME_BOOK,
7546 ALC283_FIXUP_SENSE_COMBO_JACK,
7547 ALC282_FIXUP_ASUS_TX300,
7548 ALC283_FIXUP_INT_MIC,
7549 ALC290_FIXUP_MONO_SPEAKERS,
7550 ALC290_FIXUP_MONO_SPEAKERS_HSJACK,
7551 ALC290_FIXUP_SUBWOOFER,
7552 ALC290_FIXUP_SUBWOOFER_HSJACK,
7553 ALC269_FIXUP_THINKPAD_ACPI,
7554 ALC269_FIXUP_DMIC_THINKPAD_ACPI,
7555 ALC269VB_FIXUP_INFINIX_ZERO_BOOK_13,
7556 ALC269VB_FIXUP_CHUWI_COREBOOK_XPRO,
7557 ALC255_FIXUP_ACER_MIC_NO_PRESENCE,
7558 ALC255_FIXUP_ASUS_MIC_NO_PRESENCE,
7559 ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
7560 ALC255_FIXUP_DELL1_LIMIT_INT_MIC_BOOST,
7561 ALC255_FIXUP_DELL2_MIC_NO_PRESENCE,
7562 ALC255_FIXUP_HEADSET_MODE,
7563 ALC255_FIXUP_HEADSET_MODE_NO_HP_MIC,
7564 ALC293_FIXUP_DELL1_MIC_NO_PRESENCE,
7565 ALC292_FIXUP_TPT440_DOCK,
7566 ALC292_FIXUP_TPT440,
7567 ALC283_FIXUP_HEADSET_MIC,
7568 ALC255_FIXUP_MIC_MUTE_LED,
7569 ALC282_FIXUP_ASPIRE_V5_PINS,
7570 ALC269VB_FIXUP_ASPIRE_E1_COEF,
7571 ALC280_FIXUP_HP_GPIO4,
7572 ALC286_FIXUP_HP_GPIO_LED,
7573 ALC280_FIXUP_HP_GPIO2_MIC_HOTKEY,
7574 ALC280_FIXUP_HP_DOCK_PINS,
7575 ALC269_FIXUP_HP_DOCK_GPIO_MIC1_LED,
7576 ALC280_FIXUP_HP_9480M,
7577 ALC245_FIXUP_HP_X360_AMP,
7578 ALC285_FIXUP_HP_SPECTRE_X360_EB1,
7579 ALC285_FIXUP_HP_ENVY_X360,
7580 ALC288_FIXUP_DELL_HEADSET_MODE,
7581 ALC288_FIXUP_DELL1_MIC_NO_PRESENCE,
7582 ALC288_FIXUP_DELL_XPS_13,
7583 ALC288_FIXUP_DISABLE_AAMIX,
7584 ALC292_FIXUP_DELL_E7X_AAMIX,
7585 ALC292_FIXUP_DELL_E7X,
7586 ALC292_FIXUP_DISABLE_AAMIX,
7587 ALC293_FIXUP_DISABLE_AAMIX_MULTIJACK,
7588 ALC298_FIXUP_ALIENWARE_MIC_NO_PRESENCE,
7589 ALC298_FIXUP_DELL1_MIC_NO_PRESENCE,
7590 ALC298_FIXUP_DELL_AIO_MIC_NO_PRESENCE,
7591 ALC275_FIXUP_DELL_XPS,
7592 ALC293_FIXUP_LENOVO_SPK_NOISE,
7593 ALC233_FIXUP_LENOVO_LINE2_MIC_HOTKEY,
7594 ALC255_FIXUP_DELL_SPK_NOISE,
7595 ALC225_FIXUP_DISABLE_MIC_VREF,
7596 ALC225_FIXUP_DELL1_MIC_NO_PRESENCE,
7597 ALC295_FIXUP_DISABLE_DAC3,
7598 ALC285_FIXUP_SPEAKER2_TO_DAC1,
7599 ALC285_FIXUP_ASUS_SPEAKER2_TO_DAC1,
7600 ALC285_FIXUP_ASUS_HEADSET_MIC,
7601 ALC285_FIXUP_ASUS_SPI_REAR_SPEAKERS,
7602 ALC285_FIXUP_ASUS_I2C_SPEAKER2_TO_DAC1,
7603 ALC285_FIXUP_ASUS_I2C_HEADSET_MIC,
7604 ALC280_FIXUP_HP_HEADSET_MIC,
7605 ALC221_FIXUP_HP_FRONT_MIC,
7606 ALC292_FIXUP_TPT460,
7607 ALC298_FIXUP_SPK_VOLUME,
7608 ALC298_FIXUP_LENOVO_SPK_VOLUME,
7609 ALC256_FIXUP_DELL_INSPIRON_7559_SUBWOOFER,
7610 ALC269_FIXUP_ATIV_BOOK_8,
7611 ALC221_FIXUP_HP_288PRO_MIC_NO_PRESENCE,
7612 ALC221_FIXUP_HP_MIC_NO_PRESENCE,
7613 ALC256_FIXUP_ASUS_HEADSET_MODE,
7614 ALC256_FIXUP_ASUS_MIC,
7615 ALC256_FIXUP_ASUS_AIO_GPIO2,
7616 ALC233_FIXUP_ASUS_MIC_NO_PRESENCE,
7617 ALC233_FIXUP_EAPD_COEF_AND_MIC_NO_PRESENCE,
7618 ALC233_FIXUP_LENOVO_MULTI_CODECS,
7619 ALC233_FIXUP_ACER_HEADSET_MIC,
7620 ALC294_FIXUP_LENOVO_MIC_LOCATION,
7621 ALC225_FIXUP_DELL_WYSE_MIC_NO_PRESENCE,
7622 ALC225_FIXUP_S3_POP_NOISE,
7623 ALC700_FIXUP_INTEL_REFERENCE,
7624 ALC274_FIXUP_DELL_BIND_DACS,
7625 ALC274_FIXUP_DELL_AIO_LINEOUT_VERB,
7626 ALC298_FIXUP_TPT470_DOCK_FIX,
7627 ALC298_FIXUP_TPT470_DOCK,
7628 ALC255_FIXUP_DUMMY_LINEOUT_VERB,
7629 ALC255_FIXUP_DELL_HEADSET_MIC,
7630 ALC256_FIXUP_HUAWEI_MACH_WX9_PINS,
7631 ALC298_FIXUP_HUAWEI_MBX_STEREO,
7632 ALC295_FIXUP_HP_X360,
7633 ALC221_FIXUP_HP_HEADSET_MIC,
7634 ALC285_FIXUP_LENOVO_HEADPHONE_NOISE,
7635 ALC295_FIXUP_HP_AUTO_MUTE,
7636 ALC286_FIXUP_ACER_AIO_MIC_NO_PRESENCE,
7637 ALC294_FIXUP_ASUS_MIC,
7638 ALC294_FIXUP_ASUS_HEADSET_MIC,
7639 ALC294_FIXUP_ASUS_SPK,
7640 ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE,
7641 ALC285_FIXUP_LENOVO_PC_BEEP_IN_NOISE,
7642 ALC255_FIXUP_ACER_HEADSET_MIC,
7643 ALC295_FIXUP_CHROME_BOOK,
7644 ALC225_FIXUP_HEADSET_JACK,
7645 ALC225_FIXUP_DELL_WYSE_AIO_MIC_NO_PRESENCE,
7646 ALC225_FIXUP_WYSE_AUTO_MUTE,
7647 ALC225_FIXUP_WYSE_DISABLE_MIC_VREF,
7648 ALC286_FIXUP_ACER_AIO_HEADSET_MIC,
7649 ALC256_FIXUP_ASUS_HEADSET_MIC,
7650 ALC256_FIXUP_ASUS_MIC_NO_PRESENCE,
7651 ALC255_FIXUP_PREDATOR_SUBWOOFER,
7652 ALC299_FIXUP_PREDATOR_SPK,
7653 ALC256_FIXUP_MEDION_HEADSET_NO_PRESENCE,
7654 ALC289_FIXUP_DELL_SPK1,
7655 ALC289_FIXUP_DELL_SPK2,
7656 ALC289_FIXUP_DUAL_SPK,
7657 ALC289_FIXUP_RTK_AMP_DUAL_SPK,
7658 ALC294_FIXUP_SPK2_TO_DAC1,
7659 ALC294_FIXUP_ASUS_DUAL_SPK,
7660 ALC285_FIXUP_THINKPAD_X1_GEN7,
7661 ALC285_FIXUP_THINKPAD_HEADSET_JACK,
7662 ALC294_FIXUP_ASUS_ALLY,
7663 ALC294_FIXUP_ASUS_ALLY_X,
7664 ALC294_FIXUP_ASUS_ALLY_PINS,
7665 ALC294_FIXUP_ASUS_ALLY_VERBS,
7666 ALC294_FIXUP_ASUS_ALLY_SPEAKER,
7667 ALC294_FIXUP_ASUS_HPE,
7668 ALC294_FIXUP_ASUS_COEF_1B,
7669 ALC294_FIXUP_ASUS_GX502_HP,
7670 ALC294_FIXUP_ASUS_GX502_PINS,
7671 ALC294_FIXUP_ASUS_GX502_VERBS,
7672 ALC294_FIXUP_ASUS_GU502_HP,
7673 ALC294_FIXUP_ASUS_GU502_PINS,
7674 ALC294_FIXUP_ASUS_GU502_VERBS,
7675 ALC294_FIXUP_ASUS_G513_PINS,
7676 ALC285_FIXUP_ASUS_G533Z_PINS,
7677 ALC285_FIXUP_HP_GPIO_LED,
7678 ALC285_FIXUP_HP_MUTE_LED,
7679 ALC285_FIXUP_HP_SPECTRE_X360_MUTE_LED,
7680 ALC236_FIXUP_HP_MUTE_LED_COEFBIT2,
7681 ALC236_FIXUP_HP_GPIO_LED,
7682 ALC236_FIXUP_HP_MUTE_LED,
7683 ALC236_FIXUP_HP_MUTE_LED_MICMUTE_VREF,
7684 ALC236_FIXUP_LENOVO_INV_DMIC,
7685 ALC298_FIXUP_SAMSUNG_AMP,
7686 ALC298_FIXUP_SAMSUNG_AMP_V2_2_AMPS,
7687 ALC298_FIXUP_SAMSUNG_AMP_V2_4_AMPS,
7688 ALC298_FIXUP_SAMSUNG_HEADPHONE_VERY_QUIET,
7689 ALC256_FIXUP_SAMSUNG_HEADPHONE_VERY_QUIET,
7690 ALC295_FIXUP_ASUS_MIC_NO_PRESENCE,
7691 ALC269VC_FIXUP_ACER_VCOPPERBOX_PINS,
7692 ALC269VC_FIXUP_ACER_HEADSET_MIC,
7693 ALC269VC_FIXUP_ACER_MIC_NO_PRESENCE,
7694 ALC289_FIXUP_ASUS_GA401,
7695 ALC289_FIXUP_ASUS_GA502,
7696 ALC256_FIXUP_ACER_MIC_NO_PRESENCE,
7697 ALC285_FIXUP_HP_GPIO_AMP_INIT,
7698 ALC269_FIXUP_CZC_B20,
7699 ALC269_FIXUP_CZC_TMI,
7700 ALC269_FIXUP_CZC_L101,
7701 ALC269_FIXUP_LEMOTE_A1802,
7702 ALC269_FIXUP_LEMOTE_A190X,
7703 ALC256_FIXUP_INTEL_NUC8_RUGGED,
7704 ALC233_FIXUP_INTEL_NUC8_DMIC,
7705 ALC233_FIXUP_INTEL_NUC8_BOOST,
7706 ALC256_FIXUP_INTEL_NUC10,
7707 ALC255_FIXUP_XIAOMI_HEADSET_MIC,
7708 ALC274_FIXUP_HP_MIC,
7709 ALC274_FIXUP_HP_HEADSET_MIC,
7710 ALC274_FIXUP_HP_ENVY_GPIO,
7711 ALC256_FIXUP_ASUS_HPE,
7712 ALC285_FIXUP_THINKPAD_NO_BASS_SPK_HEADSET_JACK,
7713 ALC287_FIXUP_HP_GPIO_LED,
7714 ALC256_FIXUP_HP_HEADSET_MIC,
7715 ALC245_FIXUP_HP_GPIO_LED,
7716 ALC236_FIXUP_DELL_AIO_HEADSET_MIC,
7717 ALC282_FIXUP_ACER_DISABLE_LINEOUT,
7718 ALC255_FIXUP_ACER_LIMIT_INT_MIC_BOOST,
7719 ALC256_FIXUP_ACER_HEADSET_MIC,
7720 ALC285_FIXUP_IDEAPAD_S740_COEF,
7721 ALC285_FIXUP_HP_LIMIT_INT_MIC_BOOST,
7722 ALC295_FIXUP_ASUS_DACS,
7723 ALC295_FIXUP_HP_OMEN,
7724 ALC285_FIXUP_HP_SPECTRE_X360,
7725 ALC287_FIXUP_IDEAPAD_BASS_SPK_AMP,
7726 ALC623_FIXUP_LENOVO_THINKSTATION_P340,
7727 ALC255_FIXUP_ACER_HEADPHONE_AND_MIC,
7728 ALC236_FIXUP_HP_LIMIT_INT_MIC_BOOST,
7729 ALC287_FIXUP_LEGION_15IMHG05_SPEAKERS,
7730 ALC287_FIXUP_LEGION_15IMHG05_AUTOMUTE,
7731 ALC287_FIXUP_YOGA7_14ITL_SPEAKERS,
7732 ALC298_FIXUP_LENOVO_C940_DUET7,
7733 ALC287_FIXUP_LENOVO_14IRP8_DUETITL,
7734 ALC287_FIXUP_LENOVO_LEGION_7,
7735 ALC287_FIXUP_13S_GEN2_SPEAKERS,
7736 ALC256_FIXUP_SET_COEF_DEFAULTS,
7737 ALC256_FIXUP_SYSTEM76_MIC_NO_PRESENCE,
7738 ALC233_FIXUP_NO_AUDIO_JACK,
7739 ALC256_FIXUP_MIC_NO_PRESENCE_AND_RESUME,
7740 ALC285_FIXUP_LEGION_Y9000X_SPEAKERS,
7741 ALC285_FIXUP_LEGION_Y9000X_AUTOMUTE,
7742 ALC287_FIXUP_LEGION_16ACHG6,
7743 ALC287_FIXUP_CS35L41_I2C_2,
7744 ALC287_FIXUP_CS35L41_I2C_2_HP_GPIO_LED,
7745 ALC287_FIXUP_CS35L41_I2C_4,
7746 ALC245_FIXUP_CS35L41_SPI_2,
7747 ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED,
7748 ALC245_FIXUP_CS35L41_SPI_4,
7749 ALC245_FIXUP_CS35L41_SPI_4_HP_GPIO_LED,
7750 ALC285_FIXUP_HP_SPEAKERS_MICMUTE_LED,
7751 ALC295_FIXUP_FRAMEWORK_LAPTOP_MIC_NO_PRESENCE,
7752 ALC287_FIXUP_LEGION_16ITHG6,
7753 ALC287_FIXUP_YOGA9_14IAP7_BASS_SPK,
7754 ALC287_FIXUP_YOGA9_14IAP7_BASS_SPK_PIN,
7755 ALC287_FIXUP_YOGA9_14IMH9_BASS_SPK_PIN,
7756 ALC295_FIXUP_DELL_INSPIRON_TOP_SPEAKERS,
7757 ALC236_FIXUP_DELL_DUAL_CODECS,
7758 ALC287_FIXUP_CS35L41_I2C_2_THINKPAD_ACPI,
7759 ALC287_FIXUP_TAS2781_I2C,
7760 ALC287_FIXUP_YOGA7_14ARB7_I2C,
7761 ALC245_FIXUP_HP_MUTE_LED_COEFBIT,
7762 ALC245_FIXUP_HP_X360_MUTE_LEDS,
7763 ALC287_FIXUP_THINKPAD_I2S_SPK,
7764 ALC287_FIXUP_MG_RTKC_CSAMP_CS35L41_I2C_THINKPAD,
7765 ALC2XX_FIXUP_HEADSET_MIC,
7766 ALC289_FIXUP_DELL_CS35L41_SPI_2,
7767 ALC294_FIXUP_CS35L41_I2C_2,
7768 ALC256_FIXUP_ACER_SFG16_MICMUTE_LED,
7769 ALC256_FIXUP_HEADPHONE_AMP_VOL,
7770 ALC245_FIXUP_HP_SPECTRE_X360_EU0XXX,
7771 ALC245_FIXUP_HP_SPECTRE_X360_16_AA0XXX,
7772 ALC285_FIXUP_ASUS_GA403U,
7773 ALC285_FIXUP_ASUS_GA403U_HEADSET_MIC,
7774 ALC285_FIXUP_ASUS_GA403U_I2C_SPEAKER2_TO_DAC1,
7775 ALC285_FIXUP_ASUS_GU605_SPI_2_HEADSET_MIC,
7776 ALC285_FIXUP_ASUS_GU605_SPI_SPEAKER2_TO_DAC1,
7777 ALC287_FIXUP_LENOVO_THKPAD_WH_ALC1318,
7778 ALC256_FIXUP_CHROME_BOOK,
7779 ALC287_FIXUP_LENOVO_14ARP8_LEGION_IAH7,
7780 ALC287_FIXUP_LENOVO_SSID_17AA3820,
7781 ALC245_FIXUP_CLEVO_NOISY_MIC,
7782 ALC269_FIXUP_VAIO_VJFH52_MIC_NO_PRESENCE,
7783 };
7784
7785 /* A special fixup for Lenovo C940 and Yoga Duet 7;
7786 * both have the very same PCI SSID, and we need to apply different fixups
7787 * depending on the codec ID
7788 */
alc298_fixup_lenovo_c940_duet7(struct hda_codec * codec,const struct hda_fixup * fix,int action)7789 static void alc298_fixup_lenovo_c940_duet7(struct hda_codec *codec,
7790 const struct hda_fixup *fix,
7791 int action)
7792 {
7793 int id;
7794
7795 if (codec->core.vendor_id == 0x10ec0298)
7796 id = ALC298_FIXUP_LENOVO_SPK_VOLUME; /* C940 */
7797 else
7798 id = ALC287_FIXUP_YOGA7_14ITL_SPEAKERS; /* Duet 7 */
7799 __snd_hda_apply_fixup(codec, id, action, 0);
7800 }
7801
7802 /* A special fixup for Lenovo Slim/Yoga Pro 9 14IRP8 and Yoga DuetITL 2021;
7803 * 14IRP8 PCI SSID will mistakenly be matched with the DuetITL codec SSID,
7804 * so we need to apply a different fixup in this case. The only DuetITL codec
7805 * SSID reported so far is the 17aa:3802 while the 14IRP8 has the 17aa:38be
7806 * and 17aa:38bf. If it weren't for the PCI SSID, the 14IRP8 models would
7807 * have matched correctly by their codecs.
7808 */
alc287_fixup_lenovo_14irp8_duetitl(struct hda_codec * codec,const struct hda_fixup * fix,int action)7809 static void alc287_fixup_lenovo_14irp8_duetitl(struct hda_codec *codec,
7810 const struct hda_fixup *fix,
7811 int action)
7812 {
7813 int id;
7814
7815 if (codec->core.subsystem_id == 0x17aa3802)
7816 id = ALC287_FIXUP_YOGA7_14ITL_SPEAKERS; /* DuetITL */
7817 else
7818 id = ALC287_FIXUP_TAS2781_I2C; /* 14IRP8 */
7819 __snd_hda_apply_fixup(codec, id, action, 0);
7820 }
7821
7822 /* Similar to above the Lenovo Yoga Pro 7 14ARP8 PCI SSID matches the codec SSID of the
7823 Legion Y9000X 2022 IAH7.*/
alc287_fixup_lenovo_14arp8_legion_iah7(struct hda_codec * codec,const struct hda_fixup * fix,int action)7824 static void alc287_fixup_lenovo_14arp8_legion_iah7(struct hda_codec *codec,
7825 const struct hda_fixup *fix,
7826 int action)
7827 {
7828 int id;
7829
7830 if (codec->core.subsystem_id == 0x17aa386e)
7831 id = ALC287_FIXUP_CS35L41_I2C_2; /* Legion Y9000X 2022 IAH7 */
7832 else
7833 id = ALC285_FIXUP_SPEAKER2_TO_DAC1; /* Yoga Pro 7 14ARP8 */
7834 __snd_hda_apply_fixup(codec, id, action, 0);
7835 }
7836
7837 /* Another hilarious PCI SSID conflict with Lenovo Legion Pro 7 16ARX8H (with
7838 * TAS2781 codec) and Legion 7i 16IAX7 (with CS35L41 codec);
7839 * we apply a corresponding fixup depending on the codec SSID instead
7840 */
alc287_fixup_lenovo_legion_7(struct hda_codec * codec,const struct hda_fixup * fix,int action)7841 static void alc287_fixup_lenovo_legion_7(struct hda_codec *codec,
7842 const struct hda_fixup *fix,
7843 int action)
7844 {
7845 int id;
7846
7847 if (codec->core.subsystem_id == 0x17aa38a8)
7848 id = ALC287_FIXUP_TAS2781_I2C; /* Legion Pro 7 16ARX8H */
7849 else
7850 id = ALC287_FIXUP_CS35L41_I2C_2; /* Legion 7i 16IAX7 */
7851 __snd_hda_apply_fixup(codec, id, action, 0);
7852 }
7853
7854 /* Yet more conflicting PCI SSID (17aa:3820) on two Lenovo models */
alc287_fixup_lenovo_ssid_17aa3820(struct hda_codec * codec,const struct hda_fixup * fix,int action)7855 static void alc287_fixup_lenovo_ssid_17aa3820(struct hda_codec *codec,
7856 const struct hda_fixup *fix,
7857 int action)
7858 {
7859 int id;
7860
7861 if (codec->core.subsystem_id == 0x17aa3820)
7862 id = ALC269_FIXUP_ASPIRE_HEADSET_MIC; /* IdeaPad 330-17IKB 81DM */
7863 else /* 0x17aa3802 */
7864 id = ALC287_FIXUP_YOGA7_14ITL_SPEAKERS; /* "Yoga Duet 7 13ITL6 */
7865 __snd_hda_apply_fixup(codec, id, action, 0);
7866 }
7867
7868 static const struct hda_fixup alc269_fixups[] = {
7869 [ALC269_FIXUP_GPIO2] = {
7870 .type = HDA_FIXUP_FUNC,
7871 .v.func = alc_fixup_gpio2,
7872 },
7873 [ALC269_FIXUP_SONY_VAIO] = {
7874 .type = HDA_FIXUP_PINCTLS,
7875 .v.pins = (const struct hda_pintbl[]) {
7876 {0x19, PIN_VREFGRD},
7877 {}
7878 }
7879 },
7880 [ALC275_FIXUP_SONY_VAIO_GPIO2] = {
7881 .type = HDA_FIXUP_FUNC,
7882 .v.func = alc275_fixup_gpio4_off,
7883 .chained = true,
7884 .chain_id = ALC269_FIXUP_SONY_VAIO
7885 },
7886 [ALC269_FIXUP_DELL_M101Z] = {
7887 .type = HDA_FIXUP_VERBS,
7888 .v.verbs = (const struct hda_verb[]) {
7889 /* Enables internal speaker */
7890 {0x20, AC_VERB_SET_COEF_INDEX, 13},
7891 {0x20, AC_VERB_SET_PROC_COEF, 0x4040},
7892 {}
7893 }
7894 },
7895 [ALC269_FIXUP_SKU_IGNORE] = {
7896 .type = HDA_FIXUP_FUNC,
7897 .v.func = alc_fixup_sku_ignore,
7898 },
7899 [ALC269_FIXUP_ASUS_G73JW] = {
7900 .type = HDA_FIXUP_PINS,
7901 .v.pins = (const struct hda_pintbl[]) {
7902 { 0x17, 0x99130111 }, /* subwoofer */
7903 { }
7904 }
7905 },
7906 [ALC269_FIXUP_ASUS_N7601ZM_PINS] = {
7907 .type = HDA_FIXUP_PINS,
7908 .v.pins = (const struct hda_pintbl[]) {
7909 { 0x19, 0x03A11050 },
7910 { 0x1a, 0x03A11C30 },
7911 { 0x21, 0x03211420 },
7912 { }
7913 }
7914 },
7915 [ALC269_FIXUP_ASUS_N7601ZM] = {
7916 .type = HDA_FIXUP_VERBS,
7917 .v.verbs = (const struct hda_verb[]) {
7918 {0x20, AC_VERB_SET_COEF_INDEX, 0x62},
7919 {0x20, AC_VERB_SET_PROC_COEF, 0xa007},
7920 {0x20, AC_VERB_SET_COEF_INDEX, 0x10},
7921 {0x20, AC_VERB_SET_PROC_COEF, 0x8420},
7922 {0x20, AC_VERB_SET_COEF_INDEX, 0x0f},
7923 {0x20, AC_VERB_SET_PROC_COEF, 0x7774},
7924 { }
7925 },
7926 .chained = true,
7927 .chain_id = ALC269_FIXUP_ASUS_N7601ZM_PINS,
7928 },
7929 [ALC269_FIXUP_LENOVO_EAPD] = {
7930 .type = HDA_FIXUP_VERBS,
7931 .v.verbs = (const struct hda_verb[]) {
7932 {0x14, AC_VERB_SET_EAPD_BTLENABLE, 0},
7933 {}
7934 }
7935 },
7936 [ALC275_FIXUP_SONY_HWEQ] = {
7937 .type = HDA_FIXUP_FUNC,
7938 .v.func = alc269_fixup_hweq,
7939 .chained = true,
7940 .chain_id = ALC275_FIXUP_SONY_VAIO_GPIO2
7941 },
7942 [ALC275_FIXUP_SONY_DISABLE_AAMIX] = {
7943 .type = HDA_FIXUP_FUNC,
7944 .v.func = alc_fixup_disable_aamix,
7945 .chained = true,
7946 .chain_id = ALC269_FIXUP_SONY_VAIO
7947 },
7948 [ALC271_FIXUP_DMIC] = {
7949 .type = HDA_FIXUP_FUNC,
7950 .v.func = alc271_fixup_dmic,
7951 },
7952 [ALC269_FIXUP_PCM_44K] = {
7953 .type = HDA_FIXUP_FUNC,
7954 .v.func = alc269_fixup_pcm_44k,
7955 .chained = true,
7956 .chain_id = ALC269_FIXUP_QUANTA_MUTE
7957 },
7958 [ALC269_FIXUP_STEREO_DMIC] = {
7959 .type = HDA_FIXUP_FUNC,
7960 .v.func = alc269_fixup_stereo_dmic,
7961 },
7962 [ALC269_FIXUP_HEADSET_MIC] = {
7963 .type = HDA_FIXUP_FUNC,
7964 .v.func = alc269_fixup_headset_mic,
7965 },
7966 [ALC269_FIXUP_QUANTA_MUTE] = {
7967 .type = HDA_FIXUP_FUNC,
7968 .v.func = alc269_fixup_quanta_mute,
7969 },
7970 [ALC269_FIXUP_LIFEBOOK] = {
7971 .type = HDA_FIXUP_PINS,
7972 .v.pins = (const struct hda_pintbl[]) {
7973 { 0x1a, 0x2101103f }, /* dock line-out */
7974 { 0x1b, 0x23a11040 }, /* dock mic-in */
7975 { }
7976 },
7977 .chained = true,
7978 .chain_id = ALC269_FIXUP_QUANTA_MUTE
7979 },
7980 [ALC269_FIXUP_LIFEBOOK_EXTMIC] = {
7981 .type = HDA_FIXUP_PINS,
7982 .v.pins = (const struct hda_pintbl[]) {
7983 { 0x19, 0x01a1903c }, /* headset mic, with jack detect */
7984 { }
7985 },
7986 },
7987 [ALC269_FIXUP_LIFEBOOK_HP_PIN] = {
7988 .type = HDA_FIXUP_PINS,
7989 .v.pins = (const struct hda_pintbl[]) {
7990 { 0x21, 0x0221102f }, /* HP out */
7991 { }
7992 },
7993 },
7994 [ALC269_FIXUP_LIFEBOOK_NO_HP_TO_LINEOUT] = {
7995 .type = HDA_FIXUP_FUNC,
7996 .v.func = alc269_fixup_pincfg_no_hp_to_lineout,
7997 },
7998 [ALC255_FIXUP_LIFEBOOK_U7x7_HEADSET_MIC] = {
7999 .type = HDA_FIXUP_FUNC,
8000 .v.func = alc269_fixup_pincfg_U7x7_headset_mic,
8001 },
8002 [ALC269VB_FIXUP_INFINIX_ZERO_BOOK_13] = {
8003 .type = HDA_FIXUP_PINS,
8004 .v.pins = (const struct hda_pintbl[]) {
8005 { 0x14, 0x90170151 }, /* use as internal speaker (LFE) */
8006 { 0x1b, 0x90170152 }, /* use as internal speaker (back) */
8007 { }
8008 },
8009 .chained = true,
8010 .chain_id = ALC269_FIXUP_LIMIT_INT_MIC_BOOST
8011 },
8012 [ALC269VB_FIXUP_CHUWI_COREBOOK_XPRO] = {
8013 .type = HDA_FIXUP_PINS,
8014 .v.pins = (const struct hda_pintbl[]) {
8015 { 0x18, 0x03a19020 }, /* headset mic */
8016 { 0x1b, 0x90170150 }, /* speaker */
8017 { }
8018 },
8019 },
8020 [ALC269_FIXUP_AMIC] = {
8021 .type = HDA_FIXUP_PINS,
8022 .v.pins = (const struct hda_pintbl[]) {
8023 { 0x14, 0x99130110 }, /* speaker */
8024 { 0x15, 0x0121401f }, /* HP out */
8025 { 0x18, 0x01a19c20 }, /* mic */
8026 { 0x19, 0x99a3092f }, /* int-mic */
8027 { }
8028 },
8029 },
8030 [ALC269_FIXUP_DMIC] = {
8031 .type = HDA_FIXUP_PINS,
8032 .v.pins = (const struct hda_pintbl[]) {
8033 { 0x12, 0x99a3092f }, /* int-mic */
8034 { 0x14, 0x99130110 }, /* speaker */
8035 { 0x15, 0x0121401f }, /* HP out */
8036 { 0x18, 0x01a19c20 }, /* mic */
8037 { }
8038 },
8039 },
8040 [ALC269VB_FIXUP_AMIC] = {
8041 .type = HDA_FIXUP_PINS,
8042 .v.pins = (const struct hda_pintbl[]) {
8043 { 0x14, 0x99130110 }, /* speaker */
8044 { 0x18, 0x01a19c20 }, /* mic */
8045 { 0x19, 0x99a3092f }, /* int-mic */
8046 { 0x21, 0x0121401f }, /* HP out */
8047 { }
8048 },
8049 },
8050 [ALC269VB_FIXUP_DMIC] = {
8051 .type = HDA_FIXUP_PINS,
8052 .v.pins = (const struct hda_pintbl[]) {
8053 { 0x12, 0x99a3092f }, /* int-mic */
8054 { 0x14, 0x99130110 }, /* speaker */
8055 { 0x18, 0x01a19c20 }, /* mic */
8056 { 0x21, 0x0121401f }, /* HP out */
8057 { }
8058 },
8059 },
8060 [ALC269_FIXUP_HP_MUTE_LED] = {
8061 .type = HDA_FIXUP_FUNC,
8062 .v.func = alc269_fixup_hp_mute_led,
8063 },
8064 [ALC269_FIXUP_HP_MUTE_LED_MIC1] = {
8065 .type = HDA_FIXUP_FUNC,
8066 .v.func = alc269_fixup_hp_mute_led_mic1,
8067 },
8068 [ALC269_FIXUP_HP_MUTE_LED_MIC2] = {
8069 .type = HDA_FIXUP_FUNC,
8070 .v.func = alc269_fixup_hp_mute_led_mic2,
8071 },
8072 [ALC269_FIXUP_HP_MUTE_LED_MIC3] = {
8073 .type = HDA_FIXUP_FUNC,
8074 .v.func = alc269_fixup_hp_mute_led_mic3,
8075 .chained = true,
8076 .chain_id = ALC295_FIXUP_HP_AUTO_MUTE
8077 },
8078 [ALC269_FIXUP_HP_GPIO_LED] = {
8079 .type = HDA_FIXUP_FUNC,
8080 .v.func = alc269_fixup_hp_gpio_led,
8081 },
8082 [ALC269_FIXUP_HP_GPIO_MIC1_LED] = {
8083 .type = HDA_FIXUP_FUNC,
8084 .v.func = alc269_fixup_hp_gpio_mic1_led,
8085 },
8086 [ALC269_FIXUP_HP_LINE1_MIC1_LED] = {
8087 .type = HDA_FIXUP_FUNC,
8088 .v.func = alc269_fixup_hp_line1_mic1_led,
8089 },
8090 [ALC269_FIXUP_INV_DMIC] = {
8091 .type = HDA_FIXUP_FUNC,
8092 .v.func = alc_fixup_inv_dmic,
8093 },
8094 [ALC269_FIXUP_NO_SHUTUP] = {
8095 .type = HDA_FIXUP_FUNC,
8096 .v.func = alc_fixup_no_shutup,
8097 },
8098 [ALC269_FIXUP_LENOVO_DOCK] = {
8099 .type = HDA_FIXUP_PINS,
8100 .v.pins = (const struct hda_pintbl[]) {
8101 { 0x19, 0x23a11040 }, /* dock mic */
8102 { 0x1b, 0x2121103f }, /* dock headphone */
8103 { }
8104 },
8105 .chained = true,
8106 .chain_id = ALC269_FIXUP_PINCFG_NO_HP_TO_LINEOUT
8107 },
8108 [ALC269_FIXUP_LENOVO_DOCK_LIMIT_BOOST] = {
8109 .type = HDA_FIXUP_FUNC,
8110 .v.func = alc269_fixup_limit_int_mic_boost,
8111 .chained = true,
8112 .chain_id = ALC269_FIXUP_LENOVO_DOCK,
8113 },
8114 [ALC269_FIXUP_PINCFG_NO_HP_TO_LINEOUT] = {
8115 .type = HDA_FIXUP_FUNC,
8116 .v.func = alc269_fixup_pincfg_no_hp_to_lineout,
8117 .chained = true,
8118 .chain_id = ALC269_FIXUP_THINKPAD_ACPI,
8119 },
8120 [ALC269_FIXUP_DELL1_MIC_NO_PRESENCE] = {
8121 .type = HDA_FIXUP_PINS,
8122 .v.pins = (const struct hda_pintbl[]) {
8123 { 0x19, 0x01a1913c }, /* use as headset mic, without its own jack detect */
8124 { 0x1a, 0x01a1913d }, /* use as headphone mic, without its own jack detect */
8125 { }
8126 },
8127 .chained = true,
8128 .chain_id = ALC269_FIXUP_HEADSET_MODE
8129 },
8130 [ALC269_FIXUP_DELL1_LIMIT_INT_MIC_BOOST] = {
8131 .type = HDA_FIXUP_FUNC,
8132 .v.func = alc269_fixup_limit_int_mic_boost,
8133 .chained = true,
8134 .chain_id = ALC269_FIXUP_DELL1_MIC_NO_PRESENCE
8135 },
8136 [ALC269_FIXUP_DELL2_MIC_NO_PRESENCE] = {
8137 .type = HDA_FIXUP_PINS,
8138 .v.pins = (const struct hda_pintbl[]) {
8139 { 0x16, 0x21014020 }, /* dock line out */
8140 { 0x19, 0x21a19030 }, /* dock mic */
8141 { 0x1a, 0x01a1913c }, /* use as headset mic, without its own jack detect */
8142 { }
8143 },
8144 .chained = true,
8145 .chain_id = ALC269_FIXUP_HEADSET_MODE_NO_HP_MIC
8146 },
8147 [ALC269_FIXUP_DELL3_MIC_NO_PRESENCE] = {
8148 .type = HDA_FIXUP_PINS,
8149 .v.pins = (const struct hda_pintbl[]) {
8150 { 0x1a, 0x01a1913c }, /* use as headset mic, without its own jack detect */
8151 { }
8152 },
8153 .chained = true,
8154 .chain_id = ALC269_FIXUP_HEADSET_MODE_NO_HP_MIC
8155 },
8156 [ALC269_FIXUP_DELL4_MIC_NO_PRESENCE] = {
8157 .type = HDA_FIXUP_PINS,
8158 .v.pins = (const struct hda_pintbl[]) {
8159 { 0x19, 0x01a1913c }, /* use as headset mic, without its own jack detect */
8160 { 0x1b, 0x01a1913d }, /* use as headphone mic, without its own jack detect */
8161 { }
8162 },
8163 .chained = true,
8164 .chain_id = ALC269_FIXUP_HEADSET_MODE
8165 },
8166 [ALC269_FIXUP_HEADSET_MODE] = {
8167 .type = HDA_FIXUP_FUNC,
8168 .v.func = alc_fixup_headset_mode,
8169 .chained = true,
8170 .chain_id = ALC255_FIXUP_MIC_MUTE_LED
8171 },
8172 [ALC269_FIXUP_HEADSET_MODE_NO_HP_MIC] = {
8173 .type = HDA_FIXUP_FUNC,
8174 .v.func = alc_fixup_headset_mode_no_hp_mic,
8175 },
8176 [ALC269_FIXUP_ASPIRE_HEADSET_MIC] = {
8177 .type = HDA_FIXUP_PINS,
8178 .v.pins = (const struct hda_pintbl[]) {
8179 { 0x19, 0x01a1913c }, /* headset mic w/o jack detect */
8180 { }
8181 },
8182 .chained = true,
8183 .chain_id = ALC269_FIXUP_HEADSET_MODE,
8184 },
8185 [ALC286_FIXUP_SONY_MIC_NO_PRESENCE] = {
8186 .type = HDA_FIXUP_PINS,
8187 .v.pins = (const struct hda_pintbl[]) {
8188 { 0x18, 0x01a1913c }, /* use as headset mic, without its own jack detect */
8189 { }
8190 },
8191 .chained = true,
8192 .chain_id = ALC269_FIXUP_HEADSET_MIC
8193 },
8194 [ALC256_FIXUP_HUAWEI_MACH_WX9_PINS] = {
8195 .type = HDA_FIXUP_PINS,
8196 .v.pins = (const struct hda_pintbl[]) {
8197 {0x12, 0x90a60130},
8198 {0x13, 0x40000000},
8199 {0x14, 0x90170110},
8200 {0x18, 0x411111f0},
8201 {0x19, 0x04a11040},
8202 {0x1a, 0x411111f0},
8203 {0x1b, 0x90170112},
8204 {0x1d, 0x40759a05},
8205 {0x1e, 0x411111f0},
8206 {0x21, 0x04211020},
8207 { }
8208 },
8209 .chained = true,
8210 .chain_id = ALC255_FIXUP_MIC_MUTE_LED
8211 },
8212 [ALC298_FIXUP_HUAWEI_MBX_STEREO] = {
8213 .type = HDA_FIXUP_FUNC,
8214 .v.func = alc298_fixup_huawei_mbx_stereo,
8215 .chained = true,
8216 .chain_id = ALC255_FIXUP_MIC_MUTE_LED
8217 },
8218 [ALC269_FIXUP_ASUS_X101_FUNC] = {
8219 .type = HDA_FIXUP_FUNC,
8220 .v.func = alc269_fixup_x101_headset_mic,
8221 },
8222 [ALC269_FIXUP_ASUS_X101_VERB] = {
8223 .type = HDA_FIXUP_VERBS,
8224 .v.verbs = (const struct hda_verb[]) {
8225 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
8226 {0x20, AC_VERB_SET_COEF_INDEX, 0x08},
8227 {0x20, AC_VERB_SET_PROC_COEF, 0x0310},
8228 { }
8229 },
8230 .chained = true,
8231 .chain_id = ALC269_FIXUP_ASUS_X101_FUNC
8232 },
8233 [ALC269_FIXUP_ASUS_X101] = {
8234 .type = HDA_FIXUP_PINS,
8235 .v.pins = (const struct hda_pintbl[]) {
8236 { 0x18, 0x04a1182c }, /* Headset mic */
8237 { }
8238 },
8239 .chained = true,
8240 .chain_id = ALC269_FIXUP_ASUS_X101_VERB
8241 },
8242 [ALC271_FIXUP_AMIC_MIC2] = {
8243 .type = HDA_FIXUP_PINS,
8244 .v.pins = (const struct hda_pintbl[]) {
8245 { 0x14, 0x99130110 }, /* speaker */
8246 { 0x19, 0x01a19c20 }, /* mic */
8247 { 0x1b, 0x99a7012f }, /* int-mic */
8248 { 0x21, 0x0121401f }, /* HP out */
8249 { }
8250 },
8251 },
8252 [ALC271_FIXUP_HP_GATE_MIC_JACK] = {
8253 .type = HDA_FIXUP_FUNC,
8254 .v.func = alc271_hp_gate_mic_jack,
8255 .chained = true,
8256 .chain_id = ALC271_FIXUP_AMIC_MIC2,
8257 },
8258 [ALC271_FIXUP_HP_GATE_MIC_JACK_E1_572] = {
8259 .type = HDA_FIXUP_FUNC,
8260 .v.func = alc269_fixup_limit_int_mic_boost,
8261 .chained = true,
8262 .chain_id = ALC271_FIXUP_HP_GATE_MIC_JACK,
8263 },
8264 [ALC269_FIXUP_ACER_AC700] = {
8265 .type = HDA_FIXUP_PINS,
8266 .v.pins = (const struct hda_pintbl[]) {
8267 { 0x12, 0x99a3092f }, /* int-mic */
8268 { 0x14, 0x99130110 }, /* speaker */
8269 { 0x18, 0x03a11c20 }, /* mic */
8270 { 0x1e, 0x0346101e }, /* SPDIF1 */
8271 { 0x21, 0x0321101f }, /* HP out */
8272 { }
8273 },
8274 .chained = true,
8275 .chain_id = ALC271_FIXUP_DMIC,
8276 },
8277 [ALC269_FIXUP_LIMIT_INT_MIC_BOOST] = {
8278 .type = HDA_FIXUP_FUNC,
8279 .v.func = alc269_fixup_limit_int_mic_boost,
8280 .chained = true,
8281 .chain_id = ALC269_FIXUP_THINKPAD_ACPI,
8282 },
8283 [ALC269VB_FIXUP_ASUS_ZENBOOK] = {
8284 .type = HDA_FIXUP_FUNC,
8285 .v.func = alc269_fixup_limit_int_mic_boost,
8286 .chained = true,
8287 .chain_id = ALC269VB_FIXUP_DMIC,
8288 },
8289 [ALC269VB_FIXUP_ASUS_ZENBOOK_UX31A] = {
8290 .type = HDA_FIXUP_VERBS,
8291 .v.verbs = (const struct hda_verb[]) {
8292 /* class-D output amp +5dB */
8293 { 0x20, AC_VERB_SET_COEF_INDEX, 0x12 },
8294 { 0x20, AC_VERB_SET_PROC_COEF, 0x2800 },
8295 {}
8296 },
8297 .chained = true,
8298 .chain_id = ALC269VB_FIXUP_ASUS_ZENBOOK,
8299 },
8300 [ALC269VB_FIXUP_ASUS_MIC_NO_PRESENCE] = {
8301 .type = HDA_FIXUP_PINS,
8302 .v.pins = (const struct hda_pintbl[]) {
8303 { 0x18, 0x01a110f0 }, /* use as headset mic */
8304 { }
8305 },
8306 .chained = true,
8307 .chain_id = ALC269_FIXUP_HEADSET_MIC
8308 },
8309 [ALC269_FIXUP_LIMIT_INT_MIC_BOOST_MUTE_LED] = {
8310 .type = HDA_FIXUP_FUNC,
8311 .v.func = alc269_fixup_limit_int_mic_boost,
8312 .chained = true,
8313 .chain_id = ALC269_FIXUP_HP_MUTE_LED_MIC1,
8314 },
8315 [ALC269VB_FIXUP_ORDISSIMO_EVE2] = {
8316 .type = HDA_FIXUP_PINS,
8317 .v.pins = (const struct hda_pintbl[]) {
8318 { 0x12, 0x99a3092f }, /* int-mic */
8319 { 0x18, 0x03a11d20 }, /* mic */
8320 { 0x19, 0x411111f0 }, /* Unused bogus pin */
8321 { }
8322 },
8323 },
8324 [ALC283_FIXUP_CHROME_BOOK] = {
8325 .type = HDA_FIXUP_FUNC,
8326 .v.func = alc283_fixup_chromebook,
8327 },
8328 [ALC283_FIXUP_SENSE_COMBO_JACK] = {
8329 .type = HDA_FIXUP_FUNC,
8330 .v.func = alc283_fixup_sense_combo_jack,
8331 .chained = true,
8332 .chain_id = ALC283_FIXUP_CHROME_BOOK,
8333 },
8334 [ALC282_FIXUP_ASUS_TX300] = {
8335 .type = HDA_FIXUP_FUNC,
8336 .v.func = alc282_fixup_asus_tx300,
8337 },
8338 [ALC283_FIXUP_INT_MIC] = {
8339 .type = HDA_FIXUP_VERBS,
8340 .v.verbs = (const struct hda_verb[]) {
8341 {0x20, AC_VERB_SET_COEF_INDEX, 0x1a},
8342 {0x20, AC_VERB_SET_PROC_COEF, 0x0011},
8343 { }
8344 },
8345 .chained = true,
8346 .chain_id = ALC269_FIXUP_LIMIT_INT_MIC_BOOST
8347 },
8348 [ALC290_FIXUP_SUBWOOFER_HSJACK] = {
8349 .type = HDA_FIXUP_PINS,
8350 .v.pins = (const struct hda_pintbl[]) {
8351 { 0x17, 0x90170112 }, /* subwoofer */
8352 { }
8353 },
8354 .chained = true,
8355 .chain_id = ALC290_FIXUP_MONO_SPEAKERS_HSJACK,
8356 },
8357 [ALC290_FIXUP_SUBWOOFER] = {
8358 .type = HDA_FIXUP_PINS,
8359 .v.pins = (const struct hda_pintbl[]) {
8360 { 0x17, 0x90170112 }, /* subwoofer */
8361 { }
8362 },
8363 .chained = true,
8364 .chain_id = ALC290_FIXUP_MONO_SPEAKERS,
8365 },
8366 [ALC290_FIXUP_MONO_SPEAKERS] = {
8367 .type = HDA_FIXUP_FUNC,
8368 .v.func = alc290_fixup_mono_speakers,
8369 },
8370 [ALC290_FIXUP_MONO_SPEAKERS_HSJACK] = {
8371 .type = HDA_FIXUP_FUNC,
8372 .v.func = alc290_fixup_mono_speakers,
8373 .chained = true,
8374 .chain_id = ALC269_FIXUP_DELL3_MIC_NO_PRESENCE,
8375 },
8376 [ALC269_FIXUP_THINKPAD_ACPI] = {
8377 .type = HDA_FIXUP_FUNC,
8378 .v.func = alc_fixup_thinkpad_acpi,
8379 .chained = true,
8380 .chain_id = ALC269_FIXUP_SKU_IGNORE,
8381 },
8382 [ALC269_FIXUP_DMIC_THINKPAD_ACPI] = {
8383 .type = HDA_FIXUP_FUNC,
8384 .v.func = alc_fixup_inv_dmic,
8385 .chained = true,
8386 .chain_id = ALC269_FIXUP_THINKPAD_ACPI,
8387 },
8388 [ALC255_FIXUP_ACER_MIC_NO_PRESENCE] = {
8389 .type = HDA_FIXUP_PINS,
8390 .v.pins = (const struct hda_pintbl[]) {
8391 { 0x19, 0x01a1913c }, /* use as headset mic, without its own jack detect */
8392 { }
8393 },
8394 .chained = true,
8395 .chain_id = ALC255_FIXUP_HEADSET_MODE
8396 },
8397 [ALC255_FIXUP_ASUS_MIC_NO_PRESENCE] = {
8398 .type = HDA_FIXUP_PINS,
8399 .v.pins = (const struct hda_pintbl[]) {
8400 { 0x19, 0x01a1913c }, /* use as headset mic, without its own jack detect */
8401 { }
8402 },
8403 .chained = true,
8404 .chain_id = ALC255_FIXUP_HEADSET_MODE
8405 },
8406 [ALC255_FIXUP_DELL1_MIC_NO_PRESENCE] = {
8407 .type = HDA_FIXUP_PINS,
8408 .v.pins = (const struct hda_pintbl[]) {
8409 { 0x19, 0x01a1913c }, /* use as headset mic, without its own jack detect */
8410 { 0x1a, 0x01a1913d }, /* use as headphone mic, without its own jack detect */
8411 { }
8412 },
8413 .chained = true,
8414 .chain_id = ALC255_FIXUP_HEADSET_MODE
8415 },
8416 [ALC255_FIXUP_DELL1_LIMIT_INT_MIC_BOOST] = {
8417 .type = HDA_FIXUP_FUNC,
8418 .v.func = alc269_fixup_limit_int_mic_boost,
8419 .chained = true,
8420 .chain_id = ALC255_FIXUP_DELL1_MIC_NO_PRESENCE
8421 },
8422 [ALC255_FIXUP_DELL2_MIC_NO_PRESENCE] = {
8423 .type = HDA_FIXUP_PINS,
8424 .v.pins = (const struct hda_pintbl[]) {
8425 { 0x19, 0x01a1913c }, /* use as headset mic, without its own jack detect */
8426 { }
8427 },
8428 .chained = true,
8429 .chain_id = ALC255_FIXUP_HEADSET_MODE_NO_HP_MIC
8430 },
8431 [ALC255_FIXUP_HEADSET_MODE] = {
8432 .type = HDA_FIXUP_FUNC,
8433 .v.func = alc_fixup_headset_mode_alc255,
8434 .chained = true,
8435 .chain_id = ALC255_FIXUP_MIC_MUTE_LED
8436 },
8437 [ALC255_FIXUP_HEADSET_MODE_NO_HP_MIC] = {
8438 .type = HDA_FIXUP_FUNC,
8439 .v.func = alc_fixup_headset_mode_alc255_no_hp_mic,
8440 },
8441 [ALC293_FIXUP_DELL1_MIC_NO_PRESENCE] = {
8442 .type = HDA_FIXUP_PINS,
8443 .v.pins = (const struct hda_pintbl[]) {
8444 { 0x18, 0x01a1913d }, /* use as headphone mic, without its own jack detect */
8445 { 0x1a, 0x01a1913c }, /* use as headset mic, without its own jack detect */
8446 { }
8447 },
8448 .chained = true,
8449 .chain_id = ALC269_FIXUP_HEADSET_MODE
8450 },
8451 [ALC292_FIXUP_TPT440_DOCK] = {
8452 .type = HDA_FIXUP_FUNC,
8453 .v.func = alc_fixup_tpt440_dock,
8454 .chained = true,
8455 .chain_id = ALC269_FIXUP_LIMIT_INT_MIC_BOOST
8456 },
8457 [ALC292_FIXUP_TPT440] = {
8458 .type = HDA_FIXUP_FUNC,
8459 .v.func = alc_fixup_disable_aamix,
8460 .chained = true,
8461 .chain_id = ALC292_FIXUP_TPT440_DOCK,
8462 },
8463 [ALC283_FIXUP_HEADSET_MIC] = {
8464 .type = HDA_FIXUP_PINS,
8465 .v.pins = (const struct hda_pintbl[]) {
8466 { 0x19, 0x04a110f0 },
8467 { },
8468 },
8469 },
8470 [ALC255_FIXUP_MIC_MUTE_LED] = {
8471 .type = HDA_FIXUP_FUNC,
8472 .v.func = alc_fixup_micmute_led,
8473 },
8474 [ALC282_FIXUP_ASPIRE_V5_PINS] = {
8475 .type = HDA_FIXUP_PINS,
8476 .v.pins = (const struct hda_pintbl[]) {
8477 { 0x12, 0x90a60130 },
8478 { 0x14, 0x90170110 },
8479 { 0x17, 0x40000008 },
8480 { 0x18, 0x411111f0 },
8481 { 0x19, 0x01a1913c },
8482 { 0x1a, 0x411111f0 },
8483 { 0x1b, 0x411111f0 },
8484 { 0x1d, 0x40f89b2d },
8485 { 0x1e, 0x411111f0 },
8486 { 0x21, 0x0321101f },
8487 { },
8488 },
8489 },
8490 [ALC269VB_FIXUP_ASPIRE_E1_COEF] = {
8491 .type = HDA_FIXUP_FUNC,
8492 .v.func = alc269vb_fixup_aspire_e1_coef,
8493 },
8494 [ALC280_FIXUP_HP_GPIO4] = {
8495 .type = HDA_FIXUP_FUNC,
8496 .v.func = alc280_fixup_hp_gpio4,
8497 },
8498 [ALC286_FIXUP_HP_GPIO_LED] = {
8499 .type = HDA_FIXUP_FUNC,
8500 .v.func = alc286_fixup_hp_gpio_led,
8501 },
8502 [ALC280_FIXUP_HP_GPIO2_MIC_HOTKEY] = {
8503 .type = HDA_FIXUP_FUNC,
8504 .v.func = alc280_fixup_hp_gpio2_mic_hotkey,
8505 },
8506 [ALC280_FIXUP_HP_DOCK_PINS] = {
8507 .type = HDA_FIXUP_PINS,
8508 .v.pins = (const struct hda_pintbl[]) {
8509 { 0x1b, 0x21011020 }, /* line-out */
8510 { 0x1a, 0x01a1903c }, /* headset mic */
8511 { 0x18, 0x2181103f }, /* line-in */
8512 { },
8513 },
8514 .chained = true,
8515 .chain_id = ALC280_FIXUP_HP_GPIO4
8516 },
8517 [ALC269_FIXUP_HP_DOCK_GPIO_MIC1_LED] = {
8518 .type = HDA_FIXUP_PINS,
8519 .v.pins = (const struct hda_pintbl[]) {
8520 { 0x1b, 0x21011020 }, /* line-out */
8521 { 0x18, 0x2181103f }, /* line-in */
8522 { },
8523 },
8524 .chained = true,
8525 .chain_id = ALC269_FIXUP_HP_GPIO_MIC1_LED
8526 },
8527 [ALC280_FIXUP_HP_9480M] = {
8528 .type = HDA_FIXUP_FUNC,
8529 .v.func = alc280_fixup_hp_9480m,
8530 },
8531 [ALC245_FIXUP_HP_X360_AMP] = {
8532 .type = HDA_FIXUP_FUNC,
8533 .v.func = alc245_fixup_hp_x360_amp,
8534 .chained = true,
8535 .chain_id = ALC245_FIXUP_HP_GPIO_LED
8536 },
8537 [ALC288_FIXUP_DELL_HEADSET_MODE] = {
8538 .type = HDA_FIXUP_FUNC,
8539 .v.func = alc_fixup_headset_mode_dell_alc288,
8540 .chained = true,
8541 .chain_id = ALC255_FIXUP_MIC_MUTE_LED
8542 },
8543 [ALC288_FIXUP_DELL1_MIC_NO_PRESENCE] = {
8544 .type = HDA_FIXUP_PINS,
8545 .v.pins = (const struct hda_pintbl[]) {
8546 { 0x18, 0x01a1913c }, /* use as headset mic, without its own jack detect */
8547 { 0x1a, 0x01a1913d }, /* use as headphone mic, without its own jack detect */
8548 { }
8549 },
8550 .chained = true,
8551 .chain_id = ALC288_FIXUP_DELL_HEADSET_MODE
8552 },
8553 [ALC288_FIXUP_DISABLE_AAMIX] = {
8554 .type = HDA_FIXUP_FUNC,
8555 .v.func = alc_fixup_disable_aamix,
8556 .chained = true,
8557 .chain_id = ALC288_FIXUP_DELL1_MIC_NO_PRESENCE
8558 },
8559 [ALC288_FIXUP_DELL_XPS_13] = {
8560 .type = HDA_FIXUP_FUNC,
8561 .v.func = alc_fixup_dell_xps13,
8562 .chained = true,
8563 .chain_id = ALC288_FIXUP_DISABLE_AAMIX
8564 },
8565 [ALC292_FIXUP_DISABLE_AAMIX] = {
8566 .type = HDA_FIXUP_FUNC,
8567 .v.func = alc_fixup_disable_aamix,
8568 .chained = true,
8569 .chain_id = ALC269_FIXUP_DELL2_MIC_NO_PRESENCE
8570 },
8571 [ALC293_FIXUP_DISABLE_AAMIX_MULTIJACK] = {
8572 .type = HDA_FIXUP_FUNC,
8573 .v.func = alc_fixup_disable_aamix,
8574 .chained = true,
8575 .chain_id = ALC293_FIXUP_DELL1_MIC_NO_PRESENCE
8576 },
8577 [ALC292_FIXUP_DELL_E7X_AAMIX] = {
8578 .type = HDA_FIXUP_FUNC,
8579 .v.func = alc_fixup_dell_xps13,
8580 .chained = true,
8581 .chain_id = ALC292_FIXUP_DISABLE_AAMIX
8582 },
8583 [ALC292_FIXUP_DELL_E7X] = {
8584 .type = HDA_FIXUP_FUNC,
8585 .v.func = alc_fixup_micmute_led,
8586 /* micmute fixup must be applied at last */
8587 .chained_before = true,
8588 .chain_id = ALC292_FIXUP_DELL_E7X_AAMIX,
8589 },
8590 [ALC298_FIXUP_ALIENWARE_MIC_NO_PRESENCE] = {
8591 .type = HDA_FIXUP_PINS,
8592 .v.pins = (const struct hda_pintbl[]) {
8593 { 0x18, 0x01a1913c }, /* headset mic w/o jack detect */
8594 { }
8595 },
8596 .chained_before = true,
8597 .chain_id = ALC269_FIXUP_HEADSET_MODE,
8598 },
8599 [ALC298_FIXUP_DELL1_MIC_NO_PRESENCE] = {
8600 .type = HDA_FIXUP_PINS,
8601 .v.pins = (const struct hda_pintbl[]) {
8602 { 0x18, 0x01a1913c }, /* use as headset mic, without its own jack detect */
8603 { 0x1a, 0x01a1913d }, /* use as headphone mic, without its own jack detect */
8604 { }
8605 },
8606 .chained = true,
8607 .chain_id = ALC269_FIXUP_HEADSET_MODE
8608 },
8609 [ALC298_FIXUP_DELL_AIO_MIC_NO_PRESENCE] = {
8610 .type = HDA_FIXUP_PINS,
8611 .v.pins = (const struct hda_pintbl[]) {
8612 { 0x18, 0x01a1913c }, /* use as headset mic, without its own jack detect */
8613 { }
8614 },
8615 .chained = true,
8616 .chain_id = ALC269_FIXUP_HEADSET_MODE
8617 },
8618 [ALC275_FIXUP_DELL_XPS] = {
8619 .type = HDA_FIXUP_VERBS,
8620 .v.verbs = (const struct hda_verb[]) {
8621 /* Enables internal speaker */
8622 {0x20, AC_VERB_SET_COEF_INDEX, 0x1f},
8623 {0x20, AC_VERB_SET_PROC_COEF, 0x00c0},
8624 {0x20, AC_VERB_SET_COEF_INDEX, 0x30},
8625 {0x20, AC_VERB_SET_PROC_COEF, 0x00b1},
8626 {}
8627 }
8628 },
8629 [ALC293_FIXUP_LENOVO_SPK_NOISE] = {
8630 .type = HDA_FIXUP_FUNC,
8631 .v.func = alc_fixup_disable_aamix,
8632 .chained = true,
8633 .chain_id = ALC269_FIXUP_THINKPAD_ACPI
8634 },
8635 [ALC233_FIXUP_LENOVO_LINE2_MIC_HOTKEY] = {
8636 .type = HDA_FIXUP_FUNC,
8637 .v.func = alc233_fixup_lenovo_line2_mic_hotkey,
8638 },
8639 [ALC233_FIXUP_INTEL_NUC8_DMIC] = {
8640 .type = HDA_FIXUP_FUNC,
8641 .v.func = alc_fixup_inv_dmic,
8642 .chained = true,
8643 .chain_id = ALC233_FIXUP_INTEL_NUC8_BOOST,
8644 },
8645 [ALC233_FIXUP_INTEL_NUC8_BOOST] = {
8646 .type = HDA_FIXUP_FUNC,
8647 .v.func = alc269_fixup_limit_int_mic_boost
8648 },
8649 [ALC255_FIXUP_DELL_SPK_NOISE] = {
8650 .type = HDA_FIXUP_FUNC,
8651 .v.func = alc_fixup_disable_aamix,
8652 .chained = true,
8653 .chain_id = ALC255_FIXUP_DELL1_MIC_NO_PRESENCE
8654 },
8655 [ALC225_FIXUP_DISABLE_MIC_VREF] = {
8656 .type = HDA_FIXUP_FUNC,
8657 .v.func = alc_fixup_disable_mic_vref,
8658 .chained = true,
8659 .chain_id = ALC269_FIXUP_DELL1_MIC_NO_PRESENCE
8660 },
8661 [ALC225_FIXUP_DELL1_MIC_NO_PRESENCE] = {
8662 .type = HDA_FIXUP_VERBS,
8663 .v.verbs = (const struct hda_verb[]) {
8664 /* Disable pass-through path for FRONT 14h */
8665 { 0x20, AC_VERB_SET_COEF_INDEX, 0x36 },
8666 { 0x20, AC_VERB_SET_PROC_COEF, 0x57d7 },
8667 {}
8668 },
8669 .chained = true,
8670 .chain_id = ALC225_FIXUP_DISABLE_MIC_VREF
8671 },
8672 [ALC280_FIXUP_HP_HEADSET_MIC] = {
8673 .type = HDA_FIXUP_FUNC,
8674 .v.func = alc_fixup_disable_aamix,
8675 .chained = true,
8676 .chain_id = ALC269_FIXUP_HEADSET_MIC,
8677 },
8678 [ALC221_FIXUP_HP_FRONT_MIC] = {
8679 .type = HDA_FIXUP_PINS,
8680 .v.pins = (const struct hda_pintbl[]) {
8681 { 0x19, 0x02a19020 }, /* Front Mic */
8682 { }
8683 },
8684 },
8685 [ALC292_FIXUP_TPT460] = {
8686 .type = HDA_FIXUP_FUNC,
8687 .v.func = alc_fixup_tpt440_dock,
8688 .chained = true,
8689 .chain_id = ALC293_FIXUP_LENOVO_SPK_NOISE,
8690 },
8691 [ALC298_FIXUP_SPK_VOLUME] = {
8692 .type = HDA_FIXUP_FUNC,
8693 .v.func = alc298_fixup_speaker_volume,
8694 .chained = true,
8695 .chain_id = ALC298_FIXUP_DELL_AIO_MIC_NO_PRESENCE,
8696 },
8697 [ALC298_FIXUP_LENOVO_SPK_VOLUME] = {
8698 .type = HDA_FIXUP_FUNC,
8699 .v.func = alc298_fixup_speaker_volume,
8700 },
8701 [ALC295_FIXUP_DISABLE_DAC3] = {
8702 .type = HDA_FIXUP_FUNC,
8703 .v.func = alc295_fixup_disable_dac3,
8704 },
8705 [ALC285_FIXUP_SPEAKER2_TO_DAC1] = {
8706 .type = HDA_FIXUP_FUNC,
8707 .v.func = alc285_fixup_speaker2_to_dac1,
8708 .chained = true,
8709 .chain_id = ALC269_FIXUP_THINKPAD_ACPI
8710 },
8711 [ALC285_FIXUP_ASUS_SPEAKER2_TO_DAC1] = {
8712 .type = HDA_FIXUP_FUNC,
8713 .v.func = alc285_fixup_speaker2_to_dac1,
8714 .chained = true,
8715 .chain_id = ALC245_FIXUP_CS35L41_SPI_2
8716 },
8717 [ALC285_FIXUP_ASUS_HEADSET_MIC] = {
8718 .type = HDA_FIXUP_PINS,
8719 .v.pins = (const struct hda_pintbl[]) {
8720 { 0x19, 0x03a11050 },
8721 { 0x1b, 0x03a11c30 },
8722 { }
8723 },
8724 .chained = true,
8725 .chain_id = ALC285_FIXUP_ASUS_SPEAKER2_TO_DAC1
8726 },
8727 [ALC285_FIXUP_ASUS_SPI_REAR_SPEAKERS] = {
8728 .type = HDA_FIXUP_PINS,
8729 .v.pins = (const struct hda_pintbl[]) {
8730 { 0x14, 0x90170120 },
8731 { }
8732 },
8733 .chained = true,
8734 .chain_id = ALC285_FIXUP_ASUS_HEADSET_MIC
8735 },
8736 [ALC285_FIXUP_ASUS_I2C_SPEAKER2_TO_DAC1] = {
8737 .type = HDA_FIXUP_FUNC,
8738 .v.func = alc285_fixup_speaker2_to_dac1,
8739 .chained = true,
8740 .chain_id = ALC287_FIXUP_CS35L41_I2C_2
8741 },
8742 [ALC285_FIXUP_ASUS_I2C_HEADSET_MIC] = {
8743 .type = HDA_FIXUP_PINS,
8744 .v.pins = (const struct hda_pintbl[]) {
8745 { 0x19, 0x03a11050 },
8746 { 0x1b, 0x03a11c30 },
8747 { }
8748 },
8749 .chained = true,
8750 .chain_id = ALC285_FIXUP_ASUS_I2C_SPEAKER2_TO_DAC1
8751 },
8752 [ALC256_FIXUP_DELL_INSPIRON_7559_SUBWOOFER] = {
8753 .type = HDA_FIXUP_PINS,
8754 .v.pins = (const struct hda_pintbl[]) {
8755 { 0x1b, 0x90170151 },
8756 { }
8757 },
8758 .chained = true,
8759 .chain_id = ALC255_FIXUP_DELL1_MIC_NO_PRESENCE
8760 },
8761 [ALC269_FIXUP_ATIV_BOOK_8] = {
8762 .type = HDA_FIXUP_FUNC,
8763 .v.func = alc_fixup_auto_mute_via_amp,
8764 .chained = true,
8765 .chain_id = ALC269_FIXUP_NO_SHUTUP
8766 },
8767 [ALC221_FIXUP_HP_288PRO_MIC_NO_PRESENCE] = {
8768 .type = HDA_FIXUP_PINS,
8769 .v.pins = (const struct hda_pintbl[]) {
8770 { 0x19, 0x01a1913c }, /* use as headset mic, without its own jack detect */
8771 { 0x1a, 0x01813030 }, /* use as headphone mic, without its own jack detect */
8772 { }
8773 },
8774 .chained = true,
8775 .chain_id = ALC269_FIXUP_HEADSET_MODE
8776 },
8777 [ALC221_FIXUP_HP_MIC_NO_PRESENCE] = {
8778 .type = HDA_FIXUP_PINS,
8779 .v.pins = (const struct hda_pintbl[]) {
8780 { 0x18, 0x01a1913c }, /* use as headset mic, without its own jack detect */
8781 { 0x1a, 0x01a1913d }, /* use as headphone mic, without its own jack detect */
8782 { }
8783 },
8784 .chained = true,
8785 .chain_id = ALC269_FIXUP_HEADSET_MODE
8786 },
8787 [ALC256_FIXUP_ASUS_HEADSET_MODE] = {
8788 .type = HDA_FIXUP_FUNC,
8789 .v.func = alc_fixup_headset_mode,
8790 },
8791 [ALC256_FIXUP_ASUS_MIC] = {
8792 .type = HDA_FIXUP_PINS,
8793 .v.pins = (const struct hda_pintbl[]) {
8794 { 0x13, 0x90a60160 }, /* use as internal mic */
8795 { 0x19, 0x04a11120 }, /* use as headset mic, without its own jack detect */
8796 { }
8797 },
8798 .chained = true,
8799 .chain_id = ALC256_FIXUP_ASUS_HEADSET_MODE
8800 },
8801 [ALC256_FIXUP_ASUS_AIO_GPIO2] = {
8802 .type = HDA_FIXUP_FUNC,
8803 /* Set up GPIO2 for the speaker amp */
8804 .v.func = alc_fixup_gpio4,
8805 },
8806 [ALC233_FIXUP_ASUS_MIC_NO_PRESENCE] = {
8807 .type = HDA_FIXUP_PINS,
8808 .v.pins = (const struct hda_pintbl[]) {
8809 { 0x19, 0x01a1913c }, /* use as headset mic, without its own jack detect */
8810 { }
8811 },
8812 .chained = true,
8813 .chain_id = ALC269_FIXUP_HEADSET_MIC
8814 },
8815 [ALC233_FIXUP_EAPD_COEF_AND_MIC_NO_PRESENCE] = {
8816 .type = HDA_FIXUP_VERBS,
8817 .v.verbs = (const struct hda_verb[]) {
8818 /* Enables internal speaker */
8819 {0x20, AC_VERB_SET_COEF_INDEX, 0x40},
8820 {0x20, AC_VERB_SET_PROC_COEF, 0x8800},
8821 {}
8822 },
8823 .chained = true,
8824 .chain_id = ALC233_FIXUP_ASUS_MIC_NO_PRESENCE
8825 },
8826 [ALC233_FIXUP_LENOVO_MULTI_CODECS] = {
8827 .type = HDA_FIXUP_FUNC,
8828 .v.func = alc233_alc662_fixup_lenovo_dual_codecs,
8829 .chained = true,
8830 .chain_id = ALC269_FIXUP_GPIO2
8831 },
8832 [ALC233_FIXUP_ACER_HEADSET_MIC] = {
8833 .type = HDA_FIXUP_VERBS,
8834 .v.verbs = (const struct hda_verb[]) {
8835 { 0x20, AC_VERB_SET_COEF_INDEX, 0x45 },
8836 { 0x20, AC_VERB_SET_PROC_COEF, 0x5089 },
8837 { }
8838 },
8839 .chained = true,
8840 .chain_id = ALC233_FIXUP_ASUS_MIC_NO_PRESENCE
8841 },
8842 [ALC294_FIXUP_LENOVO_MIC_LOCATION] = {
8843 .type = HDA_FIXUP_PINS,
8844 .v.pins = (const struct hda_pintbl[]) {
8845 /* Change the mic location from front to right, otherwise there are
8846 two front mics with the same name, pulseaudio can't handle them.
8847 This is just a temporary workaround, after applying this fixup,
8848 there will be one "Front Mic" and one "Mic" in this machine.
8849 */
8850 { 0x1a, 0x04a19040 },
8851 { }
8852 },
8853 },
8854 [ALC225_FIXUP_DELL_WYSE_MIC_NO_PRESENCE] = {
8855 .type = HDA_FIXUP_PINS,
8856 .v.pins = (const struct hda_pintbl[]) {
8857 { 0x16, 0x0101102f }, /* Rear Headset HP */
8858 { 0x19, 0x02a1913c }, /* use as Front headset mic, without its own jack detect */
8859 { 0x1a, 0x01a19030 }, /* Rear Headset MIC */
8860 { 0x1b, 0x02011020 },
8861 { }
8862 },
8863 .chained = true,
8864 .chain_id = ALC225_FIXUP_S3_POP_NOISE
8865 },
8866 [ALC225_FIXUP_S3_POP_NOISE] = {
8867 .type = HDA_FIXUP_FUNC,
8868 .v.func = alc225_fixup_s3_pop_noise,
8869 .chained = true,
8870 .chain_id = ALC269_FIXUP_HEADSET_MODE_NO_HP_MIC
8871 },
8872 [ALC700_FIXUP_INTEL_REFERENCE] = {
8873 .type = HDA_FIXUP_VERBS,
8874 .v.verbs = (const struct hda_verb[]) {
8875 /* Enables internal speaker */
8876 {0x20, AC_VERB_SET_COEF_INDEX, 0x45},
8877 {0x20, AC_VERB_SET_PROC_COEF, 0x5289},
8878 {0x20, AC_VERB_SET_COEF_INDEX, 0x4A},
8879 {0x20, AC_VERB_SET_PROC_COEF, 0x001b},
8880 {0x58, AC_VERB_SET_COEF_INDEX, 0x00},
8881 {0x58, AC_VERB_SET_PROC_COEF, 0x3888},
8882 {0x20, AC_VERB_SET_COEF_INDEX, 0x6f},
8883 {0x20, AC_VERB_SET_PROC_COEF, 0x2c0b},
8884 {}
8885 }
8886 },
8887 [ALC274_FIXUP_DELL_BIND_DACS] = {
8888 .type = HDA_FIXUP_FUNC,
8889 .v.func = alc274_fixup_bind_dacs,
8890 .chained = true,
8891 .chain_id = ALC269_FIXUP_DELL1_MIC_NO_PRESENCE
8892 },
8893 [ALC274_FIXUP_DELL_AIO_LINEOUT_VERB] = {
8894 .type = HDA_FIXUP_PINS,
8895 .v.pins = (const struct hda_pintbl[]) {
8896 { 0x1b, 0x0401102f },
8897 { }
8898 },
8899 .chained = true,
8900 .chain_id = ALC274_FIXUP_DELL_BIND_DACS
8901 },
8902 [ALC298_FIXUP_TPT470_DOCK_FIX] = {
8903 .type = HDA_FIXUP_FUNC,
8904 .v.func = alc_fixup_tpt470_dock,
8905 .chained = true,
8906 .chain_id = ALC293_FIXUP_LENOVO_SPK_NOISE
8907 },
8908 [ALC298_FIXUP_TPT470_DOCK] = {
8909 .type = HDA_FIXUP_FUNC,
8910 .v.func = alc_fixup_tpt470_dacs,
8911 .chained = true,
8912 .chain_id = ALC298_FIXUP_TPT470_DOCK_FIX
8913 },
8914 [ALC255_FIXUP_DUMMY_LINEOUT_VERB] = {
8915 .type = HDA_FIXUP_PINS,
8916 .v.pins = (const struct hda_pintbl[]) {
8917 { 0x14, 0x0201101f },
8918 { }
8919 },
8920 .chained = true,
8921 .chain_id = ALC255_FIXUP_DELL1_MIC_NO_PRESENCE
8922 },
8923 [ALC255_FIXUP_DELL_HEADSET_MIC] = {
8924 .type = HDA_FIXUP_PINS,
8925 .v.pins = (const struct hda_pintbl[]) {
8926 { 0x19, 0x01a1913c }, /* use as headset mic, without its own jack detect */
8927 { }
8928 },
8929 .chained = true,
8930 .chain_id = ALC269_FIXUP_HEADSET_MIC
8931 },
8932 [ALC295_FIXUP_HP_X360] = {
8933 .type = HDA_FIXUP_FUNC,
8934 .v.func = alc295_fixup_hp_top_speakers,
8935 .chained = true,
8936 .chain_id = ALC269_FIXUP_HP_MUTE_LED_MIC3
8937 },
8938 [ALC221_FIXUP_HP_HEADSET_MIC] = {
8939 .type = HDA_FIXUP_PINS,
8940 .v.pins = (const struct hda_pintbl[]) {
8941 { 0x19, 0x0181313f},
8942 { }
8943 },
8944 .chained = true,
8945 .chain_id = ALC269_FIXUP_HEADSET_MIC
8946 },
8947 [ALC285_FIXUP_LENOVO_HEADPHONE_NOISE] = {
8948 .type = HDA_FIXUP_FUNC,
8949 .v.func = alc285_fixup_invalidate_dacs,
8950 .chained = true,
8951 .chain_id = ALC269_FIXUP_THINKPAD_ACPI
8952 },
8953 [ALC295_FIXUP_HP_AUTO_MUTE] = {
8954 .type = HDA_FIXUP_FUNC,
8955 .v.func = alc_fixup_auto_mute_via_amp,
8956 },
8957 [ALC286_FIXUP_ACER_AIO_MIC_NO_PRESENCE] = {
8958 .type = HDA_FIXUP_PINS,
8959 .v.pins = (const struct hda_pintbl[]) {
8960 { 0x18, 0x01a1913c }, /* use as headset mic, without its own jack detect */
8961 { }
8962 },
8963 .chained = true,
8964 .chain_id = ALC269_FIXUP_HEADSET_MIC
8965 },
8966 [ALC294_FIXUP_ASUS_MIC] = {
8967 .type = HDA_FIXUP_PINS,
8968 .v.pins = (const struct hda_pintbl[]) {
8969 { 0x13, 0x90a60160 }, /* use as internal mic */
8970 { 0x19, 0x04a11120 }, /* use as headset mic, without its own jack detect */
8971 { }
8972 },
8973 .chained = true,
8974 .chain_id = ALC269_FIXUP_HEADSET_MIC
8975 },
8976 [ALC294_FIXUP_ASUS_HEADSET_MIC] = {
8977 .type = HDA_FIXUP_PINS,
8978 .v.pins = (const struct hda_pintbl[]) {
8979 { 0x19, 0x01a1103c }, /* use as headset mic */
8980 { }
8981 },
8982 .chained = true,
8983 .chain_id = ALC269_FIXUP_HEADSET_MIC
8984 },
8985 [ALC294_FIXUP_ASUS_SPK] = {
8986 .type = HDA_FIXUP_VERBS,
8987 .v.verbs = (const struct hda_verb[]) {
8988 /* Set EAPD high */
8989 { 0x20, AC_VERB_SET_COEF_INDEX, 0x40 },
8990 { 0x20, AC_VERB_SET_PROC_COEF, 0x8800 },
8991 { 0x20, AC_VERB_SET_COEF_INDEX, 0x0f },
8992 { 0x20, AC_VERB_SET_PROC_COEF, 0x7774 },
8993 { }
8994 },
8995 .chained = true,
8996 .chain_id = ALC294_FIXUP_ASUS_HEADSET_MIC
8997 },
8998 [ALC295_FIXUP_CHROME_BOOK] = {
8999 .type = HDA_FIXUP_FUNC,
9000 .v.func = alc295_fixup_chromebook,
9001 .chained = true,
9002 .chain_id = ALC225_FIXUP_HEADSET_JACK
9003 },
9004 [ALC225_FIXUP_HEADSET_JACK] = {
9005 .type = HDA_FIXUP_FUNC,
9006 .v.func = alc_fixup_headset_jack,
9007 },
9008 [ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE] = {
9009 .type = HDA_FIXUP_PINS,
9010 .v.pins = (const struct hda_pintbl[]) {
9011 { 0x1a, 0x01a1913c }, /* use as headset mic, without its own jack detect */
9012 { }
9013 },
9014 .chained = true,
9015 .chain_id = ALC269_FIXUP_HEADSET_MODE_NO_HP_MIC
9016 },
9017 [ALC285_FIXUP_LENOVO_PC_BEEP_IN_NOISE] = {
9018 .type = HDA_FIXUP_VERBS,
9019 .v.verbs = (const struct hda_verb[]) {
9020 /* Disable PCBEEP-IN passthrough */
9021 { 0x20, AC_VERB_SET_COEF_INDEX, 0x36 },
9022 { 0x20, AC_VERB_SET_PROC_COEF, 0x57d7 },
9023 { }
9024 },
9025 .chained = true,
9026 .chain_id = ALC285_FIXUP_LENOVO_HEADPHONE_NOISE
9027 },
9028 [ALC255_FIXUP_ACER_HEADSET_MIC] = {
9029 .type = HDA_FIXUP_PINS,
9030 .v.pins = (const struct hda_pintbl[]) {
9031 { 0x19, 0x03a11130 },
9032 { 0x1a, 0x90a60140 }, /* use as internal mic */
9033 { }
9034 },
9035 .chained = true,
9036 .chain_id = ALC255_FIXUP_HEADSET_MODE_NO_HP_MIC
9037 },
9038 [ALC225_FIXUP_DELL_WYSE_AIO_MIC_NO_PRESENCE] = {
9039 .type = HDA_FIXUP_PINS,
9040 .v.pins = (const struct hda_pintbl[]) {
9041 { 0x16, 0x01011020 }, /* Rear Line out */
9042 { 0x19, 0x01a1913c }, /* use as Front headset mic, without its own jack detect */
9043 { }
9044 },
9045 .chained = true,
9046 .chain_id = ALC225_FIXUP_WYSE_AUTO_MUTE
9047 },
9048 [ALC225_FIXUP_WYSE_AUTO_MUTE] = {
9049 .type = HDA_FIXUP_FUNC,
9050 .v.func = alc_fixup_auto_mute_via_amp,
9051 .chained = true,
9052 .chain_id = ALC225_FIXUP_WYSE_DISABLE_MIC_VREF
9053 },
9054 [ALC225_FIXUP_WYSE_DISABLE_MIC_VREF] = {
9055 .type = HDA_FIXUP_FUNC,
9056 .v.func = alc_fixup_disable_mic_vref,
9057 .chained = true,
9058 .chain_id = ALC269_FIXUP_HEADSET_MODE_NO_HP_MIC
9059 },
9060 [ALC286_FIXUP_ACER_AIO_HEADSET_MIC] = {
9061 .type = HDA_FIXUP_VERBS,
9062 .v.verbs = (const struct hda_verb[]) {
9063 { 0x20, AC_VERB_SET_COEF_INDEX, 0x4f },
9064 { 0x20, AC_VERB_SET_PROC_COEF, 0x5029 },
9065 { }
9066 },
9067 .chained = true,
9068 .chain_id = ALC286_FIXUP_ACER_AIO_MIC_NO_PRESENCE
9069 },
9070 [ALC256_FIXUP_ASUS_HEADSET_MIC] = {
9071 .type = HDA_FIXUP_PINS,
9072 .v.pins = (const struct hda_pintbl[]) {
9073 { 0x19, 0x03a11020 }, /* headset mic with jack detect */
9074 { }
9075 },
9076 .chained = true,
9077 .chain_id = ALC256_FIXUP_ASUS_HEADSET_MODE
9078 },
9079 [ALC256_FIXUP_ASUS_MIC_NO_PRESENCE] = {
9080 .type = HDA_FIXUP_PINS,
9081 .v.pins = (const struct hda_pintbl[]) {
9082 { 0x19, 0x04a11120 }, /* use as headset mic, without its own jack detect */
9083 { }
9084 },
9085 .chained = true,
9086 .chain_id = ALC256_FIXUP_ASUS_HEADSET_MODE
9087 },
9088 [ALC255_FIXUP_PREDATOR_SUBWOOFER] = {
9089 .type = HDA_FIXUP_PINS,
9090 .v.pins = (const struct hda_pintbl[]) {
9091 { 0x17, 0x90170151 }, /* use as internal speaker (LFE) */
9092 { 0x1b, 0x90170152 } /* use as internal speaker (back) */
9093 }
9094 },
9095 [ALC299_FIXUP_PREDATOR_SPK] = {
9096 .type = HDA_FIXUP_PINS,
9097 .v.pins = (const struct hda_pintbl[]) {
9098 { 0x21, 0x90170150 }, /* use as headset mic, without its own jack detect */
9099 { }
9100 }
9101 },
9102 [ALC256_FIXUP_MEDION_HEADSET_NO_PRESENCE] = {
9103 .type = HDA_FIXUP_PINS,
9104 .v.pins = (const struct hda_pintbl[]) {
9105 { 0x19, 0x04a11040 },
9106 { 0x21, 0x04211020 },
9107 { }
9108 },
9109 .chained = true,
9110 .chain_id = ALC256_FIXUP_ASUS_HEADSET_MODE
9111 },
9112 [ALC289_FIXUP_DELL_SPK1] = {
9113 .type = HDA_FIXUP_PINS,
9114 .v.pins = (const struct hda_pintbl[]) {
9115 { 0x14, 0x90170140 },
9116 { }
9117 },
9118 .chained = true,
9119 .chain_id = ALC269_FIXUP_DELL4_MIC_NO_PRESENCE
9120 },
9121 [ALC289_FIXUP_DELL_SPK2] = {
9122 .type = HDA_FIXUP_PINS,
9123 .v.pins = (const struct hda_pintbl[]) {
9124 { 0x17, 0x90170130 }, /* bass spk */
9125 { }
9126 },
9127 .chained = true,
9128 .chain_id = ALC269_FIXUP_DELL4_MIC_NO_PRESENCE
9129 },
9130 [ALC289_FIXUP_DUAL_SPK] = {
9131 .type = HDA_FIXUP_FUNC,
9132 .v.func = alc285_fixup_speaker2_to_dac1,
9133 .chained = true,
9134 .chain_id = ALC289_FIXUP_DELL_SPK2
9135 },
9136 [ALC289_FIXUP_RTK_AMP_DUAL_SPK] = {
9137 .type = HDA_FIXUP_FUNC,
9138 .v.func = alc285_fixup_speaker2_to_dac1,
9139 .chained = true,
9140 .chain_id = ALC289_FIXUP_DELL_SPK1
9141 },
9142 [ALC294_FIXUP_SPK2_TO_DAC1] = {
9143 .type = HDA_FIXUP_FUNC,
9144 .v.func = alc285_fixup_speaker2_to_dac1,
9145 .chained = true,
9146 .chain_id = ALC294_FIXUP_ASUS_HEADSET_MIC
9147 },
9148 [ALC294_FIXUP_ASUS_DUAL_SPK] = {
9149 .type = HDA_FIXUP_FUNC,
9150 /* The GPIO must be pulled to initialize the AMP */
9151 .v.func = alc_fixup_gpio4,
9152 .chained = true,
9153 .chain_id = ALC294_FIXUP_SPK2_TO_DAC1
9154 },
9155 [ALC294_FIXUP_ASUS_ALLY] = {
9156 .type = HDA_FIXUP_FUNC,
9157 .v.func = cs35l41_fixup_i2c_two,
9158 .chained = true,
9159 .chain_id = ALC294_FIXUP_ASUS_ALLY_PINS
9160 },
9161 [ALC294_FIXUP_ASUS_ALLY_X] = {
9162 .type = HDA_FIXUP_FUNC,
9163 .v.func = tas2781_fixup_i2c,
9164 .chained = true,
9165 .chain_id = ALC294_FIXUP_ASUS_ALLY_PINS
9166 },
9167 [ALC294_FIXUP_ASUS_ALLY_PINS] = {
9168 .type = HDA_FIXUP_PINS,
9169 .v.pins = (const struct hda_pintbl[]) {
9170 { 0x19, 0x03a11050 },
9171 { 0x1a, 0x03a11c30 },
9172 { 0x21, 0x03211420 },
9173 { }
9174 },
9175 .chained = true,
9176 .chain_id = ALC294_FIXUP_ASUS_ALLY_VERBS
9177 },
9178 [ALC294_FIXUP_ASUS_ALLY_VERBS] = {
9179 .type = HDA_FIXUP_VERBS,
9180 .v.verbs = (const struct hda_verb[]) {
9181 { 0x20, AC_VERB_SET_COEF_INDEX, 0x45 },
9182 { 0x20, AC_VERB_SET_PROC_COEF, 0x5089 },
9183 { 0x20, AC_VERB_SET_COEF_INDEX, 0x46 },
9184 { 0x20, AC_VERB_SET_PROC_COEF, 0x0004 },
9185 { 0x20, AC_VERB_SET_COEF_INDEX, 0x47 },
9186 { 0x20, AC_VERB_SET_PROC_COEF, 0xa47a },
9187 { 0x20, AC_VERB_SET_COEF_INDEX, 0x49 },
9188 { 0x20, AC_VERB_SET_PROC_COEF, 0x0049},
9189 { 0x20, AC_VERB_SET_COEF_INDEX, 0x4a },
9190 { 0x20, AC_VERB_SET_PROC_COEF, 0x201b },
9191 { 0x20, AC_VERB_SET_COEF_INDEX, 0x6b },
9192 { 0x20, AC_VERB_SET_PROC_COEF, 0x4278},
9193 { }
9194 },
9195 .chained = true,
9196 .chain_id = ALC294_FIXUP_ASUS_ALLY_SPEAKER
9197 },
9198 [ALC294_FIXUP_ASUS_ALLY_SPEAKER] = {
9199 .type = HDA_FIXUP_FUNC,
9200 .v.func = alc285_fixup_speaker2_to_dac1,
9201 },
9202 [ALC285_FIXUP_THINKPAD_X1_GEN7] = {
9203 .type = HDA_FIXUP_FUNC,
9204 .v.func = alc285_fixup_thinkpad_x1_gen7,
9205 .chained = true,
9206 .chain_id = ALC269_FIXUP_THINKPAD_ACPI
9207 },
9208 [ALC285_FIXUP_THINKPAD_HEADSET_JACK] = {
9209 .type = HDA_FIXUP_FUNC,
9210 .v.func = alc_fixup_headset_jack,
9211 .chained = true,
9212 .chain_id = ALC285_FIXUP_THINKPAD_X1_GEN7
9213 },
9214 [ALC294_FIXUP_ASUS_HPE] = {
9215 .type = HDA_FIXUP_VERBS,
9216 .v.verbs = (const struct hda_verb[]) {
9217 /* Set EAPD high */
9218 { 0x20, AC_VERB_SET_COEF_INDEX, 0x0f },
9219 { 0x20, AC_VERB_SET_PROC_COEF, 0x7774 },
9220 { }
9221 },
9222 .chained = true,
9223 .chain_id = ALC294_FIXUP_ASUS_HEADSET_MIC
9224 },
9225 [ALC294_FIXUP_ASUS_GX502_PINS] = {
9226 .type = HDA_FIXUP_PINS,
9227 .v.pins = (const struct hda_pintbl[]) {
9228 { 0x19, 0x03a11050 }, /* front HP mic */
9229 { 0x1a, 0x01a11830 }, /* rear external mic */
9230 { 0x21, 0x03211020 }, /* front HP out */
9231 { }
9232 },
9233 .chained = true,
9234 .chain_id = ALC294_FIXUP_ASUS_GX502_VERBS
9235 },
9236 [ALC294_FIXUP_ASUS_GX502_VERBS] = {
9237 .type = HDA_FIXUP_VERBS,
9238 .v.verbs = (const struct hda_verb[]) {
9239 /* set 0x15 to HP-OUT ctrl */
9240 { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0 },
9241 /* unmute the 0x15 amp */
9242 { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000 },
9243 { }
9244 },
9245 .chained = true,
9246 .chain_id = ALC294_FIXUP_ASUS_GX502_HP
9247 },
9248 [ALC294_FIXUP_ASUS_GX502_HP] = {
9249 .type = HDA_FIXUP_FUNC,
9250 .v.func = alc294_fixup_gx502_hp,
9251 },
9252 [ALC294_FIXUP_ASUS_GU502_PINS] = {
9253 .type = HDA_FIXUP_PINS,
9254 .v.pins = (const struct hda_pintbl[]) {
9255 { 0x19, 0x01a11050 }, /* rear HP mic */
9256 { 0x1a, 0x01a11830 }, /* rear external mic */
9257 { 0x21, 0x012110f0 }, /* rear HP out */
9258 { }
9259 },
9260 .chained = true,
9261 .chain_id = ALC294_FIXUP_ASUS_GU502_VERBS
9262 },
9263 [ALC294_FIXUP_ASUS_GU502_VERBS] = {
9264 .type = HDA_FIXUP_VERBS,
9265 .v.verbs = (const struct hda_verb[]) {
9266 /* set 0x15 to HP-OUT ctrl */
9267 { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0 },
9268 /* unmute the 0x15 amp */
9269 { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000 },
9270 /* set 0x1b to HP-OUT */
9271 { 0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
9272 { }
9273 },
9274 .chained = true,
9275 .chain_id = ALC294_FIXUP_ASUS_GU502_HP
9276 },
9277 [ALC294_FIXUP_ASUS_GU502_HP] = {
9278 .type = HDA_FIXUP_FUNC,
9279 .v.func = alc294_fixup_gu502_hp,
9280 },
9281 [ALC294_FIXUP_ASUS_G513_PINS] = {
9282 .type = HDA_FIXUP_PINS,
9283 .v.pins = (const struct hda_pintbl[]) {
9284 { 0x19, 0x03a11050 }, /* front HP mic */
9285 { 0x1a, 0x03a11c30 }, /* rear external mic */
9286 { 0x21, 0x03211420 }, /* front HP out */
9287 { }
9288 },
9289 },
9290 [ALC285_FIXUP_ASUS_G533Z_PINS] = {
9291 .type = HDA_FIXUP_PINS,
9292 .v.pins = (const struct hda_pintbl[]) {
9293 { 0x14, 0x90170152 }, /* Speaker Surround Playback Switch */
9294 { 0x19, 0x03a19020 }, /* Mic Boost Volume */
9295 { 0x1a, 0x03a11c30 }, /* Mic Boost Volume */
9296 { 0x1e, 0x90170151 }, /* Rear jack, IN OUT EAPD Detect */
9297 { 0x21, 0x03211420 },
9298 { }
9299 },
9300 },
9301 [ALC294_FIXUP_ASUS_COEF_1B] = {
9302 .type = HDA_FIXUP_VERBS,
9303 .v.verbs = (const struct hda_verb[]) {
9304 /* Set bit 10 to correct noisy output after reboot from
9305 * Windows 10 (due to pop noise reduction?)
9306 */
9307 { 0x20, AC_VERB_SET_COEF_INDEX, 0x1b },
9308 { 0x20, AC_VERB_SET_PROC_COEF, 0x4e4b },
9309 { }
9310 },
9311 .chained = true,
9312 .chain_id = ALC289_FIXUP_ASUS_GA401,
9313 },
9314 [ALC285_FIXUP_HP_GPIO_LED] = {
9315 .type = HDA_FIXUP_FUNC,
9316 .v.func = alc285_fixup_hp_gpio_led,
9317 },
9318 [ALC285_FIXUP_HP_MUTE_LED] = {
9319 .type = HDA_FIXUP_FUNC,
9320 .v.func = alc285_fixup_hp_mute_led,
9321 },
9322 [ALC285_FIXUP_HP_SPECTRE_X360_MUTE_LED] = {
9323 .type = HDA_FIXUP_FUNC,
9324 .v.func = alc285_fixup_hp_spectre_x360_mute_led,
9325 },
9326 [ALC236_FIXUP_HP_MUTE_LED_COEFBIT2] = {
9327 .type = HDA_FIXUP_FUNC,
9328 .v.func = alc236_fixup_hp_mute_led_coefbit2,
9329 },
9330 [ALC236_FIXUP_HP_GPIO_LED] = {
9331 .type = HDA_FIXUP_FUNC,
9332 .v.func = alc236_fixup_hp_gpio_led,
9333 },
9334 [ALC236_FIXUP_HP_MUTE_LED] = {
9335 .type = HDA_FIXUP_FUNC,
9336 .v.func = alc236_fixup_hp_mute_led,
9337 },
9338 [ALC236_FIXUP_HP_MUTE_LED_MICMUTE_VREF] = {
9339 .type = HDA_FIXUP_FUNC,
9340 .v.func = alc236_fixup_hp_mute_led_micmute_vref,
9341 },
9342 [ALC236_FIXUP_LENOVO_INV_DMIC] = {
9343 .type = HDA_FIXUP_FUNC,
9344 .v.func = alc_fixup_inv_dmic,
9345 .chained = true,
9346 .chain_id = ALC283_FIXUP_INT_MIC,
9347 },
9348 [ALC298_FIXUP_SAMSUNG_AMP] = {
9349 .type = HDA_FIXUP_FUNC,
9350 .v.func = alc298_fixup_samsung_amp,
9351 .chained = true,
9352 .chain_id = ALC298_FIXUP_SAMSUNG_HEADPHONE_VERY_QUIET
9353 },
9354 [ALC298_FIXUP_SAMSUNG_AMP_V2_2_AMPS] = {
9355 .type = HDA_FIXUP_FUNC,
9356 .v.func = alc298_fixup_samsung_amp_v2_2_amps
9357 },
9358 [ALC298_FIXUP_SAMSUNG_AMP_V2_4_AMPS] = {
9359 .type = HDA_FIXUP_FUNC,
9360 .v.func = alc298_fixup_samsung_amp_v2_4_amps
9361 },
9362 [ALC298_FIXUP_SAMSUNG_HEADPHONE_VERY_QUIET] = {
9363 .type = HDA_FIXUP_VERBS,
9364 .v.verbs = (const struct hda_verb[]) {
9365 { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc5 },
9366 { }
9367 },
9368 },
9369 [ALC256_FIXUP_SAMSUNG_HEADPHONE_VERY_QUIET] = {
9370 .type = HDA_FIXUP_VERBS,
9371 .v.verbs = (const struct hda_verb[]) {
9372 { 0x20, AC_VERB_SET_COEF_INDEX, 0x08},
9373 { 0x20, AC_VERB_SET_PROC_COEF, 0x2fcf},
9374 { }
9375 },
9376 },
9377 [ALC295_FIXUP_ASUS_MIC_NO_PRESENCE] = {
9378 .type = HDA_FIXUP_PINS,
9379 .v.pins = (const struct hda_pintbl[]) {
9380 { 0x19, 0x01a1913c }, /* use as headset mic, without its own jack detect */
9381 { }
9382 },
9383 .chained = true,
9384 .chain_id = ALC269_FIXUP_HEADSET_MODE
9385 },
9386 [ALC269VC_FIXUP_ACER_VCOPPERBOX_PINS] = {
9387 .type = HDA_FIXUP_PINS,
9388 .v.pins = (const struct hda_pintbl[]) {
9389 { 0x14, 0x90100120 }, /* use as internal speaker */
9390 { 0x18, 0x02a111f0 }, /* use as headset mic, without its own jack detect */
9391 { 0x1a, 0x01011020 }, /* use as line out */
9392 { },
9393 },
9394 .chained = true,
9395 .chain_id = ALC269_FIXUP_HEADSET_MIC
9396 },
9397 [ALC269VC_FIXUP_ACER_HEADSET_MIC] = {
9398 .type = HDA_FIXUP_PINS,
9399 .v.pins = (const struct hda_pintbl[]) {
9400 { 0x18, 0x02a11030 }, /* use as headset mic */
9401 { }
9402 },
9403 .chained = true,
9404 .chain_id = ALC269_FIXUP_HEADSET_MIC
9405 },
9406 [ALC269VC_FIXUP_ACER_MIC_NO_PRESENCE] = {
9407 .type = HDA_FIXUP_PINS,
9408 .v.pins = (const struct hda_pintbl[]) {
9409 { 0x18, 0x01a11130 }, /* use as headset mic, without its own jack detect */
9410 { }
9411 },
9412 .chained = true,
9413 .chain_id = ALC269_FIXUP_HEADSET_MIC
9414 },
9415 [ALC289_FIXUP_ASUS_GA401] = {
9416 .type = HDA_FIXUP_FUNC,
9417 .v.func = alc289_fixup_asus_ga401,
9418 .chained = true,
9419 .chain_id = ALC289_FIXUP_ASUS_GA502,
9420 },
9421 [ALC289_FIXUP_ASUS_GA502] = {
9422 .type = HDA_FIXUP_PINS,
9423 .v.pins = (const struct hda_pintbl[]) {
9424 { 0x19, 0x03a11020 }, /* headset mic with jack detect */
9425 { }
9426 },
9427 },
9428 [ALC256_FIXUP_ACER_MIC_NO_PRESENCE] = {
9429 .type = HDA_FIXUP_PINS,
9430 .v.pins = (const struct hda_pintbl[]) {
9431 { 0x19, 0x02a11120 }, /* use as headset mic, without its own jack detect */
9432 { }
9433 },
9434 .chained = true,
9435 .chain_id = ALC256_FIXUP_ASUS_HEADSET_MODE
9436 },
9437 [ALC285_FIXUP_HP_GPIO_AMP_INIT] = {
9438 .type = HDA_FIXUP_FUNC,
9439 .v.func = alc285_fixup_hp_gpio_amp_init,
9440 .chained = true,
9441 .chain_id = ALC285_FIXUP_HP_GPIO_LED
9442 },
9443 [ALC269_FIXUP_CZC_B20] = {
9444 .type = HDA_FIXUP_PINS,
9445 .v.pins = (const struct hda_pintbl[]) {
9446 { 0x12, 0x411111f0 },
9447 { 0x14, 0x90170110 }, /* speaker */
9448 { 0x15, 0x032f1020 }, /* HP out */
9449 { 0x17, 0x411111f0 },
9450 { 0x18, 0x03ab1040 }, /* mic */
9451 { 0x19, 0xb7a7013f },
9452 { 0x1a, 0x0181305f },
9453 { 0x1b, 0x411111f0 },
9454 { 0x1d, 0x411111f0 },
9455 { 0x1e, 0x411111f0 },
9456 { }
9457 },
9458 .chain_id = ALC269_FIXUP_DMIC,
9459 },
9460 [ALC269_FIXUP_CZC_TMI] = {
9461 .type = HDA_FIXUP_PINS,
9462 .v.pins = (const struct hda_pintbl[]) {
9463 { 0x12, 0x4000c000 },
9464 { 0x14, 0x90170110 }, /* speaker */
9465 { 0x15, 0x0421401f }, /* HP out */
9466 { 0x17, 0x411111f0 },
9467 { 0x18, 0x04a19020 }, /* mic */
9468 { 0x19, 0x411111f0 },
9469 { 0x1a, 0x411111f0 },
9470 { 0x1b, 0x411111f0 },
9471 { 0x1d, 0x40448505 },
9472 { 0x1e, 0x411111f0 },
9473 { 0x20, 0x8000ffff },
9474 { }
9475 },
9476 .chain_id = ALC269_FIXUP_DMIC,
9477 },
9478 [ALC269_FIXUP_CZC_L101] = {
9479 .type = HDA_FIXUP_PINS,
9480 .v.pins = (const struct hda_pintbl[]) {
9481 { 0x12, 0x40000000 },
9482 { 0x14, 0x01014010 }, /* speaker */
9483 { 0x15, 0x411111f0 }, /* HP out */
9484 { 0x16, 0x411111f0 },
9485 { 0x18, 0x01a19020 }, /* mic */
9486 { 0x19, 0x02a19021 },
9487 { 0x1a, 0x0181302f },
9488 { 0x1b, 0x0221401f },
9489 { 0x1c, 0x411111f0 },
9490 { 0x1d, 0x4044c601 },
9491 { 0x1e, 0x411111f0 },
9492 { }
9493 },
9494 .chain_id = ALC269_FIXUP_DMIC,
9495 },
9496 [ALC269_FIXUP_LEMOTE_A1802] = {
9497 .type = HDA_FIXUP_PINS,
9498 .v.pins = (const struct hda_pintbl[]) {
9499 { 0x12, 0x40000000 },
9500 { 0x14, 0x90170110 }, /* speaker */
9501 { 0x17, 0x411111f0 },
9502 { 0x18, 0x03a19040 }, /* mic1 */
9503 { 0x19, 0x90a70130 }, /* mic2 */
9504 { 0x1a, 0x411111f0 },
9505 { 0x1b, 0x411111f0 },
9506 { 0x1d, 0x40489d2d },
9507 { 0x1e, 0x411111f0 },
9508 { 0x20, 0x0003ffff },
9509 { 0x21, 0x03214020 },
9510 { }
9511 },
9512 .chain_id = ALC269_FIXUP_DMIC,
9513 },
9514 [ALC269_FIXUP_LEMOTE_A190X] = {
9515 .type = HDA_FIXUP_PINS,
9516 .v.pins = (const struct hda_pintbl[]) {
9517 { 0x14, 0x99130110 }, /* speaker */
9518 { 0x15, 0x0121401f }, /* HP out */
9519 { 0x18, 0x01a19c20 }, /* rear mic */
9520 { 0x19, 0x99a3092f }, /* front mic */
9521 { 0x1b, 0x0201401f }, /* front lineout */
9522 { }
9523 },
9524 .chain_id = ALC269_FIXUP_DMIC,
9525 },
9526 [ALC256_FIXUP_INTEL_NUC8_RUGGED] = {
9527 .type = HDA_FIXUP_PINS,
9528 .v.pins = (const struct hda_pintbl[]) {
9529 { 0x1b, 0x01a1913c }, /* use as headset mic, without its own jack detect */
9530 { }
9531 },
9532 .chained = true,
9533 .chain_id = ALC269_FIXUP_HEADSET_MODE
9534 },
9535 [ALC256_FIXUP_INTEL_NUC10] = {
9536 .type = HDA_FIXUP_PINS,
9537 .v.pins = (const struct hda_pintbl[]) {
9538 { 0x19, 0x01a1913c }, /* use as headset mic, without its own jack detect */
9539 { }
9540 },
9541 .chained = true,
9542 .chain_id = ALC269_FIXUP_HEADSET_MODE
9543 },
9544 [ALC255_FIXUP_XIAOMI_HEADSET_MIC] = {
9545 .type = HDA_FIXUP_VERBS,
9546 .v.verbs = (const struct hda_verb[]) {
9547 { 0x20, AC_VERB_SET_COEF_INDEX, 0x45 },
9548 { 0x20, AC_VERB_SET_PROC_COEF, 0x5089 },
9549 { }
9550 },
9551 .chained = true,
9552 .chain_id = ALC289_FIXUP_ASUS_GA502
9553 },
9554 [ALC274_FIXUP_HP_MIC] = {
9555 .type = HDA_FIXUP_VERBS,
9556 .v.verbs = (const struct hda_verb[]) {
9557 { 0x20, AC_VERB_SET_COEF_INDEX, 0x45 },
9558 { 0x20, AC_VERB_SET_PROC_COEF, 0x5089 },
9559 { }
9560 },
9561 },
9562 [ALC274_FIXUP_HP_HEADSET_MIC] = {
9563 .type = HDA_FIXUP_FUNC,
9564 .v.func = alc274_fixup_hp_headset_mic,
9565 .chained = true,
9566 .chain_id = ALC274_FIXUP_HP_MIC
9567 },
9568 [ALC274_FIXUP_HP_ENVY_GPIO] = {
9569 .type = HDA_FIXUP_FUNC,
9570 .v.func = alc274_fixup_hp_envy_gpio,
9571 },
9572 [ALC256_FIXUP_ASUS_HPE] = {
9573 .type = HDA_FIXUP_VERBS,
9574 .v.verbs = (const struct hda_verb[]) {
9575 /* Set EAPD high */
9576 { 0x20, AC_VERB_SET_COEF_INDEX, 0x0f },
9577 { 0x20, AC_VERB_SET_PROC_COEF, 0x7778 },
9578 { }
9579 },
9580 .chained = true,
9581 .chain_id = ALC294_FIXUP_ASUS_HEADSET_MIC
9582 },
9583 [ALC285_FIXUP_THINKPAD_NO_BASS_SPK_HEADSET_JACK] = {
9584 .type = HDA_FIXUP_FUNC,
9585 .v.func = alc_fixup_headset_jack,
9586 .chained = true,
9587 .chain_id = ALC269_FIXUP_THINKPAD_ACPI
9588 },
9589 [ALC287_FIXUP_HP_GPIO_LED] = {
9590 .type = HDA_FIXUP_FUNC,
9591 .v.func = alc287_fixup_hp_gpio_led,
9592 },
9593 [ALC256_FIXUP_HP_HEADSET_MIC] = {
9594 .type = HDA_FIXUP_FUNC,
9595 .v.func = alc274_fixup_hp_headset_mic,
9596 },
9597 [ALC236_FIXUP_DELL_AIO_HEADSET_MIC] = {
9598 .type = HDA_FIXUP_FUNC,
9599 .v.func = alc_fixup_no_int_mic,
9600 .chained = true,
9601 .chain_id = ALC255_FIXUP_DELL1_MIC_NO_PRESENCE
9602 },
9603 [ALC282_FIXUP_ACER_DISABLE_LINEOUT] = {
9604 .type = HDA_FIXUP_PINS,
9605 .v.pins = (const struct hda_pintbl[]) {
9606 { 0x1b, 0x411111f0 },
9607 { 0x18, 0x01a1913c }, /* use as headset mic, without its own jack detect */
9608 { },
9609 },
9610 .chained = true,
9611 .chain_id = ALC269_FIXUP_HEADSET_MODE
9612 },
9613 [ALC255_FIXUP_ACER_LIMIT_INT_MIC_BOOST] = {
9614 .type = HDA_FIXUP_FUNC,
9615 .v.func = alc269_fixup_limit_int_mic_boost,
9616 .chained = true,
9617 .chain_id = ALC255_FIXUP_ACER_MIC_NO_PRESENCE,
9618 },
9619 [ALC256_FIXUP_ACER_HEADSET_MIC] = {
9620 .type = HDA_FIXUP_PINS,
9621 .v.pins = (const struct hda_pintbl[]) {
9622 { 0x19, 0x02a1113c }, /* use as headset mic, without its own jack detect */
9623 { 0x1a, 0x90a1092f }, /* use as internal mic */
9624 { }
9625 },
9626 .chained = true,
9627 .chain_id = ALC269_FIXUP_HEADSET_MODE_NO_HP_MIC
9628 },
9629 [ALC285_FIXUP_IDEAPAD_S740_COEF] = {
9630 .type = HDA_FIXUP_FUNC,
9631 .v.func = alc285_fixup_ideapad_s740_coef,
9632 .chained = true,
9633 .chain_id = ALC269_FIXUP_THINKPAD_ACPI,
9634 },
9635 [ALC285_FIXUP_HP_LIMIT_INT_MIC_BOOST] = {
9636 .type = HDA_FIXUP_FUNC,
9637 .v.func = alc269_fixup_limit_int_mic_boost,
9638 .chained = true,
9639 .chain_id = ALC285_FIXUP_HP_MUTE_LED,
9640 },
9641 [ALC295_FIXUP_ASUS_DACS] = {
9642 .type = HDA_FIXUP_FUNC,
9643 .v.func = alc295_fixup_asus_dacs,
9644 },
9645 [ALC295_FIXUP_HP_OMEN] = {
9646 .type = HDA_FIXUP_PINS,
9647 .v.pins = (const struct hda_pintbl[]) {
9648 { 0x12, 0xb7a60130 },
9649 { 0x13, 0x40000000 },
9650 { 0x14, 0x411111f0 },
9651 { 0x16, 0x411111f0 },
9652 { 0x17, 0x90170110 },
9653 { 0x18, 0x411111f0 },
9654 { 0x19, 0x02a11030 },
9655 { 0x1a, 0x411111f0 },
9656 { 0x1b, 0x04a19030 },
9657 { 0x1d, 0x40600001 },
9658 { 0x1e, 0x411111f0 },
9659 { 0x21, 0x03211020 },
9660 {}
9661 },
9662 .chained = true,
9663 .chain_id = ALC269_FIXUP_HP_LINE1_MIC1_LED,
9664 },
9665 [ALC285_FIXUP_HP_SPECTRE_X360] = {
9666 .type = HDA_FIXUP_FUNC,
9667 .v.func = alc285_fixup_hp_spectre_x360,
9668 },
9669 [ALC285_FIXUP_HP_SPECTRE_X360_EB1] = {
9670 .type = HDA_FIXUP_FUNC,
9671 .v.func = alc285_fixup_hp_spectre_x360_eb1
9672 },
9673 [ALC285_FIXUP_HP_ENVY_X360] = {
9674 .type = HDA_FIXUP_FUNC,
9675 .v.func = alc285_fixup_hp_envy_x360,
9676 .chained = true,
9677 .chain_id = ALC285_FIXUP_HP_GPIO_AMP_INIT,
9678 },
9679 [ALC287_FIXUP_IDEAPAD_BASS_SPK_AMP] = {
9680 .type = HDA_FIXUP_FUNC,
9681 .v.func = alc285_fixup_ideapad_s740_coef,
9682 .chained = true,
9683 .chain_id = ALC285_FIXUP_THINKPAD_HEADSET_JACK,
9684 },
9685 [ALC623_FIXUP_LENOVO_THINKSTATION_P340] = {
9686 .type = HDA_FIXUP_FUNC,
9687 .v.func = alc_fixup_no_shutup,
9688 .chained = true,
9689 .chain_id = ALC283_FIXUP_HEADSET_MIC,
9690 },
9691 [ALC255_FIXUP_ACER_HEADPHONE_AND_MIC] = {
9692 .type = HDA_FIXUP_PINS,
9693 .v.pins = (const struct hda_pintbl[]) {
9694 { 0x21, 0x03211030 }, /* Change the Headphone location to Left */
9695 { }
9696 },
9697 .chained = true,
9698 .chain_id = ALC255_FIXUP_XIAOMI_HEADSET_MIC
9699 },
9700 [ALC236_FIXUP_HP_LIMIT_INT_MIC_BOOST] = {
9701 .type = HDA_FIXUP_FUNC,
9702 .v.func = alc269_fixup_limit_int_mic_boost,
9703 .chained = true,
9704 .chain_id = ALC236_FIXUP_HP_MUTE_LED_MICMUTE_VREF,
9705 },
9706 [ALC285_FIXUP_LEGION_Y9000X_SPEAKERS] = {
9707 .type = HDA_FIXUP_FUNC,
9708 .v.func = alc285_fixup_ideapad_s740_coef,
9709 .chained = true,
9710 .chain_id = ALC285_FIXUP_LEGION_Y9000X_AUTOMUTE,
9711 },
9712 [ALC285_FIXUP_LEGION_Y9000X_AUTOMUTE] = {
9713 .type = HDA_FIXUP_FUNC,
9714 .v.func = alc287_fixup_legion_15imhg05_speakers,
9715 .chained = true,
9716 .chain_id = ALC269_FIXUP_THINKPAD_ACPI,
9717 },
9718 [ALC287_FIXUP_LEGION_15IMHG05_SPEAKERS] = {
9719 .type = HDA_FIXUP_VERBS,
9720 //.v.verbs = legion_15imhg05_coefs,
9721 .v.verbs = (const struct hda_verb[]) {
9722 // set left speaker Legion 7i.
9723 { 0x20, AC_VERB_SET_COEF_INDEX, 0x24 },
9724 { 0x20, AC_VERB_SET_PROC_COEF, 0x41 },
9725
9726 { 0x20, AC_VERB_SET_COEF_INDEX, 0x26 },
9727 { 0x20, AC_VERB_SET_PROC_COEF, 0xc },
9728 { 0x20, AC_VERB_SET_PROC_COEF, 0x0 },
9729 { 0x20, AC_VERB_SET_PROC_COEF, 0x1a },
9730 { 0x20, AC_VERB_SET_PROC_COEF, 0xb020 },
9731
9732 { 0x20, AC_VERB_SET_COEF_INDEX, 0x26 },
9733 { 0x20, AC_VERB_SET_PROC_COEF, 0x2 },
9734 { 0x20, AC_VERB_SET_PROC_COEF, 0x0 },
9735 { 0x20, AC_VERB_SET_PROC_COEF, 0x0 },
9736 { 0x20, AC_VERB_SET_PROC_COEF, 0xb020 },
9737
9738 // set right speaker Legion 7i.
9739 { 0x20, AC_VERB_SET_COEF_INDEX, 0x24 },
9740 { 0x20, AC_VERB_SET_PROC_COEF, 0x42 },
9741
9742 { 0x20, AC_VERB_SET_COEF_INDEX, 0x26 },
9743 { 0x20, AC_VERB_SET_PROC_COEF, 0xc },
9744 { 0x20, AC_VERB_SET_PROC_COEF, 0x0 },
9745 { 0x20, AC_VERB_SET_PROC_COEF, 0x2a },
9746 { 0x20, AC_VERB_SET_PROC_COEF, 0xb020 },
9747
9748 { 0x20, AC_VERB_SET_COEF_INDEX, 0x26 },
9749 { 0x20, AC_VERB_SET_PROC_COEF, 0x2 },
9750 { 0x20, AC_VERB_SET_PROC_COEF, 0x0 },
9751 { 0x20, AC_VERB_SET_PROC_COEF, 0x0 },
9752 { 0x20, AC_VERB_SET_PROC_COEF, 0xb020 },
9753 {}
9754 },
9755 .chained = true,
9756 .chain_id = ALC287_FIXUP_LEGION_15IMHG05_AUTOMUTE,
9757 },
9758 [ALC287_FIXUP_LEGION_15IMHG05_AUTOMUTE] = {
9759 .type = HDA_FIXUP_FUNC,
9760 .v.func = alc287_fixup_legion_15imhg05_speakers,
9761 .chained = true,
9762 .chain_id = ALC269_FIXUP_HEADSET_MODE,
9763 },
9764 [ALC287_FIXUP_YOGA7_14ITL_SPEAKERS] = {
9765 .type = HDA_FIXUP_VERBS,
9766 .v.verbs = (const struct hda_verb[]) {
9767 // set left speaker Yoga 7i.
9768 { 0x20, AC_VERB_SET_COEF_INDEX, 0x24 },
9769 { 0x20, AC_VERB_SET_PROC_COEF, 0x41 },
9770
9771 { 0x20, AC_VERB_SET_COEF_INDEX, 0x26 },
9772 { 0x20, AC_VERB_SET_PROC_COEF, 0xc },
9773 { 0x20, AC_VERB_SET_PROC_COEF, 0x0 },
9774 { 0x20, AC_VERB_SET_PROC_COEF, 0x1a },
9775 { 0x20, AC_VERB_SET_PROC_COEF, 0xb020 },
9776
9777 { 0x20, AC_VERB_SET_COEF_INDEX, 0x26 },
9778 { 0x20, AC_VERB_SET_PROC_COEF, 0x2 },
9779 { 0x20, AC_VERB_SET_PROC_COEF, 0x0 },
9780 { 0x20, AC_VERB_SET_PROC_COEF, 0x0 },
9781 { 0x20, AC_VERB_SET_PROC_COEF, 0xb020 },
9782
9783 // set right speaker Yoga 7i.
9784 { 0x20, AC_VERB_SET_COEF_INDEX, 0x24 },
9785 { 0x20, AC_VERB_SET_PROC_COEF, 0x46 },
9786
9787 { 0x20, AC_VERB_SET_COEF_INDEX, 0x26 },
9788 { 0x20, AC_VERB_SET_PROC_COEF, 0xc },
9789 { 0x20, AC_VERB_SET_PROC_COEF, 0x0 },
9790 { 0x20, AC_VERB_SET_PROC_COEF, 0x2a },
9791 { 0x20, AC_VERB_SET_PROC_COEF, 0xb020 },
9792
9793 { 0x20, AC_VERB_SET_COEF_INDEX, 0x26 },
9794 { 0x20, AC_VERB_SET_PROC_COEF, 0x2 },
9795 { 0x20, AC_VERB_SET_PROC_COEF, 0x0 },
9796 { 0x20, AC_VERB_SET_PROC_COEF, 0x0 },
9797 { 0x20, AC_VERB_SET_PROC_COEF, 0xb020 },
9798 {}
9799 },
9800 .chained = true,
9801 .chain_id = ALC269_FIXUP_HEADSET_MODE,
9802 },
9803 [ALC298_FIXUP_LENOVO_C940_DUET7] = {
9804 .type = HDA_FIXUP_FUNC,
9805 .v.func = alc298_fixup_lenovo_c940_duet7,
9806 },
9807 [ALC287_FIXUP_LENOVO_14IRP8_DUETITL] = {
9808 .type = HDA_FIXUP_FUNC,
9809 .v.func = alc287_fixup_lenovo_14irp8_duetitl,
9810 },
9811 [ALC287_FIXUP_LENOVO_LEGION_7] = {
9812 .type = HDA_FIXUP_FUNC,
9813 .v.func = alc287_fixup_lenovo_legion_7,
9814 },
9815 [ALC287_FIXUP_13S_GEN2_SPEAKERS] = {
9816 .type = HDA_FIXUP_VERBS,
9817 .v.verbs = (const struct hda_verb[]) {
9818 { 0x20, AC_VERB_SET_COEF_INDEX, 0x24 },
9819 { 0x20, AC_VERB_SET_PROC_COEF, 0x41 },
9820 { 0x20, AC_VERB_SET_COEF_INDEX, 0x26 },
9821 { 0x20, AC_VERB_SET_PROC_COEF, 0x2 },
9822 { 0x20, AC_VERB_SET_PROC_COEF, 0x0 },
9823 { 0x20, AC_VERB_SET_PROC_COEF, 0x0 },
9824 { 0x20, AC_VERB_SET_PROC_COEF, 0xb020 },
9825 { 0x20, AC_VERB_SET_COEF_INDEX, 0x24 },
9826 { 0x20, AC_VERB_SET_PROC_COEF, 0x42 },
9827 { 0x20, AC_VERB_SET_COEF_INDEX, 0x26 },
9828 { 0x20, AC_VERB_SET_PROC_COEF, 0x2 },
9829 { 0x20, AC_VERB_SET_PROC_COEF, 0x0 },
9830 { 0x20, AC_VERB_SET_PROC_COEF, 0x0 },
9831 { 0x20, AC_VERB_SET_PROC_COEF, 0xb020 },
9832 {}
9833 },
9834 .chained = true,
9835 .chain_id = ALC269_FIXUP_HEADSET_MODE,
9836 },
9837 [ALC256_FIXUP_SET_COEF_DEFAULTS] = {
9838 .type = HDA_FIXUP_FUNC,
9839 .v.func = alc256_fixup_set_coef_defaults,
9840 },
9841 [ALC245_FIXUP_HP_GPIO_LED] = {
9842 .type = HDA_FIXUP_FUNC,
9843 .v.func = alc245_fixup_hp_gpio_led,
9844 },
9845 [ALC256_FIXUP_SYSTEM76_MIC_NO_PRESENCE] = {
9846 .type = HDA_FIXUP_PINS,
9847 .v.pins = (const struct hda_pintbl[]) {
9848 { 0x19, 0x03a11120 }, /* use as headset mic, without its own jack detect */
9849 { }
9850 },
9851 .chained = true,
9852 .chain_id = ALC269_FIXUP_HEADSET_MODE_NO_HP_MIC,
9853 },
9854 [ALC233_FIXUP_NO_AUDIO_JACK] = {
9855 .type = HDA_FIXUP_FUNC,
9856 .v.func = alc233_fixup_no_audio_jack,
9857 },
9858 [ALC256_FIXUP_MIC_NO_PRESENCE_AND_RESUME] = {
9859 .type = HDA_FIXUP_FUNC,
9860 .v.func = alc256_fixup_mic_no_presence_and_resume,
9861 .chained = true,
9862 .chain_id = ALC269_FIXUP_HEADSET_MODE_NO_HP_MIC
9863 },
9864 [ALC287_FIXUP_LEGION_16ACHG6] = {
9865 .type = HDA_FIXUP_FUNC,
9866 .v.func = alc287_fixup_legion_16achg6_speakers,
9867 },
9868 [ALC287_FIXUP_CS35L41_I2C_2] = {
9869 .type = HDA_FIXUP_FUNC,
9870 .v.func = cs35l41_fixup_i2c_two,
9871 },
9872 [ALC287_FIXUP_CS35L41_I2C_2_HP_GPIO_LED] = {
9873 .type = HDA_FIXUP_FUNC,
9874 .v.func = cs35l41_fixup_i2c_two,
9875 .chained = true,
9876 .chain_id = ALC285_FIXUP_HP_MUTE_LED,
9877 },
9878 [ALC287_FIXUP_CS35L41_I2C_4] = {
9879 .type = HDA_FIXUP_FUNC,
9880 .v.func = cs35l41_fixup_i2c_four,
9881 },
9882 [ALC245_FIXUP_CS35L41_SPI_2] = {
9883 .type = HDA_FIXUP_FUNC,
9884 .v.func = cs35l41_fixup_spi_two,
9885 },
9886 [ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED] = {
9887 .type = HDA_FIXUP_FUNC,
9888 .v.func = cs35l41_fixup_spi_two,
9889 .chained = true,
9890 .chain_id = ALC285_FIXUP_HP_GPIO_LED,
9891 },
9892 [ALC245_FIXUP_CS35L41_SPI_4] = {
9893 .type = HDA_FIXUP_FUNC,
9894 .v.func = cs35l41_fixup_spi_four,
9895 },
9896 [ALC245_FIXUP_CS35L41_SPI_4_HP_GPIO_LED] = {
9897 .type = HDA_FIXUP_FUNC,
9898 .v.func = cs35l41_fixup_spi_four,
9899 .chained = true,
9900 .chain_id = ALC285_FIXUP_HP_GPIO_LED,
9901 },
9902 [ALC285_FIXUP_HP_SPEAKERS_MICMUTE_LED] = {
9903 .type = HDA_FIXUP_VERBS,
9904 .v.verbs = (const struct hda_verb[]) {
9905 { 0x20, AC_VERB_SET_COEF_INDEX, 0x19 },
9906 { 0x20, AC_VERB_SET_PROC_COEF, 0x8e11 },
9907 { }
9908 },
9909 .chained = true,
9910 .chain_id = ALC285_FIXUP_HP_MUTE_LED,
9911 },
9912 [ALC269_FIXUP_DELL4_MIC_NO_PRESENCE_QUIET] = {
9913 .type = HDA_FIXUP_FUNC,
9914 .v.func = alc_fixup_dell4_mic_no_presence_quiet,
9915 .chained = true,
9916 .chain_id = ALC269_FIXUP_DELL4_MIC_NO_PRESENCE,
9917 },
9918 [ALC295_FIXUP_FRAMEWORK_LAPTOP_MIC_NO_PRESENCE] = {
9919 .type = HDA_FIXUP_PINS,
9920 .v.pins = (const struct hda_pintbl[]) {
9921 { 0x19, 0x02a1112c }, /* use as headset mic, without its own jack detect */
9922 { }
9923 },
9924 .chained = true,
9925 .chain_id = ALC269_FIXUP_HEADSET_MODE_NO_HP_MIC
9926 },
9927 [ALC287_FIXUP_LEGION_16ITHG6] = {
9928 .type = HDA_FIXUP_FUNC,
9929 .v.func = alc287_fixup_legion_16ithg6_speakers,
9930 },
9931 [ALC287_FIXUP_YOGA9_14IAP7_BASS_SPK] = {
9932 .type = HDA_FIXUP_VERBS,
9933 .v.verbs = (const struct hda_verb[]) {
9934 // enable left speaker
9935 { 0x20, AC_VERB_SET_COEF_INDEX, 0x24 },
9936 { 0x20, AC_VERB_SET_PROC_COEF, 0x41 },
9937
9938 { 0x20, AC_VERB_SET_COEF_INDEX, 0x26 },
9939 { 0x20, AC_VERB_SET_PROC_COEF, 0xc },
9940 { 0x20, AC_VERB_SET_PROC_COEF, 0x0 },
9941 { 0x20, AC_VERB_SET_PROC_COEF, 0x1a },
9942 { 0x20, AC_VERB_SET_PROC_COEF, 0xb020 },
9943
9944 { 0x20, AC_VERB_SET_COEF_INDEX, 0x26 },
9945 { 0x20, AC_VERB_SET_PROC_COEF, 0xf },
9946 { 0x20, AC_VERB_SET_PROC_COEF, 0x0 },
9947 { 0x20, AC_VERB_SET_PROC_COEF, 0x42 },
9948 { 0x20, AC_VERB_SET_PROC_COEF, 0xb020 },
9949
9950 { 0x20, AC_VERB_SET_COEF_INDEX, 0x26 },
9951 { 0x20, AC_VERB_SET_PROC_COEF, 0x10 },
9952 { 0x20, AC_VERB_SET_PROC_COEF, 0x0 },
9953 { 0x20, AC_VERB_SET_PROC_COEF, 0x40 },
9954 { 0x20, AC_VERB_SET_PROC_COEF, 0xb020 },
9955
9956 { 0x20, AC_VERB_SET_COEF_INDEX, 0x26 },
9957 { 0x20, AC_VERB_SET_PROC_COEF, 0x2 },
9958 { 0x20, AC_VERB_SET_PROC_COEF, 0x0 },
9959 { 0x20, AC_VERB_SET_PROC_COEF, 0x0 },
9960 { 0x20, AC_VERB_SET_PROC_COEF, 0xb020 },
9961
9962 // enable right speaker
9963 { 0x20, AC_VERB_SET_COEF_INDEX, 0x24 },
9964 { 0x20, AC_VERB_SET_PROC_COEF, 0x46 },
9965
9966 { 0x20, AC_VERB_SET_COEF_INDEX, 0x26 },
9967 { 0x20, AC_VERB_SET_PROC_COEF, 0xc },
9968 { 0x20, AC_VERB_SET_PROC_COEF, 0x0 },
9969 { 0x20, AC_VERB_SET_PROC_COEF, 0x2a },
9970 { 0x20, AC_VERB_SET_PROC_COEF, 0xb020 },
9971
9972 { 0x20, AC_VERB_SET_COEF_INDEX, 0x26 },
9973 { 0x20, AC_VERB_SET_PROC_COEF, 0xf },
9974 { 0x20, AC_VERB_SET_PROC_COEF, 0x0 },
9975 { 0x20, AC_VERB_SET_PROC_COEF, 0x46 },
9976 { 0x20, AC_VERB_SET_PROC_COEF, 0xb020 },
9977
9978 { 0x20, AC_VERB_SET_COEF_INDEX, 0x26 },
9979 { 0x20, AC_VERB_SET_PROC_COEF, 0x10 },
9980 { 0x20, AC_VERB_SET_PROC_COEF, 0x0 },
9981 { 0x20, AC_VERB_SET_PROC_COEF, 0x44 },
9982 { 0x20, AC_VERB_SET_PROC_COEF, 0xb020 },
9983
9984 { 0x20, AC_VERB_SET_COEF_INDEX, 0x26 },
9985 { 0x20, AC_VERB_SET_PROC_COEF, 0x2 },
9986 { 0x20, AC_VERB_SET_PROC_COEF, 0x0 },
9987 { 0x20, AC_VERB_SET_PROC_COEF, 0x0 },
9988 { 0x20, AC_VERB_SET_PROC_COEF, 0xb020 },
9989
9990 { },
9991 },
9992 },
9993 [ALC287_FIXUP_YOGA9_14IAP7_BASS_SPK_PIN] = {
9994 .type = HDA_FIXUP_FUNC,
9995 .v.func = alc287_fixup_yoga9_14iap7_bass_spk_pin,
9996 .chained = true,
9997 .chain_id = ALC287_FIXUP_YOGA9_14IAP7_BASS_SPK,
9998 },
9999 [ALC287_FIXUP_LENOVO_14ARP8_LEGION_IAH7] = {
10000 .type = HDA_FIXUP_FUNC,
10001 .v.func = alc287_fixup_lenovo_14arp8_legion_iah7,
10002 },
10003 [ALC287_FIXUP_YOGA9_14IMH9_BASS_SPK_PIN] = {
10004 .type = HDA_FIXUP_FUNC,
10005 .v.func = alc287_fixup_yoga9_14iap7_bass_spk_pin,
10006 .chained = true,
10007 .chain_id = ALC287_FIXUP_CS35L41_I2C_2,
10008 },
10009 [ALC295_FIXUP_DELL_INSPIRON_TOP_SPEAKERS] = {
10010 .type = HDA_FIXUP_FUNC,
10011 .v.func = alc295_fixup_dell_inspiron_top_speakers,
10012 .chained = true,
10013 .chain_id = ALC269_FIXUP_DELL4_MIC_NO_PRESENCE,
10014 },
10015 [ALC236_FIXUP_DELL_DUAL_CODECS] = {
10016 .type = HDA_FIXUP_PINS,
10017 .v.func = alc1220_fixup_gb_dual_codecs,
10018 .chained = true,
10019 .chain_id = ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
10020 },
10021 [ALC287_FIXUP_CS35L41_I2C_2_THINKPAD_ACPI] = {
10022 .type = HDA_FIXUP_FUNC,
10023 .v.func = cs35l41_fixup_i2c_two,
10024 .chained = true,
10025 .chain_id = ALC285_FIXUP_THINKPAD_NO_BASS_SPK_HEADSET_JACK,
10026 },
10027 [ALC287_FIXUP_TAS2781_I2C] = {
10028 .type = HDA_FIXUP_FUNC,
10029 .v.func = tas2781_fixup_i2c,
10030 .chained = true,
10031 .chain_id = ALC285_FIXUP_THINKPAD_HEADSET_JACK,
10032 },
10033 [ALC287_FIXUP_YOGA7_14ARB7_I2C] = {
10034 .type = HDA_FIXUP_FUNC,
10035 .v.func = yoga7_14arb7_fixup_i2c,
10036 .chained = true,
10037 .chain_id = ALC285_FIXUP_THINKPAD_HEADSET_JACK,
10038 },
10039 [ALC245_FIXUP_HP_MUTE_LED_COEFBIT] = {
10040 .type = HDA_FIXUP_FUNC,
10041 .v.func = alc245_fixup_hp_mute_led_coefbit,
10042 },
10043 [ALC245_FIXUP_HP_X360_MUTE_LEDS] = {
10044 .type = HDA_FIXUP_FUNC,
10045 .v.func = alc245_fixup_hp_mute_led_coefbit,
10046 .chained = true,
10047 .chain_id = ALC245_FIXUP_HP_GPIO_LED
10048 },
10049 [ALC287_FIXUP_THINKPAD_I2S_SPK] = {
10050 .type = HDA_FIXUP_FUNC,
10051 .v.func = alc287_fixup_bind_dacs,
10052 .chained = true,
10053 .chain_id = ALC285_FIXUP_THINKPAD_NO_BASS_SPK_HEADSET_JACK,
10054 },
10055 [ALC287_FIXUP_MG_RTKC_CSAMP_CS35L41_I2C_THINKPAD] = {
10056 .type = HDA_FIXUP_FUNC,
10057 .v.func = alc287_fixup_bind_dacs,
10058 .chained = true,
10059 .chain_id = ALC287_FIXUP_CS35L41_I2C_2_THINKPAD_ACPI,
10060 },
10061 [ALC2XX_FIXUP_HEADSET_MIC] = {
10062 .type = HDA_FIXUP_FUNC,
10063 .v.func = alc_fixup_headset_mic,
10064 },
10065 [ALC289_FIXUP_DELL_CS35L41_SPI_2] = {
10066 .type = HDA_FIXUP_FUNC,
10067 .v.func = cs35l41_fixup_spi_two,
10068 .chained = true,
10069 .chain_id = ALC289_FIXUP_DUAL_SPK
10070 },
10071 [ALC294_FIXUP_CS35L41_I2C_2] = {
10072 .type = HDA_FIXUP_FUNC,
10073 .v.func = cs35l41_fixup_i2c_two,
10074 },
10075 [ALC256_FIXUP_ACER_SFG16_MICMUTE_LED] = {
10076 .type = HDA_FIXUP_FUNC,
10077 .v.func = alc256_fixup_acer_sfg16_micmute_led,
10078 },
10079 [ALC256_FIXUP_HEADPHONE_AMP_VOL] = {
10080 .type = HDA_FIXUP_FUNC,
10081 .v.func = alc256_decrease_headphone_amp_val,
10082 },
10083 [ALC245_FIXUP_HP_SPECTRE_X360_EU0XXX] = {
10084 .type = HDA_FIXUP_FUNC,
10085 .v.func = alc245_fixup_hp_spectre_x360_eu0xxx,
10086 },
10087 [ALC245_FIXUP_HP_SPECTRE_X360_16_AA0XXX] = {
10088 .type = HDA_FIXUP_FUNC,
10089 .v.func = alc245_fixup_hp_spectre_x360_16_aa0xxx,
10090 },
10091 [ALC285_FIXUP_ASUS_GA403U] = {
10092 .type = HDA_FIXUP_FUNC,
10093 .v.func = alc285_fixup_asus_ga403u,
10094 },
10095 [ALC285_FIXUP_ASUS_GA403U_HEADSET_MIC] = {
10096 .type = HDA_FIXUP_PINS,
10097 .v.pins = (const struct hda_pintbl[]) {
10098 { 0x19, 0x03a11050 },
10099 { 0x1b, 0x03a11c30 },
10100 { }
10101 },
10102 .chained = true,
10103 .chain_id = ALC285_FIXUP_ASUS_GA403U_I2C_SPEAKER2_TO_DAC1
10104 },
10105 [ALC285_FIXUP_ASUS_GU605_SPI_SPEAKER2_TO_DAC1] = {
10106 .type = HDA_FIXUP_FUNC,
10107 .v.func = alc285_fixup_speaker2_to_dac1,
10108 .chained = true,
10109 .chain_id = ALC285_FIXUP_ASUS_GU605_SPI_2_HEADSET_MIC,
10110 },
10111 [ALC285_FIXUP_ASUS_GU605_SPI_2_HEADSET_MIC] = {
10112 .type = HDA_FIXUP_PINS,
10113 .v.pins = (const struct hda_pintbl[]) {
10114 { 0x19, 0x03a11050 },
10115 { 0x1b, 0x03a11c30 },
10116 { }
10117 },
10118 },
10119 [ALC285_FIXUP_ASUS_GA403U_I2C_SPEAKER2_TO_DAC1] = {
10120 .type = HDA_FIXUP_FUNC,
10121 .v.func = alc285_fixup_speaker2_to_dac1,
10122 .chained = true,
10123 .chain_id = ALC285_FIXUP_ASUS_GA403U,
10124 },
10125 [ALC287_FIXUP_LENOVO_THKPAD_WH_ALC1318] = {
10126 .type = HDA_FIXUP_FUNC,
10127 .v.func = alc287_fixup_lenovo_thinkpad_with_alc1318,
10128 .chained = true,
10129 .chain_id = ALC269_FIXUP_THINKPAD_ACPI
10130 },
10131 [ALC256_FIXUP_CHROME_BOOK] = {
10132 .type = HDA_FIXUP_FUNC,
10133 .v.func = alc256_fixup_chromebook,
10134 .chained = true,
10135 .chain_id = ALC225_FIXUP_HEADSET_JACK
10136 },
10137 [ALC287_FIXUP_LENOVO_SSID_17AA3820] = {
10138 .type = HDA_FIXUP_FUNC,
10139 .v.func = alc287_fixup_lenovo_ssid_17aa3820,
10140 },
10141 [ALC245_FIXUP_CLEVO_NOISY_MIC] = {
10142 .type = HDA_FIXUP_FUNC,
10143 .v.func = alc269_fixup_limit_int_mic_boost,
10144 .chained = true,
10145 .chain_id = ALC256_FIXUP_SYSTEM76_MIC_NO_PRESENCE,
10146 },
10147 [ALC269_FIXUP_VAIO_VJFH52_MIC_NO_PRESENCE] = {
10148 .type = HDA_FIXUP_PINS,
10149 .v.pins = (const struct hda_pintbl[]) {
10150 { 0x19, 0x03a1113c }, /* use as headset mic, without its own jack detect */
10151 { 0x1b, 0x20a11040 }, /* dock mic */
10152 { }
10153 },
10154 .chained = true,
10155 .chain_id = ALC269_FIXUP_LIMIT_INT_MIC_BOOST
10156 },
10157 };
10158
10159 static const struct snd_pci_quirk alc269_fixup_tbl[] = {
10160 SND_PCI_QUIRK(0x1025, 0x0283, "Acer TravelMate 8371", ALC269_FIXUP_INV_DMIC),
10161 SND_PCI_QUIRK(0x1025, 0x029b, "Acer 1810TZ", ALC269_FIXUP_INV_DMIC),
10162 SND_PCI_QUIRK(0x1025, 0x0349, "Acer AOD260", ALC269_FIXUP_INV_DMIC),
10163 SND_PCI_QUIRK(0x1025, 0x047c, "Acer AC700", ALC269_FIXUP_ACER_AC700),
10164 SND_PCI_QUIRK(0x1025, 0x072d, "Acer Aspire V5-571G", ALC269_FIXUP_ASPIRE_HEADSET_MIC),
10165 SND_PCI_QUIRK(0x1025, 0x0740, "Acer AO725", ALC271_FIXUP_HP_GATE_MIC_JACK),
10166 SND_PCI_QUIRK(0x1025, 0x0742, "Acer AO756", ALC271_FIXUP_HP_GATE_MIC_JACK),
10167 SND_PCI_QUIRK(0x1025, 0x0762, "Acer Aspire E1-472", ALC271_FIXUP_HP_GATE_MIC_JACK_E1_572),
10168 SND_PCI_QUIRK(0x1025, 0x0775, "Acer Aspire E1-572", ALC271_FIXUP_HP_GATE_MIC_JACK_E1_572),
10169 SND_PCI_QUIRK(0x1025, 0x079b, "Acer Aspire V5-573G", ALC282_FIXUP_ASPIRE_V5_PINS),
10170 SND_PCI_QUIRK(0x1025, 0x080d, "Acer Aspire V5-122P", ALC269_FIXUP_ASPIRE_HEADSET_MIC),
10171 SND_PCI_QUIRK(0x1025, 0x0840, "Acer Aspire E1", ALC269VB_FIXUP_ASPIRE_E1_COEF),
10172 SND_PCI_QUIRK(0x1025, 0x100c, "Acer Aspire E5-574G", ALC255_FIXUP_ACER_LIMIT_INT_MIC_BOOST),
10173 SND_PCI_QUIRK(0x1025, 0x101c, "Acer Veriton N2510G", ALC269_FIXUP_LIFEBOOK),
10174 SND_PCI_QUIRK(0x1025, 0x102b, "Acer Aspire C24-860", ALC286_FIXUP_ACER_AIO_MIC_NO_PRESENCE),
10175 SND_PCI_QUIRK(0x1025, 0x1065, "Acer Aspire C20-820", ALC269VC_FIXUP_ACER_HEADSET_MIC),
10176 SND_PCI_QUIRK(0x1025, 0x106d, "Acer Cloudbook 14", ALC283_FIXUP_CHROME_BOOK),
10177 SND_PCI_QUIRK(0x1025, 0x1094, "Acer Aspire E5-575T", ALC255_FIXUP_ACER_LIMIT_INT_MIC_BOOST),
10178 SND_PCI_QUIRK(0x1025, 0x1099, "Acer Aspire E5-523G", ALC255_FIXUP_ACER_MIC_NO_PRESENCE),
10179 SND_PCI_QUIRK(0x1025, 0x110e, "Acer Aspire ES1-432", ALC255_FIXUP_ACER_MIC_NO_PRESENCE),
10180 SND_PCI_QUIRK(0x1025, 0x1166, "Acer Veriton N4640G", ALC269_FIXUP_LIFEBOOK),
10181 SND_PCI_QUIRK(0x1025, 0x1167, "Acer Veriton N6640G", ALC269_FIXUP_LIFEBOOK),
10182 SND_PCI_QUIRK(0x1025, 0x1177, "Acer Predator G9-593", ALC255_FIXUP_PREDATOR_SUBWOOFER),
10183 SND_PCI_QUIRK(0x1025, 0x1178, "Acer Predator G9-593", ALC255_FIXUP_PREDATOR_SUBWOOFER),
10184 SND_PCI_QUIRK(0x1025, 0x1246, "Acer Predator Helios 500", ALC299_FIXUP_PREDATOR_SPK),
10185 SND_PCI_QUIRK(0x1025, 0x1247, "Acer vCopperbox", ALC269VC_FIXUP_ACER_VCOPPERBOX_PINS),
10186 SND_PCI_QUIRK(0x1025, 0x1248, "Acer Veriton N4660G", ALC269VC_FIXUP_ACER_MIC_NO_PRESENCE),
10187 SND_PCI_QUIRK(0x1025, 0x1269, "Acer SWIFT SF314-54", ALC256_FIXUP_ACER_HEADSET_MIC),
10188 SND_PCI_QUIRK(0x1025, 0x126a, "Acer Swift SF114-32", ALC256_FIXUP_ACER_MIC_NO_PRESENCE),
10189 SND_PCI_QUIRK(0x1025, 0x128f, "Acer Veriton Z6860G", ALC286_FIXUP_ACER_AIO_HEADSET_MIC),
10190 SND_PCI_QUIRK(0x1025, 0x1290, "Acer Veriton Z4860G", ALC286_FIXUP_ACER_AIO_HEADSET_MIC),
10191 SND_PCI_QUIRK(0x1025, 0x1291, "Acer Veriton Z4660G", ALC286_FIXUP_ACER_AIO_HEADSET_MIC),
10192 SND_PCI_QUIRK(0x1025, 0x129c, "Acer SWIFT SF314-55", ALC256_FIXUP_ACER_HEADSET_MIC),
10193 SND_PCI_QUIRK(0x1025, 0x129d, "Acer SWIFT SF313-51", ALC256_FIXUP_ACER_MIC_NO_PRESENCE),
10194 SND_PCI_QUIRK(0x1025, 0x1300, "Acer SWIFT SF314-56", ALC256_FIXUP_ACER_MIC_NO_PRESENCE),
10195 SND_PCI_QUIRK(0x1025, 0x1308, "Acer Aspire Z24-890", ALC286_FIXUP_ACER_AIO_HEADSET_MIC),
10196 SND_PCI_QUIRK(0x1025, 0x132a, "Acer TravelMate B114-21", ALC233_FIXUP_ACER_HEADSET_MIC),
10197 SND_PCI_QUIRK(0x1025, 0x1330, "Acer TravelMate X514-51T", ALC255_FIXUP_ACER_HEADSET_MIC),
10198 SND_PCI_QUIRK(0x1025, 0x141f, "Acer Spin SP513-54N", ALC255_FIXUP_ACER_MIC_NO_PRESENCE),
10199 SND_PCI_QUIRK(0x1025, 0x142b, "Acer Swift SF314-42", ALC255_FIXUP_ACER_MIC_NO_PRESENCE),
10200 SND_PCI_QUIRK(0x1025, 0x1430, "Acer TravelMate B311R-31", ALC256_FIXUP_ACER_MIC_NO_PRESENCE),
10201 SND_PCI_QUIRK(0x1025, 0x1466, "Acer Aspire A515-56", ALC255_FIXUP_ACER_HEADPHONE_AND_MIC),
10202 SND_PCI_QUIRK(0x1025, 0x1534, "Acer Predator PH315-54", ALC255_FIXUP_ACER_MIC_NO_PRESENCE),
10203 SND_PCI_QUIRK(0x1025, 0x169a, "Acer Swift SFG16", ALC256_FIXUP_ACER_SFG16_MICMUTE_LED),
10204 SND_PCI_QUIRK(0x1028, 0x0470, "Dell M101z", ALC269_FIXUP_DELL_M101Z),
10205 SND_PCI_QUIRK(0x1028, 0x053c, "Dell Latitude E5430", ALC292_FIXUP_DELL_E7X),
10206 SND_PCI_QUIRK(0x1028, 0x054b, "Dell XPS one 2710", ALC275_FIXUP_DELL_XPS),
10207 SND_PCI_QUIRK(0x1028, 0x05bd, "Dell Latitude E6440", ALC292_FIXUP_DELL_E7X),
10208 SND_PCI_QUIRK(0x1028, 0x05be, "Dell Latitude E6540", ALC292_FIXUP_DELL_E7X),
10209 SND_PCI_QUIRK(0x1028, 0x05ca, "Dell Latitude E7240", ALC292_FIXUP_DELL_E7X),
10210 SND_PCI_QUIRK(0x1028, 0x05cb, "Dell Latitude E7440", ALC292_FIXUP_DELL_E7X),
10211 SND_PCI_QUIRK(0x1028, 0x05da, "Dell Vostro 5460", ALC290_FIXUP_SUBWOOFER),
10212 SND_PCI_QUIRK(0x1028, 0x05f4, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE),
10213 SND_PCI_QUIRK(0x1028, 0x05f5, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE),
10214 SND_PCI_QUIRK(0x1028, 0x05f6, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE),
10215 SND_PCI_QUIRK(0x1028, 0x0615, "Dell Vostro 5470", ALC290_FIXUP_SUBWOOFER_HSJACK),
10216 SND_PCI_QUIRK(0x1028, 0x0616, "Dell Vostro 5470", ALC290_FIXUP_SUBWOOFER_HSJACK),
10217 SND_PCI_QUIRK(0x1028, 0x062c, "Dell Latitude E5550", ALC292_FIXUP_DELL_E7X),
10218 SND_PCI_QUIRK(0x1028, 0x062e, "Dell Latitude E7450", ALC292_FIXUP_DELL_E7X),
10219 SND_PCI_QUIRK(0x1028, 0x0638, "Dell Inspiron 5439", ALC290_FIXUP_MONO_SPEAKERS_HSJACK),
10220 SND_PCI_QUIRK(0x1028, 0x064a, "Dell", ALC293_FIXUP_DELL1_MIC_NO_PRESENCE),
10221 SND_PCI_QUIRK(0x1028, 0x064b, "Dell", ALC293_FIXUP_DELL1_MIC_NO_PRESENCE),
10222 SND_PCI_QUIRK(0x1028, 0x0665, "Dell XPS 13", ALC288_FIXUP_DELL_XPS_13),
10223 SND_PCI_QUIRK(0x1028, 0x0669, "Dell Optiplex 9020m", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE),
10224 SND_PCI_QUIRK(0x1028, 0x069a, "Dell Vostro 5480", ALC290_FIXUP_SUBWOOFER_HSJACK),
10225 SND_PCI_QUIRK(0x1028, 0x06c7, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE),
10226 SND_PCI_QUIRK(0x1028, 0x06d9, "Dell", ALC293_FIXUP_DELL1_MIC_NO_PRESENCE),
10227 SND_PCI_QUIRK(0x1028, 0x06da, "Dell", ALC293_FIXUP_DELL1_MIC_NO_PRESENCE),
10228 SND_PCI_QUIRK(0x1028, 0x06db, "Dell", ALC293_FIXUP_DISABLE_AAMIX_MULTIJACK),
10229 SND_PCI_QUIRK(0x1028, 0x06dd, "Dell", ALC293_FIXUP_DISABLE_AAMIX_MULTIJACK),
10230 SND_PCI_QUIRK(0x1028, 0x06de, "Dell", ALC293_FIXUP_DISABLE_AAMIX_MULTIJACK),
10231 SND_PCI_QUIRK(0x1028, 0x06df, "Dell", ALC293_FIXUP_DISABLE_AAMIX_MULTIJACK),
10232 SND_PCI_QUIRK(0x1028, 0x06e0, "Dell", ALC293_FIXUP_DISABLE_AAMIX_MULTIJACK),
10233 SND_PCI_QUIRK(0x1028, 0x0706, "Dell Inspiron 7559", ALC256_FIXUP_DELL_INSPIRON_7559_SUBWOOFER),
10234 SND_PCI_QUIRK(0x1028, 0x0725, "Dell Inspiron 3162", ALC255_FIXUP_DELL_SPK_NOISE),
10235 SND_PCI_QUIRK(0x1028, 0x0738, "Dell Precision 5820", ALC269_FIXUP_NO_SHUTUP),
10236 SND_PCI_QUIRK(0x1028, 0x075c, "Dell XPS 27 7760", ALC298_FIXUP_SPK_VOLUME),
10237 SND_PCI_QUIRK(0x1028, 0x075d, "Dell AIO", ALC298_FIXUP_SPK_VOLUME),
10238 SND_PCI_QUIRK(0x1028, 0x0798, "Dell Inspiron 17 7000 Gaming", ALC256_FIXUP_DELL_INSPIRON_7559_SUBWOOFER),
10239 SND_PCI_QUIRK(0x1028, 0x07b0, "Dell Precision 7520", ALC295_FIXUP_DISABLE_DAC3),
10240 SND_PCI_QUIRK(0x1028, 0x080c, "Dell WYSE", ALC225_FIXUP_DELL_WYSE_MIC_NO_PRESENCE),
10241 SND_PCI_QUIRK(0x1028, 0x084b, "Dell", ALC274_FIXUP_DELL_AIO_LINEOUT_VERB),
10242 SND_PCI_QUIRK(0x1028, 0x084e, "Dell", ALC274_FIXUP_DELL_AIO_LINEOUT_VERB),
10243 SND_PCI_QUIRK(0x1028, 0x0871, "Dell Precision 3630", ALC255_FIXUP_DELL_HEADSET_MIC),
10244 SND_PCI_QUIRK(0x1028, 0x0872, "Dell Precision 3630", ALC255_FIXUP_DELL_HEADSET_MIC),
10245 SND_PCI_QUIRK(0x1028, 0x0873, "Dell Precision 3930", ALC255_FIXUP_DUMMY_LINEOUT_VERB),
10246 SND_PCI_QUIRK(0x1028, 0x08ad, "Dell WYSE AIO", ALC225_FIXUP_DELL_WYSE_AIO_MIC_NO_PRESENCE),
10247 SND_PCI_QUIRK(0x1028, 0x08ae, "Dell WYSE NB", ALC225_FIXUP_DELL1_MIC_NO_PRESENCE),
10248 SND_PCI_QUIRK(0x1028, 0x0935, "Dell", ALC274_FIXUP_DELL_AIO_LINEOUT_VERB),
10249 SND_PCI_QUIRK(0x1028, 0x097d, "Dell Precision", ALC289_FIXUP_DUAL_SPK),
10250 SND_PCI_QUIRK(0x1028, 0x097e, "Dell Precision", ALC289_FIXUP_DUAL_SPK),
10251 SND_PCI_QUIRK(0x1028, 0x098d, "Dell Precision", ALC233_FIXUP_ASUS_MIC_NO_PRESENCE),
10252 SND_PCI_QUIRK(0x1028, 0x09bf, "Dell Precision", ALC233_FIXUP_ASUS_MIC_NO_PRESENCE),
10253 SND_PCI_QUIRK(0x1028, 0x0a2e, "Dell", ALC236_FIXUP_DELL_AIO_HEADSET_MIC),
10254 SND_PCI_QUIRK(0x1028, 0x0a30, "Dell", ALC236_FIXUP_DELL_AIO_HEADSET_MIC),
10255 SND_PCI_QUIRK(0x1028, 0x0a38, "Dell Latitude 7520", ALC269_FIXUP_DELL4_MIC_NO_PRESENCE_QUIET),
10256 SND_PCI_QUIRK(0x1028, 0x0a58, "Dell", ALC255_FIXUP_DELL_HEADSET_MIC),
10257 SND_PCI_QUIRK(0x1028, 0x0a61, "Dell XPS 15 9510", ALC289_FIXUP_DUAL_SPK),
10258 SND_PCI_QUIRK(0x1028, 0x0a62, "Dell Precision 5560", ALC289_FIXUP_DUAL_SPK),
10259 SND_PCI_QUIRK(0x1028, 0x0a9d, "Dell Latitude 5430", ALC269_FIXUP_DELL4_MIC_NO_PRESENCE),
10260 SND_PCI_QUIRK(0x1028, 0x0a9e, "Dell Latitude 5430", ALC269_FIXUP_DELL4_MIC_NO_PRESENCE),
10261 SND_PCI_QUIRK(0x1028, 0x0b19, "Dell XPS 15 9520", ALC289_FIXUP_DUAL_SPK),
10262 SND_PCI_QUIRK(0x1028, 0x0b1a, "Dell Precision 5570", ALC289_FIXUP_DUAL_SPK),
10263 SND_PCI_QUIRK(0x1028, 0x0b27, "Dell", ALC245_FIXUP_CS35L41_SPI_2),
10264 SND_PCI_QUIRK(0x1028, 0x0b28, "Dell", ALC245_FIXUP_CS35L41_SPI_2),
10265 SND_PCI_QUIRK(0x1028, 0x0b37, "Dell Inspiron 16 Plus 7620 2-in-1", ALC295_FIXUP_DELL_INSPIRON_TOP_SPEAKERS),
10266 SND_PCI_QUIRK(0x1028, 0x0b71, "Dell Inspiron 16 Plus 7620", ALC295_FIXUP_DELL_INSPIRON_TOP_SPEAKERS),
10267 SND_PCI_QUIRK(0x1028, 0x0beb, "Dell XPS 15 9530 (2023)", ALC289_FIXUP_DELL_CS35L41_SPI_2),
10268 SND_PCI_QUIRK(0x1028, 0x0c03, "Dell Precision 5340", ALC269_FIXUP_DELL4_MIC_NO_PRESENCE),
10269 SND_PCI_QUIRK(0x1028, 0x0c0b, "Dell Oasis 14 RPL-P", ALC289_FIXUP_RTK_AMP_DUAL_SPK),
10270 SND_PCI_QUIRK(0x1028, 0x0c0d, "Dell Oasis", ALC289_FIXUP_RTK_AMP_DUAL_SPK),
10271 SND_PCI_QUIRK(0x1028, 0x0c0e, "Dell Oasis 16", ALC289_FIXUP_RTK_AMP_DUAL_SPK),
10272 SND_PCI_QUIRK(0x1028, 0x0c19, "Dell Precision 3340", ALC236_FIXUP_DELL_DUAL_CODECS),
10273 SND_PCI_QUIRK(0x1028, 0x0c1a, "Dell Precision 3340", ALC236_FIXUP_DELL_DUAL_CODECS),
10274 SND_PCI_QUIRK(0x1028, 0x0c1b, "Dell Precision 3440", ALC236_FIXUP_DELL_DUAL_CODECS),
10275 SND_PCI_QUIRK(0x1028, 0x0c1c, "Dell Precision 3540", ALC236_FIXUP_DELL_DUAL_CODECS),
10276 SND_PCI_QUIRK(0x1028, 0x0c1d, "Dell Precision 3440", ALC236_FIXUP_DELL_DUAL_CODECS),
10277 SND_PCI_QUIRK(0x1028, 0x0c1e, "Dell Precision 3540", ALC236_FIXUP_DELL_DUAL_CODECS),
10278 SND_PCI_QUIRK(0x1028, 0x0c28, "Dell Inspiron 16 Plus 7630", ALC295_FIXUP_DELL_INSPIRON_TOP_SPEAKERS),
10279 SND_PCI_QUIRK(0x1028, 0x0c4d, "Dell", ALC287_FIXUP_CS35L41_I2C_4),
10280 SND_PCI_QUIRK(0x1028, 0x0c94, "Dell Polaris 3 metal", ALC287_FIXUP_TAS2781_I2C),
10281 SND_PCI_QUIRK(0x1028, 0x0c96, "Dell Polaris 2in1", ALC287_FIXUP_TAS2781_I2C),
10282 SND_PCI_QUIRK(0x1028, 0x0cbd, "Dell Oasis 13 CS MTL-U", ALC289_FIXUP_DELL_CS35L41_SPI_2),
10283 SND_PCI_QUIRK(0x1028, 0x0cbe, "Dell Oasis 13 2-IN-1 MTL-U", ALC289_FIXUP_DELL_CS35L41_SPI_2),
10284 SND_PCI_QUIRK(0x1028, 0x0cbf, "Dell Oasis 13 Low Weight MTU-L", ALC289_FIXUP_DELL_CS35L41_SPI_2),
10285 SND_PCI_QUIRK(0x1028, 0x0cc0, "Dell Oasis 13", ALC289_FIXUP_RTK_AMP_DUAL_SPK),
10286 SND_PCI_QUIRK(0x1028, 0x0cc1, "Dell Oasis 14 MTL-H/U", ALC289_FIXUP_DELL_CS35L41_SPI_2),
10287 SND_PCI_QUIRK(0x1028, 0x0cc2, "Dell Oasis 14 2-in-1 MTL-H/U", ALC289_FIXUP_DELL_CS35L41_SPI_2),
10288 SND_PCI_QUIRK(0x1028, 0x0cc3, "Dell Oasis 14 Low Weight MTL-U", ALC289_FIXUP_DELL_CS35L41_SPI_2),
10289 SND_PCI_QUIRK(0x1028, 0x0cc4, "Dell Oasis 16 MTL-H/U", ALC289_FIXUP_DELL_CS35L41_SPI_2),
10290 SND_PCI_QUIRK(0x1028, 0x0cc5, "Dell Oasis 14", ALC289_FIXUP_RTK_AMP_DUAL_SPK),
10291 SND_PCI_QUIRK(0x1028, 0x164a, "Dell", ALC293_FIXUP_DELL1_MIC_NO_PRESENCE),
10292 SND_PCI_QUIRK(0x1028, 0x164b, "Dell", ALC293_FIXUP_DELL1_MIC_NO_PRESENCE),
10293 SND_PCI_QUIRK(0x103c, 0x1586, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC2),
10294 SND_PCI_QUIRK(0x103c, 0x18e6, "HP", ALC269_FIXUP_HP_GPIO_LED),
10295 SND_PCI_QUIRK(0x103c, 0x218b, "HP", ALC269_FIXUP_LIMIT_INT_MIC_BOOST_MUTE_LED),
10296 SND_PCI_QUIRK(0x103c, 0x21f9, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
10297 SND_PCI_QUIRK(0x103c, 0x2210, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
10298 SND_PCI_QUIRK(0x103c, 0x2214, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
10299 SND_PCI_QUIRK(0x103c, 0x221b, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),
10300 SND_PCI_QUIRK(0x103c, 0x221c, "HP EliteBook 755 G2", ALC280_FIXUP_HP_HEADSET_MIC),
10301 SND_PCI_QUIRK(0x103c, 0x2221, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),
10302 SND_PCI_QUIRK(0x103c, 0x2225, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),
10303 SND_PCI_QUIRK(0x103c, 0x2236, "HP", ALC269_FIXUP_HP_LINE1_MIC1_LED),
10304 SND_PCI_QUIRK(0x103c, 0x2237, "HP", ALC269_FIXUP_HP_LINE1_MIC1_LED),
10305 SND_PCI_QUIRK(0x103c, 0x2238, "HP", ALC269_FIXUP_HP_LINE1_MIC1_LED),
10306 SND_PCI_QUIRK(0x103c, 0x2239, "HP", ALC269_FIXUP_HP_LINE1_MIC1_LED),
10307 SND_PCI_QUIRK(0x103c, 0x224b, "HP", ALC269_FIXUP_HP_LINE1_MIC1_LED),
10308 SND_PCI_QUIRK(0x103c, 0x2253, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),
10309 SND_PCI_QUIRK(0x103c, 0x2254, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),
10310 SND_PCI_QUIRK(0x103c, 0x2255, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),
10311 SND_PCI_QUIRK(0x103c, 0x2256, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),
10312 SND_PCI_QUIRK(0x103c, 0x2257, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),
10313 SND_PCI_QUIRK(0x103c, 0x2259, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),
10314 SND_PCI_QUIRK(0x103c, 0x225a, "HP", ALC269_FIXUP_HP_DOCK_GPIO_MIC1_LED),
10315 SND_PCI_QUIRK(0x103c, 0x225f, "HP", ALC280_FIXUP_HP_GPIO2_MIC_HOTKEY),
10316 SND_PCI_QUIRK(0x103c, 0x2260, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
10317 SND_PCI_QUIRK(0x103c, 0x2263, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
10318 SND_PCI_QUIRK(0x103c, 0x2264, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
10319 SND_PCI_QUIRK(0x103c, 0x2265, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
10320 SND_PCI_QUIRK(0x103c, 0x2268, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
10321 SND_PCI_QUIRK(0x103c, 0x226a, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
10322 SND_PCI_QUIRK(0x103c, 0x226b, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
10323 SND_PCI_QUIRK(0x103c, 0x226e, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
10324 SND_PCI_QUIRK(0x103c, 0x2271, "HP", ALC286_FIXUP_HP_GPIO_LED),
10325 SND_PCI_QUIRK(0x103c, 0x2272, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),
10326 SND_PCI_QUIRK(0x103c, 0x2272, "HP", ALC280_FIXUP_HP_DOCK_PINS),
10327 SND_PCI_QUIRK(0x103c, 0x2273, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),
10328 SND_PCI_QUIRK(0x103c, 0x2273, "HP", ALC280_FIXUP_HP_DOCK_PINS),
10329 SND_PCI_QUIRK(0x103c, 0x2278, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),
10330 SND_PCI_QUIRK(0x103c, 0x227f, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
10331 SND_PCI_QUIRK(0x103c, 0x2282, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
10332 SND_PCI_QUIRK(0x103c, 0x228b, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
10333 SND_PCI_QUIRK(0x103c, 0x228e, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
10334 SND_PCI_QUIRK(0x103c, 0x229e, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
10335 SND_PCI_QUIRK(0x103c, 0x22b2, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
10336 SND_PCI_QUIRK(0x103c, 0x22b7, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
10337 SND_PCI_QUIRK(0x103c, 0x22bf, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
10338 SND_PCI_QUIRK(0x103c, 0x22c4, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
10339 SND_PCI_QUIRK(0x103c, 0x22c5, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
10340 SND_PCI_QUIRK(0x103c, 0x22c7, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
10341 SND_PCI_QUIRK(0x103c, 0x22c8, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
10342 SND_PCI_QUIRK(0x103c, 0x22cf, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
10343 SND_PCI_QUIRK(0x103c, 0x22db, "HP", ALC280_FIXUP_HP_9480M),
10344 SND_PCI_QUIRK(0x103c, 0x22dc, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),
10345 SND_PCI_QUIRK(0x103c, 0x22fb, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),
10346 SND_PCI_QUIRK(0x103c, 0x2334, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
10347 SND_PCI_QUIRK(0x103c, 0x2335, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
10348 SND_PCI_QUIRK(0x103c, 0x2336, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
10349 SND_PCI_QUIRK(0x103c, 0x2337, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
10350 SND_PCI_QUIRK(0x103c, 0x2b5e, "HP 288 Pro G2 MT", ALC221_FIXUP_HP_288PRO_MIC_NO_PRESENCE),
10351 SND_PCI_QUIRK(0x103c, 0x802e, "HP Z240 SFF", ALC221_FIXUP_HP_MIC_NO_PRESENCE),
10352 SND_PCI_QUIRK(0x103c, 0x802f, "HP Z240", ALC221_FIXUP_HP_MIC_NO_PRESENCE),
10353 SND_PCI_QUIRK(0x103c, 0x8077, "HP", ALC256_FIXUP_HP_HEADSET_MIC),
10354 SND_PCI_QUIRK(0x103c, 0x8158, "HP", ALC256_FIXUP_HP_HEADSET_MIC),
10355 SND_PCI_QUIRK(0x103c, 0x820d, "HP Pavilion 15", ALC295_FIXUP_HP_X360),
10356 SND_PCI_QUIRK(0x103c, 0x8256, "HP", ALC221_FIXUP_HP_FRONT_MIC),
10357 SND_PCI_QUIRK(0x103c, 0x827e, "HP x360", ALC295_FIXUP_HP_X360),
10358 SND_PCI_QUIRK(0x103c, 0x827f, "HP x360", ALC269_FIXUP_HP_MUTE_LED_MIC3),
10359 SND_PCI_QUIRK(0x103c, 0x82bf, "HP G3 mini", ALC221_FIXUP_HP_MIC_NO_PRESENCE),
10360 SND_PCI_QUIRK(0x103c, 0x82c0, "HP G3 mini premium", ALC221_FIXUP_HP_MIC_NO_PRESENCE),
10361 SND_PCI_QUIRK(0x103c, 0x83b9, "HP Spectre x360", ALC269_FIXUP_HP_MUTE_LED_MIC3),
10362 SND_PCI_QUIRK(0x103c, 0x841c, "HP Pavilion 15-CK0xx", ALC269_FIXUP_HP_MUTE_LED_MIC3),
10363 SND_PCI_QUIRK(0x103c, 0x8497, "HP Envy x360", ALC269_FIXUP_HP_MUTE_LED_MIC3),
10364 SND_PCI_QUIRK(0x103c, 0x84a6, "HP 250 G7 Notebook PC", ALC269_FIXUP_HP_LINE1_MIC1_LED),
10365 SND_PCI_QUIRK(0x103c, 0x84ae, "HP 15-db0403ng", ALC236_FIXUP_HP_MUTE_LED_COEFBIT2),
10366 SND_PCI_QUIRK(0x103c, 0x84da, "HP OMEN dc0019-ur", ALC295_FIXUP_HP_OMEN),
10367 SND_PCI_QUIRK(0x103c, 0x84e7, "HP Pavilion 15", ALC269_FIXUP_HP_MUTE_LED_MIC3),
10368 SND_PCI_QUIRK(0x103c, 0x8519, "HP Spectre x360 15-df0xxx", ALC285_FIXUP_HP_SPECTRE_X360),
10369 SND_PCI_QUIRK(0x103c, 0x8537, "HP ProBook 440 G6", ALC236_FIXUP_HP_MUTE_LED_MICMUTE_VREF),
10370 SND_PCI_QUIRK(0x103c, 0x85de, "HP Envy x360 13-ar0xxx", ALC285_FIXUP_HP_ENVY_X360),
10371 SND_PCI_QUIRK(0x103c, 0x860f, "HP ZBook 15 G6", ALC285_FIXUP_HP_GPIO_AMP_INIT),
10372 SND_PCI_QUIRK(0x103c, 0x861f, "HP Elite Dragonfly G1", ALC285_FIXUP_HP_GPIO_AMP_INIT),
10373 SND_PCI_QUIRK(0x103c, 0x869d, "HP", ALC236_FIXUP_HP_MUTE_LED),
10374 SND_PCI_QUIRK(0x103c, 0x86c1, "HP Laptop 15-da3001TU", ALC236_FIXUP_HP_MUTE_LED_COEFBIT2),
10375 SND_PCI_QUIRK(0x103c, 0x86c7, "HP Envy AiO 32", ALC274_FIXUP_HP_ENVY_GPIO),
10376 SND_PCI_QUIRK(0x103c, 0x86e7, "HP Spectre x360 15-eb0xxx", ALC285_FIXUP_HP_SPECTRE_X360_EB1),
10377 SND_PCI_QUIRK(0x103c, 0x86e8, "HP Spectre x360 15-eb0xxx", ALC285_FIXUP_HP_SPECTRE_X360_EB1),
10378 SND_PCI_QUIRK(0x103c, 0x86f9, "HP Spectre x360 13-aw0xxx", ALC285_FIXUP_HP_SPECTRE_X360_MUTE_LED),
10379 SND_PCI_QUIRK(0x103c, 0x8716, "HP Elite Dragonfly G2 Notebook PC", ALC285_FIXUP_HP_GPIO_AMP_INIT),
10380 SND_PCI_QUIRK(0x103c, 0x8720, "HP EliteBook x360 1040 G8 Notebook PC", ALC285_FIXUP_HP_GPIO_AMP_INIT),
10381 SND_PCI_QUIRK(0x103c, 0x8724, "HP EliteBook 850 G7", ALC285_FIXUP_HP_GPIO_LED),
10382 SND_PCI_QUIRK(0x103c, 0x8728, "HP EliteBook 840 G7", ALC285_FIXUP_HP_GPIO_LED),
10383 SND_PCI_QUIRK(0x103c, 0x8729, "HP", ALC285_FIXUP_HP_GPIO_LED),
10384 SND_PCI_QUIRK(0x103c, 0x8730, "HP ProBook 445 G7", ALC236_FIXUP_HP_MUTE_LED_MICMUTE_VREF),
10385 SND_PCI_QUIRK(0x103c, 0x8735, "HP ProBook 435 G7", ALC236_FIXUP_HP_MUTE_LED_MICMUTE_VREF),
10386 SND_PCI_QUIRK(0x103c, 0x8736, "HP", ALC285_FIXUP_HP_GPIO_AMP_INIT),
10387 SND_PCI_QUIRK(0x103c, 0x8760, "HP", ALC285_FIXUP_HP_MUTE_LED),
10388 SND_PCI_QUIRK(0x103c, 0x876e, "HP ENVY x360 Convertible 13-ay0xxx", ALC245_FIXUP_HP_X360_MUTE_LEDS),
10389 SND_PCI_QUIRK(0x103c, 0x877a, "HP", ALC285_FIXUP_HP_MUTE_LED),
10390 SND_PCI_QUIRK(0x103c, 0x877d, "HP", ALC236_FIXUP_HP_MUTE_LED),
10391 SND_PCI_QUIRK(0x103c, 0x8780, "HP ZBook Fury 17 G7 Mobile Workstation",
10392 ALC285_FIXUP_HP_GPIO_AMP_INIT),
10393 SND_PCI_QUIRK(0x103c, 0x8783, "HP ZBook Fury 15 G7 Mobile Workstation",
10394 ALC285_FIXUP_HP_GPIO_AMP_INIT),
10395 SND_PCI_QUIRK(0x103c, 0x8786, "HP OMEN 15", ALC285_FIXUP_HP_MUTE_LED),
10396 SND_PCI_QUIRK(0x103c, 0x8787, "HP OMEN 15", ALC285_FIXUP_HP_MUTE_LED),
10397 SND_PCI_QUIRK(0x103c, 0x8788, "HP OMEN 15", ALC285_FIXUP_HP_MUTE_LED),
10398 SND_PCI_QUIRK(0x103c, 0x87b7, "HP Laptop 14-fq0xxx", ALC236_FIXUP_HP_MUTE_LED_COEFBIT2),
10399 SND_PCI_QUIRK(0x103c, 0x87c8, "HP", ALC287_FIXUP_HP_GPIO_LED),
10400 SND_PCI_QUIRK(0x103c, 0x87d3, "HP Laptop 15-gw0xxx", ALC236_FIXUP_HP_MUTE_LED_COEFBIT2),
10401 SND_PCI_QUIRK(0x103c, 0x87e5, "HP ProBook 440 G8 Notebook PC", ALC236_FIXUP_HP_GPIO_LED),
10402 SND_PCI_QUIRK(0x103c, 0x87e7, "HP ProBook 450 G8 Notebook PC", ALC236_FIXUP_HP_GPIO_LED),
10403 SND_PCI_QUIRK(0x103c, 0x87f1, "HP ProBook 630 G8 Notebook PC", ALC236_FIXUP_HP_GPIO_LED),
10404 SND_PCI_QUIRK(0x103c, 0x87f2, "HP ProBook 640 G8 Notebook PC", ALC236_FIXUP_HP_GPIO_LED),
10405 SND_PCI_QUIRK(0x103c, 0x87f4, "HP", ALC287_FIXUP_HP_GPIO_LED),
10406 SND_PCI_QUIRK(0x103c, 0x87f5, "HP", ALC287_FIXUP_HP_GPIO_LED),
10407 SND_PCI_QUIRK(0x103c, 0x87f6, "HP Spectre x360 14", ALC245_FIXUP_HP_X360_AMP),
10408 SND_PCI_QUIRK(0x103c, 0x87f7, "HP Spectre x360 14", ALC245_FIXUP_HP_X360_AMP),
10409 SND_PCI_QUIRK(0x103c, 0x87fd, "HP Laptop 14-dq2xxx", ALC236_FIXUP_HP_MUTE_LED_COEFBIT2),
10410 SND_PCI_QUIRK(0x103c, 0x87fe, "HP Laptop 15s-fq2xxx", ALC236_FIXUP_HP_MUTE_LED_COEFBIT2),
10411 SND_PCI_QUIRK(0x103c, 0x8805, "HP ProBook 650 G8 Notebook PC", ALC236_FIXUP_HP_GPIO_LED),
10412 SND_PCI_QUIRK(0x103c, 0x880d, "HP EliteBook 830 G8 Notebook PC", ALC285_FIXUP_HP_GPIO_LED),
10413 SND_PCI_QUIRK(0x103c, 0x8811, "HP Spectre x360 15-eb1xxx", ALC285_FIXUP_HP_SPECTRE_X360_EB1),
10414 SND_PCI_QUIRK(0x103c, 0x8812, "HP Spectre x360 15-eb1xxx", ALC285_FIXUP_HP_SPECTRE_X360_EB1),
10415 SND_PCI_QUIRK(0x103c, 0x881d, "HP 250 G8 Notebook PC", ALC236_FIXUP_HP_MUTE_LED_COEFBIT2),
10416 SND_PCI_QUIRK(0x103c, 0x8846, "HP EliteBook 850 G8 Notebook PC", ALC285_FIXUP_HP_GPIO_LED),
10417 SND_PCI_QUIRK(0x103c, 0x8847, "HP EliteBook x360 830 G8 Notebook PC", ALC285_FIXUP_HP_GPIO_LED),
10418 SND_PCI_QUIRK(0x103c, 0x884b, "HP EliteBook 840 Aero G8 Notebook PC", ALC285_FIXUP_HP_GPIO_LED),
10419 SND_PCI_QUIRK(0x103c, 0x884c, "HP EliteBook 840 G8 Notebook PC", ALC285_FIXUP_HP_GPIO_LED),
10420 SND_PCI_QUIRK(0x103c, 0x8862, "HP ProBook 445 G8 Notebook PC", ALC236_FIXUP_HP_LIMIT_INT_MIC_BOOST),
10421 SND_PCI_QUIRK(0x103c, 0x8863, "HP ProBook 445 G8 Notebook PC", ALC236_FIXUP_HP_LIMIT_INT_MIC_BOOST),
10422 SND_PCI_QUIRK(0x103c, 0x886d, "HP ZBook Fury 17.3 Inch G8 Mobile Workstation PC", ALC285_FIXUP_HP_GPIO_AMP_INIT),
10423 SND_PCI_QUIRK(0x103c, 0x8870, "HP ZBook Fury 15.6 Inch G8 Mobile Workstation PC", ALC285_FIXUP_HP_GPIO_AMP_INIT),
10424 SND_PCI_QUIRK(0x103c, 0x8873, "HP ZBook Studio 15.6 Inch G8 Mobile Workstation PC", ALC285_FIXUP_HP_GPIO_AMP_INIT),
10425 SND_PCI_QUIRK(0x103c, 0x887a, "HP Laptop 15s-eq2xxx", ALC236_FIXUP_HP_MUTE_LED_COEFBIT2),
10426 SND_PCI_QUIRK(0x103c, 0x888a, "HP ENVY x360 Convertible 15-eu0xxx", ALC245_FIXUP_HP_X360_MUTE_LEDS),
10427 SND_PCI_QUIRK(0x103c, 0x888d, "HP ZBook Power 15.6 inch G8 Mobile Workstation PC", ALC236_FIXUP_HP_GPIO_LED),
10428 SND_PCI_QUIRK(0x103c, 0x8895, "HP EliteBook 855 G8 Notebook PC", ALC285_FIXUP_HP_SPEAKERS_MICMUTE_LED),
10429 SND_PCI_QUIRK(0x103c, 0x8896, "HP EliteBook 855 G8 Notebook PC", ALC285_FIXUP_HP_MUTE_LED),
10430 SND_PCI_QUIRK(0x103c, 0x8898, "HP EliteBook 845 G8 Notebook PC", ALC285_FIXUP_HP_LIMIT_INT_MIC_BOOST),
10431 SND_PCI_QUIRK(0x103c, 0x88d0, "HP Pavilion 15-eh1xxx (mainboard 88D0)", ALC287_FIXUP_HP_GPIO_LED),
10432 SND_PCI_QUIRK(0x103c, 0x88dd, "HP Pavilion 15z-ec200", ALC285_FIXUP_HP_MUTE_LED),
10433 SND_PCI_QUIRK(0x103c, 0x8902, "HP OMEN 16", ALC285_FIXUP_HP_MUTE_LED),
10434 SND_PCI_QUIRK(0x103c, 0x890e, "HP 255 G8 Notebook PC", ALC236_FIXUP_HP_MUTE_LED_COEFBIT2),
10435 SND_PCI_QUIRK(0x103c, 0x8919, "HP Pavilion Aero Laptop 13-be0xxx", ALC287_FIXUP_HP_GPIO_LED),
10436 SND_PCI_QUIRK(0x103c, 0x896d, "HP ZBook Firefly 16 G9", ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED),
10437 SND_PCI_QUIRK(0x103c, 0x896e, "HP EliteBook x360 830 G9", ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED),
10438 SND_PCI_QUIRK(0x103c, 0x8971, "HP EliteBook 830 G9", ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED),
10439 SND_PCI_QUIRK(0x103c, 0x8972, "HP EliteBook 840 G9", ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED),
10440 SND_PCI_QUIRK(0x103c, 0x8973, "HP EliteBook 860 G9", ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED),
10441 SND_PCI_QUIRK(0x103c, 0x8974, "HP EliteBook 840 Aero G9", ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED),
10442 SND_PCI_QUIRK(0x103c, 0x8975, "HP EliteBook x360 840 Aero G9", ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED),
10443 SND_PCI_QUIRK(0x103c, 0x897d, "HP mt440 Mobile Thin Client U74", ALC236_FIXUP_HP_GPIO_LED),
10444 SND_PCI_QUIRK(0x103c, 0x8981, "HP Elite Dragonfly G3", ALC245_FIXUP_CS35L41_SPI_4),
10445 SND_PCI_QUIRK(0x103c, 0x898e, "HP EliteBook 835 G9", ALC287_FIXUP_CS35L41_I2C_2),
10446 SND_PCI_QUIRK(0x103c, 0x898f, "HP EliteBook 835 G9", ALC287_FIXUP_CS35L41_I2C_2),
10447 SND_PCI_QUIRK(0x103c, 0x8991, "HP EliteBook 845 G9", ALC287_FIXUP_CS35L41_I2C_2_HP_GPIO_LED),
10448 SND_PCI_QUIRK(0x103c, 0x8992, "HP EliteBook 845 G9", ALC287_FIXUP_CS35L41_I2C_2),
10449 SND_PCI_QUIRK(0x103c, 0x8994, "HP EliteBook 855 G9", ALC287_FIXUP_CS35L41_I2C_2_HP_GPIO_LED),
10450 SND_PCI_QUIRK(0x103c, 0x8995, "HP EliteBook 855 G9", ALC287_FIXUP_CS35L41_I2C_2),
10451 SND_PCI_QUIRK(0x103c, 0x89a4, "HP ProBook 440 G9", ALC236_FIXUP_HP_GPIO_LED),
10452 SND_PCI_QUIRK(0x103c, 0x89a6, "HP ProBook 450 G9", ALC236_FIXUP_HP_GPIO_LED),
10453 SND_PCI_QUIRK(0x103c, 0x89aa, "HP EliteBook 630 G9", ALC236_FIXUP_HP_GPIO_LED),
10454 SND_PCI_QUIRK(0x103c, 0x89ac, "HP EliteBook 640 G9", ALC236_FIXUP_HP_GPIO_LED),
10455 SND_PCI_QUIRK(0x103c, 0x89ae, "HP EliteBook 650 G9", ALC236_FIXUP_HP_GPIO_LED),
10456 SND_PCI_QUIRK(0x103c, 0x89c0, "HP ZBook Power 15.6 G9", ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED),
10457 SND_PCI_QUIRK(0x103c, 0x89c3, "Zbook Studio G9", ALC245_FIXUP_CS35L41_SPI_4_HP_GPIO_LED),
10458 SND_PCI_QUIRK(0x103c, 0x89c6, "Zbook Fury 17 G9", ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED),
10459 SND_PCI_QUIRK(0x103c, 0x89ca, "HP", ALC236_FIXUP_HP_MUTE_LED_MICMUTE_VREF),
10460 SND_PCI_QUIRK(0x103c, 0x89d3, "HP EliteBook 645 G9 (MB 89D2)", ALC236_FIXUP_HP_MUTE_LED_MICMUTE_VREF),
10461 SND_PCI_QUIRK(0x103c, 0x89e7, "HP Elite x2 G9", ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED),
10462 SND_PCI_QUIRK(0x103c, 0x8a0f, "HP Pavilion 14-ec1xxx", ALC287_FIXUP_HP_GPIO_LED),
10463 SND_PCI_QUIRK(0x103c, 0x8a20, "HP Laptop 15s-fq5xxx", ALC236_FIXUP_HP_MUTE_LED_COEFBIT2),
10464 SND_PCI_QUIRK(0x103c, 0x8a25, "HP Victus 16-d1xxx (MB 8A25)", ALC245_FIXUP_HP_MUTE_LED_COEFBIT),
10465 SND_PCI_QUIRK(0x103c, 0x8a28, "HP Envy 13", ALC287_FIXUP_CS35L41_I2C_2),
10466 SND_PCI_QUIRK(0x103c, 0x8a29, "HP Envy 15", ALC287_FIXUP_CS35L41_I2C_2),
10467 SND_PCI_QUIRK(0x103c, 0x8a2a, "HP Envy 15", ALC287_FIXUP_CS35L41_I2C_2),
10468 SND_PCI_QUIRK(0x103c, 0x8a2b, "HP Envy 15", ALC287_FIXUP_CS35L41_I2C_2),
10469 SND_PCI_QUIRK(0x103c, 0x8a2c, "HP Envy 16", ALC287_FIXUP_CS35L41_I2C_2),
10470 SND_PCI_QUIRK(0x103c, 0x8a2d, "HP Envy 16", ALC287_FIXUP_CS35L41_I2C_2),
10471 SND_PCI_QUIRK(0x103c, 0x8a2e, "HP Envy 16", ALC287_FIXUP_CS35L41_I2C_2),
10472 SND_PCI_QUIRK(0x103c, 0x8a30, "HP Envy 17", ALC287_FIXUP_CS35L41_I2C_2),
10473 SND_PCI_QUIRK(0x103c, 0x8a31, "HP Envy 15", ALC287_FIXUP_CS35L41_I2C_2),
10474 SND_PCI_QUIRK(0x103c, 0x8a6e, "HP EDNA 360", ALC287_FIXUP_CS35L41_I2C_4),
10475 SND_PCI_QUIRK(0x103c, 0x8a74, "HP ProBook 440 G8 Notebook PC", ALC236_FIXUP_HP_GPIO_LED),
10476 SND_PCI_QUIRK(0x103c, 0x8a78, "HP Dev One", ALC285_FIXUP_HP_LIMIT_INT_MIC_BOOST),
10477 SND_PCI_QUIRK(0x103c, 0x8aa0, "HP ProBook 440 G9 (MB 8A9E)", ALC236_FIXUP_HP_GPIO_LED),
10478 SND_PCI_QUIRK(0x103c, 0x8aa3, "HP ProBook 450 G9 (MB 8AA1)", ALC236_FIXUP_HP_GPIO_LED),
10479 SND_PCI_QUIRK(0x103c, 0x8aa8, "HP EliteBook 640 G9 (MB 8AA6)", ALC236_FIXUP_HP_GPIO_LED),
10480 SND_PCI_QUIRK(0x103c, 0x8aab, "HP EliteBook 650 G9 (MB 8AA9)", ALC236_FIXUP_HP_GPIO_LED),
10481 SND_PCI_QUIRK(0x103c, 0x8ab9, "HP EliteBook 840 G8 (MB 8AB8)", ALC285_FIXUP_HP_GPIO_LED),
10482 SND_PCI_QUIRK(0x103c, 0x8abb, "HP ZBook Firefly 14 G9", ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED),
10483 SND_PCI_QUIRK(0x103c, 0x8ad1, "HP EliteBook 840 14 inch G9 Notebook PC", ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED),
10484 SND_PCI_QUIRK(0x103c, 0x8ad2, "HP EliteBook 860 16 inch G9 Notebook PC", ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED),
10485 SND_PCI_QUIRK(0x103c, 0x8ad8, "HP 800 G9", ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED),
10486 SND_PCI_QUIRK(0x103c, 0x8b0f, "HP Elite mt645 G7 Mobile Thin Client U81", ALC236_FIXUP_HP_MUTE_LED_MICMUTE_VREF),
10487 SND_PCI_QUIRK(0x103c, 0x8b2f, "HP 255 15.6 inch G10 Notebook PC", ALC236_FIXUP_HP_MUTE_LED_COEFBIT2),
10488 SND_PCI_QUIRK(0x103c, 0x8b3a, "HP Envy 15", ALC287_FIXUP_CS35L41_I2C_2),
10489 SND_PCI_QUIRK(0x103c, 0x8b3f, "HP mt440 Mobile Thin Client U91", ALC236_FIXUP_HP_GPIO_LED),
10490 SND_PCI_QUIRK(0x103c, 0x8b42, "HP", ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED),
10491 SND_PCI_QUIRK(0x103c, 0x8b43, "HP", ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED),
10492 SND_PCI_QUIRK(0x103c, 0x8b44, "HP", ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED),
10493 SND_PCI_QUIRK(0x103c, 0x8b45, "HP", ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED),
10494 SND_PCI_QUIRK(0x103c, 0x8b46, "HP", ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED),
10495 SND_PCI_QUIRK(0x103c, 0x8b47, "HP", ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED),
10496 SND_PCI_QUIRK(0x103c, 0x8b59, "HP Elite mt645 G7 Mobile Thin Client U89", ALC236_FIXUP_HP_MUTE_LED_MICMUTE_VREF),
10497 SND_PCI_QUIRK(0x103c, 0x8b5d, "HP", ALC236_FIXUP_HP_MUTE_LED_MICMUTE_VREF),
10498 SND_PCI_QUIRK(0x103c, 0x8b5e, "HP", ALC236_FIXUP_HP_MUTE_LED_MICMUTE_VREF),
10499 SND_PCI_QUIRK(0x103c, 0x8b63, "HP Elite Dragonfly 13.5 inch G4", ALC245_FIXUP_CS35L41_SPI_4_HP_GPIO_LED),
10500 SND_PCI_QUIRK(0x103c, 0x8b65, "HP ProBook 455 15.6 inch G10 Notebook PC", ALC236_FIXUP_HP_MUTE_LED_MICMUTE_VREF),
10501 SND_PCI_QUIRK(0x103c, 0x8b66, "HP", ALC236_FIXUP_HP_MUTE_LED_MICMUTE_VREF),
10502 SND_PCI_QUIRK(0x103c, 0x8b70, "HP EliteBook 835 G10", ALC287_FIXUP_CS35L41_I2C_2_HP_GPIO_LED),
10503 SND_PCI_QUIRK(0x103c, 0x8b72, "HP EliteBook 845 G10", ALC287_FIXUP_CS35L41_I2C_2_HP_GPIO_LED),
10504 SND_PCI_QUIRK(0x103c, 0x8b74, "HP EliteBook 845W G10", ALC287_FIXUP_CS35L41_I2C_2_HP_GPIO_LED),
10505 SND_PCI_QUIRK(0x103c, 0x8b77, "HP ElieBook 865 G10", ALC287_FIXUP_CS35L41_I2C_2),
10506 SND_PCI_QUIRK(0x103c, 0x8b7a, "HP", ALC236_FIXUP_HP_GPIO_LED),
10507 SND_PCI_QUIRK(0x103c, 0x8b7d, "HP", ALC236_FIXUP_HP_GPIO_LED),
10508 SND_PCI_QUIRK(0x103c, 0x8b87, "HP", ALC236_FIXUP_HP_GPIO_LED),
10509 SND_PCI_QUIRK(0x103c, 0x8b8a, "HP", ALC236_FIXUP_HP_GPIO_LED),
10510 SND_PCI_QUIRK(0x103c, 0x8b8b, "HP", ALC236_FIXUP_HP_GPIO_LED),
10511 SND_PCI_QUIRK(0x103c, 0x8b8d, "HP", ALC236_FIXUP_HP_GPIO_LED),
10512 SND_PCI_QUIRK(0x103c, 0x8b8f, "HP", ALC245_FIXUP_CS35L41_SPI_4_HP_GPIO_LED),
10513 SND_PCI_QUIRK(0x103c, 0x8b92, "HP", ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED),
10514 SND_PCI_QUIRK(0x103c, 0x8b96, "HP", ALC236_FIXUP_HP_MUTE_LED_MICMUTE_VREF),
10515 SND_PCI_QUIRK(0x103c, 0x8b97, "HP", ALC236_FIXUP_HP_MUTE_LED_MICMUTE_VREF),
10516 SND_PCI_QUIRK(0x103c, 0x8bb3, "HP Slim OMEN", ALC287_FIXUP_CS35L41_I2C_2),
10517 SND_PCI_QUIRK(0x103c, 0x8bb4, "HP Slim OMEN", ALC287_FIXUP_CS35L41_I2C_2),
10518 SND_PCI_QUIRK(0x103c, 0x8bdd, "HP Envy 17", ALC287_FIXUP_CS35L41_I2C_2),
10519 SND_PCI_QUIRK(0x103c, 0x8bde, "HP Envy 17", ALC287_FIXUP_CS35L41_I2C_2),
10520 SND_PCI_QUIRK(0x103c, 0x8bdf, "HP Envy 15", ALC287_FIXUP_CS35L41_I2C_2),
10521 SND_PCI_QUIRK(0x103c, 0x8be0, "HP Envy 15", ALC287_FIXUP_CS35L41_I2C_2),
10522 SND_PCI_QUIRK(0x103c, 0x8be1, "HP Envy 15", ALC287_FIXUP_CS35L41_I2C_2),
10523 SND_PCI_QUIRK(0x103c, 0x8be2, "HP Envy 15", ALC287_FIXUP_CS35L41_I2C_2),
10524 SND_PCI_QUIRK(0x103c, 0x8be3, "HP Envy 15", ALC287_FIXUP_CS35L41_I2C_2),
10525 SND_PCI_QUIRK(0x103c, 0x8be5, "HP Envy 16", ALC287_FIXUP_CS35L41_I2C_2),
10526 SND_PCI_QUIRK(0x103c, 0x8be6, "HP Envy 16", ALC287_FIXUP_CS35L41_I2C_2),
10527 SND_PCI_QUIRK(0x103c, 0x8be7, "HP Envy 17", ALC287_FIXUP_CS35L41_I2C_2),
10528 SND_PCI_QUIRK(0x103c, 0x8be8, "HP Envy 17", ALC287_FIXUP_CS35L41_I2C_2),
10529 SND_PCI_QUIRK(0x103c, 0x8be9, "HP Envy 15", ALC287_FIXUP_CS35L41_I2C_2),
10530 SND_PCI_QUIRK(0x103c, 0x8bf0, "HP", ALC236_FIXUP_HP_GPIO_LED),
10531 SND_PCI_QUIRK(0x103c, 0x8c15, "HP Spectre x360 2-in-1 Laptop 14-eu0xxx", ALC245_FIXUP_HP_SPECTRE_X360_EU0XXX),
10532 SND_PCI_QUIRK(0x103c, 0x8c16, "HP Spectre x360 2-in-1 Laptop 16-aa0xxx", ALC245_FIXUP_HP_SPECTRE_X360_16_AA0XXX),
10533 SND_PCI_QUIRK(0x103c, 0x8c17, "HP Spectre 16", ALC287_FIXUP_CS35L41_I2C_2),
10534 SND_PCI_QUIRK(0x103c, 0x8c21, "HP Pavilion Plus Laptop 14-ey0XXX", ALC245_FIXUP_HP_X360_MUTE_LEDS),
10535 SND_PCI_QUIRK(0x103c, 0x8c30, "HP Victus 15-fb1xxx", ALC245_FIXUP_HP_MUTE_LED_COEFBIT),
10536 SND_PCI_QUIRK(0x103c, 0x8c46, "HP EliteBook 830 G11", ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED),
10537 SND_PCI_QUIRK(0x103c, 0x8c47, "HP EliteBook 840 G11", ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED),
10538 SND_PCI_QUIRK(0x103c, 0x8c48, "HP EliteBook 860 G11", ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED),
10539 SND_PCI_QUIRK(0x103c, 0x8c49, "HP Elite x360 830 2-in-1 G11", ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED),
10540 SND_PCI_QUIRK(0x103c, 0x8c4d, "HP Omen", ALC287_FIXUP_CS35L41_I2C_2),
10541 SND_PCI_QUIRK(0x103c, 0x8c4e, "HP Omen", ALC287_FIXUP_CS35L41_I2C_2),
10542 SND_PCI_QUIRK(0x103c, 0x8c4f, "HP Envy 15", ALC287_FIXUP_CS35L41_I2C_2),
10543 SND_PCI_QUIRK(0x103c, 0x8c50, "HP Envy 17", ALC287_FIXUP_CS35L41_I2C_2),
10544 SND_PCI_QUIRK(0x103c, 0x8c51, "HP Envy 17", ALC287_FIXUP_CS35L41_I2C_2),
10545 SND_PCI_QUIRK(0x103c, 0x8c52, "HP EliteBook 1040 G11", ALC285_FIXUP_HP_GPIO_LED),
10546 SND_PCI_QUIRK(0x103c, 0x8c53, "HP Elite x360 1040 2-in-1 G11", ALC285_FIXUP_HP_GPIO_LED),
10547 SND_PCI_QUIRK(0x103c, 0x8c66, "HP Envy 16", ALC287_FIXUP_CS35L41_I2C_2),
10548 SND_PCI_QUIRK(0x103c, 0x8c67, "HP Envy 17", ALC287_FIXUP_CS35L41_I2C_2),
10549 SND_PCI_QUIRK(0x103c, 0x8c68, "HP Envy 17", ALC287_FIXUP_CS35L41_I2C_2),
10550 SND_PCI_QUIRK(0x103c, 0x8c6a, "HP Envy 16", ALC287_FIXUP_CS35L41_I2C_2),
10551 SND_PCI_QUIRK(0x103c, 0x8c70, "HP EliteBook 835 G11", ALC287_FIXUP_CS35L41_I2C_2_HP_GPIO_LED),
10552 SND_PCI_QUIRK(0x103c, 0x8c71, "HP EliteBook 845 G11", ALC287_FIXUP_CS35L41_I2C_2_HP_GPIO_LED),
10553 SND_PCI_QUIRK(0x103c, 0x8c72, "HP EliteBook 865 G11", ALC287_FIXUP_CS35L41_I2C_2_HP_GPIO_LED),
10554 SND_PCI_QUIRK(0x103c, 0x8c7b, "HP ProBook 445 G11", ALC236_FIXUP_HP_MUTE_LED_MICMUTE_VREF),
10555 SND_PCI_QUIRK(0x103c, 0x8c7c, "HP ProBook 445 G11", ALC236_FIXUP_HP_MUTE_LED_MICMUTE_VREF),
10556 SND_PCI_QUIRK(0x103c, 0x8c7d, "HP ProBook 465 G11", ALC236_FIXUP_HP_MUTE_LED_MICMUTE_VREF),
10557 SND_PCI_QUIRK(0x103c, 0x8c7e, "HP ProBook 465 G11", ALC236_FIXUP_HP_MUTE_LED_MICMUTE_VREF),
10558 SND_PCI_QUIRK(0x103c, 0x8c7f, "HP EliteBook 645 G11", ALC236_FIXUP_HP_MUTE_LED_MICMUTE_VREF),
10559 SND_PCI_QUIRK(0x103c, 0x8c80, "HP EliteBook 645 G11", ALC236_FIXUP_HP_MUTE_LED_MICMUTE_VREF),
10560 SND_PCI_QUIRK(0x103c, 0x8c81, "HP EliteBook 665 G11", ALC236_FIXUP_HP_MUTE_LED_MICMUTE_VREF),
10561 SND_PCI_QUIRK(0x103c, 0x8c89, "HP ProBook 460 G11", ALC236_FIXUP_HP_GPIO_LED),
10562 SND_PCI_QUIRK(0x103c, 0x8c8a, "HP EliteBook 630", ALC236_FIXUP_HP_GPIO_LED),
10563 SND_PCI_QUIRK(0x103c, 0x8c8c, "HP EliteBook 660", ALC236_FIXUP_HP_GPIO_LED),
10564 SND_PCI_QUIRK(0x103c, 0x8c8d, "HP ProBook 440 G11", ALC236_FIXUP_HP_GPIO_LED),
10565 SND_PCI_QUIRK(0x103c, 0x8c8e, "HP ProBook 460 G11", ALC236_FIXUP_HP_GPIO_LED),
10566 SND_PCI_QUIRK(0x103c, 0x8c90, "HP EliteBook 640", ALC236_FIXUP_HP_GPIO_LED),
10567 SND_PCI_QUIRK(0x103c, 0x8c91, "HP EliteBook 660", ALC236_FIXUP_HP_GPIO_LED),
10568 SND_PCI_QUIRK(0x103c, 0x8c96, "HP", ALC236_FIXUP_HP_MUTE_LED_MICMUTE_VREF),
10569 SND_PCI_QUIRK(0x103c, 0x8c97, "HP ZBook", ALC236_FIXUP_HP_MUTE_LED_MICMUTE_VREF),
10570 SND_PCI_QUIRK(0x103c, 0x8ca1, "HP ZBook Power", ALC236_FIXUP_HP_GPIO_LED),
10571 SND_PCI_QUIRK(0x103c, 0x8ca2, "HP ZBook Power", ALC236_FIXUP_HP_GPIO_LED),
10572 SND_PCI_QUIRK(0x103c, 0x8ca4, "HP ZBook Fury", ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED),
10573 SND_PCI_QUIRK(0x103c, 0x8ca7, "HP ZBook Fury", ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED),
10574 SND_PCI_QUIRK(0x103c, 0x8caf, "HP Elite mt645 G8 Mobile Thin Client", ALC236_FIXUP_HP_MUTE_LED_MICMUTE_VREF),
10575 SND_PCI_QUIRK(0x103c, 0x8cbd, "HP Pavilion Aero Laptop 13-bg0xxx", ALC245_FIXUP_HP_X360_MUTE_LEDS),
10576 SND_PCI_QUIRK(0x103c, 0x8cdd, "HP Spectre", ALC287_FIXUP_CS35L41_I2C_2),
10577 SND_PCI_QUIRK(0x103c, 0x8cde, "HP Spectre", ALC287_FIXUP_CS35L41_I2C_2),
10578 SND_PCI_QUIRK(0x103c, 0x8cdf, "HP SnowWhite", ALC287_FIXUP_CS35L41_I2C_2_HP_GPIO_LED),
10579 SND_PCI_QUIRK(0x103c, 0x8ce0, "HP SnowWhite", ALC287_FIXUP_CS35L41_I2C_2_HP_GPIO_LED),
10580 SND_PCI_QUIRK(0x103c, 0x8cf5, "HP ZBook Studio 16", ALC245_FIXUP_CS35L41_SPI_4_HP_GPIO_LED),
10581 SND_PCI_QUIRK(0x1043, 0x103e, "ASUS X540SA", ALC256_FIXUP_ASUS_MIC),
10582 SND_PCI_QUIRK(0x1043, 0x103f, "ASUS TX300", ALC282_FIXUP_ASUS_TX300),
10583 SND_PCI_QUIRK(0x1043, 0x106d, "Asus K53BE", ALC269_FIXUP_LIMIT_INT_MIC_BOOST),
10584 SND_PCI_QUIRK(0x1043, 0x10a1, "ASUS UX391UA", ALC294_FIXUP_ASUS_SPK),
10585 SND_PCI_QUIRK(0x1043, 0x10a4, "ASUS TP3407SA", ALC287_FIXUP_TAS2781_I2C),
10586 SND_PCI_QUIRK(0x1043, 0x10c0, "ASUS X540SA", ALC256_FIXUP_ASUS_MIC),
10587 SND_PCI_QUIRK(0x1043, 0x10d0, "ASUS X540LA/X540LJ", ALC255_FIXUP_ASUS_MIC_NO_PRESENCE),
10588 SND_PCI_QUIRK(0x1043, 0x10d3, "ASUS K6500ZC", ALC294_FIXUP_ASUS_SPK),
10589 SND_PCI_QUIRK(0x1043, 0x1154, "ASUS TP3607SH", ALC287_FIXUP_TAS2781_I2C),
10590 SND_PCI_QUIRK(0x1043, 0x115d, "Asus 1015E", ALC269_FIXUP_LIMIT_INT_MIC_BOOST),
10591 SND_PCI_QUIRK(0x1043, 0x11c0, "ASUS X556UR", ALC255_FIXUP_ASUS_MIC_NO_PRESENCE),
10592 SND_PCI_QUIRK(0x1043, 0x1204, "ASUS Strix G615JHR_JMR_JPR", ALC287_FIXUP_TAS2781_I2C),
10593 SND_PCI_QUIRK(0x1043, 0x1214, "ASUS Strix G615LH_LM_LP", ALC287_FIXUP_TAS2781_I2C),
10594 SND_PCI_QUIRK(0x1043, 0x125e, "ASUS Q524UQK", ALC255_FIXUP_ASUS_MIC_NO_PRESENCE),
10595 SND_PCI_QUIRK(0x1043, 0x1271, "ASUS X430UN", ALC256_FIXUP_ASUS_MIC_NO_PRESENCE),
10596 SND_PCI_QUIRK(0x1043, 0x1290, "ASUS X441SA", ALC233_FIXUP_EAPD_COEF_AND_MIC_NO_PRESENCE),
10597 SND_PCI_QUIRK(0x1043, 0x12a0, "ASUS X441UV", ALC233_FIXUP_EAPD_COEF_AND_MIC_NO_PRESENCE),
10598 SND_PCI_QUIRK(0x1043, 0x12a3, "Asus N7691ZM", ALC269_FIXUP_ASUS_N7601ZM),
10599 SND_PCI_QUIRK(0x1043, 0x12af, "ASUS UX582ZS", ALC245_FIXUP_CS35L41_SPI_2),
10600 SND_PCI_QUIRK(0x1043, 0x12e0, "ASUS X541SA", ALC256_FIXUP_ASUS_MIC),
10601 SND_PCI_QUIRK(0x1043, 0x12f0, "ASUS X541UV", ALC256_FIXUP_ASUS_MIC),
10602 SND_PCI_QUIRK(0x1043, 0x1313, "Asus K42JZ", ALC269VB_FIXUP_ASUS_MIC_NO_PRESENCE),
10603 SND_PCI_QUIRK(0x1043, 0x13b0, "ASUS Z550SA", ALC256_FIXUP_ASUS_MIC),
10604 SND_PCI_QUIRK(0x1043, 0x1427, "Asus Zenbook UX31E", ALC269VB_FIXUP_ASUS_ZENBOOK),
10605 SND_PCI_QUIRK(0x1043, 0x1433, "ASUS GX650PY/PZ/PV/PU/PYV/PZV/PIV/PVV", ALC285_FIXUP_ASUS_I2C_HEADSET_MIC),
10606 SND_PCI_QUIRK(0x1043, 0x1463, "Asus GA402X/GA402N", ALC285_FIXUP_ASUS_I2C_HEADSET_MIC),
10607 SND_PCI_QUIRK(0x1043, 0x1473, "ASUS GU604VI/VC/VE/VG/VJ/VQ/VU/VV/VY/VZ", ALC285_FIXUP_ASUS_HEADSET_MIC),
10608 SND_PCI_QUIRK(0x1043, 0x1483, "ASUS GU603VQ/VU/VV/VJ/VI", ALC285_FIXUP_ASUS_HEADSET_MIC),
10609 SND_PCI_QUIRK(0x1043, 0x1493, "ASUS GV601VV/VU/VJ/VQ/VI", ALC285_FIXUP_ASUS_HEADSET_MIC),
10610 SND_PCI_QUIRK(0x1043, 0x14d3, "ASUS G614JY/JZ/JG", ALC245_FIXUP_CS35L41_SPI_2),
10611 SND_PCI_QUIRK(0x1043, 0x14e3, "ASUS G513PI/PU/PV", ALC287_FIXUP_CS35L41_I2C_2),
10612 SND_PCI_QUIRK(0x1043, 0x1503, "ASUS G733PY/PZ/PZV/PYV", ALC287_FIXUP_CS35L41_I2C_2),
10613 SND_PCI_QUIRK(0x1043, 0x1517, "Asus Zenbook UX31A", ALC269VB_FIXUP_ASUS_ZENBOOK_UX31A),
10614 SND_PCI_QUIRK(0x1043, 0x1533, "ASUS GV302XA/XJ/XQ/XU/XV/XI", ALC287_FIXUP_CS35L41_I2C_2),
10615 SND_PCI_QUIRK(0x1043, 0x1573, "ASUS GZ301VV/VQ/VU/VJ/VA/VC/VE/VVC/VQC/VUC/VJC/VEC/VCC", ALC285_FIXUP_ASUS_HEADSET_MIC),
10616 SND_PCI_QUIRK(0x1043, 0x1662, "ASUS GV301QH", ALC294_FIXUP_ASUS_DUAL_SPK),
10617 SND_PCI_QUIRK(0x1043, 0x1663, "ASUS GU603ZI/ZJ/ZQ/ZU/ZV", ALC285_FIXUP_ASUS_HEADSET_MIC),
10618 SND_PCI_QUIRK(0x1043, 0x1683, "ASUS UM3402YAR", ALC287_FIXUP_CS35L41_I2C_2),
10619 SND_PCI_QUIRK(0x1043, 0x16a3, "ASUS UX3402VA", ALC245_FIXUP_CS35L41_SPI_2),
10620 SND_PCI_QUIRK(0x1043, 0x16b2, "ASUS GU603", ALC289_FIXUP_ASUS_GA401),
10621 SND_PCI_QUIRK(0x1043, 0x16d3, "ASUS UX5304VA", ALC245_FIXUP_CS35L41_SPI_2),
10622 SND_PCI_QUIRK(0x1043, 0x16e3, "ASUS UX50", ALC269_FIXUP_STEREO_DMIC),
10623 SND_PCI_QUIRK(0x1043, 0x16f3, "ASUS UX7602VI/BZ", ALC245_FIXUP_CS35L41_SPI_2),
10624 SND_PCI_QUIRK(0x1043, 0x1740, "ASUS UX430UA", ALC295_FIXUP_ASUS_DACS),
10625 SND_PCI_QUIRK(0x1043, 0x17d1, "ASUS UX431FL", ALC294_FIXUP_ASUS_DUAL_SPK),
10626 SND_PCI_QUIRK(0x1043, 0x17f3, "ROG Ally NR2301L/X", ALC294_FIXUP_ASUS_ALLY),
10627 SND_PCI_QUIRK(0x1043, 0x1eb3, "ROG Ally X RC72LA", ALC294_FIXUP_ASUS_ALLY_X),
10628 SND_PCI_QUIRK(0x1043, 0x1863, "ASUS UX6404VI/VV", ALC245_FIXUP_CS35L41_SPI_2),
10629 SND_PCI_QUIRK(0x1043, 0x1881, "ASUS Zephyrus S/M", ALC294_FIXUP_ASUS_GX502_PINS),
10630 SND_PCI_QUIRK(0x1043, 0x18b1, "Asus MJ401TA", ALC256_FIXUP_ASUS_HEADSET_MIC),
10631 SND_PCI_QUIRK(0x1043, 0x18d3, "ASUS UM3504DA", ALC294_FIXUP_CS35L41_I2C_2),
10632 SND_PCI_QUIRK(0x1043, 0x18f1, "Asus FX505DT", ALC256_FIXUP_ASUS_HEADSET_MIC),
10633 SND_PCI_QUIRK(0x1043, 0x194e, "ASUS UX563FD", ALC294_FIXUP_ASUS_HPE),
10634 SND_PCI_QUIRK(0x1043, 0x1970, "ASUS UX550VE", ALC289_FIXUP_ASUS_GA401),
10635 SND_PCI_QUIRK(0x1043, 0x1982, "ASUS B1400CEPE", ALC256_FIXUP_ASUS_HPE),
10636 SND_PCI_QUIRK(0x1043, 0x19ce, "ASUS B9450FA", ALC294_FIXUP_ASUS_HPE),
10637 SND_PCI_QUIRK(0x1043, 0x19e1, "ASUS UX581LV", ALC295_FIXUP_ASUS_MIC_NO_PRESENCE),
10638 SND_PCI_QUIRK(0x1043, 0x1a13, "Asus G73Jw", ALC269_FIXUP_ASUS_G73JW),
10639 SND_PCI_QUIRK(0x1043, 0x1a30, "ASUS X705UD", ALC256_FIXUP_ASUS_MIC),
10640 SND_PCI_QUIRK(0x1043, 0x1a63, "ASUS UX3405MA", ALC245_FIXUP_CS35L41_SPI_2),
10641 SND_PCI_QUIRK(0x1043, 0x1a83, "ASUS UM5302LA", ALC294_FIXUP_CS35L41_I2C_2),
10642 SND_PCI_QUIRK(0x1043, 0x1a8f, "ASUS UX582ZS", ALC245_FIXUP_CS35L41_SPI_2),
10643 SND_PCI_QUIRK(0x1043, 0x1b11, "ASUS UX431DA", ALC294_FIXUP_ASUS_COEF_1B),
10644 SND_PCI_QUIRK(0x1043, 0x1b13, "ASUS U41SV/GA403U", ALC285_FIXUP_ASUS_GA403U_HEADSET_MIC),
10645 SND_PCI_QUIRK(0x1043, 0x1b93, "ASUS G614JVR/JIR", ALC245_FIXUP_CS35L41_SPI_2),
10646 SND_PCI_QUIRK(0x1043, 0x1bbd, "ASUS Z550MA", ALC255_FIXUP_ASUS_MIC_NO_PRESENCE),
10647 SND_PCI_QUIRK(0x1043, 0x1c03, "ASUS UM3406HA", ALC287_FIXUP_CS35L41_I2C_2),
10648 SND_PCI_QUIRK(0x1043, 0x1c23, "Asus X55U", ALC269_FIXUP_LIMIT_INT_MIC_BOOST),
10649 SND_PCI_QUIRK(0x1043, 0x1c33, "ASUS UX5304MA", ALC245_FIXUP_CS35L41_SPI_2),
10650 SND_PCI_QUIRK(0x1043, 0x1c43, "ASUS UX8406MA", ALC245_FIXUP_CS35L41_SPI_2),
10651 SND_PCI_QUIRK(0x1043, 0x1c62, "ASUS GU603", ALC289_FIXUP_ASUS_GA401),
10652 SND_PCI_QUIRK(0x1043, 0x1c63, "ASUS GU605M", ALC285_FIXUP_ASUS_GU605_SPI_SPEAKER2_TO_DAC1),
10653 SND_PCI_QUIRK(0x1043, 0x1c92, "ASUS ROG Strix G15", ALC285_FIXUP_ASUS_G533Z_PINS),
10654 SND_PCI_QUIRK(0x1043, 0x1c9f, "ASUS G614JU/JV/JI", ALC285_FIXUP_ASUS_HEADSET_MIC),
10655 SND_PCI_QUIRK(0x1043, 0x1caf, "ASUS G634JY/JZ/JI/JG", ALC285_FIXUP_ASUS_SPI_REAR_SPEAKERS),
10656 SND_PCI_QUIRK(0x1043, 0x1ccd, "ASUS X555UB", ALC256_FIXUP_ASUS_MIC),
10657 SND_PCI_QUIRK(0x1043, 0x1ccf, "ASUS G814JU/JV/JI", ALC245_FIXUP_CS35L41_SPI_2),
10658 SND_PCI_QUIRK(0x1043, 0x1cdf, "ASUS G814JY/JZ/JG", ALC245_FIXUP_CS35L41_SPI_2),
10659 SND_PCI_QUIRK(0x1043, 0x1cef, "ASUS G834JY/JZ/JI/JG", ALC285_FIXUP_ASUS_HEADSET_MIC),
10660 SND_PCI_QUIRK(0x1043, 0x1d1f, "ASUS G713PI/PU/PV/PVN", ALC287_FIXUP_CS35L41_I2C_2),
10661 SND_PCI_QUIRK(0x1043, 0x1d42, "ASUS Zephyrus G14 2022", ALC289_FIXUP_ASUS_GA401),
10662 SND_PCI_QUIRK(0x1043, 0x1d4e, "ASUS TM420", ALC256_FIXUP_ASUS_HPE),
10663 SND_PCI_QUIRK(0x1043, 0x1da2, "ASUS UP6502ZA/ZD", ALC245_FIXUP_CS35L41_SPI_2),
10664 SND_PCI_QUIRK(0x1043, 0x1e02, "ASUS UX3402ZA", ALC245_FIXUP_CS35L41_SPI_2),
10665 SND_PCI_QUIRK(0x1043, 0x1e11, "ASUS Zephyrus G15", ALC289_FIXUP_ASUS_GA502),
10666 SND_PCI_QUIRK(0x1043, 0x1e12, "ASUS UM3402", ALC287_FIXUP_CS35L41_I2C_2),
10667 SND_PCI_QUIRK(0x1043, 0x1e1f, "ASUS Vivobook 15 X1504VAP", ALC2XX_FIXUP_HEADSET_MIC),
10668 SND_PCI_QUIRK(0x1043, 0x1e51, "ASUS Zephyrus M15", ALC294_FIXUP_ASUS_GU502_PINS),
10669 SND_PCI_QUIRK(0x1043, 0x1e5e, "ASUS ROG Strix G513", ALC294_FIXUP_ASUS_G513_PINS),
10670 SND_PCI_QUIRK(0x1043, 0x1e8e, "ASUS Zephyrus G15", ALC289_FIXUP_ASUS_GA401),
10671 SND_PCI_QUIRK(0x1043, 0x1eb3, "ASUS Ally RCLA72", ALC287_FIXUP_TAS2781_I2C),
10672 SND_PCI_QUIRK(0x1043, 0x1ed3, "ASUS HN7306W", ALC287_FIXUP_CS35L41_I2C_2),
10673 SND_PCI_QUIRK(0x1043, 0x1ee2, "ASUS UM6702RA/RC", ALC287_FIXUP_CS35L41_I2C_2),
10674 SND_PCI_QUIRK(0x1043, 0x1c52, "ASUS Zephyrus G15 2022", ALC289_FIXUP_ASUS_GA401),
10675 SND_PCI_QUIRK(0x1043, 0x1f11, "ASUS Zephyrus G14", ALC289_FIXUP_ASUS_GA401),
10676 SND_PCI_QUIRK(0x1043, 0x1f12, "ASUS UM5302", ALC287_FIXUP_CS35L41_I2C_2),
10677 SND_PCI_QUIRK(0x1043, 0x1f1f, "ASUS H7604JI/JV/J3D", ALC245_FIXUP_CS35L41_SPI_2),
10678 SND_PCI_QUIRK(0x1043, 0x1f62, "ASUS UX7602ZM", ALC245_FIXUP_CS35L41_SPI_2),
10679 SND_PCI_QUIRK(0x1043, 0x1f92, "ASUS ROG Flow X16", ALC289_FIXUP_ASUS_GA401),
10680 SND_PCI_QUIRK(0x1043, 0x3030, "ASUS ZN270IE", ALC256_FIXUP_ASUS_AIO_GPIO2),
10681 SND_PCI_QUIRK(0x1043, 0x3a20, "ASUS G614JZR", ALC285_FIXUP_ASUS_SPI_REAR_SPEAKERS),
10682 SND_PCI_QUIRK(0x1043, 0x3a30, "ASUS G814JVR/JIR", ALC285_FIXUP_ASUS_SPI_REAR_SPEAKERS),
10683 SND_PCI_QUIRK(0x1043, 0x3a40, "ASUS G814JZR", ALC285_FIXUP_ASUS_SPI_REAR_SPEAKERS),
10684 SND_PCI_QUIRK(0x1043, 0x3a50, "ASUS G834JYR/JZR", ALC285_FIXUP_ASUS_SPI_REAR_SPEAKERS),
10685 SND_PCI_QUIRK(0x1043, 0x3a60, "ASUS G634JYR/JZR", ALC285_FIXUP_ASUS_SPI_REAR_SPEAKERS),
10686 SND_PCI_QUIRK(0x1043, 0x3e30, "ASUS TP3607SA", ALC287_FIXUP_TAS2781_I2C),
10687 SND_PCI_QUIRK(0x1043, 0x3ee0, "ASUS Strix G815_JHR_JMR_JPR", ALC287_FIXUP_TAS2781_I2C),
10688 SND_PCI_QUIRK(0x1043, 0x3ef0, "ASUS Strix G635LR_LW_LX", ALC287_FIXUP_TAS2781_I2C),
10689 SND_PCI_QUIRK(0x1043, 0x3f00, "ASUS Strix G815LH_LM_LP", ALC287_FIXUP_TAS2781_I2C),
10690 SND_PCI_QUIRK(0x1043, 0x3f10, "ASUS Strix G835LR_LW_LX", ALC287_FIXUP_TAS2781_I2C),
10691 SND_PCI_QUIRK(0x1043, 0x3f20, "ASUS Strix G615LR_LW", ALC287_FIXUP_TAS2781_I2C),
10692 SND_PCI_QUIRK(0x1043, 0x3f30, "ASUS Strix G815LR_LW", ALC287_FIXUP_TAS2781_I2C),
10693 SND_PCI_QUIRK(0x1043, 0x831a, "ASUS P901", ALC269_FIXUP_STEREO_DMIC),
10694 SND_PCI_QUIRK(0x1043, 0x834a, "ASUS S101", ALC269_FIXUP_STEREO_DMIC),
10695 SND_PCI_QUIRK(0x1043, 0x8398, "ASUS P1005", ALC269_FIXUP_STEREO_DMIC),
10696 SND_PCI_QUIRK(0x1043, 0x83ce, "ASUS P1005", ALC269_FIXUP_STEREO_DMIC),
10697 SND_PCI_QUIRK(0x1043, 0x8516, "ASUS X101CH", ALC269_FIXUP_ASUS_X101),
10698 SND_PCI_QUIRK(0x104d, 0x9073, "Sony VAIO", ALC275_FIXUP_SONY_VAIO_GPIO2),
10699 SND_PCI_QUIRK(0x104d, 0x907b, "Sony VAIO", ALC275_FIXUP_SONY_HWEQ),
10700 SND_PCI_QUIRK(0x104d, 0x9084, "Sony VAIO", ALC275_FIXUP_SONY_HWEQ),
10701 SND_PCI_QUIRK(0x104d, 0x9099, "Sony VAIO S13", ALC275_FIXUP_SONY_DISABLE_AAMIX),
10702 SND_PCI_QUIRK(0x104d, 0x90b5, "Sony VAIO Pro 11", ALC286_FIXUP_SONY_MIC_NO_PRESENCE),
10703 SND_PCI_QUIRK(0x104d, 0x90b6, "Sony VAIO Pro 13", ALC286_FIXUP_SONY_MIC_NO_PRESENCE),
10704 SND_PCI_QUIRK(0x10cf, 0x1475, "Lifebook", ALC269_FIXUP_LIFEBOOK),
10705 SND_PCI_QUIRK(0x10cf, 0x159f, "Lifebook E780", ALC269_FIXUP_LIFEBOOK_NO_HP_TO_LINEOUT),
10706 SND_PCI_QUIRK(0x10cf, 0x15dc, "Lifebook T731", ALC269_FIXUP_LIFEBOOK_HP_PIN),
10707 SND_PCI_QUIRK(0x10cf, 0x1629, "Lifebook U7x7", ALC255_FIXUP_LIFEBOOK_U7x7_HEADSET_MIC),
10708 SND_PCI_QUIRK(0x10cf, 0x1757, "Lifebook E752", ALC269_FIXUP_LIFEBOOK_HP_PIN),
10709 SND_PCI_QUIRK(0x10cf, 0x1845, "Lifebook U904", ALC269_FIXUP_LIFEBOOK_EXTMIC),
10710 SND_PCI_QUIRK(0x10ec, 0x10f2, "Intel Reference board", ALC700_FIXUP_INTEL_REFERENCE),
10711 SND_PCI_QUIRK(0x10ec, 0x118c, "Medion EE4254 MD62100", ALC256_FIXUP_MEDION_HEADSET_NO_PRESENCE),
10712 SND_PCI_QUIRK(0x10ec, 0x119e, "Positivo SU C1400", ALC269_FIXUP_ASPIRE_HEADSET_MIC),
10713 SND_PCI_QUIRK(0x10ec, 0x11bc, "VAIO VJFE-IL", ALC269_FIXUP_LIMIT_INT_MIC_BOOST),
10714 SND_PCI_QUIRK(0x10ec, 0x1230, "Intel Reference board", ALC295_FIXUP_CHROME_BOOK),
10715 SND_PCI_QUIRK(0x10ec, 0x124c, "Intel Reference board", ALC295_FIXUP_CHROME_BOOK),
10716 SND_PCI_QUIRK(0x10ec, 0x1252, "Intel Reference board", ALC295_FIXUP_CHROME_BOOK),
10717 SND_PCI_QUIRK(0x10ec, 0x1254, "Intel Reference board", ALC295_FIXUP_CHROME_BOOK),
10718 SND_PCI_QUIRK(0x10ec, 0x12cc, "Intel Reference board", ALC295_FIXUP_CHROME_BOOK),
10719 SND_PCI_QUIRK(0x10ec, 0x12f6, "Intel Reference board", ALC295_FIXUP_CHROME_BOOK),
10720 SND_PCI_QUIRK(0x10f7, 0x8338, "Panasonic CF-SZ6", ALC269_FIXUP_ASPIRE_HEADSET_MIC),
10721 SND_PCI_QUIRK(0x144d, 0xc109, "Samsung Ativ book 9 (NP900X3G)", ALC269_FIXUP_INV_DMIC),
10722 SND_PCI_QUIRK(0x144d, 0xc169, "Samsung Notebook 9 Pen (NP930SBE-K01US)", ALC298_FIXUP_SAMSUNG_AMP),
10723 SND_PCI_QUIRK(0x144d, 0xc176, "Samsung Notebook 9 Pro (NP930MBE-K04US)", ALC298_FIXUP_SAMSUNG_AMP),
10724 SND_PCI_QUIRK(0x144d, 0xc189, "Samsung Galaxy Flex Book (NT950QCG-X716)", ALC298_FIXUP_SAMSUNG_AMP),
10725 SND_PCI_QUIRK(0x144d, 0xc18a, "Samsung Galaxy Book Ion (NP930XCJ-K01US)", ALC298_FIXUP_SAMSUNG_AMP),
10726 SND_PCI_QUIRK(0x144d, 0xc1a3, "Samsung Galaxy Book Pro (NP935XDB-KC1SE)", ALC298_FIXUP_SAMSUNG_AMP),
10727 SND_PCI_QUIRK(0x144d, 0xc1a4, "Samsung Galaxy Book Pro 360 (NT935QBD)", ALC298_FIXUP_SAMSUNG_AMP),
10728 SND_PCI_QUIRK(0x144d, 0xc1a6, "Samsung Galaxy Book Pro 360 (NP930QBD)", ALC298_FIXUP_SAMSUNG_AMP),
10729 SND_PCI_QUIRK(0x144d, 0xc740, "Samsung Ativ book 8 (NP870Z5G)", ALC269_FIXUP_ATIV_BOOK_8),
10730 SND_PCI_QUIRK(0x144d, 0xc812, "Samsung Notebook Pen S (NT950SBE-X58)", ALC298_FIXUP_SAMSUNG_AMP),
10731 SND_PCI_QUIRK(0x144d, 0xc830, "Samsung Galaxy Book Ion (NT950XCJ-X716A)", ALC298_FIXUP_SAMSUNG_AMP),
10732 SND_PCI_QUIRK(0x144d, 0xc832, "Samsung Galaxy Book Flex Alpha (NP730QCJ)", ALC256_FIXUP_SAMSUNG_HEADPHONE_VERY_QUIET),
10733 SND_PCI_QUIRK(0x144d, 0xca03, "Samsung Galaxy Book2 Pro 360 (NP930QED)", ALC298_FIXUP_SAMSUNG_AMP),
10734 SND_PCI_QUIRK(0x144d, 0xc868, "Samsung Galaxy Book2 Pro (NP930XED)", ALC298_FIXUP_SAMSUNG_AMP),
10735 SND_PCI_QUIRK(0x144d, 0xc870, "Samsung Galaxy Book2 Pro (NP950XED)", ALC298_FIXUP_SAMSUNG_AMP_V2_2_AMPS),
10736 SND_PCI_QUIRK(0x144d, 0xc872, "Samsung Galaxy Book2 Pro (NP950XEE)", ALC298_FIXUP_SAMSUNG_AMP_V2_2_AMPS),
10737 SND_PCI_QUIRK(0x144d, 0xc886, "Samsung Galaxy Book3 Pro (NP964XFG)", ALC298_FIXUP_SAMSUNG_AMP_V2_4_AMPS),
10738 SND_PCI_QUIRK(0x144d, 0xc1ca, "Samsung Galaxy Book3 Pro 360 (NP960QFG)", ALC298_FIXUP_SAMSUNG_AMP_V2_4_AMPS),
10739 SND_PCI_QUIRK(0x144d, 0xc1cc, "Samsung Galaxy Book3 Ultra (NT960XFH)", ALC298_FIXUP_SAMSUNG_AMP_V2_4_AMPS),
10740 SND_PCI_QUIRK(0x1458, 0xfa53, "Gigabyte BXBT-2807", ALC283_FIXUP_HEADSET_MIC),
10741 SND_PCI_QUIRK(0x1462, 0xb120, "MSI Cubi MS-B120", ALC283_FIXUP_HEADSET_MIC),
10742 SND_PCI_QUIRK(0x1462, 0xb171, "Cubi N 8GL (MS-B171)", ALC283_FIXUP_HEADSET_MIC),
10743 SND_PCI_QUIRK(0x152d, 0x1082, "Quanta NL3", ALC269_FIXUP_LIFEBOOK),
10744 SND_PCI_QUIRK(0x152d, 0x1262, "Huawei NBLB-WAX9N", ALC2XX_FIXUP_HEADSET_MIC),
10745 SND_PCI_QUIRK(0x1558, 0x0353, "Clevo V35[05]SN[CDE]Q", ALC256_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10746 SND_PCI_QUIRK(0x1558, 0x1323, "Clevo N130ZU", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10747 SND_PCI_QUIRK(0x1558, 0x1325, "Clevo N15[01][CW]U", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10748 SND_PCI_QUIRK(0x1558, 0x1401, "Clevo L140[CZ]U", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10749 SND_PCI_QUIRK(0x1558, 0x1403, "Clevo N140CU", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10750 SND_PCI_QUIRK(0x1558, 0x1404, "Clevo N150CU", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10751 SND_PCI_QUIRK(0x1558, 0x14a1, "Clevo L141MU", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10752 SND_PCI_QUIRK(0x1558, 0x2624, "Clevo L240TU", ALC256_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10753 SND_PCI_QUIRK(0x1558, 0x28c1, "Clevo V370VND", ALC2XX_FIXUP_HEADSET_MIC),
10754 SND_PCI_QUIRK(0x1558, 0x4018, "Clevo NV40M[BE]", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10755 SND_PCI_QUIRK(0x1558, 0x4019, "Clevo NV40MZ", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10756 SND_PCI_QUIRK(0x1558, 0x4020, "Clevo NV40MB", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10757 SND_PCI_QUIRK(0x1558, 0x4041, "Clevo NV4[15]PZ", ALC256_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10758 SND_PCI_QUIRK(0x1558, 0x40a1, "Clevo NL40GU", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10759 SND_PCI_QUIRK(0x1558, 0x40c1, "Clevo NL40[CZ]U", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10760 SND_PCI_QUIRK(0x1558, 0x40d1, "Clevo NL41DU", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10761 SND_PCI_QUIRK(0x1558, 0x5015, "Clevo NH5[58]H[HJK]Q", ALC256_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10762 SND_PCI_QUIRK(0x1558, 0x5017, "Clevo NH7[79]H[HJK]Q", ALC256_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10763 SND_PCI_QUIRK(0x1558, 0x50a3, "Clevo NJ51GU", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10764 SND_PCI_QUIRK(0x1558, 0x50b3, "Clevo NK50S[BEZ]", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10765 SND_PCI_QUIRK(0x1558, 0x50b6, "Clevo NK50S5", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10766 SND_PCI_QUIRK(0x1558, 0x50b8, "Clevo NK50SZ", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10767 SND_PCI_QUIRK(0x1558, 0x50d5, "Clevo NP50D5", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10768 SND_PCI_QUIRK(0x1558, 0x50e1, "Clevo NH5[58]HPQ", ALC256_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10769 SND_PCI_QUIRK(0x1558, 0x50e2, "Clevo NH7[79]HPQ", ALC256_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10770 SND_PCI_QUIRK(0x1558, 0x50f0, "Clevo NH50A[CDF]", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10771 SND_PCI_QUIRK(0x1558, 0x50f2, "Clevo NH50E[PR]", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10772 SND_PCI_QUIRK(0x1558, 0x50f3, "Clevo NH58DPQ", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10773 SND_PCI_QUIRK(0x1558, 0x50f5, "Clevo NH55EPY", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10774 SND_PCI_QUIRK(0x1558, 0x50f6, "Clevo NH55DPQ", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10775 SND_PCI_QUIRK(0x1558, 0x5101, "Clevo S510WU", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10776 SND_PCI_QUIRK(0x1558, 0x5157, "Clevo W517GU1", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10777 SND_PCI_QUIRK(0x1558, 0x51a1, "Clevo NS50MU", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10778 SND_PCI_QUIRK(0x1558, 0x51b1, "Clevo NS50AU", ALC256_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10779 SND_PCI_QUIRK(0x1558, 0x51b3, "Clevo NS70AU", ALC256_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10780 SND_PCI_QUIRK(0x1558, 0x5630, "Clevo NP50RNJS", ALC256_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10781 SND_PCI_QUIRK(0x1558, 0x70a1, "Clevo NB70T[HJK]", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10782 SND_PCI_QUIRK(0x1558, 0x70b3, "Clevo NK70SB", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10783 SND_PCI_QUIRK(0x1558, 0x70f2, "Clevo NH79EPY", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10784 SND_PCI_QUIRK(0x1558, 0x70f3, "Clevo NH77DPQ", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10785 SND_PCI_QUIRK(0x1558, 0x70f4, "Clevo NH77EPY", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10786 SND_PCI_QUIRK(0x1558, 0x70f6, "Clevo NH77DPQ-Y", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10787 SND_PCI_QUIRK(0x1558, 0x7716, "Clevo NS50PU", ALC256_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10788 SND_PCI_QUIRK(0x1558, 0x7717, "Clevo NS70PU", ALC256_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10789 SND_PCI_QUIRK(0x1558, 0x7718, "Clevo L140PU", ALC256_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10790 SND_PCI_QUIRK(0x1558, 0x7724, "Clevo L140AU", ALC256_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10791 SND_PCI_QUIRK(0x1558, 0x8228, "Clevo NR40BU", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10792 SND_PCI_QUIRK(0x1558, 0x8520, "Clevo NH50D[CD]", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10793 SND_PCI_QUIRK(0x1558, 0x8521, "Clevo NH77D[CD]", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10794 SND_PCI_QUIRK(0x1558, 0x8535, "Clevo NH50D[BE]", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10795 SND_PCI_QUIRK(0x1558, 0x8536, "Clevo NH79D[BE]", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10796 SND_PCI_QUIRK(0x1558, 0x8550, "Clevo NH[57][0-9][ER][ACDH]Q", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10797 SND_PCI_QUIRK(0x1558, 0x8551, "Clevo NH[57][0-9][ER][ACDH]Q", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10798 SND_PCI_QUIRK(0x1558, 0x8560, "Clevo NH[57][0-9][ER][ACDH]Q", ALC269_FIXUP_HEADSET_MIC),
10799 SND_PCI_QUIRK(0x1558, 0x8561, "Clevo NH[57][0-9][ER][ACDH]Q", ALC269_FIXUP_HEADSET_MIC),
10800 SND_PCI_QUIRK(0x1558, 0x8562, "Clevo NH[57][0-9]RZ[Q]", ALC269_FIXUP_DMIC),
10801 SND_PCI_QUIRK(0x1558, 0x8668, "Clevo NP50B[BE]", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10802 SND_PCI_QUIRK(0x1558, 0x866d, "Clevo NP5[05]PN[HJK]", ALC256_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10803 SND_PCI_QUIRK(0x1558, 0x867c, "Clevo NP7[01]PNP", ALC256_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10804 SND_PCI_QUIRK(0x1558, 0x867d, "Clevo NP7[01]PN[HJK]", ALC256_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10805 SND_PCI_QUIRK(0x1558, 0x8680, "Clevo NJ50LU", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10806 SND_PCI_QUIRK(0x1558, 0x8686, "Clevo NH50[CZ]U", ALC256_FIXUP_MIC_NO_PRESENCE_AND_RESUME),
10807 SND_PCI_QUIRK(0x1558, 0x8a20, "Clevo NH55DCQ-Y", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10808 SND_PCI_QUIRK(0x1558, 0x8a51, "Clevo NH70RCQ-Y", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10809 SND_PCI_QUIRK(0x1558, 0x8d50, "Clevo NH55RCQ-M", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10810 SND_PCI_QUIRK(0x1558, 0x951d, "Clevo N950T[CDF]", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10811 SND_PCI_QUIRK(0x1558, 0x9600, "Clevo N960K[PR]", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10812 SND_PCI_QUIRK(0x1558, 0x961d, "Clevo N960S[CDF]", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10813 SND_PCI_QUIRK(0x1558, 0x971d, "Clevo N970T[CDF]", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10814 SND_PCI_QUIRK(0x1558, 0xa500, "Clevo NL5[03]RU", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10815 SND_PCI_QUIRK(0x1558, 0xa554, "VAIO VJFH52", ALC269_FIXUP_VAIO_VJFH52_MIC_NO_PRESENCE),
10816 SND_PCI_QUIRK(0x1558, 0xa600, "Clevo NL50NU", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10817 SND_PCI_QUIRK(0x1558, 0xa650, "Clevo NP[567]0SN[CD]", ALC256_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10818 SND_PCI_QUIRK(0x1558, 0xa671, "Clevo NP70SN[CDE]", ALC256_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10819 SND_PCI_QUIRK(0x1558, 0xa741, "Clevo V54x_6x_TNE", ALC245_FIXUP_CLEVO_NOISY_MIC),
10820 SND_PCI_QUIRK(0x1558, 0xa763, "Clevo V54x_6x_TU", ALC245_FIXUP_CLEVO_NOISY_MIC),
10821 SND_PCI_QUIRK(0x1558, 0xb018, "Clevo NP50D[BE]", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10822 SND_PCI_QUIRK(0x1558, 0xb019, "Clevo NH77D[BE]Q", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10823 SND_PCI_QUIRK(0x1558, 0xb022, "Clevo NH77D[DC][QW]", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10824 SND_PCI_QUIRK(0x1558, 0xc018, "Clevo NP50D[BE]", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10825 SND_PCI_QUIRK(0x1558, 0xc019, "Clevo NH77D[BE]Q", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10826 SND_PCI_QUIRK(0x1558, 0xc022, "Clevo NH77[DC][QW]", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10827 SND_PCI_QUIRK(0x17aa, 0x1036, "Lenovo P520", ALC233_FIXUP_LENOVO_MULTI_CODECS),
10828 SND_PCI_QUIRK(0x17aa, 0x1048, "ThinkCentre Station", ALC623_FIXUP_LENOVO_THINKSTATION_P340),
10829 SND_PCI_QUIRK(0x17aa, 0x20f2, "Thinkpad SL410/510", ALC269_FIXUP_SKU_IGNORE),
10830 SND_PCI_QUIRK(0x17aa, 0x215e, "Thinkpad L512", ALC269_FIXUP_SKU_IGNORE),
10831 SND_PCI_QUIRK(0x17aa, 0x21b8, "Thinkpad Edge 14", ALC269_FIXUP_SKU_IGNORE),
10832 SND_PCI_QUIRK(0x17aa, 0x21ca, "Thinkpad L412", ALC269_FIXUP_SKU_IGNORE),
10833 SND_PCI_QUIRK(0x17aa, 0x21e9, "Thinkpad Edge 15", ALC269_FIXUP_SKU_IGNORE),
10834 SND_PCI_QUIRK(0x17aa, 0x21f3, "Thinkpad T430", ALC269_FIXUP_LENOVO_DOCK),
10835 SND_PCI_QUIRK(0x17aa, 0x21f6, "Thinkpad T530", ALC269_FIXUP_LENOVO_DOCK_LIMIT_BOOST),
10836 SND_PCI_QUIRK(0x17aa, 0x21fa, "Thinkpad X230", ALC269_FIXUP_LENOVO_DOCK),
10837 SND_PCI_QUIRK(0x17aa, 0x21fb, "Thinkpad T430s", ALC269_FIXUP_LENOVO_DOCK),
10838 SND_PCI_QUIRK(0x17aa, 0x2203, "Thinkpad X230 Tablet", ALC269_FIXUP_LENOVO_DOCK),
10839 SND_PCI_QUIRK(0x17aa, 0x2208, "Thinkpad T431s", ALC269_FIXUP_LENOVO_DOCK),
10840 SND_PCI_QUIRK(0x17aa, 0x220c, "Thinkpad T440s", ALC292_FIXUP_TPT440),
10841 SND_PCI_QUIRK(0x17aa, 0x220e, "Thinkpad T440p", ALC292_FIXUP_TPT440_DOCK),
10842 SND_PCI_QUIRK(0x17aa, 0x2210, "Thinkpad T540p", ALC292_FIXUP_TPT440_DOCK),
10843 SND_PCI_QUIRK(0x17aa, 0x2211, "Thinkpad W541", ALC292_FIXUP_TPT440_DOCK),
10844 SND_PCI_QUIRK(0x17aa, 0x2212, "Thinkpad T440", ALC292_FIXUP_TPT440_DOCK),
10845 SND_PCI_QUIRK(0x17aa, 0x2214, "Thinkpad X240", ALC292_FIXUP_TPT440_DOCK),
10846 SND_PCI_QUIRK(0x17aa, 0x2215, "Thinkpad", ALC269_FIXUP_LIMIT_INT_MIC_BOOST),
10847 SND_PCI_QUIRK(0x17aa, 0x2218, "Thinkpad X1 Carbon 2nd", ALC292_FIXUP_TPT440_DOCK),
10848 SND_PCI_QUIRK(0x17aa, 0x2223, "ThinkPad T550", ALC292_FIXUP_TPT440_DOCK),
10849 SND_PCI_QUIRK(0x17aa, 0x2226, "ThinkPad X250", ALC292_FIXUP_TPT440_DOCK),
10850 SND_PCI_QUIRK(0x17aa, 0x222d, "Thinkpad", ALC298_FIXUP_TPT470_DOCK),
10851 SND_PCI_QUIRK(0x17aa, 0x222e, "Thinkpad", ALC298_FIXUP_TPT470_DOCK),
10852 SND_PCI_QUIRK(0x17aa, 0x2231, "Thinkpad T560", ALC292_FIXUP_TPT460),
10853 SND_PCI_QUIRK(0x17aa, 0x2233, "Thinkpad", ALC292_FIXUP_TPT460),
10854 SND_PCI_QUIRK(0x17aa, 0x2234, "Thinkpad ICE-1", ALC287_FIXUP_TAS2781_I2C),
10855 SND_PCI_QUIRK(0x17aa, 0x2245, "Thinkpad T470", ALC298_FIXUP_TPT470_DOCK),
10856 SND_PCI_QUIRK(0x17aa, 0x2246, "Thinkpad", ALC298_FIXUP_TPT470_DOCK),
10857 SND_PCI_QUIRK(0x17aa, 0x2247, "Thinkpad", ALC298_FIXUP_TPT470_DOCK),
10858 SND_PCI_QUIRK(0x17aa, 0x2249, "Thinkpad", ALC292_FIXUP_TPT460),
10859 SND_PCI_QUIRK(0x17aa, 0x224b, "Thinkpad", ALC298_FIXUP_TPT470_DOCK),
10860 SND_PCI_QUIRK(0x17aa, 0x224c, "Thinkpad", ALC298_FIXUP_TPT470_DOCK),
10861 SND_PCI_QUIRK(0x17aa, 0x224d, "Thinkpad", ALC298_FIXUP_TPT470_DOCK),
10862 SND_PCI_QUIRK(0x17aa, 0x225d, "Thinkpad T480", ALC269_FIXUP_LIMIT_INT_MIC_BOOST),
10863 SND_PCI_QUIRK(0x17aa, 0x2292, "Thinkpad X1 Carbon 7th", ALC285_FIXUP_THINKPAD_HEADSET_JACK),
10864 SND_PCI_QUIRK(0x17aa, 0x22be, "Thinkpad X1 Carbon 8th", ALC285_FIXUP_THINKPAD_HEADSET_JACK),
10865 SND_PCI_QUIRK(0x17aa, 0x22c1, "Thinkpad P1 Gen 3", ALC285_FIXUP_THINKPAD_NO_BASS_SPK_HEADSET_JACK),
10866 SND_PCI_QUIRK(0x17aa, 0x22c2, "Thinkpad X1 Extreme Gen 3", ALC285_FIXUP_THINKPAD_NO_BASS_SPK_HEADSET_JACK),
10867 SND_PCI_QUIRK(0x17aa, 0x22f1, "Thinkpad", ALC287_FIXUP_MG_RTKC_CSAMP_CS35L41_I2C_THINKPAD),
10868 SND_PCI_QUIRK(0x17aa, 0x22f2, "Thinkpad", ALC287_FIXUP_MG_RTKC_CSAMP_CS35L41_I2C_THINKPAD),
10869 SND_PCI_QUIRK(0x17aa, 0x22f3, "Thinkpad", ALC287_FIXUP_MG_RTKC_CSAMP_CS35L41_I2C_THINKPAD),
10870 SND_PCI_QUIRK(0x17aa, 0x2316, "Thinkpad P1 Gen 6", ALC287_FIXUP_MG_RTKC_CSAMP_CS35L41_I2C_THINKPAD),
10871 SND_PCI_QUIRK(0x17aa, 0x2317, "Thinkpad P1 Gen 6", ALC287_FIXUP_MG_RTKC_CSAMP_CS35L41_I2C_THINKPAD),
10872 SND_PCI_QUIRK(0x17aa, 0x2318, "Thinkpad Z13 Gen2", ALC287_FIXUP_MG_RTKC_CSAMP_CS35L41_I2C_THINKPAD),
10873 SND_PCI_QUIRK(0x17aa, 0x2319, "Thinkpad Z16 Gen2", ALC287_FIXUP_MG_RTKC_CSAMP_CS35L41_I2C_THINKPAD),
10874 SND_PCI_QUIRK(0x17aa, 0x231a, "Thinkpad Z16 Gen2", ALC287_FIXUP_MG_RTKC_CSAMP_CS35L41_I2C_THINKPAD),
10875 SND_PCI_QUIRK(0x17aa, 0x231e, "Thinkpad", ALC287_FIXUP_LENOVO_THKPAD_WH_ALC1318),
10876 SND_PCI_QUIRK(0x17aa, 0x231f, "Thinkpad", ALC287_FIXUP_LENOVO_THKPAD_WH_ALC1318),
10877 SND_PCI_QUIRK(0x17aa, 0x2326, "Hera2", ALC287_FIXUP_TAS2781_I2C),
10878 SND_PCI_QUIRK(0x17aa, 0x30bb, "ThinkCentre AIO", ALC233_FIXUP_LENOVO_LINE2_MIC_HOTKEY),
10879 SND_PCI_QUIRK(0x17aa, 0x30e2, "ThinkCentre AIO", ALC233_FIXUP_LENOVO_LINE2_MIC_HOTKEY),
10880 SND_PCI_QUIRK(0x17aa, 0x310c, "ThinkCentre Station", ALC294_FIXUP_LENOVO_MIC_LOCATION),
10881 SND_PCI_QUIRK(0x17aa, 0x3111, "ThinkCentre Station", ALC294_FIXUP_LENOVO_MIC_LOCATION),
10882 SND_PCI_QUIRK(0x17aa, 0x312a, "ThinkCentre Station", ALC294_FIXUP_LENOVO_MIC_LOCATION),
10883 SND_PCI_QUIRK(0x17aa, 0x312f, "ThinkCentre Station", ALC294_FIXUP_LENOVO_MIC_LOCATION),
10884 SND_PCI_QUIRK(0x17aa, 0x313c, "ThinkCentre Station", ALC294_FIXUP_LENOVO_MIC_LOCATION),
10885 SND_PCI_QUIRK(0x17aa, 0x3151, "ThinkCentre Station", ALC283_FIXUP_HEADSET_MIC),
10886 SND_PCI_QUIRK(0x17aa, 0x3176, "ThinkCentre Station", ALC283_FIXUP_HEADSET_MIC),
10887 SND_PCI_QUIRK(0x17aa, 0x3178, "ThinkCentre Station", ALC283_FIXUP_HEADSET_MIC),
10888 SND_PCI_QUIRK(0x17aa, 0x31af, "ThinkCentre Station", ALC623_FIXUP_LENOVO_THINKSTATION_P340),
10889 SND_PCI_QUIRK(0x17aa, 0x334b, "Lenovo ThinkCentre M70 Gen5", ALC283_FIXUP_HEADSET_MIC),
10890 SND_PCI_QUIRK(0x17aa, 0x3801, "Lenovo Yoga9 14IAP7", ALC287_FIXUP_YOGA9_14IAP7_BASS_SPK_PIN),
10891 SND_PCI_QUIRK(0x17aa, 0x3802, "Lenovo Yoga Pro 9 14IRP8 / DuetITL 2021", ALC287_FIXUP_LENOVO_14IRP8_DUETITL),
10892 SND_PCI_QUIRK(0x17aa, 0x3813, "Legion 7i 15IMHG05", ALC287_FIXUP_LEGION_15IMHG05_SPEAKERS),
10893 SND_PCI_QUIRK(0x17aa, 0x3818, "Lenovo C940 / Yoga Duet 7", ALC298_FIXUP_LENOVO_C940_DUET7),
10894 SND_PCI_QUIRK(0x17aa, 0x3819, "Lenovo 13s Gen2 ITL", ALC287_FIXUP_13S_GEN2_SPEAKERS),
10895 SND_PCI_QUIRK(0x17aa, 0x3820, "IdeaPad 330 / Yoga Duet 7", ALC287_FIXUP_LENOVO_SSID_17AA3820),
10896 SND_PCI_QUIRK(0x17aa, 0x3824, "Legion Y9000X 2020", ALC285_FIXUP_LEGION_Y9000X_SPEAKERS),
10897 SND_PCI_QUIRK(0x17aa, 0x3827, "Ideapad S740", ALC285_FIXUP_IDEAPAD_S740_COEF),
10898 SND_PCI_QUIRK(0x17aa, 0x3834, "Lenovo IdeaPad Slim 9i 14ITL5", ALC287_FIXUP_YOGA7_14ITL_SPEAKERS),
10899 SND_PCI_QUIRK(0x17aa, 0x383d, "Legion Y9000X 2019", ALC285_FIXUP_LEGION_Y9000X_SPEAKERS),
10900 SND_PCI_QUIRK(0x17aa, 0x3843, "Yoga 9i", ALC287_FIXUP_IDEAPAD_BASS_SPK_AMP),
10901 SND_PCI_QUIRK(0x17aa, 0x3847, "Legion 7 16ACHG6", ALC287_FIXUP_LEGION_16ACHG6),
10902 SND_PCI_QUIRK(0x17aa, 0x384a, "Lenovo Yoga 7 15ITL5", ALC287_FIXUP_YOGA7_14ITL_SPEAKERS),
10903 SND_PCI_QUIRK(0x17aa, 0x3852, "Lenovo Yoga 7 14ITL5", ALC287_FIXUP_YOGA7_14ITL_SPEAKERS),
10904 SND_PCI_QUIRK(0x17aa, 0x3853, "Lenovo Yoga 7 15ITL5", ALC287_FIXUP_YOGA7_14ITL_SPEAKERS),
10905 SND_PCI_QUIRK(0x17aa, 0x3855, "Legion 7 16ITHG6", ALC287_FIXUP_LEGION_16ITHG6),
10906 SND_PCI_QUIRK(0x17aa, 0x3865, "Lenovo 13X", ALC287_FIXUP_CS35L41_I2C_2),
10907 SND_PCI_QUIRK(0x17aa, 0x3866, "Lenovo 13X", ALC287_FIXUP_CS35L41_I2C_2),
10908 SND_PCI_QUIRK(0x17aa, 0x3869, "Lenovo Yoga7 14IAL7", ALC287_FIXUP_YOGA9_14IAP7_BASS_SPK_PIN),
10909 SND_PCI_QUIRK(0x17aa, 0x386e, "Legion Y9000X 2022 IAH7 / Yoga Pro 7 14ARP8", ALC287_FIXUP_LENOVO_14ARP8_LEGION_IAH7),
10910 SND_PCI_QUIRK(0x17aa, 0x386f, "Legion Pro 7/7i", ALC287_FIXUP_LENOVO_LEGION_7),
10911 SND_PCI_QUIRK(0x17aa, 0x3870, "Lenovo Yoga 7 14ARB7", ALC287_FIXUP_YOGA7_14ARB7_I2C),
10912 SND_PCI_QUIRK(0x17aa, 0x3877, "Lenovo Legion 7 Slim 16ARHA7", ALC287_FIXUP_CS35L41_I2C_2),
10913 SND_PCI_QUIRK(0x17aa, 0x3878, "Lenovo Legion 7 Slim 16ARHA7", ALC287_FIXUP_CS35L41_I2C_2),
10914 SND_PCI_QUIRK(0x17aa, 0x387d, "Yoga S780-16 pro Quad AAC", ALC287_FIXUP_TAS2781_I2C),
10915 SND_PCI_QUIRK(0x17aa, 0x387e, "Yoga S780-16 pro Quad YC", ALC287_FIXUP_TAS2781_I2C),
10916 SND_PCI_QUIRK(0x17aa, 0x387f, "Yoga S780-16 pro dual LX", ALC287_FIXUP_TAS2781_I2C),
10917 SND_PCI_QUIRK(0x17aa, 0x3880, "Yoga S780-16 pro dual YC", ALC287_FIXUP_TAS2781_I2C),
10918 SND_PCI_QUIRK(0x17aa, 0x3881, "YB9 dual power mode2 YC", ALC287_FIXUP_TAS2781_I2C),
10919 SND_PCI_QUIRK(0x17aa, 0x3882, "Lenovo Yoga Pro 7 14APH8", ALC287_FIXUP_YOGA9_14IAP7_BASS_SPK_PIN),
10920 SND_PCI_QUIRK(0x17aa, 0x3884, "Y780 YG DUAL", ALC287_FIXUP_TAS2781_I2C),
10921 SND_PCI_QUIRK(0x17aa, 0x3886, "Y780 VECO DUAL", ALC287_FIXUP_TAS2781_I2C),
10922 SND_PCI_QUIRK(0x17aa, 0x3891, "Lenovo Yoga Pro 7 14AHP9", ALC287_FIXUP_YOGA9_14IAP7_BASS_SPK_PIN),
10923 SND_PCI_QUIRK(0x17aa, 0x38a5, "Y580P AMD dual", ALC287_FIXUP_TAS2781_I2C),
10924 SND_PCI_QUIRK(0x17aa, 0x38a7, "Y780P AMD YG dual", ALC287_FIXUP_TAS2781_I2C),
10925 SND_PCI_QUIRK(0x17aa, 0x38a8, "Y780P AMD VECO dual", ALC287_FIXUP_TAS2781_I2C),
10926 SND_PCI_QUIRK(0x17aa, 0x38a9, "Thinkbook 16P", ALC287_FIXUP_MG_RTKC_CSAMP_CS35L41_I2C_THINKPAD),
10927 SND_PCI_QUIRK(0x17aa, 0x38ab, "Thinkbook 16P", ALC287_FIXUP_MG_RTKC_CSAMP_CS35L41_I2C_THINKPAD),
10928 SND_PCI_QUIRK(0x17aa, 0x38b4, "Legion Slim 7 16IRH8", ALC287_FIXUP_CS35L41_I2C_2),
10929 SND_PCI_QUIRK(0x17aa, 0x38b5, "Legion Slim 7 16IRH8", ALC287_FIXUP_CS35L41_I2C_2),
10930 SND_PCI_QUIRK(0x17aa, 0x38b6, "Legion Slim 7 16APH8", ALC287_FIXUP_CS35L41_I2C_2),
10931 SND_PCI_QUIRK(0x17aa, 0x38b7, "Legion Slim 7 16APH8", ALC287_FIXUP_CS35L41_I2C_2),
10932 SND_PCI_QUIRK(0x17aa, 0x38b8, "Yoga S780-14.5 proX AMD YC Dual", ALC287_FIXUP_TAS2781_I2C),
10933 SND_PCI_QUIRK(0x17aa, 0x38b9, "Yoga S780-14.5 proX AMD LX Dual", ALC287_FIXUP_TAS2781_I2C),
10934 SND_PCI_QUIRK(0x17aa, 0x38ba, "Yoga S780-14.5 Air AMD quad YC", ALC287_FIXUP_TAS2781_I2C),
10935 SND_PCI_QUIRK(0x17aa, 0x38bb, "Yoga S780-14.5 Air AMD quad AAC", ALC287_FIXUP_TAS2781_I2C),
10936 SND_PCI_QUIRK(0x17aa, 0x38be, "Yoga S980-14.5 proX YC Dual", ALC287_FIXUP_TAS2781_I2C),
10937 SND_PCI_QUIRK(0x17aa, 0x38bf, "Yoga S980-14.5 proX LX Dual", ALC287_FIXUP_TAS2781_I2C),
10938 SND_PCI_QUIRK(0x17aa, 0x38c3, "Y980 DUAL", ALC287_FIXUP_TAS2781_I2C),
10939 SND_PCI_QUIRK(0x17aa, 0x38c7, "Thinkbook 13x Gen 4", ALC287_FIXUP_CS35L41_I2C_4),
10940 SND_PCI_QUIRK(0x17aa, 0x38c8, "Thinkbook 13x Gen 4", ALC287_FIXUP_CS35L41_I2C_4),
10941 SND_PCI_QUIRK(0x17aa, 0x38cb, "Y790 YG DUAL", ALC287_FIXUP_TAS2781_I2C),
10942 SND_PCI_QUIRK(0x17aa, 0x38cd, "Y790 VECO DUAL", ALC287_FIXUP_TAS2781_I2C),
10943 SND_PCI_QUIRK(0x17aa, 0x38d2, "Lenovo Yoga 9 14IMH9", ALC287_FIXUP_YOGA9_14IMH9_BASS_SPK_PIN),
10944 SND_PCI_QUIRK(0x17aa, 0x38d3, "Yoga S990-16 Pro IMH YC Dual", ALC287_FIXUP_TAS2781_I2C),
10945 SND_PCI_QUIRK(0x17aa, 0x38d4, "Yoga S990-16 Pro IMH VECO Dual", ALC287_FIXUP_TAS2781_I2C),
10946 SND_PCI_QUIRK(0x17aa, 0x38d5, "Yoga S990-16 Pro IMH YC Quad", ALC287_FIXUP_TAS2781_I2C),
10947 SND_PCI_QUIRK(0x17aa, 0x38d6, "Yoga S990-16 Pro IMH VECO Quad", ALC287_FIXUP_TAS2781_I2C),
10948 SND_PCI_QUIRK(0x17aa, 0x38d7, "Lenovo Yoga 9 14IMH9", ALC287_FIXUP_YOGA9_14IMH9_BASS_SPK_PIN),
10949 SND_PCI_QUIRK(0x17aa, 0x38df, "Yoga Y990 Intel YC Dual", ALC287_FIXUP_TAS2781_I2C),
10950 SND_PCI_QUIRK(0x17aa, 0x38e0, "Yoga Y990 Intel VECO Dual", ALC287_FIXUP_TAS2781_I2C),
10951 SND_PCI_QUIRK(0x17aa, 0x38f8, "Yoga Book 9i", ALC287_FIXUP_TAS2781_I2C),
10952 SND_PCI_QUIRK(0x17aa, 0x38df, "Y990 YG DUAL", ALC287_FIXUP_TAS2781_I2C),
10953 SND_PCI_QUIRK(0x17aa, 0x38f9, "Thinkbook 16P Gen5", ALC287_FIXUP_CS35L41_I2C_2),
10954 SND_PCI_QUIRK(0x17aa, 0x38fa, "Thinkbook 16P Gen5", ALC287_FIXUP_CS35L41_I2C_2),
10955 SND_PCI_QUIRK(0x17aa, 0x38fd, "ThinkBook plus Gen5 Hybrid", ALC287_FIXUP_TAS2781_I2C),
10956 SND_PCI_QUIRK(0x17aa, 0x3902, "Lenovo E50-80", ALC269_FIXUP_DMIC_THINKPAD_ACPI),
10957 SND_PCI_QUIRK(0x17aa, 0x3913, "Lenovo 145", ALC236_FIXUP_LENOVO_INV_DMIC),
10958 SND_PCI_QUIRK(0x17aa, 0x391f, "Yoga S990-16 pro Quad YC Quad", ALC287_FIXUP_TAS2781_I2C),
10959 SND_PCI_QUIRK(0x17aa, 0x3920, "Yoga S990-16 pro Quad VECO Quad", ALC287_FIXUP_TAS2781_I2C),
10960 SND_PCI_QUIRK(0x17aa, 0x3977, "IdeaPad S210", ALC283_FIXUP_INT_MIC),
10961 SND_PCI_QUIRK(0x17aa, 0x3978, "Lenovo B50-70", ALC269_FIXUP_DMIC_THINKPAD_ACPI),
10962 SND_PCI_QUIRK(0x17aa, 0x3bf8, "Quanta FL1", ALC269_FIXUP_PCM_44K),
10963 SND_PCI_QUIRK(0x17aa, 0x5013, "Thinkpad", ALC269_FIXUP_LIMIT_INT_MIC_BOOST),
10964 SND_PCI_QUIRK(0x17aa, 0x501a, "Thinkpad", ALC283_FIXUP_INT_MIC),
10965 SND_PCI_QUIRK(0x17aa, 0x501e, "Thinkpad L440", ALC292_FIXUP_TPT440_DOCK),
10966 SND_PCI_QUIRK(0x17aa, 0x5026, "Thinkpad", ALC269_FIXUP_LIMIT_INT_MIC_BOOST),
10967 SND_PCI_QUIRK(0x17aa, 0x5034, "Thinkpad T450", ALC292_FIXUP_TPT440_DOCK),
10968 SND_PCI_QUIRK(0x17aa, 0x5036, "Thinkpad T450s", ALC292_FIXUP_TPT440_DOCK),
10969 SND_PCI_QUIRK(0x17aa, 0x503c, "Thinkpad L450", ALC292_FIXUP_TPT440_DOCK),
10970 SND_PCI_QUIRK(0x17aa, 0x504a, "ThinkPad X260", ALC292_FIXUP_TPT440_DOCK),
10971 SND_PCI_QUIRK(0x17aa, 0x504b, "Thinkpad", ALC293_FIXUP_LENOVO_SPK_NOISE),
10972 SND_PCI_QUIRK(0x17aa, 0x5050, "Thinkpad T560p", ALC292_FIXUP_TPT460),
10973 SND_PCI_QUIRK(0x17aa, 0x5051, "Thinkpad L460", ALC292_FIXUP_TPT460),
10974 SND_PCI_QUIRK(0x17aa, 0x5053, "Thinkpad T460", ALC292_FIXUP_TPT460),
10975 SND_PCI_QUIRK(0x17aa, 0x505d, "Thinkpad", ALC298_FIXUP_TPT470_DOCK),
10976 SND_PCI_QUIRK(0x17aa, 0x505f, "Thinkpad", ALC298_FIXUP_TPT470_DOCK),
10977 SND_PCI_QUIRK(0x17aa, 0x5062, "Thinkpad", ALC298_FIXUP_TPT470_DOCK),
10978 SND_PCI_QUIRK(0x17aa, 0x508b, "Thinkpad X12 Gen 1", ALC287_FIXUP_LEGION_15IMHG05_SPEAKERS),
10979 SND_PCI_QUIRK(0x17aa, 0x5109, "Thinkpad", ALC269_FIXUP_LIMIT_INT_MIC_BOOST),
10980 SND_PCI_QUIRK(0x17aa, 0x511e, "Thinkpad", ALC298_FIXUP_TPT470_DOCK),
10981 SND_PCI_QUIRK(0x17aa, 0x511f, "Thinkpad", ALC298_FIXUP_TPT470_DOCK),
10982 SND_PCI_QUIRK(0x17aa, 0x9e54, "LENOVO NB", ALC269_FIXUP_LENOVO_EAPD),
10983 SND_PCI_QUIRK(0x17aa, 0x9e56, "Lenovo ZhaoYang CF4620Z", ALC286_FIXUP_SONY_MIC_NO_PRESENCE),
10984 SND_PCI_QUIRK(0x1849, 0x1233, "ASRock NUC Box 1100", ALC233_FIXUP_NO_AUDIO_JACK),
10985 SND_PCI_QUIRK(0x1849, 0xa233, "Positivo Master C6300", ALC269_FIXUP_HEADSET_MIC),
10986 SND_PCI_QUIRK(0x1854, 0x0440, "LG CQ6", ALC256_FIXUP_HEADPHONE_AMP_VOL),
10987 SND_PCI_QUIRK(0x1854, 0x0441, "LG CQ6 AIO", ALC256_FIXUP_HEADPHONE_AMP_VOL),
10988 SND_PCI_QUIRK(0x1854, 0x0488, "LG gram 16 (16Z90R)", ALC298_FIXUP_SAMSUNG_AMP_V2_4_AMPS),
10989 SND_PCI_QUIRK(0x1854, 0x048a, "LG gram 17 (17ZD90R)", ALC298_FIXUP_SAMSUNG_AMP_V2_4_AMPS),
10990 SND_PCI_QUIRK(0x19e5, 0x3204, "Huawei MACH-WX9", ALC256_FIXUP_HUAWEI_MACH_WX9_PINS),
10991 SND_PCI_QUIRK(0x19e5, 0x320f, "Huawei WRT-WX9 ", ALC256_FIXUP_ASUS_MIC_NO_PRESENCE),
10992 SND_PCI_QUIRK(0x19e5, 0x3212, "Huawei KLV-WX9 ", ALC256_FIXUP_ACER_HEADSET_MIC),
10993 SND_PCI_QUIRK(0x1b35, 0x1235, "CZC B20", ALC269_FIXUP_CZC_B20),
10994 SND_PCI_QUIRK(0x1b35, 0x1236, "CZC TMI", ALC269_FIXUP_CZC_TMI),
10995 SND_PCI_QUIRK(0x1b35, 0x1237, "CZC L101", ALC269_FIXUP_CZC_L101),
10996 SND_PCI_QUIRK(0x1b7d, 0xa831, "Ordissimo EVE2 ", ALC269VB_FIXUP_ORDISSIMO_EVE2), /* Also known as Malata PC-B1303 */
10997 SND_PCI_QUIRK(0x1c06, 0x2013, "Lemote A1802", ALC269_FIXUP_LEMOTE_A1802),
10998 SND_PCI_QUIRK(0x1c06, 0x2015, "Lemote A190X", ALC269_FIXUP_LEMOTE_A190X),
10999 SND_PCI_QUIRK(0x1c6c, 0x122a, "Positivo N14AP7", ALC269_FIXUP_LIMIT_INT_MIC_BOOST),
11000 SND_PCI_QUIRK(0x1c6c, 0x1251, "Positivo N14KP6-TG", ALC288_FIXUP_DELL1_MIC_NO_PRESENCE),
11001 SND_PCI_QUIRK(0x1d05, 0x1132, "TongFang PHxTxX1", ALC256_FIXUP_SET_COEF_DEFAULTS),
11002 SND_PCI_QUIRK(0x1d05, 0x1096, "TongFang GMxMRxx", ALC269_FIXUP_NO_SHUTUP),
11003 SND_PCI_QUIRK(0x1d05, 0x1100, "TongFang GKxNRxx", ALC269_FIXUP_NO_SHUTUP),
11004 SND_PCI_QUIRK(0x1d05, 0x1111, "TongFang GMxZGxx", ALC269_FIXUP_NO_SHUTUP),
11005 SND_PCI_QUIRK(0x1d05, 0x1119, "TongFang GMxZGxx", ALC269_FIXUP_NO_SHUTUP),
11006 SND_PCI_QUIRK(0x1d05, 0x1129, "TongFang GMxZGxx", ALC269_FIXUP_NO_SHUTUP),
11007 SND_PCI_QUIRK(0x1d05, 0x1147, "TongFang GMxTGxx", ALC269_FIXUP_NO_SHUTUP),
11008 SND_PCI_QUIRK(0x1d05, 0x115c, "TongFang GMxTGxx", ALC269_FIXUP_NO_SHUTUP),
11009 SND_PCI_QUIRK(0x1d05, 0x121b, "TongFang GMxAGxx", ALC269_FIXUP_NO_SHUTUP),
11010 SND_PCI_QUIRK(0x1d05, 0x1387, "TongFang GMxIXxx", ALC2XX_FIXUP_HEADSET_MIC),
11011 SND_PCI_QUIRK(0x1d05, 0x1409, "TongFang GMxIXxx", ALC2XX_FIXUP_HEADSET_MIC),
11012 SND_PCI_QUIRK(0x1d17, 0x3288, "Haier Boyue G42", ALC269VC_FIXUP_ACER_VCOPPERBOX_PINS),
11013 SND_PCI_QUIRK(0x1d72, 0x1602, "RedmiBook", ALC255_FIXUP_XIAOMI_HEADSET_MIC),
11014 SND_PCI_QUIRK(0x1d72, 0x1701, "XiaomiNotebook Pro", ALC298_FIXUP_DELL1_MIC_NO_PRESENCE),
11015 SND_PCI_QUIRK(0x1d72, 0x1901, "RedmiBook 14", ALC256_FIXUP_ASUS_HEADSET_MIC),
11016 SND_PCI_QUIRK(0x1d72, 0x1945, "Redmi G", ALC256_FIXUP_ASUS_HEADSET_MIC),
11017 SND_PCI_QUIRK(0x1d72, 0x1947, "RedmiBook Air", ALC255_FIXUP_XIAOMI_HEADSET_MIC),
11018 SND_PCI_QUIRK(0x2782, 0x0214, "VAIO VJFE-CL", ALC269_FIXUP_LIMIT_INT_MIC_BOOST),
11019 SND_PCI_QUIRK(0x2782, 0x0228, "Infinix ZERO BOOK 13", ALC269VB_FIXUP_INFINIX_ZERO_BOOK_13),
11020 SND_PCI_QUIRK(0x2782, 0x0232, "CHUWI CoreBook XPro", ALC269VB_FIXUP_CHUWI_COREBOOK_XPRO),
11021 SND_PCI_QUIRK(0x2782, 0x1707, "Vaio VJFE-ADL", ALC298_FIXUP_SPK_VOLUME),
11022 SND_PCI_QUIRK(0x8086, 0x2074, "Intel NUC 8", ALC233_FIXUP_INTEL_NUC8_DMIC),
11023 SND_PCI_QUIRK(0x8086, 0x2080, "Intel NUC 8 Rugged", ALC256_FIXUP_INTEL_NUC8_RUGGED),
11024 SND_PCI_QUIRK(0x8086, 0x2081, "Intel NUC 10", ALC256_FIXUP_INTEL_NUC10),
11025 SND_PCI_QUIRK(0x8086, 0x3038, "Intel NUC 13", ALC295_FIXUP_CHROME_BOOK),
11026 SND_PCI_QUIRK(0xf111, 0x0001, "Framework Laptop", ALC295_FIXUP_FRAMEWORK_LAPTOP_MIC_NO_PRESENCE),
11027 SND_PCI_QUIRK(0xf111, 0x0006, "Framework Laptop", ALC295_FIXUP_FRAMEWORK_LAPTOP_MIC_NO_PRESENCE),
11028 SND_PCI_QUIRK(0xf111, 0x0009, "Framework Laptop", ALC295_FIXUP_FRAMEWORK_LAPTOP_MIC_NO_PRESENCE),
11029
11030 #if 0
11031 /* Below is a quirk table taken from the old code.
11032 * Basically the device should work as is without the fixup table.
11033 * If BIOS doesn't give a proper info, enable the corresponding
11034 * fixup entry.
11035 */
11036 SND_PCI_QUIRK(0x1043, 0x8330, "ASUS Eeepc P703 P900A",
11037 ALC269_FIXUP_AMIC),
11038 SND_PCI_QUIRK(0x1043, 0x1013, "ASUS N61Da", ALC269_FIXUP_AMIC),
11039 SND_PCI_QUIRK(0x1043, 0x1143, "ASUS B53f", ALC269_FIXUP_AMIC),
11040 SND_PCI_QUIRK(0x1043, 0x1133, "ASUS UJ20ft", ALC269_FIXUP_AMIC),
11041 SND_PCI_QUIRK(0x1043, 0x1183, "ASUS K72DR", ALC269_FIXUP_AMIC),
11042 SND_PCI_QUIRK(0x1043, 0x11b3, "ASUS K52DR", ALC269_FIXUP_AMIC),
11043 SND_PCI_QUIRK(0x1043, 0x11e3, "ASUS U33Jc", ALC269_FIXUP_AMIC),
11044 SND_PCI_QUIRK(0x1043, 0x1273, "ASUS UL80Jt", ALC269_FIXUP_AMIC),
11045 SND_PCI_QUIRK(0x1043, 0x1283, "ASUS U53Jc", ALC269_FIXUP_AMIC),
11046 SND_PCI_QUIRK(0x1043, 0x12b3, "ASUS N82JV", ALC269_FIXUP_AMIC),
11047 SND_PCI_QUIRK(0x1043, 0x12d3, "ASUS N61Jv", ALC269_FIXUP_AMIC),
11048 SND_PCI_QUIRK(0x1043, 0x13a3, "ASUS UL30Vt", ALC269_FIXUP_AMIC),
11049 SND_PCI_QUIRK(0x1043, 0x1373, "ASUS G73JX", ALC269_FIXUP_AMIC),
11050 SND_PCI_QUIRK(0x1043, 0x1383, "ASUS UJ30Jc", ALC269_FIXUP_AMIC),
11051 SND_PCI_QUIRK(0x1043, 0x13d3, "ASUS N61JA", ALC269_FIXUP_AMIC),
11052 SND_PCI_QUIRK(0x1043, 0x1413, "ASUS UL50", ALC269_FIXUP_AMIC),
11053 SND_PCI_QUIRK(0x1043, 0x1443, "ASUS UL30", ALC269_FIXUP_AMIC),
11054 SND_PCI_QUIRK(0x1043, 0x1453, "ASUS M60Jv", ALC269_FIXUP_AMIC),
11055 SND_PCI_QUIRK(0x1043, 0x1483, "ASUS UL80", ALC269_FIXUP_AMIC),
11056 SND_PCI_QUIRK(0x1043, 0x14f3, "ASUS F83Vf", ALC269_FIXUP_AMIC),
11057 SND_PCI_QUIRK(0x1043, 0x14e3, "ASUS UL20", ALC269_FIXUP_AMIC),
11058 SND_PCI_QUIRK(0x1043, 0x1513, "ASUS UX30", ALC269_FIXUP_AMIC),
11059 SND_PCI_QUIRK(0x1043, 0x1593, "ASUS N51Vn", ALC269_FIXUP_AMIC),
11060 SND_PCI_QUIRK(0x1043, 0x15a3, "ASUS N60Jv", ALC269_FIXUP_AMIC),
11061 SND_PCI_QUIRK(0x1043, 0x15b3, "ASUS N60Dp", ALC269_FIXUP_AMIC),
11062 SND_PCI_QUIRK(0x1043, 0x15c3, "ASUS N70De", ALC269_FIXUP_AMIC),
11063 SND_PCI_QUIRK(0x1043, 0x15e3, "ASUS F83T", ALC269_FIXUP_AMIC),
11064 SND_PCI_QUIRK(0x1043, 0x1643, "ASUS M60J", ALC269_FIXUP_AMIC),
11065 SND_PCI_QUIRK(0x1043, 0x1653, "ASUS U50", ALC269_FIXUP_AMIC),
11066 SND_PCI_QUIRK(0x1043, 0x1693, "ASUS F50N", ALC269_FIXUP_AMIC),
11067 SND_PCI_QUIRK(0x1043, 0x16a3, "ASUS F5Q", ALC269_FIXUP_AMIC),
11068 SND_PCI_QUIRK(0x1043, 0x1723, "ASUS P80", ALC269_FIXUP_AMIC),
11069 SND_PCI_QUIRK(0x1043, 0x1743, "ASUS U80", ALC269_FIXUP_AMIC),
11070 SND_PCI_QUIRK(0x1043, 0x1773, "ASUS U20A", ALC269_FIXUP_AMIC),
11071 SND_PCI_QUIRK(0x1043, 0x1883, "ASUS F81Se", ALC269_FIXUP_AMIC),
11072 SND_PCI_QUIRK(0x152d, 0x1778, "Quanta ON1", ALC269_FIXUP_DMIC),
11073 SND_PCI_QUIRK(0x17aa, 0x3be9, "Quanta Wistron", ALC269_FIXUP_AMIC),
11074 SND_PCI_QUIRK(0x17aa, 0x3bf8, "Quanta FL1", ALC269_FIXUP_AMIC),
11075 SND_PCI_QUIRK(0x17ff, 0x059a, "Quanta EL3", ALC269_FIXUP_DMIC),
11076 SND_PCI_QUIRK(0x17ff, 0x059b, "Quanta JR1", ALC269_FIXUP_DMIC),
11077 #endif
11078 {}
11079 };
11080
11081 static const struct snd_pci_quirk alc269_fixup_vendor_tbl[] = {
11082 SND_PCI_QUIRK_VENDOR(0x1025, "Acer Aspire", ALC271_FIXUP_DMIC),
11083 SND_PCI_QUIRK_VENDOR(0x103c, "HP", ALC269_FIXUP_HP_MUTE_LED),
11084 SND_PCI_QUIRK_VENDOR(0x104d, "Sony VAIO", ALC269_FIXUP_SONY_VAIO),
11085 SND_PCI_QUIRK_VENDOR(0x17aa, "Thinkpad", ALC269_FIXUP_THINKPAD_ACPI),
11086 SND_PCI_QUIRK_VENDOR(0x19e5, "Huawei Matebook", ALC255_FIXUP_MIC_MUTE_LED),
11087 {}
11088 };
11089
11090 static const struct hda_model_fixup alc269_fixup_models[] = {
11091 {.id = ALC269_FIXUP_AMIC, .name = "laptop-amic"},
11092 {.id = ALC269_FIXUP_DMIC, .name = "laptop-dmic"},
11093 {.id = ALC269_FIXUP_STEREO_DMIC, .name = "alc269-dmic"},
11094 {.id = ALC271_FIXUP_DMIC, .name = "alc271-dmic"},
11095 {.id = ALC269_FIXUP_INV_DMIC, .name = "inv-dmic"},
11096 {.id = ALC269_FIXUP_HEADSET_MIC, .name = "headset-mic"},
11097 {.id = ALC269_FIXUP_HEADSET_MODE, .name = "headset-mode"},
11098 {.id = ALC269_FIXUP_HEADSET_MODE_NO_HP_MIC, .name = "headset-mode-no-hp-mic"},
11099 {.id = ALC269_FIXUP_LENOVO_DOCK, .name = "lenovo-dock"},
11100 {.id = ALC269_FIXUP_LENOVO_DOCK_LIMIT_BOOST, .name = "lenovo-dock-limit-boost"},
11101 {.id = ALC269_FIXUP_HP_GPIO_LED, .name = "hp-gpio-led"},
11102 {.id = ALC269_FIXUP_HP_DOCK_GPIO_MIC1_LED, .name = "hp-dock-gpio-mic1-led"},
11103 {.id = ALC269_FIXUP_DELL1_MIC_NO_PRESENCE, .name = "dell-headset-multi"},
11104 {.id = ALC269_FIXUP_DELL2_MIC_NO_PRESENCE, .name = "dell-headset-dock"},
11105 {.id = ALC269_FIXUP_DELL3_MIC_NO_PRESENCE, .name = "dell-headset3"},
11106 {.id = ALC269_FIXUP_DELL4_MIC_NO_PRESENCE, .name = "dell-headset4"},
11107 {.id = ALC269_FIXUP_DELL4_MIC_NO_PRESENCE_QUIET, .name = "dell-headset4-quiet"},
11108 {.id = ALC283_FIXUP_CHROME_BOOK, .name = "alc283-dac-wcaps"},
11109 {.id = ALC283_FIXUP_SENSE_COMBO_JACK, .name = "alc283-sense-combo"},
11110 {.id = ALC292_FIXUP_TPT440_DOCK, .name = "tpt440-dock"},
11111 {.id = ALC292_FIXUP_TPT440, .name = "tpt440"},
11112 {.id = ALC292_FIXUP_TPT460, .name = "tpt460"},
11113 {.id = ALC298_FIXUP_TPT470_DOCK_FIX, .name = "tpt470-dock-fix"},
11114 {.id = ALC298_FIXUP_TPT470_DOCK, .name = "tpt470-dock"},
11115 {.id = ALC233_FIXUP_LENOVO_MULTI_CODECS, .name = "dual-codecs"},
11116 {.id = ALC700_FIXUP_INTEL_REFERENCE, .name = "alc700-ref"},
11117 {.id = ALC269_FIXUP_SONY_VAIO, .name = "vaio"},
11118 {.id = ALC269_FIXUP_DELL_M101Z, .name = "dell-m101z"},
11119 {.id = ALC269_FIXUP_ASUS_G73JW, .name = "asus-g73jw"},
11120 {.id = ALC269_FIXUP_LENOVO_EAPD, .name = "lenovo-eapd"},
11121 {.id = ALC275_FIXUP_SONY_HWEQ, .name = "sony-hweq"},
11122 {.id = ALC269_FIXUP_PCM_44K, .name = "pcm44k"},
11123 {.id = ALC269_FIXUP_LIFEBOOK, .name = "lifebook"},
11124 {.id = ALC269_FIXUP_LIFEBOOK_EXTMIC, .name = "lifebook-extmic"},
11125 {.id = ALC269_FIXUP_LIFEBOOK_HP_PIN, .name = "lifebook-hp-pin"},
11126 {.id = ALC255_FIXUP_LIFEBOOK_U7x7_HEADSET_MIC, .name = "lifebook-u7x7"},
11127 {.id = ALC269VB_FIXUP_AMIC, .name = "alc269vb-amic"},
11128 {.id = ALC269VB_FIXUP_DMIC, .name = "alc269vb-dmic"},
11129 {.id = ALC269_FIXUP_HP_MUTE_LED_MIC1, .name = "hp-mute-led-mic1"},
11130 {.id = ALC269_FIXUP_HP_MUTE_LED_MIC2, .name = "hp-mute-led-mic2"},
11131 {.id = ALC269_FIXUP_HP_MUTE_LED_MIC3, .name = "hp-mute-led-mic3"},
11132 {.id = ALC269_FIXUP_HP_GPIO_MIC1_LED, .name = "hp-gpio-mic1"},
11133 {.id = ALC269_FIXUP_HP_LINE1_MIC1_LED, .name = "hp-line1-mic1"},
11134 {.id = ALC269_FIXUP_NO_SHUTUP, .name = "noshutup"},
11135 {.id = ALC286_FIXUP_SONY_MIC_NO_PRESENCE, .name = "sony-nomic"},
11136 {.id = ALC269_FIXUP_ASPIRE_HEADSET_MIC, .name = "aspire-headset-mic"},
11137 {.id = ALC269_FIXUP_ASUS_X101, .name = "asus-x101"},
11138 {.id = ALC271_FIXUP_HP_GATE_MIC_JACK, .name = "acer-ao7xx"},
11139 {.id = ALC271_FIXUP_HP_GATE_MIC_JACK_E1_572, .name = "acer-aspire-e1"},
11140 {.id = ALC269_FIXUP_ACER_AC700, .name = "acer-ac700"},
11141 {.id = ALC269_FIXUP_LIMIT_INT_MIC_BOOST, .name = "limit-mic-boost"},
11142 {.id = ALC269VB_FIXUP_ASUS_ZENBOOK, .name = "asus-zenbook"},
11143 {.id = ALC269VB_FIXUP_ASUS_ZENBOOK_UX31A, .name = "asus-zenbook-ux31a"},
11144 {.id = ALC269VB_FIXUP_ORDISSIMO_EVE2, .name = "ordissimo"},
11145 {.id = ALC282_FIXUP_ASUS_TX300, .name = "asus-tx300"},
11146 {.id = ALC283_FIXUP_INT_MIC, .name = "alc283-int-mic"},
11147 {.id = ALC290_FIXUP_MONO_SPEAKERS_HSJACK, .name = "mono-speakers"},
11148 {.id = ALC290_FIXUP_SUBWOOFER_HSJACK, .name = "alc290-subwoofer"},
11149 {.id = ALC269_FIXUP_THINKPAD_ACPI, .name = "thinkpad"},
11150 {.id = ALC269_FIXUP_DMIC_THINKPAD_ACPI, .name = "dmic-thinkpad"},
11151 {.id = ALC255_FIXUP_ACER_MIC_NO_PRESENCE, .name = "alc255-acer"},
11152 {.id = ALC255_FIXUP_ASUS_MIC_NO_PRESENCE, .name = "alc255-asus"},
11153 {.id = ALC255_FIXUP_DELL1_MIC_NO_PRESENCE, .name = "alc255-dell1"},
11154 {.id = ALC255_FIXUP_DELL2_MIC_NO_PRESENCE, .name = "alc255-dell2"},
11155 {.id = ALC293_FIXUP_DELL1_MIC_NO_PRESENCE, .name = "alc293-dell1"},
11156 {.id = ALC283_FIXUP_HEADSET_MIC, .name = "alc283-headset"},
11157 {.id = ALC255_FIXUP_MIC_MUTE_LED, .name = "alc255-dell-mute"},
11158 {.id = ALC282_FIXUP_ASPIRE_V5_PINS, .name = "aspire-v5"},
11159 {.id = ALC269VB_FIXUP_ASPIRE_E1_COEF, .name = "aspire-e1-coef"},
11160 {.id = ALC280_FIXUP_HP_GPIO4, .name = "hp-gpio4"},
11161 {.id = ALC286_FIXUP_HP_GPIO_LED, .name = "hp-gpio-led"},
11162 {.id = ALC280_FIXUP_HP_GPIO2_MIC_HOTKEY, .name = "hp-gpio2-hotkey"},
11163 {.id = ALC280_FIXUP_HP_DOCK_PINS, .name = "hp-dock-pins"},
11164 {.id = ALC269_FIXUP_HP_DOCK_GPIO_MIC1_LED, .name = "hp-dock-gpio-mic"},
11165 {.id = ALC280_FIXUP_HP_9480M, .name = "hp-9480m"},
11166 {.id = ALC288_FIXUP_DELL_HEADSET_MODE, .name = "alc288-dell-headset"},
11167 {.id = ALC288_FIXUP_DELL1_MIC_NO_PRESENCE, .name = "alc288-dell1"},
11168 {.id = ALC288_FIXUP_DELL_XPS_13, .name = "alc288-dell-xps13"},
11169 {.id = ALC292_FIXUP_DELL_E7X, .name = "dell-e7x"},
11170 {.id = ALC293_FIXUP_DISABLE_AAMIX_MULTIJACK, .name = "alc293-dell"},
11171 {.id = ALC298_FIXUP_DELL1_MIC_NO_PRESENCE, .name = "alc298-dell1"},
11172 {.id = ALC298_FIXUP_DELL_AIO_MIC_NO_PRESENCE, .name = "alc298-dell-aio"},
11173 {.id = ALC275_FIXUP_DELL_XPS, .name = "alc275-dell-xps"},
11174 {.id = ALC293_FIXUP_LENOVO_SPK_NOISE, .name = "lenovo-spk-noise"},
11175 {.id = ALC233_FIXUP_LENOVO_LINE2_MIC_HOTKEY, .name = "lenovo-hotkey"},
11176 {.id = ALC255_FIXUP_DELL_SPK_NOISE, .name = "dell-spk-noise"},
11177 {.id = ALC225_FIXUP_DELL1_MIC_NO_PRESENCE, .name = "alc225-dell1"},
11178 {.id = ALC295_FIXUP_DISABLE_DAC3, .name = "alc295-disable-dac3"},
11179 {.id = ALC285_FIXUP_SPEAKER2_TO_DAC1, .name = "alc285-speaker2-to-dac1"},
11180 {.id = ALC280_FIXUP_HP_HEADSET_MIC, .name = "alc280-hp-headset"},
11181 {.id = ALC221_FIXUP_HP_FRONT_MIC, .name = "alc221-hp-mic"},
11182 {.id = ALC298_FIXUP_SPK_VOLUME, .name = "alc298-spk-volume"},
11183 {.id = ALC256_FIXUP_DELL_INSPIRON_7559_SUBWOOFER, .name = "dell-inspiron-7559"},
11184 {.id = ALC269_FIXUP_ATIV_BOOK_8, .name = "ativ-book"},
11185 {.id = ALC221_FIXUP_HP_MIC_NO_PRESENCE, .name = "alc221-hp-mic"},
11186 {.id = ALC256_FIXUP_ASUS_HEADSET_MODE, .name = "alc256-asus-headset"},
11187 {.id = ALC256_FIXUP_ASUS_MIC, .name = "alc256-asus-mic"},
11188 {.id = ALC256_FIXUP_ASUS_AIO_GPIO2, .name = "alc256-asus-aio"},
11189 {.id = ALC233_FIXUP_ASUS_MIC_NO_PRESENCE, .name = "alc233-asus"},
11190 {.id = ALC233_FIXUP_EAPD_COEF_AND_MIC_NO_PRESENCE, .name = "alc233-eapd"},
11191 {.id = ALC294_FIXUP_LENOVO_MIC_LOCATION, .name = "alc294-lenovo-mic"},
11192 {.id = ALC225_FIXUP_DELL_WYSE_MIC_NO_PRESENCE, .name = "alc225-wyse"},
11193 {.id = ALC274_FIXUP_DELL_AIO_LINEOUT_VERB, .name = "alc274-dell-aio"},
11194 {.id = ALC255_FIXUP_DUMMY_LINEOUT_VERB, .name = "alc255-dummy-lineout"},
11195 {.id = ALC255_FIXUP_DELL_HEADSET_MIC, .name = "alc255-dell-headset"},
11196 {.id = ALC295_FIXUP_HP_X360, .name = "alc295-hp-x360"},
11197 {.id = ALC225_FIXUP_HEADSET_JACK, .name = "alc-headset-jack"},
11198 {.id = ALC295_FIXUP_CHROME_BOOK, .name = "alc-chrome-book"},
11199 {.id = ALC256_FIXUP_CHROME_BOOK, .name = "alc-2024y-chromebook"},
11200 {.id = ALC299_FIXUP_PREDATOR_SPK, .name = "predator-spk"},
11201 {.id = ALC298_FIXUP_HUAWEI_MBX_STEREO, .name = "huawei-mbx-stereo"},
11202 {.id = ALC256_FIXUP_MEDION_HEADSET_NO_PRESENCE, .name = "alc256-medion-headset"},
11203 {.id = ALC298_FIXUP_SAMSUNG_AMP, .name = "alc298-samsung-amp"},
11204 {.id = ALC298_FIXUP_SAMSUNG_AMP_V2_2_AMPS, .name = "alc298-samsung-amp-v2-2-amps"},
11205 {.id = ALC298_FIXUP_SAMSUNG_AMP_V2_4_AMPS, .name = "alc298-samsung-amp-v2-4-amps"},
11206 {.id = ALC256_FIXUP_SAMSUNG_HEADPHONE_VERY_QUIET, .name = "alc256-samsung-headphone"},
11207 {.id = ALC255_FIXUP_XIAOMI_HEADSET_MIC, .name = "alc255-xiaomi-headset"},
11208 {.id = ALC274_FIXUP_HP_MIC, .name = "alc274-hp-mic-detect"},
11209 {.id = ALC245_FIXUP_HP_X360_AMP, .name = "alc245-hp-x360-amp"},
11210 {.id = ALC295_FIXUP_HP_OMEN, .name = "alc295-hp-omen"},
11211 {.id = ALC285_FIXUP_HP_SPECTRE_X360, .name = "alc285-hp-spectre-x360"},
11212 {.id = ALC285_FIXUP_HP_SPECTRE_X360_EB1, .name = "alc285-hp-spectre-x360-eb1"},
11213 {.id = ALC285_FIXUP_HP_ENVY_X360, .name = "alc285-hp-envy-x360"},
11214 {.id = ALC287_FIXUP_IDEAPAD_BASS_SPK_AMP, .name = "alc287-ideapad-bass-spk-amp"},
11215 {.id = ALC287_FIXUP_YOGA9_14IAP7_BASS_SPK_PIN, .name = "alc287-yoga9-bass-spk-pin"},
11216 {.id = ALC623_FIXUP_LENOVO_THINKSTATION_P340, .name = "alc623-lenovo-thinkstation-p340"},
11217 {.id = ALC255_FIXUP_ACER_HEADPHONE_AND_MIC, .name = "alc255-acer-headphone-and-mic"},
11218 {.id = ALC285_FIXUP_HP_GPIO_AMP_INIT, .name = "alc285-hp-amp-init"},
11219 {.id = ALC236_FIXUP_LENOVO_INV_DMIC, .name = "alc236-fixup-lenovo-inv-mic"},
11220 {}
11221 };
11222 #define ALC225_STANDARD_PINS \
11223 {0x21, 0x04211020}
11224
11225 #define ALC256_STANDARD_PINS \
11226 {0x12, 0x90a60140}, \
11227 {0x14, 0x90170110}, \
11228 {0x21, 0x02211020}
11229
11230 #define ALC282_STANDARD_PINS \
11231 {0x14, 0x90170110}
11232
11233 #define ALC290_STANDARD_PINS \
11234 {0x12, 0x99a30130}
11235
11236 #define ALC292_STANDARD_PINS \
11237 {0x14, 0x90170110}, \
11238 {0x15, 0x0221401f}
11239
11240 #define ALC295_STANDARD_PINS \
11241 {0x12, 0xb7a60130}, \
11242 {0x14, 0x90170110}, \
11243 {0x21, 0x04211020}
11244
11245 #define ALC298_STANDARD_PINS \
11246 {0x12, 0x90a60130}, \
11247 {0x21, 0x03211020}
11248
11249 static const struct snd_hda_pin_quirk alc269_pin_fixup_tbl[] = {
11250 SND_HDA_PIN_QUIRK(0x10ec0221, 0x103c, "HP Workstation", ALC221_FIXUP_HP_HEADSET_MIC,
11251 {0x14, 0x01014020},
11252 {0x17, 0x90170110},
11253 {0x18, 0x02a11030},
11254 {0x19, 0x0181303F},
11255 {0x21, 0x0221102f}),
11256 SND_HDA_PIN_QUIRK(0x10ec0255, 0x1025, "Acer", ALC255_FIXUP_ACER_MIC_NO_PRESENCE,
11257 {0x12, 0x90a601c0},
11258 {0x14, 0x90171120},
11259 {0x21, 0x02211030}),
11260 SND_HDA_PIN_QUIRK(0x10ec0255, 0x1043, "ASUS", ALC255_FIXUP_ASUS_MIC_NO_PRESENCE,
11261 {0x14, 0x90170110},
11262 {0x1b, 0x90a70130},
11263 {0x21, 0x03211020}),
11264 SND_HDA_PIN_QUIRK(0x10ec0255, 0x1043, "ASUS", ALC255_FIXUP_ASUS_MIC_NO_PRESENCE,
11265 {0x1a, 0x90a70130},
11266 {0x1b, 0x90170110},
11267 {0x21, 0x03211020}),
11268 SND_HDA_PIN_QUIRK(0x10ec0225, 0x1028, "Dell", ALC225_FIXUP_DELL1_MIC_NO_PRESENCE,
11269 ALC225_STANDARD_PINS,
11270 {0x12, 0xb7a60130},
11271 {0x14, 0x901701a0}),
11272 SND_HDA_PIN_QUIRK(0x10ec0225, 0x1028, "Dell", ALC225_FIXUP_DELL1_MIC_NO_PRESENCE,
11273 ALC225_STANDARD_PINS,
11274 {0x12, 0xb7a60130},
11275 {0x14, 0x901701b0}),
11276 SND_HDA_PIN_QUIRK(0x10ec0225, 0x1028, "Dell", ALC225_FIXUP_DELL1_MIC_NO_PRESENCE,
11277 ALC225_STANDARD_PINS,
11278 {0x12, 0xb7a60150},
11279 {0x14, 0x901701a0}),
11280 SND_HDA_PIN_QUIRK(0x10ec0225, 0x1028, "Dell", ALC225_FIXUP_DELL1_MIC_NO_PRESENCE,
11281 ALC225_STANDARD_PINS,
11282 {0x12, 0xb7a60150},
11283 {0x14, 0x901701b0}),
11284 SND_HDA_PIN_QUIRK(0x10ec0225, 0x1028, "Dell", ALC225_FIXUP_DELL1_MIC_NO_PRESENCE,
11285 ALC225_STANDARD_PINS,
11286 {0x12, 0xb7a60130},
11287 {0x1b, 0x90170110}),
11288 SND_HDA_PIN_QUIRK(0x10ec0233, 0x8086, "Intel NUC Skull Canyon", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE,
11289 {0x1b, 0x01111010},
11290 {0x1e, 0x01451130},
11291 {0x21, 0x02211020}),
11292 SND_HDA_PIN_QUIRK(0x10ec0235, 0x17aa, "Lenovo", ALC233_FIXUP_LENOVO_LINE2_MIC_HOTKEY,
11293 {0x12, 0x90a60140},
11294 {0x14, 0x90170110},
11295 {0x19, 0x02a11030},
11296 {0x21, 0x02211020}),
11297 SND_HDA_PIN_QUIRK(0x10ec0235, 0x17aa, "Lenovo", ALC294_FIXUP_LENOVO_MIC_LOCATION,
11298 {0x14, 0x90170110},
11299 {0x19, 0x02a11030},
11300 {0x1a, 0x02a11040},
11301 {0x1b, 0x01014020},
11302 {0x21, 0x0221101f}),
11303 SND_HDA_PIN_QUIRK(0x10ec0235, 0x17aa, "Lenovo", ALC294_FIXUP_LENOVO_MIC_LOCATION,
11304 {0x14, 0x90170110},
11305 {0x19, 0x02a11030},
11306 {0x1a, 0x02a11040},
11307 {0x1b, 0x01011020},
11308 {0x21, 0x0221101f}),
11309 SND_HDA_PIN_QUIRK(0x10ec0235, 0x17aa, "Lenovo", ALC294_FIXUP_LENOVO_MIC_LOCATION,
11310 {0x14, 0x90170110},
11311 {0x19, 0x02a11020},
11312 {0x1a, 0x02a11030},
11313 {0x21, 0x0221101f}),
11314 SND_HDA_PIN_QUIRK(0x10ec0236, 0x1028, "Dell", ALC236_FIXUP_DELL_AIO_HEADSET_MIC,
11315 {0x21, 0x02211010}),
11316 SND_HDA_PIN_QUIRK(0x10ec0236, 0x103c, "HP", ALC256_FIXUP_HP_HEADSET_MIC,
11317 {0x14, 0x90170110},
11318 {0x19, 0x02a11020},
11319 {0x21, 0x02211030}),
11320 SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL2_MIC_NO_PRESENCE,
11321 {0x14, 0x90170110},
11322 {0x21, 0x02211020}),
11323 SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
11324 {0x14, 0x90170130},
11325 {0x21, 0x02211040}),
11326 SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
11327 {0x12, 0x90a60140},
11328 {0x14, 0x90170110},
11329 {0x21, 0x02211020}),
11330 SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
11331 {0x12, 0x90a60160},
11332 {0x14, 0x90170120},
11333 {0x21, 0x02211030}),
11334 SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
11335 {0x14, 0x90170110},
11336 {0x1b, 0x02011020},
11337 {0x21, 0x0221101f}),
11338 SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
11339 {0x14, 0x90170110},
11340 {0x1b, 0x01011020},
11341 {0x21, 0x0221101f}),
11342 SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
11343 {0x14, 0x90170130},
11344 {0x1b, 0x01014020},
11345 {0x21, 0x0221103f}),
11346 SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
11347 {0x14, 0x90170130},
11348 {0x1b, 0x01011020},
11349 {0x21, 0x0221103f}),
11350 SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
11351 {0x14, 0x90170130},
11352 {0x1b, 0x02011020},
11353 {0x21, 0x0221103f}),
11354 SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
11355 {0x14, 0x90170150},
11356 {0x1b, 0x02011020},
11357 {0x21, 0x0221105f}),
11358 SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
11359 {0x14, 0x90170110},
11360 {0x1b, 0x01014020},
11361 {0x21, 0x0221101f}),
11362 SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
11363 {0x12, 0x90a60160},
11364 {0x14, 0x90170120},
11365 {0x17, 0x90170140},
11366 {0x21, 0x0321102f}),
11367 SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
11368 {0x12, 0x90a60160},
11369 {0x14, 0x90170130},
11370 {0x21, 0x02211040}),
11371 SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
11372 {0x12, 0x90a60160},
11373 {0x14, 0x90170140},
11374 {0x21, 0x02211050}),
11375 SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
11376 {0x12, 0x90a60170},
11377 {0x14, 0x90170120},
11378 {0x21, 0x02211030}),
11379 SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
11380 {0x12, 0x90a60170},
11381 {0x14, 0x90170130},
11382 {0x21, 0x02211040}),
11383 SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
11384 {0x12, 0x90a60170},
11385 {0x14, 0x90171130},
11386 {0x21, 0x02211040}),
11387 SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
11388 {0x12, 0x90a60170},
11389 {0x14, 0x90170140},
11390 {0x21, 0x02211050}),
11391 SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell Inspiron 5548", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
11392 {0x12, 0x90a60180},
11393 {0x14, 0x90170130},
11394 {0x21, 0x02211040}),
11395 SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell Inspiron 5565", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
11396 {0x12, 0x90a60180},
11397 {0x14, 0x90170120},
11398 {0x21, 0x02211030}),
11399 SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
11400 {0x1b, 0x01011020},
11401 {0x21, 0x02211010}),
11402 SND_HDA_PIN_QUIRK(0x10ec0256, 0x1043, "ASUS", ALC256_FIXUP_ASUS_MIC,
11403 {0x14, 0x90170110},
11404 {0x1b, 0x90a70130},
11405 {0x21, 0x04211020}),
11406 SND_HDA_PIN_QUIRK(0x10ec0256, 0x1043, "ASUS", ALC256_FIXUP_ASUS_MIC,
11407 {0x14, 0x90170110},
11408 {0x1b, 0x90a70130},
11409 {0x21, 0x03211020}),
11410 SND_HDA_PIN_QUIRK(0x10ec0256, 0x1043, "ASUS", ALC256_FIXUP_ASUS_MIC_NO_PRESENCE,
11411 {0x12, 0x90a60130},
11412 {0x14, 0x90170110},
11413 {0x21, 0x03211020}),
11414 SND_HDA_PIN_QUIRK(0x10ec0256, 0x1043, "ASUS", ALC256_FIXUP_ASUS_MIC_NO_PRESENCE,
11415 {0x12, 0x90a60130},
11416 {0x14, 0x90170110},
11417 {0x21, 0x04211020}),
11418 SND_HDA_PIN_QUIRK(0x10ec0256, 0x1043, "ASUS", ALC256_FIXUP_ASUS_MIC_NO_PRESENCE,
11419 {0x1a, 0x90a70130},
11420 {0x1b, 0x90170110},
11421 {0x21, 0x03211020}),
11422 SND_HDA_PIN_QUIRK(0x10ec0256, 0x103c, "HP", ALC256_FIXUP_HP_HEADSET_MIC,
11423 {0x14, 0x90170110},
11424 {0x19, 0x02a11020},
11425 {0x21, 0x0221101f}),
11426 SND_HDA_PIN_QUIRK(0x10ec0274, 0x103c, "HP", ALC274_FIXUP_HP_HEADSET_MIC,
11427 {0x17, 0x90170110},
11428 {0x19, 0x03a11030},
11429 {0x21, 0x03211020}),
11430 SND_HDA_PIN_QUIRK(0x10ec0280, 0x103c, "HP", ALC280_FIXUP_HP_GPIO4,
11431 {0x12, 0x90a60130},
11432 {0x14, 0x90170110},
11433 {0x15, 0x0421101f},
11434 {0x1a, 0x04a11020}),
11435 SND_HDA_PIN_QUIRK(0x10ec0280, 0x103c, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED,
11436 {0x12, 0x90a60140},
11437 {0x14, 0x90170110},
11438 {0x15, 0x0421101f},
11439 {0x18, 0x02811030},
11440 {0x1a, 0x04a1103f},
11441 {0x1b, 0x02011020}),
11442 SND_HDA_PIN_QUIRK(0x10ec0282, 0x103c, "HP 15 Touchsmart", ALC269_FIXUP_HP_MUTE_LED_MIC1,
11443 ALC282_STANDARD_PINS,
11444 {0x12, 0x99a30130},
11445 {0x19, 0x03a11020},
11446 {0x21, 0x0321101f}),
11447 SND_HDA_PIN_QUIRK(0x10ec0282, 0x103c, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1,
11448 ALC282_STANDARD_PINS,
11449 {0x12, 0x99a30130},
11450 {0x19, 0x03a11020},
11451 {0x21, 0x03211040}),
11452 SND_HDA_PIN_QUIRK(0x10ec0282, 0x103c, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1,
11453 ALC282_STANDARD_PINS,
11454 {0x12, 0x99a30130},
11455 {0x19, 0x03a11030},
11456 {0x21, 0x03211020}),
11457 SND_HDA_PIN_QUIRK(0x10ec0282, 0x103c, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1,
11458 ALC282_STANDARD_PINS,
11459 {0x12, 0x99a30130},
11460 {0x19, 0x04a11020},
11461 {0x21, 0x0421101f}),
11462 SND_HDA_PIN_QUIRK(0x10ec0282, 0x103c, "HP", ALC269_FIXUP_HP_LINE1_MIC1_LED,
11463 ALC282_STANDARD_PINS,
11464 {0x12, 0x90a60140},
11465 {0x19, 0x04a11030},
11466 {0x21, 0x04211020}),
11467 SND_HDA_PIN_QUIRK(0x10ec0282, 0x1025, "Acer", ALC282_FIXUP_ACER_DISABLE_LINEOUT,
11468 ALC282_STANDARD_PINS,
11469 {0x12, 0x90a609c0},
11470 {0x18, 0x03a11830},
11471 {0x19, 0x04a19831},
11472 {0x1a, 0x0481303f},
11473 {0x1b, 0x04211020},
11474 {0x21, 0x0321101f}),
11475 SND_HDA_PIN_QUIRK(0x10ec0282, 0x1025, "Acer", ALC282_FIXUP_ACER_DISABLE_LINEOUT,
11476 ALC282_STANDARD_PINS,
11477 {0x12, 0x90a60940},
11478 {0x18, 0x03a11830},
11479 {0x19, 0x04a19831},
11480 {0x1a, 0x0481303f},
11481 {0x1b, 0x04211020},
11482 {0x21, 0x0321101f}),
11483 SND_HDA_PIN_QUIRK(0x10ec0283, 0x1028, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE,
11484 ALC282_STANDARD_PINS,
11485 {0x12, 0x90a60130},
11486 {0x21, 0x0321101f}),
11487 SND_HDA_PIN_QUIRK(0x10ec0283, 0x1028, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE,
11488 {0x12, 0x90a60160},
11489 {0x14, 0x90170120},
11490 {0x21, 0x02211030}),
11491 SND_HDA_PIN_QUIRK(0x10ec0283, 0x1028, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE,
11492 ALC282_STANDARD_PINS,
11493 {0x12, 0x90a60130},
11494 {0x19, 0x03a11020},
11495 {0x21, 0x0321101f}),
11496 SND_HDA_PIN_QUIRK(0x10ec0285, 0x17aa, "Lenovo", ALC285_FIXUP_LENOVO_PC_BEEP_IN_NOISE,
11497 {0x12, 0x90a60130},
11498 {0x14, 0x90170110},
11499 {0x19, 0x04a11040},
11500 {0x21, 0x04211020}),
11501 SND_HDA_PIN_QUIRK(0x10ec0285, 0x17aa, "Lenovo", ALC285_FIXUP_LENOVO_PC_BEEP_IN_NOISE,
11502 {0x14, 0x90170110},
11503 {0x19, 0x04a11040},
11504 {0x1d, 0x40600001},
11505 {0x21, 0x04211020}),
11506 SND_HDA_PIN_QUIRK(0x10ec0285, 0x17aa, "Lenovo", ALC285_FIXUP_THINKPAD_NO_BASS_SPK_HEADSET_JACK,
11507 {0x14, 0x90170110},
11508 {0x19, 0x04a11040},
11509 {0x21, 0x04211020}),
11510 SND_HDA_PIN_QUIRK(0x10ec0287, 0x17aa, "Lenovo", ALC285_FIXUP_THINKPAD_HEADSET_JACK,
11511 {0x14, 0x90170110},
11512 {0x17, 0x90170111},
11513 {0x19, 0x03a11030},
11514 {0x21, 0x03211020}),
11515 SND_HDA_PIN_QUIRK(0x10ec0287, 0x17aa, "Lenovo", ALC287_FIXUP_THINKPAD_I2S_SPK,
11516 {0x17, 0x90170110},
11517 {0x19, 0x03a11030},
11518 {0x21, 0x03211020}),
11519 SND_HDA_PIN_QUIRK(0x10ec0287, 0x17aa, "Lenovo", ALC287_FIXUP_THINKPAD_I2S_SPK,
11520 {0x17, 0x90170110}, /* 0x231f with RTK I2S AMP */
11521 {0x19, 0x04a11040},
11522 {0x21, 0x04211020}),
11523 SND_HDA_PIN_QUIRK(0x10ec0286, 0x1025, "Acer", ALC286_FIXUP_ACER_AIO_MIC_NO_PRESENCE,
11524 {0x12, 0x90a60130},
11525 {0x17, 0x90170110},
11526 {0x21, 0x02211020}),
11527 SND_HDA_PIN_QUIRK(0x10ec0288, 0x1028, "Dell", ALC288_FIXUP_DELL1_MIC_NO_PRESENCE,
11528 {0x12, 0x90a60120},
11529 {0x14, 0x90170110},
11530 {0x21, 0x0321101f}),
11531 SND_HDA_PIN_QUIRK(0x10ec0290, 0x103c, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1,
11532 ALC290_STANDARD_PINS,
11533 {0x15, 0x04211040},
11534 {0x18, 0x90170112},
11535 {0x1a, 0x04a11020}),
11536 SND_HDA_PIN_QUIRK(0x10ec0290, 0x103c, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1,
11537 ALC290_STANDARD_PINS,
11538 {0x15, 0x04211040},
11539 {0x18, 0x90170110},
11540 {0x1a, 0x04a11020}),
11541 SND_HDA_PIN_QUIRK(0x10ec0290, 0x103c, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1,
11542 ALC290_STANDARD_PINS,
11543 {0x15, 0x0421101f},
11544 {0x1a, 0x04a11020}),
11545 SND_HDA_PIN_QUIRK(0x10ec0290, 0x103c, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1,
11546 ALC290_STANDARD_PINS,
11547 {0x15, 0x04211020},
11548 {0x1a, 0x04a11040}),
11549 SND_HDA_PIN_QUIRK(0x10ec0290, 0x103c, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1,
11550 ALC290_STANDARD_PINS,
11551 {0x14, 0x90170110},
11552 {0x15, 0x04211020},
11553 {0x1a, 0x04a11040}),
11554 SND_HDA_PIN_QUIRK(0x10ec0290, 0x103c, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1,
11555 ALC290_STANDARD_PINS,
11556 {0x14, 0x90170110},
11557 {0x15, 0x04211020},
11558 {0x1a, 0x04a11020}),
11559 SND_HDA_PIN_QUIRK(0x10ec0290, 0x103c, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1,
11560 ALC290_STANDARD_PINS,
11561 {0x14, 0x90170110},
11562 {0x15, 0x0421101f},
11563 {0x1a, 0x04a11020}),
11564 SND_HDA_PIN_QUIRK(0x10ec0292, 0x1028, "Dell", ALC269_FIXUP_DELL2_MIC_NO_PRESENCE,
11565 ALC292_STANDARD_PINS,
11566 {0x12, 0x90a60140},
11567 {0x16, 0x01014020},
11568 {0x19, 0x01a19030}),
11569 SND_HDA_PIN_QUIRK(0x10ec0292, 0x1028, "Dell", ALC269_FIXUP_DELL2_MIC_NO_PRESENCE,
11570 ALC292_STANDARD_PINS,
11571 {0x12, 0x90a60140},
11572 {0x16, 0x01014020},
11573 {0x18, 0x02a19031},
11574 {0x19, 0x01a1903e}),
11575 SND_HDA_PIN_QUIRK(0x10ec0292, 0x1028, "Dell", ALC269_FIXUP_DELL3_MIC_NO_PRESENCE,
11576 ALC292_STANDARD_PINS,
11577 {0x12, 0x90a60140}),
11578 SND_HDA_PIN_QUIRK(0x10ec0293, 0x1028, "Dell", ALC293_FIXUP_DELL1_MIC_NO_PRESENCE,
11579 ALC292_STANDARD_PINS,
11580 {0x13, 0x90a60140},
11581 {0x16, 0x21014020},
11582 {0x19, 0x21a19030}),
11583 SND_HDA_PIN_QUIRK(0x10ec0293, 0x1028, "Dell", ALC293_FIXUP_DELL1_MIC_NO_PRESENCE,
11584 ALC292_STANDARD_PINS,
11585 {0x13, 0x90a60140}),
11586 SND_HDA_PIN_QUIRK(0x10ec0294, 0x1043, "ASUS", ALC294_FIXUP_ASUS_HPE,
11587 {0x17, 0x90170110},
11588 {0x21, 0x04211020}),
11589 SND_HDA_PIN_QUIRK(0x10ec0294, 0x1043, "ASUS", ALC294_FIXUP_ASUS_MIC,
11590 {0x14, 0x90170110},
11591 {0x1b, 0x90a70130},
11592 {0x21, 0x04211020}),
11593 SND_HDA_PIN_QUIRK(0x10ec0294, 0x1043, "ASUS", ALC294_FIXUP_ASUS_SPK,
11594 {0x12, 0x90a60130},
11595 {0x17, 0x90170110},
11596 {0x21, 0x03211020}),
11597 SND_HDA_PIN_QUIRK(0x10ec0294, 0x1043, "ASUS", ALC294_FIXUP_ASUS_SPK,
11598 {0x12, 0x90a60130},
11599 {0x17, 0x90170110},
11600 {0x21, 0x04211020}),
11601 SND_HDA_PIN_QUIRK(0x10ec0295, 0x1043, "ASUS", ALC294_FIXUP_ASUS_SPK,
11602 {0x12, 0x90a60130},
11603 {0x17, 0x90170110},
11604 {0x21, 0x03211020}),
11605 SND_HDA_PIN_QUIRK(0x10ec0295, 0x1043, "ASUS", ALC295_FIXUP_ASUS_MIC_NO_PRESENCE,
11606 {0x12, 0x90a60120},
11607 {0x17, 0x90170110},
11608 {0x21, 0x04211030}),
11609 SND_HDA_PIN_QUIRK(0x10ec0295, 0x1043, "ASUS", ALC295_FIXUP_ASUS_MIC_NO_PRESENCE,
11610 {0x12, 0x90a60130},
11611 {0x17, 0x90170110},
11612 {0x21, 0x03211020}),
11613 SND_HDA_PIN_QUIRK(0x10ec0295, 0x1043, "ASUS", ALC295_FIXUP_ASUS_MIC_NO_PRESENCE,
11614 {0x12, 0x90a60130},
11615 {0x17, 0x90170110},
11616 {0x21, 0x03211020}),
11617 SND_HDA_PIN_QUIRK(0x10ec0298, 0x1028, "Dell", ALC298_FIXUP_DELL1_MIC_NO_PRESENCE,
11618 ALC298_STANDARD_PINS,
11619 {0x17, 0x90170110}),
11620 SND_HDA_PIN_QUIRK(0x10ec0298, 0x1028, "Dell", ALC298_FIXUP_DELL1_MIC_NO_PRESENCE,
11621 ALC298_STANDARD_PINS,
11622 {0x17, 0x90170140}),
11623 SND_HDA_PIN_QUIRK(0x10ec0298, 0x1028, "Dell", ALC298_FIXUP_DELL1_MIC_NO_PRESENCE,
11624 ALC298_STANDARD_PINS,
11625 {0x17, 0x90170150}),
11626 SND_HDA_PIN_QUIRK(0x10ec0298, 0x1028, "Dell", ALC298_FIXUP_SPK_VOLUME,
11627 {0x12, 0xb7a60140},
11628 {0x13, 0xb7a60150},
11629 {0x17, 0x90170110},
11630 {0x1a, 0x03011020},
11631 {0x21, 0x03211030}),
11632 SND_HDA_PIN_QUIRK(0x10ec0298, 0x1028, "Dell", ALC298_FIXUP_ALIENWARE_MIC_NO_PRESENCE,
11633 {0x12, 0xb7a60140},
11634 {0x17, 0x90170110},
11635 {0x1a, 0x03a11030},
11636 {0x21, 0x03211020}),
11637 SND_HDA_PIN_QUIRK(0x10ec0299, 0x1028, "Dell", ALC269_FIXUP_DELL4_MIC_NO_PRESENCE,
11638 ALC225_STANDARD_PINS,
11639 {0x12, 0xb7a60130},
11640 {0x17, 0x90170110}),
11641 SND_HDA_PIN_QUIRK(0x10ec0623, 0x17aa, "Lenovo", ALC283_FIXUP_HEADSET_MIC,
11642 {0x14, 0x01014010},
11643 {0x17, 0x90170120},
11644 {0x18, 0x02a11030},
11645 {0x19, 0x02a1103f},
11646 {0x21, 0x0221101f}),
11647 {}
11648 };
11649
11650 /* This is the fallback pin_fixup_tbl for alc269 family, to make the tbl match
11651 * more machines, don't need to match all valid pins, just need to match
11652 * all the pins defined in the tbl. Just because of this reason, it is possible
11653 * that a single machine matches multiple tbls, so there is one limitation:
11654 * at most one tbl is allowed to define for the same vendor and same codec
11655 */
11656 static const struct snd_hda_pin_quirk alc269_fallback_pin_fixup_tbl[] = {
11657 SND_HDA_PIN_QUIRK(0x10ec0256, 0x1025, "Acer", ALC2XX_FIXUP_HEADSET_MIC,
11658 {0x19, 0x40000000}),
11659 SND_HDA_PIN_QUIRK(0x10ec0289, 0x1028, "Dell", ALC269_FIXUP_DELL4_MIC_NO_PRESENCE,
11660 {0x19, 0x40000000},
11661 {0x1b, 0x40000000}),
11662 SND_HDA_PIN_QUIRK(0x10ec0295, 0x1028, "Dell", ALC269_FIXUP_DELL4_MIC_NO_PRESENCE_QUIET,
11663 {0x19, 0x40000000},
11664 {0x1b, 0x40000000}),
11665 SND_HDA_PIN_QUIRK(0x10ec0256, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
11666 {0x19, 0x40000000},
11667 {0x1a, 0x40000000}),
11668 SND_HDA_PIN_QUIRK(0x10ec0236, 0x1028, "Dell", ALC255_FIXUP_DELL1_LIMIT_INT_MIC_BOOST,
11669 {0x19, 0x40000000},
11670 {0x1a, 0x40000000}),
11671 SND_HDA_PIN_QUIRK(0x10ec0274, 0x1028, "Dell", ALC269_FIXUP_DELL1_LIMIT_INT_MIC_BOOST,
11672 {0x19, 0x40000000},
11673 {0x1a, 0x40000000}),
11674 SND_HDA_PIN_QUIRK(0x10ec0256, 0x1043, "ASUS", ALC2XX_FIXUP_HEADSET_MIC,
11675 {0x19, 0x40000000}),
11676 {}
11677 };
11678
alc269_fill_coef(struct hda_codec * codec)11679 static void alc269_fill_coef(struct hda_codec *codec)
11680 {
11681 struct alc_spec *spec = codec->spec;
11682 int val;
11683
11684 if (spec->codec_variant != ALC269_TYPE_ALC269VB)
11685 return;
11686
11687 if ((alc_get_coef0(codec) & 0x00ff) < 0x015) {
11688 alc_write_coef_idx(codec, 0xf, 0x960b);
11689 alc_write_coef_idx(codec, 0xe, 0x8817);
11690 }
11691
11692 if ((alc_get_coef0(codec) & 0x00ff) == 0x016) {
11693 alc_write_coef_idx(codec, 0xf, 0x960b);
11694 alc_write_coef_idx(codec, 0xe, 0x8814);
11695 }
11696
11697 if ((alc_get_coef0(codec) & 0x00ff) == 0x017) {
11698 /* Power up output pin */
11699 alc_update_coef_idx(codec, 0x04, 0, 1<<11);
11700 }
11701
11702 if ((alc_get_coef0(codec) & 0x00ff) == 0x018) {
11703 val = alc_read_coef_idx(codec, 0xd);
11704 if (val != -1 && (val & 0x0c00) >> 10 != 0x1) {
11705 /* Capless ramp up clock control */
11706 alc_write_coef_idx(codec, 0xd, val | (1<<10));
11707 }
11708 val = alc_read_coef_idx(codec, 0x17);
11709 if (val != -1 && (val & 0x01c0) >> 6 != 0x4) {
11710 /* Class D power on reset */
11711 alc_write_coef_idx(codec, 0x17, val | (1<<7));
11712 }
11713 }
11714
11715 /* HP */
11716 alc_update_coef_idx(codec, 0x4, 0, 1<<11);
11717 }
11718
11719 /*
11720 */
patch_alc269(struct hda_codec * codec)11721 static int patch_alc269(struct hda_codec *codec)
11722 {
11723 struct alc_spec *spec;
11724 int err;
11725
11726 err = alc_alloc_spec(codec, 0x0b);
11727 if (err < 0)
11728 return err;
11729
11730 spec = codec->spec;
11731 spec->gen.shared_mic_vref_pin = 0x18;
11732 codec->power_save_node = 0;
11733 spec->en_3kpull_low = true;
11734
11735 codec->patch_ops.suspend = alc269_suspend;
11736 codec->patch_ops.resume = alc269_resume;
11737 spec->shutup = alc_default_shutup;
11738 spec->init_hook = alc_default_init;
11739
11740 switch (codec->core.vendor_id) {
11741 case 0x10ec0269:
11742 spec->codec_variant = ALC269_TYPE_ALC269VA;
11743 switch (alc_get_coef0(codec) & 0x00f0) {
11744 case 0x0010:
11745 if (codec->bus->pci &&
11746 codec->bus->pci->subsystem_vendor == 0x1025 &&
11747 spec->cdefine.platform_type == 1)
11748 err = alc_codec_rename(codec, "ALC271X");
11749 spec->codec_variant = ALC269_TYPE_ALC269VB;
11750 break;
11751 case 0x0020:
11752 if (codec->bus->pci &&
11753 codec->bus->pci->subsystem_vendor == 0x17aa &&
11754 codec->bus->pci->subsystem_device == 0x21f3)
11755 err = alc_codec_rename(codec, "ALC3202");
11756 spec->codec_variant = ALC269_TYPE_ALC269VC;
11757 break;
11758 case 0x0030:
11759 spec->codec_variant = ALC269_TYPE_ALC269VD;
11760 break;
11761 default:
11762 alc_fix_pll_init(codec, 0x20, 0x04, 15);
11763 }
11764 if (err < 0)
11765 goto error;
11766 spec->shutup = alc269_shutup;
11767 spec->init_hook = alc269_fill_coef;
11768 alc269_fill_coef(codec);
11769 break;
11770
11771 case 0x10ec0280:
11772 case 0x10ec0290:
11773 spec->codec_variant = ALC269_TYPE_ALC280;
11774 break;
11775 case 0x10ec0282:
11776 spec->codec_variant = ALC269_TYPE_ALC282;
11777 spec->shutup = alc282_shutup;
11778 spec->init_hook = alc282_init;
11779 break;
11780 case 0x10ec0233:
11781 case 0x10ec0283:
11782 spec->codec_variant = ALC269_TYPE_ALC283;
11783 spec->shutup = alc283_shutup;
11784 spec->init_hook = alc283_init;
11785 break;
11786 case 0x10ec0284:
11787 case 0x10ec0292:
11788 spec->codec_variant = ALC269_TYPE_ALC284;
11789 break;
11790 case 0x10ec0293:
11791 spec->codec_variant = ALC269_TYPE_ALC293;
11792 break;
11793 case 0x10ec0286:
11794 case 0x10ec0288:
11795 spec->codec_variant = ALC269_TYPE_ALC286;
11796 break;
11797 case 0x10ec0298:
11798 spec->codec_variant = ALC269_TYPE_ALC298;
11799 break;
11800 case 0x10ec0235:
11801 case 0x10ec0255:
11802 spec->codec_variant = ALC269_TYPE_ALC255;
11803 spec->shutup = alc256_shutup;
11804 spec->init_hook = alc256_init;
11805 break;
11806 case 0x10ec0230:
11807 case 0x10ec0236:
11808 case 0x10ec0256:
11809 case 0x19e58326:
11810 spec->codec_variant = ALC269_TYPE_ALC256;
11811 spec->shutup = alc256_shutup;
11812 spec->init_hook = alc256_init;
11813 spec->gen.mixer_nid = 0; /* ALC256 does not have any loopback mixer path */
11814 if (codec->core.vendor_id == 0x10ec0236 &&
11815 codec->bus->pci->vendor != PCI_VENDOR_ID_AMD)
11816 spec->en_3kpull_low = false;
11817 break;
11818 case 0x10ec0257:
11819 spec->codec_variant = ALC269_TYPE_ALC257;
11820 spec->shutup = alc256_shutup;
11821 spec->init_hook = alc256_init;
11822 spec->gen.mixer_nid = 0;
11823 spec->en_3kpull_low = false;
11824 break;
11825 case 0x10ec0215:
11826 case 0x10ec0245:
11827 case 0x10ec0285:
11828 case 0x10ec0289:
11829 if (alc_get_coef0(codec) & 0x0010)
11830 spec->codec_variant = ALC269_TYPE_ALC245;
11831 else
11832 spec->codec_variant = ALC269_TYPE_ALC215;
11833 spec->shutup = alc225_shutup;
11834 spec->init_hook = alc225_init;
11835 spec->gen.mixer_nid = 0;
11836 break;
11837 case 0x10ec0225:
11838 case 0x10ec0295:
11839 case 0x10ec0299:
11840 spec->codec_variant = ALC269_TYPE_ALC225;
11841 spec->shutup = alc225_shutup;
11842 spec->init_hook = alc225_init;
11843 spec->gen.mixer_nid = 0; /* no loopback on ALC225, ALC295 and ALC299 */
11844 break;
11845 case 0x10ec0287:
11846 spec->codec_variant = ALC269_TYPE_ALC287;
11847 spec->shutup = alc225_shutup;
11848 spec->init_hook = alc225_init;
11849 spec->gen.mixer_nid = 0; /* no loopback on ALC287 */
11850 break;
11851 case 0x10ec0234:
11852 case 0x10ec0274:
11853 case 0x10ec0294:
11854 spec->codec_variant = ALC269_TYPE_ALC294;
11855 spec->gen.mixer_nid = 0; /* ALC2x4 does not have any loopback mixer path */
11856 alc_update_coef_idx(codec, 0x6b, 0x0018, (1<<4) | (1<<3)); /* UAJ MIC Vref control by verb */
11857 spec->init_hook = alc294_init;
11858 break;
11859 case 0x10ec0300:
11860 spec->codec_variant = ALC269_TYPE_ALC300;
11861 spec->gen.mixer_nid = 0; /* no loopback on ALC300 */
11862 break;
11863 case 0x10ec0623:
11864 spec->codec_variant = ALC269_TYPE_ALC623;
11865 break;
11866 case 0x10ec0700:
11867 case 0x10ec0701:
11868 case 0x10ec0703:
11869 case 0x10ec0711:
11870 spec->codec_variant = ALC269_TYPE_ALC700;
11871 spec->gen.mixer_nid = 0; /* ALC700 does not have any loopback mixer path */
11872 alc_update_coef_idx(codec, 0x4a, 1 << 15, 0); /* Combo jack auto trigger control */
11873 spec->init_hook = alc294_init;
11874 break;
11875
11876 }
11877
11878 if (snd_hda_codec_read(codec, 0x51, 0, AC_VERB_PARAMETERS, 0) == 0x10ec5505) {
11879 spec->has_alc5505_dsp = 1;
11880 spec->init_hook = alc5505_dsp_init;
11881 }
11882
11883 alc_pre_init(codec);
11884
11885 snd_hda_pick_fixup(codec, alc269_fixup_models,
11886 alc269_fixup_tbl, alc269_fixups);
11887 /* FIXME: both TX300 and ROG Strix G17 have the same SSID, and
11888 * the quirk breaks the latter (bko#214101).
11889 * Clear the wrong entry.
11890 */
11891 if (codec->fixup_id == ALC282_FIXUP_ASUS_TX300 &&
11892 codec->core.vendor_id == 0x10ec0294) {
11893 codec_dbg(codec, "Clear wrong fixup for ASUS ROG Strix G17\n");
11894 codec->fixup_id = HDA_FIXUP_ID_NOT_SET;
11895 }
11896
11897 snd_hda_pick_pin_fixup(codec, alc269_pin_fixup_tbl, alc269_fixups, true);
11898 snd_hda_pick_pin_fixup(codec, alc269_fallback_pin_fixup_tbl, alc269_fixups, false);
11899 snd_hda_pick_fixup(codec, NULL, alc269_fixup_vendor_tbl,
11900 alc269_fixups);
11901
11902 /*
11903 * Check whether ACPI describes companion amplifiers that require
11904 * component binding
11905 */
11906 find_cirrus_companion_amps(codec);
11907
11908 snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE);
11909
11910 alc_auto_parse_customize_define(codec);
11911
11912 if (has_cdefine_beep(codec))
11913 spec->gen.beep_nid = 0x01;
11914
11915 /* automatic parse from the BIOS config */
11916 err = alc269_parse_auto_config(codec);
11917 if (err < 0)
11918 goto error;
11919
11920 if (!spec->gen.no_analog && spec->gen.beep_nid && spec->gen.mixer_nid) {
11921 err = set_beep_amp(spec, spec->gen.mixer_nid, 0x04, HDA_INPUT);
11922 if (err < 0)
11923 goto error;
11924 }
11925
11926 snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE);
11927
11928 return 0;
11929
11930 error:
11931 alc_free(codec);
11932 return err;
11933 }
11934
11935 /*
11936 * ALC861
11937 */
11938
alc861_parse_auto_config(struct hda_codec * codec)11939 static int alc861_parse_auto_config(struct hda_codec *codec)
11940 {
11941 static const hda_nid_t alc861_ignore[] = { 0x1d, 0 };
11942 static const hda_nid_t alc861_ssids[] = { 0x0e, 0x0f, 0x0b, 0 };
11943 return alc_parse_auto_config(codec, alc861_ignore, alc861_ssids);
11944 }
11945
11946 /* Pin config fixes */
11947 enum {
11948 ALC861_FIXUP_FSC_AMILO_PI1505,
11949 ALC861_FIXUP_AMP_VREF_0F,
11950 ALC861_FIXUP_NO_JACK_DETECT,
11951 ALC861_FIXUP_ASUS_A6RP,
11952 ALC660_FIXUP_ASUS_W7J,
11953 };
11954
11955 /* On some laptops, VREF of pin 0x0f is abused for controlling the main amp */
alc861_fixup_asus_amp_vref_0f(struct hda_codec * codec,const struct hda_fixup * fix,int action)11956 static void alc861_fixup_asus_amp_vref_0f(struct hda_codec *codec,
11957 const struct hda_fixup *fix, int action)
11958 {
11959 struct alc_spec *spec = codec->spec;
11960 unsigned int val;
11961
11962 if (action != HDA_FIXUP_ACT_INIT)
11963 return;
11964 val = snd_hda_codec_get_pin_target(codec, 0x0f);
11965 if (!(val & (AC_PINCTL_IN_EN | AC_PINCTL_OUT_EN)))
11966 val |= AC_PINCTL_IN_EN;
11967 val |= AC_PINCTL_VREF_50;
11968 snd_hda_set_pin_ctl(codec, 0x0f, val);
11969 spec->gen.keep_vref_in_automute = 1;
11970 }
11971
11972 /* suppress the jack-detection */
alc_fixup_no_jack_detect(struct hda_codec * codec,const struct hda_fixup * fix,int action)11973 static void alc_fixup_no_jack_detect(struct hda_codec *codec,
11974 const struct hda_fixup *fix, int action)
11975 {
11976 if (action == HDA_FIXUP_ACT_PRE_PROBE)
11977 codec->no_jack_detect = 1;
11978 }
11979
11980 static const struct hda_fixup alc861_fixups[] = {
11981 [ALC861_FIXUP_FSC_AMILO_PI1505] = {
11982 .type = HDA_FIXUP_PINS,
11983 .v.pins = (const struct hda_pintbl[]) {
11984 { 0x0b, 0x0221101f }, /* HP */
11985 { 0x0f, 0x90170310 }, /* speaker */
11986 { }
11987 }
11988 },
11989 [ALC861_FIXUP_AMP_VREF_0F] = {
11990 .type = HDA_FIXUP_FUNC,
11991 .v.func = alc861_fixup_asus_amp_vref_0f,
11992 },
11993 [ALC861_FIXUP_NO_JACK_DETECT] = {
11994 .type = HDA_FIXUP_FUNC,
11995 .v.func = alc_fixup_no_jack_detect,
11996 },
11997 [ALC861_FIXUP_ASUS_A6RP] = {
11998 .type = HDA_FIXUP_FUNC,
11999 .v.func = alc861_fixup_asus_amp_vref_0f,
12000 .chained = true,
12001 .chain_id = ALC861_FIXUP_NO_JACK_DETECT,
12002 },
12003 [ALC660_FIXUP_ASUS_W7J] = {
12004 .type = HDA_FIXUP_VERBS,
12005 .v.verbs = (const struct hda_verb[]) {
12006 /* ASUS W7J needs a magic pin setup on unused NID 0x10
12007 * for enabling outputs
12008 */
12009 {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
12010 { }
12011 },
12012 }
12013 };
12014
12015 static const struct snd_pci_quirk alc861_fixup_tbl[] = {
12016 SND_PCI_QUIRK(0x1043, 0x1253, "ASUS W7J", ALC660_FIXUP_ASUS_W7J),
12017 SND_PCI_QUIRK(0x1043, 0x1263, "ASUS Z35HL", ALC660_FIXUP_ASUS_W7J),
12018 SND_PCI_QUIRK(0x1043, 0x1393, "ASUS A6Rp", ALC861_FIXUP_ASUS_A6RP),
12019 SND_PCI_QUIRK_VENDOR(0x1043, "ASUS laptop", ALC861_FIXUP_AMP_VREF_0F),
12020 SND_PCI_QUIRK(0x1462, 0x7254, "HP DX2200", ALC861_FIXUP_NO_JACK_DETECT),
12021 SND_PCI_QUIRK_VENDOR(0x1584, "Haier/Uniwill", ALC861_FIXUP_AMP_VREF_0F),
12022 SND_PCI_QUIRK(0x1734, 0x10c7, "FSC Amilo Pi1505", ALC861_FIXUP_FSC_AMILO_PI1505),
12023 {}
12024 };
12025
12026 /*
12027 */
patch_alc861(struct hda_codec * codec)12028 static int patch_alc861(struct hda_codec *codec)
12029 {
12030 struct alc_spec *spec;
12031 int err;
12032
12033 err = alc_alloc_spec(codec, 0x15);
12034 if (err < 0)
12035 return err;
12036
12037 spec = codec->spec;
12038 if (has_cdefine_beep(codec))
12039 spec->gen.beep_nid = 0x23;
12040
12041 spec->power_hook = alc_power_eapd;
12042
12043 alc_pre_init(codec);
12044
12045 snd_hda_pick_fixup(codec, NULL, alc861_fixup_tbl, alc861_fixups);
12046 snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE);
12047
12048 /* automatic parse from the BIOS config */
12049 err = alc861_parse_auto_config(codec);
12050 if (err < 0)
12051 goto error;
12052
12053 if (!spec->gen.no_analog) {
12054 err = set_beep_amp(spec, 0x23, 0, HDA_OUTPUT);
12055 if (err < 0)
12056 goto error;
12057 }
12058
12059 snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE);
12060
12061 return 0;
12062
12063 error:
12064 alc_free(codec);
12065 return err;
12066 }
12067
12068 /*
12069 * ALC861-VD support
12070 *
12071 * Based on ALC882
12072 *
12073 * In addition, an independent DAC
12074 */
alc861vd_parse_auto_config(struct hda_codec * codec)12075 static int alc861vd_parse_auto_config(struct hda_codec *codec)
12076 {
12077 static const hda_nid_t alc861vd_ignore[] = { 0x1d, 0 };
12078 static const hda_nid_t alc861vd_ssids[] = { 0x15, 0x1b, 0x14, 0 };
12079 return alc_parse_auto_config(codec, alc861vd_ignore, alc861vd_ssids);
12080 }
12081
12082 enum {
12083 ALC660VD_FIX_ASUS_GPIO1,
12084 ALC861VD_FIX_DALLAS,
12085 };
12086
12087 /* exclude VREF80 */
alc861vd_fixup_dallas(struct hda_codec * codec,const struct hda_fixup * fix,int action)12088 static void alc861vd_fixup_dallas(struct hda_codec *codec,
12089 const struct hda_fixup *fix, int action)
12090 {
12091 if (action == HDA_FIXUP_ACT_PRE_PROBE) {
12092 snd_hda_override_pin_caps(codec, 0x18, 0x00000734);
12093 snd_hda_override_pin_caps(codec, 0x19, 0x0000073c);
12094 }
12095 }
12096
12097 /* reset GPIO1 */
alc660vd_fixup_asus_gpio1(struct hda_codec * codec,const struct hda_fixup * fix,int action)12098 static void alc660vd_fixup_asus_gpio1(struct hda_codec *codec,
12099 const struct hda_fixup *fix, int action)
12100 {
12101 struct alc_spec *spec = codec->spec;
12102
12103 if (action == HDA_FIXUP_ACT_PRE_PROBE)
12104 spec->gpio_mask |= 0x02;
12105 alc_fixup_gpio(codec, action, 0x01);
12106 }
12107
12108 static const struct hda_fixup alc861vd_fixups[] = {
12109 [ALC660VD_FIX_ASUS_GPIO1] = {
12110 .type = HDA_FIXUP_FUNC,
12111 .v.func = alc660vd_fixup_asus_gpio1,
12112 },
12113 [ALC861VD_FIX_DALLAS] = {
12114 .type = HDA_FIXUP_FUNC,
12115 .v.func = alc861vd_fixup_dallas,
12116 },
12117 };
12118
12119 static const struct snd_pci_quirk alc861vd_fixup_tbl[] = {
12120 SND_PCI_QUIRK(0x103c, 0x30bf, "HP TX1000", ALC861VD_FIX_DALLAS),
12121 SND_PCI_QUIRK(0x1043, 0x1339, "ASUS A7-K", ALC660VD_FIX_ASUS_GPIO1),
12122 SND_PCI_QUIRK(0x1179, 0xff31, "Toshiba L30-149", ALC861VD_FIX_DALLAS),
12123 {}
12124 };
12125
12126 /*
12127 */
patch_alc861vd(struct hda_codec * codec)12128 static int patch_alc861vd(struct hda_codec *codec)
12129 {
12130 struct alc_spec *spec;
12131 int err;
12132
12133 err = alc_alloc_spec(codec, 0x0b);
12134 if (err < 0)
12135 return err;
12136
12137 spec = codec->spec;
12138 if (has_cdefine_beep(codec))
12139 spec->gen.beep_nid = 0x23;
12140
12141 spec->shutup = alc_eapd_shutup;
12142
12143 alc_pre_init(codec);
12144
12145 snd_hda_pick_fixup(codec, NULL, alc861vd_fixup_tbl, alc861vd_fixups);
12146 snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE);
12147
12148 /* automatic parse from the BIOS config */
12149 err = alc861vd_parse_auto_config(codec);
12150 if (err < 0)
12151 goto error;
12152
12153 if (!spec->gen.no_analog) {
12154 err = set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
12155 if (err < 0)
12156 goto error;
12157 }
12158
12159 snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE);
12160
12161 return 0;
12162
12163 error:
12164 alc_free(codec);
12165 return err;
12166 }
12167
12168 /*
12169 * ALC662 support
12170 *
12171 * ALC662 is almost identical with ALC880 but has cleaner and more flexible
12172 * configuration. Each pin widget can choose any input DACs and a mixer.
12173 * Each ADC is connected from a mixer of all inputs. This makes possible
12174 * 6-channel independent captures.
12175 *
12176 * In addition, an independent DAC for the multi-playback (not used in this
12177 * driver yet).
12178 */
12179
12180 /*
12181 * BIOS auto configuration
12182 */
12183
alc662_parse_auto_config(struct hda_codec * codec)12184 static int alc662_parse_auto_config(struct hda_codec *codec)
12185 {
12186 static const hda_nid_t alc662_ignore[] = { 0x1d, 0 };
12187 static const hda_nid_t alc663_ssids[] = { 0x15, 0x1b, 0x14, 0x21 };
12188 static const hda_nid_t alc662_ssids[] = { 0x15, 0x1b, 0x14, 0 };
12189 const hda_nid_t *ssids;
12190
12191 if (codec->core.vendor_id == 0x10ec0272 || codec->core.vendor_id == 0x10ec0663 ||
12192 codec->core.vendor_id == 0x10ec0665 || codec->core.vendor_id == 0x10ec0670 ||
12193 codec->core.vendor_id == 0x10ec0671)
12194 ssids = alc663_ssids;
12195 else
12196 ssids = alc662_ssids;
12197 return alc_parse_auto_config(codec, alc662_ignore, ssids);
12198 }
12199
alc272_fixup_mario(struct hda_codec * codec,const struct hda_fixup * fix,int action)12200 static void alc272_fixup_mario(struct hda_codec *codec,
12201 const struct hda_fixup *fix, int action)
12202 {
12203 if (action != HDA_FIXUP_ACT_PRE_PROBE)
12204 return;
12205 if (snd_hda_override_amp_caps(codec, 0x2, HDA_OUTPUT,
12206 (0x3b << AC_AMPCAP_OFFSET_SHIFT) |
12207 (0x3b << AC_AMPCAP_NUM_STEPS_SHIFT) |
12208 (0x03 << AC_AMPCAP_STEP_SIZE_SHIFT) |
12209 (0 << AC_AMPCAP_MUTE_SHIFT)))
12210 codec_warn(codec, "failed to override amp caps for NID 0x2\n");
12211 }
12212
12213 static const struct snd_pcm_chmap_elem asus_pcm_2_1_chmaps[] = {
12214 { .channels = 2,
12215 .map = { SNDRV_CHMAP_FL, SNDRV_CHMAP_FR } },
12216 { .channels = 4,
12217 .map = { SNDRV_CHMAP_FL, SNDRV_CHMAP_FR,
12218 SNDRV_CHMAP_NA, SNDRV_CHMAP_LFE } }, /* LFE only on right */
12219 { }
12220 };
12221
12222 /* override the 2.1 chmap */
alc_fixup_bass_chmap(struct hda_codec * codec,const struct hda_fixup * fix,int action)12223 static void alc_fixup_bass_chmap(struct hda_codec *codec,
12224 const struct hda_fixup *fix, int action)
12225 {
12226 if (action == HDA_FIXUP_ACT_BUILD) {
12227 struct alc_spec *spec = codec->spec;
12228 spec->gen.pcm_rec[0]->stream[0].chmap = asus_pcm_2_1_chmaps;
12229 }
12230 }
12231
12232 /* avoid D3 for keeping GPIO up */
gpio_led_power_filter(struct hda_codec * codec,hda_nid_t nid,unsigned int power_state)12233 static unsigned int gpio_led_power_filter(struct hda_codec *codec,
12234 hda_nid_t nid,
12235 unsigned int power_state)
12236 {
12237 struct alc_spec *spec = codec->spec;
12238 if (nid == codec->core.afg && power_state == AC_PWRST_D3 && spec->gpio_data)
12239 return AC_PWRST_D0;
12240 return power_state;
12241 }
12242
alc662_fixup_led_gpio1(struct hda_codec * codec,const struct hda_fixup * fix,int action)12243 static void alc662_fixup_led_gpio1(struct hda_codec *codec,
12244 const struct hda_fixup *fix, int action)
12245 {
12246 struct alc_spec *spec = codec->spec;
12247
12248 alc_fixup_hp_gpio_led(codec, action, 0x01, 0);
12249 if (action == HDA_FIXUP_ACT_PRE_PROBE) {
12250 spec->mute_led_polarity = 1;
12251 codec->power_filter = gpio_led_power_filter;
12252 }
12253 }
12254
alc662_usi_automute_hook(struct hda_codec * codec,struct hda_jack_callback * jack)12255 static void alc662_usi_automute_hook(struct hda_codec *codec,
12256 struct hda_jack_callback *jack)
12257 {
12258 struct alc_spec *spec = codec->spec;
12259 int vref;
12260 msleep(200);
12261 snd_hda_gen_hp_automute(codec, jack);
12262
12263 vref = spec->gen.hp_jack_present ? PIN_VREF80 : 0;
12264 msleep(100);
12265 snd_hda_codec_write(codec, 0x19, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
12266 vref);
12267 }
12268
alc662_fixup_usi_headset_mic(struct hda_codec * codec,const struct hda_fixup * fix,int action)12269 static void alc662_fixup_usi_headset_mic(struct hda_codec *codec,
12270 const struct hda_fixup *fix, int action)
12271 {
12272 struct alc_spec *spec = codec->spec;
12273 if (action == HDA_FIXUP_ACT_PRE_PROBE) {
12274 spec->parse_flags |= HDA_PINCFG_HEADSET_MIC;
12275 spec->gen.hp_automute_hook = alc662_usi_automute_hook;
12276 }
12277 }
12278
alc662_aspire_ethos_mute_speakers(struct hda_codec * codec,struct hda_jack_callback * cb)12279 static void alc662_aspire_ethos_mute_speakers(struct hda_codec *codec,
12280 struct hda_jack_callback *cb)
12281 {
12282 /* surround speakers at 0x1b already get muted automatically when
12283 * headphones are plugged in, but we have to mute/unmute the remaining
12284 * channels manually:
12285 * 0x15 - front left/front right
12286 * 0x18 - front center/ LFE
12287 */
12288 if (snd_hda_jack_detect_state(codec, 0x1b) == HDA_JACK_PRESENT) {
12289 snd_hda_set_pin_ctl_cache(codec, 0x15, 0);
12290 snd_hda_set_pin_ctl_cache(codec, 0x18, 0);
12291 } else {
12292 snd_hda_set_pin_ctl_cache(codec, 0x15, PIN_OUT);
12293 snd_hda_set_pin_ctl_cache(codec, 0x18, PIN_OUT);
12294 }
12295 }
12296
alc662_fixup_aspire_ethos_hp(struct hda_codec * codec,const struct hda_fixup * fix,int action)12297 static void alc662_fixup_aspire_ethos_hp(struct hda_codec *codec,
12298 const struct hda_fixup *fix, int action)
12299 {
12300 /* Pin 0x1b: shared headphones jack and surround speakers */
12301 if (!is_jack_detectable(codec, 0x1b))
12302 return;
12303
12304 switch (action) {
12305 case HDA_FIXUP_ACT_PRE_PROBE:
12306 snd_hda_jack_detect_enable_callback(codec, 0x1b,
12307 alc662_aspire_ethos_mute_speakers);
12308 /* subwoofer needs an extra GPIO setting to become audible */
12309 alc_setup_gpio(codec, 0x02);
12310 break;
12311 case HDA_FIXUP_ACT_INIT:
12312 /* Make sure to start in a correct state, i.e. if
12313 * headphones have been plugged in before powering up the system
12314 */
12315 alc662_aspire_ethos_mute_speakers(codec, NULL);
12316 break;
12317 }
12318 }
12319
alc671_fixup_hp_headset_mic2(struct hda_codec * codec,const struct hda_fixup * fix,int action)12320 static void alc671_fixup_hp_headset_mic2(struct hda_codec *codec,
12321 const struct hda_fixup *fix, int action)
12322 {
12323 struct alc_spec *spec = codec->spec;
12324
12325 static const struct hda_pintbl pincfgs[] = {
12326 { 0x19, 0x02a11040 }, /* use as headset mic, with its own jack detect */
12327 { 0x1b, 0x0181304f },
12328 { }
12329 };
12330
12331 switch (action) {
12332 case HDA_FIXUP_ACT_PRE_PROBE:
12333 spec->gen.mixer_nid = 0;
12334 spec->parse_flags |= HDA_PINCFG_HEADSET_MIC;
12335 snd_hda_apply_pincfgs(codec, pincfgs);
12336 break;
12337 case HDA_FIXUP_ACT_INIT:
12338 alc_write_coef_idx(codec, 0x19, 0xa054);
12339 break;
12340 }
12341 }
12342
alc897_hp_automute_hook(struct hda_codec * codec,struct hda_jack_callback * jack)12343 static void alc897_hp_automute_hook(struct hda_codec *codec,
12344 struct hda_jack_callback *jack)
12345 {
12346 struct alc_spec *spec = codec->spec;
12347 int vref;
12348
12349 snd_hda_gen_hp_automute(codec, jack);
12350 vref = spec->gen.hp_jack_present ? (PIN_HP | AC_PINCTL_VREF_100) : PIN_HP;
12351 snd_hda_set_pin_ctl(codec, 0x1b, vref);
12352 }
12353
alc897_fixup_lenovo_headset_mic(struct hda_codec * codec,const struct hda_fixup * fix,int action)12354 static void alc897_fixup_lenovo_headset_mic(struct hda_codec *codec,
12355 const struct hda_fixup *fix, int action)
12356 {
12357 struct alc_spec *spec = codec->spec;
12358 if (action == HDA_FIXUP_ACT_PRE_PROBE) {
12359 spec->gen.hp_automute_hook = alc897_hp_automute_hook;
12360 spec->no_shutup_pins = 1;
12361 }
12362 if (action == HDA_FIXUP_ACT_PROBE) {
12363 snd_hda_set_pin_ctl_cache(codec, 0x1a, PIN_IN | AC_PINCTL_VREF_100);
12364 }
12365 }
12366
alc897_fixup_lenovo_headset_mode(struct hda_codec * codec,const struct hda_fixup * fix,int action)12367 static void alc897_fixup_lenovo_headset_mode(struct hda_codec *codec,
12368 const struct hda_fixup *fix, int action)
12369 {
12370 struct alc_spec *spec = codec->spec;
12371
12372 if (action == HDA_FIXUP_ACT_PRE_PROBE) {
12373 spec->parse_flags |= HDA_PINCFG_HEADSET_MIC;
12374 spec->gen.hp_automute_hook = alc897_hp_automute_hook;
12375 }
12376 }
12377
12378 static const struct coef_fw alc668_coefs[] = {
12379 WRITE_COEF(0x01, 0xbebe), WRITE_COEF(0x02, 0xaaaa), WRITE_COEF(0x03, 0x0),
12380 WRITE_COEF(0x04, 0x0180), WRITE_COEF(0x06, 0x0), WRITE_COEF(0x07, 0x0f80),
12381 WRITE_COEF(0x08, 0x0031), WRITE_COEF(0x0a, 0x0060), WRITE_COEF(0x0b, 0x0),
12382 WRITE_COEF(0x0c, 0x7cf7), WRITE_COEF(0x0d, 0x1080), WRITE_COEF(0x0e, 0x7f7f),
12383 WRITE_COEF(0x0f, 0xcccc), WRITE_COEF(0x10, 0xddcc), WRITE_COEF(0x11, 0x0001),
12384 WRITE_COEF(0x13, 0x0), WRITE_COEF(0x14, 0x2aa0), WRITE_COEF(0x17, 0xa940),
12385 WRITE_COEF(0x19, 0x0), WRITE_COEF(0x1a, 0x0), WRITE_COEF(0x1b, 0x0),
12386 WRITE_COEF(0x1c, 0x0), WRITE_COEF(0x1d, 0x0), WRITE_COEF(0x1e, 0x7418),
12387 WRITE_COEF(0x1f, 0x0804), WRITE_COEF(0x20, 0x4200), WRITE_COEF(0x21, 0x0468),
12388 WRITE_COEF(0x22, 0x8ccc), WRITE_COEF(0x23, 0x0250), WRITE_COEF(0x24, 0x7418),
12389 WRITE_COEF(0x27, 0x0), WRITE_COEF(0x28, 0x8ccc), WRITE_COEF(0x2a, 0xff00),
12390 WRITE_COEF(0x2b, 0x8000), WRITE_COEF(0xa7, 0xff00), WRITE_COEF(0xa8, 0x8000),
12391 WRITE_COEF(0xaa, 0x2e17), WRITE_COEF(0xab, 0xa0c0), WRITE_COEF(0xac, 0x0),
12392 WRITE_COEF(0xad, 0x0), WRITE_COEF(0xae, 0x2ac6), WRITE_COEF(0xaf, 0xa480),
12393 WRITE_COEF(0xb0, 0x0), WRITE_COEF(0xb1, 0x0), WRITE_COEF(0xb2, 0x0),
12394 WRITE_COEF(0xb3, 0x0), WRITE_COEF(0xb4, 0x0), WRITE_COEF(0xb5, 0x1040),
12395 WRITE_COEF(0xb6, 0xd697), WRITE_COEF(0xb7, 0x902b), WRITE_COEF(0xb8, 0xd697),
12396 WRITE_COEF(0xb9, 0x902b), WRITE_COEF(0xba, 0xb8ba), WRITE_COEF(0xbb, 0xaaab),
12397 WRITE_COEF(0xbc, 0xaaaf), WRITE_COEF(0xbd, 0x6aaa), WRITE_COEF(0xbe, 0x1c02),
12398 WRITE_COEF(0xc0, 0x00ff), WRITE_COEF(0xc1, 0x0fa6),
12399 {}
12400 };
12401
alc668_restore_default_value(struct hda_codec * codec)12402 static void alc668_restore_default_value(struct hda_codec *codec)
12403 {
12404 alc_process_coef_fw(codec, alc668_coefs);
12405 }
12406
12407 enum {
12408 ALC662_FIXUP_ASPIRE,
12409 ALC662_FIXUP_LED_GPIO1,
12410 ALC662_FIXUP_IDEAPAD,
12411 ALC272_FIXUP_MARIO,
12412 ALC662_FIXUP_CZC_ET26,
12413 ALC662_FIXUP_CZC_P10T,
12414 ALC662_FIXUP_SKU_IGNORE,
12415 ALC662_FIXUP_HP_RP5800,
12416 ALC662_FIXUP_ASUS_MODE1,
12417 ALC662_FIXUP_ASUS_MODE2,
12418 ALC662_FIXUP_ASUS_MODE3,
12419 ALC662_FIXUP_ASUS_MODE4,
12420 ALC662_FIXUP_ASUS_MODE5,
12421 ALC662_FIXUP_ASUS_MODE6,
12422 ALC662_FIXUP_ASUS_MODE7,
12423 ALC662_FIXUP_ASUS_MODE8,
12424 ALC662_FIXUP_NO_JACK_DETECT,
12425 ALC662_FIXUP_ZOTAC_Z68,
12426 ALC662_FIXUP_INV_DMIC,
12427 ALC662_FIXUP_DELL_MIC_NO_PRESENCE,
12428 ALC668_FIXUP_DELL_MIC_NO_PRESENCE,
12429 ALC662_FIXUP_HEADSET_MODE,
12430 ALC668_FIXUP_HEADSET_MODE,
12431 ALC662_FIXUP_BASS_MODE4_CHMAP,
12432 ALC662_FIXUP_BASS_16,
12433 ALC662_FIXUP_BASS_1A,
12434 ALC662_FIXUP_BASS_CHMAP,
12435 ALC668_FIXUP_AUTO_MUTE,
12436 ALC668_FIXUP_DELL_DISABLE_AAMIX,
12437 ALC668_FIXUP_DELL_XPS13,
12438 ALC662_FIXUP_ASUS_Nx50,
12439 ALC668_FIXUP_ASUS_Nx51_HEADSET_MODE,
12440 ALC668_FIXUP_ASUS_Nx51,
12441 ALC668_FIXUP_MIC_COEF,
12442 ALC668_FIXUP_ASUS_G751,
12443 ALC891_FIXUP_HEADSET_MODE,
12444 ALC891_FIXUP_DELL_MIC_NO_PRESENCE,
12445 ALC662_FIXUP_ACER_VERITON,
12446 ALC892_FIXUP_ASROCK_MOBO,
12447 ALC662_FIXUP_USI_FUNC,
12448 ALC662_FIXUP_USI_HEADSET_MODE,
12449 ALC662_FIXUP_LENOVO_MULTI_CODECS,
12450 ALC669_FIXUP_ACER_ASPIRE_ETHOS,
12451 ALC669_FIXUP_ACER_ASPIRE_ETHOS_HEADSET,
12452 ALC671_FIXUP_HP_HEADSET_MIC2,
12453 ALC662_FIXUP_ACER_X2660G_HEADSET_MODE,
12454 ALC662_FIXUP_ACER_NITRO_HEADSET_MODE,
12455 ALC668_FIXUP_ASUS_NO_HEADSET_MIC,
12456 ALC668_FIXUP_HEADSET_MIC,
12457 ALC668_FIXUP_MIC_DET_COEF,
12458 ALC897_FIXUP_LENOVO_HEADSET_MIC,
12459 ALC897_FIXUP_HEADSET_MIC_PIN,
12460 ALC897_FIXUP_HP_HSMIC_VERB,
12461 ALC897_FIXUP_LENOVO_HEADSET_MODE,
12462 ALC897_FIXUP_HEADSET_MIC_PIN2,
12463 ALC897_FIXUP_UNIS_H3C_X500S,
12464 ALC897_FIXUP_HEADSET_MIC_PIN3,
12465 };
12466
12467 static const struct hda_fixup alc662_fixups[] = {
12468 [ALC662_FIXUP_ASPIRE] = {
12469 .type = HDA_FIXUP_PINS,
12470 .v.pins = (const struct hda_pintbl[]) {
12471 { 0x15, 0x99130112 }, /* subwoofer */
12472 { }
12473 }
12474 },
12475 [ALC662_FIXUP_LED_GPIO1] = {
12476 .type = HDA_FIXUP_FUNC,
12477 .v.func = alc662_fixup_led_gpio1,
12478 },
12479 [ALC662_FIXUP_IDEAPAD] = {
12480 .type = HDA_FIXUP_PINS,
12481 .v.pins = (const struct hda_pintbl[]) {
12482 { 0x17, 0x99130112 }, /* subwoofer */
12483 { }
12484 },
12485 .chained = true,
12486 .chain_id = ALC662_FIXUP_LED_GPIO1,
12487 },
12488 [ALC272_FIXUP_MARIO] = {
12489 .type = HDA_FIXUP_FUNC,
12490 .v.func = alc272_fixup_mario,
12491 },
12492 [ALC662_FIXUP_CZC_ET26] = {
12493 .type = HDA_FIXUP_PINS,
12494 .v.pins = (const struct hda_pintbl[]) {
12495 {0x12, 0x403cc000},
12496 {0x14, 0x90170110}, /* speaker */
12497 {0x15, 0x411111f0},
12498 {0x16, 0x411111f0},
12499 {0x18, 0x01a19030}, /* mic */
12500 {0x19, 0x90a7013f}, /* int-mic */
12501 {0x1a, 0x01014020},
12502 {0x1b, 0x0121401f},
12503 {0x1c, 0x411111f0},
12504 {0x1d, 0x411111f0},
12505 {0x1e, 0x40478e35},
12506 {}
12507 },
12508 .chained = true,
12509 .chain_id = ALC662_FIXUP_SKU_IGNORE
12510 },
12511 [ALC662_FIXUP_CZC_P10T] = {
12512 .type = HDA_FIXUP_VERBS,
12513 .v.verbs = (const struct hda_verb[]) {
12514 {0x14, AC_VERB_SET_EAPD_BTLENABLE, 0},
12515 {}
12516 }
12517 },
12518 [ALC662_FIXUP_SKU_IGNORE] = {
12519 .type = HDA_FIXUP_FUNC,
12520 .v.func = alc_fixup_sku_ignore,
12521 },
12522 [ALC662_FIXUP_HP_RP5800] = {
12523 .type = HDA_FIXUP_PINS,
12524 .v.pins = (const struct hda_pintbl[]) {
12525 { 0x14, 0x0221201f }, /* HP out */
12526 { }
12527 },
12528 .chained = true,
12529 .chain_id = ALC662_FIXUP_SKU_IGNORE
12530 },
12531 [ALC662_FIXUP_ASUS_MODE1] = {
12532 .type = HDA_FIXUP_PINS,
12533 .v.pins = (const struct hda_pintbl[]) {
12534 { 0x14, 0x99130110 }, /* speaker */
12535 { 0x18, 0x01a19c20 }, /* mic */
12536 { 0x19, 0x99a3092f }, /* int-mic */
12537 { 0x21, 0x0121401f }, /* HP out */
12538 { }
12539 },
12540 .chained = true,
12541 .chain_id = ALC662_FIXUP_SKU_IGNORE
12542 },
12543 [ALC662_FIXUP_ASUS_MODE2] = {
12544 .type = HDA_FIXUP_PINS,
12545 .v.pins = (const struct hda_pintbl[]) {
12546 { 0x14, 0x99130110 }, /* speaker */
12547 { 0x18, 0x01a19820 }, /* mic */
12548 { 0x19, 0x99a3092f }, /* int-mic */
12549 { 0x1b, 0x0121401f }, /* HP out */
12550 { }
12551 },
12552 .chained = true,
12553 .chain_id = ALC662_FIXUP_SKU_IGNORE
12554 },
12555 [ALC662_FIXUP_ASUS_MODE3] = {
12556 .type = HDA_FIXUP_PINS,
12557 .v.pins = (const struct hda_pintbl[]) {
12558 { 0x14, 0x99130110 }, /* speaker */
12559 { 0x15, 0x0121441f }, /* HP */
12560 { 0x18, 0x01a19840 }, /* mic */
12561 { 0x19, 0x99a3094f }, /* int-mic */
12562 { 0x21, 0x01211420 }, /* HP2 */
12563 { }
12564 },
12565 .chained = true,
12566 .chain_id = ALC662_FIXUP_SKU_IGNORE
12567 },
12568 [ALC662_FIXUP_ASUS_MODE4] = {
12569 .type = HDA_FIXUP_PINS,
12570 .v.pins = (const struct hda_pintbl[]) {
12571 { 0x14, 0x99130110 }, /* speaker */
12572 { 0x16, 0x99130111 }, /* speaker */
12573 { 0x18, 0x01a19840 }, /* mic */
12574 { 0x19, 0x99a3094f }, /* int-mic */
12575 { 0x21, 0x0121441f }, /* HP */
12576 { }
12577 },
12578 .chained = true,
12579 .chain_id = ALC662_FIXUP_SKU_IGNORE
12580 },
12581 [ALC662_FIXUP_ASUS_MODE5] = {
12582 .type = HDA_FIXUP_PINS,
12583 .v.pins = (const struct hda_pintbl[]) {
12584 { 0x14, 0x99130110 }, /* speaker */
12585 { 0x15, 0x0121441f }, /* HP */
12586 { 0x16, 0x99130111 }, /* speaker */
12587 { 0x18, 0x01a19840 }, /* mic */
12588 { 0x19, 0x99a3094f }, /* int-mic */
12589 { }
12590 },
12591 .chained = true,
12592 .chain_id = ALC662_FIXUP_SKU_IGNORE
12593 },
12594 [ALC662_FIXUP_ASUS_MODE6] = {
12595 .type = HDA_FIXUP_PINS,
12596 .v.pins = (const struct hda_pintbl[]) {
12597 { 0x14, 0x99130110 }, /* speaker */
12598 { 0x15, 0x01211420 }, /* HP2 */
12599 { 0x18, 0x01a19840 }, /* mic */
12600 { 0x19, 0x99a3094f }, /* int-mic */
12601 { 0x1b, 0x0121441f }, /* HP */
12602 { }
12603 },
12604 .chained = true,
12605 .chain_id = ALC662_FIXUP_SKU_IGNORE
12606 },
12607 [ALC662_FIXUP_ASUS_MODE7] = {
12608 .type = HDA_FIXUP_PINS,
12609 .v.pins = (const struct hda_pintbl[]) {
12610 { 0x14, 0x99130110 }, /* speaker */
12611 { 0x17, 0x99130111 }, /* speaker */
12612 { 0x18, 0x01a19840 }, /* mic */
12613 { 0x19, 0x99a3094f }, /* int-mic */
12614 { 0x1b, 0x01214020 }, /* HP */
12615 { 0x21, 0x0121401f }, /* HP */
12616 { }
12617 },
12618 .chained = true,
12619 .chain_id = ALC662_FIXUP_SKU_IGNORE
12620 },
12621 [ALC662_FIXUP_ASUS_MODE8] = {
12622 .type = HDA_FIXUP_PINS,
12623 .v.pins = (const struct hda_pintbl[]) {
12624 { 0x14, 0x99130110 }, /* speaker */
12625 { 0x12, 0x99a30970 }, /* int-mic */
12626 { 0x15, 0x01214020 }, /* HP */
12627 { 0x17, 0x99130111 }, /* speaker */
12628 { 0x18, 0x01a19840 }, /* mic */
12629 { 0x21, 0x0121401f }, /* HP */
12630 { }
12631 },
12632 .chained = true,
12633 .chain_id = ALC662_FIXUP_SKU_IGNORE
12634 },
12635 [ALC662_FIXUP_NO_JACK_DETECT] = {
12636 .type = HDA_FIXUP_FUNC,
12637 .v.func = alc_fixup_no_jack_detect,
12638 },
12639 [ALC662_FIXUP_ZOTAC_Z68] = {
12640 .type = HDA_FIXUP_PINS,
12641 .v.pins = (const struct hda_pintbl[]) {
12642 { 0x1b, 0x02214020 }, /* Front HP */
12643 { }
12644 }
12645 },
12646 [ALC662_FIXUP_INV_DMIC] = {
12647 .type = HDA_FIXUP_FUNC,
12648 .v.func = alc_fixup_inv_dmic,
12649 },
12650 [ALC668_FIXUP_DELL_XPS13] = {
12651 .type = HDA_FIXUP_FUNC,
12652 .v.func = alc_fixup_dell_xps13,
12653 .chained = true,
12654 .chain_id = ALC668_FIXUP_DELL_DISABLE_AAMIX
12655 },
12656 [ALC668_FIXUP_DELL_DISABLE_AAMIX] = {
12657 .type = HDA_FIXUP_FUNC,
12658 .v.func = alc_fixup_disable_aamix,
12659 .chained = true,
12660 .chain_id = ALC668_FIXUP_DELL_MIC_NO_PRESENCE
12661 },
12662 [ALC668_FIXUP_AUTO_MUTE] = {
12663 .type = HDA_FIXUP_FUNC,
12664 .v.func = alc_fixup_auto_mute_via_amp,
12665 .chained = true,
12666 .chain_id = ALC668_FIXUP_DELL_MIC_NO_PRESENCE
12667 },
12668 [ALC662_FIXUP_DELL_MIC_NO_PRESENCE] = {
12669 .type = HDA_FIXUP_PINS,
12670 .v.pins = (const struct hda_pintbl[]) {
12671 { 0x19, 0x03a1113c }, /* use as headset mic, without its own jack detect */
12672 /* headphone mic by setting pin control of 0x1b (headphone out) to in + vref_50 */
12673 { }
12674 },
12675 .chained = true,
12676 .chain_id = ALC662_FIXUP_HEADSET_MODE
12677 },
12678 [ALC662_FIXUP_HEADSET_MODE] = {
12679 .type = HDA_FIXUP_FUNC,
12680 .v.func = alc_fixup_headset_mode_alc662,
12681 },
12682 [ALC668_FIXUP_DELL_MIC_NO_PRESENCE] = {
12683 .type = HDA_FIXUP_PINS,
12684 .v.pins = (const struct hda_pintbl[]) {
12685 { 0x19, 0x03a1913d }, /* use as headphone mic, without its own jack detect */
12686 { 0x1b, 0x03a1113c }, /* use as headset mic, without its own jack detect */
12687 { }
12688 },
12689 .chained = true,
12690 .chain_id = ALC668_FIXUP_HEADSET_MODE
12691 },
12692 [ALC668_FIXUP_HEADSET_MODE] = {
12693 .type = HDA_FIXUP_FUNC,
12694 .v.func = alc_fixup_headset_mode_alc668,
12695 },
12696 [ALC662_FIXUP_BASS_MODE4_CHMAP] = {
12697 .type = HDA_FIXUP_FUNC,
12698 .v.func = alc_fixup_bass_chmap,
12699 .chained = true,
12700 .chain_id = ALC662_FIXUP_ASUS_MODE4
12701 },
12702 [ALC662_FIXUP_BASS_16] = {
12703 .type = HDA_FIXUP_PINS,
12704 .v.pins = (const struct hda_pintbl[]) {
12705 {0x16, 0x80106111}, /* bass speaker */
12706 {}
12707 },
12708 .chained = true,
12709 .chain_id = ALC662_FIXUP_BASS_CHMAP,
12710 },
12711 [ALC662_FIXUP_BASS_1A] = {
12712 .type = HDA_FIXUP_PINS,
12713 .v.pins = (const struct hda_pintbl[]) {
12714 {0x1a, 0x80106111}, /* bass speaker */
12715 {}
12716 },
12717 .chained = true,
12718 .chain_id = ALC662_FIXUP_BASS_CHMAP,
12719 },
12720 [ALC662_FIXUP_BASS_CHMAP] = {
12721 .type = HDA_FIXUP_FUNC,
12722 .v.func = alc_fixup_bass_chmap,
12723 },
12724 [ALC662_FIXUP_ASUS_Nx50] = {
12725 .type = HDA_FIXUP_FUNC,
12726 .v.func = alc_fixup_auto_mute_via_amp,
12727 .chained = true,
12728 .chain_id = ALC662_FIXUP_BASS_1A
12729 },
12730 [ALC668_FIXUP_ASUS_Nx51_HEADSET_MODE] = {
12731 .type = HDA_FIXUP_FUNC,
12732 .v.func = alc_fixup_headset_mode_alc668,
12733 .chain_id = ALC662_FIXUP_BASS_CHMAP
12734 },
12735 [ALC668_FIXUP_ASUS_Nx51] = {
12736 .type = HDA_FIXUP_PINS,
12737 .v.pins = (const struct hda_pintbl[]) {
12738 { 0x19, 0x03a1913d }, /* use as headphone mic, without its own jack detect */
12739 { 0x1a, 0x90170151 }, /* bass speaker */
12740 { 0x1b, 0x03a1113c }, /* use as headset mic, without its own jack detect */
12741 {}
12742 },
12743 .chained = true,
12744 .chain_id = ALC668_FIXUP_ASUS_Nx51_HEADSET_MODE,
12745 },
12746 [ALC668_FIXUP_MIC_COEF] = {
12747 .type = HDA_FIXUP_VERBS,
12748 .v.verbs = (const struct hda_verb[]) {
12749 { 0x20, AC_VERB_SET_COEF_INDEX, 0xc3 },
12750 { 0x20, AC_VERB_SET_PROC_COEF, 0x4000 },
12751 {}
12752 },
12753 },
12754 [ALC668_FIXUP_ASUS_G751] = {
12755 .type = HDA_FIXUP_PINS,
12756 .v.pins = (const struct hda_pintbl[]) {
12757 { 0x16, 0x0421101f }, /* HP */
12758 {}
12759 },
12760 .chained = true,
12761 .chain_id = ALC668_FIXUP_MIC_COEF
12762 },
12763 [ALC891_FIXUP_HEADSET_MODE] = {
12764 .type = HDA_FIXUP_FUNC,
12765 .v.func = alc_fixup_headset_mode,
12766 },
12767 [ALC891_FIXUP_DELL_MIC_NO_PRESENCE] = {
12768 .type = HDA_FIXUP_PINS,
12769 .v.pins = (const struct hda_pintbl[]) {
12770 { 0x19, 0x03a1913d }, /* use as headphone mic, without its own jack detect */
12771 { 0x1b, 0x03a1113c }, /* use as headset mic, without its own jack detect */
12772 { }
12773 },
12774 .chained = true,
12775 .chain_id = ALC891_FIXUP_HEADSET_MODE
12776 },
12777 [ALC662_FIXUP_ACER_VERITON] = {
12778 .type = HDA_FIXUP_PINS,
12779 .v.pins = (const struct hda_pintbl[]) {
12780 { 0x15, 0x50170120 }, /* no internal speaker */
12781 { }
12782 }
12783 },
12784 [ALC892_FIXUP_ASROCK_MOBO] = {
12785 .type = HDA_FIXUP_PINS,
12786 .v.pins = (const struct hda_pintbl[]) {
12787 { 0x15, 0x40f000f0 }, /* disabled */
12788 { 0x16, 0x40f000f0 }, /* disabled */
12789 { }
12790 }
12791 },
12792 [ALC662_FIXUP_USI_FUNC] = {
12793 .type = HDA_FIXUP_FUNC,
12794 .v.func = alc662_fixup_usi_headset_mic,
12795 },
12796 [ALC662_FIXUP_USI_HEADSET_MODE] = {
12797 .type = HDA_FIXUP_PINS,
12798 .v.pins = (const struct hda_pintbl[]) {
12799 { 0x19, 0x02a1913c }, /* use as headset mic, without its own jack detect */
12800 { 0x18, 0x01a1903d },
12801 { }
12802 },
12803 .chained = true,
12804 .chain_id = ALC662_FIXUP_USI_FUNC
12805 },
12806 [ALC662_FIXUP_LENOVO_MULTI_CODECS] = {
12807 .type = HDA_FIXUP_FUNC,
12808 .v.func = alc233_alc662_fixup_lenovo_dual_codecs,
12809 },
12810 [ALC669_FIXUP_ACER_ASPIRE_ETHOS_HEADSET] = {
12811 .type = HDA_FIXUP_FUNC,
12812 .v.func = alc662_fixup_aspire_ethos_hp,
12813 },
12814 [ALC669_FIXUP_ACER_ASPIRE_ETHOS] = {
12815 .type = HDA_FIXUP_PINS,
12816 .v.pins = (const struct hda_pintbl[]) {
12817 { 0x15, 0x92130110 }, /* front speakers */
12818 { 0x18, 0x99130111 }, /* center/subwoofer */
12819 { 0x1b, 0x11130012 }, /* surround plus jack for HP */
12820 { }
12821 },
12822 .chained = true,
12823 .chain_id = ALC669_FIXUP_ACER_ASPIRE_ETHOS_HEADSET
12824 },
12825 [ALC671_FIXUP_HP_HEADSET_MIC2] = {
12826 .type = HDA_FIXUP_FUNC,
12827 .v.func = alc671_fixup_hp_headset_mic2,
12828 },
12829 [ALC662_FIXUP_ACER_X2660G_HEADSET_MODE] = {
12830 .type = HDA_FIXUP_PINS,
12831 .v.pins = (const struct hda_pintbl[]) {
12832 { 0x1a, 0x02a1113c }, /* use as headset mic, without its own jack detect */
12833 { }
12834 },
12835 .chained = true,
12836 .chain_id = ALC662_FIXUP_USI_FUNC
12837 },
12838 [ALC662_FIXUP_ACER_NITRO_HEADSET_MODE] = {
12839 .type = HDA_FIXUP_PINS,
12840 .v.pins = (const struct hda_pintbl[]) {
12841 { 0x1a, 0x01a11140 }, /* use as headset mic, without its own jack detect */
12842 { 0x1b, 0x0221144f },
12843 { }
12844 },
12845 .chained = true,
12846 .chain_id = ALC662_FIXUP_USI_FUNC
12847 },
12848 [ALC668_FIXUP_ASUS_NO_HEADSET_MIC] = {
12849 .type = HDA_FIXUP_PINS,
12850 .v.pins = (const struct hda_pintbl[]) {
12851 { 0x1b, 0x04a1112c },
12852 { }
12853 },
12854 .chained = true,
12855 .chain_id = ALC668_FIXUP_HEADSET_MIC
12856 },
12857 [ALC668_FIXUP_HEADSET_MIC] = {
12858 .type = HDA_FIXUP_FUNC,
12859 .v.func = alc269_fixup_headset_mic,
12860 .chained = true,
12861 .chain_id = ALC668_FIXUP_MIC_DET_COEF
12862 },
12863 [ALC668_FIXUP_MIC_DET_COEF] = {
12864 .type = HDA_FIXUP_VERBS,
12865 .v.verbs = (const struct hda_verb[]) {
12866 { 0x20, AC_VERB_SET_COEF_INDEX, 0x15 },
12867 { 0x20, AC_VERB_SET_PROC_COEF, 0x0d60 },
12868 {}
12869 },
12870 },
12871 [ALC897_FIXUP_LENOVO_HEADSET_MIC] = {
12872 .type = HDA_FIXUP_FUNC,
12873 .v.func = alc897_fixup_lenovo_headset_mic,
12874 },
12875 [ALC897_FIXUP_HEADSET_MIC_PIN] = {
12876 .type = HDA_FIXUP_PINS,
12877 .v.pins = (const struct hda_pintbl[]) {
12878 { 0x1a, 0x03a11050 },
12879 { }
12880 },
12881 .chained = true,
12882 .chain_id = ALC897_FIXUP_LENOVO_HEADSET_MIC
12883 },
12884 [ALC897_FIXUP_HP_HSMIC_VERB] = {
12885 .type = HDA_FIXUP_PINS,
12886 .v.pins = (const struct hda_pintbl[]) {
12887 { 0x19, 0x01a1913c }, /* use as headset mic, without its own jack detect */
12888 { }
12889 },
12890 },
12891 [ALC897_FIXUP_LENOVO_HEADSET_MODE] = {
12892 .type = HDA_FIXUP_FUNC,
12893 .v.func = alc897_fixup_lenovo_headset_mode,
12894 },
12895 [ALC897_FIXUP_HEADSET_MIC_PIN2] = {
12896 .type = HDA_FIXUP_PINS,
12897 .v.pins = (const struct hda_pintbl[]) {
12898 { 0x1a, 0x01a11140 }, /* use as headset mic, without its own jack detect */
12899 { }
12900 },
12901 .chained = true,
12902 .chain_id = ALC897_FIXUP_LENOVO_HEADSET_MODE
12903 },
12904 [ALC897_FIXUP_UNIS_H3C_X500S] = {
12905 .type = HDA_FIXUP_VERBS,
12906 .v.verbs = (const struct hda_verb[]) {
12907 { 0x14, AC_VERB_SET_EAPD_BTLENABLE, 0 },
12908 {}
12909 },
12910 },
12911 [ALC897_FIXUP_HEADSET_MIC_PIN3] = {
12912 .type = HDA_FIXUP_PINS,
12913 .v.pins = (const struct hda_pintbl[]) {
12914 { 0x19, 0x03a11050 }, /* use as headset mic */
12915 { }
12916 },
12917 },
12918 };
12919
12920 static const struct snd_pci_quirk alc662_fixup_tbl[] = {
12921 SND_PCI_QUIRK(0x1019, 0x9087, "ECS", ALC662_FIXUP_ASUS_MODE2),
12922 SND_PCI_QUIRK(0x1019, 0x9859, "JP-IK LEAP W502", ALC897_FIXUP_HEADSET_MIC_PIN3),
12923 SND_PCI_QUIRK(0x1025, 0x022f, "Acer Aspire One", ALC662_FIXUP_INV_DMIC),
12924 SND_PCI_QUIRK(0x1025, 0x0241, "Packard Bell DOTS", ALC662_FIXUP_INV_DMIC),
12925 SND_PCI_QUIRK(0x1025, 0x0308, "Acer Aspire 8942G", ALC662_FIXUP_ASPIRE),
12926 SND_PCI_QUIRK(0x1025, 0x031c, "Gateway NV79", ALC662_FIXUP_SKU_IGNORE),
12927 SND_PCI_QUIRK(0x1025, 0x0349, "eMachines eM250", ALC662_FIXUP_INV_DMIC),
12928 SND_PCI_QUIRK(0x1025, 0x034a, "Gateway LT27", ALC662_FIXUP_INV_DMIC),
12929 SND_PCI_QUIRK(0x1025, 0x038b, "Acer Aspire 8943G", ALC662_FIXUP_ASPIRE),
12930 SND_PCI_QUIRK(0x1025, 0x0566, "Acer Aspire Ethos 8951G", ALC669_FIXUP_ACER_ASPIRE_ETHOS),
12931 SND_PCI_QUIRK(0x1025, 0x123c, "Acer Nitro N50-600", ALC662_FIXUP_ACER_NITRO_HEADSET_MODE),
12932 SND_PCI_QUIRK(0x1025, 0x124e, "Acer 2660G", ALC662_FIXUP_ACER_X2660G_HEADSET_MODE),
12933 SND_PCI_QUIRK(0x1028, 0x05d8, "Dell", ALC668_FIXUP_DELL_MIC_NO_PRESENCE),
12934 SND_PCI_QUIRK(0x1028, 0x05db, "Dell", ALC668_FIXUP_DELL_MIC_NO_PRESENCE),
12935 SND_PCI_QUIRK(0x1028, 0x05fe, "Dell XPS 15", ALC668_FIXUP_DELL_XPS13),
12936 SND_PCI_QUIRK(0x1028, 0x060a, "Dell XPS 13", ALC668_FIXUP_DELL_XPS13),
12937 SND_PCI_QUIRK(0x1028, 0x060d, "Dell M3800", ALC668_FIXUP_DELL_XPS13),
12938 SND_PCI_QUIRK(0x1028, 0x0625, "Dell", ALC668_FIXUP_DELL_MIC_NO_PRESENCE),
12939 SND_PCI_QUIRK(0x1028, 0x0626, "Dell", ALC668_FIXUP_DELL_MIC_NO_PRESENCE),
12940 SND_PCI_QUIRK(0x1028, 0x0696, "Dell", ALC668_FIXUP_DELL_MIC_NO_PRESENCE),
12941 SND_PCI_QUIRK(0x1028, 0x0698, "Dell", ALC668_FIXUP_DELL_MIC_NO_PRESENCE),
12942 SND_PCI_QUIRK(0x1028, 0x069f, "Dell", ALC668_FIXUP_DELL_MIC_NO_PRESENCE),
12943 SND_PCI_QUIRK(0x103c, 0x1632, "HP RP5800", ALC662_FIXUP_HP_RP5800),
12944 SND_PCI_QUIRK(0x103c, 0x870c, "HP", ALC897_FIXUP_HP_HSMIC_VERB),
12945 SND_PCI_QUIRK(0x103c, 0x8719, "HP", ALC897_FIXUP_HP_HSMIC_VERB),
12946 SND_PCI_QUIRK(0x103c, 0x872b, "HP", ALC897_FIXUP_HP_HSMIC_VERB),
12947 SND_PCI_QUIRK(0x103c, 0x873e, "HP", ALC671_FIXUP_HP_HEADSET_MIC2),
12948 SND_PCI_QUIRK(0x103c, 0x8768, "HP Slim Desktop S01", ALC671_FIXUP_HP_HEADSET_MIC2),
12949 SND_PCI_QUIRK(0x103c, 0x877e, "HP 288 Pro G6", ALC671_FIXUP_HP_HEADSET_MIC2),
12950 SND_PCI_QUIRK(0x103c, 0x885f, "HP 288 Pro G8", ALC671_FIXUP_HP_HEADSET_MIC2),
12951 SND_PCI_QUIRK(0x1043, 0x1080, "Asus UX501VW", ALC668_FIXUP_HEADSET_MODE),
12952 SND_PCI_QUIRK(0x1043, 0x11cd, "Asus N550", ALC662_FIXUP_ASUS_Nx50),
12953 SND_PCI_QUIRK(0x1043, 0x129d, "Asus N750", ALC662_FIXUP_ASUS_Nx50),
12954 SND_PCI_QUIRK(0x1043, 0x12ff, "ASUS G751", ALC668_FIXUP_ASUS_G751),
12955 SND_PCI_QUIRK(0x1043, 0x13df, "Asus N550JX", ALC662_FIXUP_BASS_1A),
12956 SND_PCI_QUIRK(0x1043, 0x1477, "ASUS N56VZ", ALC662_FIXUP_BASS_MODE4_CHMAP),
12957 SND_PCI_QUIRK(0x1043, 0x15a7, "ASUS UX51VZH", ALC662_FIXUP_BASS_16),
12958 SND_PCI_QUIRK(0x1043, 0x177d, "ASUS N551", ALC668_FIXUP_ASUS_Nx51),
12959 SND_PCI_QUIRK(0x1043, 0x17bd, "ASUS N751", ALC668_FIXUP_ASUS_Nx51),
12960 SND_PCI_QUIRK(0x1043, 0x185d, "ASUS G551JW", ALC668_FIXUP_ASUS_NO_HEADSET_MIC),
12961 SND_PCI_QUIRK(0x1043, 0x1963, "ASUS X71SL", ALC662_FIXUP_ASUS_MODE8),
12962 SND_PCI_QUIRK(0x1043, 0x1b73, "ASUS N55SF", ALC662_FIXUP_BASS_16),
12963 SND_PCI_QUIRK(0x1043, 0x1bf3, "ASUS N76VZ", ALC662_FIXUP_BASS_MODE4_CHMAP),
12964 SND_PCI_QUIRK(0x1043, 0x8469, "ASUS mobo", ALC662_FIXUP_NO_JACK_DETECT),
12965 SND_PCI_QUIRK(0x105b, 0x0cd6, "Foxconn", ALC662_FIXUP_ASUS_MODE2),
12966 SND_PCI_QUIRK(0x144d, 0xc051, "Samsung R720", ALC662_FIXUP_IDEAPAD),
12967 SND_PCI_QUIRK(0x14cd, 0x5003, "USI", ALC662_FIXUP_USI_HEADSET_MODE),
12968 SND_PCI_QUIRK(0x17aa, 0x1036, "Lenovo P520", ALC662_FIXUP_LENOVO_MULTI_CODECS),
12969 SND_PCI_QUIRK(0x17aa, 0x1057, "Lenovo P360", ALC897_FIXUP_HEADSET_MIC_PIN),
12970 SND_PCI_QUIRK(0x17aa, 0x1064, "Lenovo P3 Tower", ALC897_FIXUP_HEADSET_MIC_PIN),
12971 SND_PCI_QUIRK(0x17aa, 0x32ca, "Lenovo ThinkCentre M80", ALC897_FIXUP_HEADSET_MIC_PIN),
12972 SND_PCI_QUIRK(0x17aa, 0x32cb, "Lenovo ThinkCentre M70", ALC897_FIXUP_HEADSET_MIC_PIN),
12973 SND_PCI_QUIRK(0x17aa, 0x32cf, "Lenovo ThinkCentre M950", ALC897_FIXUP_HEADSET_MIC_PIN),
12974 SND_PCI_QUIRK(0x17aa, 0x32f7, "Lenovo ThinkCentre M90", ALC897_FIXUP_HEADSET_MIC_PIN),
12975 SND_PCI_QUIRK(0x17aa, 0x3321, "Lenovo ThinkCentre M70 Gen4", ALC897_FIXUP_HEADSET_MIC_PIN),
12976 SND_PCI_QUIRK(0x17aa, 0x331b, "Lenovo ThinkCentre M90 Gen4", ALC897_FIXUP_HEADSET_MIC_PIN),
12977 SND_PCI_QUIRK(0x17aa, 0x3364, "Lenovo ThinkCentre M90 Gen5", ALC897_FIXUP_HEADSET_MIC_PIN),
12978 SND_PCI_QUIRK(0x17aa, 0x3742, "Lenovo TianYi510Pro-14IOB", ALC897_FIXUP_HEADSET_MIC_PIN2),
12979 SND_PCI_QUIRK(0x17aa, 0x38af, "Lenovo Ideapad Y550P", ALC662_FIXUP_IDEAPAD),
12980 SND_PCI_QUIRK(0x17aa, 0x3a0d, "Lenovo Ideapad Y550", ALC662_FIXUP_IDEAPAD),
12981 SND_PCI_QUIRK(0x1849, 0x5892, "ASRock B150M", ALC892_FIXUP_ASROCK_MOBO),
12982 SND_PCI_QUIRK(0x19da, 0xa130, "Zotac Z68", ALC662_FIXUP_ZOTAC_Z68),
12983 SND_PCI_QUIRK(0x1b0a, 0x01b8, "ACER Veriton", ALC662_FIXUP_ACER_VERITON),
12984 SND_PCI_QUIRK(0x1b35, 0x1234, "CZC ET26", ALC662_FIXUP_CZC_ET26),
12985 SND_PCI_QUIRK(0x1b35, 0x2206, "CZC P10T", ALC662_FIXUP_CZC_P10T),
12986 SND_PCI_QUIRK(0x1c6c, 0x1239, "Compaq N14JP6-V2", ALC897_FIXUP_HP_HSMIC_VERB),
12987
12988 #if 0
12989 /* Below is a quirk table taken from the old code.
12990 * Basically the device should work as is without the fixup table.
12991 * If BIOS doesn't give a proper info, enable the corresponding
12992 * fixup entry.
12993 */
12994 SND_PCI_QUIRK(0x1043, 0x1000, "ASUS N50Vm", ALC662_FIXUP_ASUS_MODE1),
12995 SND_PCI_QUIRK(0x1043, 0x1092, "ASUS NB", ALC662_FIXUP_ASUS_MODE3),
12996 SND_PCI_QUIRK(0x1043, 0x1173, "ASUS K73Jn", ALC662_FIXUP_ASUS_MODE1),
12997 SND_PCI_QUIRK(0x1043, 0x11c3, "ASUS M70V", ALC662_FIXUP_ASUS_MODE3),
12998 SND_PCI_QUIRK(0x1043, 0x11d3, "ASUS NB", ALC662_FIXUP_ASUS_MODE1),
12999 SND_PCI_QUIRK(0x1043, 0x11f3, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),
13000 SND_PCI_QUIRK(0x1043, 0x1203, "ASUS NB", ALC662_FIXUP_ASUS_MODE1),
13001 SND_PCI_QUIRK(0x1043, 0x1303, "ASUS G60J", ALC662_FIXUP_ASUS_MODE1),
13002 SND_PCI_QUIRK(0x1043, 0x1333, "ASUS G60Jx", ALC662_FIXUP_ASUS_MODE1),
13003 SND_PCI_QUIRK(0x1043, 0x1339, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),
13004 SND_PCI_QUIRK(0x1043, 0x13e3, "ASUS N71JA", ALC662_FIXUP_ASUS_MODE7),
13005 SND_PCI_QUIRK(0x1043, 0x1463, "ASUS N71", ALC662_FIXUP_ASUS_MODE7),
13006 SND_PCI_QUIRK(0x1043, 0x14d3, "ASUS G72", ALC662_FIXUP_ASUS_MODE8),
13007 SND_PCI_QUIRK(0x1043, 0x1563, "ASUS N90", ALC662_FIXUP_ASUS_MODE3),
13008 SND_PCI_QUIRK(0x1043, 0x15d3, "ASUS N50SF F50SF", ALC662_FIXUP_ASUS_MODE1),
13009 SND_PCI_QUIRK(0x1043, 0x16c3, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),
13010 SND_PCI_QUIRK(0x1043, 0x16f3, "ASUS K40C K50C", ALC662_FIXUP_ASUS_MODE2),
13011 SND_PCI_QUIRK(0x1043, 0x1733, "ASUS N81De", ALC662_FIXUP_ASUS_MODE1),
13012 SND_PCI_QUIRK(0x1043, 0x1753, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),
13013 SND_PCI_QUIRK(0x1043, 0x1763, "ASUS NB", ALC662_FIXUP_ASUS_MODE6),
13014 SND_PCI_QUIRK(0x1043, 0x1765, "ASUS NB", ALC662_FIXUP_ASUS_MODE6),
13015 SND_PCI_QUIRK(0x1043, 0x1783, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),
13016 SND_PCI_QUIRK(0x1043, 0x1793, "ASUS F50GX", ALC662_FIXUP_ASUS_MODE1),
13017 SND_PCI_QUIRK(0x1043, 0x17b3, "ASUS F70SL", ALC662_FIXUP_ASUS_MODE3),
13018 SND_PCI_QUIRK(0x1043, 0x17f3, "ASUS X58LE", ALC662_FIXUP_ASUS_MODE2),
13019 SND_PCI_QUIRK(0x1043, 0x1813, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),
13020 SND_PCI_QUIRK(0x1043, 0x1823, "ASUS NB", ALC662_FIXUP_ASUS_MODE5),
13021 SND_PCI_QUIRK(0x1043, 0x1833, "ASUS NB", ALC662_FIXUP_ASUS_MODE6),
13022 SND_PCI_QUIRK(0x1043, 0x1843, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),
13023 SND_PCI_QUIRK(0x1043, 0x1853, "ASUS F50Z", ALC662_FIXUP_ASUS_MODE1),
13024 SND_PCI_QUIRK(0x1043, 0x1864, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),
13025 SND_PCI_QUIRK(0x1043, 0x1876, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),
13026 SND_PCI_QUIRK(0x1043, 0x1893, "ASUS M50Vm", ALC662_FIXUP_ASUS_MODE3),
13027 SND_PCI_QUIRK(0x1043, 0x1894, "ASUS X55", ALC662_FIXUP_ASUS_MODE3),
13028 SND_PCI_QUIRK(0x1043, 0x18b3, "ASUS N80Vc", ALC662_FIXUP_ASUS_MODE1),
13029 SND_PCI_QUIRK(0x1043, 0x18c3, "ASUS VX5", ALC662_FIXUP_ASUS_MODE1),
13030 SND_PCI_QUIRK(0x1043, 0x18d3, "ASUS N81Te", ALC662_FIXUP_ASUS_MODE1),
13031 SND_PCI_QUIRK(0x1043, 0x18f3, "ASUS N505Tp", ALC662_FIXUP_ASUS_MODE1),
13032 SND_PCI_QUIRK(0x1043, 0x1903, "ASUS F5GL", ALC662_FIXUP_ASUS_MODE1),
13033 SND_PCI_QUIRK(0x1043, 0x1913, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),
13034 SND_PCI_QUIRK(0x1043, 0x1933, "ASUS F80Q", ALC662_FIXUP_ASUS_MODE2),
13035 SND_PCI_QUIRK(0x1043, 0x1943, "ASUS Vx3V", ALC662_FIXUP_ASUS_MODE1),
13036 SND_PCI_QUIRK(0x1043, 0x1953, "ASUS NB", ALC662_FIXUP_ASUS_MODE1),
13037 SND_PCI_QUIRK(0x1043, 0x1963, "ASUS X71C", ALC662_FIXUP_ASUS_MODE3),
13038 SND_PCI_QUIRK(0x1043, 0x1983, "ASUS N5051A", ALC662_FIXUP_ASUS_MODE1),
13039 SND_PCI_QUIRK(0x1043, 0x1993, "ASUS N20", ALC662_FIXUP_ASUS_MODE1),
13040 SND_PCI_QUIRK(0x1043, 0x19b3, "ASUS F7Z", ALC662_FIXUP_ASUS_MODE1),
13041 SND_PCI_QUIRK(0x1043, 0x19c3, "ASUS F5Z/F6x", ALC662_FIXUP_ASUS_MODE2),
13042 SND_PCI_QUIRK(0x1043, 0x19e3, "ASUS NB", ALC662_FIXUP_ASUS_MODE1),
13043 SND_PCI_QUIRK(0x1043, 0x19f3, "ASUS NB", ALC662_FIXUP_ASUS_MODE4),
13044 #endif
13045 {}
13046 };
13047
13048 static const struct hda_model_fixup alc662_fixup_models[] = {
13049 {.id = ALC662_FIXUP_ASPIRE, .name = "aspire"},
13050 {.id = ALC662_FIXUP_IDEAPAD, .name = "ideapad"},
13051 {.id = ALC272_FIXUP_MARIO, .name = "mario"},
13052 {.id = ALC662_FIXUP_HP_RP5800, .name = "hp-rp5800"},
13053 {.id = ALC662_FIXUP_ASUS_MODE1, .name = "asus-mode1"},
13054 {.id = ALC662_FIXUP_ASUS_MODE2, .name = "asus-mode2"},
13055 {.id = ALC662_FIXUP_ASUS_MODE3, .name = "asus-mode3"},
13056 {.id = ALC662_FIXUP_ASUS_MODE4, .name = "asus-mode4"},
13057 {.id = ALC662_FIXUP_ASUS_MODE5, .name = "asus-mode5"},
13058 {.id = ALC662_FIXUP_ASUS_MODE6, .name = "asus-mode6"},
13059 {.id = ALC662_FIXUP_ASUS_MODE7, .name = "asus-mode7"},
13060 {.id = ALC662_FIXUP_ASUS_MODE8, .name = "asus-mode8"},
13061 {.id = ALC662_FIXUP_ZOTAC_Z68, .name = "zotac-z68"},
13062 {.id = ALC662_FIXUP_INV_DMIC, .name = "inv-dmic"},
13063 {.id = ALC662_FIXUP_DELL_MIC_NO_PRESENCE, .name = "alc662-headset-multi"},
13064 {.id = ALC668_FIXUP_DELL_MIC_NO_PRESENCE, .name = "dell-headset-multi"},
13065 {.id = ALC662_FIXUP_HEADSET_MODE, .name = "alc662-headset"},
13066 {.id = ALC668_FIXUP_HEADSET_MODE, .name = "alc668-headset"},
13067 {.id = ALC662_FIXUP_BASS_16, .name = "bass16"},
13068 {.id = ALC662_FIXUP_BASS_1A, .name = "bass1a"},
13069 {.id = ALC668_FIXUP_AUTO_MUTE, .name = "automute"},
13070 {.id = ALC668_FIXUP_DELL_XPS13, .name = "dell-xps13"},
13071 {.id = ALC662_FIXUP_ASUS_Nx50, .name = "asus-nx50"},
13072 {.id = ALC668_FIXUP_ASUS_Nx51, .name = "asus-nx51"},
13073 {.id = ALC668_FIXUP_ASUS_G751, .name = "asus-g751"},
13074 {.id = ALC891_FIXUP_HEADSET_MODE, .name = "alc891-headset"},
13075 {.id = ALC891_FIXUP_DELL_MIC_NO_PRESENCE, .name = "alc891-headset-multi"},
13076 {.id = ALC662_FIXUP_ACER_VERITON, .name = "acer-veriton"},
13077 {.id = ALC892_FIXUP_ASROCK_MOBO, .name = "asrock-mobo"},
13078 {.id = ALC662_FIXUP_USI_HEADSET_MODE, .name = "usi-headset"},
13079 {.id = ALC662_FIXUP_LENOVO_MULTI_CODECS, .name = "dual-codecs"},
13080 {.id = ALC669_FIXUP_ACER_ASPIRE_ETHOS, .name = "aspire-ethos"},
13081 {.id = ALC897_FIXUP_UNIS_H3C_X500S, .name = "unis-h3c-x500s"},
13082 {}
13083 };
13084
13085 static const struct snd_hda_pin_quirk alc662_pin_fixup_tbl[] = {
13086 SND_HDA_PIN_QUIRK(0x10ec0867, 0x1028, "Dell", ALC891_FIXUP_DELL_MIC_NO_PRESENCE,
13087 {0x17, 0x02211010},
13088 {0x18, 0x01a19030},
13089 {0x1a, 0x01813040},
13090 {0x21, 0x01014020}),
13091 SND_HDA_PIN_QUIRK(0x10ec0867, 0x1028, "Dell", ALC891_FIXUP_DELL_MIC_NO_PRESENCE,
13092 {0x16, 0x01813030},
13093 {0x17, 0x02211010},
13094 {0x18, 0x01a19040},
13095 {0x21, 0x01014020}),
13096 SND_HDA_PIN_QUIRK(0x10ec0662, 0x1028, "Dell", ALC662_FIXUP_DELL_MIC_NO_PRESENCE,
13097 {0x14, 0x01014010},
13098 {0x18, 0x01a19020},
13099 {0x1a, 0x0181302f},
13100 {0x1b, 0x0221401f}),
13101 SND_HDA_PIN_QUIRK(0x10ec0668, 0x1028, "Dell", ALC668_FIXUP_AUTO_MUTE,
13102 {0x12, 0x99a30130},
13103 {0x14, 0x90170110},
13104 {0x15, 0x0321101f},
13105 {0x16, 0x03011020}),
13106 SND_HDA_PIN_QUIRK(0x10ec0668, 0x1028, "Dell", ALC668_FIXUP_AUTO_MUTE,
13107 {0x12, 0x99a30140},
13108 {0x14, 0x90170110},
13109 {0x15, 0x0321101f},
13110 {0x16, 0x03011020}),
13111 SND_HDA_PIN_QUIRK(0x10ec0668, 0x1028, "Dell", ALC668_FIXUP_AUTO_MUTE,
13112 {0x12, 0x99a30150},
13113 {0x14, 0x90170110},
13114 {0x15, 0x0321101f},
13115 {0x16, 0x03011020}),
13116 SND_HDA_PIN_QUIRK(0x10ec0668, 0x1028, "Dell", ALC668_FIXUP_AUTO_MUTE,
13117 {0x14, 0x90170110},
13118 {0x15, 0x0321101f},
13119 {0x16, 0x03011020}),
13120 SND_HDA_PIN_QUIRK(0x10ec0668, 0x1028, "Dell XPS 15", ALC668_FIXUP_AUTO_MUTE,
13121 {0x12, 0x90a60130},
13122 {0x14, 0x90170110},
13123 {0x15, 0x0321101f}),
13124 SND_HDA_PIN_QUIRK(0x10ec0671, 0x103c, "HP cPC", ALC671_FIXUP_HP_HEADSET_MIC2,
13125 {0x14, 0x01014010},
13126 {0x17, 0x90170150},
13127 {0x19, 0x02a11060},
13128 {0x1b, 0x01813030},
13129 {0x21, 0x02211020}),
13130 SND_HDA_PIN_QUIRK(0x10ec0671, 0x103c, "HP cPC", ALC671_FIXUP_HP_HEADSET_MIC2,
13131 {0x14, 0x01014010},
13132 {0x18, 0x01a19040},
13133 {0x1b, 0x01813030},
13134 {0x21, 0x02211020}),
13135 SND_HDA_PIN_QUIRK(0x10ec0671, 0x103c, "HP cPC", ALC671_FIXUP_HP_HEADSET_MIC2,
13136 {0x14, 0x01014020},
13137 {0x17, 0x90170110},
13138 {0x18, 0x01a19050},
13139 {0x1b, 0x01813040},
13140 {0x21, 0x02211030}),
13141 {}
13142 };
13143
13144 /*
13145 */
patch_alc662(struct hda_codec * codec)13146 static int patch_alc662(struct hda_codec *codec)
13147 {
13148 struct alc_spec *spec;
13149 int err;
13150
13151 err = alc_alloc_spec(codec, 0x0b);
13152 if (err < 0)
13153 return err;
13154
13155 spec = codec->spec;
13156
13157 spec->shutup = alc_eapd_shutup;
13158
13159 /* handle multiple HPs as is */
13160 spec->parse_flags = HDA_PINCFG_NO_HP_FIXUP;
13161
13162 alc_fix_pll_init(codec, 0x20, 0x04, 15);
13163
13164 switch (codec->core.vendor_id) {
13165 case 0x10ec0668:
13166 spec->init_hook = alc668_restore_default_value;
13167 break;
13168 }
13169
13170 alc_pre_init(codec);
13171
13172 snd_hda_pick_fixup(codec, alc662_fixup_models,
13173 alc662_fixup_tbl, alc662_fixups);
13174 snd_hda_pick_pin_fixup(codec, alc662_pin_fixup_tbl, alc662_fixups, true);
13175 snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE);
13176
13177 alc_auto_parse_customize_define(codec);
13178
13179 if (has_cdefine_beep(codec))
13180 spec->gen.beep_nid = 0x01;
13181
13182 if ((alc_get_coef0(codec) & (1 << 14)) &&
13183 codec->bus->pci && codec->bus->pci->subsystem_vendor == 0x1025 &&
13184 spec->cdefine.platform_type == 1) {
13185 err = alc_codec_rename(codec, "ALC272X");
13186 if (err < 0)
13187 goto error;
13188 }
13189
13190 /* automatic parse from the BIOS config */
13191 err = alc662_parse_auto_config(codec);
13192 if (err < 0)
13193 goto error;
13194
13195 if (!spec->gen.no_analog && spec->gen.beep_nid) {
13196 switch (codec->core.vendor_id) {
13197 case 0x10ec0662:
13198 err = set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
13199 break;
13200 case 0x10ec0272:
13201 case 0x10ec0663:
13202 case 0x10ec0665:
13203 case 0x10ec0668:
13204 err = set_beep_amp(spec, 0x0b, 0x04, HDA_INPUT);
13205 break;
13206 case 0x10ec0273:
13207 err = set_beep_amp(spec, 0x0b, 0x03, HDA_INPUT);
13208 break;
13209 }
13210 if (err < 0)
13211 goto error;
13212 }
13213
13214 snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE);
13215
13216 return 0;
13217
13218 error:
13219 alc_free(codec);
13220 return err;
13221 }
13222
13223 /*
13224 * ALC680 support
13225 */
13226
alc680_parse_auto_config(struct hda_codec * codec)13227 static int alc680_parse_auto_config(struct hda_codec *codec)
13228 {
13229 return alc_parse_auto_config(codec, NULL, NULL);
13230 }
13231
13232 /*
13233 */
patch_alc680(struct hda_codec * codec)13234 static int patch_alc680(struct hda_codec *codec)
13235 {
13236 int err;
13237
13238 /* ALC680 has no aa-loopback mixer */
13239 err = alc_alloc_spec(codec, 0);
13240 if (err < 0)
13241 return err;
13242
13243 /* automatic parse from the BIOS config */
13244 err = alc680_parse_auto_config(codec);
13245 if (err < 0) {
13246 alc_free(codec);
13247 return err;
13248 }
13249
13250 return 0;
13251 }
13252
13253 /*
13254 * patch entries
13255 */
13256 static const struct hda_device_id snd_hda_id_realtek[] = {
13257 HDA_CODEC_ENTRY(0x10ec0215, "ALC215", patch_alc269),
13258 HDA_CODEC_ENTRY(0x10ec0221, "ALC221", patch_alc269),
13259 HDA_CODEC_ENTRY(0x10ec0222, "ALC222", patch_alc269),
13260 HDA_CODEC_ENTRY(0x10ec0225, "ALC225", patch_alc269),
13261 HDA_CODEC_ENTRY(0x10ec0230, "ALC236", patch_alc269),
13262 HDA_CODEC_ENTRY(0x10ec0231, "ALC231", patch_alc269),
13263 HDA_CODEC_ENTRY(0x10ec0233, "ALC233", patch_alc269),
13264 HDA_CODEC_ENTRY(0x10ec0234, "ALC234", patch_alc269),
13265 HDA_CODEC_ENTRY(0x10ec0235, "ALC233", patch_alc269),
13266 HDA_CODEC_ENTRY(0x10ec0236, "ALC236", patch_alc269),
13267 HDA_CODEC_ENTRY(0x10ec0245, "ALC245", patch_alc269),
13268 HDA_CODEC_ENTRY(0x10ec0255, "ALC255", patch_alc269),
13269 HDA_CODEC_ENTRY(0x10ec0256, "ALC256", patch_alc269),
13270 HDA_CODEC_ENTRY(0x10ec0257, "ALC257", patch_alc269),
13271 HDA_CODEC_ENTRY(0x10ec0260, "ALC260", patch_alc260),
13272 HDA_CODEC_ENTRY(0x10ec0262, "ALC262", patch_alc262),
13273 HDA_CODEC_ENTRY(0x10ec0267, "ALC267", patch_alc268),
13274 HDA_CODEC_ENTRY(0x10ec0268, "ALC268", patch_alc268),
13275 HDA_CODEC_ENTRY(0x10ec0269, "ALC269", patch_alc269),
13276 HDA_CODEC_ENTRY(0x10ec0270, "ALC270", patch_alc269),
13277 HDA_CODEC_ENTRY(0x10ec0272, "ALC272", patch_alc662),
13278 HDA_CODEC_ENTRY(0x10ec0274, "ALC274", patch_alc269),
13279 HDA_CODEC_ENTRY(0x10ec0275, "ALC275", patch_alc269),
13280 HDA_CODEC_ENTRY(0x10ec0276, "ALC276", patch_alc269),
13281 HDA_CODEC_ENTRY(0x10ec0280, "ALC280", patch_alc269),
13282 HDA_CODEC_ENTRY(0x10ec0282, "ALC282", patch_alc269),
13283 HDA_CODEC_ENTRY(0x10ec0283, "ALC283", patch_alc269),
13284 HDA_CODEC_ENTRY(0x10ec0284, "ALC284", patch_alc269),
13285 HDA_CODEC_ENTRY(0x10ec0285, "ALC285", patch_alc269),
13286 HDA_CODEC_ENTRY(0x10ec0286, "ALC286", patch_alc269),
13287 HDA_CODEC_ENTRY(0x10ec0287, "ALC287", patch_alc269),
13288 HDA_CODEC_ENTRY(0x10ec0288, "ALC288", patch_alc269),
13289 HDA_CODEC_ENTRY(0x10ec0289, "ALC289", patch_alc269),
13290 HDA_CODEC_ENTRY(0x10ec0290, "ALC290", patch_alc269),
13291 HDA_CODEC_ENTRY(0x10ec0292, "ALC292", patch_alc269),
13292 HDA_CODEC_ENTRY(0x10ec0293, "ALC293", patch_alc269),
13293 HDA_CODEC_ENTRY(0x10ec0294, "ALC294", patch_alc269),
13294 HDA_CODEC_ENTRY(0x10ec0295, "ALC295", patch_alc269),
13295 HDA_CODEC_ENTRY(0x10ec0298, "ALC298", patch_alc269),
13296 HDA_CODEC_ENTRY(0x10ec0299, "ALC299", patch_alc269),
13297 HDA_CODEC_ENTRY(0x10ec0300, "ALC300", patch_alc269),
13298 HDA_CODEC_ENTRY(0x10ec0623, "ALC623", patch_alc269),
13299 HDA_CODEC_REV_ENTRY(0x10ec0861, 0x100340, "ALC660", patch_alc861),
13300 HDA_CODEC_ENTRY(0x10ec0660, "ALC660-VD", patch_alc861vd),
13301 HDA_CODEC_ENTRY(0x10ec0861, "ALC861", patch_alc861),
13302 HDA_CODEC_ENTRY(0x10ec0862, "ALC861-VD", patch_alc861vd),
13303 HDA_CODEC_REV_ENTRY(0x10ec0662, 0x100002, "ALC662 rev2", patch_alc882),
13304 HDA_CODEC_REV_ENTRY(0x10ec0662, 0x100101, "ALC662 rev1", patch_alc662),
13305 HDA_CODEC_REV_ENTRY(0x10ec0662, 0x100300, "ALC662 rev3", patch_alc662),
13306 HDA_CODEC_ENTRY(0x10ec0663, "ALC663", patch_alc662),
13307 HDA_CODEC_ENTRY(0x10ec0665, "ALC665", patch_alc662),
13308 HDA_CODEC_ENTRY(0x10ec0667, "ALC667", patch_alc662),
13309 HDA_CODEC_ENTRY(0x10ec0668, "ALC668", patch_alc662),
13310 HDA_CODEC_ENTRY(0x10ec0670, "ALC670", patch_alc662),
13311 HDA_CODEC_ENTRY(0x10ec0671, "ALC671", patch_alc662),
13312 HDA_CODEC_ENTRY(0x10ec0680, "ALC680", patch_alc680),
13313 HDA_CODEC_ENTRY(0x10ec0700, "ALC700", patch_alc269),
13314 HDA_CODEC_ENTRY(0x10ec0701, "ALC701", patch_alc269),
13315 HDA_CODEC_ENTRY(0x10ec0703, "ALC703", patch_alc269),
13316 HDA_CODEC_ENTRY(0x10ec0711, "ALC711", patch_alc269),
13317 HDA_CODEC_ENTRY(0x10ec0867, "ALC891", patch_alc662),
13318 HDA_CODEC_ENTRY(0x10ec0880, "ALC880", patch_alc880),
13319 HDA_CODEC_ENTRY(0x10ec0882, "ALC882", patch_alc882),
13320 HDA_CODEC_ENTRY(0x10ec0883, "ALC883", patch_alc882),
13321 HDA_CODEC_REV_ENTRY(0x10ec0885, 0x100101, "ALC889A", patch_alc882),
13322 HDA_CODEC_REV_ENTRY(0x10ec0885, 0x100103, "ALC889A", patch_alc882),
13323 HDA_CODEC_ENTRY(0x10ec0885, "ALC885", patch_alc882),
13324 HDA_CODEC_ENTRY(0x10ec0887, "ALC887", patch_alc882),
13325 HDA_CODEC_REV_ENTRY(0x10ec0888, 0x100101, "ALC1200", patch_alc882),
13326 HDA_CODEC_ENTRY(0x10ec0888, "ALC888", patch_alc882),
13327 HDA_CODEC_ENTRY(0x10ec0889, "ALC889", patch_alc882),
13328 HDA_CODEC_ENTRY(0x10ec0892, "ALC892", patch_alc662),
13329 HDA_CODEC_ENTRY(0x10ec0897, "ALC897", patch_alc662),
13330 HDA_CODEC_ENTRY(0x10ec0899, "ALC898", patch_alc882),
13331 HDA_CODEC_ENTRY(0x10ec0900, "ALC1150", patch_alc882),
13332 HDA_CODEC_ENTRY(0x10ec0b00, "ALCS1200A", patch_alc882),
13333 HDA_CODEC_ENTRY(0x10ec1168, "ALC1220", patch_alc882),
13334 HDA_CODEC_ENTRY(0x10ec1220, "ALC1220", patch_alc882),
13335 HDA_CODEC_ENTRY(0x19e58326, "HW8326", patch_alc269),
13336 {} /* terminator */
13337 };
13338 MODULE_DEVICE_TABLE(hdaudio, snd_hda_id_realtek);
13339
13340 MODULE_LICENSE("GPL");
13341 MODULE_DESCRIPTION("Realtek HD-audio codec");
13342 MODULE_IMPORT_NS(SND_HDA_SCODEC_COMPONENT);
13343
13344 static struct hda_codec_driver realtek_driver = {
13345 .id = snd_hda_id_realtek,
13346 };
13347
13348 module_hda_codec_driver(realtek_driver);
13349