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