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