patch_realtek.c 248.2 KB
Newer Older
L
Linus Torvalds 已提交
1 2 3
/*
 * Universal Interface for Intel High Definition Audio Codec
 *
4
 * HD audio interface patch for Realtek ALC codecs
L
Linus Torvalds 已提交
5
 *
6 7
 * Copyright (c) 2004 Kailang Yang <kailang@realtek.com.tw>
 *                    PeiSen Hou <pshou@realtek.com.tw>
L
Linus Torvalds 已提交
8
 *                    Takashi Iwai <tiwai@suse.de>
J
Jonathan Woithe 已提交
9
 *                    Jonathan Woithe <jwoithe@just42.net>
L
Linus Torvalds 已提交
10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29
 *
 *  This driver is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  This driver is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program; if not, write to the Free Software
 *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
 */

#include <linux/init.h>
#include <linux/delay.h>
#include <linux/slab.h>
#include <linux/pci.h>
30
#include <linux/dmi.h>
31
#include <linux/module.h>
32
#include <linux/input.h>
L
Linus Torvalds 已提交
33
#include <sound/core.h>
34
#include <sound/jack.h>
L
Linus Torvalds 已提交
35 36
#include "hda_codec.h"
#include "hda_local.h"
37
#include "hda_auto_parser.h"
38
#include "hda_jack.h"
39
#include "hda_generic.h"
L
Linus Torvalds 已提交
40

41 42 43
/* keep halting ALC5505 DSP, for power saving */
#define HALT_REALTEK_ALC5505

44 45 46 47 48 49 50 51 52
/* extra amp-initialization sequence types */
enum {
	ALC_INIT_NONE,
	ALC_INIT_DEFAULT,
	ALC_INIT_GPIO1,
	ALC_INIT_GPIO2,
	ALC_INIT_GPIO3,
};

53 54 55 56 57 58 59 60 61 62 63 64 65 66
enum {
	ALC_HEADSET_MODE_UNKNOWN,
	ALC_HEADSET_MODE_UNPLUGGED,
	ALC_HEADSET_MODE_HEADSET,
	ALC_HEADSET_MODE_MIC,
	ALC_HEADSET_MODE_HEADPHONE,
};

enum {
	ALC_HEADSET_TYPE_UNKNOWN,
	ALC_HEADSET_TYPE_CTIA,
	ALC_HEADSET_TYPE_OMTP,
};

67 68 69 70
enum {
	ALC_KEY_MICMUTE_INDEX,
};

71 72 73 74 75 76 77 78 79 80
struct alc_customize_define {
	unsigned int  sku_cfg;
	unsigned char port_connectivity;
	unsigned char check_sum;
	unsigned char customization;
	unsigned char external_amp;
	unsigned int  enable_pcbeep:1;
	unsigned int  platform_type:1;
	unsigned int  swap:1;
	unsigned int  override:1;
81
	unsigned int  fixup:1; /* Means that this sku is set by driver, not read from hw */
82 83
};

L
Linus Torvalds 已提交
84
struct alc_spec {
85
	struct hda_gen_spec gen; /* must be at head */
86

L
Linus Torvalds 已提交
87
	/* codec parameterization */
88
	const struct snd_kcontrol_new *mixers[5];	/* mixer arrays */
L
Linus Torvalds 已提交
89
	unsigned int num_mixers;
90
	unsigned int beep_amp;	/* beep amp value, set via set_beep_amp() */
L
Linus Torvalds 已提交
91

92
	struct alc_customize_define cdefine;
93
	unsigned int parse_flags; /* flag for snd_hda_parse_pin_defcfg() */
94

95 96 97
	/* mute LED for HP laptops, see alc269_fixup_mic_mute_hook() */
	int mute_led_polarity;
	hda_nid_t mute_led_nid;
98
	hda_nid_t cap_mute_led_nid;
99

100
	unsigned int gpio_led; /* used for alc269_fixup_hp_gpio_led() */
101 102
	unsigned int gpio_mute_led_mask;
	unsigned int gpio_mic_led_mask;
103

104 105 106 107 108
	hda_nid_t headset_mic_pin;
	hda_nid_t headphone_mic_pin;
	int current_headset_mode;
	int current_headset_type;

109 110
	/* hooks */
	void (*init_hook)(struct hda_codec *codec);
111
#ifdef CONFIG_PM
112
	void (*power_hook)(struct hda_codec *codec);
113
#endif
114
	void (*shutup)(struct hda_codec *codec);
115
	void (*reboot_notify)(struct hda_codec *codec);
116

117
	int init_amp;
118
	int codec_variant;	/* flag for other variants */
119 120
	unsigned int has_alc5505_dsp:1;
	unsigned int no_depop_delay:1;
121

122 123 124
	/* for PLL fix */
	hda_nid_t pll_nid;
	unsigned int pll_coef_idx, pll_coef_bit;
125
	unsigned int coef0;
126
	struct input_dev *kb_dev;
127
	u8 alc_mute_keycode_map[1];
128 129
};

130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156
/*
 * COEF access helper functions
 */

static int alc_read_coefex_idx(struct hda_codec *codec, hda_nid_t nid,
			       unsigned int coef_idx)
{
	unsigned int val;

	snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_COEF_INDEX, coef_idx);
	val = snd_hda_codec_read(codec, nid, 0, AC_VERB_GET_PROC_COEF, 0);
	return val;
}

#define alc_read_coef_idx(codec, coef_idx) \
	alc_read_coefex_idx(codec, 0x20, coef_idx)

static void alc_write_coefex_idx(struct hda_codec *codec, hda_nid_t nid,
				 unsigned int coef_idx, unsigned int coef_val)
{
	snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_COEF_INDEX, coef_idx);
	snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_PROC_COEF, coef_val);
}

#define alc_write_coef_idx(codec, coef_idx, coef_val) \
	alc_write_coefex_idx(codec, 0x20, coef_idx, coef_val)

157 158 159 160 161 162 163 164 165 166 167 168 169 170
static void alc_update_coefex_idx(struct hda_codec *codec, hda_nid_t nid,
				  unsigned int coef_idx, unsigned int mask,
				  unsigned int bits_set)
{
	unsigned int val = alc_read_coefex_idx(codec, nid, coef_idx);

	if (val != -1)
		alc_write_coefex_idx(codec, nid, coef_idx,
				     (val & ~mask) | bits_set);
}

#define alc_update_coef_idx(codec, coef_idx, mask, bits_set)	\
	alc_update_coefex_idx(codec, 0x20, coef_idx, mask, bits_set)

171 172 173 174 175 176 177 178 179 180
/* a special bypass for COEF 0; read the cached value at the second time */
static unsigned int alc_get_coef0(struct hda_codec *codec)
{
	struct alc_spec *spec = codec->spec;

	if (!spec->coef0)
		spec->coef0 = alc_read_coef_idx(codec, 0);
	return spec->coef0;
}

181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206
/* coef writes/updates batch */
struct coef_fw {
	unsigned char nid;
	unsigned char idx;
	unsigned short mask;
	unsigned short val;
};

#define UPDATE_COEFEX(_nid, _idx, _mask, _val) \
	{ .nid = (_nid), .idx = (_idx), .mask = (_mask), .val = (_val) }
#define WRITE_COEFEX(_nid, _idx, _val) UPDATE_COEFEX(_nid, _idx, -1, _val)
#define WRITE_COEF(_idx, _val) WRITE_COEFEX(0x20, _idx, _val)
#define UPDATE_COEF(_idx, _mask, _val) UPDATE_COEFEX(0x20, _idx, _mask, _val)

static void alc_process_coef_fw(struct hda_codec *codec,
				const struct coef_fw *fw)
{
	for (; fw->nid; fw++) {
		if (fw->mask == (unsigned short)-1)
			alc_write_coefex_idx(codec, fw->nid, fw->idx, fw->val);
		else
			alc_update_coefex_idx(codec, fw->nid, fw->idx,
					      fw->mask, fw->val);
	}
}

207
/*
208 209 210
 * Append the given mixer and verb elements for the later use
 * The mixer array is referred in build_controls(), and init_verbs are
 * called in init().
211
 */
212
static void add_mixer(struct alc_spec *spec, const struct snd_kcontrol_new *mix)
213 214 215 216 217 218
{
	if (snd_BUG_ON(spec->num_mixers >= ARRAY_SIZE(spec->mixers)))
		return;
	spec->mixers[spec->num_mixers++] = mix;
}

219
/*
220
 * GPIO setup tables, used in initialization
221
 */
222
/* Enable GPIO mask and set output */
223
static const struct hda_verb alc_gpio1_init_verbs[] = {
224 225 226 227 228 229
	{0x01, AC_VERB_SET_GPIO_MASK, 0x01},
	{0x01, AC_VERB_SET_GPIO_DIRECTION, 0x01},
	{0x01, AC_VERB_SET_GPIO_DATA, 0x01},
	{ }
};

230
static const struct hda_verb alc_gpio2_init_verbs[] = {
231 232 233 234 235 236
	{0x01, AC_VERB_SET_GPIO_MASK, 0x02},
	{0x01, AC_VERB_SET_GPIO_DIRECTION, 0x02},
	{0x01, AC_VERB_SET_GPIO_DATA, 0x02},
	{ }
};

237
static const struct hda_verb alc_gpio3_init_verbs[] = {
238 239 240 241 242 243
	{0x01, AC_VERB_SET_GPIO_MASK, 0x03},
	{0x01, AC_VERB_SET_GPIO_DIRECTION, 0x03},
	{0x01, AC_VERB_SET_GPIO_DATA, 0x03},
	{ }
};

244 245 246 247 248 249 250 251 252
/*
 * Fix hardware PLL issue
 * On some codecs, the analog PLL gating control must be off while
 * the default value is 1.
 */
static void alc_fix_pll(struct hda_codec *codec)
{
	struct alc_spec *spec = codec->spec;

253 254 255
	if (spec->pll_nid)
		alc_update_coefex_idx(codec, spec->pll_nid, spec->pll_coef_idx,
				      1 << spec->pll_coef_bit, 0);
256 257 258 259 260 261 262 263 264 265 266 267
}

static void alc_fix_pll_init(struct hda_codec *codec, hda_nid_t nid,
			     unsigned int coef_idx, unsigned int coef_bit)
{
	struct alc_spec *spec = codec->spec;
	spec->pll_nid = nid;
	spec->pll_coef_idx = coef_idx;
	spec->pll_coef_bit = coef_bit;
	alc_fix_pll(codec);
}

268
/* update the master volume per volume-knob's unsol event */
269 270
static void alc_update_knob_master(struct hda_codec *codec,
				   struct hda_jack_callback *jack)
271 272 273 274 275 276 277 278 279 280 281
{
	unsigned int val;
	struct snd_kcontrol *kctl;
	struct snd_ctl_elem_value *uctl;

	kctl = snd_hda_find_mixer_ctl(codec, "Master Playback Volume");
	if (!kctl)
		return;
	uctl = kzalloc(sizeof(*uctl), GFP_KERNEL);
	if (!uctl)
		return;
282
	val = snd_hda_codec_read(codec, jack->nid, 0,
283 284 285 286 287 288 289 290
				 AC_VERB_GET_VOLUME_KNOB_CONTROL, 0);
	val &= HDA_AMP_VOLMASK;
	uctl->value.integer.value[0] = val;
	uctl->value.integer.value[1] = val;
	kctl->put(kctl, uctl);
	kfree(uctl);
}

291
static void alc880_unsol_event(struct hda_codec *codec, unsigned int res)
292
{
293 294 295
	/* For some reason, the res given from ALC880 is broken.
	   Here we adjust it properly. */
	snd_hda_jack_unsol_event(codec, res >> 2);
296 297
}

298 299 300 301 302 303 304
/* Change EAPD to verb control */
static void alc_fill_eapd_coef(struct hda_codec *codec)
{
	int coef;

	coef = alc_get_coef0(codec);

305
	switch (codec->core.vendor_id) {
306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326
	case 0x10ec0262:
		alc_update_coef_idx(codec, 0x7, 0, 1<<5);
		break;
	case 0x10ec0267:
	case 0x10ec0268:
		alc_update_coef_idx(codec, 0x7, 0, 1<<13);
		break;
	case 0x10ec0269:
		if ((coef & 0x00f0) == 0x0010)
			alc_update_coef_idx(codec, 0xd, 0, 1<<14);
		if ((coef & 0x00f0) == 0x0020)
			alc_update_coef_idx(codec, 0x4, 1<<15, 0);
		if ((coef & 0x00f0) == 0x0030)
			alc_update_coef_idx(codec, 0x10, 1<<9, 0);
		break;
	case 0x10ec0280:
	case 0x10ec0284:
	case 0x10ec0290:
	case 0x10ec0292:
		alc_update_coef_idx(codec, 0x4, 1<<15, 0);
		break;
327
	case 0x10ec0225:
328 329 330 331 332
	case 0x10ec0295:
	case 0x10ec0299:
		alc_update_coef_idx(codec, 0x67, 0xf000, 0x3000);
		/* fallthrough */
	case 0x10ec0215:
333
	case 0x10ec0233:
334
	case 0x10ec0235:
335
	case 0x10ec0236:
336
	case 0x10ec0255:
337
	case 0x10ec0256:
338
	case 0x10ec0257:
339 340 341 342
	case 0x10ec0282:
	case 0x10ec0283:
	case 0x10ec0286:
	case 0x10ec0288:
343
	case 0x10ec0285:
344
	case 0x10ec0298:
345
	case 0x10ec0289:
346 347
		alc_update_coef_idx(codec, 0x10, 1<<9, 0);
		break;
348 349 350
	case 0x10ec0275:
		alc_update_coef_idx(codec, 0xe, 0, 1<<0);
		break;
351 352 353
	case 0x10ec0293:
		alc_update_coef_idx(codec, 0xa, 1<<13, 0);
		break;
354 355 356
	case 0x10ec0234:
	case 0x10ec0274:
	case 0x10ec0294:
357 358 359
	case 0x10ec0700:
	case 0x10ec0701:
	case 0x10ec0703:
360 361
		alc_update_coef_idx(codec, 0x10, 1<<15, 0);
		break;
362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389
	case 0x10ec0662:
		if ((coef & 0x00f0) == 0x0030)
			alc_update_coef_idx(codec, 0x4, 1<<10, 0); /* EAPD Ctrl */
		break;
	case 0x10ec0272:
	case 0x10ec0273:
	case 0x10ec0663:
	case 0x10ec0665:
	case 0x10ec0670:
	case 0x10ec0671:
	case 0x10ec0672:
		alc_update_coef_idx(codec, 0xd, 0, 1<<14); /* EAPD Ctrl */
		break;
	case 0x10ec0668:
		alc_update_coef_idx(codec, 0x7, 3<<13, 0);
		break;
	case 0x10ec0867:
		alc_update_coef_idx(codec, 0x4, 1<<10, 0);
		break;
	case 0x10ec0888:
		if ((coef & 0x00f0) == 0x0020 || (coef & 0x00f0) == 0x0030)
			alc_update_coef_idx(codec, 0x7, 1<<5, 0);
		break;
	case 0x10ec0892:
		alc_update_coef_idx(codec, 0x7, 1<<5, 0);
		break;
	case 0x10ec0899:
	case 0x10ec0900:
390
	case 0x10ec1168:
391
	case 0x10ec1220:
392 393 394 395 396
		alc_update_coef_idx(codec, 0x7, 1<<1, 0);
		break;
	}
}

397 398 399
/* additional initialization for ALC888 variants */
static void alc888_coef_init(struct hda_codec *codec)
{
400 401 402 403 404 405 406 407
	switch (alc_get_coef0(codec) & 0x00f0) {
	/* alc888-VA */
	case 0x00:
	/* alc888-VB */
	case 0x10:
		alc_update_coef_idx(codec, 7, 0, 0x2030); /* Turn EAPD to High */
		break;
	}
408 409
}

410 411 412 413 414 415 416 417 418 419
/* turn on/off EAPD control (only if available) */
static void set_eapd(struct hda_codec *codec, hda_nid_t nid, int on)
{
	if (get_wcaps_type(get_wcaps(codec, nid)) != AC_WID_PIN)
		return;
	if (snd_hda_query_pin_caps(codec, nid) & AC_PINCAP_EAPD)
		snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_EAPD_BTLENABLE,
				    on ? 2 : 0);
}

420 421 422 423
/* turn on/off EAPD controls of the codec */
static void alc_auto_setup_eapd(struct hda_codec *codec, bool on)
{
	/* We currently only handle front, HP */
424
	static hda_nid_t pins[] = {
425
		0x0f, 0x10, 0x14, 0x15, 0x17, 0
426 427 428 429
	};
	hda_nid_t *p;
	for (p = pins; *p; p++)
		set_eapd(codec, *p, on);
430 431
}

432
/* generic shutup callback;
L
Lars-Peter Clausen 已提交
433
 * just turning off EAPD and a little pause for avoiding pop-noise
434 435 436
 */
static void alc_eapd_shutup(struct hda_codec *codec)
{
437 438
	struct alc_spec *spec = codec->spec;

439
	alc_auto_setup_eapd(codec, false);
440 441
	if (!spec->no_depop_delay)
		msleep(200);
442
	snd_hda_shutup_pins(codec);
443 444
}

445
/* generic EAPD initialization */
446
static void alc_auto_init_amp(struct hda_codec *codec, int type)
447
{
448
	alc_fill_eapd_coef(codec);
449
	alc_auto_setup_eapd(codec, true);
450 451
	switch (type) {
	case ALC_INIT_GPIO1:
452 453
		snd_hda_sequence_write(codec, alc_gpio1_init_verbs);
		break;
454
	case ALC_INIT_GPIO2:
455 456
		snd_hda_sequence_write(codec, alc_gpio2_init_verbs);
		break;
457
	case ALC_INIT_GPIO3:
458 459
		snd_hda_sequence_write(codec, alc_gpio3_init_verbs);
		break;
460
	case ALC_INIT_DEFAULT:
461
		switch (codec->core.vendor_id) {
462
		case 0x10ec0260:
463
			alc_update_coefex_idx(codec, 0x1a, 7, 0, 0x2010);
464 465 466 467 468
			break;
		case 0x10ec0880:
		case 0x10ec0882:
		case 0x10ec0883:
		case 0x10ec0885:
469
			alc_update_coef_idx(codec, 7, 0, 0x2030);
470
			break;
471
		case 0x10ec0888:
472
			alc888_coef_init(codec);
473
			break;
474
		}
475 476 477 478
		break;
	}
}

479

480
/*
481
 * Realtek SSID verification
482
 */
483

484 485 486 487
/* Could be any non-zero and even value. When used as fixup, tells
 * the driver to ignore any present sku defines.
 */
#define ALC_FIXUP_SKU_IGNORE (2)
488

489 490
static void alc_fixup_sku_ignore(struct hda_codec *codec,
				 const struct hda_fixup *fix, int action)
491 492
{
	struct alc_spec *spec = codec->spec;
493 494 495
	if (action == HDA_FIXUP_ACT_PRE_PROBE) {
		spec->cdefine.fixup = 1;
		spec->cdefine.sku_cfg = ALC_FIXUP_SKU_IGNORE;
496 497 498
	}
}

499 500 501 502 503
static void alc_fixup_no_depop_delay(struct hda_codec *codec,
				    const struct hda_fixup *fix, int action)
{
	struct alc_spec *spec = codec->spec;

504
	if (action == HDA_FIXUP_ACT_PROBE) {
505
		spec->no_depop_delay = 1;
506 507
		codec->depop_delay = 0;
	}
508 509
}

510
static int alc_auto_parse_customize_define(struct hda_codec *codec)
511
{
512 513
	unsigned int ass, tmp, i;
	unsigned nid = 0;
514 515
	struct alc_spec *spec = codec->spec;

516
	spec->cdefine.enable_pcbeep = 1; /* assume always enabled */
517

518 519 520 521 522
	if (spec->cdefine.fixup) {
		ass = spec->cdefine.sku_cfg;
		if (ass == ALC_FIXUP_SKU_IGNORE)
			return -1;
		goto do_sku;
523 524
	}

525 526
	if (!codec->bus->pci)
		return -1;
527
	ass = codec->core.subsystem_id & 0xffff;
528 529
	if (ass != codec->bus->pci->subsystem_device && (ass & 1))
		goto do_sku;
530

531
	nid = 0x1d;
532
	if (codec->core.vendor_id == 0x10ec0260)
533 534
		nid = 0x17;
	ass = snd_hda_codec_get_pincfg(codec, nid);
535

536
	if (!(ass & 1)) {
537
		codec_info(codec, "%s: SKU not ready 0x%08x\n",
538
			   codec->core.chip_name, ass);
539
		return -1;
540 541
	}

542 543 544 545 546
	/* check sum */
	tmp = 0;
	for (i = 1; i < 16; i++) {
		if ((ass >> i) & 1)
			tmp++;
547
	}
548 549
	if (((ass >> 16) & 0xf) != tmp)
		return -1;
550

551 552 553 554 555 556 557 558 559 560 561
	spec->cdefine.port_connectivity = ass >> 30;
	spec->cdefine.enable_pcbeep = (ass & 0x100000) >> 20;
	spec->cdefine.check_sum = (ass >> 16) & 0xf;
	spec->cdefine.customization = ass >> 8;
do_sku:
	spec->cdefine.sku_cfg = ass;
	spec->cdefine.external_amp = (ass & 0x38) >> 3;
	spec->cdefine.platform_type = (ass & 0x4) >> 2;
	spec->cdefine.swap = (ass & 0x2) >> 1;
	spec->cdefine.override = ass & 0x1;

562
	codec_dbg(codec, "SKU: Nid=0x%x sku_cfg=0x%08x\n",
563
		   nid, spec->cdefine.sku_cfg);
564
	codec_dbg(codec, "SKU: port_connectivity=0x%x\n",
565
		   spec->cdefine.port_connectivity);
566 567 568 569 570 571 572
	codec_dbg(codec, "SKU: enable_pcbeep=0x%x\n", spec->cdefine.enable_pcbeep);
	codec_dbg(codec, "SKU: check_sum=0x%08x\n", spec->cdefine.check_sum);
	codec_dbg(codec, "SKU: customization=0x%08x\n", spec->cdefine.customization);
	codec_dbg(codec, "SKU: external_amp=0x%x\n", spec->cdefine.external_amp);
	codec_dbg(codec, "SKU: platform_type=0x%x\n", spec->cdefine.platform_type);
	codec_dbg(codec, "SKU: swap=0x%x\n", spec->cdefine.swap);
	codec_dbg(codec, "SKU: override=0x%x\n", spec->cdefine.override);
573 574 575 576

	return 0;
}

577 578 579 580 581 582 583 584 585
/* return the position of NID in the list, or -1 if not found */
static int find_idx_in_nid_list(hda_nid_t nid, const hda_nid_t *list, int nums)
{
	int i;
	for (i = 0; i < nums; i++)
		if (list[i] == nid)
			return i;
	return -1;
}
586
/* return true if the given NID is found in the list */
587 588
static bool found_in_nid_list(hda_nid_t nid, const hda_nid_t *list, int nums)
{
589
	return find_idx_in_nid_list(nid, list, nums) >= 0;
590 591
}

592 593 594 595 596 597 598 599 600
/* check subsystem ID and set up device-specific initialization;
 * return 1 if initialized, 0 if invalid SSID
 */
/* 32-bit subsystem ID for BIOS loading in HD Audio codec.
 *	31 ~ 16 :	Manufacture ID
 *	15 ~ 8	:	SKU ID
 *	7  ~ 0	:	Assembly ID
 *	port-A --> pin 39/41, port-E --> pin 14/15, port-D --> pin 35/36
 */
601
static int alc_subsystem_id(struct hda_codec *codec, const hda_nid_t *ports)
602 603 604 605 606
{
	unsigned int ass, tmp, i;
	unsigned nid;
	struct alc_spec *spec = codec->spec;

607 608 609 610 611 612 613
	if (spec->cdefine.fixup) {
		ass = spec->cdefine.sku_cfg;
		if (ass == ALC_FIXUP_SKU_IGNORE)
			return 0;
		goto do_sku;
	}

614
	ass = codec->core.subsystem_id & 0xffff;
615 616
	if (codec->bus->pci &&
	    ass != codec->bus->pci->subsystem_device && (ass & 1))
617 618 619 620
		goto do_sku;

	/* invalid SSID, check the special NID pin defcfg instead */
	/*
621
	 * 31~30	: port connectivity
622 623 624 625 626 627 628
	 * 29~21	: reserve
	 * 20		: PCBEEP input
	 * 19~16	: Check sum (15:1)
	 * 15~1		: Custom
	 * 0		: override
	*/
	nid = 0x1d;
629
	if (codec->core.vendor_id == 0x10ec0260)
630 631
		nid = 0x17;
	ass = snd_hda_codec_get_pincfg(codec, nid);
632 633
	codec_dbg(codec,
		  "realtek: No valid SSID, checking pincfg 0x%08x for NID 0x%x\n",
634
		   ass, nid);
635
	if (!(ass & 1))
636 637 638 639 640 641 642 643 644 645 646 647 648
		return 0;
	if ((ass >> 30) != 1)	/* no physical connection */
		return 0;

	/* check sum */
	tmp = 0;
	for (i = 1; i < 16; i++) {
		if ((ass >> i) & 1)
			tmp++;
	}
	if (((ass >> 16) & 0xf) != tmp)
		return 0;
do_sku:
649
	codec_dbg(codec, "realtek: Enabling init ASM_ID=0x%04x CODEC_ID=%08x\n",
650
		   ass & 0xffff, codec->core.vendor_id);
651 652 653 654 655 656 657 658 659 660 661 662 663 664 665 666 667 668 669
	/*
	 * 0 : override
	 * 1 :	Swap Jack
	 * 2 : 0 --> Desktop, 1 --> Laptop
	 * 3~5 : External Amplifier control
	 * 7~6 : Reserved
	*/
	tmp = (ass & 0x38) >> 3;	/* external Amp control */
	switch (tmp) {
	case 1:
		spec->init_amp = ALC_INIT_GPIO1;
		break;
	case 3:
		spec->init_amp = ALC_INIT_GPIO2;
		break;
	case 7:
		spec->init_amp = ALC_INIT_GPIO3;
		break;
	case 5:
670
	default:
671
		spec->init_amp = ALC_INIT_DEFAULT;
672 673
		break;
	}
674

675
	/* is laptop or Desktop and enable the function "Mute internal speaker
676 677
	 * when the external headphone out jack is plugged"
	 */
678
	if (!(ass & 0x8000))
679
		return 1;
680 681 682 683 684 685 686
	/*
	 * 10~8 : Jack location
	 * 12~11: Headphone out -> 00: PortA, 01: PortE, 02: PortD, 03: Resvered
	 * 14~13: Resvered
	 * 15   : 1 --> enable the function "Mute internal speaker
	 *	        when the external headphone out jack is plugged"
	 */
687 688 689
	if (!spec->gen.autocfg.hp_pins[0] &&
	    !(spec->gen.autocfg.line_out_pins[0] &&
	      spec->gen.autocfg.line_out_type == AUTO_PIN_HP_OUT)) {
690
		hda_nid_t nid;
691
		tmp = (ass >> 11) & 0x3;	/* HP to chassis */
692
		nid = ports[tmp];
693 694
		if (found_in_nid_list(nid, spec->gen.autocfg.line_out_pins,
				      spec->gen.autocfg.line_outs))
695
			return 1;
696
		spec->gen.autocfg.hp_pins[0] = nid;
697
	}
698 699
	return 1;
}
700

701 702 703
/* Check the validity of ALC subsystem-id
 * ports contains an array of 4 pin NIDs for port-A, E, D and I */
static void alc_ssid_check(struct hda_codec *codec, const hda_nid_t *ports)
704
{
705
	if (!alc_subsystem_id(codec, ports)) {
706
		struct alc_spec *spec = codec->spec;
707 708
		codec_dbg(codec,
			  "realtek: Enable default setup for auto mode as fallback\n");
709 710
		spec->init_amp = ALC_INIT_DEFAULT;
	}
711
}
712

713
/*
714
 */
715

716 717
static void alc_fixup_inv_dmic(struct hda_codec *codec,
			       const struct hda_fixup *fix, int action)
718 719
{
	struct alc_spec *spec = codec->spec;
720

721
	spec->gen.inv_dmic_split = 1;
722 723
}

724

725 726 727 728 729
#ifdef CONFIG_SND_HDA_INPUT_BEEP
/* additional beep mixers; the actual parameters are overwritten at build */
static const struct snd_kcontrol_new alc_beep_mixer[] = {
	HDA_CODEC_VOLUME("Beep Playback Volume", 0, 0, HDA_INPUT),
	HDA_CODEC_MUTE_BEEP("Beep Playback Switch", 0, 0, HDA_INPUT),
730 731
	{ } /* end */
};
732
#endif
733

734
static int alc_build_controls(struct hda_codec *codec)
735 736
{
	struct alc_spec *spec = codec->spec;
737
	int i, err;
738

739 740 741
	err = snd_hda_gen_build_controls(codec);
	if (err < 0)
		return err;
L
Linus Torvalds 已提交
742 743 744 745 746 747

	for (i = 0; i < spec->num_mixers; i++) {
		err = snd_hda_add_new_ctls(codec, spec->mixers[i]);
		if (err < 0)
			return err;
	}
748

749
#ifdef CONFIG_SND_HDA_INPUT_BEEP
750 751
	/* create beep controls if needed */
	if (spec->beep_amp) {
752
		const struct snd_kcontrol_new *knew;
753 754 755 756
		for (knew = alc_beep_mixer; knew->name; knew++) {
			struct snd_kcontrol *kctl;
			kctl = snd_ctl_new1(knew, codec);
			if (!kctl)
757 758 759 760 761
				return -ENOMEM;
			kctl->private_value = spec->beep_amp;
			err = snd_hda_ctl_add(codec, 0, kctl);
			if (err < 0)
				return err;
762
		}
763
	}
764
#endif
765

766
	snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_BUILD);
767
	return 0;
768 769 770
}


771
/*
772
 * Common callbacks
773
 */
774

775
static int alc_init(struct hda_codec *codec)
776 777
{
	struct alc_spec *spec = codec->spec;
778

779 780
	if (spec->init_hook)
		spec->init_hook(codec);
781

782 783
	alc_fix_pll(codec);
	alc_auto_init_amp(codec, spec->init_amp);
784

785
	snd_hda_gen_init(codec);
786

787
	snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_INIT);
788

789 790
	return 0;
}
791

792
static inline void alc_shutup(struct hda_codec *codec)
793 794
{
	struct alc_spec *spec = codec->spec;
795

796 797
	if (spec && spec->shutup)
		spec->shutup(codec);
798 799
	else
		snd_hda_shutup_pins(codec);
800 801
}

802 803 804 805 806 807 808 809 810 811 812 813 814 815 816 817 818 819 820
static void alc_reboot_notify(struct hda_codec *codec)
{
	struct alc_spec *spec = codec->spec;

	if (spec && spec->reboot_notify)
		spec->reboot_notify(codec);
	else
		alc_shutup(codec);
}

/* power down codec to D3 at reboot/shutdown; set as reboot_notify ops */
static void alc_d3_at_reboot(struct hda_codec *codec)
{
	snd_hda_codec_set_power_to_all(codec, codec->core.afg, AC_PWRST_D3);
	snd_hda_codec_write(codec, codec->core.afg, 0,
			    AC_VERB_SET_POWER_STATE, AC_PWRST_D3);
	msleep(10);
}

821
#define alc_free	snd_hda_gen_free
822

823 824
#ifdef CONFIG_PM
static void alc_power_eapd(struct hda_codec *codec)
825
{
826
	alc_auto_setup_eapd(codec, false);
827
}
828

829
static int alc_suspend(struct hda_codec *codec)
830 831
{
	struct alc_spec *spec = codec->spec;
832 833 834
	alc_shutup(codec);
	if (spec && spec->power_hook)
		spec->power_hook(codec);
835 836
	return 0;
}
837
#endif
838

839 840
#ifdef CONFIG_PM
static int alc_resume(struct hda_codec *codec)
841
{
842 843 844 845
	struct alc_spec *spec = codec->spec;

	if (!spec->no_depop_delay)
		msleep(150); /* to avoid pop noise */
846
	codec->patch_ops.init(codec);
847
	regcache_sync(codec->core.regmap);
848 849
	hda_call_check_power_status(codec, 0x01);
	return 0;
850
}
851
#endif
852

853 854
/*
 */
855 856 857 858 859 860 861 862 863
static const struct hda_codec_ops alc_patch_ops = {
	.build_controls = alc_build_controls,
	.build_pcms = snd_hda_gen_build_pcms,
	.init = alc_init,
	.free = alc_free,
	.unsol_event = snd_hda_jack_unsol_event,
#ifdef CONFIG_PM
	.resume = alc_resume,
	.suspend = alc_suspend,
864
	.check_power_status = snd_hda_gen_check_power_status,
865
#endif
866
	.reboot_notify = alc_reboot_notify,
867
};
868

869

870
#define alc_codec_rename(codec, name) snd_hda_codec_set_name(codec, name)
871

872
/*
873
 * Rename codecs appropriately from COEF value or subvendor id
874
 */
875 876 877 878 879 880
struct alc_codec_rename_table {
	unsigned int vendor_id;
	unsigned short coef_mask;
	unsigned short coef_bits;
	const char *name;
};
K
Kailang Yang 已提交
881

882 883 884 885 886 887 888
struct alc_codec_rename_pci_table {
	unsigned int codec_vendor_id;
	unsigned short pci_subvendor;
	unsigned short pci_subdevice;
	const char *name;
};

889
static struct alc_codec_rename_table rename_tbl[] = {
890
	{ 0x10ec0221, 0xf00f, 0x1003, "ALC231" },
891 892 893 894 895 896 897 898
	{ 0x10ec0269, 0xfff0, 0x3010, "ALC277" },
	{ 0x10ec0269, 0xf0f0, 0x2010, "ALC259" },
	{ 0x10ec0269, 0xf0f0, 0x3010, "ALC258" },
	{ 0x10ec0269, 0x00f0, 0x0010, "ALC269VB" },
	{ 0x10ec0269, 0xffff, 0xa023, "ALC259" },
	{ 0x10ec0269, 0xffff, 0x6023, "ALC281X" },
	{ 0x10ec0269, 0x00f0, 0x0020, "ALC269VC" },
	{ 0x10ec0269, 0x00f0, 0x0030, "ALC269VD" },
899
	{ 0x10ec0662, 0xffff, 0x4020, "ALC656" },
900 901 902 903 904 905 906 907 908
	{ 0x10ec0887, 0x00f0, 0x0030, "ALC887-VD" },
	{ 0x10ec0888, 0x00f0, 0x0030, "ALC888-VD" },
	{ 0x10ec0888, 0xf0f0, 0x3020, "ALC886" },
	{ 0x10ec0899, 0x2000, 0x2000, "ALC899" },
	{ 0x10ec0892, 0xffff, 0x8020, "ALC661" },
	{ 0x10ec0892, 0xffff, 0x8011, "ALC661" },
	{ 0x10ec0892, 0xffff, 0x4011, "ALC656" },
	{ } /* terminator */
};
K
Kailang Yang 已提交
909

910 911 912 913
static struct alc_codec_rename_pci_table rename_pci_tbl[] = {
	{ 0x10ec0280, 0x1028, 0, "ALC3220" },
	{ 0x10ec0282, 0x1028, 0, "ALC3221" },
	{ 0x10ec0283, 0x1028, 0, "ALC3223" },
914
	{ 0x10ec0288, 0x1028, 0, "ALC3263" },
915
	{ 0x10ec0292, 0x1028, 0, "ALC3226" },
916
	{ 0x10ec0293, 0x1028, 0, "ALC3235" },
917 918
	{ 0x10ec0255, 0x1028, 0, "ALC3234" },
	{ 0x10ec0668, 0x1028, 0, "ALC3661" },
919 920
	{ 0x10ec0275, 0x1028, 0, "ALC3260" },
	{ 0x10ec0899, 0x1028, 0, "ALC3861" },
921
	{ 0x10ec0298, 0x1028, 0, "ALC3266" },
922
	{ 0x10ec0236, 0x1028, 0, "ALC3204" },
923
	{ 0x10ec0256, 0x1028, 0, "ALC3246" },
924
	{ 0x10ec0225, 0x1028, 0, "ALC3253" },
925
	{ 0x10ec0295, 0x1028, 0, "ALC3254" },
926
	{ 0x10ec0299, 0x1028, 0, "ALC3271" },
927 928 929 930 931 932 933 934 935 936 937
	{ 0x10ec0670, 0x1025, 0, "ALC669X" },
	{ 0x10ec0676, 0x1025, 0, "ALC679X" },
	{ 0x10ec0282, 0x1043, 0, "ALC3229" },
	{ 0x10ec0233, 0x1043, 0, "ALC3236" },
	{ 0x10ec0280, 0x103c, 0, "ALC3228" },
	{ 0x10ec0282, 0x103c, 0, "ALC3227" },
	{ 0x10ec0286, 0x103c, 0, "ALC3242" },
	{ 0x10ec0290, 0x103c, 0, "ALC3241" },
	{ 0x10ec0668, 0x103c, 0, "ALC3662" },
	{ 0x10ec0283, 0x17aa, 0, "ALC3239" },
	{ 0x10ec0292, 0x17aa, 0, "ALC3232" },
938 939 940
	{ } /* terminator */
};

941
static int alc_codec_rename_from_preset(struct hda_codec *codec)
942
{
943
	const struct alc_codec_rename_table *p;
944
	const struct alc_codec_rename_pci_table *q;
945

946
	for (p = rename_tbl; p->vendor_id; p++) {
947
		if (p->vendor_id != codec->core.vendor_id)
948 949 950
			continue;
		if ((alc_get_coef0(codec) & p->coef_mask) == p->coef_bits)
			return alc_codec_rename(codec, p->name);
951
	}
952

953 954
	if (!codec->bus->pci)
		return 0;
955
	for (q = rename_pci_tbl; q->codec_vendor_id; q++) {
956
		if (q->codec_vendor_id != codec->core.vendor_id)
957 958 959 960 961 962 963 964
			continue;
		if (q->pci_subvendor != codec->bus->pci->subsystem_vendor)
			continue;
		if (!q->pci_subdevice ||
		    q->pci_subdevice == codec->bus->pci->subsystem_device)
			return alc_codec_rename(codec, q->name);
	}

965
	return 0;
966
}
967

968

969 970 971 972 973 974
/*
 * Digital-beep handlers
 */
#ifdef CONFIG_SND_HDA_INPUT_BEEP
#define set_beep_amp(spec, nid, idx, dir) \
	((spec)->beep_amp = HDA_COMPOSE_AMP_VAL(nid, 3, idx, dir))
K
Kailang Yang 已提交
975

976
static const struct snd_pci_quirk beep_white_list[] = {
977
	SND_PCI_QUIRK(0x1043, 0x103c, "ASUS", 1),
978
	SND_PCI_QUIRK(0x1043, 0x115d, "ASUS", 1),
979
	SND_PCI_QUIRK(0x1043, 0x829f, "ASUS", 1),
980
	SND_PCI_QUIRK(0x1043, 0x8376, "EeePC", 1),
981 982 983
	SND_PCI_QUIRK(0x1043, 0x83ce, "EeePC", 1),
	SND_PCI_QUIRK(0x1043, 0x831a, "EeePC", 1),
	SND_PCI_QUIRK(0x1043, 0x834a, "EeePC", 1),
984
	SND_PCI_QUIRK(0x1458, 0xa002, "GA-MA790X", 1),
985 986
	SND_PCI_QUIRK(0x8086, 0xd613, "Intel", 1),
	{}
987 988
};

989 990 991 992 993 994 995 996 997 998 999 1000 1001
static inline int has_cdefine_beep(struct hda_codec *codec)
{
	struct alc_spec *spec = codec->spec;
	const struct snd_pci_quirk *q;
	q = snd_pci_quirk_lookup(codec->bus->pci, beep_white_list);
	if (q)
		return q->value;
	return spec->cdefine.enable_pcbeep;
}
#else
#define set_beep_amp(spec, nid, idx, dir) /* NOP */
#define has_cdefine_beep(codec)		0
#endif
K
Kailang Yang 已提交
1002

1003 1004 1005 1006
/* parse the BIOS configuration and set up the alc_spec */
/* return 1 if successful, 0 if the proper config is not found,
 * or a negative error code
 */
1007 1008 1009
static int alc_parse_auto_config(struct hda_codec *codec,
				 const hda_nid_t *ignore_nids,
				 const hda_nid_t *ssid_nids)
1010 1011
{
	struct alc_spec *spec = codec->spec;
1012
	struct auto_pin_cfg *cfg = &spec->gen.autocfg;
1013
	int err;
1014

1015 1016
	err = snd_hda_parse_pin_defcfg(codec, cfg, ignore_nids,
				       spec->parse_flags);
1017 1018
	if (err < 0)
		return err;
1019 1020 1021

	if (ssid_nids)
		alc_ssid_check(codec, ssid_nids);
1022

1023 1024 1025
	err = snd_hda_gen_parse_auto_config(codec, cfg);
	if (err < 0)
		return err;
1026

1027
	return 1;
1028
}
1029

1030 1031 1032 1033 1034 1035 1036 1037 1038
/* common preparation job for alc_spec */
static int alc_alloc_spec(struct hda_codec *codec, hda_nid_t mixer_nid)
{
	struct alc_spec *spec = kzalloc(sizeof(*spec), GFP_KERNEL);
	int err;

	if (!spec)
		return -ENOMEM;
	codec->spec = spec;
1039 1040 1041
	snd_hda_gen_spec_init(&spec->gen);
	spec->gen.mixer_nid = mixer_nid;
	spec->gen.own_eapd_ctl = 1;
1042
	codec->single_adc_amp = 1;
1043 1044
	/* FIXME: do we need this for all Realtek codec models? */
	codec->spdif_status_reset = 1;
1045
	codec->patch_ops = alc_patch_ops;
1046 1047 1048 1049 1050 1051 1052 1053 1054

	err = alc_codec_rename_from_preset(codec);
	if (err < 0) {
		kfree(spec);
		return err;
	}
	return 0;
}

1055 1056 1057
static int alc880_parse_auto_config(struct hda_codec *codec)
{
	static const hda_nid_t alc880_ignore[] = { 0x1d, 0 };
1058
	static const hda_nid_t alc880_ssids[] = { 0x15, 0x1b, 0x14, 0 };
1059 1060 1061
	return alc_parse_auto_config(codec, alc880_ignore, alc880_ssids);
}

1062 1063 1064 1065
/*
 * ALC880 fix-ups
 */
enum {
1066
	ALC880_FIXUP_GPIO1,
1067 1068
	ALC880_FIXUP_GPIO2,
	ALC880_FIXUP_MEDION_RIM,
1069
	ALC880_FIXUP_LG,
1070
	ALC880_FIXUP_LG_LW25,
1071
	ALC880_FIXUP_W810,
1072
	ALC880_FIXUP_EAPD_COEF,
1073
	ALC880_FIXUP_TCL_S700,
1074 1075
	ALC880_FIXUP_VOL_KNOB,
	ALC880_FIXUP_FUJITSU,
1076
	ALC880_FIXUP_F1734,
1077
	ALC880_FIXUP_UNIWILL,
1078
	ALC880_FIXUP_UNIWILL_DIG,
1079
	ALC880_FIXUP_Z71V,
1080
	ALC880_FIXUP_ASUS_W5A,
1081 1082 1083 1084 1085 1086 1087 1088 1089
	ALC880_FIXUP_3ST_BASE,
	ALC880_FIXUP_3ST,
	ALC880_FIXUP_3ST_DIG,
	ALC880_FIXUP_5ST_BASE,
	ALC880_FIXUP_5ST,
	ALC880_FIXUP_5ST_DIG,
	ALC880_FIXUP_6ST_BASE,
	ALC880_FIXUP_6ST,
	ALC880_FIXUP_6ST_DIG,
1090
	ALC880_FIXUP_6ST_AUTOMUTE,
1091 1092
};

1093 1094
/* enable the volume-knob widget support on NID 0x21 */
static void alc880_fixup_vol_knob(struct hda_codec *codec,
1095
				  const struct hda_fixup *fix, int action)
1096
{
1097
	if (action == HDA_FIXUP_ACT_PROBE)
1098 1099
		snd_hda_jack_detect_enable_callback(codec, 0x21,
						    alc_update_knob_master);
1100 1101
}

1102
static const struct hda_fixup alc880_fixups[] = {
1103
	[ALC880_FIXUP_GPIO1] = {
1104
		.type = HDA_FIXUP_VERBS,
1105 1106
		.v.verbs = alc_gpio1_init_verbs,
	},
1107
	[ALC880_FIXUP_GPIO2] = {
1108
		.type = HDA_FIXUP_VERBS,
1109 1110 1111
		.v.verbs = alc_gpio2_init_verbs,
	},
	[ALC880_FIXUP_MEDION_RIM] = {
1112
		.type = HDA_FIXUP_VERBS,
1113 1114 1115 1116 1117 1118 1119 1120
		.v.verbs = (const struct hda_verb[]) {
			{ 0x20, AC_VERB_SET_COEF_INDEX, 0x07 },
			{ 0x20, AC_VERB_SET_PROC_COEF,  0x3060 },
			{ }
		},
		.chained = true,
		.chain_id = ALC880_FIXUP_GPIO2,
	},
1121
	[ALC880_FIXUP_LG] = {
1122 1123
		.type = HDA_FIXUP_PINS,
		.v.pins = (const struct hda_pintbl[]) {
1124 1125 1126 1127 1128 1129 1130
			/* disable bogus unused pins */
			{ 0x16, 0x411111f0 },
			{ 0x18, 0x411111f0 },
			{ 0x1a, 0x411111f0 },
			{ }
		}
	},
1131 1132 1133 1134 1135 1136 1137 1138
	[ALC880_FIXUP_LG_LW25] = {
		.type = HDA_FIXUP_PINS,
		.v.pins = (const struct hda_pintbl[]) {
			{ 0x1a, 0x0181344f }, /* line-in */
			{ 0x1b, 0x0321403f }, /* headphone */
			{ }
		}
	},
1139
	[ALC880_FIXUP_W810] = {
1140 1141
		.type = HDA_FIXUP_PINS,
		.v.pins = (const struct hda_pintbl[]) {
1142 1143 1144 1145 1146 1147 1148
			/* disable bogus unused pins */
			{ 0x17, 0x411111f0 },
			{ }
		},
		.chained = true,
		.chain_id = ALC880_FIXUP_GPIO2,
	},
1149
	[ALC880_FIXUP_EAPD_COEF] = {
1150
		.type = HDA_FIXUP_VERBS,
1151 1152 1153 1154 1155 1156 1157
		.v.verbs = (const struct hda_verb[]) {
			/* change to EAPD mode */
			{ 0x20, AC_VERB_SET_COEF_INDEX, 0x07 },
			{ 0x20, AC_VERB_SET_PROC_COEF,  0x3060 },
			{}
		},
	},
1158
	[ALC880_FIXUP_TCL_S700] = {
1159
		.type = HDA_FIXUP_VERBS,
1160 1161 1162 1163 1164 1165 1166 1167 1168
		.v.verbs = (const struct hda_verb[]) {
			/* change to EAPD mode */
			{ 0x20, AC_VERB_SET_COEF_INDEX, 0x07 },
			{ 0x20, AC_VERB_SET_PROC_COEF,  0x3070 },
			{}
		},
		.chained = true,
		.chain_id = ALC880_FIXUP_GPIO2,
	},
1169
	[ALC880_FIXUP_VOL_KNOB] = {
1170
		.type = HDA_FIXUP_FUNC,
1171 1172 1173 1174
		.v.func = alc880_fixup_vol_knob,
	},
	[ALC880_FIXUP_FUJITSU] = {
		/* override all pins as BIOS on old Amilo is broken */
1175 1176
		.type = HDA_FIXUP_PINS,
		.v.pins = (const struct hda_pintbl[]) {
1177
			{ 0x14, 0x0121401f }, /* HP */
1178 1179 1180 1181 1182 1183 1184 1185 1186 1187 1188 1189 1190 1191 1192
			{ 0x15, 0x99030120 }, /* speaker */
			{ 0x16, 0x99030130 }, /* bass speaker */
			{ 0x17, 0x411111f0 }, /* N/A */
			{ 0x18, 0x411111f0 }, /* N/A */
			{ 0x19, 0x01a19950 }, /* mic-in */
			{ 0x1a, 0x411111f0 }, /* N/A */
			{ 0x1b, 0x411111f0 }, /* N/A */
			{ 0x1c, 0x411111f0 }, /* N/A */
			{ 0x1d, 0x411111f0 }, /* N/A */
			{ 0x1e, 0x01454140 }, /* SPDIF out */
			{ }
		},
		.chained = true,
		.chain_id = ALC880_FIXUP_VOL_KNOB,
	},
1193 1194
	[ALC880_FIXUP_F1734] = {
		/* almost compatible with FUJITSU, but no bass and SPDIF */
1195 1196
		.type = HDA_FIXUP_PINS,
		.v.pins = (const struct hda_pintbl[]) {
1197
			{ 0x14, 0x0121401f }, /* HP */
1198 1199 1200 1201 1202 1203 1204 1205 1206 1207 1208 1209 1210 1211 1212
			{ 0x15, 0x99030120 }, /* speaker */
			{ 0x16, 0x411111f0 }, /* N/A */
			{ 0x17, 0x411111f0 }, /* N/A */
			{ 0x18, 0x411111f0 }, /* N/A */
			{ 0x19, 0x01a19950 }, /* mic-in */
			{ 0x1a, 0x411111f0 }, /* N/A */
			{ 0x1b, 0x411111f0 }, /* N/A */
			{ 0x1c, 0x411111f0 }, /* N/A */
			{ 0x1d, 0x411111f0 }, /* N/A */
			{ 0x1e, 0x411111f0 }, /* N/A */
			{ }
		},
		.chained = true,
		.chain_id = ALC880_FIXUP_VOL_KNOB,
	},
1213 1214
	[ALC880_FIXUP_UNIWILL] = {
		/* need to fix HP and speaker pins to be parsed correctly */
1215 1216
		.type = HDA_FIXUP_PINS,
		.v.pins = (const struct hda_pintbl[]) {
1217 1218 1219 1220 1221 1222
			{ 0x14, 0x0121411f }, /* HP */
			{ 0x15, 0x99030120 }, /* speaker */
			{ 0x16, 0x99030130 }, /* bass speaker */
			{ }
		},
	},
1223
	[ALC880_FIXUP_UNIWILL_DIG] = {
1224 1225
		.type = HDA_FIXUP_PINS,
		.v.pins = (const struct hda_pintbl[]) {
1226 1227 1228 1229 1230 1231 1232 1233
			/* disable bogus unused pins */
			{ 0x17, 0x411111f0 },
			{ 0x19, 0x411111f0 },
			{ 0x1b, 0x411111f0 },
			{ 0x1f, 0x411111f0 },
			{ }
		}
	},
1234
	[ALC880_FIXUP_Z71V] = {
1235 1236
		.type = HDA_FIXUP_PINS,
		.v.pins = (const struct hda_pintbl[]) {
1237 1238 1239 1240 1241 1242 1243 1244 1245 1246 1247 1248 1249 1250 1251
			/* set up the whole pins as BIOS is utterly broken */
			{ 0x14, 0x99030120 }, /* speaker */
			{ 0x15, 0x0121411f }, /* HP */
			{ 0x16, 0x411111f0 }, /* N/A */
			{ 0x17, 0x411111f0 }, /* N/A */
			{ 0x18, 0x01a19950 }, /* mic-in */
			{ 0x19, 0x411111f0 }, /* N/A */
			{ 0x1a, 0x01813031 }, /* line-in */
			{ 0x1b, 0x411111f0 }, /* N/A */
			{ 0x1c, 0x411111f0 }, /* N/A */
			{ 0x1d, 0x411111f0 }, /* N/A */
			{ 0x1e, 0x0144111e }, /* SPDIF */
			{ }
		}
	},
1252 1253 1254 1255 1256 1257 1258 1259 1260 1261 1262 1263 1264 1265 1266 1267 1268 1269 1270 1271
	[ALC880_FIXUP_ASUS_W5A] = {
		.type = HDA_FIXUP_PINS,
		.v.pins = (const struct hda_pintbl[]) {
			/* set up the whole pins as BIOS is utterly broken */
			{ 0x14, 0x0121411f }, /* HP */
			{ 0x15, 0x411111f0 }, /* N/A */
			{ 0x16, 0x411111f0 }, /* N/A */
			{ 0x17, 0x411111f0 }, /* N/A */
			{ 0x18, 0x90a60160 }, /* mic */
			{ 0x19, 0x411111f0 }, /* N/A */
			{ 0x1a, 0x411111f0 }, /* N/A */
			{ 0x1b, 0x411111f0 }, /* N/A */
			{ 0x1c, 0x411111f0 }, /* N/A */
			{ 0x1d, 0x411111f0 }, /* N/A */
			{ 0x1e, 0xb743111e }, /* SPDIF out */
			{ }
		},
		.chained = true,
		.chain_id = ALC880_FIXUP_GPIO1,
	},
1272
	[ALC880_FIXUP_3ST_BASE] = {
1273 1274
		.type = HDA_FIXUP_PINS,
		.v.pins = (const struct hda_pintbl[]) {
1275 1276 1277 1278 1279 1280 1281 1282 1283 1284 1285 1286 1287 1288 1289 1290
			{ 0x14, 0x01014010 }, /* line-out */
			{ 0x15, 0x411111f0 }, /* N/A */
			{ 0x16, 0x411111f0 }, /* N/A */
			{ 0x17, 0x411111f0 }, /* N/A */
			{ 0x18, 0x01a19c30 }, /* mic-in */
			{ 0x19, 0x0121411f }, /* HP */
			{ 0x1a, 0x01813031 }, /* line-in */
			{ 0x1b, 0x02a19c40 }, /* front-mic */
			{ 0x1c, 0x411111f0 }, /* N/A */
			{ 0x1d, 0x411111f0 }, /* N/A */
			/* 0x1e is filled in below */
			{ 0x1f, 0x411111f0 }, /* N/A */
			{ }
		}
	},
	[ALC880_FIXUP_3ST] = {
1291 1292
		.type = HDA_FIXUP_PINS,
		.v.pins = (const struct hda_pintbl[]) {
1293 1294 1295 1296 1297 1298 1299
			{ 0x1e, 0x411111f0 }, /* N/A */
			{ }
		},
		.chained = true,
		.chain_id = ALC880_FIXUP_3ST_BASE,
	},
	[ALC880_FIXUP_3ST_DIG] = {
1300 1301
		.type = HDA_FIXUP_PINS,
		.v.pins = (const struct hda_pintbl[]) {
1302 1303 1304 1305 1306 1307 1308
			{ 0x1e, 0x0144111e }, /* SPDIF */
			{ }
		},
		.chained = true,
		.chain_id = ALC880_FIXUP_3ST_BASE,
	},
	[ALC880_FIXUP_5ST_BASE] = {
1309 1310
		.type = HDA_FIXUP_PINS,
		.v.pins = (const struct hda_pintbl[]) {
1311 1312 1313 1314 1315 1316 1317 1318 1319 1320 1321 1322 1323 1324 1325 1326
			{ 0x14, 0x01014010 }, /* front */
			{ 0x15, 0x411111f0 }, /* N/A */
			{ 0x16, 0x01011411 }, /* CLFE */
			{ 0x17, 0x01016412 }, /* surr */
			{ 0x18, 0x01a19c30 }, /* mic-in */
			{ 0x19, 0x0121411f }, /* HP */
			{ 0x1a, 0x01813031 }, /* line-in */
			{ 0x1b, 0x02a19c40 }, /* front-mic */
			{ 0x1c, 0x411111f0 }, /* N/A */
			{ 0x1d, 0x411111f0 }, /* N/A */
			/* 0x1e is filled in below */
			{ 0x1f, 0x411111f0 }, /* N/A */
			{ }
		}
	},
	[ALC880_FIXUP_5ST] = {
1327 1328
		.type = HDA_FIXUP_PINS,
		.v.pins = (const struct hda_pintbl[]) {
1329 1330 1331 1332 1333 1334 1335
			{ 0x1e, 0x411111f0 }, /* N/A */
			{ }
		},
		.chained = true,
		.chain_id = ALC880_FIXUP_5ST_BASE,
	},
	[ALC880_FIXUP_5ST_DIG] = {
1336 1337
		.type = HDA_FIXUP_PINS,
		.v.pins = (const struct hda_pintbl[]) {
1338 1339 1340 1341 1342 1343 1344
			{ 0x1e, 0x0144111e }, /* SPDIF */
			{ }
		},
		.chained = true,
		.chain_id = ALC880_FIXUP_5ST_BASE,
	},
	[ALC880_FIXUP_6ST_BASE] = {
1345 1346
		.type = HDA_FIXUP_PINS,
		.v.pins = (const struct hda_pintbl[]) {
1347 1348 1349 1350 1351 1352 1353 1354 1355 1356 1357 1358 1359 1360 1361 1362
			{ 0x14, 0x01014010 }, /* front */
			{ 0x15, 0x01016412 }, /* surr */
			{ 0x16, 0x01011411 }, /* CLFE */
			{ 0x17, 0x01012414 }, /* side */
			{ 0x18, 0x01a19c30 }, /* mic-in */
			{ 0x19, 0x02a19c40 }, /* front-mic */
			{ 0x1a, 0x01813031 }, /* line-in */
			{ 0x1b, 0x0121411f }, /* HP */
			{ 0x1c, 0x411111f0 }, /* N/A */
			{ 0x1d, 0x411111f0 }, /* N/A */
			/* 0x1e is filled in below */
			{ 0x1f, 0x411111f0 }, /* N/A */
			{ }
		}
	},
	[ALC880_FIXUP_6ST] = {
1363 1364
		.type = HDA_FIXUP_PINS,
		.v.pins = (const struct hda_pintbl[]) {
1365 1366 1367 1368 1369 1370 1371
			{ 0x1e, 0x411111f0 }, /* N/A */
			{ }
		},
		.chained = true,
		.chain_id = ALC880_FIXUP_6ST_BASE,
	},
	[ALC880_FIXUP_6ST_DIG] = {
1372 1373
		.type = HDA_FIXUP_PINS,
		.v.pins = (const struct hda_pintbl[]) {
1374 1375 1376 1377 1378 1379
			{ 0x1e, 0x0144111e }, /* SPDIF */
			{ }
		},
		.chained = true,
		.chain_id = ALC880_FIXUP_6ST_BASE,
	},
1380 1381 1382 1383 1384 1385 1386 1387 1388
	[ALC880_FIXUP_6ST_AUTOMUTE] = {
		.type = HDA_FIXUP_PINS,
		.v.pins = (const struct hda_pintbl[]) {
			{ 0x1b, 0x0121401f }, /* HP with jack detect */
			{ }
		},
		.chained_before = true,
		.chain_id = ALC880_FIXUP_6ST_BASE,
	},
1389 1390 1391
};

static const struct snd_pci_quirk alc880_fixup_tbl[] = {
1392
	SND_PCI_QUIRK(0x1019, 0x0f69, "Coeus G610P", ALC880_FIXUP_W810),
1393
	SND_PCI_QUIRK(0x1043, 0x10c3, "ASUS W5A", ALC880_FIXUP_ASUS_W5A),
1394
	SND_PCI_QUIRK(0x1043, 0x1964, "ASUS Z71V", ALC880_FIXUP_Z71V),
1395
	SND_PCI_QUIRK_VENDOR(0x1043, "ASUS", ALC880_FIXUP_GPIO1),
1396
	SND_PCI_QUIRK(0x147b, 0x1045, "ABit AA8XE", ALC880_FIXUP_6ST_AUTOMUTE),
1397
	SND_PCI_QUIRK(0x1558, 0x5401, "Clevo GPIO2", ALC880_FIXUP_GPIO2),
1398
	SND_PCI_QUIRK_VENDOR(0x1558, "Clevo", ALC880_FIXUP_EAPD_COEF),
1399
	SND_PCI_QUIRK(0x1584, 0x9050, "Uniwill", ALC880_FIXUP_UNIWILL_DIG),
1400
	SND_PCI_QUIRK(0x1584, 0x9054, "Uniwill", ALC880_FIXUP_F1734),
1401
	SND_PCI_QUIRK(0x1584, 0x9070, "Uniwill", ALC880_FIXUP_UNIWILL),
1402
	SND_PCI_QUIRK(0x1584, 0x9077, "Uniwill P53", ALC880_FIXUP_VOL_KNOB),
1403
	SND_PCI_QUIRK(0x161f, 0x203d, "W810", ALC880_FIXUP_W810),
1404
	SND_PCI_QUIRK(0x161f, 0x205d, "Medion Rim 2150", ALC880_FIXUP_MEDION_RIM),
1405
	SND_PCI_QUIRK(0x1631, 0xe011, "PB 13201056", ALC880_FIXUP_6ST_AUTOMUTE),
1406
	SND_PCI_QUIRK(0x1734, 0x107c, "FSC Amilo M1437", ALC880_FIXUP_FUJITSU),
1407
	SND_PCI_QUIRK(0x1734, 0x1094, "FSC Amilo M1451G", ALC880_FIXUP_FUJITSU),
1408
	SND_PCI_QUIRK(0x1734, 0x10ac, "FSC AMILO Xi 1526", ALC880_FIXUP_F1734),
1409
	SND_PCI_QUIRK(0x1734, 0x10b0, "FSC Amilo Pi1556", ALC880_FIXUP_FUJITSU),
1410 1411 1412
	SND_PCI_QUIRK(0x1854, 0x003b, "LG", ALC880_FIXUP_LG),
	SND_PCI_QUIRK(0x1854, 0x005f, "LG P1 Express", ALC880_FIXUP_LG),
	SND_PCI_QUIRK(0x1854, 0x0068, "LG w1", ALC880_FIXUP_LG),
1413
	SND_PCI_QUIRK(0x1854, 0x0077, "LG LW25", ALC880_FIXUP_LG_LW25),
1414
	SND_PCI_QUIRK(0x19db, 0x4188, "TCL S700", ALC880_FIXUP_TCL_S700),
1415 1416 1417 1418 1419 1420 1421 1422 1423 1424 1425 1426 1427 1428 1429 1430 1431 1432 1433 1434 1435 1436 1437 1438 1439 1440 1441 1442 1443 1444 1445 1446 1447 1448 1449 1450 1451 1452 1453 1454 1455 1456 1457 1458 1459 1460 1461

	/* Below is the copied entries from alc880_quirks.c.
	 * It's not quite sure whether BIOS sets the correct pin-config table
	 * on these machines, thus they are kept to be compatible with
	 * the old static quirks.  Once when it's confirmed to work without
	 * these overrides, it'd be better to remove.
	 */
	SND_PCI_QUIRK(0x1019, 0xa880, "ECS", ALC880_FIXUP_5ST_DIG),
	SND_PCI_QUIRK(0x1019, 0xa884, "Acer APFV", ALC880_FIXUP_6ST),
	SND_PCI_QUIRK(0x1025, 0x0070, "ULI", ALC880_FIXUP_3ST_DIG),
	SND_PCI_QUIRK(0x1025, 0x0077, "ULI", ALC880_FIXUP_6ST_DIG),
	SND_PCI_QUIRK(0x1025, 0x0078, "ULI", ALC880_FIXUP_6ST_DIG),
	SND_PCI_QUIRK(0x1025, 0x0087, "ULI", ALC880_FIXUP_6ST_DIG),
	SND_PCI_QUIRK(0x1025, 0xe309, "ULI", ALC880_FIXUP_3ST_DIG),
	SND_PCI_QUIRK(0x1025, 0xe310, "ULI", ALC880_FIXUP_3ST),
	SND_PCI_QUIRK(0x1039, 0x1234, NULL, ALC880_FIXUP_6ST_DIG),
	SND_PCI_QUIRK(0x104d, 0x81a0, "Sony", ALC880_FIXUP_3ST),
	SND_PCI_QUIRK(0x104d, 0x81d6, "Sony", ALC880_FIXUP_3ST),
	SND_PCI_QUIRK(0x107b, 0x3032, "Gateway", ALC880_FIXUP_5ST),
	SND_PCI_QUIRK(0x107b, 0x3033, "Gateway", ALC880_FIXUP_5ST),
	SND_PCI_QUIRK(0x107b, 0x4039, "Gateway", ALC880_FIXUP_5ST),
	SND_PCI_QUIRK(0x1297, 0xc790, "Shuttle ST20G5", ALC880_FIXUP_6ST_DIG),
	SND_PCI_QUIRK(0x1458, 0xa102, "Gigabyte K8", ALC880_FIXUP_6ST_DIG),
	SND_PCI_QUIRK(0x1462, 0x1150, "MSI", ALC880_FIXUP_6ST_DIG),
	SND_PCI_QUIRK(0x1509, 0x925d, "FIC P4M", ALC880_FIXUP_6ST_DIG),
	SND_PCI_QUIRK(0x1565, 0x8202, "Biostar", ALC880_FIXUP_5ST_DIG),
	SND_PCI_QUIRK(0x1695, 0x400d, "EPoX", ALC880_FIXUP_5ST_DIG),
	SND_PCI_QUIRK(0x1695, 0x4012, "EPox EP-5LDA", ALC880_FIXUP_5ST_DIG),
	SND_PCI_QUIRK(0x2668, 0x8086, NULL, ALC880_FIXUP_6ST_DIG), /* broken BIOS */
	SND_PCI_QUIRK(0x8086, 0x2668, NULL, ALC880_FIXUP_6ST_DIG),
	SND_PCI_QUIRK(0x8086, 0xa100, "Intel mobo", ALC880_FIXUP_5ST_DIG),
	SND_PCI_QUIRK(0x8086, 0xd400, "Intel mobo", ALC880_FIXUP_5ST_DIG),
	SND_PCI_QUIRK(0x8086, 0xd401, "Intel mobo", ALC880_FIXUP_5ST_DIG),
	SND_PCI_QUIRK(0x8086, 0xd402, "Intel mobo", ALC880_FIXUP_3ST_DIG),
	SND_PCI_QUIRK(0x8086, 0xe224, "Intel mobo", ALC880_FIXUP_5ST_DIG),
	SND_PCI_QUIRK(0x8086, 0xe305, "Intel mobo", ALC880_FIXUP_3ST_DIG),
	SND_PCI_QUIRK(0x8086, 0xe308, "Intel mobo", ALC880_FIXUP_3ST_DIG),
	SND_PCI_QUIRK(0x8086, 0xe400, "Intel mobo", ALC880_FIXUP_5ST_DIG),
	SND_PCI_QUIRK(0x8086, 0xe401, "Intel mobo", ALC880_FIXUP_5ST_DIG),
	SND_PCI_QUIRK(0x8086, 0xe402, "Intel mobo", ALC880_FIXUP_5ST_DIG),
	/* default Intel */
	SND_PCI_QUIRK_VENDOR(0x8086, "Intel mobo", ALC880_FIXUP_3ST),
	SND_PCI_QUIRK(0xa0a0, 0x0560, "AOpen i915GMm-HFS", ALC880_FIXUP_5ST_DIG),
	SND_PCI_QUIRK(0xe803, 0x1019, NULL, ALC880_FIXUP_6ST_DIG),
	{}
};

1462
static const struct hda_model_fixup alc880_fixup_models[] = {
1463 1464 1465 1466 1467 1468
	{.id = ALC880_FIXUP_3ST, .name = "3stack"},
	{.id = ALC880_FIXUP_3ST_DIG, .name = "3stack-digout"},
	{.id = ALC880_FIXUP_5ST, .name = "5stack"},
	{.id = ALC880_FIXUP_5ST_DIG, .name = "5stack-digout"},
	{.id = ALC880_FIXUP_6ST, .name = "6stack"},
	{.id = ALC880_FIXUP_6ST_DIG, .name = "6stack-digout"},
1469
	{.id = ALC880_FIXUP_6ST_AUTOMUTE, .name = "6stack-automute"},
1470 1471 1472 1473
	{}
};


1474 1475 1476 1477
/*
 * OK, here we have finally the patch for ALC880
 */
static int patch_alc880(struct hda_codec *codec)
1478
{
1479 1480
	struct alc_spec *spec;
	int err;
1481

1482 1483 1484
	err = alc_alloc_spec(codec, 0x0b);
	if (err < 0)
		return err;
1485

1486
	spec = codec->spec;
1487
	spec->gen.need_dac_fix = 1;
1488
	spec->gen.beep_nid = 0x01;
1489

1490 1491
	codec->patch_ops.unsol_event = alc880_unsol_event;

1492
	snd_hda_pick_fixup(codec, alc880_fixup_models, alc880_fixup_tbl,
1493
		       alc880_fixups);
1494
	snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE);
1495

1496 1497 1498 1499
	/* automatic parse from the BIOS config */
	err = alc880_parse_auto_config(codec);
	if (err < 0)
		goto error;
1500

1501
	if (!spec->gen.no_analog)
1502
		set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
1503

1504
	snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE);
1505

1506
	return 0;
1507 1508 1509 1510

 error:
	alc_free(codec);
	return err;
1511 1512
}

1513

1514
/*
1515
 * ALC260 support
1516
 */
1517
static int alc260_parse_auto_config(struct hda_codec *codec)
1518
{
1519
	static const hda_nid_t alc260_ignore[] = { 0x17, 0 };
1520 1521
	static const hda_nid_t alc260_ssids[] = { 0x10, 0x15, 0x0f, 0 };
	return alc_parse_auto_config(codec, alc260_ignore, alc260_ssids);
1522 1523
}

1524 1525 1526 1527
/*
 * Pin config fixes
 */
enum {
1528 1529 1530
	ALC260_FIXUP_HP_DC5750,
	ALC260_FIXUP_HP_PIN_0F,
	ALC260_FIXUP_COEF,
1531
	ALC260_FIXUP_GPIO1,
1532 1533
	ALC260_FIXUP_GPIO1_TOGGLE,
	ALC260_FIXUP_REPLACER,
1534
	ALC260_FIXUP_HP_B1900,
1535
	ALC260_FIXUP_KN1,
1536
	ALC260_FIXUP_FSC_S7020,
1537
	ALC260_FIXUP_FSC_S7020_JWSE,
1538
	ALC260_FIXUP_VAIO_PINS,
1539 1540
};

1541 1542 1543 1544
static void alc260_gpio1_automute(struct hda_codec *codec)
{
	struct alc_spec *spec = codec->spec;
	snd_hda_codec_write(codec, 0x01, 0, AC_VERB_SET_GPIO_DATA,
1545
			    spec->gen.hp_jack_present);
1546 1547 1548
}

static void alc260_fixup_gpio1_toggle(struct hda_codec *codec,
1549
				      const struct hda_fixup *fix, int action)
1550 1551
{
	struct alc_spec *spec = codec->spec;
1552
	if (action == HDA_FIXUP_ACT_PROBE) {
1553 1554 1555
		/* although the machine has only one output pin, we need to
		 * toggle GPIO1 according to the jack state
		 */
1556 1557 1558 1559
		spec->gen.automute_hook = alc260_gpio1_automute;
		spec->gen.detect_hp = 1;
		spec->gen.automute_speaker = 1;
		spec->gen.autocfg.hp_pins[0] = 0x0f; /* copy it for automute */
1560
		snd_hda_jack_detect_enable_callback(codec, 0x0f,
1561
						    snd_hda_gen_hp_automute);
1562
		snd_hda_add_verbs(codec, alc_gpio1_init_verbs);
1563 1564 1565
	}
}

1566
static void alc260_fixup_kn1(struct hda_codec *codec,
1567
			     const struct hda_fixup *fix, int action)
1568 1569
{
	struct alc_spec *spec = codec->spec;
1570
	static const struct hda_pintbl pincfgs[] = {
1571 1572 1573 1574 1575 1576 1577 1578 1579 1580 1581 1582 1583 1584 1585 1586
		{ 0x0f, 0x02214000 }, /* HP/speaker */
		{ 0x12, 0x90a60160 }, /* int mic */
		{ 0x13, 0x02a19000 }, /* ext mic */
		{ 0x18, 0x01446000 }, /* SPDIF out */
		/* disable bogus I/O pins */
		{ 0x10, 0x411111f0 },
		{ 0x11, 0x411111f0 },
		{ 0x14, 0x411111f0 },
		{ 0x15, 0x411111f0 },
		{ 0x16, 0x411111f0 },
		{ 0x17, 0x411111f0 },
		{ 0x19, 0x411111f0 },
		{ }
	};

	switch (action) {
1587 1588
	case HDA_FIXUP_ACT_PRE_PROBE:
		snd_hda_apply_pincfgs(codec, pincfgs);
1589
		break;
1590
	case HDA_FIXUP_ACT_PROBE:
1591 1592 1593 1594 1595
		spec->init_amp = ALC_INIT_NONE;
		break;
	}
}

1596 1597 1598 1599
static void alc260_fixup_fsc_s7020(struct hda_codec *codec,
				   const struct hda_fixup *fix, int action)
{
	struct alc_spec *spec = codec->spec;
1600 1601 1602
	if (action == HDA_FIXUP_ACT_PROBE)
		spec->init_amp = ALC_INIT_NONE;
}
1603

1604 1605 1606 1607 1608
static void alc260_fixup_fsc_s7020_jwse(struct hda_codec *codec,
				   const struct hda_fixup *fix, int action)
{
	struct alc_spec *spec = codec->spec;
	if (action == HDA_FIXUP_ACT_PRE_PROBE) {
1609
		spec->gen.add_jack_modes = 1;
1610
		spec->gen.hp_mic = 1;
1611
	}
1612 1613
}

1614
static const struct hda_fixup alc260_fixups[] = {
1615
	[ALC260_FIXUP_HP_DC5750] = {
1616 1617
		.type = HDA_FIXUP_PINS,
		.v.pins = (const struct hda_pintbl[]) {
1618 1619 1620 1621
			{ 0x11, 0x90130110 }, /* speaker */
			{ }
		}
	},
1622
	[ALC260_FIXUP_HP_PIN_0F] = {
1623 1624
		.type = HDA_FIXUP_PINS,
		.v.pins = (const struct hda_pintbl[]) {
1625 1626 1627 1628 1629
			{ 0x0f, 0x01214000 }, /* HP */
			{ }
		}
	},
	[ALC260_FIXUP_COEF] = {
1630
		.type = HDA_FIXUP_VERBS,
1631
		.v.verbs = (const struct hda_verb[]) {
1632 1633
			{ 0x1a, AC_VERB_SET_COEF_INDEX, 0x07 },
			{ 0x1a, AC_VERB_SET_PROC_COEF,  0x3040 },
1634 1635 1636
			{ }
		},
	},
1637
	[ALC260_FIXUP_GPIO1] = {
1638
		.type = HDA_FIXUP_VERBS,
1639 1640
		.v.verbs = alc_gpio1_init_verbs,
	},
1641
	[ALC260_FIXUP_GPIO1_TOGGLE] = {
1642
		.type = HDA_FIXUP_FUNC,
1643 1644 1645 1646 1647
		.v.func = alc260_fixup_gpio1_toggle,
		.chained = true,
		.chain_id = ALC260_FIXUP_HP_PIN_0F,
	},
	[ALC260_FIXUP_REPLACER] = {
1648
		.type = HDA_FIXUP_VERBS,
1649
		.v.verbs = (const struct hda_verb[]) {
1650 1651
			{ 0x1a, AC_VERB_SET_COEF_INDEX, 0x07 },
			{ 0x1a, AC_VERB_SET_PROC_COEF,  0x3050 },
1652 1653 1654 1655 1656
			{ }
		},
		.chained = true,
		.chain_id = ALC260_FIXUP_GPIO1_TOGGLE,
	},
1657
	[ALC260_FIXUP_HP_B1900] = {
1658
		.type = HDA_FIXUP_FUNC,
1659 1660 1661
		.v.func = alc260_fixup_gpio1_toggle,
		.chained = true,
		.chain_id = ALC260_FIXUP_COEF,
1662 1663
	},
	[ALC260_FIXUP_KN1] = {
1664
		.type = HDA_FIXUP_FUNC,
1665 1666
		.v.func = alc260_fixup_kn1,
	},
1667 1668 1669 1670
	[ALC260_FIXUP_FSC_S7020] = {
		.type = HDA_FIXUP_FUNC,
		.v.func = alc260_fixup_fsc_s7020,
	},
1671 1672 1673 1674 1675 1676
	[ALC260_FIXUP_FSC_S7020_JWSE] = {
		.type = HDA_FIXUP_FUNC,
		.v.func = alc260_fixup_fsc_s7020_jwse,
		.chained = true,
		.chain_id = ALC260_FIXUP_FSC_S7020,
	},
1677 1678 1679 1680 1681 1682 1683 1684 1685 1686 1687 1688 1689 1690 1691 1692 1693 1694
	[ALC260_FIXUP_VAIO_PINS] = {
		.type = HDA_FIXUP_PINS,
		.v.pins = (const struct hda_pintbl[]) {
			/* Pin configs are missing completely on some VAIOs */
			{ 0x0f, 0x01211020 },
			{ 0x10, 0x0001003f },
			{ 0x11, 0x411111f0 },
			{ 0x12, 0x01a15930 },
			{ 0x13, 0x411111f0 },
			{ 0x14, 0x411111f0 },
			{ 0x15, 0x411111f0 },
			{ 0x16, 0x411111f0 },
			{ 0x17, 0x411111f0 },
			{ 0x18, 0x411111f0 },
			{ 0x19, 0x411111f0 },
			{ }
		}
	},
1695 1696 1697
};

static const struct snd_pci_quirk alc260_fixup_tbl[] = {
1698
	SND_PCI_QUIRK(0x1025, 0x007b, "Acer C20x", ALC260_FIXUP_GPIO1),
1699
	SND_PCI_QUIRK(0x1025, 0x007f, "Acer Aspire 9500", ALC260_FIXUP_COEF),
1700
	SND_PCI_QUIRK(0x1025, 0x008f, "Acer", ALC260_FIXUP_GPIO1),
1701
	SND_PCI_QUIRK(0x103c, 0x280a, "HP dc5750", ALC260_FIXUP_HP_DC5750),
1702
	SND_PCI_QUIRK(0x103c, 0x30ba, "HP Presario B1900", ALC260_FIXUP_HP_B1900),
1703
	SND_PCI_QUIRK(0x104d, 0x81bb, "Sony VAIO", ALC260_FIXUP_VAIO_PINS),
1704
	SND_PCI_QUIRK(0x104d, 0x81e2, "Sony VAIO TX", ALC260_FIXUP_HP_PIN_0F),
1705
	SND_PCI_QUIRK(0x10cf, 0x1326, "FSC LifeBook S7020", ALC260_FIXUP_FSC_S7020),
1706
	SND_PCI_QUIRK(0x1509, 0x4540, "Favorit 100XS", ALC260_FIXUP_GPIO1),
1707
	SND_PCI_QUIRK(0x152d, 0x0729, "Quanta KN1", ALC260_FIXUP_KN1),
1708
	SND_PCI_QUIRK(0x161f, 0x2057, "Replacer 672V", ALC260_FIXUP_REPLACER),
1709
	SND_PCI_QUIRK(0x1631, 0xc017, "PB V7900", ALC260_FIXUP_COEF),
1710 1711 1712
	{}
};

1713 1714 1715 1716 1717 1718 1719 1720
static const struct hda_model_fixup alc260_fixup_models[] = {
	{.id = ALC260_FIXUP_GPIO1, .name = "gpio1"},
	{.id = ALC260_FIXUP_COEF, .name = "coef"},
	{.id = ALC260_FIXUP_FSC_S7020, .name = "fujitsu"},
	{.id = ALC260_FIXUP_FSC_S7020_JWSE, .name = "fujitsu-jwse"},
	{}
};

1721 1722 1723
/*
 */
static int patch_alc260(struct hda_codec *codec)
1724
{
1725
	struct alc_spec *spec;
1726
	int err;
1727

1728 1729 1730
	err = alc_alloc_spec(codec, 0x07);
	if (err < 0)
		return err;
1731

1732
	spec = codec->spec;
1733 1734 1735 1736 1737
	/* as quite a few machines require HP amp for speaker outputs,
	 * it's easier to enable it unconditionally; even if it's unneeded,
	 * it's almost harmless.
	 */
	spec->gen.prefer_hp_amp = 1;
1738
	spec->gen.beep_nid = 0x01;
1739

1740 1741
	spec->shutup = alc_eapd_shutup;

1742 1743
	snd_hda_pick_fixup(codec, alc260_fixup_models, alc260_fixup_tbl,
			   alc260_fixups);
1744
	snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE);
1745

1746 1747 1748 1749
	/* automatic parse from the BIOS config */
	err = alc260_parse_auto_config(codec);
	if (err < 0)
		goto error;
1750

1751
	if (!spec->gen.no_analog)
1752
		set_beep_amp(spec, 0x07, 0x05, HDA_INPUT);
1753

1754
	snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE);
1755

1756
	return 0;
1757 1758 1759 1760

 error:
	alc_free(codec);
	return err;
1761 1762
}

1763 1764 1765 1766 1767 1768 1769 1770 1771 1772 1773 1774 1775 1776 1777 1778

/*
 * ALC882/883/885/888/889 support
 *
 * ALC882 is almost identical with ALC880 but has cleaner and more flexible
 * configuration.  Each pin widget can choose any input DACs and a mixer.
 * Each ADC is connected from a mixer of all inputs.  This makes possible
 * 6-channel independent captures.
 *
 * In addition, an independent DAC for the multi-playback (not used in this
 * driver yet).
 */

/*
 * Pin config fixes
 */
1779
enum {
1780 1781 1782 1783 1784
	ALC882_FIXUP_ABIT_AW9D_MAX,
	ALC882_FIXUP_LENOVO_Y530,
	ALC882_FIXUP_PB_M5210,
	ALC882_FIXUP_ACER_ASPIRE_7736,
	ALC882_FIXUP_ASUS_W90V,
1785
	ALC889_FIXUP_CD,
1786
	ALC889_FIXUP_FRONT_HP_NO_PRESENCE,
1787
	ALC889_FIXUP_VAIO_TT,
1788
	ALC888_FIXUP_EEE1601,
1789
	ALC882_FIXUP_EAPD,
1790
	ALC883_FIXUP_EAPD,
1791
	ALC883_FIXUP_ACER_EAPD,
1792 1793
	ALC882_FIXUP_GPIO1,
	ALC882_FIXUP_GPIO2,
1794
	ALC882_FIXUP_GPIO3,
1795 1796
	ALC889_FIXUP_COEF,
	ALC882_FIXUP_ASUS_W2JC,
1797 1798 1799
	ALC882_FIXUP_ACER_ASPIRE_4930G,
	ALC882_FIXUP_ACER_ASPIRE_8930G,
	ALC882_FIXUP_ASPIRE_8930G_VERBS,
1800
	ALC885_FIXUP_MACPRO_GPIO,
1801
	ALC889_FIXUP_DAC_ROUTE,
1802 1803
	ALC889_FIXUP_MBP_VREF,
	ALC889_FIXUP_IMAC91_VREF,
1804
	ALC889_FIXUP_MBA11_VREF,
1805
	ALC889_FIXUP_MBA21_VREF,
1806
	ALC889_FIXUP_MP11_VREF,
1807
	ALC889_FIXUP_MP41_VREF,
1808
	ALC882_FIXUP_INV_DMIC,
1809
	ALC882_FIXUP_NO_PRIMARY_HP,
1810
	ALC887_FIXUP_ASUS_BASS,
1811
	ALC887_FIXUP_BASS_CHMAP,
1812
	ALC1220_FIXUP_GB_DUAL_CODECS,
1813
	ALC1220_FIXUP_CLEVO_P950,
1814 1815
};

1816
static void alc889_fixup_coef(struct hda_codec *codec,
1817
			      const struct hda_fixup *fix, int action)
1818
{
1819
	if (action != HDA_FIXUP_ACT_INIT)
1820
		return;
1821
	alc_update_coef_idx(codec, 7, 0, 0x2030);
1822 1823
}

1824 1825 1826 1827 1828
/* toggle speaker-output according to the hp-jack state */
static void alc882_gpio_mute(struct hda_codec *codec, int pin, int muted)
{
	unsigned int gpiostate, gpiomask, gpiodir;

1829
	gpiostate = snd_hda_codec_read(codec, codec->core.afg, 0,
1830 1831 1832 1833 1834 1835 1836
				       AC_VERB_GET_GPIO_DATA, 0);

	if (!muted)
		gpiostate |= (1 << pin);
	else
		gpiostate &= ~(1 << pin);

1837
	gpiomask = snd_hda_codec_read(codec, codec->core.afg, 0,
1838 1839 1840
				      AC_VERB_GET_GPIO_MASK, 0);
	gpiomask |= (1 << pin);

1841
	gpiodir = snd_hda_codec_read(codec, codec->core.afg, 0,
1842 1843 1844 1845
				     AC_VERB_GET_GPIO_DIRECTION, 0);
	gpiodir |= (1 << pin);


1846
	snd_hda_codec_write(codec, codec->core.afg, 0,
1847
			    AC_VERB_SET_GPIO_MASK, gpiomask);
1848
	snd_hda_codec_write(codec, codec->core.afg, 0,
1849 1850 1851 1852
			    AC_VERB_SET_GPIO_DIRECTION, gpiodir);

	msleep(1);

1853
	snd_hda_codec_write(codec, codec->core.afg, 0,
1854 1855 1856 1857 1858
			    AC_VERB_SET_GPIO_DATA, gpiostate);
}

/* set up GPIO at initialization */
static void alc885_fixup_macpro_gpio(struct hda_codec *codec,
1859
				     const struct hda_fixup *fix, int action)
1860
{
1861
	if (action != HDA_FIXUP_ACT_INIT)
1862 1863 1864 1865 1866
		return;
	alc882_gpio_mute(codec, 0, 0);
	alc882_gpio_mute(codec, 1, 0);
}

1867 1868 1869 1870 1871
/* Fix the connection of some pins for ALC889:
 * At least, Acer Aspire 5935 shows the connections to DAC3/4 don't
 * work correctly (bko#42740)
 */
static void alc889_fixup_dac_route(struct hda_codec *codec,
1872
				   const struct hda_fixup *fix, int action)
1873
{
1874
	if (action == HDA_FIXUP_ACT_PRE_PROBE) {
1875
		/* fake the connections during parsing the tree */
1876 1877 1878 1879 1880 1881
		hda_nid_t conn1[2] = { 0x0c, 0x0d };
		hda_nid_t conn2[2] = { 0x0e, 0x0f };
		snd_hda_override_conn_list(codec, 0x14, 2, conn1);
		snd_hda_override_conn_list(codec, 0x15, 2, conn1);
		snd_hda_override_conn_list(codec, 0x18, 2, conn2);
		snd_hda_override_conn_list(codec, 0x1a, 2, conn2);
1882
	} else if (action == HDA_FIXUP_ACT_PROBE) {
1883 1884 1885 1886 1887 1888
		/* restore the connections */
		hda_nid_t conn[5] = { 0x0c, 0x0d, 0x0e, 0x0f, 0x26 };
		snd_hda_override_conn_list(codec, 0x14, 5, conn);
		snd_hda_override_conn_list(codec, 0x15, 5, conn);
		snd_hda_override_conn_list(codec, 0x18, 5, conn);
		snd_hda_override_conn_list(codec, 0x1a, 5, conn);
1889 1890 1891
	}
}

1892 1893
/* Set VREF on HP pin */
static void alc889_fixup_mbp_vref(struct hda_codec *codec,
1894
				  const struct hda_fixup *fix, int action)
1895 1896
{
	struct alc_spec *spec = codec->spec;
1897
	static hda_nid_t nids[3] = { 0x14, 0x15, 0x19 };
1898 1899
	int i;

1900
	if (action != HDA_FIXUP_ACT_INIT)
1901 1902 1903 1904 1905
		return;
	for (i = 0; i < ARRAY_SIZE(nids); i++) {
		unsigned int val = snd_hda_codec_get_pincfg(codec, nids[i]);
		if (get_defcfg_device(val) != AC_JACK_HP_OUT)
			continue;
1906
		val = snd_hda_codec_get_pin_target(codec, nids[i]);
1907
		val |= AC_PINCTL_VREF_80;
1908
		snd_hda_set_pin_ctl(codec, nids[i], val);
1909
		spec->gen.keep_vref_in_automute = 1;
1910 1911 1912 1913
		break;
	}
}

1914 1915
static void alc889_fixup_mac_pins(struct hda_codec *codec,
				  const hda_nid_t *nids, int num_nids)
1916 1917 1918 1919
{
	struct alc_spec *spec = codec->spec;
	int i;

1920
	for (i = 0; i < num_nids; i++) {
1921
		unsigned int val;
1922
		val = snd_hda_codec_get_pin_target(codec, nids[i]);
1923
		val |= AC_PINCTL_VREF_50;
1924
		snd_hda_set_pin_ctl(codec, nids[i], val);
1925
	}
1926
	spec->gen.keep_vref_in_automute = 1;
1927 1928
}

1929 1930 1931 1932 1933 1934 1935 1936 1937 1938
/* Set VREF on speaker pins on imac91 */
static void alc889_fixup_imac91_vref(struct hda_codec *codec,
				     const struct hda_fixup *fix, int action)
{
	static hda_nid_t nids[2] = { 0x18, 0x1a };

	if (action == HDA_FIXUP_ACT_INIT)
		alc889_fixup_mac_pins(codec, nids, ARRAY_SIZE(nids));
}

1939 1940 1941 1942 1943 1944 1945 1946 1947 1948
/* Set VREF on speaker pins on mba11 */
static void alc889_fixup_mba11_vref(struct hda_codec *codec,
				    const struct hda_fixup *fix, int action)
{
	static hda_nid_t nids[1] = { 0x18 };

	if (action == HDA_FIXUP_ACT_INIT)
		alc889_fixup_mac_pins(codec, nids, ARRAY_SIZE(nids));
}

1949 1950 1951 1952 1953 1954 1955 1956 1957 1958
/* Set VREF on speaker pins on mba21 */
static void alc889_fixup_mba21_vref(struct hda_codec *codec,
				    const struct hda_fixup *fix, int action)
{
	static hda_nid_t nids[2] = { 0x18, 0x19 };

	if (action == HDA_FIXUP_ACT_INIT)
		alc889_fixup_mac_pins(codec, nids, ARRAY_SIZE(nids));
}

1959
/* Don't take HP output as primary
1960 1961
 * Strangely, the speaker output doesn't work on Vaio Z and some Vaio
 * all-in-one desktop PCs (for example VGC-LN51JGB) through DAC 0x05
1962 1963
 */
static void alc882_fixup_no_primary_hp(struct hda_codec *codec,
1964
				       const struct hda_fixup *fix, int action)
1965 1966
{
	struct alc_spec *spec = codec->spec;
1967
	if (action == HDA_FIXUP_ACT_PRE_PROBE) {
1968
		spec->gen.no_primary_hp = 1;
1969 1970
		spec->gen.no_multi_io = 1;
	}
1971 1972
}

1973 1974 1975
static void alc_fixup_bass_chmap(struct hda_codec *codec,
				 const struct hda_fixup *fix, int action);

1976 1977 1978 1979 1980 1981 1982 1983 1984 1985 1986 1987 1988 1989 1990 1991 1992 1993 1994 1995 1996 1997 1998 1999 2000 2001 2002 2003 2004 2005 2006 2007 2008 2009 2010 2011 2012 2013 2014 2015 2016 2017 2018 2019 2020 2021 2022 2023 2024 2025 2026 2027 2028 2029 2030
/* For dual-codec configuration, we need to disable some features to avoid
 * conflicts of kctls and PCM streams
 */
static void alc_fixup_dual_codecs(struct hda_codec *codec,
				  const struct hda_fixup *fix, int action)
{
	struct alc_spec *spec = codec->spec;

	if (action != HDA_FIXUP_ACT_PRE_PROBE)
		return;
	/* disable vmaster */
	spec->gen.suppress_vmaster = 1;
	/* auto-mute and auto-mic switch don't work with multiple codecs */
	spec->gen.suppress_auto_mute = 1;
	spec->gen.suppress_auto_mic = 1;
	/* disable aamix as well */
	spec->gen.mixer_nid = 0;
	/* add location prefix to avoid conflicts */
	codec->force_pin_prefix = 1;
}

static void rename_ctl(struct hda_codec *codec, const char *oldname,
		       const char *newname)
{
	struct snd_kcontrol *kctl;

	kctl = snd_hda_find_mixer_ctl(codec, oldname);
	if (kctl)
		strcpy(kctl->id.name, newname);
}

static void alc1220_fixup_gb_dual_codecs(struct hda_codec *codec,
					 const struct hda_fixup *fix,
					 int action)
{
	alc_fixup_dual_codecs(codec, fix, action);
	switch (action) {
	case HDA_FIXUP_ACT_PRE_PROBE:
		/* override card longname to provide a unique UCM profile */
		strcpy(codec->card->longname, "HDAudio-Gigabyte-ALC1220DualCodecs");
		break;
	case HDA_FIXUP_ACT_BUILD:
		/* rename Capture controls depending on the codec */
		rename_ctl(codec, "Capture Volume",
			   codec->addr == 0 ?
			   "Rear-Panel Capture Volume" :
			   "Front-Panel Capture Volume");
		rename_ctl(codec, "Capture Switch",
			   codec->addr == 0 ?
			   "Rear-Panel Capture Switch" :
			   "Front-Panel Capture Switch");
		break;
	}
}

2031 2032 2033 2034 2035 2036 2037 2038 2039 2040 2041 2042 2043 2044 2045 2046 2047
static void alc1220_fixup_clevo_p950(struct hda_codec *codec,
				     const struct hda_fixup *fix,
				     int action)
{
	hda_nid_t conn1[1] = { 0x0c };

	if (action != HDA_FIXUP_ACT_PRE_PROBE)
		return;

	alc_update_coef_idx(codec, 0x7, 0, 0x3c3);
	/* We therefore want to make sure 0x14 (front headphone) and
	 * 0x1b (speakers) use the stereo DAC 0x02
	 */
	snd_hda_override_conn_list(codec, 0x14, 1, conn1);
	snd_hda_override_conn_list(codec, 0x1b, 1, conn1);
}

2048
static const struct hda_fixup alc882_fixups[] = {
2049
	[ALC882_FIXUP_ABIT_AW9D_MAX] = {
2050 2051
		.type = HDA_FIXUP_PINS,
		.v.pins = (const struct hda_pintbl[]) {
2052 2053 2054
			{ 0x15, 0x01080104 }, /* side */
			{ 0x16, 0x01011012 }, /* rear */
			{ 0x17, 0x01016011 }, /* clfe */
2055
			{ }
2056 2057
		}
	},
2058
	[ALC882_FIXUP_LENOVO_Y530] = {
2059 2060
		.type = HDA_FIXUP_PINS,
		.v.pins = (const struct hda_pintbl[]) {
2061 2062
			{ 0x15, 0x99130112 }, /* rear int speakers */
			{ 0x16, 0x99130111 }, /* subwoofer */
2063 2064 2065
			{ }
		}
	},
2066
	[ALC882_FIXUP_PB_M5210] = {
2067 2068 2069
		.type = HDA_FIXUP_PINCTLS,
		.v.pins = (const struct hda_pintbl[]) {
			{ 0x19, PIN_VREF50 },
2070 2071 2072
			{}
		}
	},
2073
	[ALC882_FIXUP_ACER_ASPIRE_7736] = {
2074
		.type = HDA_FIXUP_FUNC,
2075
		.v.func = alc_fixup_sku_ignore,
2076
	},
2077
	[ALC882_FIXUP_ASUS_W90V] = {
2078 2079
		.type = HDA_FIXUP_PINS,
		.v.pins = (const struct hda_pintbl[]) {
2080 2081 2082 2083
			{ 0x16, 0x99130110 }, /* fix sequence for CLFE */
			{ }
		}
	},
2084
	[ALC889_FIXUP_CD] = {
2085 2086
		.type = HDA_FIXUP_PINS,
		.v.pins = (const struct hda_pintbl[]) {
2087 2088 2089 2090
			{ 0x1c, 0x993301f0 }, /* CD */
			{ }
		}
	},
2091 2092 2093 2094 2095 2096 2097 2098 2099
	[ALC889_FIXUP_FRONT_HP_NO_PRESENCE] = {
		.type = HDA_FIXUP_PINS,
		.v.pins = (const struct hda_pintbl[]) {
			{ 0x1b, 0x02214120 }, /* Front HP jack is flaky, disable jack detect */
			{ }
		},
		.chained = true,
		.chain_id = ALC889_FIXUP_CD,
	},
2100
	[ALC889_FIXUP_VAIO_TT] = {
2101 2102
		.type = HDA_FIXUP_PINS,
		.v.pins = (const struct hda_pintbl[]) {
2103 2104 2105 2106
			{ 0x17, 0x90170111 }, /* hidden surround speaker */
			{ }
		}
	},
2107
	[ALC888_FIXUP_EEE1601] = {
2108
		.type = HDA_FIXUP_VERBS,
2109 2110 2111 2112 2113
		.v.verbs = (const struct hda_verb[]) {
			{ 0x20, AC_VERB_SET_COEF_INDEX, 0x0b },
			{ 0x20, AC_VERB_SET_PROC_COEF,  0x0838 },
			{ }
		}
2114 2115
	},
	[ALC882_FIXUP_EAPD] = {
2116
		.type = HDA_FIXUP_VERBS,
2117 2118 2119 2120 2121 2122 2123
		.v.verbs = (const struct hda_verb[]) {
			/* change to EAPD mode */
			{ 0x20, AC_VERB_SET_COEF_INDEX, 0x07 },
			{ 0x20, AC_VERB_SET_PROC_COEF, 0x3060 },
			{ }
		}
	},
2124
	[ALC883_FIXUP_EAPD] = {
2125
		.type = HDA_FIXUP_VERBS,
2126 2127 2128 2129 2130 2131 2132
		.v.verbs = (const struct hda_verb[]) {
			/* change to EAPD mode */
			{ 0x20, AC_VERB_SET_COEF_INDEX, 0x07 },
			{ 0x20, AC_VERB_SET_PROC_COEF, 0x3070 },
			{ }
		}
	},
2133
	[ALC883_FIXUP_ACER_EAPD] = {
2134
		.type = HDA_FIXUP_VERBS,
2135 2136 2137 2138 2139 2140 2141
		.v.verbs = (const struct hda_verb[]) {
			/* eanable EAPD on Acer laptops */
			{ 0x20, AC_VERB_SET_COEF_INDEX, 0x07 },
			{ 0x20, AC_VERB_SET_PROC_COEF, 0x3050 },
			{ }
		}
	},
2142
	[ALC882_FIXUP_GPIO1] = {
2143
		.type = HDA_FIXUP_VERBS,
2144 2145 2146
		.v.verbs = alc_gpio1_init_verbs,
	},
	[ALC882_FIXUP_GPIO2] = {
2147
		.type = HDA_FIXUP_VERBS,
2148 2149
		.v.verbs = alc_gpio2_init_verbs,
	},
2150
	[ALC882_FIXUP_GPIO3] = {
2151
		.type = HDA_FIXUP_VERBS,
2152 2153
		.v.verbs = alc_gpio3_init_verbs,
	},
2154
	[ALC882_FIXUP_ASUS_W2JC] = {
2155
		.type = HDA_FIXUP_VERBS,
2156 2157 2158 2159 2160
		.v.verbs = alc_gpio1_init_verbs,
		.chained = true,
		.chain_id = ALC882_FIXUP_EAPD,
	},
	[ALC889_FIXUP_COEF] = {
2161
		.type = HDA_FIXUP_FUNC,
2162 2163
		.v.func = alc889_fixup_coef,
	},
2164
	[ALC882_FIXUP_ACER_ASPIRE_4930G] = {
2165 2166
		.type = HDA_FIXUP_PINS,
		.v.pins = (const struct hda_pintbl[]) {
2167 2168 2169
			{ 0x16, 0x99130111 }, /* CLFE speaker */
			{ 0x17, 0x99130112 }, /* surround speaker */
			{ }
2170 2171 2172
		},
		.chained = true,
		.chain_id = ALC882_FIXUP_GPIO1,
2173 2174
	},
	[ALC882_FIXUP_ACER_ASPIRE_8930G] = {
2175 2176
		.type = HDA_FIXUP_PINS,
		.v.pins = (const struct hda_pintbl[]) {
2177 2178 2179 2180 2181 2182 2183 2184 2185
			{ 0x16, 0x99130111 }, /* CLFE speaker */
			{ 0x1b, 0x99130112 }, /* surround speaker */
			{ }
		},
		.chained = true,
		.chain_id = ALC882_FIXUP_ASPIRE_8930G_VERBS,
	},
	[ALC882_FIXUP_ASPIRE_8930G_VERBS] = {
		/* additional init verbs for Acer Aspire 8930G */
2186
		.type = HDA_FIXUP_VERBS,
2187 2188 2189 2190 2191 2192 2193 2194 2195 2196 2197 2198 2199 2200 2201 2202 2203 2204 2205 2206 2207 2208 2209 2210 2211 2212 2213 2214
		.v.verbs = (const struct hda_verb[]) {
			/* Enable all DACs */
			/* DAC DISABLE/MUTE 1? */
			/*  setting bits 1-5 disables DAC nids 0x02-0x06
			 *  apparently. Init=0x38 */
			{ 0x20, AC_VERB_SET_COEF_INDEX, 0x03 },
			{ 0x20, AC_VERB_SET_PROC_COEF, 0x0000 },
			/* DAC DISABLE/MUTE 2? */
			/*  some bit here disables the other DACs.
			 *  Init=0x4900 */
			{ 0x20, AC_VERB_SET_COEF_INDEX, 0x08 },
			{ 0x20, AC_VERB_SET_PROC_COEF, 0x0000 },
			/* DMIC fix
			 * This laptop has a stereo digital microphone.
			 * The mics are only 1cm apart which makes the stereo
			 * useless. However, either the mic or the ALC889
			 * makes the signal become a difference/sum signal
			 * instead of standard stereo, which is annoying.
			 * So instead we flip this bit which makes the
			 * codec replicate the sum signal to both channels,
			 * turning it into a normal mono mic.
			 */
			/* DMIC_CONTROL? Init value = 0x0001 */
			{ 0x20, AC_VERB_SET_COEF_INDEX, 0x0b },
			{ 0x20, AC_VERB_SET_PROC_COEF, 0x0003 },
			{ 0x20, AC_VERB_SET_COEF_INDEX, 0x07 },
			{ 0x20, AC_VERB_SET_PROC_COEF, 0x3050 },
			{ }
2215 2216 2217
		},
		.chained = true,
		.chain_id = ALC882_FIXUP_GPIO1,
2218
	},
2219
	[ALC885_FIXUP_MACPRO_GPIO] = {
2220
		.type = HDA_FIXUP_FUNC,
2221 2222
		.v.func = alc885_fixup_macpro_gpio,
	},
2223
	[ALC889_FIXUP_DAC_ROUTE] = {
2224
		.type = HDA_FIXUP_FUNC,
2225 2226
		.v.func = alc889_fixup_dac_route,
	},
2227
	[ALC889_FIXUP_MBP_VREF] = {
2228
		.type = HDA_FIXUP_FUNC,
2229 2230 2231 2232 2233
		.v.func = alc889_fixup_mbp_vref,
		.chained = true,
		.chain_id = ALC882_FIXUP_GPIO1,
	},
	[ALC889_FIXUP_IMAC91_VREF] = {
2234
		.type = HDA_FIXUP_FUNC,
2235 2236 2237 2238
		.v.func = alc889_fixup_imac91_vref,
		.chained = true,
		.chain_id = ALC882_FIXUP_GPIO1,
	},
2239 2240 2241 2242 2243 2244
	[ALC889_FIXUP_MBA11_VREF] = {
		.type = HDA_FIXUP_FUNC,
		.v.func = alc889_fixup_mba11_vref,
		.chained = true,
		.chain_id = ALC889_FIXUP_MBP_VREF,
	},
2245 2246 2247 2248 2249 2250
	[ALC889_FIXUP_MBA21_VREF] = {
		.type = HDA_FIXUP_FUNC,
		.v.func = alc889_fixup_mba21_vref,
		.chained = true,
		.chain_id = ALC889_FIXUP_MBP_VREF,
	},
2251 2252 2253 2254 2255 2256
	[ALC889_FIXUP_MP11_VREF] = {
		.type = HDA_FIXUP_FUNC,
		.v.func = alc889_fixup_mba11_vref,
		.chained = true,
		.chain_id = ALC885_FIXUP_MACPRO_GPIO,
	},
2257 2258 2259 2260 2261 2262
	[ALC889_FIXUP_MP41_VREF] = {
		.type = HDA_FIXUP_FUNC,
		.v.func = alc889_fixup_mbp_vref,
		.chained = true,
		.chain_id = ALC885_FIXUP_MACPRO_GPIO,
	},
2263
	[ALC882_FIXUP_INV_DMIC] = {
2264
		.type = HDA_FIXUP_FUNC,
2265
		.v.func = alc_fixup_inv_dmic,
2266
	},
2267
	[ALC882_FIXUP_NO_PRIMARY_HP] = {
2268
		.type = HDA_FIXUP_FUNC,
2269 2270
		.v.func = alc882_fixup_no_primary_hp,
	},
2271 2272 2273 2274 2275 2276
	[ALC887_FIXUP_ASUS_BASS] = {
		.type = HDA_FIXUP_PINS,
		.v.pins = (const struct hda_pintbl[]) {
			{0x16, 0x99130130}, /* bass speaker */
			{}
		},
2277 2278 2279 2280 2281 2282
		.chained = true,
		.chain_id = ALC887_FIXUP_BASS_CHMAP,
	},
	[ALC887_FIXUP_BASS_CHMAP] = {
		.type = HDA_FIXUP_FUNC,
		.v.func = alc_fixup_bass_chmap,
2283
	},
2284 2285 2286 2287
	[ALC1220_FIXUP_GB_DUAL_CODECS] = {
		.type = HDA_FIXUP_FUNC,
		.v.func = alc1220_fixup_gb_dual_codecs,
	},
2288 2289 2290 2291
	[ALC1220_FIXUP_CLEVO_P950] = {
		.type = HDA_FIXUP_FUNC,
		.v.func = alc1220_fixup_clevo_p950,
	},
2292 2293
};

2294
static const struct snd_pci_quirk alc882_fixup_tbl[] = {
2295 2296
	SND_PCI_QUIRK(0x1025, 0x006c, "Acer Aspire 9810", ALC883_FIXUP_ACER_EAPD),
	SND_PCI_QUIRK(0x1025, 0x0090, "Acer Aspire", ALC883_FIXUP_ACER_EAPD),
2297
	SND_PCI_QUIRK(0x1025, 0x0107, "Acer Aspire", ALC883_FIXUP_ACER_EAPD),
2298 2299 2300 2301
	SND_PCI_QUIRK(0x1025, 0x010a, "Acer Ferrari 5000", ALC883_FIXUP_ACER_EAPD),
	SND_PCI_QUIRK(0x1025, 0x0110, "Acer Aspire", ALC883_FIXUP_ACER_EAPD),
	SND_PCI_QUIRK(0x1025, 0x0112, "Acer Aspire 9303", ALC883_FIXUP_ACER_EAPD),
	SND_PCI_QUIRK(0x1025, 0x0121, "Acer Aspire 5920G", ALC883_FIXUP_ACER_EAPD),
2302 2303 2304 2305 2306 2307 2308 2309 2310 2311 2312 2313 2314 2315
	SND_PCI_QUIRK(0x1025, 0x013e, "Acer Aspire 4930G",
		      ALC882_FIXUP_ACER_ASPIRE_4930G),
	SND_PCI_QUIRK(0x1025, 0x013f, "Acer Aspire 5930G",
		      ALC882_FIXUP_ACER_ASPIRE_4930G),
	SND_PCI_QUIRK(0x1025, 0x0145, "Acer Aspire 8930G",
		      ALC882_FIXUP_ACER_ASPIRE_8930G),
	SND_PCI_QUIRK(0x1025, 0x0146, "Acer Aspire 6935G",
		      ALC882_FIXUP_ACER_ASPIRE_8930G),
	SND_PCI_QUIRK(0x1025, 0x015e, "Acer Aspire 6930G",
		      ALC882_FIXUP_ACER_ASPIRE_4930G),
	SND_PCI_QUIRK(0x1025, 0x0166, "Acer Aspire 6530G",
		      ALC882_FIXUP_ACER_ASPIRE_4930G),
	SND_PCI_QUIRK(0x1025, 0x0142, "Acer Aspire 7730G",
		      ALC882_FIXUP_ACER_ASPIRE_4930G),
2316
	SND_PCI_QUIRK(0x1025, 0x0155, "Packard-Bell M5120", ALC882_FIXUP_PB_M5210),
2317 2318
	SND_PCI_QUIRK(0x1025, 0x021e, "Acer Aspire 5739G",
		      ALC882_FIXUP_ACER_ASPIRE_4930G),
2319
	SND_PCI_QUIRK(0x1025, 0x0259, "Acer Aspire 5935", ALC889_FIXUP_DAC_ROUTE),
2320
	SND_PCI_QUIRK(0x1025, 0x026b, "Acer Aspire 8940G", ALC882_FIXUP_ACER_ASPIRE_8930G),
2321
	SND_PCI_QUIRK(0x1025, 0x0296, "Acer Aspire 7736z", ALC882_FIXUP_ACER_ASPIRE_7736),
2322
	SND_PCI_QUIRK(0x1043, 0x13c2, "Asus A7M", ALC882_FIXUP_EAPD),
2323
	SND_PCI_QUIRK(0x1043, 0x1873, "ASUS W90V", ALC882_FIXUP_ASUS_W90V),
2324
	SND_PCI_QUIRK(0x1043, 0x1971, "Asus W2JC", ALC882_FIXUP_ASUS_W2JC),
2325
	SND_PCI_QUIRK(0x1043, 0x835f, "Asus Eee 1601", ALC888_FIXUP_EEE1601),
2326
	SND_PCI_QUIRK(0x1043, 0x84bc, "ASUS ET2700", ALC887_FIXUP_ASUS_BASS),
2327
	SND_PCI_QUIRK(0x1043, 0x8691, "ASUS ROG Ranger VIII", ALC882_FIXUP_GPIO3),
2328
	SND_PCI_QUIRK(0x104d, 0x9047, "Sony Vaio TT", ALC889_FIXUP_VAIO_TT),
2329
	SND_PCI_QUIRK(0x104d, 0x905a, "Sony Vaio Z", ALC882_FIXUP_NO_PRIMARY_HP),
2330
	SND_PCI_QUIRK(0x104d, 0x9060, "Sony Vaio VPCL14M1R", ALC882_FIXUP_NO_PRIMARY_HP),
2331
	SND_PCI_QUIRK(0x104d, 0x9043, "Sony Vaio VGC-LN51JGB", ALC882_FIXUP_NO_PRIMARY_HP),
2332
	SND_PCI_QUIRK(0x104d, 0x9044, "Sony VAIO AiO", ALC882_FIXUP_NO_PRIMARY_HP),
2333 2334

	/* All Apple entries are in codec SSIDs */
2335 2336 2337
	SND_PCI_QUIRK(0x106b, 0x00a0, "MacBookPro 3,1", ALC889_FIXUP_MBP_VREF),
	SND_PCI_QUIRK(0x106b, 0x00a1, "Macbook", ALC889_FIXUP_MBP_VREF),
	SND_PCI_QUIRK(0x106b, 0x00a4, "MacbookPro 4,1", ALC889_FIXUP_MBP_VREF),
2338
	SND_PCI_QUIRK(0x106b, 0x0c00, "Mac Pro", ALC889_FIXUP_MP11_VREF),
2339 2340
	SND_PCI_QUIRK(0x106b, 0x1000, "iMac 24", ALC885_FIXUP_MACPRO_GPIO),
	SND_PCI_QUIRK(0x106b, 0x2800, "AppleTV", ALC885_FIXUP_MACPRO_GPIO),
2341 2342
	SND_PCI_QUIRK(0x106b, 0x2c00, "MacbookPro rev3", ALC889_FIXUP_MBP_VREF),
	SND_PCI_QUIRK(0x106b, 0x3000, "iMac", ALC889_FIXUP_MBP_VREF),
2343
	SND_PCI_QUIRK(0x106b, 0x3200, "iMac 7,1 Aluminum", ALC882_FIXUP_EAPD),
2344
	SND_PCI_QUIRK(0x106b, 0x3400, "MacBookAir 1,1", ALC889_FIXUP_MBA11_VREF),
2345
	SND_PCI_QUIRK(0x106b, 0x3500, "MacBookAir 2,1", ALC889_FIXUP_MBA21_VREF),
2346 2347
	SND_PCI_QUIRK(0x106b, 0x3600, "Macbook 3,1", ALC889_FIXUP_MBP_VREF),
	SND_PCI_QUIRK(0x106b, 0x3800, "MacbookPro 4,1", ALC889_FIXUP_MBP_VREF),
2348
	SND_PCI_QUIRK(0x106b, 0x3e00, "iMac 24 Aluminum", ALC885_FIXUP_MACPRO_GPIO),
2349 2350 2351
	SND_PCI_QUIRK(0x106b, 0x3f00, "Macbook 5,1", ALC889_FIXUP_IMAC91_VREF),
	SND_PCI_QUIRK(0x106b, 0x4000, "MacbookPro 5,1", ALC889_FIXUP_IMAC91_VREF),
	SND_PCI_QUIRK(0x106b, 0x4100, "Macmini 3,1", ALC889_FIXUP_IMAC91_VREF),
2352
	SND_PCI_QUIRK(0x106b, 0x4200, "Mac Pro 4,1/5,1", ALC889_FIXUP_MP41_VREF),
2353
	SND_PCI_QUIRK(0x106b, 0x4300, "iMac 9,1", ALC889_FIXUP_IMAC91_VREF),
2354 2355
	SND_PCI_QUIRK(0x106b, 0x4600, "MacbookPro 5,2", ALC889_FIXUP_IMAC91_VREF),
	SND_PCI_QUIRK(0x106b, 0x4900, "iMac 9,1 Aluminum", ALC889_FIXUP_IMAC91_VREF),
2356
	SND_PCI_QUIRK(0x106b, 0x4a00, "Macbook 5,2", ALC889_FIXUP_MBA11_VREF),
2357

2358
	SND_PCI_QUIRK(0x1071, 0x8258, "Evesham Voyaeger", ALC882_FIXUP_EAPD),
2359
	SND_PCI_QUIRK(0x1458, 0xa002, "Gigabyte EP45-DS3/Z87X-UD3H", ALC889_FIXUP_FRONT_HP_NO_PRESENCE),
2360
	SND_PCI_QUIRK(0x1458, 0xa0b8, "Gigabyte AZ370-Gaming", ALC1220_FIXUP_GB_DUAL_CODECS),
2361
	SND_PCI_QUIRK(0x1462, 0x7350, "MSI-7350", ALC889_FIXUP_CD),
2362
	SND_PCI_QUIRK(0x1462, 0xda57, "MSI Z270-Gaming", ALC1220_FIXUP_GB_DUAL_CODECS),
2363
	SND_PCI_QUIRK_VENDOR(0x1462, "MSI", ALC882_FIXUP_GPIO3),
2364
	SND_PCI_QUIRK(0x147b, 0x107a, "Abit AW9D-MAX", ALC882_FIXUP_ABIT_AW9D_MAX),
2365
	SND_PCI_QUIRK(0x1558, 0x9501, "Clevo P950HR", ALC1220_FIXUP_CLEVO_P950),
2366
	SND_PCI_QUIRK(0x1558, 0x95e2, "Clevo P950ER", ALC1220_FIXUP_CLEVO_P950),
2367 2368
	SND_PCI_QUIRK_VENDOR(0x1558, "Clevo laptop", ALC882_FIXUP_EAPD),
	SND_PCI_QUIRK(0x161f, 0x2054, "Medion laptop", ALC883_FIXUP_EAPD),
2369
	SND_PCI_QUIRK(0x17aa, 0x3a0d, "Lenovo Y530", ALC882_FIXUP_LENOVO_Y530),
2370
	SND_PCI_QUIRK(0x8086, 0x0022, "DX58SO", ALC889_FIXUP_COEF),
2371 2372 2373
	{}
};

2374
static const struct hda_model_fixup alc882_fixup_models[] = {
2375 2376 2377
	{.id = ALC882_FIXUP_ACER_ASPIRE_4930G, .name = "acer-aspire-4930g"},
	{.id = ALC882_FIXUP_ACER_ASPIRE_8930G, .name = "acer-aspire-8930g"},
	{.id = ALC883_FIXUP_ACER_EAPD, .name = "acer-aspire"},
2378
	{.id = ALC882_FIXUP_INV_DMIC, .name = "inv-dmic"},
2379
	{.id = ALC882_FIXUP_NO_PRIMARY_HP, .name = "no-primary-hp"},
2380
	{.id = ALC1220_FIXUP_GB_DUAL_CODECS, .name = "dual-codecs"},
2381 2382 2383
	{}
};

2384
/*
2385
 * BIOS auto configuration
2386
 */
2387 2388 2389 2390
/* almost identical with ALC880 parser... */
static int alc882_parse_auto_config(struct hda_codec *codec)
{
	static const hda_nid_t alc882_ignore[] = { 0x1d, 0 };
2391 2392
	static const hda_nid_t alc882_ssids[] = { 0x15, 0x1b, 0x14, 0 };
	return alc_parse_auto_config(codec, alc882_ignore, alc882_ssids);
2393
}
2394

2395 2396 2397
/*
 */
static int patch_alc882(struct hda_codec *codec)
2398 2399
{
	struct alc_spec *spec;
2400
	int err;
2401

2402 2403 2404
	err = alc_alloc_spec(codec, 0x0b);
	if (err < 0)
		return err;
2405

2406
	spec = codec->spec;
2407

2408
	switch (codec->core.vendor_id) {
2409 2410
	case 0x10ec0882:
	case 0x10ec0885:
2411
	case 0x10ec0900:
2412
	case 0x10ec1220:
2413 2414 2415 2416 2417
		break;
	default:
		/* ALC883 and variants */
		alc_fix_pll_init(codec, 0x20, 0x0a, 10);
		break;
2418
	}
2419

2420
	snd_hda_pick_fixup(codec, alc882_fixup_models, alc882_fixup_tbl,
2421
		       alc882_fixups);
2422
	snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE);
2423

2424 2425
	alc_auto_parse_customize_define(codec);

2426 2427 2428
	if (has_cdefine_beep(codec))
		spec->gen.beep_nid = 0x01;

2429 2430 2431 2432
	/* automatic parse from the BIOS config */
	err = alc882_parse_auto_config(codec);
	if (err < 0)
		goto error;
2433

2434
	if (!spec->gen.no_analog && spec->gen.beep_nid)
2435
		set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
2436

2437
	snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE);
2438

2439
	return 0;
2440 2441 2442 2443

 error:
	alc_free(codec);
	return err;
2444 2445
}

2446 2447

/*
2448
 * ALC262 support
2449
 */
2450
static int alc262_parse_auto_config(struct hda_codec *codec)
2451
{
2452
	static const hda_nid_t alc262_ignore[] = { 0x1d, 0 };
2453 2454
	static const hda_nid_t alc262_ssids[] = { 0x15, 0x1b, 0x14, 0 };
	return alc_parse_auto_config(codec, alc262_ignore, alc262_ssids);
2455 2456 2457
}

/*
2458
 * Pin config fixes
2459
 */
2460
enum {
2461
	ALC262_FIXUP_FSC_H270,
2462
	ALC262_FIXUP_FSC_S7110,
2463 2464
	ALC262_FIXUP_HP_Z200,
	ALC262_FIXUP_TYAN,
2465
	ALC262_FIXUP_LENOVO_3000,
2466 2467
	ALC262_FIXUP_BENQ,
	ALC262_FIXUP_BENQ_T31,
2468
	ALC262_FIXUP_INV_DMIC,
2469
	ALC262_FIXUP_INTEL_BAYLEYBAY,
2470 2471
};

2472
static const struct hda_fixup alc262_fixups[] = {
2473
	[ALC262_FIXUP_FSC_H270] = {
2474 2475
		.type = HDA_FIXUP_PINS,
		.v.pins = (const struct hda_pintbl[]) {
2476 2477 2478 2479 2480 2481
			{ 0x14, 0x99130110 }, /* speaker */
			{ 0x15, 0x0221142f }, /* front HP */
			{ 0x1b, 0x0121141f }, /* rear HP */
			{ }
		}
	},
2482 2483 2484 2485 2486 2487 2488 2489 2490
	[ALC262_FIXUP_FSC_S7110] = {
		.type = HDA_FIXUP_PINS,
		.v.pins = (const struct hda_pintbl[]) {
			{ 0x15, 0x90170110 }, /* speaker */
			{ }
		},
		.chained = true,
		.chain_id = ALC262_FIXUP_BENQ,
	},
2491
	[ALC262_FIXUP_HP_Z200] = {
2492 2493
		.type = HDA_FIXUP_PINS,
		.v.pins = (const struct hda_pintbl[]) {
2494
			{ 0x16, 0x99130120 }, /* internal speaker */
2495 2496
			{ }
		}
2497
	},
2498
	[ALC262_FIXUP_TYAN] = {
2499 2500
		.type = HDA_FIXUP_PINS,
		.v.pins = (const struct hda_pintbl[]) {
2501 2502 2503 2504
			{ 0x14, 0x1993e1f0 }, /* int AUX */
			{ }
		}
	},
2505
	[ALC262_FIXUP_LENOVO_3000] = {
2506 2507 2508
		.type = HDA_FIXUP_PINCTLS,
		.v.pins = (const struct hda_pintbl[]) {
			{ 0x19, PIN_VREF50 },
2509 2510 2511 2512 2513 2514
			{}
		},
		.chained = true,
		.chain_id = ALC262_FIXUP_BENQ,
	},
	[ALC262_FIXUP_BENQ] = {
2515
		.type = HDA_FIXUP_VERBS,
2516
		.v.verbs = (const struct hda_verb[]) {
2517 2518 2519 2520 2521
			{ 0x20, AC_VERB_SET_COEF_INDEX, 0x07 },
			{ 0x20, AC_VERB_SET_PROC_COEF, 0x3070 },
			{}
		}
	},
2522
	[ALC262_FIXUP_BENQ_T31] = {
2523
		.type = HDA_FIXUP_VERBS,
2524 2525 2526 2527 2528 2529
		.v.verbs = (const struct hda_verb[]) {
			{ 0x20, AC_VERB_SET_COEF_INDEX, 0x07 },
			{ 0x20, AC_VERB_SET_PROC_COEF, 0x3050 },
			{}
		}
	},
2530
	[ALC262_FIXUP_INV_DMIC] = {
2531
		.type = HDA_FIXUP_FUNC,
2532
		.v.func = alc_fixup_inv_dmic,
2533
	},
2534 2535 2536 2537
	[ALC262_FIXUP_INTEL_BAYLEYBAY] = {
		.type = HDA_FIXUP_FUNC,
		.v.func = alc_fixup_no_depop_delay,
	},
2538 2539
};

2540
static const struct snd_pci_quirk alc262_fixup_tbl[] = {
2541
	SND_PCI_QUIRK(0x103c, 0x170b, "HP Z200", ALC262_FIXUP_HP_Z200),
2542
	SND_PCI_QUIRK(0x10cf, 0x1397, "Fujitsu Lifebook S7110", ALC262_FIXUP_FSC_S7110),
2543
	SND_PCI_QUIRK(0x10cf, 0x142d, "Fujitsu Lifebook E8410", ALC262_FIXUP_BENQ),
2544 2545
	SND_PCI_QUIRK(0x10f1, 0x2915, "Tyan Thunder n6650W", ALC262_FIXUP_TYAN),
	SND_PCI_QUIRK(0x1734, 0x1147, "FSC Celsius H270", ALC262_FIXUP_FSC_H270),
2546
	SND_PCI_QUIRK(0x17aa, 0x384e, "Lenovo 3000", ALC262_FIXUP_LENOVO_3000),
2547 2548
	SND_PCI_QUIRK(0x17ff, 0x0560, "Benq ED8", ALC262_FIXUP_BENQ),
	SND_PCI_QUIRK(0x17ff, 0x058d, "Benq T31-16", ALC262_FIXUP_BENQ_T31),
2549
	SND_PCI_QUIRK(0x8086, 0x7270, "BayleyBay", ALC262_FIXUP_INTEL_BAYLEYBAY),
2550 2551
	{}
};
2552

2553
static const struct hda_model_fixup alc262_fixup_models[] = {
2554 2555 2556
	{.id = ALC262_FIXUP_INV_DMIC, .name = "inv-dmic"},
	{}
};
2557 2558 2559 2560

/*
 */
static int patch_alc262(struct hda_codec *codec)
2561 2562 2563 2564
{
	struct alc_spec *spec;
	int err;

2565 2566 2567
	err = alc_alloc_spec(codec, 0x0b);
	if (err < 0)
		return err;
2568

2569
	spec = codec->spec;
2570
	spec->gen.shared_mic_vref_pin = 0x18;
2571

2572 2573
	spec->shutup = alc_eapd_shutup;

2574 2575 2576 2577
#if 0
	/* pshou 07/11/05  set a zero PCM sample to DAC when FIFO is
	 * under-run
	 */
2578
	alc_update_coefex_idx(codec, 0x1a, 7, 0, 0x80);
2579 2580 2581
#endif
	alc_fix_pll_init(codec, 0x20, 0x0a, 10);

2582
	snd_hda_pick_fixup(codec, alc262_fixup_models, alc262_fixup_tbl,
2583
		       alc262_fixups);
2584
	snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE);
2585

2586 2587
	alc_auto_parse_customize_define(codec);

2588 2589 2590
	if (has_cdefine_beep(codec))
		spec->gen.beep_nid = 0x01;

2591 2592 2593 2594
	/* automatic parse from the BIOS config */
	err = alc262_parse_auto_config(codec);
	if (err < 0)
		goto error;
2595

2596
	if (!spec->gen.no_analog && spec->gen.beep_nid)
2597
		set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
2598

2599
	snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE);
2600

L
Linus Torvalds 已提交
2601
	return 0;
2602 2603 2604 2605

 error:
	alc_free(codec);
	return err;
L
Linus Torvalds 已提交
2606 2607
}

2608
/*
2609
 *  ALC268
2610
 */
2611
/* bind Beep switches of both NID 0x0f and 0x10 */
2612 2613 2614 2615 2616 2617 2618 2619 2620 2621 2622 2623 2624 2625 2626 2627 2628 2629 2630
static int alc268_beep_switch_put(struct snd_kcontrol *kcontrol,
				  struct snd_ctl_elem_value *ucontrol)
{
	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
	unsigned long pval;
	int err;

	mutex_lock(&codec->control_mutex);
	pval = kcontrol->private_value;
	kcontrol->private_value = (pval & ~0xff) | 0x0f;
	err = snd_hda_mixer_amp_switch_put(kcontrol, ucontrol);
	if (err >= 0) {
		kcontrol->private_value = (pval & ~0xff) | 0x10;
		err = snd_hda_mixer_amp_switch_put(kcontrol, ucontrol);
	}
	kcontrol->private_value = pval;
	mutex_unlock(&codec->control_mutex);
	return err;
}
2631

2632 2633
static const struct snd_kcontrol_new alc268_beep_mixer[] = {
	HDA_CODEC_VOLUME("Beep Playback Volume", 0x1d, 0x0, HDA_INPUT),
2634 2635 2636 2637 2638 2639 2640 2641 2642
	{
		.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
		.name = "Beep Playback Switch",
		.subdevice = HDA_SUBDEV_AMP_FLAG,
		.info = snd_hda_mixer_amp_switch_info,
		.get = snd_hda_mixer_amp_switch_get,
		.put = alc268_beep_switch_put,
		.private_value = HDA_COMPOSE_AMP_VAL(0x0f, 3, 1, HDA_INPUT)
	},
2643
	{ }
2644 2645
};

2646 2647 2648 2649 2650 2651
/* set PCBEEP vol = 0, mute connections */
static const struct hda_verb alc268_beep_init_verbs[] = {
	{0x1d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
	{0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
	{0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
	{ }
2652 2653
};

2654 2655
enum {
	ALC268_FIXUP_INV_DMIC,
2656
	ALC268_FIXUP_HP_EAPD,
2657
	ALC268_FIXUP_SPDIF,
2658 2659
};

2660
static const struct hda_fixup alc268_fixups[] = {
2661
	[ALC268_FIXUP_INV_DMIC] = {
2662
		.type = HDA_FIXUP_FUNC,
2663
		.v.func = alc_fixup_inv_dmic,
2664
	},
2665
	[ALC268_FIXUP_HP_EAPD] = {
2666
		.type = HDA_FIXUP_VERBS,
2667 2668 2669 2670 2671
		.v.verbs = (const struct hda_verb[]) {
			{0x15, AC_VERB_SET_EAPD_BTLENABLE, 0},
			{}
		}
	},
2672 2673 2674 2675 2676 2677 2678
	[ALC268_FIXUP_SPDIF] = {
		.type = HDA_FIXUP_PINS,
		.v.pins = (const struct hda_pintbl[]) {
			{ 0x1e, 0x014b1180 }, /* enable SPDIF out */
			{}
		}
	},
2679 2680
};

2681
static const struct hda_model_fixup alc268_fixup_models[] = {
2682
	{.id = ALC268_FIXUP_INV_DMIC, .name = "inv-dmic"},
2683 2684 2685 2686 2687
	{.id = ALC268_FIXUP_HP_EAPD, .name = "hp-eapd"},
	{}
};

static const struct snd_pci_quirk alc268_fixup_tbl[] = {
2688
	SND_PCI_QUIRK(0x1025, 0x0139, "Acer TravelMate 6293", ALC268_FIXUP_SPDIF),
2689
	SND_PCI_QUIRK(0x1025, 0x015b, "Acer AOA 150 (ZG5)", ALC268_FIXUP_INV_DMIC),
2690 2691 2692 2693
	/* below is codec SSID since multiple Toshiba laptops have the
	 * same PCI SSID 1179:ff00
	 */
	SND_PCI_QUIRK(0x1179, 0xff06, "Toshiba P200", ALC268_FIXUP_HP_EAPD),
2694 2695 2696
	{}
};

2697 2698 2699
/*
 * BIOS auto configuration
 */
2700
static int alc268_parse_auto_config(struct hda_codec *codec)
2701
{
2702
	static const hda_nid_t alc268_ssids[] = { 0x15, 0x1b, 0x14, 0 };
2703
	return alc_parse_auto_config(codec, NULL, alc268_ssids);
2704 2705
}

2706 2707 2708
/*
 */
static int patch_alc268(struct hda_codec *codec)
2709 2710
{
	struct alc_spec *spec;
2711
	int err;
2712

2713
	/* ALC268 has no aa-loopback mixer */
2714 2715 2716 2717 2718
	err = alc_alloc_spec(codec, 0);
	if (err < 0)
		return err;

	spec = codec->spec;
2719
	spec->gen.beep_nid = 0x01;
2720

2721 2722
	spec->shutup = alc_eapd_shutup;

2723 2724
	snd_hda_pick_fixup(codec, alc268_fixup_models, alc268_fixup_tbl, alc268_fixups);
	snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE);
2725

2726 2727
	/* automatic parse from the BIOS config */
	err = alc268_parse_auto_config(codec);
2728 2729
	if (err < 0)
		goto error;
2730

2731 2732 2733 2734
	if (err > 0 && !spec->gen.no_analog &&
	    spec->gen.autocfg.speaker_pins[0] != 0x1d) {
		add_mixer(spec, alc268_beep_mixer);
		snd_hda_add_verbs(codec, alc268_beep_init_verbs);
2735 2736 2737 2738 2739 2740 2741
		if (!query_amp_caps(codec, 0x1d, HDA_INPUT))
			/* override the amp caps for beep generator */
			snd_hda_override_amp_caps(codec, 0x1d, HDA_INPUT,
					  (0x0c << AC_AMPCAP_OFFSET_SHIFT) |
					  (0x0c << AC_AMPCAP_NUM_STEPS_SHIFT) |
					  (0x07 << AC_AMPCAP_STEP_SIZE_SHIFT) |
					  (0 << AC_AMPCAP_MUTE_SHIFT));
2742 2743
	}

2744
	snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE);
2745

2746
	return 0;
2747 2748 2749 2750

 error:
	alc_free(codec);
	return err;
2751 2752
}

2753
/*
2754
 * ALC269
2755
 */
2756

2757 2758
static const struct hda_pcm_stream alc269_44k_pcm_analog_playback = {
	.rates = SNDRV_PCM_RATE_44100, /* fixed rate */
2759 2760
};

2761 2762
static const struct hda_pcm_stream alc269_44k_pcm_analog_capture = {
	.rates = SNDRV_PCM_RATE_44100, /* fixed rate */
2763
};
2764

2765 2766 2767 2768 2769
/* different alc269-variants */
enum {
	ALC269_TYPE_ALC269VA,
	ALC269_TYPE_ALC269VB,
	ALC269_TYPE_ALC269VC,
2770
	ALC269_TYPE_ALC269VD,
2771 2772
	ALC269_TYPE_ALC280,
	ALC269_TYPE_ALC282,
2773
	ALC269_TYPE_ALC283,
2774
	ALC269_TYPE_ALC284,
2775
	ALC269_TYPE_ALC293,
2776
	ALC269_TYPE_ALC286,
2777
	ALC269_TYPE_ALC298,
2778
	ALC269_TYPE_ALC255,
2779
	ALC269_TYPE_ALC256,
2780
	ALC269_TYPE_ALC257,
2781
	ALC269_TYPE_ALC215,
2782
	ALC269_TYPE_ALC225,
2783
	ALC269_TYPE_ALC294,
2784
	ALC269_TYPE_ALC700,
2785 2786 2787
};

/*
2788
 * BIOS auto configuration
2789
 */
2790 2791 2792
static int alc269_parse_auto_config(struct hda_codec *codec)
{
	static const hda_nid_t alc269_ignore[] = { 0x1d, 0 };
2793 2794 2795
	static const hda_nid_t alc269_ssids[] = { 0, 0x1b, 0x14, 0x21 };
	static const hda_nid_t alc269va_ssids[] = { 0x15, 0x1b, 0x14, 0 };
	struct alc_spec *spec = codec->spec;
2796 2797 2798 2799 2800
	const hda_nid_t *ssids;

	switch (spec->codec_variant) {
	case ALC269_TYPE_ALC269VA:
	case ALC269_TYPE_ALC269VC:
2801 2802
	case ALC269_TYPE_ALC280:
	case ALC269_TYPE_ALC284:
2803
	case ALC269_TYPE_ALC293:
2804 2805 2806 2807
		ssids = alc269va_ssids;
		break;
	case ALC269_TYPE_ALC269VB:
	case ALC269_TYPE_ALC269VD:
2808
	case ALC269_TYPE_ALC282:
2809
	case ALC269_TYPE_ALC283:
2810
	case ALC269_TYPE_ALC286:
2811
	case ALC269_TYPE_ALC298:
2812
	case ALC269_TYPE_ALC255:
2813
	case ALC269_TYPE_ALC256:
2814
	case ALC269_TYPE_ALC257:
2815
	case ALC269_TYPE_ALC215:
2816
	case ALC269_TYPE_ALC225:
2817
	case ALC269_TYPE_ALC294:
2818
	case ALC269_TYPE_ALC700:
2819 2820 2821 2822 2823 2824
		ssids = alc269_ssids;
		break;
	default:
		ssids = alc269_ssids;
		break;
	}
2825

2826
	return alc_parse_auto_config(codec, alc269_ignore, ssids);
2827
}
2828

2829 2830 2831 2832
static int find_ext_mic_pin(struct hda_codec *codec);

static void alc286_shutup(struct hda_codec *codec)
{
2833
	const struct hda_pincfg *pin;
2834 2835 2836 2837 2838 2839 2840
	int i;
	int mic_pin = find_ext_mic_pin(codec);
	/* don't shut up pins when unloading the driver; otherwise it breaks
	 * the default pin setup at the next load of the driver
	 */
	if (codec->bus->shutdown)
		return;
2841
	snd_array_for_each(&codec->init_pins, i, pin) {
2842 2843 2844 2845 2846 2847 2848 2849
		/* use read here for syncing after issuing each verb */
		if (pin->nid != mic_pin)
			snd_hda_codec_read(codec, pin->nid, 0,
					AC_VERB_SET_PIN_WIDGET_CONTROL, 0);
	}
	codec->pins_shutup = 1;
}

2850
static void alc269vb_toggle_power_output(struct hda_codec *codec, int power_up)
2851
{
2852
	alc_update_coef_idx(codec, 0x04, 1 << 11, power_up ? (1 << 11) : 0);
2853
}
2854

2855 2856
static void alc269_shutup(struct hda_codec *codec)
{
2857 2858
	struct alc_spec *spec = codec->spec;

2859 2860 2861 2862
	if (spec->codec_variant == ALC269_TYPE_ALC269VB)
		alc269vb_toggle_power_output(codec, 0);
	if (spec->codec_variant == ALC269_TYPE_ALC269VB &&
			(alc_get_coef0(codec) & 0x00ff) == 0x018) {
2863 2864
		msleep(150);
	}
2865
	snd_hda_shutup_pins(codec);
2866
}
2867

2868 2869
static struct coef_fw alc282_coefs[] = {
	WRITE_COEF(0x03, 0x0002), /* Power Down Control */
2870
	UPDATE_COEF(0x05, 0xff3f, 0x0700), /* FIFO and filter clock */
2871 2872 2873 2874 2875 2876 2877 2878 2879 2880 2881 2882 2883 2884 2885 2886 2887 2888 2889 2890 2891 2892 2893 2894 2895 2896 2897 2898 2899 2900
	WRITE_COEF(0x07, 0x0200), /* DMIC control */
	UPDATE_COEF(0x06, 0x00f0, 0), /* Analog clock */
	UPDATE_COEF(0x08, 0xfffc, 0x0c2c), /* JD */
	WRITE_COEF(0x0a, 0xcccc), /* JD offset1 */
	WRITE_COEF(0x0b, 0xcccc), /* JD offset2 */
	WRITE_COEF(0x0e, 0x6e00), /* LDO1/2/3, DAC/ADC */
	UPDATE_COEF(0x0f, 0xf800, 0x1000), /* JD */
	UPDATE_COEF(0x10, 0xfc00, 0x0c00), /* Capless */
	WRITE_COEF(0x6f, 0x0), /* Class D test 4 */
	UPDATE_COEF(0x0c, 0xfe00, 0), /* IO power down directly */
	WRITE_COEF(0x34, 0xa0c0), /* ANC */
	UPDATE_COEF(0x16, 0x0008, 0), /* AGC MUX */
	UPDATE_COEF(0x1d, 0x00e0, 0), /* DAC simple content protection */
	UPDATE_COEF(0x1f, 0x00e0, 0), /* ADC simple content protection */
	WRITE_COEF(0x21, 0x8804), /* DAC ADC Zero Detection */
	WRITE_COEF(0x63, 0x2902), /* PLL */
	WRITE_COEF(0x68, 0xa080), /* capless control 2 */
	WRITE_COEF(0x69, 0x3400), /* capless control 3 */
	WRITE_COEF(0x6a, 0x2f3e), /* capless control 4 */
	WRITE_COEF(0x6b, 0x0), /* capless control 5 */
	UPDATE_COEF(0x6d, 0x0fff, 0x0900), /* class D test 2 */
	WRITE_COEF(0x6e, 0x110a), /* class D test 3 */
	UPDATE_COEF(0x70, 0x00f8, 0x00d8), /* class D test 5 */
	WRITE_COEF(0x71, 0x0014), /* class D test 6 */
	WRITE_COEF(0x72, 0xc2ba), /* classD OCP */
	UPDATE_COEF(0x77, 0x0f80, 0), /* classD pure DC test */
	WRITE_COEF(0x6c, 0xfc06), /* Class D amp control */
	{}
};

2901 2902
static void alc282_restore_default_value(struct hda_codec *codec)
{
2903
	alc_process_coef_fw(codec, alc282_coefs);
2904 2905
}

2906 2907 2908 2909 2910 2911 2912
static void alc282_init(struct hda_codec *codec)
{
	struct alc_spec *spec = codec->spec;
	hda_nid_t hp_pin = spec->gen.autocfg.hp_pins[0];
	bool hp_pin_sense;
	int coef78;

2913 2914
	alc282_restore_default_value(codec);

2915 2916 2917 2918 2919 2920 2921 2922 2923 2924 2925 2926 2927 2928 2929 2930 2931 2932 2933 2934 2935 2936 2937 2938 2939 2940 2941 2942 2943 2944 2945 2946 2947 2948 2949 2950 2951 2952 2953 2954 2955 2956 2957 2958 2959 2960 2961 2962 2963 2964 2965 2966 2967 2968 2969 2970 2971 2972 2973 2974 2975 2976 2977 2978
	if (!hp_pin)
		return;
	hp_pin_sense = snd_hda_jack_detect(codec, hp_pin);
	coef78 = alc_read_coef_idx(codec, 0x78);

	/* Index 0x78 Direct Drive HP AMP LPM Control 1 */
	/* Headphone capless set to high power mode */
	alc_write_coef_idx(codec, 0x78, 0x9004);

	if (hp_pin_sense)
		msleep(2);

	snd_hda_codec_write(codec, hp_pin, 0,
			    AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);

	if (hp_pin_sense)
		msleep(85);

	snd_hda_codec_write(codec, hp_pin, 0,
			    AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT);

	if (hp_pin_sense)
		msleep(100);

	/* Headphone capless set to normal mode */
	alc_write_coef_idx(codec, 0x78, coef78);
}

static void alc282_shutup(struct hda_codec *codec)
{
	struct alc_spec *spec = codec->spec;
	hda_nid_t hp_pin = spec->gen.autocfg.hp_pins[0];
	bool hp_pin_sense;
	int coef78;

	if (!hp_pin) {
		alc269_shutup(codec);
		return;
	}

	hp_pin_sense = snd_hda_jack_detect(codec, hp_pin);
	coef78 = alc_read_coef_idx(codec, 0x78);
	alc_write_coef_idx(codec, 0x78, 0x9004);

	if (hp_pin_sense)
		msleep(2);

	snd_hda_codec_write(codec, hp_pin, 0,
			    AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);

	if (hp_pin_sense)
		msleep(85);

	snd_hda_codec_write(codec, hp_pin, 0,
			    AC_VERB_SET_PIN_WIDGET_CONTROL, 0x0);

	if (hp_pin_sense)
		msleep(100);

	alc_auto_setup_eapd(codec, false);
	snd_hda_shutup_pins(codec);
	alc_write_coef_idx(codec, 0x78, coef78);
}

2979 2980
static struct coef_fw alc283_coefs[] = {
	WRITE_COEF(0x03, 0x0002), /* Power Down Control */
2981
	UPDATE_COEF(0x05, 0xff3f, 0x0700), /* FIFO and filter clock */
2982 2983 2984 2985 2986 2987 2988 2989 2990 2991 2992 2993 2994 2995 2996 2997 2998 2999 3000 3001 3002 3003 3004 3005 3006 3007 3008 3009 3010 3011
	WRITE_COEF(0x07, 0x0200), /* DMIC control */
	UPDATE_COEF(0x06, 0x00f0, 0), /* Analog clock */
	UPDATE_COEF(0x08, 0xfffc, 0x0c2c), /* JD */
	WRITE_COEF(0x0a, 0xcccc), /* JD offset1 */
	WRITE_COEF(0x0b, 0xcccc), /* JD offset2 */
	WRITE_COEF(0x0e, 0x6fc0), /* LDO1/2/3, DAC/ADC */
	UPDATE_COEF(0x0f, 0xf800, 0x1000), /* JD */
	UPDATE_COEF(0x10, 0xfc00, 0x0c00), /* Capless */
	WRITE_COEF(0x3a, 0x0), /* Class D test 4 */
	UPDATE_COEF(0x0c, 0xfe00, 0x0), /* IO power down directly */
	WRITE_COEF(0x22, 0xa0c0), /* ANC */
	UPDATE_COEFEX(0x53, 0x01, 0x000f, 0x0008), /* AGC MUX */
	UPDATE_COEF(0x1d, 0x00e0, 0), /* DAC simple content protection */
	UPDATE_COEF(0x1f, 0x00e0, 0), /* ADC simple content protection */
	WRITE_COEF(0x21, 0x8804), /* DAC ADC Zero Detection */
	WRITE_COEF(0x2e, 0x2902), /* PLL */
	WRITE_COEF(0x33, 0xa080), /* capless control 2 */
	WRITE_COEF(0x34, 0x3400), /* capless control 3 */
	WRITE_COEF(0x35, 0x2f3e), /* capless control 4 */
	WRITE_COEF(0x36, 0x0), /* capless control 5 */
	UPDATE_COEF(0x38, 0x0fff, 0x0900), /* class D test 2 */
	WRITE_COEF(0x39, 0x110a), /* class D test 3 */
	UPDATE_COEF(0x3b, 0x00f8, 0x00d8), /* class D test 5 */
	WRITE_COEF(0x3c, 0x0014), /* class D test 6 */
	WRITE_COEF(0x3d, 0xc2ba), /* classD OCP */
	UPDATE_COEF(0x42, 0x0f80, 0x0), /* classD pure DC test */
	WRITE_COEF(0x49, 0x0), /* test mode */
	UPDATE_COEF(0x40, 0xf800, 0x9800), /* Class D DC enable */
	UPDATE_COEF(0x42, 0xf000, 0x2000), /* DC offset */
	WRITE_COEF(0x37, 0xfc06), /* Class D amp control */
3012
	UPDATE_COEF(0x1b, 0x8000, 0), /* HP JD control */
3013 3014 3015
	{}
};

3016 3017
static void alc283_restore_default_value(struct hda_codec *codec)
{
3018
	alc_process_coef_fw(codec, alc283_coefs);
3019 3020
}

3021 3022 3023 3024 3025 3026
static void alc283_init(struct hda_codec *codec)
{
	struct alc_spec *spec = codec->spec;
	hda_nid_t hp_pin = spec->gen.autocfg.hp_pins[0];
	bool hp_pin_sense;

3027 3028 3029 3030 3031
	if (!spec->gen.autocfg.hp_outs) {
		if (spec->gen.autocfg.line_out_type == AC_JACK_HP_OUT)
			hp_pin = spec->gen.autocfg.line_out_pins[0];
	}

3032 3033
	alc283_restore_default_value(codec);

3034 3035
	if (!hp_pin)
		return;
3036 3037

	msleep(30);
3038 3039 3040 3041 3042 3043 3044 3045 3046 3047 3048 3049 3050 3051 3052 3053 3054 3055 3056
	hp_pin_sense = snd_hda_jack_detect(codec, hp_pin);

	/* Index 0x43 Direct Drive HP AMP LPM Control 1 */
	/* Headphone capless set to high power mode */
	alc_write_coef_idx(codec, 0x43, 0x9004);

	snd_hda_codec_write(codec, hp_pin, 0,
			    AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);

	if (hp_pin_sense)
		msleep(85);

	snd_hda_codec_write(codec, hp_pin, 0,
			    AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT);

	if (hp_pin_sense)
		msleep(85);
	/* Index 0x46 Combo jack auto switch control 2 */
	/* 3k pull low control for Headset jack. */
3057
	alc_update_coef_idx(codec, 0x46, 3 << 12, 0);
3058 3059 3060 3061 3062 3063 3064 3065 3066 3067
	/* Headphone capless set to normal mode */
	alc_write_coef_idx(codec, 0x43, 0x9614);
}

static void alc283_shutup(struct hda_codec *codec)
{
	struct alc_spec *spec = codec->spec;
	hda_nid_t hp_pin = spec->gen.autocfg.hp_pins[0];
	bool hp_pin_sense;

3068 3069 3070 3071 3072
	if (!spec->gen.autocfg.hp_outs) {
		if (spec->gen.autocfg.line_out_type == AC_JACK_HP_OUT)
			hp_pin = spec->gen.autocfg.line_out_pins[0];
	}

3073 3074 3075 3076 3077 3078 3079 3080 3081
	if (!hp_pin) {
		alc269_shutup(codec);
		return;
	}

	hp_pin_sense = snd_hda_jack_detect(codec, hp_pin);

	alc_write_coef_idx(codec, 0x43, 0x9004);

3082 3083 3084
	/*depop hp during suspend*/
	alc_write_coef_idx(codec, 0x06, 0x2100);

3085 3086 3087 3088
	snd_hda_codec_write(codec, hp_pin, 0,
			    AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);

	if (hp_pin_sense)
3089
		msleep(100);
3090 3091 3092 3093

	snd_hda_codec_write(codec, hp_pin, 0,
			    AC_VERB_SET_PIN_WIDGET_CONTROL, 0x0);

3094
	alc_update_coef_idx(codec, 0x46, 0, 3 << 12);
3095 3096

	if (hp_pin_sense)
3097
		msleep(100);
3098
	alc_auto_setup_eapd(codec, false);
3099 3100 3101 3102
	snd_hda_shutup_pins(codec);
	alc_write_coef_idx(codec, 0x43, 0x9614);
}

3103 3104 3105 3106 3107 3108 3109 3110 3111 3112 3113 3114 3115 3116 3117 3118 3119 3120 3121 3122 3123 3124 3125 3126 3127 3128 3129 3130 3131 3132 3133 3134
static void alc256_init(struct hda_codec *codec)
{
	struct alc_spec *spec = codec->spec;
	hda_nid_t hp_pin = spec->gen.autocfg.hp_pins[0];
	bool hp_pin_sense;

	if (!hp_pin)
		return;

	msleep(30);

	hp_pin_sense = snd_hda_jack_detect(codec, hp_pin);

	if (hp_pin_sense)
		msleep(2);

	alc_update_coefex_idx(codec, 0x57, 0x04, 0x0007, 0x1); /* Low power */

	snd_hda_codec_write(codec, hp_pin, 0,
			    AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);

	if (hp_pin_sense)
		msleep(85);

	snd_hda_codec_write(codec, hp_pin, 0,
			    AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT);

	if (hp_pin_sense)
		msleep(100);

	alc_update_coef_idx(codec, 0x46, 3 << 12, 0);
	alc_update_coefex_idx(codec, 0x57, 0x04, 0x0007, 0x4); /* Hight power */
3135 3136
	alc_update_coefex_idx(codec, 0x53, 0x02, 0x8000, 1 << 15); /* Clear bit */
	alc_update_coefex_idx(codec, 0x53, 0x02, 0x8000, 0 << 15);
3137 3138 3139 3140 3141 3142 3143 3144 3145 3146 3147 3148 3149 3150 3151 3152 3153 3154 3155 3156 3157 3158 3159 3160
}

static void alc256_shutup(struct hda_codec *codec)
{
	struct alc_spec *spec = codec->spec;
	hda_nid_t hp_pin = spec->gen.autocfg.hp_pins[0];
	bool hp_pin_sense;

	if (!hp_pin) {
		alc269_shutup(codec);
		return;
	}

	hp_pin_sense = snd_hda_jack_detect(codec, hp_pin);

	if (hp_pin_sense)
		msleep(2);

	snd_hda_codec_write(codec, hp_pin, 0,
			    AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);

	if (hp_pin_sense)
		msleep(85);

3161 3162 3163 3164
	/* 3k pull low control for Headset jack. */
	/* NOTE: call this before clearing the pin, otherwise codec stalls */
	alc_update_coef_idx(codec, 0x46, 0, 3 << 12);

3165 3166 3167 3168 3169 3170 3171 3172 3173 3174
	snd_hda_codec_write(codec, hp_pin, 0,
			    AC_VERB_SET_PIN_WIDGET_CONTROL, 0x0);

	if (hp_pin_sense)
		msleep(100);

	alc_auto_setup_eapd(codec, false);
	snd_hda_shutup_pins(codec);
}

3175 3176 3177 3178 3179 3180 3181 3182 3183 3184 3185 3186 3187 3188 3189 3190 3191 3192 3193 3194 3195 3196 3197 3198 3199 3200 3201 3202 3203 3204 3205 3206 3207 3208 3209 3210 3211 3212 3213 3214 3215 3216 3217 3218 3219 3220 3221 3222 3223 3224 3225 3226 3227 3228 3229 3230 3231 3232 3233 3234 3235 3236 3237 3238 3239 3240 3241 3242 3243 3244 3245 3246 3247 3248 3249 3250 3251 3252 3253 3254 3255 3256 3257 3258 3259 3260 3261
static void alc225_init(struct hda_codec *codec)
{
	struct alc_spec *spec = codec->spec;
	hda_nid_t hp_pin = spec->gen.autocfg.hp_pins[0];
	bool hp1_pin_sense, hp2_pin_sense;

	if (!hp_pin)
		return;

	msleep(30);

	hp1_pin_sense = snd_hda_jack_detect(codec, hp_pin);
	hp2_pin_sense = snd_hda_jack_detect(codec, 0x16);

	if (hp1_pin_sense || hp2_pin_sense)
		msleep(2);

	alc_update_coefex_idx(codec, 0x57, 0x04, 0x0007, 0x1); /* Low power */

	if (hp1_pin_sense)
		snd_hda_codec_write(codec, hp_pin, 0,
			    AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);
	if (hp2_pin_sense)
		snd_hda_codec_write(codec, 0x16, 0,
			    AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);

	if (hp1_pin_sense || hp2_pin_sense)
		msleep(85);

	if (hp1_pin_sense)
		snd_hda_codec_write(codec, hp_pin, 0,
			    AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT);
	if (hp2_pin_sense)
		snd_hda_codec_write(codec, 0x16, 0,
			    AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT);

	if (hp1_pin_sense || hp2_pin_sense)
		msleep(100);

	alc_update_coef_idx(codec, 0x4a, 3 << 10, 0);
	alc_update_coefex_idx(codec, 0x57, 0x04, 0x0007, 0x4); /* Hight power */
}

static void alc225_shutup(struct hda_codec *codec)
{
	struct alc_spec *spec = codec->spec;
	hda_nid_t hp_pin = spec->gen.autocfg.hp_pins[0];
	bool hp1_pin_sense, hp2_pin_sense;

	if (!hp_pin) {
		alc269_shutup(codec);
		return;
	}

	/* 3k pull low control for Headset jack. */
	alc_update_coef_idx(codec, 0x4a, 0, 3 << 10);

	hp1_pin_sense = snd_hda_jack_detect(codec, hp_pin);
	hp2_pin_sense = snd_hda_jack_detect(codec, 0x16);

	if (hp1_pin_sense || hp2_pin_sense)
		msleep(2);

	if (hp1_pin_sense)
		snd_hda_codec_write(codec, hp_pin, 0,
			    AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);
	if (hp2_pin_sense)
		snd_hda_codec_write(codec, 0x16, 0,
			    AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);

	if (hp1_pin_sense || hp2_pin_sense)
		msleep(85);

	if (hp1_pin_sense)
		snd_hda_codec_write(codec, hp_pin, 0,
			    AC_VERB_SET_PIN_WIDGET_CONTROL, 0x0);
	if (hp2_pin_sense)
		snd_hda_codec_write(codec, 0x16, 0,
			    AC_VERB_SET_PIN_WIDGET_CONTROL, 0x0);

	if (hp1_pin_sense || hp2_pin_sense)
		msleep(100);

	alc_auto_setup_eapd(codec, false);
	snd_hda_shutup_pins(codec);
}

3262 3263 3264 3265 3266 3267 3268 3269 3270 3271 3272 3273 3274 3275 3276 3277 3278 3279 3280 3281 3282 3283 3284 3285 3286 3287 3288 3289 3290 3291 3292 3293 3294 3295 3296 3297 3298 3299 3300 3301 3302 3303 3304 3305 3306 3307 3308 3309 3310 3311 3312 3313 3314 3315 3316 3317 3318 3319 3320 3321 3322
static void alc_default_init(struct hda_codec *codec)
{
	struct alc_spec *spec = codec->spec;
	hda_nid_t hp_pin = spec->gen.autocfg.hp_pins[0];
	bool hp_pin_sense;

	if (!hp_pin)
		return;

	msleep(30);

	hp_pin_sense = snd_hda_jack_detect(codec, hp_pin);

	if (hp_pin_sense)
		msleep(2);

	snd_hda_codec_write(codec, hp_pin, 0,
			    AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);

	if (hp_pin_sense)
		msleep(85);

	snd_hda_codec_write(codec, hp_pin, 0,
			    AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT);

	if (hp_pin_sense)
		msleep(100);
}

static void alc_default_shutup(struct hda_codec *codec)
{
	struct alc_spec *spec = codec->spec;
	hda_nid_t hp_pin = spec->gen.autocfg.hp_pins[0];
	bool hp_pin_sense;

	if (!hp_pin) {
		alc269_shutup(codec);
		return;
	}

	hp_pin_sense = snd_hda_jack_detect(codec, hp_pin);

	if (hp_pin_sense)
		msleep(2);

	snd_hda_codec_write(codec, hp_pin, 0,
			    AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);

	if (hp_pin_sense)
		msleep(85);

	snd_hda_codec_write(codec, hp_pin, 0,
			    AC_VERB_SET_PIN_WIDGET_CONTROL, 0x0);

	if (hp_pin_sense)
		msleep(100);

	alc_auto_setup_eapd(codec, false);
	snd_hda_shutup_pins(codec);
}

3323 3324 3325 3326 3327 3328 3329 3330 3331 3332 3333 3334 3335 3336 3337 3338 3339 3340 3341 3342 3343 3344 3345 3346 3347 3348 3349 3350 3351 3352 3353 3354 3355 3356 3357 3358 3359 3360 3361 3362 3363 3364 3365 3366 3367 3368 3369 3370 3371 3372 3373 3374 3375 3376 3377 3378 3379 3380 3381 3382 3383 3384 3385 3386 3387 3388 3389 3390 3391 3392 3393 3394 3395 3396 3397 3398 3399 3400
static void alc5505_coef_set(struct hda_codec *codec, unsigned int index_reg,
			     unsigned int val)
{
	snd_hda_codec_write(codec, 0x51, 0, AC_VERB_SET_COEF_INDEX, index_reg >> 1);
	snd_hda_codec_write(codec, 0x51, 0, AC_VERB_SET_PROC_COEF, val & 0xffff); /* LSB */
	snd_hda_codec_write(codec, 0x51, 0, AC_VERB_SET_PROC_COEF, val >> 16); /* MSB */
}

static int alc5505_coef_get(struct hda_codec *codec, unsigned int index_reg)
{
	unsigned int val;

	snd_hda_codec_write(codec, 0x51, 0, AC_VERB_SET_COEF_INDEX, index_reg >> 1);
	val = snd_hda_codec_read(codec, 0x51, 0, AC_VERB_GET_PROC_COEF, 0)
		& 0xffff;
	val |= snd_hda_codec_read(codec, 0x51, 0, AC_VERB_GET_PROC_COEF, 0)
		<< 16;
	return val;
}

static void alc5505_dsp_halt(struct hda_codec *codec)
{
	unsigned int val;

	alc5505_coef_set(codec, 0x3000, 0x000c); /* DSP CPU stop */
	alc5505_coef_set(codec, 0x880c, 0x0008); /* DDR enter self refresh */
	alc5505_coef_set(codec, 0x61c0, 0x11110080); /* Clock control for PLL and CPU */
	alc5505_coef_set(codec, 0x6230, 0xfc0d4011); /* Disable Input OP */
	alc5505_coef_set(codec, 0x61b4, 0x040a2b03); /* Stop PLL2 */
	alc5505_coef_set(codec, 0x61b0, 0x00005b17); /* Stop PLL1 */
	alc5505_coef_set(codec, 0x61b8, 0x04133303); /* Stop PLL3 */
	val = alc5505_coef_get(codec, 0x6220);
	alc5505_coef_set(codec, 0x6220, (val | 0x3000)); /* switch Ringbuffer clock to DBUS clock */
}

static void alc5505_dsp_back_from_halt(struct hda_codec *codec)
{
	alc5505_coef_set(codec, 0x61b8, 0x04133302);
	alc5505_coef_set(codec, 0x61b0, 0x00005b16);
	alc5505_coef_set(codec, 0x61b4, 0x040a2b02);
	alc5505_coef_set(codec, 0x6230, 0xf80d4011);
	alc5505_coef_set(codec, 0x6220, 0x2002010f);
	alc5505_coef_set(codec, 0x880c, 0x00000004);
}

static void alc5505_dsp_init(struct hda_codec *codec)
{
	unsigned int val;

	alc5505_dsp_halt(codec);
	alc5505_dsp_back_from_halt(codec);
	alc5505_coef_set(codec, 0x61b0, 0x5b14); /* PLL1 control */
	alc5505_coef_set(codec, 0x61b0, 0x5b16);
	alc5505_coef_set(codec, 0x61b4, 0x04132b00); /* PLL2 control */
	alc5505_coef_set(codec, 0x61b4, 0x04132b02);
	alc5505_coef_set(codec, 0x61b8, 0x041f3300); /* PLL3 control*/
	alc5505_coef_set(codec, 0x61b8, 0x041f3302);
	snd_hda_codec_write(codec, 0x51, 0, AC_VERB_SET_CODEC_RESET, 0); /* Function reset */
	alc5505_coef_set(codec, 0x61b8, 0x041b3302);
	alc5505_coef_set(codec, 0x61b8, 0x04173302);
	alc5505_coef_set(codec, 0x61b8, 0x04163302);
	alc5505_coef_set(codec, 0x8800, 0x348b328b); /* DRAM control */
	alc5505_coef_set(codec, 0x8808, 0x00020022); /* DRAM control */
	alc5505_coef_set(codec, 0x8818, 0x00000400); /* DRAM control */

	val = alc5505_coef_get(codec, 0x6200) >> 16; /* Read revision ID */
	if (val <= 3)
		alc5505_coef_set(codec, 0x6220, 0x2002010f); /* I/O PAD Configuration */
	else
		alc5505_coef_set(codec, 0x6220, 0x6002018f);

	alc5505_coef_set(codec, 0x61ac, 0x055525f0); /**/
	alc5505_coef_set(codec, 0x61c0, 0x12230080); /* Clock control */
	alc5505_coef_set(codec, 0x61b4, 0x040e2b02); /* PLL2 control */
	alc5505_coef_set(codec, 0x61bc, 0x010234f8); /* OSC Control */
	alc5505_coef_set(codec, 0x880c, 0x00000004); /* DRAM Function control */
	alc5505_coef_set(codec, 0x880c, 0x00000003);
	alc5505_coef_set(codec, 0x880c, 0x00000010);
3401 3402 3403 3404

#ifdef HALT_REALTEK_ALC5505
	alc5505_dsp_halt(codec);
#endif
3405 3406
}

3407 3408 3409 3410 3411 3412 3413 3414
#ifdef HALT_REALTEK_ALC5505
#define alc5505_dsp_suspend(codec)	/* NOP */
#define alc5505_dsp_resume(codec)	/* NOP */
#else
#define alc5505_dsp_suspend(codec)	alc5505_dsp_halt(codec)
#define alc5505_dsp_resume(codec)	alc5505_dsp_back_from_halt(codec)
#endif

3415
#ifdef CONFIG_PM
3416 3417 3418 3419 3420
static int alc269_suspend(struct hda_codec *codec)
{
	struct alc_spec *spec = codec->spec;

	if (spec->has_alc5505_dsp)
3421
		alc5505_dsp_suspend(codec);
3422 3423 3424
	return alc_suspend(codec);
}

3425 3426
static int alc269_resume(struct hda_codec *codec)
{
3427 3428
	struct alc_spec *spec = codec->spec;

3429 3430 3431
	if (spec->codec_variant == ALC269_TYPE_ALC269VB)
		alc269vb_toggle_power_output(codec, 0);
	if (spec->codec_variant == ALC269_TYPE_ALC269VB &&
3432
			(alc_get_coef0(codec) & 0x00ff) == 0x018) {
3433 3434
		msleep(150);
	}
3435

3436
	codec->patch_ops.init(codec);
3437

3438 3439 3440
	if (spec->codec_variant == ALC269_TYPE_ALC269VB)
		alc269vb_toggle_power_output(codec, 1);
	if (spec->codec_variant == ALC269_TYPE_ALC269VB &&
3441
			(alc_get_coef0(codec) & 0x00ff) == 0x017) {
3442 3443
		msleep(200);
	}
3444

3445
	regcache_sync(codec->core.regmap);
3446
	hda_call_check_power_status(codec, 0x01);
3447 3448 3449 3450 3451 3452

	/* on some machine, the BIOS will clear the codec gpio data when enter
	 * suspend, and won't restore the data after resume, so we restore it
	 * in the driver.
	 */
	if (spec->gpio_led)
3453
		snd_hda_codec_write(codec, codec->core.afg, 0, AC_VERB_SET_GPIO_DATA,
3454 3455
			    spec->gpio_led);

3456
	if (spec->has_alc5505_dsp)
3457
		alc5505_dsp_resume(codec);
3458

3459 3460
	return 0;
}
3461
#endif /* CONFIG_PM */
3462

3463
static void alc269_fixup_pincfg_no_hp_to_lineout(struct hda_codec *codec,
3464
						 const struct hda_fixup *fix, int action)
3465 3466 3467
{
	struct alc_spec *spec = codec->spec;

3468
	if (action == HDA_FIXUP_ACT_PRE_PROBE)
3469 3470 3471
		spec->parse_flags = HDA_PINCFG_NO_HP_FIXUP;
}

3472 3473 3474 3475 3476 3477 3478 3479 3480 3481 3482 3483 3484
static void alc269_fixup_pincfg_U7x7_headset_mic(struct hda_codec *codec,
						 const struct hda_fixup *fix,
						 int action)
{
	unsigned int cfg_headphone = snd_hda_codec_get_pincfg(codec, 0x21);
	unsigned int cfg_headset_mic = snd_hda_codec_get_pincfg(codec, 0x19);

	if (cfg_headphone && cfg_headset_mic == 0x411111f0)
		snd_hda_codec_set_pincfg(codec, 0x19,
			(cfg_headphone & ~AC_DEFCFG_DEVICE) |
			(AC_JACK_MIC_IN << AC_DEFCFG_DEVICE_SHIFT));
}

3485
static void alc269_fixup_hweq(struct hda_codec *codec,
3486
			       const struct hda_fixup *fix, int action)
3487
{
3488 3489
	if (action == HDA_FIXUP_ACT_INIT)
		alc_update_coef_idx(codec, 0x1e, 0, 0x80);
3490
}
3491

3492 3493 3494 3495 3496 3497 3498 3499 3500
static void alc269_fixup_headset_mic(struct hda_codec *codec,
				       const struct hda_fixup *fix, int action)
{
	struct alc_spec *spec = codec->spec;

	if (action == HDA_FIXUP_ACT_PRE_PROBE)
		spec->parse_flags |= HDA_PINCFG_HEADSET_MIC;
}

3501
static void alc271_fixup_dmic(struct hda_codec *codec,
3502
			      const struct hda_fixup *fix, int action)
3503 3504 3505 3506 3507 3508 3509
{
	static const struct hda_verb verbs[] = {
		{0x20, AC_VERB_SET_COEF_INDEX, 0x0d},
		{0x20, AC_VERB_SET_PROC_COEF, 0x4000},
		{}
	};
	unsigned int cfg;
3510

3511 3512
	if (strcmp(codec->core.chip_name, "ALC271X") &&
	    strcmp(codec->core.chip_name, "ALC269VB"))
3513 3514 3515 3516 3517
		return;
	cfg = snd_hda_codec_get_pincfg(codec, 0x12);
	if (get_defcfg_connect(cfg) == AC_JACK_PORT_FIXED)
		snd_hda_sequence_write(codec, verbs);
}
3518

3519
static void alc269_fixup_pcm_44k(struct hda_codec *codec,
3520
				 const struct hda_fixup *fix, int action)
3521 3522 3523
{
	struct alc_spec *spec = codec->spec;

3524
	if (action != HDA_FIXUP_ACT_PROBE)
3525 3526 3527 3528 3529
		return;

	/* Due to a hardware problem on Lenovo Ideadpad, we need to
	 * fix the sample rate of analog I/O to 44.1kHz
	 */
3530 3531
	spec->gen.stream_analog_playback = &alc269_44k_pcm_analog_playback;
	spec->gen.stream_analog_capture = &alc269_44k_pcm_analog_capture;
3532 3533
}

3534
static void alc269_fixup_stereo_dmic(struct hda_codec *codec,
3535
				     const struct hda_fixup *fix, int action)
3536 3537 3538 3539 3540 3541
{
	/* The digital-mic unit sends PDM (differential signal) instead of
	 * the standard PCM, thus you can't record a valid mono stream as is.
	 * Below is a workaround specific to ALC269 to control the dmic
	 * signal source as mono.
	 */
3542 3543
	if (action == HDA_FIXUP_ACT_INIT)
		alc_update_coef_idx(codec, 0x07, 0, 0x80);
3544 3545
}

3546 3547
static void alc269_quanta_automute(struct hda_codec *codec)
{
3548
	snd_hda_gen_update_outputs(codec);
3549

3550 3551
	alc_write_coef_idx(codec, 0x0c, 0x680);
	alc_write_coef_idx(codec, 0x0c, 0x480);
3552 3553 3554
}

static void alc269_fixup_quanta_mute(struct hda_codec *codec,
3555
				     const struct hda_fixup *fix, int action)
3556 3557
{
	struct alc_spec *spec = codec->spec;
3558
	if (action != HDA_FIXUP_ACT_PROBE)
3559
		return;
3560
	spec->gen.automute_hook = alc269_quanta_automute;
3561 3562
}

3563
static void alc269_x101_hp_automute_hook(struct hda_codec *codec,
3564
					 struct hda_jack_callback *jack)
3565 3566 3567 3568 3569 3570 3571 3572 3573 3574 3575 3576 3577 3578 3579 3580 3581 3582 3583 3584 3585 3586 3587 3588 3589 3590
{
	struct alc_spec *spec = codec->spec;
	int vref;
	msleep(200);
	snd_hda_gen_hp_automute(codec, jack);

	vref = spec->gen.hp_jack_present ? PIN_VREF80 : 0;
	msleep(100);
	snd_hda_codec_write(codec, 0x18, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
			    vref);
	msleep(500);
	snd_hda_codec_write(codec, 0x18, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
			    vref);
}

static void alc269_fixup_x101_headset_mic(struct hda_codec *codec,
				     const struct hda_fixup *fix, int action)
{
	struct alc_spec *spec = codec->spec;
	if (action == HDA_FIXUP_ACT_PRE_PROBE) {
		spec->parse_flags |= HDA_PINCFG_HEADSET_MIC;
		spec->gen.hp_automute_hook = alc269_x101_hp_automute_hook;
	}
}


3591 3592
/* update mute-LED according to the speaker mute state via mic VREF pin */
static void alc269_fixup_mic_mute_hook(void *private_data, int enabled)
3593 3594
{
	struct hda_codec *codec = private_data;
3595 3596 3597 3598 3599
	struct alc_spec *spec = codec->spec;
	unsigned int pinval;

	if (spec->mute_led_polarity)
		enabled = !enabled;
3600 3601 3602
	pinval = snd_hda_codec_get_pin_target(codec, spec->mute_led_nid);
	pinval &= ~AC_PINCTL_VREFEN;
	pinval |= enabled ? AC_PINCTL_VREF_HIZ : AC_PINCTL_VREF_80;
3603 3604 3605
	if (spec->mute_led_nid) {
		/* temporarily power up/down for setting VREF */
		snd_hda_power_up_pm(codec);
3606
		snd_hda_set_pin_ctl_cache(codec, spec->mute_led_nid, pinval);
3607 3608
		snd_hda_power_down_pm(codec);
	}
3609 3610
}

3611 3612 3613 3614 3615 3616 3617
/* Make sure the led works even in runtime suspend */
static unsigned int led_power_filter(struct hda_codec *codec,
						  hda_nid_t nid,
						  unsigned int power_state)
{
	struct alc_spec *spec = codec->spec;

3618 3619
	if (power_state != AC_PWRST_D3 || nid == 0 ||
	    (nid != spec->mute_led_nid && nid != spec->cap_mute_led_nid))
3620 3621 3622 3623 3624 3625
		return power_state;

	/* Set pin ctl again, it might have just been set to 0 */
	snd_hda_set_pin_ctl(codec, nid,
			    snd_hda_codec_get_pin_target(codec, nid));

3626
	return snd_hda_gen_path_power_filter(codec, nid, power_state);
3627 3628
}

3629 3630
static void alc269_fixup_hp_mute_led(struct hda_codec *codec,
				     const struct hda_fixup *fix, int action)
3631 3632
{
	struct alc_spec *spec = codec->spec;
3633 3634 3635 3636 3637 3638 3639 3640 3641 3642 3643 3644 3645 3646
	const struct dmi_device *dev = NULL;

	if (action != HDA_FIXUP_ACT_PRE_PROBE)
		return;

	while ((dev = dmi_find_device(DMI_DEV_TYPE_OEM_STRING, NULL, dev))) {
		int pol, pin;
		if (sscanf(dev->name, "HP_Mute_LED_%d_%x", &pol, &pin) != 2)
			continue;
		if (pin < 0x0a || pin >= 0x10)
			break;
		spec->mute_led_polarity = pol;
		spec->mute_led_nid = pin - 0x0a + 0x18;
		spec->gen.vmaster_mute.hook = alc269_fixup_mic_mute_hook;
3647
		spec->gen.vmaster_mute_enum = 1;
3648
		codec->power_filter = led_power_filter;
3649 3650
		codec_dbg(codec,
			  "Detected mute LED for %x:%d\n", spec->mute_led_nid,
3651
			   spec->mute_led_polarity);
3652 3653 3654 3655
		break;
	}
}

3656 3657 3658
static void alc269_fixup_hp_mute_led_micx(struct hda_codec *codec,
					  const struct hda_fixup *fix,
					  int action, hda_nid_t pin)
3659 3660
{
	struct alc_spec *spec = codec->spec;
3661

3662 3663
	if (action == HDA_FIXUP_ACT_PRE_PROBE) {
		spec->mute_led_polarity = 0;
3664
		spec->mute_led_nid = pin;
3665 3666
		spec->gen.vmaster_mute.hook = alc269_fixup_mic_mute_hook;
		spec->gen.vmaster_mute_enum = 1;
3667
		codec->power_filter = led_power_filter;
3668 3669 3670
	}
}

3671 3672 3673 3674 3675 3676
static void alc269_fixup_hp_mute_led_mic1(struct hda_codec *codec,
				const struct hda_fixup *fix, int action)
{
	alc269_fixup_hp_mute_led_micx(codec, fix, action, 0x18);
}

3677 3678
static void alc269_fixup_hp_mute_led_mic2(struct hda_codec *codec,
				const struct hda_fixup *fix, int action)
3679
{
3680
	alc269_fixup_hp_mute_led_micx(codec, fix, action, 0x19);
3681 3682
}

3683 3684 3685
static void alc269_fixup_hp_mute_led_mic3(struct hda_codec *codec,
				const struct hda_fixup *fix, int action)
{
3686
	alc269_fixup_hp_mute_led_micx(codec, fix, action, 0x1b);
3687 3688
}

3689 3690 3691
/* update LED status via GPIO */
static void alc_update_gpio_led(struct hda_codec *codec, unsigned int mask,
				bool enabled)
3692 3693 3694 3695
{
	struct alc_spec *spec = codec->spec;
	unsigned int oldval = spec->gpio_led;

3696 3697 3698
	if (spec->mute_led_polarity)
		enabled = !enabled;

3699
	if (enabled)
3700
		spec->gpio_led &= ~mask;
3701
	else
3702
		spec->gpio_led |= mask;
3703 3704 3705 3706 3707
	if (spec->gpio_led != oldval)
		snd_hda_codec_write(codec, 0x01, 0, AC_VERB_SET_GPIO_DATA,
				    spec->gpio_led);
}

3708 3709
/* turn on/off mute LED via GPIO per vmaster hook */
static void alc_fixup_gpio_mute_hook(void *private_data, int enabled)
3710
{
3711
	struct hda_codec *codec = private_data;
3712 3713
	struct alc_spec *spec = codec->spec;

3714 3715
	alc_update_gpio_led(codec, spec->gpio_mute_led_mask, enabled);
}
3716

3717 3718 3719 3720 3721 3722 3723 3724 3725 3726 3727
/* turn on/off mic-mute LED via GPIO per capture hook */
static void alc_fixup_gpio_mic_mute_hook(struct hda_codec *codec,
					 struct snd_kcontrol *kcontrol,
					 struct snd_ctl_elem_value *ucontrol)
{
	struct alc_spec *spec = codec->spec;

	if (ucontrol)
		alc_update_gpio_led(codec, spec->gpio_mic_led_mask,
				    ucontrol->value.integer.value[0] ||
				    ucontrol->value.integer.value[1]);
3728 3729 3730 3731 3732 3733 3734 3735 3736 3737 3738 3739 3740
}

static void alc269_fixup_hp_gpio_led(struct hda_codec *codec,
				const struct hda_fixup *fix, int action)
{
	struct alc_spec *spec = codec->spec;
	static const struct hda_verb gpio_init[] = {
		{ 0x01, AC_VERB_SET_GPIO_MASK, 0x18 },
		{ 0x01, AC_VERB_SET_GPIO_DIRECTION, 0x18 },
		{}
	};

	if (action == HDA_FIXUP_ACT_PRE_PROBE) {
3741 3742
		spec->gen.vmaster_mute.hook = alc_fixup_gpio_mute_hook;
		spec->gen.cap_sync_hook = alc_fixup_gpio_mic_mute_hook;
3743
		spec->gpio_led = 0;
3744 3745 3746
		spec->mute_led_polarity = 0;
		spec->gpio_mute_led_mask = 0x08;
		spec->gpio_mic_led_mask = 0x10;
3747 3748 3749 3750
		snd_hda_add_verbs(codec, gpio_init);
	}
}

3751 3752 3753 3754 3755 3756 3757 3758 3759 3760 3761 3762 3763
static void alc286_fixup_hp_gpio_led(struct hda_codec *codec,
				const struct hda_fixup *fix, int action)
{
	struct alc_spec *spec = codec->spec;
	static const struct hda_verb gpio_init[] = {
		{ 0x01, AC_VERB_SET_GPIO_MASK, 0x22 },
		{ 0x01, AC_VERB_SET_GPIO_DIRECTION, 0x22 },
		{}
	};

	if (action == HDA_FIXUP_ACT_PRE_PROBE) {
		spec->gen.vmaster_mute.hook = alc_fixup_gpio_mute_hook;
		spec->gen.cap_sync_hook = alc_fixup_gpio_mic_mute_hook;
3764
		spec->gpio_led = 0;
3765 3766 3767
		spec->mute_led_polarity = 0;
		spec->gpio_mute_led_mask = 0x02;
		spec->gpio_mic_led_mask = 0x20;
3768 3769 3770 3771
		snd_hda_add_verbs(codec, gpio_init);
	}
}

3772 3773 3774 3775 3776 3777 3778 3779
/* turn on/off mic-mute LED per capture hook */
static void alc269_fixup_hp_cap_mic_mute_hook(struct hda_codec *codec,
					       struct snd_kcontrol *kcontrol,
					       struct snd_ctl_elem_value *ucontrol)
{
	struct alc_spec *spec = codec->spec;
	unsigned int pinval, enable, disable;

3780
	pinval = snd_hda_codec_get_pin_target(codec, spec->cap_mute_led_nid);
3781 3782 3783 3784 3785 3786 3787 3788 3789 3790 3791 3792 3793 3794 3795 3796 3797 3798 3799 3800 3801 3802 3803 3804 3805 3806 3807 3808
	pinval &= ~AC_PINCTL_VREFEN;
	enable  = pinval | AC_PINCTL_VREF_80;
	disable = pinval | AC_PINCTL_VREF_HIZ;

	if (!ucontrol)
		return;

	if (ucontrol->value.integer.value[0] ||
	    ucontrol->value.integer.value[1])
		pinval = disable;
	else
		pinval = enable;

	if (spec->cap_mute_led_nid)
		snd_hda_set_pin_ctl_cache(codec, spec->cap_mute_led_nid, pinval);
}

static void alc269_fixup_hp_gpio_mic1_led(struct hda_codec *codec,
				const struct hda_fixup *fix, int action)
{
	struct alc_spec *spec = codec->spec;
	static const struct hda_verb gpio_init[] = {
		{ 0x01, AC_VERB_SET_GPIO_MASK, 0x08 },
		{ 0x01, AC_VERB_SET_GPIO_DIRECTION, 0x08 },
		{}
	};

	if (action == HDA_FIXUP_ACT_PRE_PROBE) {
3809
		spec->gen.vmaster_mute.hook = alc_fixup_gpio_mute_hook;
3810 3811
		spec->gen.cap_sync_hook = alc269_fixup_hp_cap_mic_mute_hook;
		spec->gpio_led = 0;
3812 3813
		spec->mute_led_polarity = 0;
		spec->gpio_mute_led_mask = 0x08;
3814 3815
		spec->cap_mute_led_nid = 0x18;
		snd_hda_add_verbs(codec, gpio_init);
3816
		codec->power_filter = led_power_filter;
3817 3818 3819
	}
}

3820 3821 3822 3823 3824 3825 3826 3827 3828 3829 3830 3831
static void alc280_fixup_hp_gpio4(struct hda_codec *codec,
				   const struct hda_fixup *fix, int action)
{
	/* Like hp_gpio_mic1_led, but also needs GPIO4 low to enable headphone amp */
	struct alc_spec *spec = codec->spec;
	static const struct hda_verb gpio_init[] = {
		{ 0x01, AC_VERB_SET_GPIO_MASK, 0x18 },
		{ 0x01, AC_VERB_SET_GPIO_DIRECTION, 0x18 },
		{}
	};

	if (action == HDA_FIXUP_ACT_PRE_PROBE) {
3832
		spec->gen.vmaster_mute.hook = alc_fixup_gpio_mute_hook;
3833 3834
		spec->gen.cap_sync_hook = alc269_fixup_hp_cap_mic_mute_hook;
		spec->gpio_led = 0;
3835 3836
		spec->mute_led_polarity = 0;
		spec->gpio_mute_led_mask = 0x08;
3837 3838 3839 3840 3841 3842
		spec->cap_mute_led_nid = 0x18;
		snd_hda_add_verbs(codec, gpio_init);
		codec->power_filter = led_power_filter;
	}
}

3843
#if IS_REACHABLE(CONFIG_INPUT)
3844 3845 3846 3847 3848 3849 3850
static void gpio2_mic_hotkey_event(struct hda_codec *codec,
				   struct hda_jack_callback *event)
{
	struct alc_spec *spec = codec->spec;

	/* GPIO2 just toggles on a keypress/keyrelease cycle. Therefore
	   send both key on and key off event for every interrupt. */
3851
	input_report_key(spec->kb_dev, spec->alc_mute_keycode_map[ALC_KEY_MICMUTE_INDEX], 1);
3852
	input_sync(spec->kb_dev);
3853
	input_report_key(spec->kb_dev, spec->alc_mute_keycode_map[ALC_KEY_MICMUTE_INDEX], 0);
3854 3855 3856
	input_sync(spec->kb_dev);
}

3857 3858 3859
static int alc_register_micmute_input_device(struct hda_codec *codec)
{
	struct alc_spec *spec = codec->spec;
3860
	int i;
3861 3862 3863 3864 3865 3866

	spec->kb_dev = input_allocate_device();
	if (!spec->kb_dev) {
		codec_err(codec, "Out of memory (input_allocate_device)\n");
		return -ENOMEM;
	}
3867 3868 3869

	spec->alc_mute_keycode_map[ALC_KEY_MICMUTE_INDEX] = KEY_MICMUTE;

3870 3871
	spec->kb_dev->name = "Microphone Mute Button";
	spec->kb_dev->evbit[0] = BIT_MASK(EV_KEY);
3872 3873 3874 3875 3876
	spec->kb_dev->keycodesize = sizeof(spec->alc_mute_keycode_map[0]);
	spec->kb_dev->keycodemax = ARRAY_SIZE(spec->alc_mute_keycode_map);
	spec->kb_dev->keycode = spec->alc_mute_keycode_map;
	for (i = 0; i < ARRAY_SIZE(spec->alc_mute_keycode_map); i++)
		set_bit(spec->alc_mute_keycode_map[i], spec->kb_dev->keybit);
3877 3878 3879 3880 3881 3882 3883 3884 3885 3886 3887

	if (input_register_device(spec->kb_dev)) {
		codec_err(codec, "input_register_device failed\n");
		input_free_device(spec->kb_dev);
		spec->kb_dev = NULL;
		return -ENOMEM;
	}

	return 0;
}

3888 3889 3890 3891 3892 3893 3894 3895 3896 3897 3898 3899 3900 3901 3902 3903 3904
static void alc280_fixup_hp_gpio2_mic_hotkey(struct hda_codec *codec,
					     const struct hda_fixup *fix, int action)
{
	/* GPIO1 = set according to SKU external amp
	   GPIO2 = mic mute hotkey
	   GPIO3 = mute LED
	   GPIO4 = mic mute LED */
	static const struct hda_verb gpio_init[] = {
		{ 0x01, AC_VERB_SET_GPIO_MASK, 0x1e },
		{ 0x01, AC_VERB_SET_GPIO_DIRECTION, 0x1a },
		{ 0x01, AC_VERB_SET_GPIO_DATA, 0x02 },
		{}
	};

	struct alc_spec *spec = codec->spec;

	if (action == HDA_FIXUP_ACT_PRE_PROBE) {
3905
		if (alc_register_micmute_input_device(codec) != 0)
3906 3907 3908
			return;

		snd_hda_add_verbs(codec, gpio_init);
3909
		snd_hda_codec_write_cache(codec, codec->core.afg, 0,
3910
					  AC_VERB_SET_GPIO_UNSOLICITED_RSP_MASK, 0x04);
3911
		snd_hda_jack_detect_enable_callback(codec, codec->core.afg,
3912 3913 3914 3915 3916 3917 3918 3919 3920 3921 3922 3923 3924 3925 3926 3927 3928 3929 3930 3931 3932 3933 3934 3935
						    gpio2_mic_hotkey_event);

		spec->gen.vmaster_mute.hook = alc_fixup_gpio_mute_hook;
		spec->gen.cap_sync_hook = alc_fixup_gpio_mic_mute_hook;
		spec->gpio_led = 0;
		spec->mute_led_polarity = 0;
		spec->gpio_mute_led_mask = 0x08;
		spec->gpio_mic_led_mask = 0x10;
		return;
	}

	if (!spec->kb_dev)
		return;

	switch (action) {
	case HDA_FIXUP_ACT_PROBE:
		spec->init_amp = ALC_INIT_DEFAULT;
		break;
	case HDA_FIXUP_ACT_FREE:
		input_unregister_device(spec->kb_dev);
		spec->kb_dev = NULL;
	}
}

3936 3937 3938 3939 3940 3941 3942 3943 3944 3945 3946 3947 3948 3949 3950 3951 3952 3953 3954 3955 3956 3957 3958 3959 3960 3961 3962 3963 3964 3965 3966 3967 3968 3969 3970 3971 3972 3973 3974 3975
static void alc233_fixup_lenovo_line2_mic_hotkey(struct hda_codec *codec,
					     const struct hda_fixup *fix, int action)
{
	/* Line2 = mic mute hotkey
	   GPIO2 = mic mute LED */
	static const struct hda_verb gpio_init[] = {
		{ 0x01, AC_VERB_SET_GPIO_MASK, 0x04 },
		{ 0x01, AC_VERB_SET_GPIO_DIRECTION, 0x04 },
		{}
	};

	struct alc_spec *spec = codec->spec;

	if (action == HDA_FIXUP_ACT_PRE_PROBE) {
		if (alc_register_micmute_input_device(codec) != 0)
			return;

		snd_hda_add_verbs(codec, gpio_init);
		snd_hda_jack_detect_enable_callback(codec, 0x1b,
						    gpio2_mic_hotkey_event);

		spec->gen.cap_sync_hook = alc_fixup_gpio_mic_mute_hook;
		spec->gpio_led = 0;
		spec->mute_led_polarity = 0;
		spec->gpio_mic_led_mask = 0x04;
		return;
	}

	if (!spec->kb_dev)
		return;

	switch (action) {
	case HDA_FIXUP_ACT_PROBE:
		spec->init_amp = ALC_INIT_DEFAULT;
		break;
	case HDA_FIXUP_ACT_FREE:
		input_unregister_device(spec->kb_dev);
		spec->kb_dev = NULL;
	}
}
3976 3977 3978 3979
#else /* INPUT */
#define alc280_fixup_hp_gpio2_mic_hotkey	NULL
#define alc233_fixup_lenovo_line2_mic_hotkey	NULL
#endif /* INPUT */
3980

3981 3982 3983 3984 3985 3986 3987 3988 3989 3990 3991 3992 3993 3994 3995 3996
static void alc269_fixup_hp_line1_mic1_led(struct hda_codec *codec,
				const struct hda_fixup *fix, int action)
{
	struct alc_spec *spec = codec->spec;

	if (action == HDA_FIXUP_ACT_PRE_PROBE) {
		spec->gen.vmaster_mute.hook = alc269_fixup_mic_mute_hook;
		spec->gen.cap_sync_hook = alc269_fixup_hp_cap_mic_mute_hook;
		spec->mute_led_polarity = 0;
		spec->mute_led_nid = 0x1a;
		spec->cap_mute_led_nid = 0x18;
		spec->gen.vmaster_mute_enum = 1;
		codec->power_filter = led_power_filter;
	}
}

3997 3998 3999 4000 4001 4002 4003 4004 4005 4006 4007
static struct coef_fw alc225_pre_hsmode[] = {
	UPDATE_COEF(0x4a, 1<<8, 0),
	UPDATE_COEFEX(0x57, 0x05, 1<<14, 0),
	UPDATE_COEF(0x63, 3<<14, 3<<14),
	UPDATE_COEF(0x4a, 3<<4, 2<<4),
	UPDATE_COEF(0x4a, 3<<10, 3<<10),
	UPDATE_COEF(0x45, 0x3f<<10, 0x34<<10),
	UPDATE_COEF(0x4a, 3<<10, 0),
	{}
};

4008 4009
static void alc_headset_mode_unplugged(struct hda_codec *codec)
{
4010 4011 4012 4013 4014 4015 4016
	static struct coef_fw coef0255[] = {
		WRITE_COEF(0x45, 0xd089), /* UAJ function set to menual mode */
		UPDATE_COEFEX(0x57, 0x05, 1<<14, 0), /* Direct Drive HP Amp control(Set to verb control)*/
		WRITE_COEF(0x06, 0x6104), /* Set MIC2 Vref gate with HP */
		WRITE_COEFEX(0x57, 0x03, 0x8aa6), /* Direct Drive HP Amp control */
		{}
	};
4017 4018 4019 4020 4021 4022 4023 4024
	static struct coef_fw coef0255_1[] = {
		WRITE_COEF(0x1b, 0x0c0b), /* LDO and MISC control */
		{}
	};
	static struct coef_fw coef0256[] = {
		WRITE_COEF(0x1b, 0x0c4b), /* LDO and MISC control */
		{}
	};
4025 4026 4027 4028 4029 4030 4031 4032 4033 4034
	static struct coef_fw coef0233[] = {
		WRITE_COEF(0x1b, 0x0c0b),
		WRITE_COEF(0x45, 0xc429),
		UPDATE_COEF(0x35, 0x4000, 0),
		WRITE_COEF(0x06, 0x2104),
		WRITE_COEF(0x1a, 0x0001),
		WRITE_COEF(0x26, 0x0004),
		WRITE_COEF(0x32, 0x42a3),
		{}
	};
4035 4036 4037 4038 4039 4040 4041 4042
	static struct coef_fw coef0288[] = {
		UPDATE_COEF(0x4f, 0xfcc0, 0xc400),
		UPDATE_COEF(0x50, 0x2000, 0x2000),
		UPDATE_COEF(0x56, 0x0006, 0x0006),
		UPDATE_COEF(0x66, 0x0008, 0),
		UPDATE_COEF(0x67, 0x2000, 0),
		{}
	};
4043 4044 4045 4046
	static struct coef_fw coef0298[] = {
		UPDATE_COEF(0x19, 0x1300, 0x0300),
		{}
	};
4047 4048 4049 4050 4051 4052 4053 4054 4055 4056 4057 4058 4059 4060 4061 4062 4063 4064 4065 4066 4067
	static struct coef_fw coef0292[] = {
		WRITE_COEF(0x76, 0x000e),
		WRITE_COEF(0x6c, 0x2400),
		WRITE_COEF(0x18, 0x7308),
		WRITE_COEF(0x6b, 0xc429),
		{}
	};
	static struct coef_fw coef0293[] = {
		UPDATE_COEF(0x10, 7<<8, 6<<8), /* SET Line1 JD to 0 */
		UPDATE_COEFEX(0x57, 0x05, 1<<15|1<<13, 0x0), /* SET charge pump by verb */
		UPDATE_COEFEX(0x57, 0x03, 1<<10, 1<<10), /* SET EN_OSW to 1 */
		UPDATE_COEF(0x1a, 1<<3, 1<<3), /* Combo JD gating with LINE1-VREFO */
		WRITE_COEF(0x45, 0xc429), /* Set to TRS type */
		UPDATE_COEF(0x4a, 0x000f, 0x000e), /* Combo Jack auto detect */
		{}
	};
	static struct coef_fw coef0668[] = {
		WRITE_COEF(0x15, 0x0d40),
		WRITE_COEF(0xb7, 0x802b),
		{}
	};
4068
	static struct coef_fw coef0225[] = {
4069
		UPDATE_COEF(0x63, 3<<14, 0),
4070 4071
		{}
	};
4072 4073 4074 4075 4076 4077 4078 4079 4080 4081
	static struct coef_fw coef0274[] = {
		UPDATE_COEF(0x4a, 0x0100, 0),
		UPDATE_COEFEX(0x57, 0x05, 0x4000, 0),
		UPDATE_COEF(0x6b, 0xf000, 0x5000),
		UPDATE_COEF(0x4a, 0x0010, 0),
		UPDATE_COEF(0x4a, 0x0c00, 0x0c00),
		WRITE_COEF(0x45, 0x5289),
		UPDATE_COEF(0x4a, 0x0c00, 0),
		{}
	};
4082

4083
	switch (codec->core.vendor_id) {
4084
	case 0x10ec0255:
4085 4086 4087
		alc_process_coef_fw(codec, coef0255_1);
		alc_process_coef_fw(codec, coef0255);
		break;
4088
	case 0x10ec0236:
4089
	case 0x10ec0256:
4090
		alc_process_coef_fw(codec, coef0256);
4091
		alc_process_coef_fw(codec, coef0255);
4092
		break;
4093 4094 4095 4096 4097
	case 0x10ec0234:
	case 0x10ec0274:
	case 0x10ec0294:
		alc_process_coef_fw(codec, coef0274);
		break;
4098
	case 0x10ec0233:
4099
	case 0x10ec0283:
4100
		alc_process_coef_fw(codec, coef0233);
4101
		break;
4102 4103
	case 0x10ec0286:
	case 0x10ec0288:
4104 4105
		alc_process_coef_fw(codec, coef0288);
		break;
4106
	case 0x10ec0298:
4107
		alc_process_coef_fw(codec, coef0298);
4108 4109
		alc_process_coef_fw(codec, coef0288);
		break;
4110
	case 0x10ec0292:
4111
		alc_process_coef_fw(codec, coef0292);
4112
		break;
4113
	case 0x10ec0293:
4114
		alc_process_coef_fw(codec, coef0293);
4115
		break;
4116
	case 0x10ec0668:
4117
		alc_process_coef_fw(codec, coef0668);
4118
		break;
4119
	case 0x10ec0215:
4120
	case 0x10ec0225:
4121
	case 0x10ec0285:
4122
	case 0x10ec0295:
4123
	case 0x10ec0289:
4124
	case 0x10ec0299:
4125 4126
		alc_process_coef_fw(codec, coef0225);
		break;
4127 4128 4129
	case 0x10ec0867:
		alc_update_coefex_idx(codec, 0x57, 0x5, 1<<14, 0);
		break;
4130
	}
4131
	codec_dbg(codec, "Headset jack set to unplugged mode.\n");
4132 4133 4134 4135 4136 4137
}


static void alc_headset_mode_mic_in(struct hda_codec *codec, hda_nid_t hp_pin,
				    hda_nid_t mic_pin)
{
4138 4139 4140 4141 4142 4143 4144 4145 4146 4147 4148 4149
	static struct coef_fw coef0255[] = {
		WRITE_COEFEX(0x57, 0x03, 0x8aa6),
		WRITE_COEF(0x06, 0x6100), /* Set MIC2 Vref gate to normal */
		{}
	};
	static struct coef_fw coef0233[] = {
		UPDATE_COEF(0x35, 0, 1<<14),
		WRITE_COEF(0x06, 0x2100),
		WRITE_COEF(0x1a, 0x0021),
		WRITE_COEF(0x26, 0x008c),
		{}
	};
4150
	static struct coef_fw coef0288[] = {
4151
		UPDATE_COEF(0x4f, 0x00c0, 0),
4152 4153 4154 4155 4156 4157 4158
		UPDATE_COEF(0x50, 0x2000, 0),
		UPDATE_COEF(0x56, 0x0006, 0),
		UPDATE_COEF(0x4f, 0xfcc0, 0xc400),
		UPDATE_COEF(0x66, 0x0008, 0x0008),
		UPDATE_COEF(0x67, 0x2000, 0x2000),
		{}
	};
4159 4160 4161 4162 4163 4164 4165 4166 4167 4168 4169 4170 4171 4172 4173 4174 4175
	static struct coef_fw coef0292[] = {
		WRITE_COEF(0x19, 0xa208),
		WRITE_COEF(0x2e, 0xacf0),
		{}
	};
	static struct coef_fw coef0293[] = {
		UPDATE_COEFEX(0x57, 0x05, 0, 1<<15|1<<13), /* SET charge pump by verb */
		UPDATE_COEFEX(0x57, 0x03, 1<<10, 0), /* SET EN_OSW to 0 */
		UPDATE_COEF(0x1a, 1<<3, 0), /* Combo JD gating without LINE1-VREFO */
		{}
	};
	static struct coef_fw coef0688[] = {
		WRITE_COEF(0xb7, 0x802b),
		WRITE_COEF(0xb5, 0x1040),
		UPDATE_COEF(0xc3, 0, 1<<12),
		{}
	};
4176 4177 4178 4179 4180 4181
	static struct coef_fw coef0225[] = {
		UPDATE_COEFEX(0x57, 0x05, 1<<14, 1<<14),
		UPDATE_COEF(0x4a, 3<<4, 2<<4),
		UPDATE_COEF(0x63, 3<<14, 0),
		{}
	};
4182 4183 4184 4185 4186 4187
	static struct coef_fw coef0274[] = {
		UPDATE_COEFEX(0x57, 0x05, 0x4000, 0x4000),
		UPDATE_COEF(0x4a, 0x0010, 0),
		UPDATE_COEF(0x6b, 0xf000, 0),
		{}
	};
4188

4189
	switch (codec->core.vendor_id) {
4190
	case 0x10ec0236:
4191
	case 0x10ec0255:
4192
	case 0x10ec0256:
4193 4194
		alc_write_coef_idx(codec, 0x45, 0xc489);
		snd_hda_set_pin_ctl_cache(codec, hp_pin, 0);
4195
		alc_process_coef_fw(codec, coef0255);
4196 4197
		snd_hda_set_pin_ctl_cache(codec, mic_pin, PIN_VREF50);
		break;
4198 4199 4200 4201 4202 4203 4204 4205
	case 0x10ec0234:
	case 0x10ec0274:
	case 0x10ec0294:
		alc_write_coef_idx(codec, 0x45, 0x4689);
		snd_hda_set_pin_ctl_cache(codec, hp_pin, 0);
		alc_process_coef_fw(codec, coef0274);
		snd_hda_set_pin_ctl_cache(codec, mic_pin, PIN_VREF50);
		break;
4206
	case 0x10ec0233:
4207 4208 4209
	case 0x10ec0283:
		alc_write_coef_idx(codec, 0x45, 0xc429);
		snd_hda_set_pin_ctl_cache(codec, hp_pin, 0);
4210
		alc_process_coef_fw(codec, coef0233);
4211 4212
		snd_hda_set_pin_ctl_cache(codec, mic_pin, PIN_VREF50);
		break;
4213 4214
	case 0x10ec0286:
	case 0x10ec0288:
4215
	case 0x10ec0298:
4216 4217 4218 4219
		snd_hda_set_pin_ctl_cache(codec, hp_pin, 0);
		alc_process_coef_fw(codec, coef0288);
		snd_hda_set_pin_ctl_cache(codec, mic_pin, PIN_VREF50);
		break;
4220 4221
	case 0x10ec0292:
		snd_hda_set_pin_ctl_cache(codec, hp_pin, 0);
4222
		alc_process_coef_fw(codec, coef0292);
4223
		break;
4224 4225 4226 4227
	case 0x10ec0293:
		/* Set to TRS mode */
		alc_write_coef_idx(codec, 0x45, 0xc429);
		snd_hda_set_pin_ctl_cache(codec, hp_pin, 0);
4228
		alc_process_coef_fw(codec, coef0293);
4229 4230
		snd_hda_set_pin_ctl_cache(codec, mic_pin, PIN_VREF50);
		break;
4231 4232 4233
	case 0x10ec0867:
		alc_update_coefex_idx(codec, 0x57, 0x5, 0, 1<<14);
		/* fallthru */
4234
	case 0x10ec0221:
4235 4236 4237 4238
	case 0x10ec0662:
		snd_hda_set_pin_ctl_cache(codec, hp_pin, 0);
		snd_hda_set_pin_ctl_cache(codec, mic_pin, PIN_VREF50);
		break;
4239 4240 4241
	case 0x10ec0668:
		alc_write_coef_idx(codec, 0x11, 0x0001);
		snd_hda_set_pin_ctl_cache(codec, hp_pin, 0);
4242
		alc_process_coef_fw(codec, coef0688);
4243 4244
		snd_hda_set_pin_ctl_cache(codec, mic_pin, PIN_VREF50);
		break;
4245
	case 0x10ec0215:
4246
	case 0x10ec0225:
4247
	case 0x10ec0285:
4248
	case 0x10ec0295:
4249
	case 0x10ec0289:
4250
	case 0x10ec0299:
4251
		alc_process_coef_fw(codec, alc225_pre_hsmode);
4252 4253 4254 4255 4256
		alc_update_coef_idx(codec, 0x45, 0x3f<<10, 0x31<<10);
		snd_hda_set_pin_ctl_cache(codec, hp_pin, 0);
		alc_process_coef_fw(codec, coef0225);
		snd_hda_set_pin_ctl_cache(codec, mic_pin, PIN_VREF50);
		break;
4257
	}
4258
	codec_dbg(codec, "Headset jack set to mic-in mode.\n");
4259 4260 4261 4262
}

static void alc_headset_mode_default(struct hda_codec *codec)
{
4263
	static struct coef_fw coef0225[] = {
4264 4265 4266 4267 4268 4269
		UPDATE_COEF(0x45, 0x3f<<10, 0x30<<10),
		UPDATE_COEF(0x45, 0x3f<<10, 0x31<<10),
		UPDATE_COEF(0x49, 3<<8, 0<<8),
		UPDATE_COEF(0x4a, 3<<4, 3<<4),
		UPDATE_COEF(0x63, 3<<14, 0),
		UPDATE_COEF(0x67, 0xf000, 0x3000),
4270 4271
		{}
	};
4272 4273 4274 4275 4276 4277 4278 4279 4280 4281 4282 4283
	static struct coef_fw coef0255[] = {
		WRITE_COEF(0x45, 0xc089),
		WRITE_COEF(0x45, 0xc489),
		WRITE_COEFEX(0x57, 0x03, 0x8ea6),
		WRITE_COEF(0x49, 0x0049),
		{}
	};
	static struct coef_fw coef0233[] = {
		WRITE_COEF(0x06, 0x2100),
		WRITE_COEF(0x32, 0x4ea3),
		{}
	};
4284 4285 4286 4287 4288 4289 4290 4291
	static struct coef_fw coef0288[] = {
		UPDATE_COEF(0x4f, 0xfcc0, 0xc400), /* Set to TRS type */
		UPDATE_COEF(0x50, 0x2000, 0x2000),
		UPDATE_COEF(0x56, 0x0006, 0x0006),
		UPDATE_COEF(0x66, 0x0008, 0),
		UPDATE_COEF(0x67, 0x2000, 0),
		{}
	};
4292 4293 4294 4295 4296 4297 4298 4299 4300 4301 4302 4303 4304 4305 4306 4307 4308 4309 4310
	static struct coef_fw coef0292[] = {
		WRITE_COEF(0x76, 0x000e),
		WRITE_COEF(0x6c, 0x2400),
		WRITE_COEF(0x6b, 0xc429),
		WRITE_COEF(0x18, 0x7308),
		{}
	};
	static struct coef_fw coef0293[] = {
		UPDATE_COEF(0x4a, 0x000f, 0x000e), /* Combo Jack auto detect */
		WRITE_COEF(0x45, 0xC429), /* Set to TRS type */
		UPDATE_COEF(0x1a, 1<<3, 0), /* Combo JD gating without LINE1-VREFO */
		{}
	};
	static struct coef_fw coef0688[] = {
		WRITE_COEF(0x11, 0x0041),
		WRITE_COEF(0x15, 0x0d40),
		WRITE_COEF(0xb7, 0x802b),
		{}
	};
4311 4312 4313 4314 4315 4316 4317
	static struct coef_fw coef0274[] = {
		WRITE_COEF(0x45, 0x4289),
		UPDATE_COEF(0x4a, 0x0010, 0x0010),
		UPDATE_COEF(0x6b, 0x0f00, 0),
		UPDATE_COEF(0x49, 0x0300, 0x0300),
		{}
	};
4318

4319
	switch (codec->core.vendor_id) {
4320
	case 0x10ec0215:
4321
	case 0x10ec0225:
4322
	case 0x10ec0285:
4323
	case 0x10ec0295:
4324
	case 0x10ec0289:
4325
	case 0x10ec0299:
4326
		alc_process_coef_fw(codec, alc225_pre_hsmode);
4327 4328
		alc_process_coef_fw(codec, coef0225);
		break;
4329
	case 0x10ec0236:
4330
	case 0x10ec0255:
4331
	case 0x10ec0256:
4332
		alc_process_coef_fw(codec, coef0255);
4333
		break;
4334 4335 4336 4337 4338
	case 0x10ec0234:
	case 0x10ec0274:
	case 0x10ec0294:
		alc_process_coef_fw(codec, coef0274);
		break;
4339
	case 0x10ec0233:
4340
	case 0x10ec0283:
4341
		alc_process_coef_fw(codec, coef0233);
4342
		break;
4343 4344
	case 0x10ec0286:
	case 0x10ec0288:
4345
	case 0x10ec0298:
4346 4347
		alc_process_coef_fw(codec, coef0288);
		break;
4348
	case 0x10ec0292:
4349
		alc_process_coef_fw(codec, coef0292);
4350
		break;
4351
	case 0x10ec0293:
4352
		alc_process_coef_fw(codec, coef0293);
4353
		break;
4354
	case 0x10ec0668:
4355
		alc_process_coef_fw(codec, coef0688);
4356
		break;
4357 4358 4359
	case 0x10ec0867:
		alc_update_coefex_idx(codec, 0x57, 0x5, 1<<14, 0);
		break;
4360
	}
4361
	codec_dbg(codec, "Headset jack set to headphone (default) mode.\n");
4362 4363 4364 4365 4366
}

/* Iphone type */
static void alc_headset_mode_ctia(struct hda_codec *codec)
{
4367 4368
	int val;

4369 4370 4371 4372 4373 4374
	static struct coef_fw coef0255[] = {
		WRITE_COEF(0x45, 0xd489), /* Set to CTIA type */
		WRITE_COEF(0x1b, 0x0c2b),
		WRITE_COEFEX(0x57, 0x03, 0x8ea6),
		{}
	};
4375 4376 4377 4378 4379 4380
	static struct coef_fw coef0256[] = {
		WRITE_COEF(0x45, 0xd489), /* Set to CTIA type */
		WRITE_COEF(0x1b, 0x0c6b),
		WRITE_COEFEX(0x57, 0x03, 0x8ea6),
		{}
	};
4381 4382 4383 4384 4385 4386
	static struct coef_fw coef0233[] = {
		WRITE_COEF(0x45, 0xd429),
		WRITE_COEF(0x1b, 0x0c2b),
		WRITE_COEF(0x32, 0x4ea3),
		{}
	};
4387 4388 4389 4390 4391 4392 4393
	static struct coef_fw coef0288[] = {
		UPDATE_COEF(0x50, 0x2000, 0x2000),
		UPDATE_COEF(0x56, 0x0006, 0x0006),
		UPDATE_COEF(0x66, 0x0008, 0),
		UPDATE_COEF(0x67, 0x2000, 0),
		{}
	};
4394 4395 4396 4397 4398 4399 4400 4401 4402 4403 4404 4405 4406 4407 4408 4409 4410
	static struct coef_fw coef0292[] = {
		WRITE_COEF(0x6b, 0xd429),
		WRITE_COEF(0x76, 0x0008),
		WRITE_COEF(0x18, 0x7388),
		{}
	};
	static struct coef_fw coef0293[] = {
		WRITE_COEF(0x45, 0xd429), /* Set to ctia type */
		UPDATE_COEF(0x10, 7<<8, 7<<8), /* SET Line1 JD to 1 */
		{}
	};
	static struct coef_fw coef0688[] = {
		WRITE_COEF(0x11, 0x0001),
		WRITE_COEF(0x15, 0x0d60),
		WRITE_COEF(0xc3, 0x0000),
		{}
	};
4411
	static struct coef_fw coef0225_1[] = {
4412
		UPDATE_COEF(0x45, 0x3f<<10, 0x35<<10),
4413 4414 4415 4416 4417 4418
		UPDATE_COEF(0x63, 3<<14, 2<<14),
		{}
	};
	static struct coef_fw coef0225_2[] = {
		UPDATE_COEF(0x45, 0x3f<<10, 0x35<<10),
		UPDATE_COEF(0x63, 3<<14, 1<<14),
4419 4420
		{}
	};
4421

4422
	switch (codec->core.vendor_id) {
4423
	case 0x10ec0255:
4424
		alc_process_coef_fw(codec, coef0255);
4425
		break;
4426
	case 0x10ec0236:
4427 4428 4429
	case 0x10ec0256:
		alc_process_coef_fw(codec, coef0256);
		break;
4430 4431 4432 4433 4434
	case 0x10ec0234:
	case 0x10ec0274:
	case 0x10ec0294:
		alc_write_coef_idx(codec, 0x45, 0xd689);
		break;
4435
	case 0x10ec0233:
4436
	case 0x10ec0283:
4437
		alc_process_coef_fw(codec, coef0233);
4438
		break;
4439
	case 0x10ec0298:
4440 4441 4442 4443 4444 4445 4446 4447 4448 4449 4450
		val = alc_read_coef_idx(codec, 0x50);
		if (val & (1 << 12)) {
			alc_update_coef_idx(codec, 0x8e, 0x0070, 0x0020);
			alc_update_coef_idx(codec, 0x4f, 0xfcc0, 0xd400);
			msleep(300);
		} else {
			alc_update_coef_idx(codec, 0x8e, 0x0070, 0x0010);
			alc_update_coef_idx(codec, 0x4f, 0xfcc0, 0xd400);
			msleep(300);
		}
		break;
4451 4452 4453 4454 4455 4456
	case 0x10ec0286:
	case 0x10ec0288:
		alc_update_coef_idx(codec, 0x4f, 0xfcc0, 0xd400);
		msleep(300);
		alc_process_coef_fw(codec, coef0288);
		break;
4457
	case 0x10ec0292:
4458
		alc_process_coef_fw(codec, coef0292);
4459
		break;
4460
	case 0x10ec0293:
4461
		alc_process_coef_fw(codec, coef0293);
4462
		break;
4463
	case 0x10ec0668:
4464
		alc_process_coef_fw(codec, coef0688);
4465
		break;
4466
	case 0x10ec0215:
4467
	case 0x10ec0225:
4468
	case 0x10ec0285:
4469
	case 0x10ec0295:
4470
	case 0x10ec0289:
4471
	case 0x10ec0299:
4472 4473 4474 4475 4476
		val = alc_read_coef_idx(codec, 0x45);
		if (val & (1 << 9))
			alc_process_coef_fw(codec, coef0225_2);
		else
			alc_process_coef_fw(codec, coef0225_1);
4477
		break;
4478 4479 4480
	case 0x10ec0867:
		alc_update_coefex_idx(codec, 0x57, 0x5, 1<<14, 0);
		break;
4481
	}
4482
	codec_dbg(codec, "Headset jack set to iPhone-style headset mode.\n");
4483 4484 4485 4486 4487
}

/* Nokia type */
static void alc_headset_mode_omtp(struct hda_codec *codec)
{
4488 4489 4490 4491 4492 4493
	static struct coef_fw coef0255[] = {
		WRITE_COEF(0x45, 0xe489), /* Set to OMTP Type */
		WRITE_COEF(0x1b, 0x0c2b),
		WRITE_COEFEX(0x57, 0x03, 0x8ea6),
		{}
	};
4494 4495 4496 4497 4498 4499
	static struct coef_fw coef0256[] = {
		WRITE_COEF(0x45, 0xe489), /* Set to OMTP Type */
		WRITE_COEF(0x1b, 0x0c6b),
		WRITE_COEFEX(0x57, 0x03, 0x8ea6),
		{}
	};
4500 4501 4502 4503 4504 4505
	static struct coef_fw coef0233[] = {
		WRITE_COEF(0x45, 0xe429),
		WRITE_COEF(0x1b, 0x0c2b),
		WRITE_COEF(0x32, 0x4ea3),
		{}
	};
4506 4507 4508 4509 4510 4511 4512
	static struct coef_fw coef0288[] = {
		UPDATE_COEF(0x50, 0x2000, 0x2000),
		UPDATE_COEF(0x56, 0x0006, 0x0006),
		UPDATE_COEF(0x66, 0x0008, 0),
		UPDATE_COEF(0x67, 0x2000, 0),
		{}
	};
4513 4514 4515 4516 4517 4518 4519 4520 4521 4522 4523 4524 4525 4526 4527 4528 4529
	static struct coef_fw coef0292[] = {
		WRITE_COEF(0x6b, 0xe429),
		WRITE_COEF(0x76, 0x0008),
		WRITE_COEF(0x18, 0x7388),
		{}
	};
	static struct coef_fw coef0293[] = {
		WRITE_COEF(0x45, 0xe429), /* Set to omtp type */
		UPDATE_COEF(0x10, 7<<8, 7<<8), /* SET Line1 JD to 1 */
		{}
	};
	static struct coef_fw coef0688[] = {
		WRITE_COEF(0x11, 0x0001),
		WRITE_COEF(0x15, 0x0d50),
		WRITE_COEF(0xc3, 0x0000),
		{}
	};
4530 4531
	static struct coef_fw coef0225[] = {
		UPDATE_COEF(0x45, 0x3f<<10, 0x39<<10),
4532
		UPDATE_COEF(0x63, 3<<14, 2<<14),
4533 4534
		{}
	};
4535

4536
	switch (codec->core.vendor_id) {
4537
	case 0x10ec0255:
4538
		alc_process_coef_fw(codec, coef0255);
4539
		break;
4540
	case 0x10ec0236:
4541 4542 4543
	case 0x10ec0256:
		alc_process_coef_fw(codec, coef0256);
		break;
4544 4545 4546 4547 4548
	case 0x10ec0234:
	case 0x10ec0274:
	case 0x10ec0294:
		alc_write_coef_idx(codec, 0x45, 0xe689);
		break;
4549
	case 0x10ec0233:
4550
	case 0x10ec0283:
4551
		alc_process_coef_fw(codec, coef0233);
4552
		break;
4553 4554
	case 0x10ec0298:
		alc_update_coef_idx(codec, 0x8e, 0x0070, 0x0010);/* Headset output enable */
4555 4556 4557
		alc_update_coef_idx(codec, 0x4f, 0xfcc0, 0xe400);
		msleep(300);
		break;
4558 4559 4560 4561 4562 4563
	case 0x10ec0286:
	case 0x10ec0288:
		alc_update_coef_idx(codec, 0x4f, 0xfcc0, 0xe400);
		msleep(300);
		alc_process_coef_fw(codec, coef0288);
		break;
4564
	case 0x10ec0292:
4565
		alc_process_coef_fw(codec, coef0292);
4566
		break;
4567
	case 0x10ec0293:
4568
		alc_process_coef_fw(codec, coef0293);
4569
		break;
4570
	case 0x10ec0668:
4571
		alc_process_coef_fw(codec, coef0688);
4572
		break;
4573
	case 0x10ec0215:
4574
	case 0x10ec0225:
4575
	case 0x10ec0285:
4576
	case 0x10ec0295:
4577
	case 0x10ec0289:
4578
	case 0x10ec0299:
4579 4580
		alc_process_coef_fw(codec, coef0225);
		break;
4581
	}
4582
	codec_dbg(codec, "Headset jack set to Nokia-style headset mode.\n");
4583 4584 4585 4586 4587 4588 4589
}

static void alc_determine_headset_type(struct hda_codec *codec)
{
	int val;
	bool is_ctia = false;
	struct alc_spec *spec = codec->spec;
4590 4591 4592 4593 4594 4595
	static struct coef_fw coef0255[] = {
		WRITE_COEF(0x45, 0xd089), /* combo jack auto switch control(Check type)*/
		WRITE_COEF(0x49, 0x0149), /* combo jack auto switch control(Vref
 conteol) */
		{}
	};
4596 4597 4598 4599
	static struct coef_fw coef0288[] = {
		UPDATE_COEF(0x4f, 0xfcc0, 0xd400), /* Check Type */
		{}
	};
4600 4601 4602 4603 4604 4605 4606 4607
	static struct coef_fw coef0298[] = {
		UPDATE_COEF(0x50, 0x2000, 0x2000),
		UPDATE_COEF(0x56, 0x0006, 0x0006),
		UPDATE_COEF(0x66, 0x0008, 0),
		UPDATE_COEF(0x67, 0x2000, 0),
		UPDATE_COEF(0x19, 0x1300, 0x1300),
		{}
	};
4608 4609 4610 4611 4612 4613 4614 4615 4616 4617 4618 4619
	static struct coef_fw coef0293[] = {
		UPDATE_COEF(0x4a, 0x000f, 0x0008), /* Combo Jack auto detect */
		WRITE_COEF(0x45, 0xD429), /* Set to ctia type */
		{}
	};
	static struct coef_fw coef0688[] = {
		WRITE_COEF(0x11, 0x0001),
		WRITE_COEF(0xb7, 0x802b),
		WRITE_COEF(0x15, 0x0d60),
		WRITE_COEF(0xc3, 0x0c00),
		{}
	};
4620 4621 4622 4623 4624 4625 4626
	static struct coef_fw coef0274[] = {
		UPDATE_COEF(0x4a, 0x0010, 0),
		UPDATE_COEF(0x4a, 0x8000, 0),
		WRITE_COEF(0x45, 0xd289),
		UPDATE_COEF(0x49, 0x0300, 0x0300),
		{}
	};
4627

4628
	switch (codec->core.vendor_id) {
4629
	case 0x10ec0236:
4630
	case 0x10ec0255:
4631
	case 0x10ec0256:
4632
		alc_process_coef_fw(codec, coef0255);
4633 4634 4635 4636
		msleep(300);
		val = alc_read_coef_idx(codec, 0x46);
		is_ctia = (val & 0x0070) == 0x0070;
		break;
4637 4638 4639 4640 4641 4642 4643 4644
	case 0x10ec0234:
	case 0x10ec0274:
	case 0x10ec0294:
		alc_process_coef_fw(codec, coef0274);
		msleep(80);
		val = alc_read_coef_idx(codec, 0x46);
		is_ctia = (val & 0x00f0) == 0x00f0;
		break;
4645
	case 0x10ec0233:
4646 4647 4648 4649 4650 4651
	case 0x10ec0283:
		alc_write_coef_idx(codec, 0x45, 0xd029);
		msleep(300);
		val = alc_read_coef_idx(codec, 0x46);
		is_ctia = (val & 0x0070) == 0x0070;
		break;
4652
	case 0x10ec0298:
4653 4654 4655 4656 4657 4658 4659 4660 4661 4662 4663 4664 4665 4666 4667 4668 4669 4670 4671 4672 4673 4674 4675 4676 4677 4678 4679 4680
		snd_hda_codec_write(codec, 0x21, 0,
			    AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);
		msleep(100);
		snd_hda_codec_write(codec, 0x21, 0,
			    AC_VERB_SET_PIN_WIDGET_CONTROL, 0x0);
		msleep(200);

		val = alc_read_coef_idx(codec, 0x50);
		if (val & (1 << 12)) {
			alc_update_coef_idx(codec, 0x8e, 0x0070, 0x0020);
			alc_process_coef_fw(codec, coef0288);
			msleep(350);
			val = alc_read_coef_idx(codec, 0x50);
			is_ctia = (val & 0x0070) == 0x0070;
		} else {
			alc_update_coef_idx(codec, 0x8e, 0x0070, 0x0010);
			alc_process_coef_fw(codec, coef0288);
			msleep(350);
			val = alc_read_coef_idx(codec, 0x50);
			is_ctia = (val & 0x0070) == 0x0070;
		}
		alc_process_coef_fw(codec, coef0298);
		snd_hda_codec_write(codec, 0x21, 0,
			    AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP);
		msleep(75);
		snd_hda_codec_write(codec, 0x21, 0,
			    AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE);
		break;
4681 4682 4683 4684 4685 4686 4687
	case 0x10ec0286:
	case 0x10ec0288:
		alc_process_coef_fw(codec, coef0288);
		msleep(350);
		val = alc_read_coef_idx(codec, 0x50);
		is_ctia = (val & 0x0070) == 0x0070;
		break;
4688 4689 4690 4691 4692 4693
	case 0x10ec0292:
		alc_write_coef_idx(codec, 0x6b, 0xd429);
		msleep(300);
		val = alc_read_coef_idx(codec, 0x6c);
		is_ctia = (val & 0x001c) == 0x001c;
		break;
4694
	case 0x10ec0293:
4695
		alc_process_coef_fw(codec, coef0293);
4696 4697 4698 4699
		msleep(300);
		val = alc_read_coef_idx(codec, 0x46);
		is_ctia = (val & 0x0070) == 0x0070;
		break;
4700
	case 0x10ec0668:
4701
		alc_process_coef_fw(codec, coef0688);
4702 4703 4704 4705
		msleep(300);
		val = alc_read_coef_idx(codec, 0xbe);
		is_ctia = (val & 0x1c02) == 0x1c02;
		break;
4706
	case 0x10ec0215:
4707
	case 0x10ec0225:
4708
	case 0x10ec0285:
4709
	case 0x10ec0295:
4710
	case 0x10ec0289:
4711
	case 0x10ec0299:
4712 4713 4714 4715 4716 4717
		snd_hda_codec_write(codec, 0x21, 0,
			    AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);
		msleep(80);
		snd_hda_codec_write(codec, 0x21, 0,
			    AC_VERB_SET_PIN_WIDGET_CONTROL, 0x0);

4718 4719 4720 4721 4722 4723 4724 4725 4726 4727 4728 4729 4730 4731 4732 4733 4734 4735 4736
		alc_process_coef_fw(codec, alc225_pre_hsmode);
		alc_update_coef_idx(codec, 0x67, 0xf000, 0x1000);
		val = alc_read_coef_idx(codec, 0x45);
		if (val & (1 << 9)) {
			alc_update_coef_idx(codec, 0x45, 0x3f<<10, 0x34<<10);
			alc_update_coef_idx(codec, 0x49, 3<<8, 2<<8);
			msleep(800);
			val = alc_read_coef_idx(codec, 0x46);
			is_ctia = (val & 0x00f0) == 0x00f0;
		} else {
			alc_update_coef_idx(codec, 0x45, 0x3f<<10, 0x34<<10);
			alc_update_coef_idx(codec, 0x49, 3<<8, 1<<8);
			msleep(800);
			val = alc_read_coef_idx(codec, 0x46);
			is_ctia = (val & 0x00f0) == 0x00f0;
		}
		alc_update_coef_idx(codec, 0x4a, 7<<6, 7<<6);
		alc_update_coef_idx(codec, 0x4a, 3<<4, 3<<4);
		alc_update_coef_idx(codec, 0x67, 0xf000, 0x3000);
4737 4738 4739 4740 4741 4742

		snd_hda_codec_write(codec, 0x21, 0,
			    AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT);
		msleep(80);
		snd_hda_codec_write(codec, 0x21, 0,
			    AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE);
4743
		break;
4744 4745 4746
	case 0x10ec0867:
		is_ctia = true;
		break;
4747 4748
	}

4749
	codec_dbg(codec, "Headset jack detected iPhone-style headset: %s\n",
4750 4751 4752 4753 4754 4755 4756 4757 4758 4759 4760 4761 4762 4763 4764 4765 4766 4767 4768 4769 4770 4771
		    is_ctia ? "yes" : "no");
	spec->current_headset_type = is_ctia ? ALC_HEADSET_TYPE_CTIA : ALC_HEADSET_TYPE_OMTP;
}

static void alc_update_headset_mode(struct hda_codec *codec)
{
	struct alc_spec *spec = codec->spec;

	hda_nid_t mux_pin = spec->gen.imux_pins[spec->gen.cur_mux[0]];
	hda_nid_t hp_pin = spec->gen.autocfg.hp_pins[0];

	int new_headset_mode;

	if (!snd_hda_jack_detect(codec, hp_pin))
		new_headset_mode = ALC_HEADSET_MODE_UNPLUGGED;
	else if (mux_pin == spec->headset_mic_pin)
		new_headset_mode = ALC_HEADSET_MODE_HEADSET;
	else if (mux_pin == spec->headphone_mic_pin)
		new_headset_mode = ALC_HEADSET_MODE_MIC;
	else
		new_headset_mode = ALC_HEADSET_MODE_HEADPHONE;

4772 4773
	if (new_headset_mode == spec->current_headset_mode) {
		snd_hda_gen_update_outputs(codec);
4774
		return;
4775
	}
4776 4777 4778 4779 4780 4781 4782 4783 4784 4785 4786 4787 4788 4789 4790 4791 4792 4793 4794 4795 4796 4797 4798 4799 4800 4801 4802

	switch (new_headset_mode) {
	case ALC_HEADSET_MODE_UNPLUGGED:
		alc_headset_mode_unplugged(codec);
		spec->gen.hp_jack_present = false;
		break;
	case ALC_HEADSET_MODE_HEADSET:
		if (spec->current_headset_type == ALC_HEADSET_TYPE_UNKNOWN)
			alc_determine_headset_type(codec);
		if (spec->current_headset_type == ALC_HEADSET_TYPE_CTIA)
			alc_headset_mode_ctia(codec);
		else if (spec->current_headset_type == ALC_HEADSET_TYPE_OMTP)
			alc_headset_mode_omtp(codec);
		spec->gen.hp_jack_present = true;
		break;
	case ALC_HEADSET_MODE_MIC:
		alc_headset_mode_mic_in(codec, hp_pin, spec->headphone_mic_pin);
		spec->gen.hp_jack_present = false;
		break;
	case ALC_HEADSET_MODE_HEADPHONE:
		alc_headset_mode_default(codec);
		spec->gen.hp_jack_present = true;
		break;
	}
	if (new_headset_mode != ALC_HEADSET_MODE_MIC) {
		snd_hda_set_pin_ctl_cache(codec, hp_pin,
					  AC_PINCTL_OUT_EN | AC_PINCTL_HP_EN);
4803
		if (spec->headphone_mic_pin && spec->headphone_mic_pin != hp_pin)
4804 4805 4806 4807 4808 4809 4810 4811 4812
			snd_hda_set_pin_ctl_cache(codec, spec->headphone_mic_pin,
						  PIN_VREFHIZ);
	}
	spec->current_headset_mode = new_headset_mode;

	snd_hda_gen_update_outputs(codec);
}

static void alc_update_headset_mode_hook(struct hda_codec *codec,
4813 4814
					 struct snd_kcontrol *kcontrol,
					 struct snd_ctl_elem_value *ucontrol)
4815 4816 4817 4818
{
	alc_update_headset_mode(codec);
}

4819 4820
static void alc_update_headset_jack_cb(struct hda_codec *codec,
				       struct hda_jack_callback *jack)
4821 4822
{
	struct alc_spec *spec = codec->spec;
4823
	spec->current_headset_type = ALC_HEADSET_TYPE_UNKNOWN;
4824 4825 4826 4827 4828 4829 4830 4831 4832 4833 4834 4835 4836 4837 4838 4839 4840 4841 4842 4843 4844 4845 4846 4847 4848 4849 4850 4851 4852 4853 4854 4855 4856 4857 4858 4859 4860 4861 4862 4863 4864 4865 4866 4867 4868 4869 4870 4871 4872 4873 4874 4875
	snd_hda_gen_hp_automute(codec, jack);
}

static void alc_probe_headset_mode(struct hda_codec *codec)
{
	int i;
	struct alc_spec *spec = codec->spec;
	struct auto_pin_cfg *cfg = &spec->gen.autocfg;

	/* Find mic pins */
	for (i = 0; i < cfg->num_inputs; i++) {
		if (cfg->inputs[i].is_headset_mic && !spec->headset_mic_pin)
			spec->headset_mic_pin = cfg->inputs[i].pin;
		if (cfg->inputs[i].is_headphone_mic && !spec->headphone_mic_pin)
			spec->headphone_mic_pin = cfg->inputs[i].pin;
	}

	spec->gen.cap_sync_hook = alc_update_headset_mode_hook;
	spec->gen.automute_hook = alc_update_headset_mode;
	spec->gen.hp_automute_hook = alc_update_headset_jack_cb;
}

static void alc_fixup_headset_mode(struct hda_codec *codec,
				const struct hda_fixup *fix, int action)
{
	struct alc_spec *spec = codec->spec;

	switch (action) {
	case HDA_FIXUP_ACT_PRE_PROBE:
		spec->parse_flags |= HDA_PINCFG_HEADSET_MIC | HDA_PINCFG_HEADPHONE_MIC;
		break;
	case HDA_FIXUP_ACT_PROBE:
		alc_probe_headset_mode(codec);
		break;
	case HDA_FIXUP_ACT_INIT:
		spec->current_headset_mode = 0;
		alc_update_headset_mode(codec);
		break;
	}
}

static void alc_fixup_headset_mode_no_hp_mic(struct hda_codec *codec,
				const struct hda_fixup *fix, int action)
{
	if (action == HDA_FIXUP_ACT_PRE_PROBE) {
		struct alc_spec *spec = codec->spec;
		spec->parse_flags |= HDA_PINCFG_HEADSET_MIC;
	}
	else
		alc_fixup_headset_mode(codec, fix, action);
}

4876 4877 4878
static void alc255_set_default_jack_type(struct hda_codec *codec)
{
	/* Set to iphone type */
4879
	static struct coef_fw alc255fw[] = {
4880 4881 4882 4883 4884 4885 4886
		WRITE_COEF(0x1b, 0x880b),
		WRITE_COEF(0x45, 0xd089),
		WRITE_COEF(0x1b, 0x080b),
		WRITE_COEF(0x46, 0x0004),
		WRITE_COEF(0x1b, 0x0c0b),
		{}
	};
4887 4888 4889 4890 4891 4892 4893 4894 4895 4896 4897 4898
	static struct coef_fw alc256fw[] = {
		WRITE_COEF(0x1b, 0x884b),
		WRITE_COEF(0x45, 0xd089),
		WRITE_COEF(0x1b, 0x084b),
		WRITE_COEF(0x46, 0x0004),
		WRITE_COEF(0x1b, 0x0c4b),
		{}
	};
	switch (codec->core.vendor_id) {
	case 0x10ec0255:
		alc_process_coef_fw(codec, alc255fw);
		break;
4899
	case 0x10ec0236:
4900 4901 4902 4903
	case 0x10ec0256:
		alc_process_coef_fw(codec, alc256fw);
		break;
	}
4904 4905 4906
	msleep(30);
}

4907 4908 4909 4910
static void alc_fixup_headset_mode_alc255(struct hda_codec *codec,
				const struct hda_fixup *fix, int action)
{
	if (action == HDA_FIXUP_ACT_PRE_PROBE) {
4911
		alc255_set_default_jack_type(codec);
4912 4913 4914 4915
	}
	alc_fixup_headset_mode(codec, fix, action);
}

4916 4917 4918 4919 4920 4921 4922 4923 4924 4925 4926 4927
static void alc_fixup_headset_mode_alc255_no_hp_mic(struct hda_codec *codec,
				const struct hda_fixup *fix, int action)
{
	if (action == HDA_FIXUP_ACT_PRE_PROBE) {
		struct alc_spec *spec = codec->spec;
		spec->parse_flags |= HDA_PINCFG_HEADSET_MIC;
		alc255_set_default_jack_type(codec);
	} 
	else
		alc_fixup_headset_mode(codec, fix, action);
}

4928 4929 4930 4931 4932 4933 4934 4935 4936 4937 4938 4939 4940 4941 4942 4943 4944 4945 4946 4947 4948 4949 4950
static void alc288_update_headset_jack_cb(struct hda_codec *codec,
				       struct hda_jack_callback *jack)
{
	struct alc_spec *spec = codec->spec;
	int present;

	alc_update_headset_jack_cb(codec, jack);
	/* Headset Mic enable or disable, only for Dell Dino */
	present = spec->gen.hp_jack_present ? 0x40 : 0;
	snd_hda_codec_write(codec, 0x01, 0, AC_VERB_SET_GPIO_DATA,
				present);
}

static void alc_fixup_headset_mode_dell_alc288(struct hda_codec *codec,
				const struct hda_fixup *fix, int action)
{
	alc_fixup_headset_mode(codec, fix, action);
	if (action == HDA_FIXUP_ACT_PROBE) {
		struct alc_spec *spec = codec->spec;
		spec->gen.hp_automute_hook = alc288_update_headset_jack_cb;
	}
}

4951 4952 4953 4954 4955 4956 4957 4958 4959
static void alc_fixup_auto_mute_via_amp(struct hda_codec *codec,
					const struct hda_fixup *fix, int action)
{
	if (action == HDA_FIXUP_ACT_PRE_PROBE) {
		struct alc_spec *spec = codec->spec;
		spec->gen.auto_mute_via_amp = 1;
	}
}

4960 4961 4962 4963 4964 4965 4966
static void alc_no_shutup(struct hda_codec *codec)
{
}

static void alc_fixup_no_shutup(struct hda_codec *codec,
				const struct hda_fixup *fix, int action)
{
4967
	if (action == HDA_FIXUP_ACT_PROBE) {
4968 4969 4970 4971 4972
		struct alc_spec *spec = codec->spec;
		spec->shutup = alc_no_shutup;
	}
}

4973 4974 4975 4976 4977 4978 4979 4980 4981 4982
static void alc_fixup_disable_aamix(struct hda_codec *codec,
				    const struct hda_fixup *fix, int action)
{
	if (action == HDA_FIXUP_ACT_PRE_PROBE) {
		struct alc_spec *spec = codec->spec;
		/* Disable AA-loopback as it causes white noise */
		spec->gen.mixer_nid = 0;
	}
}

4983 4984 4985 4986 4987 4988 4989 4990 4991 4992 4993 4994
/* fixup for Thinkpad docks: add dock pins, avoid HP parser fixup */
static void alc_fixup_tpt440_dock(struct hda_codec *codec,
				  const struct hda_fixup *fix, int action)
{
	static const struct hda_pintbl pincfgs[] = {
		{ 0x16, 0x21211010 }, /* dock headphone */
		{ 0x19, 0x21a11010 }, /* dock mic */
		{ }
	};
	struct alc_spec *spec = codec->spec;

	if (action == HDA_FIXUP_ACT_PRE_PROBE) {
4995
		spec->shutup = alc_no_shutup; /* reduce click noise */
4996
		spec->reboot_notify = alc_d3_at_reboot; /* reduce noise */
4997 4998 4999 5000 5001 5002
		spec->parse_flags = HDA_PINCFG_NO_HP_FIXUP;
		codec->power_save_node = 0; /* avoid click noises */
		snd_hda_apply_pincfgs(codec, pincfgs);
	}
}

5003 5004 5005 5006 5007 5008 5009 5010 5011 5012 5013 5014
static void alc_fixup_tpt470_dock(struct hda_codec *codec,
				  const struct hda_fixup *fix, int action)
{
	static const struct hda_pintbl pincfgs[] = {
		{ 0x17, 0x21211010 }, /* dock headphone */
		{ 0x19, 0x21a11010 }, /* dock mic */
		{ }
	};
	struct alc_spec *spec = codec->spec;

	if (action == HDA_FIXUP_ACT_PRE_PROBE) {
		spec->parse_flags = HDA_PINCFG_NO_HP_FIXUP;
5015 5016
		snd_hda_apply_pincfgs(codec, pincfgs);
	} else if (action == HDA_FIXUP_ACT_INIT) {
5017 5018 5019 5020 5021 5022 5023 5024 5025
		/* Enable DOCK device */
		snd_hda_codec_write(codec, 0x17, 0,
			    AC_VERB_SET_CONFIG_DEFAULT_BYTES_3, 0);
		/* Enable DOCK device */
		snd_hda_codec_write(codec, 0x19, 0,
			    AC_VERB_SET_CONFIG_DEFAULT_BYTES_3, 0);
	}
}

5026
static void alc_shutup_dell_xps13(struct hda_codec *codec)
5027 5028
{
	struct alc_spec *spec = codec->spec;
5029
	int hp_pin = spec->gen.autocfg.hp_pins[0];
5030

5031 5032 5033 5034
	/* Prevent pop noises when headphones are plugged in */
	snd_hda_codec_write(codec, hp_pin, 0,
			    AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);
	msleep(20);
5035 5036 5037 5038 5039
}

static void alc_fixup_dell_xps13(struct hda_codec *codec,
				const struct hda_fixup *fix, int action)
{
5040 5041 5042
	struct alc_spec *spec = codec->spec;
	struct hda_input_mux *imux = &spec->gen.input_mux;
	int i;
5043

5044 5045 5046 5047 5048 5049 5050 5051
	switch (action) {
	case HDA_FIXUP_ACT_PRE_PROBE:
		/* mic pin 0x19 must be initialized with Vref Hi-Z, otherwise
		 * it causes a click noise at start up
		 */
		snd_hda_codec_set_pin_target(codec, 0x19, PIN_VREFHIZ);
		break;
	case HDA_FIXUP_ACT_PROBE:
5052
		spec->shutup = alc_shutup_dell_xps13;
5053 5054 5055 5056 5057 5058 5059 5060

		/* Make the internal mic the default input source. */
		for (i = 0; i < imux->num_items; i++) {
			if (spec->gen.imux_pins[i] == 0x12) {
				spec->gen.cur_mux[0] = i;
				break;
			}
		}
5061
		break;
5062 5063 5064
	}
}

5065 5066 5067 5068 5069 5070 5071 5072
static void alc_fixup_headset_mode_alc662(struct hda_codec *codec,
				const struct hda_fixup *fix, int action)
{
	struct alc_spec *spec = codec->spec;

	if (action == HDA_FIXUP_ACT_PRE_PROBE) {
		spec->parse_flags |= HDA_PINCFG_HEADSET_MIC;
		spec->gen.hp_mic = 1; /* Mic-in is same pin as headphone */
5073 5074 5075 5076 5077

		/* Disable boost for mic-in permanently. (This code is only called
		   from quirks that guarantee that the headphone is at NID 0x1b.) */
		snd_hda_codec_write(codec, 0x1b, 0, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000);
		snd_hda_override_wcaps(codec, 0x1b, get_wcaps(codec, 0x1b) & ~AC_WCAP_IN_AMP);
5078 5079 5080 5081
	} else
		alc_fixup_headset_mode(codec, fix, action);
}

5082 5083 5084 5085 5086
static void alc_fixup_headset_mode_alc668(struct hda_codec *codec,
				const struct hda_fixup *fix, int action)
{
	if (action == HDA_FIXUP_ACT_PRE_PROBE) {
		alc_write_coef_idx(codec, 0xc4, 0x8000);
5087
		alc_update_coef_idx(codec, 0xc2, ~0xfe, 0);
5088 5089 5090 5091 5092
		snd_hda_set_pin_ctl_cache(codec, 0x18, 0);
	}
	alc_fixup_headset_mode(codec, fix, action);
}

5093 5094 5095 5096 5097 5098 5099 5100 5101 5102 5103 5104 5105 5106 5107 5108 5109 5110 5111 5112 5113 5114
/* Returns the nid of the external mic input pin, or 0 if it cannot be found. */
static int find_ext_mic_pin(struct hda_codec *codec)
{
	struct alc_spec *spec = codec->spec;
	struct auto_pin_cfg *cfg = &spec->gen.autocfg;
	hda_nid_t nid;
	unsigned int defcfg;
	int i;

	for (i = 0; i < cfg->num_inputs; i++) {
		if (cfg->inputs[i].type != AUTO_PIN_MIC)
			continue;
		nid = cfg->inputs[i].pin;
		defcfg = snd_hda_codec_get_pincfg(codec, nid);
		if (snd_hda_get_input_pin_attr(defcfg) == INPUT_PIN_ATTR_INT)
			continue;
		return nid;
	}

	return 0;
}

5115
static void alc271_hp_gate_mic_jack(struct hda_codec *codec,
5116
				    const struct hda_fixup *fix,
5117 5118 5119 5120
				    int action)
{
	struct alc_spec *spec = codec->spec;

5121
	if (action == HDA_FIXUP_ACT_PROBE) {
5122 5123 5124 5125
		int mic_pin = find_ext_mic_pin(codec);
		int hp_pin = spec->gen.autocfg.hp_pins[0];

		if (snd_BUG_ON(!mic_pin || !hp_pin))
5126
			return;
5127
		snd_hda_jack_set_gating_jack(codec, mic_pin, hp_pin);
5128
	}
5129
}
5130

5131 5132 5133 5134 5135 5136 5137 5138 5139 5140 5141 5142 5143 5144 5145 5146 5147 5148 5149 5150 5151 5152 5153 5154 5155 5156 5157 5158 5159 5160 5161 5162
static void alc269_fixup_limit_int_mic_boost(struct hda_codec *codec,
					     const struct hda_fixup *fix,
					     int action)
{
	struct alc_spec *spec = codec->spec;
	struct auto_pin_cfg *cfg = &spec->gen.autocfg;
	int i;

	/* The mic boosts on level 2 and 3 are too noisy
	   on the internal mic input.
	   Therefore limit the boost to 0 or 1. */

	if (action != HDA_FIXUP_ACT_PROBE)
		return;

	for (i = 0; i < cfg->num_inputs; i++) {
		hda_nid_t nid = cfg->inputs[i].pin;
		unsigned int defcfg;
		if (cfg->inputs[i].type != AUTO_PIN_MIC)
			continue;
		defcfg = snd_hda_codec_get_pincfg(codec, nid);
		if (snd_hda_get_input_pin_attr(defcfg) != INPUT_PIN_ATTR_INT)
			continue;

		snd_hda_override_amp_caps(codec, nid, HDA_INPUT,
					  (0x00 << AC_AMPCAP_OFFSET_SHIFT) |
					  (0x01 << AC_AMPCAP_NUM_STEPS_SHIFT) |
					  (0x2f << AC_AMPCAP_STEP_SIZE_SHIFT) |
					  (0 << AC_AMPCAP_MUTE_SHIFT));
	}
}

5163
static void alc283_hp_automute_hook(struct hda_codec *codec,
5164
				    struct hda_jack_callback *jack)
5165 5166 5167 5168 5169 5170 5171 5172 5173 5174 5175 5176 5177 5178 5179 5180 5181 5182 5183 5184 5185
{
	struct alc_spec *spec = codec->spec;
	int vref;

	msleep(200);
	snd_hda_gen_hp_automute(codec, jack);

	vref = spec->gen.hp_jack_present ? PIN_VREF80 : 0;

	msleep(600);
	snd_hda_codec_write(codec, 0x19, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
			    vref);
}

static void alc283_fixup_chromebook(struct hda_codec *codec,
				    const struct hda_fixup *fix, int action)
{
	struct alc_spec *spec = codec->spec;

	switch (action) {
	case HDA_FIXUP_ACT_PRE_PROBE:
5186
		snd_hda_override_wcaps(codec, 0x03, 0);
5187 5188
		/* Disable AA-loopback as it causes white noise */
		spec->gen.mixer_nid = 0;
5189
		break;
5190
	case HDA_FIXUP_ACT_INIT:
5191 5192
		/* MIC2-VREF control */
		/* Set to manual mode */
5193
		alc_update_coef_idx(codec, 0x06, 0x000c, 0);
5194
		/* Enable Line1 input control by verb */
5195
		alc_update_coef_idx(codec, 0x1a, 0, 1 << 4);
5196 5197 5198 5199 5200 5201 5202 5203 5204 5205 5206
		break;
	}
}

static void alc283_fixup_sense_combo_jack(struct hda_codec *codec,
				    const struct hda_fixup *fix, int action)
{
	struct alc_spec *spec = codec->spec;

	switch (action) {
	case HDA_FIXUP_ACT_PRE_PROBE:
5207
		spec->gen.hp_automute_hook = alc283_hp_automute_hook;
5208 5209
		break;
	case HDA_FIXUP_ACT_INIT:
5210 5211
		/* MIC2-VREF control */
		/* Set to manual mode */
5212
		alc_update_coef_idx(codec, 0x06, 0x000c, 0);
5213 5214 5215 5216
		break;
	}
}

5217 5218 5219 5220 5221 5222 5223 5224 5225 5226 5227 5228 5229 5230 5231 5232 5233 5234 5235 5236 5237 5238 5239 5240 5241 5242 5243 5244 5245 5246 5247 5248 5249 5250 5251 5252 5253 5254
/* mute tablet speaker pin (0x14) via dock plugging in addition */
static void asus_tx300_automute(struct hda_codec *codec)
{
	struct alc_spec *spec = codec->spec;
	snd_hda_gen_update_outputs(codec);
	if (snd_hda_jack_detect(codec, 0x1b))
		spec->gen.mute_bits |= (1ULL << 0x14);
}

static void alc282_fixup_asus_tx300(struct hda_codec *codec,
				    const struct hda_fixup *fix, int action)
{
	struct alc_spec *spec = codec->spec;
	/* TX300 needs to set up GPIO2 for the speaker amp */
	static const struct hda_verb gpio2_verbs[] = {
		{ 0x01, AC_VERB_SET_GPIO_MASK, 0x04 },
		{ 0x01, AC_VERB_SET_GPIO_DIRECTION, 0x04 },
		{ 0x01, AC_VERB_SET_GPIO_DATA, 0x04 },
		{}
	};
	static const struct hda_pintbl dock_pins[] = {
		{ 0x1b, 0x21114000 }, /* dock speaker pin */
		{}
	};

	switch (action) {
	case HDA_FIXUP_ACT_PRE_PROBE:
		snd_hda_add_verbs(codec, gpio2_verbs);
		snd_hda_apply_pincfgs(codec, dock_pins);
		spec->gen.auto_mute_via_amp = 1;
		spec->gen.automute_hook = asus_tx300_automute;
		snd_hda_jack_detect_enable_callback(codec, 0x1b,
						    snd_hda_gen_hp_automute);
		break;
	case HDA_FIXUP_ACT_BUILD:
		/* this is a bit tricky; give more sane names for the main
		 * (tablet) speaker and the dock speaker, respectively
		 */
5255 5256 5257 5258
		rename_ctl(codec, "Speaker Playback Switch",
			   "Dock Speaker Playback Switch");
		rename_ctl(codec, "Bass Speaker Playback Switch",
			   "Speaker Playback Switch");
5259 5260 5261 5262
		break;
	}
}

5263 5264 5265
static void alc290_fixup_mono_speakers(struct hda_codec *codec,
				       const struct hda_fixup *fix, int action)
{
5266 5267 5268 5269 5270 5271 5272 5273
	if (action == HDA_FIXUP_ACT_PRE_PROBE) {
		/* DAC node 0x03 is giving mono output. We therefore want to
		   make sure 0x14 (front speaker) and 0x15 (headphones) use the
		   stereo DAC, while leaving 0x17 (bass speaker) for node 0x03. */
		hda_nid_t conn1[2] = { 0x0c };
		snd_hda_override_conn_list(codec, 0x14, 1, conn1);
		snd_hda_override_conn_list(codec, 0x15, 1, conn1);
	}
5274 5275
}

5276 5277 5278 5279 5280 5281 5282 5283 5284 5285 5286 5287 5288 5289 5290 5291
static void alc298_fixup_speaker_volume(struct hda_codec *codec,
					const struct hda_fixup *fix, int action)
{
	if (action == HDA_FIXUP_ACT_PRE_PROBE) {
		/* The speaker is routed to the Node 0x06 by a mistake, as a result
		   we can't adjust the speaker's volume since this node does not has
		   Amp-out capability. we change the speaker's route to:
		   Node 0x02 (Audio Output) -> Node 0x0c (Audio Mixer) -> Node 0x17 (
		   Pin Complex), since Node 0x02 has Amp-out caps, we can adjust
		   speaker's volume now. */

		hda_nid_t conn1[1] = { 0x0c };
		snd_hda_override_conn_list(codec, 0x17, 1, conn1);
	}
}

5292 5293 5294 5295 5296 5297 5298 5299 5300 5301
/* disable DAC3 (0x06) selection on NID 0x17 as it has no volume amp control */
static void alc295_fixup_disable_dac3(struct hda_codec *codec,
				      const struct hda_fixup *fix, int action)
{
	if (action == HDA_FIXUP_ACT_PRE_PROBE) {
		hda_nid_t conn[2] = { 0x02, 0x03 };
		snd_hda_override_conn_list(codec, 0x17, 2, conn);
	}
}

5302 5303 5304 5305 5306 5307 5308 5309 5310 5311 5312 5313 5314 5315 5316 5317 5318 5319 5320 5321 5322 5323 5324 5325 5326 5327 5328 5329 5330 5331 5332 5333 5334 5335 5336 5337 5338 5339 5340 5341 5342 5343 5344 5345 5346 5347 5348 5349 5350
/* Hook to update amp GPIO4 for automute */
static void alc280_hp_gpio4_automute_hook(struct hda_codec *codec,
					  struct hda_jack_callback *jack)
{
	struct alc_spec *spec = codec->spec;

	snd_hda_gen_hp_automute(codec, jack);
	/* mute_led_polarity is set to 0, so we pass inverted value here */
	alc_update_gpio_led(codec, 0x10, !spec->gen.hp_jack_present);
}

/* Manage GPIOs for HP EliteBook Folio 9480m.
 *
 * GPIO4 is the headphone amplifier power control
 * GPIO3 is the audio output mute indicator LED
 */

static void alc280_fixup_hp_9480m(struct hda_codec *codec,
				  const struct hda_fixup *fix,
				  int action)
{
	struct alc_spec *spec = codec->spec;
	static const struct hda_verb gpio_init[] = {
		{ 0x01, AC_VERB_SET_GPIO_MASK, 0x18 },
		{ 0x01, AC_VERB_SET_GPIO_DIRECTION, 0x18 },
		{}
	};

	if (action == HDA_FIXUP_ACT_PRE_PROBE) {
		/* Set the hooks to turn the headphone amp on/off
		 * as needed
		 */
		spec->gen.vmaster_mute.hook = alc_fixup_gpio_mute_hook;
		spec->gen.hp_automute_hook = alc280_hp_gpio4_automute_hook;

		/* The GPIOs are currently off */
		spec->gpio_led = 0;

		/* GPIO3 is connected to the output mute LED,
		 * high is on, low is off
		 */
		spec->mute_led_polarity = 0;
		spec->gpio_mute_led_mask = 0x08;

		/* Initialize GPIO configuration */
		snd_hda_add_verbs(codec, gpio_init);
	}
}

5351 5352 5353 5354 5355 5356 5357 5358 5359 5360 5361 5362 5363 5364 5365 5366 5367 5368 5369 5370 5371 5372 5373 5374
static void alc233_alc662_fixup_lenovo_dual_codecs(struct hda_codec *codec,
					 const struct hda_fixup *fix,
					 int action)
{
	alc_fixup_dual_codecs(codec, fix, action);
	switch (action) {
	case HDA_FIXUP_ACT_PRE_PROBE:
		/* override card longname to provide a unique UCM profile */
		strcpy(codec->card->longname, "HDAudio-Lenovo-DualCodecs");
		break;
	case HDA_FIXUP_ACT_BUILD:
		/* rename Capture controls depending on the codec */
		rename_ctl(codec, "Capture Volume",
			   codec->addr == 0 ?
			   "Rear-Panel Capture Volume" :
			   "Front-Panel Capture Volume");
		rename_ctl(codec, "Capture Switch",
			   codec->addr == 0 ?
			   "Rear-Panel Capture Switch" :
			   "Front-Panel Capture Switch");
		break;
	}
}

5375 5376 5377 5378 5379 5380 5381 5382 5383 5384 5385 5386 5387 5388 5389 5390
/* Forcibly assign NID 0x03 to HP/LO while NID 0x02 to SPK for EQ */
static void alc274_fixup_bind_dacs(struct hda_codec *codec,
				    const struct hda_fixup *fix, int action)
{
	struct alc_spec *spec = codec->spec;
	static hda_nid_t preferred_pairs[] = {
		0x21, 0x03, 0x1b, 0x03, 0x16, 0x02,
		0
	};

	if (action != HDA_FIXUP_ACT_PRE_PROBE)
		return;

	spec->gen.preferred_dacs = preferred_pairs;
}

5391 5392
/* for hda_fixup_thinkpad_acpi() */
#include "thinkpad_helper.c"
5393

5394 5395 5396
/* for dell wmi mic mute led */
#include "dell_wmi_helper.c"

5397 5398 5399
/* for alc295_fixup_hp_top_speakers */
#include "hp_x360_helper.c"

5400 5401 5402 5403 5404 5405 5406 5407
enum {
	ALC269_FIXUP_SONY_VAIO,
	ALC275_FIXUP_SONY_VAIO_GPIO2,
	ALC269_FIXUP_DELL_M101Z,
	ALC269_FIXUP_SKU_IGNORE,
	ALC269_FIXUP_ASUS_G73JW,
	ALC269_FIXUP_LENOVO_EAPD,
	ALC275_FIXUP_SONY_HWEQ,
5408
	ALC275_FIXUP_SONY_DISABLE_AAMIX,
5409
	ALC271_FIXUP_DMIC,
5410
	ALC269_FIXUP_PCM_44K,
5411
	ALC269_FIXUP_STEREO_DMIC,
5412
	ALC269_FIXUP_HEADSET_MIC,
5413 5414
	ALC269_FIXUP_QUANTA_MUTE,
	ALC269_FIXUP_LIFEBOOK,
5415
	ALC269_FIXUP_LIFEBOOK_EXTMIC,
5416
	ALC269_FIXUP_LIFEBOOK_HP_PIN,
5417
	ALC269_FIXUP_LIFEBOOK_NO_HP_TO_LINEOUT,
5418
	ALC255_FIXUP_LIFEBOOK_U7x7_HEADSET_MIC,
5419 5420 5421 5422
	ALC269_FIXUP_AMIC,
	ALC269_FIXUP_DMIC,
	ALC269VB_FIXUP_AMIC,
	ALC269VB_FIXUP_DMIC,
5423
	ALC269_FIXUP_HP_MUTE_LED,
5424
	ALC269_FIXUP_HP_MUTE_LED_MIC1,
5425
	ALC269_FIXUP_HP_MUTE_LED_MIC2,
5426
	ALC269_FIXUP_HP_MUTE_LED_MIC3,
5427
	ALC269_FIXUP_HP_GPIO_LED,
5428 5429
	ALC269_FIXUP_HP_GPIO_MIC1_LED,
	ALC269_FIXUP_HP_LINE1_MIC1_LED,
5430
	ALC269_FIXUP_INV_DMIC,
5431
	ALC269_FIXUP_LENOVO_DOCK,
5432
	ALC269_FIXUP_NO_SHUTUP,
5433
	ALC286_FIXUP_SONY_MIC_NO_PRESENCE,
5434
	ALC269_FIXUP_PINCFG_NO_HP_TO_LINEOUT,
5435 5436
	ALC269_FIXUP_DELL1_MIC_NO_PRESENCE,
	ALC269_FIXUP_DELL2_MIC_NO_PRESENCE,
5437
	ALC269_FIXUP_DELL3_MIC_NO_PRESENCE,
5438
	ALC269_FIXUP_DELL4_MIC_NO_PRESENCE,
5439 5440
	ALC269_FIXUP_HEADSET_MODE,
	ALC269_FIXUP_HEADSET_MODE_NO_HP_MIC,
5441
	ALC269_FIXUP_ASPIRE_HEADSET_MIC,
5442 5443 5444
	ALC269_FIXUP_ASUS_X101_FUNC,
	ALC269_FIXUP_ASUS_X101_VERB,
	ALC269_FIXUP_ASUS_X101,
5445 5446
	ALC271_FIXUP_AMIC_MIC2,
	ALC271_FIXUP_HP_GATE_MIC_JACK,
5447
	ALC271_FIXUP_HP_GATE_MIC_JACK_E1_572,
5448
	ALC269_FIXUP_ACER_AC700,
5449
	ALC269_FIXUP_LIMIT_INT_MIC_BOOST,
5450
	ALC269VB_FIXUP_ASUS_ZENBOOK,
5451
	ALC269VB_FIXUP_ASUS_ZENBOOK_UX31A,
5452
	ALC269_FIXUP_LIMIT_INT_MIC_BOOST_MUTE_LED,
5453
	ALC269VB_FIXUP_ORDISSIMO_EVE2,
5454
	ALC283_FIXUP_CHROME_BOOK,
5455
	ALC283_FIXUP_SENSE_COMBO_JACK,
5456
	ALC282_FIXUP_ASUS_TX300,
5457
	ALC283_FIXUP_INT_MIC,
5458
	ALC290_FIXUP_MONO_SPEAKERS,
5459 5460 5461
	ALC290_FIXUP_MONO_SPEAKERS_HSJACK,
	ALC290_FIXUP_SUBWOOFER,
	ALC290_FIXUP_SUBWOOFER_HSJACK,
5462
	ALC269_FIXUP_THINKPAD_ACPI,
5463
	ALC269_FIXUP_DMIC_THINKPAD_ACPI,
5464
	ALC255_FIXUP_ACER_MIC_NO_PRESENCE,
5465
	ALC255_FIXUP_ASUS_MIC_NO_PRESENCE,
5466
	ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
5467
	ALC255_FIXUP_DELL2_MIC_NO_PRESENCE,
5468
	ALC255_FIXUP_HEADSET_MODE,
5469
	ALC255_FIXUP_HEADSET_MODE_NO_HP_MIC,
5470
	ALC293_FIXUP_DELL1_MIC_NO_PRESENCE,
5471
	ALC292_FIXUP_TPT440_DOCK,
5472
	ALC292_FIXUP_TPT440,
5473
	ALC283_FIXUP_HEADSET_MIC,
5474
	ALC255_FIXUP_DELL_WMI_MIC_MUTE_LED,
5475
	ALC282_FIXUP_ASPIRE_V5_PINS,
5476
	ALC280_FIXUP_HP_GPIO4,
5477
	ALC286_FIXUP_HP_GPIO_LED,
5478
	ALC280_FIXUP_HP_GPIO2_MIC_HOTKEY,
5479
	ALC280_FIXUP_HP_DOCK_PINS,
5480
	ALC269_FIXUP_HP_DOCK_GPIO_MIC1_LED,
5481
	ALC280_FIXUP_HP_9480M,
5482 5483 5484
	ALC288_FIXUP_DELL_HEADSET_MODE,
	ALC288_FIXUP_DELL1_MIC_NO_PRESENCE,
	ALC288_FIXUP_DELL_XPS_13_GPIO6,
5485 5486
	ALC288_FIXUP_DELL_XPS_13,
	ALC288_FIXUP_DISABLE_AAMIX,
5487 5488
	ALC292_FIXUP_DELL_E7X,
	ALC292_FIXUP_DISABLE_AAMIX,
5489
	ALC293_FIXUP_DISABLE_AAMIX_MULTIJACK,
5490
	ALC298_FIXUP_DELL1_MIC_NO_PRESENCE,
5491
	ALC298_FIXUP_DELL_AIO_MIC_NO_PRESENCE,
5492
	ALC275_FIXUP_DELL_XPS,
5493
	ALC256_FIXUP_DELL_XPS_13_HEADPHONE_NOISE,
5494
	ALC293_FIXUP_LENOVO_SPK_NOISE,
5495
	ALC233_FIXUP_LENOVO_LINE2_MIC_HOTKEY,
5496
	ALC255_FIXUP_DELL_SPK_NOISE,
5497
	ALC225_FIXUP_DELL1_MIC_NO_PRESENCE,
5498
	ALC295_FIXUP_DISABLE_DAC3,
5499
	ALC280_FIXUP_HP_HEADSET_MIC,
5500
	ALC221_FIXUP_HP_FRONT_MIC,
5501
	ALC292_FIXUP_TPT460,
5502
	ALC298_FIXUP_SPK_VOLUME,
5503
	ALC256_FIXUP_DELL_INSPIRON_7559_SUBWOOFER,
5504
	ALC269_FIXUP_ATIV_BOOK_8,
5505
	ALC221_FIXUP_HP_MIC_NO_PRESENCE,
5506 5507
	ALC256_FIXUP_ASUS_HEADSET_MODE,
	ALC256_FIXUP_ASUS_MIC,
5508
	ALC256_FIXUP_ASUS_AIO_GPIO2,
5509 5510
	ALC233_FIXUP_ASUS_MIC_NO_PRESENCE,
	ALC233_FIXUP_EAPD_COEF_AND_MIC_NO_PRESENCE,
5511
	ALC233_FIXUP_LENOVO_MULTI_CODECS,
5512
	ALC294_FIXUP_LENOVO_MIC_LOCATION,
5513
	ALC225_FIXUP_DELL_WYSE_MIC_NO_PRESENCE,
5514
	ALC700_FIXUP_INTEL_REFERENCE,
5515 5516
	ALC274_FIXUP_DELL_BIND_DACS,
	ALC274_FIXUP_DELL_AIO_LINEOUT_VERB,
5517
	ALC298_FIXUP_TPT470_DOCK,
5518
	ALC255_FIXUP_DUMMY_LINEOUT_VERB,
5519
	ALC255_FIXUP_DELL_HEADSET_MIC,
5520
	ALC295_FIXUP_HP_X360,
5521 5522
};

5523
static const struct hda_fixup alc269_fixups[] = {
5524
	[ALC269_FIXUP_SONY_VAIO] = {
5525 5526 5527
		.type = HDA_FIXUP_PINCTLS,
		.v.pins = (const struct hda_pintbl[]) {
			{0x19, PIN_VREFGRD},
5528 5529
			{}
		}
5530
	},
5531
	[ALC275_FIXUP_SONY_VAIO_GPIO2] = {
5532
		.type = HDA_FIXUP_VERBS,
5533 5534 5535 5536 5537 5538 5539 5540 5541 5542
		.v.verbs = (const struct hda_verb[]) {
			{0x01, AC_VERB_SET_GPIO_MASK, 0x04},
			{0x01, AC_VERB_SET_GPIO_DIRECTION, 0x04},
			{0x01, AC_VERB_SET_GPIO_DATA, 0x00},
			{ }
		},
		.chained = true,
		.chain_id = ALC269_FIXUP_SONY_VAIO
	},
	[ALC269_FIXUP_DELL_M101Z] = {
5543
		.type = HDA_FIXUP_VERBS,
5544 5545 5546 5547 5548 5549 5550 5551
		.v.verbs = (const struct hda_verb[]) {
			/* Enables internal speaker */
			{0x20, AC_VERB_SET_COEF_INDEX, 13},
			{0x20, AC_VERB_SET_PROC_COEF, 0x4040},
			{}
		}
	},
	[ALC269_FIXUP_SKU_IGNORE] = {
5552
		.type = HDA_FIXUP_FUNC,
5553
		.v.func = alc_fixup_sku_ignore,
5554 5555
	},
	[ALC269_FIXUP_ASUS_G73JW] = {
5556 5557
		.type = HDA_FIXUP_PINS,
		.v.pins = (const struct hda_pintbl[]) {
5558 5559 5560 5561 5562
			{ 0x17, 0x99130111 }, /* subwoofer */
			{ }
		}
	},
	[ALC269_FIXUP_LENOVO_EAPD] = {
5563
		.type = HDA_FIXUP_VERBS,
5564 5565 5566 5567 5568 5569
		.v.verbs = (const struct hda_verb[]) {
			{0x14, AC_VERB_SET_EAPD_BTLENABLE, 0},
			{}
		}
	},
	[ALC275_FIXUP_SONY_HWEQ] = {
5570
		.type = HDA_FIXUP_FUNC,
5571 5572 5573 5574
		.v.func = alc269_fixup_hweq,
		.chained = true,
		.chain_id = ALC275_FIXUP_SONY_VAIO_GPIO2
	},
5575 5576 5577 5578 5579 5580
	[ALC275_FIXUP_SONY_DISABLE_AAMIX] = {
		.type = HDA_FIXUP_FUNC,
		.v.func = alc_fixup_disable_aamix,
		.chained = true,
		.chain_id = ALC269_FIXUP_SONY_VAIO
	},
5581
	[ALC271_FIXUP_DMIC] = {
5582
		.type = HDA_FIXUP_FUNC,
5583
		.v.func = alc271_fixup_dmic,
5584
	},
5585
	[ALC269_FIXUP_PCM_44K] = {
5586
		.type = HDA_FIXUP_FUNC,
5587
		.v.func = alc269_fixup_pcm_44k,
5588 5589
		.chained = true,
		.chain_id = ALC269_FIXUP_QUANTA_MUTE
5590
	},
5591
	[ALC269_FIXUP_STEREO_DMIC] = {
5592
		.type = HDA_FIXUP_FUNC,
5593 5594
		.v.func = alc269_fixup_stereo_dmic,
	},
5595 5596 5597 5598
	[ALC269_FIXUP_HEADSET_MIC] = {
		.type = HDA_FIXUP_FUNC,
		.v.func = alc269_fixup_headset_mic,
	},
5599
	[ALC269_FIXUP_QUANTA_MUTE] = {
5600
		.type = HDA_FIXUP_FUNC,
5601 5602 5603
		.v.func = alc269_fixup_quanta_mute,
	},
	[ALC269_FIXUP_LIFEBOOK] = {
5604 5605
		.type = HDA_FIXUP_PINS,
		.v.pins = (const struct hda_pintbl[]) {
5606 5607 5608 5609 5610 5611 5612
			{ 0x1a, 0x2101103f }, /* dock line-out */
			{ 0x1b, 0x23a11040 }, /* dock mic-in */
			{ }
		},
		.chained = true,
		.chain_id = ALC269_FIXUP_QUANTA_MUTE
	},
5613 5614 5615 5616 5617 5618 5619
	[ALC269_FIXUP_LIFEBOOK_EXTMIC] = {
		.type = HDA_FIXUP_PINS,
		.v.pins = (const struct hda_pintbl[]) {
			{ 0x19, 0x01a1903c }, /* headset mic, with jack detect */
			{ }
		},
	},
5620 5621 5622 5623 5624 5625 5626
	[ALC269_FIXUP_LIFEBOOK_HP_PIN] = {
		.type = HDA_FIXUP_PINS,
		.v.pins = (const struct hda_pintbl[]) {
			{ 0x21, 0x0221102f }, /* HP out */
			{ }
		},
	},
5627 5628 5629 5630
	[ALC269_FIXUP_LIFEBOOK_NO_HP_TO_LINEOUT] = {
		.type = HDA_FIXUP_FUNC,
		.v.func = alc269_fixup_pincfg_no_hp_to_lineout,
	},
5631 5632 5633 5634
	[ALC255_FIXUP_LIFEBOOK_U7x7_HEADSET_MIC] = {
		.type = HDA_FIXUP_FUNC,
		.v.func = alc269_fixup_pincfg_U7x7_headset_mic,
	},
5635
	[ALC269_FIXUP_AMIC] = {
5636 5637
		.type = HDA_FIXUP_PINS,
		.v.pins = (const struct hda_pintbl[]) {
5638 5639 5640 5641 5642 5643 5644 5645
			{ 0x14, 0x99130110 }, /* speaker */
			{ 0x15, 0x0121401f }, /* HP out */
			{ 0x18, 0x01a19c20 }, /* mic */
			{ 0x19, 0x99a3092f }, /* int-mic */
			{ }
		},
	},
	[ALC269_FIXUP_DMIC] = {
5646 5647
		.type = HDA_FIXUP_PINS,
		.v.pins = (const struct hda_pintbl[]) {
5648 5649 5650 5651 5652 5653 5654 5655
			{ 0x12, 0x99a3092f }, /* int-mic */
			{ 0x14, 0x99130110 }, /* speaker */
			{ 0x15, 0x0121401f }, /* HP out */
			{ 0x18, 0x01a19c20 }, /* mic */
			{ }
		},
	},
	[ALC269VB_FIXUP_AMIC] = {
5656 5657
		.type = HDA_FIXUP_PINS,
		.v.pins = (const struct hda_pintbl[]) {
5658 5659 5660 5661 5662 5663 5664
			{ 0x14, 0x99130110 }, /* speaker */
			{ 0x18, 0x01a19c20 }, /* mic */
			{ 0x19, 0x99a3092f }, /* int-mic */
			{ 0x21, 0x0121401f }, /* HP out */
			{ }
		},
	},
5665
	[ALC269VB_FIXUP_DMIC] = {
5666 5667
		.type = HDA_FIXUP_PINS,
		.v.pins = (const struct hda_pintbl[]) {
5668 5669 5670 5671 5672 5673 5674
			{ 0x12, 0x99a3092f }, /* int-mic */
			{ 0x14, 0x99130110 }, /* speaker */
			{ 0x18, 0x01a19c20 }, /* mic */
			{ 0x21, 0x0121401f }, /* HP out */
			{ }
		},
	},
5675
	[ALC269_FIXUP_HP_MUTE_LED] = {
5676
		.type = HDA_FIXUP_FUNC,
5677
		.v.func = alc269_fixup_hp_mute_led,
5678
	},
5679 5680 5681 5682
	[ALC269_FIXUP_HP_MUTE_LED_MIC1] = {
		.type = HDA_FIXUP_FUNC,
		.v.func = alc269_fixup_hp_mute_led_mic1,
	},
5683
	[ALC269_FIXUP_HP_MUTE_LED_MIC2] = {
5684
		.type = HDA_FIXUP_FUNC,
5685
		.v.func = alc269_fixup_hp_mute_led_mic2,
5686
	},
5687 5688 5689 5690
	[ALC269_FIXUP_HP_MUTE_LED_MIC3] = {
		.type = HDA_FIXUP_FUNC,
		.v.func = alc269_fixup_hp_mute_led_mic3,
	},
5691 5692 5693 5694
	[ALC269_FIXUP_HP_GPIO_LED] = {
		.type = HDA_FIXUP_FUNC,
		.v.func = alc269_fixup_hp_gpio_led,
	},
5695 5696 5697 5698 5699 5700 5701 5702
	[ALC269_FIXUP_HP_GPIO_MIC1_LED] = {
		.type = HDA_FIXUP_FUNC,
		.v.func = alc269_fixup_hp_gpio_mic1_led,
	},
	[ALC269_FIXUP_HP_LINE1_MIC1_LED] = {
		.type = HDA_FIXUP_FUNC,
		.v.func = alc269_fixup_hp_line1_mic1_led,
	},
5703
	[ALC269_FIXUP_INV_DMIC] = {
5704
		.type = HDA_FIXUP_FUNC,
5705
		.v.func = alc_fixup_inv_dmic,
5706
	},
5707 5708 5709 5710
	[ALC269_FIXUP_NO_SHUTUP] = {
		.type = HDA_FIXUP_FUNC,
		.v.func = alc_fixup_no_shutup,
	},
5711
	[ALC269_FIXUP_LENOVO_DOCK] = {
5712 5713
		.type = HDA_FIXUP_PINS,
		.v.pins = (const struct hda_pintbl[]) {
5714 5715 5716 5717 5718 5719 5720 5721
			{ 0x19, 0x23a11040 }, /* dock mic */
			{ 0x1b, 0x2121103f }, /* dock headphone */
			{ }
		},
		.chained = true,
		.chain_id = ALC269_FIXUP_PINCFG_NO_HP_TO_LINEOUT
	},
	[ALC269_FIXUP_PINCFG_NO_HP_TO_LINEOUT] = {
5722
		.type = HDA_FIXUP_FUNC,
5723
		.v.func = alc269_fixup_pincfg_no_hp_to_lineout,
5724 5725
		.chained = true,
		.chain_id = ALC269_FIXUP_THINKPAD_ACPI,
5726
	},
5727 5728 5729 5730 5731 5732 5733 5734 5735 5736 5737 5738 5739 5740 5741 5742 5743 5744 5745 5746 5747
	[ALC269_FIXUP_DELL1_MIC_NO_PRESENCE] = {
		.type = HDA_FIXUP_PINS,
		.v.pins = (const struct hda_pintbl[]) {
			{ 0x19, 0x01a1913c }, /* use as headset mic, without its own jack detect */
			{ 0x1a, 0x01a1913d }, /* use as headphone mic, without its own jack detect */
			{ }
		},
		.chained = true,
		.chain_id = ALC269_FIXUP_HEADSET_MODE
	},
	[ALC269_FIXUP_DELL2_MIC_NO_PRESENCE] = {
		.type = HDA_FIXUP_PINS,
		.v.pins = (const struct hda_pintbl[]) {
			{ 0x16, 0x21014020 }, /* dock line out */
			{ 0x19, 0x21a19030 }, /* dock mic */
			{ 0x1a, 0x01a1913c }, /* use as headset mic, without its own jack detect */
			{ }
		},
		.chained = true,
		.chain_id = ALC269_FIXUP_HEADSET_MODE_NO_HP_MIC
	},
5748 5749 5750 5751 5752 5753 5754 5755 5756
	[ALC269_FIXUP_DELL3_MIC_NO_PRESENCE] = {
		.type = HDA_FIXUP_PINS,
		.v.pins = (const struct hda_pintbl[]) {
			{ 0x1a, 0x01a1913c }, /* use as headset mic, without its own jack detect */
			{ }
		},
		.chained = true,
		.chain_id = ALC269_FIXUP_HEADSET_MODE_NO_HP_MIC
	},
5757 5758 5759 5760 5761 5762 5763 5764 5765 5766
	[ALC269_FIXUP_DELL4_MIC_NO_PRESENCE] = {
		.type = HDA_FIXUP_PINS,
		.v.pins = (const struct hda_pintbl[]) {
			{ 0x19, 0x01a1913c }, /* use as headset mic, without its own jack detect */
			{ 0x1b, 0x01a1913d }, /* use as headphone mic, without its own jack detect */
			{ }
		},
		.chained = true,
		.chain_id = ALC269_FIXUP_HEADSET_MODE
	},
5767 5768 5769
	[ALC269_FIXUP_HEADSET_MODE] = {
		.type = HDA_FIXUP_FUNC,
		.v.func = alc_fixup_headset_mode,
5770 5771
		.chained = true,
		.chain_id = ALC255_FIXUP_DELL_WMI_MIC_MUTE_LED
5772 5773 5774 5775 5776
	},
	[ALC269_FIXUP_HEADSET_MODE_NO_HP_MIC] = {
		.type = HDA_FIXUP_FUNC,
		.v.func = alc_fixup_headset_mode_no_hp_mic,
	},
5777 5778 5779 5780 5781 5782 5783 5784 5785
	[ALC269_FIXUP_ASPIRE_HEADSET_MIC] = {
		.type = HDA_FIXUP_PINS,
		.v.pins = (const struct hda_pintbl[]) {
			{ 0x19, 0x01a1913c }, /* headset mic w/o jack detect */
			{ }
		},
		.chained = true,
		.chain_id = ALC269_FIXUP_HEADSET_MODE,
	},
5786 5787 5788 5789 5790 5791
	[ALC286_FIXUP_SONY_MIC_NO_PRESENCE] = {
		.type = HDA_FIXUP_PINS,
		.v.pins = (const struct hda_pintbl[]) {
			{ 0x18, 0x01a1913c }, /* use as headset mic, without its own jack detect */
			{ }
		},
5792 5793
		.chained = true,
		.chain_id = ALC269_FIXUP_HEADSET_MIC
5794
	},
5795 5796 5797 5798 5799 5800 5801 5802 5803 5804 5805 5806 5807 5808 5809 5810 5811 5812 5813 5814 5815 5816 5817 5818
	[ALC269_FIXUP_ASUS_X101_FUNC] = {
		.type = HDA_FIXUP_FUNC,
		.v.func = alc269_fixup_x101_headset_mic,
	},
	[ALC269_FIXUP_ASUS_X101_VERB] = {
		.type = HDA_FIXUP_VERBS,
		.v.verbs = (const struct hda_verb[]) {
			{0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
			{0x20, AC_VERB_SET_COEF_INDEX, 0x08},
			{0x20, AC_VERB_SET_PROC_COEF,  0x0310},
			{ }
		},
		.chained = true,
		.chain_id = ALC269_FIXUP_ASUS_X101_FUNC
	},
	[ALC269_FIXUP_ASUS_X101] = {
		.type = HDA_FIXUP_PINS,
		.v.pins = (const struct hda_pintbl[]) {
			{ 0x18, 0x04a1182c }, /* Headset mic */
			{ }
		},
		.chained = true,
		.chain_id = ALC269_FIXUP_ASUS_X101_VERB
	},
5819
	[ALC271_FIXUP_AMIC_MIC2] = {
5820 5821
		.type = HDA_FIXUP_PINS,
		.v.pins = (const struct hda_pintbl[]) {
5822 5823 5824 5825 5826 5827 5828 5829
			{ 0x14, 0x99130110 }, /* speaker */
			{ 0x19, 0x01a19c20 }, /* mic */
			{ 0x1b, 0x99a7012f }, /* int-mic */
			{ 0x21, 0x0121401f }, /* HP out */
			{ }
		},
	},
	[ALC271_FIXUP_HP_GATE_MIC_JACK] = {
5830
		.type = HDA_FIXUP_FUNC,
5831 5832 5833 5834
		.v.func = alc271_hp_gate_mic_jack,
		.chained = true,
		.chain_id = ALC271_FIXUP_AMIC_MIC2,
	},
5835 5836 5837 5838 5839 5840
	[ALC271_FIXUP_HP_GATE_MIC_JACK_E1_572] = {
		.type = HDA_FIXUP_FUNC,
		.v.func = alc269_fixup_limit_int_mic_boost,
		.chained = true,
		.chain_id = ALC271_FIXUP_HP_GATE_MIC_JACK,
	},
5841 5842 5843 5844 5845 5846 5847 5848 5849 5850 5851 5852 5853
	[ALC269_FIXUP_ACER_AC700] = {
		.type = HDA_FIXUP_PINS,
		.v.pins = (const struct hda_pintbl[]) {
			{ 0x12, 0x99a3092f }, /* int-mic */
			{ 0x14, 0x99130110 }, /* speaker */
			{ 0x18, 0x03a11c20 }, /* mic */
			{ 0x1e, 0x0346101e }, /* SPDIF1 */
			{ 0x21, 0x0321101f }, /* HP out */
			{ }
		},
		.chained = true,
		.chain_id = ALC271_FIXUP_DMIC,
	},
5854 5855 5856
	[ALC269_FIXUP_LIMIT_INT_MIC_BOOST] = {
		.type = HDA_FIXUP_FUNC,
		.v.func = alc269_fixup_limit_int_mic_boost,
5857 5858
		.chained = true,
		.chain_id = ALC269_FIXUP_THINKPAD_ACPI,
5859
	},
5860 5861 5862 5863 5864 5865
	[ALC269VB_FIXUP_ASUS_ZENBOOK] = {
		.type = HDA_FIXUP_FUNC,
		.v.func = alc269_fixup_limit_int_mic_boost,
		.chained = true,
		.chain_id = ALC269VB_FIXUP_DMIC,
	},
5866 5867 5868 5869 5870 5871 5872 5873 5874 5875 5876
	[ALC269VB_FIXUP_ASUS_ZENBOOK_UX31A] = {
		.type = HDA_FIXUP_VERBS,
		.v.verbs = (const struct hda_verb[]) {
			/* class-D output amp +5dB */
			{ 0x20, AC_VERB_SET_COEF_INDEX, 0x12 },
			{ 0x20, AC_VERB_SET_PROC_COEF, 0x2800 },
			{}
		},
		.chained = true,
		.chain_id = ALC269VB_FIXUP_ASUS_ZENBOOK,
	},
5877 5878 5879 5880 5881 5882
	[ALC269_FIXUP_LIMIT_INT_MIC_BOOST_MUTE_LED] = {
		.type = HDA_FIXUP_FUNC,
		.v.func = alc269_fixup_limit_int_mic_boost,
		.chained = true,
		.chain_id = ALC269_FIXUP_HP_MUTE_LED_MIC1,
	},
5883 5884 5885 5886 5887 5888 5889 5890 5891
	[ALC269VB_FIXUP_ORDISSIMO_EVE2] = {
		.type = HDA_FIXUP_PINS,
		.v.pins = (const struct hda_pintbl[]) {
			{ 0x12, 0x99a3092f }, /* int-mic */
			{ 0x18, 0x03a11d20 }, /* mic */
			{ 0x19, 0x411111f0 }, /* Unused bogus pin */
			{ }
		},
	},
5892 5893 5894 5895
	[ALC283_FIXUP_CHROME_BOOK] = {
		.type = HDA_FIXUP_FUNC,
		.v.func = alc283_fixup_chromebook,
	},
5896 5897 5898 5899 5900 5901
	[ALC283_FIXUP_SENSE_COMBO_JACK] = {
		.type = HDA_FIXUP_FUNC,
		.v.func = alc283_fixup_sense_combo_jack,
		.chained = true,
		.chain_id = ALC283_FIXUP_CHROME_BOOK,
	},
5902 5903 5904 5905
	[ALC282_FIXUP_ASUS_TX300] = {
		.type = HDA_FIXUP_FUNC,
		.v.func = alc282_fixup_asus_tx300,
	},
5906 5907 5908 5909 5910 5911 5912 5913 5914 5915
	[ALC283_FIXUP_INT_MIC] = {
		.type = HDA_FIXUP_VERBS,
		.v.verbs = (const struct hda_verb[]) {
			{0x20, AC_VERB_SET_COEF_INDEX, 0x1a},
			{0x20, AC_VERB_SET_PROC_COEF, 0x0011},
			{ }
		},
		.chained = true,
		.chain_id = ALC269_FIXUP_LIMIT_INT_MIC_BOOST
	},
5916 5917 5918 5919 5920 5921 5922 5923 5924 5925 5926 5927 5928 5929 5930 5931 5932 5933
	[ALC290_FIXUP_SUBWOOFER_HSJACK] = {
		.type = HDA_FIXUP_PINS,
		.v.pins = (const struct hda_pintbl[]) {
			{ 0x17, 0x90170112 }, /* subwoofer */
			{ }
		},
		.chained = true,
		.chain_id = ALC290_FIXUP_MONO_SPEAKERS_HSJACK,
	},
	[ALC290_FIXUP_SUBWOOFER] = {
		.type = HDA_FIXUP_PINS,
		.v.pins = (const struct hda_pintbl[]) {
			{ 0x17, 0x90170112 }, /* subwoofer */
			{ }
		},
		.chained = true,
		.chain_id = ALC290_FIXUP_MONO_SPEAKERS,
	},
5934 5935 5936
	[ALC290_FIXUP_MONO_SPEAKERS] = {
		.type = HDA_FIXUP_FUNC,
		.v.func = alc290_fixup_mono_speakers,
5937 5938 5939 5940
	},
	[ALC290_FIXUP_MONO_SPEAKERS_HSJACK] = {
		.type = HDA_FIXUP_FUNC,
		.v.func = alc290_fixup_mono_speakers,
5941 5942 5943
		.chained = true,
		.chain_id = ALC269_FIXUP_DELL3_MIC_NO_PRESENCE,
	},
5944 5945
	[ALC269_FIXUP_THINKPAD_ACPI] = {
		.type = HDA_FIXUP_FUNC,
5946
		.v.func = hda_fixup_thinkpad_acpi,
5947 5948
		.chained = true,
		.chain_id = ALC269_FIXUP_SKU_IGNORE,
5949
	},
5950 5951 5952 5953 5954 5955
	[ALC269_FIXUP_DMIC_THINKPAD_ACPI] = {
		.type = HDA_FIXUP_FUNC,
		.v.func = alc_fixup_inv_dmic,
		.chained = true,
		.chain_id = ALC269_FIXUP_THINKPAD_ACPI,
	},
5956 5957 5958 5959 5960 5961 5962 5963 5964
	[ALC255_FIXUP_ACER_MIC_NO_PRESENCE] = {
		.type = HDA_FIXUP_PINS,
		.v.pins = (const struct hda_pintbl[]) {
			{ 0x19, 0x01a1913c }, /* use as headset mic, without its own jack detect */
			{ }
		},
		.chained = true,
		.chain_id = ALC255_FIXUP_HEADSET_MODE
	},
5965 5966 5967 5968 5969 5970 5971 5972 5973
	[ALC255_FIXUP_ASUS_MIC_NO_PRESENCE] = {
		.type = HDA_FIXUP_PINS,
		.v.pins = (const struct hda_pintbl[]) {
			{ 0x19, 0x01a1913c }, /* use as headset mic, without its own jack detect */
			{ }
		},
		.chained = true,
		.chain_id = ALC255_FIXUP_HEADSET_MODE
	},
5974 5975 5976 5977 5978 5979 5980 5981 5982 5983
	[ALC255_FIXUP_DELL1_MIC_NO_PRESENCE] = {
		.type = HDA_FIXUP_PINS,
		.v.pins = (const struct hda_pintbl[]) {
			{ 0x19, 0x01a1913c }, /* use as headset mic, without its own jack detect */
			{ 0x1a, 0x01a1913d }, /* use as headphone mic, without its own jack detect */
			{ }
		},
		.chained = true,
		.chain_id = ALC255_FIXUP_HEADSET_MODE
	},
5984 5985 5986 5987 5988 5989 5990 5991 5992
	[ALC255_FIXUP_DELL2_MIC_NO_PRESENCE] = {
		.type = HDA_FIXUP_PINS,
		.v.pins = (const struct hda_pintbl[]) {
			{ 0x19, 0x01a1913c }, /* use as headset mic, without its own jack detect */
			{ }
		},
		.chained = true,
		.chain_id = ALC255_FIXUP_HEADSET_MODE_NO_HP_MIC
	},
5993 5994 5995
	[ALC255_FIXUP_HEADSET_MODE] = {
		.type = HDA_FIXUP_FUNC,
		.v.func = alc_fixup_headset_mode_alc255,
5996 5997
		.chained = true,
		.chain_id = ALC255_FIXUP_DELL_WMI_MIC_MUTE_LED
5998
	},
5999 6000 6001 6002
	[ALC255_FIXUP_HEADSET_MODE_NO_HP_MIC] = {
		.type = HDA_FIXUP_FUNC,
		.v.func = alc_fixup_headset_mode_alc255_no_hp_mic,
	},
6003 6004 6005 6006 6007 6008 6009 6010 6011 6012
	[ALC293_FIXUP_DELL1_MIC_NO_PRESENCE] = {
		.type = HDA_FIXUP_PINS,
		.v.pins = (const struct hda_pintbl[]) {
			{ 0x18, 0x01a1913d }, /* use as headphone mic, without its own jack detect */
			{ 0x1a, 0x01a1913c }, /* use as headset mic, without its own jack detect */
			{ }
		},
		.chained = true,
		.chain_id = ALC269_FIXUP_HEADSET_MODE
	},
6013
	[ALC292_FIXUP_TPT440_DOCK] = {
6014
		.type = HDA_FIXUP_FUNC,
6015
		.v.func = alc_fixup_tpt440_dock,
6016 6017 6018
		.chained = true,
		.chain_id = ALC269_FIXUP_LIMIT_INT_MIC_BOOST
	},
6019 6020
	[ALC292_FIXUP_TPT440] = {
		.type = HDA_FIXUP_FUNC,
6021
		.v.func = alc_fixup_disable_aamix,
6022 6023 6024
		.chained = true,
		.chain_id = ALC292_FIXUP_TPT440_DOCK,
	},
6025
	[ALC283_FIXUP_HEADSET_MIC] = {
6026 6027 6028 6029 6030 6031
		.type = HDA_FIXUP_PINS,
		.v.pins = (const struct hda_pintbl[]) {
			{ 0x19, 0x04a110f0 },
			{ },
		},
	},
6032 6033 6034 6035
	[ALC255_FIXUP_DELL_WMI_MIC_MUTE_LED] = {
		.type = HDA_FIXUP_FUNC,
		.v.func = alc_fixup_dell_wmi,
	},
6036 6037 6038 6039 6040 6041 6042
	[ALC282_FIXUP_ASPIRE_V5_PINS] = {
		.type = HDA_FIXUP_PINS,
		.v.pins = (const struct hda_pintbl[]) {
			{ 0x12, 0x90a60130 },
			{ 0x14, 0x90170110 },
			{ 0x17, 0x40000008 },
			{ 0x18, 0x411111f0 },
6043
			{ 0x19, 0x01a1913c },
6044 6045 6046 6047 6048 6049 6050 6051
			{ 0x1a, 0x411111f0 },
			{ 0x1b, 0x411111f0 },
			{ 0x1d, 0x40f89b2d },
			{ 0x1e, 0x411111f0 },
			{ 0x21, 0x0321101f },
			{ },
		},
	},
6052 6053 6054 6055
	[ALC280_FIXUP_HP_GPIO4] = {
		.type = HDA_FIXUP_FUNC,
		.v.func = alc280_fixup_hp_gpio4,
	},
6056 6057 6058 6059
	[ALC286_FIXUP_HP_GPIO_LED] = {
		.type = HDA_FIXUP_FUNC,
		.v.func = alc286_fixup_hp_gpio_led,
	},
6060 6061 6062 6063
	[ALC280_FIXUP_HP_GPIO2_MIC_HOTKEY] = {
		.type = HDA_FIXUP_FUNC,
		.v.func = alc280_fixup_hp_gpio2_mic_hotkey,
	},
6064 6065 6066 6067 6068 6069 6070 6071 6072 6073 6074
	[ALC280_FIXUP_HP_DOCK_PINS] = {
		.type = HDA_FIXUP_PINS,
		.v.pins = (const struct hda_pintbl[]) {
			{ 0x1b, 0x21011020 }, /* line-out */
			{ 0x1a, 0x01a1903c }, /* headset mic */
			{ 0x18, 0x2181103f }, /* line-in */
			{ },
		},
		.chained = true,
		.chain_id = ALC280_FIXUP_HP_GPIO4
	},
6075 6076 6077 6078 6079 6080 6081 6082 6083 6084
	[ALC269_FIXUP_HP_DOCK_GPIO_MIC1_LED] = {
		.type = HDA_FIXUP_PINS,
		.v.pins = (const struct hda_pintbl[]) {
			{ 0x1b, 0x21011020 }, /* line-out */
			{ 0x18, 0x2181103f }, /* line-in */
			{ },
		},
		.chained = true,
		.chain_id = ALC269_FIXUP_HP_GPIO_MIC1_LED
	},
6085 6086 6087 6088
	[ALC280_FIXUP_HP_9480M] = {
		.type = HDA_FIXUP_FUNC,
		.v.func = alc280_fixup_hp_9480m,
	},
6089 6090 6091 6092 6093 6094 6095 6096 6097 6098 6099 6100 6101 6102 6103 6104 6105 6106 6107 6108 6109 6110 6111 6112 6113 6114 6115
	[ALC288_FIXUP_DELL_HEADSET_MODE] = {
		.type = HDA_FIXUP_FUNC,
		.v.func = alc_fixup_headset_mode_dell_alc288,
		.chained = true,
		.chain_id = ALC255_FIXUP_DELL_WMI_MIC_MUTE_LED
	},
	[ALC288_FIXUP_DELL1_MIC_NO_PRESENCE] = {
		.type = HDA_FIXUP_PINS,
		.v.pins = (const struct hda_pintbl[]) {
			{ 0x18, 0x01a1913c }, /* use as headset mic, without its own jack detect */
			{ 0x1a, 0x01a1913d }, /* use as headphone mic, without its own jack detect */
			{ }
		},
		.chained = true,
		.chain_id = ALC288_FIXUP_DELL_HEADSET_MODE
	},
	[ALC288_FIXUP_DELL_XPS_13_GPIO6] = {
		.type = HDA_FIXUP_VERBS,
		.v.verbs = (const struct hda_verb[]) {
			{0x01, AC_VERB_SET_GPIO_MASK, 0x40},
			{0x01, AC_VERB_SET_GPIO_DIRECTION, 0x40},
			{0x01, AC_VERB_SET_GPIO_DATA, 0x00},
			{ }
		},
		.chained = true,
		.chain_id = ALC288_FIXUP_DELL1_MIC_NO_PRESENCE
	},
6116 6117 6118 6119 6120 6121 6122 6123 6124 6125 6126 6127
	[ALC288_FIXUP_DISABLE_AAMIX] = {
		.type = HDA_FIXUP_FUNC,
		.v.func = alc_fixup_disable_aamix,
		.chained = true,
		.chain_id = ALC288_FIXUP_DELL_XPS_13_GPIO6
	},
	[ALC288_FIXUP_DELL_XPS_13] = {
		.type = HDA_FIXUP_FUNC,
		.v.func = alc_fixup_dell_xps13,
		.chained = true,
		.chain_id = ALC288_FIXUP_DISABLE_AAMIX
	},
6128 6129 6130
	[ALC292_FIXUP_DISABLE_AAMIX] = {
		.type = HDA_FIXUP_FUNC,
		.v.func = alc_fixup_disable_aamix,
6131 6132
		.chained = true,
		.chain_id = ALC269_FIXUP_DELL2_MIC_NO_PRESENCE
6133
	},
6134 6135 6136 6137 6138 6139
	[ALC293_FIXUP_DISABLE_AAMIX_MULTIJACK] = {
		.type = HDA_FIXUP_FUNC,
		.v.func = alc_fixup_disable_aamix,
		.chained = true,
		.chain_id = ALC293_FIXUP_DELL1_MIC_NO_PRESENCE
	},
6140 6141 6142 6143 6144 6145
	[ALC292_FIXUP_DELL_E7X] = {
		.type = HDA_FIXUP_FUNC,
		.v.func = alc_fixup_dell_xps13,
		.chained = true,
		.chain_id = ALC292_FIXUP_DISABLE_AAMIX
	},
6146 6147 6148 6149 6150 6151 6152 6153 6154 6155
	[ALC298_FIXUP_DELL1_MIC_NO_PRESENCE] = {
		.type = HDA_FIXUP_PINS,
		.v.pins = (const struct hda_pintbl[]) {
			{ 0x18, 0x01a1913c }, /* use as headset mic, without its own jack detect */
			{ 0x1a, 0x01a1913d }, /* use as headphone mic, without its own jack detect */
			{ }
		},
		.chained = true,
		.chain_id = ALC269_FIXUP_HEADSET_MODE
	},
6156 6157 6158 6159 6160 6161 6162 6163 6164
	[ALC298_FIXUP_DELL_AIO_MIC_NO_PRESENCE] = {
		.type = HDA_FIXUP_PINS,
		.v.pins = (const struct hda_pintbl[]) {
			{ 0x18, 0x01a1913c }, /* use as headset mic, without its own jack detect */
			{ }
		},
		.chained = true,
		.chain_id = ALC269_FIXUP_HEADSET_MODE
	},
6165 6166 6167 6168 6169 6170 6171 6172 6173 6174 6175
	[ALC275_FIXUP_DELL_XPS] = {
		.type = HDA_FIXUP_VERBS,
		.v.verbs = (const struct hda_verb[]) {
			/* Enables internal speaker */
			{0x20, AC_VERB_SET_COEF_INDEX, 0x1f},
			{0x20, AC_VERB_SET_PROC_COEF, 0x00c0},
			{0x20, AC_VERB_SET_COEF_INDEX, 0x30},
			{0x20, AC_VERB_SET_PROC_COEF, 0x00b1},
			{}
		}
	},
6176 6177 6178 6179 6180 6181 6182 6183 6184 6185 6186
	[ALC256_FIXUP_DELL_XPS_13_HEADPHONE_NOISE] = {
		.type = HDA_FIXUP_VERBS,
		.v.verbs = (const struct hda_verb[]) {
			/* Disable pass-through path for FRONT 14h */
			{0x20, AC_VERB_SET_COEF_INDEX, 0x36},
			{0x20, AC_VERB_SET_PROC_COEF, 0x1737},
			{}
		},
		.chained = true,
		.chain_id = ALC255_FIXUP_DELL1_MIC_NO_PRESENCE
	},
6187 6188 6189 6190 6191 6192
	[ALC293_FIXUP_LENOVO_SPK_NOISE] = {
		.type = HDA_FIXUP_FUNC,
		.v.func = alc_fixup_disable_aamix,
		.chained = true,
		.chain_id = ALC269_FIXUP_THINKPAD_ACPI
	},
6193 6194 6195 6196
	[ALC233_FIXUP_LENOVO_LINE2_MIC_HOTKEY] = {
		.type = HDA_FIXUP_FUNC,
		.v.func = alc233_fixup_lenovo_line2_mic_hotkey,
	},
6197 6198 6199 6200 6201 6202
	[ALC255_FIXUP_DELL_SPK_NOISE] = {
		.type = HDA_FIXUP_FUNC,
		.v.func = alc_fixup_disable_aamix,
		.chained = true,
		.chain_id = ALC255_FIXUP_DELL1_MIC_NO_PRESENCE
	},
6203 6204 6205 6206 6207 6208 6209 6210 6211 6212 6213
	[ALC225_FIXUP_DELL1_MIC_NO_PRESENCE] = {
		.type = HDA_FIXUP_VERBS,
		.v.verbs = (const struct hda_verb[]) {
			/* Disable pass-through path for FRONT 14h */
			{ 0x20, AC_VERB_SET_COEF_INDEX, 0x36 },
			{ 0x20, AC_VERB_SET_PROC_COEF, 0x57d7 },
			{}
		},
		.chained = true,
		.chain_id = ALC269_FIXUP_DELL1_MIC_NO_PRESENCE
	},
6214 6215 6216 6217 6218 6219
	[ALC280_FIXUP_HP_HEADSET_MIC] = {
		.type = HDA_FIXUP_FUNC,
		.v.func = alc_fixup_disable_aamix,
		.chained = true,
		.chain_id = ALC269_FIXUP_HEADSET_MIC,
	},
6220 6221 6222 6223 6224 6225 6226
	[ALC221_FIXUP_HP_FRONT_MIC] = {
		.type = HDA_FIXUP_PINS,
		.v.pins = (const struct hda_pintbl[]) {
			{ 0x19, 0x02a19020 }, /* Front Mic */
			{ }
		},
	},
6227 6228 6229 6230 6231 6232
	[ALC292_FIXUP_TPT460] = {
		.type = HDA_FIXUP_FUNC,
		.v.func = alc_fixup_tpt440_dock,
		.chained = true,
		.chain_id = ALC293_FIXUP_LENOVO_SPK_NOISE,
	},
6233 6234 6235
	[ALC298_FIXUP_SPK_VOLUME] = {
		.type = HDA_FIXUP_FUNC,
		.v.func = alc298_fixup_speaker_volume,
6236
		.chained = true,
6237
		.chain_id = ALC298_FIXUP_DELL_AIO_MIC_NO_PRESENCE,
6238
	},
6239 6240 6241 6242
	[ALC295_FIXUP_DISABLE_DAC3] = {
		.type = HDA_FIXUP_FUNC,
		.v.func = alc295_fixup_disable_dac3,
	},
6243 6244 6245 6246 6247 6248 6249 6250 6251
	[ALC256_FIXUP_DELL_INSPIRON_7559_SUBWOOFER] = {
		.type = HDA_FIXUP_PINS,
		.v.pins = (const struct hda_pintbl[]) {
			{ 0x1b, 0x90170151 },
			{ }
		},
		.chained = true,
		.chain_id = ALC255_FIXUP_DELL1_MIC_NO_PRESENCE
	},
6252 6253 6254 6255 6256 6257
	[ALC269_FIXUP_ATIV_BOOK_8] = {
		.type = HDA_FIXUP_FUNC,
		.v.func = alc_fixup_auto_mute_via_amp,
		.chained = true,
		.chain_id = ALC269_FIXUP_NO_SHUTUP
	},
6258 6259 6260 6261 6262 6263 6264 6265 6266 6267
	[ALC221_FIXUP_HP_MIC_NO_PRESENCE] = {
		.type = HDA_FIXUP_PINS,
		.v.pins = (const struct hda_pintbl[]) {
			{ 0x18, 0x01a1913c }, /* use as headset mic, without its own jack detect */
			{ 0x1a, 0x01a1913d }, /* use as headphone mic, without its own jack detect */
			{ }
		},
		.chained = true,
		.chain_id = ALC269_FIXUP_HEADSET_MODE
	},
6268 6269 6270 6271 6272 6273 6274 6275 6276 6277 6278 6279 6280 6281
	[ALC256_FIXUP_ASUS_HEADSET_MODE] = {
		.type = HDA_FIXUP_FUNC,
		.v.func = alc_fixup_headset_mode,
	},
	[ALC256_FIXUP_ASUS_MIC] = {
		.type = HDA_FIXUP_PINS,
		.v.pins = (const struct hda_pintbl[]) {
			{ 0x13, 0x90a60160 }, /* use as internal mic */
			{ 0x19, 0x04a11120 }, /* use as headset mic, without its own jack detect */
			{ }
		},
		.chained = true,
		.chain_id = ALC256_FIXUP_ASUS_HEADSET_MODE
	},
6282 6283 6284 6285 6286 6287 6288 6289 6290 6291
	[ALC256_FIXUP_ASUS_AIO_GPIO2] = {
		.type = HDA_FIXUP_VERBS,
		.v.verbs = (const struct hda_verb[]) {
			/* Set up GPIO2 for the speaker amp */
			{ 0x01, AC_VERB_SET_GPIO_MASK, 0x04 },
			{ 0x01, AC_VERB_SET_GPIO_DIRECTION, 0x04 },
			{ 0x01, AC_VERB_SET_GPIO_DATA, 0x04 },
			{}
		},
	},
6292 6293 6294 6295 6296 6297 6298 6299 6300 6301 6302 6303 6304 6305 6306 6307 6308 6309 6310 6311
	[ALC233_FIXUP_ASUS_MIC_NO_PRESENCE] = {
		.type = HDA_FIXUP_PINS,
		.v.pins = (const struct hda_pintbl[]) {
			{ 0x19, 0x01a1913c }, /* use as headset mic, without its own jack detect */
			{ }
		},
		.chained = true,
		.chain_id = ALC269_FIXUP_HEADSET_MIC
	},
	[ALC233_FIXUP_EAPD_COEF_AND_MIC_NO_PRESENCE] = {
		.type = HDA_FIXUP_VERBS,
		.v.verbs = (const struct hda_verb[]) {
			/* Enables internal speaker */
			{0x20, AC_VERB_SET_COEF_INDEX, 0x40},
			{0x20, AC_VERB_SET_PROC_COEF, 0x8800},
			{}
		},
		.chained = true,
		.chain_id = ALC233_FIXUP_ASUS_MIC_NO_PRESENCE
	},
6312 6313 6314 6315
	[ALC233_FIXUP_LENOVO_MULTI_CODECS] = {
		.type = HDA_FIXUP_FUNC,
		.v.func = alc233_alc662_fixup_lenovo_dual_codecs,
	},
6316 6317 6318 6319 6320 6321 6322 6323 6324 6325 6326 6327
	[ALC294_FIXUP_LENOVO_MIC_LOCATION] = {
		.type = HDA_FIXUP_PINS,
		.v.pins = (const struct hda_pintbl[]) {
			/* Change the mic location from front to right, otherwise there are
			   two front mics with the same name, pulseaudio can't handle them.
			   This is just a temporary workaround, after applying this fixup,
			   there will be one "Front Mic" and one "Mic" in this machine.
			 */
			{ 0x1a, 0x04a19040 },
			{ }
		},
	},
6328 6329 6330 6331 6332 6333 6334 6335 6336 6337 6338 6339
	[ALC225_FIXUP_DELL_WYSE_MIC_NO_PRESENCE] = {
		.type = HDA_FIXUP_PINS,
		.v.pins = (const struct hda_pintbl[]) {
			{ 0x16, 0x0101102f }, /* Rear Headset HP */
			{ 0x19, 0x02a1913c }, /* use as Front headset mic, without its own jack detect */
			{ 0x1a, 0x01a19030 }, /* Rear Headset MIC */
			{ 0x1b, 0x02011020 },
			{ }
		},
		.chained = true,
		.chain_id = ALC269_FIXUP_HEADSET_MODE_NO_HP_MIC
	},
6340 6341 6342 6343 6344 6345 6346 6347 6348 6349 6350 6351 6352 6353 6354
	[ALC700_FIXUP_INTEL_REFERENCE] = {
		.type = HDA_FIXUP_VERBS,
		.v.verbs = (const struct hda_verb[]) {
			/* Enables internal speaker */
			{0x20, AC_VERB_SET_COEF_INDEX, 0x45},
			{0x20, AC_VERB_SET_PROC_COEF, 0x5289},
			{0x20, AC_VERB_SET_COEF_INDEX, 0x4A},
			{0x20, AC_VERB_SET_PROC_COEF, 0x001b},
			{0x58, AC_VERB_SET_COEF_INDEX, 0x00},
			{0x58, AC_VERB_SET_PROC_COEF, 0x3888},
			{0x20, AC_VERB_SET_COEF_INDEX, 0x6f},
			{0x20, AC_VERB_SET_PROC_COEF, 0x2c0b},
			{}
		}
	},
6355 6356 6357 6358 6359 6360 6361 6362 6363 6364 6365 6366 6367 6368 6369
	[ALC274_FIXUP_DELL_BIND_DACS] = {
		.type = HDA_FIXUP_FUNC,
		.v.func = alc274_fixup_bind_dacs,
		.chained = true,
		.chain_id = ALC269_FIXUP_DELL1_MIC_NO_PRESENCE
	},
	[ALC274_FIXUP_DELL_AIO_LINEOUT_VERB] = {
		.type = HDA_FIXUP_PINS,
		.v.pins = (const struct hda_pintbl[]) {
			{ 0x1b, 0x0401102f },
			{ }
		},
		.chained = true,
		.chain_id = ALC274_FIXUP_DELL_BIND_DACS
	},
6370 6371 6372 6373 6374 6375
	[ALC298_FIXUP_TPT470_DOCK] = {
		.type = HDA_FIXUP_FUNC,
		.v.func = alc_fixup_tpt470_dock,
		.chained = true,
		.chain_id = ALC293_FIXUP_LENOVO_SPK_NOISE
	},
6376 6377 6378 6379 6380 6381 6382 6383 6384
	[ALC255_FIXUP_DUMMY_LINEOUT_VERB] = {
		.type = HDA_FIXUP_PINS,
		.v.pins = (const struct hda_pintbl[]) {
			{ 0x14, 0x0201101f },
			{ }
		},
		.chained = true,
		.chain_id = ALC255_FIXUP_DELL1_MIC_NO_PRESENCE
	},
6385 6386 6387 6388 6389 6390
	[ALC255_FIXUP_DELL_HEADSET_MIC] = {
		.type = HDA_FIXUP_PINS,
		.v.pins = (const struct hda_pintbl[]) {
			{ 0x19, 0x01a1913c }, /* use as headset mic, without its own jack detect */
			{ }
		},
6391 6392
		.chained = true,
		.chain_id = ALC269_FIXUP_HEADSET_MIC
6393
	},
6394 6395 6396 6397 6398 6399
	[ALC295_FIXUP_HP_X360] = {
		.type = HDA_FIXUP_FUNC,
		.v.func = alc295_fixup_hp_top_speakers,
		.chained = true,
		.chain_id = ALC269_FIXUP_HP_MUTE_LED_MIC3
	}
6400 6401
};

6402
static const struct snd_pci_quirk alc269_fixup_tbl[] = {
6403
	SND_PCI_QUIRK(0x1025, 0x0283, "Acer TravelMate 8371", ALC269_FIXUP_INV_DMIC),
6404 6405
	SND_PCI_QUIRK(0x1025, 0x029b, "Acer 1810TZ", ALC269_FIXUP_INV_DMIC),
	SND_PCI_QUIRK(0x1025, 0x0349, "Acer AOD260", ALC269_FIXUP_INV_DMIC),
6406
	SND_PCI_QUIRK(0x1025, 0x047c, "Acer AC700", ALC269_FIXUP_ACER_AC700),
6407 6408
	SND_PCI_QUIRK(0x1025, 0x072d, "Acer Aspire V5-571G", ALC269_FIXUP_ASPIRE_HEADSET_MIC),
	SND_PCI_QUIRK(0x1025, 0x080d, "Acer Aspire V5-122P", ALC269_FIXUP_ASPIRE_HEADSET_MIC),
6409 6410
	SND_PCI_QUIRK(0x1025, 0x0740, "Acer AO725", ALC271_FIXUP_HP_GATE_MIC_JACK),
	SND_PCI_QUIRK(0x1025, 0x0742, "Acer AO756", ALC271_FIXUP_HP_GATE_MIC_JACK),
6411
	SND_PCI_QUIRK(0x1025, 0x0762, "Acer Aspire E1-472", ALC271_FIXUP_HP_GATE_MIC_JACK_E1_572),
6412
	SND_PCI_QUIRK(0x1025, 0x0775, "Acer Aspire E1-572", ALC271_FIXUP_HP_GATE_MIC_JACK_E1_572),
6413
	SND_PCI_QUIRK(0x1025, 0x079b, "Acer Aspire V5-573G", ALC282_FIXUP_ASPIRE_V5_PINS),
6414
	SND_PCI_QUIRK(0x1025, 0x106d, "Acer Cloudbook 14", ALC283_FIXUP_CHROME_BOOK),
6415
	SND_PCI_QUIRK(0x1028, 0x0470, "Dell M101z", ALC269_FIXUP_DELL_M101Z),
6416
	SND_PCI_QUIRK(0x1028, 0x054b, "Dell XPS one 2710", ALC275_FIXUP_DELL_XPS),
6417
	SND_PCI_QUIRK(0x1028, 0x05bd, "Dell Latitude E6440", ALC292_FIXUP_DELL_E7X),
6418
	SND_PCI_QUIRK(0x1028, 0x05be, "Dell Latitude E6540", ALC292_FIXUP_DELL_E7X),
6419 6420
	SND_PCI_QUIRK(0x1028, 0x05ca, "Dell Latitude E7240", ALC292_FIXUP_DELL_E7X),
	SND_PCI_QUIRK(0x1028, 0x05cb, "Dell Latitude E7440", ALC292_FIXUP_DELL_E7X),
6421
	SND_PCI_QUIRK(0x1028, 0x05da, "Dell Vostro 5460", ALC290_FIXUP_SUBWOOFER),
6422 6423 6424
	SND_PCI_QUIRK(0x1028, 0x05f4, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE),
	SND_PCI_QUIRK(0x1028, 0x05f5, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE),
	SND_PCI_QUIRK(0x1028, 0x05f6, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE),
6425 6426
	SND_PCI_QUIRK(0x1028, 0x0615, "Dell Vostro 5470", ALC290_FIXUP_SUBWOOFER_HSJACK),
	SND_PCI_QUIRK(0x1028, 0x0616, "Dell Vostro 5470", ALC290_FIXUP_SUBWOOFER_HSJACK),
6427
	SND_PCI_QUIRK(0x1028, 0x062c, "Dell Latitude E5550", ALC292_FIXUP_DELL_E7X),
6428
	SND_PCI_QUIRK(0x1028, 0x062e, "Dell Latitude E7450", ALC292_FIXUP_DELL_E7X),
6429
	SND_PCI_QUIRK(0x1028, 0x0638, "Dell Inspiron 5439", ALC290_FIXUP_MONO_SPEAKERS_HSJACK),
6430 6431
	SND_PCI_QUIRK(0x1028, 0x064a, "Dell", ALC293_FIXUP_DELL1_MIC_NO_PRESENCE),
	SND_PCI_QUIRK(0x1028, 0x064b, "Dell", ALC293_FIXUP_DELL1_MIC_NO_PRESENCE),
6432
	SND_PCI_QUIRK(0x1028, 0x0665, "Dell XPS 13", ALC288_FIXUP_DELL_XPS_13),
6433
	SND_PCI_QUIRK(0x1028, 0x0669, "Dell Optiplex 9020m", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE),
6434
	SND_PCI_QUIRK(0x1028, 0x069a, "Dell Vostro 5480", ALC290_FIXUP_SUBWOOFER_HSJACK),
6435
	SND_PCI_QUIRK(0x1028, 0x06c7, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE),
6436 6437
	SND_PCI_QUIRK(0x1028, 0x06d9, "Dell", ALC293_FIXUP_DELL1_MIC_NO_PRESENCE),
	SND_PCI_QUIRK(0x1028, 0x06da, "Dell", ALC293_FIXUP_DELL1_MIC_NO_PRESENCE),
6438 6439 6440 6441 6442
	SND_PCI_QUIRK(0x1028, 0x06db, "Dell", ALC293_FIXUP_DISABLE_AAMIX_MULTIJACK),
	SND_PCI_QUIRK(0x1028, 0x06dd, "Dell", ALC293_FIXUP_DISABLE_AAMIX_MULTIJACK),
	SND_PCI_QUIRK(0x1028, 0x06de, "Dell", ALC293_FIXUP_DISABLE_AAMIX_MULTIJACK),
	SND_PCI_QUIRK(0x1028, 0x06df, "Dell", ALC293_FIXUP_DISABLE_AAMIX_MULTIJACK),
	SND_PCI_QUIRK(0x1028, 0x06e0, "Dell", ALC293_FIXUP_DISABLE_AAMIX_MULTIJACK),
6443
	SND_PCI_QUIRK(0x1028, 0x0704, "Dell XPS 13 9350", ALC256_FIXUP_DELL_XPS_13_HEADPHONE_NOISE),
6444
	SND_PCI_QUIRK(0x1028, 0x0706, "Dell Inspiron 7559", ALC256_FIXUP_DELL_INSPIRON_7559_SUBWOOFER),
6445
	SND_PCI_QUIRK(0x1028, 0x0725, "Dell Inspiron 3162", ALC255_FIXUP_DELL_SPK_NOISE),
6446
	SND_PCI_QUIRK(0x1028, 0x075b, "Dell XPS 13 9360", ALC256_FIXUP_DELL_XPS_13_HEADPHONE_NOISE),
6447
	SND_PCI_QUIRK(0x1028, 0x075d, "Dell AIO", ALC298_FIXUP_SPK_VOLUME),
6448
	SND_PCI_QUIRK(0x1028, 0x07b0, "Dell Precision 7520", ALC295_FIXUP_DISABLE_DAC3),
6449
	SND_PCI_QUIRK(0x1028, 0x0798, "Dell Inspiron 17 7000 Gaming", ALC256_FIXUP_DELL_INSPIRON_7559_SUBWOOFER),
6450
	SND_PCI_QUIRK(0x1028, 0x080c, "Dell WYSE", ALC225_FIXUP_DELL_WYSE_MIC_NO_PRESENCE),
6451
	SND_PCI_QUIRK(0x1028, 0x082a, "Dell XPS 13 9360", ALC256_FIXUP_DELL_XPS_13_HEADPHONE_NOISE),
6452 6453
	SND_PCI_QUIRK(0x1028, 0x084b, "Dell", ALC274_FIXUP_DELL_AIO_LINEOUT_VERB),
	SND_PCI_QUIRK(0x1028, 0x084e, "Dell", ALC274_FIXUP_DELL_AIO_LINEOUT_VERB),
6454 6455
	SND_PCI_QUIRK(0x1028, 0x0871, "Dell Precision 3630", ALC255_FIXUP_DELL_HEADSET_MIC),
	SND_PCI_QUIRK(0x1028, 0x0872, "Dell Precision 3630", ALC255_FIXUP_DELL_HEADSET_MIC),
6456
	SND_PCI_QUIRK(0x1028, 0x0873, "Dell Precision 3930", ALC255_FIXUP_DUMMY_LINEOUT_VERB),
6457 6458
	SND_PCI_QUIRK(0x1028, 0x164a, "Dell", ALC293_FIXUP_DELL1_MIC_NO_PRESENCE),
	SND_PCI_QUIRK(0x1028, 0x164b, "Dell", ALC293_FIXUP_DELL1_MIC_NO_PRESENCE),
6459
	SND_PCI_QUIRK(0x103c, 0x1586, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC2),
6460
	SND_PCI_QUIRK(0x103c, 0x18e6, "HP", ALC269_FIXUP_HP_GPIO_LED),
6461
	SND_PCI_QUIRK(0x103c, 0x218b, "HP", ALC269_FIXUP_LIMIT_INT_MIC_BOOST_MUTE_LED),
6462
	SND_PCI_QUIRK(0x103c, 0x225f, "HP", ALC280_FIXUP_HP_GPIO2_MIC_HOTKEY),
6463
	/* ALC282 */
6464
	SND_PCI_QUIRK(0x103c, 0x21f9, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
6465 6466
	SND_PCI_QUIRK(0x103c, 0x2210, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
	SND_PCI_QUIRK(0x103c, 0x2214, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
6467 6468 6469 6470 6471
	SND_PCI_QUIRK(0x103c, 0x2236, "HP", ALC269_FIXUP_HP_LINE1_MIC1_LED),
	SND_PCI_QUIRK(0x103c, 0x2237, "HP", ALC269_FIXUP_HP_LINE1_MIC1_LED),
	SND_PCI_QUIRK(0x103c, 0x2238, "HP", ALC269_FIXUP_HP_LINE1_MIC1_LED),
	SND_PCI_QUIRK(0x103c, 0x2239, "HP", ALC269_FIXUP_HP_LINE1_MIC1_LED),
	SND_PCI_QUIRK(0x103c, 0x224b, "HP", ALC269_FIXUP_HP_LINE1_MIC1_LED),
6472 6473 6474
	SND_PCI_QUIRK(0x103c, 0x2268, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
	SND_PCI_QUIRK(0x103c, 0x226a, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
	SND_PCI_QUIRK(0x103c, 0x226b, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
6475
	SND_PCI_QUIRK(0x103c, 0x226e, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
6476
	SND_PCI_QUIRK(0x103c, 0x2271, "HP", ALC286_FIXUP_HP_GPIO_LED),
6477
	SND_PCI_QUIRK(0x103c, 0x2272, "HP", ALC280_FIXUP_HP_DOCK_PINS),
6478
	SND_PCI_QUIRK(0x103c, 0x2273, "HP", ALC280_FIXUP_HP_DOCK_PINS),
6479 6480 6481 6482 6483
	SND_PCI_QUIRK(0x103c, 0x229e, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
	SND_PCI_QUIRK(0x103c, 0x22b2, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
	SND_PCI_QUIRK(0x103c, 0x22b7, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
	SND_PCI_QUIRK(0x103c, 0x22bf, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
	SND_PCI_QUIRK(0x103c, 0x22cf, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
6484
	SND_PCI_QUIRK(0x103c, 0x22db, "HP", ALC280_FIXUP_HP_9480M),
6485 6486
	SND_PCI_QUIRK(0x103c, 0x22dc, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),
	SND_PCI_QUIRK(0x103c, 0x22fb, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),
6487
	/* ALC290 */
6488 6489 6490 6491 6492 6493 6494 6495 6496
	SND_PCI_QUIRK(0x103c, 0x221b, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),
	SND_PCI_QUIRK(0x103c, 0x2221, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),
	SND_PCI_QUIRK(0x103c, 0x2225, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),
	SND_PCI_QUIRK(0x103c, 0x2253, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),
	SND_PCI_QUIRK(0x103c, 0x2254, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),
	SND_PCI_QUIRK(0x103c, 0x2255, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),
	SND_PCI_QUIRK(0x103c, 0x2256, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),
	SND_PCI_QUIRK(0x103c, 0x2257, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),
	SND_PCI_QUIRK(0x103c, 0x2259, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),
6497
	SND_PCI_QUIRK(0x103c, 0x225a, "HP", ALC269_FIXUP_HP_DOCK_GPIO_MIC1_LED),
6498 6499 6500 6501
	SND_PCI_QUIRK(0x103c, 0x2260, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
	SND_PCI_QUIRK(0x103c, 0x2263, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
	SND_PCI_QUIRK(0x103c, 0x2264, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
	SND_PCI_QUIRK(0x103c, 0x2265, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
6502 6503 6504
	SND_PCI_QUIRK(0x103c, 0x2272, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),
	SND_PCI_QUIRK(0x103c, 0x2273, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),
	SND_PCI_QUIRK(0x103c, 0x2278, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),
6505 6506 6507 6508 6509 6510 6511 6512
	SND_PCI_QUIRK(0x103c, 0x227f, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
	SND_PCI_QUIRK(0x103c, 0x2282, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
	SND_PCI_QUIRK(0x103c, 0x228b, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
	SND_PCI_QUIRK(0x103c, 0x228e, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
	SND_PCI_QUIRK(0x103c, 0x22c5, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
	SND_PCI_QUIRK(0x103c, 0x22c7, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
	SND_PCI_QUIRK(0x103c, 0x22c8, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
	SND_PCI_QUIRK(0x103c, 0x22c4, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
6513 6514 6515 6516
	SND_PCI_QUIRK(0x103c, 0x2334, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
	SND_PCI_QUIRK(0x103c, 0x2335, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
	SND_PCI_QUIRK(0x103c, 0x2336, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
	SND_PCI_QUIRK(0x103c, 0x2337, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
6517
	SND_PCI_QUIRK(0x103c, 0x221c, "HP EliteBook 755 G2", ALC280_FIXUP_HP_HEADSET_MIC),
6518
	SND_PCI_QUIRK(0x103c, 0x8256, "HP", ALC221_FIXUP_HP_FRONT_MIC),
6519
	SND_PCI_QUIRK(0x103c, 0x827e, "HP x360", ALC295_FIXUP_HP_X360),
6520 6521
	SND_PCI_QUIRK(0x103c, 0x82bf, "HP", ALC221_FIXUP_HP_MIC_NO_PRESENCE),
	SND_PCI_QUIRK(0x103c, 0x82c0, "HP", ALC221_FIXUP_HP_MIC_NO_PRESENCE),
6522
	SND_PCI_QUIRK(0x1043, 0x103e, "ASUS X540SA", ALC256_FIXUP_ASUS_MIC),
6523
	SND_PCI_QUIRK(0x1043, 0x103f, "ASUS TX300", ALC282_FIXUP_ASUS_TX300),
6524
	SND_PCI_QUIRK(0x1043, 0x106d, "Asus K53BE", ALC269_FIXUP_LIMIT_INT_MIC_BOOST),
6525
	SND_PCI_QUIRK(0x1043, 0x10c0, "ASUS X540SA", ALC256_FIXUP_ASUS_MIC),
6526
	SND_PCI_QUIRK(0x1043, 0x10d0, "ASUS X540LA/X540LJ", ALC255_FIXUP_ASUS_MIC_NO_PRESENCE),
6527
	SND_PCI_QUIRK(0x1043, 0x115d, "Asus 1015E", ALC269_FIXUP_LIMIT_INT_MIC_BOOST),
6528 6529 6530
	SND_PCI_QUIRK(0x1043, 0x11c0, "ASUS X556UR", ALC255_FIXUP_ASUS_MIC_NO_PRESENCE),
	SND_PCI_QUIRK(0x1043, 0x1290, "ASUS X441SA", ALC233_FIXUP_EAPD_COEF_AND_MIC_NO_PRESENCE),
	SND_PCI_QUIRK(0x1043, 0x12a0, "ASUS X441UV", ALC233_FIXUP_EAPD_COEF_AND_MIC_NO_PRESENCE),
6531 6532 6533
	SND_PCI_QUIRK(0x1043, 0x12f0, "ASUS X541UV", ALC256_FIXUP_ASUS_MIC),
	SND_PCI_QUIRK(0x1043, 0x12e0, "ASUS X541SA", ALC256_FIXUP_ASUS_MIC),
	SND_PCI_QUIRK(0x1043, 0x13b0, "ASUS Z550SA", ALC256_FIXUP_ASUS_MIC),
6534
	SND_PCI_QUIRK(0x1043, 0x1427, "Asus Zenbook UX31E", ALC269VB_FIXUP_ASUS_ZENBOOK),
6535
	SND_PCI_QUIRK(0x1043, 0x1517, "Asus Zenbook UX31A", ALC269VB_FIXUP_ASUS_ZENBOOK_UX31A),
6536
	SND_PCI_QUIRK(0x1043, 0x16e3, "ASUS UX50", ALC269_FIXUP_STEREO_DMIC),
6537
	SND_PCI_QUIRK(0x1043, 0x1a13, "Asus G73Jw", ALC269_FIXUP_ASUS_G73JW),
6538
	SND_PCI_QUIRK(0x1043, 0x1a30, "ASUS X705UD", ALC256_FIXUP_ASUS_MIC),
6539
	SND_PCI_QUIRK(0x1043, 0x1b13, "Asus U41SV", ALC269_FIXUP_INV_DMIC),
6540
	SND_PCI_QUIRK(0x1043, 0x1bbd, "ASUS Z550MA", ALC255_FIXUP_ASUS_MIC_NO_PRESENCE),
6541
	SND_PCI_QUIRK(0x1043, 0x1c23, "Asus X55U", ALC269_FIXUP_LIMIT_INT_MIC_BOOST),
6542
	SND_PCI_QUIRK(0x1043, 0x1ccd, "ASUS X555UB", ALC256_FIXUP_ASUS_MIC),
6543
	SND_PCI_QUIRK(0x1043, 0x3030, "ASUS ZN270IE", ALC256_FIXUP_ASUS_AIO_GPIO2),
6544 6545 6546 6547
	SND_PCI_QUIRK(0x1043, 0x831a, "ASUS P901", ALC269_FIXUP_STEREO_DMIC),
	SND_PCI_QUIRK(0x1043, 0x834a, "ASUS S101", ALC269_FIXUP_STEREO_DMIC),
	SND_PCI_QUIRK(0x1043, 0x8398, "ASUS P1005", ALC269_FIXUP_STEREO_DMIC),
	SND_PCI_QUIRK(0x1043, 0x83ce, "ASUS P1005", ALC269_FIXUP_STEREO_DMIC),
6548
	SND_PCI_QUIRK(0x1043, 0x8516, "ASUS X101CH", ALC269_FIXUP_ASUS_X101),
6549
	SND_PCI_QUIRK(0x104d, 0x90b5, "Sony VAIO Pro 11", ALC286_FIXUP_SONY_MIC_NO_PRESENCE),
6550
	SND_PCI_QUIRK(0x104d, 0x90b6, "Sony VAIO Pro 13", ALC286_FIXUP_SONY_MIC_NO_PRESENCE),
6551 6552 6553
	SND_PCI_QUIRK(0x104d, 0x9073, "Sony VAIO", ALC275_FIXUP_SONY_VAIO_GPIO2),
	SND_PCI_QUIRK(0x104d, 0x907b, "Sony VAIO", ALC275_FIXUP_SONY_HWEQ),
	SND_PCI_QUIRK(0x104d, 0x9084, "Sony VAIO", ALC275_FIXUP_SONY_HWEQ),
6554
	SND_PCI_QUIRK(0x104d, 0x9099, "Sony VAIO S13", ALC275_FIXUP_SONY_DISABLE_AAMIX),
6555
	SND_PCI_QUIRK(0x10cf, 0x1475, "Lifebook", ALC269_FIXUP_LIFEBOOK),
6556
	SND_PCI_QUIRK(0x10cf, 0x159f, "Lifebook E780", ALC269_FIXUP_LIFEBOOK_NO_HP_TO_LINEOUT),
6557
	SND_PCI_QUIRK(0x10cf, 0x15dc, "Lifebook T731", ALC269_FIXUP_LIFEBOOK_HP_PIN),
6558
	SND_PCI_QUIRK(0x10cf, 0x1757, "Lifebook E752", ALC269_FIXUP_LIFEBOOK_HP_PIN),
6559
	SND_PCI_QUIRK(0x10cf, 0x1629, "Lifebook U7x7", ALC255_FIXUP_LIFEBOOK_U7x7_HEADSET_MIC),
6560
	SND_PCI_QUIRK(0x10cf, 0x1845, "Lifebook U904", ALC269_FIXUP_LIFEBOOK_EXTMIC),
6561
	SND_PCI_QUIRK(0x10ec, 0x10f2, "Intel Reference board", ALC700_FIXUP_INTEL_REFERENCE),
6562
	SND_PCI_QUIRK(0x144d, 0xc109, "Samsung Ativ book 9 (NP900X3G)", ALC269_FIXUP_INV_DMIC),
6563
	SND_PCI_QUIRK(0x144d, 0xc740, "Samsung Ativ book 8 (NP870Z5G)", ALC269_FIXUP_ATIV_BOOK_8),
6564 6565
	SND_PCI_QUIRK(0x1458, 0xfa53, "Gigabyte BXBT-2807", ALC283_FIXUP_HEADSET_MIC),
	SND_PCI_QUIRK(0x1462, 0xb120, "MSI Cubi MS-B120", ALC283_FIXUP_HEADSET_MIC),
6566
	SND_PCI_QUIRK(0x17aa, 0x1036, "Lenovo P520", ALC233_FIXUP_LENOVO_MULTI_CODECS),
6567 6568 6569 6570 6571
	SND_PCI_QUIRK(0x17aa, 0x20f2, "Thinkpad SL410/510", ALC269_FIXUP_SKU_IGNORE),
	SND_PCI_QUIRK(0x17aa, 0x215e, "Thinkpad L512", ALC269_FIXUP_SKU_IGNORE),
	SND_PCI_QUIRK(0x17aa, 0x21b8, "Thinkpad Edge 14", ALC269_FIXUP_SKU_IGNORE),
	SND_PCI_QUIRK(0x17aa, 0x21ca, "Thinkpad L412", ALC269_FIXUP_SKU_IGNORE),
	SND_PCI_QUIRK(0x17aa, 0x21e9, "Thinkpad Edge 15", ALC269_FIXUP_SKU_IGNORE),
6572
	SND_PCI_QUIRK(0x17aa, 0x21f6, "Thinkpad T530", ALC269_FIXUP_LENOVO_DOCK),
6573
	SND_PCI_QUIRK(0x17aa, 0x21fa, "Thinkpad X230", ALC269_FIXUP_LENOVO_DOCK),
6574
	SND_PCI_QUIRK(0x17aa, 0x21f3, "Thinkpad T430", ALC269_FIXUP_LENOVO_DOCK),
6575
	SND_PCI_QUIRK(0x17aa, 0x21fb, "Thinkpad T430s", ALC269_FIXUP_LENOVO_DOCK),
6576
	SND_PCI_QUIRK(0x17aa, 0x2203, "Thinkpad X230 Tablet", ALC269_FIXUP_LENOVO_DOCK),
6577
	SND_PCI_QUIRK(0x17aa, 0x2208, "Thinkpad T431s", ALC269_FIXUP_LENOVO_DOCK),
6578
	SND_PCI_QUIRK(0x17aa, 0x220c, "Thinkpad T440s", ALC292_FIXUP_TPT440),
6579
	SND_PCI_QUIRK(0x17aa, 0x220e, "Thinkpad T440p", ALC292_FIXUP_TPT440_DOCK),
6580
	SND_PCI_QUIRK(0x17aa, 0x2210, "Thinkpad T540p", ALC292_FIXUP_TPT440_DOCK),
6581
	SND_PCI_QUIRK(0x17aa, 0x2211, "Thinkpad W541", ALC292_FIXUP_TPT440_DOCK),
6582
	SND_PCI_QUIRK(0x17aa, 0x2212, "Thinkpad T440", ALC292_FIXUP_TPT440_DOCK),
6583
	SND_PCI_QUIRK(0x17aa, 0x2214, "Thinkpad X240", ALC292_FIXUP_TPT440_DOCK),
6584
	SND_PCI_QUIRK(0x17aa, 0x2215, "Thinkpad", ALC269_FIXUP_LIMIT_INT_MIC_BOOST),
6585
	SND_PCI_QUIRK(0x17aa, 0x2218, "Thinkpad X1 Carbon 2nd", ALC292_FIXUP_TPT440_DOCK),
6586
	SND_PCI_QUIRK(0x17aa, 0x2223, "ThinkPad T550", ALC292_FIXUP_TPT440_DOCK),
6587
	SND_PCI_QUIRK(0x17aa, 0x2226, "ThinkPad X250", ALC292_FIXUP_TPT440_DOCK),
6588 6589
	SND_PCI_QUIRK(0x17aa, 0x222d, "Thinkpad", ALC298_FIXUP_TPT470_DOCK),
	SND_PCI_QUIRK(0x17aa, 0x222e, "Thinkpad", ALC298_FIXUP_TPT470_DOCK),
6590
	SND_PCI_QUIRK(0x17aa, 0x2231, "Thinkpad T560", ALC292_FIXUP_TPT460),
6591
	SND_PCI_QUIRK(0x17aa, 0x2233, "Thinkpad", ALC292_FIXUP_TPT460),
6592 6593 6594
	SND_PCI_QUIRK(0x17aa, 0x2245, "Thinkpad T470", ALC298_FIXUP_TPT470_DOCK),
	SND_PCI_QUIRK(0x17aa, 0x2246, "Thinkpad", ALC298_FIXUP_TPT470_DOCK),
	SND_PCI_QUIRK(0x17aa, 0x2247, "Thinkpad", ALC298_FIXUP_TPT470_DOCK),
6595
	SND_PCI_QUIRK(0x17aa, 0x2249, "Thinkpad", ALC292_FIXUP_TPT460),
6596 6597 6598
	SND_PCI_QUIRK(0x17aa, 0x224b, "Thinkpad", ALC298_FIXUP_TPT470_DOCK),
	SND_PCI_QUIRK(0x17aa, 0x224c, "Thinkpad", ALC298_FIXUP_TPT470_DOCK),
	SND_PCI_QUIRK(0x17aa, 0x224d, "Thinkpad", ALC298_FIXUP_TPT470_DOCK),
6599
	SND_PCI_QUIRK(0x17aa, 0x225d, "Thinkpad T480", ALC269_FIXUP_LIMIT_INT_MIC_BOOST),
6600
	SND_PCI_QUIRK(0x17aa, 0x30bb, "ThinkCentre AIO", ALC233_FIXUP_LENOVO_LINE2_MIC_HOTKEY),
6601
	SND_PCI_QUIRK(0x17aa, 0x30e2, "ThinkCentre AIO", ALC233_FIXUP_LENOVO_LINE2_MIC_HOTKEY),
6602
	SND_PCI_QUIRK(0x17aa, 0x310c, "ThinkCentre Station", ALC294_FIXUP_LENOVO_MIC_LOCATION),
6603
	SND_PCI_QUIRK(0x17aa, 0x312f, "ThinkCentre Station", ALC294_FIXUP_LENOVO_MIC_LOCATION),
6604
	SND_PCI_QUIRK(0x17aa, 0x3138, "ThinkCentre Station", ALC294_FIXUP_LENOVO_MIC_LOCATION),
6605
	SND_PCI_QUIRK(0x17aa, 0x313c, "ThinkCentre Station", ALC294_FIXUP_LENOVO_MIC_LOCATION),
6606
	SND_PCI_QUIRK(0x17aa, 0x3902, "Lenovo E50-80", ALC269_FIXUP_DMIC_THINKPAD_ACPI),
6607
	SND_PCI_QUIRK(0x17aa, 0x3977, "IdeaPad S210", ALC283_FIXUP_INT_MIC),
6608
	SND_PCI_QUIRK(0x17aa, 0x3978, "IdeaPad Y410P", ALC269_FIXUP_NO_SHUTUP),
6609
	SND_PCI_QUIRK(0x17aa, 0x5013, "Thinkpad", ALC269_FIXUP_LIMIT_INT_MIC_BOOST),
6610
	SND_PCI_QUIRK(0x17aa, 0x501a, "Thinkpad", ALC283_FIXUP_INT_MIC),
6611
	SND_PCI_QUIRK(0x17aa, 0x501e, "Thinkpad L440", ALC292_FIXUP_TPT440_DOCK),
6612
	SND_PCI_QUIRK(0x17aa, 0x5026, "Thinkpad", ALC269_FIXUP_LIMIT_INT_MIC_BOOST),
6613
	SND_PCI_QUIRK(0x17aa, 0x5034, "Thinkpad T450", ALC292_FIXUP_TPT440_DOCK),
6614
	SND_PCI_QUIRK(0x17aa, 0x5036, "Thinkpad T450s", ALC292_FIXUP_TPT440_DOCK),
6615
	SND_PCI_QUIRK(0x17aa, 0x503c, "Thinkpad L450", ALC292_FIXUP_TPT440_DOCK),
6616
	SND_PCI_QUIRK(0x17aa, 0x504a, "ThinkPad X260", ALC292_FIXUP_TPT440_DOCK),
6617
	SND_PCI_QUIRK(0x17aa, 0x504b, "Thinkpad", ALC293_FIXUP_LENOVO_SPK_NOISE),
6618
	SND_PCI_QUIRK(0x17aa, 0x5050, "Thinkpad T560p", ALC292_FIXUP_TPT460),
6619
	SND_PCI_QUIRK(0x17aa, 0x5051, "Thinkpad L460", ALC292_FIXUP_TPT460),
6620
	SND_PCI_QUIRK(0x17aa, 0x5053, "Thinkpad T460", ALC292_FIXUP_TPT460),
6621 6622 6623
	SND_PCI_QUIRK(0x17aa, 0x505d, "Thinkpad", ALC298_FIXUP_TPT470_DOCK),
	SND_PCI_QUIRK(0x17aa, 0x505f, "Thinkpad", ALC298_FIXUP_TPT470_DOCK),
	SND_PCI_QUIRK(0x17aa, 0x5062, "Thinkpad", ALC298_FIXUP_TPT470_DOCK),
6624
	SND_PCI_QUIRK(0x17aa, 0x5109, "Thinkpad", ALC269_FIXUP_LIMIT_INT_MIC_BOOST),
6625 6626
	SND_PCI_QUIRK(0x17aa, 0x511e, "Thinkpad", ALC298_FIXUP_TPT470_DOCK),
	SND_PCI_QUIRK(0x17aa, 0x511f, "Thinkpad", ALC298_FIXUP_TPT470_DOCK),
6627
	SND_PCI_QUIRK(0x17aa, 0x3bf8, "Quanta FL1", ALC269_FIXUP_PCM_44K),
6628
	SND_PCI_QUIRK(0x17aa, 0x9e54, "LENOVO NB", ALC269_FIXUP_LENOVO_EAPD),
6629
	SND_PCI_QUIRK(0x1b7d, 0xa831, "Ordissimo EVE2 ", ALC269VB_FIXUP_ORDISSIMO_EVE2), /* Also known as Malata PC-B1303 */
6630

6631
#if 0
6632 6633 6634 6635
	/* Below is a quirk table taken from the old code.
	 * Basically the device should work as is without the fixup table.
	 * If BIOS doesn't give a proper info, enable the corresponding
	 * fixup entry.
6636
	 */
6637 6638 6639 6640 6641 6642 6643 6644 6645 6646 6647 6648 6649 6650 6651 6652 6653 6654 6655 6656 6657 6658 6659 6660 6661 6662 6663 6664 6665 6666 6667 6668 6669 6670 6671 6672 6673 6674 6675 6676 6677 6678 6679 6680 6681
	SND_PCI_QUIRK(0x1043, 0x8330, "ASUS Eeepc P703 P900A",
		      ALC269_FIXUP_AMIC),
	SND_PCI_QUIRK(0x1043, 0x1013, "ASUS N61Da", ALC269_FIXUP_AMIC),
	SND_PCI_QUIRK(0x1043, 0x1143, "ASUS B53f", ALC269_FIXUP_AMIC),
	SND_PCI_QUIRK(0x1043, 0x1133, "ASUS UJ20ft", ALC269_FIXUP_AMIC),
	SND_PCI_QUIRK(0x1043, 0x1183, "ASUS K72DR", ALC269_FIXUP_AMIC),
	SND_PCI_QUIRK(0x1043, 0x11b3, "ASUS K52DR", ALC269_FIXUP_AMIC),
	SND_PCI_QUIRK(0x1043, 0x11e3, "ASUS U33Jc", ALC269_FIXUP_AMIC),
	SND_PCI_QUIRK(0x1043, 0x1273, "ASUS UL80Jt", ALC269_FIXUP_AMIC),
	SND_PCI_QUIRK(0x1043, 0x1283, "ASUS U53Jc", ALC269_FIXUP_AMIC),
	SND_PCI_QUIRK(0x1043, 0x12b3, "ASUS N82JV", ALC269_FIXUP_AMIC),
	SND_PCI_QUIRK(0x1043, 0x12d3, "ASUS N61Jv", ALC269_FIXUP_AMIC),
	SND_PCI_QUIRK(0x1043, 0x13a3, "ASUS UL30Vt", ALC269_FIXUP_AMIC),
	SND_PCI_QUIRK(0x1043, 0x1373, "ASUS G73JX", ALC269_FIXUP_AMIC),
	SND_PCI_QUIRK(0x1043, 0x1383, "ASUS UJ30Jc", ALC269_FIXUP_AMIC),
	SND_PCI_QUIRK(0x1043, 0x13d3, "ASUS N61JA", ALC269_FIXUP_AMIC),
	SND_PCI_QUIRK(0x1043, 0x1413, "ASUS UL50", ALC269_FIXUP_AMIC),
	SND_PCI_QUIRK(0x1043, 0x1443, "ASUS UL30", ALC269_FIXUP_AMIC),
	SND_PCI_QUIRK(0x1043, 0x1453, "ASUS M60Jv", ALC269_FIXUP_AMIC),
	SND_PCI_QUIRK(0x1043, 0x1483, "ASUS UL80", ALC269_FIXUP_AMIC),
	SND_PCI_QUIRK(0x1043, 0x14f3, "ASUS F83Vf", ALC269_FIXUP_AMIC),
	SND_PCI_QUIRK(0x1043, 0x14e3, "ASUS UL20", ALC269_FIXUP_AMIC),
	SND_PCI_QUIRK(0x1043, 0x1513, "ASUS UX30", ALC269_FIXUP_AMIC),
	SND_PCI_QUIRK(0x1043, 0x1593, "ASUS N51Vn", ALC269_FIXUP_AMIC),
	SND_PCI_QUIRK(0x1043, 0x15a3, "ASUS N60Jv", ALC269_FIXUP_AMIC),
	SND_PCI_QUIRK(0x1043, 0x15b3, "ASUS N60Dp", ALC269_FIXUP_AMIC),
	SND_PCI_QUIRK(0x1043, 0x15c3, "ASUS N70De", ALC269_FIXUP_AMIC),
	SND_PCI_QUIRK(0x1043, 0x15e3, "ASUS F83T", ALC269_FIXUP_AMIC),
	SND_PCI_QUIRK(0x1043, 0x1643, "ASUS M60J", ALC269_FIXUP_AMIC),
	SND_PCI_QUIRK(0x1043, 0x1653, "ASUS U50", ALC269_FIXUP_AMIC),
	SND_PCI_QUIRK(0x1043, 0x1693, "ASUS F50N", ALC269_FIXUP_AMIC),
	SND_PCI_QUIRK(0x1043, 0x16a3, "ASUS F5Q", ALC269_FIXUP_AMIC),
	SND_PCI_QUIRK(0x1043, 0x1723, "ASUS P80", ALC269_FIXUP_AMIC),
	SND_PCI_QUIRK(0x1043, 0x1743, "ASUS U80", ALC269_FIXUP_AMIC),
	SND_PCI_QUIRK(0x1043, 0x1773, "ASUS U20A", ALC269_FIXUP_AMIC),
	SND_PCI_QUIRK(0x1043, 0x1883, "ASUS F81Se", ALC269_FIXUP_AMIC),
	SND_PCI_QUIRK(0x152d, 0x1778, "Quanta ON1", ALC269_FIXUP_DMIC),
	SND_PCI_QUIRK(0x17aa, 0x3be9, "Quanta Wistron", ALC269_FIXUP_AMIC),
	SND_PCI_QUIRK(0x17aa, 0x3bf8, "Quanta FL1", ALC269_FIXUP_AMIC),
	SND_PCI_QUIRK(0x17ff, 0x059a, "Quanta EL3", ALC269_FIXUP_DMIC),
	SND_PCI_QUIRK(0x17ff, 0x059b, "Quanta JR1", ALC269_FIXUP_DMIC),
#endif
	{}
};

6682 6683 6684 6685 6686 6687 6688 6689
static const struct snd_pci_quirk alc269_fixup_vendor_tbl[] = {
	SND_PCI_QUIRK_VENDOR(0x1025, "Acer Aspire", ALC271_FIXUP_DMIC),
	SND_PCI_QUIRK_VENDOR(0x103c, "HP", ALC269_FIXUP_HP_MUTE_LED),
	SND_PCI_QUIRK_VENDOR(0x104d, "Sony VAIO", ALC269_FIXUP_SONY_VAIO),
	SND_PCI_QUIRK_VENDOR(0x17aa, "Thinkpad", ALC269_FIXUP_THINKPAD_ACPI),
	{}
};

6690
static const struct hda_model_fixup alc269_fixup_models[] = {
6691 6692
	{.id = ALC269_FIXUP_AMIC, .name = "laptop-amic"},
	{.id = ALC269_FIXUP_DMIC, .name = "laptop-dmic"},
6693 6694 6695
	{.id = ALC269_FIXUP_STEREO_DMIC, .name = "alc269-dmic"},
	{.id = ALC271_FIXUP_DMIC, .name = "alc271-dmic"},
	{.id = ALC269_FIXUP_INV_DMIC, .name = "inv-dmic"},
6696
	{.id = ALC269_FIXUP_HEADSET_MIC, .name = "headset-mic"},
6697 6698
	{.id = ALC269_FIXUP_HEADSET_MODE, .name = "headset-mode"},
	{.id = ALC269_FIXUP_HEADSET_MODE_NO_HP_MIC, .name = "headset-mode-no-hp-mic"},
6699
	{.id = ALC269_FIXUP_LENOVO_DOCK, .name = "lenovo-dock"},
6700
	{.id = ALC269_FIXUP_HP_GPIO_LED, .name = "hp-gpio-led"},
6701
	{.id = ALC269_FIXUP_HP_DOCK_GPIO_MIC1_LED, .name = "hp-dock-gpio-mic1-led"},
6702 6703
	{.id = ALC269_FIXUP_DELL1_MIC_NO_PRESENCE, .name = "dell-headset-multi"},
	{.id = ALC269_FIXUP_DELL2_MIC_NO_PRESENCE, .name = "dell-headset-dock"},
6704
	{.id = ALC283_FIXUP_CHROME_BOOK, .name = "alc283-dac-wcaps"},
6705
	{.id = ALC283_FIXUP_SENSE_COMBO_JACK, .name = "alc283-sense-combo"},
6706
	{.id = ALC292_FIXUP_TPT440_DOCK, .name = "tpt440-dock"},
6707
	{.id = ALC292_FIXUP_TPT440, .name = "tpt440"},
6708
	{.id = ALC292_FIXUP_TPT460, .name = "tpt460"},
6709
	{.id = ALC233_FIXUP_LENOVO_MULTI_CODECS, .name = "dual-codecs"},
6710
	{.id = ALC700_FIXUP_INTEL_REFERENCE, .name = "alc700-ref"},
6711
	{}
K
Kailang Yang 已提交
6712
};
6713 6714
#define ALC225_STANDARD_PINS \
	{0x21, 0x04211020}
K
Kailang Yang 已提交
6715

6716 6717 6718 6719 6720
#define ALC256_STANDARD_PINS \
	{0x12, 0x90a60140}, \
	{0x14, 0x90170110}, \
	{0x21, 0x02211020}

6721
#define ALC282_STANDARD_PINS \
6722
	{0x14, 0x90170110}
6723

6724
#define ALC290_STANDARD_PINS \
6725
	{0x12, 0x99a30130}
6726 6727 6728

#define ALC292_STANDARD_PINS \
	{0x14, 0x90170110}, \
6729
	{0x15, 0x0221401f}
6730

6731 6732 6733 6734 6735
#define ALC295_STANDARD_PINS \
	{0x12, 0xb7a60130}, \
	{0x14, 0x90170110}, \
	{0x21, 0x04211020}

6736 6737 6738 6739
#define ALC298_STANDARD_PINS \
	{0x12, 0x90a60130}, \
	{0x21, 0x03211020}

6740
static const struct snd_hda_pin_quirk alc269_pin_fixup_tbl[] = {
6741 6742 6743 6744
	SND_HDA_PIN_QUIRK(0x10ec0255, 0x1025, "Acer", ALC255_FIXUP_ACER_MIC_NO_PRESENCE,
		{0x12, 0x90a601c0},
		{0x14, 0x90171120},
		{0x21, 0x02211030}),
6745 6746 6747 6748 6749 6750 6751 6752
	SND_HDA_PIN_QUIRK(0x10ec0255, 0x1043, "ASUS", ALC255_FIXUP_ASUS_MIC_NO_PRESENCE,
		{0x14, 0x90170110},
		{0x1b, 0x90a70130},
		{0x21, 0x03211020}),
	SND_HDA_PIN_QUIRK(0x10ec0255, 0x1043, "ASUS", ALC255_FIXUP_ASUS_MIC_NO_PRESENCE,
		{0x1a, 0x90a70130},
		{0x1b, 0x90170110},
		{0x21, 0x03211020}),
6753
	SND_HDA_PIN_QUIRK(0x10ec0225, 0x1028, "Dell", ALC225_FIXUP_DELL1_MIC_NO_PRESENCE,
6754
		ALC225_STANDARD_PINS,
6755
		{0x12, 0xb7a60130},
6756
		{0x14, 0x901701a0}),
6757
	SND_HDA_PIN_QUIRK(0x10ec0225, 0x1028, "Dell", ALC225_FIXUP_DELL1_MIC_NO_PRESENCE,
6758
		ALC225_STANDARD_PINS,
6759
		{0x12, 0xb7a60130},
6760
		{0x14, 0x901701b0}),
6761 6762 6763 6764 6765 6766 6767 6768 6769 6770 6771 6772
	SND_HDA_PIN_QUIRK(0x10ec0225, 0x1028, "Dell", ALC225_FIXUP_DELL1_MIC_NO_PRESENCE,
		ALC225_STANDARD_PINS,
		{0x12, 0xb7a60150},
		{0x14, 0x901701a0}),
	SND_HDA_PIN_QUIRK(0x10ec0225, 0x1028, "Dell", ALC225_FIXUP_DELL1_MIC_NO_PRESENCE,
		ALC225_STANDARD_PINS,
		{0x12, 0xb7a60150},
		{0x14, 0x901701b0}),
	SND_HDA_PIN_QUIRK(0x10ec0225, 0x1028, "Dell", ALC225_FIXUP_DELL1_MIC_NO_PRESENCE,
		ALC225_STANDARD_PINS,
		{0x12, 0xb7a60130},
		{0x1b, 0x90170110}),
6773 6774 6775 6776
	SND_HDA_PIN_QUIRK(0x10ec0233, 0x8086, "Intel NUC Skull Canyon", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE,
		{0x1b, 0x01111010},
		{0x1e, 0x01451130},
		{0x21, 0x02211020}),
6777 6778 6779 6780 6781
	SND_HDA_PIN_QUIRK(0x10ec0235, 0x17aa, "Lenovo", ALC233_FIXUP_LENOVO_LINE2_MIC_HOTKEY,
		{0x12, 0x90a60140},
		{0x14, 0x90170110},
		{0x19, 0x02a11030},
		{0x21, 0x02211020}),
6782 6783 6784 6785 6786 6787 6788 6789
	SND_HDA_PIN_QUIRK(0x10ec0236, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
		{0x12, 0x90a60140},
		{0x14, 0x90170110},
		{0x21, 0x02211020}),
	SND_HDA_PIN_QUIRK(0x10ec0236, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
		{0x12, 0x90a60140},
		{0x14, 0x90170150},
		{0x21, 0x02211020}),
6790 6791 6792
	SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL2_MIC_NO_PRESENCE,
		{0x14, 0x90170110},
		{0x21, 0x02211020}),
6793 6794 6795
	SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
		{0x14, 0x90170130},
		{0x21, 0x02211040}),
6796 6797 6798 6799 6800 6801 6802 6803
	SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
		{0x12, 0x90a60140},
		{0x14, 0x90170110},
		{0x21, 0x02211020}),
	SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
		{0x12, 0x90a60160},
		{0x14, 0x90170120},
		{0x21, 0x02211030}),
6804 6805 6806 6807
	SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
		{0x14, 0x90170110},
		{0x1b, 0x02011020},
		{0x21, 0x0221101f}),
6808 6809 6810 6811
	SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
		{0x14, 0x90170110},
		{0x1b, 0x01011020},
		{0x21, 0x0221101f}),
6812 6813 6814 6815
	SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
		{0x14, 0x90170130},
		{0x1b, 0x01014020},
		{0x21, 0x0221103f}),
6816 6817 6818 6819
	SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
		{0x14, 0x90170130},
		{0x1b, 0x01011020},
		{0x21, 0x0221103f}),
6820 6821 6822 6823
	SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
		{0x14, 0x90170130},
		{0x1b, 0x02011020},
		{0x21, 0x0221103f}),
6824 6825 6826 6827 6828 6829 6830 6831
	SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
		{0x14, 0x90170150},
		{0x1b, 0x02011020},
		{0x21, 0x0221105f}),
	SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
		{0x14, 0x90170110},
		{0x1b, 0x01014020},
		{0x21, 0x0221101f}),
6832 6833 6834 6835 6836 6837 6838 6839 6840 6841 6842 6843 6844 6845 6846 6847 6848 6849 6850 6851 6852
	SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
		{0x12, 0x90a60160},
		{0x14, 0x90170120},
		{0x17, 0x90170140},
		{0x21, 0x0321102f}),
	SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
		{0x12, 0x90a60160},
		{0x14, 0x90170130},
		{0x21, 0x02211040}),
	SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
		{0x12, 0x90a60160},
		{0x14, 0x90170140},
		{0x21, 0x02211050}),
	SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
		{0x12, 0x90a60170},
		{0x14, 0x90170120},
		{0x21, 0x02211030}),
	SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
		{0x12, 0x90a60170},
		{0x14, 0x90170130},
		{0x21, 0x02211040}),
6853 6854 6855 6856
	SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
		{0x12, 0x90a60170},
		{0x14, 0x90171130},
		{0x21, 0x02211040}),
6857 6858 6859 6860
	SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
		{0x12, 0x90a60170},
		{0x14, 0x90170140},
		{0x21, 0x02211050}),
6861 6862 6863 6864
	SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell Inspiron 5548", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
		{0x12, 0x90a60180},
		{0x14, 0x90170130},
		{0x21, 0x02211040}),
6865 6866 6867 6868
	SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell Inspiron 5565", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
		{0x12, 0x90a60180},
		{0x14, 0x90170120},
		{0x21, 0x02211030}),
6869 6870 6871
	SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
		{0x1b, 0x01011020},
		{0x21, 0x02211010}),
6872 6873 6874 6875 6876
	SND_HDA_PIN_QUIRK(0x10ec0256, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
		{0x12, 0x90a60130},
		{0x14, 0x90170110},
		{0x1b, 0x01011020},
		{0x21, 0x0221101f}),
6877 6878 6879 6880
	SND_HDA_PIN_QUIRK(0x10ec0256, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
		{0x12, 0x90a60160},
		{0x14, 0x90170120},
		{0x21, 0x02211030}),
6881 6882 6883 6884
	SND_HDA_PIN_QUIRK(0x10ec0256, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
		{0x12, 0x90a60170},
		{0x14, 0x90170120},
		{0x21, 0x02211030}),
6885 6886 6887 6888
	SND_HDA_PIN_QUIRK(0x10ec0256, 0x1028, "Dell Inspiron 5468", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
		{0x12, 0x90a60180},
		{0x14, 0x90170120},
		{0x21, 0x02211030}),
6889 6890 6891 6892
	SND_HDA_PIN_QUIRK(0x10ec0256, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
		{0x12, 0xb7a60130},
		{0x14, 0x90170110},
		{0x21, 0x02211020}),
6893 6894 6895 6896 6897
	SND_HDA_PIN_QUIRK(0x10ec0256, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
		{0x12, 0x90a60130},
		{0x14, 0x90170110},
		{0x14, 0x01011020},
		{0x21, 0x0221101f}),
6898
	SND_HDA_PIN_QUIRK(0x10ec0256, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
6899
		ALC256_STANDARD_PINS),
6900 6901 6902 6903 6904 6905 6906 6907
	SND_HDA_PIN_QUIRK(0x10ec0256, 0x1043, "ASUS", ALC256_FIXUP_ASUS_MIC,
		{0x14, 0x90170110},
		{0x1b, 0x90a70130},
		{0x21, 0x04211020}),
	SND_HDA_PIN_QUIRK(0x10ec0256, 0x1043, "ASUS", ALC256_FIXUP_ASUS_MIC,
		{0x14, 0x90170110},
		{0x1b, 0x90a70130},
		{0x21, 0x03211020}),
6908
	SND_HDA_PIN_QUIRK(0x10ec0274, 0x1028, "Dell", ALC274_FIXUP_DELL_AIO_LINEOUT_VERB,
6909 6910 6911 6912
		{0x12, 0xb7a60130},
		{0x13, 0xb8a61140},
		{0x16, 0x90170110},
		{0x21, 0x04211020}),
6913 6914 6915 6916
	SND_HDA_PIN_QUIRK(0x10ec0280, 0x103c, "HP", ALC280_FIXUP_HP_GPIO4,
		{0x12, 0x90a60130},
		{0x14, 0x90170110},
		{0x15, 0x0421101f},
6917
		{0x1a, 0x04a11020}),
6918 6919 6920 6921 6922 6923
	SND_HDA_PIN_QUIRK(0x10ec0280, 0x103c, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED,
		{0x12, 0x90a60140},
		{0x14, 0x90170110},
		{0x15, 0x0421101f},
		{0x18, 0x02811030},
		{0x1a, 0x04a1103f},
6924
		{0x1b, 0x02011020}),
6925
	SND_HDA_PIN_QUIRK(0x10ec0282, 0x103c, "HP 15 Touchsmart", ALC269_FIXUP_HP_MUTE_LED_MIC1,
6926
		ALC282_STANDARD_PINS,
6927 6928 6929
		{0x12, 0x99a30130},
		{0x19, 0x03a11020},
		{0x21, 0x0321101f}),
6930
	SND_HDA_PIN_QUIRK(0x10ec0282, 0x103c, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1,
6931
		ALC282_STANDARD_PINS,
6932 6933 6934 6935
		{0x12, 0x99a30130},
		{0x19, 0x03a11020},
		{0x21, 0x03211040}),
	SND_HDA_PIN_QUIRK(0x10ec0282, 0x103c, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1,
6936
		ALC282_STANDARD_PINS,
6937 6938 6939 6940
		{0x12, 0x99a30130},
		{0x19, 0x03a11030},
		{0x21, 0x03211020}),
	SND_HDA_PIN_QUIRK(0x10ec0282, 0x103c, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1,
6941
		ALC282_STANDARD_PINS,
6942 6943 6944
		{0x12, 0x99a30130},
		{0x19, 0x04a11020},
		{0x21, 0x0421101f}),
6945
	SND_HDA_PIN_QUIRK(0x10ec0282, 0x103c, "HP", ALC269_FIXUP_HP_LINE1_MIC1_LED,
6946
		ALC282_STANDARD_PINS,
6947 6948 6949
		{0x12, 0x90a60140},
		{0x19, 0x04a11030},
		{0x21, 0x04211020}),
6950
	SND_HDA_PIN_QUIRK(0x10ec0283, 0x1028, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE,
6951
		ALC282_STANDARD_PINS,
6952 6953 6954 6955 6956 6957
		{0x12, 0x90a60130},
		{0x21, 0x0321101f}),
	SND_HDA_PIN_QUIRK(0x10ec0283, 0x1028, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE,
		{0x12, 0x90a60160},
		{0x14, 0x90170120},
		{0x21, 0x02211030}),
6958
	SND_HDA_PIN_QUIRK(0x10ec0283, 0x1028, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE,
6959
		ALC282_STANDARD_PINS,
6960 6961 6962
		{0x12, 0x90a60130},
		{0x19, 0x03a11020},
		{0x21, 0x0321101f}),
6963 6964 6965 6966
	SND_HDA_PIN_QUIRK(0x10ec0288, 0x1028, "Dell", ALC288_FIXUP_DELL_XPS_13_GPIO6,
		{0x12, 0x90a60120},
		{0x14, 0x90170110},
		{0x21, 0x0321101f}),
6967
	SND_HDA_PIN_QUIRK(0x10ec0289, 0x1028, "Dell", ALC269_FIXUP_DELL4_MIC_NO_PRESENCE,
6968 6969 6970
		{0x12, 0xb7a60130},
		{0x14, 0x90170110},
		{0x21, 0x04211020}),
6971
	SND_HDA_PIN_QUIRK(0x10ec0290, 0x103c, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1,
6972
		ALC290_STANDARD_PINS,
6973 6974
		{0x15, 0x04211040},
		{0x18, 0x90170112},
6975
		{0x1a, 0x04a11020}),
6976
	SND_HDA_PIN_QUIRK(0x10ec0290, 0x103c, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1,
6977
		ALC290_STANDARD_PINS,
6978 6979
		{0x15, 0x04211040},
		{0x18, 0x90170110},
6980
		{0x1a, 0x04a11020}),
6981
	SND_HDA_PIN_QUIRK(0x10ec0290, 0x103c, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1,
6982
		ALC290_STANDARD_PINS,
6983
		{0x15, 0x0421101f},
6984
		{0x1a, 0x04a11020}),
6985
	SND_HDA_PIN_QUIRK(0x10ec0290, 0x103c, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1,
6986
		ALC290_STANDARD_PINS,
6987
		{0x15, 0x04211020},
6988
		{0x1a, 0x04a11040}),
6989
	SND_HDA_PIN_QUIRK(0x10ec0290, 0x103c, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1,
6990
		ALC290_STANDARD_PINS,
6991 6992
		{0x14, 0x90170110},
		{0x15, 0x04211020},
6993
		{0x1a, 0x04a11040}),
6994
	SND_HDA_PIN_QUIRK(0x10ec0290, 0x103c, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1,
6995
		ALC290_STANDARD_PINS,
6996 6997
		{0x14, 0x90170110},
		{0x15, 0x04211020},
6998
		{0x1a, 0x04a11020}),
6999
	SND_HDA_PIN_QUIRK(0x10ec0290, 0x103c, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1,
7000
		ALC290_STANDARD_PINS,
7001 7002
		{0x14, 0x90170110},
		{0x15, 0x0421101f},
7003
		{0x1a, 0x04a11020}),
7004
	SND_HDA_PIN_QUIRK(0x10ec0292, 0x1028, "Dell", ALC269_FIXUP_DELL2_MIC_NO_PRESENCE,
7005
		ALC292_STANDARD_PINS,
7006 7007
		{0x12, 0x90a60140},
		{0x16, 0x01014020},
7008
		{0x19, 0x01a19030}),
7009
	SND_HDA_PIN_QUIRK(0x10ec0292, 0x1028, "Dell", ALC269_FIXUP_DELL2_MIC_NO_PRESENCE,
7010
		ALC292_STANDARD_PINS,
7011 7012 7013
		{0x12, 0x90a60140},
		{0x16, 0x01014020},
		{0x18, 0x02a19031},
7014
		{0x19, 0x01a1903e}),
7015
	SND_HDA_PIN_QUIRK(0x10ec0292, 0x1028, "Dell", ALC269_FIXUP_DELL3_MIC_NO_PRESENCE,
7016
		ALC292_STANDARD_PINS,
7017
		{0x12, 0x90a60140}),
7018
	SND_HDA_PIN_QUIRK(0x10ec0293, 0x1028, "Dell", ALC293_FIXUP_DELL1_MIC_NO_PRESENCE,
7019
		ALC292_STANDARD_PINS,
7020 7021
		{0x13, 0x90a60140},
		{0x16, 0x21014020},
7022
		{0x19, 0x21a19030}),
7023
	SND_HDA_PIN_QUIRK(0x10ec0293, 0x1028, "Dell", ALC293_FIXUP_DELL1_MIC_NO_PRESENCE,
7024
		ALC292_STANDARD_PINS,
7025
		{0x13, 0x90a60140}),
7026
	SND_HDA_PIN_QUIRK(0x10ec0295, 0x1028, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE,
7027 7028 7029 7030 7031 7032 7033
		ALC295_STANDARD_PINS,
		{0x17, 0x21014020},
		{0x18, 0x21a19030}),
	SND_HDA_PIN_QUIRK(0x10ec0295, 0x1028, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE,
		ALC295_STANDARD_PINS,
		{0x17, 0x21014040},
		{0x18, 0x21a19050}),
7034 7035
	SND_HDA_PIN_QUIRK(0x10ec0295, 0x1028, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE,
		ALC295_STANDARD_PINS),
7036 7037 7038
	SND_HDA_PIN_QUIRK(0x10ec0298, 0x1028, "Dell", ALC298_FIXUP_DELL1_MIC_NO_PRESENCE,
		ALC298_STANDARD_PINS,
		{0x17, 0x90170110}),
7039
	SND_HDA_PIN_QUIRK(0x10ec0298, 0x1028, "Dell", ALC298_FIXUP_DELL1_MIC_NO_PRESENCE,
7040 7041 7042 7043
		ALC298_STANDARD_PINS,
		{0x17, 0x90170140}),
	SND_HDA_PIN_QUIRK(0x10ec0298, 0x1028, "Dell", ALC298_FIXUP_DELL1_MIC_NO_PRESENCE,
		ALC298_STANDARD_PINS,
7044
		{0x17, 0x90170150}),
7045 7046 7047 7048 7049 7050
	SND_HDA_PIN_QUIRK(0x10ec0298, 0x1028, "Dell", ALC298_FIXUP_SPK_VOLUME,
		{0x12, 0xb7a60140},
		{0x13, 0xb7a60150},
		{0x17, 0x90170110},
		{0x1a, 0x03011020},
		{0x21, 0x03211030}),
7051 7052 7053 7054
	SND_HDA_PIN_QUIRK(0x10ec0299, 0x1028, "Dell", ALC269_FIXUP_DELL4_MIC_NO_PRESENCE,
		ALC225_STANDARD_PINS,
		{0x12, 0xb7a60130},
		{0x17, 0x90170110}),
7055 7056
	{}
};
K
Kailang Yang 已提交
7057

7058
static void alc269_fill_coef(struct hda_codec *codec)
7059
{
7060
	struct alc_spec *spec = codec->spec;
7061
	int val;
7062

7063
	if (spec->codec_variant != ALC269_TYPE_ALC269VB)
7064
		return;
7065

7066
	if ((alc_get_coef0(codec) & 0x00ff) < 0x015) {
7067 7068 7069
		alc_write_coef_idx(codec, 0xf, 0x960b);
		alc_write_coef_idx(codec, 0xe, 0x8817);
	}
7070

7071
	if ((alc_get_coef0(codec) & 0x00ff) == 0x016) {
7072 7073 7074
		alc_write_coef_idx(codec, 0xf, 0x960b);
		alc_write_coef_idx(codec, 0xe, 0x8814);
	}
7075

7076
	if ((alc_get_coef0(codec) & 0x00ff) == 0x017) {
7077
		/* Power up output pin */
7078
		alc_update_coef_idx(codec, 0x04, 0, 1<<11);
7079
	}
7080

7081
	if ((alc_get_coef0(codec) & 0x00ff) == 0x018) {
7082
		val = alc_read_coef_idx(codec, 0xd);
7083
		if (val != -1 && (val & 0x0c00) >> 10 != 0x1) {
7084 7085 7086 7087
			/* Capless ramp up clock control */
			alc_write_coef_idx(codec, 0xd, val | (1<<10));
		}
		val = alc_read_coef_idx(codec, 0x17);
7088
		if (val != -1 && (val & 0x01c0) >> 6 != 0x4) {
7089 7090 7091 7092
			/* Class D power on reset */
			alc_write_coef_idx(codec, 0x17, val | (1<<7));
		}
	}
7093

7094 7095
	/* HP */
	alc_update_coef_idx(codec, 0x4, 0, 1<<11);
7096
}
7097

7098 7099 7100 7101 7102
/*
 */
static int patch_alc269(struct hda_codec *codec)
{
	struct alc_spec *spec;
7103
	int err;
7104

7105
	err = alc_alloc_spec(codec, 0x0b);
7106
	if (err < 0)
7107 7108 7109
		return err;

	spec = codec->spec;
7110
	spec->gen.shared_mic_vref_pin = 0x18;
7111
	codec->power_save_node = 1;
7112

7113 7114 7115 7116
#ifdef CONFIG_PM
	codec->patch_ops.suspend = alc269_suspend;
	codec->patch_ops.resume = alc269_resume;
#endif
7117 7118
	spec->shutup = alc_default_shutup;
	spec->init_hook = alc_default_init;
7119

7120
	snd_hda_pick_fixup(codec, alc269_fixup_models,
7121
		       alc269_fixup_tbl, alc269_fixups);
7122
	snd_hda_pick_pin_fixup(codec, alc269_pin_fixup_tbl, alc269_fixups);
7123 7124
	snd_hda_pick_fixup(codec, NULL,	alc269_fixup_vendor_tbl,
			   alc269_fixups);
7125
	snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE);
7126 7127 7128

	alc_auto_parse_customize_define(codec);

7129 7130 7131
	if (has_cdefine_beep(codec))
		spec->gen.beep_nid = 0x01;

7132
	switch (codec->core.vendor_id) {
7133
	case 0x10ec0269:
7134
		spec->codec_variant = ALC269_TYPE_ALC269VA;
7135 7136
		switch (alc_get_coef0(codec) & 0x00f0) {
		case 0x0010:
7137 7138
			if (codec->bus->pci &&
			    codec->bus->pci->subsystem_vendor == 0x1025 &&
7139
			    spec->cdefine.platform_type == 1)
7140
				err = alc_codec_rename(codec, "ALC271X");
7141
			spec->codec_variant = ALC269_TYPE_ALC269VB;
7142 7143
			break;
		case 0x0020:
7144 7145
			if (codec->bus->pci &&
			    codec->bus->pci->subsystem_vendor == 0x17aa &&
7146
			    codec->bus->pci->subsystem_device == 0x21f3)
7147
				err = alc_codec_rename(codec, "ALC3202");
7148
			spec->codec_variant = ALC269_TYPE_ALC269VC;
7149
			break;
7150 7151 7152
		case 0x0030:
			spec->codec_variant = ALC269_TYPE_ALC269VD;
			break;
7153
		default:
7154
			alc_fix_pll_init(codec, 0x20, 0x04, 15);
7155
		}
7156 7157
		if (err < 0)
			goto error;
7158
		spec->shutup = alc269_shutup;
7159
		spec->init_hook = alc269_fill_coef;
7160
		alc269_fill_coef(codec);
7161 7162 7163 7164 7165 7166 7167 7168
		break;

	case 0x10ec0280:
	case 0x10ec0290:
		spec->codec_variant = ALC269_TYPE_ALC280;
		break;
	case 0x10ec0282:
		spec->codec_variant = ALC269_TYPE_ALC282;
7169 7170
		spec->shutup = alc282_shutup;
		spec->init_hook = alc282_init;
7171
		break;
7172 7173 7174 7175 7176 7177
	case 0x10ec0233:
	case 0x10ec0283:
		spec->codec_variant = ALC269_TYPE_ALC283;
		spec->shutup = alc283_shutup;
		spec->init_hook = alc283_init;
		break;
7178 7179 7180 7181
	case 0x10ec0284:
	case 0x10ec0292:
		spec->codec_variant = ALC269_TYPE_ALC284;
		break;
7182
	case 0x10ec0293:
7183
		spec->codec_variant = ALC269_TYPE_ALC293;
7184
		break;
7185
	case 0x10ec0286:
7186
	case 0x10ec0288:
7187
		spec->codec_variant = ALC269_TYPE_ALC286;
7188
		spec->shutup = alc286_shutup;
7189
		break;
7190 7191 7192
	case 0x10ec0298:
		spec->codec_variant = ALC269_TYPE_ALC298;
		break;
7193
	case 0x10ec0235:
7194 7195
	case 0x10ec0255:
		spec->codec_variant = ALC269_TYPE_ALC255;
7196 7197
		spec->shutup = alc256_shutup;
		spec->init_hook = alc256_init;
7198
		break;
7199
	case 0x10ec0236:
7200 7201
	case 0x10ec0256:
		spec->codec_variant = ALC269_TYPE_ALC256;
7202 7203
		spec->shutup = alc256_shutup;
		spec->init_hook = alc256_init;
7204
		spec->gen.mixer_nid = 0; /* ALC256 does not have any loopback mixer path */
7205
		alc_update_coef_idx(codec, 0x36, 1 << 13, 1 << 5); /* Switch pcbeep path to Line in path*/
7206
		break;
7207 7208
	case 0x10ec0257:
		spec->codec_variant = ALC269_TYPE_ALC257;
7209 7210
		spec->shutup = alc256_shutup;
		spec->init_hook = alc256_init;
7211 7212
		spec->gen.mixer_nid = 0;
		break;
7213 7214 7215 7216
	case 0x10ec0215:
	case 0x10ec0285:
	case 0x10ec0289:
		spec->codec_variant = ALC269_TYPE_ALC215;
7217 7218
		spec->shutup = alc225_shutup;
		spec->init_hook = alc225_init;
7219 7220
		spec->gen.mixer_nid = 0;
		break;
7221
	case 0x10ec0225:
7222
	case 0x10ec0295:
7223
	case 0x10ec0299:
7224
		spec->codec_variant = ALC269_TYPE_ALC225;
7225 7226
		spec->shutup = alc225_shutup;
		spec->init_hook = alc225_init;
7227
		spec->gen.mixer_nid = 0; /* no loopback on ALC225, ALC295 and ALC299 */
7228
		break;
7229 7230 7231 7232
	case 0x10ec0234:
	case 0x10ec0274:
	case 0x10ec0294:
		spec->codec_variant = ALC269_TYPE_ALC294;
7233
		spec->gen.mixer_nid = 0; /* ALC2x4 does not have any loopback mixer path */
7234
		alc_update_coef_idx(codec, 0x6b, 0x0018, (1<<4) | (1<<3)); /* UAJ MIC Vref control by verb */
7235
		break;
7236 7237 7238 7239 7240
	case 0x10ec0700:
	case 0x10ec0701:
	case 0x10ec0703:
		spec->codec_variant = ALC269_TYPE_ALC700;
		spec->gen.mixer_nid = 0; /* ALC700 does not have any loopback mixer path */
7241
		alc_update_coef_idx(codec, 0x4a, 1 << 15, 0); /* Combo jack auto trigger control */
7242 7243
		break;

7244
	}
K
Kailang Yang 已提交
7245

7246
	if (snd_hda_codec_read(codec, 0x51, 0, AC_VERB_PARAMETERS, 0) == 0x10ec5505) {
7247
		spec->has_alc5505_dsp = 1;
7248 7249 7250
		spec->init_hook = alc5505_dsp_init;
	}

7251 7252
	/* automatic parse from the BIOS config */
	err = alc269_parse_auto_config(codec);
7253 7254
	if (err < 0)
		goto error;
K
Kailang Yang 已提交
7255

7256 7257
	if (!spec->gen.no_analog && spec->gen.beep_nid && spec->gen.mixer_nid)
		set_beep_amp(spec, spec->gen.mixer_nid, 0x04, HDA_INPUT);
7258

7259
	snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE);
7260

7261
	return 0;
7262 7263 7264 7265

 error:
	alc_free(codec);
	return err;
7266
}
7267

7268 7269 7270
/*
 * ALC861
 */
7271

7272
static int alc861_parse_auto_config(struct hda_codec *codec)
K
Kailang Yang 已提交
7273
{
7274
	static const hda_nid_t alc861_ignore[] = { 0x1d, 0 };
7275 7276
	static const hda_nid_t alc861_ssids[] = { 0x0e, 0x0f, 0x0b, 0 };
	return alc_parse_auto_config(codec, alc861_ignore, alc861_ssids);
7277 7278
}

7279 7280
/* Pin config fixes */
enum {
7281 7282 7283 7284
	ALC861_FIXUP_FSC_AMILO_PI1505,
	ALC861_FIXUP_AMP_VREF_0F,
	ALC861_FIXUP_NO_JACK_DETECT,
	ALC861_FIXUP_ASUS_A6RP,
7285
	ALC660_FIXUP_ASUS_W7J,
7286
};
7287

7288 7289
/* On some laptops, VREF of pin 0x0f is abused for controlling the main amp */
static void alc861_fixup_asus_amp_vref_0f(struct hda_codec *codec,
7290
			const struct hda_fixup *fix, int action)
7291 7292 7293 7294
{
	struct alc_spec *spec = codec->spec;
	unsigned int val;

7295
	if (action != HDA_FIXUP_ACT_INIT)
7296
		return;
7297
	val = snd_hda_codec_get_pin_target(codec, 0x0f);
7298 7299 7300
	if (!(val & (AC_PINCTL_IN_EN | AC_PINCTL_OUT_EN)))
		val |= AC_PINCTL_IN_EN;
	val |= AC_PINCTL_VREF_50;
7301
	snd_hda_set_pin_ctl(codec, 0x0f, val);
7302
	spec->gen.keep_vref_in_automute = 1;
7303 7304
}

7305 7306
/* suppress the jack-detection */
static void alc_fixup_no_jack_detect(struct hda_codec *codec,
7307
				     const struct hda_fixup *fix, int action)
7308
{
7309
	if (action == HDA_FIXUP_ACT_PRE_PROBE)
7310
		codec->no_jack_detect = 1;
7311
}
7312

7313
static const struct hda_fixup alc861_fixups[] = {
7314
	[ALC861_FIXUP_FSC_AMILO_PI1505] = {
7315 7316
		.type = HDA_FIXUP_PINS,
		.v.pins = (const struct hda_pintbl[]) {
7317 7318 7319 7320 7321
			{ 0x0b, 0x0221101f }, /* HP */
			{ 0x0f, 0x90170310 }, /* speaker */
			{ }
		}
	},
7322
	[ALC861_FIXUP_AMP_VREF_0F] = {
7323
		.type = HDA_FIXUP_FUNC,
7324
		.v.func = alc861_fixup_asus_amp_vref_0f,
7325
	},
7326
	[ALC861_FIXUP_NO_JACK_DETECT] = {
7327
		.type = HDA_FIXUP_FUNC,
7328 7329 7330
		.v.func = alc_fixup_no_jack_detect,
	},
	[ALC861_FIXUP_ASUS_A6RP] = {
7331
		.type = HDA_FIXUP_FUNC,
7332 7333 7334
		.v.func = alc861_fixup_asus_amp_vref_0f,
		.chained = true,
		.chain_id = ALC861_FIXUP_NO_JACK_DETECT,
7335 7336 7337 7338 7339 7340 7341 7342 7343 7344
	},
	[ALC660_FIXUP_ASUS_W7J] = {
		.type = HDA_FIXUP_VERBS,
		.v.verbs = (const struct hda_verb[]) {
			/* ASUS W7J needs a magic pin setup on unused NID 0x10
			 * for enabling outputs
			 */
			{0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
			{ }
		},
7345
	}
7346
};
7347

7348
static const struct snd_pci_quirk alc861_fixup_tbl[] = {
7349
	SND_PCI_QUIRK(0x1043, 0x1253, "ASUS W7J", ALC660_FIXUP_ASUS_W7J),
7350
	SND_PCI_QUIRK(0x1043, 0x1263, "ASUS Z35HL", ALC660_FIXUP_ASUS_W7J),
7351 7352 7353 7354 7355 7356
	SND_PCI_QUIRK(0x1043, 0x1393, "ASUS A6Rp", ALC861_FIXUP_ASUS_A6RP),
	SND_PCI_QUIRK_VENDOR(0x1043, "ASUS laptop", ALC861_FIXUP_AMP_VREF_0F),
	SND_PCI_QUIRK(0x1462, 0x7254, "HP DX2200", ALC861_FIXUP_NO_JACK_DETECT),
	SND_PCI_QUIRK(0x1584, 0x2b01, "Haier W18", ALC861_FIXUP_AMP_VREF_0F),
	SND_PCI_QUIRK(0x1584, 0x0000, "Uniwill ECS M31EI", ALC861_FIXUP_AMP_VREF_0F),
	SND_PCI_QUIRK(0x1734, 0x10c7, "FSC Amilo Pi1505", ALC861_FIXUP_FSC_AMILO_PI1505),
7357 7358
	{}
};
7359

7360 7361 7362
/*
 */
static int patch_alc861(struct hda_codec *codec)
7363
{
7364 7365
	struct alc_spec *spec;
	int err;
7366

7367 7368 7369
	err = alc_alloc_spec(codec, 0x15);
	if (err < 0)
		return err;
7370

7371
	spec = codec->spec;
7372
	spec->gen.beep_nid = 0x23;
7373

7374 7375 7376 7377
#ifdef CONFIG_PM
	spec->power_hook = alc_power_eapd;
#endif

7378 7379
	snd_hda_pick_fixup(codec, NULL, alc861_fixup_tbl, alc861_fixups);
	snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE);
7380

7381 7382
	/* automatic parse from the BIOS config */
	err = alc861_parse_auto_config(codec);
7383 7384
	if (err < 0)
		goto error;
7385

7386
	if (!spec->gen.no_analog)
7387
		set_beep_amp(spec, 0x23, 0, HDA_OUTPUT);
7388

7389
	snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE);
7390

7391
	return 0;
7392 7393 7394 7395

 error:
	alc_free(codec);
	return err;
7396 7397
}

7398 7399 7400 7401 7402 7403 7404 7405
/*
 * ALC861-VD support
 *
 * Based on ALC882
 *
 * In addition, an independent DAC
 */
static int alc861vd_parse_auto_config(struct hda_codec *codec)
7406
{
7407
	static const hda_nid_t alc861vd_ignore[] = { 0x1d, 0 };
7408 7409
	static const hda_nid_t alc861vd_ssids[] = { 0x15, 0x1b, 0x14, 0 };
	return alc_parse_auto_config(codec, alc861vd_ignore, alc861vd_ssids);
7410 7411
}

7412
enum {
7413 7414
	ALC660VD_FIX_ASUS_GPIO1,
	ALC861VD_FIX_DALLAS,
7415
};
7416

7417 7418
/* exclude VREF80 */
static void alc861vd_fixup_dallas(struct hda_codec *codec,
7419
				  const struct hda_fixup *fix, int action)
7420
{
7421
	if (action == HDA_FIXUP_ACT_PRE_PROBE) {
7422 7423
		snd_hda_override_pin_caps(codec, 0x18, 0x00000734);
		snd_hda_override_pin_caps(codec, 0x19, 0x0000073c);
7424 7425 7426
	}
}

7427
static const struct hda_fixup alc861vd_fixups[] = {
7428
	[ALC660VD_FIX_ASUS_GPIO1] = {
7429
		.type = HDA_FIXUP_VERBS,
7430
		.v.verbs = (const struct hda_verb[]) {
7431
			/* reset GPIO1 */
7432 7433 7434 7435 7436 7437
			{0x01, AC_VERB_SET_GPIO_MASK, 0x03},
			{0x01, AC_VERB_SET_GPIO_DIRECTION, 0x01},
			{0x01, AC_VERB_SET_GPIO_DATA, 0x01},
			{ }
		}
	},
7438
	[ALC861VD_FIX_DALLAS] = {
7439
		.type = HDA_FIXUP_FUNC,
7440 7441
		.v.func = alc861vd_fixup_dallas,
	},
7442
};
7443

7444
static const struct snd_pci_quirk alc861vd_fixup_tbl[] = {
7445
	SND_PCI_QUIRK(0x103c, 0x30bf, "HP TX1000", ALC861VD_FIX_DALLAS),
7446
	SND_PCI_QUIRK(0x1043, 0x1339, "ASUS A7-K", ALC660VD_FIX_ASUS_GPIO1),
7447
	SND_PCI_QUIRK(0x1179, 0xff31, "Toshiba L30-149", ALC861VD_FIX_DALLAS),
7448 7449
	{}
};
7450

7451 7452 7453
/*
 */
static int patch_alc861vd(struct hda_codec *codec)
7454
{
7455
	struct alc_spec *spec;
7456
	int err;
7457

7458 7459 7460
	err = alc_alloc_spec(codec, 0x0b);
	if (err < 0)
		return err;
7461

7462
	spec = codec->spec;
7463
	spec->gen.beep_nid = 0x23;
7464

7465 7466
	spec->shutup = alc_eapd_shutup;

7467 7468
	snd_hda_pick_fixup(codec, NULL, alc861vd_fixup_tbl, alc861vd_fixups);
	snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE);
7469

7470 7471
	/* automatic parse from the BIOS config */
	err = alc861vd_parse_auto_config(codec);
7472 7473
	if (err < 0)
		goto error;
7474

7475
	if (!spec->gen.no_analog)
7476
		set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
7477

7478
	snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE);
7479

7480
	return 0;
7481 7482 7483 7484

 error:
	alc_free(codec);
	return err;
7485 7486
}

7487 7488 7489 7490 7491 7492 7493 7494 7495 7496 7497 7498 7499 7500 7501 7502
/*
 * ALC662 support
 *
 * ALC662 is almost identical with ALC880 but has cleaner and more flexible
 * configuration.  Each pin widget can choose any input DACs and a mixer.
 * Each ADC is connected from a mixer of all inputs.  This makes possible
 * 6-channel independent captures.
 *
 * In addition, an independent DAC for the multi-playback (not used in this
 * driver yet).
 */

/*
 * BIOS auto configuration
 */

7503 7504
static int alc662_parse_auto_config(struct hda_codec *codec)
{
7505
	static const hda_nid_t alc662_ignore[] = { 0x1d, 0 };
7506 7507 7508
	static const hda_nid_t alc663_ssids[] = { 0x15, 0x1b, 0x14, 0x21 };
	static const hda_nid_t alc662_ssids[] = { 0x15, 0x1b, 0x14, 0 };
	const hda_nid_t *ssids;
7509

7510 7511 7512
	if (codec->core.vendor_id == 0x10ec0272 || codec->core.vendor_id == 0x10ec0663 ||
	    codec->core.vendor_id == 0x10ec0665 || codec->core.vendor_id == 0x10ec0670 ||
	    codec->core.vendor_id == 0x10ec0671)
7513
		ssids = alc663_ssids;
7514
	else
7515 7516
		ssids = alc662_ssids;
	return alc_parse_auto_config(codec, alc662_ignore, ssids);
7517 7518
}

T
Todd Broch 已提交
7519
static void alc272_fixup_mario(struct hda_codec *codec,
7520
			       const struct hda_fixup *fix, int action)
7521
{
7522
	if (action != HDA_FIXUP_ACT_PRE_PROBE)
7523
		return;
T
Todd Broch 已提交
7524 7525 7526 7527 7528
	if (snd_hda_override_amp_caps(codec, 0x2, HDA_OUTPUT,
				      (0x3b << AC_AMPCAP_OFFSET_SHIFT) |
				      (0x3b << AC_AMPCAP_NUM_STEPS_SHIFT) |
				      (0x03 << AC_AMPCAP_STEP_SIZE_SHIFT) |
				      (0 << AC_AMPCAP_MUTE_SHIFT)))
7529
		codec_warn(codec, "failed to override amp caps for NID 0x2\n");
T
Todd Broch 已提交
7530 7531
}

7532 7533 7534 7535 7536 7537 7538 7539 7540 7541
static const struct snd_pcm_chmap_elem asus_pcm_2_1_chmaps[] = {
	{ .channels = 2,
	  .map = { SNDRV_CHMAP_FL, SNDRV_CHMAP_FR } },
	{ .channels = 4,
	  .map = { SNDRV_CHMAP_FL, SNDRV_CHMAP_FR,
		   SNDRV_CHMAP_NA, SNDRV_CHMAP_LFE } }, /* LFE only on right */
	{ }
};

/* override the 2.1 chmap */
7542
static void alc_fixup_bass_chmap(struct hda_codec *codec,
7543 7544 7545 7546
				    const struct hda_fixup *fix, int action)
{
	if (action == HDA_FIXUP_ACT_BUILD) {
		struct alc_spec *spec = codec->spec;
7547
		spec->gen.pcm_rec[0]->stream[0].chmap = asus_pcm_2_1_chmaps;
7548 7549 7550
	}
}

7551 7552 7553 7554 7555 7556
/* avoid D3 for keeping GPIO up */
static unsigned int gpio_led_power_filter(struct hda_codec *codec,
					  hda_nid_t nid,
					  unsigned int power_state)
{
	struct alc_spec *spec = codec->spec;
7557
	if (nid == codec->core.afg && power_state == AC_PWRST_D3 && spec->gpio_led)
7558 7559 7560 7561
		return AC_PWRST_D0;
	return power_state;
}

7562 7563 7564 7565 7566 7567 7568 7569 7570 7571 7572
static void alc662_fixup_led_gpio1(struct hda_codec *codec,
				   const struct hda_fixup *fix, int action)
{
	struct alc_spec *spec = codec->spec;
	static const struct hda_verb gpio_init[] = {
		{ 0x01, AC_VERB_SET_GPIO_MASK, 0x01 },
		{ 0x01, AC_VERB_SET_GPIO_DIRECTION, 0x01 },
		{}
	};

	if (action == HDA_FIXUP_ACT_PRE_PROBE) {
7573
		spec->gen.vmaster_mute.hook = alc_fixup_gpio_mute_hook;
7574
		spec->gpio_led = 0;
7575 7576
		spec->mute_led_polarity = 1;
		spec->gpio_mute_led_mask = 0x01;
7577
		snd_hda_add_verbs(codec, gpio_init);
7578
		codec->power_filter = gpio_led_power_filter;
7579 7580 7581
	}
}

7582 7583 7584 7585 7586 7587 7588 7589 7590 7591 7592 7593 7594 7595 7596 7597 7598 7599 7600 7601 7602 7603 7604 7605
static void alc662_usi_automute_hook(struct hda_codec *codec,
					 struct hda_jack_callback *jack)
{
	struct alc_spec *spec = codec->spec;
	int vref;
	msleep(200);
	snd_hda_gen_hp_automute(codec, jack);

	vref = spec->gen.hp_jack_present ? PIN_VREF80 : 0;
	msleep(100);
	snd_hda_codec_write(codec, 0x19, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
			    vref);
}

static void alc662_fixup_usi_headset_mic(struct hda_codec *codec,
				     const struct hda_fixup *fix, int action)
{
	struct alc_spec *spec = codec->spec;
	if (action == HDA_FIXUP_ACT_PRE_PROBE) {
		spec->parse_flags |= HDA_PINCFG_HEADSET_MIC;
		spec->gen.hp_automute_hook = alc662_usi_automute_hook;
	}
}

7606 7607 7608 7609 7610 7611 7612 7613 7614 7615 7616 7617 7618 7619 7620 7621 7622 7623 7624 7625 7626 7627 7628 7629 7630 7631 7632 7633 7634
static struct coef_fw alc668_coefs[] = {
	WRITE_COEF(0x01, 0xbebe), WRITE_COEF(0x02, 0xaaaa), WRITE_COEF(0x03,    0x0),
	WRITE_COEF(0x04, 0x0180), WRITE_COEF(0x06,    0x0), WRITE_COEF(0x07, 0x0f80),
	WRITE_COEF(0x08, 0x0031), WRITE_COEF(0x0a, 0x0060), WRITE_COEF(0x0b,    0x0),
	WRITE_COEF(0x0c, 0x7cf7), WRITE_COEF(0x0d, 0x1080), WRITE_COEF(0x0e, 0x7f7f),
	WRITE_COEF(0x0f, 0xcccc), WRITE_COEF(0x10, 0xddcc), WRITE_COEF(0x11, 0x0001),
	WRITE_COEF(0x13,    0x0), WRITE_COEF(0x14, 0x2aa0), WRITE_COEF(0x17, 0xa940),
	WRITE_COEF(0x19,    0x0), WRITE_COEF(0x1a,    0x0), WRITE_COEF(0x1b,    0x0),
	WRITE_COEF(0x1c,    0x0), WRITE_COEF(0x1d,    0x0), WRITE_COEF(0x1e, 0x7418),
	WRITE_COEF(0x1f, 0x0804), WRITE_COEF(0x20, 0x4200), WRITE_COEF(0x21, 0x0468),
	WRITE_COEF(0x22, 0x8ccc), WRITE_COEF(0x23, 0x0250), WRITE_COEF(0x24, 0x7418),
	WRITE_COEF(0x27,    0x0), WRITE_COEF(0x28, 0x8ccc), WRITE_COEF(0x2a, 0xff00),
	WRITE_COEF(0x2b, 0x8000), WRITE_COEF(0xa7, 0xff00), WRITE_COEF(0xa8, 0x8000),
	WRITE_COEF(0xaa, 0x2e17), WRITE_COEF(0xab, 0xa0c0), WRITE_COEF(0xac,    0x0),
	WRITE_COEF(0xad,    0x0), WRITE_COEF(0xae, 0x2ac6), WRITE_COEF(0xaf, 0xa480),
	WRITE_COEF(0xb0,    0x0), WRITE_COEF(0xb1,    0x0), WRITE_COEF(0xb2,    0x0),
	WRITE_COEF(0xb3,    0x0), WRITE_COEF(0xb4,    0x0), WRITE_COEF(0xb5, 0x1040),
	WRITE_COEF(0xb6, 0xd697), WRITE_COEF(0xb7, 0x902b), WRITE_COEF(0xb8, 0xd697),
	WRITE_COEF(0xb9, 0x902b), WRITE_COEF(0xba, 0xb8ba), WRITE_COEF(0xbb, 0xaaab),
	WRITE_COEF(0xbc, 0xaaaf), WRITE_COEF(0xbd, 0x6aaa), WRITE_COEF(0xbe, 0x1c02),
	WRITE_COEF(0xc0, 0x00ff), WRITE_COEF(0xc1, 0x0fa6),
	{}
};

static void alc668_restore_default_value(struct hda_codec *codec)
{
	alc_process_coef_fw(codec, alc668_coefs);
}

7635
enum {
7636
	ALC662_FIXUP_ASPIRE,
7637
	ALC662_FIXUP_LED_GPIO1,
7638
	ALC662_FIXUP_IDEAPAD,
T
Todd Broch 已提交
7639
	ALC272_FIXUP_MARIO,
7640
	ALC662_FIXUP_CZC_P10T,
7641
	ALC662_FIXUP_SKU_IGNORE,
7642
	ALC662_FIXUP_HP_RP5800,
7643 7644 7645 7646 7647 7648 7649 7650
	ALC662_FIXUP_ASUS_MODE1,
	ALC662_FIXUP_ASUS_MODE2,
	ALC662_FIXUP_ASUS_MODE3,
	ALC662_FIXUP_ASUS_MODE4,
	ALC662_FIXUP_ASUS_MODE5,
	ALC662_FIXUP_ASUS_MODE6,
	ALC662_FIXUP_ASUS_MODE7,
	ALC662_FIXUP_ASUS_MODE8,
7651
	ALC662_FIXUP_NO_JACK_DETECT,
7652
	ALC662_FIXUP_ZOTAC_Z68,
7653
	ALC662_FIXUP_INV_DMIC,
7654
	ALC662_FIXUP_DELL_MIC_NO_PRESENCE,
7655
	ALC668_FIXUP_DELL_MIC_NO_PRESENCE,
7656
	ALC662_FIXUP_HEADSET_MODE,
7657
	ALC668_FIXUP_HEADSET_MODE,
7658
	ALC662_FIXUP_BASS_MODE4_CHMAP,
7659
	ALC662_FIXUP_BASS_16,
7660
	ALC662_FIXUP_BASS_1A,
7661
	ALC662_FIXUP_BASS_CHMAP,
7662
	ALC668_FIXUP_AUTO_MUTE,
7663
	ALC668_FIXUP_DELL_DISABLE_AAMIX,
7664
	ALC668_FIXUP_DELL_XPS13,
7665
	ALC662_FIXUP_ASUS_Nx50,
7666
	ALC668_FIXUP_ASUS_Nx51_HEADSET_MODE,
7667
	ALC668_FIXUP_ASUS_Nx51,
7668 7669
	ALC891_FIXUP_HEADSET_MODE,
	ALC891_FIXUP_DELL_MIC_NO_PRESENCE,
7670
	ALC662_FIXUP_ACER_VERITON,
7671
	ALC892_FIXUP_ASROCK_MOBO,
7672 7673
	ALC662_FIXUP_USI_FUNC,
	ALC662_FIXUP_USI_HEADSET_MODE,
7674
	ALC662_FIXUP_LENOVO_MULTI_CODECS,
7675 7676
};

7677
static const struct hda_fixup alc662_fixups[] = {
7678
	[ALC662_FIXUP_ASPIRE] = {
7679 7680
		.type = HDA_FIXUP_PINS,
		.v.pins = (const struct hda_pintbl[]) {
7681 7682 7683 7684
			{ 0x15, 0x99130112 }, /* subwoofer */
			{ }
		}
	},
7685 7686 7687 7688
	[ALC662_FIXUP_LED_GPIO1] = {
		.type = HDA_FIXUP_FUNC,
		.v.func = alc662_fixup_led_gpio1,
	},
7689
	[ALC662_FIXUP_IDEAPAD] = {
7690 7691
		.type = HDA_FIXUP_PINS,
		.v.pins = (const struct hda_pintbl[]) {
7692 7693
			{ 0x17, 0x99130112 }, /* subwoofer */
			{ }
7694 7695 7696
		},
		.chained = true,
		.chain_id = ALC662_FIXUP_LED_GPIO1,
7697
	},
T
Todd Broch 已提交
7698
	[ALC272_FIXUP_MARIO] = {
7699
		.type = HDA_FIXUP_FUNC,
7700
		.v.func = alc272_fixup_mario,
7701 7702
	},
	[ALC662_FIXUP_CZC_P10T] = {
7703
		.type = HDA_FIXUP_VERBS,
7704 7705 7706 7707 7708
		.v.verbs = (const struct hda_verb[]) {
			{0x14, AC_VERB_SET_EAPD_BTLENABLE, 0},
			{}
		}
	},
7709
	[ALC662_FIXUP_SKU_IGNORE] = {
7710
		.type = HDA_FIXUP_FUNC,
7711
		.v.func = alc_fixup_sku_ignore,
7712
	},
7713
	[ALC662_FIXUP_HP_RP5800] = {
7714 7715
		.type = HDA_FIXUP_PINS,
		.v.pins = (const struct hda_pintbl[]) {
7716 7717 7718 7719 7720 7721
			{ 0x14, 0x0221201f }, /* HP out */
			{ }
		},
		.chained = true,
		.chain_id = ALC662_FIXUP_SKU_IGNORE
	},
7722
	[ALC662_FIXUP_ASUS_MODE1] = {
7723 7724
		.type = HDA_FIXUP_PINS,
		.v.pins = (const struct hda_pintbl[]) {
7725 7726 7727 7728 7729 7730 7731 7732 7733 7734
			{ 0x14, 0x99130110 }, /* speaker */
			{ 0x18, 0x01a19c20 }, /* mic */
			{ 0x19, 0x99a3092f }, /* int-mic */
			{ 0x21, 0x0121401f }, /* HP out */
			{ }
		},
		.chained = true,
		.chain_id = ALC662_FIXUP_SKU_IGNORE
	},
	[ALC662_FIXUP_ASUS_MODE2] = {
7735 7736
		.type = HDA_FIXUP_PINS,
		.v.pins = (const struct hda_pintbl[]) {
7737 7738 7739 7740 7741 7742
			{ 0x14, 0x99130110 }, /* speaker */
			{ 0x18, 0x01a19820 }, /* mic */
			{ 0x19, 0x99a3092f }, /* int-mic */
			{ 0x1b, 0x0121401f }, /* HP out */
			{ }
		},
7743 7744 7745 7746
		.chained = true,
		.chain_id = ALC662_FIXUP_SKU_IGNORE
	},
	[ALC662_FIXUP_ASUS_MODE3] = {
7747 7748
		.type = HDA_FIXUP_PINS,
		.v.pins = (const struct hda_pintbl[]) {
7749 7750 7751 7752 7753 7754 7755 7756 7757 7758 7759
			{ 0x14, 0x99130110 }, /* speaker */
			{ 0x15, 0x0121441f }, /* HP */
			{ 0x18, 0x01a19840 }, /* mic */
			{ 0x19, 0x99a3094f }, /* int-mic */
			{ 0x21, 0x01211420 }, /* HP2 */
			{ }
		},
		.chained = true,
		.chain_id = ALC662_FIXUP_SKU_IGNORE
	},
	[ALC662_FIXUP_ASUS_MODE4] = {
7760 7761
		.type = HDA_FIXUP_PINS,
		.v.pins = (const struct hda_pintbl[]) {
7762 7763 7764 7765 7766 7767 7768 7769 7770 7771 7772
			{ 0x14, 0x99130110 }, /* speaker */
			{ 0x16, 0x99130111 }, /* speaker */
			{ 0x18, 0x01a19840 }, /* mic */
			{ 0x19, 0x99a3094f }, /* int-mic */
			{ 0x21, 0x0121441f }, /* HP */
			{ }
		},
		.chained = true,
		.chain_id = ALC662_FIXUP_SKU_IGNORE
	},
	[ALC662_FIXUP_ASUS_MODE5] = {
7773 7774
		.type = HDA_FIXUP_PINS,
		.v.pins = (const struct hda_pintbl[]) {
7775 7776 7777 7778 7779 7780 7781 7782 7783 7784 7785
			{ 0x14, 0x99130110 }, /* speaker */
			{ 0x15, 0x0121441f }, /* HP */
			{ 0x16, 0x99130111 }, /* speaker */
			{ 0x18, 0x01a19840 }, /* mic */
			{ 0x19, 0x99a3094f }, /* int-mic */
			{ }
		},
		.chained = true,
		.chain_id = ALC662_FIXUP_SKU_IGNORE
	},
	[ALC662_FIXUP_ASUS_MODE6] = {
7786 7787
		.type = HDA_FIXUP_PINS,
		.v.pins = (const struct hda_pintbl[]) {
7788 7789 7790 7791 7792 7793 7794 7795 7796 7797 7798
			{ 0x14, 0x99130110 }, /* speaker */
			{ 0x15, 0x01211420 }, /* HP2 */
			{ 0x18, 0x01a19840 }, /* mic */
			{ 0x19, 0x99a3094f }, /* int-mic */
			{ 0x1b, 0x0121441f }, /* HP */
			{ }
		},
		.chained = true,
		.chain_id = ALC662_FIXUP_SKU_IGNORE
	},
	[ALC662_FIXUP_ASUS_MODE7] = {
7799 7800
		.type = HDA_FIXUP_PINS,
		.v.pins = (const struct hda_pintbl[]) {
7801 7802 7803 7804 7805 7806 7807 7808 7809 7810 7811 7812
			{ 0x14, 0x99130110 }, /* speaker */
			{ 0x17, 0x99130111 }, /* speaker */
			{ 0x18, 0x01a19840 }, /* mic */
			{ 0x19, 0x99a3094f }, /* int-mic */
			{ 0x1b, 0x01214020 }, /* HP */
			{ 0x21, 0x0121401f }, /* HP */
			{ }
		},
		.chained = true,
		.chain_id = ALC662_FIXUP_SKU_IGNORE
	},
	[ALC662_FIXUP_ASUS_MODE8] = {
7813 7814
		.type = HDA_FIXUP_PINS,
		.v.pins = (const struct hda_pintbl[]) {
7815 7816 7817 7818 7819 7820 7821 7822 7823 7824
			{ 0x14, 0x99130110 }, /* speaker */
			{ 0x12, 0x99a30970 }, /* int-mic */
			{ 0x15, 0x01214020 }, /* HP */
			{ 0x17, 0x99130111 }, /* speaker */
			{ 0x18, 0x01a19840 }, /* mic */
			{ 0x21, 0x0121401f }, /* HP */
			{ }
		},
		.chained = true,
		.chain_id = ALC662_FIXUP_SKU_IGNORE
7825
	},
7826
	[ALC662_FIXUP_NO_JACK_DETECT] = {
7827
		.type = HDA_FIXUP_FUNC,
7828 7829
		.v.func = alc_fixup_no_jack_detect,
	},
7830
	[ALC662_FIXUP_ZOTAC_Z68] = {
7831 7832
		.type = HDA_FIXUP_PINS,
		.v.pins = (const struct hda_pintbl[]) {
7833 7834 7835 7836
			{ 0x1b, 0x02214020 }, /* Front HP */
			{ }
		}
	},
7837
	[ALC662_FIXUP_INV_DMIC] = {
7838
		.type = HDA_FIXUP_FUNC,
7839
		.v.func = alc_fixup_inv_dmic,
7840
	},
7841 7842 7843 7844 7845 7846
	[ALC668_FIXUP_DELL_XPS13] = {
		.type = HDA_FIXUP_FUNC,
		.v.func = alc_fixup_dell_xps13,
		.chained = true,
		.chain_id = ALC668_FIXUP_DELL_DISABLE_AAMIX
	},
7847 7848 7849 7850 7851 7852
	[ALC668_FIXUP_DELL_DISABLE_AAMIX] = {
		.type = HDA_FIXUP_FUNC,
		.v.func = alc_fixup_disable_aamix,
		.chained = true,
		.chain_id = ALC668_FIXUP_DELL_MIC_NO_PRESENCE
	},
7853 7854 7855 7856 7857 7858
	[ALC668_FIXUP_AUTO_MUTE] = {
		.type = HDA_FIXUP_FUNC,
		.v.func = alc_fixup_auto_mute_via_amp,
		.chained = true,
		.chain_id = ALC668_FIXUP_DELL_MIC_NO_PRESENCE
	},
7859 7860 7861 7862 7863 7864 7865 7866 7867 7868 7869 7870 7871 7872
	[ALC662_FIXUP_DELL_MIC_NO_PRESENCE] = {
		.type = HDA_FIXUP_PINS,
		.v.pins = (const struct hda_pintbl[]) {
			{ 0x19, 0x03a1113c }, /* use as headset mic, without its own jack detect */
			/* headphone mic by setting pin control of 0x1b (headphone out) to in + vref_50 */
			{ }
		},
		.chained = true,
		.chain_id = ALC662_FIXUP_HEADSET_MODE
	},
	[ALC662_FIXUP_HEADSET_MODE] = {
		.type = HDA_FIXUP_FUNC,
		.v.func = alc_fixup_headset_mode_alc662,
	},
7873 7874 7875 7876 7877 7878 7879 7880 7881 7882 7883 7884 7885 7886
	[ALC668_FIXUP_DELL_MIC_NO_PRESENCE] = {
		.type = HDA_FIXUP_PINS,
		.v.pins = (const struct hda_pintbl[]) {
			{ 0x19, 0x03a1913d }, /* use as headphone mic, without its own jack detect */
			{ 0x1b, 0x03a1113c }, /* use as headset mic, without its own jack detect */
			{ }
		},
		.chained = true,
		.chain_id = ALC668_FIXUP_HEADSET_MODE
	},
	[ALC668_FIXUP_HEADSET_MODE] = {
		.type = HDA_FIXUP_FUNC,
		.v.func = alc_fixup_headset_mode_alc668,
	},
7887
	[ALC662_FIXUP_BASS_MODE4_CHMAP] = {
7888
		.type = HDA_FIXUP_FUNC,
7889
		.v.func = alc_fixup_bass_chmap,
7890 7891 7892
		.chained = true,
		.chain_id = ALC662_FIXUP_ASUS_MODE4
	},
7893 7894 7895 7896 7897 7898 7899 7900 7901
	[ALC662_FIXUP_BASS_16] = {
		.type = HDA_FIXUP_PINS,
		.v.pins = (const struct hda_pintbl[]) {
			{0x16, 0x80106111}, /* bass speaker */
			{}
		},
		.chained = true,
		.chain_id = ALC662_FIXUP_BASS_CHMAP,
	},
7902 7903 7904 7905 7906 7907
	[ALC662_FIXUP_BASS_1A] = {
		.type = HDA_FIXUP_PINS,
		.v.pins = (const struct hda_pintbl[]) {
			{0x1a, 0x80106111}, /* bass speaker */
			{}
		},
7908 7909
		.chained = true,
		.chain_id = ALC662_FIXUP_BASS_CHMAP,
7910
	},
7911
	[ALC662_FIXUP_BASS_CHMAP] = {
7912
		.type = HDA_FIXUP_FUNC,
7913
		.v.func = alc_fixup_bass_chmap,
7914
	},
7915 7916 7917 7918 7919 7920
	[ALC662_FIXUP_ASUS_Nx50] = {
		.type = HDA_FIXUP_FUNC,
		.v.func = alc_fixup_auto_mute_via_amp,
		.chained = true,
		.chain_id = ALC662_FIXUP_BASS_1A
	},
7921 7922 7923 7924 7925
	[ALC668_FIXUP_ASUS_Nx51_HEADSET_MODE] = {
		.type = HDA_FIXUP_FUNC,
		.v.func = alc_fixup_headset_mode_alc668,
		.chain_id = ALC662_FIXUP_BASS_CHMAP
	},
7926 7927 7928
	[ALC668_FIXUP_ASUS_Nx51] = {
		.type = HDA_FIXUP_PINS,
		.v.pins = (const struct hda_pintbl[]) {
7929 7930 7931
			{ 0x19, 0x03a1913d }, /* use as headphone mic, without its own jack detect */
			{ 0x1a, 0x90170151 }, /* bass speaker */
			{ 0x1b, 0x03a1113c }, /* use as headset mic, without its own jack detect */
7932 7933 7934
			{}
		},
		.chained = true,
7935
		.chain_id = ALC668_FIXUP_ASUS_Nx51_HEADSET_MODE,
7936
	},
7937 7938 7939 7940 7941 7942 7943 7944 7945 7946 7947 7948 7949 7950
	[ALC891_FIXUP_HEADSET_MODE] = {
		.type = HDA_FIXUP_FUNC,
		.v.func = alc_fixup_headset_mode,
	},
	[ALC891_FIXUP_DELL_MIC_NO_PRESENCE] = {
		.type = HDA_FIXUP_PINS,
		.v.pins = (const struct hda_pintbl[]) {
			{ 0x19, 0x03a1913d }, /* use as headphone mic, without its own jack detect */
			{ 0x1b, 0x03a1113c }, /* use as headset mic, without its own jack detect */
			{ }
		},
		.chained = true,
		.chain_id = ALC891_FIXUP_HEADSET_MODE
	},
7951 7952 7953 7954 7955 7956 7957
	[ALC662_FIXUP_ACER_VERITON] = {
		.type = HDA_FIXUP_PINS,
		.v.pins = (const struct hda_pintbl[]) {
			{ 0x15, 0x50170120 }, /* no internal speaker */
			{ }
		}
	},
7958 7959 7960 7961 7962 7963 7964 7965
	[ALC892_FIXUP_ASROCK_MOBO] = {
		.type = HDA_FIXUP_PINS,
		.v.pins = (const struct hda_pintbl[]) {
			{ 0x15, 0x40f000f0 }, /* disabled */
			{ 0x16, 0x40f000f0 }, /* disabled */
			{ }
		}
	},
7966 7967 7968 7969 7970 7971 7972 7973 7974 7975 7976 7977 7978 7979
	[ALC662_FIXUP_USI_FUNC] = {
		.type = HDA_FIXUP_FUNC,
		.v.func = alc662_fixup_usi_headset_mic,
	},
	[ALC662_FIXUP_USI_HEADSET_MODE] = {
		.type = HDA_FIXUP_PINS,
		.v.pins = (const struct hda_pintbl[]) {
			{ 0x19, 0x02a1913c }, /* use as headset mic, without its own jack detect */
			{ 0x18, 0x01a1903d },
			{ }
		},
		.chained = true,
		.chain_id = ALC662_FIXUP_USI_FUNC
	},
7980 7981 7982 7983
	[ALC662_FIXUP_LENOVO_MULTI_CODECS] = {
		.type = HDA_FIXUP_FUNC,
		.v.func = alc233_alc662_fixup_lenovo_dual_codecs,
	},
7984 7985
};

7986
static const struct snd_pci_quirk alc662_fixup_tbl[] = {
7987
	SND_PCI_QUIRK(0x1019, 0x9087, "ECS", ALC662_FIXUP_ASUS_MODE2),
7988
	SND_PCI_QUIRK(0x1025, 0x022f, "Acer Aspire One", ALC662_FIXUP_INV_DMIC),
7989
	SND_PCI_QUIRK(0x1025, 0x0241, "Packard Bell DOTS", ALC662_FIXUP_INV_DMIC),
7990
	SND_PCI_QUIRK(0x1025, 0x0308, "Acer Aspire 8942G", ALC662_FIXUP_ASPIRE),
7991
	SND_PCI_QUIRK(0x1025, 0x031c, "Gateway NV79", ALC662_FIXUP_SKU_IGNORE),
7992
	SND_PCI_QUIRK(0x1025, 0x0349, "eMachines eM250", ALC662_FIXUP_INV_DMIC),
7993
	SND_PCI_QUIRK(0x1025, 0x034a, "Gateway LT27", ALC662_FIXUP_INV_DMIC),
7994
	SND_PCI_QUIRK(0x1025, 0x038b, "Acer Aspire 8943G", ALC662_FIXUP_ASPIRE),
7995 7996
	SND_PCI_QUIRK(0x1028, 0x05d8, "Dell", ALC668_FIXUP_DELL_MIC_NO_PRESENCE),
	SND_PCI_QUIRK(0x1028, 0x05db, "Dell", ALC668_FIXUP_DELL_MIC_NO_PRESENCE),
7997
	SND_PCI_QUIRK(0x1028, 0x05fe, "Dell XPS 15", ALC668_FIXUP_DELL_XPS13),
7998
	SND_PCI_QUIRK(0x1028, 0x060a, "Dell XPS 13", ALC668_FIXUP_DELL_XPS13),
7999
	SND_PCI_QUIRK(0x1028, 0x060d, "Dell M3800", ALC668_FIXUP_DELL_XPS13),
8000
	SND_PCI_QUIRK(0x1028, 0x0625, "Dell", ALC668_FIXUP_DELL_MIC_NO_PRESENCE),
8001
	SND_PCI_QUIRK(0x1028, 0x0626, "Dell", ALC668_FIXUP_DELL_MIC_NO_PRESENCE),
8002 8003
	SND_PCI_QUIRK(0x1028, 0x0696, "Dell", ALC668_FIXUP_DELL_MIC_NO_PRESENCE),
	SND_PCI_QUIRK(0x1028, 0x0698, "Dell", ALC668_FIXUP_DELL_MIC_NO_PRESENCE),
8004
	SND_PCI_QUIRK(0x1028, 0x069f, "Dell", ALC668_FIXUP_DELL_MIC_NO_PRESENCE),
8005
	SND_PCI_QUIRK(0x103c, 0x1632, "HP RP5800", ALC662_FIXUP_HP_RP5800),
8006
	SND_PCI_QUIRK(0x1043, 0x1080, "Asus UX501VW", ALC668_FIXUP_HEADSET_MODE),
8007
	SND_PCI_QUIRK(0x1043, 0x11cd, "Asus N550", ALC662_FIXUP_ASUS_Nx50),
8008
	SND_PCI_QUIRK(0x1043, 0x13df, "Asus N550JX", ALC662_FIXUP_BASS_1A),
8009
	SND_PCI_QUIRK(0x1043, 0x129d, "Asus N750", ALC662_FIXUP_ASUS_Nx50),
8010
	SND_PCI_QUIRK(0x1043, 0x1477, "ASUS N56VZ", ALC662_FIXUP_BASS_MODE4_CHMAP),
8011
	SND_PCI_QUIRK(0x1043, 0x15a7, "ASUS UX51VZH", ALC662_FIXUP_BASS_16),
8012 8013
	SND_PCI_QUIRK(0x1043, 0x177d, "ASUS N551", ALC668_FIXUP_ASUS_Nx51),
	SND_PCI_QUIRK(0x1043, 0x17bd, "ASUS N751", ALC668_FIXUP_ASUS_Nx51),
8014
	SND_PCI_QUIRK(0x1043, 0x1963, "ASUS X71SL", ALC662_FIXUP_ASUS_MODE8),
8015
	SND_PCI_QUIRK(0x1043, 0x1b73, "ASUS N55SF", ALC662_FIXUP_BASS_16),
8016
	SND_PCI_QUIRK(0x1043, 0x1bf3, "ASUS N76VZ", ALC662_FIXUP_BASS_MODE4_CHMAP),
8017
	SND_PCI_QUIRK(0x1043, 0x8469, "ASUS mobo", ALC662_FIXUP_NO_JACK_DETECT),
8018
	SND_PCI_QUIRK(0x105b, 0x0cd6, "Foxconn", ALC662_FIXUP_ASUS_MODE2),
8019
	SND_PCI_QUIRK(0x144d, 0xc051, "Samsung R720", ALC662_FIXUP_IDEAPAD),
8020
	SND_PCI_QUIRK(0x14cd, 0x5003, "USI", ALC662_FIXUP_USI_HEADSET_MODE),
8021
	SND_PCI_QUIRK(0x17aa, 0x1036, "Lenovo P520", ALC662_FIXUP_LENOVO_MULTI_CODECS),
8022
	SND_PCI_QUIRK(0x17aa, 0x38af, "Lenovo Ideapad Y550P", ALC662_FIXUP_IDEAPAD),
8023
	SND_PCI_QUIRK(0x17aa, 0x3a0d, "Lenovo Ideapad Y550", ALC662_FIXUP_IDEAPAD),
8024
	SND_PCI_QUIRK(0x1849, 0x5892, "ASRock B150M", ALC892_FIXUP_ASROCK_MOBO),
8025
	SND_PCI_QUIRK(0x19da, 0xa130, "Zotac Z68", ALC662_FIXUP_ZOTAC_Z68),
8026
	SND_PCI_QUIRK(0x1b0a, 0x01b8, "ACER Veriton", ALC662_FIXUP_ACER_VERITON),
8027
	SND_PCI_QUIRK(0x1b35, 0x2206, "CZC P10T", ALC662_FIXUP_CZC_P10T),
8028 8029 8030 8031 8032 8033

#if 0
	/* Below is a quirk table taken from the old code.
	 * Basically the device should work as is without the fixup table.
	 * If BIOS doesn't give a proper info, enable the corresponding
	 * fixup entry.
8034
	 */
8035 8036 8037 8038 8039 8040 8041 8042 8043 8044 8045 8046 8047 8048 8049 8050 8051 8052 8053 8054 8055 8056 8057 8058 8059 8060 8061 8062 8063 8064 8065 8066 8067 8068 8069 8070 8071 8072 8073 8074 8075 8076 8077 8078 8079 8080 8081 8082 8083 8084 8085
	SND_PCI_QUIRK(0x1043, 0x1000, "ASUS N50Vm", ALC662_FIXUP_ASUS_MODE1),
	SND_PCI_QUIRK(0x1043, 0x1092, "ASUS NB", ALC662_FIXUP_ASUS_MODE3),
	SND_PCI_QUIRK(0x1043, 0x1173, "ASUS K73Jn", ALC662_FIXUP_ASUS_MODE1),
	SND_PCI_QUIRK(0x1043, 0x11c3, "ASUS M70V", ALC662_FIXUP_ASUS_MODE3),
	SND_PCI_QUIRK(0x1043, 0x11d3, "ASUS NB", ALC662_FIXUP_ASUS_MODE1),
	SND_PCI_QUIRK(0x1043, 0x11f3, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),
	SND_PCI_QUIRK(0x1043, 0x1203, "ASUS NB", ALC662_FIXUP_ASUS_MODE1),
	SND_PCI_QUIRK(0x1043, 0x1303, "ASUS G60J", ALC662_FIXUP_ASUS_MODE1),
	SND_PCI_QUIRK(0x1043, 0x1333, "ASUS G60Jx", ALC662_FIXUP_ASUS_MODE1),
	SND_PCI_QUIRK(0x1043, 0x1339, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),
	SND_PCI_QUIRK(0x1043, 0x13e3, "ASUS N71JA", ALC662_FIXUP_ASUS_MODE7),
	SND_PCI_QUIRK(0x1043, 0x1463, "ASUS N71", ALC662_FIXUP_ASUS_MODE7),
	SND_PCI_QUIRK(0x1043, 0x14d3, "ASUS G72", ALC662_FIXUP_ASUS_MODE8),
	SND_PCI_QUIRK(0x1043, 0x1563, "ASUS N90", ALC662_FIXUP_ASUS_MODE3),
	SND_PCI_QUIRK(0x1043, 0x15d3, "ASUS N50SF F50SF", ALC662_FIXUP_ASUS_MODE1),
	SND_PCI_QUIRK(0x1043, 0x16c3, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),
	SND_PCI_QUIRK(0x1043, 0x16f3, "ASUS K40C K50C", ALC662_FIXUP_ASUS_MODE2),
	SND_PCI_QUIRK(0x1043, 0x1733, "ASUS N81De", ALC662_FIXUP_ASUS_MODE1),
	SND_PCI_QUIRK(0x1043, 0x1753, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),
	SND_PCI_QUIRK(0x1043, 0x1763, "ASUS NB", ALC662_FIXUP_ASUS_MODE6),
	SND_PCI_QUIRK(0x1043, 0x1765, "ASUS NB", ALC662_FIXUP_ASUS_MODE6),
	SND_PCI_QUIRK(0x1043, 0x1783, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),
	SND_PCI_QUIRK(0x1043, 0x1793, "ASUS F50GX", ALC662_FIXUP_ASUS_MODE1),
	SND_PCI_QUIRK(0x1043, 0x17b3, "ASUS F70SL", ALC662_FIXUP_ASUS_MODE3),
	SND_PCI_QUIRK(0x1043, 0x17f3, "ASUS X58LE", ALC662_FIXUP_ASUS_MODE2),
	SND_PCI_QUIRK(0x1043, 0x1813, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),
	SND_PCI_QUIRK(0x1043, 0x1823, "ASUS NB", ALC662_FIXUP_ASUS_MODE5),
	SND_PCI_QUIRK(0x1043, 0x1833, "ASUS NB", ALC662_FIXUP_ASUS_MODE6),
	SND_PCI_QUIRK(0x1043, 0x1843, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),
	SND_PCI_QUIRK(0x1043, 0x1853, "ASUS F50Z", ALC662_FIXUP_ASUS_MODE1),
	SND_PCI_QUIRK(0x1043, 0x1864, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),
	SND_PCI_QUIRK(0x1043, 0x1876, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),
	SND_PCI_QUIRK(0x1043, 0x1893, "ASUS M50Vm", ALC662_FIXUP_ASUS_MODE3),
	SND_PCI_QUIRK(0x1043, 0x1894, "ASUS X55", ALC662_FIXUP_ASUS_MODE3),
	SND_PCI_QUIRK(0x1043, 0x18b3, "ASUS N80Vc", ALC662_FIXUP_ASUS_MODE1),
	SND_PCI_QUIRK(0x1043, 0x18c3, "ASUS VX5", ALC662_FIXUP_ASUS_MODE1),
	SND_PCI_QUIRK(0x1043, 0x18d3, "ASUS N81Te", ALC662_FIXUP_ASUS_MODE1),
	SND_PCI_QUIRK(0x1043, 0x18f3, "ASUS N505Tp", ALC662_FIXUP_ASUS_MODE1),
	SND_PCI_QUIRK(0x1043, 0x1903, "ASUS F5GL", ALC662_FIXUP_ASUS_MODE1),
	SND_PCI_QUIRK(0x1043, 0x1913, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),
	SND_PCI_QUIRK(0x1043, 0x1933, "ASUS F80Q", ALC662_FIXUP_ASUS_MODE2),
	SND_PCI_QUIRK(0x1043, 0x1943, "ASUS Vx3V", ALC662_FIXUP_ASUS_MODE1),
	SND_PCI_QUIRK(0x1043, 0x1953, "ASUS NB", ALC662_FIXUP_ASUS_MODE1),
	SND_PCI_QUIRK(0x1043, 0x1963, "ASUS X71C", ALC662_FIXUP_ASUS_MODE3),
	SND_PCI_QUIRK(0x1043, 0x1983, "ASUS N5051A", ALC662_FIXUP_ASUS_MODE1),
	SND_PCI_QUIRK(0x1043, 0x1993, "ASUS N20", ALC662_FIXUP_ASUS_MODE1),
	SND_PCI_QUIRK(0x1043, 0x19b3, "ASUS F7Z", ALC662_FIXUP_ASUS_MODE1),
	SND_PCI_QUIRK(0x1043, 0x19c3, "ASUS F5Z/F6x", ALC662_FIXUP_ASUS_MODE2),
	SND_PCI_QUIRK(0x1043, 0x19e3, "ASUS NB", ALC662_FIXUP_ASUS_MODE1),
	SND_PCI_QUIRK(0x1043, 0x19f3, "ASUS NB", ALC662_FIXUP_ASUS_MODE4),
#endif
8086 8087 8088
	{}
};

8089
static const struct hda_model_fixup alc662_fixup_models[] = {
T
Todd Broch 已提交
8090
	{.id = ALC272_FIXUP_MARIO, .name = "mario"},
8091 8092 8093 8094 8095 8096 8097 8098
	{.id = ALC662_FIXUP_ASUS_MODE1, .name = "asus-mode1"},
	{.id = ALC662_FIXUP_ASUS_MODE2, .name = "asus-mode2"},
	{.id = ALC662_FIXUP_ASUS_MODE3, .name = "asus-mode3"},
	{.id = ALC662_FIXUP_ASUS_MODE4, .name = "asus-mode4"},
	{.id = ALC662_FIXUP_ASUS_MODE5, .name = "asus-mode5"},
	{.id = ALC662_FIXUP_ASUS_MODE6, .name = "asus-mode6"},
	{.id = ALC662_FIXUP_ASUS_MODE7, .name = "asus-mode7"},
	{.id = ALC662_FIXUP_ASUS_MODE8, .name = "asus-mode8"},
8099
	{.id = ALC662_FIXUP_INV_DMIC, .name = "inv-dmic"},
8100
	{.id = ALC668_FIXUP_DELL_MIC_NO_PRESENCE, .name = "dell-headset-multi"},
8101
	{.id = ALC662_FIXUP_LENOVO_MULTI_CODECS, .name = "dual-codecs"},
T
Todd Broch 已提交
8102 8103
	{}
};
8104

8105
static const struct snd_hda_pin_quirk alc662_pin_fixup_tbl[] = {
8106 8107 8108 8109 8110
	SND_HDA_PIN_QUIRK(0x10ec0867, 0x1028, "Dell", ALC891_FIXUP_DELL_MIC_NO_PRESENCE,
		{0x17, 0x02211010},
		{0x18, 0x01a19030},
		{0x1a, 0x01813040},
		{0x21, 0x01014020}),
8111 8112 8113 8114
	SND_HDA_PIN_QUIRK(0x10ec0662, 0x1028, "Dell", ALC662_FIXUP_DELL_MIC_NO_PRESENCE,
		{0x14, 0x01014010},
		{0x18, 0x01a19020},
		{0x1a, 0x0181302f},
8115
		{0x1b, 0x0221401f}),
8116 8117 8118 8119
	SND_HDA_PIN_QUIRK(0x10ec0668, 0x1028, "Dell", ALC668_FIXUP_AUTO_MUTE,
		{0x12, 0x99a30130},
		{0x14, 0x90170110},
		{0x15, 0x0321101f},
8120
		{0x16, 0x03011020}),
8121 8122 8123 8124
	SND_HDA_PIN_QUIRK(0x10ec0668, 0x1028, "Dell", ALC668_FIXUP_AUTO_MUTE,
		{0x12, 0x99a30140},
		{0x14, 0x90170110},
		{0x15, 0x0321101f},
8125
		{0x16, 0x03011020}),
8126 8127 8128 8129
	SND_HDA_PIN_QUIRK(0x10ec0668, 0x1028, "Dell", ALC668_FIXUP_AUTO_MUTE,
		{0x12, 0x99a30150},
		{0x14, 0x90170110},
		{0x15, 0x0321101f},
8130
		{0x16, 0x03011020}),
8131 8132 8133
	SND_HDA_PIN_QUIRK(0x10ec0668, 0x1028, "Dell", ALC668_FIXUP_AUTO_MUTE,
		{0x14, 0x90170110},
		{0x15, 0x0321101f},
8134
		{0x16, 0x03011020}),
8135 8136 8137
	SND_HDA_PIN_QUIRK(0x10ec0668, 0x1028, "Dell XPS 15", ALC668_FIXUP_AUTO_MUTE,
		{0x12, 0x90a60130},
		{0x14, 0x90170110},
8138
		{0x15, 0x0321101f}),
8139 8140 8141
	{}
};

8142 8143
/*
 */
8144 8145 8146
static int patch_alc662(struct hda_codec *codec)
{
	struct alc_spec *spec;
8147
	int err;
8148

8149 8150 8151
	err = alc_alloc_spec(codec, 0x0b);
	if (err < 0)
		return err;
8152

8153
	spec = codec->spec;
8154

8155 8156
	spec->shutup = alc_eapd_shutup;

8157 8158 8159
	/* handle multiple HPs as is */
	spec->parse_flags = HDA_PINCFG_NO_HP_FIXUP;

8160 8161
	alc_fix_pll_init(codec, 0x20, 0x04, 15);

8162
	switch (codec->core.vendor_id) {
8163 8164 8165 8166
	case 0x10ec0668:
		spec->init_hook = alc668_restore_default_value;
		break;
	}
8167

8168
	snd_hda_pick_fixup(codec, alc662_fixup_models,
8169
		       alc662_fixup_tbl, alc662_fixups);
8170
	snd_hda_pick_pin_fixup(codec, alc662_pin_fixup_tbl, alc662_fixups);
8171
	snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE);
8172 8173 8174

	alc_auto_parse_customize_define(codec);

8175 8176 8177
	if (has_cdefine_beep(codec))
		spec->gen.beep_nid = 0x01;

8178
	if ((alc_get_coef0(codec) & (1 << 14)) &&
8179
	    codec->bus->pci && codec->bus->pci->subsystem_vendor == 0x1025 &&
8180
	    spec->cdefine.platform_type == 1) {
8181 8182
		err = alc_codec_rename(codec, "ALC272X");
		if (err < 0)
8183
			goto error;
8184
	}
8185

8186 8187
	/* automatic parse from the BIOS config */
	err = alc662_parse_auto_config(codec);
8188 8189
	if (err < 0)
		goto error;
8190

8191
	if (!spec->gen.no_analog && spec->gen.beep_nid) {
8192
		switch (codec->core.vendor_id) {
8193 8194 8195 8196 8197 8198
		case 0x10ec0662:
			set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
			break;
		case 0x10ec0272:
		case 0x10ec0663:
		case 0x10ec0665:
8199
		case 0x10ec0668:
8200 8201 8202 8203 8204 8205
			set_beep_amp(spec, 0x0b, 0x04, HDA_INPUT);
			break;
		case 0x10ec0273:
			set_beep_amp(spec, 0x0b, 0x03, HDA_INPUT);
			break;
		}
K
Kailang Yang 已提交
8206
	}
8207

8208
	snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE);
8209

8210
	return 0;
8211

8212 8213 8214
 error:
	alc_free(codec);
	return err;
8215 8216
}

K
Kailang Yang 已提交
8217 8218 8219 8220 8221 8222
/*
 * ALC680 support
 */

static int alc680_parse_auto_config(struct hda_codec *codec)
{
8223
	return alc_parse_auto_config(codec, NULL, NULL);
K
Kailang Yang 已提交
8224 8225 8226 8227 8228 8229 8230 8231
}

/*
 */
static int patch_alc680(struct hda_codec *codec)
{
	int err;

8232
	/* ALC680 has no aa-loopback mixer */
8233 8234 8235
	err = alc_alloc_spec(codec, 0);
	if (err < 0)
		return err;
8236

8237 8238 8239 8240 8241
	/* automatic parse from the BIOS config */
	err = alc680_parse_auto_config(codec);
	if (err < 0) {
		alc_free(codec);
		return err;
K
Kailang Yang 已提交
8242 8243 8244 8245 8246
	}

	return 0;
}

L
Linus Torvalds 已提交
8247 8248 8249
/*
 * patch entries
 */
8250
static const struct hda_device_id snd_hda_id_realtek[] = {
8251
	HDA_CODEC_ENTRY(0x10ec0215, "ALC215", patch_alc269),
8252
	HDA_CODEC_ENTRY(0x10ec0221, "ALC221", patch_alc269),
8253
	HDA_CODEC_ENTRY(0x10ec0225, "ALC225", patch_alc269),
8254 8255
	HDA_CODEC_ENTRY(0x10ec0231, "ALC231", patch_alc269),
	HDA_CODEC_ENTRY(0x10ec0233, "ALC233", patch_alc269),
8256
	HDA_CODEC_ENTRY(0x10ec0234, "ALC234", patch_alc269),
8257
	HDA_CODEC_ENTRY(0x10ec0235, "ALC233", patch_alc269),
8258
	HDA_CODEC_ENTRY(0x10ec0236, "ALC236", patch_alc269),
8259 8260
	HDA_CODEC_ENTRY(0x10ec0255, "ALC255", patch_alc269),
	HDA_CODEC_ENTRY(0x10ec0256, "ALC256", patch_alc269),
8261
	HDA_CODEC_ENTRY(0x10ec0257, "ALC257", patch_alc269),
8262 8263 8264 8265 8266 8267 8268
	HDA_CODEC_ENTRY(0x10ec0260, "ALC260", patch_alc260),
	HDA_CODEC_ENTRY(0x10ec0262, "ALC262", patch_alc262),
	HDA_CODEC_ENTRY(0x10ec0267, "ALC267", patch_alc268),
	HDA_CODEC_ENTRY(0x10ec0268, "ALC268", patch_alc268),
	HDA_CODEC_ENTRY(0x10ec0269, "ALC269", patch_alc269),
	HDA_CODEC_ENTRY(0x10ec0270, "ALC270", patch_alc269),
	HDA_CODEC_ENTRY(0x10ec0272, "ALC272", patch_alc662),
8269
	HDA_CODEC_ENTRY(0x10ec0274, "ALC274", patch_alc269),
8270 8271 8272 8273 8274 8275
	HDA_CODEC_ENTRY(0x10ec0275, "ALC275", patch_alc269),
	HDA_CODEC_ENTRY(0x10ec0276, "ALC276", patch_alc269),
	HDA_CODEC_ENTRY(0x10ec0280, "ALC280", patch_alc269),
	HDA_CODEC_ENTRY(0x10ec0282, "ALC282", patch_alc269),
	HDA_CODEC_ENTRY(0x10ec0283, "ALC283", patch_alc269),
	HDA_CODEC_ENTRY(0x10ec0284, "ALC284", patch_alc269),
8276
	HDA_CODEC_ENTRY(0x10ec0285, "ALC285", patch_alc269),
8277 8278
	HDA_CODEC_ENTRY(0x10ec0286, "ALC286", patch_alc269),
	HDA_CODEC_ENTRY(0x10ec0288, "ALC288", patch_alc269),
8279
	HDA_CODEC_ENTRY(0x10ec0289, "ALC289", patch_alc269),
8280 8281 8282
	HDA_CODEC_ENTRY(0x10ec0290, "ALC290", patch_alc269),
	HDA_CODEC_ENTRY(0x10ec0292, "ALC292", patch_alc269),
	HDA_CODEC_ENTRY(0x10ec0293, "ALC293", patch_alc269),
8283
	HDA_CODEC_ENTRY(0x10ec0294, "ALC294", patch_alc269),
8284
	HDA_CODEC_ENTRY(0x10ec0295, "ALC295", patch_alc269),
8285
	HDA_CODEC_ENTRY(0x10ec0298, "ALC298", patch_alc269),
8286
	HDA_CODEC_ENTRY(0x10ec0299, "ALC299", patch_alc269),
8287 8288 8289 8290 8291 8292 8293 8294 8295 8296 8297 8298 8299 8300
	HDA_CODEC_REV_ENTRY(0x10ec0861, 0x100340, "ALC660", patch_alc861),
	HDA_CODEC_ENTRY(0x10ec0660, "ALC660-VD", patch_alc861vd),
	HDA_CODEC_ENTRY(0x10ec0861, "ALC861", patch_alc861),
	HDA_CODEC_ENTRY(0x10ec0862, "ALC861-VD", patch_alc861vd),
	HDA_CODEC_REV_ENTRY(0x10ec0662, 0x100002, "ALC662 rev2", patch_alc882),
	HDA_CODEC_REV_ENTRY(0x10ec0662, 0x100101, "ALC662 rev1", patch_alc662),
	HDA_CODEC_REV_ENTRY(0x10ec0662, 0x100300, "ALC662 rev3", patch_alc662),
	HDA_CODEC_ENTRY(0x10ec0663, "ALC663", patch_alc662),
	HDA_CODEC_ENTRY(0x10ec0665, "ALC665", patch_alc662),
	HDA_CODEC_ENTRY(0x10ec0667, "ALC667", patch_alc662),
	HDA_CODEC_ENTRY(0x10ec0668, "ALC668", patch_alc662),
	HDA_CODEC_ENTRY(0x10ec0670, "ALC670", patch_alc662),
	HDA_CODEC_ENTRY(0x10ec0671, "ALC671", patch_alc662),
	HDA_CODEC_ENTRY(0x10ec0680, "ALC680", patch_alc680),
8301 8302 8303
	HDA_CODEC_ENTRY(0x10ec0700, "ALC700", patch_alc269),
	HDA_CODEC_ENTRY(0x10ec0701, "ALC701", patch_alc269),
	HDA_CODEC_ENTRY(0x10ec0703, "ALC703", patch_alc269),
8304
	HDA_CODEC_ENTRY(0x10ec0867, "ALC891", patch_alc662),
8305 8306 8307 8308 8309 8310 8311 8312 8313 8314 8315 8316 8317
	HDA_CODEC_ENTRY(0x10ec0880, "ALC880", patch_alc880),
	HDA_CODEC_ENTRY(0x10ec0882, "ALC882", patch_alc882),
	HDA_CODEC_ENTRY(0x10ec0883, "ALC883", patch_alc882),
	HDA_CODEC_REV_ENTRY(0x10ec0885, 0x100101, "ALC889A", patch_alc882),
	HDA_CODEC_REV_ENTRY(0x10ec0885, 0x100103, "ALC889A", patch_alc882),
	HDA_CODEC_ENTRY(0x10ec0885, "ALC885", patch_alc882),
	HDA_CODEC_ENTRY(0x10ec0887, "ALC887", patch_alc882),
	HDA_CODEC_REV_ENTRY(0x10ec0888, 0x100101, "ALC1200", patch_alc882),
	HDA_CODEC_ENTRY(0x10ec0888, "ALC888", patch_alc882),
	HDA_CODEC_ENTRY(0x10ec0889, "ALC889", patch_alc882),
	HDA_CODEC_ENTRY(0x10ec0892, "ALC892", patch_alc662),
	HDA_CODEC_ENTRY(0x10ec0899, "ALC898", patch_alc882),
	HDA_CODEC_ENTRY(0x10ec0900, "ALC1150", patch_alc882),
8318
	HDA_CODEC_ENTRY(0x10ec1168, "ALC1220", patch_alc882),
8319
	HDA_CODEC_ENTRY(0x10ec1220, "ALC1220", patch_alc882),
L
Linus Torvalds 已提交
8320 8321
	{} /* terminator */
};
8322
MODULE_DEVICE_TABLE(hdaudio, snd_hda_id_realtek);
8323 8324 8325 8326

MODULE_LICENSE("GPL");
MODULE_DESCRIPTION("Realtek HD-audio codec");

8327
static struct hda_codec_driver realtek_driver = {
8328
	.id = snd_hda_id_realtek,
8329 8330
};

8331
module_hda_codec_driver(realtek_driver);