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