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