1
2
3
4
5
6
7
8
9
10
11
12
13#include <linux/init.h>
14#include <linux/delay.h>
15#include <linux/slab.h>
16#include <linux/pci.h>
17#include <linux/dmi.h>
18#include <linux/module.h>
19#include <linux/input.h>
20#include <linux/leds.h>
21#include <sound/core.h>
22#include <sound/jack.h>
23#include <sound/hda_codec.h>
24#include "hda_local.h"
25#include "hda_auto_parser.h"
26#include "hda_jack.h"
27#include "hda_generic.h"
28
29
30#define HALT_REALTEK_ALC5505
31
32
33enum {
34 ALC_INIT_UNDEFINED,
35 ALC_INIT_NONE,
36 ALC_INIT_DEFAULT,
37};
38
39enum {
40 ALC_HEADSET_MODE_UNKNOWN,
41 ALC_HEADSET_MODE_UNPLUGGED,
42 ALC_HEADSET_MODE_HEADSET,
43 ALC_HEADSET_MODE_MIC,
44 ALC_HEADSET_MODE_HEADPHONE,
45};
46
47enum {
48 ALC_HEADSET_TYPE_UNKNOWN,
49 ALC_HEADSET_TYPE_CTIA,
50 ALC_HEADSET_TYPE_OMTP,
51};
52
53enum {
54 ALC_KEY_MICMUTE_INDEX,
55};
56
57struct alc_customize_define {
58 unsigned int sku_cfg;
59 unsigned char port_connectivity;
60 unsigned char check_sum;
61 unsigned char customization;
62 unsigned char external_amp;
63 unsigned int enable_pcbeep:1;
64 unsigned int platform_type:1;
65 unsigned int swap:1;
66 unsigned int override:1;
67 unsigned int fixup:1;
68};
69
70struct alc_coef_led {
71 unsigned int idx;
72 unsigned int mask;
73 unsigned int on;
74 unsigned int off;
75};
76
77struct alc_spec {
78 struct hda_gen_spec gen;
79
80
81 struct alc_customize_define cdefine;
82 unsigned int parse_flags;
83
84
85 unsigned int gpio_mask;
86 unsigned int gpio_dir;
87 unsigned int gpio_data;
88 bool gpio_write_delay;
89
90
91 int mute_led_polarity;
92 int micmute_led_polarity;
93 hda_nid_t mute_led_nid;
94 hda_nid_t cap_mute_led_nid;
95
96 unsigned int gpio_mute_led_mask;
97 unsigned int gpio_mic_led_mask;
98 struct alc_coef_led mute_led_coef;
99 struct alc_coef_led mic_led_coef;
100
101 hda_nid_t headset_mic_pin;
102 hda_nid_t headphone_mic_pin;
103 int current_headset_mode;
104 int current_headset_type;
105
106
107 void (*init_hook)(struct hda_codec *codec);
108#ifdef CONFIG_PM
109 void (*power_hook)(struct hda_codec *codec);
110#endif
111 void (*shutup)(struct hda_codec *codec);
112 void (*reboot_notify)(struct hda_codec *codec);
113
114 int init_amp;
115 int codec_variant;
116 unsigned int has_alc5505_dsp:1;
117 unsigned int no_depop_delay:1;
118 unsigned int done_hp_init:1;
119 unsigned int no_shutup_pins:1;
120 unsigned int ultra_low_power:1;
121 unsigned int has_hs_key:1;
122
123
124 hda_nid_t pll_nid;
125 unsigned int pll_coef_idx, pll_coef_bit;
126 unsigned int coef0;
127 struct input_dev *kb_dev;
128 u8 alc_mute_keycode_map[1];
129};
130
131
132
133
134
135static int alc_read_coefex_idx(struct hda_codec *codec, hda_nid_t nid,
136 unsigned int coef_idx)
137{
138 unsigned int val;
139
140 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_COEF_INDEX, coef_idx);
141 val = snd_hda_codec_read(codec, nid, 0, AC_VERB_GET_PROC_COEF, 0);
142 return val;
143}
144
145#define alc_read_coef_idx(codec, coef_idx) \
146 alc_read_coefex_idx(codec, 0x20, coef_idx)
147
148static void alc_write_coefex_idx(struct hda_codec *codec, hda_nid_t nid,
149 unsigned int coef_idx, unsigned int coef_val)
150{
151 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_COEF_INDEX, coef_idx);
152 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_PROC_COEF, coef_val);
153}
154
155#define alc_write_coef_idx(codec, coef_idx, coef_val) \
156 alc_write_coefex_idx(codec, 0x20, coef_idx, coef_val)
157
158static void alc_update_coefex_idx(struct hda_codec *codec, hda_nid_t nid,
159 unsigned int coef_idx, unsigned int mask,
160 unsigned int bits_set)
161{
162 unsigned int val = alc_read_coefex_idx(codec, nid, coef_idx);
163
164 if (val != -1)
165 alc_write_coefex_idx(codec, nid, coef_idx,
166 (val & ~mask) | bits_set);
167}
168
169#define alc_update_coef_idx(codec, coef_idx, mask, bits_set) \
170 alc_update_coefex_idx(codec, 0x20, coef_idx, mask, bits_set)
171
172
173static unsigned int alc_get_coef0(struct hda_codec *codec)
174{
175 struct alc_spec *spec = codec->spec;
176
177 if (!spec->coef0)
178 spec->coef0 = alc_read_coef_idx(codec, 0);
179 return spec->coef0;
180}
181
182
183struct coef_fw {
184 unsigned char nid;
185 unsigned char idx;
186 unsigned short mask;
187 unsigned short val;
188};
189
190#define UPDATE_COEFEX(_nid, _idx, _mask, _val) \
191 { .nid = (_nid), .idx = (_idx), .mask = (_mask), .val = (_val) }
192#define WRITE_COEFEX(_nid, _idx, _val) UPDATE_COEFEX(_nid, _idx, -1, _val)
193#define WRITE_COEF(_idx, _val) WRITE_COEFEX(0x20, _idx, _val)
194#define UPDATE_COEF(_idx, _mask, _val) UPDATE_COEFEX(0x20, _idx, _mask, _val)
195
196static void alc_process_coef_fw(struct hda_codec *codec,
197 const struct coef_fw *fw)
198{
199 for (; fw->nid; fw++) {
200 if (fw->mask == (unsigned short)-1)
201 alc_write_coefex_idx(codec, fw->nid, fw->idx, fw->val);
202 else
203 alc_update_coefex_idx(codec, fw->nid, fw->idx,
204 fw->mask, fw->val);
205 }
206}
207
208
209
210
211
212
213static void alc_setup_gpio(struct hda_codec *codec, unsigned int mask)
214{
215 struct alc_spec *spec = codec->spec;
216
217 spec->gpio_mask |= mask;
218 spec->gpio_dir |= mask;
219 spec->gpio_data |= mask;
220}
221
222static void alc_write_gpio_data(struct hda_codec *codec)
223{
224 struct alc_spec *spec = codec->spec;
225
226 snd_hda_codec_write(codec, 0x01, 0, AC_VERB_SET_GPIO_DATA,
227 spec->gpio_data);
228}
229
230static void alc_update_gpio_data(struct hda_codec *codec, unsigned int mask,
231 bool on)
232{
233 struct alc_spec *spec = codec->spec;
234 unsigned int oldval = spec->gpio_data;
235
236 if (on)
237 spec->gpio_data |= mask;
238 else
239 spec->gpio_data &= ~mask;
240 if (oldval != spec->gpio_data)
241 alc_write_gpio_data(codec);
242}
243
244static void alc_write_gpio(struct hda_codec *codec)
245{
246 struct alc_spec *spec = codec->spec;
247
248 if (!spec->gpio_mask)
249 return;
250
251 snd_hda_codec_write(codec, codec->core.afg, 0,
252 AC_VERB_SET_GPIO_MASK, spec->gpio_mask);
253 snd_hda_codec_write(codec, codec->core.afg, 0,
254 AC_VERB_SET_GPIO_DIRECTION, spec->gpio_dir);
255 if (spec->gpio_write_delay)
256 msleep(1);
257 alc_write_gpio_data(codec);
258}
259
260static void alc_fixup_gpio(struct hda_codec *codec, int action,
261 unsigned int mask)
262{
263 if (action == HDA_FIXUP_ACT_PRE_PROBE)
264 alc_setup_gpio(codec, mask);
265}
266
267static void alc_fixup_gpio1(struct hda_codec *codec,
268 const struct hda_fixup *fix, int action)
269{
270 alc_fixup_gpio(codec, action, 0x01);
271}
272
273static void alc_fixup_gpio2(struct hda_codec *codec,
274 const struct hda_fixup *fix, int action)
275{
276 alc_fixup_gpio(codec, action, 0x02);
277}
278
279static void alc_fixup_gpio3(struct hda_codec *codec,
280 const struct hda_fixup *fix, int action)
281{
282 alc_fixup_gpio(codec, action, 0x03);
283}
284
285static void alc_fixup_gpio4(struct hda_codec *codec,
286 const struct hda_fixup *fix, int action)
287{
288 alc_fixup_gpio(codec, action, 0x04);
289}
290
291static void alc_fixup_micmute_led(struct hda_codec *codec,
292 const struct hda_fixup *fix, int action)
293{
294 if (action == HDA_FIXUP_ACT_PROBE)
295 snd_hda_gen_add_micmute_led_cdev(codec, NULL);
296}
297
298
299
300
301
302
303static void alc_fix_pll(struct hda_codec *codec)
304{
305 struct alc_spec *spec = codec->spec;
306
307 if (spec->pll_nid)
308 alc_update_coefex_idx(codec, spec->pll_nid, spec->pll_coef_idx,
309 1 << spec->pll_coef_bit, 0);
310}
311
312static void alc_fix_pll_init(struct hda_codec *codec, hda_nid_t nid,
313 unsigned int coef_idx, unsigned int coef_bit)
314{
315 struct alc_spec *spec = codec->spec;
316 spec->pll_nid = nid;
317 spec->pll_coef_idx = coef_idx;
318 spec->pll_coef_bit = coef_bit;
319 alc_fix_pll(codec);
320}
321
322
323static void alc_update_knob_master(struct hda_codec *codec,
324 struct hda_jack_callback *jack)
325{
326 unsigned int val;
327 struct snd_kcontrol *kctl;
328 struct snd_ctl_elem_value *uctl;
329
330 kctl = snd_hda_find_mixer_ctl(codec, "Master Playback Volume");
331 if (!kctl)
332 return;
333 uctl = kzalloc(sizeof(*uctl), GFP_KERNEL);
334 if (!uctl)
335 return;
336 val = snd_hda_codec_read(codec, jack->nid, 0,
337 AC_VERB_GET_VOLUME_KNOB_CONTROL, 0);
338 val &= HDA_AMP_VOLMASK;
339 uctl->value.integer.value[0] = val;
340 uctl->value.integer.value[1] = val;
341 kctl->put(kctl, uctl);
342 kfree(uctl);
343}
344
345static void alc880_unsol_event(struct hda_codec *codec, unsigned int res)
346{
347
348
349 snd_hda_jack_unsol_event(codec, res >> 2);
350}
351
352
353static void alc_fill_eapd_coef(struct hda_codec *codec)
354{
355 int coef;
356
357 coef = alc_get_coef0(codec);
358
359 switch (codec->core.vendor_id) {
360 case 0x10ec0262:
361 alc_update_coef_idx(codec, 0x7, 0, 1<<5);
362 break;
363 case 0x10ec0267:
364 case 0x10ec0268:
365 alc_update_coef_idx(codec, 0x7, 0, 1<<13);
366 break;
367 case 0x10ec0269:
368 if ((coef & 0x00f0) == 0x0010)
369 alc_update_coef_idx(codec, 0xd, 0, 1<<14);
370 if ((coef & 0x00f0) == 0x0020)
371 alc_update_coef_idx(codec, 0x4, 1<<15, 0);
372 if ((coef & 0x00f0) == 0x0030)
373 alc_update_coef_idx(codec, 0x10, 1<<9, 0);
374 break;
375 case 0x10ec0280:
376 case 0x10ec0284:
377 case 0x10ec0290:
378 case 0x10ec0292:
379 alc_update_coef_idx(codec, 0x4, 1<<15, 0);
380 break;
381 case 0x10ec0225:
382 case 0x10ec0295:
383 case 0x10ec0299:
384 alc_update_coef_idx(codec, 0x67, 0xf000, 0x3000);
385 fallthrough;
386 case 0x10ec0215:
387 case 0x10ec0233:
388 case 0x10ec0235:
389 case 0x10ec0236:
390 case 0x10ec0245:
391 case 0x10ec0255:
392 case 0x10ec0256:
393 case 0x10ec0257:
394 case 0x10ec0282:
395 case 0x10ec0283:
396 case 0x10ec0286:
397 case 0x10ec0287:
398 case 0x10ec0288:
399 case 0x10ec0285:
400 case 0x10ec0298:
401 case 0x10ec0289:
402 case 0x10ec0300:
403 alc_update_coef_idx(codec, 0x10, 1<<9, 0);
404 break;
405 case 0x10ec0275:
406 alc_update_coef_idx(codec, 0xe, 0, 1<<0);
407 break;
408 case 0x10ec0293:
409 alc_update_coef_idx(codec, 0xa, 1<<13, 0);
410 break;
411 case 0x10ec0234:
412 case 0x10ec0274:
413 case 0x10ec0294:
414 case 0x10ec0700:
415 case 0x10ec0701:
416 case 0x10ec0703:
417 case 0x10ec0711:
418 alc_update_coef_idx(codec, 0x10, 1<<15, 0);
419 break;
420 case 0x10ec0662:
421 if ((coef & 0x00f0) == 0x0030)
422 alc_update_coef_idx(codec, 0x4, 1<<10, 0);
423 break;
424 case 0x10ec0272:
425 case 0x10ec0273:
426 case 0x10ec0663:
427 case 0x10ec0665:
428 case 0x10ec0670:
429 case 0x10ec0671:
430 case 0x10ec0672:
431 alc_update_coef_idx(codec, 0xd, 0, 1<<14);
432 break;
433 case 0x10ec0222:
434 case 0x10ec0623:
435 alc_update_coef_idx(codec, 0x19, 1<<13, 0);
436 break;
437 case 0x10ec0668:
438 alc_update_coef_idx(codec, 0x7, 3<<13, 0);
439 break;
440 case 0x10ec0867:
441 alc_update_coef_idx(codec, 0x4, 1<<10, 0);
442 break;
443 case 0x10ec0888:
444 if ((coef & 0x00f0) == 0x0020 || (coef & 0x00f0) == 0x0030)
445 alc_update_coef_idx(codec, 0x7, 1<<5, 0);
446 break;
447 case 0x10ec0892:
448 alc_update_coef_idx(codec, 0x7, 1<<5, 0);
449 break;
450 case 0x10ec0899:
451 case 0x10ec0900:
452 case 0x10ec0b00:
453 case 0x10ec1168:
454 case 0x10ec1220:
455 alc_update_coef_idx(codec, 0x7, 1<<1, 0);
456 break;
457 }
458}
459
460
461static void alc888_coef_init(struct hda_codec *codec)
462{
463 switch (alc_get_coef0(codec) & 0x00f0) {
464
465 case 0x00:
466
467 case 0x10:
468 alc_update_coef_idx(codec, 7, 0, 0x2030);
469 break;
470 }
471}
472
473
474static void set_eapd(struct hda_codec *codec, hda_nid_t nid, int on)
475{
476 if (get_wcaps_type(get_wcaps(codec, nid)) != AC_WID_PIN)
477 return;
478 if (snd_hda_query_pin_caps(codec, nid) & AC_PINCAP_EAPD)
479 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_EAPD_BTLENABLE,
480 on ? 2 : 0);
481}
482
483
484static void alc_auto_setup_eapd(struct hda_codec *codec, bool on)
485{
486
487 static const hda_nid_t pins[] = {
488 0x0f, 0x10, 0x14, 0x15, 0x17, 0
489 };
490 const hda_nid_t *p;
491 for (p = pins; *p; p++)
492 set_eapd(codec, *p, on);
493}
494
495static int find_ext_mic_pin(struct hda_codec *codec);
496
497static void alc_headset_mic_no_shutup(struct hda_codec *codec)
498{
499 const struct hda_pincfg *pin;
500 int mic_pin = find_ext_mic_pin(codec);
501 int i;
502
503
504
505
506 if (codec->bus->shutdown)
507 return;
508
509 snd_array_for_each(&codec->init_pins, i, pin) {
510
511 if (pin->nid != mic_pin)
512 snd_hda_codec_read(codec, pin->nid, 0,
513 AC_VERB_SET_PIN_WIDGET_CONTROL, 0);
514 }
515
516 codec->pins_shutup = 1;
517}
518
519static void alc_shutup_pins(struct hda_codec *codec)
520{
521 struct alc_spec *spec = codec->spec;
522
523 switch (codec->core.vendor_id) {
524 case 0x10ec0283:
525 case 0x10ec0286:
526 case 0x10ec0288:
527 case 0x10ec0298:
528 alc_headset_mic_no_shutup(codec);
529 break;
530 default:
531 if (!spec->no_shutup_pins)
532 snd_hda_shutup_pins(codec);
533 break;
534 }
535}
536
537
538
539
540static void alc_eapd_shutup(struct hda_codec *codec)
541{
542 struct alc_spec *spec = codec->spec;
543
544 alc_auto_setup_eapd(codec, false);
545 if (!spec->no_depop_delay)
546 msleep(200);
547 alc_shutup_pins(codec);
548}
549
550
551static void alc_auto_init_amp(struct hda_codec *codec, int type)
552{
553 alc_auto_setup_eapd(codec, true);
554 alc_write_gpio(codec);
555 switch (type) {
556 case ALC_INIT_DEFAULT:
557 switch (codec->core.vendor_id) {
558 case 0x10ec0260:
559 alc_update_coefex_idx(codec, 0x1a, 7, 0, 0x2010);
560 break;
561 case 0x10ec0880:
562 case 0x10ec0882:
563 case 0x10ec0883:
564 case 0x10ec0885:
565 alc_update_coef_idx(codec, 7, 0, 0x2030);
566 break;
567 case 0x10ec0888:
568 alc888_coef_init(codec);
569 break;
570 }
571 break;
572 }
573}
574
575
576static hda_nid_t alc_get_hp_pin(struct alc_spec *spec)
577{
578 if (spec->gen.autocfg.hp_pins[0])
579 return spec->gen.autocfg.hp_pins[0];
580 if (spec->gen.autocfg.line_out_type == AC_JACK_HP_OUT)
581 return spec->gen.autocfg.line_out_pins[0];
582 return 0;
583}
584
585
586
587
588
589
590
591
592#define ALC_FIXUP_SKU_IGNORE (2)
593
594static void alc_fixup_sku_ignore(struct hda_codec *codec,
595 const struct hda_fixup *fix, int action)
596{
597 struct alc_spec *spec = codec->spec;
598 if (action == HDA_FIXUP_ACT_PRE_PROBE) {
599 spec->cdefine.fixup = 1;
600 spec->cdefine.sku_cfg = ALC_FIXUP_SKU_IGNORE;
601 }
602}
603
604static void alc_fixup_no_depop_delay(struct hda_codec *codec,
605 const struct hda_fixup *fix, int action)
606{
607 struct alc_spec *spec = codec->spec;
608
609 if (action == HDA_FIXUP_ACT_PROBE) {
610 spec->no_depop_delay = 1;
611 codec->depop_delay = 0;
612 }
613}
614
615static int alc_auto_parse_customize_define(struct hda_codec *codec)
616{
617 unsigned int ass, tmp, i;
618 unsigned nid = 0;
619 struct alc_spec *spec = codec->spec;
620
621 spec->cdefine.enable_pcbeep = 1;
622
623 if (spec->cdefine.fixup) {
624 ass = spec->cdefine.sku_cfg;
625 if (ass == ALC_FIXUP_SKU_IGNORE)
626 return -1;
627 goto do_sku;
628 }
629
630 if (!codec->bus->pci)
631 return -1;
632 ass = codec->core.subsystem_id & 0xffff;
633 if (ass != codec->bus->pci->subsystem_device && (ass & 1))
634 goto do_sku;
635
636 nid = 0x1d;
637 if (codec->core.vendor_id == 0x10ec0260)
638 nid = 0x17;
639 ass = snd_hda_codec_get_pincfg(codec, nid);
640
641 if (!(ass & 1)) {
642 codec_info(codec, "%s: SKU not ready 0x%08x\n",
643 codec->core.chip_name, ass);
644 return -1;
645 }
646
647
648 tmp = 0;
649 for (i = 1; i < 16; i++) {
650 if ((ass >> i) & 1)
651 tmp++;
652 }
653 if (((ass >> 16) & 0xf) != tmp)
654 return -1;
655
656 spec->cdefine.port_connectivity = ass >> 30;
657 spec->cdefine.enable_pcbeep = (ass & 0x100000) >> 20;
658 spec->cdefine.check_sum = (ass >> 16) & 0xf;
659 spec->cdefine.customization = ass >> 8;
660do_sku:
661 spec->cdefine.sku_cfg = ass;
662 spec->cdefine.external_amp = (ass & 0x38) >> 3;
663 spec->cdefine.platform_type = (ass & 0x4) >> 2;
664 spec->cdefine.swap = (ass & 0x2) >> 1;
665 spec->cdefine.override = ass & 0x1;
666
667 codec_dbg(codec, "SKU: Nid=0x%x sku_cfg=0x%08x\n",
668 nid, spec->cdefine.sku_cfg);
669 codec_dbg(codec, "SKU: port_connectivity=0x%x\n",
670 spec->cdefine.port_connectivity);
671 codec_dbg(codec, "SKU: enable_pcbeep=0x%x\n", spec->cdefine.enable_pcbeep);
672 codec_dbg(codec, "SKU: check_sum=0x%08x\n", spec->cdefine.check_sum);
673 codec_dbg(codec, "SKU: customization=0x%08x\n", spec->cdefine.customization);
674 codec_dbg(codec, "SKU: external_amp=0x%x\n", spec->cdefine.external_amp);
675 codec_dbg(codec, "SKU: platform_type=0x%x\n", spec->cdefine.platform_type);
676 codec_dbg(codec, "SKU: swap=0x%x\n", spec->cdefine.swap);
677 codec_dbg(codec, "SKU: override=0x%x\n", spec->cdefine.override);
678
679 return 0;
680}
681
682
683static int find_idx_in_nid_list(hda_nid_t nid, const hda_nid_t *list, int nums)
684{
685 int i;
686 for (i = 0; i < nums; i++)
687 if (list[i] == nid)
688 return i;
689 return -1;
690}
691
692static bool found_in_nid_list(hda_nid_t nid, const hda_nid_t *list, int nums)
693{
694 return find_idx_in_nid_list(nid, list, nums) >= 0;
695}
696
697
698
699
700
701
702
703
704
705
706static int alc_subsystem_id(struct hda_codec *codec, const hda_nid_t *ports)
707{
708 unsigned int ass, tmp, i;
709 unsigned nid;
710 struct alc_spec *spec = codec->spec;
711
712 if (spec->cdefine.fixup) {
713 ass = spec->cdefine.sku_cfg;
714 if (ass == ALC_FIXUP_SKU_IGNORE)
715 return 0;
716 goto do_sku;
717 }
718
719 ass = codec->core.subsystem_id & 0xffff;
720 if (codec->bus->pci &&
721 ass != codec->bus->pci->subsystem_device && (ass & 1))
722 goto do_sku;
723
724
725
726
727
728
729
730
731
732
733 nid = 0x1d;
734 if (codec->core.vendor_id == 0x10ec0260)
735 nid = 0x17;
736 ass = snd_hda_codec_get_pincfg(codec, nid);
737 codec_dbg(codec,
738 "realtek: No valid SSID, checking pincfg 0x%08x for NID 0x%x\n",
739 ass, nid);
740 if (!(ass & 1))
741 return 0;
742 if ((ass >> 30) != 1)
743 return 0;
744
745
746 tmp = 0;
747 for (i = 1; i < 16; i++) {
748 if ((ass >> i) & 1)
749 tmp++;
750 }
751 if (((ass >> 16) & 0xf) != tmp)
752 return 0;
753do_sku:
754 codec_dbg(codec, "realtek: Enabling init ASM_ID=0x%04x CODEC_ID=%08x\n",
755 ass & 0xffff, codec->core.vendor_id);
756
757
758
759
760
761
762
763 tmp = (ass & 0x38) >> 3;
764 if (spec->init_amp == ALC_INIT_UNDEFINED) {
765 switch (tmp) {
766 case 1:
767 alc_setup_gpio(codec, 0x01);
768 break;
769 case 3:
770 alc_setup_gpio(codec, 0x02);
771 break;
772 case 7:
773 alc_setup_gpio(codec, 0x03);
774 break;
775 case 5:
776 default:
777 spec->init_amp = ALC_INIT_DEFAULT;
778 break;
779 }
780 }
781
782
783
784
785 if (!(ass & 0x8000))
786 return 1;
787
788
789
790
791
792
793
794 if (!alc_get_hp_pin(spec)) {
795 hda_nid_t nid;
796 tmp = (ass >> 11) & 0x3;
797 nid = ports[tmp];
798 if (found_in_nid_list(nid, spec->gen.autocfg.line_out_pins,
799 spec->gen.autocfg.line_outs))
800 return 1;
801 spec->gen.autocfg.hp_pins[0] = nid;
802 }
803 return 1;
804}
805
806
807
808static void alc_ssid_check(struct hda_codec *codec, const hda_nid_t *ports)
809{
810 if (!alc_subsystem_id(codec, ports)) {
811 struct alc_spec *spec = codec->spec;
812 if (spec->init_amp == ALC_INIT_UNDEFINED) {
813 codec_dbg(codec,
814 "realtek: Enable default setup for auto mode as fallback\n");
815 spec->init_amp = ALC_INIT_DEFAULT;
816 }
817 }
818}
819
820
821
822
823static void alc_fixup_inv_dmic(struct hda_codec *codec,
824 const struct hda_fixup *fix, int action)
825{
826 struct alc_spec *spec = codec->spec;
827
828 spec->gen.inv_dmic_split = 1;
829}
830
831
832static int alc_build_controls(struct hda_codec *codec)
833{
834 int err;
835
836 err = snd_hda_gen_build_controls(codec);
837 if (err < 0)
838 return err;
839
840 snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_BUILD);
841 return 0;
842}
843
844
845
846
847
848
849static void alc_pre_init(struct hda_codec *codec)
850{
851 alc_fill_eapd_coef(codec);
852}
853
854#define is_s3_resume(codec) \
855 ((codec)->core.dev.power.power_state.event == PM_EVENT_RESUME)
856#define is_s4_resume(codec) \
857 ((codec)->core.dev.power.power_state.event == PM_EVENT_RESTORE)
858
859static int alc_init(struct hda_codec *codec)
860{
861 struct alc_spec *spec = codec->spec;
862
863
864 if (is_s4_resume(codec))
865 alc_pre_init(codec);
866
867 if (spec->init_hook)
868 spec->init_hook(codec);
869
870 spec->gen.skip_verbs = 1;
871 snd_hda_gen_init(codec);
872 alc_fix_pll(codec);
873 alc_auto_init_amp(codec, spec->init_amp);
874 snd_hda_apply_verbs(codec);
875
876 snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_INIT);
877
878 return 0;
879}
880
881static inline void alc_shutup(struct hda_codec *codec)
882{
883 struct alc_spec *spec = codec->spec;
884
885 if (!snd_hda_get_bool_hint(codec, "shutup"))
886 return;
887
888 if (spec && spec->shutup)
889 spec->shutup(codec);
890 else
891 alc_shutup_pins(codec);
892}
893
894static void alc_reboot_notify(struct hda_codec *codec)
895{
896 struct alc_spec *spec = codec->spec;
897
898 if (spec && spec->reboot_notify)
899 spec->reboot_notify(codec);
900 else
901 alc_shutup(codec);
902}
903
904#define alc_free snd_hda_gen_free
905
906#ifdef CONFIG_PM
907static void alc_power_eapd(struct hda_codec *codec)
908{
909 alc_auto_setup_eapd(codec, false);
910}
911
912static int alc_suspend(struct hda_codec *codec)
913{
914 struct alc_spec *spec = codec->spec;
915 alc_shutup(codec);
916 if (spec && spec->power_hook)
917 spec->power_hook(codec);
918 return 0;
919}
920#endif
921
922#ifdef CONFIG_PM
923static int alc_resume(struct hda_codec *codec)
924{
925 struct alc_spec *spec = codec->spec;
926
927 if (!spec->no_depop_delay)
928 msleep(150);
929 codec->patch_ops.init(codec);
930 snd_hda_regmap_sync(codec);
931 hda_call_check_power_status(codec, 0x01);
932 return 0;
933}
934#endif
935
936
937
938static const struct hda_codec_ops alc_patch_ops = {
939 .build_controls = alc_build_controls,
940 .build_pcms = snd_hda_gen_build_pcms,
941 .init = alc_init,
942 .free = alc_free,
943 .unsol_event = snd_hda_jack_unsol_event,
944#ifdef CONFIG_PM
945 .resume = alc_resume,
946 .suspend = alc_suspend,
947 .check_power_status = snd_hda_gen_check_power_status,
948#endif
949 .reboot_notify = alc_reboot_notify,
950};
951
952
953#define alc_codec_rename(codec, name) snd_hda_codec_set_name(codec, name)
954
955
956
957
958struct alc_codec_rename_table {
959 unsigned int vendor_id;
960 unsigned short coef_mask;
961 unsigned short coef_bits;
962 const char *name;
963};
964
965struct alc_codec_rename_pci_table {
966 unsigned int codec_vendor_id;
967 unsigned short pci_subvendor;
968 unsigned short pci_subdevice;
969 const char *name;
970};
971
972static const struct alc_codec_rename_table rename_tbl[] = {
973 { 0x10ec0221, 0xf00f, 0x1003, "ALC231" },
974 { 0x10ec0269, 0xfff0, 0x3010, "ALC277" },
975 { 0x10ec0269, 0xf0f0, 0x2010, "ALC259" },
976 { 0x10ec0269, 0xf0f0, 0x3010, "ALC258" },
977 { 0x10ec0269, 0x00f0, 0x0010, "ALC269VB" },
978 { 0x10ec0269, 0xffff, 0xa023, "ALC259" },
979 { 0x10ec0269, 0xffff, 0x6023, "ALC281X" },
980 { 0x10ec0269, 0x00f0, 0x0020, "ALC269VC" },
981 { 0x10ec0269, 0x00f0, 0x0030, "ALC269VD" },
982 { 0x10ec0662, 0xffff, 0x4020, "ALC656" },
983 { 0x10ec0887, 0x00f0, 0x0030, "ALC887-VD" },
984 { 0x10ec0888, 0x00f0, 0x0030, "ALC888-VD" },
985 { 0x10ec0888, 0xf0f0, 0x3020, "ALC886" },
986 { 0x10ec0899, 0x2000, 0x2000, "ALC899" },
987 { 0x10ec0892, 0xffff, 0x8020, "ALC661" },
988 { 0x10ec0892, 0xffff, 0x8011, "ALC661" },
989 { 0x10ec0892, 0xffff, 0x4011, "ALC656" },
990 { }
991};
992
993static const struct alc_codec_rename_pci_table rename_pci_tbl[] = {
994 { 0x10ec0280, 0x1028, 0, "ALC3220" },
995 { 0x10ec0282, 0x1028, 0, "ALC3221" },
996 { 0x10ec0283, 0x1028, 0, "ALC3223" },
997 { 0x10ec0288, 0x1028, 0, "ALC3263" },
998 { 0x10ec0292, 0x1028, 0, "ALC3226" },
999 { 0x10ec0293, 0x1028, 0, "ALC3235" },
1000 { 0x10ec0255, 0x1028, 0, "ALC3234" },
1001 { 0x10ec0668, 0x1028, 0, "ALC3661" },
1002 { 0x10ec0275, 0x1028, 0, "ALC3260" },
1003 { 0x10ec0899, 0x1028, 0, "ALC3861" },
1004 { 0x10ec0298, 0x1028, 0, "ALC3266" },
1005 { 0x10ec0236, 0x1028, 0, "ALC3204" },
1006 { 0x10ec0256, 0x1028, 0, "ALC3246" },
1007 { 0x10ec0225, 0x1028, 0, "ALC3253" },
1008 { 0x10ec0295, 0x1028, 0, "ALC3254" },
1009 { 0x10ec0299, 0x1028, 0, "ALC3271" },
1010 { 0x10ec0670, 0x1025, 0, "ALC669X" },
1011 { 0x10ec0676, 0x1025, 0, "ALC679X" },
1012 { 0x10ec0282, 0x1043, 0, "ALC3229" },
1013 { 0x10ec0233, 0x1043, 0, "ALC3236" },
1014 { 0x10ec0280, 0x103c, 0, "ALC3228" },
1015 { 0x10ec0282, 0x103c, 0, "ALC3227" },
1016 { 0x10ec0286, 0x103c, 0, "ALC3242" },
1017 { 0x10ec0290, 0x103c, 0, "ALC3241" },
1018 { 0x10ec0668, 0x103c, 0, "ALC3662" },
1019 { 0x10ec0283, 0x17aa, 0, "ALC3239" },
1020 { 0x10ec0292, 0x17aa, 0, "ALC3232" },
1021 { }
1022};
1023
1024static int alc_codec_rename_from_preset(struct hda_codec *codec)
1025{
1026 const struct alc_codec_rename_table *p;
1027 const struct alc_codec_rename_pci_table *q;
1028
1029 for (p = rename_tbl; p->vendor_id; p++) {
1030 if (p->vendor_id != codec->core.vendor_id)
1031 continue;
1032 if ((alc_get_coef0(codec) & p->coef_mask) == p->coef_bits)
1033 return alc_codec_rename(codec, p->name);
1034 }
1035
1036 if (!codec->bus->pci)
1037 return 0;
1038 for (q = rename_pci_tbl; q->codec_vendor_id; q++) {
1039 if (q->codec_vendor_id != codec->core.vendor_id)
1040 continue;
1041 if (q->pci_subvendor != codec->bus->pci->subsystem_vendor)
1042 continue;
1043 if (!q->pci_subdevice ||
1044 q->pci_subdevice == codec->bus->pci->subsystem_device)
1045 return alc_codec_rename(codec, q->name);
1046 }
1047
1048 return 0;
1049}
1050
1051
1052
1053
1054
1055#ifdef CONFIG_SND_HDA_INPUT_BEEP
1056
1057
1058static const struct snd_kcontrol_new alc_beep_mixer[] = {
1059 HDA_CODEC_VOLUME("Beep Playback Volume", 0, 0, HDA_INPUT),
1060 HDA_CODEC_MUTE_BEEP("Beep Playback Switch", 0, 0, HDA_INPUT),
1061};
1062
1063
1064static int set_beep_amp(struct alc_spec *spec, hda_nid_t nid,
1065 int idx, int dir)
1066{
1067 struct snd_kcontrol_new *knew;
1068 unsigned int beep_amp = HDA_COMPOSE_AMP_VAL(nid, 3, idx, dir);
1069 int i;
1070
1071 for (i = 0; i < ARRAY_SIZE(alc_beep_mixer); i++) {
1072 knew = snd_hda_gen_add_kctl(&spec->gen, NULL,
1073 &alc_beep_mixer[i]);
1074 if (!knew)
1075 return -ENOMEM;
1076 knew->private_value = beep_amp;
1077 }
1078 return 0;
1079}
1080
1081static const struct snd_pci_quirk beep_allow_list[] = {
1082 SND_PCI_QUIRK(0x1043, 0x103c, "ASUS", 1),
1083 SND_PCI_QUIRK(0x1043, 0x115d, "ASUS", 1),
1084 SND_PCI_QUIRK(0x1043, 0x829f, "ASUS", 1),
1085 SND_PCI_QUIRK(0x1043, 0x8376, "EeePC", 1),
1086 SND_PCI_QUIRK(0x1043, 0x83ce, "EeePC", 1),
1087 SND_PCI_QUIRK(0x1043, 0x831a, "EeePC", 1),
1088 SND_PCI_QUIRK(0x1043, 0x834a, "EeePC", 1),
1089 SND_PCI_QUIRK(0x1458, 0xa002, "GA-MA790X", 1),
1090 SND_PCI_QUIRK(0x8086, 0xd613, "Intel", 1),
1091
1092 SND_PCI_QUIRK(0x17aa, 0x309e, "Lenovo ThinkCentre M73", 0),
1093 SND_PCI_QUIRK(0x17aa, 0x30a3, "Lenovo ThinkCentre M93", 0),
1094 {}
1095};
1096
1097static inline int has_cdefine_beep(struct hda_codec *codec)
1098{
1099 struct alc_spec *spec = codec->spec;
1100 const struct snd_pci_quirk *q;
1101 q = snd_pci_quirk_lookup(codec->bus->pci, beep_allow_list);
1102 if (q)
1103 return q->value;
1104 return spec->cdefine.enable_pcbeep;
1105}
1106#else
1107#define set_beep_amp(spec, nid, idx, dir) 0
1108#define has_cdefine_beep(codec) 0
1109#endif
1110
1111
1112
1113
1114
1115static int alc_parse_auto_config(struct hda_codec *codec,
1116 const hda_nid_t *ignore_nids,
1117 const hda_nid_t *ssid_nids)
1118{
1119 struct alc_spec *spec = codec->spec;
1120 struct auto_pin_cfg *cfg = &spec->gen.autocfg;
1121 int err;
1122
1123 err = snd_hda_parse_pin_defcfg(codec, cfg, ignore_nids,
1124 spec->parse_flags);
1125 if (err < 0)
1126 return err;
1127
1128 if (ssid_nids)
1129 alc_ssid_check(codec, ssid_nids);
1130
1131 err = snd_hda_gen_parse_auto_config(codec, cfg);
1132 if (err < 0)
1133 return err;
1134
1135 return 1;
1136}
1137
1138
1139static int alc_alloc_spec(struct hda_codec *codec, hda_nid_t mixer_nid)
1140{
1141 struct alc_spec *spec = kzalloc(sizeof(*spec), GFP_KERNEL);
1142 int err;
1143
1144 if (!spec)
1145 return -ENOMEM;
1146 codec->spec = spec;
1147 snd_hda_gen_spec_init(&spec->gen);
1148 spec->gen.mixer_nid = mixer_nid;
1149 spec->gen.own_eapd_ctl = 1;
1150 codec->single_adc_amp = 1;
1151
1152 codec->spdif_status_reset = 1;
1153 codec->patch_ops = alc_patch_ops;
1154
1155 err = alc_codec_rename_from_preset(codec);
1156 if (err < 0) {
1157 kfree(spec);
1158 return err;
1159 }
1160 return 0;
1161}
1162
1163static int alc880_parse_auto_config(struct hda_codec *codec)
1164{
1165 static const hda_nid_t alc880_ignore[] = { 0x1d, 0 };
1166 static const hda_nid_t alc880_ssids[] = { 0x15, 0x1b, 0x14, 0 };
1167 return alc_parse_auto_config(codec, alc880_ignore, alc880_ssids);
1168}
1169
1170
1171
1172
1173enum {
1174 ALC880_FIXUP_GPIO1,
1175 ALC880_FIXUP_GPIO2,
1176 ALC880_FIXUP_MEDION_RIM,
1177 ALC880_FIXUP_LG,
1178 ALC880_FIXUP_LG_LW25,
1179 ALC880_FIXUP_W810,
1180 ALC880_FIXUP_EAPD_COEF,
1181 ALC880_FIXUP_TCL_S700,
1182 ALC880_FIXUP_VOL_KNOB,
1183 ALC880_FIXUP_FUJITSU,
1184 ALC880_FIXUP_F1734,
1185 ALC880_FIXUP_UNIWILL,
1186 ALC880_FIXUP_UNIWILL_DIG,
1187 ALC880_FIXUP_Z71V,
1188 ALC880_FIXUP_ASUS_W5A,
1189 ALC880_FIXUP_3ST_BASE,
1190 ALC880_FIXUP_3ST,
1191 ALC880_FIXUP_3ST_DIG,
1192 ALC880_FIXUP_5ST_BASE,
1193 ALC880_FIXUP_5ST,
1194 ALC880_FIXUP_5ST_DIG,
1195 ALC880_FIXUP_6ST_BASE,
1196 ALC880_FIXUP_6ST,
1197 ALC880_FIXUP_6ST_DIG,
1198 ALC880_FIXUP_6ST_AUTOMUTE,
1199};
1200
1201
1202static void alc880_fixup_vol_knob(struct hda_codec *codec,
1203 const struct hda_fixup *fix, int action)
1204{
1205 if (action == HDA_FIXUP_ACT_PROBE)
1206 snd_hda_jack_detect_enable_callback(codec, 0x21,
1207 alc_update_knob_master);
1208}
1209
1210static const struct hda_fixup alc880_fixups[] = {
1211 [ALC880_FIXUP_GPIO1] = {
1212 .type = HDA_FIXUP_FUNC,
1213 .v.func = alc_fixup_gpio1,
1214 },
1215 [ALC880_FIXUP_GPIO2] = {
1216 .type = HDA_FIXUP_FUNC,
1217 .v.func = alc_fixup_gpio2,
1218 },
1219 [ALC880_FIXUP_MEDION_RIM] = {
1220 .type = HDA_FIXUP_VERBS,
1221 .v.verbs = (const struct hda_verb[]) {
1222 { 0x20, AC_VERB_SET_COEF_INDEX, 0x07 },
1223 { 0x20, AC_VERB_SET_PROC_COEF, 0x3060 },
1224 { }
1225 },
1226 .chained = true,
1227 .chain_id = ALC880_FIXUP_GPIO2,
1228 },
1229 [ALC880_FIXUP_LG] = {
1230 .type = HDA_FIXUP_PINS,
1231 .v.pins = (const struct hda_pintbl[]) {
1232
1233 { 0x16, 0x411111f0 },
1234 { 0x18, 0x411111f0 },
1235 { 0x1a, 0x411111f0 },
1236 { }
1237 }
1238 },
1239 [ALC880_FIXUP_LG_LW25] = {
1240 .type = HDA_FIXUP_PINS,
1241 .v.pins = (const struct hda_pintbl[]) {
1242 { 0x1a, 0x0181344f },
1243 { 0x1b, 0x0321403f },
1244 { }
1245 }
1246 },
1247 [ALC880_FIXUP_W810] = {
1248 .type = HDA_FIXUP_PINS,
1249 .v.pins = (const struct hda_pintbl[]) {
1250
1251 { 0x17, 0x411111f0 },
1252 { }
1253 },
1254 .chained = true,
1255 .chain_id = ALC880_FIXUP_GPIO2,
1256 },
1257 [ALC880_FIXUP_EAPD_COEF] = {
1258 .type = HDA_FIXUP_VERBS,
1259 .v.verbs = (const struct hda_verb[]) {
1260
1261 { 0x20, AC_VERB_SET_COEF_INDEX, 0x07 },
1262 { 0x20, AC_VERB_SET_PROC_COEF, 0x3060 },
1263 {}
1264 },
1265 },
1266 [ALC880_FIXUP_TCL_S700] = {
1267 .type = HDA_FIXUP_VERBS,
1268 .v.verbs = (const struct hda_verb[]) {
1269
1270 { 0x20, AC_VERB_SET_COEF_INDEX, 0x07 },
1271 { 0x20, AC_VERB_SET_PROC_COEF, 0x3070 },
1272 {}
1273 },
1274 .chained = true,
1275 .chain_id = ALC880_FIXUP_GPIO2,
1276 },
1277 [ALC880_FIXUP_VOL_KNOB] = {
1278 .type = HDA_FIXUP_FUNC,
1279 .v.func = alc880_fixup_vol_knob,
1280 },
1281 [ALC880_FIXUP_FUJITSU] = {
1282
1283 .type = HDA_FIXUP_PINS,
1284 .v.pins = (const struct hda_pintbl[]) {
1285 { 0x14, 0x0121401f },
1286 { 0x15, 0x99030120 },
1287 { 0x16, 0x99030130 },
1288 { 0x17, 0x411111f0 },
1289 { 0x18, 0x411111f0 },
1290 { 0x19, 0x01a19950 },
1291 { 0x1a, 0x411111f0 },
1292 { 0x1b, 0x411111f0 },
1293 { 0x1c, 0x411111f0 },
1294 { 0x1d, 0x411111f0 },
1295 { 0x1e, 0x01454140 },
1296 { }
1297 },
1298 .chained = true,
1299 .chain_id = ALC880_FIXUP_VOL_KNOB,
1300 },
1301 [ALC880_FIXUP_F1734] = {
1302
1303 .type = HDA_FIXUP_PINS,
1304 .v.pins = (const struct hda_pintbl[]) {
1305 { 0x14, 0x0121401f },
1306 { 0x15, 0x99030120 },
1307 { 0x16, 0x411111f0 },
1308 { 0x17, 0x411111f0 },
1309 { 0x18, 0x411111f0 },
1310 { 0x19, 0x01a19950 },
1311 { 0x1a, 0x411111f0 },
1312 { 0x1b, 0x411111f0 },
1313 { 0x1c, 0x411111f0 },
1314 { 0x1d, 0x411111f0 },
1315 { 0x1e, 0x411111f0 },
1316 { }
1317 },
1318 .chained = true,
1319 .chain_id = ALC880_FIXUP_VOL_KNOB,
1320 },
1321 [ALC880_FIXUP_UNIWILL] = {
1322
1323 .type = HDA_FIXUP_PINS,
1324 .v.pins = (const struct hda_pintbl[]) {
1325 { 0x14, 0x0121411f },
1326 { 0x15, 0x99030120 },
1327 { 0x16, 0x99030130 },
1328 { }
1329 },
1330 },
1331 [ALC880_FIXUP_UNIWILL_DIG] = {
1332 .type = HDA_FIXUP_PINS,
1333 .v.pins = (const struct hda_pintbl[]) {
1334
1335 { 0x17, 0x411111f0 },
1336 { 0x19, 0x411111f0 },
1337 { 0x1b, 0x411111f0 },
1338 { 0x1f, 0x411111f0 },
1339 { }
1340 }
1341 },
1342 [ALC880_FIXUP_Z71V] = {
1343 .type = HDA_FIXUP_PINS,
1344 .v.pins = (const struct hda_pintbl[]) {
1345
1346 { 0x14, 0x99030120 },
1347 { 0x15, 0x0121411f },
1348 { 0x16, 0x411111f0 },
1349 { 0x17, 0x411111f0 },
1350 { 0x18, 0x01a19950 },
1351 { 0x19, 0x411111f0 },
1352 { 0x1a, 0x01813031 },
1353 { 0x1b, 0x411111f0 },
1354 { 0x1c, 0x411111f0 },
1355 { 0x1d, 0x411111f0 },
1356 { 0x1e, 0x0144111e },
1357 { }
1358 }
1359 },
1360 [ALC880_FIXUP_ASUS_W5A] = {
1361 .type = HDA_FIXUP_PINS,
1362 .v.pins = (const struct hda_pintbl[]) {
1363
1364 { 0x14, 0x0121411f },
1365 { 0x15, 0x411111f0 },
1366 { 0x16, 0x411111f0 },
1367 { 0x17, 0x411111f0 },
1368 { 0x18, 0x90a60160 },
1369 { 0x19, 0x411111f0 },
1370 { 0x1a, 0x411111f0 },
1371 { 0x1b, 0x411111f0 },
1372 { 0x1c, 0x411111f0 },
1373 { 0x1d, 0x411111f0 },
1374 { 0x1e, 0xb743111e },
1375 { }
1376 },
1377 .chained = true,
1378 .chain_id = ALC880_FIXUP_GPIO1,
1379 },
1380 [ALC880_FIXUP_3ST_BASE] = {
1381 .type = HDA_FIXUP_PINS,
1382 .v.pins = (const struct hda_pintbl[]) {
1383 { 0x14, 0x01014010 },
1384 { 0x15, 0x411111f0 },
1385 { 0x16, 0x411111f0 },
1386 { 0x17, 0x411111f0 },
1387 { 0x18, 0x01a19c30 },
1388 { 0x19, 0x0121411f },
1389 { 0x1a, 0x01813031 },
1390 { 0x1b, 0x02a19c40 },
1391 { 0x1c, 0x411111f0 },
1392 { 0x1d, 0x411111f0 },
1393
1394 { 0x1f, 0x411111f0 },
1395 { }
1396 }
1397 },
1398 [ALC880_FIXUP_3ST] = {
1399 .type = HDA_FIXUP_PINS,
1400 .v.pins = (const struct hda_pintbl[]) {
1401 { 0x1e, 0x411111f0 },
1402 { }
1403 },
1404 .chained = true,
1405 .chain_id = ALC880_FIXUP_3ST_BASE,
1406 },
1407 [ALC880_FIXUP_3ST_DIG] = {
1408 .type = HDA_FIXUP_PINS,
1409 .v.pins = (const struct hda_pintbl[]) {
1410 { 0x1e, 0x0144111e },
1411 { }
1412 },
1413 .chained = true,
1414 .chain_id = ALC880_FIXUP_3ST_BASE,
1415 },
1416 [ALC880_FIXUP_5ST_BASE] = {
1417 .type = HDA_FIXUP_PINS,
1418 .v.pins = (const struct hda_pintbl[]) {
1419 { 0x14, 0x01014010 },
1420 { 0x15, 0x411111f0 },
1421 { 0x16, 0x01011411 },
1422 { 0x17, 0x01016412 },
1423 { 0x18, 0x01a19c30 },
1424 { 0x19, 0x0121411f },
1425 { 0x1a, 0x01813031 },
1426 { 0x1b, 0x02a19c40 },
1427 { 0x1c, 0x411111f0 },
1428 { 0x1d, 0x411111f0 },
1429
1430 { 0x1f, 0x411111f0 },
1431 { }
1432 }
1433 },
1434 [ALC880_FIXUP_5ST] = {
1435 .type = HDA_FIXUP_PINS,
1436 .v.pins = (const struct hda_pintbl[]) {
1437 { 0x1e, 0x411111f0 },
1438 { }
1439 },
1440 .chained = true,
1441 .chain_id = ALC880_FIXUP_5ST_BASE,
1442 },
1443 [ALC880_FIXUP_5ST_DIG] = {
1444 .type = HDA_FIXUP_PINS,
1445 .v.pins = (const struct hda_pintbl[]) {
1446 { 0x1e, 0x0144111e },
1447 { }
1448 },
1449 .chained = true,
1450 .chain_id = ALC880_FIXUP_5ST_BASE,
1451 },
1452 [ALC880_FIXUP_6ST_BASE] = {
1453 .type = HDA_FIXUP_PINS,
1454 .v.pins = (const struct hda_pintbl[]) {
1455 { 0x14, 0x01014010 },
1456 { 0x15, 0x01016412 },
1457 { 0x16, 0x01011411 },
1458 { 0x17, 0x01012414 },
1459 { 0x18, 0x01a19c30 },
1460 { 0x19, 0x02a19c40 },
1461 { 0x1a, 0x01813031 },
1462 { 0x1b, 0x0121411f },
1463 { 0x1c, 0x411111f0 },
1464 { 0x1d, 0x411111f0 },
1465
1466 { 0x1f, 0x411111f0 },
1467 { }
1468 }
1469 },
1470 [ALC880_FIXUP_6ST] = {
1471 .type = HDA_FIXUP_PINS,
1472 .v.pins = (const struct hda_pintbl[]) {
1473 { 0x1e, 0x411111f0 },
1474 { }
1475 },
1476 .chained = true,
1477 .chain_id = ALC880_FIXUP_6ST_BASE,
1478 },
1479 [ALC880_FIXUP_6ST_DIG] = {
1480 .type = HDA_FIXUP_PINS,
1481 .v.pins = (const struct hda_pintbl[]) {
1482 { 0x1e, 0x0144111e },
1483 { }
1484 },
1485 .chained = true,
1486 .chain_id = ALC880_FIXUP_6ST_BASE,
1487 },
1488 [ALC880_FIXUP_6ST_AUTOMUTE] = {
1489 .type = HDA_FIXUP_PINS,
1490 .v.pins = (const struct hda_pintbl[]) {
1491 { 0x1b, 0x0121401f },
1492 { }
1493 },
1494 .chained_before = true,
1495 .chain_id = ALC880_FIXUP_6ST_BASE,
1496 },
1497};
1498
1499static const struct snd_pci_quirk alc880_fixup_tbl[] = {
1500 SND_PCI_QUIRK(0x1019, 0x0f69, "Coeus G610P", ALC880_FIXUP_W810),
1501 SND_PCI_QUIRK(0x1043, 0x10c3, "ASUS W5A", ALC880_FIXUP_ASUS_W5A),
1502 SND_PCI_QUIRK(0x1043, 0x1964, "ASUS Z71V", ALC880_FIXUP_Z71V),
1503 SND_PCI_QUIRK_VENDOR(0x1043, "ASUS", ALC880_FIXUP_GPIO1),
1504 SND_PCI_QUIRK(0x147b, 0x1045, "ABit AA8XE", ALC880_FIXUP_6ST_AUTOMUTE),
1505 SND_PCI_QUIRK(0x1558, 0x5401, "Clevo GPIO2", ALC880_FIXUP_GPIO2),
1506 SND_PCI_QUIRK_VENDOR(0x1558, "Clevo", ALC880_FIXUP_EAPD_COEF),
1507 SND_PCI_QUIRK(0x1584, 0x9050, "Uniwill", ALC880_FIXUP_UNIWILL_DIG),
1508 SND_PCI_QUIRK(0x1584, 0x9054, "Uniwill", ALC880_FIXUP_F1734),
1509 SND_PCI_QUIRK(0x1584, 0x9070, "Uniwill", ALC880_FIXUP_UNIWILL),
1510 SND_PCI_QUIRK(0x1584, 0x9077, "Uniwill P53", ALC880_FIXUP_VOL_KNOB),
1511 SND_PCI_QUIRK(0x161f, 0x203d, "W810", ALC880_FIXUP_W810),
1512 SND_PCI_QUIRK(0x161f, 0x205d, "Medion Rim 2150", ALC880_FIXUP_MEDION_RIM),
1513 SND_PCI_QUIRK(0x1631, 0xe011, "PB 13201056", ALC880_FIXUP_6ST_AUTOMUTE),
1514 SND_PCI_QUIRK(0x1734, 0x107c, "FSC Amilo M1437", ALC880_FIXUP_FUJITSU),
1515 SND_PCI_QUIRK(0x1734, 0x1094, "FSC Amilo M1451G", ALC880_FIXUP_FUJITSU),
1516 SND_PCI_QUIRK(0x1734, 0x10ac, "FSC AMILO Xi 1526", ALC880_FIXUP_F1734),
1517 SND_PCI_QUIRK(0x1734, 0x10b0, "FSC Amilo Pi1556", ALC880_FIXUP_FUJITSU),
1518 SND_PCI_QUIRK(0x1854, 0x003b, "LG", ALC880_FIXUP_LG),
1519 SND_PCI_QUIRK(0x1854, 0x005f, "LG P1 Express", ALC880_FIXUP_LG),
1520 SND_PCI_QUIRK(0x1854, 0x0068, "LG w1", ALC880_FIXUP_LG),
1521 SND_PCI_QUIRK(0x1854, 0x0077, "LG LW25", ALC880_FIXUP_LG_LW25),
1522 SND_PCI_QUIRK(0x19db, 0x4188, "TCL S700", ALC880_FIXUP_TCL_S700),
1523
1524
1525
1526
1527
1528
1529
1530 SND_PCI_QUIRK(0x1019, 0xa880, "ECS", ALC880_FIXUP_5ST_DIG),
1531 SND_PCI_QUIRK(0x1019, 0xa884, "Acer APFV", ALC880_FIXUP_6ST),
1532 SND_PCI_QUIRK(0x1025, 0x0070, "ULI", ALC880_FIXUP_3ST_DIG),
1533 SND_PCI_QUIRK(0x1025, 0x0077, "ULI", ALC880_FIXUP_6ST_DIG),
1534 SND_PCI_QUIRK(0x1025, 0x0078, "ULI", ALC880_FIXUP_6ST_DIG),
1535 SND_PCI_QUIRK(0x1025, 0x0087, "ULI", ALC880_FIXUP_6ST_DIG),
1536 SND_PCI_QUIRK(0x1025, 0xe309, "ULI", ALC880_FIXUP_3ST_DIG),
1537 SND_PCI_QUIRK(0x1025, 0xe310, "ULI", ALC880_FIXUP_3ST),
1538 SND_PCI_QUIRK(0x1039, 0x1234, NULL, ALC880_FIXUP_6ST_DIG),
1539 SND_PCI_QUIRK(0x104d, 0x81a0, "Sony", ALC880_FIXUP_3ST),
1540 SND_PCI_QUIRK(0x104d, 0x81d6, "Sony", ALC880_FIXUP_3ST),
1541 SND_PCI_QUIRK(0x107b, 0x3032, "Gateway", ALC880_FIXUP_5ST),
1542 SND_PCI_QUIRK(0x107b, 0x3033, "Gateway", ALC880_FIXUP_5ST),
1543 SND_PCI_QUIRK(0x107b, 0x4039, "Gateway", ALC880_FIXUP_5ST),
1544 SND_PCI_QUIRK(0x1297, 0xc790, "Shuttle ST20G5", ALC880_FIXUP_6ST_DIG),
1545 SND_PCI_QUIRK(0x1458, 0xa102, "Gigabyte K8", ALC880_FIXUP_6ST_DIG),
1546 SND_PCI_QUIRK(0x1462, 0x1150, "MSI", ALC880_FIXUP_6ST_DIG),
1547 SND_PCI_QUIRK(0x1509, 0x925d, "FIC P4M", ALC880_FIXUP_6ST_DIG),
1548 SND_PCI_QUIRK(0x1565, 0x8202, "Biostar", ALC880_FIXUP_5ST_DIG),
1549 SND_PCI_QUIRK(0x1695, 0x400d, "EPoX", ALC880_FIXUP_5ST_DIG),
1550 SND_PCI_QUIRK(0x1695, 0x4012, "EPox EP-5LDA", ALC880_FIXUP_5ST_DIG),
1551 SND_PCI_QUIRK(0x2668, 0x8086, NULL, ALC880_FIXUP_6ST_DIG),
1552 SND_PCI_QUIRK(0x8086, 0x2668, NULL, ALC880_FIXUP_6ST_DIG),
1553 SND_PCI_QUIRK(0x8086, 0xa100, "Intel mobo", ALC880_FIXUP_5ST_DIG),
1554 SND_PCI_QUIRK(0x8086, 0xd400, "Intel mobo", ALC880_FIXUP_5ST_DIG),
1555 SND_PCI_QUIRK(0x8086, 0xd401, "Intel mobo", ALC880_FIXUP_5ST_DIG),
1556 SND_PCI_QUIRK(0x8086, 0xd402, "Intel mobo", ALC880_FIXUP_3ST_DIG),
1557 SND_PCI_QUIRK(0x8086, 0xe224, "Intel mobo", ALC880_FIXUP_5ST_DIG),
1558 SND_PCI_QUIRK(0x8086, 0xe305, "Intel mobo", ALC880_FIXUP_3ST_DIG),
1559 SND_PCI_QUIRK(0x8086, 0xe308, "Intel mobo", ALC880_FIXUP_3ST_DIG),
1560 SND_PCI_QUIRK(0x8086, 0xe400, "Intel mobo", ALC880_FIXUP_5ST_DIG),
1561 SND_PCI_QUIRK(0x8086, 0xe401, "Intel mobo", ALC880_FIXUP_5ST_DIG),
1562 SND_PCI_QUIRK(0x8086, 0xe402, "Intel mobo", ALC880_FIXUP_5ST_DIG),
1563
1564 SND_PCI_QUIRK_VENDOR(0x8086, "Intel mobo", ALC880_FIXUP_3ST),
1565 SND_PCI_QUIRK(0xa0a0, 0x0560, "AOpen i915GMm-HFS", ALC880_FIXUP_5ST_DIG),
1566 SND_PCI_QUIRK(0xe803, 0x1019, NULL, ALC880_FIXUP_6ST_DIG),
1567 {}
1568};
1569
1570static const struct hda_model_fixup alc880_fixup_models[] = {
1571 {.id = ALC880_FIXUP_3ST, .name = "3stack"},
1572 {.id = ALC880_FIXUP_3ST_DIG, .name = "3stack-digout"},
1573 {.id = ALC880_FIXUP_5ST, .name = "5stack"},
1574 {.id = ALC880_FIXUP_5ST_DIG, .name = "5stack-digout"},
1575 {.id = ALC880_FIXUP_6ST, .name = "6stack"},
1576 {.id = ALC880_FIXUP_6ST_DIG, .name = "6stack-digout"},
1577 {.id = ALC880_FIXUP_6ST_AUTOMUTE, .name = "6stack-automute"},
1578 {}
1579};
1580
1581
1582
1583
1584
1585static int patch_alc880(struct hda_codec *codec)
1586{
1587 struct alc_spec *spec;
1588 int err;
1589
1590 err = alc_alloc_spec(codec, 0x0b);
1591 if (err < 0)
1592 return err;
1593
1594 spec = codec->spec;
1595 spec->gen.need_dac_fix = 1;
1596 spec->gen.beep_nid = 0x01;
1597
1598 codec->patch_ops.unsol_event = alc880_unsol_event;
1599
1600 alc_pre_init(codec);
1601
1602 snd_hda_pick_fixup(codec, alc880_fixup_models, alc880_fixup_tbl,
1603 alc880_fixups);
1604 snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE);
1605
1606
1607 err = alc880_parse_auto_config(codec);
1608 if (err < 0)
1609 goto error;
1610
1611 if (!spec->gen.no_analog) {
1612 err = set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
1613 if (err < 0)
1614 goto error;
1615 }
1616
1617 snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE);
1618
1619 return 0;
1620
1621 error:
1622 alc_free(codec);
1623 return err;
1624}
1625
1626
1627
1628
1629
1630static int alc260_parse_auto_config(struct hda_codec *codec)
1631{
1632 static const hda_nid_t alc260_ignore[] = { 0x17, 0 };
1633 static const hda_nid_t alc260_ssids[] = { 0x10, 0x15, 0x0f, 0 };
1634 return alc_parse_auto_config(codec, alc260_ignore, alc260_ssids);
1635}
1636
1637
1638
1639
1640enum {
1641 ALC260_FIXUP_HP_DC5750,
1642 ALC260_FIXUP_HP_PIN_0F,
1643 ALC260_FIXUP_COEF,
1644 ALC260_FIXUP_GPIO1,
1645 ALC260_FIXUP_GPIO1_TOGGLE,
1646 ALC260_FIXUP_REPLACER,
1647 ALC260_FIXUP_HP_B1900,
1648 ALC260_FIXUP_KN1,
1649 ALC260_FIXUP_FSC_S7020,
1650 ALC260_FIXUP_FSC_S7020_JWSE,
1651 ALC260_FIXUP_VAIO_PINS,
1652};
1653
1654static void alc260_gpio1_automute(struct hda_codec *codec)
1655{
1656 struct alc_spec *spec = codec->spec;
1657
1658 alc_update_gpio_data(codec, 0x01, spec->gen.hp_jack_present);
1659}
1660
1661static void alc260_fixup_gpio1_toggle(struct hda_codec *codec,
1662 const struct hda_fixup *fix, int action)
1663{
1664 struct alc_spec *spec = codec->spec;
1665 if (action == HDA_FIXUP_ACT_PROBE) {
1666
1667
1668
1669 spec->gen.automute_hook = alc260_gpio1_automute;
1670 spec->gen.detect_hp = 1;
1671 spec->gen.automute_speaker = 1;
1672 spec->gen.autocfg.hp_pins[0] = 0x0f;
1673 snd_hda_jack_detect_enable_callback(codec, 0x0f,
1674 snd_hda_gen_hp_automute);
1675 alc_setup_gpio(codec, 0x01);
1676 }
1677}
1678
1679static void alc260_fixup_kn1(struct hda_codec *codec,
1680 const struct hda_fixup *fix, int action)
1681{
1682 struct alc_spec *spec = codec->spec;
1683 static const struct hda_pintbl pincfgs[] = {
1684 { 0x0f, 0x02214000 },
1685 { 0x12, 0x90a60160 },
1686 { 0x13, 0x02a19000 },
1687 { 0x18, 0x01446000 },
1688
1689 { 0x10, 0x411111f0 },
1690 { 0x11, 0x411111f0 },
1691 { 0x14, 0x411111f0 },
1692 { 0x15, 0x411111f0 },
1693 { 0x16, 0x411111f0 },
1694 { 0x17, 0x411111f0 },
1695 { 0x19, 0x411111f0 },
1696 { }
1697 };
1698
1699 switch (action) {
1700 case HDA_FIXUP_ACT_PRE_PROBE:
1701 snd_hda_apply_pincfgs(codec, pincfgs);
1702 spec->init_amp = ALC_INIT_NONE;
1703 break;
1704 }
1705}
1706
1707static void alc260_fixup_fsc_s7020(struct hda_codec *codec,
1708 const struct hda_fixup *fix, int action)
1709{
1710 struct alc_spec *spec = codec->spec;
1711 if (action == HDA_FIXUP_ACT_PRE_PROBE)
1712 spec->init_amp = ALC_INIT_NONE;
1713}
1714
1715static void alc260_fixup_fsc_s7020_jwse(struct hda_codec *codec,
1716 const struct hda_fixup *fix, int action)
1717{
1718 struct alc_spec *spec = codec->spec;
1719 if (action == HDA_FIXUP_ACT_PRE_PROBE) {
1720 spec->gen.add_jack_modes = 1;
1721 spec->gen.hp_mic = 1;
1722 }
1723}
1724
1725static const struct hda_fixup alc260_fixups[] = {
1726 [ALC260_FIXUP_HP_DC5750] = {
1727 .type = HDA_FIXUP_PINS,
1728 .v.pins = (const struct hda_pintbl[]) {
1729 { 0x11, 0x90130110 },
1730 { }
1731 }
1732 },
1733 [ALC260_FIXUP_HP_PIN_0F] = {
1734 .type = HDA_FIXUP_PINS,
1735 .v.pins = (const struct hda_pintbl[]) {
1736 { 0x0f, 0x01214000 },
1737 { }
1738 }
1739 },
1740 [ALC260_FIXUP_COEF] = {
1741 .type = HDA_FIXUP_VERBS,
1742 .v.verbs = (const struct hda_verb[]) {
1743 { 0x1a, AC_VERB_SET_COEF_INDEX, 0x07 },
1744 { 0x1a, AC_VERB_SET_PROC_COEF, 0x3040 },
1745 { }
1746 },
1747 },
1748 [ALC260_FIXUP_GPIO1] = {
1749 .type = HDA_FIXUP_FUNC,
1750 .v.func = alc_fixup_gpio1,
1751 },
1752 [ALC260_FIXUP_GPIO1_TOGGLE] = {
1753 .type = HDA_FIXUP_FUNC,
1754 .v.func = alc260_fixup_gpio1_toggle,
1755 .chained = true,
1756 .chain_id = ALC260_FIXUP_HP_PIN_0F,
1757 },
1758 [ALC260_FIXUP_REPLACER] = {
1759 .type = HDA_FIXUP_VERBS,
1760 .v.verbs = (const struct hda_verb[]) {
1761 { 0x1a, AC_VERB_SET_COEF_INDEX, 0x07 },
1762 { 0x1a, AC_VERB_SET_PROC_COEF, 0x3050 },
1763 { }
1764 },
1765 .chained = true,
1766 .chain_id = ALC260_FIXUP_GPIO1_TOGGLE,
1767 },
1768 [ALC260_FIXUP_HP_B1900] = {
1769 .type = HDA_FIXUP_FUNC,
1770 .v.func = alc260_fixup_gpio1_toggle,
1771 .chained = true,
1772 .chain_id = ALC260_FIXUP_COEF,
1773 },
1774 [ALC260_FIXUP_KN1] = {
1775 .type = HDA_FIXUP_FUNC,
1776 .v.func = alc260_fixup_kn1,
1777 },
1778 [ALC260_FIXUP_FSC_S7020] = {
1779 .type = HDA_FIXUP_FUNC,
1780 .v.func = alc260_fixup_fsc_s7020,
1781 },
1782 [ALC260_FIXUP_FSC_S7020_JWSE] = {
1783 .type = HDA_FIXUP_FUNC,
1784 .v.func = alc260_fixup_fsc_s7020_jwse,
1785 .chained = true,
1786 .chain_id = ALC260_FIXUP_FSC_S7020,
1787 },
1788 [ALC260_FIXUP_VAIO_PINS] = {
1789 .type = HDA_FIXUP_PINS,
1790 .v.pins = (const struct hda_pintbl[]) {
1791
1792 { 0x0f, 0x01211020 },
1793 { 0x10, 0x0001003f },
1794 { 0x11, 0x411111f0 },
1795 { 0x12, 0x01a15930 },
1796 { 0x13, 0x411111f0 },
1797 { 0x14, 0x411111f0 },
1798 { 0x15, 0x411111f0 },
1799 { 0x16, 0x411111f0 },
1800 { 0x17, 0x411111f0 },
1801 { 0x18, 0x411111f0 },
1802 { 0x19, 0x411111f0 },
1803 { }
1804 }
1805 },
1806};
1807
1808static const struct snd_pci_quirk alc260_fixup_tbl[] = {
1809 SND_PCI_QUIRK(0x1025, 0x007b, "Acer C20x", ALC260_FIXUP_GPIO1),
1810 SND_PCI_QUIRK(0x1025, 0x007f, "Acer Aspire 9500", ALC260_FIXUP_COEF),
1811 SND_PCI_QUIRK(0x1025, 0x008f, "Acer", ALC260_FIXUP_GPIO1),
1812 SND_PCI_QUIRK(0x103c, 0x280a, "HP dc5750", ALC260_FIXUP_HP_DC5750),
1813 SND_PCI_QUIRK(0x103c, 0x30ba, "HP Presario B1900", ALC260_FIXUP_HP_B1900),
1814 SND_PCI_QUIRK(0x104d, 0x81bb, "Sony VAIO", ALC260_FIXUP_VAIO_PINS),
1815 SND_PCI_QUIRK(0x104d, 0x81e2, "Sony VAIO TX", ALC260_FIXUP_HP_PIN_0F),
1816 SND_PCI_QUIRK(0x10cf, 0x1326, "FSC LifeBook S7020", ALC260_FIXUP_FSC_S7020),
1817 SND_PCI_QUIRK(0x1509, 0x4540, "Favorit 100XS", ALC260_FIXUP_GPIO1),
1818 SND_PCI_QUIRK(0x152d, 0x0729, "Quanta KN1", ALC260_FIXUP_KN1),
1819 SND_PCI_QUIRK(0x161f, 0x2057, "Replacer 672V", ALC260_FIXUP_REPLACER),
1820 SND_PCI_QUIRK(0x1631, 0xc017, "PB V7900", ALC260_FIXUP_COEF),
1821 {}
1822};
1823
1824static const struct hda_model_fixup alc260_fixup_models[] = {
1825 {.id = ALC260_FIXUP_GPIO1, .name = "gpio1"},
1826 {.id = ALC260_FIXUP_COEF, .name = "coef"},
1827 {.id = ALC260_FIXUP_FSC_S7020, .name = "fujitsu"},
1828 {.id = ALC260_FIXUP_FSC_S7020_JWSE, .name = "fujitsu-jwse"},
1829 {}
1830};
1831
1832
1833
1834static int patch_alc260(struct hda_codec *codec)
1835{
1836 struct alc_spec *spec;
1837 int err;
1838
1839 err = alc_alloc_spec(codec, 0x07);
1840 if (err < 0)
1841 return err;
1842
1843 spec = codec->spec;
1844
1845
1846
1847
1848 spec->gen.prefer_hp_amp = 1;
1849 spec->gen.beep_nid = 0x01;
1850
1851 spec->shutup = alc_eapd_shutup;
1852
1853 alc_pre_init(codec);
1854
1855 snd_hda_pick_fixup(codec, alc260_fixup_models, alc260_fixup_tbl,
1856 alc260_fixups);
1857 snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE);
1858
1859
1860 err = alc260_parse_auto_config(codec);
1861 if (err < 0)
1862 goto error;
1863
1864 if (!spec->gen.no_analog) {
1865 err = set_beep_amp(spec, 0x07, 0x05, HDA_INPUT);
1866 if (err < 0)
1867 goto error;
1868 }
1869
1870 snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE);
1871
1872 return 0;
1873
1874 error:
1875 alc_free(codec);
1876 return err;
1877}
1878
1879
1880
1881
1882
1883
1884
1885
1886
1887
1888
1889
1890
1891
1892
1893
1894
1895enum {
1896 ALC882_FIXUP_ABIT_AW9D_MAX,
1897 ALC882_FIXUP_LENOVO_Y530,
1898 ALC882_FIXUP_PB_M5210,
1899 ALC882_FIXUP_ACER_ASPIRE_7736,
1900 ALC882_FIXUP_ASUS_W90V,
1901 ALC889_FIXUP_CD,
1902 ALC889_FIXUP_FRONT_HP_NO_PRESENCE,
1903 ALC889_FIXUP_VAIO_TT,
1904 ALC888_FIXUP_EEE1601,
1905 ALC882_FIXUP_EAPD,
1906 ALC883_FIXUP_EAPD,
1907 ALC883_FIXUP_ACER_EAPD,
1908 ALC882_FIXUP_GPIO1,
1909 ALC882_FIXUP_GPIO2,
1910 ALC882_FIXUP_GPIO3,
1911 ALC889_FIXUP_COEF,
1912 ALC882_FIXUP_ASUS_W2JC,
1913 ALC882_FIXUP_ACER_ASPIRE_4930G,
1914 ALC882_FIXUP_ACER_ASPIRE_8930G,
1915 ALC882_FIXUP_ASPIRE_8930G_VERBS,
1916 ALC885_FIXUP_MACPRO_GPIO,
1917 ALC889_FIXUP_DAC_ROUTE,
1918 ALC889_FIXUP_MBP_VREF,
1919 ALC889_FIXUP_IMAC91_VREF,
1920 ALC889_FIXUP_MBA11_VREF,
1921 ALC889_FIXUP_MBA21_VREF,
1922 ALC889_FIXUP_MP11_VREF,
1923 ALC889_FIXUP_MP41_VREF,
1924 ALC882_FIXUP_INV_DMIC,
1925 ALC882_FIXUP_NO_PRIMARY_HP,
1926 ALC887_FIXUP_ASUS_BASS,
1927 ALC887_FIXUP_BASS_CHMAP,
1928 ALC1220_FIXUP_GB_DUAL_CODECS,
1929 ALC1220_FIXUP_CLEVO_P950,
1930 ALC1220_FIXUP_CLEVO_PB51ED,
1931 ALC1220_FIXUP_CLEVO_PB51ED_PINS,
1932};
1933
1934static void alc889_fixup_coef(struct hda_codec *codec,
1935 const struct hda_fixup *fix, int action)
1936{
1937 if (action != HDA_FIXUP_ACT_INIT)
1938 return;
1939 alc_update_coef_idx(codec, 7, 0, 0x2030);
1940}
1941
1942
1943static void alc885_fixup_macpro_gpio(struct hda_codec *codec,
1944 const struct hda_fixup *fix, int action)
1945{
1946 struct alc_spec *spec = codec->spec;
1947
1948 spec->gpio_write_delay = true;
1949 alc_fixup_gpio3(codec, fix, action);
1950}
1951
1952
1953
1954
1955
1956static void alc889_fixup_dac_route(struct hda_codec *codec,
1957 const struct hda_fixup *fix, int action)
1958{
1959 if (action == HDA_FIXUP_ACT_PRE_PROBE) {
1960
1961 static const hda_nid_t conn1[] = { 0x0c, 0x0d };
1962 static const hda_nid_t conn2[] = { 0x0e, 0x0f };
1963 snd_hda_override_conn_list(codec, 0x14, ARRAY_SIZE(conn1), conn1);
1964 snd_hda_override_conn_list(codec, 0x15, ARRAY_SIZE(conn1), conn1);
1965 snd_hda_override_conn_list(codec, 0x18, ARRAY_SIZE(conn2), conn2);
1966 snd_hda_override_conn_list(codec, 0x1a, ARRAY_SIZE(conn2), conn2);
1967 } else if (action == HDA_FIXUP_ACT_PROBE) {
1968
1969 static const hda_nid_t conn[] = { 0x0c, 0x0d, 0x0e, 0x0f, 0x26 };
1970 snd_hda_override_conn_list(codec, 0x14, ARRAY_SIZE(conn), conn);
1971 snd_hda_override_conn_list(codec, 0x15, ARRAY_SIZE(conn), conn);
1972 snd_hda_override_conn_list(codec, 0x18, ARRAY_SIZE(conn), conn);
1973 snd_hda_override_conn_list(codec, 0x1a, ARRAY_SIZE(conn), conn);
1974 }
1975}
1976
1977
1978static void alc889_fixup_mbp_vref(struct hda_codec *codec,
1979 const struct hda_fixup *fix, int action)
1980{
1981 static const hda_nid_t nids[] = { 0x14, 0x15, 0x19 };
1982 struct alc_spec *spec = codec->spec;
1983 int i;
1984
1985 if (action != HDA_FIXUP_ACT_INIT)
1986 return;
1987 for (i = 0; i < ARRAY_SIZE(nids); i++) {
1988 unsigned int val = snd_hda_codec_get_pincfg(codec, nids[i]);
1989 if (get_defcfg_device(val) != AC_JACK_HP_OUT)
1990 continue;
1991 val = snd_hda_codec_get_pin_target(codec, nids[i]);
1992 val |= AC_PINCTL_VREF_80;
1993 snd_hda_set_pin_ctl(codec, nids[i], val);
1994 spec->gen.keep_vref_in_automute = 1;
1995 break;
1996 }
1997}
1998
1999static void alc889_fixup_mac_pins(struct hda_codec *codec,
2000 const hda_nid_t *nids, int num_nids)
2001{
2002 struct alc_spec *spec = codec->spec;
2003 int i;
2004
2005 for (i = 0; i < num_nids; i++) {
2006 unsigned int val;
2007 val = snd_hda_codec_get_pin_target(codec, nids[i]);
2008 val |= AC_PINCTL_VREF_50;
2009 snd_hda_set_pin_ctl(codec, nids[i], val);
2010 }
2011 spec->gen.keep_vref_in_automute = 1;
2012}
2013
2014
2015static void alc889_fixup_imac91_vref(struct hda_codec *codec,
2016 const struct hda_fixup *fix, int action)
2017{
2018 static const hda_nid_t nids[] = { 0x18, 0x1a };
2019
2020 if (action == HDA_FIXUP_ACT_INIT)
2021 alc889_fixup_mac_pins(codec, nids, ARRAY_SIZE(nids));
2022}
2023
2024
2025static void alc889_fixup_mba11_vref(struct hda_codec *codec,
2026 const struct hda_fixup *fix, int action)
2027{
2028 static const hda_nid_t nids[] = { 0x18 };
2029
2030 if (action == HDA_FIXUP_ACT_INIT)
2031 alc889_fixup_mac_pins(codec, nids, ARRAY_SIZE(nids));
2032}
2033
2034
2035static void alc889_fixup_mba21_vref(struct hda_codec *codec,
2036 const struct hda_fixup *fix, int action)
2037{
2038 static const hda_nid_t nids[] = { 0x18, 0x19 };
2039
2040 if (action == HDA_FIXUP_ACT_INIT)
2041 alc889_fixup_mac_pins(codec, nids, ARRAY_SIZE(nids));
2042}
2043
2044
2045
2046
2047
2048static void alc882_fixup_no_primary_hp(struct hda_codec *codec,
2049 const struct hda_fixup *fix, int action)
2050{
2051 struct alc_spec *spec = codec->spec;
2052 if (action == HDA_FIXUP_ACT_PRE_PROBE) {
2053 spec->gen.no_primary_hp = 1;
2054 spec->gen.no_multi_io = 1;
2055 }
2056}
2057
2058static void alc_fixup_bass_chmap(struct hda_codec *codec,
2059 const struct hda_fixup *fix, int action);
2060
2061
2062
2063
2064static void alc_fixup_dual_codecs(struct hda_codec *codec,
2065 const struct hda_fixup *fix, int action)
2066{
2067 struct alc_spec *spec = codec->spec;
2068
2069 if (action != HDA_FIXUP_ACT_PRE_PROBE)
2070 return;
2071
2072 spec->gen.suppress_vmaster = 1;
2073
2074 spec->gen.suppress_auto_mute = 1;
2075 spec->gen.suppress_auto_mic = 1;
2076
2077 spec->gen.mixer_nid = 0;
2078
2079 codec->force_pin_prefix = 1;
2080}
2081
2082static void rename_ctl(struct hda_codec *codec, const char *oldname,
2083 const char *newname)
2084{
2085 struct snd_kcontrol *kctl;
2086
2087 kctl = snd_hda_find_mixer_ctl(codec, oldname);
2088 if (kctl)
2089 strcpy(kctl->id.name, newname);
2090}
2091
2092static void alc1220_fixup_gb_dual_codecs(struct hda_codec *codec,
2093 const struct hda_fixup *fix,
2094 int action)
2095{
2096 alc_fixup_dual_codecs(codec, fix, action);
2097 switch (action) {
2098 case HDA_FIXUP_ACT_PRE_PROBE:
2099
2100 strcpy(codec->card->longname, "HDAudio-Gigabyte-ALC1220DualCodecs");
2101 break;
2102 case HDA_FIXUP_ACT_BUILD:
2103
2104 rename_ctl(codec, "Capture Volume",
2105 codec->addr == 0 ?
2106 "Rear-Panel Capture Volume" :
2107 "Front-Panel Capture Volume");
2108 rename_ctl(codec, "Capture Switch",
2109 codec->addr == 0 ?
2110 "Rear-Panel Capture Switch" :
2111 "Front-Panel Capture Switch");
2112 break;
2113 }
2114}
2115
2116static void alc1220_fixup_clevo_p950(struct hda_codec *codec,
2117 const struct hda_fixup *fix,
2118 int action)
2119{
2120 static const hda_nid_t conn1[] = { 0x0c };
2121
2122 if (action != HDA_FIXUP_ACT_PRE_PROBE)
2123 return;
2124
2125 alc_update_coef_idx(codec, 0x7, 0, 0x3c3);
2126
2127
2128
2129 snd_hda_override_conn_list(codec, 0x14, ARRAY_SIZE(conn1), conn1);
2130 snd_hda_override_conn_list(codec, 0x1b, ARRAY_SIZE(conn1), conn1);
2131}
2132
2133static void alc_fixup_headset_mode_no_hp_mic(struct hda_codec *codec,
2134 const struct hda_fixup *fix, int action);
2135
2136static void alc1220_fixup_clevo_pb51ed(struct hda_codec *codec,
2137 const struct hda_fixup *fix,
2138 int action)
2139{
2140 alc1220_fixup_clevo_p950(codec, fix, action);
2141 alc_fixup_headset_mode_no_hp_mic(codec, fix, action);
2142}
2143
2144static const struct hda_fixup alc882_fixups[] = {
2145 [ALC882_FIXUP_ABIT_AW9D_MAX] = {
2146 .type = HDA_FIXUP_PINS,
2147 .v.pins = (const struct hda_pintbl[]) {
2148 { 0x15, 0x01080104 },
2149 { 0x16, 0x01011012 },
2150 { 0x17, 0x01016011 },
2151 { }
2152 }
2153 },
2154 [ALC882_FIXUP_LENOVO_Y530] = {
2155 .type = HDA_FIXUP_PINS,
2156 .v.pins = (const struct hda_pintbl[]) {
2157 { 0x15, 0x99130112 },
2158 { 0x16, 0x99130111 },
2159 { }
2160 }
2161 },
2162 [ALC882_FIXUP_PB_M5210] = {
2163 .type = HDA_FIXUP_PINCTLS,
2164 .v.pins = (const struct hda_pintbl[]) {
2165 { 0x19, PIN_VREF50 },
2166 {}
2167 }
2168 },
2169 [ALC882_FIXUP_ACER_ASPIRE_7736] = {
2170 .type = HDA_FIXUP_FUNC,
2171 .v.func = alc_fixup_sku_ignore,
2172 },
2173 [ALC882_FIXUP_ASUS_W90V] = {
2174 .type = HDA_FIXUP_PINS,
2175 .v.pins = (const struct hda_pintbl[]) {
2176 { 0x16, 0x99130110 },
2177 { }
2178 }
2179 },
2180 [ALC889_FIXUP_CD] = {
2181 .type = HDA_FIXUP_PINS,
2182 .v.pins = (const struct hda_pintbl[]) {
2183 { 0x1c, 0x993301f0 },
2184 { }
2185 }
2186 },
2187 [ALC889_FIXUP_FRONT_HP_NO_PRESENCE] = {
2188 .type = HDA_FIXUP_PINS,
2189 .v.pins = (const struct hda_pintbl[]) {
2190 { 0x1b, 0x02214120 },
2191 { }
2192 },
2193 .chained = true,
2194 .chain_id = ALC889_FIXUP_CD,
2195 },
2196 [ALC889_FIXUP_VAIO_TT] = {
2197 .type = HDA_FIXUP_PINS,
2198 .v.pins = (const struct hda_pintbl[]) {
2199 { 0x17, 0x90170111 },
2200 { }
2201 }
2202 },
2203 [ALC888_FIXUP_EEE1601] = {
2204 .type = HDA_FIXUP_VERBS,
2205 .v.verbs = (const struct hda_verb[]) {
2206 { 0x20, AC_VERB_SET_COEF_INDEX, 0x0b },
2207 { 0x20, AC_VERB_SET_PROC_COEF, 0x0838 },
2208 { }
2209 }
2210 },
2211 [ALC882_FIXUP_EAPD] = {
2212 .type = HDA_FIXUP_VERBS,
2213 .v.verbs = (const struct hda_verb[]) {
2214
2215 { 0x20, AC_VERB_SET_COEF_INDEX, 0x07 },
2216 { 0x20, AC_VERB_SET_PROC_COEF, 0x3060 },
2217 { }
2218 }
2219 },
2220 [ALC883_FIXUP_EAPD] = {
2221 .type = HDA_FIXUP_VERBS,
2222 .v.verbs = (const struct hda_verb[]) {
2223
2224 { 0x20, AC_VERB_SET_COEF_INDEX, 0x07 },
2225 { 0x20, AC_VERB_SET_PROC_COEF, 0x3070 },
2226 { }
2227 }
2228 },
2229 [ALC883_FIXUP_ACER_EAPD] = {
2230 .type = HDA_FIXUP_VERBS,
2231 .v.verbs = (const struct hda_verb[]) {
2232
2233 { 0x20, AC_VERB_SET_COEF_INDEX, 0x07 },
2234 { 0x20, AC_VERB_SET_PROC_COEF, 0x3050 },
2235 { }
2236 }
2237 },
2238 [ALC882_FIXUP_GPIO1] = {
2239 .type = HDA_FIXUP_FUNC,
2240 .v.func = alc_fixup_gpio1,
2241 },
2242 [ALC882_FIXUP_GPIO2] = {
2243 .type = HDA_FIXUP_FUNC,
2244 .v.func = alc_fixup_gpio2,
2245 },
2246 [ALC882_FIXUP_GPIO3] = {
2247 .type = HDA_FIXUP_FUNC,
2248 .v.func = alc_fixup_gpio3,
2249 },
2250 [ALC882_FIXUP_ASUS_W2JC] = {
2251 .type = HDA_FIXUP_FUNC,
2252 .v.func = alc_fixup_gpio1,
2253 .chained = true,
2254 .chain_id = ALC882_FIXUP_EAPD,
2255 },
2256 [ALC889_FIXUP_COEF] = {
2257 .type = HDA_FIXUP_FUNC,
2258 .v.func = alc889_fixup_coef,
2259 },
2260 [ALC882_FIXUP_ACER_ASPIRE_4930G] = {
2261 .type = HDA_FIXUP_PINS,
2262 .v.pins = (const struct hda_pintbl[]) {
2263 { 0x16, 0x99130111 },
2264 { 0x17, 0x99130112 },
2265 { }
2266 },
2267 .chained = true,
2268 .chain_id = ALC882_FIXUP_GPIO1,
2269 },
2270 [ALC882_FIXUP_ACER_ASPIRE_8930G] = {
2271 .type = HDA_FIXUP_PINS,
2272 .v.pins = (const struct hda_pintbl[]) {
2273 { 0x16, 0x99130111 },
2274 { 0x1b, 0x99130112 },
2275 { }
2276 },
2277 .chained = true,
2278 .chain_id = ALC882_FIXUP_ASPIRE_8930G_VERBS,
2279 },
2280 [ALC882_FIXUP_ASPIRE_8930G_VERBS] = {
2281
2282 .type = HDA_FIXUP_VERBS,
2283 .v.verbs = (const struct hda_verb[]) {
2284
2285
2286
2287
2288 { 0x20, AC_VERB_SET_COEF_INDEX, 0x03 },
2289 { 0x20, AC_VERB_SET_PROC_COEF, 0x0000 },
2290
2291
2292
2293 { 0x20, AC_VERB_SET_COEF_INDEX, 0x08 },
2294 { 0x20, AC_VERB_SET_PROC_COEF, 0x0000 },
2295
2296
2297
2298
2299
2300
2301
2302
2303
2304
2305
2306 { 0x20, AC_VERB_SET_COEF_INDEX, 0x0b },
2307 { 0x20, AC_VERB_SET_PROC_COEF, 0x0003 },
2308 { 0x20, AC_VERB_SET_COEF_INDEX, 0x07 },
2309 { 0x20, AC_VERB_SET_PROC_COEF, 0x3050 },
2310 { }
2311 },
2312 .chained = true,
2313 .chain_id = ALC882_FIXUP_GPIO1,
2314 },
2315 [ALC885_FIXUP_MACPRO_GPIO] = {
2316 .type = HDA_FIXUP_FUNC,
2317 .v.func = alc885_fixup_macpro_gpio,
2318 },
2319 [ALC889_FIXUP_DAC_ROUTE] = {
2320 .type = HDA_FIXUP_FUNC,
2321 .v.func = alc889_fixup_dac_route,
2322 },
2323 [ALC889_FIXUP_MBP_VREF] = {
2324 .type = HDA_FIXUP_FUNC,
2325 .v.func = alc889_fixup_mbp_vref,
2326 .chained = true,
2327 .chain_id = ALC882_FIXUP_GPIO1,
2328 },
2329 [ALC889_FIXUP_IMAC91_VREF] = {
2330 .type = HDA_FIXUP_FUNC,
2331 .v.func = alc889_fixup_imac91_vref,
2332 .chained = true,
2333 .chain_id = ALC882_FIXUP_GPIO1,
2334 },
2335 [ALC889_FIXUP_MBA11_VREF] = {
2336 .type = HDA_FIXUP_FUNC,
2337 .v.func = alc889_fixup_mba11_vref,
2338 .chained = true,
2339 .chain_id = ALC889_FIXUP_MBP_VREF,
2340 },
2341 [ALC889_FIXUP_MBA21_VREF] = {
2342 .type = HDA_FIXUP_FUNC,
2343 .v.func = alc889_fixup_mba21_vref,
2344 .chained = true,
2345 .chain_id = ALC889_FIXUP_MBP_VREF,
2346 },
2347 [ALC889_FIXUP_MP11_VREF] = {
2348 .type = HDA_FIXUP_FUNC,
2349 .v.func = alc889_fixup_mba11_vref,
2350 .chained = true,
2351 .chain_id = ALC885_FIXUP_MACPRO_GPIO,
2352 },
2353 [ALC889_FIXUP_MP41_VREF] = {
2354 .type = HDA_FIXUP_FUNC,
2355 .v.func = alc889_fixup_mbp_vref,
2356 .chained = true,
2357 .chain_id = ALC885_FIXUP_MACPRO_GPIO,
2358 },
2359 [ALC882_FIXUP_INV_DMIC] = {
2360 .type = HDA_FIXUP_FUNC,
2361 .v.func = alc_fixup_inv_dmic,
2362 },
2363 [ALC882_FIXUP_NO_PRIMARY_HP] = {
2364 .type = HDA_FIXUP_FUNC,
2365 .v.func = alc882_fixup_no_primary_hp,
2366 },
2367 [ALC887_FIXUP_ASUS_BASS] = {
2368 .type = HDA_FIXUP_PINS,
2369 .v.pins = (const struct hda_pintbl[]) {
2370 {0x16, 0x99130130},
2371 {}
2372 },
2373 .chained = true,
2374 .chain_id = ALC887_FIXUP_BASS_CHMAP,
2375 },
2376 [ALC887_FIXUP_BASS_CHMAP] = {
2377 .type = HDA_FIXUP_FUNC,
2378 .v.func = alc_fixup_bass_chmap,
2379 },
2380 [ALC1220_FIXUP_GB_DUAL_CODECS] = {
2381 .type = HDA_FIXUP_FUNC,
2382 .v.func = alc1220_fixup_gb_dual_codecs,
2383 },
2384 [ALC1220_FIXUP_CLEVO_P950] = {
2385 .type = HDA_FIXUP_FUNC,
2386 .v.func = alc1220_fixup_clevo_p950,
2387 },
2388 [ALC1220_FIXUP_CLEVO_PB51ED] = {
2389 .type = HDA_FIXUP_FUNC,
2390 .v.func = alc1220_fixup_clevo_pb51ed,
2391 },
2392 [ALC1220_FIXUP_CLEVO_PB51ED_PINS] = {
2393 .type = HDA_FIXUP_PINS,
2394 .v.pins = (const struct hda_pintbl[]) {
2395 { 0x19, 0x01a1913c },
2396 {}
2397 },
2398 .chained = true,
2399 .chain_id = ALC1220_FIXUP_CLEVO_PB51ED,
2400 },
2401};
2402
2403static const struct snd_pci_quirk alc882_fixup_tbl[] = {
2404 SND_PCI_QUIRK(0x1025, 0x006c, "Acer Aspire 9810", ALC883_FIXUP_ACER_EAPD),
2405 SND_PCI_QUIRK(0x1025, 0x0090, "Acer Aspire", ALC883_FIXUP_ACER_EAPD),
2406 SND_PCI_QUIRK(0x1025, 0x0107, "Acer Aspire", ALC883_FIXUP_ACER_EAPD),
2407 SND_PCI_QUIRK(0x1025, 0x010a, "Acer Ferrari 5000", ALC883_FIXUP_ACER_EAPD),
2408 SND_PCI_QUIRK(0x1025, 0x0110, "Acer Aspire", ALC883_FIXUP_ACER_EAPD),
2409 SND_PCI_QUIRK(0x1025, 0x0112, "Acer Aspire 9303", ALC883_FIXUP_ACER_EAPD),
2410 SND_PCI_QUIRK(0x1025, 0x0121, "Acer Aspire 5920G", ALC883_FIXUP_ACER_EAPD),
2411 SND_PCI_QUIRK(0x1025, 0x013e, "Acer Aspire 4930G",
2412 ALC882_FIXUP_ACER_ASPIRE_4930G),
2413 SND_PCI_QUIRK(0x1025, 0x013f, "Acer Aspire 5930G",
2414 ALC882_FIXUP_ACER_ASPIRE_4930G),
2415 SND_PCI_QUIRK(0x1025, 0x0145, "Acer Aspire 8930G",
2416 ALC882_FIXUP_ACER_ASPIRE_8930G),
2417 SND_PCI_QUIRK(0x1025, 0x0146, "Acer Aspire 6935G",
2418 ALC882_FIXUP_ACER_ASPIRE_8930G),
2419 SND_PCI_QUIRK(0x1025, 0x015e, "Acer Aspire 6930G",
2420 ALC882_FIXUP_ACER_ASPIRE_4930G),
2421 SND_PCI_QUIRK(0x1025, 0x0166, "Acer Aspire 6530G",
2422 ALC882_FIXUP_ACER_ASPIRE_4930G),
2423 SND_PCI_QUIRK(0x1025, 0x0142, "Acer Aspire 7730G",
2424 ALC882_FIXUP_ACER_ASPIRE_4930G),
2425 SND_PCI_QUIRK(0x1025, 0x0155, "Packard-Bell M5120", ALC882_FIXUP_PB_M5210),
2426 SND_PCI_QUIRK(0x1025, 0x021e, "Acer Aspire 5739G",
2427 ALC882_FIXUP_ACER_ASPIRE_4930G),
2428 SND_PCI_QUIRK(0x1025, 0x0259, "Acer Aspire 5935", ALC889_FIXUP_DAC_ROUTE),
2429 SND_PCI_QUIRK(0x1025, 0x026b, "Acer Aspire 8940G", ALC882_FIXUP_ACER_ASPIRE_8930G),
2430 SND_PCI_QUIRK(0x1025, 0x0296, "Acer Aspire 7736z", ALC882_FIXUP_ACER_ASPIRE_7736),
2431 SND_PCI_QUIRK(0x1043, 0x13c2, "Asus A7M", ALC882_FIXUP_EAPD),
2432 SND_PCI_QUIRK(0x1043, 0x1873, "ASUS W90V", ALC882_FIXUP_ASUS_W90V),
2433 SND_PCI_QUIRK(0x1043, 0x1971, "Asus W2JC", ALC882_FIXUP_ASUS_W2JC),
2434 SND_PCI_QUIRK(0x1043, 0x835f, "Asus Eee 1601", ALC888_FIXUP_EEE1601),
2435 SND_PCI_QUIRK(0x1043, 0x84bc, "ASUS ET2700", ALC887_FIXUP_ASUS_BASS),
2436 SND_PCI_QUIRK(0x1043, 0x8691, "ASUS ROG Ranger VIII", ALC882_FIXUP_GPIO3),
2437 SND_PCI_QUIRK(0x104d, 0x9047, "Sony Vaio TT", ALC889_FIXUP_VAIO_TT),
2438 SND_PCI_QUIRK(0x104d, 0x905a, "Sony Vaio Z", ALC882_FIXUP_NO_PRIMARY_HP),
2439 SND_PCI_QUIRK(0x104d, 0x9060, "Sony Vaio VPCL14M1R", ALC882_FIXUP_NO_PRIMARY_HP),
2440 SND_PCI_QUIRK(0x104d, 0x9043, "Sony Vaio VGC-LN51JGB", ALC882_FIXUP_NO_PRIMARY_HP),
2441 SND_PCI_QUIRK(0x104d, 0x9044, "Sony VAIO AiO", ALC882_FIXUP_NO_PRIMARY_HP),
2442
2443
2444 SND_PCI_QUIRK(0x106b, 0x00a0, "MacBookPro 3,1", ALC889_FIXUP_MBP_VREF),
2445 SND_PCI_QUIRK(0x106b, 0x00a1, "Macbook", ALC889_FIXUP_MBP_VREF),
2446 SND_PCI_QUIRK(0x106b, 0x00a4, "MacbookPro 4,1", ALC889_FIXUP_MBP_VREF),
2447 SND_PCI_QUIRK(0x106b, 0x0c00, "Mac Pro", ALC889_FIXUP_MP11_VREF),
2448 SND_PCI_QUIRK(0x106b, 0x1000, "iMac 24", ALC885_FIXUP_MACPRO_GPIO),
2449 SND_PCI_QUIRK(0x106b, 0x2800, "AppleTV", ALC885_FIXUP_MACPRO_GPIO),
2450 SND_PCI_QUIRK(0x106b, 0x2c00, "MacbookPro rev3", ALC889_FIXUP_MBP_VREF),
2451 SND_PCI_QUIRK(0x106b, 0x3000, "iMac", ALC889_FIXUP_MBP_VREF),
2452 SND_PCI_QUIRK(0x106b, 0x3200, "iMac 7,1 Aluminum", ALC882_FIXUP_EAPD),
2453 SND_PCI_QUIRK(0x106b, 0x3400, "MacBookAir 1,1", ALC889_FIXUP_MBA11_VREF),
2454 SND_PCI_QUIRK(0x106b, 0x3500, "MacBookAir 2,1", ALC889_FIXUP_MBA21_VREF),
2455 SND_PCI_QUIRK(0x106b, 0x3600, "Macbook 3,1", ALC889_FIXUP_MBP_VREF),
2456 SND_PCI_QUIRK(0x106b, 0x3800, "MacbookPro 4,1", ALC889_FIXUP_MBP_VREF),
2457 SND_PCI_QUIRK(0x106b, 0x3e00, "iMac 24 Aluminum", ALC885_FIXUP_MACPRO_GPIO),
2458 SND_PCI_QUIRK(0x106b, 0x3f00, "Macbook 5,1", ALC889_FIXUP_IMAC91_VREF),
2459 SND_PCI_QUIRK(0x106b, 0x4000, "MacbookPro 5,1", ALC889_FIXUP_IMAC91_VREF),
2460 SND_PCI_QUIRK(0x106b, 0x4100, "Macmini 3,1", ALC889_FIXUP_IMAC91_VREF),
2461 SND_PCI_QUIRK(0x106b, 0x4200, "Mac Pro 4,1/5,1", ALC889_FIXUP_MP41_VREF),
2462 SND_PCI_QUIRK(0x106b, 0x4300, "iMac 9,1", ALC889_FIXUP_IMAC91_VREF),
2463 SND_PCI_QUIRK(0x106b, 0x4600, "MacbookPro 5,2", ALC889_FIXUP_IMAC91_VREF),
2464 SND_PCI_QUIRK(0x106b, 0x4900, "iMac 9,1 Aluminum", ALC889_FIXUP_IMAC91_VREF),
2465 SND_PCI_QUIRK(0x106b, 0x4a00, "Macbook 5,2", ALC889_FIXUP_MBA11_VREF),
2466
2467 SND_PCI_QUIRK(0x1071, 0x8258, "Evesham Voyaeger", ALC882_FIXUP_EAPD),
2468 SND_PCI_QUIRK(0x1458, 0xa002, "Gigabyte EP45-DS3/Z87X-UD3H", ALC889_FIXUP_FRONT_HP_NO_PRESENCE),
2469 SND_PCI_QUIRK(0x1458, 0xa0b8, "Gigabyte AZ370-Gaming", ALC1220_FIXUP_GB_DUAL_CODECS),
2470 SND_PCI_QUIRK(0x1458, 0xa0cd, "Gigabyte X570 Aorus Master", ALC1220_FIXUP_CLEVO_P950),
2471 SND_PCI_QUIRK(0x1458, 0xa0ce, "Gigabyte X570 Aorus Xtreme", ALC1220_FIXUP_CLEVO_P950),
2472 SND_PCI_QUIRK(0x1462, 0x11f7, "MSI-GE63", ALC1220_FIXUP_CLEVO_P950),
2473 SND_PCI_QUIRK(0x1462, 0x1228, "MSI-GP63", ALC1220_FIXUP_CLEVO_P950),
2474 SND_PCI_QUIRK(0x1462, 0x1275, "MSI-GL63", ALC1220_FIXUP_CLEVO_P950),
2475 SND_PCI_QUIRK(0x1462, 0x1276, "MSI-GL73", ALC1220_FIXUP_CLEVO_P950),
2476 SND_PCI_QUIRK(0x1462, 0x1293, "MSI-GP65", ALC1220_FIXUP_CLEVO_P950),
2477 SND_PCI_QUIRK(0x1462, 0x7350, "MSI-7350", ALC889_FIXUP_CD),
2478 SND_PCI_QUIRK(0x1462, 0xda57, "MSI Z270-Gaming", ALC1220_FIXUP_GB_DUAL_CODECS),
2479 SND_PCI_QUIRK_VENDOR(0x1462, "MSI", ALC882_FIXUP_GPIO3),
2480 SND_PCI_QUIRK(0x147b, 0x107a, "Abit AW9D-MAX", ALC882_FIXUP_ABIT_AW9D_MAX),
2481 SND_PCI_QUIRK(0x1558, 0x9501, "Clevo P950HR", ALC1220_FIXUP_CLEVO_P950),
2482 SND_PCI_QUIRK(0x1558, 0x95e1, "Clevo P95xER", ALC1220_FIXUP_CLEVO_P950),
2483 SND_PCI_QUIRK(0x1558, 0x95e2, "Clevo P950ER", ALC1220_FIXUP_CLEVO_P950),
2484 SND_PCI_QUIRK(0x1558, 0x96e1, "Clevo P960[ER][CDFN]-K", ALC1220_FIXUP_CLEVO_P950),
2485 SND_PCI_QUIRK(0x1558, 0x97e1, "Clevo P970[ER][CDFN]", ALC1220_FIXUP_CLEVO_P950),
2486 SND_PCI_QUIRK(0x1558, 0x65d1, "Clevo PB51[ER][CDF]", ALC1220_FIXUP_CLEVO_PB51ED_PINS),
2487 SND_PCI_QUIRK(0x1558, 0x67d1, "Clevo PB71[ER][CDF]", ALC1220_FIXUP_CLEVO_PB51ED_PINS),
2488 SND_PCI_QUIRK(0x1558, 0x50d3, "Clevo PC50[ER][CDF]", ALC1220_FIXUP_CLEVO_PB51ED_PINS),
2489 SND_PCI_QUIRK(0x1558, 0x70d1, "Clevo PC70[ER][CDF]", ALC1220_FIXUP_CLEVO_PB51ED_PINS),
2490 SND_PCI_QUIRK(0x1558, 0x7714, "Clevo X170", ALC1220_FIXUP_CLEVO_PB51ED_PINS),
2491 SND_PCI_QUIRK_VENDOR(0x1558, "Clevo laptop", ALC882_FIXUP_EAPD),
2492 SND_PCI_QUIRK(0x161f, 0x2054, "Medion laptop", ALC883_FIXUP_EAPD),
2493 SND_PCI_QUIRK(0x17aa, 0x3a0d, "Lenovo Y530", ALC882_FIXUP_LENOVO_Y530),
2494 SND_PCI_QUIRK(0x8086, 0x0022, "DX58SO", ALC889_FIXUP_COEF),
2495 {}
2496};
2497
2498static const struct hda_model_fixup alc882_fixup_models[] = {
2499 {.id = ALC882_FIXUP_ABIT_AW9D_MAX, .name = "abit-aw9d"},
2500 {.id = ALC882_FIXUP_LENOVO_Y530, .name = "lenovo-y530"},
2501 {.id = ALC882_FIXUP_ACER_ASPIRE_7736, .name = "acer-aspire-7736"},
2502 {.id = ALC882_FIXUP_ASUS_W90V, .name = "asus-w90v"},
2503 {.id = ALC889_FIXUP_CD, .name = "cd"},
2504 {.id = ALC889_FIXUP_FRONT_HP_NO_PRESENCE, .name = "no-front-hp"},
2505 {.id = ALC889_FIXUP_VAIO_TT, .name = "vaio-tt"},
2506 {.id = ALC888_FIXUP_EEE1601, .name = "eee1601"},
2507 {.id = ALC882_FIXUP_EAPD, .name = "alc882-eapd"},
2508 {.id = ALC883_FIXUP_EAPD, .name = "alc883-eapd"},
2509 {.id = ALC882_FIXUP_GPIO1, .name = "gpio1"},
2510 {.id = ALC882_FIXUP_GPIO2, .name = "gpio2"},
2511 {.id = ALC882_FIXUP_GPIO3, .name = "gpio3"},
2512 {.id = ALC889_FIXUP_COEF, .name = "alc889-coef"},
2513 {.id = ALC882_FIXUP_ASUS_W2JC, .name = "asus-w2jc"},
2514 {.id = ALC882_FIXUP_ACER_ASPIRE_4930G, .name = "acer-aspire-4930g"},
2515 {.id = ALC882_FIXUP_ACER_ASPIRE_8930G, .name = "acer-aspire-8930g"},
2516 {.id = ALC883_FIXUP_ACER_EAPD, .name = "acer-aspire"},
2517 {.id = ALC885_FIXUP_MACPRO_GPIO, .name = "macpro-gpio"},
2518 {.id = ALC889_FIXUP_DAC_ROUTE, .name = "dac-route"},
2519 {.id = ALC889_FIXUP_MBP_VREF, .name = "mbp-vref"},
2520 {.id = ALC889_FIXUP_IMAC91_VREF, .name = "imac91-vref"},
2521 {.id = ALC889_FIXUP_MBA11_VREF, .name = "mba11-vref"},
2522 {.id = ALC889_FIXUP_MBA21_VREF, .name = "mba21-vref"},
2523 {.id = ALC889_FIXUP_MP11_VREF, .name = "mp11-vref"},
2524 {.id = ALC889_FIXUP_MP41_VREF, .name = "mp41-vref"},
2525 {.id = ALC882_FIXUP_INV_DMIC, .name = "inv-dmic"},
2526 {.id = ALC882_FIXUP_NO_PRIMARY_HP, .name = "no-primary-hp"},
2527 {.id = ALC887_FIXUP_ASUS_BASS, .name = "asus-bass"},
2528 {.id = ALC1220_FIXUP_GB_DUAL_CODECS, .name = "dual-codecs"},
2529 {.id = ALC1220_FIXUP_CLEVO_P950, .name = "clevo-p950"},
2530 {}
2531};
2532
2533
2534
2535
2536
2537static int alc882_parse_auto_config(struct hda_codec *codec)
2538{
2539 static const hda_nid_t alc882_ignore[] = { 0x1d, 0 };
2540 static const hda_nid_t alc882_ssids[] = { 0x15, 0x1b, 0x14, 0 };
2541 return alc_parse_auto_config(codec, alc882_ignore, alc882_ssids);
2542}
2543
2544
2545
2546static int patch_alc882(struct hda_codec *codec)
2547{
2548 struct alc_spec *spec;
2549 int err;
2550
2551 err = alc_alloc_spec(codec, 0x0b);
2552 if (err < 0)
2553 return err;
2554
2555 spec = codec->spec;
2556
2557 switch (codec->core.vendor_id) {
2558 case 0x10ec0882:
2559 case 0x10ec0885:
2560 case 0x10ec0900:
2561 case 0x10ec0b00:
2562 case 0x10ec1220:
2563 break;
2564 default:
2565
2566 alc_fix_pll_init(codec, 0x20, 0x0a, 10);
2567 break;
2568 }
2569
2570 alc_pre_init(codec);
2571
2572 snd_hda_pick_fixup(codec, alc882_fixup_models, alc882_fixup_tbl,
2573 alc882_fixups);
2574 snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE);
2575
2576 alc_auto_parse_customize_define(codec);
2577
2578 if (has_cdefine_beep(codec))
2579 spec->gen.beep_nid = 0x01;
2580
2581
2582 err = alc882_parse_auto_config(codec);
2583 if (err < 0)
2584 goto error;
2585
2586 if (!spec->gen.no_analog && spec->gen.beep_nid) {
2587 err = set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
2588 if (err < 0)
2589 goto error;
2590 }
2591
2592 snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE);
2593
2594 return 0;
2595
2596 error:
2597 alc_free(codec);
2598 return err;
2599}
2600
2601
2602
2603
2604
2605static int alc262_parse_auto_config(struct hda_codec *codec)
2606{
2607 static const hda_nid_t alc262_ignore[] = { 0x1d, 0 };
2608 static const hda_nid_t alc262_ssids[] = { 0x15, 0x1b, 0x14, 0 };
2609 return alc_parse_auto_config(codec, alc262_ignore, alc262_ssids);
2610}
2611
2612
2613
2614
2615enum {
2616 ALC262_FIXUP_FSC_H270,
2617 ALC262_FIXUP_FSC_S7110,
2618 ALC262_FIXUP_HP_Z200,
2619 ALC262_FIXUP_TYAN,
2620 ALC262_FIXUP_LENOVO_3000,
2621 ALC262_FIXUP_BENQ,
2622 ALC262_FIXUP_BENQ_T31,
2623 ALC262_FIXUP_INV_DMIC,
2624 ALC262_FIXUP_INTEL_BAYLEYBAY,
2625};
2626
2627static const struct hda_fixup alc262_fixups[] = {
2628 [ALC262_FIXUP_FSC_H270] = {
2629 .type = HDA_FIXUP_PINS,
2630 .v.pins = (const struct hda_pintbl[]) {
2631 { 0x14, 0x99130110 },
2632 { 0x15, 0x0221142f },
2633 { 0x1b, 0x0121141f },
2634 { }
2635 }
2636 },
2637 [ALC262_FIXUP_FSC_S7110] = {
2638 .type = HDA_FIXUP_PINS,
2639 .v.pins = (const struct hda_pintbl[]) {
2640 { 0x15, 0x90170110 },
2641 { }
2642 },
2643 .chained = true,
2644 .chain_id = ALC262_FIXUP_BENQ,
2645 },
2646 [ALC262_FIXUP_HP_Z200] = {
2647 .type = HDA_FIXUP_PINS,
2648 .v.pins = (const struct hda_pintbl[]) {
2649 { 0x16, 0x99130120 },
2650 { }
2651 }
2652 },
2653 [ALC262_FIXUP_TYAN] = {
2654 .type = HDA_FIXUP_PINS,
2655 .v.pins = (const struct hda_pintbl[]) {
2656 { 0x14, 0x1993e1f0 },
2657 { }
2658 }
2659 },
2660 [ALC262_FIXUP_LENOVO_3000] = {
2661 .type = HDA_FIXUP_PINCTLS,
2662 .v.pins = (const struct hda_pintbl[]) {
2663 { 0x19, PIN_VREF50 },
2664 {}
2665 },
2666 .chained = true,
2667 .chain_id = ALC262_FIXUP_BENQ,
2668 },
2669 [ALC262_FIXUP_BENQ] = {
2670 .type = HDA_FIXUP_VERBS,
2671 .v.verbs = (const struct hda_verb[]) {
2672 { 0x20, AC_VERB_SET_COEF_INDEX, 0x07 },
2673 { 0x20, AC_VERB_SET_PROC_COEF, 0x3070 },
2674 {}
2675 }
2676 },
2677 [ALC262_FIXUP_BENQ_T31] = {
2678 .type = HDA_FIXUP_VERBS,
2679 .v.verbs = (const struct hda_verb[]) {
2680 { 0x20, AC_VERB_SET_COEF_INDEX, 0x07 },
2681 { 0x20, AC_VERB_SET_PROC_COEF, 0x3050 },
2682 {}
2683 }
2684 },
2685 [ALC262_FIXUP_INV_DMIC] = {
2686 .type = HDA_FIXUP_FUNC,
2687 .v.func = alc_fixup_inv_dmic,
2688 },
2689 [ALC262_FIXUP_INTEL_BAYLEYBAY] = {
2690 .type = HDA_FIXUP_FUNC,
2691 .v.func = alc_fixup_no_depop_delay,
2692 },
2693};
2694
2695static const struct snd_pci_quirk alc262_fixup_tbl[] = {
2696 SND_PCI_QUIRK(0x103c, 0x170b, "HP Z200", ALC262_FIXUP_HP_Z200),
2697 SND_PCI_QUIRK(0x10cf, 0x1397, "Fujitsu Lifebook S7110", ALC262_FIXUP_FSC_S7110),
2698 SND_PCI_QUIRK(0x10cf, 0x142d, "Fujitsu Lifebook E8410", ALC262_FIXUP_BENQ),
2699 SND_PCI_QUIRK(0x10f1, 0x2915, "Tyan Thunder n6650W", ALC262_FIXUP_TYAN),
2700 SND_PCI_QUIRK(0x1734, 0x1141, "FSC ESPRIMO U9210", ALC262_FIXUP_FSC_H270),
2701 SND_PCI_QUIRK(0x1734, 0x1147, "FSC Celsius H270", ALC262_FIXUP_FSC_H270),
2702 SND_PCI_QUIRK(0x17aa, 0x384e, "Lenovo 3000", ALC262_FIXUP_LENOVO_3000),
2703 SND_PCI_QUIRK(0x17ff, 0x0560, "Benq ED8", ALC262_FIXUP_BENQ),
2704 SND_PCI_QUIRK(0x17ff, 0x058d, "Benq T31-16", ALC262_FIXUP_BENQ_T31),
2705 SND_PCI_QUIRK(0x8086, 0x7270, "BayleyBay", ALC262_FIXUP_INTEL_BAYLEYBAY),
2706 {}
2707};
2708
2709static const struct hda_model_fixup alc262_fixup_models[] = {
2710 {.id = ALC262_FIXUP_INV_DMIC, .name = "inv-dmic"},
2711 {.id = ALC262_FIXUP_FSC_H270, .name = "fsc-h270"},
2712 {.id = ALC262_FIXUP_FSC_S7110, .name = "fsc-s7110"},
2713 {.id = ALC262_FIXUP_HP_Z200, .name = "hp-z200"},
2714 {.id = ALC262_FIXUP_TYAN, .name = "tyan"},
2715 {.id = ALC262_FIXUP_LENOVO_3000, .name = "lenovo-3000"},
2716 {.id = ALC262_FIXUP_BENQ, .name = "benq"},
2717 {.id = ALC262_FIXUP_BENQ_T31, .name = "benq-t31"},
2718 {.id = ALC262_FIXUP_INTEL_BAYLEYBAY, .name = "bayleybay"},
2719 {}
2720};
2721
2722
2723
2724static int patch_alc262(struct hda_codec *codec)
2725{
2726 struct alc_spec *spec;
2727 int err;
2728
2729 err = alc_alloc_spec(codec, 0x0b);
2730 if (err < 0)
2731 return err;
2732
2733 spec = codec->spec;
2734 spec->gen.shared_mic_vref_pin = 0x18;
2735
2736 spec->shutup = alc_eapd_shutup;
2737
2738#if 0
2739
2740
2741
2742 alc_update_coefex_idx(codec, 0x1a, 7, 0, 0x80);
2743#endif
2744 alc_fix_pll_init(codec, 0x20, 0x0a, 10);
2745
2746 alc_pre_init(codec);
2747
2748 snd_hda_pick_fixup(codec, alc262_fixup_models, alc262_fixup_tbl,
2749 alc262_fixups);
2750 snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE);
2751
2752 alc_auto_parse_customize_define(codec);
2753
2754 if (has_cdefine_beep(codec))
2755 spec->gen.beep_nid = 0x01;
2756
2757
2758 err = alc262_parse_auto_config(codec);
2759 if (err < 0)
2760 goto error;
2761
2762 if (!spec->gen.no_analog && spec->gen.beep_nid) {
2763 err = set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
2764 if (err < 0)
2765 goto error;
2766 }
2767
2768 snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE);
2769
2770 return 0;
2771
2772 error:
2773 alc_free(codec);
2774 return err;
2775}
2776
2777
2778
2779
2780
2781static int alc268_beep_switch_put(struct snd_kcontrol *kcontrol,
2782 struct snd_ctl_elem_value *ucontrol)
2783{
2784 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2785 unsigned long pval;
2786 int err;
2787
2788 mutex_lock(&codec->control_mutex);
2789 pval = kcontrol->private_value;
2790 kcontrol->private_value = (pval & ~0xff) | 0x0f;
2791 err = snd_hda_mixer_amp_switch_put(kcontrol, ucontrol);
2792 if (err >= 0) {
2793 kcontrol->private_value = (pval & ~0xff) | 0x10;
2794 err = snd_hda_mixer_amp_switch_put(kcontrol, ucontrol);
2795 }
2796 kcontrol->private_value = pval;
2797 mutex_unlock(&codec->control_mutex);
2798 return err;
2799}
2800
2801static const struct snd_kcontrol_new alc268_beep_mixer[] = {
2802 HDA_CODEC_VOLUME("Beep Playback Volume", 0x1d, 0x0, HDA_INPUT),
2803 {
2804 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2805 .name = "Beep Playback Switch",
2806 .subdevice = HDA_SUBDEV_AMP_FLAG,
2807 .info = snd_hda_mixer_amp_switch_info,
2808 .get = snd_hda_mixer_amp_switch_get,
2809 .put = alc268_beep_switch_put,
2810 .private_value = HDA_COMPOSE_AMP_VAL(0x0f, 3, 1, HDA_INPUT)
2811 },
2812};
2813
2814
2815static const struct hda_verb alc268_beep_init_verbs[] = {
2816 {0x1d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
2817 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
2818 {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
2819 { }
2820};
2821
2822enum {
2823 ALC268_FIXUP_INV_DMIC,
2824 ALC268_FIXUP_HP_EAPD,
2825 ALC268_FIXUP_SPDIF,
2826};
2827
2828static const struct hda_fixup alc268_fixups[] = {
2829 [ALC268_FIXUP_INV_DMIC] = {
2830 .type = HDA_FIXUP_FUNC,
2831 .v.func = alc_fixup_inv_dmic,
2832 },
2833 [ALC268_FIXUP_HP_EAPD] = {
2834 .type = HDA_FIXUP_VERBS,
2835 .v.verbs = (const struct hda_verb[]) {
2836 {0x15, AC_VERB_SET_EAPD_BTLENABLE, 0},
2837 {}
2838 }
2839 },
2840 [ALC268_FIXUP_SPDIF] = {
2841 .type = HDA_FIXUP_PINS,
2842 .v.pins = (const struct hda_pintbl[]) {
2843 { 0x1e, 0x014b1180 },
2844 {}
2845 }
2846 },
2847};
2848
2849static const struct hda_model_fixup alc268_fixup_models[] = {
2850 {.id = ALC268_FIXUP_INV_DMIC, .name = "inv-dmic"},
2851 {.id = ALC268_FIXUP_HP_EAPD, .name = "hp-eapd"},
2852 {.id = ALC268_FIXUP_SPDIF, .name = "spdif"},
2853 {}
2854};
2855
2856static const struct snd_pci_quirk alc268_fixup_tbl[] = {
2857 SND_PCI_QUIRK(0x1025, 0x0139, "Acer TravelMate 6293", ALC268_FIXUP_SPDIF),
2858 SND_PCI_QUIRK(0x1025, 0x015b, "Acer AOA 150 (ZG5)", ALC268_FIXUP_INV_DMIC),
2859
2860
2861
2862 SND_PCI_QUIRK(0x1179, 0xff06, "Toshiba P200", ALC268_FIXUP_HP_EAPD),
2863 {}
2864};
2865
2866
2867
2868
2869static int alc268_parse_auto_config(struct hda_codec *codec)
2870{
2871 static const hda_nid_t alc268_ssids[] = { 0x15, 0x1b, 0x14, 0 };
2872 return alc_parse_auto_config(codec, NULL, alc268_ssids);
2873}
2874
2875
2876
2877static int patch_alc268(struct hda_codec *codec)
2878{
2879 struct alc_spec *spec;
2880 int i, err;
2881
2882
2883 err = alc_alloc_spec(codec, 0);
2884 if (err < 0)
2885 return err;
2886
2887 spec = codec->spec;
2888 if (has_cdefine_beep(codec))
2889 spec->gen.beep_nid = 0x01;
2890
2891 spec->shutup = alc_eapd_shutup;
2892
2893 alc_pre_init(codec);
2894
2895 snd_hda_pick_fixup(codec, alc268_fixup_models, alc268_fixup_tbl, alc268_fixups);
2896 snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE);
2897
2898
2899 err = alc268_parse_auto_config(codec);
2900 if (err < 0)
2901 goto error;
2902
2903 if (err > 0 && !spec->gen.no_analog &&
2904 spec->gen.autocfg.speaker_pins[0] != 0x1d) {
2905 for (i = 0; i < ARRAY_SIZE(alc268_beep_mixer); i++) {
2906 if (!snd_hda_gen_add_kctl(&spec->gen, NULL,
2907 &alc268_beep_mixer[i])) {
2908 err = -ENOMEM;
2909 goto error;
2910 }
2911 }
2912 snd_hda_add_verbs(codec, alc268_beep_init_verbs);
2913 if (!query_amp_caps(codec, 0x1d, HDA_INPUT))
2914
2915 snd_hda_override_amp_caps(codec, 0x1d, HDA_INPUT,
2916 (0x0c << AC_AMPCAP_OFFSET_SHIFT) |
2917 (0x0c << AC_AMPCAP_NUM_STEPS_SHIFT) |
2918 (0x07 << AC_AMPCAP_STEP_SIZE_SHIFT) |
2919 (0 << AC_AMPCAP_MUTE_SHIFT));
2920 }
2921
2922 snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE);
2923
2924 return 0;
2925
2926 error:
2927 alc_free(codec);
2928 return err;
2929}
2930
2931
2932
2933
2934
2935static const struct hda_pcm_stream alc269_44k_pcm_analog_playback = {
2936 .rates = SNDRV_PCM_RATE_44100,
2937};
2938
2939static const struct hda_pcm_stream alc269_44k_pcm_analog_capture = {
2940 .rates = SNDRV_PCM_RATE_44100,
2941};
2942
2943
2944enum {
2945 ALC269_TYPE_ALC269VA,
2946 ALC269_TYPE_ALC269VB,
2947 ALC269_TYPE_ALC269VC,
2948 ALC269_TYPE_ALC269VD,
2949 ALC269_TYPE_ALC280,
2950 ALC269_TYPE_ALC282,
2951 ALC269_TYPE_ALC283,
2952 ALC269_TYPE_ALC284,
2953 ALC269_TYPE_ALC293,
2954 ALC269_TYPE_ALC286,
2955 ALC269_TYPE_ALC298,
2956 ALC269_TYPE_ALC255,
2957 ALC269_TYPE_ALC256,
2958 ALC269_TYPE_ALC257,
2959 ALC269_TYPE_ALC215,
2960 ALC269_TYPE_ALC225,
2961 ALC269_TYPE_ALC294,
2962 ALC269_TYPE_ALC300,
2963 ALC269_TYPE_ALC623,
2964 ALC269_TYPE_ALC700,
2965};
2966
2967
2968
2969
2970static int alc269_parse_auto_config(struct hda_codec *codec)
2971{
2972 static const hda_nid_t alc269_ignore[] = { 0x1d, 0 };
2973 static const hda_nid_t alc269_ssids[] = { 0, 0x1b, 0x14, 0x21 };
2974 static const hda_nid_t alc269va_ssids[] = { 0x15, 0x1b, 0x14, 0 };
2975 struct alc_spec *spec = codec->spec;
2976 const hda_nid_t *ssids;
2977
2978 switch (spec->codec_variant) {
2979 case ALC269_TYPE_ALC269VA:
2980 case ALC269_TYPE_ALC269VC:
2981 case ALC269_TYPE_ALC280:
2982 case ALC269_TYPE_ALC284:
2983 case ALC269_TYPE_ALC293:
2984 ssids = alc269va_ssids;
2985 break;
2986 case ALC269_TYPE_ALC269VB:
2987 case ALC269_TYPE_ALC269VD:
2988 case ALC269_TYPE_ALC282:
2989 case ALC269_TYPE_ALC283:
2990 case ALC269_TYPE_ALC286:
2991 case ALC269_TYPE_ALC298:
2992 case ALC269_TYPE_ALC255:
2993 case ALC269_TYPE_ALC256:
2994 case ALC269_TYPE_ALC257:
2995 case ALC269_TYPE_ALC215:
2996 case ALC269_TYPE_ALC225:
2997 case ALC269_TYPE_ALC294:
2998 case ALC269_TYPE_ALC300:
2999 case ALC269_TYPE_ALC623:
3000 case ALC269_TYPE_ALC700:
3001 ssids = alc269_ssids;
3002 break;
3003 default:
3004 ssids = alc269_ssids;
3005 break;
3006 }
3007
3008 return alc_parse_auto_config(codec, alc269_ignore, ssids);
3009}
3010
3011static const struct hda_jack_keymap alc_headset_btn_keymap[] = {
3012 { SND_JACK_BTN_0, KEY_PLAYPAUSE },
3013 { SND_JACK_BTN_1, KEY_VOICECOMMAND },
3014 { SND_JACK_BTN_2, KEY_VOLUMEUP },
3015 { SND_JACK_BTN_3, KEY_VOLUMEDOWN },
3016 {}
3017};
3018
3019static void alc_headset_btn_callback(struct hda_codec *codec,
3020 struct hda_jack_callback *jack)
3021{
3022 int report = 0;
3023
3024 if (jack->unsol_res & (7 << 13))
3025 report |= SND_JACK_BTN_0;
3026
3027 if (jack->unsol_res & (1 << 16 | 3 << 8))
3028 report |= SND_JACK_BTN_1;
3029
3030
3031 if (jack->unsol_res & (7 << 23))
3032 report |= SND_JACK_BTN_2;
3033
3034
3035 if (jack->unsol_res & (7 << 10))
3036 report |= SND_JACK_BTN_3;
3037
3038 jack->jack->button_state = report;
3039}
3040
3041static void alc_disable_headset_jack_key(struct hda_codec *codec)
3042{
3043 struct alc_spec *spec = codec->spec;
3044
3045 if (!spec->has_hs_key)
3046 return;
3047
3048 switch (codec->core.vendor_id) {
3049 case 0x10ec0215:
3050 case 0x10ec0225:
3051 case 0x10ec0285:
3052 case 0x10ec0295:
3053 case 0x10ec0289:
3054 case 0x10ec0299:
3055 alc_write_coef_idx(codec, 0x48, 0x0);
3056 alc_update_coef_idx(codec, 0x49, 0x0045, 0x0);
3057 alc_update_coef_idx(codec, 0x44, 0x0045 << 8, 0x0);
3058 break;
3059 case 0x10ec0236:
3060 case 0x10ec0256:
3061 alc_write_coef_idx(codec, 0x48, 0x0);
3062 alc_update_coef_idx(codec, 0x49, 0x0045, 0x0);
3063 break;
3064 }
3065}
3066
3067static void alc_enable_headset_jack_key(struct hda_codec *codec)
3068{
3069 struct alc_spec *spec = codec->spec;
3070
3071 if (!spec->has_hs_key)
3072 return;
3073
3074 switch (codec->core.vendor_id) {
3075 case 0x10ec0215:
3076 case 0x10ec0225:
3077 case 0x10ec0285:
3078 case 0x10ec0295:
3079 case 0x10ec0289:
3080 case 0x10ec0299:
3081 alc_write_coef_idx(codec, 0x48, 0xd011);
3082 alc_update_coef_idx(codec, 0x49, 0x007f, 0x0045);
3083 alc_update_coef_idx(codec, 0x44, 0x007f << 8, 0x0045 << 8);
3084 break;
3085 case 0x10ec0236:
3086 case 0x10ec0256:
3087 alc_write_coef_idx(codec, 0x48, 0xd011);
3088 alc_update_coef_idx(codec, 0x49, 0x007f, 0x0045);
3089 break;
3090 }
3091}
3092
3093static void alc_fixup_headset_jack(struct hda_codec *codec,
3094 const struct hda_fixup *fix, int action)
3095{
3096 struct alc_spec *spec = codec->spec;
3097
3098 switch (action) {
3099 case HDA_FIXUP_ACT_PRE_PROBE:
3100 spec->has_hs_key = 1;
3101 snd_hda_jack_detect_enable_callback(codec, 0x55,
3102 alc_headset_btn_callback);
3103 snd_hda_jack_add_kctl(codec, 0x55, "Headset Jack", false,
3104 SND_JACK_HEADSET, alc_headset_btn_keymap);
3105 break;
3106 case HDA_FIXUP_ACT_INIT:
3107 alc_enable_headset_jack_key(codec);
3108 break;
3109 }
3110}
3111
3112static void alc269vb_toggle_power_output(struct hda_codec *codec, int power_up)
3113{
3114 alc_update_coef_idx(codec, 0x04, 1 << 11, power_up ? (1 << 11) : 0);
3115}
3116
3117static void alc269_shutup(struct hda_codec *codec)
3118{
3119 struct alc_spec *spec = codec->spec;
3120
3121 if (spec->codec_variant == ALC269_TYPE_ALC269VB)
3122 alc269vb_toggle_power_output(codec, 0);
3123 if (spec->codec_variant == ALC269_TYPE_ALC269VB &&
3124 (alc_get_coef0(codec) & 0x00ff) == 0x018) {
3125 msleep(150);
3126 }
3127 alc_shutup_pins(codec);
3128}
3129
3130static const struct coef_fw alc282_coefs[] = {
3131 WRITE_COEF(0x03, 0x0002),
3132 UPDATE_COEF(0x05, 0xff3f, 0x0700),
3133 WRITE_COEF(0x07, 0x0200),
3134 UPDATE_COEF(0x06, 0x00f0, 0),
3135 UPDATE_COEF(0x08, 0xfffc, 0x0c2c),
3136 WRITE_COEF(0x0a, 0xcccc),
3137 WRITE_COEF(0x0b, 0xcccc),
3138 WRITE_COEF(0x0e, 0x6e00),
3139 UPDATE_COEF(0x0f, 0xf800, 0x1000),
3140 UPDATE_COEF(0x10, 0xfc00, 0x0c00),
3141 WRITE_COEF(0x6f, 0x0),
3142 UPDATE_COEF(0x0c, 0xfe00, 0),
3143 WRITE_COEF(0x34, 0xa0c0),
3144 UPDATE_COEF(0x16, 0x0008, 0),
3145 UPDATE_COEF(0x1d, 0x00e0, 0),
3146 UPDATE_COEF(0x1f, 0x00e0, 0),
3147 WRITE_COEF(0x21, 0x8804),
3148 WRITE_COEF(0x63, 0x2902),
3149 WRITE_COEF(0x68, 0xa080),
3150 WRITE_COEF(0x69, 0x3400),
3151 WRITE_COEF(0x6a, 0x2f3e),
3152 WRITE_COEF(0x6b, 0x0),
3153 UPDATE_COEF(0x6d, 0x0fff, 0x0900),
3154 WRITE_COEF(0x6e, 0x110a),
3155 UPDATE_COEF(0x70, 0x00f8, 0x00d8),
3156 WRITE_COEF(0x71, 0x0014),
3157 WRITE_COEF(0x72, 0xc2ba),
3158 UPDATE_COEF(0x77, 0x0f80, 0),
3159 WRITE_COEF(0x6c, 0xfc06),
3160 {}
3161};
3162
3163static void alc282_restore_default_value(struct hda_codec *codec)
3164{
3165 alc_process_coef_fw(codec, alc282_coefs);
3166}
3167
3168static void alc282_init(struct hda_codec *codec)
3169{
3170 struct alc_spec *spec = codec->spec;
3171 hda_nid_t hp_pin = alc_get_hp_pin(spec);
3172 bool hp_pin_sense;
3173 int coef78;
3174
3175 alc282_restore_default_value(codec);
3176
3177 if (!hp_pin)
3178 return;
3179 hp_pin_sense = snd_hda_jack_detect(codec, hp_pin);
3180 coef78 = alc_read_coef_idx(codec, 0x78);
3181
3182
3183
3184 alc_write_coef_idx(codec, 0x78, 0x9004);
3185
3186 if (hp_pin_sense)
3187 msleep(2);
3188
3189 snd_hda_codec_write(codec, hp_pin, 0,
3190 AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);
3191
3192 if (hp_pin_sense)
3193 msleep(85);
3194
3195 snd_hda_codec_write(codec, hp_pin, 0,
3196 AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT);
3197
3198 if (hp_pin_sense)
3199 msleep(100);
3200
3201
3202 alc_write_coef_idx(codec, 0x78, coef78);
3203}
3204
3205static void alc282_shutup(struct hda_codec *codec)
3206{
3207 struct alc_spec *spec = codec->spec;
3208 hda_nid_t hp_pin = alc_get_hp_pin(spec);
3209 bool hp_pin_sense;
3210 int coef78;
3211
3212 if (!hp_pin) {
3213 alc269_shutup(codec);
3214 return;
3215 }
3216
3217 hp_pin_sense = snd_hda_jack_detect(codec, hp_pin);
3218 coef78 = alc_read_coef_idx(codec, 0x78);
3219 alc_write_coef_idx(codec, 0x78, 0x9004);
3220
3221 if (hp_pin_sense)
3222 msleep(2);
3223
3224 snd_hda_codec_write(codec, hp_pin, 0,
3225 AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);
3226
3227 if (hp_pin_sense)
3228 msleep(85);
3229
3230 if (!spec->no_shutup_pins)
3231 snd_hda_codec_write(codec, hp_pin, 0,
3232 AC_VERB_SET_PIN_WIDGET_CONTROL, 0x0);
3233
3234 if (hp_pin_sense)
3235 msleep(100);
3236
3237 alc_auto_setup_eapd(codec, false);
3238 alc_shutup_pins(codec);
3239 alc_write_coef_idx(codec, 0x78, coef78);
3240}
3241
3242static const struct coef_fw alc283_coefs[] = {
3243 WRITE_COEF(0x03, 0x0002),
3244 UPDATE_COEF(0x05, 0xff3f, 0x0700),
3245 WRITE_COEF(0x07, 0x0200),
3246 UPDATE_COEF(0x06, 0x00f0, 0),
3247 UPDATE_COEF(0x08, 0xfffc, 0x0c2c),
3248 WRITE_COEF(0x0a, 0xcccc),
3249 WRITE_COEF(0x0b, 0xcccc),
3250 WRITE_COEF(0x0e, 0x6fc0),
3251 UPDATE_COEF(0x0f, 0xf800, 0x1000),
3252 UPDATE_COEF(0x10, 0xfc00, 0x0c00),
3253 WRITE_COEF(0x3a, 0x0),
3254 UPDATE_COEF(0x0c, 0xfe00, 0x0),
3255 WRITE_COEF(0x22, 0xa0c0),
3256 UPDATE_COEFEX(0x53, 0x01, 0x000f, 0x0008),
3257 UPDATE_COEF(0x1d, 0x00e0, 0),
3258 UPDATE_COEF(0x1f, 0x00e0, 0),
3259 WRITE_COEF(0x21, 0x8804),
3260 WRITE_COEF(0x2e, 0x2902),
3261 WRITE_COEF(0x33, 0xa080),
3262 WRITE_COEF(0x34, 0x3400),
3263 WRITE_COEF(0x35, 0x2f3e),
3264 WRITE_COEF(0x36, 0x0),
3265 UPDATE_COEF(0x38, 0x0fff, 0x0900),
3266 WRITE_COEF(0x39, 0x110a),
3267 UPDATE_COEF(0x3b, 0x00f8, 0x00d8),
3268 WRITE_COEF(0x3c, 0x0014),
3269 WRITE_COEF(0x3d, 0xc2ba),
3270 UPDATE_COEF(0x42, 0x0f80, 0x0),
3271 WRITE_COEF(0x49, 0x0),
3272 UPDATE_COEF(0x40, 0xf800, 0x9800),
3273 UPDATE_COEF(0x42, 0xf000, 0x2000),
3274 WRITE_COEF(0x37, 0xfc06),
3275 UPDATE_COEF(0x1b, 0x8000, 0),
3276 {}
3277};
3278
3279static void alc283_restore_default_value(struct hda_codec *codec)
3280{
3281 alc_process_coef_fw(codec, alc283_coefs);
3282}
3283
3284static void alc283_init(struct hda_codec *codec)
3285{
3286 struct alc_spec *spec = codec->spec;
3287 hda_nid_t hp_pin = alc_get_hp_pin(spec);
3288 bool hp_pin_sense;
3289
3290 alc283_restore_default_value(codec);
3291
3292 if (!hp_pin)
3293 return;
3294
3295 msleep(30);
3296 hp_pin_sense = snd_hda_jack_detect(codec, hp_pin);
3297
3298
3299
3300 alc_write_coef_idx(codec, 0x43, 0x9004);
3301
3302 snd_hda_codec_write(codec, hp_pin, 0,
3303 AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);
3304
3305 if (hp_pin_sense)
3306 msleep(85);
3307
3308 snd_hda_codec_write(codec, hp_pin, 0,
3309 AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT);
3310
3311 if (hp_pin_sense)
3312 msleep(85);
3313
3314
3315 alc_update_coef_idx(codec, 0x46, 3 << 12, 0);
3316
3317 alc_write_coef_idx(codec, 0x43, 0x9614);
3318}
3319
3320static void alc283_shutup(struct hda_codec *codec)
3321{
3322 struct alc_spec *spec = codec->spec;
3323 hda_nid_t hp_pin = alc_get_hp_pin(spec);
3324 bool hp_pin_sense;
3325
3326 if (!hp_pin) {
3327 alc269_shutup(codec);
3328 return;
3329 }
3330
3331 hp_pin_sense = snd_hda_jack_detect(codec, hp_pin);
3332
3333 alc_write_coef_idx(codec, 0x43, 0x9004);
3334
3335
3336 alc_write_coef_idx(codec, 0x06, 0x2100);
3337
3338 snd_hda_codec_write(codec, hp_pin, 0,
3339 AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);
3340
3341 if (hp_pin_sense)
3342 msleep(100);
3343
3344 if (!spec->no_shutup_pins)
3345 snd_hda_codec_write(codec, hp_pin, 0,
3346 AC_VERB_SET_PIN_WIDGET_CONTROL, 0x0);
3347
3348 alc_update_coef_idx(codec, 0x46, 0, 3 << 12);
3349
3350 if (hp_pin_sense)
3351 msleep(100);
3352 alc_auto_setup_eapd(codec, false);
3353 alc_shutup_pins(codec);
3354 alc_write_coef_idx(codec, 0x43, 0x9614);
3355}
3356
3357static void alc256_init(struct hda_codec *codec)
3358{
3359 struct alc_spec *spec = codec->spec;
3360 hda_nid_t hp_pin = alc_get_hp_pin(spec);
3361 bool hp_pin_sense;
3362
3363 if (!hp_pin)
3364 hp_pin = 0x21;
3365
3366 msleep(30);
3367
3368 hp_pin_sense = snd_hda_jack_detect(codec, hp_pin);
3369
3370 if (hp_pin_sense)
3371 msleep(2);
3372
3373 alc_update_coefex_idx(codec, 0x57, 0x04, 0x0007, 0x1);
3374 if (spec->ultra_low_power) {
3375 alc_update_coef_idx(codec, 0x03, 1<<1, 1<<1);
3376 alc_update_coef_idx(codec, 0x08, 3<<2, 3<<2);
3377 alc_update_coef_idx(codec, 0x08, 7<<4, 0);
3378 alc_update_coef_idx(codec, 0x3b, 1<<15, 0);
3379 alc_update_coef_idx(codec, 0x0e, 7<<6, 7<<6);
3380 msleep(30);
3381 }
3382
3383 snd_hda_codec_write(codec, hp_pin, 0,
3384 AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);
3385
3386 if (hp_pin_sense || spec->ultra_low_power)
3387 msleep(85);
3388
3389 snd_hda_codec_write(codec, hp_pin, 0,
3390 AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT);
3391
3392 if (hp_pin_sense || spec->ultra_low_power)
3393 msleep(100);
3394
3395 alc_update_coef_idx(codec, 0x46, 3 << 12, 0);
3396 alc_update_coefex_idx(codec, 0x57, 0x04, 0x0007, 0x4);
3397 alc_update_coefex_idx(codec, 0x53, 0x02, 0x8000, 1 << 15);
3398 alc_update_coefex_idx(codec, 0x53, 0x02, 0x8000, 0 << 15);
3399
3400
3401
3402
3403
3404
3405 alc_write_coef_idx(codec, 0x36, 0x5757);
3406}
3407
3408static void alc256_shutup(struct hda_codec *codec)
3409{
3410 struct alc_spec *spec = codec->spec;
3411 hda_nid_t hp_pin = alc_get_hp_pin(spec);
3412 bool hp_pin_sense;
3413
3414 if (!hp_pin)
3415 hp_pin = 0x21;
3416
3417 hp_pin_sense = snd_hda_jack_detect(codec, hp_pin);
3418
3419 if (hp_pin_sense)
3420 msleep(2);
3421
3422 snd_hda_codec_write(codec, hp_pin, 0,
3423 AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);
3424
3425 if (hp_pin_sense || spec->ultra_low_power)
3426 msleep(85);
3427
3428
3429
3430
3431
3432
3433 if (codec->core.vendor_id != 0x10ec0257)
3434 alc_update_coef_idx(codec, 0x46, 0, 3 << 12);
3435
3436 if (!spec->no_shutup_pins)
3437 snd_hda_codec_write(codec, hp_pin, 0,
3438 AC_VERB_SET_PIN_WIDGET_CONTROL, 0x0);
3439
3440 if (hp_pin_sense || spec->ultra_low_power)
3441 msleep(100);
3442
3443 alc_auto_setup_eapd(codec, false);
3444 alc_shutup_pins(codec);
3445 if (spec->ultra_low_power) {
3446 msleep(50);
3447 alc_update_coef_idx(codec, 0x03, 1<<1, 0);
3448 alc_update_coef_idx(codec, 0x08, 7<<4, 7<<4);
3449 alc_update_coef_idx(codec, 0x08, 3<<2, 0);
3450 alc_update_coef_idx(codec, 0x3b, 1<<15, 1<<15);
3451 alc_update_coef_idx(codec, 0x0e, 7<<6, 0);
3452 msleep(30);
3453 }
3454}
3455
3456static void alc225_init(struct hda_codec *codec)
3457{
3458 struct alc_spec *spec = codec->spec;
3459 hda_nid_t hp_pin = alc_get_hp_pin(spec);
3460 bool hp1_pin_sense, hp2_pin_sense;
3461
3462 if (!hp_pin)
3463 hp_pin = 0x21;
3464 msleep(30);
3465
3466 hp1_pin_sense = snd_hda_jack_detect(codec, hp_pin);
3467 hp2_pin_sense = snd_hda_jack_detect(codec, 0x16);
3468
3469 if (hp1_pin_sense || hp2_pin_sense)
3470 msleep(2);
3471
3472 alc_update_coefex_idx(codec, 0x57, 0x04, 0x0007, 0x1);
3473 if (spec->ultra_low_power) {
3474 alc_update_coef_idx(codec, 0x08, 0x0f << 2, 3<<2);
3475 alc_update_coef_idx(codec, 0x0e, 7<<6, 7<<6);
3476 alc_update_coef_idx(codec, 0x33, 1<<11, 0);
3477 msleep(30);
3478 }
3479
3480 if (hp1_pin_sense || spec->ultra_low_power)
3481 snd_hda_codec_write(codec, hp_pin, 0,
3482 AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);
3483 if (hp2_pin_sense)
3484 snd_hda_codec_write(codec, 0x16, 0,
3485 AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);
3486
3487 if (hp1_pin_sense || hp2_pin_sense || spec->ultra_low_power)
3488 msleep(85);
3489
3490 if (hp1_pin_sense || spec->ultra_low_power)
3491 snd_hda_codec_write(codec, hp_pin, 0,
3492 AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT);
3493 if (hp2_pin_sense)
3494 snd_hda_codec_write(codec, 0x16, 0,
3495 AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT);
3496
3497 if (hp1_pin_sense || hp2_pin_sense || spec->ultra_low_power)
3498 msleep(100);
3499
3500 alc_update_coef_idx(codec, 0x4a, 3 << 10, 0);
3501 alc_update_coefex_idx(codec, 0x57, 0x04, 0x0007, 0x4);
3502}
3503
3504static void alc225_shutup(struct hda_codec *codec)
3505{
3506 struct alc_spec *spec = codec->spec;
3507 hda_nid_t hp_pin = alc_get_hp_pin(spec);
3508 bool hp1_pin_sense, hp2_pin_sense;
3509
3510 if (!hp_pin)
3511 hp_pin = 0x21;
3512
3513 alc_disable_headset_jack_key(codec);
3514
3515 alc_update_coef_idx(codec, 0x4a, 0, 3 << 10);
3516
3517 hp1_pin_sense = snd_hda_jack_detect(codec, hp_pin);
3518 hp2_pin_sense = snd_hda_jack_detect(codec, 0x16);
3519
3520 if (hp1_pin_sense || hp2_pin_sense)
3521 msleep(2);
3522
3523 if (hp1_pin_sense || spec->ultra_low_power)
3524 snd_hda_codec_write(codec, hp_pin, 0,
3525 AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);
3526 if (hp2_pin_sense)
3527 snd_hda_codec_write(codec, 0x16, 0,
3528 AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);
3529
3530 if (hp1_pin_sense || hp2_pin_sense || spec->ultra_low_power)
3531 msleep(85);
3532
3533 if (hp1_pin_sense || spec->ultra_low_power)
3534 snd_hda_codec_write(codec, hp_pin, 0,
3535 AC_VERB_SET_PIN_WIDGET_CONTROL, 0x0);
3536 if (hp2_pin_sense)
3537 snd_hda_codec_write(codec, 0x16, 0,
3538 AC_VERB_SET_PIN_WIDGET_CONTROL, 0x0);
3539
3540 if (hp1_pin_sense || hp2_pin_sense || spec->ultra_low_power)
3541 msleep(100);
3542
3543 alc_auto_setup_eapd(codec, false);
3544 alc_shutup_pins(codec);
3545 if (spec->ultra_low_power) {
3546 msleep(50);
3547 alc_update_coef_idx(codec, 0x08, 0x0f << 2, 0x0c << 2);
3548 alc_update_coef_idx(codec, 0x0e, 7<<6, 0);
3549 alc_update_coef_idx(codec, 0x33, 1<<11, 1<<11);
3550 alc_update_coef_idx(codec, 0x4a, 3<<4, 2<<4);
3551 msleep(30);
3552 }
3553
3554 alc_update_coef_idx(codec, 0x4a, 3 << 10, 0);
3555 alc_enable_headset_jack_key(codec);
3556}
3557
3558static void alc_default_init(struct hda_codec *codec)
3559{
3560 struct alc_spec *spec = codec->spec;
3561 hda_nid_t hp_pin = alc_get_hp_pin(spec);
3562 bool hp_pin_sense;
3563
3564 if (!hp_pin)
3565 return;
3566
3567 msleep(30);
3568
3569 hp_pin_sense = snd_hda_jack_detect(codec, hp_pin);
3570
3571 if (hp_pin_sense)
3572 msleep(2);
3573
3574 snd_hda_codec_write(codec, hp_pin, 0,
3575 AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);
3576
3577 if (hp_pin_sense)
3578 msleep(85);
3579
3580 snd_hda_codec_write(codec, hp_pin, 0,
3581 AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT);
3582
3583 if (hp_pin_sense)
3584 msleep(100);
3585}
3586
3587static void alc_default_shutup(struct hda_codec *codec)
3588{
3589 struct alc_spec *spec = codec->spec;
3590 hda_nid_t hp_pin = alc_get_hp_pin(spec);
3591 bool hp_pin_sense;
3592
3593 if (!hp_pin) {
3594 alc269_shutup(codec);
3595 return;
3596 }
3597
3598 hp_pin_sense = snd_hda_jack_detect(codec, hp_pin);
3599
3600 if (hp_pin_sense)
3601 msleep(2);
3602
3603 snd_hda_codec_write(codec, hp_pin, 0,
3604 AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);
3605
3606 if (hp_pin_sense)
3607 msleep(85);
3608
3609 if (!spec->no_shutup_pins)
3610 snd_hda_codec_write(codec, hp_pin, 0,
3611 AC_VERB_SET_PIN_WIDGET_CONTROL, 0x0);
3612
3613 if (hp_pin_sense)
3614 msleep(100);
3615
3616 alc_auto_setup_eapd(codec, false);
3617 alc_shutup_pins(codec);
3618}
3619
3620static void alc294_hp_init(struct hda_codec *codec)
3621{
3622 struct alc_spec *spec = codec->spec;
3623 hda_nid_t hp_pin = alc_get_hp_pin(spec);
3624 int i, val;
3625
3626 if (!hp_pin)
3627 return;
3628
3629 snd_hda_codec_write(codec, hp_pin, 0,
3630 AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);
3631
3632 msleep(100);
3633
3634 if (!spec->no_shutup_pins)
3635 snd_hda_codec_write(codec, hp_pin, 0,
3636 AC_VERB_SET_PIN_WIDGET_CONTROL, 0x0);
3637
3638 alc_update_coef_idx(codec, 0x6f, 0x000f, 0);
3639 alc_update_coefex_idx(codec, 0x58, 0x00, 0x8000, 0x8000);
3640
3641
3642 val = alc_read_coefex_idx(codec, 0x58, 0x01);
3643 for (i = 0; i < 20 && val & 0x0080; i++) {
3644 msleep(50);
3645 val = alc_read_coefex_idx(codec, 0x58, 0x01);
3646 }
3647
3648 alc_update_coef_idx(codec, 0x6f, 0x000f, 0x000b);
3649 msleep(50);
3650}
3651
3652static void alc294_init(struct hda_codec *codec)
3653{
3654 struct alc_spec *spec = codec->spec;
3655
3656
3657 if (!spec->done_hp_init ||
3658 codec->core.dev.power.power_state.event == PM_EVENT_RESTORE) {
3659 alc294_hp_init(codec);
3660 spec->done_hp_init = true;
3661 }
3662 alc_default_init(codec);
3663}
3664
3665static void alc5505_coef_set(struct hda_codec *codec, unsigned int index_reg,
3666 unsigned int val)
3667{
3668 snd_hda_codec_write(codec, 0x51, 0, AC_VERB_SET_COEF_INDEX, index_reg >> 1);
3669 snd_hda_codec_write(codec, 0x51, 0, AC_VERB_SET_PROC_COEF, val & 0xffff);
3670 snd_hda_codec_write(codec, 0x51, 0, AC_VERB_SET_PROC_COEF, val >> 16);
3671}
3672
3673static int alc5505_coef_get(struct hda_codec *codec, unsigned int index_reg)
3674{
3675 unsigned int val;
3676
3677 snd_hda_codec_write(codec, 0x51, 0, AC_VERB_SET_COEF_INDEX, index_reg >> 1);
3678 val = snd_hda_codec_read(codec, 0x51, 0, AC_VERB_GET_PROC_COEF, 0)
3679 & 0xffff;
3680 val |= snd_hda_codec_read(codec, 0x51, 0, AC_VERB_GET_PROC_COEF, 0)
3681 << 16;
3682 return val;
3683}
3684
3685static void alc5505_dsp_halt(struct hda_codec *codec)
3686{
3687 unsigned int val;
3688
3689 alc5505_coef_set(codec, 0x3000, 0x000c);
3690 alc5505_coef_set(codec, 0x880c, 0x0008);
3691 alc5505_coef_set(codec, 0x61c0, 0x11110080);
3692 alc5505_coef_set(codec, 0x6230, 0xfc0d4011);
3693 alc5505_coef_set(codec, 0x61b4, 0x040a2b03);
3694 alc5505_coef_set(codec, 0x61b0, 0x00005b17);
3695 alc5505_coef_set(codec, 0x61b8, 0x04133303);
3696 val = alc5505_coef_get(codec, 0x6220);
3697 alc5505_coef_set(codec, 0x6220, (val | 0x3000));
3698}
3699
3700static void alc5505_dsp_back_from_halt(struct hda_codec *codec)
3701{
3702 alc5505_coef_set(codec, 0x61b8, 0x04133302);
3703 alc5505_coef_set(codec, 0x61b0, 0x00005b16);
3704 alc5505_coef_set(codec, 0x61b4, 0x040a2b02);
3705 alc5505_coef_set(codec, 0x6230, 0xf80d4011);
3706 alc5505_coef_set(codec, 0x6220, 0x2002010f);
3707 alc5505_coef_set(codec, 0x880c, 0x00000004);
3708}
3709
3710static void alc5505_dsp_init(struct hda_codec *codec)
3711{
3712 unsigned int val;
3713
3714 alc5505_dsp_halt(codec);
3715 alc5505_dsp_back_from_halt(codec);
3716 alc5505_coef_set(codec, 0x61b0, 0x5b14);
3717 alc5505_coef_set(codec, 0x61b0, 0x5b16);
3718 alc5505_coef_set(codec, 0x61b4, 0x04132b00);
3719 alc5505_coef_set(codec, 0x61b4, 0x04132b02);
3720 alc5505_coef_set(codec, 0x61b8, 0x041f3300);
3721 alc5505_coef_set(codec, 0x61b8, 0x041f3302);
3722 snd_hda_codec_write(codec, 0x51, 0, AC_VERB_SET_CODEC_RESET, 0);
3723 alc5505_coef_set(codec, 0x61b8, 0x041b3302);
3724 alc5505_coef_set(codec, 0x61b8, 0x04173302);
3725 alc5505_coef_set(codec, 0x61b8, 0x04163302);
3726 alc5505_coef_set(codec, 0x8800, 0x348b328b);
3727 alc5505_coef_set(codec, 0x8808, 0x00020022);
3728 alc5505_coef_set(codec, 0x8818, 0x00000400);
3729
3730 val = alc5505_coef_get(codec, 0x6200) >> 16;
3731 if (val <= 3)
3732 alc5505_coef_set(codec, 0x6220, 0x2002010f);
3733 else
3734 alc5505_coef_set(codec, 0x6220, 0x6002018f);
3735
3736 alc5505_coef_set(codec, 0x61ac, 0x055525f0);
3737 alc5505_coef_set(codec, 0x61c0, 0x12230080);
3738 alc5505_coef_set(codec, 0x61b4, 0x040e2b02);
3739 alc5505_coef_set(codec, 0x61bc, 0x010234f8);
3740 alc5505_coef_set(codec, 0x880c, 0x00000004);
3741 alc5505_coef_set(codec, 0x880c, 0x00000003);
3742 alc5505_coef_set(codec, 0x880c, 0x00000010);
3743
3744#ifdef HALT_REALTEK_ALC5505
3745 alc5505_dsp_halt(codec);
3746#endif
3747}
3748
3749#ifdef HALT_REALTEK_ALC5505
3750#define alc5505_dsp_suspend(codec) do { } while (0)
3751#define alc5505_dsp_resume(codec) do { } while (0)
3752#else
3753#define alc5505_dsp_suspend(codec) alc5505_dsp_halt(codec)
3754#define alc5505_dsp_resume(codec) alc5505_dsp_back_from_halt(codec)
3755#endif
3756
3757#ifdef CONFIG_PM
3758static int alc269_suspend(struct hda_codec *codec)
3759{
3760 struct alc_spec *spec = codec->spec;
3761
3762 if (spec->has_alc5505_dsp)
3763 alc5505_dsp_suspend(codec);
3764 return alc_suspend(codec);
3765}
3766
3767static int alc269_resume(struct hda_codec *codec)
3768{
3769 struct alc_spec *spec = codec->spec;
3770
3771 if (spec->codec_variant == ALC269_TYPE_ALC269VB)
3772 alc269vb_toggle_power_output(codec, 0);
3773 if (spec->codec_variant == ALC269_TYPE_ALC269VB &&
3774 (alc_get_coef0(codec) & 0x00ff) == 0x018) {
3775 msleep(150);
3776 }
3777
3778 codec->patch_ops.init(codec);
3779
3780 if (spec->codec_variant == ALC269_TYPE_ALC269VB)
3781 alc269vb_toggle_power_output(codec, 1);
3782 if (spec->codec_variant == ALC269_TYPE_ALC269VB &&
3783 (alc_get_coef0(codec) & 0x00ff) == 0x017) {
3784 msleep(200);
3785 }
3786
3787 snd_hda_regmap_sync(codec);
3788 hda_call_check_power_status(codec, 0x01);
3789
3790
3791
3792
3793
3794 if (spec->gpio_data)
3795 alc_write_gpio_data(codec);
3796
3797 if (spec->has_alc5505_dsp)
3798 alc5505_dsp_resume(codec);
3799
3800 return 0;
3801}
3802#endif
3803
3804static void alc269_fixup_pincfg_no_hp_to_lineout(struct hda_codec *codec,
3805 const struct hda_fixup *fix, int action)
3806{
3807 struct alc_spec *spec = codec->spec;
3808
3809 if (action == HDA_FIXUP_ACT_PRE_PROBE)
3810 spec->parse_flags = HDA_PINCFG_NO_HP_FIXUP;
3811}
3812
3813static void alc269_fixup_pincfg_U7x7_headset_mic(struct hda_codec *codec,
3814 const struct hda_fixup *fix,
3815 int action)
3816{
3817 unsigned int cfg_headphone = snd_hda_codec_get_pincfg(codec, 0x21);
3818 unsigned int cfg_headset_mic = snd_hda_codec_get_pincfg(codec, 0x19);
3819
3820 if (cfg_headphone && cfg_headset_mic == 0x411111f0)
3821 snd_hda_codec_set_pincfg(codec, 0x19,
3822 (cfg_headphone & ~AC_DEFCFG_DEVICE) |
3823 (AC_JACK_MIC_IN << AC_DEFCFG_DEVICE_SHIFT));
3824}
3825
3826static void alc269_fixup_hweq(struct hda_codec *codec,
3827 const struct hda_fixup *fix, int action)
3828{
3829 if (action == HDA_FIXUP_ACT_INIT)
3830 alc_update_coef_idx(codec, 0x1e, 0, 0x80);
3831}
3832
3833static void alc269_fixup_headset_mic(struct hda_codec *codec,
3834 const struct hda_fixup *fix, int action)
3835{
3836 struct alc_spec *spec = codec->spec;
3837
3838 if (action == HDA_FIXUP_ACT_PRE_PROBE)
3839 spec->parse_flags |= HDA_PINCFG_HEADSET_MIC;
3840}
3841
3842static void alc271_fixup_dmic(struct hda_codec *codec,
3843 const struct hda_fixup *fix, int action)
3844{
3845 static const struct hda_verb verbs[] = {
3846 {0x20, AC_VERB_SET_COEF_INDEX, 0x0d},
3847 {0x20, AC_VERB_SET_PROC_COEF, 0x4000},
3848 {}
3849 };
3850 unsigned int cfg;
3851
3852 if (strcmp(codec->core.chip_name, "ALC271X") &&
3853 strcmp(codec->core.chip_name, "ALC269VB"))
3854 return;
3855 cfg = snd_hda_codec_get_pincfg(codec, 0x12);
3856 if (get_defcfg_connect(cfg) == AC_JACK_PORT_FIXED)
3857 snd_hda_sequence_write(codec, verbs);
3858}
3859
3860static void alc269_fixup_pcm_44k(struct hda_codec *codec,
3861 const struct hda_fixup *fix, int action)
3862{
3863 struct alc_spec *spec = codec->spec;
3864
3865 if (action != HDA_FIXUP_ACT_PROBE)
3866 return;
3867
3868
3869
3870
3871 spec->gen.stream_analog_playback = &alc269_44k_pcm_analog_playback;
3872 spec->gen.stream_analog_capture = &alc269_44k_pcm_analog_capture;
3873}
3874
3875static void alc269_fixup_stereo_dmic(struct hda_codec *codec,
3876 const struct hda_fixup *fix, int action)
3877{
3878
3879
3880
3881
3882
3883 if (action == HDA_FIXUP_ACT_INIT)
3884 alc_update_coef_idx(codec, 0x07, 0, 0x80);
3885}
3886
3887static void alc269_quanta_automute(struct hda_codec *codec)
3888{
3889 snd_hda_gen_update_outputs(codec);
3890
3891 alc_write_coef_idx(codec, 0x0c, 0x680);
3892 alc_write_coef_idx(codec, 0x0c, 0x480);
3893}
3894
3895static void alc269_fixup_quanta_mute(struct hda_codec *codec,
3896 const struct hda_fixup *fix, int action)
3897{
3898 struct alc_spec *spec = codec->spec;
3899 if (action != HDA_FIXUP_ACT_PROBE)
3900 return;
3901 spec->gen.automute_hook = alc269_quanta_automute;
3902}
3903
3904static void alc269_x101_hp_automute_hook(struct hda_codec *codec,
3905 struct hda_jack_callback *jack)
3906{
3907 struct alc_spec *spec = codec->spec;
3908 int vref;
3909 msleep(200);
3910 snd_hda_gen_hp_automute(codec, jack);
3911
3912 vref = spec->gen.hp_jack_present ? PIN_VREF80 : 0;
3913 msleep(100);
3914 snd_hda_codec_write(codec, 0x18, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
3915 vref);
3916 msleep(500);
3917 snd_hda_codec_write(codec, 0x18, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
3918 vref);
3919}
3920
3921
3922
3923
3924struct hda_alc298_mbxinit {
3925 unsigned char value_0x23;
3926 unsigned char value_0x25;
3927};
3928
3929static void alc298_huawei_mbx_stereo_seq(struct hda_codec *codec,
3930 const struct hda_alc298_mbxinit *initval,
3931 bool first)
3932{
3933 snd_hda_codec_write(codec, 0x06, 0, AC_VERB_SET_DIGI_CONVERT_3, 0x0);
3934 alc_write_coef_idx(codec, 0x26, 0xb000);
3935
3936 if (first)
3937 snd_hda_codec_write(codec, 0x21, 0, AC_VERB_GET_PIN_SENSE, 0x0);
3938
3939 snd_hda_codec_write(codec, 0x6, 0, AC_VERB_SET_DIGI_CONVERT_3, 0x80);
3940 alc_write_coef_idx(codec, 0x26, 0xf000);
3941 alc_write_coef_idx(codec, 0x23, initval->value_0x23);
3942
3943 if (initval->value_0x23 != 0x1e)
3944 alc_write_coef_idx(codec, 0x25, initval->value_0x25);
3945
3946 snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_COEF_INDEX, 0x26);
3947 snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_PROC_COEF, 0xb010);
3948}
3949
3950static void alc298_fixup_huawei_mbx_stereo(struct hda_codec *codec,
3951 const struct hda_fixup *fix,
3952 int action)
3953{
3954
3955 static const struct hda_alc298_mbxinit dac_init[] = {
3956 {0x0c, 0x00}, {0x0d, 0x00}, {0x0e, 0x00}, {0x0f, 0x00},
3957 {0x10, 0x00}, {0x1a, 0x40}, {0x1b, 0x82}, {0x1c, 0x00},
3958 {0x1d, 0x00}, {0x1e, 0x00}, {0x1f, 0x00},
3959 {0x20, 0xc2}, {0x21, 0xc8}, {0x22, 0x26}, {0x23, 0x24},
3960 {0x27, 0xff}, {0x28, 0xff}, {0x29, 0xff}, {0x2a, 0x8f},
3961 {0x2b, 0x02}, {0x2c, 0x48}, {0x2d, 0x34}, {0x2e, 0x00},
3962 {0x2f, 0x00},
3963 {0x30, 0x00}, {0x31, 0x00}, {0x32, 0x00}, {0x33, 0x00},
3964 {0x34, 0x00}, {0x35, 0x01}, {0x36, 0x93}, {0x37, 0x0c},
3965 {0x38, 0x00}, {0x39, 0x00}, {0x3a, 0xf8}, {0x38, 0x80},
3966 {}
3967 };
3968 const struct hda_alc298_mbxinit *seq;
3969
3970 if (action != HDA_FIXUP_ACT_INIT)
3971 return;
3972
3973
3974 snd_hda_codec_write(codec, 0x06, 0, AC_VERB_SET_DIGI_CONVERT_3, 0x00);
3975 snd_hda_codec_write(codec, 0x06, 0, AC_VERB_SET_DIGI_CONVERT_3, 0x80);
3976 alc_write_coef_idx(codec, 0x26, 0xf000);
3977 alc_write_coef_idx(codec, 0x22, 0x31);
3978 alc_write_coef_idx(codec, 0x23, 0x0b);
3979 alc_write_coef_idx(codec, 0x25, 0x00);
3980 snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_COEF_INDEX, 0x26);
3981 snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_PROC_COEF, 0xb010);
3982
3983 for (seq = dac_init; seq->value_0x23; seq++)
3984 alc298_huawei_mbx_stereo_seq(codec, seq, seq == dac_init);
3985}
3986
3987static void alc269_fixup_x101_headset_mic(struct hda_codec *codec,
3988 const struct hda_fixup *fix, int action)
3989{
3990 struct alc_spec *spec = codec->spec;
3991 if (action == HDA_FIXUP_ACT_PRE_PROBE) {
3992 spec->parse_flags |= HDA_PINCFG_HEADSET_MIC;
3993 spec->gen.hp_automute_hook = alc269_x101_hp_automute_hook;
3994 }
3995}
3996
3997static void alc_update_vref_led(struct hda_codec *codec, hda_nid_t pin,
3998 bool polarity, bool on)
3999{
4000 unsigned int pinval;
4001
4002 if (!pin)
4003 return;
4004 if (polarity)
4005 on = !on;
4006 pinval = snd_hda_codec_get_pin_target(codec, pin);
4007 pinval &= ~AC_PINCTL_VREFEN;
4008 pinval |= on ? AC_PINCTL_VREF_80 : AC_PINCTL_VREF_HIZ;
4009
4010 snd_hda_power_up_pm(codec);
4011 snd_hda_set_pin_ctl_cache(codec, pin, pinval);
4012 snd_hda_power_down_pm(codec);
4013}
4014
4015
4016static int vref_mute_led_set(struct led_classdev *led_cdev,
4017 enum led_brightness brightness)
4018{
4019 struct hda_codec *codec = dev_to_hda_codec(led_cdev->dev->parent);
4020 struct alc_spec *spec = codec->spec;
4021
4022 alc_update_vref_led(codec, spec->mute_led_nid,
4023 spec->mute_led_polarity, brightness);
4024 return 0;
4025}
4026
4027
4028static unsigned int led_power_filter(struct hda_codec *codec,
4029 hda_nid_t nid,
4030 unsigned int power_state)
4031{
4032 struct alc_spec *spec = codec->spec;
4033
4034 if (power_state != AC_PWRST_D3 || nid == 0 ||
4035 (nid != spec->mute_led_nid && nid != spec->cap_mute_led_nid))
4036 return power_state;
4037
4038
4039 snd_hda_set_pin_ctl(codec, nid,
4040 snd_hda_codec_get_pin_target(codec, nid));
4041
4042 return snd_hda_gen_path_power_filter(codec, nid, power_state);
4043}
4044
4045static void alc269_fixup_hp_mute_led(struct hda_codec *codec,
4046 const struct hda_fixup *fix, int action)
4047{
4048 struct alc_spec *spec = codec->spec;
4049 const struct dmi_device *dev = NULL;
4050
4051 if (action != HDA_FIXUP_ACT_PRE_PROBE)
4052 return;
4053
4054 while ((dev = dmi_find_device(DMI_DEV_TYPE_OEM_STRING, NULL, dev))) {
4055 int pol, pin;
4056 if (sscanf(dev->name, "HP_Mute_LED_%d_%x", &pol, &pin) != 2)
4057 continue;
4058 if (pin < 0x0a || pin >= 0x10)
4059 break;
4060 spec->mute_led_polarity = pol;
4061 spec->mute_led_nid = pin - 0x0a + 0x18;
4062 snd_hda_gen_add_mute_led_cdev(codec, vref_mute_led_set);
4063 codec->power_filter = led_power_filter;
4064 codec_dbg(codec,
4065 "Detected mute LED for %x:%d\n", spec->mute_led_nid,
4066 spec->mute_led_polarity);
4067 break;
4068 }
4069}
4070
4071static void alc269_fixup_hp_mute_led_micx(struct hda_codec *codec,
4072 const struct hda_fixup *fix,
4073 int action, hda_nid_t pin)
4074{
4075 struct alc_spec *spec = codec->spec;
4076
4077 if (action == HDA_FIXUP_ACT_PRE_PROBE) {
4078 spec->mute_led_polarity = 0;
4079 spec->mute_led_nid = pin;
4080 snd_hda_gen_add_mute_led_cdev(codec, vref_mute_led_set);
4081 codec->power_filter = led_power_filter;
4082 }
4083}
4084
4085static void alc269_fixup_hp_mute_led_mic1(struct hda_codec *codec,
4086 const struct hda_fixup *fix, int action)
4087{
4088 alc269_fixup_hp_mute_led_micx(codec, fix, action, 0x18);
4089}
4090
4091static void alc269_fixup_hp_mute_led_mic2(struct hda_codec *codec,
4092 const struct hda_fixup *fix, int action)
4093{
4094 alc269_fixup_hp_mute_led_micx(codec, fix, action, 0x19);
4095}
4096
4097static void alc269_fixup_hp_mute_led_mic3(struct hda_codec *codec,
4098 const struct hda_fixup *fix, int action)
4099{
4100 alc269_fixup_hp_mute_led_micx(codec, fix, action, 0x1b);
4101}
4102
4103
4104static void alc_update_gpio_led(struct hda_codec *codec, unsigned int mask,
4105 int polarity, bool enabled)
4106{
4107 if (polarity)
4108 enabled = !enabled;
4109 alc_update_gpio_data(codec, mask, !enabled);
4110}
4111
4112
4113static int gpio_mute_led_set(struct led_classdev *led_cdev,
4114 enum led_brightness brightness)
4115{
4116 struct hda_codec *codec = dev_to_hda_codec(led_cdev->dev->parent);
4117 struct alc_spec *spec = codec->spec;
4118
4119 alc_update_gpio_led(codec, spec->gpio_mute_led_mask,
4120 spec->mute_led_polarity, !brightness);
4121 return 0;
4122}
4123
4124
4125static int micmute_led_set(struct led_classdev *led_cdev,
4126 enum led_brightness brightness)
4127{
4128 struct hda_codec *codec = dev_to_hda_codec(led_cdev->dev->parent);
4129 struct alc_spec *spec = codec->spec;
4130
4131 alc_update_gpio_led(codec, spec->gpio_mic_led_mask,
4132 spec->micmute_led_polarity, !brightness);
4133 return 0;
4134}
4135
4136
4137static void alc_fixup_hp_gpio_led(struct hda_codec *codec,
4138 int action,
4139 unsigned int mute_mask,
4140 unsigned int micmute_mask)
4141{
4142 struct alc_spec *spec = codec->spec;
4143
4144 alc_fixup_gpio(codec, action, mute_mask | micmute_mask);
4145
4146 if (action != HDA_FIXUP_ACT_PRE_PROBE)
4147 return;
4148 if (mute_mask) {
4149 spec->gpio_mute_led_mask = mute_mask;
4150 snd_hda_gen_add_mute_led_cdev(codec, gpio_mute_led_set);
4151 }
4152 if (micmute_mask) {
4153 spec->gpio_mic_led_mask = micmute_mask;
4154 snd_hda_gen_add_micmute_led_cdev(codec, micmute_led_set);
4155 }
4156}
4157
4158static void alc269_fixup_hp_gpio_led(struct hda_codec *codec,
4159 const struct hda_fixup *fix, int action)
4160{
4161 alc_fixup_hp_gpio_led(codec, action, 0x08, 0x10);
4162}
4163
4164static void alc285_fixup_hp_gpio_led(struct hda_codec *codec,
4165 const struct hda_fixup *fix, int action)
4166{
4167 alc_fixup_hp_gpio_led(codec, action, 0x04, 0x01);
4168}
4169
4170static void alc286_fixup_hp_gpio_led(struct hda_codec *codec,
4171 const struct hda_fixup *fix, int action)
4172{
4173 alc_fixup_hp_gpio_led(codec, action, 0x02, 0x20);
4174}
4175
4176
4177static int vref_micmute_led_set(struct led_classdev *led_cdev,
4178 enum led_brightness brightness)
4179{
4180 struct hda_codec *codec = dev_to_hda_codec(led_cdev->dev->parent);
4181 struct alc_spec *spec = codec->spec;
4182
4183 alc_update_vref_led(codec, spec->cap_mute_led_nid,
4184 spec->micmute_led_polarity, brightness);
4185 return 0;
4186}
4187
4188static void alc269_fixup_hp_gpio_mic1_led(struct hda_codec *codec,
4189 const struct hda_fixup *fix, int action)
4190{
4191 struct alc_spec *spec = codec->spec;
4192
4193 alc_fixup_hp_gpio_led(codec, action, 0x08, 0);
4194 if (action == HDA_FIXUP_ACT_PRE_PROBE) {
4195
4196
4197
4198 spec->gpio_mask |= 0x10;
4199 spec->gpio_dir |= 0x10;
4200 spec->cap_mute_led_nid = 0x18;
4201 snd_hda_gen_add_micmute_led_cdev(codec, vref_micmute_led_set);
4202 codec->power_filter = led_power_filter;
4203 }
4204}
4205
4206static void alc280_fixup_hp_gpio4(struct hda_codec *codec,
4207 const struct hda_fixup *fix, int action)
4208{
4209 struct alc_spec *spec = codec->spec;
4210
4211 alc_fixup_hp_gpio_led(codec, action, 0x08, 0);
4212 if (action == HDA_FIXUP_ACT_PRE_PROBE) {
4213 spec->cap_mute_led_nid = 0x18;
4214 snd_hda_gen_add_micmute_led_cdev(codec, vref_micmute_led_set);
4215 codec->power_filter = led_power_filter;
4216 }
4217}
4218
4219static void alc_update_coef_led(struct hda_codec *codec,
4220 struct alc_coef_led *led,
4221 bool polarity, bool on)
4222{
4223 if (polarity)
4224 on = !on;
4225
4226 alc_update_coef_idx(codec, led->idx, led->mask,
4227 on ? led->on : led->off);
4228}
4229
4230
4231static int coef_mute_led_set(struct led_classdev *led_cdev,
4232 enum led_brightness brightness)
4233{
4234 struct hda_codec *codec = dev_to_hda_codec(led_cdev->dev->parent);
4235 struct alc_spec *spec = codec->spec;
4236
4237 alc_update_coef_led(codec, &spec->mute_led_coef,
4238 spec->mute_led_polarity, brightness);
4239 return 0;
4240}
4241
4242static void alc285_fixup_hp_mute_led_coefbit(struct hda_codec *codec,
4243 const struct hda_fixup *fix,
4244 int action)
4245{
4246 struct alc_spec *spec = codec->spec;
4247
4248 if (action == HDA_FIXUP_ACT_PRE_PROBE) {
4249 spec->mute_led_polarity = 0;
4250 spec->mute_led_coef.idx = 0x0b;
4251 spec->mute_led_coef.mask = 1 << 3;
4252 spec->mute_led_coef.on = 1 << 3;
4253 spec->mute_led_coef.off = 0;
4254 snd_hda_gen_add_mute_led_cdev(codec, coef_mute_led_set);
4255 }
4256}
4257
4258static void alc236_fixup_hp_mute_led_coefbit(struct hda_codec *codec,
4259 const struct hda_fixup *fix,
4260 int action)
4261{
4262 struct alc_spec *spec = codec->spec;
4263
4264 if (action == HDA_FIXUP_ACT_PRE_PROBE) {
4265 spec->mute_led_polarity = 0;
4266 spec->mute_led_coef.idx = 0x34;
4267 spec->mute_led_coef.mask = 1 << 5;
4268 spec->mute_led_coef.on = 0;
4269 spec->mute_led_coef.off = 1 << 5;
4270 snd_hda_gen_add_mute_led_cdev(codec, coef_mute_led_set);
4271 }
4272}
4273
4274
4275static int coef_micmute_led_set(struct led_classdev *led_cdev,
4276 enum led_brightness brightness)
4277{
4278 struct hda_codec *codec = dev_to_hda_codec(led_cdev->dev->parent);
4279 struct alc_spec *spec = codec->spec;
4280
4281 alc_update_coef_led(codec, &spec->mic_led_coef,
4282 spec->micmute_led_polarity, brightness);
4283 return 0;
4284}
4285
4286static void alc285_fixup_hp_coef_micmute_led(struct hda_codec *codec,
4287 const struct hda_fixup *fix, int action)
4288{
4289 struct alc_spec *spec = codec->spec;
4290
4291 if (action == HDA_FIXUP_ACT_PRE_PROBE) {
4292 spec->mic_led_coef.idx = 0x19;
4293 spec->mic_led_coef.mask = 1 << 13;
4294 spec->mic_led_coef.on = 1 << 13;
4295 spec->mic_led_coef.off = 0;
4296 snd_hda_gen_add_micmute_led_cdev(codec, coef_micmute_led_set);
4297 }
4298}
4299
4300static void alc236_fixup_hp_coef_micmute_led(struct hda_codec *codec,
4301 const struct hda_fixup *fix, int action)
4302{
4303 struct alc_spec *spec = codec->spec;
4304
4305 if (action == HDA_FIXUP_ACT_PRE_PROBE) {
4306 spec->mic_led_coef.idx = 0x35;
4307 spec->mic_led_coef.mask = 3 << 2;
4308 spec->mic_led_coef.on = 2 << 2;
4309 spec->mic_led_coef.off = 1 << 2;
4310 snd_hda_gen_add_micmute_led_cdev(codec, coef_micmute_led_set);
4311 }
4312}
4313
4314static void alc285_fixup_hp_mute_led(struct hda_codec *codec,
4315 const struct hda_fixup *fix, int action)
4316{
4317 alc285_fixup_hp_mute_led_coefbit(codec, fix, action);
4318 alc285_fixup_hp_coef_micmute_led(codec, fix, action);
4319}
4320
4321static void alc236_fixup_hp_mute_led(struct hda_codec *codec,
4322 const struct hda_fixup *fix, int action)
4323{
4324 alc236_fixup_hp_mute_led_coefbit(codec, fix, action);
4325 alc236_fixup_hp_coef_micmute_led(codec, fix, action);
4326}
4327
4328#if IS_REACHABLE(CONFIG_INPUT)
4329static void gpio2_mic_hotkey_event(struct hda_codec *codec,
4330 struct hda_jack_callback *event)
4331{
4332 struct alc_spec *spec = codec->spec;
4333
4334
4335
4336 input_report_key(spec->kb_dev, spec->alc_mute_keycode_map[ALC_KEY_MICMUTE_INDEX], 1);
4337 input_sync(spec->kb_dev);
4338 input_report_key(spec->kb_dev, spec->alc_mute_keycode_map[ALC_KEY_MICMUTE_INDEX], 0);
4339 input_sync(spec->kb_dev);
4340}
4341
4342static int alc_register_micmute_input_device(struct hda_codec *codec)
4343{
4344 struct alc_spec *spec = codec->spec;
4345 int i;
4346
4347 spec->kb_dev = input_allocate_device();
4348 if (!spec->kb_dev) {
4349 codec_err(codec, "Out of memory (input_allocate_device)\n");
4350 return -ENOMEM;
4351 }
4352
4353 spec->alc_mute_keycode_map[ALC_KEY_MICMUTE_INDEX] = KEY_MICMUTE;
4354
4355 spec->kb_dev->name = "Microphone Mute Button";
4356 spec->kb_dev->evbit[0] = BIT_MASK(EV_KEY);
4357 spec->kb_dev->keycodesize = sizeof(spec->alc_mute_keycode_map[0]);
4358 spec->kb_dev->keycodemax = ARRAY_SIZE(spec->alc_mute_keycode_map);
4359 spec->kb_dev->keycode = spec->alc_mute_keycode_map;
4360 for (i = 0; i < ARRAY_SIZE(spec->alc_mute_keycode_map); i++)
4361 set_bit(spec->alc_mute_keycode_map[i], spec->kb_dev->keybit);
4362
4363 if (input_register_device(spec->kb_dev)) {
4364 codec_err(codec, "input_register_device failed\n");
4365 input_free_device(spec->kb_dev);
4366 spec->kb_dev = NULL;
4367 return -ENOMEM;
4368 }
4369
4370 return 0;
4371}
4372
4373
4374
4375
4376
4377
4378static void alc280_fixup_hp_gpio2_mic_hotkey(struct hda_codec *codec,
4379 const struct hda_fixup *fix, int action)
4380{
4381 struct alc_spec *spec = codec->spec;
4382
4383 alc_fixup_hp_gpio_led(codec, action, 0x08, 0x10);
4384 if (action == HDA_FIXUP_ACT_PRE_PROBE) {
4385 spec->init_amp = ALC_INIT_DEFAULT;
4386 if (alc_register_micmute_input_device(codec) != 0)
4387 return;
4388
4389 spec->gpio_mask |= 0x06;
4390 spec->gpio_dir |= 0x02;
4391 spec->gpio_data |= 0x02;
4392 snd_hda_codec_write_cache(codec, codec->core.afg, 0,
4393 AC_VERB_SET_GPIO_UNSOLICITED_RSP_MASK, 0x04);
4394 snd_hda_jack_detect_enable_callback(codec, codec->core.afg,
4395 gpio2_mic_hotkey_event);
4396 return;
4397 }
4398
4399 if (!spec->kb_dev)
4400 return;
4401
4402 switch (action) {
4403 case HDA_FIXUP_ACT_FREE:
4404 input_unregister_device(spec->kb_dev);
4405 spec->kb_dev = NULL;
4406 }
4407}
4408
4409
4410
4411
4412static void alc233_fixup_lenovo_line2_mic_hotkey(struct hda_codec *codec,
4413 const struct hda_fixup *fix, int action)
4414{
4415 struct alc_spec *spec = codec->spec;
4416
4417 alc_fixup_hp_gpio_led(codec, action, 0, 0x04);
4418 if (action == HDA_FIXUP_ACT_PRE_PROBE) {
4419 spec->init_amp = ALC_INIT_DEFAULT;
4420 if (alc_register_micmute_input_device(codec) != 0)
4421 return;
4422
4423 snd_hda_jack_detect_enable_callback(codec, 0x1b,
4424 gpio2_mic_hotkey_event);
4425 return;
4426 }
4427
4428 if (!spec->kb_dev)
4429 return;
4430
4431 switch (action) {
4432 case HDA_FIXUP_ACT_FREE:
4433 input_unregister_device(spec->kb_dev);
4434 spec->kb_dev = NULL;
4435 }
4436}
4437#else
4438#define alc280_fixup_hp_gpio2_mic_hotkey NULL
4439#define alc233_fixup_lenovo_line2_mic_hotkey NULL
4440#endif
4441
4442static void alc269_fixup_hp_line1_mic1_led(struct hda_codec *codec,
4443 const struct hda_fixup *fix, int action)
4444{
4445 struct alc_spec *spec = codec->spec;
4446
4447 alc269_fixup_hp_mute_led_micx(codec, fix, action, 0x1a);
4448 if (action == HDA_FIXUP_ACT_PRE_PROBE) {
4449 spec->cap_mute_led_nid = 0x18;
4450 snd_hda_gen_add_micmute_led_cdev(codec, vref_micmute_led_set);
4451 }
4452}
4453
4454static const struct coef_fw alc225_pre_hsmode[] = {
4455 UPDATE_COEF(0x4a, 1<<8, 0),
4456 UPDATE_COEFEX(0x57, 0x05, 1<<14, 0),
4457 UPDATE_COEF(0x63, 3<<14, 3<<14),
4458 UPDATE_COEF(0x4a, 3<<4, 2<<4),
4459 UPDATE_COEF(0x4a, 3<<10, 3<<10),
4460 UPDATE_COEF(0x45, 0x3f<<10, 0x34<<10),
4461 UPDATE_COEF(0x4a, 3<<10, 0),
4462 {}
4463};
4464
4465static void alc_headset_mode_unplugged(struct hda_codec *codec)
4466{
4467 static const struct coef_fw coef0255[] = {
4468 WRITE_COEF(0x1b, 0x0c0b),
4469 WRITE_COEF(0x45, 0xd089),
4470 UPDATE_COEFEX(0x57, 0x05, 1<<14, 0),
4471 WRITE_COEF(0x06, 0x6104),
4472 WRITE_COEFEX(0x57, 0x03, 0x8aa6),
4473 {}
4474 };
4475 static const struct coef_fw coef0256[] = {
4476 WRITE_COEF(0x1b, 0x0c4b),
4477 WRITE_COEF(0x45, 0xd089),
4478 WRITE_COEF(0x06, 0x6104),
4479 WRITE_COEFEX(0x57, 0x03, 0x09a3),
4480 UPDATE_COEFEX(0x57, 0x05, 1<<14, 0),
4481 {}
4482 };
4483 static const struct coef_fw coef0233[] = {
4484 WRITE_COEF(0x1b, 0x0c0b),
4485 WRITE_COEF(0x45, 0xc429),
4486 UPDATE_COEF(0x35, 0x4000, 0),
4487 WRITE_COEF(0x06, 0x2104),
4488 WRITE_COEF(0x1a, 0x0001),
4489 WRITE_COEF(0x26, 0x0004),
4490 WRITE_COEF(0x32, 0x42a3),
4491 {}
4492 };
4493 static const struct coef_fw coef0288[] = {
4494 UPDATE_COEF(0x4f, 0xfcc0, 0xc400),
4495 UPDATE_COEF(0x50, 0x2000, 0x2000),
4496 UPDATE_COEF(0x56, 0x0006, 0x0006),
4497 UPDATE_COEF(0x66, 0x0008, 0),
4498 UPDATE_COEF(0x67, 0x2000, 0),
4499 {}
4500 };
4501 static const struct coef_fw coef0298[] = {
4502 UPDATE_COEF(0x19, 0x1300, 0x0300),
4503 {}
4504 };
4505 static const struct coef_fw coef0292[] = {
4506 WRITE_COEF(0x76, 0x000e),
4507 WRITE_COEF(0x6c, 0x2400),
4508 WRITE_COEF(0x18, 0x7308),
4509 WRITE_COEF(0x6b, 0xc429),
4510 {}
4511 };
4512 static const struct coef_fw coef0293[] = {
4513 UPDATE_COEF(0x10, 7<<8, 6<<8),
4514 UPDATE_COEFEX(0x57, 0x05, 1<<15|1<<13, 0x0),
4515 UPDATE_COEFEX(0x57, 0x03, 1<<10, 1<<10),
4516 UPDATE_COEF(0x1a, 1<<3, 1<<3),
4517 WRITE_COEF(0x45, 0xc429),
4518 UPDATE_COEF(0x4a, 0x000f, 0x000e),
4519 {}
4520 };
4521 static const struct coef_fw coef0668[] = {
4522 WRITE_COEF(0x15, 0x0d40),
4523 WRITE_COEF(0xb7, 0x802b),
4524 {}
4525 };
4526 static const struct coef_fw coef0225[] = {
4527 UPDATE_COEF(0x63, 3<<14, 0),
4528 {}
4529 };
4530 static const struct coef_fw coef0274[] = {
4531 UPDATE_COEF(0x4a, 0x0100, 0),
4532 UPDATE_COEFEX(0x57, 0x05, 0x4000, 0),
4533 UPDATE_COEF(0x6b, 0xf000, 0x5000),
4534 UPDATE_COEF(0x4a, 0x0010, 0),
4535 UPDATE_COEF(0x4a, 0x0c00, 0x0c00),
4536 WRITE_COEF(0x45, 0x5289),
4537 UPDATE_COEF(0x4a, 0x0c00, 0),
4538 {}
4539 };
4540
4541 switch (codec->core.vendor_id) {
4542 case 0x10ec0255:
4543 alc_process_coef_fw(codec, coef0255);
4544 break;
4545 case 0x10ec0236:
4546 case 0x10ec0256:
4547 alc_process_coef_fw(codec, coef0256);
4548 break;
4549 case 0x10ec0234:
4550 case 0x10ec0274:
4551 case 0x10ec0294:
4552 alc_process_coef_fw(codec, coef0274);
4553 break;
4554 case 0x10ec0233:
4555 case 0x10ec0283:
4556 alc_process_coef_fw(codec, coef0233);
4557 break;
4558 case 0x10ec0286:
4559 case 0x10ec0288:
4560 alc_process_coef_fw(codec, coef0288);
4561 break;
4562 case 0x10ec0298:
4563 alc_process_coef_fw(codec, coef0298);
4564 alc_process_coef_fw(codec, coef0288);
4565 break;
4566 case 0x10ec0292:
4567 alc_process_coef_fw(codec, coef0292);
4568 break;
4569 case 0x10ec0293:
4570 alc_process_coef_fw(codec, coef0293);
4571 break;
4572 case 0x10ec0668:
4573 alc_process_coef_fw(codec, coef0668);
4574 break;
4575 case 0x10ec0215:
4576 case 0x10ec0225:
4577 case 0x10ec0285:
4578 case 0x10ec0295:
4579 case 0x10ec0289:
4580 case 0x10ec0299:
4581 alc_process_coef_fw(codec, alc225_pre_hsmode);
4582 alc_process_coef_fw(codec, coef0225);
4583 break;
4584 case 0x10ec0867:
4585 alc_update_coefex_idx(codec, 0x57, 0x5, 1<<14, 0);
4586 break;
4587 }
4588 codec_dbg(codec, "Headset jack set to unplugged mode.\n");
4589}
4590
4591
4592static void alc_headset_mode_mic_in(struct hda_codec *codec, hda_nid_t hp_pin,
4593 hda_nid_t mic_pin)
4594{
4595 static const struct coef_fw coef0255[] = {
4596 WRITE_COEFEX(0x57, 0x03, 0x8aa6),
4597 WRITE_COEF(0x06, 0x6100),
4598 {}
4599 };
4600 static const struct coef_fw coef0256[] = {
4601 UPDATE_COEFEX(0x57, 0x05, 1<<14, 1<<14),
4602 WRITE_COEFEX(0x57, 0x03, 0x09a3),
4603 WRITE_COEF(0x06, 0x6100),
4604 {}
4605 };
4606 static const struct coef_fw coef0233[] = {
4607 UPDATE_COEF(0x35, 0, 1<<14),
4608 WRITE_COEF(0x06, 0x2100),
4609 WRITE_COEF(0x1a, 0x0021),
4610 WRITE_COEF(0x26, 0x008c),
4611 {}
4612 };
4613 static const struct coef_fw coef0288[] = {
4614 UPDATE_COEF(0x4f, 0x00c0, 0),
4615 UPDATE_COEF(0x50, 0x2000, 0),
4616 UPDATE_COEF(0x56, 0x0006, 0),
4617 UPDATE_COEF(0x4f, 0xfcc0, 0xc400),
4618 UPDATE_COEF(0x66, 0x0008, 0x0008),
4619 UPDATE_COEF(0x67, 0x2000, 0x2000),
4620 {}
4621 };
4622 static const struct coef_fw coef0292[] = {
4623 WRITE_COEF(0x19, 0xa208),
4624 WRITE_COEF(0x2e, 0xacf0),
4625 {}
4626 };
4627 static const struct coef_fw coef0293[] = {
4628 UPDATE_COEFEX(0x57, 0x05, 0, 1<<15|1<<13),
4629 UPDATE_COEFEX(0x57, 0x03, 1<<10, 0),
4630 UPDATE_COEF(0x1a, 1<<3, 0),
4631 {}
4632 };
4633 static const struct coef_fw coef0688[] = {
4634 WRITE_COEF(0xb7, 0x802b),
4635 WRITE_COEF(0xb5, 0x1040),
4636 UPDATE_COEF(0xc3, 0, 1<<12),
4637 {}
4638 };
4639 static const struct coef_fw coef0225[] = {
4640 UPDATE_COEFEX(0x57, 0x05, 1<<14, 1<<14),
4641 UPDATE_COEF(0x4a, 3<<4, 2<<4),
4642 UPDATE_COEF(0x63, 3<<14, 0),
4643 {}
4644 };
4645 static const struct coef_fw coef0274[] = {
4646 UPDATE_COEFEX(0x57, 0x05, 0x4000, 0x4000),
4647 UPDATE_COEF(0x4a, 0x0010, 0),
4648 UPDATE_COEF(0x6b, 0xf000, 0),
4649 {}
4650 };
4651
4652 switch (codec->core.vendor_id) {
4653 case 0x10ec0255:
4654 alc_write_coef_idx(codec, 0x45, 0xc489);
4655 snd_hda_set_pin_ctl_cache(codec, hp_pin, 0);
4656 alc_process_coef_fw(codec, coef0255);
4657 snd_hda_set_pin_ctl_cache(codec, mic_pin, PIN_VREF50);
4658 break;
4659 case 0x10ec0236:
4660 case 0x10ec0256:
4661 alc_write_coef_idx(codec, 0x45, 0xc489);
4662 snd_hda_set_pin_ctl_cache(codec, hp_pin, 0);
4663 alc_process_coef_fw(codec, coef0256);
4664 snd_hda_set_pin_ctl_cache(codec, mic_pin, PIN_VREF50);
4665 break;
4666 case 0x10ec0234:
4667 case 0x10ec0274:
4668 case 0x10ec0294:
4669 alc_write_coef_idx(codec, 0x45, 0x4689);
4670 snd_hda_set_pin_ctl_cache(codec, hp_pin, 0);
4671 alc_process_coef_fw(codec, coef0274);
4672 snd_hda_set_pin_ctl_cache(codec, mic_pin, PIN_VREF50);
4673 break;
4674 case 0x10ec0233:
4675 case 0x10ec0283:
4676 alc_write_coef_idx(codec, 0x45, 0xc429);
4677 snd_hda_set_pin_ctl_cache(codec, hp_pin, 0);
4678 alc_process_coef_fw(codec, coef0233);
4679 snd_hda_set_pin_ctl_cache(codec, mic_pin, PIN_VREF50);
4680 break;
4681 case 0x10ec0286:
4682 case 0x10ec0288:
4683 case 0x10ec0298:
4684 snd_hda_set_pin_ctl_cache(codec, hp_pin, 0);
4685 alc_process_coef_fw(codec, coef0288);
4686 snd_hda_set_pin_ctl_cache(codec, mic_pin, PIN_VREF50);
4687 break;
4688 case 0x10ec0292:
4689 snd_hda_set_pin_ctl_cache(codec, hp_pin, 0);
4690 alc_process_coef_fw(codec, coef0292);
4691 break;
4692 case 0x10ec0293:
4693
4694 alc_write_coef_idx(codec, 0x45, 0xc429);
4695 snd_hda_set_pin_ctl_cache(codec, hp_pin, 0);
4696 alc_process_coef_fw(codec, coef0293);
4697 snd_hda_set_pin_ctl_cache(codec, mic_pin, PIN_VREF50);
4698 break;
4699 case 0x10ec0867:
4700 alc_update_coefex_idx(codec, 0x57, 0x5, 0, 1<<14);
4701 fallthrough;
4702 case 0x10ec0221:
4703 case 0x10ec0662:
4704 snd_hda_set_pin_ctl_cache(codec, hp_pin, 0);
4705 snd_hda_set_pin_ctl_cache(codec, mic_pin, PIN_VREF50);
4706 break;
4707 case 0x10ec0668:
4708 alc_write_coef_idx(codec, 0x11, 0x0001);
4709 snd_hda_set_pin_ctl_cache(codec, hp_pin, 0);
4710 alc_process_coef_fw(codec, coef0688);
4711 snd_hda_set_pin_ctl_cache(codec, mic_pin, PIN_VREF50);
4712 break;
4713 case 0x10ec0215:
4714 case 0x10ec0225:
4715 case 0x10ec0285:
4716 case 0x10ec0295:
4717 case 0x10ec0289:
4718 case 0x10ec0299:
4719 alc_process_coef_fw(codec, alc225_pre_hsmode);
4720 alc_update_coef_idx(codec, 0x45, 0x3f<<10, 0x31<<10);
4721 snd_hda_set_pin_ctl_cache(codec, hp_pin, 0);
4722 alc_process_coef_fw(codec, coef0225);
4723 snd_hda_set_pin_ctl_cache(codec, mic_pin, PIN_VREF50);
4724 break;
4725 }
4726 codec_dbg(codec, "Headset jack set to mic-in mode.\n");
4727}
4728
4729static void alc_headset_mode_default(struct hda_codec *codec)
4730{
4731 static const struct coef_fw coef0225[] = {
4732 UPDATE_COEF(0x45, 0x3f<<10, 0x30<<10),
4733 UPDATE_COEF(0x45, 0x3f<<10, 0x31<<10),
4734 UPDATE_COEF(0x49, 3<<8, 0<<8),
4735 UPDATE_COEF(0x4a, 3<<4, 3<<4),
4736 UPDATE_COEF(0x63, 3<<14, 0),
4737 UPDATE_COEF(0x67, 0xf000, 0x3000),
4738 {}
4739 };
4740 static const struct coef_fw coef0255[] = {
4741 WRITE_COEF(0x45, 0xc089),
4742 WRITE_COEF(0x45, 0xc489),
4743 WRITE_COEFEX(0x57, 0x03, 0x8ea6),
4744 WRITE_COEF(0x49, 0x0049),
4745 {}
4746 };
4747 static const struct coef_fw coef0256[] = {
4748 WRITE_COEF(0x45, 0xc489),
4749 WRITE_COEFEX(0x57, 0x03, 0x0da3),
4750 WRITE_COEF(0x49, 0x0049),
4751 UPDATE_COEFEX(0x57, 0x05, 1<<14, 0),
4752 WRITE_COEF(0x06, 0x6100),
4753 {}
4754 };
4755 static const struct coef_fw coef0233[] = {
4756 WRITE_COEF(0x06, 0x2100),
4757 WRITE_COEF(0x32, 0x4ea3),
4758 {}
4759 };
4760 static const struct coef_fw coef0288[] = {
4761 UPDATE_COEF(0x4f, 0xfcc0, 0xc400),
4762 UPDATE_COEF(0x50, 0x2000, 0x2000),
4763 UPDATE_COEF(0x56, 0x0006, 0x0006),
4764 UPDATE_COEF(0x66, 0x0008, 0),
4765 UPDATE_COEF(0x67, 0x2000, 0),
4766 {}
4767 };
4768 static const struct coef_fw coef0292[] = {
4769 WRITE_COEF(0x76, 0x000e),
4770 WRITE_COEF(0x6c, 0x2400),
4771 WRITE_COEF(0x6b, 0xc429),
4772 WRITE_COEF(0x18, 0x7308),
4773 {}
4774 };
4775 static const struct coef_fw coef0293[] = {
4776 UPDATE_COEF(0x4a, 0x000f, 0x000e),
4777 WRITE_COEF(0x45, 0xC429),
4778 UPDATE_COEF(0x1a, 1<<3, 0),
4779 {}
4780 };
4781 static const struct coef_fw coef0688[] = {
4782 WRITE_COEF(0x11, 0x0041),
4783 WRITE_COEF(0x15, 0x0d40),
4784 WRITE_COEF(0xb7, 0x802b),
4785 {}
4786 };
4787 static const struct coef_fw coef0274[] = {
4788 WRITE_COEF(0x45, 0x4289),
4789 UPDATE_COEF(0x4a, 0x0010, 0x0010),
4790 UPDATE_COEF(0x6b, 0x0f00, 0),
4791 UPDATE_COEF(0x49, 0x0300, 0x0300),
4792 {}
4793 };
4794
4795 switch (codec->core.vendor_id) {
4796 case 0x10ec0215:
4797 case 0x10ec0225:
4798 case 0x10ec0285:
4799 case 0x10ec0295:
4800 case 0x10ec0289:
4801 case 0x10ec0299:
4802 alc_process_coef_fw(codec, alc225_pre_hsmode);
4803 alc_process_coef_fw(codec, coef0225);
4804 break;
4805 case 0x10ec0255:
4806 alc_process_coef_fw(codec, coef0255);
4807 break;
4808 case 0x10ec0236:
4809 case 0x10ec0256:
4810 alc_write_coef_idx(codec, 0x1b, 0x0e4b);
4811 alc_write_coef_idx(codec, 0x45, 0xc089);
4812 msleep(50);
4813 alc_process_coef_fw(codec, coef0256);
4814 break;
4815 case 0x10ec0234:
4816 case 0x10ec0274:
4817 case 0x10ec0294:
4818 alc_process_coef_fw(codec, coef0274);
4819 break;
4820 case 0x10ec0233:
4821 case 0x10ec0283:
4822 alc_process_coef_fw(codec, coef0233);
4823 break;
4824 case 0x10ec0286:
4825 case 0x10ec0288:
4826 case 0x10ec0298:
4827 alc_process_coef_fw(codec, coef0288);
4828 break;
4829 case 0x10ec0292:
4830 alc_process_coef_fw(codec, coef0292);
4831 break;
4832 case 0x10ec0293:
4833 alc_process_coef_fw(codec, coef0293);
4834 break;
4835 case 0x10ec0668:
4836 alc_process_coef_fw(codec, coef0688);
4837 break;
4838 case 0x10ec0867:
4839 alc_update_coefex_idx(codec, 0x57, 0x5, 1<<14, 0);
4840 break;
4841 }
4842 codec_dbg(codec, "Headset jack set to headphone (default) mode.\n");
4843}
4844
4845
4846static void alc_headset_mode_ctia(struct hda_codec *codec)
4847{
4848 int val;
4849
4850 static const struct coef_fw coef0255[] = {
4851 WRITE_COEF(0x45, 0xd489),
4852 WRITE_COEF(0x1b, 0x0c2b),
4853 WRITE_COEFEX(0x57, 0x03, 0x8ea6),
4854 {}
4855 };
4856 static const struct coef_fw coef0256[] = {
4857 WRITE_COEF(0x45, 0xd489),
4858 WRITE_COEF(0x1b, 0x0e6b),
4859 {}
4860 };
4861 static const struct coef_fw coef0233[] = {
4862 WRITE_COEF(0x45, 0xd429),
4863 WRITE_COEF(0x1b, 0x0c2b),
4864 WRITE_COEF(0x32, 0x4ea3),
4865 {}
4866 };
4867 static const struct coef_fw coef0288[] = {
4868 UPDATE_COEF(0x50, 0x2000, 0x2000),
4869 UPDATE_COEF(0x56, 0x0006, 0x0006),
4870 UPDATE_COEF(0x66, 0x0008, 0),
4871 UPDATE_COEF(0x67, 0x2000, 0),
4872 {}
4873 };
4874 static const struct coef_fw coef0292[] = {
4875 WRITE_COEF(0x6b, 0xd429),
4876 WRITE_COEF(0x76, 0x0008),
4877 WRITE_COEF(0x18, 0x7388),
4878 {}
4879 };
4880 static const struct coef_fw coef0293[] = {
4881 WRITE_COEF(0x45, 0xd429),
4882 UPDATE_COEF(0x10, 7<<8, 7<<8),
4883 {}
4884 };
4885 static const struct coef_fw coef0688[] = {
4886 WRITE_COEF(0x11, 0x0001),
4887 WRITE_COEF(0x15, 0x0d60),
4888 WRITE_COEF(0xc3, 0x0000),
4889 {}
4890 };
4891 static const struct coef_fw coef0225_1[] = {
4892 UPDATE_COEF(0x45, 0x3f<<10, 0x35<<10),
4893 UPDATE_COEF(0x63, 3<<14, 2<<14),
4894 {}
4895 };
4896 static const struct coef_fw coef0225_2[] = {
4897 UPDATE_COEF(0x45, 0x3f<<10, 0x35<<10),
4898 UPDATE_COEF(0x63, 3<<14, 1<<14),
4899 {}
4900 };
4901
4902 switch (codec->core.vendor_id) {
4903 case 0x10ec0255:
4904 alc_process_coef_fw(codec, coef0255);
4905 break;
4906 case 0x10ec0236:
4907 case 0x10ec0256:
4908 alc_process_coef_fw(codec, coef0256);
4909 break;
4910 case 0x10ec0234:
4911 case 0x10ec0274:
4912 case 0x10ec0294:
4913 alc_write_coef_idx(codec, 0x45, 0xd689);
4914 break;
4915 case 0x10ec0233:
4916 case 0x10ec0283:
4917 alc_process_coef_fw(codec, coef0233);
4918 break;
4919 case 0x10ec0298:
4920 val = alc_read_coef_idx(codec, 0x50);
4921 if (val & (1 << 12)) {
4922 alc_update_coef_idx(codec, 0x8e, 0x0070, 0x0020);
4923 alc_update_coef_idx(codec, 0x4f, 0xfcc0, 0xd400);
4924 msleep(300);
4925 } else {
4926 alc_update_coef_idx(codec, 0x8e, 0x0070, 0x0010);
4927 alc_update_coef_idx(codec, 0x4f, 0xfcc0, 0xd400);
4928 msleep(300);
4929 }
4930 break;
4931 case 0x10ec0286:
4932 case 0x10ec0288:
4933 alc_update_coef_idx(codec, 0x4f, 0xfcc0, 0xd400);
4934 msleep(300);
4935 alc_process_coef_fw(codec, coef0288);
4936 break;
4937 case 0x10ec0292:
4938 alc_process_coef_fw(codec, coef0292);
4939 break;
4940 case 0x10ec0293:
4941 alc_process_coef_fw(codec, coef0293);
4942 break;
4943 case 0x10ec0668:
4944 alc_process_coef_fw(codec, coef0688);
4945 break;
4946 case 0x10ec0215:
4947 case 0x10ec0225:
4948 case 0x10ec0285:
4949 case 0x10ec0295:
4950 case 0x10ec0289:
4951 case 0x10ec0299:
4952 val = alc_read_coef_idx(codec, 0x45);
4953 if (val & (1 << 9))
4954 alc_process_coef_fw(codec, coef0225_2);
4955 else
4956 alc_process_coef_fw(codec, coef0225_1);
4957 break;
4958 case 0x10ec0867:
4959 alc_update_coefex_idx(codec, 0x57, 0x5, 1<<14, 0);
4960 break;
4961 }
4962 codec_dbg(codec, "Headset jack set to iPhone-style headset mode.\n");
4963}
4964
4965
4966static void alc_headset_mode_omtp(struct hda_codec *codec)
4967{
4968 static const struct coef_fw coef0255[] = {
4969 WRITE_COEF(0x45, 0xe489),
4970 WRITE_COEF(0x1b, 0x0c2b),
4971 WRITE_COEFEX(0x57, 0x03, 0x8ea6),
4972 {}
4973 };
4974 static const struct coef_fw coef0256[] = {
4975 WRITE_COEF(0x45, 0xe489),
4976 WRITE_COEF(0x1b, 0x0e6b),
4977 {}
4978 };
4979 static const struct coef_fw coef0233[] = {
4980 WRITE_COEF(0x45, 0xe429),
4981 WRITE_COEF(0x1b, 0x0c2b),
4982 WRITE_COEF(0x32, 0x4ea3),
4983 {}
4984 };
4985 static const struct coef_fw coef0288[] = {
4986 UPDATE_COEF(0x50, 0x2000, 0x2000),
4987 UPDATE_COEF(0x56, 0x0006, 0x0006),
4988 UPDATE_COEF(0x66, 0x0008, 0),
4989 UPDATE_COEF(0x67, 0x2000, 0),
4990 {}
4991 };
4992 static const struct coef_fw coef0292[] = {
4993 WRITE_COEF(0x6b, 0xe429),
4994 WRITE_COEF(0x76, 0x0008),
4995 WRITE_COEF(0x18, 0x7388),
4996 {}
4997 };
4998 static const struct coef_fw coef0293[] = {
4999 WRITE_COEF(0x45, 0xe429),
5000 UPDATE_COEF(0x10, 7<<8, 7<<8),
5001 {}
5002 };
5003 static const struct coef_fw coef0688[] = {
5004 WRITE_COEF(0x11, 0x0001),
5005 WRITE_COEF(0x15, 0x0d50),
5006 WRITE_COEF(0xc3, 0x0000),
5007 {}
5008 };
5009 static const struct coef_fw coef0225[] = {
5010 UPDATE_COEF(0x45, 0x3f<<10, 0x39<<10),
5011 UPDATE_COEF(0x63, 3<<14, 2<<14),
5012 {}
5013 };
5014
5015 switch (codec->core.vendor_id) {
5016 case 0x10ec0255:
5017 alc_process_coef_fw(codec, coef0255);
5018 break;
5019 case 0x10ec0236:
5020 case 0x10ec0256:
5021 alc_process_coef_fw(codec, coef0256);
5022 break;
5023 case 0x10ec0234:
5024 case 0x10ec0274:
5025 case 0x10ec0294:
5026 alc_write_coef_idx(codec, 0x45, 0xe689);
5027 break;
5028 case 0x10ec0233:
5029 case 0x10ec0283:
5030 alc_process_coef_fw(codec, coef0233);
5031 break;
5032 case 0x10ec0298:
5033 alc_update_coef_idx(codec, 0x8e, 0x0070, 0x0010);
5034 alc_update_coef_idx(codec, 0x4f, 0xfcc0, 0xe400);
5035 msleep(300);
5036 break;
5037 case 0x10ec0286:
5038 case 0x10ec0288:
5039 alc_update_coef_idx(codec, 0x4f, 0xfcc0, 0xe400);
5040 msleep(300);
5041 alc_process_coef_fw(codec, coef0288);
5042 break;
5043 case 0x10ec0292:
5044 alc_process_coef_fw(codec, coef0292);
5045 break;
5046 case 0x10ec0293:
5047 alc_process_coef_fw(codec, coef0293);
5048 break;
5049 case 0x10ec0668:
5050 alc_process_coef_fw(codec, coef0688);
5051 break;
5052 case 0x10ec0215:
5053 case 0x10ec0225:
5054 case 0x10ec0285:
5055 case 0x10ec0295:
5056 case 0x10ec0289:
5057 case 0x10ec0299:
5058 alc_process_coef_fw(codec, coef0225);
5059 break;
5060 }
5061 codec_dbg(codec, "Headset jack set to Nokia-style headset mode.\n");
5062}
5063
5064static void alc_determine_headset_type(struct hda_codec *codec)
5065{
5066 int val;
5067 bool is_ctia = false;
5068 struct alc_spec *spec = codec->spec;
5069 static const struct coef_fw coef0255[] = {
5070 WRITE_COEF(0x45, 0xd089),
5071 WRITE_COEF(0x49, 0x0149),
5072
5073 {}
5074 };
5075 static const struct coef_fw coef0288[] = {
5076 UPDATE_COEF(0x4f, 0xfcc0, 0xd400),
5077 {}
5078 };
5079 static const struct coef_fw coef0298[] = {
5080 UPDATE_COEF(0x50, 0x2000, 0x2000),
5081 UPDATE_COEF(0x56, 0x0006, 0x0006),
5082 UPDATE_COEF(0x66, 0x0008, 0),
5083 UPDATE_COEF(0x67, 0x2000, 0),
5084 UPDATE_COEF(0x19, 0x1300, 0x1300),
5085 {}
5086 };
5087 static const struct coef_fw coef0293[] = {
5088 UPDATE_COEF(0x4a, 0x000f, 0x0008),
5089 WRITE_COEF(0x45, 0xD429),
5090 {}
5091 };
5092 static const struct coef_fw coef0688[] = {
5093 WRITE_COEF(0x11, 0x0001),
5094 WRITE_COEF(0xb7, 0x802b),
5095 WRITE_COEF(0x15, 0x0d60),
5096 WRITE_COEF(0xc3, 0x0c00),
5097 {}
5098 };
5099 static const struct coef_fw coef0274[] = {
5100 UPDATE_COEF(0x4a, 0x0010, 0),
5101 UPDATE_COEF(0x4a, 0x8000, 0),
5102 WRITE_COEF(0x45, 0xd289),
5103 UPDATE_COEF(0x49, 0x0300, 0x0300),
5104 {}
5105 };
5106
5107 switch (codec->core.vendor_id) {
5108 case 0x10ec0255:
5109 alc_process_coef_fw(codec, coef0255);
5110 msleep(300);
5111 val = alc_read_coef_idx(codec, 0x46);
5112 is_ctia = (val & 0x0070) == 0x0070;
5113 break;
5114 case 0x10ec0236:
5115 case 0x10ec0256:
5116 alc_write_coef_idx(codec, 0x1b, 0x0e4b);
5117 alc_write_coef_idx(codec, 0x06, 0x6104);
5118 alc_write_coefex_idx(codec, 0x57, 0x3, 0x09a3);
5119
5120 snd_hda_codec_write(codec, 0x21, 0,
5121 AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);
5122 msleep(80);
5123 snd_hda_codec_write(codec, 0x21, 0,
5124 AC_VERB_SET_PIN_WIDGET_CONTROL, 0x0);
5125
5126 alc_process_coef_fw(codec, coef0255);
5127 msleep(300);
5128 val = alc_read_coef_idx(codec, 0x46);
5129 is_ctia = (val & 0x0070) == 0x0070;
5130
5131 alc_write_coefex_idx(codec, 0x57, 0x3, 0x0da3);
5132 alc_update_coefex_idx(codec, 0x57, 0x5, 1<<14, 0);
5133
5134 snd_hda_codec_write(codec, 0x21, 0,
5135 AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT);
5136 msleep(80);
5137 snd_hda_codec_write(codec, 0x21, 0,
5138 AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE);
5139 break;
5140 case 0x10ec0234:
5141 case 0x10ec0274:
5142 case 0x10ec0294:
5143 alc_process_coef_fw(codec, coef0274);
5144 msleep(80);
5145 val = alc_read_coef_idx(codec, 0x46);
5146 is_ctia = (val & 0x00f0) == 0x00f0;
5147 break;
5148 case 0x10ec0233:
5149 case 0x10ec0283:
5150 alc_write_coef_idx(codec, 0x45, 0xd029);
5151 msleep(300);
5152 val = alc_read_coef_idx(codec, 0x46);
5153 is_ctia = (val & 0x0070) == 0x0070;
5154 break;
5155 case 0x10ec0298:
5156 snd_hda_codec_write(codec, 0x21, 0,
5157 AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);
5158 msleep(100);
5159 snd_hda_codec_write(codec, 0x21, 0,
5160 AC_VERB_SET_PIN_WIDGET_CONTROL, 0x0);
5161 msleep(200);
5162
5163 val = alc_read_coef_idx(codec, 0x50);
5164 if (val & (1 << 12)) {
5165 alc_update_coef_idx(codec, 0x8e, 0x0070, 0x0020);
5166 alc_process_coef_fw(codec, coef0288);
5167 msleep(350);
5168 val = alc_read_coef_idx(codec, 0x50);
5169 is_ctia = (val & 0x0070) == 0x0070;
5170 } else {
5171 alc_update_coef_idx(codec, 0x8e, 0x0070, 0x0010);
5172 alc_process_coef_fw(codec, coef0288);
5173 msleep(350);
5174 val = alc_read_coef_idx(codec, 0x50);
5175 is_ctia = (val & 0x0070) == 0x0070;
5176 }
5177 alc_process_coef_fw(codec, coef0298);
5178 snd_hda_codec_write(codec, 0x21, 0,
5179 AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP);
5180 msleep(75);
5181 snd_hda_codec_write(codec, 0x21, 0,
5182 AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE);
5183 break;
5184 case 0x10ec0286:
5185 case 0x10ec0288:
5186 alc_process_coef_fw(codec, coef0288);
5187 msleep(350);
5188 val = alc_read_coef_idx(codec, 0x50);
5189 is_ctia = (val & 0x0070) == 0x0070;
5190 break;
5191 case 0x10ec0292:
5192 alc_write_coef_idx(codec, 0x6b, 0xd429);
5193 msleep(300);
5194 val = alc_read_coef_idx(codec, 0x6c);
5195 is_ctia = (val & 0x001c) == 0x001c;
5196 break;
5197 case 0x10ec0293:
5198 alc_process_coef_fw(codec, coef0293);
5199 msleep(300);
5200 val = alc_read_coef_idx(codec, 0x46);
5201 is_ctia = (val & 0x0070) == 0x0070;
5202 break;
5203 case 0x10ec0668:
5204 alc_process_coef_fw(codec, coef0688);
5205 msleep(300);
5206 val = alc_read_coef_idx(codec, 0xbe);
5207 is_ctia = (val & 0x1c02) == 0x1c02;
5208 break;
5209 case 0x10ec0215:
5210 case 0x10ec0225:
5211 case 0x10ec0285:
5212 case 0x10ec0295:
5213 case 0x10ec0289:
5214 case 0x10ec0299:
5215 snd_hda_codec_write(codec, 0x21, 0,
5216 AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);
5217 msleep(80);
5218 snd_hda_codec_write(codec, 0x21, 0,
5219 AC_VERB_SET_PIN_WIDGET_CONTROL, 0x0);
5220
5221 alc_process_coef_fw(codec, alc225_pre_hsmode);
5222 alc_update_coef_idx(codec, 0x67, 0xf000, 0x1000);
5223 val = alc_read_coef_idx(codec, 0x45);
5224 if (val & (1 << 9)) {
5225 alc_update_coef_idx(codec, 0x45, 0x3f<<10, 0x34<<10);
5226 alc_update_coef_idx(codec, 0x49, 3<<8, 2<<8);
5227 msleep(800);
5228 val = alc_read_coef_idx(codec, 0x46);
5229 is_ctia = (val & 0x00f0) == 0x00f0;
5230 } else {
5231 alc_update_coef_idx(codec, 0x45, 0x3f<<10, 0x34<<10);
5232 alc_update_coef_idx(codec, 0x49, 3<<8, 1<<8);
5233 msleep(800);
5234 val = alc_read_coef_idx(codec, 0x46);
5235 is_ctia = (val & 0x00f0) == 0x00f0;
5236 }
5237 alc_update_coef_idx(codec, 0x4a, 7<<6, 7<<6);
5238 alc_update_coef_idx(codec, 0x4a, 3<<4, 3<<4);
5239 alc_update_coef_idx(codec, 0x67, 0xf000, 0x3000);
5240
5241 snd_hda_codec_write(codec, 0x21, 0,
5242 AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT);
5243 msleep(80);
5244 snd_hda_codec_write(codec, 0x21, 0,
5245 AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE);
5246 break;
5247 case 0x10ec0867:
5248 is_ctia = true;
5249 break;
5250 }
5251
5252 codec_dbg(codec, "Headset jack detected iPhone-style headset: %s\n",
5253 is_ctia ? "yes" : "no");
5254 spec->current_headset_type = is_ctia ? ALC_HEADSET_TYPE_CTIA : ALC_HEADSET_TYPE_OMTP;
5255}
5256
5257static void alc_update_headset_mode(struct hda_codec *codec)
5258{
5259 struct alc_spec *spec = codec->spec;
5260
5261 hda_nid_t mux_pin = spec->gen.imux_pins[spec->gen.cur_mux[0]];
5262 hda_nid_t hp_pin = alc_get_hp_pin(spec);
5263
5264 int new_headset_mode;
5265
5266 if (!snd_hda_jack_detect(codec, hp_pin))
5267 new_headset_mode = ALC_HEADSET_MODE_UNPLUGGED;
5268 else if (mux_pin == spec->headset_mic_pin)
5269 new_headset_mode = ALC_HEADSET_MODE_HEADSET;
5270 else if (mux_pin == spec->headphone_mic_pin)
5271 new_headset_mode = ALC_HEADSET_MODE_MIC;
5272 else
5273 new_headset_mode = ALC_HEADSET_MODE_HEADPHONE;
5274
5275 if (new_headset_mode == spec->current_headset_mode) {
5276 snd_hda_gen_update_outputs(codec);
5277 return;
5278 }
5279
5280 switch (new_headset_mode) {
5281 case ALC_HEADSET_MODE_UNPLUGGED:
5282 alc_headset_mode_unplugged(codec);
5283 spec->current_headset_mode = ALC_HEADSET_MODE_UNKNOWN;
5284 spec->current_headset_type = ALC_HEADSET_TYPE_UNKNOWN;
5285 spec->gen.hp_jack_present = false;
5286 break;
5287 case ALC_HEADSET_MODE_HEADSET:
5288 if (spec->current_headset_type == ALC_HEADSET_TYPE_UNKNOWN)
5289 alc_determine_headset_type(codec);
5290 if (spec->current_headset_type == ALC_HEADSET_TYPE_CTIA)
5291 alc_headset_mode_ctia(codec);
5292 else if (spec->current_headset_type == ALC_HEADSET_TYPE_OMTP)
5293 alc_headset_mode_omtp(codec);
5294 spec->gen.hp_jack_present = true;
5295 break;
5296 case ALC_HEADSET_MODE_MIC:
5297 alc_headset_mode_mic_in(codec, hp_pin, spec->headphone_mic_pin);
5298 spec->gen.hp_jack_present = false;
5299 break;
5300 case ALC_HEADSET_MODE_HEADPHONE:
5301 alc_headset_mode_default(codec);
5302 spec->gen.hp_jack_present = true;
5303 break;
5304 }
5305 if (new_headset_mode != ALC_HEADSET_MODE_MIC) {
5306 snd_hda_set_pin_ctl_cache(codec, hp_pin,
5307 AC_PINCTL_OUT_EN | AC_PINCTL_HP_EN);
5308 if (spec->headphone_mic_pin && spec->headphone_mic_pin != hp_pin)
5309 snd_hda_set_pin_ctl_cache(codec, spec->headphone_mic_pin,
5310 PIN_VREFHIZ);
5311 }
5312 spec->current_headset_mode = new_headset_mode;
5313
5314 snd_hda_gen_update_outputs(codec);
5315}
5316
5317static void alc_update_headset_mode_hook(struct hda_codec *codec,
5318 struct snd_kcontrol *kcontrol,
5319 struct snd_ctl_elem_value *ucontrol)
5320{
5321 alc_update_headset_mode(codec);
5322}
5323
5324static void alc_update_headset_jack_cb(struct hda_codec *codec,
5325 struct hda_jack_callback *jack)
5326{
5327 snd_hda_gen_hp_automute(codec, jack);
5328}
5329
5330static void alc_probe_headset_mode(struct hda_codec *codec)
5331{
5332 int i;
5333 struct alc_spec *spec = codec->spec;
5334 struct auto_pin_cfg *cfg = &spec->gen.autocfg;
5335
5336
5337 for (i = 0; i < cfg->num_inputs; i++) {
5338 if (cfg->inputs[i].is_headset_mic && !spec->headset_mic_pin)
5339 spec->headset_mic_pin = cfg->inputs[i].pin;
5340 if (cfg->inputs[i].is_headphone_mic && !spec->headphone_mic_pin)
5341 spec->headphone_mic_pin = cfg->inputs[i].pin;
5342 }
5343
5344 WARN_ON(spec->gen.cap_sync_hook);
5345 spec->gen.cap_sync_hook = alc_update_headset_mode_hook;
5346 spec->gen.automute_hook = alc_update_headset_mode;
5347 spec->gen.hp_automute_hook = alc_update_headset_jack_cb;
5348}
5349
5350static void alc_fixup_headset_mode(struct hda_codec *codec,
5351 const struct hda_fixup *fix, int action)
5352{
5353 struct alc_spec *spec = codec->spec;
5354
5355 switch (action) {
5356 case HDA_FIXUP_ACT_PRE_PROBE:
5357 spec->parse_flags |= HDA_PINCFG_HEADSET_MIC | HDA_PINCFG_HEADPHONE_MIC;
5358 break;
5359 case HDA_FIXUP_ACT_PROBE:
5360 alc_probe_headset_mode(codec);
5361 break;
5362 case HDA_FIXUP_ACT_INIT:
5363 if (is_s3_resume(codec) || is_s4_resume(codec)) {
5364 spec->current_headset_mode = ALC_HEADSET_MODE_UNKNOWN;
5365 spec->current_headset_type = ALC_HEADSET_TYPE_UNKNOWN;
5366 }
5367 alc_update_headset_mode(codec);
5368 break;
5369 }
5370}
5371
5372static void alc_fixup_headset_mode_no_hp_mic(struct hda_codec *codec,
5373 const struct hda_fixup *fix, int action)
5374{
5375 if (action == HDA_FIXUP_ACT_PRE_PROBE) {
5376 struct alc_spec *spec = codec->spec;
5377 spec->parse_flags |= HDA_PINCFG_HEADSET_MIC;
5378 }
5379 else
5380 alc_fixup_headset_mode(codec, fix, action);
5381}
5382
5383static void alc255_set_default_jack_type(struct hda_codec *codec)
5384{
5385
5386 static const struct coef_fw alc255fw[] = {
5387 WRITE_COEF(0x1b, 0x880b),
5388 WRITE_COEF(0x45, 0xd089),
5389 WRITE_COEF(0x1b, 0x080b),
5390 WRITE_COEF(0x46, 0x0004),
5391 WRITE_COEF(0x1b, 0x0c0b),
5392 {}
5393 };
5394 static const struct coef_fw alc256fw[] = {
5395 WRITE_COEF(0x1b, 0x884b),
5396 WRITE_COEF(0x45, 0xd089),
5397 WRITE_COEF(0x1b, 0x084b),
5398 WRITE_COEF(0x46, 0x0004),
5399 WRITE_COEF(0x1b, 0x0c4b),
5400 {}
5401 };
5402 switch (codec->core.vendor_id) {
5403 case 0x10ec0255:
5404 alc_process_coef_fw(codec, alc255fw);
5405 break;
5406 case 0x10ec0236:
5407 case 0x10ec0256:
5408 alc_process_coef_fw(codec, alc256fw);
5409 break;
5410 }
5411 msleep(30);
5412}
5413
5414static void alc_fixup_headset_mode_alc255(struct hda_codec *codec,
5415 const struct hda_fixup *fix, int action)
5416{
5417 if (action == HDA_FIXUP_ACT_PRE_PROBE) {
5418 alc255_set_default_jack_type(codec);
5419 }
5420 alc_fixup_headset_mode(codec, fix, action);
5421}
5422
5423static void alc_fixup_headset_mode_alc255_no_hp_mic(struct hda_codec *codec,
5424 const struct hda_fixup *fix, int action)
5425{
5426 if (action == HDA_FIXUP_ACT_PRE_PROBE) {
5427 struct alc_spec *spec = codec->spec;
5428 spec->parse_flags |= HDA_PINCFG_HEADSET_MIC;
5429 alc255_set_default_jack_type(codec);
5430 }
5431 else
5432 alc_fixup_headset_mode(codec, fix, action);
5433}
5434
5435static void alc288_update_headset_jack_cb(struct hda_codec *codec,
5436 struct hda_jack_callback *jack)
5437{
5438 struct alc_spec *spec = codec->spec;
5439
5440 alc_update_headset_jack_cb(codec, jack);
5441
5442 alc_update_gpio_data(codec, 0x40, spec->gen.hp_jack_present);
5443}
5444
5445static void alc_fixup_headset_mode_dell_alc288(struct hda_codec *codec,
5446 const struct hda_fixup *fix, int action)
5447{
5448 alc_fixup_headset_mode(codec, fix, action);
5449 if (action == HDA_FIXUP_ACT_PROBE) {
5450 struct alc_spec *spec = codec->spec;
5451
5452 spec->gpio_mask |= 0x40;
5453 spec->gpio_dir |= 0x40;
5454 spec->gen.hp_automute_hook = alc288_update_headset_jack_cb;
5455 }
5456}
5457
5458static void alc_fixup_auto_mute_via_amp(struct hda_codec *codec,
5459 const struct hda_fixup *fix, int action)
5460{
5461 if (action == HDA_FIXUP_ACT_PRE_PROBE) {
5462 struct alc_spec *spec = codec->spec;
5463 spec->gen.auto_mute_via_amp = 1;
5464 }
5465}
5466
5467static void alc_fixup_no_shutup(struct hda_codec *codec,
5468 const struct hda_fixup *fix, int action)
5469{
5470 if (action == HDA_FIXUP_ACT_PRE_PROBE) {
5471 struct alc_spec *spec = codec->spec;
5472 spec->no_shutup_pins = 1;
5473 }
5474}
5475
5476static void alc_fixup_disable_aamix(struct hda_codec *codec,
5477 const struct hda_fixup *fix, int action)
5478{
5479 if (action == HDA_FIXUP_ACT_PRE_PROBE) {
5480 struct alc_spec *spec = codec->spec;
5481
5482 spec->gen.mixer_nid = 0;
5483 }
5484}
5485
5486
5487static void alc_fixup_tpt440_dock(struct hda_codec *codec,
5488 const struct hda_fixup *fix, int action)
5489{
5490 static const struct hda_pintbl pincfgs[] = {
5491 { 0x16, 0x21211010 },
5492 { 0x19, 0x21a11010 },
5493 { }
5494 };
5495 struct alc_spec *spec = codec->spec;
5496
5497 if (action == HDA_FIXUP_ACT_PRE_PROBE) {
5498 spec->reboot_notify = snd_hda_gen_reboot_notify;
5499 spec->parse_flags = HDA_PINCFG_NO_HP_FIXUP;
5500 codec->power_save_node = 0;
5501 snd_hda_apply_pincfgs(codec, pincfgs);
5502 }
5503}
5504
5505static void alc_fixup_tpt470_dock(struct hda_codec *codec,
5506 const struct hda_fixup *fix, int action)
5507{
5508 static const struct hda_pintbl pincfgs[] = {
5509 { 0x17, 0x21211010 },
5510 { 0x19, 0x21a11010 },
5511 { }
5512 };
5513 struct alc_spec *spec = codec->spec;
5514
5515 if (action == HDA_FIXUP_ACT_PRE_PROBE) {
5516 spec->parse_flags = HDA_PINCFG_NO_HP_FIXUP;
5517 snd_hda_apply_pincfgs(codec, pincfgs);
5518 } else if (action == HDA_FIXUP_ACT_INIT) {
5519
5520 snd_hda_codec_write(codec, 0x17, 0,
5521 AC_VERB_SET_CONFIG_DEFAULT_BYTES_3, 0);
5522
5523 snd_hda_codec_write(codec, 0x19, 0,
5524 AC_VERB_SET_CONFIG_DEFAULT_BYTES_3, 0);
5525 }
5526}
5527
5528static void alc_fixup_tpt470_dacs(struct hda_codec *codec,
5529 const struct hda_fixup *fix, int action)
5530{
5531
5532
5533
5534
5535 static const hda_nid_t preferred_pairs[] = {
5536 0x14, 0x03, 0x17, 0x02, 0x21, 0x02,
5537 0
5538 };
5539 struct alc_spec *spec = codec->spec;
5540
5541 if (action == HDA_FIXUP_ACT_PRE_PROBE)
5542 spec->gen.preferred_dacs = preferred_pairs;
5543}
5544
5545static void alc_shutup_dell_xps13(struct hda_codec *codec)
5546{
5547 struct alc_spec *spec = codec->spec;
5548 int hp_pin = alc_get_hp_pin(spec);
5549
5550
5551 snd_hda_codec_write(codec, hp_pin, 0,
5552 AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);
5553 msleep(20);
5554}
5555
5556static void alc_fixup_dell_xps13(struct hda_codec *codec,
5557 const struct hda_fixup *fix, int action)
5558{
5559 struct alc_spec *spec = codec->spec;
5560 struct hda_input_mux *imux = &spec->gen.input_mux;
5561 int i;
5562
5563 switch (action) {
5564 case HDA_FIXUP_ACT_PRE_PROBE:
5565
5566
5567
5568 snd_hda_codec_set_pin_target(codec, 0x19, PIN_VREFHIZ);
5569 spec->shutup = alc_shutup_dell_xps13;
5570 break;
5571 case HDA_FIXUP_ACT_PROBE:
5572
5573 for (i = 0; i < imux->num_items; i++) {
5574 if (spec->gen.imux_pins[i] == 0x12) {
5575 spec->gen.cur_mux[0] = i;
5576 break;
5577 }
5578 }
5579 break;
5580 }
5581}
5582
5583static void alc_fixup_headset_mode_alc662(struct hda_codec *codec,
5584 const struct hda_fixup *fix, int action)
5585{
5586 struct alc_spec *spec = codec->spec;
5587
5588 if (action == HDA_FIXUP_ACT_PRE_PROBE) {
5589 spec->parse_flags |= HDA_PINCFG_HEADSET_MIC;
5590 spec->gen.hp_mic = 1;
5591
5592
5593
5594 snd_hda_codec_write(codec, 0x1b, 0, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000);
5595 snd_hda_override_wcaps(codec, 0x1b, get_wcaps(codec, 0x1b) & ~AC_WCAP_IN_AMP);
5596 } else
5597 alc_fixup_headset_mode(codec, fix, action);
5598}
5599
5600static void alc_fixup_headset_mode_alc668(struct hda_codec *codec,
5601 const struct hda_fixup *fix, int action)
5602{
5603 if (action == HDA_FIXUP_ACT_PRE_PROBE) {
5604 alc_write_coef_idx(codec, 0xc4, 0x8000);
5605 alc_update_coef_idx(codec, 0xc2, ~0xfe, 0);
5606 snd_hda_set_pin_ctl_cache(codec, 0x18, 0);
5607 }
5608 alc_fixup_headset_mode(codec, fix, action);
5609}
5610
5611
5612static int find_ext_mic_pin(struct hda_codec *codec)
5613{
5614 struct alc_spec *spec = codec->spec;
5615 struct auto_pin_cfg *cfg = &spec->gen.autocfg;
5616 hda_nid_t nid;
5617 unsigned int defcfg;
5618 int i;
5619
5620 for (i = 0; i < cfg->num_inputs; i++) {
5621 if (cfg->inputs[i].type != AUTO_PIN_MIC)
5622 continue;
5623 nid = cfg->inputs[i].pin;
5624 defcfg = snd_hda_codec_get_pincfg(codec, nid);
5625 if (snd_hda_get_input_pin_attr(defcfg) == INPUT_PIN_ATTR_INT)
5626 continue;
5627 return nid;
5628 }
5629
5630 return 0;
5631}
5632
5633static void alc271_hp_gate_mic_jack(struct hda_codec *codec,
5634 const struct hda_fixup *fix,
5635 int action)
5636{
5637 struct alc_spec *spec = codec->spec;
5638
5639 if (action == HDA_FIXUP_ACT_PROBE) {
5640 int mic_pin = find_ext_mic_pin(codec);
5641 int hp_pin = alc_get_hp_pin(spec);
5642
5643 if (snd_BUG_ON(!mic_pin || !hp_pin))
5644 return;
5645 snd_hda_jack_set_gating_jack(codec, mic_pin, hp_pin);
5646 }
5647}
5648
5649static void alc269_fixup_limit_int_mic_boost(struct hda_codec *codec,
5650 const struct hda_fixup *fix,
5651 int action)
5652{
5653 struct alc_spec *spec = codec->spec;
5654 struct auto_pin_cfg *cfg = &spec->gen.autocfg;
5655 int i;
5656
5657
5658
5659
5660
5661 if (action != HDA_FIXUP_ACT_PROBE)
5662 return;
5663
5664 for (i = 0; i < cfg->num_inputs; i++) {
5665 hda_nid_t nid = cfg->inputs[i].pin;
5666 unsigned int defcfg;
5667 if (cfg->inputs[i].type != AUTO_PIN_MIC)
5668 continue;
5669 defcfg = snd_hda_codec_get_pincfg(codec, nid);
5670 if (snd_hda_get_input_pin_attr(defcfg) != INPUT_PIN_ATTR_INT)
5671 continue;
5672
5673 snd_hda_override_amp_caps(codec, nid, HDA_INPUT,
5674 (0x00 << AC_AMPCAP_OFFSET_SHIFT) |
5675 (0x01 << AC_AMPCAP_NUM_STEPS_SHIFT) |
5676 (0x2f << AC_AMPCAP_STEP_SIZE_SHIFT) |
5677 (0 << AC_AMPCAP_MUTE_SHIFT));
5678 }
5679}
5680
5681static void alc283_hp_automute_hook(struct hda_codec *codec,
5682 struct hda_jack_callback *jack)
5683{
5684 struct alc_spec *spec = codec->spec;
5685 int vref;
5686
5687 msleep(200);
5688 snd_hda_gen_hp_automute(codec, jack);
5689
5690 vref = spec->gen.hp_jack_present ? PIN_VREF80 : 0;
5691
5692 msleep(600);
5693 snd_hda_codec_write(codec, 0x19, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
5694 vref);
5695}
5696
5697static void alc283_fixup_chromebook(struct hda_codec *codec,
5698 const struct hda_fixup *fix, int action)
5699{
5700 struct alc_spec *spec = codec->spec;
5701
5702 switch (action) {
5703 case HDA_FIXUP_ACT_PRE_PROBE:
5704 snd_hda_override_wcaps(codec, 0x03, 0);
5705
5706 spec->gen.mixer_nid = 0;
5707 break;
5708 case HDA_FIXUP_ACT_INIT:
5709
5710
5711 alc_update_coef_idx(codec, 0x06, 0x000c, 0);
5712
5713 alc_update_coef_idx(codec, 0x1a, 0, 1 << 4);
5714 break;
5715 }
5716}
5717
5718static void alc283_fixup_sense_combo_jack(struct hda_codec *codec,
5719 const struct hda_fixup *fix, int action)
5720{
5721 struct alc_spec *spec = codec->spec;
5722
5723 switch (action) {
5724 case HDA_FIXUP_ACT_PRE_PROBE:
5725 spec->gen.hp_automute_hook = alc283_hp_automute_hook;
5726 break;
5727 case HDA_FIXUP_ACT_INIT:
5728
5729
5730 alc_update_coef_idx(codec, 0x06, 0x000c, 0);
5731 break;
5732 }
5733}
5734
5735
5736static void asus_tx300_automute(struct hda_codec *codec)
5737{
5738 struct alc_spec *spec = codec->spec;
5739 snd_hda_gen_update_outputs(codec);
5740 if (snd_hda_jack_detect(codec, 0x1b))
5741 spec->gen.mute_bits |= (1ULL << 0x14);
5742}
5743
5744static void alc282_fixup_asus_tx300(struct hda_codec *codec,
5745 const struct hda_fixup *fix, int action)
5746{
5747 struct alc_spec *spec = codec->spec;
5748 static const struct hda_pintbl dock_pins[] = {
5749 { 0x1b, 0x21114000 },
5750 {}
5751 };
5752
5753 switch (action) {
5754 case HDA_FIXUP_ACT_PRE_PROBE:
5755 spec->init_amp = ALC_INIT_DEFAULT;
5756
5757 alc_setup_gpio(codec, 0x04);
5758 snd_hda_apply_pincfgs(codec, dock_pins);
5759 spec->gen.auto_mute_via_amp = 1;
5760 spec->gen.automute_hook = asus_tx300_automute;
5761 snd_hda_jack_detect_enable_callback(codec, 0x1b,
5762 snd_hda_gen_hp_automute);
5763 break;
5764 case HDA_FIXUP_ACT_PROBE:
5765 spec->init_amp = ALC_INIT_DEFAULT;
5766 break;
5767 case HDA_FIXUP_ACT_BUILD:
5768
5769
5770
5771 rename_ctl(codec, "Speaker Playback Switch",
5772 "Dock Speaker Playback Switch");
5773 rename_ctl(codec, "Bass Speaker Playback Switch",
5774 "Speaker Playback Switch");
5775 break;
5776 }
5777}
5778
5779static void alc290_fixup_mono_speakers(struct hda_codec *codec,
5780 const struct hda_fixup *fix, int action)
5781{
5782 if (action == HDA_FIXUP_ACT_PRE_PROBE) {
5783
5784
5785
5786 static const hda_nid_t conn1[] = { 0x0c };
5787 snd_hda_override_conn_list(codec, 0x14, ARRAY_SIZE(conn1), conn1);
5788 snd_hda_override_conn_list(codec, 0x15, ARRAY_SIZE(conn1), conn1);
5789 }
5790}
5791
5792static void alc298_fixup_speaker_volume(struct hda_codec *codec,
5793 const struct hda_fixup *fix, int action)
5794{
5795 if (action == HDA_FIXUP_ACT_PRE_PROBE) {
5796
5797
5798
5799
5800
5801
5802
5803 static const hda_nid_t conn1[] = { 0x0c };
5804 snd_hda_override_conn_list(codec, 0x17, ARRAY_SIZE(conn1), conn1);
5805 }
5806}
5807
5808
5809static void alc295_fixup_disable_dac3(struct hda_codec *codec,
5810 const struct hda_fixup *fix, int action)
5811{
5812 if (action == HDA_FIXUP_ACT_PRE_PROBE) {
5813 static const hda_nid_t conn[] = { 0x02, 0x03 };
5814 snd_hda_override_conn_list(codec, 0x17, ARRAY_SIZE(conn), conn);
5815 }
5816}
5817
5818
5819static void alc285_fixup_speaker2_to_dac1(struct hda_codec *codec,
5820 const struct hda_fixup *fix, int action)
5821{
5822 if (action == HDA_FIXUP_ACT_PRE_PROBE) {
5823 static const hda_nid_t conn[] = { 0x02 };
5824 snd_hda_override_conn_list(codec, 0x17, ARRAY_SIZE(conn), conn);
5825 }
5826}
5827
5828
5829static void alc280_hp_gpio4_automute_hook(struct hda_codec *codec,
5830 struct hda_jack_callback *jack)
5831{
5832 struct alc_spec *spec = codec->spec;
5833
5834 snd_hda_gen_hp_automute(codec, jack);
5835
5836 alc_update_gpio_led(codec, 0x10, spec->mute_led_polarity,
5837 !spec->gen.hp_jack_present);
5838}
5839
5840
5841
5842
5843
5844
5845
5846static void alc280_fixup_hp_9480m(struct hda_codec *codec,
5847 const struct hda_fixup *fix,
5848 int action)
5849{
5850 struct alc_spec *spec = codec->spec;
5851
5852 alc_fixup_hp_gpio_led(codec, action, 0x08, 0);
5853 if (action == HDA_FIXUP_ACT_PRE_PROBE) {
5854
5855 spec->gpio_mask |= 0x10;
5856 spec->gpio_dir |= 0x10;
5857 spec->gen.hp_automute_hook = alc280_hp_gpio4_automute_hook;
5858 }
5859}
5860
5861static void alc275_fixup_gpio4_off(struct hda_codec *codec,
5862 const struct hda_fixup *fix,
5863 int action)
5864{
5865 struct alc_spec *spec = codec->spec;
5866
5867 if (action == HDA_FIXUP_ACT_PRE_PROBE) {
5868 spec->gpio_mask |= 0x04;
5869 spec->gpio_dir |= 0x04;
5870
5871 }
5872}
5873
5874
5875
5876
5877
5878
5879
5880static void alc285_fixup_thinkpad_x1_gen7(struct hda_codec *codec,
5881 const struct hda_fixup *fix, int action)
5882{
5883 static const hda_nid_t conn[] = { 0x02, 0x03 };
5884 static const hda_nid_t preferred_pairs[] = {
5885 0x14, 0x02, 0x17, 0x03, 0x21, 0x03, 0
5886 };
5887 struct alc_spec *spec = codec->spec;
5888
5889 switch (action) {
5890 case HDA_FIXUP_ACT_PRE_PROBE:
5891 snd_hda_override_conn_list(codec, 0x17, ARRAY_SIZE(conn), conn);
5892 spec->gen.preferred_dacs = preferred_pairs;
5893 break;
5894 case HDA_FIXUP_ACT_BUILD:
5895
5896
5897
5898
5899
5900
5901 rename_ctl(codec, "Front Playback Volume", "DAC1 Playback Volume");
5902 rename_ctl(codec, "Bass Speaker Playback Volume", "DAC2 Playback Volume");
5903 break;
5904 }
5905}
5906
5907static void alc233_alc662_fixup_lenovo_dual_codecs(struct hda_codec *codec,
5908 const struct hda_fixup *fix,
5909 int action)
5910{
5911 alc_fixup_dual_codecs(codec, fix, action);
5912 switch (action) {
5913 case HDA_FIXUP_ACT_PRE_PROBE:
5914
5915 strcpy(codec->card->longname, "HDAudio-Lenovo-DualCodecs");
5916 break;
5917 case HDA_FIXUP_ACT_BUILD:
5918
5919 rename_ctl(codec, "Capture Volume",
5920 codec->addr == 0 ?
5921 "Rear-Panel Capture Volume" :
5922 "Front-Panel Capture Volume");
5923 rename_ctl(codec, "Capture Switch",
5924 codec->addr == 0 ?
5925 "Rear-Panel Capture Switch" :
5926 "Front-Panel Capture Switch");
5927 break;
5928 }
5929}
5930
5931static void alc225_fixup_s3_pop_noise(struct hda_codec *codec,
5932 const struct hda_fixup *fix, int action)
5933{
5934 if (action != HDA_FIXUP_ACT_PRE_PROBE)
5935 return;
5936
5937 codec->power_save_node = 1;
5938}
5939
5940
5941static void alc274_fixup_bind_dacs(struct hda_codec *codec,
5942 const struct hda_fixup *fix, int action)
5943{
5944 struct alc_spec *spec = codec->spec;
5945 static const hda_nid_t preferred_pairs[] = {
5946 0x21, 0x03, 0x1b, 0x03, 0x16, 0x02,
5947 0
5948 };
5949
5950 if (action != HDA_FIXUP_ACT_PRE_PROBE)
5951 return;
5952
5953 spec->gen.preferred_dacs = preferred_pairs;
5954 spec->gen.auto_mute_via_amp = 1;
5955 codec->power_save_node = 0;
5956}
5957
5958
5959static void alc285_fixup_invalidate_dacs(struct hda_codec *codec,
5960 const struct hda_fixup *fix, int action)
5961{
5962 if (action != HDA_FIXUP_ACT_PRE_PROBE)
5963 return;
5964
5965 snd_hda_override_wcaps(codec, 0x03, 0);
5966}
5967
5968static void alc295_fixup_chromebook(struct hda_codec *codec,
5969 const struct hda_fixup *fix, int action)
5970{
5971 struct alc_spec *spec = codec->spec;
5972
5973 switch (action) {
5974 case HDA_FIXUP_ACT_PRE_PROBE:
5975 spec->ultra_low_power = true;
5976 break;
5977 case HDA_FIXUP_ACT_INIT:
5978 switch (codec->core.vendor_id) {
5979 case 0x10ec0295:
5980 alc_update_coef_idx(codec, 0x4a, 0x8000, 1 << 15);
5981 alc_update_coef_idx(codec, 0x4a, 0x8000, 0 << 15);
5982 break;
5983 case 0x10ec0236:
5984 alc_update_coef_idx(codec, 0x1b, 0x8000, 1 << 15);
5985 alc_update_coef_idx(codec, 0x1b, 0x8000, 0 << 15);
5986 break;
5987 }
5988 break;
5989 }
5990}
5991
5992static void alc_fixup_disable_mic_vref(struct hda_codec *codec,
5993 const struct hda_fixup *fix, int action)
5994{
5995 if (action == HDA_FIXUP_ACT_PRE_PROBE)
5996 snd_hda_codec_set_pin_target(codec, 0x19, PIN_VREFHIZ);
5997}
5998
5999
6000static void alc294_gx502_toggle_output(struct hda_codec *codec,
6001 struct hda_jack_callback *cb)
6002{
6003
6004
6005
6006 if (snd_hda_jack_detect_state(codec, 0x21) == HDA_JACK_PRESENT)
6007 alc_write_coef_idx(codec, 0x10, 0x8a20);
6008 else
6009 alc_write_coef_idx(codec, 0x10, 0x0a20);
6010}
6011
6012static void alc294_fixup_gx502_hp(struct hda_codec *codec,
6013 const struct hda_fixup *fix, int action)
6014{
6015
6016 if (!is_jack_detectable(codec, 0x21))
6017 return;
6018
6019 switch (action) {
6020 case HDA_FIXUP_ACT_PRE_PROBE:
6021 snd_hda_jack_detect_enable_callback(codec, 0x21,
6022 alc294_gx502_toggle_output);
6023 break;
6024 case HDA_FIXUP_ACT_INIT:
6025
6026
6027
6028 alc294_gx502_toggle_output(codec, NULL);
6029 break;
6030 }
6031}
6032
6033static void alc285_fixup_hp_gpio_amp_init(struct hda_codec *codec,
6034 const struct hda_fixup *fix, int action)
6035{
6036 if (action != HDA_FIXUP_ACT_INIT)
6037 return;
6038
6039 msleep(100);
6040 alc_write_coef_idx(codec, 0x65, 0x0);
6041}
6042
6043
6044#include "thinkpad_helper.c"
6045
6046static void alc_fixup_thinkpad_acpi(struct hda_codec *codec,
6047 const struct hda_fixup *fix, int action)
6048{
6049 alc_fixup_no_shutup(codec, fix, action);
6050 hda_fixup_thinkpad_acpi(codec, fix, action);
6051}
6052
6053
6054#include "hp_x360_helper.c"
6055
6056enum {
6057 ALC269_FIXUP_GPIO2,
6058 ALC269_FIXUP_SONY_VAIO,
6059 ALC275_FIXUP_SONY_VAIO_GPIO2,
6060 ALC269_FIXUP_DELL_M101Z,
6061 ALC269_FIXUP_SKU_IGNORE,
6062 ALC269_FIXUP_ASUS_G73JW,
6063 ALC269_FIXUP_LENOVO_EAPD,
6064 ALC275_FIXUP_SONY_HWEQ,
6065 ALC275_FIXUP_SONY_DISABLE_AAMIX,
6066 ALC271_FIXUP_DMIC,
6067 ALC269_FIXUP_PCM_44K,
6068 ALC269_FIXUP_STEREO_DMIC,
6069 ALC269_FIXUP_HEADSET_MIC,
6070 ALC269_FIXUP_QUANTA_MUTE,
6071 ALC269_FIXUP_LIFEBOOK,
6072 ALC269_FIXUP_LIFEBOOK_EXTMIC,
6073 ALC269_FIXUP_LIFEBOOK_HP_PIN,
6074 ALC269_FIXUP_LIFEBOOK_NO_HP_TO_LINEOUT,
6075 ALC255_FIXUP_LIFEBOOK_U7x7_HEADSET_MIC,
6076 ALC269_FIXUP_AMIC,
6077 ALC269_FIXUP_DMIC,
6078 ALC269VB_FIXUP_AMIC,
6079 ALC269VB_FIXUP_DMIC,
6080 ALC269_FIXUP_HP_MUTE_LED,
6081 ALC269_FIXUP_HP_MUTE_LED_MIC1,
6082 ALC269_FIXUP_HP_MUTE_LED_MIC2,
6083 ALC269_FIXUP_HP_MUTE_LED_MIC3,
6084 ALC269_FIXUP_HP_GPIO_LED,
6085 ALC269_FIXUP_HP_GPIO_MIC1_LED,
6086 ALC269_FIXUP_HP_LINE1_MIC1_LED,
6087 ALC269_FIXUP_INV_DMIC,
6088 ALC269_FIXUP_LENOVO_DOCK,
6089 ALC269_FIXUP_LENOVO_DOCK_LIMIT_BOOST,
6090 ALC269_FIXUP_NO_SHUTUP,
6091 ALC286_FIXUP_SONY_MIC_NO_PRESENCE,
6092 ALC269_FIXUP_PINCFG_NO_HP_TO_LINEOUT,
6093 ALC269_FIXUP_DELL1_MIC_NO_PRESENCE,
6094 ALC269_FIXUP_DELL2_MIC_NO_PRESENCE,
6095 ALC269_FIXUP_DELL3_MIC_NO_PRESENCE,
6096 ALC269_FIXUP_DELL4_MIC_NO_PRESENCE,
6097 ALC269_FIXUP_HEADSET_MODE,
6098 ALC269_FIXUP_HEADSET_MODE_NO_HP_MIC,
6099 ALC269_FIXUP_ASPIRE_HEADSET_MIC,
6100 ALC269_FIXUP_ASUS_X101_FUNC,
6101 ALC269_FIXUP_ASUS_X101_VERB,
6102 ALC269_FIXUP_ASUS_X101,
6103 ALC271_FIXUP_AMIC_MIC2,
6104 ALC271_FIXUP_HP_GATE_MIC_JACK,
6105 ALC271_FIXUP_HP_GATE_MIC_JACK_E1_572,
6106 ALC269_FIXUP_ACER_AC700,
6107 ALC269_FIXUP_LIMIT_INT_MIC_BOOST,
6108 ALC269VB_FIXUP_ASUS_ZENBOOK,
6109 ALC269VB_FIXUP_ASUS_ZENBOOK_UX31A,
6110 ALC269_FIXUP_LIMIT_INT_MIC_BOOST_MUTE_LED,
6111 ALC269VB_FIXUP_ORDISSIMO_EVE2,
6112 ALC283_FIXUP_CHROME_BOOK,
6113 ALC283_FIXUP_SENSE_COMBO_JACK,
6114 ALC282_FIXUP_ASUS_TX300,
6115 ALC283_FIXUP_INT_MIC,
6116 ALC290_FIXUP_MONO_SPEAKERS,
6117 ALC290_FIXUP_MONO_SPEAKERS_HSJACK,
6118 ALC290_FIXUP_SUBWOOFER,
6119 ALC290_FIXUP_SUBWOOFER_HSJACK,
6120 ALC269_FIXUP_THINKPAD_ACPI,
6121 ALC269_FIXUP_DMIC_THINKPAD_ACPI,
6122 ALC255_FIXUP_ACER_MIC_NO_PRESENCE,
6123 ALC255_FIXUP_ASUS_MIC_NO_PRESENCE,
6124 ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
6125 ALC255_FIXUP_DELL2_MIC_NO_PRESENCE,
6126 ALC255_FIXUP_HEADSET_MODE,
6127 ALC255_FIXUP_HEADSET_MODE_NO_HP_MIC,
6128 ALC293_FIXUP_DELL1_MIC_NO_PRESENCE,
6129 ALC292_FIXUP_TPT440_DOCK,
6130 ALC292_FIXUP_TPT440,
6131 ALC283_FIXUP_HEADSET_MIC,
6132 ALC255_FIXUP_MIC_MUTE_LED,
6133 ALC282_FIXUP_ASPIRE_V5_PINS,
6134 ALC280_FIXUP_HP_GPIO4,
6135 ALC286_FIXUP_HP_GPIO_LED,
6136 ALC280_FIXUP_HP_GPIO2_MIC_HOTKEY,
6137 ALC280_FIXUP_HP_DOCK_PINS,
6138 ALC269_FIXUP_HP_DOCK_GPIO_MIC1_LED,
6139 ALC280_FIXUP_HP_9480M,
6140 ALC288_FIXUP_DELL_HEADSET_MODE,
6141 ALC288_FIXUP_DELL1_MIC_NO_PRESENCE,
6142 ALC288_FIXUP_DELL_XPS_13,
6143 ALC288_FIXUP_DISABLE_AAMIX,
6144 ALC292_FIXUP_DELL_E7X_AAMIX,
6145 ALC292_FIXUP_DELL_E7X,
6146 ALC292_FIXUP_DISABLE_AAMIX,
6147 ALC293_FIXUP_DISABLE_AAMIX_MULTIJACK,
6148 ALC298_FIXUP_ALIENWARE_MIC_NO_PRESENCE,
6149 ALC298_FIXUP_DELL1_MIC_NO_PRESENCE,
6150 ALC298_FIXUP_DELL_AIO_MIC_NO_PRESENCE,
6151 ALC275_FIXUP_DELL_XPS,
6152 ALC293_FIXUP_LENOVO_SPK_NOISE,
6153 ALC233_FIXUP_LENOVO_LINE2_MIC_HOTKEY,
6154 ALC255_FIXUP_DELL_SPK_NOISE,
6155 ALC225_FIXUP_DISABLE_MIC_VREF,
6156 ALC225_FIXUP_DELL1_MIC_NO_PRESENCE,
6157 ALC295_FIXUP_DISABLE_DAC3,
6158 ALC285_FIXUP_SPEAKER2_TO_DAC1,
6159 ALC280_FIXUP_HP_HEADSET_MIC,
6160 ALC221_FIXUP_HP_FRONT_MIC,
6161 ALC292_FIXUP_TPT460,
6162 ALC298_FIXUP_SPK_VOLUME,
6163 ALC256_FIXUP_DELL_INSPIRON_7559_SUBWOOFER,
6164 ALC269_FIXUP_ATIV_BOOK_8,
6165 ALC221_FIXUP_HP_MIC_NO_PRESENCE,
6166 ALC256_FIXUP_ASUS_HEADSET_MODE,
6167 ALC256_FIXUP_ASUS_MIC,
6168 ALC256_FIXUP_ASUS_AIO_GPIO2,
6169 ALC233_FIXUP_ASUS_MIC_NO_PRESENCE,
6170 ALC233_FIXUP_EAPD_COEF_AND_MIC_NO_PRESENCE,
6171 ALC233_FIXUP_LENOVO_MULTI_CODECS,
6172 ALC233_FIXUP_ACER_HEADSET_MIC,
6173 ALC294_FIXUP_LENOVO_MIC_LOCATION,
6174 ALC225_FIXUP_DELL_WYSE_MIC_NO_PRESENCE,
6175 ALC225_FIXUP_S3_POP_NOISE,
6176 ALC700_FIXUP_INTEL_REFERENCE,
6177 ALC274_FIXUP_DELL_BIND_DACS,
6178 ALC274_FIXUP_DELL_AIO_LINEOUT_VERB,
6179 ALC298_FIXUP_TPT470_DOCK_FIX,
6180 ALC298_FIXUP_TPT470_DOCK,
6181 ALC255_FIXUP_DUMMY_LINEOUT_VERB,
6182 ALC255_FIXUP_DELL_HEADSET_MIC,
6183 ALC256_FIXUP_HUAWEI_MACH_WX9_PINS,
6184 ALC298_FIXUP_HUAWEI_MBX_STEREO,
6185 ALC295_FIXUP_HP_X360,
6186 ALC221_FIXUP_HP_HEADSET_MIC,
6187 ALC285_FIXUP_LENOVO_HEADPHONE_NOISE,
6188 ALC295_FIXUP_HP_AUTO_MUTE,
6189 ALC286_FIXUP_ACER_AIO_MIC_NO_PRESENCE,
6190 ALC294_FIXUP_ASUS_MIC,
6191 ALC294_FIXUP_ASUS_HEADSET_MIC,
6192 ALC294_FIXUP_ASUS_SPK,
6193 ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE,
6194 ALC285_FIXUP_LENOVO_PC_BEEP_IN_NOISE,
6195 ALC255_FIXUP_ACER_HEADSET_MIC,
6196 ALC295_FIXUP_CHROME_BOOK,
6197 ALC225_FIXUP_HEADSET_JACK,
6198 ALC225_FIXUP_DELL_WYSE_AIO_MIC_NO_PRESENCE,
6199 ALC225_FIXUP_WYSE_AUTO_MUTE,
6200 ALC225_FIXUP_WYSE_DISABLE_MIC_VREF,
6201 ALC286_FIXUP_ACER_AIO_HEADSET_MIC,
6202 ALC256_FIXUP_ASUS_HEADSET_MIC,
6203 ALC256_FIXUP_ASUS_MIC_NO_PRESENCE,
6204 ALC299_FIXUP_PREDATOR_SPK,
6205 ALC256_FIXUP_MEDION_HEADSET_NO_PRESENCE,
6206 ALC289_FIXUP_DELL_SPK2,
6207 ALC289_FIXUP_DUAL_SPK,
6208 ALC294_FIXUP_SPK2_TO_DAC1,
6209 ALC294_FIXUP_ASUS_DUAL_SPK,
6210 ALC285_FIXUP_THINKPAD_X1_GEN7,
6211 ALC285_FIXUP_THINKPAD_HEADSET_JACK,
6212 ALC294_FIXUP_ASUS_HPE,
6213 ALC294_FIXUP_ASUS_COEF_1B,
6214 ALC294_FIXUP_ASUS_GX502_HP,
6215 ALC294_FIXUP_ASUS_GX502_PINS,
6216 ALC294_FIXUP_ASUS_GX502_VERBS,
6217 ALC285_FIXUP_HP_GPIO_LED,
6218 ALC285_FIXUP_HP_MUTE_LED,
6219 ALC236_FIXUP_HP_MUTE_LED,
6220 ALC298_FIXUP_SAMSUNG_HEADPHONE_VERY_QUIET,
6221 ALC295_FIXUP_ASUS_MIC_NO_PRESENCE,
6222 ALC269VC_FIXUP_ACER_VCOPPERBOX_PINS,
6223 ALC269VC_FIXUP_ACER_HEADSET_MIC,
6224 ALC269VC_FIXUP_ACER_MIC_NO_PRESENCE,
6225 ALC289_FIXUP_ASUS_GA401,
6226 ALC289_FIXUP_ASUS_GA502,
6227 ALC256_FIXUP_ACER_MIC_NO_PRESENCE,
6228 ALC285_FIXUP_HP_GPIO_AMP_INIT,
6229 ALC269_FIXUP_CZC_B20,
6230 ALC269_FIXUP_CZC_TMI,
6231 ALC269_FIXUP_CZC_L101,
6232 ALC269_FIXUP_LEMOTE_A1802,
6233 ALC269_FIXUP_LEMOTE_A190X,
6234 ALC256_FIXUP_INTEL_NUC8_RUGGED,
6235 ALC255_FIXUP_XIAOMI_HEADSET_MIC,
6236};
6237
6238static const struct hda_fixup alc269_fixups[] = {
6239 [ALC269_FIXUP_GPIO2] = {
6240 .type = HDA_FIXUP_FUNC,
6241 .v.func = alc_fixup_gpio2,
6242 },
6243 [ALC269_FIXUP_SONY_VAIO] = {
6244 .type = HDA_FIXUP_PINCTLS,
6245 .v.pins = (const struct hda_pintbl[]) {
6246 {0x19, PIN_VREFGRD},
6247 {}
6248 }
6249 },
6250 [ALC275_FIXUP_SONY_VAIO_GPIO2] = {
6251 .type = HDA_FIXUP_FUNC,
6252 .v.func = alc275_fixup_gpio4_off,
6253 .chained = true,
6254 .chain_id = ALC269_FIXUP_SONY_VAIO
6255 },
6256 [ALC269_FIXUP_DELL_M101Z] = {
6257 .type = HDA_FIXUP_VERBS,
6258 .v.verbs = (const struct hda_verb[]) {
6259
6260 {0x20, AC_VERB_SET_COEF_INDEX, 13},
6261 {0x20, AC_VERB_SET_PROC_COEF, 0x4040},
6262 {}
6263 }
6264 },
6265 [ALC269_FIXUP_SKU_IGNORE] = {
6266 .type = HDA_FIXUP_FUNC,
6267 .v.func = alc_fixup_sku_ignore,
6268 },
6269 [ALC269_FIXUP_ASUS_G73JW] = {
6270 .type = HDA_FIXUP_PINS,
6271 .v.pins = (const struct hda_pintbl[]) {
6272 { 0x17, 0x99130111 },
6273 { }
6274 }
6275 },
6276 [ALC269_FIXUP_LENOVO_EAPD] = {
6277 .type = HDA_FIXUP_VERBS,
6278 .v.verbs = (const struct hda_verb[]) {
6279 {0x14, AC_VERB_SET_EAPD_BTLENABLE, 0},
6280 {}
6281 }
6282 },
6283 [ALC275_FIXUP_SONY_HWEQ] = {
6284 .type = HDA_FIXUP_FUNC,
6285 .v.func = alc269_fixup_hweq,
6286 .chained = true,
6287 .chain_id = ALC275_FIXUP_SONY_VAIO_GPIO2
6288 },
6289 [ALC275_FIXUP_SONY_DISABLE_AAMIX] = {
6290 .type = HDA_FIXUP_FUNC,
6291 .v.func = alc_fixup_disable_aamix,
6292 .chained = true,
6293 .chain_id = ALC269_FIXUP_SONY_VAIO
6294 },
6295 [ALC271_FIXUP_DMIC] = {
6296 .type = HDA_FIXUP_FUNC,
6297 .v.func = alc271_fixup_dmic,
6298 },
6299 [ALC269_FIXUP_PCM_44K] = {
6300 .type = HDA_FIXUP_FUNC,
6301 .v.func = alc269_fixup_pcm_44k,
6302 .chained = true,
6303 .chain_id = ALC269_FIXUP_QUANTA_MUTE
6304 },
6305 [ALC269_FIXUP_STEREO_DMIC] = {
6306 .type = HDA_FIXUP_FUNC,
6307 .v.func = alc269_fixup_stereo_dmic,
6308 },
6309 [ALC269_FIXUP_HEADSET_MIC] = {
6310 .type = HDA_FIXUP_FUNC,
6311 .v.func = alc269_fixup_headset_mic,
6312 },
6313 [ALC269_FIXUP_QUANTA_MUTE] = {
6314 .type = HDA_FIXUP_FUNC,
6315 .v.func = alc269_fixup_quanta_mute,
6316 },
6317 [ALC269_FIXUP_LIFEBOOK] = {
6318 .type = HDA_FIXUP_PINS,
6319 .v.pins = (const struct hda_pintbl[]) {
6320 { 0x1a, 0x2101103f },
6321 { 0x1b, 0x23a11040 },
6322 { }
6323 },
6324 .chained = true,
6325 .chain_id = ALC269_FIXUP_QUANTA_MUTE
6326 },
6327 [ALC269_FIXUP_LIFEBOOK_EXTMIC] = {
6328 .type = HDA_FIXUP_PINS,
6329 .v.pins = (const struct hda_pintbl[]) {
6330 { 0x19, 0x01a1903c },
6331 { }
6332 },
6333 },
6334 [ALC269_FIXUP_LIFEBOOK_HP_PIN] = {
6335 .type = HDA_FIXUP_PINS,
6336 .v.pins = (const struct hda_pintbl[]) {
6337 { 0x21, 0x0221102f },
6338 { }
6339 },
6340 },
6341 [ALC269_FIXUP_LIFEBOOK_NO_HP_TO_LINEOUT] = {
6342 .type = HDA_FIXUP_FUNC,
6343 .v.func = alc269_fixup_pincfg_no_hp_to_lineout,
6344 },
6345 [ALC255_FIXUP_LIFEBOOK_U7x7_HEADSET_MIC] = {
6346 .type = HDA_FIXUP_FUNC,
6347 .v.func = alc269_fixup_pincfg_U7x7_headset_mic,
6348 },
6349 [ALC269_FIXUP_AMIC] = {
6350 .type = HDA_FIXUP_PINS,
6351 .v.pins = (const struct hda_pintbl[]) {
6352 { 0x14, 0x99130110 },
6353 { 0x15, 0x0121401f },
6354 { 0x18, 0x01a19c20 },
6355 { 0x19, 0x99a3092f },
6356 { }
6357 },
6358 },
6359 [ALC269_FIXUP_DMIC] = {
6360 .type = HDA_FIXUP_PINS,
6361 .v.pins = (const struct hda_pintbl[]) {
6362 { 0x12, 0x99a3092f },
6363 { 0x14, 0x99130110 },
6364 { 0x15, 0x0121401f },
6365 { 0x18, 0x01a19c20 },
6366 { }
6367 },
6368 },
6369 [ALC269VB_FIXUP_AMIC] = {
6370 .type = HDA_FIXUP_PINS,
6371 .v.pins = (const struct hda_pintbl[]) {
6372 { 0x14, 0x99130110 },
6373 { 0x18, 0x01a19c20 },
6374 { 0x19, 0x99a3092f },
6375 { 0x21, 0x0121401f },
6376 { }
6377 },
6378 },
6379 [ALC269VB_FIXUP_DMIC] = {
6380 .type = HDA_FIXUP_PINS,
6381 .v.pins = (const struct hda_pintbl[]) {
6382 { 0x12, 0x99a3092f },
6383 { 0x14, 0x99130110 },
6384 { 0x18, 0x01a19c20 },
6385 { 0x21, 0x0121401f },
6386 { }
6387 },
6388 },
6389 [ALC269_FIXUP_HP_MUTE_LED] = {
6390 .type = HDA_FIXUP_FUNC,
6391 .v.func = alc269_fixup_hp_mute_led,
6392 },
6393 [ALC269_FIXUP_HP_MUTE_LED_MIC1] = {
6394 .type = HDA_FIXUP_FUNC,
6395 .v.func = alc269_fixup_hp_mute_led_mic1,
6396 },
6397 [ALC269_FIXUP_HP_MUTE_LED_MIC2] = {
6398 .type = HDA_FIXUP_FUNC,
6399 .v.func = alc269_fixup_hp_mute_led_mic2,
6400 },
6401 [ALC269_FIXUP_HP_MUTE_LED_MIC3] = {
6402 .type = HDA_FIXUP_FUNC,
6403 .v.func = alc269_fixup_hp_mute_led_mic3,
6404 .chained = true,
6405 .chain_id = ALC295_FIXUP_HP_AUTO_MUTE
6406 },
6407 [ALC269_FIXUP_HP_GPIO_LED] = {
6408 .type = HDA_FIXUP_FUNC,
6409 .v.func = alc269_fixup_hp_gpio_led,
6410 },
6411 [ALC269_FIXUP_HP_GPIO_MIC1_LED] = {
6412 .type = HDA_FIXUP_FUNC,
6413 .v.func = alc269_fixup_hp_gpio_mic1_led,
6414 },
6415 [ALC269_FIXUP_HP_LINE1_MIC1_LED] = {
6416 .type = HDA_FIXUP_FUNC,
6417 .v.func = alc269_fixup_hp_line1_mic1_led,
6418 },
6419 [ALC269_FIXUP_INV_DMIC] = {
6420 .type = HDA_FIXUP_FUNC,
6421 .v.func = alc_fixup_inv_dmic,
6422 },
6423 [ALC269_FIXUP_NO_SHUTUP] = {
6424 .type = HDA_FIXUP_FUNC,
6425 .v.func = alc_fixup_no_shutup,
6426 },
6427 [ALC269_FIXUP_LENOVO_DOCK] = {
6428 .type = HDA_FIXUP_PINS,
6429 .v.pins = (const struct hda_pintbl[]) {
6430 { 0x19, 0x23a11040 },
6431 { 0x1b, 0x2121103f },
6432 { }
6433 },
6434 .chained = true,
6435 .chain_id = ALC269_FIXUP_PINCFG_NO_HP_TO_LINEOUT
6436 },
6437 [ALC269_FIXUP_LENOVO_DOCK_LIMIT_BOOST] = {
6438 .type = HDA_FIXUP_FUNC,
6439 .v.func = alc269_fixup_limit_int_mic_boost,
6440 .chained = true,
6441 .chain_id = ALC269_FIXUP_LENOVO_DOCK,
6442 },
6443 [ALC269_FIXUP_PINCFG_NO_HP_TO_LINEOUT] = {
6444 .type = HDA_FIXUP_FUNC,
6445 .v.func = alc269_fixup_pincfg_no_hp_to_lineout,
6446 .chained = true,
6447 .chain_id = ALC269_FIXUP_THINKPAD_ACPI,
6448 },
6449 [ALC269_FIXUP_DELL1_MIC_NO_PRESENCE] = {
6450 .type = HDA_FIXUP_PINS,
6451 .v.pins = (const struct hda_pintbl[]) {
6452 { 0x19, 0x01a1913c },
6453 { 0x1a, 0x01a1913d },
6454 { }
6455 },
6456 .chained = true,
6457 .chain_id = ALC269_FIXUP_HEADSET_MODE
6458 },
6459 [ALC269_FIXUP_DELL2_MIC_NO_PRESENCE] = {
6460 .type = HDA_FIXUP_PINS,
6461 .v.pins = (const struct hda_pintbl[]) {
6462 { 0x16, 0x21014020 },
6463 { 0x19, 0x21a19030 },
6464 { 0x1a, 0x01a1913c },
6465 { }
6466 },
6467 .chained = true,
6468 .chain_id = ALC269_FIXUP_HEADSET_MODE_NO_HP_MIC
6469 },
6470 [ALC269_FIXUP_DELL3_MIC_NO_PRESENCE] = {
6471 .type = HDA_FIXUP_PINS,
6472 .v.pins = (const struct hda_pintbl[]) {
6473 { 0x1a, 0x01a1913c },
6474 { }
6475 },
6476 .chained = true,
6477 .chain_id = ALC269_FIXUP_HEADSET_MODE_NO_HP_MIC
6478 },
6479 [ALC269_FIXUP_DELL4_MIC_NO_PRESENCE] = {
6480 .type = HDA_FIXUP_PINS,
6481 .v.pins = (const struct hda_pintbl[]) {
6482 { 0x19, 0x01a1913c },
6483 { 0x1b, 0x01a1913d },
6484 { }
6485 },
6486 .chained = true,
6487 .chain_id = ALC269_FIXUP_HEADSET_MODE
6488 },
6489 [ALC269_FIXUP_HEADSET_MODE] = {
6490 .type = HDA_FIXUP_FUNC,
6491 .v.func = alc_fixup_headset_mode,
6492 .chained = true,
6493 .chain_id = ALC255_FIXUP_MIC_MUTE_LED
6494 },
6495 [ALC269_FIXUP_HEADSET_MODE_NO_HP_MIC] = {
6496 .type = HDA_FIXUP_FUNC,
6497 .v.func = alc_fixup_headset_mode_no_hp_mic,
6498 },
6499 [ALC269_FIXUP_ASPIRE_HEADSET_MIC] = {
6500 .type = HDA_FIXUP_PINS,
6501 .v.pins = (const struct hda_pintbl[]) {
6502 { 0x19, 0x01a1913c },
6503 { }
6504 },
6505 .chained = true,
6506 .chain_id = ALC269_FIXUP_HEADSET_MODE,
6507 },
6508 [ALC286_FIXUP_SONY_MIC_NO_PRESENCE] = {
6509 .type = HDA_FIXUP_PINS,
6510 .v.pins = (const struct hda_pintbl[]) {
6511 { 0x18, 0x01a1913c },
6512 { }
6513 },
6514 .chained = true,
6515 .chain_id = ALC269_FIXUP_HEADSET_MIC
6516 },
6517 [ALC256_FIXUP_HUAWEI_MACH_WX9_PINS] = {
6518 .type = HDA_FIXUP_PINS,
6519 .v.pins = (const struct hda_pintbl[]) {
6520 {0x12, 0x90a60130},
6521 {0x13, 0x40000000},
6522 {0x14, 0x90170110},
6523 {0x18, 0x411111f0},
6524 {0x19, 0x04a11040},
6525 {0x1a, 0x411111f0},
6526 {0x1b, 0x90170112},
6527 {0x1d, 0x40759a05},
6528 {0x1e, 0x411111f0},
6529 {0x21, 0x04211020},
6530 { }
6531 },
6532 .chained = true,
6533 .chain_id = ALC255_FIXUP_MIC_MUTE_LED
6534 },
6535 [ALC298_FIXUP_HUAWEI_MBX_STEREO] = {
6536 .type = HDA_FIXUP_FUNC,
6537 .v.func = alc298_fixup_huawei_mbx_stereo,
6538 .chained = true,
6539 .chain_id = ALC255_FIXUP_MIC_MUTE_LED
6540 },
6541 [ALC269_FIXUP_ASUS_X101_FUNC] = {
6542 .type = HDA_FIXUP_FUNC,
6543 .v.func = alc269_fixup_x101_headset_mic,
6544 },
6545 [ALC269_FIXUP_ASUS_X101_VERB] = {
6546 .type = HDA_FIXUP_VERBS,
6547 .v.verbs = (const struct hda_verb[]) {
6548 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
6549 {0x20, AC_VERB_SET_COEF_INDEX, 0x08},
6550 {0x20, AC_VERB_SET_PROC_COEF, 0x0310},
6551 { }
6552 },
6553 .chained = true,
6554 .chain_id = ALC269_FIXUP_ASUS_X101_FUNC
6555 },
6556 [ALC269_FIXUP_ASUS_X101] = {
6557 .type = HDA_FIXUP_PINS,
6558 .v.pins = (const struct hda_pintbl[]) {
6559 { 0x18, 0x04a1182c },
6560 { }
6561 },
6562 .chained = true,
6563 .chain_id = ALC269_FIXUP_ASUS_X101_VERB
6564 },
6565 [ALC271_FIXUP_AMIC_MIC2] = {
6566 .type = HDA_FIXUP_PINS,
6567 .v.pins = (const struct hda_pintbl[]) {
6568 { 0x14, 0x99130110 },
6569 { 0x19, 0x01a19c20 },
6570 { 0x1b, 0x99a7012f },
6571 { 0x21, 0x0121401f },
6572 { }
6573 },
6574 },
6575 [ALC271_FIXUP_HP_GATE_MIC_JACK] = {
6576 .type = HDA_FIXUP_FUNC,
6577 .v.func = alc271_hp_gate_mic_jack,
6578 .chained = true,
6579 .chain_id = ALC271_FIXUP_AMIC_MIC2,
6580 },
6581 [ALC271_FIXUP_HP_GATE_MIC_JACK_E1_572] = {
6582 .type = HDA_FIXUP_FUNC,
6583 .v.func = alc269_fixup_limit_int_mic_boost,
6584 .chained = true,
6585 .chain_id = ALC271_FIXUP_HP_GATE_MIC_JACK,
6586 },
6587 [ALC269_FIXUP_ACER_AC700] = {
6588 .type = HDA_FIXUP_PINS,
6589 .v.pins = (const struct hda_pintbl[]) {
6590 { 0x12, 0x99a3092f },
6591 { 0x14, 0x99130110 },
6592 { 0x18, 0x03a11c20 },
6593 { 0x1e, 0x0346101e },
6594 { 0x21, 0x0321101f },
6595 { }
6596 },
6597 .chained = true,
6598 .chain_id = ALC271_FIXUP_DMIC,
6599 },
6600 [ALC269_FIXUP_LIMIT_INT_MIC_BOOST] = {
6601 .type = HDA_FIXUP_FUNC,
6602 .v.func = alc269_fixup_limit_int_mic_boost,
6603 .chained = true,
6604 .chain_id = ALC269_FIXUP_THINKPAD_ACPI,
6605 },
6606 [ALC269VB_FIXUP_ASUS_ZENBOOK] = {
6607 .type = HDA_FIXUP_FUNC,
6608 .v.func = alc269_fixup_limit_int_mic_boost,
6609 .chained = true,
6610 .chain_id = ALC269VB_FIXUP_DMIC,
6611 },
6612 [ALC269VB_FIXUP_ASUS_ZENBOOK_UX31A] = {
6613 .type = HDA_FIXUP_VERBS,
6614 .v.verbs = (const struct hda_verb[]) {
6615
6616 { 0x20, AC_VERB_SET_COEF_INDEX, 0x12 },
6617 { 0x20, AC_VERB_SET_PROC_COEF, 0x2800 },
6618 {}
6619 },
6620 .chained = true,
6621 .chain_id = ALC269VB_FIXUP_ASUS_ZENBOOK,
6622 },
6623 [ALC269_FIXUP_LIMIT_INT_MIC_BOOST_MUTE_LED] = {
6624 .type = HDA_FIXUP_FUNC,
6625 .v.func = alc269_fixup_limit_int_mic_boost,
6626 .chained = true,
6627 .chain_id = ALC269_FIXUP_HP_MUTE_LED_MIC1,
6628 },
6629 [ALC269VB_FIXUP_ORDISSIMO_EVE2] = {
6630 .type = HDA_FIXUP_PINS,
6631 .v.pins = (const struct hda_pintbl[]) {
6632 { 0x12, 0x99a3092f },
6633 { 0x18, 0x03a11d20 },
6634 { 0x19, 0x411111f0 },
6635 { }
6636 },
6637 },
6638 [ALC283_FIXUP_CHROME_BOOK] = {
6639 .type = HDA_FIXUP_FUNC,
6640 .v.func = alc283_fixup_chromebook,
6641 },
6642 [ALC283_FIXUP_SENSE_COMBO_JACK] = {
6643 .type = HDA_FIXUP_FUNC,
6644 .v.func = alc283_fixup_sense_combo_jack,
6645 .chained = true,
6646 .chain_id = ALC283_FIXUP_CHROME_BOOK,
6647 },
6648 [ALC282_FIXUP_ASUS_TX300] = {
6649 .type = HDA_FIXUP_FUNC,
6650 .v.func = alc282_fixup_asus_tx300,
6651 },
6652 [ALC283_FIXUP_INT_MIC] = {
6653 .type = HDA_FIXUP_VERBS,
6654 .v.verbs = (const struct hda_verb[]) {
6655 {0x20, AC_VERB_SET_COEF_INDEX, 0x1a},
6656 {0x20, AC_VERB_SET_PROC_COEF, 0x0011},
6657 { }
6658 },
6659 .chained = true,
6660 .chain_id = ALC269_FIXUP_LIMIT_INT_MIC_BOOST
6661 },
6662 [ALC290_FIXUP_SUBWOOFER_HSJACK] = {
6663 .type = HDA_FIXUP_PINS,
6664 .v.pins = (const struct hda_pintbl[]) {
6665 { 0x17, 0x90170112 },
6666 { }
6667 },
6668 .chained = true,
6669 .chain_id = ALC290_FIXUP_MONO_SPEAKERS_HSJACK,
6670 },
6671 [ALC290_FIXUP_SUBWOOFER] = {
6672 .type = HDA_FIXUP_PINS,
6673 .v.pins = (const struct hda_pintbl[]) {
6674 { 0x17, 0x90170112 },
6675 { }
6676 },
6677 .chained = true,
6678 .chain_id = ALC290_FIXUP_MONO_SPEAKERS,
6679 },
6680 [ALC290_FIXUP_MONO_SPEAKERS] = {
6681 .type = HDA_FIXUP_FUNC,
6682 .v.func = alc290_fixup_mono_speakers,
6683 },
6684 [ALC290_FIXUP_MONO_SPEAKERS_HSJACK] = {
6685 .type = HDA_FIXUP_FUNC,
6686 .v.func = alc290_fixup_mono_speakers,
6687 .chained = true,
6688 .chain_id = ALC269_FIXUP_DELL3_MIC_NO_PRESENCE,
6689 },
6690 [ALC269_FIXUP_THINKPAD_ACPI] = {
6691 .type = HDA_FIXUP_FUNC,
6692 .v.func = alc_fixup_thinkpad_acpi,
6693 .chained = true,
6694 .chain_id = ALC269_FIXUP_SKU_IGNORE,
6695 },
6696 [ALC269_FIXUP_DMIC_THINKPAD_ACPI] = {
6697 .type = HDA_FIXUP_FUNC,
6698 .v.func = alc_fixup_inv_dmic,
6699 .chained = true,
6700 .chain_id = ALC269_FIXUP_THINKPAD_ACPI,
6701 },
6702 [ALC255_FIXUP_ACER_MIC_NO_PRESENCE] = {
6703 .type = HDA_FIXUP_PINS,
6704 .v.pins = (const struct hda_pintbl[]) {
6705 { 0x19, 0x01a1913c },
6706 { }
6707 },
6708 .chained = true,
6709 .chain_id = ALC255_FIXUP_HEADSET_MODE
6710 },
6711 [ALC255_FIXUP_ASUS_MIC_NO_PRESENCE] = {
6712 .type = HDA_FIXUP_PINS,
6713 .v.pins = (const struct hda_pintbl[]) {
6714 { 0x19, 0x01a1913c },
6715 { }
6716 },
6717 .chained = true,
6718 .chain_id = ALC255_FIXUP_HEADSET_MODE
6719 },
6720 [ALC255_FIXUP_DELL1_MIC_NO_PRESENCE] = {
6721 .type = HDA_FIXUP_PINS,
6722 .v.pins = (const struct hda_pintbl[]) {
6723 { 0x19, 0x01a1913c },
6724 { 0x1a, 0x01a1913d },
6725 { }
6726 },
6727 .chained = true,
6728 .chain_id = ALC255_FIXUP_HEADSET_MODE
6729 },
6730 [ALC255_FIXUP_DELL2_MIC_NO_PRESENCE] = {
6731 .type = HDA_FIXUP_PINS,
6732 .v.pins = (const struct hda_pintbl[]) {
6733 { 0x19, 0x01a1913c },
6734 { }
6735 },
6736 .chained = true,
6737 .chain_id = ALC255_FIXUP_HEADSET_MODE_NO_HP_MIC
6738 },
6739 [ALC255_FIXUP_HEADSET_MODE] = {
6740 .type = HDA_FIXUP_FUNC,
6741 .v.func = alc_fixup_headset_mode_alc255,
6742 .chained = true,
6743 .chain_id = ALC255_FIXUP_MIC_MUTE_LED
6744 },
6745 [ALC255_FIXUP_HEADSET_MODE_NO_HP_MIC] = {
6746 .type = HDA_FIXUP_FUNC,
6747 .v.func = alc_fixup_headset_mode_alc255_no_hp_mic,
6748 },
6749 [ALC293_FIXUP_DELL1_MIC_NO_PRESENCE] = {
6750 .type = HDA_FIXUP_PINS,
6751 .v.pins = (const struct hda_pintbl[]) {
6752 { 0x18, 0x01a1913d },
6753 { 0x1a, 0x01a1913c },
6754 { }
6755 },
6756 .chained = true,
6757 .chain_id = ALC269_FIXUP_HEADSET_MODE
6758 },
6759 [ALC292_FIXUP_TPT440_DOCK] = {
6760 .type = HDA_FIXUP_FUNC,
6761 .v.func = alc_fixup_tpt440_dock,
6762 .chained = true,
6763 .chain_id = ALC269_FIXUP_LIMIT_INT_MIC_BOOST
6764 },
6765 [ALC292_FIXUP_TPT440] = {
6766 .type = HDA_FIXUP_FUNC,
6767 .v.func = alc_fixup_disable_aamix,
6768 .chained = true,
6769 .chain_id = ALC292_FIXUP_TPT440_DOCK,
6770 },
6771 [ALC283_FIXUP_HEADSET_MIC] = {
6772 .type = HDA_FIXUP_PINS,
6773 .v.pins = (const struct hda_pintbl[]) {
6774 { 0x19, 0x04a110f0 },
6775 { },
6776 },
6777 },
6778 [ALC255_FIXUP_MIC_MUTE_LED] = {
6779 .type = HDA_FIXUP_FUNC,
6780 .v.func = alc_fixup_micmute_led,
6781 },
6782 [ALC282_FIXUP_ASPIRE_V5_PINS] = {
6783 .type = HDA_FIXUP_PINS,
6784 .v.pins = (const struct hda_pintbl[]) {
6785 { 0x12, 0x90a60130 },
6786 { 0x14, 0x90170110 },
6787 { 0x17, 0x40000008 },
6788 { 0x18, 0x411111f0 },
6789 { 0x19, 0x01a1913c },
6790 { 0x1a, 0x411111f0 },
6791 { 0x1b, 0x411111f0 },
6792 { 0x1d, 0x40f89b2d },
6793 { 0x1e, 0x411111f0 },
6794 { 0x21, 0x0321101f },
6795 { },
6796 },
6797 },
6798 [ALC280_FIXUP_HP_GPIO4] = {
6799 .type = HDA_FIXUP_FUNC,
6800 .v.func = alc280_fixup_hp_gpio4,
6801 },
6802 [ALC286_FIXUP_HP_GPIO_LED] = {
6803 .type = HDA_FIXUP_FUNC,
6804 .v.func = alc286_fixup_hp_gpio_led,
6805 },
6806 [ALC280_FIXUP_HP_GPIO2_MIC_HOTKEY] = {
6807 .type = HDA_FIXUP_FUNC,
6808 .v.func = alc280_fixup_hp_gpio2_mic_hotkey,
6809 },
6810 [ALC280_FIXUP_HP_DOCK_PINS] = {
6811 .type = HDA_FIXUP_PINS,
6812 .v.pins = (const struct hda_pintbl[]) {
6813 { 0x1b, 0x21011020 },
6814 { 0x1a, 0x01a1903c },
6815 { 0x18, 0x2181103f },
6816 { },
6817 },
6818 .chained = true,
6819 .chain_id = ALC280_FIXUP_HP_GPIO4
6820 },
6821 [ALC269_FIXUP_HP_DOCK_GPIO_MIC1_LED] = {
6822 .type = HDA_FIXUP_PINS,
6823 .v.pins = (const struct hda_pintbl[]) {
6824 { 0x1b, 0x21011020 },
6825 { 0x18, 0x2181103f },
6826 { },
6827 },
6828 .chained = true,
6829 .chain_id = ALC269_FIXUP_HP_GPIO_MIC1_LED
6830 },
6831 [ALC280_FIXUP_HP_9480M] = {
6832 .type = HDA_FIXUP_FUNC,
6833 .v.func = alc280_fixup_hp_9480m,
6834 },
6835 [ALC288_FIXUP_DELL_HEADSET_MODE] = {
6836 .type = HDA_FIXUP_FUNC,
6837 .v.func = alc_fixup_headset_mode_dell_alc288,
6838 .chained = true,
6839 .chain_id = ALC255_FIXUP_MIC_MUTE_LED
6840 },
6841 [ALC288_FIXUP_DELL1_MIC_NO_PRESENCE] = {
6842 .type = HDA_FIXUP_PINS,
6843 .v.pins = (const struct hda_pintbl[]) {
6844 { 0x18, 0x01a1913c },
6845 { 0x1a, 0x01a1913d },
6846 { }
6847 },
6848 .chained = true,
6849 .chain_id = ALC288_FIXUP_DELL_HEADSET_MODE
6850 },
6851 [ALC288_FIXUP_DISABLE_AAMIX] = {
6852 .type = HDA_FIXUP_FUNC,
6853 .v.func = alc_fixup_disable_aamix,
6854 .chained = true,
6855 .chain_id = ALC288_FIXUP_DELL1_MIC_NO_PRESENCE
6856 },
6857 [ALC288_FIXUP_DELL_XPS_13] = {
6858 .type = HDA_FIXUP_FUNC,
6859 .v.func = alc_fixup_dell_xps13,
6860 .chained = true,
6861 .chain_id = ALC288_FIXUP_DISABLE_AAMIX
6862 },
6863 [ALC292_FIXUP_DISABLE_AAMIX] = {
6864 .type = HDA_FIXUP_FUNC,
6865 .v.func = alc_fixup_disable_aamix,
6866 .chained = true,
6867 .chain_id = ALC269_FIXUP_DELL2_MIC_NO_PRESENCE
6868 },
6869 [ALC293_FIXUP_DISABLE_AAMIX_MULTIJACK] = {
6870 .type = HDA_FIXUP_FUNC,
6871 .v.func = alc_fixup_disable_aamix,
6872 .chained = true,
6873 .chain_id = ALC293_FIXUP_DELL1_MIC_NO_PRESENCE
6874 },
6875 [ALC292_FIXUP_DELL_E7X_AAMIX] = {
6876 .type = HDA_FIXUP_FUNC,
6877 .v.func = alc_fixup_dell_xps13,
6878 .chained = true,
6879 .chain_id = ALC292_FIXUP_DISABLE_AAMIX
6880 },
6881 [ALC292_FIXUP_DELL_E7X] = {
6882 .type = HDA_FIXUP_FUNC,
6883 .v.func = alc_fixup_micmute_led,
6884
6885 .chained_before = true,
6886 .chain_id = ALC292_FIXUP_DELL_E7X_AAMIX,
6887 },
6888 [ALC298_FIXUP_ALIENWARE_MIC_NO_PRESENCE] = {
6889 .type = HDA_FIXUP_PINS,
6890 .v.pins = (const struct hda_pintbl[]) {
6891 { 0x18, 0x01a1913c },
6892 { }
6893 },
6894 .chained_before = true,
6895 .chain_id = ALC269_FIXUP_HEADSET_MODE,
6896 },
6897 [ALC298_FIXUP_DELL1_MIC_NO_PRESENCE] = {
6898 .type = HDA_FIXUP_PINS,
6899 .v.pins = (const struct hda_pintbl[]) {
6900 { 0x18, 0x01a1913c },
6901 { 0x1a, 0x01a1913d },
6902 { }
6903 },
6904 .chained = true,
6905 .chain_id = ALC269_FIXUP_HEADSET_MODE
6906 },
6907 [ALC298_FIXUP_DELL_AIO_MIC_NO_PRESENCE] = {
6908 .type = HDA_FIXUP_PINS,
6909 .v.pins = (const struct hda_pintbl[]) {
6910 { 0x18, 0x01a1913c },
6911 { }
6912 },
6913 .chained = true,
6914 .chain_id = ALC269_FIXUP_HEADSET_MODE
6915 },
6916 [ALC275_FIXUP_DELL_XPS] = {
6917 .type = HDA_FIXUP_VERBS,
6918 .v.verbs = (const struct hda_verb[]) {
6919
6920 {0x20, AC_VERB_SET_COEF_INDEX, 0x1f},
6921 {0x20, AC_VERB_SET_PROC_COEF, 0x00c0},
6922 {0x20, AC_VERB_SET_COEF_INDEX, 0x30},
6923 {0x20, AC_VERB_SET_PROC_COEF, 0x00b1},
6924 {}
6925 }
6926 },
6927 [ALC293_FIXUP_LENOVO_SPK_NOISE] = {
6928 .type = HDA_FIXUP_FUNC,
6929 .v.func = alc_fixup_disable_aamix,
6930 .chained = true,
6931 .chain_id = ALC269_FIXUP_THINKPAD_ACPI
6932 },
6933 [ALC233_FIXUP_LENOVO_LINE2_MIC_HOTKEY] = {
6934 .type = HDA_FIXUP_FUNC,
6935 .v.func = alc233_fixup_lenovo_line2_mic_hotkey,
6936 },
6937 [ALC255_FIXUP_DELL_SPK_NOISE] = {
6938 .type = HDA_FIXUP_FUNC,
6939 .v.func = alc_fixup_disable_aamix,
6940 .chained = true,
6941 .chain_id = ALC255_FIXUP_DELL1_MIC_NO_PRESENCE
6942 },
6943 [ALC225_FIXUP_DISABLE_MIC_VREF] = {
6944 .type = HDA_FIXUP_FUNC,
6945 .v.func = alc_fixup_disable_mic_vref,
6946 .chained = true,
6947 .chain_id = ALC269_FIXUP_DELL1_MIC_NO_PRESENCE
6948 },
6949 [ALC225_FIXUP_DELL1_MIC_NO_PRESENCE] = {
6950 .type = HDA_FIXUP_VERBS,
6951 .v.verbs = (const struct hda_verb[]) {
6952
6953 { 0x20, AC_VERB_SET_COEF_INDEX, 0x36 },
6954 { 0x20, AC_VERB_SET_PROC_COEF, 0x57d7 },
6955 {}
6956 },
6957 .chained = true,
6958 .chain_id = ALC225_FIXUP_DISABLE_MIC_VREF
6959 },
6960 [ALC280_FIXUP_HP_HEADSET_MIC] = {
6961 .type = HDA_FIXUP_FUNC,
6962 .v.func = alc_fixup_disable_aamix,
6963 .chained = true,
6964 .chain_id = ALC269_FIXUP_HEADSET_MIC,
6965 },
6966 [ALC221_FIXUP_HP_FRONT_MIC] = {
6967 .type = HDA_FIXUP_PINS,
6968 .v.pins = (const struct hda_pintbl[]) {
6969 { 0x19, 0x02a19020 },
6970 { }
6971 },
6972 },
6973 [ALC292_FIXUP_TPT460] = {
6974 .type = HDA_FIXUP_FUNC,
6975 .v.func = alc_fixup_tpt440_dock,
6976 .chained = true,
6977 .chain_id = ALC293_FIXUP_LENOVO_SPK_NOISE,
6978 },
6979 [ALC298_FIXUP_SPK_VOLUME] = {
6980 .type = HDA_FIXUP_FUNC,
6981 .v.func = alc298_fixup_speaker_volume,
6982 .chained = true,
6983 .chain_id = ALC298_FIXUP_DELL_AIO_MIC_NO_PRESENCE,
6984 },
6985 [ALC295_FIXUP_DISABLE_DAC3] = {
6986 .type = HDA_FIXUP_FUNC,
6987 .v.func = alc295_fixup_disable_dac3,
6988 },
6989 [ALC285_FIXUP_SPEAKER2_TO_DAC1] = {
6990 .type = HDA_FIXUP_FUNC,
6991 .v.func = alc285_fixup_speaker2_to_dac1,
6992 .chained = true,
6993 .chain_id = ALC269_FIXUP_THINKPAD_ACPI
6994 },
6995 [ALC256_FIXUP_DELL_INSPIRON_7559_SUBWOOFER] = {
6996 .type = HDA_FIXUP_PINS,
6997 .v.pins = (const struct hda_pintbl[]) {
6998 { 0x1b, 0x90170151 },
6999 { }
7000 },
7001 .chained = true,
7002 .chain_id = ALC255_FIXUP_DELL1_MIC_NO_PRESENCE
7003 },
7004 [ALC269_FIXUP_ATIV_BOOK_8] = {
7005 .type = HDA_FIXUP_FUNC,
7006 .v.func = alc_fixup_auto_mute_via_amp,
7007 .chained = true,
7008 .chain_id = ALC269_FIXUP_NO_SHUTUP
7009 },
7010 [ALC221_FIXUP_HP_MIC_NO_PRESENCE] = {
7011 .type = HDA_FIXUP_PINS,
7012 .v.pins = (const struct hda_pintbl[]) {
7013 { 0x18, 0x01a1913c },
7014 { 0x1a, 0x01a1913d },
7015 { }
7016 },
7017 .chained = true,
7018 .chain_id = ALC269_FIXUP_HEADSET_MODE
7019 },
7020 [ALC256_FIXUP_ASUS_HEADSET_MODE] = {
7021 .type = HDA_FIXUP_FUNC,
7022 .v.func = alc_fixup_headset_mode,
7023 },
7024 [ALC256_FIXUP_ASUS_MIC] = {
7025 .type = HDA_FIXUP_PINS,
7026 .v.pins = (const struct hda_pintbl[]) {
7027 { 0x13, 0x90a60160 },
7028 { 0x19, 0x04a11120 },
7029 { }
7030 },
7031 .chained = true,
7032 .chain_id = ALC256_FIXUP_ASUS_HEADSET_MODE
7033 },
7034 [ALC256_FIXUP_ASUS_AIO_GPIO2] = {
7035 .type = HDA_FIXUP_FUNC,
7036
7037 .v.func = alc_fixup_gpio4,
7038 },
7039 [ALC233_FIXUP_ASUS_MIC_NO_PRESENCE] = {
7040 .type = HDA_FIXUP_PINS,
7041 .v.pins = (const struct hda_pintbl[]) {
7042 { 0x19, 0x01a1913c },
7043 { }
7044 },
7045 .chained = true,
7046 .chain_id = ALC269_FIXUP_HEADSET_MIC
7047 },
7048 [ALC233_FIXUP_EAPD_COEF_AND_MIC_NO_PRESENCE] = {
7049 .type = HDA_FIXUP_VERBS,
7050 .v.verbs = (const struct hda_verb[]) {
7051
7052 {0x20, AC_VERB_SET_COEF_INDEX, 0x40},
7053 {0x20, AC_VERB_SET_PROC_COEF, 0x8800},
7054 {}
7055 },
7056 .chained = true,
7057 .chain_id = ALC233_FIXUP_ASUS_MIC_NO_PRESENCE
7058 },
7059 [ALC233_FIXUP_LENOVO_MULTI_CODECS] = {
7060 .type = HDA_FIXUP_FUNC,
7061 .v.func = alc233_alc662_fixup_lenovo_dual_codecs,
7062 .chained = true,
7063 .chain_id = ALC269_FIXUP_GPIO2
7064 },
7065 [ALC233_FIXUP_ACER_HEADSET_MIC] = {
7066 .type = HDA_FIXUP_VERBS,
7067 .v.verbs = (const struct hda_verb[]) {
7068 { 0x20, AC_VERB_SET_COEF_INDEX, 0x45 },
7069 { 0x20, AC_VERB_SET_PROC_COEF, 0x5089 },
7070 { }
7071 },
7072 .chained = true,
7073 .chain_id = ALC233_FIXUP_ASUS_MIC_NO_PRESENCE
7074 },
7075 [ALC294_FIXUP_LENOVO_MIC_LOCATION] = {
7076 .type = HDA_FIXUP_PINS,
7077 .v.pins = (const struct hda_pintbl[]) {
7078
7079
7080
7081
7082
7083 { 0x1a, 0x04a19040 },
7084 { }
7085 },
7086 },
7087 [ALC225_FIXUP_DELL_WYSE_MIC_NO_PRESENCE] = {
7088 .type = HDA_FIXUP_PINS,
7089 .v.pins = (const struct hda_pintbl[]) {
7090 { 0x16, 0x0101102f },
7091 { 0x19, 0x02a1913c },
7092 { 0x1a, 0x01a19030 },
7093 { 0x1b, 0x02011020 },
7094 { }
7095 },
7096 .chained = true,
7097 .chain_id = ALC225_FIXUP_S3_POP_NOISE
7098 },
7099 [ALC225_FIXUP_S3_POP_NOISE] = {
7100 .type = HDA_FIXUP_FUNC,
7101 .v.func = alc225_fixup_s3_pop_noise,
7102 .chained = true,
7103 .chain_id = ALC269_FIXUP_HEADSET_MODE_NO_HP_MIC
7104 },
7105 [ALC700_FIXUP_INTEL_REFERENCE] = {
7106 .type = HDA_FIXUP_VERBS,
7107 .v.verbs = (const struct hda_verb[]) {
7108
7109 {0x20, AC_VERB_SET_COEF_INDEX, 0x45},
7110 {0x20, AC_VERB_SET_PROC_COEF, 0x5289},
7111 {0x20, AC_VERB_SET_COEF_INDEX, 0x4A},
7112 {0x20, AC_VERB_SET_PROC_COEF, 0x001b},
7113 {0x58, AC_VERB_SET_COEF_INDEX, 0x00},
7114 {0x58, AC_VERB_SET_PROC_COEF, 0x3888},
7115 {0x20, AC_VERB_SET_COEF_INDEX, 0x6f},
7116 {0x20, AC_VERB_SET_PROC_COEF, 0x2c0b},
7117 {}
7118 }
7119 },
7120 [ALC274_FIXUP_DELL_BIND_DACS] = {
7121 .type = HDA_FIXUP_FUNC,
7122 .v.func = alc274_fixup_bind_dacs,
7123 .chained = true,
7124 .chain_id = ALC269_FIXUP_DELL1_MIC_NO_PRESENCE
7125 },
7126 [ALC274_FIXUP_DELL_AIO_LINEOUT_VERB] = {
7127 .type = HDA_FIXUP_PINS,
7128 .v.pins = (const struct hda_pintbl[]) {
7129 { 0x1b, 0x0401102f },
7130 { }
7131 },
7132 .chained = true,
7133 .chain_id = ALC274_FIXUP_DELL_BIND_DACS
7134 },
7135 [ALC298_FIXUP_TPT470_DOCK_FIX] = {
7136 .type = HDA_FIXUP_FUNC,
7137 .v.func = alc_fixup_tpt470_dock,
7138 .chained = true,
7139 .chain_id = ALC293_FIXUP_LENOVO_SPK_NOISE
7140 },
7141 [ALC298_FIXUP_TPT470_DOCK] = {
7142 .type = HDA_FIXUP_FUNC,
7143 .v.func = alc_fixup_tpt470_dacs,
7144 .chained = true,
7145 .chain_id = ALC298_FIXUP_TPT470_DOCK_FIX
7146 },
7147 [ALC255_FIXUP_DUMMY_LINEOUT_VERB] = {
7148 .type = HDA_FIXUP_PINS,
7149 .v.pins = (const struct hda_pintbl[]) {
7150 { 0x14, 0x0201101f },
7151 { }
7152 },
7153 .chained = true,
7154 .chain_id = ALC255_FIXUP_DELL1_MIC_NO_PRESENCE
7155 },
7156 [ALC255_FIXUP_DELL_HEADSET_MIC] = {
7157 .type = HDA_FIXUP_PINS,
7158 .v.pins = (const struct hda_pintbl[]) {
7159 { 0x19, 0x01a1913c },
7160 { }
7161 },
7162 .chained = true,
7163 .chain_id = ALC269_FIXUP_HEADSET_MIC
7164 },
7165 [ALC295_FIXUP_HP_X360] = {
7166 .type = HDA_FIXUP_FUNC,
7167 .v.func = alc295_fixup_hp_top_speakers,
7168 .chained = true,
7169 .chain_id = ALC269_FIXUP_HP_MUTE_LED_MIC3
7170 },
7171 [ALC221_FIXUP_HP_HEADSET_MIC] = {
7172 .type = HDA_FIXUP_PINS,
7173 .v.pins = (const struct hda_pintbl[]) {
7174 { 0x19, 0x0181313f},
7175 { }
7176 },
7177 .chained = true,
7178 .chain_id = ALC269_FIXUP_HEADSET_MIC
7179 },
7180 [ALC285_FIXUP_LENOVO_HEADPHONE_NOISE] = {
7181 .type = HDA_FIXUP_FUNC,
7182 .v.func = alc285_fixup_invalidate_dacs,
7183 .chained = true,
7184 .chain_id = ALC269_FIXUP_THINKPAD_ACPI
7185 },
7186 [ALC295_FIXUP_HP_AUTO_MUTE] = {
7187 .type = HDA_FIXUP_FUNC,
7188 .v.func = alc_fixup_auto_mute_via_amp,
7189 },
7190 [ALC286_FIXUP_ACER_AIO_MIC_NO_PRESENCE] = {
7191 .type = HDA_FIXUP_PINS,
7192 .v.pins = (const struct hda_pintbl[]) {
7193 { 0x18, 0x01a1913c },
7194 { }
7195 },
7196 .chained = true,
7197 .chain_id = ALC269_FIXUP_HEADSET_MIC
7198 },
7199 [ALC294_FIXUP_ASUS_MIC] = {
7200 .type = HDA_FIXUP_PINS,
7201 .v.pins = (const struct hda_pintbl[]) {
7202 { 0x13, 0x90a60160 },
7203 { 0x19, 0x04a11120 },
7204 { }
7205 },
7206 .chained = true,
7207 .chain_id = ALC269_FIXUP_HEADSET_MIC
7208 },
7209 [ALC294_FIXUP_ASUS_HEADSET_MIC] = {
7210 .type = HDA_FIXUP_PINS,
7211 .v.pins = (const struct hda_pintbl[]) {
7212 { 0x19, 0x01a1103c },
7213 { }
7214 },
7215 .chained = true,
7216 .chain_id = ALC269_FIXUP_HEADSET_MIC
7217 },
7218 [ALC294_FIXUP_ASUS_SPK] = {
7219 .type = HDA_FIXUP_VERBS,
7220 .v.verbs = (const struct hda_verb[]) {
7221
7222 { 0x20, AC_VERB_SET_COEF_INDEX, 0x40 },
7223 { 0x20, AC_VERB_SET_PROC_COEF, 0x8800 },
7224 { 0x20, AC_VERB_SET_COEF_INDEX, 0x0f },
7225 { 0x20, AC_VERB_SET_PROC_COEF, 0x7774 },
7226 { }
7227 },
7228 .chained = true,
7229 .chain_id = ALC294_FIXUP_ASUS_HEADSET_MIC
7230 },
7231 [ALC295_FIXUP_CHROME_BOOK] = {
7232 .type = HDA_FIXUP_FUNC,
7233 .v.func = alc295_fixup_chromebook,
7234 .chained = true,
7235 .chain_id = ALC225_FIXUP_HEADSET_JACK
7236 },
7237 [ALC225_FIXUP_HEADSET_JACK] = {
7238 .type = HDA_FIXUP_FUNC,
7239 .v.func = alc_fixup_headset_jack,
7240 },
7241 [ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE] = {
7242 .type = HDA_FIXUP_PINS,
7243 .v.pins = (const struct hda_pintbl[]) {
7244 { 0x1a, 0x01a1913c },
7245 { }
7246 },
7247 .chained = true,
7248 .chain_id = ALC269_FIXUP_HEADSET_MODE_NO_HP_MIC
7249 },
7250 [ALC285_FIXUP_LENOVO_PC_BEEP_IN_NOISE] = {
7251 .type = HDA_FIXUP_VERBS,
7252 .v.verbs = (const struct hda_verb[]) {
7253
7254 { 0x20, AC_VERB_SET_COEF_INDEX, 0x36 },
7255 { 0x20, AC_VERB_SET_PROC_COEF, 0x57d7 },
7256 { }
7257 },
7258 .chained = true,
7259 .chain_id = ALC285_FIXUP_LENOVO_HEADPHONE_NOISE
7260 },
7261 [ALC255_FIXUP_ACER_HEADSET_MIC] = {
7262 .type = HDA_FIXUP_PINS,
7263 .v.pins = (const struct hda_pintbl[]) {
7264 { 0x19, 0x03a11130 },
7265 { 0x1a, 0x90a60140 },
7266 { }
7267 },
7268 .chained = true,
7269 .chain_id = ALC255_FIXUP_HEADSET_MODE_NO_HP_MIC
7270 },
7271 [ALC225_FIXUP_DELL_WYSE_AIO_MIC_NO_PRESENCE] = {
7272 .type = HDA_FIXUP_PINS,
7273 .v.pins = (const struct hda_pintbl[]) {
7274 { 0x16, 0x01011020 },
7275 { 0x19, 0x01a1913c },
7276 { }
7277 },
7278 .chained = true,
7279 .chain_id = ALC225_FIXUP_WYSE_AUTO_MUTE
7280 },
7281 [ALC225_FIXUP_WYSE_AUTO_MUTE] = {
7282 .type = HDA_FIXUP_FUNC,
7283 .v.func = alc_fixup_auto_mute_via_amp,
7284 .chained = true,
7285 .chain_id = ALC225_FIXUP_WYSE_DISABLE_MIC_VREF
7286 },
7287 [ALC225_FIXUP_WYSE_DISABLE_MIC_VREF] = {
7288 .type = HDA_FIXUP_FUNC,
7289 .v.func = alc_fixup_disable_mic_vref,
7290 .chained = true,
7291 .chain_id = ALC269_FIXUP_HEADSET_MODE_NO_HP_MIC
7292 },
7293 [ALC286_FIXUP_ACER_AIO_HEADSET_MIC] = {
7294 .type = HDA_FIXUP_VERBS,
7295 .v.verbs = (const struct hda_verb[]) {
7296 { 0x20, AC_VERB_SET_COEF_INDEX, 0x4f },
7297 { 0x20, AC_VERB_SET_PROC_COEF, 0x5029 },
7298 { }
7299 },
7300 .chained = true,
7301 .chain_id = ALC286_FIXUP_ACER_AIO_MIC_NO_PRESENCE
7302 },
7303 [ALC256_FIXUP_ASUS_HEADSET_MIC] = {
7304 .type = HDA_FIXUP_PINS,
7305 .v.pins = (const struct hda_pintbl[]) {
7306 { 0x19, 0x03a11020 },
7307 { }
7308 },
7309 .chained = true,
7310 .chain_id = ALC256_FIXUP_ASUS_HEADSET_MODE
7311 },
7312 [ALC256_FIXUP_ASUS_MIC_NO_PRESENCE] = {
7313 .type = HDA_FIXUP_PINS,
7314 .v.pins = (const struct hda_pintbl[]) {
7315 { 0x19, 0x04a11120 },
7316 { }
7317 },
7318 .chained = true,
7319 .chain_id = ALC256_FIXUP_ASUS_HEADSET_MODE
7320 },
7321 [ALC299_FIXUP_PREDATOR_SPK] = {
7322 .type = HDA_FIXUP_PINS,
7323 .v.pins = (const struct hda_pintbl[]) {
7324 { 0x21, 0x90170150 },
7325 { }
7326 }
7327 },
7328 [ALC256_FIXUP_MEDION_HEADSET_NO_PRESENCE] = {
7329 .type = HDA_FIXUP_PINS,
7330 .v.pins = (const struct hda_pintbl[]) {
7331 { 0x19, 0x04a11040 },
7332 { 0x21, 0x04211020 },
7333 { }
7334 },
7335 .chained = true,
7336 .chain_id = ALC256_FIXUP_ASUS_HEADSET_MODE
7337 },
7338 [ALC289_FIXUP_DELL_SPK2] = {
7339 .type = HDA_FIXUP_PINS,
7340 .v.pins = (const struct hda_pintbl[]) {
7341 { 0x17, 0x90170130 },
7342 { }
7343 },
7344 .chained = true,
7345 .chain_id = ALC269_FIXUP_DELL4_MIC_NO_PRESENCE
7346 },
7347 [ALC289_FIXUP_DUAL_SPK] = {
7348 .type = HDA_FIXUP_FUNC,
7349 .v.func = alc285_fixup_speaker2_to_dac1,
7350 .chained = true,
7351 .chain_id = ALC289_FIXUP_DELL_SPK2
7352 },
7353 [ALC294_FIXUP_SPK2_TO_DAC1] = {
7354 .type = HDA_FIXUP_FUNC,
7355 .v.func = alc285_fixup_speaker2_to_dac1,
7356 .chained = true,
7357 .chain_id = ALC294_FIXUP_ASUS_HEADSET_MIC
7358 },
7359 [ALC294_FIXUP_ASUS_DUAL_SPK] = {
7360 .type = HDA_FIXUP_FUNC,
7361
7362 .v.func = alc_fixup_gpio4,
7363 .chained = true,
7364 .chain_id = ALC294_FIXUP_SPK2_TO_DAC1
7365 },
7366 [ALC285_FIXUP_THINKPAD_X1_GEN7] = {
7367 .type = HDA_FIXUP_FUNC,
7368 .v.func = alc285_fixup_thinkpad_x1_gen7,
7369 .chained = true,
7370 .chain_id = ALC269_FIXUP_THINKPAD_ACPI
7371 },
7372 [ALC285_FIXUP_THINKPAD_HEADSET_JACK] = {
7373 .type = HDA_FIXUP_FUNC,
7374 .v.func = alc_fixup_headset_jack,
7375 .chained = true,
7376 .chain_id = ALC285_FIXUP_THINKPAD_X1_GEN7
7377 },
7378 [ALC294_FIXUP_ASUS_HPE] = {
7379 .type = HDA_FIXUP_VERBS,
7380 .v.verbs = (const struct hda_verb[]) {
7381
7382 { 0x20, AC_VERB_SET_COEF_INDEX, 0x0f },
7383 { 0x20, AC_VERB_SET_PROC_COEF, 0x7774 },
7384 { }
7385 },
7386 .chained = true,
7387 .chain_id = ALC294_FIXUP_ASUS_HEADSET_MIC
7388 },
7389 [ALC294_FIXUP_ASUS_GX502_PINS] = {
7390 .type = HDA_FIXUP_PINS,
7391 .v.pins = (const struct hda_pintbl[]) {
7392 { 0x19, 0x03a11050 },
7393 { 0x1a, 0x01a11830 },
7394 { 0x21, 0x03211020 },
7395 { }
7396 },
7397 .chained = true,
7398 .chain_id = ALC294_FIXUP_ASUS_GX502_VERBS
7399 },
7400 [ALC294_FIXUP_ASUS_GX502_VERBS] = {
7401 .type = HDA_FIXUP_VERBS,
7402 .v.verbs = (const struct hda_verb[]) {
7403
7404 { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0 },
7405
7406 { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000 },
7407 { }
7408 },
7409 .chained = true,
7410 .chain_id = ALC294_FIXUP_ASUS_GX502_HP
7411 },
7412 [ALC294_FIXUP_ASUS_GX502_HP] = {
7413 .type = HDA_FIXUP_FUNC,
7414 .v.func = alc294_fixup_gx502_hp,
7415 },
7416 [ALC294_FIXUP_ASUS_COEF_1B] = {
7417 .type = HDA_FIXUP_VERBS,
7418 .v.verbs = (const struct hda_verb[]) {
7419
7420
7421
7422 { 0x20, AC_VERB_SET_COEF_INDEX, 0x1b },
7423 { 0x20, AC_VERB_SET_PROC_COEF, 0x4e4b },
7424 { }
7425 },
7426 },
7427 [ALC285_FIXUP_HP_GPIO_LED] = {
7428 .type = HDA_FIXUP_FUNC,
7429 .v.func = alc285_fixup_hp_gpio_led,
7430 },
7431 [ALC285_FIXUP_HP_MUTE_LED] = {
7432 .type = HDA_FIXUP_FUNC,
7433 .v.func = alc285_fixup_hp_mute_led,
7434 },
7435 [ALC236_FIXUP_HP_MUTE_LED] = {
7436 .type = HDA_FIXUP_FUNC,
7437 .v.func = alc236_fixup_hp_mute_led,
7438 },
7439 [ALC298_FIXUP_SAMSUNG_HEADPHONE_VERY_QUIET] = {
7440 .type = HDA_FIXUP_VERBS,
7441 .v.verbs = (const struct hda_verb[]) {
7442 { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc5 },
7443 { }
7444 },
7445 },
7446 [ALC295_FIXUP_ASUS_MIC_NO_PRESENCE] = {
7447 .type = HDA_FIXUP_PINS,
7448 .v.pins = (const struct hda_pintbl[]) {
7449 { 0x19, 0x01a1913c },
7450 { }
7451 },
7452 .chained = true,
7453 .chain_id = ALC269_FIXUP_HEADSET_MODE
7454 },
7455 [ALC269VC_FIXUP_ACER_VCOPPERBOX_PINS] = {
7456 .type = HDA_FIXUP_PINS,
7457 .v.pins = (const struct hda_pintbl[]) {
7458 { 0x14, 0x90100120 },
7459 { 0x18, 0x02a111f0 },
7460 { 0x1a, 0x01011020 },
7461 { },
7462 },
7463 .chained = true,
7464 .chain_id = ALC269_FIXUP_HEADSET_MIC
7465 },
7466 [ALC269VC_FIXUP_ACER_HEADSET_MIC] = {
7467 .type = HDA_FIXUP_PINS,
7468 .v.pins = (const struct hda_pintbl[]) {
7469 { 0x18, 0x02a11030 },
7470 { }
7471 },
7472 .chained = true,
7473 .chain_id = ALC269_FIXUP_HEADSET_MIC
7474 },
7475 [ALC269VC_FIXUP_ACER_MIC_NO_PRESENCE] = {
7476 .type = HDA_FIXUP_PINS,
7477 .v.pins = (const struct hda_pintbl[]) {
7478 { 0x18, 0x01a11130 },
7479 { }
7480 },
7481 .chained = true,
7482 .chain_id = ALC269_FIXUP_HEADSET_MIC
7483 },
7484 [ALC289_FIXUP_ASUS_GA401] = {
7485 .type = HDA_FIXUP_PINS,
7486 .v.pins = (const struct hda_pintbl[]) {
7487 { 0x19, 0x03a11020 },
7488 { }
7489 },
7490 },
7491 [ALC289_FIXUP_ASUS_GA502] = {
7492 .type = HDA_FIXUP_PINS,
7493 .v.pins = (const struct hda_pintbl[]) {
7494 { 0x19, 0x03a11020 },
7495 { }
7496 },
7497 },
7498 [ALC256_FIXUP_ACER_MIC_NO_PRESENCE] = {
7499 .type = HDA_FIXUP_PINS,
7500 .v.pins = (const struct hda_pintbl[]) {
7501 { 0x19, 0x02a11120 },
7502 { }
7503 },
7504 .chained = true,
7505 .chain_id = ALC256_FIXUP_ASUS_HEADSET_MODE
7506 },
7507 [ALC285_FIXUP_HP_GPIO_AMP_INIT] = {
7508 .type = HDA_FIXUP_FUNC,
7509 .v.func = alc285_fixup_hp_gpio_amp_init,
7510 .chained = true,
7511 .chain_id = ALC285_FIXUP_HP_GPIO_LED
7512 },
7513 [ALC269_FIXUP_CZC_B20] = {
7514 .type = HDA_FIXUP_PINS,
7515 .v.pins = (const struct hda_pintbl[]) {
7516 { 0x12, 0x411111f0 },
7517 { 0x14, 0x90170110 },
7518 { 0x15, 0x032f1020 },
7519 { 0x17, 0x411111f0 },
7520 { 0x18, 0x03ab1040 },
7521 { 0x19, 0xb7a7013f },
7522 { 0x1a, 0x0181305f },
7523 { 0x1b, 0x411111f0 },
7524 { 0x1d, 0x411111f0 },
7525 { 0x1e, 0x411111f0 },
7526 { }
7527 },
7528 .chain_id = ALC269_FIXUP_DMIC,
7529 },
7530 [ALC269_FIXUP_CZC_TMI] = {
7531 .type = HDA_FIXUP_PINS,
7532 .v.pins = (const struct hda_pintbl[]) {
7533 { 0x12, 0x4000c000 },
7534 { 0x14, 0x90170110 },
7535 { 0x15, 0x0421401f },
7536 { 0x17, 0x411111f0 },
7537 { 0x18, 0x04a19020 },
7538 { 0x19, 0x411111f0 },
7539 { 0x1a, 0x411111f0 },
7540 { 0x1b, 0x411111f0 },
7541 { 0x1d, 0x40448505 },
7542 { 0x1e, 0x411111f0 },
7543 { 0x20, 0x8000ffff },
7544 { }
7545 },
7546 .chain_id = ALC269_FIXUP_DMIC,
7547 },
7548 [ALC269_FIXUP_CZC_L101] = {
7549 .type = HDA_FIXUP_PINS,
7550 .v.pins = (const struct hda_pintbl[]) {
7551 { 0x12, 0x40000000 },
7552 { 0x14, 0x01014010 },
7553 { 0x15, 0x411111f0 },
7554 { 0x16, 0x411111f0 },
7555 { 0x18, 0x01a19020 },
7556 { 0x19, 0x02a19021 },
7557 { 0x1a, 0x0181302f },
7558 { 0x1b, 0x0221401f },
7559 { 0x1c, 0x411111f0 },
7560 { 0x1d, 0x4044c601 },
7561 { 0x1e, 0x411111f0 },
7562 { }
7563 },
7564 .chain_id = ALC269_FIXUP_DMIC,
7565 },
7566 [ALC269_FIXUP_LEMOTE_A1802] = {
7567 .type = HDA_FIXUP_PINS,
7568 .v.pins = (const struct hda_pintbl[]) {
7569 { 0x12, 0x40000000 },
7570 { 0x14, 0x90170110 },
7571 { 0x17, 0x411111f0 },
7572 { 0x18, 0x03a19040 },
7573 { 0x19, 0x90a70130 },
7574 { 0x1a, 0x411111f0 },
7575 { 0x1b, 0x411111f0 },
7576 { 0x1d, 0x40489d2d },
7577 { 0x1e, 0x411111f0 },
7578 { 0x20, 0x0003ffff },
7579 { 0x21, 0x03214020 },
7580 { }
7581 },
7582 .chain_id = ALC269_FIXUP_DMIC,
7583 },
7584 [ALC269_FIXUP_LEMOTE_A190X] = {
7585 .type = HDA_FIXUP_PINS,
7586 .v.pins = (const struct hda_pintbl[]) {
7587 { 0x14, 0x99130110 },
7588 { 0x15, 0x0121401f },
7589 { 0x18, 0x01a19c20 },
7590 { 0x19, 0x99a3092f },
7591 { 0x1b, 0x0201401f },
7592 { }
7593 },
7594 .chain_id = ALC269_FIXUP_DMIC,
7595 },
7596 [ALC256_FIXUP_INTEL_NUC8_RUGGED] = {
7597 .type = HDA_FIXUP_PINS,
7598 .v.pins = (const struct hda_pintbl[]) {
7599 { 0x1b, 0x01a1913c },
7600 { }
7601 },
7602 .chained = true,
7603 .chain_id = ALC269_FIXUP_HEADSET_MODE
7604 },
7605 [ALC255_FIXUP_XIAOMI_HEADSET_MIC] = {
7606 .type = HDA_FIXUP_VERBS,
7607 .v.verbs = (const struct hda_verb[]) {
7608 { 0x20, AC_VERB_SET_COEF_INDEX, 0x45 },
7609 { 0x20, AC_VERB_SET_PROC_COEF, 0x5089 },
7610 { }
7611 },
7612 .chained = true,
7613 .chain_id = ALC289_FIXUP_ASUS_GA401
7614 },
7615};
7616
7617static const struct snd_pci_quirk alc269_fixup_tbl[] = {
7618 SND_PCI_QUIRK(0x1025, 0x0283, "Acer TravelMate 8371", ALC269_FIXUP_INV_DMIC),
7619 SND_PCI_QUIRK(0x1025, 0x029b, "Acer 1810TZ", ALC269_FIXUP_INV_DMIC),
7620 SND_PCI_QUIRK(0x1025, 0x0349, "Acer AOD260", ALC269_FIXUP_INV_DMIC),
7621 SND_PCI_QUIRK(0x1025, 0x047c, "Acer AC700", ALC269_FIXUP_ACER_AC700),
7622 SND_PCI_QUIRK(0x1025, 0x072d, "Acer Aspire V5-571G", ALC269_FIXUP_ASPIRE_HEADSET_MIC),
7623 SND_PCI_QUIRK(0x1025, 0x080d, "Acer Aspire V5-122P", ALC269_FIXUP_ASPIRE_HEADSET_MIC),
7624 SND_PCI_QUIRK(0x1025, 0x0740, "Acer AO725", ALC271_FIXUP_HP_GATE_MIC_JACK),
7625 SND_PCI_QUIRK(0x1025, 0x0742, "Acer AO756", ALC271_FIXUP_HP_GATE_MIC_JACK),
7626 SND_PCI_QUIRK(0x1025, 0x0762, "Acer Aspire E1-472", ALC271_FIXUP_HP_GATE_MIC_JACK_E1_572),
7627 SND_PCI_QUIRK(0x1025, 0x0775, "Acer Aspire E1-572", ALC271_FIXUP_HP_GATE_MIC_JACK_E1_572),
7628 SND_PCI_QUIRK(0x1025, 0x079b, "Acer Aspire V5-573G", ALC282_FIXUP_ASPIRE_V5_PINS),
7629 SND_PCI_QUIRK(0x1025, 0x102b, "Acer Aspire C24-860", ALC286_FIXUP_ACER_AIO_MIC_NO_PRESENCE),
7630 SND_PCI_QUIRK(0x1025, 0x1065, "Acer Aspire C20-820", ALC269VC_FIXUP_ACER_HEADSET_MIC),
7631 SND_PCI_QUIRK(0x1025, 0x106d, "Acer Cloudbook 14", ALC283_FIXUP_CHROME_BOOK),
7632 SND_PCI_QUIRK(0x1025, 0x1099, "Acer Aspire E5-523G", ALC255_FIXUP_ACER_MIC_NO_PRESENCE),
7633 SND_PCI_QUIRK(0x1025, 0x110e, "Acer Aspire ES1-432", ALC255_FIXUP_ACER_MIC_NO_PRESENCE),
7634 SND_PCI_QUIRK(0x1025, 0x1246, "Acer Predator Helios 500", ALC299_FIXUP_PREDATOR_SPK),
7635 SND_PCI_QUIRK(0x1025, 0x1247, "Acer vCopperbox", ALC269VC_FIXUP_ACER_VCOPPERBOX_PINS),
7636 SND_PCI_QUIRK(0x1025, 0x1248, "Acer Veriton N4660G", ALC269VC_FIXUP_ACER_MIC_NO_PRESENCE),
7637 SND_PCI_QUIRK(0x1025, 0x128f, "Acer Veriton Z6860G", ALC286_FIXUP_ACER_AIO_HEADSET_MIC),
7638 SND_PCI_QUIRK(0x1025, 0x1290, "Acer Veriton Z4860G", ALC286_FIXUP_ACER_AIO_HEADSET_MIC),
7639 SND_PCI_QUIRK(0x1025, 0x1291, "Acer Veriton Z4660G", ALC286_FIXUP_ACER_AIO_HEADSET_MIC),
7640 SND_PCI_QUIRK(0x1025, 0x1308, "Acer Aspire Z24-890", ALC286_FIXUP_ACER_AIO_HEADSET_MIC),
7641 SND_PCI_QUIRK(0x1025, 0x132a, "Acer TravelMate B114-21", ALC233_FIXUP_ACER_HEADSET_MIC),
7642 SND_PCI_QUIRK(0x1025, 0x1330, "Acer TravelMate X514-51T", ALC255_FIXUP_ACER_HEADSET_MIC),
7643 SND_PCI_QUIRK(0x1025, 0x1430, "Acer TravelMate B311R-31", ALC256_FIXUP_ACER_MIC_NO_PRESENCE),
7644 SND_PCI_QUIRK(0x1028, 0x0470, "Dell M101z", ALC269_FIXUP_DELL_M101Z),
7645 SND_PCI_QUIRK(0x1028, 0x054b, "Dell XPS one 2710", ALC275_FIXUP_DELL_XPS),
7646 SND_PCI_QUIRK(0x1028, 0x05bd, "Dell Latitude E6440", ALC292_FIXUP_DELL_E7X),
7647 SND_PCI_QUIRK(0x1028, 0x05be, "Dell Latitude E6540", ALC292_FIXUP_DELL_E7X),
7648 SND_PCI_QUIRK(0x1028, 0x05ca, "Dell Latitude E7240", ALC292_FIXUP_DELL_E7X),
7649 SND_PCI_QUIRK(0x1028, 0x05cb, "Dell Latitude E7440", ALC292_FIXUP_DELL_E7X),
7650 SND_PCI_QUIRK(0x1028, 0x05da, "Dell Vostro 5460", ALC290_FIXUP_SUBWOOFER),
7651 SND_PCI_QUIRK(0x1028, 0x05f4, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE),
7652 SND_PCI_QUIRK(0x1028, 0x05f5, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE),
7653 SND_PCI_QUIRK(0x1028, 0x05f6, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE),
7654 SND_PCI_QUIRK(0x1028, 0x0615, "Dell Vostro 5470", ALC290_FIXUP_SUBWOOFER_HSJACK),
7655 SND_PCI_QUIRK(0x1028, 0x0616, "Dell Vostro 5470", ALC290_FIXUP_SUBWOOFER_HSJACK),
7656 SND_PCI_QUIRK(0x1028, 0x062c, "Dell Latitude E5550", ALC292_FIXUP_DELL_E7X),
7657 SND_PCI_QUIRK(0x1028, 0x062e, "Dell Latitude E7450", ALC292_FIXUP_DELL_E7X),
7658 SND_PCI_QUIRK(0x1028, 0x0638, "Dell Inspiron 5439", ALC290_FIXUP_MONO_SPEAKERS_HSJACK),
7659 SND_PCI_QUIRK(0x1028, 0x064a, "Dell", ALC293_FIXUP_DELL1_MIC_NO_PRESENCE),
7660 SND_PCI_QUIRK(0x1028, 0x064b, "Dell", ALC293_FIXUP_DELL1_MIC_NO_PRESENCE),
7661 SND_PCI_QUIRK(0x1028, 0x0665, "Dell XPS 13", ALC288_FIXUP_DELL_XPS_13),
7662 SND_PCI_QUIRK(0x1028, 0x0669, "Dell Optiplex 9020m", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE),
7663 SND_PCI_QUIRK(0x1028, 0x069a, "Dell Vostro 5480", ALC290_FIXUP_SUBWOOFER_HSJACK),
7664 SND_PCI_QUIRK(0x1028, 0x06c7, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE),
7665 SND_PCI_QUIRK(0x1028, 0x06d9, "Dell", ALC293_FIXUP_DELL1_MIC_NO_PRESENCE),
7666 SND_PCI_QUIRK(0x1028, 0x06da, "Dell", ALC293_FIXUP_DELL1_MIC_NO_PRESENCE),
7667 SND_PCI_QUIRK(0x1028, 0x06db, "Dell", ALC293_FIXUP_DISABLE_AAMIX_MULTIJACK),
7668 SND_PCI_QUIRK(0x1028, 0x06dd, "Dell", ALC293_FIXUP_DISABLE_AAMIX_MULTIJACK),
7669 SND_PCI_QUIRK(0x1028, 0x06de, "Dell", ALC293_FIXUP_DISABLE_AAMIX_MULTIJACK),
7670 SND_PCI_QUIRK(0x1028, 0x06df, "Dell", ALC293_FIXUP_DISABLE_AAMIX_MULTIJACK),
7671 SND_PCI_QUIRK(0x1028, 0x06e0, "Dell", ALC293_FIXUP_DISABLE_AAMIX_MULTIJACK),
7672 SND_PCI_QUIRK(0x1028, 0x0706, "Dell Inspiron 7559", ALC256_FIXUP_DELL_INSPIRON_7559_SUBWOOFER),
7673 SND_PCI_QUIRK(0x1028, 0x0725, "Dell Inspiron 3162", ALC255_FIXUP_DELL_SPK_NOISE),
7674 SND_PCI_QUIRK(0x1028, 0x0738, "Dell Precision 5820", ALC269_FIXUP_NO_SHUTUP),
7675 SND_PCI_QUIRK(0x1028, 0x075c, "Dell XPS 27 7760", ALC298_FIXUP_SPK_VOLUME),
7676 SND_PCI_QUIRK(0x1028, 0x075d, "Dell AIO", ALC298_FIXUP_SPK_VOLUME),
7677 SND_PCI_QUIRK(0x1028, 0x07b0, "Dell Precision 7520", ALC295_FIXUP_DISABLE_DAC3),
7678 SND_PCI_QUIRK(0x1028, 0x0798, "Dell Inspiron 17 7000 Gaming", ALC256_FIXUP_DELL_INSPIRON_7559_SUBWOOFER),
7679 SND_PCI_QUIRK(0x1028, 0x080c, "Dell WYSE", ALC225_FIXUP_DELL_WYSE_MIC_NO_PRESENCE),
7680 SND_PCI_QUIRK(0x1028, 0x084b, "Dell", ALC274_FIXUP_DELL_AIO_LINEOUT_VERB),
7681 SND_PCI_QUIRK(0x1028, 0x084e, "Dell", ALC274_FIXUP_DELL_AIO_LINEOUT_VERB),
7682 SND_PCI_QUIRK(0x1028, 0x0871, "Dell Precision 3630", ALC255_FIXUP_DELL_HEADSET_MIC),
7683 SND_PCI_QUIRK(0x1028, 0x0872, "Dell Precision 3630", ALC255_FIXUP_DELL_HEADSET_MIC),
7684 SND_PCI_QUIRK(0x1028, 0x0873, "Dell Precision 3930", ALC255_FIXUP_DUMMY_LINEOUT_VERB),
7685 SND_PCI_QUIRK(0x1028, 0x08ad, "Dell WYSE AIO", ALC225_FIXUP_DELL_WYSE_AIO_MIC_NO_PRESENCE),
7686 SND_PCI_QUIRK(0x1028, 0x08ae, "Dell WYSE NB", ALC225_FIXUP_DELL1_MIC_NO_PRESENCE),
7687 SND_PCI_QUIRK(0x1028, 0x0935, "Dell", ALC274_FIXUP_DELL_AIO_LINEOUT_VERB),
7688 SND_PCI_QUIRK(0x1028, 0x097e, "Dell Precision", ALC289_FIXUP_DUAL_SPK),
7689 SND_PCI_QUIRK(0x1028, 0x097d, "Dell Precision", ALC289_FIXUP_DUAL_SPK),
7690 SND_PCI_QUIRK(0x1028, 0x098d, "Dell Precision", ALC233_FIXUP_ASUS_MIC_NO_PRESENCE),
7691 SND_PCI_QUIRK(0x1028, 0x09bf, "Dell Precision", ALC233_FIXUP_ASUS_MIC_NO_PRESENCE),
7692 SND_PCI_QUIRK(0x1028, 0x164a, "Dell", ALC293_FIXUP_DELL1_MIC_NO_PRESENCE),
7693 SND_PCI_QUIRK(0x1028, 0x164b, "Dell", ALC293_FIXUP_DELL1_MIC_NO_PRESENCE),
7694 SND_PCI_QUIRK(0x103c, 0x1586, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC2),
7695 SND_PCI_QUIRK(0x103c, 0x18e6, "HP", ALC269_FIXUP_HP_GPIO_LED),
7696 SND_PCI_QUIRK(0x103c, 0x218b, "HP", ALC269_FIXUP_LIMIT_INT_MIC_BOOST_MUTE_LED),
7697 SND_PCI_QUIRK(0x103c, 0x225f, "HP", ALC280_FIXUP_HP_GPIO2_MIC_HOTKEY),
7698
7699 SND_PCI_QUIRK(0x103c, 0x21f9, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
7700 SND_PCI_QUIRK(0x103c, 0x2210, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
7701 SND_PCI_QUIRK(0x103c, 0x2214, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
7702 SND_PCI_QUIRK(0x103c, 0x2236, "HP", ALC269_FIXUP_HP_LINE1_MIC1_LED),
7703 SND_PCI_QUIRK(0x103c, 0x2237, "HP", ALC269_FIXUP_HP_LINE1_MIC1_LED),
7704 SND_PCI_QUIRK(0x103c, 0x2238, "HP", ALC269_FIXUP_HP_LINE1_MIC1_LED),
7705 SND_PCI_QUIRK(0x103c, 0x2239, "HP", ALC269_FIXUP_HP_LINE1_MIC1_LED),
7706 SND_PCI_QUIRK(0x103c, 0x224b, "HP", ALC269_FIXUP_HP_LINE1_MIC1_LED),
7707 SND_PCI_QUIRK(0x103c, 0x2268, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
7708 SND_PCI_QUIRK(0x103c, 0x226a, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
7709 SND_PCI_QUIRK(0x103c, 0x226b, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
7710 SND_PCI_QUIRK(0x103c, 0x226e, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
7711 SND_PCI_QUIRK(0x103c, 0x2271, "HP", ALC286_FIXUP_HP_GPIO_LED),
7712 SND_PCI_QUIRK(0x103c, 0x2272, "HP", ALC280_FIXUP_HP_DOCK_PINS),
7713 SND_PCI_QUIRK(0x103c, 0x2273, "HP", ALC280_FIXUP_HP_DOCK_PINS),
7714 SND_PCI_QUIRK(0x103c, 0x229e, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
7715 SND_PCI_QUIRK(0x103c, 0x22b2, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
7716 SND_PCI_QUIRK(0x103c, 0x22b7, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
7717 SND_PCI_QUIRK(0x103c, 0x22bf, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
7718 SND_PCI_QUIRK(0x103c, 0x22cf, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
7719 SND_PCI_QUIRK(0x103c, 0x22db, "HP", ALC280_FIXUP_HP_9480M),
7720 SND_PCI_QUIRK(0x103c, 0x22dc, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),
7721 SND_PCI_QUIRK(0x103c, 0x22fb, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),
7722
7723 SND_PCI_QUIRK(0x103c, 0x221b, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),
7724 SND_PCI_QUIRK(0x103c, 0x2221, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),
7725 SND_PCI_QUIRK(0x103c, 0x2225, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),
7726 SND_PCI_QUIRK(0x103c, 0x2253, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),
7727 SND_PCI_QUIRK(0x103c, 0x2254, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),
7728 SND_PCI_QUIRK(0x103c, 0x2255, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),
7729 SND_PCI_QUIRK(0x103c, 0x2256, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),
7730 SND_PCI_QUIRK(0x103c, 0x2257, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),
7731 SND_PCI_QUIRK(0x103c, 0x2259, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),
7732 SND_PCI_QUIRK(0x103c, 0x225a, "HP", ALC269_FIXUP_HP_DOCK_GPIO_MIC1_LED),
7733 SND_PCI_QUIRK(0x103c, 0x2260, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
7734 SND_PCI_QUIRK(0x103c, 0x2263, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
7735 SND_PCI_QUIRK(0x103c, 0x2264, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
7736 SND_PCI_QUIRK(0x103c, 0x2265, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
7737 SND_PCI_QUIRK(0x103c, 0x2272, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),
7738 SND_PCI_QUIRK(0x103c, 0x2273, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),
7739 SND_PCI_QUIRK(0x103c, 0x2278, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),
7740 SND_PCI_QUIRK(0x103c, 0x227f, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
7741 SND_PCI_QUIRK(0x103c, 0x2282, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
7742 SND_PCI_QUIRK(0x103c, 0x228b, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
7743 SND_PCI_QUIRK(0x103c, 0x228e, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
7744 SND_PCI_QUIRK(0x103c, 0x22c5, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
7745 SND_PCI_QUIRK(0x103c, 0x22c7, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
7746 SND_PCI_QUIRK(0x103c, 0x22c8, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
7747 SND_PCI_QUIRK(0x103c, 0x22c4, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
7748 SND_PCI_QUIRK(0x103c, 0x2334, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
7749 SND_PCI_QUIRK(0x103c, 0x2335, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
7750 SND_PCI_QUIRK(0x103c, 0x2336, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
7751 SND_PCI_QUIRK(0x103c, 0x2337, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
7752 SND_PCI_QUIRK(0x103c, 0x221c, "HP EliteBook 755 G2", ALC280_FIXUP_HP_HEADSET_MIC),
7753 SND_PCI_QUIRK(0x103c, 0x802e, "HP Z240 SFF", ALC221_FIXUP_HP_MIC_NO_PRESENCE),
7754 SND_PCI_QUIRK(0x103c, 0x802f, "HP Z240", ALC221_FIXUP_HP_MIC_NO_PRESENCE),
7755 SND_PCI_QUIRK(0x103c, 0x820d, "HP Pavilion 15", ALC269_FIXUP_HP_MUTE_LED_MIC3),
7756 SND_PCI_QUIRK(0x103c, 0x8256, "HP", ALC221_FIXUP_HP_FRONT_MIC),
7757 SND_PCI_QUIRK(0x103c, 0x827e, "HP x360", ALC295_FIXUP_HP_X360),
7758 SND_PCI_QUIRK(0x103c, 0x82bf, "HP G3 mini", ALC221_FIXUP_HP_MIC_NO_PRESENCE),
7759 SND_PCI_QUIRK(0x103c, 0x82c0, "HP G3 mini premium", ALC221_FIXUP_HP_MIC_NO_PRESENCE),
7760 SND_PCI_QUIRK(0x103c, 0x83b9, "HP Spectre x360", ALC269_FIXUP_HP_MUTE_LED_MIC3),
7761 SND_PCI_QUIRK(0x103c, 0x8497, "HP Envy x360", ALC269_FIXUP_HP_MUTE_LED_MIC3),
7762 SND_PCI_QUIRK(0x103c, 0x84e7, "HP Pavilion 15", ALC269_FIXUP_HP_MUTE_LED_MIC3),
7763 SND_PCI_QUIRK(0x103c, 0x869d, "HP", ALC236_FIXUP_HP_MUTE_LED),
7764 SND_PCI_QUIRK(0x103c, 0x8729, "HP", ALC285_FIXUP_HP_GPIO_LED),
7765 SND_PCI_QUIRK(0x103c, 0x8736, "HP", ALC285_FIXUP_HP_GPIO_AMP_INIT),
7766 SND_PCI_QUIRK(0x103c, 0x877a, "HP", ALC285_FIXUP_HP_MUTE_LED),
7767 SND_PCI_QUIRK(0x103c, 0x877d, "HP", ALC236_FIXUP_HP_MUTE_LED),
7768 SND_PCI_QUIRK(0x1043, 0x103e, "ASUS X540SA", ALC256_FIXUP_ASUS_MIC),
7769 SND_PCI_QUIRK(0x1043, 0x103f, "ASUS TX300", ALC282_FIXUP_ASUS_TX300),
7770 SND_PCI_QUIRK(0x1043, 0x106d, "Asus K53BE", ALC269_FIXUP_LIMIT_INT_MIC_BOOST),
7771 SND_PCI_QUIRK(0x1043, 0x10a1, "ASUS UX391UA", ALC294_FIXUP_ASUS_SPK),
7772 SND_PCI_QUIRK(0x1043, 0x10c0, "ASUS X540SA", ALC256_FIXUP_ASUS_MIC),
7773 SND_PCI_QUIRK(0x1043, 0x10d0, "ASUS X540LA/X540LJ", ALC255_FIXUP_ASUS_MIC_NO_PRESENCE),
7774 SND_PCI_QUIRK(0x1043, 0x115d, "Asus 1015E", ALC269_FIXUP_LIMIT_INT_MIC_BOOST),
7775 SND_PCI_QUIRK(0x1043, 0x11c0, "ASUS X556UR", ALC255_FIXUP_ASUS_MIC_NO_PRESENCE),
7776 SND_PCI_QUIRK(0x1043, 0x1290, "ASUS X441SA", ALC233_FIXUP_EAPD_COEF_AND_MIC_NO_PRESENCE),
7777 SND_PCI_QUIRK(0x1043, 0x12a0, "ASUS X441UV", ALC233_FIXUP_EAPD_COEF_AND_MIC_NO_PRESENCE),
7778 SND_PCI_QUIRK(0x1043, 0x12f0, "ASUS X541UV", ALC256_FIXUP_ASUS_MIC),
7779 SND_PCI_QUIRK(0x1043, 0x12e0, "ASUS X541SA", ALC256_FIXUP_ASUS_MIC),
7780 SND_PCI_QUIRK(0x1043, 0x13b0, "ASUS Z550SA", ALC256_FIXUP_ASUS_MIC),
7781 SND_PCI_QUIRK(0x1043, 0x1427, "Asus Zenbook UX31E", ALC269VB_FIXUP_ASUS_ZENBOOK),
7782 SND_PCI_QUIRK(0x1043, 0x1517, "Asus Zenbook UX31A", ALC269VB_FIXUP_ASUS_ZENBOOK_UX31A),
7783 SND_PCI_QUIRK(0x1043, 0x16e3, "ASUS UX50", ALC269_FIXUP_STEREO_DMIC),
7784 SND_PCI_QUIRK(0x1043, 0x17d1, "ASUS UX431FL", ALC294_FIXUP_ASUS_DUAL_SPK),
7785 SND_PCI_QUIRK(0x1043, 0x18b1, "Asus MJ401TA", ALC256_FIXUP_ASUS_HEADSET_MIC),
7786 SND_PCI_QUIRK(0x1043, 0x18f1, "Asus FX505DT", ALC256_FIXUP_ASUS_HEADSET_MIC),
7787 SND_PCI_QUIRK(0x1043, 0x194e, "ASUS UX563FD", ALC294_FIXUP_ASUS_HPE),
7788 SND_PCI_QUIRK(0x1043, 0x19ce, "ASUS B9450FA", ALC294_FIXUP_ASUS_HPE),
7789 SND_PCI_QUIRK(0x1043, 0x19e1, "ASUS UX581LV", ALC295_FIXUP_ASUS_MIC_NO_PRESENCE),
7790 SND_PCI_QUIRK(0x1043, 0x1a13, "Asus G73Jw", ALC269_FIXUP_ASUS_G73JW),
7791 SND_PCI_QUIRK(0x1043, 0x1a30, "ASUS X705UD", ALC256_FIXUP_ASUS_MIC),
7792 SND_PCI_QUIRK(0x1043, 0x1b11, "ASUS UX431DA", ALC294_FIXUP_ASUS_COEF_1B),
7793 SND_PCI_QUIRK(0x1043, 0x1b13, "Asus U41SV", ALC269_FIXUP_INV_DMIC),
7794 SND_PCI_QUIRK(0x1043, 0x1bbd, "ASUS Z550MA", ALC255_FIXUP_ASUS_MIC_NO_PRESENCE),
7795 SND_PCI_QUIRK(0x1043, 0x1c23, "Asus X55U", ALC269_FIXUP_LIMIT_INT_MIC_BOOST),
7796 SND_PCI_QUIRK(0x1043, 0x1ccd, "ASUS X555UB", ALC256_FIXUP_ASUS_MIC),
7797 SND_PCI_QUIRK(0x1043, 0x1e11, "ASUS Zephyrus G15", ALC289_FIXUP_ASUS_GA502),
7798 SND_PCI_QUIRK(0x1043, 0x1f11, "ASUS Zephyrus G14", ALC289_FIXUP_ASUS_GA401),
7799 SND_PCI_QUIRK(0x1043, 0x1881, "ASUS Zephyrus S/M", ALC294_FIXUP_ASUS_GX502_PINS),
7800 SND_PCI_QUIRK(0x1043, 0x3030, "ASUS ZN270IE", ALC256_FIXUP_ASUS_AIO_GPIO2),
7801 SND_PCI_QUIRK(0x1043, 0x831a, "ASUS P901", ALC269_FIXUP_STEREO_DMIC),
7802 SND_PCI_QUIRK(0x1043, 0x834a, "ASUS S101", ALC269_FIXUP_STEREO_DMIC),
7803 SND_PCI_QUIRK(0x1043, 0x8398, "ASUS P1005", ALC269_FIXUP_STEREO_DMIC),
7804 SND_PCI_QUIRK(0x1043, 0x83ce, "ASUS P1005", ALC269_FIXUP_STEREO_DMIC),
7805 SND_PCI_QUIRK(0x1043, 0x8516, "ASUS X101CH", ALC269_FIXUP_ASUS_X101),
7806 SND_PCI_QUIRK(0x104d, 0x90b5, "Sony VAIO Pro 11", ALC286_FIXUP_SONY_MIC_NO_PRESENCE),
7807 SND_PCI_QUIRK(0x104d, 0x90b6, "Sony VAIO Pro 13", ALC286_FIXUP_SONY_MIC_NO_PRESENCE),
7808 SND_PCI_QUIRK(0x104d, 0x9073, "Sony VAIO", ALC275_FIXUP_SONY_VAIO_GPIO2),
7809 SND_PCI_QUIRK(0x104d, 0x907b, "Sony VAIO", ALC275_FIXUP_SONY_HWEQ),
7810 SND_PCI_QUIRK(0x104d, 0x9084, "Sony VAIO", ALC275_FIXUP_SONY_HWEQ),
7811 SND_PCI_QUIRK(0x104d, 0x9099, "Sony VAIO S13", ALC275_FIXUP_SONY_DISABLE_AAMIX),
7812 SND_PCI_QUIRK(0x10cf, 0x1475, "Lifebook", ALC269_FIXUP_LIFEBOOK),
7813 SND_PCI_QUIRK(0x10cf, 0x159f, "Lifebook E780", ALC269_FIXUP_LIFEBOOK_NO_HP_TO_LINEOUT),
7814 SND_PCI_QUIRK(0x10cf, 0x15dc, "Lifebook T731", ALC269_FIXUP_LIFEBOOK_HP_PIN),
7815 SND_PCI_QUIRK(0x10cf, 0x1757, "Lifebook E752", ALC269_FIXUP_LIFEBOOK_HP_PIN),
7816 SND_PCI_QUIRK(0x10cf, 0x1629, "Lifebook U7x7", ALC255_FIXUP_LIFEBOOK_U7x7_HEADSET_MIC),
7817 SND_PCI_QUIRK(0x10cf, 0x1845, "Lifebook U904", ALC269_FIXUP_LIFEBOOK_EXTMIC),
7818 SND_PCI_QUIRK(0x10ec, 0x10f2, "Intel Reference board", ALC700_FIXUP_INTEL_REFERENCE),
7819 SND_PCI_QUIRK(0x10ec, 0x1230, "Intel Reference board", ALC295_FIXUP_CHROME_BOOK),
7820 SND_PCI_QUIRK(0x10f7, 0x8338, "Panasonic CF-SZ6", ALC269_FIXUP_HEADSET_MODE),
7821 SND_PCI_QUIRK(0x144d, 0xc109, "Samsung Ativ book 9 (NP900X3G)", ALC269_FIXUP_INV_DMIC),
7822 SND_PCI_QUIRK(0x144d, 0xc169, "Samsung Notebook 9 Pen (NP930SBE-K01US)", ALC298_FIXUP_SAMSUNG_HEADPHONE_VERY_QUIET),
7823 SND_PCI_QUIRK(0x144d, 0xc176, "Samsung Notebook 9 Pro (NP930MBE-K04US)", ALC298_FIXUP_SAMSUNG_HEADPHONE_VERY_QUIET),
7824 SND_PCI_QUIRK(0x144d, 0xc189, "Samsung Galaxy Flex Book (NT950QCG-X716)", ALC298_FIXUP_SAMSUNG_HEADPHONE_VERY_QUIET),
7825 SND_PCI_QUIRK(0x144d, 0xc18a, "Samsung Galaxy Book Ion (NP930XCJ-K01US)", ALC298_FIXUP_SAMSUNG_HEADPHONE_VERY_QUIET),
7826 SND_PCI_QUIRK(0x144d, 0xc830, "Samsung Galaxy Book Ion (NT950XCJ-X716A)", ALC298_FIXUP_SAMSUNG_HEADPHONE_VERY_QUIET),
7827 SND_PCI_QUIRK(0x144d, 0xc740, "Samsung Ativ book 8 (NP870Z5G)", ALC269_FIXUP_ATIV_BOOK_8),
7828 SND_PCI_QUIRK(0x144d, 0xc812, "Samsung Notebook Pen S (NT950SBE-X58)", ALC298_FIXUP_SAMSUNG_HEADPHONE_VERY_QUIET),
7829 SND_PCI_QUIRK(0x1458, 0xfa53, "Gigabyte BXBT-2807", ALC283_FIXUP_HEADSET_MIC),
7830 SND_PCI_QUIRK(0x1462, 0xb120, "MSI Cubi MS-B120", ALC283_FIXUP_HEADSET_MIC),
7831 SND_PCI_QUIRK(0x1462, 0xb171, "Cubi N 8GL (MS-B171)", ALC283_FIXUP_HEADSET_MIC),
7832 SND_PCI_QUIRK(0x1558, 0x1325, "System76 Darter Pro (darp5)", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
7833 SND_PCI_QUIRK(0x1558, 0x8550, "System76 Gazelle (gaze14)", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
7834 SND_PCI_QUIRK(0x1558, 0x8551, "System76 Gazelle (gaze14)", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
7835 SND_PCI_QUIRK(0x1558, 0x8560, "System76 Gazelle (gaze14)", ALC269_FIXUP_HEADSET_MIC),
7836 SND_PCI_QUIRK(0x1558, 0x8561, "System76 Gazelle (gaze14)", ALC269_FIXUP_HEADSET_MIC),
7837 SND_PCI_QUIRK(0x17aa, 0x1036, "Lenovo P520", ALC233_FIXUP_LENOVO_MULTI_CODECS),
7838 SND_PCI_QUIRK(0x17aa, 0x1048, "ThinkCentre Station", ALC283_FIXUP_HEADSET_MIC),
7839 SND_PCI_QUIRK(0x17aa, 0x20f2, "Thinkpad SL410/510", ALC269_FIXUP_SKU_IGNORE),
7840 SND_PCI_QUIRK(0x17aa, 0x215e, "Thinkpad L512", ALC269_FIXUP_SKU_IGNORE),
7841 SND_PCI_QUIRK(0x17aa, 0x21b8, "Thinkpad Edge 14", ALC269_FIXUP_SKU_IGNORE),
7842 SND_PCI_QUIRK(0x17aa, 0x21ca, "Thinkpad L412", ALC269_FIXUP_SKU_IGNORE),
7843 SND_PCI_QUIRK(0x17aa, 0x21e9, "Thinkpad Edge 15", ALC269_FIXUP_SKU_IGNORE),
7844 SND_PCI_QUIRK(0x17aa, 0x21f6, "Thinkpad T530", ALC269_FIXUP_LENOVO_DOCK_LIMIT_BOOST),
7845 SND_PCI_QUIRK(0x17aa, 0x21fa, "Thinkpad X230", ALC269_FIXUP_LENOVO_DOCK),
7846 SND_PCI_QUIRK(0x17aa, 0x21f3, "Thinkpad T430", ALC269_FIXUP_LENOVO_DOCK),
7847 SND_PCI_QUIRK(0x17aa, 0x21fb, "Thinkpad T430s", ALC269_FIXUP_LENOVO_DOCK),
7848 SND_PCI_QUIRK(0x17aa, 0x2203, "Thinkpad X230 Tablet", ALC269_FIXUP_LENOVO_DOCK),
7849 SND_PCI_QUIRK(0x17aa, 0x2208, "Thinkpad T431s", ALC269_FIXUP_LENOVO_DOCK),
7850 SND_PCI_QUIRK(0x17aa, 0x220c, "Thinkpad T440s", ALC292_FIXUP_TPT440),
7851 SND_PCI_QUIRK(0x17aa, 0x220e, "Thinkpad T440p", ALC292_FIXUP_TPT440_DOCK),
7852 SND_PCI_QUIRK(0x17aa, 0x2210, "Thinkpad T540p", ALC292_FIXUP_TPT440_DOCK),
7853 SND_PCI_QUIRK(0x17aa, 0x2211, "Thinkpad W541", ALC292_FIXUP_TPT440_DOCK),
7854 SND_PCI_QUIRK(0x17aa, 0x2212, "Thinkpad T440", ALC292_FIXUP_TPT440_DOCK),
7855 SND_PCI_QUIRK(0x17aa, 0x2214, "Thinkpad X240", ALC292_FIXUP_TPT440_DOCK),
7856 SND_PCI_QUIRK(0x17aa, 0x2215, "Thinkpad", ALC269_FIXUP_LIMIT_INT_MIC_BOOST),
7857 SND_PCI_QUIRK(0x17aa, 0x2218, "Thinkpad X1 Carbon 2nd", ALC292_FIXUP_TPT440_DOCK),
7858 SND_PCI_QUIRK(0x17aa, 0x2223, "ThinkPad T550", ALC292_FIXUP_TPT440_DOCK),
7859 SND_PCI_QUIRK(0x17aa, 0x2226, "ThinkPad X250", ALC292_FIXUP_TPT440_DOCK),
7860 SND_PCI_QUIRK(0x17aa, 0x222d, "Thinkpad", ALC298_FIXUP_TPT470_DOCK),
7861 SND_PCI_QUIRK(0x17aa, 0x222e, "Thinkpad", ALC298_FIXUP_TPT470_DOCK),
7862 SND_PCI_QUIRK(0x17aa, 0x2231, "Thinkpad T560", ALC292_FIXUP_TPT460),
7863 SND_PCI_QUIRK(0x17aa, 0x2233, "Thinkpad", ALC292_FIXUP_TPT460),
7864 SND_PCI_QUIRK(0x17aa, 0x2245, "Thinkpad T470", ALC298_FIXUP_TPT470_DOCK),
7865 SND_PCI_QUIRK(0x17aa, 0x2246, "Thinkpad", ALC298_FIXUP_TPT470_DOCK),
7866 SND_PCI_QUIRK(0x17aa, 0x2247, "Thinkpad", ALC298_FIXUP_TPT470_DOCK),
7867 SND_PCI_QUIRK(0x17aa, 0x2249, "Thinkpad", ALC292_FIXUP_TPT460),
7868 SND_PCI_QUIRK(0x17aa, 0x224b, "Thinkpad", ALC298_FIXUP_TPT470_DOCK),
7869 SND_PCI_QUIRK(0x17aa, 0x224c, "Thinkpad", ALC298_FIXUP_TPT470_DOCK),
7870 SND_PCI_QUIRK(0x17aa, 0x224d, "Thinkpad", ALC298_FIXUP_TPT470_DOCK),
7871 SND_PCI_QUIRK(0x17aa, 0x225d, "Thinkpad T480", ALC269_FIXUP_LIMIT_INT_MIC_BOOST),
7872 SND_PCI_QUIRK(0x17aa, 0x2292, "Thinkpad X1 Carbon 7th", ALC285_FIXUP_THINKPAD_HEADSET_JACK),
7873 SND_PCI_QUIRK(0x17aa, 0x22be, "Thinkpad X1 Carbon 8th", ALC285_FIXUP_THINKPAD_HEADSET_JACK),
7874 SND_PCI_QUIRK(0x17aa, 0x30bb, "ThinkCentre AIO", ALC233_FIXUP_LENOVO_LINE2_MIC_HOTKEY),
7875 SND_PCI_QUIRK(0x17aa, 0x30e2, "ThinkCentre AIO", ALC233_FIXUP_LENOVO_LINE2_MIC_HOTKEY),
7876 SND_PCI_QUIRK(0x17aa, 0x310c, "ThinkCentre Station", ALC294_FIXUP_LENOVO_MIC_LOCATION),
7877 SND_PCI_QUIRK(0x17aa, 0x3111, "ThinkCentre Station", ALC294_FIXUP_LENOVO_MIC_LOCATION),
7878 SND_PCI_QUIRK(0x17aa, 0x312a, "ThinkCentre Station", ALC294_FIXUP_LENOVO_MIC_LOCATION),
7879 SND_PCI_QUIRK(0x17aa, 0x312f, "ThinkCentre Station", ALC294_FIXUP_LENOVO_MIC_LOCATION),
7880 SND_PCI_QUIRK(0x17aa, 0x313c, "ThinkCentre Station", ALC294_FIXUP_LENOVO_MIC_LOCATION),
7881 SND_PCI_QUIRK(0x17aa, 0x3151, "ThinkCentre Station", ALC283_FIXUP_HEADSET_MIC),
7882 SND_PCI_QUIRK(0x17aa, 0x3176, "ThinkCentre Station", ALC283_FIXUP_HEADSET_MIC),
7883 SND_PCI_QUIRK(0x17aa, 0x3178, "ThinkCentre Station", ALC283_FIXUP_HEADSET_MIC),
7884 SND_PCI_QUIRK(0x17aa, 0x3902, "Lenovo E50-80", ALC269_FIXUP_DMIC_THINKPAD_ACPI),
7885 SND_PCI_QUIRK(0x17aa, 0x3977, "IdeaPad S210", ALC283_FIXUP_INT_MIC),
7886 SND_PCI_QUIRK(0x17aa, 0x3978, "Lenovo B50-70", ALC269_FIXUP_DMIC_THINKPAD_ACPI),
7887 SND_PCI_QUIRK(0x17aa, 0x5013, "Thinkpad", ALC269_FIXUP_LIMIT_INT_MIC_BOOST),
7888 SND_PCI_QUIRK(0x17aa, 0x501a, "Thinkpad", ALC283_FIXUP_INT_MIC),
7889 SND_PCI_QUIRK(0x17aa, 0x501e, "Thinkpad L440", ALC292_FIXUP_TPT440_DOCK),
7890 SND_PCI_QUIRK(0x17aa, 0x5026, "Thinkpad", ALC269_FIXUP_LIMIT_INT_MIC_BOOST),
7891 SND_PCI_QUIRK(0x17aa, 0x5034, "Thinkpad T450", ALC292_FIXUP_TPT440_DOCK),
7892 SND_PCI_QUIRK(0x17aa, 0x5036, "Thinkpad T450s", ALC292_FIXUP_TPT440_DOCK),
7893 SND_PCI_QUIRK(0x17aa, 0x503c, "Thinkpad L450", ALC292_FIXUP_TPT440_DOCK),
7894 SND_PCI_QUIRK(0x17aa, 0x504a, "ThinkPad X260", ALC292_FIXUP_TPT440_DOCK),
7895 SND_PCI_QUIRK(0x17aa, 0x504b, "Thinkpad", ALC293_FIXUP_LENOVO_SPK_NOISE),
7896 SND_PCI_QUIRK(0x17aa, 0x5050, "Thinkpad T560p", ALC292_FIXUP_TPT460),
7897 SND_PCI_QUIRK(0x17aa, 0x5051, "Thinkpad L460", ALC292_FIXUP_TPT460),
7898 SND_PCI_QUIRK(0x17aa, 0x5053, "Thinkpad T460", ALC292_FIXUP_TPT460),
7899 SND_PCI_QUIRK(0x17aa, 0x505d, "Thinkpad", ALC298_FIXUP_TPT470_DOCK),
7900 SND_PCI_QUIRK(0x17aa, 0x505f, "Thinkpad", ALC298_FIXUP_TPT470_DOCK),
7901 SND_PCI_QUIRK(0x17aa, 0x5062, "Thinkpad", ALC298_FIXUP_TPT470_DOCK),
7902 SND_PCI_QUIRK(0x17aa, 0x5109, "Thinkpad", ALC269_FIXUP_LIMIT_INT_MIC_BOOST),
7903 SND_PCI_QUIRK(0x17aa, 0x511e, "Thinkpad", ALC298_FIXUP_TPT470_DOCK),
7904 SND_PCI_QUIRK(0x17aa, 0x511f, "Thinkpad", ALC298_FIXUP_TPT470_DOCK),
7905 SND_PCI_QUIRK(0x17aa, 0x3bf8, "Quanta FL1", ALC269_FIXUP_PCM_44K),
7906 SND_PCI_QUIRK(0x17aa, 0x9e54, "LENOVO NB", ALC269_FIXUP_LENOVO_EAPD),
7907 SND_PCI_QUIRK(0x19e5, 0x3204, "Huawei MACH-WX9", ALC256_FIXUP_HUAWEI_MACH_WX9_PINS),
7908 SND_PCI_QUIRK(0x1b35, 0x1235, "CZC B20", ALC269_FIXUP_CZC_B20),
7909 SND_PCI_QUIRK(0x1b35, 0x1236, "CZC TMI", ALC269_FIXUP_CZC_TMI),
7910 SND_PCI_QUIRK(0x1b35, 0x1237, "CZC L101", ALC269_FIXUP_CZC_L101),
7911 SND_PCI_QUIRK(0x1b7d, 0xa831, "Ordissimo EVE2 ", ALC269VB_FIXUP_ORDISSIMO_EVE2),
7912 SND_PCI_QUIRK(0x1d72, 0x1602, "RedmiBook", ALC255_FIXUP_XIAOMI_HEADSET_MIC),
7913 SND_PCI_QUIRK(0x1d72, 0x1901, "RedmiBook 14", ALC256_FIXUP_ASUS_HEADSET_MIC),
7914 SND_PCI_QUIRK(0x10ec, 0x118c, "Medion EE4254 MD62100", ALC256_FIXUP_MEDION_HEADSET_NO_PRESENCE),
7915 SND_PCI_QUIRK(0x1c06, 0x2013, "Lemote A1802", ALC269_FIXUP_LEMOTE_A1802),
7916 SND_PCI_QUIRK(0x1c06, 0x2015, "Lemote A190X", ALC269_FIXUP_LEMOTE_A190X),
7917 SND_PCI_QUIRK(0x8086, 0x2080, "Intel NUC 8 Rugged", ALC256_FIXUP_INTEL_NUC8_RUGGED),
7918
7919#if 0
7920
7921
7922
7923
7924
7925 SND_PCI_QUIRK(0x1043, 0x8330, "ASUS Eeepc P703 P900A",
7926 ALC269_FIXUP_AMIC),
7927 SND_PCI_QUIRK(0x1043, 0x1013, "ASUS N61Da", ALC269_FIXUP_AMIC),
7928 SND_PCI_QUIRK(0x1043, 0x1143, "ASUS B53f", ALC269_FIXUP_AMIC),
7929 SND_PCI_QUIRK(0x1043, 0x1133, "ASUS UJ20ft", ALC269_FIXUP_AMIC),
7930 SND_PCI_QUIRK(0x1043, 0x1183, "ASUS K72DR", ALC269_FIXUP_AMIC),
7931 SND_PCI_QUIRK(0x1043, 0x11b3, "ASUS K52DR", ALC269_FIXUP_AMIC),
7932 SND_PCI_QUIRK(0x1043, 0x11e3, "ASUS U33Jc", ALC269_FIXUP_AMIC),
7933 SND_PCI_QUIRK(0x1043, 0x1273, "ASUS UL80Jt", ALC269_FIXUP_AMIC),
7934 SND_PCI_QUIRK(0x1043, 0x1283, "ASUS U53Jc", ALC269_FIXUP_AMIC),
7935 SND_PCI_QUIRK(0x1043, 0x12b3, "ASUS N82JV", ALC269_FIXUP_AMIC),
7936 SND_PCI_QUIRK(0x1043, 0x12d3, "ASUS N61Jv", ALC269_FIXUP_AMIC),
7937 SND_PCI_QUIRK(0x1043, 0x13a3, "ASUS UL30Vt", ALC269_FIXUP_AMIC),
7938 SND_PCI_QUIRK(0x1043, 0x1373, "ASUS G73JX", ALC269_FIXUP_AMIC),
7939 SND_PCI_QUIRK(0x1043, 0x1383, "ASUS UJ30Jc", ALC269_FIXUP_AMIC),
7940 SND_PCI_QUIRK(0x1043, 0x13d3, "ASUS N61JA", ALC269_FIXUP_AMIC),
7941 SND_PCI_QUIRK(0x1043, 0x1413, "ASUS UL50", ALC269_FIXUP_AMIC),
7942 SND_PCI_QUIRK(0x1043, 0x1443, "ASUS UL30", ALC269_FIXUP_AMIC),
7943 SND_PCI_QUIRK(0x1043, 0x1453, "ASUS M60Jv", ALC269_FIXUP_AMIC),
7944 SND_PCI_QUIRK(0x1043, 0x1483, "ASUS UL80", ALC269_FIXUP_AMIC),
7945 SND_PCI_QUIRK(0x1043, 0x14f3, "ASUS F83Vf", ALC269_FIXUP_AMIC),
7946 SND_PCI_QUIRK(0x1043, 0x14e3, "ASUS UL20", ALC269_FIXUP_AMIC),
7947 SND_PCI_QUIRK(0x1043, 0x1513, "ASUS UX30", ALC269_FIXUP_AMIC),
7948 SND_PCI_QUIRK(0x1043, 0x1593, "ASUS N51Vn", ALC269_FIXUP_AMIC),
7949 SND_PCI_QUIRK(0x1043, 0x15a3, "ASUS N60Jv", ALC269_FIXUP_AMIC),
7950 SND_PCI_QUIRK(0x1043, 0x15b3, "ASUS N60Dp", ALC269_FIXUP_AMIC),
7951 SND_PCI_QUIRK(0x1043, 0x15c3, "ASUS N70De", ALC269_FIXUP_AMIC),
7952 SND_PCI_QUIRK(0x1043, 0x15e3, "ASUS F83T", ALC269_FIXUP_AMIC),
7953 SND_PCI_QUIRK(0x1043, 0x1643, "ASUS M60J", ALC269_FIXUP_AMIC),
7954 SND_PCI_QUIRK(0x1043, 0x1653, "ASUS U50", ALC269_FIXUP_AMIC),
7955 SND_PCI_QUIRK(0x1043, 0x1693, "ASUS F50N", ALC269_FIXUP_AMIC),
7956 SND_PCI_QUIRK(0x1043, 0x16a3, "ASUS F5Q", ALC269_FIXUP_AMIC),
7957 SND_PCI_QUIRK(0x1043, 0x1723, "ASUS P80", ALC269_FIXUP_AMIC),
7958 SND_PCI_QUIRK(0x1043, 0x1743, "ASUS U80", ALC269_FIXUP_AMIC),
7959 SND_PCI_QUIRK(0x1043, 0x1773, "ASUS U20A", ALC269_FIXUP_AMIC),
7960 SND_PCI_QUIRK(0x1043, 0x1883, "ASUS F81Se", ALC269_FIXUP_AMIC),
7961 SND_PCI_QUIRK(0x152d, 0x1778, "Quanta ON1", ALC269_FIXUP_DMIC),
7962 SND_PCI_QUIRK(0x17aa, 0x3be9, "Quanta Wistron", ALC269_FIXUP_AMIC),
7963 SND_PCI_QUIRK(0x17aa, 0x3bf8, "Quanta FL1", ALC269_FIXUP_AMIC),
7964 SND_PCI_QUIRK(0x17ff, 0x059a, "Quanta EL3", ALC269_FIXUP_DMIC),
7965 SND_PCI_QUIRK(0x17ff, 0x059b, "Quanta JR1", ALC269_FIXUP_DMIC),
7966#endif
7967 {}
7968};
7969
7970static const struct snd_pci_quirk alc269_fixup_vendor_tbl[] = {
7971 SND_PCI_QUIRK_VENDOR(0x1025, "Acer Aspire", ALC271_FIXUP_DMIC),
7972 SND_PCI_QUIRK_VENDOR(0x103c, "HP", ALC269_FIXUP_HP_MUTE_LED),
7973 SND_PCI_QUIRK_VENDOR(0x104d, "Sony VAIO", ALC269_FIXUP_SONY_VAIO),
7974 SND_PCI_QUIRK_VENDOR(0x17aa, "Thinkpad", ALC269_FIXUP_THINKPAD_ACPI),
7975 SND_PCI_QUIRK_VENDOR(0x19e5, "Huawei Matebook", ALC255_FIXUP_MIC_MUTE_LED),
7976 {}
7977};
7978
7979static const struct hda_model_fixup alc269_fixup_models[] = {
7980 {.id = ALC269_FIXUP_AMIC, .name = "laptop-amic"},
7981 {.id = ALC269_FIXUP_DMIC, .name = "laptop-dmic"},
7982 {.id = ALC269_FIXUP_STEREO_DMIC, .name = "alc269-dmic"},
7983 {.id = ALC271_FIXUP_DMIC, .name = "alc271-dmic"},
7984 {.id = ALC269_FIXUP_INV_DMIC, .name = "inv-dmic"},
7985 {.id = ALC269_FIXUP_HEADSET_MIC, .name = "headset-mic"},
7986 {.id = ALC269_FIXUP_HEADSET_MODE, .name = "headset-mode"},
7987 {.id = ALC269_FIXUP_HEADSET_MODE_NO_HP_MIC, .name = "headset-mode-no-hp-mic"},
7988 {.id = ALC269_FIXUP_LENOVO_DOCK, .name = "lenovo-dock"},
7989 {.id = ALC269_FIXUP_LENOVO_DOCK_LIMIT_BOOST, .name = "lenovo-dock-limit-boost"},
7990 {.id = ALC269_FIXUP_HP_GPIO_LED, .name = "hp-gpio-led"},
7991 {.id = ALC269_FIXUP_HP_DOCK_GPIO_MIC1_LED, .name = "hp-dock-gpio-mic1-led"},
7992 {.id = ALC269_FIXUP_DELL1_MIC_NO_PRESENCE, .name = "dell-headset-multi"},
7993 {.id = ALC269_FIXUP_DELL2_MIC_NO_PRESENCE, .name = "dell-headset-dock"},
7994 {.id = ALC269_FIXUP_DELL3_MIC_NO_PRESENCE, .name = "dell-headset3"},
7995 {.id = ALC269_FIXUP_DELL4_MIC_NO_PRESENCE, .name = "dell-headset4"},
7996 {.id = ALC283_FIXUP_CHROME_BOOK, .name = "alc283-dac-wcaps"},
7997 {.id = ALC283_FIXUP_SENSE_COMBO_JACK, .name = "alc283-sense-combo"},
7998 {.id = ALC292_FIXUP_TPT440_DOCK, .name = "tpt440-dock"},
7999 {.id = ALC292_FIXUP_TPT440, .name = "tpt440"},
8000 {.id = ALC292_FIXUP_TPT460, .name = "tpt460"},
8001 {.id = ALC298_FIXUP_TPT470_DOCK_FIX, .name = "tpt470-dock-fix"},
8002 {.id = ALC298_FIXUP_TPT470_DOCK, .name = "tpt470-dock"},
8003 {.id = ALC233_FIXUP_LENOVO_MULTI_CODECS, .name = "dual-codecs"},
8004 {.id = ALC700_FIXUP_INTEL_REFERENCE, .name = "alc700-ref"},
8005 {.id = ALC269_FIXUP_SONY_VAIO, .name = "vaio"},
8006 {.id = ALC269_FIXUP_DELL_M101Z, .name = "dell-m101z"},
8007 {.id = ALC269_FIXUP_ASUS_G73JW, .name = "asus-g73jw"},
8008 {.id = ALC269_FIXUP_LENOVO_EAPD, .name = "lenovo-eapd"},
8009 {.id = ALC275_FIXUP_SONY_HWEQ, .name = "sony-hweq"},
8010 {.id = ALC269_FIXUP_PCM_44K, .name = "pcm44k"},
8011 {.id = ALC269_FIXUP_LIFEBOOK, .name = "lifebook"},
8012 {.id = ALC269_FIXUP_LIFEBOOK_EXTMIC, .name = "lifebook-extmic"},
8013 {.id = ALC269_FIXUP_LIFEBOOK_HP_PIN, .name = "lifebook-hp-pin"},
8014 {.id = ALC255_FIXUP_LIFEBOOK_U7x7_HEADSET_MIC, .name = "lifebook-u7x7"},
8015 {.id = ALC269VB_FIXUP_AMIC, .name = "alc269vb-amic"},
8016 {.id = ALC269VB_FIXUP_DMIC, .name = "alc269vb-dmic"},
8017 {.id = ALC269_FIXUP_HP_MUTE_LED_MIC1, .name = "hp-mute-led-mic1"},
8018 {.id = ALC269_FIXUP_HP_MUTE_LED_MIC2, .name = "hp-mute-led-mic2"},
8019 {.id = ALC269_FIXUP_HP_MUTE_LED_MIC3, .name = "hp-mute-led-mic3"},
8020 {.id = ALC269_FIXUP_HP_GPIO_MIC1_LED, .name = "hp-gpio-mic1"},
8021 {.id = ALC269_FIXUP_HP_LINE1_MIC1_LED, .name = "hp-line1-mic1"},
8022 {.id = ALC269_FIXUP_NO_SHUTUP, .name = "noshutup"},
8023 {.id = ALC286_FIXUP_SONY_MIC_NO_PRESENCE, .name = "sony-nomic"},
8024 {.id = ALC269_FIXUP_ASPIRE_HEADSET_MIC, .name = "aspire-headset-mic"},
8025 {.id = ALC269_FIXUP_ASUS_X101, .name = "asus-x101"},
8026 {.id = ALC271_FIXUP_HP_GATE_MIC_JACK, .name = "acer-ao7xx"},
8027 {.id = ALC271_FIXUP_HP_GATE_MIC_JACK_E1_572, .name = "acer-aspire-e1"},
8028 {.id = ALC269_FIXUP_ACER_AC700, .name = "acer-ac700"},
8029 {.id = ALC269_FIXUP_LIMIT_INT_MIC_BOOST, .name = "limit-mic-boost"},
8030 {.id = ALC269VB_FIXUP_ASUS_ZENBOOK, .name = "asus-zenbook"},
8031 {.id = ALC269VB_FIXUP_ASUS_ZENBOOK_UX31A, .name = "asus-zenbook-ux31a"},
8032 {.id = ALC269VB_FIXUP_ORDISSIMO_EVE2, .name = "ordissimo"},
8033 {.id = ALC282_FIXUP_ASUS_TX300, .name = "asus-tx300"},
8034 {.id = ALC283_FIXUP_INT_MIC, .name = "alc283-int-mic"},
8035 {.id = ALC290_FIXUP_MONO_SPEAKERS_HSJACK, .name = "mono-speakers"},
8036 {.id = ALC290_FIXUP_SUBWOOFER_HSJACK, .name = "alc290-subwoofer"},
8037 {.id = ALC269_FIXUP_THINKPAD_ACPI, .name = "thinkpad"},
8038 {.id = ALC269_FIXUP_DMIC_THINKPAD_ACPI, .name = "dmic-thinkpad"},
8039 {.id = ALC255_FIXUP_ACER_MIC_NO_PRESENCE, .name = "alc255-acer"},
8040 {.id = ALC255_FIXUP_ASUS_MIC_NO_PRESENCE, .name = "alc255-asus"},
8041 {.id = ALC255_FIXUP_DELL1_MIC_NO_PRESENCE, .name = "alc255-dell1"},
8042 {.id = ALC255_FIXUP_DELL2_MIC_NO_PRESENCE, .name = "alc255-dell2"},
8043 {.id = ALC293_FIXUP_DELL1_MIC_NO_PRESENCE, .name = "alc293-dell1"},
8044 {.id = ALC283_FIXUP_HEADSET_MIC, .name = "alc283-headset"},
8045 {.id = ALC255_FIXUP_MIC_MUTE_LED, .name = "alc255-dell-mute"},
8046 {.id = ALC282_FIXUP_ASPIRE_V5_PINS, .name = "aspire-v5"},
8047 {.id = ALC280_FIXUP_HP_GPIO4, .name = "hp-gpio4"},
8048 {.id = ALC286_FIXUP_HP_GPIO_LED, .name = "hp-gpio-led"},
8049 {.id = ALC280_FIXUP_HP_GPIO2_MIC_HOTKEY, .name = "hp-gpio2-hotkey"},
8050 {.id = ALC280_FIXUP_HP_DOCK_PINS, .name = "hp-dock-pins"},
8051 {.id = ALC269_FIXUP_HP_DOCK_GPIO_MIC1_LED, .name = "hp-dock-gpio-mic"},
8052 {.id = ALC280_FIXUP_HP_9480M, .name = "hp-9480m"},
8053 {.id = ALC288_FIXUP_DELL_HEADSET_MODE, .name = "alc288-dell-headset"},
8054 {.id = ALC288_FIXUP_DELL1_MIC_NO_PRESENCE, .name = "alc288-dell1"},
8055 {.id = ALC288_FIXUP_DELL_XPS_13, .name = "alc288-dell-xps13"},
8056 {.id = ALC292_FIXUP_DELL_E7X, .name = "dell-e7x"},
8057 {.id = ALC293_FIXUP_DISABLE_AAMIX_MULTIJACK, .name = "alc293-dell"},
8058 {.id = ALC298_FIXUP_DELL1_MIC_NO_PRESENCE, .name = "alc298-dell1"},
8059 {.id = ALC298_FIXUP_DELL_AIO_MIC_NO_PRESENCE, .name = "alc298-dell-aio"},
8060 {.id = ALC275_FIXUP_DELL_XPS, .name = "alc275-dell-xps"},
8061 {.id = ALC293_FIXUP_LENOVO_SPK_NOISE, .name = "lenovo-spk-noise"},
8062 {.id = ALC233_FIXUP_LENOVO_LINE2_MIC_HOTKEY, .name = "lenovo-hotkey"},
8063 {.id = ALC255_FIXUP_DELL_SPK_NOISE, .name = "dell-spk-noise"},
8064 {.id = ALC225_FIXUP_DELL1_MIC_NO_PRESENCE, .name = "alc225-dell1"},
8065 {.id = ALC295_FIXUP_DISABLE_DAC3, .name = "alc295-disable-dac3"},
8066 {.id = ALC285_FIXUP_SPEAKER2_TO_DAC1, .name = "alc285-speaker2-to-dac1"},
8067 {.id = ALC280_FIXUP_HP_HEADSET_MIC, .name = "alc280-hp-headset"},
8068 {.id = ALC221_FIXUP_HP_FRONT_MIC, .name = "alc221-hp-mic"},
8069 {.id = ALC298_FIXUP_SPK_VOLUME, .name = "alc298-spk-volume"},
8070 {.id = ALC256_FIXUP_DELL_INSPIRON_7559_SUBWOOFER, .name = "dell-inspiron-7559"},
8071 {.id = ALC269_FIXUP_ATIV_BOOK_8, .name = "ativ-book"},
8072 {.id = ALC221_FIXUP_HP_MIC_NO_PRESENCE, .name = "alc221-hp-mic"},
8073 {.id = ALC256_FIXUP_ASUS_HEADSET_MODE, .name = "alc256-asus-headset"},
8074 {.id = ALC256_FIXUP_ASUS_MIC, .name = "alc256-asus-mic"},
8075 {.id = ALC256_FIXUP_ASUS_AIO_GPIO2, .name = "alc256-asus-aio"},
8076 {.id = ALC233_FIXUP_ASUS_MIC_NO_PRESENCE, .name = "alc233-asus"},
8077 {.id = ALC233_FIXUP_EAPD_COEF_AND_MIC_NO_PRESENCE, .name = "alc233-eapd"},
8078 {.id = ALC294_FIXUP_LENOVO_MIC_LOCATION, .name = "alc294-lenovo-mic"},
8079 {.id = ALC225_FIXUP_DELL_WYSE_MIC_NO_PRESENCE, .name = "alc225-wyse"},
8080 {.id = ALC274_FIXUP_DELL_AIO_LINEOUT_VERB, .name = "alc274-dell-aio"},
8081 {.id = ALC255_FIXUP_DUMMY_LINEOUT_VERB, .name = "alc255-dummy-lineout"},
8082 {.id = ALC255_FIXUP_DELL_HEADSET_MIC, .name = "alc255-dell-headset"},
8083 {.id = ALC295_FIXUP_HP_X360, .name = "alc295-hp-x360"},
8084 {.id = ALC225_FIXUP_HEADSET_JACK, .name = "alc-headset-jack"},
8085 {.id = ALC295_FIXUP_CHROME_BOOK, .name = "alc-chrome-book"},
8086 {.id = ALC299_FIXUP_PREDATOR_SPK, .name = "predator-spk"},
8087 {.id = ALC298_FIXUP_HUAWEI_MBX_STEREO, .name = "huawei-mbx-stereo"},
8088 {.id = ALC256_FIXUP_MEDION_HEADSET_NO_PRESENCE, .name = "alc256-medion-headset"},
8089 {.id = ALC298_FIXUP_SAMSUNG_HEADPHONE_VERY_QUIET, .name = "alc298-samsung-headphone"},
8090 {.id = ALC255_FIXUP_XIAOMI_HEADSET_MIC, .name = "alc255-xiaomi-headset"},
8091 {}
8092};
8093#define ALC225_STANDARD_PINS \
8094 {0x21, 0x04211020}
8095
8096#define ALC256_STANDARD_PINS \
8097 {0x12, 0x90a60140}, \
8098 {0x14, 0x90170110}, \
8099 {0x21, 0x02211020}
8100
8101#define ALC282_STANDARD_PINS \
8102 {0x14, 0x90170110}
8103
8104#define ALC290_STANDARD_PINS \
8105 {0x12, 0x99a30130}
8106
8107#define ALC292_STANDARD_PINS \
8108 {0x14, 0x90170110}, \
8109 {0x15, 0x0221401f}
8110
8111#define ALC295_STANDARD_PINS \
8112 {0x12, 0xb7a60130}, \
8113 {0x14, 0x90170110}, \
8114 {0x21, 0x04211020}
8115
8116#define ALC298_STANDARD_PINS \
8117 {0x12, 0x90a60130}, \
8118 {0x21, 0x03211020}
8119
8120static const struct snd_hda_pin_quirk alc269_pin_fixup_tbl[] = {
8121 SND_HDA_PIN_QUIRK(0x10ec0221, 0x103c, "HP Workstation", ALC221_FIXUP_HP_HEADSET_MIC,
8122 {0x14, 0x01014020},
8123 {0x17, 0x90170110},
8124 {0x18, 0x02a11030},
8125 {0x19, 0x0181303F},
8126 {0x21, 0x0221102f}),
8127 SND_HDA_PIN_QUIRK(0x10ec0255, 0x1025, "Acer", ALC255_FIXUP_ACER_MIC_NO_PRESENCE,
8128 {0x12, 0x90a601c0},
8129 {0x14, 0x90171120},
8130 {0x21, 0x02211030}),
8131 SND_HDA_PIN_QUIRK(0x10ec0255, 0x1043, "ASUS", ALC255_FIXUP_ASUS_MIC_NO_PRESENCE,
8132 {0x14, 0x90170110},
8133 {0x1b, 0x90a70130},
8134 {0x21, 0x03211020}),
8135 SND_HDA_PIN_QUIRK(0x10ec0255, 0x1043, "ASUS", ALC255_FIXUP_ASUS_MIC_NO_PRESENCE,
8136 {0x1a, 0x90a70130},
8137 {0x1b, 0x90170110},
8138 {0x21, 0x03211020}),
8139 SND_HDA_PIN_QUIRK(0x10ec0225, 0x1028, "Dell", ALC225_FIXUP_DELL1_MIC_NO_PRESENCE,
8140 ALC225_STANDARD_PINS,
8141 {0x12, 0xb7a60130},
8142 {0x14, 0x901701a0}),
8143 SND_HDA_PIN_QUIRK(0x10ec0225, 0x1028, "Dell", ALC225_FIXUP_DELL1_MIC_NO_PRESENCE,
8144 ALC225_STANDARD_PINS,
8145 {0x12, 0xb7a60130},
8146 {0x14, 0x901701b0}),
8147 SND_HDA_PIN_QUIRK(0x10ec0225, 0x1028, "Dell", ALC225_FIXUP_DELL1_MIC_NO_PRESENCE,
8148 ALC225_STANDARD_PINS,
8149 {0x12, 0xb7a60150},
8150 {0x14, 0x901701a0}),
8151 SND_HDA_PIN_QUIRK(0x10ec0225, 0x1028, "Dell", ALC225_FIXUP_DELL1_MIC_NO_PRESENCE,
8152 ALC225_STANDARD_PINS,
8153 {0x12, 0xb7a60150},
8154 {0x14, 0x901701b0}),
8155 SND_HDA_PIN_QUIRK(0x10ec0225, 0x1028, "Dell", ALC225_FIXUP_DELL1_MIC_NO_PRESENCE,
8156 ALC225_STANDARD_PINS,
8157 {0x12, 0xb7a60130},
8158 {0x1b, 0x90170110}),
8159 SND_HDA_PIN_QUIRK(0x10ec0233, 0x8086, "Intel NUC Skull Canyon", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE,
8160 {0x1b, 0x01111010},
8161 {0x1e, 0x01451130},
8162 {0x21, 0x02211020}),
8163 SND_HDA_PIN_QUIRK(0x10ec0235, 0x17aa, "Lenovo", ALC233_FIXUP_LENOVO_LINE2_MIC_HOTKEY,
8164 {0x12, 0x90a60140},
8165 {0x14, 0x90170110},
8166 {0x19, 0x02a11030},
8167 {0x21, 0x02211020}),
8168 SND_HDA_PIN_QUIRK(0x10ec0235, 0x17aa, "Lenovo", ALC294_FIXUP_LENOVO_MIC_LOCATION,
8169 {0x14, 0x90170110},
8170 {0x19, 0x02a11030},
8171 {0x1a, 0x02a11040},
8172 {0x1b, 0x01014020},
8173 {0x21, 0x0221101f}),
8174 SND_HDA_PIN_QUIRK(0x10ec0235, 0x17aa, "Lenovo", ALC294_FIXUP_LENOVO_MIC_LOCATION,
8175 {0x14, 0x90170110},
8176 {0x19, 0x02a11030},
8177 {0x1a, 0x02a11040},
8178 {0x1b, 0x01011020},
8179 {0x21, 0x0221101f}),
8180 SND_HDA_PIN_QUIRK(0x10ec0235, 0x17aa, "Lenovo", ALC294_FIXUP_LENOVO_MIC_LOCATION,
8181 {0x14, 0x90170110},
8182 {0x19, 0x02a11020},
8183 {0x1a, 0x02a11030},
8184 {0x21, 0x0221101f}),
8185 SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL2_MIC_NO_PRESENCE,
8186 {0x14, 0x90170110},
8187 {0x21, 0x02211020}),
8188 SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
8189 {0x14, 0x90170130},
8190 {0x21, 0x02211040}),
8191 SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
8192 {0x12, 0x90a60140},
8193 {0x14, 0x90170110},
8194 {0x21, 0x02211020}),
8195 SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
8196 {0x12, 0x90a60160},
8197 {0x14, 0x90170120},
8198 {0x21, 0x02211030}),
8199 SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
8200 {0x14, 0x90170110},
8201 {0x1b, 0x02011020},
8202 {0x21, 0x0221101f}),
8203 SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
8204 {0x14, 0x90170110},
8205 {0x1b, 0x01011020},
8206 {0x21, 0x0221101f}),
8207 SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
8208 {0x14, 0x90170130},
8209 {0x1b, 0x01014020},
8210 {0x21, 0x0221103f}),
8211 SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
8212 {0x14, 0x90170130},
8213 {0x1b, 0x01011020},
8214 {0x21, 0x0221103f}),
8215 SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
8216 {0x14, 0x90170130},
8217 {0x1b, 0x02011020},
8218 {0x21, 0x0221103f}),
8219 SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
8220 {0x14, 0x90170150},
8221 {0x1b, 0x02011020},
8222 {0x21, 0x0221105f}),
8223 SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
8224 {0x14, 0x90170110},
8225 {0x1b, 0x01014020},
8226 {0x21, 0x0221101f}),
8227 SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
8228 {0x12, 0x90a60160},
8229 {0x14, 0x90170120},
8230 {0x17, 0x90170140},
8231 {0x21, 0x0321102f}),
8232 SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
8233 {0x12, 0x90a60160},
8234 {0x14, 0x90170130},
8235 {0x21, 0x02211040}),
8236 SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
8237 {0x12, 0x90a60160},
8238 {0x14, 0x90170140},
8239 {0x21, 0x02211050}),
8240 SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
8241 {0x12, 0x90a60170},
8242 {0x14, 0x90170120},
8243 {0x21, 0x02211030}),
8244 SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
8245 {0x12, 0x90a60170},
8246 {0x14, 0x90170130},
8247 {0x21, 0x02211040}),
8248 SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
8249 {0x12, 0x90a60170},
8250 {0x14, 0x90171130},
8251 {0x21, 0x02211040}),
8252 SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
8253 {0x12, 0x90a60170},
8254 {0x14, 0x90170140},
8255 {0x21, 0x02211050}),
8256 SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell Inspiron 5548", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
8257 {0x12, 0x90a60180},
8258 {0x14, 0x90170130},
8259 {0x21, 0x02211040}),
8260 SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell Inspiron 5565", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
8261 {0x12, 0x90a60180},
8262 {0x14, 0x90170120},
8263 {0x21, 0x02211030}),
8264 SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
8265 {0x1b, 0x01011020},
8266 {0x21, 0x02211010}),
8267 SND_HDA_PIN_QUIRK(0x10ec0256, 0x1043, "ASUS", ALC256_FIXUP_ASUS_MIC,
8268 {0x14, 0x90170110},
8269 {0x1b, 0x90a70130},
8270 {0x21, 0x04211020}),
8271 SND_HDA_PIN_QUIRK(0x10ec0256, 0x1043, "ASUS", ALC256_FIXUP_ASUS_MIC,
8272 {0x14, 0x90170110},
8273 {0x1b, 0x90a70130},
8274 {0x21, 0x03211020}),
8275 SND_HDA_PIN_QUIRK(0x10ec0256, 0x1043, "ASUS", ALC256_FIXUP_ASUS_MIC_NO_PRESENCE,
8276 {0x12, 0x90a60130},
8277 {0x14, 0x90170110},
8278 {0x21, 0x03211020}),
8279 SND_HDA_PIN_QUIRK(0x10ec0256, 0x1043, "ASUS", ALC256_FIXUP_ASUS_MIC_NO_PRESENCE,
8280 {0x12, 0x90a60130},
8281 {0x14, 0x90170110},
8282 {0x21, 0x04211020}),
8283 SND_HDA_PIN_QUIRK(0x10ec0256, 0x1043, "ASUS", ALC256_FIXUP_ASUS_MIC_NO_PRESENCE,
8284 {0x1a, 0x90a70130},
8285 {0x1b, 0x90170110},
8286 {0x21, 0x03211020}),
8287 SND_HDA_PIN_QUIRK(0x10ec0280, 0x103c, "HP", ALC280_FIXUP_HP_GPIO4,
8288 {0x12, 0x90a60130},
8289 {0x14, 0x90170110},
8290 {0x15, 0x0421101f},
8291 {0x1a, 0x04a11020}),
8292 SND_HDA_PIN_QUIRK(0x10ec0280, 0x103c, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED,
8293 {0x12, 0x90a60140},
8294 {0x14, 0x90170110},
8295 {0x15, 0x0421101f},
8296 {0x18, 0x02811030},
8297 {0x1a, 0x04a1103f},
8298 {0x1b, 0x02011020}),
8299 SND_HDA_PIN_QUIRK(0x10ec0282, 0x103c, "HP 15 Touchsmart", ALC269_FIXUP_HP_MUTE_LED_MIC1,
8300 ALC282_STANDARD_PINS,
8301 {0x12, 0x99a30130},
8302 {0x19, 0x03a11020},
8303 {0x21, 0x0321101f}),
8304 SND_HDA_PIN_QUIRK(0x10ec0282, 0x103c, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1,
8305 ALC282_STANDARD_PINS,
8306 {0x12, 0x99a30130},
8307 {0x19, 0x03a11020},
8308 {0x21, 0x03211040}),
8309 SND_HDA_PIN_QUIRK(0x10ec0282, 0x103c, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1,
8310 ALC282_STANDARD_PINS,
8311 {0x12, 0x99a30130},
8312 {0x19, 0x03a11030},
8313 {0x21, 0x03211020}),
8314 SND_HDA_PIN_QUIRK(0x10ec0282, 0x103c, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1,
8315 ALC282_STANDARD_PINS,
8316 {0x12, 0x99a30130},
8317 {0x19, 0x04a11020},
8318 {0x21, 0x0421101f}),
8319 SND_HDA_PIN_QUIRK(0x10ec0282, 0x103c, "HP", ALC269_FIXUP_HP_LINE1_MIC1_LED,
8320 ALC282_STANDARD_PINS,
8321 {0x12, 0x90a60140},
8322 {0x19, 0x04a11030},
8323 {0x21, 0x04211020}),
8324 SND_HDA_PIN_QUIRK(0x10ec0283, 0x1028, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE,
8325 ALC282_STANDARD_PINS,
8326 {0x12, 0x90a60130},
8327 {0x21, 0x0321101f}),
8328 SND_HDA_PIN_QUIRK(0x10ec0283, 0x1028, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE,
8329 {0x12, 0x90a60160},
8330 {0x14, 0x90170120},
8331 {0x21, 0x02211030}),
8332 SND_HDA_PIN_QUIRK(0x10ec0283, 0x1028, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE,
8333 ALC282_STANDARD_PINS,
8334 {0x12, 0x90a60130},
8335 {0x19, 0x03a11020},
8336 {0x21, 0x0321101f}),
8337 SND_HDA_PIN_QUIRK(0x10ec0285, 0x17aa, "Lenovo", ALC285_FIXUP_LENOVO_PC_BEEP_IN_NOISE,
8338 {0x12, 0x90a60130},
8339 {0x14, 0x90170110},
8340 {0x19, 0x04a11040},
8341 {0x21, 0x04211020}),
8342 SND_HDA_PIN_QUIRK(0x10ec0286, 0x1025, "Acer", ALC286_FIXUP_ACER_AIO_MIC_NO_PRESENCE,
8343 {0x12, 0x90a60130},
8344 {0x17, 0x90170110},
8345 {0x21, 0x02211020}),
8346 SND_HDA_PIN_QUIRK(0x10ec0288, 0x1028, "Dell", ALC288_FIXUP_DELL1_MIC_NO_PRESENCE,
8347 {0x12, 0x90a60120},
8348 {0x14, 0x90170110},
8349 {0x21, 0x0321101f}),
8350 SND_HDA_PIN_QUIRK(0x10ec0290, 0x103c, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1,
8351 ALC290_STANDARD_PINS,
8352 {0x15, 0x04211040},
8353 {0x18, 0x90170112},
8354 {0x1a, 0x04a11020}),
8355 SND_HDA_PIN_QUIRK(0x10ec0290, 0x103c, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1,
8356 ALC290_STANDARD_PINS,
8357 {0x15, 0x04211040},
8358 {0x18, 0x90170110},
8359 {0x1a, 0x04a11020}),
8360 SND_HDA_PIN_QUIRK(0x10ec0290, 0x103c, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1,
8361 ALC290_STANDARD_PINS,
8362 {0x15, 0x0421101f},
8363 {0x1a, 0x04a11020}),
8364 SND_HDA_PIN_QUIRK(0x10ec0290, 0x103c, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1,
8365 ALC290_STANDARD_PINS,
8366 {0x15, 0x04211020},
8367 {0x1a, 0x04a11040}),
8368 SND_HDA_PIN_QUIRK(0x10ec0290, 0x103c, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1,
8369 ALC290_STANDARD_PINS,
8370 {0x14, 0x90170110},
8371 {0x15, 0x04211020},
8372 {0x1a, 0x04a11040}),
8373 SND_HDA_PIN_QUIRK(0x10ec0290, 0x103c, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1,
8374 ALC290_STANDARD_PINS,
8375 {0x14, 0x90170110},
8376 {0x15, 0x04211020},
8377 {0x1a, 0x04a11020}),
8378 SND_HDA_PIN_QUIRK(0x10ec0290, 0x103c, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1,
8379 ALC290_STANDARD_PINS,
8380 {0x14, 0x90170110},
8381 {0x15, 0x0421101f},
8382 {0x1a, 0x04a11020}),
8383 SND_HDA_PIN_QUIRK(0x10ec0292, 0x1028, "Dell", ALC269_FIXUP_DELL2_MIC_NO_PRESENCE,
8384 ALC292_STANDARD_PINS,
8385 {0x12, 0x90a60140},
8386 {0x16, 0x01014020},
8387 {0x19, 0x01a19030}),
8388 SND_HDA_PIN_QUIRK(0x10ec0292, 0x1028, "Dell", ALC269_FIXUP_DELL2_MIC_NO_PRESENCE,
8389 ALC292_STANDARD_PINS,
8390 {0x12, 0x90a60140},
8391 {0x16, 0x01014020},
8392 {0x18, 0x02a19031},
8393 {0x19, 0x01a1903e}),
8394 SND_HDA_PIN_QUIRK(0x10ec0292, 0x1028, "Dell", ALC269_FIXUP_DELL3_MIC_NO_PRESENCE,
8395 ALC292_STANDARD_PINS,
8396 {0x12, 0x90a60140}),
8397 SND_HDA_PIN_QUIRK(0x10ec0293, 0x1028, "Dell", ALC293_FIXUP_DELL1_MIC_NO_PRESENCE,
8398 ALC292_STANDARD_PINS,
8399 {0x13, 0x90a60140},
8400 {0x16, 0x21014020},
8401 {0x19, 0x21a19030}),
8402 SND_HDA_PIN_QUIRK(0x10ec0293, 0x1028, "Dell", ALC293_FIXUP_DELL1_MIC_NO_PRESENCE,
8403 ALC292_STANDARD_PINS,
8404 {0x13, 0x90a60140}),
8405 SND_HDA_PIN_QUIRK(0x10ec0294, 0x1043, "ASUS", ALC294_FIXUP_ASUS_MIC,
8406 {0x14, 0x90170110},
8407 {0x1b, 0x90a70130},
8408 {0x21, 0x04211020}),
8409 SND_HDA_PIN_QUIRK(0x10ec0294, 0x1043, "ASUS", ALC294_FIXUP_ASUS_SPK,
8410 {0x12, 0x90a60130},
8411 {0x17, 0x90170110},
8412 {0x21, 0x03211020}),
8413 SND_HDA_PIN_QUIRK(0x10ec0294, 0x1043, "ASUS", ALC294_FIXUP_ASUS_SPK,
8414 {0x12, 0x90a60130},
8415 {0x17, 0x90170110},
8416 {0x21, 0x04211020}),
8417 SND_HDA_PIN_QUIRK(0x10ec0295, 0x1043, "ASUS", ALC294_FIXUP_ASUS_SPK,
8418 {0x12, 0x90a60130},
8419 {0x17, 0x90170110},
8420 {0x21, 0x03211020}),
8421 SND_HDA_PIN_QUIRK(0x10ec0295, 0x1043, "ASUS", ALC295_FIXUP_ASUS_MIC_NO_PRESENCE,
8422 {0x12, 0x90a60120},
8423 {0x17, 0x90170110},
8424 {0x21, 0x04211030}),
8425 SND_HDA_PIN_QUIRK(0x10ec0295, 0x1043, "ASUS", ALC295_FIXUP_ASUS_MIC_NO_PRESENCE,
8426 {0x12, 0x90a60130},
8427 {0x17, 0x90170110},
8428 {0x21, 0x03211020}),
8429 SND_HDA_PIN_QUIRK(0x10ec0295, 0x1043, "ASUS", ALC295_FIXUP_ASUS_MIC_NO_PRESENCE,
8430 {0x12, 0x90a60130},
8431 {0x17, 0x90170110},
8432 {0x21, 0x03211020}),
8433 SND_HDA_PIN_QUIRK(0x10ec0295, 0x1028, "Dell", ALC269_FIXUP_DELL4_MIC_NO_PRESENCE,
8434 {0x14, 0x90170110},
8435 {0x21, 0x04211020}),
8436 SND_HDA_PIN_QUIRK(0x10ec0295, 0x1028, "Dell", ALC269_FIXUP_DELL4_MIC_NO_PRESENCE,
8437 {0x14, 0x90170110},
8438 {0x21, 0x04211030}),
8439 SND_HDA_PIN_QUIRK(0x10ec0295, 0x1028, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE,
8440 ALC295_STANDARD_PINS,
8441 {0x17, 0x21014020},
8442 {0x18, 0x21a19030}),
8443 SND_HDA_PIN_QUIRK(0x10ec0295, 0x1028, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE,
8444 ALC295_STANDARD_PINS,
8445 {0x17, 0x21014040},
8446 {0x18, 0x21a19050}),
8447 SND_HDA_PIN_QUIRK(0x10ec0295, 0x1028, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE,
8448 ALC295_STANDARD_PINS),
8449 SND_HDA_PIN_QUIRK(0x10ec0298, 0x1028, "Dell", ALC298_FIXUP_DELL1_MIC_NO_PRESENCE,
8450 ALC298_STANDARD_PINS,
8451 {0x17, 0x90170110}),
8452 SND_HDA_PIN_QUIRK(0x10ec0298, 0x1028, "Dell", ALC298_FIXUP_DELL1_MIC_NO_PRESENCE,
8453 ALC298_STANDARD_PINS,
8454 {0x17, 0x90170140}),
8455 SND_HDA_PIN_QUIRK(0x10ec0298, 0x1028, "Dell", ALC298_FIXUP_DELL1_MIC_NO_PRESENCE,
8456 ALC298_STANDARD_PINS,
8457 {0x17, 0x90170150}),
8458 SND_HDA_PIN_QUIRK(0x10ec0298, 0x1028, "Dell", ALC298_FIXUP_SPK_VOLUME,
8459 {0x12, 0xb7a60140},
8460 {0x13, 0xb7a60150},
8461 {0x17, 0x90170110},
8462 {0x1a, 0x03011020},
8463 {0x21, 0x03211030}),
8464 SND_HDA_PIN_QUIRK(0x10ec0298, 0x1028, "Dell", ALC298_FIXUP_ALIENWARE_MIC_NO_PRESENCE,
8465 {0x12, 0xb7a60140},
8466 {0x17, 0x90170110},
8467 {0x1a, 0x03a11030},
8468 {0x21, 0x03211020}),
8469 SND_HDA_PIN_QUIRK(0x10ec0299, 0x1028, "Dell", ALC269_FIXUP_DELL4_MIC_NO_PRESENCE,
8470 ALC225_STANDARD_PINS,
8471 {0x12, 0xb7a60130},
8472 {0x17, 0x90170110}),
8473 SND_HDA_PIN_QUIRK(0x10ec0623, 0x17aa, "Lenovo", ALC283_FIXUP_HEADSET_MIC,
8474 {0x14, 0x01014010},
8475 {0x17, 0x90170120},
8476 {0x18, 0x02a11030},
8477 {0x19, 0x02a1103f},
8478 {0x21, 0x0221101f}),
8479 {}
8480};
8481
8482
8483
8484
8485
8486
8487
8488static const struct snd_hda_pin_quirk alc269_fallback_pin_fixup_tbl[] = {
8489 SND_HDA_PIN_QUIRK(0x10ec0289, 0x1028, "Dell", ALC269_FIXUP_DELL4_MIC_NO_PRESENCE,
8490 {0x19, 0x40000000},
8491 {0x1b, 0x40000000}),
8492 SND_HDA_PIN_QUIRK(0x10ec0256, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
8493 {0x19, 0x40000000},
8494 {0x1a, 0x40000000}),
8495 SND_HDA_PIN_QUIRK(0x10ec0236, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
8496 {0x19, 0x40000000},
8497 {0x1a, 0x40000000}),
8498 SND_HDA_PIN_QUIRK(0x10ec0274, 0x1028, "Dell", ALC274_FIXUP_DELL_AIO_LINEOUT_VERB,
8499 {0x19, 0x40000000},
8500 {0x1a, 0x40000000}),
8501 {}
8502};
8503
8504static void alc269_fill_coef(struct hda_codec *codec)
8505{
8506 struct alc_spec *spec = codec->spec;
8507 int val;
8508
8509 if (spec->codec_variant != ALC269_TYPE_ALC269VB)
8510 return;
8511
8512 if ((alc_get_coef0(codec) & 0x00ff) < 0x015) {
8513 alc_write_coef_idx(codec, 0xf, 0x960b);
8514 alc_write_coef_idx(codec, 0xe, 0x8817);
8515 }
8516
8517 if ((alc_get_coef0(codec) & 0x00ff) == 0x016) {
8518 alc_write_coef_idx(codec, 0xf, 0x960b);
8519 alc_write_coef_idx(codec, 0xe, 0x8814);
8520 }
8521
8522 if ((alc_get_coef0(codec) & 0x00ff) == 0x017) {
8523
8524 alc_update_coef_idx(codec, 0x04, 0, 1<<11);
8525 }
8526
8527 if ((alc_get_coef0(codec) & 0x00ff) == 0x018) {
8528 val = alc_read_coef_idx(codec, 0xd);
8529 if (val != -1 && (val & 0x0c00) >> 10 != 0x1) {
8530
8531 alc_write_coef_idx(codec, 0xd, val | (1<<10));
8532 }
8533 val = alc_read_coef_idx(codec, 0x17);
8534 if (val != -1 && (val & 0x01c0) >> 6 != 0x4) {
8535
8536 alc_write_coef_idx(codec, 0x17, val | (1<<7));
8537 }
8538 }
8539
8540
8541 alc_update_coef_idx(codec, 0x4, 0, 1<<11);
8542}
8543
8544
8545
8546static int patch_alc269(struct hda_codec *codec)
8547{
8548 struct alc_spec *spec;
8549 int err;
8550
8551 err = alc_alloc_spec(codec, 0x0b);
8552 if (err < 0)
8553 return err;
8554
8555 spec = codec->spec;
8556 spec->gen.shared_mic_vref_pin = 0x18;
8557 codec->power_save_node = 0;
8558
8559#ifdef CONFIG_PM
8560 codec->patch_ops.suspend = alc269_suspend;
8561 codec->patch_ops.resume = alc269_resume;
8562#endif
8563 spec->shutup = alc_default_shutup;
8564 spec->init_hook = alc_default_init;
8565
8566 switch (codec->core.vendor_id) {
8567 case 0x10ec0269:
8568 spec->codec_variant = ALC269_TYPE_ALC269VA;
8569 switch (alc_get_coef0(codec) & 0x00f0) {
8570 case 0x0010:
8571 if (codec->bus->pci &&
8572 codec->bus->pci->subsystem_vendor == 0x1025 &&
8573 spec->cdefine.platform_type == 1)
8574 err = alc_codec_rename(codec, "ALC271X");
8575 spec->codec_variant = ALC269_TYPE_ALC269VB;
8576 break;
8577 case 0x0020:
8578 if (codec->bus->pci &&
8579 codec->bus->pci->subsystem_vendor == 0x17aa &&
8580 codec->bus->pci->subsystem_device == 0x21f3)
8581 err = alc_codec_rename(codec, "ALC3202");
8582 spec->codec_variant = ALC269_TYPE_ALC269VC;
8583 break;
8584 case 0x0030:
8585 spec->codec_variant = ALC269_TYPE_ALC269VD;
8586 break;
8587 default:
8588 alc_fix_pll_init(codec, 0x20, 0x04, 15);
8589 }
8590 if (err < 0)
8591 goto error;
8592 spec->shutup = alc269_shutup;
8593 spec->init_hook = alc269_fill_coef;
8594 alc269_fill_coef(codec);
8595 break;
8596
8597 case 0x10ec0280:
8598 case 0x10ec0290:
8599 spec->codec_variant = ALC269_TYPE_ALC280;
8600 break;
8601 case 0x10ec0282:
8602 spec->codec_variant = ALC269_TYPE_ALC282;
8603 spec->shutup = alc282_shutup;
8604 spec->init_hook = alc282_init;
8605 break;
8606 case 0x10ec0233:
8607 case 0x10ec0283:
8608 spec->codec_variant = ALC269_TYPE_ALC283;
8609 spec->shutup = alc283_shutup;
8610 spec->init_hook = alc283_init;
8611 break;
8612 case 0x10ec0284:
8613 case 0x10ec0292:
8614 spec->codec_variant = ALC269_TYPE_ALC284;
8615 break;
8616 case 0x10ec0293:
8617 spec->codec_variant = ALC269_TYPE_ALC293;
8618 break;
8619 case 0x10ec0286:
8620 case 0x10ec0288:
8621 spec->codec_variant = ALC269_TYPE_ALC286;
8622 break;
8623 case 0x10ec0298:
8624 spec->codec_variant = ALC269_TYPE_ALC298;
8625 break;
8626 case 0x10ec0235:
8627 case 0x10ec0255:
8628 spec->codec_variant = ALC269_TYPE_ALC255;
8629 spec->shutup = alc256_shutup;
8630 spec->init_hook = alc256_init;
8631 break;
8632 case 0x10ec0236:
8633 case 0x10ec0256:
8634 spec->codec_variant = ALC269_TYPE_ALC256;
8635 spec->shutup = alc256_shutup;
8636 spec->init_hook = alc256_init;
8637 spec->gen.mixer_nid = 0;
8638 break;
8639 case 0x10ec0257:
8640 spec->codec_variant = ALC269_TYPE_ALC257;
8641 spec->shutup = alc256_shutup;
8642 spec->init_hook = alc256_init;
8643 spec->gen.mixer_nid = 0;
8644 break;
8645 case 0x10ec0215:
8646 case 0x10ec0245:
8647 case 0x10ec0285:
8648 case 0x10ec0287:
8649 case 0x10ec0289:
8650 spec->codec_variant = ALC269_TYPE_ALC215;
8651 spec->shutup = alc225_shutup;
8652 spec->init_hook = alc225_init;
8653 spec->gen.mixer_nid = 0;
8654 break;
8655 case 0x10ec0225:
8656 case 0x10ec0295:
8657 case 0x10ec0299:
8658 spec->codec_variant = ALC269_TYPE_ALC225;
8659 spec->shutup = alc225_shutup;
8660 spec->init_hook = alc225_init;
8661 spec->gen.mixer_nid = 0;
8662 break;
8663 case 0x10ec0234:
8664 case 0x10ec0274:
8665 case 0x10ec0294:
8666 spec->codec_variant = ALC269_TYPE_ALC294;
8667 spec->gen.mixer_nid = 0;
8668 alc_update_coef_idx(codec, 0x6b, 0x0018, (1<<4) | (1<<3));
8669 spec->init_hook = alc294_init;
8670 break;
8671 case 0x10ec0300:
8672 spec->codec_variant = ALC269_TYPE_ALC300;
8673 spec->gen.mixer_nid = 0;
8674 break;
8675 case 0x10ec0623:
8676 spec->codec_variant = ALC269_TYPE_ALC623;
8677 break;
8678 case 0x10ec0700:
8679 case 0x10ec0701:
8680 case 0x10ec0703:
8681 case 0x10ec0711:
8682 spec->codec_variant = ALC269_TYPE_ALC700;
8683 spec->gen.mixer_nid = 0;
8684 alc_update_coef_idx(codec, 0x4a, 1 << 15, 0);
8685 spec->init_hook = alc294_init;
8686 break;
8687
8688 }
8689
8690 if (snd_hda_codec_read(codec, 0x51, 0, AC_VERB_PARAMETERS, 0) == 0x10ec5505) {
8691 spec->has_alc5505_dsp = 1;
8692 spec->init_hook = alc5505_dsp_init;
8693 }
8694
8695 alc_pre_init(codec);
8696
8697 snd_hda_pick_fixup(codec, alc269_fixup_models,
8698 alc269_fixup_tbl, alc269_fixups);
8699 snd_hda_pick_pin_fixup(codec, alc269_pin_fixup_tbl, alc269_fixups, true);
8700 snd_hda_pick_pin_fixup(codec, alc269_fallback_pin_fixup_tbl, alc269_fixups, false);
8701 snd_hda_pick_fixup(codec, NULL, alc269_fixup_vendor_tbl,
8702 alc269_fixups);
8703 snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE);
8704
8705 alc_auto_parse_customize_define(codec);
8706
8707 if (has_cdefine_beep(codec))
8708 spec->gen.beep_nid = 0x01;
8709
8710
8711 err = alc269_parse_auto_config(codec);
8712 if (err < 0)
8713 goto error;
8714
8715 if (!spec->gen.no_analog && spec->gen.beep_nid && spec->gen.mixer_nid) {
8716 err = set_beep_amp(spec, spec->gen.mixer_nid, 0x04, HDA_INPUT);
8717 if (err < 0)
8718 goto error;
8719 }
8720
8721 snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE);
8722
8723 return 0;
8724
8725 error:
8726 alc_free(codec);
8727 return err;
8728}
8729
8730
8731
8732
8733
8734static int alc861_parse_auto_config(struct hda_codec *codec)
8735{
8736 static const hda_nid_t alc861_ignore[] = { 0x1d, 0 };
8737 static const hda_nid_t alc861_ssids[] = { 0x0e, 0x0f, 0x0b, 0 };
8738 return alc_parse_auto_config(codec, alc861_ignore, alc861_ssids);
8739}
8740
8741
8742enum {
8743 ALC861_FIXUP_FSC_AMILO_PI1505,
8744 ALC861_FIXUP_AMP_VREF_0F,
8745 ALC861_FIXUP_NO_JACK_DETECT,
8746 ALC861_FIXUP_ASUS_A6RP,
8747 ALC660_FIXUP_ASUS_W7J,
8748};
8749
8750
8751static void alc861_fixup_asus_amp_vref_0f(struct hda_codec *codec,
8752 const struct hda_fixup *fix, int action)
8753{
8754 struct alc_spec *spec = codec->spec;
8755 unsigned int val;
8756
8757 if (action != HDA_FIXUP_ACT_INIT)
8758 return;
8759 val = snd_hda_codec_get_pin_target(codec, 0x0f);
8760 if (!(val & (AC_PINCTL_IN_EN | AC_PINCTL_OUT_EN)))
8761 val |= AC_PINCTL_IN_EN;
8762 val |= AC_PINCTL_VREF_50;
8763 snd_hda_set_pin_ctl(codec, 0x0f, val);
8764 spec->gen.keep_vref_in_automute = 1;
8765}
8766
8767
8768static void alc_fixup_no_jack_detect(struct hda_codec *codec,
8769 const struct hda_fixup *fix, int action)
8770{
8771 if (action == HDA_FIXUP_ACT_PRE_PROBE)
8772 codec->no_jack_detect = 1;
8773}
8774
8775static const struct hda_fixup alc861_fixups[] = {
8776 [ALC861_FIXUP_FSC_AMILO_PI1505] = {
8777 .type = HDA_FIXUP_PINS,
8778 .v.pins = (const struct hda_pintbl[]) {
8779 { 0x0b, 0x0221101f },
8780 { 0x0f, 0x90170310 },
8781 { }
8782 }
8783 },
8784 [ALC861_FIXUP_AMP_VREF_0F] = {
8785 .type = HDA_FIXUP_FUNC,
8786 .v.func = alc861_fixup_asus_amp_vref_0f,
8787 },
8788 [ALC861_FIXUP_NO_JACK_DETECT] = {
8789 .type = HDA_FIXUP_FUNC,
8790 .v.func = alc_fixup_no_jack_detect,
8791 },
8792 [ALC861_FIXUP_ASUS_A6RP] = {
8793 .type = HDA_FIXUP_FUNC,
8794 .v.func = alc861_fixup_asus_amp_vref_0f,
8795 .chained = true,
8796 .chain_id = ALC861_FIXUP_NO_JACK_DETECT,
8797 },
8798 [ALC660_FIXUP_ASUS_W7J] = {
8799 .type = HDA_FIXUP_VERBS,
8800 .v.verbs = (const struct hda_verb[]) {
8801
8802
8803
8804 {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
8805 { }
8806 },
8807 }
8808};
8809
8810static const struct snd_pci_quirk alc861_fixup_tbl[] = {
8811 SND_PCI_QUIRK(0x1043, 0x1253, "ASUS W7J", ALC660_FIXUP_ASUS_W7J),
8812 SND_PCI_QUIRK(0x1043, 0x1263, "ASUS Z35HL", ALC660_FIXUP_ASUS_W7J),
8813 SND_PCI_QUIRK(0x1043, 0x1393, "ASUS A6Rp", ALC861_FIXUP_ASUS_A6RP),
8814 SND_PCI_QUIRK_VENDOR(0x1043, "ASUS laptop", ALC861_FIXUP_AMP_VREF_0F),
8815 SND_PCI_QUIRK(0x1462, 0x7254, "HP DX2200", ALC861_FIXUP_NO_JACK_DETECT),
8816 SND_PCI_QUIRK(0x1584, 0x2b01, "Haier W18", ALC861_FIXUP_AMP_VREF_0F),
8817 SND_PCI_QUIRK(0x1584, 0x0000, "Uniwill ECS M31EI", ALC861_FIXUP_AMP_VREF_0F),
8818 SND_PCI_QUIRK(0x1734, 0x10c7, "FSC Amilo Pi1505", ALC861_FIXUP_FSC_AMILO_PI1505),
8819 {}
8820};
8821
8822
8823
8824static int patch_alc861(struct hda_codec *codec)
8825{
8826 struct alc_spec *spec;
8827 int err;
8828
8829 err = alc_alloc_spec(codec, 0x15);
8830 if (err < 0)
8831 return err;
8832
8833 spec = codec->spec;
8834 if (has_cdefine_beep(codec))
8835 spec->gen.beep_nid = 0x23;
8836
8837#ifdef CONFIG_PM
8838 spec->power_hook = alc_power_eapd;
8839#endif
8840
8841 alc_pre_init(codec);
8842
8843 snd_hda_pick_fixup(codec, NULL, alc861_fixup_tbl, alc861_fixups);
8844 snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE);
8845
8846
8847 err = alc861_parse_auto_config(codec);
8848 if (err < 0)
8849 goto error;
8850
8851 if (!spec->gen.no_analog) {
8852 err = set_beep_amp(spec, 0x23, 0, HDA_OUTPUT);
8853 if (err < 0)
8854 goto error;
8855 }
8856
8857 snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE);
8858
8859 return 0;
8860
8861 error:
8862 alc_free(codec);
8863 return err;
8864}
8865
8866
8867
8868
8869
8870
8871
8872
8873static int alc861vd_parse_auto_config(struct hda_codec *codec)
8874{
8875 static const hda_nid_t alc861vd_ignore[] = { 0x1d, 0 };
8876 static const hda_nid_t alc861vd_ssids[] = { 0x15, 0x1b, 0x14, 0 };
8877 return alc_parse_auto_config(codec, alc861vd_ignore, alc861vd_ssids);
8878}
8879
8880enum {
8881 ALC660VD_FIX_ASUS_GPIO1,
8882 ALC861VD_FIX_DALLAS,
8883};
8884
8885
8886static void alc861vd_fixup_dallas(struct hda_codec *codec,
8887 const struct hda_fixup *fix, int action)
8888{
8889 if (action == HDA_FIXUP_ACT_PRE_PROBE) {
8890 snd_hda_override_pin_caps(codec, 0x18, 0x00000734);
8891 snd_hda_override_pin_caps(codec, 0x19, 0x0000073c);
8892 }
8893}
8894
8895
8896static void alc660vd_fixup_asus_gpio1(struct hda_codec *codec,
8897 const struct hda_fixup *fix, int action)
8898{
8899 struct alc_spec *spec = codec->spec;
8900
8901 if (action == HDA_FIXUP_ACT_PRE_PROBE)
8902 spec->gpio_mask |= 0x02;
8903 alc_fixup_gpio(codec, action, 0x01);
8904}
8905
8906static const struct hda_fixup alc861vd_fixups[] = {
8907 [ALC660VD_FIX_ASUS_GPIO1] = {
8908 .type = HDA_FIXUP_FUNC,
8909 .v.func = alc660vd_fixup_asus_gpio1,
8910 },
8911 [ALC861VD_FIX_DALLAS] = {
8912 .type = HDA_FIXUP_FUNC,
8913 .v.func = alc861vd_fixup_dallas,
8914 },
8915};
8916
8917static const struct snd_pci_quirk alc861vd_fixup_tbl[] = {
8918 SND_PCI_QUIRK(0x103c, 0x30bf, "HP TX1000", ALC861VD_FIX_DALLAS),
8919 SND_PCI_QUIRK(0x1043, 0x1339, "ASUS A7-K", ALC660VD_FIX_ASUS_GPIO1),
8920 SND_PCI_QUIRK(0x1179, 0xff31, "Toshiba L30-149", ALC861VD_FIX_DALLAS),
8921 {}
8922};
8923
8924
8925
8926static int patch_alc861vd(struct hda_codec *codec)
8927{
8928 struct alc_spec *spec;
8929 int err;
8930
8931 err = alc_alloc_spec(codec, 0x0b);
8932 if (err < 0)
8933 return err;
8934
8935 spec = codec->spec;
8936 if (has_cdefine_beep(codec))
8937 spec->gen.beep_nid = 0x23;
8938
8939 spec->shutup = alc_eapd_shutup;
8940
8941 alc_pre_init(codec);
8942
8943 snd_hda_pick_fixup(codec, NULL, alc861vd_fixup_tbl, alc861vd_fixups);
8944 snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE);
8945
8946
8947 err = alc861vd_parse_auto_config(codec);
8948 if (err < 0)
8949 goto error;
8950
8951 if (!spec->gen.no_analog) {
8952 err = set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
8953 if (err < 0)
8954 goto error;
8955 }
8956
8957 snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE);
8958
8959 return 0;
8960
8961 error:
8962 alc_free(codec);
8963 return err;
8964}
8965
8966
8967
8968
8969
8970
8971
8972
8973
8974
8975
8976
8977
8978
8979
8980
8981
8982static int alc662_parse_auto_config(struct hda_codec *codec)
8983{
8984 static const hda_nid_t alc662_ignore[] = { 0x1d, 0 };
8985 static const hda_nid_t alc663_ssids[] = { 0x15, 0x1b, 0x14, 0x21 };
8986 static const hda_nid_t alc662_ssids[] = { 0x15, 0x1b, 0x14, 0 };
8987 const hda_nid_t *ssids;
8988
8989 if (codec->core.vendor_id == 0x10ec0272 || codec->core.vendor_id == 0x10ec0663 ||
8990 codec->core.vendor_id == 0x10ec0665 || codec->core.vendor_id == 0x10ec0670 ||
8991 codec->core.vendor_id == 0x10ec0671)
8992 ssids = alc663_ssids;
8993 else
8994 ssids = alc662_ssids;
8995 return alc_parse_auto_config(codec, alc662_ignore, ssids);
8996}
8997
8998static void alc272_fixup_mario(struct hda_codec *codec,
8999 const struct hda_fixup *fix, int action)
9000{
9001 if (action != HDA_FIXUP_ACT_PRE_PROBE)
9002 return;
9003 if (snd_hda_override_amp_caps(codec, 0x2, HDA_OUTPUT,
9004 (0x3b << AC_AMPCAP_OFFSET_SHIFT) |
9005 (0x3b << AC_AMPCAP_NUM_STEPS_SHIFT) |
9006 (0x03 << AC_AMPCAP_STEP_SIZE_SHIFT) |
9007 (0 << AC_AMPCAP_MUTE_SHIFT)))
9008 codec_warn(codec, "failed to override amp caps for NID 0x2\n");
9009}
9010
9011static const struct snd_pcm_chmap_elem asus_pcm_2_1_chmaps[] = {
9012 { .channels = 2,
9013 .map = { SNDRV_CHMAP_FL, SNDRV_CHMAP_FR } },
9014 { .channels = 4,
9015 .map = { SNDRV_CHMAP_FL, SNDRV_CHMAP_FR,
9016 SNDRV_CHMAP_NA, SNDRV_CHMAP_LFE } },
9017 { }
9018};
9019
9020
9021static void alc_fixup_bass_chmap(struct hda_codec *codec,
9022 const struct hda_fixup *fix, int action)
9023{
9024 if (action == HDA_FIXUP_ACT_BUILD) {
9025 struct alc_spec *spec = codec->spec;
9026 spec->gen.pcm_rec[0]->stream[0].chmap = asus_pcm_2_1_chmaps;
9027 }
9028}
9029
9030
9031static unsigned int gpio_led_power_filter(struct hda_codec *codec,
9032 hda_nid_t nid,
9033 unsigned int power_state)
9034{
9035 struct alc_spec *spec = codec->spec;
9036 if (nid == codec->core.afg && power_state == AC_PWRST_D3 && spec->gpio_data)
9037 return AC_PWRST_D0;
9038 return power_state;
9039}
9040
9041static void alc662_fixup_led_gpio1(struct hda_codec *codec,
9042 const struct hda_fixup *fix, int action)
9043{
9044 struct alc_spec *spec = codec->spec;
9045
9046 alc_fixup_hp_gpio_led(codec, action, 0x01, 0);
9047 if (action == HDA_FIXUP_ACT_PRE_PROBE) {
9048 spec->mute_led_polarity = 1;
9049 codec->power_filter = gpio_led_power_filter;
9050 }
9051}
9052
9053static void alc662_usi_automute_hook(struct hda_codec *codec,
9054 struct hda_jack_callback *jack)
9055{
9056 struct alc_spec *spec = codec->spec;
9057 int vref;
9058 msleep(200);
9059 snd_hda_gen_hp_automute(codec, jack);
9060
9061 vref = spec->gen.hp_jack_present ? PIN_VREF80 : 0;
9062 msleep(100);
9063 snd_hda_codec_write(codec, 0x19, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
9064 vref);
9065}
9066
9067static void alc662_fixup_usi_headset_mic(struct hda_codec *codec,
9068 const struct hda_fixup *fix, int action)
9069{
9070 struct alc_spec *spec = codec->spec;
9071 if (action == HDA_FIXUP_ACT_PRE_PROBE) {
9072 spec->parse_flags |= HDA_PINCFG_HEADSET_MIC;
9073 spec->gen.hp_automute_hook = alc662_usi_automute_hook;
9074 }
9075}
9076
9077static void alc662_aspire_ethos_mute_speakers(struct hda_codec *codec,
9078 struct hda_jack_callback *cb)
9079{
9080
9081
9082
9083
9084
9085
9086 if (snd_hda_jack_detect_state(codec, 0x1b) == HDA_JACK_PRESENT) {
9087 snd_hda_set_pin_ctl_cache(codec, 0x15, 0);
9088 snd_hda_set_pin_ctl_cache(codec, 0x18, 0);
9089 } else {
9090 snd_hda_set_pin_ctl_cache(codec, 0x15, PIN_OUT);
9091 snd_hda_set_pin_ctl_cache(codec, 0x18, PIN_OUT);
9092 }
9093}
9094
9095static void alc662_fixup_aspire_ethos_hp(struct hda_codec *codec,
9096 const struct hda_fixup *fix, int action)
9097{
9098
9099 if (!is_jack_detectable(codec, 0x1b))
9100 return;
9101
9102 switch (action) {
9103 case HDA_FIXUP_ACT_PRE_PROBE:
9104 snd_hda_jack_detect_enable_callback(codec, 0x1b,
9105 alc662_aspire_ethos_mute_speakers);
9106
9107 alc_setup_gpio(codec, 0x02);
9108 break;
9109 case HDA_FIXUP_ACT_INIT:
9110
9111
9112
9113 alc662_aspire_ethos_mute_speakers(codec, NULL);
9114 break;
9115 }
9116}
9117
9118static void alc671_fixup_hp_headset_mic2(struct hda_codec *codec,
9119 const struct hda_fixup *fix, int action)
9120{
9121 struct alc_spec *spec = codec->spec;
9122
9123 static const struct hda_pintbl pincfgs[] = {
9124 { 0x19, 0x02a11040 },
9125 { 0x1b, 0x0181304f },
9126 { }
9127 };
9128
9129 switch (action) {
9130 case HDA_FIXUP_ACT_PRE_PROBE:
9131 spec->gen.mixer_nid = 0;
9132 spec->parse_flags |= HDA_PINCFG_HEADSET_MIC;
9133 snd_hda_apply_pincfgs(codec, pincfgs);
9134 break;
9135 case HDA_FIXUP_ACT_INIT:
9136 alc_write_coef_idx(codec, 0x19, 0xa054);
9137 break;
9138 }
9139}
9140
9141static const struct coef_fw alc668_coefs[] = {
9142 WRITE_COEF(0x01, 0xbebe), WRITE_COEF(0x02, 0xaaaa), WRITE_COEF(0x03, 0x0),
9143 WRITE_COEF(0x04, 0x0180), WRITE_COEF(0x06, 0x0), WRITE_COEF(0x07, 0x0f80),
9144 WRITE_COEF(0x08, 0x0031), WRITE_COEF(0x0a, 0x0060), WRITE_COEF(0x0b, 0x0),
9145 WRITE_COEF(0x0c, 0x7cf7), WRITE_COEF(0x0d, 0x1080), WRITE_COEF(0x0e, 0x7f7f),
9146 WRITE_COEF(0x0f, 0xcccc), WRITE_COEF(0x10, 0xddcc), WRITE_COEF(0x11, 0x0001),
9147 WRITE_COEF(0x13, 0x0), WRITE_COEF(0x14, 0x2aa0), WRITE_COEF(0x17, 0xa940),
9148 WRITE_COEF(0x19, 0x0), WRITE_COEF(0x1a, 0x0), WRITE_COEF(0x1b, 0x0),
9149 WRITE_COEF(0x1c, 0x0), WRITE_COEF(0x1d, 0x0), WRITE_COEF(0x1e, 0x7418),
9150 WRITE_COEF(0x1f, 0x0804), WRITE_COEF(0x20, 0x4200), WRITE_COEF(0x21, 0x0468),
9151 WRITE_COEF(0x22, 0x8ccc), WRITE_COEF(0x23, 0x0250), WRITE_COEF(0x24, 0x7418),
9152 WRITE_COEF(0x27, 0x0), WRITE_COEF(0x28, 0x8ccc), WRITE_COEF(0x2a, 0xff00),
9153 WRITE_COEF(0x2b, 0x8000), WRITE_COEF(0xa7, 0xff00), WRITE_COEF(0xa8, 0x8000),
9154 WRITE_COEF(0xaa, 0x2e17), WRITE_COEF(0xab, 0xa0c0), WRITE_COEF(0xac, 0x0),
9155 WRITE_COEF(0xad, 0x0), WRITE_COEF(0xae, 0x2ac6), WRITE_COEF(0xaf, 0xa480),
9156 WRITE_COEF(0xb0, 0x0), WRITE_COEF(0xb1, 0x0), WRITE_COEF(0xb2, 0x0),
9157 WRITE_COEF(0xb3, 0x0), WRITE_COEF(0xb4, 0x0), WRITE_COEF(0xb5, 0x1040),
9158 WRITE_COEF(0xb6, 0xd697), WRITE_COEF(0xb7, 0x902b), WRITE_COEF(0xb8, 0xd697),
9159 WRITE_COEF(0xb9, 0x902b), WRITE_COEF(0xba, 0xb8ba), WRITE_COEF(0xbb, 0xaaab),
9160 WRITE_COEF(0xbc, 0xaaaf), WRITE_COEF(0xbd, 0x6aaa), WRITE_COEF(0xbe, 0x1c02),
9161 WRITE_COEF(0xc0, 0x00ff), WRITE_COEF(0xc1, 0x0fa6),
9162 {}
9163};
9164
9165static void alc668_restore_default_value(struct hda_codec *codec)
9166{
9167 alc_process_coef_fw(codec, alc668_coefs);
9168}
9169
9170enum {
9171 ALC662_FIXUP_ASPIRE,
9172 ALC662_FIXUP_LED_GPIO1,
9173 ALC662_FIXUP_IDEAPAD,
9174 ALC272_FIXUP_MARIO,
9175 ALC662_FIXUP_CZC_ET26,
9176 ALC662_FIXUP_CZC_P10T,
9177 ALC662_FIXUP_SKU_IGNORE,
9178 ALC662_FIXUP_HP_RP5800,
9179 ALC662_FIXUP_ASUS_MODE1,
9180 ALC662_FIXUP_ASUS_MODE2,
9181 ALC662_FIXUP_ASUS_MODE3,
9182 ALC662_FIXUP_ASUS_MODE4,
9183 ALC662_FIXUP_ASUS_MODE5,
9184 ALC662_FIXUP_ASUS_MODE6,
9185 ALC662_FIXUP_ASUS_MODE7,
9186 ALC662_FIXUP_ASUS_MODE8,
9187 ALC662_FIXUP_NO_JACK_DETECT,
9188 ALC662_FIXUP_ZOTAC_Z68,
9189 ALC662_FIXUP_INV_DMIC,
9190 ALC662_FIXUP_DELL_MIC_NO_PRESENCE,
9191 ALC668_FIXUP_DELL_MIC_NO_PRESENCE,
9192 ALC662_FIXUP_HEADSET_MODE,
9193 ALC668_FIXUP_HEADSET_MODE,
9194 ALC662_FIXUP_BASS_MODE4_CHMAP,
9195 ALC662_FIXUP_BASS_16,
9196 ALC662_FIXUP_BASS_1A,
9197 ALC662_FIXUP_BASS_CHMAP,
9198 ALC668_FIXUP_AUTO_MUTE,
9199 ALC668_FIXUP_DELL_DISABLE_AAMIX,
9200 ALC668_FIXUP_DELL_XPS13,
9201 ALC662_FIXUP_ASUS_Nx50,
9202 ALC668_FIXUP_ASUS_Nx51_HEADSET_MODE,
9203 ALC668_FIXUP_ASUS_Nx51,
9204 ALC668_FIXUP_MIC_COEF,
9205 ALC668_FIXUP_ASUS_G751,
9206 ALC891_FIXUP_HEADSET_MODE,
9207 ALC891_FIXUP_DELL_MIC_NO_PRESENCE,
9208 ALC662_FIXUP_ACER_VERITON,
9209 ALC892_FIXUP_ASROCK_MOBO,
9210 ALC662_FIXUP_USI_FUNC,
9211 ALC662_FIXUP_USI_HEADSET_MODE,
9212 ALC662_FIXUP_LENOVO_MULTI_CODECS,
9213 ALC669_FIXUP_ACER_ASPIRE_ETHOS,
9214 ALC669_FIXUP_ACER_ASPIRE_ETHOS_HEADSET,
9215 ALC671_FIXUP_HP_HEADSET_MIC2,
9216 ALC662_FIXUP_ACER_X2660G_HEADSET_MODE,
9217 ALC662_FIXUP_ACER_NITRO_HEADSET_MODE,
9218};
9219
9220static const struct hda_fixup alc662_fixups[] = {
9221 [ALC662_FIXUP_ASPIRE] = {
9222 .type = HDA_FIXUP_PINS,
9223 .v.pins = (const struct hda_pintbl[]) {
9224 { 0x15, 0x99130112 },
9225 { }
9226 }
9227 },
9228 [ALC662_FIXUP_LED_GPIO1] = {
9229 .type = HDA_FIXUP_FUNC,
9230 .v.func = alc662_fixup_led_gpio1,
9231 },
9232 [ALC662_FIXUP_IDEAPAD] = {
9233 .type = HDA_FIXUP_PINS,
9234 .v.pins = (const struct hda_pintbl[]) {
9235 { 0x17, 0x99130112 },
9236 { }
9237 },
9238 .chained = true,
9239 .chain_id = ALC662_FIXUP_LED_GPIO1,
9240 },
9241 [ALC272_FIXUP_MARIO] = {
9242 .type = HDA_FIXUP_FUNC,
9243 .v.func = alc272_fixup_mario,
9244 },
9245 [ALC662_FIXUP_CZC_ET26] = {
9246 .type = HDA_FIXUP_PINS,
9247 .v.pins = (const struct hda_pintbl[]) {
9248 {0x12, 0x403cc000},
9249 {0x14, 0x90170110},
9250 {0x15, 0x411111f0},
9251 {0x16, 0x411111f0},
9252 {0x18, 0x01a19030},
9253 {0x19, 0x90a7013f},
9254 {0x1a, 0x01014020},
9255 {0x1b, 0x0121401f},
9256 {0x1c, 0x411111f0},
9257 {0x1d, 0x411111f0},
9258 {0x1e, 0x40478e35},
9259 {}
9260 },
9261 .chained = true,
9262 .chain_id = ALC662_FIXUP_SKU_IGNORE
9263 },
9264 [ALC662_FIXUP_CZC_P10T] = {
9265 .type = HDA_FIXUP_VERBS,
9266 .v.verbs = (const struct hda_verb[]) {
9267 {0x14, AC_VERB_SET_EAPD_BTLENABLE, 0},
9268 {}
9269 }
9270 },
9271 [ALC662_FIXUP_SKU_IGNORE] = {
9272 .type = HDA_FIXUP_FUNC,
9273 .v.func = alc_fixup_sku_ignore,
9274 },
9275 [ALC662_FIXUP_HP_RP5800] = {
9276 .type = HDA_FIXUP_PINS,
9277 .v.pins = (const struct hda_pintbl[]) {
9278 { 0x14, 0x0221201f },
9279 { }
9280 },
9281 .chained = true,
9282 .chain_id = ALC662_FIXUP_SKU_IGNORE
9283 },
9284 [ALC662_FIXUP_ASUS_MODE1] = {
9285 .type = HDA_FIXUP_PINS,
9286 .v.pins = (const struct hda_pintbl[]) {
9287 { 0x14, 0x99130110 },
9288 { 0x18, 0x01a19c20 },
9289 { 0x19, 0x99a3092f },
9290 { 0x21, 0x0121401f },
9291 { }
9292 },
9293 .chained = true,
9294 .chain_id = ALC662_FIXUP_SKU_IGNORE
9295 },
9296 [ALC662_FIXUP_ASUS_MODE2] = {
9297 .type = HDA_FIXUP_PINS,
9298 .v.pins = (const struct hda_pintbl[]) {
9299 { 0x14, 0x99130110 },
9300 { 0x18, 0x01a19820 },
9301 { 0x19, 0x99a3092f },
9302 { 0x1b, 0x0121401f },
9303 { }
9304 },
9305 .chained = true,
9306 .chain_id = ALC662_FIXUP_SKU_IGNORE
9307 },
9308 [ALC662_FIXUP_ASUS_MODE3] = {
9309 .type = HDA_FIXUP_PINS,
9310 .v.pins = (const struct hda_pintbl[]) {
9311 { 0x14, 0x99130110 },
9312 { 0x15, 0x0121441f },
9313 { 0x18, 0x01a19840 },
9314 { 0x19, 0x99a3094f },
9315 { 0x21, 0x01211420 },
9316 { }
9317 },
9318 .chained = true,
9319 .chain_id = ALC662_FIXUP_SKU_IGNORE
9320 },
9321 [ALC662_FIXUP_ASUS_MODE4] = {
9322 .type = HDA_FIXUP_PINS,
9323 .v.pins = (const struct hda_pintbl[]) {
9324 { 0x14, 0x99130110 },
9325 { 0x16, 0x99130111 },
9326 { 0x18, 0x01a19840 },
9327 { 0x19, 0x99a3094f },
9328 { 0x21, 0x0121441f },
9329 { }
9330 },
9331 .chained = true,
9332 .chain_id = ALC662_FIXUP_SKU_IGNORE
9333 },
9334 [ALC662_FIXUP_ASUS_MODE5] = {
9335 .type = HDA_FIXUP_PINS,
9336 .v.pins = (const struct hda_pintbl[]) {
9337 { 0x14, 0x99130110 },
9338 { 0x15, 0x0121441f },
9339 { 0x16, 0x99130111 },
9340 { 0x18, 0x01a19840 },
9341 { 0x19, 0x99a3094f },
9342 { }
9343 },
9344 .chained = true,
9345 .chain_id = ALC662_FIXUP_SKU_IGNORE
9346 },
9347 [ALC662_FIXUP_ASUS_MODE6] = {
9348 .type = HDA_FIXUP_PINS,
9349 .v.pins = (const struct hda_pintbl[]) {
9350 { 0x14, 0x99130110 },
9351 { 0x15, 0x01211420 },
9352 { 0x18, 0x01a19840 },
9353 { 0x19, 0x99a3094f },
9354 { 0x1b, 0x0121441f },
9355 { }
9356 },
9357 .chained = true,
9358 .chain_id = ALC662_FIXUP_SKU_IGNORE
9359 },
9360 [ALC662_FIXUP_ASUS_MODE7] = {
9361 .type = HDA_FIXUP_PINS,
9362 .v.pins = (const struct hda_pintbl[]) {
9363 { 0x14, 0x99130110 },
9364 { 0x17, 0x99130111 },
9365 { 0x18, 0x01a19840 },
9366 { 0x19, 0x99a3094f },
9367 { 0x1b, 0x01214020 },
9368 { 0x21, 0x0121401f },
9369 { }
9370 },
9371 .chained = true,
9372 .chain_id = ALC662_FIXUP_SKU_IGNORE
9373 },
9374 [ALC662_FIXUP_ASUS_MODE8] = {
9375 .type = HDA_FIXUP_PINS,
9376 .v.pins = (const struct hda_pintbl[]) {
9377 { 0x14, 0x99130110 },
9378 { 0x12, 0x99a30970 },
9379 { 0x15, 0x01214020 },
9380 { 0x17, 0x99130111 },
9381 { 0x18, 0x01a19840 },
9382 { 0x21, 0x0121401f },
9383 { }
9384 },
9385 .chained = true,
9386 .chain_id = ALC662_FIXUP_SKU_IGNORE
9387 },
9388 [ALC662_FIXUP_NO_JACK_DETECT] = {
9389 .type = HDA_FIXUP_FUNC,
9390 .v.func = alc_fixup_no_jack_detect,
9391 },
9392 [ALC662_FIXUP_ZOTAC_Z68] = {
9393 .type = HDA_FIXUP_PINS,
9394 .v.pins = (const struct hda_pintbl[]) {
9395 { 0x1b, 0x02214020 },
9396 { }
9397 }
9398 },
9399 [ALC662_FIXUP_INV_DMIC] = {
9400 .type = HDA_FIXUP_FUNC,
9401 .v.func = alc_fixup_inv_dmic,
9402 },
9403 [ALC668_FIXUP_DELL_XPS13] = {
9404 .type = HDA_FIXUP_FUNC,
9405 .v.func = alc_fixup_dell_xps13,
9406 .chained = true,
9407 .chain_id = ALC668_FIXUP_DELL_DISABLE_AAMIX
9408 },
9409 [ALC668_FIXUP_DELL_DISABLE_AAMIX] = {
9410 .type = HDA_FIXUP_FUNC,
9411 .v.func = alc_fixup_disable_aamix,
9412 .chained = true,
9413 .chain_id = ALC668_FIXUP_DELL_MIC_NO_PRESENCE
9414 },
9415 [ALC668_FIXUP_AUTO_MUTE] = {
9416 .type = HDA_FIXUP_FUNC,
9417 .v.func = alc_fixup_auto_mute_via_amp,
9418 .chained = true,
9419 .chain_id = ALC668_FIXUP_DELL_MIC_NO_PRESENCE
9420 },
9421 [ALC662_FIXUP_DELL_MIC_NO_PRESENCE] = {
9422 .type = HDA_FIXUP_PINS,
9423 .v.pins = (const struct hda_pintbl[]) {
9424 { 0x19, 0x03a1113c },
9425
9426 { }
9427 },
9428 .chained = true,
9429 .chain_id = ALC662_FIXUP_HEADSET_MODE
9430 },
9431 [ALC662_FIXUP_HEADSET_MODE] = {
9432 .type = HDA_FIXUP_FUNC,
9433 .v.func = alc_fixup_headset_mode_alc662,
9434 },
9435 [ALC668_FIXUP_DELL_MIC_NO_PRESENCE] = {
9436 .type = HDA_FIXUP_PINS,
9437 .v.pins = (const struct hda_pintbl[]) {
9438 { 0x19, 0x03a1913d },
9439 { 0x1b, 0x03a1113c },
9440 { }
9441 },
9442 .chained = true,
9443 .chain_id = ALC668_FIXUP_HEADSET_MODE
9444 },
9445 [ALC668_FIXUP_HEADSET_MODE] = {
9446 .type = HDA_FIXUP_FUNC,
9447 .v.func = alc_fixup_headset_mode_alc668,
9448 },
9449 [ALC662_FIXUP_BASS_MODE4_CHMAP] = {
9450 .type = HDA_FIXUP_FUNC,
9451 .v.func = alc_fixup_bass_chmap,
9452 .chained = true,
9453 .chain_id = ALC662_FIXUP_ASUS_MODE4
9454 },
9455 [ALC662_FIXUP_BASS_16] = {
9456 .type = HDA_FIXUP_PINS,
9457 .v.pins = (const struct hda_pintbl[]) {
9458 {0x16, 0x80106111},
9459 {}
9460 },
9461 .chained = true,
9462 .chain_id = ALC662_FIXUP_BASS_CHMAP,
9463 },
9464 [ALC662_FIXUP_BASS_1A] = {
9465 .type = HDA_FIXUP_PINS,
9466 .v.pins = (const struct hda_pintbl[]) {
9467 {0x1a, 0x80106111},
9468 {}
9469 },
9470 .chained = true,
9471 .chain_id = ALC662_FIXUP_BASS_CHMAP,
9472 },
9473 [ALC662_FIXUP_BASS_CHMAP] = {
9474 .type = HDA_FIXUP_FUNC,
9475 .v.func = alc_fixup_bass_chmap,
9476 },
9477 [ALC662_FIXUP_ASUS_Nx50] = {
9478 .type = HDA_FIXUP_FUNC,
9479 .v.func = alc_fixup_auto_mute_via_amp,
9480 .chained = true,
9481 .chain_id = ALC662_FIXUP_BASS_1A
9482 },
9483 [ALC668_FIXUP_ASUS_Nx51_HEADSET_MODE] = {
9484 .type = HDA_FIXUP_FUNC,
9485 .v.func = alc_fixup_headset_mode_alc668,
9486 .chain_id = ALC662_FIXUP_BASS_CHMAP
9487 },
9488 [ALC668_FIXUP_ASUS_Nx51] = {
9489 .type = HDA_FIXUP_PINS,
9490 .v.pins = (const struct hda_pintbl[]) {
9491 { 0x19, 0x03a1913d },
9492 { 0x1a, 0x90170151 },
9493 { 0x1b, 0x03a1113c },
9494 {}
9495 },
9496 .chained = true,
9497 .chain_id = ALC668_FIXUP_ASUS_Nx51_HEADSET_MODE,
9498 },
9499 [ALC668_FIXUP_MIC_COEF] = {
9500 .type = HDA_FIXUP_VERBS,
9501 .v.verbs = (const struct hda_verb[]) {
9502 { 0x20, AC_VERB_SET_COEF_INDEX, 0xc3 },
9503 { 0x20, AC_VERB_SET_PROC_COEF, 0x4000 },
9504 {}
9505 },
9506 },
9507 [ALC668_FIXUP_ASUS_G751] = {
9508 .type = HDA_FIXUP_PINS,
9509 .v.pins = (const struct hda_pintbl[]) {
9510 { 0x16, 0x0421101f },
9511 {}
9512 },
9513 .chained = true,
9514 .chain_id = ALC668_FIXUP_MIC_COEF
9515 },
9516 [ALC891_FIXUP_HEADSET_MODE] = {
9517 .type = HDA_FIXUP_FUNC,
9518 .v.func = alc_fixup_headset_mode,
9519 },
9520 [ALC891_FIXUP_DELL_MIC_NO_PRESENCE] = {
9521 .type = HDA_FIXUP_PINS,
9522 .v.pins = (const struct hda_pintbl[]) {
9523 { 0x19, 0x03a1913d },
9524 { 0x1b, 0x03a1113c },
9525 { }
9526 },
9527 .chained = true,
9528 .chain_id = ALC891_FIXUP_HEADSET_MODE
9529 },
9530 [ALC662_FIXUP_ACER_VERITON] = {
9531 .type = HDA_FIXUP_PINS,
9532 .v.pins = (const struct hda_pintbl[]) {
9533 { 0x15, 0x50170120 },
9534 { }
9535 }
9536 },
9537 [ALC892_FIXUP_ASROCK_MOBO] = {
9538 .type = HDA_FIXUP_PINS,
9539 .v.pins = (const struct hda_pintbl[]) {
9540 { 0x15, 0x40f000f0 },
9541 { 0x16, 0x40f000f0 },
9542 { }
9543 }
9544 },
9545 [ALC662_FIXUP_USI_FUNC] = {
9546 .type = HDA_FIXUP_FUNC,
9547 .v.func = alc662_fixup_usi_headset_mic,
9548 },
9549 [ALC662_FIXUP_USI_HEADSET_MODE] = {
9550 .type = HDA_FIXUP_PINS,
9551 .v.pins = (const struct hda_pintbl[]) {
9552 { 0x19, 0x02a1913c },
9553 { 0x18, 0x01a1903d },
9554 { }
9555 },
9556 .chained = true,
9557 .chain_id = ALC662_FIXUP_USI_FUNC
9558 },
9559 [ALC662_FIXUP_LENOVO_MULTI_CODECS] = {
9560 .type = HDA_FIXUP_FUNC,
9561 .v.func = alc233_alc662_fixup_lenovo_dual_codecs,
9562 },
9563 [ALC669_FIXUP_ACER_ASPIRE_ETHOS_HEADSET] = {
9564 .type = HDA_FIXUP_FUNC,
9565 .v.func = alc662_fixup_aspire_ethos_hp,
9566 },
9567 [ALC669_FIXUP_ACER_ASPIRE_ETHOS] = {
9568 .type = HDA_FIXUP_PINS,
9569 .v.pins = (const struct hda_pintbl[]) {
9570 { 0x15, 0x92130110 },
9571 { 0x18, 0x99130111 },
9572 { 0x1b, 0x11130012 },
9573 { }
9574 },
9575 .chained = true,
9576 .chain_id = ALC669_FIXUP_ACER_ASPIRE_ETHOS_HEADSET
9577 },
9578 [ALC671_FIXUP_HP_HEADSET_MIC2] = {
9579 .type = HDA_FIXUP_FUNC,
9580 .v.func = alc671_fixup_hp_headset_mic2,
9581 },
9582 [ALC662_FIXUP_ACER_X2660G_HEADSET_MODE] = {
9583 .type = HDA_FIXUP_PINS,
9584 .v.pins = (const struct hda_pintbl[]) {
9585 { 0x1a, 0x02a1113c },
9586 { }
9587 },
9588 .chained = true,
9589 .chain_id = ALC662_FIXUP_USI_FUNC
9590 },
9591 [ALC662_FIXUP_ACER_NITRO_HEADSET_MODE] = {
9592 .type = HDA_FIXUP_PINS,
9593 .v.pins = (const struct hda_pintbl[]) {
9594 { 0x1a, 0x01a11140 },
9595 { 0x1b, 0x0221144f },
9596 { }
9597 },
9598 .chained = true,
9599 .chain_id = ALC662_FIXUP_USI_FUNC
9600 },
9601};
9602
9603static const struct snd_pci_quirk alc662_fixup_tbl[] = {
9604 SND_PCI_QUIRK(0x1019, 0x9087, "ECS", ALC662_FIXUP_ASUS_MODE2),
9605 SND_PCI_QUIRK(0x1025, 0x022f, "Acer Aspire One", ALC662_FIXUP_INV_DMIC),
9606 SND_PCI_QUIRK(0x1025, 0x0241, "Packard Bell DOTS", ALC662_FIXUP_INV_DMIC),
9607 SND_PCI_QUIRK(0x1025, 0x0308, "Acer Aspire 8942G", ALC662_FIXUP_ASPIRE),
9608 SND_PCI_QUIRK(0x1025, 0x031c, "Gateway NV79", ALC662_FIXUP_SKU_IGNORE),
9609 SND_PCI_QUIRK(0x1025, 0x0349, "eMachines eM250", ALC662_FIXUP_INV_DMIC),
9610 SND_PCI_QUIRK(0x1025, 0x034a, "Gateway LT27", ALC662_FIXUP_INV_DMIC),
9611 SND_PCI_QUIRK(0x1025, 0x038b, "Acer Aspire 8943G", ALC662_FIXUP_ASPIRE),
9612 SND_PCI_QUIRK(0x1025, 0x123c, "Acer Nitro N50-600", ALC662_FIXUP_ACER_NITRO_HEADSET_MODE),
9613 SND_PCI_QUIRK(0x1025, 0x124e, "Acer 2660G", ALC662_FIXUP_ACER_X2660G_HEADSET_MODE),
9614 SND_PCI_QUIRK(0x1028, 0x05d8, "Dell", ALC668_FIXUP_DELL_MIC_NO_PRESENCE),
9615 SND_PCI_QUIRK(0x1028, 0x05db, "Dell", ALC668_FIXUP_DELL_MIC_NO_PRESENCE),
9616 SND_PCI_QUIRK(0x1028, 0x05fe, "Dell XPS 15", ALC668_FIXUP_DELL_XPS13),
9617 SND_PCI_QUIRK(0x1028, 0x060a, "Dell XPS 13", ALC668_FIXUP_DELL_XPS13),
9618 SND_PCI_QUIRK(0x1028, 0x060d, "Dell M3800", ALC668_FIXUP_DELL_XPS13),
9619 SND_PCI_QUIRK(0x1028, 0x0625, "Dell", ALC668_FIXUP_DELL_MIC_NO_PRESENCE),
9620 SND_PCI_QUIRK(0x1028, 0x0626, "Dell", ALC668_FIXUP_DELL_MIC_NO_PRESENCE),
9621 SND_PCI_QUIRK(0x1028, 0x0696, "Dell", ALC668_FIXUP_DELL_MIC_NO_PRESENCE),
9622 SND_PCI_QUIRK(0x1028, 0x0698, "Dell", ALC668_FIXUP_DELL_MIC_NO_PRESENCE),
9623 SND_PCI_QUIRK(0x1028, 0x069f, "Dell", ALC668_FIXUP_DELL_MIC_NO_PRESENCE),
9624 SND_PCI_QUIRK(0x103c, 0x1632, "HP RP5800", ALC662_FIXUP_HP_RP5800),
9625 SND_PCI_QUIRK(0x1043, 0x1080, "Asus UX501VW", ALC668_FIXUP_HEADSET_MODE),
9626 SND_PCI_QUIRK(0x1043, 0x11cd, "Asus N550", ALC662_FIXUP_ASUS_Nx50),
9627 SND_PCI_QUIRK(0x1043, 0x13df, "Asus N550JX", ALC662_FIXUP_BASS_1A),
9628 SND_PCI_QUIRK(0x1043, 0x129d, "Asus N750", ALC662_FIXUP_ASUS_Nx50),
9629 SND_PCI_QUIRK(0x1043, 0x12ff, "ASUS G751", ALC668_FIXUP_ASUS_G751),
9630 SND_PCI_QUIRK(0x1043, 0x1477, "ASUS N56VZ", ALC662_FIXUP_BASS_MODE4_CHMAP),
9631 SND_PCI_QUIRK(0x1043, 0x15a7, "ASUS UX51VZH", ALC662_FIXUP_BASS_16),
9632 SND_PCI_QUIRK(0x1043, 0x177d, "ASUS N551", ALC668_FIXUP_ASUS_Nx51),
9633 SND_PCI_QUIRK(0x1043, 0x17bd, "ASUS N751", ALC668_FIXUP_ASUS_Nx51),
9634 SND_PCI_QUIRK(0x1043, 0x1963, "ASUS X71SL", ALC662_FIXUP_ASUS_MODE8),
9635 SND_PCI_QUIRK(0x1043, 0x1b73, "ASUS N55SF", ALC662_FIXUP_BASS_16),
9636 SND_PCI_QUIRK(0x1043, 0x1bf3, "ASUS N76VZ", ALC662_FIXUP_BASS_MODE4_CHMAP),
9637 SND_PCI_QUIRK(0x1043, 0x8469, "ASUS mobo", ALC662_FIXUP_NO_JACK_DETECT),
9638 SND_PCI_QUIRK(0x105b, 0x0cd6, "Foxconn", ALC662_FIXUP_ASUS_MODE2),
9639 SND_PCI_QUIRK(0x144d, 0xc051, "Samsung R720", ALC662_FIXUP_IDEAPAD),
9640 SND_PCI_QUIRK(0x14cd, 0x5003, "USI", ALC662_FIXUP_USI_HEADSET_MODE),
9641 SND_PCI_QUIRK(0x17aa, 0x1036, "Lenovo P520", ALC662_FIXUP_LENOVO_MULTI_CODECS),
9642 SND_PCI_QUIRK(0x17aa, 0x38af, "Lenovo Ideapad Y550P", ALC662_FIXUP_IDEAPAD),
9643 SND_PCI_QUIRK(0x17aa, 0x3a0d, "Lenovo Ideapad Y550", ALC662_FIXUP_IDEAPAD),
9644 SND_PCI_QUIRK(0x1849, 0x5892, "ASRock B150M", ALC892_FIXUP_ASROCK_MOBO),
9645 SND_PCI_QUIRK(0x19da, 0xa130, "Zotac Z68", ALC662_FIXUP_ZOTAC_Z68),
9646 SND_PCI_QUIRK(0x1b0a, 0x01b8, "ACER Veriton", ALC662_FIXUP_ACER_VERITON),
9647 SND_PCI_QUIRK(0x1b35, 0x1234, "CZC ET26", ALC662_FIXUP_CZC_ET26),
9648 SND_PCI_QUIRK(0x1b35, 0x2206, "CZC P10T", ALC662_FIXUP_CZC_P10T),
9649 SND_PCI_QUIRK(0x1025, 0x0566, "Acer Aspire Ethos 8951G", ALC669_FIXUP_ACER_ASPIRE_ETHOS),
9650
9651#if 0
9652
9653
9654
9655
9656
9657 SND_PCI_QUIRK(0x1043, 0x1000, "ASUS N50Vm", ALC662_FIXUP_ASUS_MODE1),
9658 SND_PCI_QUIRK(0x1043, 0x1092, "ASUS NB", ALC662_FIXUP_ASUS_MODE3),
9659 SND_PCI_QUIRK(0x1043, 0x1173, "ASUS K73Jn", ALC662_FIXUP_ASUS_MODE1),
9660 SND_PCI_QUIRK(0x1043, 0x11c3, "ASUS M70V", ALC662_FIXUP_ASUS_MODE3),
9661 SND_PCI_QUIRK(0x1043, 0x11d3, "ASUS NB", ALC662_FIXUP_ASUS_MODE1),
9662 SND_PCI_QUIRK(0x1043, 0x11f3, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),
9663 SND_PCI_QUIRK(0x1043, 0x1203, "ASUS NB", ALC662_FIXUP_ASUS_MODE1),
9664 SND_PCI_QUIRK(0x1043, 0x1303, "ASUS G60J", ALC662_FIXUP_ASUS_MODE1),
9665 SND_PCI_QUIRK(0x1043, 0x1333, "ASUS G60Jx", ALC662_FIXUP_ASUS_MODE1),
9666 SND_PCI_QUIRK(0x1043, 0x1339, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),
9667 SND_PCI_QUIRK(0x1043, 0x13e3, "ASUS N71JA", ALC662_FIXUP_ASUS_MODE7),
9668 SND_PCI_QUIRK(0x1043, 0x1463, "ASUS N71", ALC662_FIXUP_ASUS_MODE7),
9669 SND_PCI_QUIRK(0x1043, 0x14d3, "ASUS G72", ALC662_FIXUP_ASUS_MODE8),
9670 SND_PCI_QUIRK(0x1043, 0x1563, "ASUS N90", ALC662_FIXUP_ASUS_MODE3),
9671 SND_PCI_QUIRK(0x1043, 0x15d3, "ASUS N50SF F50SF", ALC662_FIXUP_ASUS_MODE1),
9672 SND_PCI_QUIRK(0x1043, 0x16c3, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),
9673 SND_PCI_QUIRK(0x1043, 0x16f3, "ASUS K40C K50C", ALC662_FIXUP_ASUS_MODE2),
9674 SND_PCI_QUIRK(0x1043, 0x1733, "ASUS N81De", ALC662_FIXUP_ASUS_MODE1),
9675 SND_PCI_QUIRK(0x1043, 0x1753, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),
9676 SND_PCI_QUIRK(0x1043, 0x1763, "ASUS NB", ALC662_FIXUP_ASUS_MODE6),
9677 SND_PCI_QUIRK(0x1043, 0x1765, "ASUS NB", ALC662_FIXUP_ASUS_MODE6),
9678 SND_PCI_QUIRK(0x1043, 0x1783, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),
9679 SND_PCI_QUIRK(0x1043, 0x1793, "ASUS F50GX", ALC662_FIXUP_ASUS_MODE1),
9680 SND_PCI_QUIRK(0x1043, 0x17b3, "ASUS F70SL", ALC662_FIXUP_ASUS_MODE3),
9681 SND_PCI_QUIRK(0x1043, 0x17f3, "ASUS X58LE", ALC662_FIXUP_ASUS_MODE2),
9682 SND_PCI_QUIRK(0x1043, 0x1813, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),
9683 SND_PCI_QUIRK(0x1043, 0x1823, "ASUS NB", ALC662_FIXUP_ASUS_MODE5),
9684 SND_PCI_QUIRK(0x1043, 0x1833, "ASUS NB", ALC662_FIXUP_ASUS_MODE6),
9685 SND_PCI_QUIRK(0x1043, 0x1843, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),
9686 SND_PCI_QUIRK(0x1043, 0x1853, "ASUS F50Z", ALC662_FIXUP_ASUS_MODE1),
9687 SND_PCI_QUIRK(0x1043, 0x1864, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),
9688 SND_PCI_QUIRK(0x1043, 0x1876, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),
9689 SND_PCI_QUIRK(0x1043, 0x1893, "ASUS M50Vm", ALC662_FIXUP_ASUS_MODE3),
9690 SND_PCI_QUIRK(0x1043, 0x1894, "ASUS X55", ALC662_FIXUP_ASUS_MODE3),
9691 SND_PCI_QUIRK(0x1043, 0x18b3, "ASUS N80Vc", ALC662_FIXUP_ASUS_MODE1),
9692 SND_PCI_QUIRK(0x1043, 0x18c3, "ASUS VX5", ALC662_FIXUP_ASUS_MODE1),
9693 SND_PCI_QUIRK(0x1043, 0x18d3, "ASUS N81Te", ALC662_FIXUP_ASUS_MODE1),
9694 SND_PCI_QUIRK(0x1043, 0x18f3, "ASUS N505Tp", ALC662_FIXUP_ASUS_MODE1),
9695 SND_PCI_QUIRK(0x1043, 0x1903, "ASUS F5GL", ALC662_FIXUP_ASUS_MODE1),
9696 SND_PCI_QUIRK(0x1043, 0x1913, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),
9697 SND_PCI_QUIRK(0x1043, 0x1933, "ASUS F80Q", ALC662_FIXUP_ASUS_MODE2),
9698 SND_PCI_QUIRK(0x1043, 0x1943, "ASUS Vx3V", ALC662_FIXUP_ASUS_MODE1),
9699 SND_PCI_QUIRK(0x1043, 0x1953, "ASUS NB", ALC662_FIXUP_ASUS_MODE1),
9700 SND_PCI_QUIRK(0x1043, 0x1963, "ASUS X71C", ALC662_FIXUP_ASUS_MODE3),
9701 SND_PCI_QUIRK(0x1043, 0x1983, "ASUS N5051A", ALC662_FIXUP_ASUS_MODE1),
9702 SND_PCI_QUIRK(0x1043, 0x1993, "ASUS N20", ALC662_FIXUP_ASUS_MODE1),
9703 SND_PCI_QUIRK(0x1043, 0x19b3, "ASUS F7Z", ALC662_FIXUP_ASUS_MODE1),
9704 SND_PCI_QUIRK(0x1043, 0x19c3, "ASUS F5Z/F6x", ALC662_FIXUP_ASUS_MODE2),
9705 SND_PCI_QUIRK(0x1043, 0x19e3, "ASUS NB", ALC662_FIXUP_ASUS_MODE1),
9706 SND_PCI_QUIRK(0x1043, 0x19f3, "ASUS NB", ALC662_FIXUP_ASUS_MODE4),
9707#endif
9708 {}
9709};
9710
9711static const struct hda_model_fixup alc662_fixup_models[] = {
9712 {.id = ALC662_FIXUP_ASPIRE, .name = "aspire"},
9713 {.id = ALC662_FIXUP_IDEAPAD, .name = "ideapad"},
9714 {.id = ALC272_FIXUP_MARIO, .name = "mario"},
9715 {.id = ALC662_FIXUP_HP_RP5800, .name = "hp-rp5800"},
9716 {.id = ALC662_FIXUP_ASUS_MODE1, .name = "asus-mode1"},
9717 {.id = ALC662_FIXUP_ASUS_MODE2, .name = "asus-mode2"},
9718 {.id = ALC662_FIXUP_ASUS_MODE3, .name = "asus-mode3"},
9719 {.id = ALC662_FIXUP_ASUS_MODE4, .name = "asus-mode4"},
9720 {.id = ALC662_FIXUP_ASUS_MODE5, .name = "asus-mode5"},
9721 {.id = ALC662_FIXUP_ASUS_MODE6, .name = "asus-mode6"},
9722 {.id = ALC662_FIXUP_ASUS_MODE7, .name = "asus-mode7"},
9723 {.id = ALC662_FIXUP_ASUS_MODE8, .name = "asus-mode8"},
9724 {.id = ALC662_FIXUP_ZOTAC_Z68, .name = "zotac-z68"},
9725 {.id = ALC662_FIXUP_INV_DMIC, .name = "inv-dmic"},
9726 {.id = ALC662_FIXUP_DELL_MIC_NO_PRESENCE, .name = "alc662-headset-multi"},
9727 {.id = ALC668_FIXUP_DELL_MIC_NO_PRESENCE, .name = "dell-headset-multi"},
9728 {.id = ALC662_FIXUP_HEADSET_MODE, .name = "alc662-headset"},
9729 {.id = ALC668_FIXUP_HEADSET_MODE, .name = "alc668-headset"},
9730 {.id = ALC662_FIXUP_BASS_16, .name = "bass16"},
9731 {.id = ALC662_FIXUP_BASS_1A, .name = "bass1a"},
9732 {.id = ALC668_FIXUP_AUTO_MUTE, .name = "automute"},
9733 {.id = ALC668_FIXUP_DELL_XPS13, .name = "dell-xps13"},
9734 {.id = ALC662_FIXUP_ASUS_Nx50, .name = "asus-nx50"},
9735 {.id = ALC668_FIXUP_ASUS_Nx51, .name = "asus-nx51"},
9736 {.id = ALC668_FIXUP_ASUS_G751, .name = "asus-g751"},
9737 {.id = ALC891_FIXUP_HEADSET_MODE, .name = "alc891-headset"},
9738 {.id = ALC891_FIXUP_DELL_MIC_NO_PRESENCE, .name = "alc891-headset-multi"},
9739 {.id = ALC662_FIXUP_ACER_VERITON, .name = "acer-veriton"},
9740 {.id = ALC892_FIXUP_ASROCK_MOBO, .name = "asrock-mobo"},
9741 {.id = ALC662_FIXUP_USI_HEADSET_MODE, .name = "usi-headset"},
9742 {.id = ALC662_FIXUP_LENOVO_MULTI_CODECS, .name = "dual-codecs"},
9743 {.id = ALC669_FIXUP_ACER_ASPIRE_ETHOS, .name = "aspire-ethos"},
9744 {}
9745};
9746
9747static const struct snd_hda_pin_quirk alc662_pin_fixup_tbl[] = {
9748 SND_HDA_PIN_QUIRK(0x10ec0867, 0x1028, "Dell", ALC891_FIXUP_DELL_MIC_NO_PRESENCE,
9749 {0x17, 0x02211010},
9750 {0x18, 0x01a19030},
9751 {0x1a, 0x01813040},
9752 {0x21, 0x01014020}),
9753 SND_HDA_PIN_QUIRK(0x10ec0867, 0x1028, "Dell", ALC891_FIXUP_DELL_MIC_NO_PRESENCE,
9754 {0x16, 0x01813030},
9755 {0x17, 0x02211010},
9756 {0x18, 0x01a19040},
9757 {0x21, 0x01014020}),
9758 SND_HDA_PIN_QUIRK(0x10ec0662, 0x1028, "Dell", ALC662_FIXUP_DELL_MIC_NO_PRESENCE,
9759 {0x14, 0x01014010},
9760 {0x18, 0x01a19020},
9761 {0x1a, 0x0181302f},
9762 {0x1b, 0x0221401f}),
9763 SND_HDA_PIN_QUIRK(0x10ec0668, 0x1028, "Dell", ALC668_FIXUP_AUTO_MUTE,
9764 {0x12, 0x99a30130},
9765 {0x14, 0x90170110},
9766 {0x15, 0x0321101f},
9767 {0x16, 0x03011020}),
9768 SND_HDA_PIN_QUIRK(0x10ec0668, 0x1028, "Dell", ALC668_FIXUP_AUTO_MUTE,
9769 {0x12, 0x99a30140},
9770 {0x14, 0x90170110},
9771 {0x15, 0x0321101f},
9772 {0x16, 0x03011020}),
9773 SND_HDA_PIN_QUIRK(0x10ec0668, 0x1028, "Dell", ALC668_FIXUP_AUTO_MUTE,
9774 {0x12, 0x99a30150},
9775 {0x14, 0x90170110},
9776 {0x15, 0x0321101f},
9777 {0x16, 0x03011020}),
9778 SND_HDA_PIN_QUIRK(0x10ec0668, 0x1028, "Dell", ALC668_FIXUP_AUTO_MUTE,
9779 {0x14, 0x90170110},
9780 {0x15, 0x0321101f},
9781 {0x16, 0x03011020}),
9782 SND_HDA_PIN_QUIRK(0x10ec0668, 0x1028, "Dell XPS 15", ALC668_FIXUP_AUTO_MUTE,
9783 {0x12, 0x90a60130},
9784 {0x14, 0x90170110},
9785 {0x15, 0x0321101f}),
9786 SND_HDA_PIN_QUIRK(0x10ec0671, 0x103c, "HP cPC", ALC671_FIXUP_HP_HEADSET_MIC2,
9787 {0x14, 0x01014010},
9788 {0x17, 0x90170150},
9789 {0x19, 0x02a11060},
9790 {0x1b, 0x01813030},
9791 {0x21, 0x02211020}),
9792 SND_HDA_PIN_QUIRK(0x10ec0671, 0x103c, "HP cPC", ALC671_FIXUP_HP_HEADSET_MIC2,
9793 {0x14, 0x01014010},
9794 {0x18, 0x01a19040},
9795 {0x1b, 0x01813030},
9796 {0x21, 0x02211020}),
9797 SND_HDA_PIN_QUIRK(0x10ec0671, 0x103c, "HP cPC", ALC671_FIXUP_HP_HEADSET_MIC2,
9798 {0x14, 0x01014020},
9799 {0x17, 0x90170110},
9800 {0x18, 0x01a19050},
9801 {0x1b, 0x01813040},
9802 {0x21, 0x02211030}),
9803 {}
9804};
9805
9806
9807
9808static int patch_alc662(struct hda_codec *codec)
9809{
9810 struct alc_spec *spec;
9811 int err;
9812
9813 err = alc_alloc_spec(codec, 0x0b);
9814 if (err < 0)
9815 return err;
9816
9817 spec = codec->spec;
9818
9819 spec->shutup = alc_eapd_shutup;
9820
9821
9822 spec->parse_flags = HDA_PINCFG_NO_HP_FIXUP;
9823
9824 alc_fix_pll_init(codec, 0x20, 0x04, 15);
9825
9826 switch (codec->core.vendor_id) {
9827 case 0x10ec0668:
9828 spec->init_hook = alc668_restore_default_value;
9829 break;
9830 }
9831
9832 alc_pre_init(codec);
9833
9834 snd_hda_pick_fixup(codec, alc662_fixup_models,
9835 alc662_fixup_tbl, alc662_fixups);
9836 snd_hda_pick_pin_fixup(codec, alc662_pin_fixup_tbl, alc662_fixups, true);
9837 snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE);
9838
9839 alc_auto_parse_customize_define(codec);
9840
9841 if (has_cdefine_beep(codec))
9842 spec->gen.beep_nid = 0x01;
9843
9844 if ((alc_get_coef0(codec) & (1 << 14)) &&
9845 codec->bus->pci && codec->bus->pci->subsystem_vendor == 0x1025 &&
9846 spec->cdefine.platform_type == 1) {
9847 err = alc_codec_rename(codec, "ALC272X");
9848 if (err < 0)
9849 goto error;
9850 }
9851
9852
9853 err = alc662_parse_auto_config(codec);
9854 if (err < 0)
9855 goto error;
9856
9857 if (!spec->gen.no_analog && spec->gen.beep_nid) {
9858 switch (codec->core.vendor_id) {
9859 case 0x10ec0662:
9860 err = set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
9861 break;
9862 case 0x10ec0272:
9863 case 0x10ec0663:
9864 case 0x10ec0665:
9865 case 0x10ec0668:
9866 err = set_beep_amp(spec, 0x0b, 0x04, HDA_INPUT);
9867 break;
9868 case 0x10ec0273:
9869 err = set_beep_amp(spec, 0x0b, 0x03, HDA_INPUT);
9870 break;
9871 }
9872 if (err < 0)
9873 goto error;
9874 }
9875
9876 snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE);
9877
9878 return 0;
9879
9880 error:
9881 alc_free(codec);
9882 return err;
9883}
9884
9885
9886
9887
9888
9889static int alc680_parse_auto_config(struct hda_codec *codec)
9890{
9891 return alc_parse_auto_config(codec, NULL, NULL);
9892}
9893
9894
9895
9896static int patch_alc680(struct hda_codec *codec)
9897{
9898 int err;
9899
9900
9901 err = alc_alloc_spec(codec, 0);
9902 if (err < 0)
9903 return err;
9904
9905
9906 err = alc680_parse_auto_config(codec);
9907 if (err < 0) {
9908 alc_free(codec);
9909 return err;
9910 }
9911
9912 return 0;
9913}
9914
9915
9916
9917
9918static const struct hda_device_id snd_hda_id_realtek[] = {
9919 HDA_CODEC_ENTRY(0x10ec0215, "ALC215", patch_alc269),
9920 HDA_CODEC_ENTRY(0x10ec0221, "ALC221", patch_alc269),
9921 HDA_CODEC_ENTRY(0x10ec0222, "ALC222", patch_alc269),
9922 HDA_CODEC_ENTRY(0x10ec0225, "ALC225", patch_alc269),
9923 HDA_CODEC_ENTRY(0x10ec0231, "ALC231", patch_alc269),
9924 HDA_CODEC_ENTRY(0x10ec0233, "ALC233", patch_alc269),
9925 HDA_CODEC_ENTRY(0x10ec0234, "ALC234", patch_alc269),
9926 HDA_CODEC_ENTRY(0x10ec0235, "ALC233", patch_alc269),
9927 HDA_CODEC_ENTRY(0x10ec0236, "ALC236", patch_alc269),
9928 HDA_CODEC_ENTRY(0x10ec0245, "ALC245", patch_alc269),
9929 HDA_CODEC_ENTRY(0x10ec0255, "ALC255", patch_alc269),
9930 HDA_CODEC_ENTRY(0x10ec0256, "ALC256", patch_alc269),
9931 HDA_CODEC_ENTRY(0x10ec0257, "ALC257", patch_alc269),
9932 HDA_CODEC_ENTRY(0x10ec0260, "ALC260", patch_alc260),
9933 HDA_CODEC_ENTRY(0x10ec0262, "ALC262", patch_alc262),
9934 HDA_CODEC_ENTRY(0x10ec0267, "ALC267", patch_alc268),
9935 HDA_CODEC_ENTRY(0x10ec0268, "ALC268", patch_alc268),
9936 HDA_CODEC_ENTRY(0x10ec0269, "ALC269", patch_alc269),
9937 HDA_CODEC_ENTRY(0x10ec0270, "ALC270", patch_alc269),
9938 HDA_CODEC_ENTRY(0x10ec0272, "ALC272", patch_alc662),
9939 HDA_CODEC_ENTRY(0x10ec0274, "ALC274", patch_alc269),
9940 HDA_CODEC_ENTRY(0x10ec0275, "ALC275", patch_alc269),
9941 HDA_CODEC_ENTRY(0x10ec0276, "ALC276", patch_alc269),
9942 HDA_CODEC_ENTRY(0x10ec0280, "ALC280", patch_alc269),
9943 HDA_CODEC_ENTRY(0x10ec0282, "ALC282", patch_alc269),
9944 HDA_CODEC_ENTRY(0x10ec0283, "ALC283", patch_alc269),
9945 HDA_CODEC_ENTRY(0x10ec0284, "ALC284", patch_alc269),
9946 HDA_CODEC_ENTRY(0x10ec0285, "ALC285", patch_alc269),
9947 HDA_CODEC_ENTRY(0x10ec0286, "ALC286", patch_alc269),
9948 HDA_CODEC_ENTRY(0x10ec0287, "ALC287", patch_alc269),
9949 HDA_CODEC_ENTRY(0x10ec0288, "ALC288", patch_alc269),
9950 HDA_CODEC_ENTRY(0x10ec0289, "ALC289", patch_alc269),
9951 HDA_CODEC_ENTRY(0x10ec0290, "ALC290", patch_alc269),
9952 HDA_CODEC_ENTRY(0x10ec0292, "ALC292", patch_alc269),
9953 HDA_CODEC_ENTRY(0x10ec0293, "ALC293", patch_alc269),
9954 HDA_CODEC_ENTRY(0x10ec0294, "ALC294", patch_alc269),
9955 HDA_CODEC_ENTRY(0x10ec0295, "ALC295", patch_alc269),
9956 HDA_CODEC_ENTRY(0x10ec0298, "ALC298", patch_alc269),
9957 HDA_CODEC_ENTRY(0x10ec0299, "ALC299", patch_alc269),
9958 HDA_CODEC_ENTRY(0x10ec0300, "ALC300", patch_alc269),
9959 HDA_CODEC_ENTRY(0x10ec0623, "ALC623", patch_alc269),
9960 HDA_CODEC_REV_ENTRY(0x10ec0861, 0x100340, "ALC660", patch_alc861),
9961 HDA_CODEC_ENTRY(0x10ec0660, "ALC660-VD", patch_alc861vd),
9962 HDA_CODEC_ENTRY(0x10ec0861, "ALC861", patch_alc861),
9963 HDA_CODEC_ENTRY(0x10ec0862, "ALC861-VD", patch_alc861vd),
9964 HDA_CODEC_REV_ENTRY(0x10ec0662, 0x100002, "ALC662 rev2", patch_alc882),
9965 HDA_CODEC_REV_ENTRY(0x10ec0662, 0x100101, "ALC662 rev1", patch_alc662),
9966 HDA_CODEC_REV_ENTRY(0x10ec0662, 0x100300, "ALC662 rev3", patch_alc662),
9967 HDA_CODEC_ENTRY(0x10ec0663, "ALC663", patch_alc662),
9968 HDA_CODEC_ENTRY(0x10ec0665, "ALC665", patch_alc662),
9969 HDA_CODEC_ENTRY(0x10ec0667, "ALC667", patch_alc662),
9970 HDA_CODEC_ENTRY(0x10ec0668, "ALC668", patch_alc662),
9971 HDA_CODEC_ENTRY(0x10ec0670, "ALC670", patch_alc662),
9972 HDA_CODEC_ENTRY(0x10ec0671, "ALC671", patch_alc662),
9973 HDA_CODEC_ENTRY(0x10ec0680, "ALC680", patch_alc680),
9974 HDA_CODEC_ENTRY(0x10ec0700, "ALC700", patch_alc269),
9975 HDA_CODEC_ENTRY(0x10ec0701, "ALC701", patch_alc269),
9976 HDA_CODEC_ENTRY(0x10ec0703, "ALC703", patch_alc269),
9977 HDA_CODEC_ENTRY(0x10ec0711, "ALC711", patch_alc269),
9978 HDA_CODEC_ENTRY(0x10ec0867, "ALC891", patch_alc662),
9979 HDA_CODEC_ENTRY(0x10ec0880, "ALC880", patch_alc880),
9980 HDA_CODEC_ENTRY(0x10ec0882, "ALC882", patch_alc882),
9981 HDA_CODEC_ENTRY(0x10ec0883, "ALC883", patch_alc882),
9982 HDA_CODEC_REV_ENTRY(0x10ec0885, 0x100101, "ALC889A", patch_alc882),
9983 HDA_CODEC_REV_ENTRY(0x10ec0885, 0x100103, "ALC889A", patch_alc882),
9984 HDA_CODEC_ENTRY(0x10ec0885, "ALC885", patch_alc882),
9985 HDA_CODEC_ENTRY(0x10ec0887, "ALC887", patch_alc882),
9986 HDA_CODEC_REV_ENTRY(0x10ec0888, 0x100101, "ALC1200", patch_alc882),
9987 HDA_CODEC_ENTRY(0x10ec0888, "ALC888", patch_alc882),
9988 HDA_CODEC_ENTRY(0x10ec0889, "ALC889", patch_alc882),
9989 HDA_CODEC_ENTRY(0x10ec0892, "ALC892", patch_alc662),
9990 HDA_CODEC_ENTRY(0x10ec0899, "ALC898", patch_alc882),
9991 HDA_CODEC_ENTRY(0x10ec0900, "ALC1150", patch_alc882),
9992 HDA_CODEC_ENTRY(0x10ec0b00, "ALCS1200A", patch_alc882),
9993 HDA_CODEC_ENTRY(0x10ec1168, "ALC1220", patch_alc882),
9994 HDA_CODEC_ENTRY(0x10ec1220, "ALC1220", patch_alc882),
9995 {}
9996};
9997MODULE_DEVICE_TABLE(hdaudio, snd_hda_id_realtek);
9998
9999MODULE_LICENSE("GPL");
10000MODULE_DESCRIPTION("Realtek HD-audio codec");
10001
10002static struct hda_codec_driver realtek_driver = {
10003 .id = snd_hda_id_realtek,
10004};
10005
10006module_hda_codec_driver(realtek_driver);
10007