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