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