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