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