patch_realtek.c 142.7 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>
L
Linus Torvalds 已提交
32
#include <sound/core.h>
33
#include <sound/jack.h>
L
Linus Torvalds 已提交
34 35
#include "hda_codec.h"
#include "hda_local.h"
36
#include "hda_auto_parser.h"
37
#include "hda_jack.h"
38
#include "hda_generic.h"
L
Linus Torvalds 已提交
39

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

43
/* unsol event tags */
44
#define ALC_DCVOL_EVENT		0x08
45

46 47 48
/* for GPIO Poll */
#define GPIO_MASK	0x03

49 50 51 52 53 54 55 56 57
/* extra amp-initialization sequence types */
enum {
	ALC_INIT_NONE,
	ALC_INIT_DEFAULT,
	ALC_INIT_GPIO1,
	ALC_INIT_GPIO2,
	ALC_INIT_GPIO3,
};

58 59 60 61 62 63 64 65 66 67 68 69 70 71
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,
};

72 73 74 75 76 77 78 79 80 81
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;
82
	unsigned int  fixup:1; /* Means that this sku is set by driver, not read from hw */
83 84
};

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

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

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

96 97 98
	/* inverted dmic fix */
	unsigned int inv_dmic_fixup:1; /* has inverted digital-mic workaround */
	unsigned int inv_dmic_muted:1; /* R-ch of inv d-mic is muted? */
99
	hda_nid_t inv_dmic_pin;
100

101 102 103 104
	/* mute LED for HP laptops, see alc269_fixup_mic_mute_hook() */
	int mute_led_polarity;
	hda_nid_t mute_led_nid;

105 106
	unsigned int gpio_led; /* used for alc269_fixup_hp_gpio_led() */

107 108 109 110 111
	hda_nid_t headset_mic_pin;
	hda_nid_t headphone_mic_pin;
	int current_headset_mode;
	int current_headset_type;

112 113
	/* hooks */
	void (*init_hook)(struct hda_codec *codec);
114
#ifdef CONFIG_PM
115
	void (*power_hook)(struct hda_codec *codec);
116
#endif
117
	void (*shutup)(struct hda_codec *codec);
118

119
	int init_amp;
120
	int codec_variant;	/* flag for other variants */
121
	bool has_alc5505_dsp;
122

123 124 125
	/* for PLL fix */
	hda_nid_t pll_nid;
	unsigned int pll_coef_idx, pll_coef_bit;
126
	unsigned int coef0;
127 128
};

129
/*
130 131 132
 * 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().
133
 */
134
static void add_mixer(struct alc_spec *spec, const struct snd_kcontrol_new *mix)
135 136 137 138 139 140
{
	if (snd_BUG_ON(spec->num_mixers >= ARRAY_SIZE(spec->mixers)))
		return;
	spec->mixers[spec->num_mixers++] = mix;
}

141
/*
142
 * GPIO setup tables, used in initialization
143
 */
144
/* Enable GPIO mask and set output */
145
static const struct hda_verb alc_gpio1_init_verbs[] = {
146 147 148 149 150 151
	{0x01, AC_VERB_SET_GPIO_MASK, 0x01},
	{0x01, AC_VERB_SET_GPIO_DIRECTION, 0x01},
	{0x01, AC_VERB_SET_GPIO_DATA, 0x01},
	{ }
};

152
static const struct hda_verb alc_gpio2_init_verbs[] = {
153 154 155 156 157 158
	{0x01, AC_VERB_SET_GPIO_MASK, 0x02},
	{0x01, AC_VERB_SET_GPIO_DIRECTION, 0x02},
	{0x01, AC_VERB_SET_GPIO_DATA, 0x02},
	{ }
};

159
static const struct hda_verb alc_gpio3_init_verbs[] = {
160 161 162 163 164 165
	{0x01, AC_VERB_SET_GPIO_MASK, 0x03},
	{0x01, AC_VERB_SET_GPIO_DIRECTION, 0x03},
	{0x01, AC_VERB_SET_GPIO_DATA, 0x03},
	{ }
};

166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197
/*
 * 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;
	unsigned int val;

	if (!spec->pll_nid)
		return;
	snd_hda_codec_write(codec, spec->pll_nid, 0, AC_VERB_SET_COEF_INDEX,
			    spec->pll_coef_idx);
	val = snd_hda_codec_read(codec, spec->pll_nid, 0,
				 AC_VERB_GET_PROC_COEF, 0);
	snd_hda_codec_write(codec, spec->pll_nid, 0, AC_VERB_SET_COEF_INDEX,
			    spec->pll_coef_idx);
	snd_hda_codec_write(codec, spec->pll_nid, 0, AC_VERB_SET_PROC_COEF,
			    val & ~(1 << spec->pll_coef_bit));
}

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);
}

198
/* update the master volume per volume-knob's unsol event */
199
static void alc_update_knob_master(struct hda_codec *codec, struct hda_jack_tbl *jack)
200 201 202 203 204 205 206 207 208 209 210
{
	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;
211
	val = snd_hda_codec_read(codec, jack->nid, 0,
212 213 214 215 216 217 218 219
				 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);
}

220
static void alc880_unsol_event(struct hda_codec *codec, unsigned int res)
221
{
222 223 224
	/* For some reason, the res given from ALC880 is broken.
	   Here we adjust it properly. */
	snd_hda_jack_unsol_event(codec, res >> 2);
225 226
}

227 228 229 230 231 232 233 234
/* additional initialization for ALC888 variants */
static void alc888_coef_init(struct hda_codec *codec)
{
	unsigned int tmp;

	snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_COEF_INDEX, 0);
	tmp = snd_hda_codec_read(codec, 0x20, 0, AC_VERB_GET_PROC_COEF, 0);
	snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_COEF_INDEX, 7);
235
	if ((tmp & 0xf0) == 0x20)
236 237 238 239 240 241 242 243 244
		/* alc888S-VC */
		snd_hda_codec_read(codec, 0x20, 0,
				   AC_VERB_SET_PROC_COEF, 0x830);
	 else
		 /* alc888-VB */
		 snd_hda_codec_read(codec, 0x20, 0,
				    AC_VERB_SET_PROC_COEF, 0x3030);
}

245
/* additional initialization for ALC889 variants */
246 247 248 249 250 251 252 253 254 255
static void alc889_coef_init(struct hda_codec *codec)
{
	unsigned int tmp;

	snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_COEF_INDEX, 7);
	tmp = snd_hda_codec_read(codec, 0x20, 0, AC_VERB_GET_PROC_COEF, 0);
	snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_COEF_INDEX, 7);
	snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_PROC_COEF, tmp|0x2010);
}

256 257 258 259 260 261 262 263 264 265
/* 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);
}

266 267 268 269
/* 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 */
270 271 272 273 274 275
	static hda_nid_t pins[] = {
		0x0f, 0x10, 0x14, 0x15, 0
	};
	hda_nid_t *p;
	for (p = pins; *p; p++)
		set_eapd(codec, *p, on);
276 277
}

278 279 280 281 282 283 284
/* generic shutup callback;
 * just turning off EPAD and a little pause for avoiding pop-noise
 */
static void alc_eapd_shutup(struct hda_codec *codec)
{
	alc_auto_setup_eapd(codec, false);
	msleep(200);
285
	snd_hda_shutup_pins(codec);
286 287
}

288
/* generic EAPD initialization */
289
static void alc_auto_init_amp(struct hda_codec *codec, int type)
290
{
291
	unsigned int tmp;
292

293
	alc_auto_setup_eapd(codec, true);
294 295
	switch (type) {
	case ALC_INIT_GPIO1:
296 297
		snd_hda_sequence_write(codec, alc_gpio1_init_verbs);
		break;
298
	case ALC_INIT_GPIO2:
299 300
		snd_hda_sequence_write(codec, alc_gpio2_init_verbs);
		break;
301
	case ALC_INIT_GPIO3:
302 303
		snd_hda_sequence_write(codec, alc_gpio3_init_verbs);
		break;
304
	case ALC_INIT_DEFAULT:
305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321
		switch (codec->vendor_id) {
		case 0x10ec0260:
			snd_hda_codec_write(codec, 0x1a, 0,
					    AC_VERB_SET_COEF_INDEX, 7);
			tmp = snd_hda_codec_read(codec, 0x1a, 0,
						 AC_VERB_GET_PROC_COEF, 0);
			snd_hda_codec_write(codec, 0x1a, 0,
					    AC_VERB_SET_COEF_INDEX, 7);
			snd_hda_codec_write(codec, 0x1a, 0,
					    AC_VERB_SET_PROC_COEF,
					    tmp | 0x2010);
			break;
		case 0x10ec0262:
		case 0x10ec0880:
		case 0x10ec0882:
		case 0x10ec0883:
		case 0x10ec0885:
322
		case 0x10ec0887:
323
		/*case 0x10ec0889:*/ /* this causes an SPDIF problem */
324
			alc889_coef_init(codec);
325
			break;
326
		case 0x10ec0888:
327
			alc888_coef_init(codec);
328
			break;
329
#if 0 /* XXX: This may cause the silent output on speaker on some machines */
330 331 332 333 334 335 336
		case 0x10ec0267:
		case 0x10ec0268:
			snd_hda_codec_write(codec, 0x20, 0,
					    AC_VERB_SET_COEF_INDEX, 7);
			tmp = snd_hda_codec_read(codec, 0x20, 0,
						 AC_VERB_GET_PROC_COEF, 0);
			snd_hda_codec_write(codec, 0x20, 0,
337
					    AC_VERB_SET_COEF_INDEX, 7);
338 339 340 341
			snd_hda_codec_write(codec, 0x20, 0,
					    AC_VERB_SET_PROC_COEF,
					    tmp | 0x3000);
			break;
342
#endif /* XXX */
343
		}
344 345 346 347
		break;
	}
}

348

349
/*
350
 * Realtek SSID verification
351
 */
352

353 354 355 356
/* 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)
357

358 359
static void alc_fixup_sku_ignore(struct hda_codec *codec,
				 const struct hda_fixup *fix, int action)
360 361
{
	struct alc_spec *spec = codec->spec;
362 363 364
	if (action == HDA_FIXUP_ACT_PRE_PROBE) {
		spec->cdefine.fixup = 1;
		spec->cdefine.sku_cfg = ALC_FIXUP_SKU_IGNORE;
365 366 367
	}
}

368
static int alc_auto_parse_customize_define(struct hda_codec *codec)
369
{
370 371
	unsigned int ass, tmp, i;
	unsigned nid = 0;
372 373
	struct alc_spec *spec = codec->spec;

374
	spec->cdefine.enable_pcbeep = 1; /* assume always enabled */
375

376 377 378 379 380
	if (spec->cdefine.fixup) {
		ass = spec->cdefine.sku_cfg;
		if (ass == ALC_FIXUP_SKU_IGNORE)
			return -1;
		goto do_sku;
381 382
	}

383 384 385
	ass = codec->subsystem_id & 0xffff;
	if (ass != codec->bus->pci->subsystem_device && (ass & 1))
		goto do_sku;
386

387 388 389 390
	nid = 0x1d;
	if (codec->vendor_id == 0x10ec0260)
		nid = 0x17;
	ass = snd_hda_codec_get_pincfg(codec, nid);
391

392 393 394 395
	if (!(ass & 1)) {
		printk(KERN_INFO "hda_codec: %s: SKU not ready 0x%08x\n",
		       codec->chip_name, ass);
		return -1;
396 397
	}

398 399 400 401 402
	/* check sum */
	tmp = 0;
	for (i = 1; i < 16; i++) {
		if ((ass >> i) & 1)
			tmp++;
403
	}
404 405
	if (((ass >> 16) & 0xf) != tmp)
		return -1;
406

407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432
	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;

	snd_printd("SKU: Nid=0x%x sku_cfg=0x%08x\n",
		   nid, spec->cdefine.sku_cfg);
	snd_printd("SKU: port_connectivity=0x%x\n",
		   spec->cdefine.port_connectivity);
	snd_printd("SKU: enable_pcbeep=0x%x\n", spec->cdefine.enable_pcbeep);
	snd_printd("SKU: check_sum=0x%08x\n", spec->cdefine.check_sum);
	snd_printd("SKU: customization=0x%08x\n", spec->cdefine.customization);
	snd_printd("SKU: external_amp=0x%x\n", spec->cdefine.external_amp);
	snd_printd("SKU: platform_type=0x%x\n", spec->cdefine.platform_type);
	snd_printd("SKU: swap=0x%x\n", spec->cdefine.swap);
	snd_printd("SKU: override=0x%x\n", spec->cdefine.override);

	return 0;
}

433 434 435 436 437 438 439 440 441
/* 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;
}
442
/* return true if the given NID is found in the list */
443 444
static bool found_in_nid_list(hda_nid_t nid, const hda_nid_t *list, int nums)
{
445
	return find_idx_in_nid_list(nid, list, nums) >= 0;
446 447
}

448 449 450 451 452 453 454 455 456 457 458
/* 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
 */
static int alc_subsystem_id(struct hda_codec *codec,
			    hda_nid_t porta, hda_nid_t porte,
459
			    hda_nid_t portd, hda_nid_t porti)
460 461 462 463 464
{
	unsigned int ass, tmp, i;
	unsigned nid;
	struct alc_spec *spec = codec->spec;

465 466 467 468 469 470 471
	if (spec->cdefine.fixup) {
		ass = spec->cdefine.sku_cfg;
		if (ass == ALC_FIXUP_SKU_IGNORE)
			return 0;
		goto do_sku;
	}

472 473 474 475 476 477
	ass = codec->subsystem_id & 0xffff;
	if ((ass != codec->bus->pci->subsystem_device) && (ass & 1))
		goto do_sku;

	/* invalid SSID, check the special NID pin defcfg instead */
	/*
478
	 * 31~30	: port connectivity
479 480 481 482 483 484 485 486 487 488 489 490
	 * 29~21	: reserve
	 * 20		: PCBEEP input
	 * 19~16	: Check sum (15:1)
	 * 15~1		: Custom
	 * 0		: override
	*/
	nid = 0x1d;
	if (codec->vendor_id == 0x10ec0260)
		nid = 0x17;
	ass = snd_hda_codec_get_pincfg(codec, nid);
	snd_printd("realtek: No valid SSID, "
		   "checking pincfg 0x%08x for NID 0x%x\n",
491
		   ass, nid);
492
	if (!(ass & 1))
493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 526
		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:
	snd_printd("realtek: Enabling init ASM_ID=0x%04x CODEC_ID=%08x\n",
		   ass & 0xffff, codec->vendor_id);
	/*
	 * 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:
527
	default:
528
		spec->init_amp = ALC_INIT_DEFAULT;
529 530
		break;
	}
531

532
	/* is laptop or Desktop and enable the function "Mute internal speaker
533 534
	 * when the external headphone out jack is plugged"
	 */
535
	if (!(ass & 0x8000))
536
		return 1;
537 538 539 540 541 542 543
	/*
	 * 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"
	 */
544 545 546
	if (!spec->gen.autocfg.hp_pins[0] &&
	    !(spec->gen.autocfg.line_out_pins[0] &&
	      spec->gen.autocfg.line_out_type == AUTO_PIN_HP_OUT)) {
547
		hda_nid_t nid;
548 549
		tmp = (ass >> 11) & 0x3;	/* HP to chassis */
		if (tmp == 0)
550
			nid = porta;
551
		else if (tmp == 1)
552
			nid = porte;
553
		else if (tmp == 2)
554
			nid = portd;
555 556
		else if (tmp == 3)
			nid = porti;
557
		else
558
			return 1;
559 560
		if (found_in_nid_list(nid, spec->gen.autocfg.line_out_pins,
				      spec->gen.autocfg.line_outs))
561
			return 1;
562
		spec->gen.autocfg.hp_pins[0] = nid;
563
	}
564 565
	return 1;
}
566

567 568 569
/* 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)
570
{
571
	if (!alc_subsystem_id(codec, ports[0], ports[1], ports[2], ports[3])) {
572 573 574 575 576
		struct alc_spec *spec = codec->spec;
		snd_printd("realtek: "
			   "Enable default setup for auto mode as fallback\n");
		spec->init_amp = ALC_INIT_DEFAULT;
	}
577
}
578

579 580 581
/*
 * COEF access helper functions
 */
582 583 584 585 586 587 588 589 590 591 592
static int alc_read_coef_idx(struct hda_codec *codec,
			unsigned int coef_idx)
{
	unsigned int val;
	snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_COEF_INDEX,
		    		coef_idx);
	val = snd_hda_codec_read(codec, 0x20, 0,
			 	AC_VERB_GET_PROC_COEF, 0);
	return val;
}

593 594 595 596 597 598 599 600 601
static void alc_write_coef_idx(struct hda_codec *codec, unsigned int coef_idx,
							unsigned int coef_val)
{
	snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_COEF_INDEX,
			    coef_idx);
	snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_PROC_COEF,
			    coef_val);
}

602 603 604 605 606 607 608 609 610
/* 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;
}

611
/*
612
 */
613

614
static hda_nid_t get_adc_nid(struct hda_codec *codec, int adc_idx, int imux_idx)
615
{
616 617 618 619
	struct hda_gen_spec *spec = codec->spec;
	if (spec->dyn_adc_switch)
		adc_idx = spec->dyn_adc_idx[imux_idx];
	return spec->adc_nids[adc_idx];
620 621
}

622
static void alc_inv_dmic_sync_adc(struct hda_codec *codec, int adc_idx)
623 624
{
	struct alc_spec *spec = codec->spec;
625
	struct hda_input_mux *imux = &spec->gen.input_mux;
626 627 628 629
	struct nid_path *path;
	hda_nid_t nid;
	int i, dir, parm;
	unsigned int val;
630

631
	for (i = 0; i < imux->num_items; i++) {
632
		if (spec->gen.imux_pins[i] == spec->inv_dmic_pin)
633
			break;
634
	}
635 636
	if (i >= imux->num_items)
		return;
637

638 639
	path = snd_hda_get_nid_path(codec, spec->inv_dmic_pin,
				    get_adc_nid(codec, adc_idx, i));
640 641 642 643 644 645 646
	val = path->ctls[NID_PATH_MUTE_CTL];
	if (!val)
		return;
	nid = get_amp_nid_(val);
	dir = get_amp_direction_(val);
	parm = AC_AMP_SET_RIGHT |
		(dir == HDA_OUTPUT ? AC_AMP_SET_OUTPUT : AC_AMP_SET_INPUT);
647

648
	/* flush all cached amps at first */
649
	snd_hda_codec_flush_cache(codec);
650

651 652 653 654 655 656 657
	/* we care only right channel */
	val = snd_hda_codec_amp_read(codec, nid, 1, dir, 0);
	if (val & 0x80) /* if already muted, we don't need to touch */
		return;
	val |= 0x80;
	snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_AMP_GAIN_MUTE,
			    parm | val);
658 659
}

660 661 662 663 664 665 666 667 668 669 670 671 672 673 674 675 676 677
/*
 * Inverted digital-mic handling
 *
 * First off, it's a bit tricky.  The "Inverted Internal Mic Capture Switch"
 * gives the additional mute only to the right channel of the digital mic
 * capture stream.  This is a workaround for avoiding the almost silence
 * by summing the stereo stream from some (known to be ForteMedia)
 * digital mic unit.
 *
 * The logic is to call alc_inv_dmic_sync() after each action (possibly)
 * modifying ADC amp.  When the mute flag is set, it mutes the R-channel
 * without caching so that the cache can still keep the original value.
 * The cached value is then restored when the flag is set off or any other
 * than d-mic is used as the current input source.
 */
static void alc_inv_dmic_sync(struct hda_codec *codec, bool force)
{
	struct alc_spec *spec = codec->spec;
678
	int src, nums;
679 680 681 682 683

	if (!spec->inv_dmic_fixup)
		return;
	if (!spec->inv_dmic_muted && !force)
		return;
684
	nums = spec->gen.dyn_adc_switch ? 1 : spec->gen.num_adc_nids;
685
	for (src = 0; src < nums; src++) {
686 687 688
		bool dmic_fixup = false;

		if (spec->inv_dmic_muted &&
689
		    spec->gen.imux_pins[spec->gen.cur_mux[src]] == spec->inv_dmic_pin)
690 691 692
			dmic_fixup = true;
		if (!dmic_fixup && !force)
			continue;
693
		alc_inv_dmic_sync_adc(codec, src);
694 695 696
	}
}

697 698
static void alc_inv_dmic_hook(struct hda_codec *codec,
			     struct snd_ctl_elem_value *ucontrol)
699 700 701 702
{
	alc_inv_dmic_sync(codec, false);
}

703 704 705 706 707 708 709 710 711 712 713 714 715 716 717 718 719 720 721 722 723 724 725 726 727 728
static int alc_inv_dmic_sw_get(struct snd_kcontrol *kcontrol,
			       struct snd_ctl_elem_value *ucontrol)
{
	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
	struct alc_spec *spec = codec->spec;

	ucontrol->value.integer.value[0] = !spec->inv_dmic_muted;
	return 0;
}

static int alc_inv_dmic_sw_put(struct snd_kcontrol *kcontrol,
			       struct snd_ctl_elem_value *ucontrol)
{
	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
	struct alc_spec *spec = codec->spec;
	unsigned int val = !ucontrol->value.integer.value[0];

	if (val == spec->inv_dmic_muted)
		return 0;
	spec->inv_dmic_muted = val;
	alc_inv_dmic_sync(codec, true);
	return 0;
}

static const struct snd_kcontrol_new alc_inv_dmic_sw = {
	.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
729
	.name = "Inverted Internal Mic Capture Switch",
730 731 732 733 734 735 736 737
	.info = snd_ctl_boolean_mono_info,
	.get = alc_inv_dmic_sw_get,
	.put = alc_inv_dmic_sw_put,
};

static int alc_add_inv_dmic_mixer(struct hda_codec *codec, hda_nid_t nid)
{
	struct alc_spec *spec = codec->spec;
738

739
	if (!snd_hda_gen_add_kctl(&spec->gen, NULL, &alc_inv_dmic_sw))
740 741 742 743
		return -ENOMEM;
	spec->inv_dmic_fixup = 1;
	spec->inv_dmic_muted = 0;
	spec->inv_dmic_pin = nid;
744
	spec->gen.cap_sync_hook = alc_inv_dmic_hook;
745 746 747
	return 0;
}

748 749
/* typically the digital mic is put at node 0x12 */
static void alc_fixup_inv_dmic_0x12(struct hda_codec *codec,
750
				    const struct hda_fixup *fix, int action)
751
{
752
	if (action == HDA_FIXUP_ACT_PROBE)
753 754 755
		alc_add_inv_dmic_mixer(codec, 0x12);
}

756

757 758 759 760 761
#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),
762 763
	{ } /* end */
};
764
#endif
765

766
static int alc_build_controls(struct hda_codec *codec)
767 768
{
	struct alc_spec *spec = codec->spec;
769
	int i, err;
770

771 772 773
	err = snd_hda_gen_build_controls(codec);
	if (err < 0)
		return err;
L
Linus Torvalds 已提交
774 775 776 777 778 779

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

781
#ifdef CONFIG_SND_HDA_INPUT_BEEP
782 783
	/* create beep controls if needed */
	if (spec->beep_amp) {
784
		const struct snd_kcontrol_new *knew;
785 786 787 788
		for (knew = alc_beep_mixer; knew->name; knew++) {
			struct snd_kcontrol *kctl;
			kctl = snd_ctl_new1(knew, codec);
			if (!kctl)
789 790 791 792 793
				return -ENOMEM;
			kctl->private_value = spec->beep_amp;
			err = snd_hda_ctl_add(codec, 0, kctl);
			if (err < 0)
				return err;
794
		}
795
	}
796
#endif
797

798
	snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_BUILD);
799
	return 0;
800 801 802
}


803
/*
804
 * Common callbacks
805
 */
806

807
static int alc_init(struct hda_codec *codec)
808 809
{
	struct alc_spec *spec = codec->spec;
810

811 812
	if (spec->init_hook)
		spec->init_hook(codec);
813

814 815
	alc_fix_pll(codec);
	alc_auto_init_amp(codec, spec->init_amp);
816

817
	snd_hda_gen_init(codec);
818

819
	snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_INIT);
820

821 822
	return 0;
}
823

824
static inline void alc_shutup(struct hda_codec *codec)
825 826
{
	struct alc_spec *spec = codec->spec;
827

828 829
	if (spec && spec->shutup)
		spec->shutup(codec);
830 831
	else
		snd_hda_shutup_pins(codec);
832 833
}

834
#define alc_free	snd_hda_gen_free
835

836 837
#ifdef CONFIG_PM
static void alc_power_eapd(struct hda_codec *codec)
838
{
839
	alc_auto_setup_eapd(codec, false);
840
}
841

842
static int alc_suspend(struct hda_codec *codec)
843 844
{
	struct alc_spec *spec = codec->spec;
845 846 847
	alc_shutup(codec);
	if (spec && spec->power_hook)
		spec->power_hook(codec);
848 849
	return 0;
}
850
#endif
851

852 853
#ifdef CONFIG_PM
static int alc_resume(struct hda_codec *codec)
854
{
855 856 857 858 859 860 861
	msleep(150); /* to avoid pop noise */
	codec->patch_ops.init(codec);
	snd_hda_codec_resume_amp(codec);
	snd_hda_codec_resume_cache(codec);
	alc_inv_dmic_sync(codec, true);
	hda_call_check_power_status(codec, 0x01);
	return 0;
862
}
863
#endif
864

865 866
/*
 */
867 868 869 870 871 872 873 874 875
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,
876
	.check_power_status = snd_hda_gen_check_power_status,
877 878 879
#endif
	.reboot_notify = alc_shutup,
};
880

881

882 883
/* replace the codec chip_name with the given string */
static int alc_codec_rename(struct hda_codec *codec, const char *name)
884
{
885 886 887 888 889
	kfree(codec->chip_name);
	codec->chip_name = kstrdup(name, GFP_KERNEL);
	if (!codec->chip_name) {
		alc_free(codec);
		return -ENOMEM;
890
	}
891
	return 0;
892
}
893

894
/*
895
 * Rename codecs appropriately from COEF value
896
 */
897 898 899 900 901 902
struct alc_codec_rename_table {
	unsigned int vendor_id;
	unsigned short coef_mask;
	unsigned short coef_bits;
	const char *name;
};
K
Kailang Yang 已提交
903

904 905 906 907 908 909 910 911 912 913 914 915 916 917 918 919 920 921
static struct alc_codec_rename_table rename_tbl[] = {
	{ 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" },
	{ 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 已提交
922

923
static int alc_codec_rename_from_preset(struct hda_codec *codec)
924
{
925
	const struct alc_codec_rename_table *p;
926

927 928 929 930 931
	for (p = rename_tbl; p->vendor_id; p++) {
		if (p->vendor_id != codec->vendor_id)
			continue;
		if ((alc_get_coef0(codec) & p->coef_mask) == p->coef_bits)
			return alc_codec_rename(codec, p->name);
932
	}
933
	return 0;
934
}
935

936

937 938 939 940 941 942
/*
 * 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 已提交
943

944
static const struct snd_pci_quirk beep_white_list[] = {
945
	SND_PCI_QUIRK(0x1043, 0x103c, "ASUS", 1),
946
	SND_PCI_QUIRK(0x1043, 0x829f, "ASUS", 1),
947
	SND_PCI_QUIRK(0x1043, 0x8376, "EeePC", 1),
948 949 950
	SND_PCI_QUIRK(0x1043, 0x83ce, "EeePC", 1),
	SND_PCI_QUIRK(0x1043, 0x831a, "EeePC", 1),
	SND_PCI_QUIRK(0x1043, 0x834a, "EeePC", 1),
951
	SND_PCI_QUIRK(0x1458, 0xa002, "GA-MA790X", 1),
952 953
	SND_PCI_QUIRK(0x8086, 0xd613, "Intel", 1),
	{}
954 955
};

956 957 958 959 960 961 962 963 964 965 966 967 968
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 已提交
969

970 971 972 973
/* 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
 */
974 975 976
static int alc_parse_auto_config(struct hda_codec *codec,
				 const hda_nid_t *ignore_nids,
				 const hda_nid_t *ssid_nids)
977 978
{
	struct alc_spec *spec = codec->spec;
979
	struct auto_pin_cfg *cfg = &spec->gen.autocfg;
980
	int err;
981

982 983
	err = snd_hda_parse_pin_defcfg(codec, cfg, ignore_nids,
				       spec->parse_flags);
984 985
	if (err < 0)
		return err;
986 987 988

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

990 991 992
	err = snd_hda_gen_parse_auto_config(codec, cfg);
	if (err < 0)
		return err;
993

994
	return 1;
995
}
996

997 998 999 1000 1001 1002 1003 1004 1005
/* 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;
1006 1007 1008
	snd_hda_gen_spec_init(&spec->gen);
	spec->gen.mixer_nid = mixer_nid;
	spec->gen.own_eapd_ctl = 1;
1009
	codec->single_adc_amp = 1;
1010 1011
	/* FIXME: do we need this for all Realtek codec models? */
	codec->spdif_status_reset = 1;
1012 1013 1014 1015 1016 1017 1018 1019 1020

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

1021 1022 1023
static int alc880_parse_auto_config(struct hda_codec *codec)
{
	static const hda_nid_t alc880_ignore[] = { 0x1d, 0 };
1024
	static const hda_nid_t alc880_ssids[] = { 0x15, 0x1b, 0x14, 0 };
1025 1026 1027
	return alc_parse_auto_config(codec, alc880_ignore, alc880_ssids);
}

1028 1029 1030 1031
/*
 * ALC880 fix-ups
 */
enum {
1032
	ALC880_FIXUP_GPIO1,
1033 1034
	ALC880_FIXUP_GPIO2,
	ALC880_FIXUP_MEDION_RIM,
1035
	ALC880_FIXUP_LG,
1036
	ALC880_FIXUP_LG_LW25,
1037
	ALC880_FIXUP_W810,
1038
	ALC880_FIXUP_EAPD_COEF,
1039
	ALC880_FIXUP_TCL_S700,
1040 1041
	ALC880_FIXUP_VOL_KNOB,
	ALC880_FIXUP_FUJITSU,
1042
	ALC880_FIXUP_F1734,
1043
	ALC880_FIXUP_UNIWILL,
1044
	ALC880_FIXUP_UNIWILL_DIG,
1045
	ALC880_FIXUP_Z71V,
1046 1047 1048 1049 1050 1051 1052 1053 1054
	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,
1055
	ALC880_FIXUP_6ST_AUTOMUTE,
1056 1057
};

1058 1059
/* enable the volume-knob widget support on NID 0x21 */
static void alc880_fixup_vol_knob(struct hda_codec *codec,
1060
				  const struct hda_fixup *fix, int action)
1061
{
1062
	if (action == HDA_FIXUP_ACT_PROBE)
1063
		snd_hda_jack_detect_enable_callback(codec, 0x21, ALC_DCVOL_EVENT, alc_update_knob_master);
1064 1065
}

1066
static const struct hda_fixup alc880_fixups[] = {
1067
	[ALC880_FIXUP_GPIO1] = {
1068
		.type = HDA_FIXUP_VERBS,
1069 1070
		.v.verbs = alc_gpio1_init_verbs,
	},
1071
	[ALC880_FIXUP_GPIO2] = {
1072
		.type = HDA_FIXUP_VERBS,
1073 1074 1075
		.v.verbs = alc_gpio2_init_verbs,
	},
	[ALC880_FIXUP_MEDION_RIM] = {
1076
		.type = HDA_FIXUP_VERBS,
1077 1078 1079 1080 1081 1082 1083 1084
		.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,
	},
1085
	[ALC880_FIXUP_LG] = {
1086 1087
		.type = HDA_FIXUP_PINS,
		.v.pins = (const struct hda_pintbl[]) {
1088 1089 1090 1091 1092 1093 1094
			/* disable bogus unused pins */
			{ 0x16, 0x411111f0 },
			{ 0x18, 0x411111f0 },
			{ 0x1a, 0x411111f0 },
			{ }
		}
	},
1095 1096 1097 1098 1099 1100 1101 1102
	[ALC880_FIXUP_LG_LW25] = {
		.type = HDA_FIXUP_PINS,
		.v.pins = (const struct hda_pintbl[]) {
			{ 0x1a, 0x0181344f }, /* line-in */
			{ 0x1b, 0x0321403f }, /* headphone */
			{ }
		}
	},
1103
	[ALC880_FIXUP_W810] = {
1104 1105
		.type = HDA_FIXUP_PINS,
		.v.pins = (const struct hda_pintbl[]) {
1106 1107 1108 1109 1110 1111 1112
			/* disable bogus unused pins */
			{ 0x17, 0x411111f0 },
			{ }
		},
		.chained = true,
		.chain_id = ALC880_FIXUP_GPIO2,
	},
1113
	[ALC880_FIXUP_EAPD_COEF] = {
1114
		.type = HDA_FIXUP_VERBS,
1115 1116 1117 1118 1119 1120 1121
		.v.verbs = (const struct hda_verb[]) {
			/* change to EAPD mode */
			{ 0x20, AC_VERB_SET_COEF_INDEX, 0x07 },
			{ 0x20, AC_VERB_SET_PROC_COEF,  0x3060 },
			{}
		},
	},
1122
	[ALC880_FIXUP_TCL_S700] = {
1123
		.type = HDA_FIXUP_VERBS,
1124 1125 1126 1127 1128 1129 1130 1131 1132
		.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,
	},
1133
	[ALC880_FIXUP_VOL_KNOB] = {
1134
		.type = HDA_FIXUP_FUNC,
1135 1136 1137 1138
		.v.func = alc880_fixup_vol_knob,
	},
	[ALC880_FIXUP_FUJITSU] = {
		/* override all pins as BIOS on old Amilo is broken */
1139 1140
		.type = HDA_FIXUP_PINS,
		.v.pins = (const struct hda_pintbl[]) {
1141 1142 1143 1144 1145 1146 1147 1148 1149 1150 1151 1152 1153 1154 1155 1156
			{ 0x14, 0x0121411f }, /* HP */
			{ 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,
	},
1157 1158
	[ALC880_FIXUP_F1734] = {
		/* almost compatible with FUJITSU, but no bass and SPDIF */
1159 1160
		.type = HDA_FIXUP_PINS,
		.v.pins = (const struct hda_pintbl[]) {
1161 1162 1163 1164 1165 1166 1167 1168 1169 1170 1171 1172 1173 1174 1175 1176
			{ 0x14, 0x0121411f }, /* HP */
			{ 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,
	},
1177 1178
	[ALC880_FIXUP_UNIWILL] = {
		/* need to fix HP and speaker pins to be parsed correctly */
1179 1180
		.type = HDA_FIXUP_PINS,
		.v.pins = (const struct hda_pintbl[]) {
1181 1182 1183 1184 1185 1186
			{ 0x14, 0x0121411f }, /* HP */
			{ 0x15, 0x99030120 }, /* speaker */
			{ 0x16, 0x99030130 }, /* bass speaker */
			{ }
		},
	},
1187
	[ALC880_FIXUP_UNIWILL_DIG] = {
1188 1189
		.type = HDA_FIXUP_PINS,
		.v.pins = (const struct hda_pintbl[]) {
1190 1191 1192 1193 1194 1195 1196 1197
			/* disable bogus unused pins */
			{ 0x17, 0x411111f0 },
			{ 0x19, 0x411111f0 },
			{ 0x1b, 0x411111f0 },
			{ 0x1f, 0x411111f0 },
			{ }
		}
	},
1198
	[ALC880_FIXUP_Z71V] = {
1199 1200
		.type = HDA_FIXUP_PINS,
		.v.pins = (const struct hda_pintbl[]) {
1201 1202 1203 1204 1205 1206 1207 1208 1209 1210 1211 1212 1213 1214 1215
			/* 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 */
			{ }
		}
	},
1216
	[ALC880_FIXUP_3ST_BASE] = {
1217 1218
		.type = HDA_FIXUP_PINS,
		.v.pins = (const struct hda_pintbl[]) {
1219 1220 1221 1222 1223 1224 1225 1226 1227 1228 1229 1230 1231 1232 1233 1234
			{ 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] = {
1235 1236
		.type = HDA_FIXUP_PINS,
		.v.pins = (const struct hda_pintbl[]) {
1237 1238 1239 1240 1241 1242 1243
			{ 0x1e, 0x411111f0 }, /* N/A */
			{ }
		},
		.chained = true,
		.chain_id = ALC880_FIXUP_3ST_BASE,
	},
	[ALC880_FIXUP_3ST_DIG] = {
1244 1245
		.type = HDA_FIXUP_PINS,
		.v.pins = (const struct hda_pintbl[]) {
1246 1247 1248 1249 1250 1251 1252
			{ 0x1e, 0x0144111e }, /* SPDIF */
			{ }
		},
		.chained = true,
		.chain_id = ALC880_FIXUP_3ST_BASE,
	},
	[ALC880_FIXUP_5ST_BASE] = {
1253 1254
		.type = HDA_FIXUP_PINS,
		.v.pins = (const struct hda_pintbl[]) {
1255 1256 1257 1258 1259 1260 1261 1262 1263 1264 1265 1266 1267 1268 1269 1270
			{ 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] = {
1271 1272
		.type = HDA_FIXUP_PINS,
		.v.pins = (const struct hda_pintbl[]) {
1273 1274 1275 1276 1277 1278 1279
			{ 0x1e, 0x411111f0 }, /* N/A */
			{ }
		},
		.chained = true,
		.chain_id = ALC880_FIXUP_5ST_BASE,
	},
	[ALC880_FIXUP_5ST_DIG] = {
1280 1281
		.type = HDA_FIXUP_PINS,
		.v.pins = (const struct hda_pintbl[]) {
1282 1283 1284 1285 1286 1287 1288
			{ 0x1e, 0x0144111e }, /* SPDIF */
			{ }
		},
		.chained = true,
		.chain_id = ALC880_FIXUP_5ST_BASE,
	},
	[ALC880_FIXUP_6ST_BASE] = {
1289 1290
		.type = HDA_FIXUP_PINS,
		.v.pins = (const struct hda_pintbl[]) {
1291 1292 1293 1294 1295 1296 1297 1298 1299 1300 1301 1302 1303 1304 1305 1306
			{ 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] = {
1307 1308
		.type = HDA_FIXUP_PINS,
		.v.pins = (const struct hda_pintbl[]) {
1309 1310 1311 1312 1313 1314 1315
			{ 0x1e, 0x411111f0 }, /* N/A */
			{ }
		},
		.chained = true,
		.chain_id = ALC880_FIXUP_6ST_BASE,
	},
	[ALC880_FIXUP_6ST_DIG] = {
1316 1317
		.type = HDA_FIXUP_PINS,
		.v.pins = (const struct hda_pintbl[]) {
1318 1319 1320 1321 1322 1323
			{ 0x1e, 0x0144111e }, /* SPDIF */
			{ }
		},
		.chained = true,
		.chain_id = ALC880_FIXUP_6ST_BASE,
	},
1324 1325 1326 1327 1328 1329 1330 1331 1332
	[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,
	},
1333 1334 1335
};

static const struct snd_pci_quirk alc880_fixup_tbl[] = {
1336
	SND_PCI_QUIRK(0x1019, 0x0f69, "Coeus G610P", ALC880_FIXUP_W810),
1337
	SND_PCI_QUIRK(0x1043, 0x1964, "ASUS Z71V", ALC880_FIXUP_Z71V),
1338 1339
	SND_PCI_QUIRK_VENDOR(0x1043, "ASUS", ALC880_FIXUP_GPIO1),
	SND_PCI_QUIRK(0x1558, 0x5401, "Clevo GPIO2", ALC880_FIXUP_GPIO2),
1340
	SND_PCI_QUIRK_VENDOR(0x1558, "Clevo", ALC880_FIXUP_EAPD_COEF),
1341
	SND_PCI_QUIRK(0x1584, 0x9050, "Uniwill", ALC880_FIXUP_UNIWILL_DIG),
1342
	SND_PCI_QUIRK(0x1584, 0x9054, "Uniwill", ALC880_FIXUP_F1734),
1343
	SND_PCI_QUIRK(0x1584, 0x9070, "Uniwill", ALC880_FIXUP_UNIWILL),
1344
	SND_PCI_QUIRK(0x1584, 0x9077, "Uniwill P53", ALC880_FIXUP_VOL_KNOB),
1345
	SND_PCI_QUIRK(0x161f, 0x203d, "W810", ALC880_FIXUP_W810),
1346
	SND_PCI_QUIRK(0x161f, 0x205d, "Medion Rim 2150", ALC880_FIXUP_MEDION_RIM),
1347
	SND_PCI_QUIRK(0x1631, 0xe011, "PB 13201056", ALC880_FIXUP_6ST_AUTOMUTE),
1348
	SND_PCI_QUIRK(0x1734, 0x107c, "FSC F1734", ALC880_FIXUP_F1734),
1349
	SND_PCI_QUIRK(0x1734, 0x1094, "FSC Amilo M1451G", ALC880_FIXUP_FUJITSU),
1350
	SND_PCI_QUIRK(0x1734, 0x10ac, "FSC AMILO Xi 1526", ALC880_FIXUP_F1734),
1351
	SND_PCI_QUIRK(0x1734, 0x10b0, "FSC Amilo Pi1556", ALC880_FIXUP_FUJITSU),
1352 1353 1354
	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),
1355
	SND_PCI_QUIRK(0x1854, 0x0077, "LG LW25", ALC880_FIXUP_LG_LW25),
1356
	SND_PCI_QUIRK(0x19db, 0x4188, "TCL S700", ALC880_FIXUP_TCL_S700),
1357 1358 1359 1360 1361 1362 1363 1364 1365 1366 1367 1368 1369 1370 1371 1372 1373 1374 1375 1376 1377 1378 1379 1380 1381 1382 1383 1384 1385 1386 1387 1388 1389 1390 1391 1392 1393 1394 1395 1396 1397 1398 1399 1400 1401 1402 1403

	/* 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),
	{}
};

1404
static const struct hda_model_fixup alc880_fixup_models[] = {
1405 1406 1407 1408 1409 1410
	{.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"},
1411
	{.id = ALC880_FIXUP_6ST_AUTOMUTE, .name = "6stack-automute"},
1412 1413 1414 1415
	{}
};


1416 1417 1418 1419
/*
 * OK, here we have finally the patch for ALC880
 */
static int patch_alc880(struct hda_codec *codec)
1420
{
1421 1422
	struct alc_spec *spec;
	int err;
1423

1424 1425 1426
	err = alc_alloc_spec(codec, 0x0b);
	if (err < 0)
		return err;
1427

1428
	spec = codec->spec;
1429
	spec->gen.need_dac_fix = 1;
1430
	spec->gen.beep_nid = 0x01;
1431

1432
	snd_hda_pick_fixup(codec, alc880_fixup_models, alc880_fixup_tbl,
1433
		       alc880_fixups);
1434
	snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE);
1435

1436 1437 1438 1439
	/* automatic parse from the BIOS config */
	err = alc880_parse_auto_config(codec);
	if (err < 0)
		goto error;
1440

1441
	if (!spec->gen.no_analog)
1442
		set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
1443

1444
	codec->patch_ops = alc_patch_ops;
1445 1446
	codec->patch_ops.unsol_event = alc880_unsol_event;

1447

1448
	snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE);
1449

1450
	return 0;
1451 1452 1453 1454

 error:
	alc_free(codec);
	return err;
1455 1456
}

1457

1458
/*
1459
 * ALC260 support
1460
 */
1461
static int alc260_parse_auto_config(struct hda_codec *codec)
1462
{
1463
	static const hda_nid_t alc260_ignore[] = { 0x17, 0 };
1464 1465
	static const hda_nid_t alc260_ssids[] = { 0x10, 0x15, 0x0f, 0 };
	return alc_parse_auto_config(codec, alc260_ignore, alc260_ssids);
1466 1467
}

1468 1469 1470 1471
/*
 * Pin config fixes
 */
enum {
1472 1473 1474
	ALC260_FIXUP_HP_DC5750,
	ALC260_FIXUP_HP_PIN_0F,
	ALC260_FIXUP_COEF,
1475
	ALC260_FIXUP_GPIO1,
1476 1477
	ALC260_FIXUP_GPIO1_TOGGLE,
	ALC260_FIXUP_REPLACER,
1478
	ALC260_FIXUP_HP_B1900,
1479
	ALC260_FIXUP_KN1,
1480
	ALC260_FIXUP_FSC_S7020,
1481
	ALC260_FIXUP_FSC_S7020_JWSE,
1482 1483
};

1484 1485 1486 1487
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,
1488
			    spec->gen.hp_jack_present);
1489 1490 1491
}

static void alc260_fixup_gpio1_toggle(struct hda_codec *codec,
1492
				      const struct hda_fixup *fix, int action)
1493 1494
{
	struct alc_spec *spec = codec->spec;
1495
	if (action == HDA_FIXUP_ACT_PROBE) {
1496 1497 1498
		/* although the machine has only one output pin, we need to
		 * toggle GPIO1 according to the jack state
		 */
1499 1500 1501 1502 1503 1504
		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 */
		snd_hda_jack_detect_enable_callback(codec, 0x0f, HDA_GEN_HP_EVENT,
						    snd_hda_gen_hp_automute);
1505
		snd_hda_add_verbs(codec, alc_gpio1_init_verbs);
1506 1507 1508
	}
}

1509
static void alc260_fixup_kn1(struct hda_codec *codec,
1510
			     const struct hda_fixup *fix, int action)
1511 1512
{
	struct alc_spec *spec = codec->spec;
1513
	static const struct hda_pintbl pincfgs[] = {
1514 1515 1516 1517 1518 1519 1520 1521 1522 1523 1524 1525 1526 1527 1528 1529
		{ 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) {
1530 1531
	case HDA_FIXUP_ACT_PRE_PROBE:
		snd_hda_apply_pincfgs(codec, pincfgs);
1532
		break;
1533
	case HDA_FIXUP_ACT_PROBE:
1534 1535 1536 1537 1538
		spec->init_amp = ALC_INIT_NONE;
		break;
	}
}

1539 1540 1541 1542
static void alc260_fixup_fsc_s7020(struct hda_codec *codec,
				   const struct hda_fixup *fix, int action)
{
	struct alc_spec *spec = codec->spec;
1543 1544 1545
	if (action == HDA_FIXUP_ACT_PROBE)
		spec->init_amp = ALC_INIT_NONE;
}
1546

1547 1548 1549 1550 1551
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) {
1552
		spec->gen.add_jack_modes = 1;
1553
		spec->gen.hp_mic = 1;
1554
	}
1555 1556
}

1557
static const struct hda_fixup alc260_fixups[] = {
1558
	[ALC260_FIXUP_HP_DC5750] = {
1559 1560
		.type = HDA_FIXUP_PINS,
		.v.pins = (const struct hda_pintbl[]) {
1561 1562 1563 1564
			{ 0x11, 0x90130110 }, /* speaker */
			{ }
		}
	},
1565
	[ALC260_FIXUP_HP_PIN_0F] = {
1566 1567
		.type = HDA_FIXUP_PINS,
		.v.pins = (const struct hda_pintbl[]) {
1568 1569 1570 1571 1572
			{ 0x0f, 0x01214000 }, /* HP */
			{ }
		}
	},
	[ALC260_FIXUP_COEF] = {
1573
		.type = HDA_FIXUP_VERBS,
1574 1575 1576 1577 1578 1579 1580 1581
		.v.verbs = (const struct hda_verb[]) {
			{ 0x20, AC_VERB_SET_COEF_INDEX, 0x07 },
			{ 0x20, AC_VERB_SET_PROC_COEF,  0x3040 },
			{ }
		},
		.chained = true,
		.chain_id = ALC260_FIXUP_HP_PIN_0F,
	},
1582
	[ALC260_FIXUP_GPIO1] = {
1583
		.type = HDA_FIXUP_VERBS,
1584 1585
		.v.verbs = alc_gpio1_init_verbs,
	},
1586
	[ALC260_FIXUP_GPIO1_TOGGLE] = {
1587
		.type = HDA_FIXUP_FUNC,
1588 1589 1590 1591 1592
		.v.func = alc260_fixup_gpio1_toggle,
		.chained = true,
		.chain_id = ALC260_FIXUP_HP_PIN_0F,
	},
	[ALC260_FIXUP_REPLACER] = {
1593
		.type = HDA_FIXUP_VERBS,
1594 1595 1596 1597 1598 1599 1600 1601
		.v.verbs = (const struct hda_verb[]) {
			{ 0x20, AC_VERB_SET_COEF_INDEX, 0x07 },
			{ 0x20, AC_VERB_SET_PROC_COEF,  0x3050 },
			{ }
		},
		.chained = true,
		.chain_id = ALC260_FIXUP_GPIO1_TOGGLE,
	},
1602
	[ALC260_FIXUP_HP_B1900] = {
1603
		.type = HDA_FIXUP_FUNC,
1604 1605 1606
		.v.func = alc260_fixup_gpio1_toggle,
		.chained = true,
		.chain_id = ALC260_FIXUP_COEF,
1607 1608
	},
	[ALC260_FIXUP_KN1] = {
1609
		.type = HDA_FIXUP_FUNC,
1610 1611
		.v.func = alc260_fixup_kn1,
	},
1612 1613 1614 1615
	[ALC260_FIXUP_FSC_S7020] = {
		.type = HDA_FIXUP_FUNC,
		.v.func = alc260_fixup_fsc_s7020,
	},
1616 1617 1618 1619 1620 1621
	[ALC260_FIXUP_FSC_S7020_JWSE] = {
		.type = HDA_FIXUP_FUNC,
		.v.func = alc260_fixup_fsc_s7020_jwse,
		.chained = true,
		.chain_id = ALC260_FIXUP_FSC_S7020,
	},
1622 1623 1624
};

static const struct snd_pci_quirk alc260_fixup_tbl[] = {
1625
	SND_PCI_QUIRK(0x1025, 0x007b, "Acer C20x", ALC260_FIXUP_GPIO1),
1626
	SND_PCI_QUIRK(0x1025, 0x007f, "Acer Aspire 9500", ALC260_FIXUP_COEF),
1627
	SND_PCI_QUIRK(0x1025, 0x008f, "Acer", ALC260_FIXUP_GPIO1),
1628
	SND_PCI_QUIRK(0x103c, 0x280a, "HP dc5750", ALC260_FIXUP_HP_DC5750),
1629
	SND_PCI_QUIRK(0x103c, 0x30ba, "HP Presario B1900", ALC260_FIXUP_HP_B1900),
1630
	SND_PCI_QUIRK(0x10cf, 0x1326, "FSC LifeBook S7020", ALC260_FIXUP_FSC_S7020),
1631
	SND_PCI_QUIRK(0x1509, 0x4540, "Favorit 100XS", ALC260_FIXUP_GPIO1),
1632
	SND_PCI_QUIRK(0x152d, 0x0729, "Quanta KN1", ALC260_FIXUP_KN1),
1633
	SND_PCI_QUIRK(0x161f, 0x2057, "Replacer 672V", ALC260_FIXUP_REPLACER),
1634
	SND_PCI_QUIRK(0x1631, 0xc017, "PB V7900", ALC260_FIXUP_COEF),
1635 1636 1637
	{}
};

1638 1639 1640 1641 1642 1643 1644 1645
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"},
	{}
};

1646 1647 1648
/*
 */
static int patch_alc260(struct hda_codec *codec)
1649
{
1650
	struct alc_spec *spec;
1651
	int err;
1652

1653 1654 1655
	err = alc_alloc_spec(codec, 0x07);
	if (err < 0)
		return err;
1656

1657
	spec = codec->spec;
1658 1659 1660 1661 1662
	/* 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;
1663
	spec->gen.beep_nid = 0x01;
1664

1665 1666
	snd_hda_pick_fixup(codec, alc260_fixup_models, alc260_fixup_tbl,
			   alc260_fixups);
1667
	snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE);
1668

1669 1670 1671 1672
	/* automatic parse from the BIOS config */
	err = alc260_parse_auto_config(codec);
	if (err < 0)
		goto error;
1673

1674
	if (!spec->gen.no_analog)
1675
		set_beep_amp(spec, 0x07, 0x05, HDA_INPUT);
1676

1677 1678
	codec->patch_ops = alc_patch_ops;
	spec->shutup = alc_eapd_shutup;
1679

1680
	snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE);
1681

1682
	return 0;
1683 1684 1685 1686

 error:
	alc_free(codec);
	return err;
1687 1688
}

1689 1690 1691 1692 1693 1694 1695 1696 1697 1698 1699 1700 1701 1702 1703 1704

/*
 * 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
 */
1705
enum {
1706 1707 1708 1709 1710
	ALC882_FIXUP_ABIT_AW9D_MAX,
	ALC882_FIXUP_LENOVO_Y530,
	ALC882_FIXUP_PB_M5210,
	ALC882_FIXUP_ACER_ASPIRE_7736,
	ALC882_FIXUP_ASUS_W90V,
1711
	ALC889_FIXUP_CD,
1712
	ALC889_FIXUP_VAIO_TT,
1713
	ALC888_FIXUP_EEE1601,
1714
	ALC882_FIXUP_EAPD,
1715
	ALC883_FIXUP_EAPD,
1716
	ALC883_FIXUP_ACER_EAPD,
1717 1718
	ALC882_FIXUP_GPIO1,
	ALC882_FIXUP_GPIO2,
1719
	ALC882_FIXUP_GPIO3,
1720 1721
	ALC889_FIXUP_COEF,
	ALC882_FIXUP_ASUS_W2JC,
1722 1723 1724
	ALC882_FIXUP_ACER_ASPIRE_4930G,
	ALC882_FIXUP_ACER_ASPIRE_8930G,
	ALC882_FIXUP_ASPIRE_8930G_VERBS,
1725
	ALC885_FIXUP_MACPRO_GPIO,
1726
	ALC889_FIXUP_DAC_ROUTE,
1727 1728
	ALC889_FIXUP_MBP_VREF,
	ALC889_FIXUP_IMAC91_VREF,
1729
	ALC882_FIXUP_INV_DMIC,
1730
	ALC882_FIXUP_NO_PRIMARY_HP,
1731 1732
};

1733
static void alc889_fixup_coef(struct hda_codec *codec,
1734
			      const struct hda_fixup *fix, int action)
1735
{
1736
	if (action != HDA_FIXUP_ACT_INIT)
1737 1738 1739 1740
		return;
	alc889_coef_init(codec);
}

1741 1742 1743 1744 1745 1746 1747 1748 1749 1750 1751 1752 1753 1754 1755 1756 1757 1758 1759 1760 1761 1762 1763 1764 1765 1766 1767 1768 1769 1770 1771 1772 1773 1774 1775
/* 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;

	gpiostate = snd_hda_codec_read(codec, codec->afg, 0,
				       AC_VERB_GET_GPIO_DATA, 0);

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

	gpiomask = snd_hda_codec_read(codec, codec->afg, 0,
				      AC_VERB_GET_GPIO_MASK, 0);
	gpiomask |= (1 << pin);

	gpiodir = snd_hda_codec_read(codec, codec->afg, 0,
				     AC_VERB_GET_GPIO_DIRECTION, 0);
	gpiodir |= (1 << pin);


	snd_hda_codec_write(codec, codec->afg, 0,
			    AC_VERB_SET_GPIO_MASK, gpiomask);
	snd_hda_codec_write(codec, codec->afg, 0,
			    AC_VERB_SET_GPIO_DIRECTION, gpiodir);

	msleep(1);

	snd_hda_codec_write(codec, codec->afg, 0,
			    AC_VERB_SET_GPIO_DATA, gpiostate);
}

/* set up GPIO at initialization */
static void alc885_fixup_macpro_gpio(struct hda_codec *codec,
1776
				     const struct hda_fixup *fix, int action)
1777
{
1778
	if (action != HDA_FIXUP_ACT_INIT)
1779 1780 1781 1782 1783
		return;
	alc882_gpio_mute(codec, 0, 0);
	alc882_gpio_mute(codec, 1, 0);
}

1784 1785 1786 1787 1788
/* 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,
1789
				   const struct hda_fixup *fix, int action)
1790
{
1791
	if (action == HDA_FIXUP_ACT_PRE_PROBE) {
1792
		/* fake the connections during parsing the tree */
1793 1794 1795 1796 1797 1798
		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);
1799
	} else if (action == HDA_FIXUP_ACT_PROBE) {
1800 1801 1802 1803 1804 1805
		/* 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);
1806 1807 1808
	}
}

1809 1810
/* Set VREF on HP pin */
static void alc889_fixup_mbp_vref(struct hda_codec *codec,
1811
				  const struct hda_fixup *fix, int action)
1812 1813 1814 1815 1816
{
	struct alc_spec *spec = codec->spec;
	static hda_nid_t nids[2] = { 0x14, 0x15 };
	int i;

1817
	if (action != HDA_FIXUP_ACT_INIT)
1818 1819 1820 1821 1822
		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;
1823
		val = snd_hda_codec_get_pin_target(codec, nids[i]);
1824
		val |= AC_PINCTL_VREF_80;
1825
		snd_hda_set_pin_ctl(codec, nids[i], val);
1826
		spec->gen.keep_vref_in_automute = 1;
1827 1828 1829 1830 1831 1832
		break;
	}
}

/* Set VREF on speaker pins on imac91 */
static void alc889_fixup_imac91_vref(struct hda_codec *codec,
1833
				     const struct hda_fixup *fix, int action)
1834 1835 1836 1837 1838
{
	struct alc_spec *spec = codec->spec;
	static hda_nid_t nids[2] = { 0x18, 0x1a };
	int i;

1839
	if (action != HDA_FIXUP_ACT_INIT)
1840 1841 1842
		return;
	for (i = 0; i < ARRAY_SIZE(nids); i++) {
		unsigned int val;
1843
		val = snd_hda_codec_get_pin_target(codec, nids[i]);
1844
		val |= AC_PINCTL_VREF_50;
1845
		snd_hda_set_pin_ctl(codec, nids[i], val);
1846
	}
1847
	spec->gen.keep_vref_in_automute = 1;
1848 1849
}

1850
/* Don't take HP output as primary
1851 1852
 * 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
1853 1854
 */
static void alc882_fixup_no_primary_hp(struct hda_codec *codec,
1855
				       const struct hda_fixup *fix, int action)
1856 1857
{
	struct alc_spec *spec = codec->spec;
1858
	if (action == HDA_FIXUP_ACT_PRE_PROBE) {
1859
		spec->gen.no_primary_hp = 1;
1860 1861
		spec->gen.no_multi_io = 1;
	}
1862 1863
}

1864
static const struct hda_fixup alc882_fixups[] = {
1865
	[ALC882_FIXUP_ABIT_AW9D_MAX] = {
1866 1867
		.type = HDA_FIXUP_PINS,
		.v.pins = (const struct hda_pintbl[]) {
1868 1869 1870
			{ 0x15, 0x01080104 }, /* side */
			{ 0x16, 0x01011012 }, /* rear */
			{ 0x17, 0x01016011 }, /* clfe */
1871
			{ }
1872 1873
		}
	},
1874
	[ALC882_FIXUP_LENOVO_Y530] = {
1875 1876
		.type = HDA_FIXUP_PINS,
		.v.pins = (const struct hda_pintbl[]) {
1877 1878
			{ 0x15, 0x99130112 }, /* rear int speakers */
			{ 0x16, 0x99130111 }, /* subwoofer */
1879 1880 1881
			{ }
		}
	},
1882
	[ALC882_FIXUP_PB_M5210] = {
1883 1884 1885
		.type = HDA_FIXUP_PINCTLS,
		.v.pins = (const struct hda_pintbl[]) {
			{ 0x19, PIN_VREF50 },
1886 1887 1888
			{}
		}
	},
1889
	[ALC882_FIXUP_ACER_ASPIRE_7736] = {
1890
		.type = HDA_FIXUP_FUNC,
1891
		.v.func = alc_fixup_sku_ignore,
1892
	},
1893
	[ALC882_FIXUP_ASUS_W90V] = {
1894 1895
		.type = HDA_FIXUP_PINS,
		.v.pins = (const struct hda_pintbl[]) {
1896 1897 1898 1899
			{ 0x16, 0x99130110 }, /* fix sequence for CLFE */
			{ }
		}
	},
1900
	[ALC889_FIXUP_CD] = {
1901 1902
		.type = HDA_FIXUP_PINS,
		.v.pins = (const struct hda_pintbl[]) {
1903 1904 1905 1906
			{ 0x1c, 0x993301f0 }, /* CD */
			{ }
		}
	},
1907
	[ALC889_FIXUP_VAIO_TT] = {
1908 1909
		.type = HDA_FIXUP_PINS,
		.v.pins = (const struct hda_pintbl[]) {
1910 1911 1912 1913
			{ 0x17, 0x90170111 }, /* hidden surround speaker */
			{ }
		}
	},
1914
	[ALC888_FIXUP_EEE1601] = {
1915
		.type = HDA_FIXUP_VERBS,
1916 1917 1918 1919 1920
		.v.verbs = (const struct hda_verb[]) {
			{ 0x20, AC_VERB_SET_COEF_INDEX, 0x0b },
			{ 0x20, AC_VERB_SET_PROC_COEF,  0x0838 },
			{ }
		}
1921 1922
	},
	[ALC882_FIXUP_EAPD] = {
1923
		.type = HDA_FIXUP_VERBS,
1924 1925 1926 1927 1928 1929 1930
		.v.verbs = (const struct hda_verb[]) {
			/* change to EAPD mode */
			{ 0x20, AC_VERB_SET_COEF_INDEX, 0x07 },
			{ 0x20, AC_VERB_SET_PROC_COEF, 0x3060 },
			{ }
		}
	},
1931
	[ALC883_FIXUP_EAPD] = {
1932
		.type = HDA_FIXUP_VERBS,
1933 1934 1935 1936 1937 1938 1939
		.v.verbs = (const struct hda_verb[]) {
			/* change to EAPD mode */
			{ 0x20, AC_VERB_SET_COEF_INDEX, 0x07 },
			{ 0x20, AC_VERB_SET_PROC_COEF, 0x3070 },
			{ }
		}
	},
1940
	[ALC883_FIXUP_ACER_EAPD] = {
1941
		.type = HDA_FIXUP_VERBS,
1942 1943 1944 1945 1946 1947 1948
		.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 },
			{ }
		}
	},
1949
	[ALC882_FIXUP_GPIO1] = {
1950
		.type = HDA_FIXUP_VERBS,
1951 1952 1953
		.v.verbs = alc_gpio1_init_verbs,
	},
	[ALC882_FIXUP_GPIO2] = {
1954
		.type = HDA_FIXUP_VERBS,
1955 1956
		.v.verbs = alc_gpio2_init_verbs,
	},
1957
	[ALC882_FIXUP_GPIO3] = {
1958
		.type = HDA_FIXUP_VERBS,
1959 1960
		.v.verbs = alc_gpio3_init_verbs,
	},
1961
	[ALC882_FIXUP_ASUS_W2JC] = {
1962
		.type = HDA_FIXUP_VERBS,
1963 1964 1965 1966 1967
		.v.verbs = alc_gpio1_init_verbs,
		.chained = true,
		.chain_id = ALC882_FIXUP_EAPD,
	},
	[ALC889_FIXUP_COEF] = {
1968
		.type = HDA_FIXUP_FUNC,
1969 1970
		.v.func = alc889_fixup_coef,
	},
1971
	[ALC882_FIXUP_ACER_ASPIRE_4930G] = {
1972 1973
		.type = HDA_FIXUP_PINS,
		.v.pins = (const struct hda_pintbl[]) {
1974 1975 1976
			{ 0x16, 0x99130111 }, /* CLFE speaker */
			{ 0x17, 0x99130112 }, /* surround speaker */
			{ }
1977 1978 1979
		},
		.chained = true,
		.chain_id = ALC882_FIXUP_GPIO1,
1980 1981
	},
	[ALC882_FIXUP_ACER_ASPIRE_8930G] = {
1982 1983
		.type = HDA_FIXUP_PINS,
		.v.pins = (const struct hda_pintbl[]) {
1984 1985 1986 1987 1988 1989 1990 1991 1992
			{ 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 */
1993
		.type = HDA_FIXUP_VERBS,
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
		.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 },
			{ }
2022 2023 2024
		},
		.chained = true,
		.chain_id = ALC882_FIXUP_GPIO1,
2025
	},
2026
	[ALC885_FIXUP_MACPRO_GPIO] = {
2027
		.type = HDA_FIXUP_FUNC,
2028 2029
		.v.func = alc885_fixup_macpro_gpio,
	},
2030
	[ALC889_FIXUP_DAC_ROUTE] = {
2031
		.type = HDA_FIXUP_FUNC,
2032 2033
		.v.func = alc889_fixup_dac_route,
	},
2034
	[ALC889_FIXUP_MBP_VREF] = {
2035
		.type = HDA_FIXUP_FUNC,
2036 2037 2038 2039 2040
		.v.func = alc889_fixup_mbp_vref,
		.chained = true,
		.chain_id = ALC882_FIXUP_GPIO1,
	},
	[ALC889_FIXUP_IMAC91_VREF] = {
2041
		.type = HDA_FIXUP_FUNC,
2042 2043 2044 2045
		.v.func = alc889_fixup_imac91_vref,
		.chained = true,
		.chain_id = ALC882_FIXUP_GPIO1,
	},
2046
	[ALC882_FIXUP_INV_DMIC] = {
2047
		.type = HDA_FIXUP_FUNC,
2048 2049
		.v.func = alc_fixup_inv_dmic_0x12,
	},
2050
	[ALC882_FIXUP_NO_PRIMARY_HP] = {
2051
		.type = HDA_FIXUP_FUNC,
2052 2053
		.v.func = alc882_fixup_no_primary_hp,
	},
2054 2055
};

2056
static const struct snd_pci_quirk alc882_fixup_tbl[] = {
2057 2058 2059 2060 2061 2062
	SND_PCI_QUIRK(0x1025, 0x006c, "Acer Aspire 9810", ALC883_FIXUP_ACER_EAPD),
	SND_PCI_QUIRK(0x1025, 0x0090, "Acer Aspire", ALC883_FIXUP_ACER_EAPD),
	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),
2063 2064 2065 2066 2067 2068 2069 2070 2071 2072 2073 2074 2075 2076
	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),
2077
	SND_PCI_QUIRK(0x1025, 0x0155, "Packard-Bell M5120", ALC882_FIXUP_PB_M5210),
2078 2079
	SND_PCI_QUIRK(0x1025, 0x021e, "Acer Aspire 5739G",
		      ALC882_FIXUP_ACER_ASPIRE_4930G),
2080
	SND_PCI_QUIRK(0x1025, 0x0259, "Acer Aspire 5935", ALC889_FIXUP_DAC_ROUTE),
2081
	SND_PCI_QUIRK(0x1025, 0x026b, "Acer Aspire 8940G", ALC882_FIXUP_ACER_ASPIRE_8930G),
2082
	SND_PCI_QUIRK(0x1025, 0x0296, "Acer Aspire 7736z", ALC882_FIXUP_ACER_ASPIRE_7736),
2083
	SND_PCI_QUIRK(0x1043, 0x13c2, "Asus A7M", ALC882_FIXUP_EAPD),
2084
	SND_PCI_QUIRK(0x1043, 0x1873, "ASUS W90V", ALC882_FIXUP_ASUS_W90V),
2085
	SND_PCI_QUIRK(0x1043, 0x1971, "Asus W2JC", ALC882_FIXUP_ASUS_W2JC),
2086
	SND_PCI_QUIRK(0x1043, 0x835f, "Asus Eee 1601", ALC888_FIXUP_EEE1601),
2087
	SND_PCI_QUIRK(0x104d, 0x9047, "Sony Vaio TT", ALC889_FIXUP_VAIO_TT),
2088
	SND_PCI_QUIRK(0x104d, 0x905a, "Sony Vaio Z", ALC882_FIXUP_NO_PRIMARY_HP),
2089
	SND_PCI_QUIRK(0x104d, 0x9043, "Sony Vaio VGC-LN51JGB", ALC882_FIXUP_NO_PRIMARY_HP),
2090 2091

	/* All Apple entries are in codec SSIDs */
2092 2093 2094
	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),
2095 2096 2097
	SND_PCI_QUIRK(0x106b, 0x0c00, "Mac Pro", ALC885_FIXUP_MACPRO_GPIO),
	SND_PCI_QUIRK(0x106b, 0x1000, "iMac 24", ALC885_FIXUP_MACPRO_GPIO),
	SND_PCI_QUIRK(0x106b, 0x2800, "AppleTV", ALC885_FIXUP_MACPRO_GPIO),
2098 2099
	SND_PCI_QUIRK(0x106b, 0x2c00, "MacbookPro rev3", ALC889_FIXUP_MBP_VREF),
	SND_PCI_QUIRK(0x106b, 0x3000, "iMac", ALC889_FIXUP_MBP_VREF),
2100
	SND_PCI_QUIRK(0x106b, 0x3200, "iMac 7,1 Aluminum", ALC882_FIXUP_EAPD),
2101 2102 2103 2104
	SND_PCI_QUIRK(0x106b, 0x3400, "MacBookAir 1,1", ALC889_FIXUP_MBP_VREF),
	SND_PCI_QUIRK(0x106b, 0x3500, "MacBookAir 2,1", ALC889_FIXUP_MBP_VREF),
	SND_PCI_QUIRK(0x106b, 0x3600, "Macbook 3,1", ALC889_FIXUP_MBP_VREF),
	SND_PCI_QUIRK(0x106b, 0x3800, "MacbookPro 4,1", ALC889_FIXUP_MBP_VREF),
2105
	SND_PCI_QUIRK(0x106b, 0x3e00, "iMac 24 Aluminum", ALC885_FIXUP_MACPRO_GPIO),
2106 2107 2108
	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),
2109
	SND_PCI_QUIRK(0x106b, 0x4200, "Mac Pro 5,1", ALC885_FIXUP_MACPRO_GPIO),
2110
	SND_PCI_QUIRK(0x106b, 0x4300, "iMac 9,1", ALC889_FIXUP_IMAC91_VREF),
2111 2112 2113
	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),
	SND_PCI_QUIRK(0x106b, 0x4a00, "Macbook 5,2", ALC889_FIXUP_IMAC91_VREF),
2114

2115
	SND_PCI_QUIRK(0x1071, 0x8258, "Evesham Voyaeger", ALC882_FIXUP_EAPD),
2116
	SND_PCI_QUIRK(0x1462, 0x7350, "MSI-7350", ALC889_FIXUP_CD),
2117
	SND_PCI_QUIRK_VENDOR(0x1462, "MSI", ALC882_FIXUP_GPIO3),
2118
	SND_PCI_QUIRK(0x1458, 0xa002, "Gigabyte EP45-DS3", ALC889_FIXUP_CD),
2119
	SND_PCI_QUIRK(0x147b, 0x107a, "Abit AW9D-MAX", ALC882_FIXUP_ABIT_AW9D_MAX),
2120 2121
	SND_PCI_QUIRK_VENDOR(0x1558, "Clevo laptop", ALC882_FIXUP_EAPD),
	SND_PCI_QUIRK(0x161f, 0x2054, "Medion laptop", ALC883_FIXUP_EAPD),
2122
	SND_PCI_QUIRK(0x17aa, 0x3a0d, "Lenovo Y530", ALC882_FIXUP_LENOVO_Y530),
2123
	SND_PCI_QUIRK(0x8086, 0x0022, "DX58SO", ALC889_FIXUP_COEF),
2124 2125 2126
	{}
};

2127
static const struct hda_model_fixup alc882_fixup_models[] = {
2128 2129 2130
	{.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"},
2131
	{.id = ALC882_FIXUP_INV_DMIC, .name = "inv-dmic"},
2132
	{.id = ALC882_FIXUP_NO_PRIMARY_HP, .name = "no-primary-hp"},
2133 2134 2135
	{}
};

2136
/*
2137
 * BIOS auto configuration
2138
 */
2139 2140 2141 2142
/* almost identical with ALC880 parser... */
static int alc882_parse_auto_config(struct hda_codec *codec)
{
	static const hda_nid_t alc882_ignore[] = { 0x1d, 0 };
2143 2144
	static const hda_nid_t alc882_ssids[] = { 0x15, 0x1b, 0x14, 0 };
	return alc_parse_auto_config(codec, alc882_ignore, alc882_ssids);
2145
}
2146

2147 2148 2149
/*
 */
static int patch_alc882(struct hda_codec *codec)
2150 2151
{
	struct alc_spec *spec;
2152
	int err;
2153

2154 2155 2156
	err = alc_alloc_spec(codec, 0x0b);
	if (err < 0)
		return err;
2157

2158
	spec = codec->spec;
2159

2160 2161 2162 2163 2164 2165 2166 2167
	switch (codec->vendor_id) {
	case 0x10ec0882:
	case 0x10ec0885:
		break;
	default:
		/* ALC883 and variants */
		alc_fix_pll_init(codec, 0x20, 0x0a, 10);
		break;
2168
	}
2169

2170
	snd_hda_pick_fixup(codec, alc882_fixup_models, alc882_fixup_tbl,
2171
		       alc882_fixups);
2172
	snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE);
2173

2174 2175
	alc_auto_parse_customize_define(codec);

2176 2177 2178
	if (has_cdefine_beep(codec))
		spec->gen.beep_nid = 0x01;

2179 2180 2181 2182
	/* automatic parse from the BIOS config */
	err = alc882_parse_auto_config(codec);
	if (err < 0)
		goto error;
2183

2184
	if (!spec->gen.no_analog && spec->gen.beep_nid)
2185
		set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
2186 2187

	codec->patch_ops = alc_patch_ops;
2188

2189
	snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE);
2190

2191
	return 0;
2192 2193 2194 2195

 error:
	alc_free(codec);
	return err;
2196 2197
}

2198 2199

/*
2200
 * ALC262 support
2201
 */
2202
static int alc262_parse_auto_config(struct hda_codec *codec)
2203
{
2204
	static const hda_nid_t alc262_ignore[] = { 0x1d, 0 };
2205 2206
	static const hda_nid_t alc262_ssids[] = { 0x15, 0x1b, 0x14, 0 };
	return alc_parse_auto_config(codec, alc262_ignore, alc262_ssids);
2207 2208 2209
}

/*
2210
 * Pin config fixes
2211
 */
2212
enum {
2213
	ALC262_FIXUP_FSC_H270,
2214
	ALC262_FIXUP_FSC_S7110,
2215 2216
	ALC262_FIXUP_HP_Z200,
	ALC262_FIXUP_TYAN,
2217
	ALC262_FIXUP_LENOVO_3000,
2218 2219
	ALC262_FIXUP_BENQ,
	ALC262_FIXUP_BENQ_T31,
2220
	ALC262_FIXUP_INV_DMIC,
2221 2222
};

2223
static const struct hda_fixup alc262_fixups[] = {
2224
	[ALC262_FIXUP_FSC_H270] = {
2225 2226
		.type = HDA_FIXUP_PINS,
		.v.pins = (const struct hda_pintbl[]) {
2227 2228 2229 2230 2231 2232
			{ 0x14, 0x99130110 }, /* speaker */
			{ 0x15, 0x0221142f }, /* front HP */
			{ 0x1b, 0x0121141f }, /* rear HP */
			{ }
		}
	},
2233 2234 2235 2236 2237 2238 2239 2240 2241
	[ALC262_FIXUP_FSC_S7110] = {
		.type = HDA_FIXUP_PINS,
		.v.pins = (const struct hda_pintbl[]) {
			{ 0x15, 0x90170110 }, /* speaker */
			{ }
		},
		.chained = true,
		.chain_id = ALC262_FIXUP_BENQ,
	},
2242
	[ALC262_FIXUP_HP_Z200] = {
2243 2244
		.type = HDA_FIXUP_PINS,
		.v.pins = (const struct hda_pintbl[]) {
2245
			{ 0x16, 0x99130120 }, /* internal speaker */
2246 2247
			{ }
		}
2248
	},
2249
	[ALC262_FIXUP_TYAN] = {
2250 2251
		.type = HDA_FIXUP_PINS,
		.v.pins = (const struct hda_pintbl[]) {
2252 2253 2254 2255
			{ 0x14, 0x1993e1f0 }, /* int AUX */
			{ }
		}
	},
2256
	[ALC262_FIXUP_LENOVO_3000] = {
2257 2258 2259
		.type = HDA_FIXUP_PINCTLS,
		.v.pins = (const struct hda_pintbl[]) {
			{ 0x19, PIN_VREF50 },
2260 2261 2262 2263 2264 2265
			{}
		},
		.chained = true,
		.chain_id = ALC262_FIXUP_BENQ,
	},
	[ALC262_FIXUP_BENQ] = {
2266
		.type = HDA_FIXUP_VERBS,
2267
		.v.verbs = (const struct hda_verb[]) {
2268 2269 2270 2271 2272
			{ 0x20, AC_VERB_SET_COEF_INDEX, 0x07 },
			{ 0x20, AC_VERB_SET_PROC_COEF, 0x3070 },
			{}
		}
	},
2273
	[ALC262_FIXUP_BENQ_T31] = {
2274
		.type = HDA_FIXUP_VERBS,
2275 2276 2277 2278 2279 2280
		.v.verbs = (const struct hda_verb[]) {
			{ 0x20, AC_VERB_SET_COEF_INDEX, 0x07 },
			{ 0x20, AC_VERB_SET_PROC_COEF, 0x3050 },
			{}
		}
	},
2281
	[ALC262_FIXUP_INV_DMIC] = {
2282
		.type = HDA_FIXUP_FUNC,
2283 2284
		.v.func = alc_fixup_inv_dmic_0x12,
	},
2285 2286
};

2287
static const struct snd_pci_quirk alc262_fixup_tbl[] = {
2288
	SND_PCI_QUIRK(0x103c, 0x170b, "HP Z200", ALC262_FIXUP_HP_Z200),
2289
	SND_PCI_QUIRK(0x10cf, 0x1397, "Fujitsu Lifebook S7110", ALC262_FIXUP_FSC_S7110),
2290
	SND_PCI_QUIRK(0x10cf, 0x142d, "Fujitsu Lifebook E8410", ALC262_FIXUP_BENQ),
2291 2292
	SND_PCI_QUIRK(0x10f1, 0x2915, "Tyan Thunder n6650W", ALC262_FIXUP_TYAN),
	SND_PCI_QUIRK(0x1734, 0x1147, "FSC Celsius H270", ALC262_FIXUP_FSC_H270),
2293
	SND_PCI_QUIRK(0x17aa, 0x384e, "Lenovo 3000", ALC262_FIXUP_LENOVO_3000),
2294 2295
	SND_PCI_QUIRK(0x17ff, 0x0560, "Benq ED8", ALC262_FIXUP_BENQ),
	SND_PCI_QUIRK(0x17ff, 0x058d, "Benq T31-16", ALC262_FIXUP_BENQ_T31),
2296 2297
	{}
};
2298

2299
static const struct hda_model_fixup alc262_fixup_models[] = {
2300 2301 2302
	{.id = ALC262_FIXUP_INV_DMIC, .name = "inv-dmic"},
	{}
};
2303 2304 2305 2306

/*
 */
static int patch_alc262(struct hda_codec *codec)
2307 2308 2309 2310
{
	struct alc_spec *spec;
	int err;

2311 2312 2313
	err = alc_alloc_spec(codec, 0x0b);
	if (err < 0)
		return err;
2314

2315
	spec = codec->spec;
2316
	spec->gen.shared_mic_vref_pin = 0x18;
2317 2318 2319 2320 2321 2322 2323 2324 2325 2326 2327 2328 2329 2330 2331

#if 0
	/* pshou 07/11/05  set a zero PCM sample to DAC when FIFO is
	 * under-run
	 */
	{
	int tmp;
	snd_hda_codec_write(codec, 0x1a, 0, AC_VERB_SET_COEF_INDEX, 7);
	tmp = snd_hda_codec_read(codec, 0x20, 0, AC_VERB_GET_PROC_COEF, 0);
	snd_hda_codec_write(codec, 0x1a, 0, AC_VERB_SET_COEF_INDEX, 7);
	snd_hda_codec_write(codec, 0x1a, 0, AC_VERB_SET_PROC_COEF, tmp | 0x80);
	}
#endif
	alc_fix_pll_init(codec, 0x20, 0x0a, 10);

2332
	snd_hda_pick_fixup(codec, alc262_fixup_models, alc262_fixup_tbl,
2333
		       alc262_fixups);
2334
	snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE);
2335

2336 2337
	alc_auto_parse_customize_define(codec);

2338 2339 2340
	if (has_cdefine_beep(codec))
		spec->gen.beep_nid = 0x01;

2341 2342 2343 2344
	/* automatic parse from the BIOS config */
	err = alc262_parse_auto_config(codec);
	if (err < 0)
		goto error;
2345

2346
	if (!spec->gen.no_analog && spec->gen.beep_nid)
2347
		set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
2348

2349
	codec->patch_ops = alc_patch_ops;
2350 2351
	spec->shutup = alc_eapd_shutup;

2352
	snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE);
2353

L
Linus Torvalds 已提交
2354
	return 0;
2355 2356 2357 2358

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

2361
/*
2362
 *  ALC268
2363
 */
2364 2365 2366 2367 2368 2369 2370 2371
/* bind Beep switches of both NID 0x0f and 0x10 */
static const struct hda_bind_ctls alc268_bind_beep_sw = {
	.ops = &snd_hda_bind_sw,
	.values = {
		HDA_COMPOSE_AMP_VAL(0x0f, 3, 1, HDA_INPUT),
		HDA_COMPOSE_AMP_VAL(0x10, 3, 1, HDA_INPUT),
		0
	},
2372 2373
};

2374 2375 2376 2377
static const struct snd_kcontrol_new alc268_beep_mixer[] = {
	HDA_CODEC_VOLUME("Beep Playback Volume", 0x1d, 0x0, HDA_INPUT),
	HDA_BIND_SW("Beep Playback Switch", &alc268_bind_beep_sw),
	{ }
2378 2379
};

2380 2381 2382 2383 2384 2385
/* 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)},
	{ }
2386 2387
};

2388 2389
enum {
	ALC268_FIXUP_INV_DMIC,
2390
	ALC268_FIXUP_HP_EAPD,
2391 2392
};

2393
static const struct hda_fixup alc268_fixups[] = {
2394
	[ALC268_FIXUP_INV_DMIC] = {
2395
		.type = HDA_FIXUP_FUNC,
2396 2397
		.v.func = alc_fixup_inv_dmic_0x12,
	},
2398
	[ALC268_FIXUP_HP_EAPD] = {
2399
		.type = HDA_FIXUP_VERBS,
2400 2401 2402 2403 2404
		.v.verbs = (const struct hda_verb[]) {
			{0x15, AC_VERB_SET_EAPD_BTLENABLE, 0},
			{}
		}
	},
2405 2406
};

2407
static const struct hda_model_fixup alc268_fixup_models[] = {
2408
	{.id = ALC268_FIXUP_INV_DMIC, .name = "inv-dmic"},
2409 2410 2411 2412 2413
	{.id = ALC268_FIXUP_HP_EAPD, .name = "hp-eapd"},
	{}
};

static const struct snd_pci_quirk alc268_fixup_tbl[] = {
2414
	SND_PCI_QUIRK(0x1025, 0x015b, "Acer AOA 150 (ZG5)", ALC268_FIXUP_INV_DMIC),
2415 2416 2417 2418
	/* 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),
2419 2420 2421
	{}
};

2422 2423 2424
/*
 * BIOS auto configuration
 */
2425
static int alc268_parse_auto_config(struct hda_codec *codec)
2426
{
2427
	static const hda_nid_t alc268_ssids[] = { 0x15, 0x1b, 0x14, 0 };
2428
	return alc_parse_auto_config(codec, NULL, alc268_ssids);
2429 2430
}

2431 2432 2433
/*
 */
static int patch_alc268(struct hda_codec *codec)
2434 2435
{
	struct alc_spec *spec;
2436
	int err;
2437

2438
	/* ALC268 has no aa-loopback mixer */
2439 2440 2441 2442 2443
	err = alc_alloc_spec(codec, 0);
	if (err < 0)
		return err;

	spec = codec->spec;
2444
	spec->gen.beep_nid = 0x01;
2445

2446 2447
	snd_hda_pick_fixup(codec, alc268_fixup_models, alc268_fixup_tbl, alc268_fixups);
	snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE);
2448

2449 2450
	/* automatic parse from the BIOS config */
	err = alc268_parse_auto_config(codec);
2451 2452
	if (err < 0)
		goto error;
2453

2454 2455 2456 2457
	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);
2458 2459 2460 2461 2462 2463 2464
		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));
2465 2466
	}

2467
	codec->patch_ops = alc_patch_ops;
2468
	spec->shutup = alc_eapd_shutup;
2469

2470
	snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE);
2471

2472
	return 0;
2473 2474 2475 2476

 error:
	alc_free(codec);
	return err;
2477 2478
}

2479
/*
2480
 * ALC269
2481
 */
2482 2483 2484 2485 2486 2487 2488 2489 2490 2491 2492 2493 2494 2495 2496 2497 2498 2499 2500 2501 2502 2503 2504 2505 2506 2507 2508 2509 2510

static int playback_pcm_open(struct hda_pcm_stream *hinfo,
			     struct hda_codec *codec,
			     struct snd_pcm_substream *substream)
{
	struct hda_gen_spec *spec = codec->spec;
	return snd_hda_multi_out_analog_open(codec, &spec->multiout, substream,
					     hinfo);
}

static int playback_pcm_prepare(struct hda_pcm_stream *hinfo,
				struct hda_codec *codec,
				unsigned int stream_tag,
				unsigned int format,
				struct snd_pcm_substream *substream)
{
	struct hda_gen_spec *spec = codec->spec;
	return snd_hda_multi_out_analog_prepare(codec, &spec->multiout,
						stream_tag, format, substream);
}

static int playback_pcm_cleanup(struct hda_pcm_stream *hinfo,
				struct hda_codec *codec,
				struct snd_pcm_substream *substream)
{
	struct hda_gen_spec *spec = codec->spec;
	return snd_hda_multi_out_analog_cleanup(codec, &spec->multiout);
}

2511 2512 2513 2514 2515 2516 2517
static const struct hda_pcm_stream alc269_44k_pcm_analog_playback = {
	.substreams = 1,
	.channels_min = 2,
	.channels_max = 8,
	.rates = SNDRV_PCM_RATE_44100, /* fixed rate */
	/* NID is set in alc_build_pcms */
	.ops = {
2518 2519 2520
		.open = playback_pcm_open,
		.prepare = playback_pcm_prepare,
		.cleanup = playback_pcm_cleanup
2521 2522 2523
	},
};

2524 2525 2526 2527 2528 2529
static const struct hda_pcm_stream alc269_44k_pcm_analog_capture = {
	.substreams = 1,
	.channels_min = 2,
	.channels_max = 2,
	.rates = SNDRV_PCM_RATE_44100, /* fixed rate */
	/* NID is set in alc_build_pcms */
2530
};
2531

2532 2533 2534 2535 2536
/* different alc269-variants */
enum {
	ALC269_TYPE_ALC269VA,
	ALC269_TYPE_ALC269VB,
	ALC269_TYPE_ALC269VC,
2537
	ALC269_TYPE_ALC269VD,
2538 2539
	ALC269_TYPE_ALC280,
	ALC269_TYPE_ALC282,
2540
	ALC269_TYPE_ALC283,
2541
	ALC269_TYPE_ALC284,
2542
	ALC269_TYPE_ALC286,
2543 2544 2545
};

/*
2546
 * BIOS auto configuration
2547
 */
2548 2549 2550
static int alc269_parse_auto_config(struct hda_codec *codec)
{
	static const hda_nid_t alc269_ignore[] = { 0x1d, 0 };
2551 2552 2553
	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;
2554 2555 2556 2557 2558
	const hda_nid_t *ssids;

	switch (spec->codec_variant) {
	case ALC269_TYPE_ALC269VA:
	case ALC269_TYPE_ALC269VC:
2559 2560
	case ALC269_TYPE_ALC280:
	case ALC269_TYPE_ALC284:
2561 2562 2563 2564
		ssids = alc269va_ssids;
		break;
	case ALC269_TYPE_ALC269VB:
	case ALC269_TYPE_ALC269VD:
2565
	case ALC269_TYPE_ALC282:
2566
	case ALC269_TYPE_ALC283:
2567
	case ALC269_TYPE_ALC286:
2568 2569 2570 2571 2572 2573
		ssids = alc269_ssids;
		break;
	default:
		ssids = alc269_ssids;
		break;
	}
2574

2575
	return alc_parse_auto_config(codec, alc269_ignore, ssids);
2576
}
2577

2578
static void alc269vb_toggle_power_output(struct hda_codec *codec, int power_up)
2579 2580 2581 2582 2583 2584 2585 2586
{
	int val = alc_read_coef_idx(codec, 0x04);
	if (power_up)
		val |= 1 << 11;
	else
		val &= ~(1 << 11);
	alc_write_coef_idx(codec, 0x04, val);
}
2587

2588 2589
static void alc269_shutup(struct hda_codec *codec)
{
2590 2591
	struct alc_spec *spec = codec->spec;

2592 2593 2594 2595
	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) {
2596 2597
		msleep(150);
	}
2598
	snd_hda_shutup_pins(codec);
2599
}
2600

2601 2602 2603 2604 2605 2606 2607 2608 2609 2610 2611 2612 2613 2614 2615 2616 2617 2618 2619 2620 2621 2622 2623 2624 2625 2626 2627 2628 2629 2630 2631 2632 2633 2634 2635 2636 2637 2638 2639 2640 2641 2642 2643 2644 2645 2646 2647 2648 2649 2650 2651 2652 2653 2654 2655 2656 2657 2658 2659 2660 2661 2662 2663 2664 2665 2666 2667 2668
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;
	int val;

	if (!hp_pin)
		return;
	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. */
	val = alc_read_coef_idx(codec, 0x46);
	alc_write_coef_idx(codec, 0x46, val & ~(3 << 12));
	/* 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;
	int val;

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

	hp_pin_sense = snd_hda_jack_detect(codec, hp_pin);

	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, 0x0);

	val = alc_read_coef_idx(codec, 0x46);
	alc_write_coef_idx(codec, 0x46, val | (3 << 12));

	if (hp_pin_sense)
		msleep(85);
	snd_hda_shutup_pins(codec);
	alc_write_coef_idx(codec, 0x43, 0x9614);
}

2669 2670 2671 2672 2673 2674 2675 2676 2677 2678 2679 2680 2681 2682 2683 2684 2685 2686 2687 2688 2689 2690 2691 2692 2693 2694 2695 2696 2697 2698 2699 2700 2701 2702 2703 2704 2705 2706 2707 2708 2709 2710 2711 2712 2713 2714 2715 2716 2717 2718 2719 2720 2721 2722 2723 2724 2725 2726 2727 2728 2729 2730 2731 2732 2733 2734 2735 2736 2737 2738 2739 2740 2741 2742 2743 2744 2745 2746
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);
2747 2748 2749 2750

#ifdef HALT_REALTEK_ALC5505
	alc5505_dsp_halt(codec);
#endif
2751 2752
}

2753 2754 2755 2756 2757 2758 2759 2760
#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

2761
#ifdef CONFIG_PM
2762 2763 2764 2765 2766
static int alc269_suspend(struct hda_codec *codec)
{
	struct alc_spec *spec = codec->spec;

	if (spec->has_alc5505_dsp)
2767
		alc5505_dsp_suspend(codec);
2768 2769 2770
	return alc_suspend(codec);
}

2771 2772
static int alc269_resume(struct hda_codec *codec)
{
2773 2774
	struct alc_spec *spec = codec->spec;

2775 2776 2777
	if (spec->codec_variant == ALC269_TYPE_ALC269VB)
		alc269vb_toggle_power_output(codec, 0);
	if (spec->codec_variant == ALC269_TYPE_ALC269VB &&
2778
			(alc_get_coef0(codec) & 0x00ff) == 0x018) {
2779 2780
		msleep(150);
	}
2781

2782
	codec->patch_ops.init(codec);
2783

2784 2785 2786
	if (spec->codec_variant == ALC269_TYPE_ALC269VB)
		alc269vb_toggle_power_output(codec, 1);
	if (spec->codec_variant == ALC269_TYPE_ALC269VB &&
2787
			(alc_get_coef0(codec) & 0x00ff) == 0x017) {
2788 2789
		msleep(200);
	}
2790

2791 2792
	snd_hda_codec_resume_amp(codec);
	snd_hda_codec_resume_cache(codec);
2793
	alc_inv_dmic_sync(codec, true);
2794
	hda_call_check_power_status(codec, 0x01);
2795
	if (spec->has_alc5505_dsp)
2796
		alc5505_dsp_resume(codec);
2797

2798 2799
	return 0;
}
2800
#endif /* CONFIG_PM */
2801

2802
static void alc269_fixup_pincfg_no_hp_to_lineout(struct hda_codec *codec,
2803
						 const struct hda_fixup *fix, int action)
2804 2805 2806
{
	struct alc_spec *spec = codec->spec;

2807
	if (action == HDA_FIXUP_ACT_PRE_PROBE)
2808 2809 2810
		spec->parse_flags = HDA_PINCFG_NO_HP_FIXUP;
}

2811
static void alc269_fixup_hweq(struct hda_codec *codec,
2812
			       const struct hda_fixup *fix, int action)
2813 2814
{
	int coef;
2815

2816
	if (action != HDA_FIXUP_ACT_INIT)
2817 2818 2819 2820
		return;
	coef = alc_read_coef_idx(codec, 0x1e);
	alc_write_coef_idx(codec, 0x1e, coef | 0x80);
}
2821

2822 2823 2824 2825 2826 2827 2828 2829 2830
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;
}

2831
static void alc271_fixup_dmic(struct hda_codec *codec,
2832
			      const struct hda_fixup *fix, int action)
2833 2834 2835 2836 2837 2838 2839
{
	static const struct hda_verb verbs[] = {
		{0x20, AC_VERB_SET_COEF_INDEX, 0x0d},
		{0x20, AC_VERB_SET_PROC_COEF, 0x4000},
		{}
	};
	unsigned int cfg;
2840

2841 2842
	if (strcmp(codec->chip_name, "ALC271X") &&
	    strcmp(codec->chip_name, "ALC269VB"))
2843 2844 2845 2846 2847
		return;
	cfg = snd_hda_codec_get_pincfg(codec, 0x12);
	if (get_defcfg_connect(cfg) == AC_JACK_PORT_FIXED)
		snd_hda_sequence_write(codec, verbs);
}
2848

2849
static void alc269_fixup_pcm_44k(struct hda_codec *codec,
2850
				 const struct hda_fixup *fix, int action)
2851 2852 2853
{
	struct alc_spec *spec = codec->spec;

2854
	if (action != HDA_FIXUP_ACT_PROBE)
2855 2856 2857 2858 2859
		return;

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

2864
static void alc269_fixup_stereo_dmic(struct hda_codec *codec,
2865
				     const struct hda_fixup *fix, int action)
2866 2867 2868
{
	int coef;

2869
	if (action != HDA_FIXUP_ACT_INIT)
2870 2871 2872 2873 2874 2875 2876 2877 2878 2879
		return;
	/* 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.
	 */
	coef = alc_read_coef_idx(codec, 0x07);
	alc_write_coef_idx(codec, 0x07, coef | 0x80);
}

2880 2881
static void alc269_quanta_automute(struct hda_codec *codec)
{
2882
	snd_hda_gen_update_outputs(codec);
2883 2884 2885 2886 2887 2888 2889 2890 2891 2892 2893 2894 2895

	snd_hda_codec_write(codec, 0x20, 0,
			AC_VERB_SET_COEF_INDEX, 0x0c);
	snd_hda_codec_write(codec, 0x20, 0,
			AC_VERB_SET_PROC_COEF, 0x680);

	snd_hda_codec_write(codec, 0x20, 0,
			AC_VERB_SET_COEF_INDEX, 0x0c);
	snd_hda_codec_write(codec, 0x20, 0,
			AC_VERB_SET_PROC_COEF, 0x480);
}

static void alc269_fixup_quanta_mute(struct hda_codec *codec,
2896
				     const struct hda_fixup *fix, int action)
2897 2898
{
	struct alc_spec *spec = codec->spec;
2899
	if (action != HDA_FIXUP_ACT_PROBE)
2900
		return;
2901
	spec->gen.automute_hook = alc269_quanta_automute;
2902 2903
}

2904 2905 2906 2907 2908 2909 2910 2911 2912 2913 2914 2915 2916 2917 2918 2919 2920 2921 2922 2923 2924 2925 2926 2927 2928 2929 2930 2931
static void alc269_x101_hp_automute_hook(struct hda_codec *codec,
					 struct hda_jack_tbl *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, 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;
	}
}


2932 2933
/* 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)
2934 2935
{
	struct hda_codec *codec = private_data;
2936 2937 2938 2939 2940 2941 2942 2943 2944
	struct alc_spec *spec = codec->spec;
	unsigned int pinval;

	if (spec->mute_led_polarity)
		enabled = !enabled;
	pinval = AC_PINCTL_IN_EN |
		(enabled ? AC_PINCTL_VREF_HIZ : AC_PINCTL_VREF_80);
	if (spec->mute_led_nid)
		snd_hda_set_pin_ctl_cache(codec, spec->mute_led_nid, pinval);
2945 2946
}

2947 2948
static void alc269_fixup_hp_mute_led(struct hda_codec *codec,
				     const struct hda_fixup *fix, int action)
2949 2950
{
	struct alc_spec *spec = codec->spec;
2951 2952 2953 2954 2955 2956 2957 2958 2959 2960 2961 2962 2963 2964
	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;
2965
		spec->gen.vmaster_mute_enum = 1;
2966 2967
		snd_printd("Detected mute LED for %x:%d\n", spec->mute_led_nid,
			   spec->mute_led_polarity);
2968 2969 2970 2971
		break;
	}
}

2972 2973 2974 2975 2976 2977 2978 2979 2980 2981 2982 2983
static void alc269_fixup_hp_mute_led_mic1(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->mute_led_polarity = 0;
		spec->mute_led_nid = 0x18;
		spec->gen.vmaster_mute.hook = alc269_fixup_mic_mute_hook;
		spec->gen.vmaster_mute_enum = 1;
	}
}

2984 2985
static void alc269_fixup_hp_mute_led_mic2(struct hda_codec *codec,
				const struct hda_fixup *fix, int action)
2986 2987
{
	struct alc_spec *spec = codec->spec;
2988
	if (action == HDA_FIXUP_ACT_PRE_PROBE) {
2989 2990 2991
		spec->mute_led_polarity = 0;
		spec->mute_led_nid = 0x19;
		spec->gen.vmaster_mute.hook = alc269_fixup_mic_mute_hook;
2992
		spec->gen.vmaster_mute_enum = 1;
2993 2994 2995
	}
}

2996 2997 2998 2999 3000 3001 3002 3003 3004 3005 3006 3007 3008 3009 3010 3011 3012 3013 3014 3015 3016 3017 3018 3019 3020 3021 3022 3023 3024 3025 3026 3027 3028 3029 3030 3031 3032 3033 3034 3035 3036 3037 3038 3039 3040 3041 3042 3043 3044 3045 3046 3047 3048 3049
/* turn on/off mute LED per vmaster hook */
static void alc269_fixup_hp_gpio_mute_hook(void *private_data, int enabled)
{
	struct hda_codec *codec = private_data;
	struct alc_spec *spec = codec->spec;
	unsigned int oldval = spec->gpio_led;

	if (enabled)
		spec->gpio_led &= ~0x08;
	else
		spec->gpio_led |= 0x08;
	if (spec->gpio_led != oldval)
		snd_hda_codec_write(codec, 0x01, 0, AC_VERB_SET_GPIO_DATA,
				    spec->gpio_led);
}

/* turn on/off mic-mute LED per capture hook */
static void alc269_fixup_hp_gpio_mic_mute_hook(struct hda_codec *codec,
			       struct snd_ctl_elem_value *ucontrol)
{
	struct alc_spec *spec = codec->spec;
	unsigned int oldval = spec->gpio_led;

	if (!ucontrol)
		return;

	if (ucontrol->value.integer.value[0] ||
	    ucontrol->value.integer.value[1])
		spec->gpio_led &= ~0x10;
	else
		spec->gpio_led |= 0x10;
	if (spec->gpio_led != oldval)
		snd_hda_codec_write(codec, 0x01, 0, AC_VERB_SET_GPIO_DATA,
				    spec->gpio_led);
}

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) {
		spec->gen.vmaster_mute.hook = alc269_fixup_hp_gpio_mute_hook;
		spec->gen.cap_sync_hook = alc269_fixup_hp_gpio_mic_mute_hook;
		spec->gpio_led = 0;
		snd_hda_add_verbs(codec, gpio_init);
	}
}

3050 3051 3052 3053 3054 3055 3056 3057 3058 3059 3060 3061 3062 3063 3064 3065 3066 3067 3068 3069 3070 3071 3072 3073 3074 3075 3076 3077 3078 3079 3080 3081 3082 3083 3084 3085 3086 3087 3088 3089 3090 3091 3092 3093 3094 3095 3096 3097 3098 3099 3100 3101 3102 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 3135 3136 3137 3138 3139 3140 3141 3142 3143 3144 3145 3146 3147 3148 3149 3150 3151 3152 3153 3154 3155 3156 3157 3158 3159 3160 3161 3162 3163 3164 3165 3166 3167 3168 3169 3170 3171 3172 3173 3174 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 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 3323 3324 3325 3326 3327 3328 3329 3330 3331 3332 3333 3334 3335 3336 3337 3338 3339 3340 3341 3342 3343 3344 3345
static void alc_headset_mode_unplugged(struct hda_codec *codec)
{
	int val;

	switch (codec->vendor_id) {
	case 0x10ec0283:
		alc_write_coef_idx(codec, 0x1b, 0x0c0b);
		alc_write_coef_idx(codec, 0x45, 0xc429);
		val = alc_read_coef_idx(codec, 0x35);
		alc_write_coef_idx(codec, 0x35, val & 0xbfff);
		alc_write_coef_idx(codec, 0x06, 0x2104);
		alc_write_coef_idx(codec, 0x1a, 0x0001);
		alc_write_coef_idx(codec, 0x26, 0x0004);
		alc_write_coef_idx(codec, 0x32, 0x42a3);
		break;
	case 0x10ec0292:
		alc_write_coef_idx(codec, 0x76, 0x000e);
		alc_write_coef_idx(codec, 0x6c, 0x2400);
		alc_write_coef_idx(codec, 0x18, 0x7308);
		alc_write_coef_idx(codec, 0x6b, 0xc429);
		break;
	case 0x10ec0668:
		alc_write_coef_idx(codec, 0x15, 0x0d40);
		alc_write_coef_idx(codec, 0xb7, 0x802b);
		break;
	}
	snd_printdd("Headset jack set to unplugged mode.\n");
}


static void alc_headset_mode_mic_in(struct hda_codec *codec, hda_nid_t hp_pin,
				    hda_nid_t mic_pin)
{
	int val;

	switch (codec->vendor_id) {
	case 0x10ec0283:
		alc_write_coef_idx(codec, 0x45, 0xc429);
		snd_hda_set_pin_ctl_cache(codec, hp_pin, 0);
		val = alc_read_coef_idx(codec, 0x35);
		alc_write_coef_idx(codec, 0x35, val | 1<<14);
		alc_write_coef_idx(codec, 0x06, 0x2100);
		alc_write_coef_idx(codec, 0x1a, 0x0021);
		alc_write_coef_idx(codec, 0x26, 0x008c);
		snd_hda_set_pin_ctl_cache(codec, mic_pin, PIN_VREF50);
		break;
	case 0x10ec0292:
		snd_hda_set_pin_ctl_cache(codec, hp_pin, 0);
		alc_write_coef_idx(codec, 0x19, 0xa208);
		alc_write_coef_idx(codec, 0x2e, 0xacf0);
		break;
	case 0x10ec0668:
		alc_write_coef_idx(codec, 0x11, 0x0001);
		snd_hda_set_pin_ctl_cache(codec, hp_pin, 0);
		alc_write_coef_idx(codec, 0xb7, 0x802b);
		alc_write_coef_idx(codec, 0xb5, 0x1040);
		val = alc_read_coef_idx(codec, 0xc3);
		alc_write_coef_idx(codec, 0xc3, val | 1<<12);
		snd_hda_set_pin_ctl_cache(codec, mic_pin, PIN_VREF50);
		break;
	}
	snd_printdd("Headset jack set to mic-in mode.\n");
}

static void alc_headset_mode_default(struct hda_codec *codec)
{
	switch (codec->vendor_id) {
	case 0x10ec0283:
		alc_write_coef_idx(codec, 0x06, 0x2100);
		alc_write_coef_idx(codec, 0x32, 0x4ea3);
		break;
	case 0x10ec0292:
		alc_write_coef_idx(codec, 0x76, 0x000e);
		alc_write_coef_idx(codec, 0x6c, 0x2400);
		alc_write_coef_idx(codec, 0x6b, 0xc429);
		alc_write_coef_idx(codec, 0x18, 0x7308);
		break;
	case 0x10ec0668:
		alc_write_coef_idx(codec, 0x11, 0x0041);
		alc_write_coef_idx(codec, 0x15, 0x0d40);
		alc_write_coef_idx(codec, 0xb7, 0x802b);
		break;
	}
	snd_printdd("Headset jack set to headphone (default) mode.\n");
}

/* Iphone type */
static void alc_headset_mode_ctia(struct hda_codec *codec)
{
	switch (codec->vendor_id) {
	case 0x10ec0283:
		alc_write_coef_idx(codec, 0x45, 0xd429);
		alc_write_coef_idx(codec, 0x1b, 0x0c2b);
		alc_write_coef_idx(codec, 0x32, 0x4ea3);
		break;
	case 0x10ec0292:
		alc_write_coef_idx(codec, 0x6b, 0xd429);
		alc_write_coef_idx(codec, 0x76, 0x0008);
		alc_write_coef_idx(codec, 0x18, 0x7388);
		break;
	case 0x10ec0668:
		alc_write_coef_idx(codec, 0x15, 0x0d60);
		alc_write_coef_idx(codec, 0xc3, 0x0000);
		break;
	}
	snd_printdd("Headset jack set to iPhone-style headset mode.\n");
}

/* Nokia type */
static void alc_headset_mode_omtp(struct hda_codec *codec)
{
	switch (codec->vendor_id) {
	case 0x10ec0283:
		alc_write_coef_idx(codec, 0x45, 0xe429);
		alc_write_coef_idx(codec, 0x1b, 0x0c2b);
		alc_write_coef_idx(codec, 0x32, 0x4ea3);
		break;
	case 0x10ec0292:
		alc_write_coef_idx(codec, 0x6b, 0xe429);
		alc_write_coef_idx(codec, 0x76, 0x0008);
		alc_write_coef_idx(codec, 0x18, 0x7388);
		break;
	case 0x10ec0668:
		alc_write_coef_idx(codec, 0x15, 0x0d50);
		alc_write_coef_idx(codec, 0xc3, 0x0000);
		break;
	}
	snd_printdd("Headset jack set to Nokia-style headset mode.\n");
}

static void alc_determine_headset_type(struct hda_codec *codec)
{
	int val;
	bool is_ctia = false;
	struct alc_spec *spec = codec->spec;

	switch (codec->vendor_id) {
	case 0x10ec0283:
		alc_write_coef_idx(codec, 0x45, 0xd029);
		msleep(300);
		val = alc_read_coef_idx(codec, 0x46);
		is_ctia = (val & 0x0070) == 0x0070;
		break;
	case 0x10ec0292:
		alc_write_coef_idx(codec, 0x6b, 0xd429);
		msleep(300);
		val = alc_read_coef_idx(codec, 0x6c);
		is_ctia = (val & 0x001c) == 0x001c;
		break;
	case 0x10ec0668:
		alc_write_coef_idx(codec, 0x11, 0x0001);
		alc_write_coef_idx(codec, 0xb7, 0x802b);
		alc_write_coef_idx(codec, 0x15, 0x0d60);
		alc_write_coef_idx(codec, 0xc3, 0x0c00);
		msleep(300);
		val = alc_read_coef_idx(codec, 0xbe);
		is_ctia = (val & 0x1c02) == 0x1c02;
		break;
	}

	snd_printdd("Headset jack detected iPhone-style headset: %s\n",
		    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;

	if (new_headset_mode == spec->current_headset_mode)
		return;

	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);
		if (spec->headphone_mic_pin)
			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,
			     struct snd_ctl_elem_value *ucontrol)
{
	alc_update_headset_mode(codec);
}

static void alc_update_headset_jack_cb(struct hda_codec *codec, struct hda_jack_tbl *jack)
{
	struct alc_spec *spec = codec->spec;
	spec->current_headset_type = ALC_HEADSET_MODE_UNKNOWN;
	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);
}

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) {
		int val;
		alc_write_coef_idx(codec, 0xc4, 0x8000);
		val = alc_read_coef_idx(codec, 0xc2);
		alc_write_coef_idx(codec, 0xc2, val & 0xfe);
		snd_hda_set_pin_ctl_cache(codec, 0x18, 0);
	}
	alc_fixup_headset_mode(codec, fix, action);
}

3346 3347 3348 3349 3350 3351 3352 3353 3354 3355 3356 3357 3358 3359 3360 3361 3362 3363 3364 3365 3366 3367
/* 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;
}

3368
static void alc271_hp_gate_mic_jack(struct hda_codec *codec,
3369
				    const struct hda_fixup *fix,
3370 3371 3372 3373
				    int action)
{
	struct alc_spec *spec = codec->spec;

3374
	if (action == HDA_FIXUP_ACT_PROBE) {
3375 3376 3377 3378
		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))
3379
			return;
3380
		snd_hda_jack_set_gating_jack(codec, mic_pin, hp_pin);
3381
	}
3382
}
3383

3384 3385 3386 3387 3388 3389 3390 3391 3392 3393 3394 3395 3396 3397 3398 3399 3400 3401 3402 3403 3404 3405 3406 3407 3408 3409 3410 3411 3412 3413 3414 3415
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));
	}
}

3416 3417 3418 3419 3420 3421 3422 3423 3424 3425 3426 3427 3428 3429 3430 3431 3432 3433 3434 3435 3436 3437 3438 3439 3440 3441 3442 3443 3444 3445 3446 3447 3448 3449 3450
static void alc283_hp_automute_hook(struct hda_codec *codec,
				    struct hda_jack_tbl *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(600);
	snd_hda_codec_write(codec, 0x19, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
			    vref);
}

static void alc283_chromebook_caps(struct hda_codec *codec)
{
	snd_hda_override_wcaps(codec, 0x03, 0);
}

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

	switch (action) {
	case HDA_FIXUP_ACT_PRE_PROBE:
		alc283_chromebook_caps(codec);
		spec->gen.hp_automute_hook = alc283_hp_automute_hook;
		/* MIC2-VREF control */
		/* Set to manual mode */
		val = alc_read_coef_idx(codec, 0x06);
		alc_write_coef_idx(codec, 0x06, val & ~0x000c);
3451 3452 3453
		/* Enable Line1 input control by verb */
		val = alc_read_coef_idx(codec, 0x1a);
		alc_write_coef_idx(codec, 0x1a, val | (1 << 4));
3454 3455 3456 3457
		break;
	}
}

3458 3459 3460 3461 3462 3463 3464 3465 3466 3467 3468 3469 3470 3471 3472 3473 3474 3475 3476 3477 3478 3479 3480 3481 3482 3483 3484 3485 3486 3487 3488 3489 3490 3491 3492 3493 3494 3495 3496 3497 3498 3499 3500 3501 3502 3503 3504 3505 3506 3507
/* 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 */
		{}
	};
	struct snd_kcontrol *kctl;

	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,
						    HDA_GEN_HP_EVENT,
						    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
		 */
		kctl = snd_hda_find_mixer_ctl(codec, "Speaker Playback Switch");
		if (kctl)
			strcpy(kctl->id.name, "Dock Speaker Playback Switch");
		kctl = snd_hda_find_mixer_ctl(codec, "Bass Speaker Playback Switch");
		if (kctl)
			strcpy(kctl->id.name, "Speaker Playback Switch");
		break;
	}
}

3508 3509 3510 3511 3512 3513 3514 3515 3516
static void alc290_fixup_mono_speakers(struct hda_codec *codec,
				       const struct hda_fixup *fix, int action)
{
	if (action == HDA_FIXUP_ACT_PRE_PROBE)
		/* Remove DAC node 0x03, as it seems to be
		   giving mono output */
		snd_hda_override_wcaps(codec, 0x03, 0);
}

3517 3518 3519 3520 3521 3522 3523 3524 3525
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,
	ALC271_FIXUP_DMIC,
3526
	ALC269_FIXUP_PCM_44K,
3527
	ALC269_FIXUP_STEREO_DMIC,
3528
	ALC269_FIXUP_HEADSET_MIC,
3529 3530
	ALC269_FIXUP_QUANTA_MUTE,
	ALC269_FIXUP_LIFEBOOK,
3531 3532 3533 3534
	ALC269_FIXUP_AMIC,
	ALC269_FIXUP_DMIC,
	ALC269VB_FIXUP_AMIC,
	ALC269VB_FIXUP_DMIC,
3535
	ALC269_FIXUP_HP_MUTE_LED,
3536
	ALC269_FIXUP_HP_MUTE_LED_MIC1,
3537
	ALC269_FIXUP_HP_MUTE_LED_MIC2,
3538
	ALC269_FIXUP_HP_GPIO_LED,
3539
	ALC269_FIXUP_INV_DMIC,
3540
	ALC269_FIXUP_LENOVO_DOCK,
3541
	ALC286_FIXUP_SONY_MIC_NO_PRESENCE,
3542
	ALC269_FIXUP_PINCFG_NO_HP_TO_LINEOUT,
3543 3544
	ALC269_FIXUP_DELL1_MIC_NO_PRESENCE,
	ALC269_FIXUP_DELL2_MIC_NO_PRESENCE,
3545
	ALC269_FIXUP_DELL3_MIC_NO_PRESENCE,
3546 3547
	ALC269_FIXUP_HEADSET_MODE,
	ALC269_FIXUP_HEADSET_MODE_NO_HP_MIC,
3548 3549 3550
	ALC269_FIXUP_ASUS_X101_FUNC,
	ALC269_FIXUP_ASUS_X101_VERB,
	ALC269_FIXUP_ASUS_X101,
3551 3552
	ALC271_FIXUP_AMIC_MIC2,
	ALC271_FIXUP_HP_GATE_MIC_JACK,
3553
	ALC269_FIXUP_ACER_AC700,
3554
	ALC269_FIXUP_LIMIT_INT_MIC_BOOST,
3555
	ALC269VB_FIXUP_ORDISSIMO_EVE2,
3556
	ALC283_FIXUP_CHROME_BOOK,
3557
	ALC282_FIXUP_ASUS_TX300,
3558
	ALC283_FIXUP_INT_MIC,
3559
	ALC290_FIXUP_MONO_SPEAKERS,
3560 3561
};

3562
static const struct hda_fixup alc269_fixups[] = {
3563
	[ALC269_FIXUP_SONY_VAIO] = {
3564 3565 3566
		.type = HDA_FIXUP_PINCTLS,
		.v.pins = (const struct hda_pintbl[]) {
			{0x19, PIN_VREFGRD},
3567 3568
			{}
		}
3569
	},
3570
	[ALC275_FIXUP_SONY_VAIO_GPIO2] = {
3571
		.type = HDA_FIXUP_VERBS,
3572 3573 3574 3575 3576 3577 3578 3579 3580 3581
		.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] = {
3582
		.type = HDA_FIXUP_VERBS,
3583 3584 3585 3586 3587 3588 3589 3590
		.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] = {
3591
		.type = HDA_FIXUP_FUNC,
3592
		.v.func = alc_fixup_sku_ignore,
3593 3594
	},
	[ALC269_FIXUP_ASUS_G73JW] = {
3595 3596
		.type = HDA_FIXUP_PINS,
		.v.pins = (const struct hda_pintbl[]) {
3597 3598 3599 3600 3601
			{ 0x17, 0x99130111 }, /* subwoofer */
			{ }
		}
	},
	[ALC269_FIXUP_LENOVO_EAPD] = {
3602
		.type = HDA_FIXUP_VERBS,
3603 3604 3605 3606 3607 3608
		.v.verbs = (const struct hda_verb[]) {
			{0x14, AC_VERB_SET_EAPD_BTLENABLE, 0},
			{}
		}
	},
	[ALC275_FIXUP_SONY_HWEQ] = {
3609
		.type = HDA_FIXUP_FUNC,
3610 3611 3612 3613 3614
		.v.func = alc269_fixup_hweq,
		.chained = true,
		.chain_id = ALC275_FIXUP_SONY_VAIO_GPIO2
	},
	[ALC271_FIXUP_DMIC] = {
3615
		.type = HDA_FIXUP_FUNC,
3616
		.v.func = alc271_fixup_dmic,
3617
	},
3618
	[ALC269_FIXUP_PCM_44K] = {
3619
		.type = HDA_FIXUP_FUNC,
3620
		.v.func = alc269_fixup_pcm_44k,
3621 3622
		.chained = true,
		.chain_id = ALC269_FIXUP_QUANTA_MUTE
3623
	},
3624
	[ALC269_FIXUP_STEREO_DMIC] = {
3625
		.type = HDA_FIXUP_FUNC,
3626 3627
		.v.func = alc269_fixup_stereo_dmic,
	},
3628 3629 3630 3631
	[ALC269_FIXUP_HEADSET_MIC] = {
		.type = HDA_FIXUP_FUNC,
		.v.func = alc269_fixup_headset_mic,
	},
3632
	[ALC269_FIXUP_QUANTA_MUTE] = {
3633
		.type = HDA_FIXUP_FUNC,
3634 3635 3636
		.v.func = alc269_fixup_quanta_mute,
	},
	[ALC269_FIXUP_LIFEBOOK] = {
3637 3638
		.type = HDA_FIXUP_PINS,
		.v.pins = (const struct hda_pintbl[]) {
3639 3640 3641 3642 3643 3644 3645
			{ 0x1a, 0x2101103f }, /* dock line-out */
			{ 0x1b, 0x23a11040 }, /* dock mic-in */
			{ }
		},
		.chained = true,
		.chain_id = ALC269_FIXUP_QUANTA_MUTE
	},
3646
	[ALC269_FIXUP_AMIC] = {
3647 3648
		.type = HDA_FIXUP_PINS,
		.v.pins = (const struct hda_pintbl[]) {
3649 3650 3651 3652 3653 3654 3655 3656
			{ 0x14, 0x99130110 }, /* speaker */
			{ 0x15, 0x0121401f }, /* HP out */
			{ 0x18, 0x01a19c20 }, /* mic */
			{ 0x19, 0x99a3092f }, /* int-mic */
			{ }
		},
	},
	[ALC269_FIXUP_DMIC] = {
3657 3658
		.type = HDA_FIXUP_PINS,
		.v.pins = (const struct hda_pintbl[]) {
3659 3660 3661 3662 3663 3664 3665 3666
			{ 0x12, 0x99a3092f }, /* int-mic */
			{ 0x14, 0x99130110 }, /* speaker */
			{ 0x15, 0x0121401f }, /* HP out */
			{ 0x18, 0x01a19c20 }, /* mic */
			{ }
		},
	},
	[ALC269VB_FIXUP_AMIC] = {
3667 3668
		.type = HDA_FIXUP_PINS,
		.v.pins = (const struct hda_pintbl[]) {
3669 3670 3671 3672 3673 3674 3675
			{ 0x14, 0x99130110 }, /* speaker */
			{ 0x18, 0x01a19c20 }, /* mic */
			{ 0x19, 0x99a3092f }, /* int-mic */
			{ 0x21, 0x0121401f }, /* HP out */
			{ }
		},
	},
3676
	[ALC269VB_FIXUP_DMIC] = {
3677 3678
		.type = HDA_FIXUP_PINS,
		.v.pins = (const struct hda_pintbl[]) {
3679 3680 3681 3682 3683 3684 3685
			{ 0x12, 0x99a3092f }, /* int-mic */
			{ 0x14, 0x99130110 }, /* speaker */
			{ 0x18, 0x01a19c20 }, /* mic */
			{ 0x21, 0x0121401f }, /* HP out */
			{ }
		},
	},
3686
	[ALC269_FIXUP_HP_MUTE_LED] = {
3687
		.type = HDA_FIXUP_FUNC,
3688
		.v.func = alc269_fixup_hp_mute_led,
3689
	},
3690 3691 3692 3693
	[ALC269_FIXUP_HP_MUTE_LED_MIC1] = {
		.type = HDA_FIXUP_FUNC,
		.v.func = alc269_fixup_hp_mute_led_mic1,
	},
3694
	[ALC269_FIXUP_HP_MUTE_LED_MIC2] = {
3695
		.type = HDA_FIXUP_FUNC,
3696
		.v.func = alc269_fixup_hp_mute_led_mic2,
3697
	},
3698 3699 3700 3701
	[ALC269_FIXUP_HP_GPIO_LED] = {
		.type = HDA_FIXUP_FUNC,
		.v.func = alc269_fixup_hp_gpio_led,
	},
3702
	[ALC269_FIXUP_INV_DMIC] = {
3703
		.type = HDA_FIXUP_FUNC,
3704
		.v.func = alc_fixup_inv_dmic_0x12,
3705
	},
3706
	[ALC269_FIXUP_LENOVO_DOCK] = {
3707 3708
		.type = HDA_FIXUP_PINS,
		.v.pins = (const struct hda_pintbl[]) {
3709 3710 3711 3712 3713 3714 3715 3716
			{ 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] = {
3717
		.type = HDA_FIXUP_FUNC,
3718 3719
		.v.func = alc269_fixup_pincfg_no_hp_to_lineout,
	},
3720 3721 3722 3723 3724 3725 3726 3727 3728 3729 3730 3731 3732 3733 3734 3735 3736 3737 3738 3739 3740
	[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
	},
3741 3742 3743 3744 3745 3746 3747 3748 3749
	[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
	},
3750 3751 3752 3753 3754 3755 3756 3757
	[ALC269_FIXUP_HEADSET_MODE] = {
		.type = HDA_FIXUP_FUNC,
		.v.func = alc_fixup_headset_mode,
	},
	[ALC269_FIXUP_HEADSET_MODE_NO_HP_MIC] = {
		.type = HDA_FIXUP_FUNC,
		.v.func = alc_fixup_headset_mode_no_hp_mic,
	},
3758 3759 3760 3761 3762 3763
	[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 */
			{ }
		},
3764 3765
		.chained = true,
		.chain_id = ALC269_FIXUP_HEADSET_MIC
3766
	},
3767 3768 3769 3770 3771 3772 3773 3774 3775 3776 3777 3778 3779 3780 3781 3782 3783 3784 3785 3786 3787 3788 3789 3790
	[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
	},
3791
	[ALC271_FIXUP_AMIC_MIC2] = {
3792 3793
		.type = HDA_FIXUP_PINS,
		.v.pins = (const struct hda_pintbl[]) {
3794 3795 3796 3797 3798 3799 3800 3801
			{ 0x14, 0x99130110 }, /* speaker */
			{ 0x19, 0x01a19c20 }, /* mic */
			{ 0x1b, 0x99a7012f }, /* int-mic */
			{ 0x21, 0x0121401f }, /* HP out */
			{ }
		},
	},
	[ALC271_FIXUP_HP_GATE_MIC_JACK] = {
3802
		.type = HDA_FIXUP_FUNC,
3803 3804 3805 3806
		.v.func = alc271_hp_gate_mic_jack,
		.chained = true,
		.chain_id = ALC271_FIXUP_AMIC_MIC2,
	},
3807 3808 3809 3810 3811 3812 3813 3814 3815 3816 3817 3818 3819
	[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,
	},
3820 3821 3822 3823
	[ALC269_FIXUP_LIMIT_INT_MIC_BOOST] = {
		.type = HDA_FIXUP_FUNC,
		.v.func = alc269_fixup_limit_int_mic_boost,
	},
3824 3825 3826 3827 3828 3829 3830 3831 3832
	[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 */
			{ }
		},
	},
3833 3834 3835 3836
	[ALC283_FIXUP_CHROME_BOOK] = {
		.type = HDA_FIXUP_FUNC,
		.v.func = alc283_fixup_chromebook,
	},
3837 3838 3839 3840
	[ALC282_FIXUP_ASUS_TX300] = {
		.type = HDA_FIXUP_FUNC,
		.v.func = alc282_fixup_asus_tx300,
	},
3841 3842 3843 3844 3845 3846 3847 3848 3849 3850
	[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
	},
3851 3852 3853 3854 3855 3856
	[ALC290_FIXUP_MONO_SPEAKERS] = {
		.type = HDA_FIXUP_FUNC,
		.v.func = alc290_fixup_mono_speakers,
		.chained = true,
		.chain_id = ALC269_FIXUP_DELL3_MIC_NO_PRESENCE,
	},
3857 3858
};

3859
static const struct snd_pci_quirk alc269_fixup_tbl[] = {
3860 3861
	SND_PCI_QUIRK(0x1025, 0x029b, "Acer 1810TZ", ALC269_FIXUP_INV_DMIC),
	SND_PCI_QUIRK(0x1025, 0x0349, "Acer AOD260", ALC269_FIXUP_INV_DMIC),
3862 3863 3864 3865 3866
	SND_PCI_QUIRK(0x1025, 0x047c, "Acer AC700", ALC269_FIXUP_ACER_AC700),
	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),
	SND_PCI_QUIRK_VENDOR(0x1025, "Acer Aspire", ALC271_FIXUP_DMIC),
	SND_PCI_QUIRK(0x1028, 0x0470, "Dell M101z", ALC269_FIXUP_DELL_M101Z),
3867 3868 3869 3870 3871 3872 3873 3874 3875 3876
	SND_PCI_QUIRK(0x1028, 0x05bd, "Dell", ALC269_FIXUP_DELL2_MIC_NO_PRESENCE),
	SND_PCI_QUIRK(0x1028, 0x05be, "Dell", ALC269_FIXUP_DELL2_MIC_NO_PRESENCE),
	SND_PCI_QUIRK(0x1028, 0x05c4, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE),
	SND_PCI_QUIRK(0x1028, 0x05c5, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE),
	SND_PCI_QUIRK(0x1028, 0x05c6, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE),
	SND_PCI_QUIRK(0x1028, 0x05c7, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE),
	SND_PCI_QUIRK(0x1028, 0x05c8, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE),
	SND_PCI_QUIRK(0x1028, 0x05c9, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE),
	SND_PCI_QUIRK(0x1028, 0x05ca, "Dell", ALC269_FIXUP_DELL2_MIC_NO_PRESENCE),
	SND_PCI_QUIRK(0x1028, 0x05cb, "Dell", ALC269_FIXUP_DELL2_MIC_NO_PRESENCE),
3877 3878
	SND_PCI_QUIRK(0x1028, 0x05cc, "Dell X5 Precision", ALC269_FIXUP_DELL2_MIC_NO_PRESENCE),
	SND_PCI_QUIRK(0x1028, 0x05cd, "Dell X5 Precision", ALC269_FIXUP_DELL2_MIC_NO_PRESENCE),
3879
	SND_PCI_QUIRK(0x1028, 0x05de, "Dell", ALC269_FIXUP_DELL2_MIC_NO_PRESENCE),
3880
	SND_PCI_QUIRK(0x1028, 0x05e0, "Dell", ALC269_FIXUP_DELL2_MIC_NO_PRESENCE),
3881 3882 3883 3884 3885 3886 3887 3888 3889 3890
	SND_PCI_QUIRK(0x1028, 0x05e9, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE),
	SND_PCI_QUIRK(0x1028, 0x05ea, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE),
	SND_PCI_QUIRK(0x1028, 0x05eb, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE),
	SND_PCI_QUIRK(0x1028, 0x05ec, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE),
	SND_PCI_QUIRK(0x1028, 0x05ed, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE),
	SND_PCI_QUIRK(0x1028, 0x05ee, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE),
	SND_PCI_QUIRK(0x1028, 0x05f3, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE),
	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),
3891
	SND_PCI_QUIRK(0x1028, 0x05f8, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE),
3892 3893
	SND_PCI_QUIRK(0x1028, 0x05f9, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE),
	SND_PCI_QUIRK(0x1028, 0x05fb, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE),
3894 3895
	SND_PCI_QUIRK(0x1028, 0x0606, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE),
	SND_PCI_QUIRK(0x1028, 0x0608, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE),
3896
	SND_PCI_QUIRK(0x1028, 0x0609, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE),
3897
	SND_PCI_QUIRK(0x1028, 0x0613, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE),
3898
	SND_PCI_QUIRK(0x1028, 0x0616, "Dell Vostro 5470", ALC290_FIXUP_MONO_SPEAKERS),
3899 3900
	SND_PCI_QUIRK(0x1028, 0x15cc, "Dell X5 Precision", ALC269_FIXUP_DELL2_MIC_NO_PRESENCE),
	SND_PCI_QUIRK(0x1028, 0x15cd, "Dell X5 Precision", ALC269_FIXUP_DELL2_MIC_NO_PRESENCE),
3901
	SND_PCI_QUIRK(0x103c, 0x1586, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC2),
3902
	SND_PCI_QUIRK(0x103c, 0x18e6, "HP", ALC269_FIXUP_HP_GPIO_LED),
3903 3904
	SND_PCI_QUIRK(0x103c, 0x1973, "HP Pavilion", ALC269_FIXUP_HP_MUTE_LED_MIC1),
	SND_PCI_QUIRK(0x103c, 0x1983, "HP Pavilion", ALC269_FIXUP_HP_MUTE_LED_MIC1),
3905
	SND_PCI_QUIRK(0x103c, 0x21ed, "HP Falco Chromebook", ALC283_FIXUP_CHROME_BOOK),
3906
	SND_PCI_QUIRK_VENDOR(0x103c, "HP", ALC269_FIXUP_HP_MUTE_LED),
3907
	SND_PCI_QUIRK(0x1043, 0x103f, "ASUS TX300", ALC282_FIXUP_ASUS_TX300),
3908 3909
	SND_PCI_QUIRK(0x1043, 0x106d, "Asus K53BE", ALC269_FIXUP_LIMIT_INT_MIC_BOOST),
	SND_PCI_QUIRK(0x1043, 0x115d, "Asus 1015E", ALC269_FIXUP_LIMIT_INT_MIC_BOOST),
3910
	SND_PCI_QUIRK(0x1043, 0x1427, "Asus Zenbook UX31E", ALC269VB_FIXUP_DMIC),
3911
	SND_PCI_QUIRK(0x1043, 0x1517, "Asus Zenbook UX31A", ALC269VB_FIXUP_DMIC),
3912
	SND_PCI_QUIRK(0x1043, 0x16e3, "ASUS UX50", ALC269_FIXUP_STEREO_DMIC),
3913
	SND_PCI_QUIRK(0x1043, 0x1a13, "Asus G73Jw", ALC269_FIXUP_ASUS_G73JW),
3914
	SND_PCI_QUIRK(0x1043, 0x1b13, "Asus U41SV", ALC269_FIXUP_INV_DMIC),
3915
	SND_PCI_QUIRK(0x1043, 0x1c23, "Asus X55U", ALC269_FIXUP_LIMIT_INT_MIC_BOOST),
3916 3917 3918 3919
	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),
3920
	SND_PCI_QUIRK(0x1043, 0x8516, "ASUS X101CH", ALC269_FIXUP_ASUS_X101),
3921
	SND_PCI_QUIRK(0x104d, 0x90b6, "Sony VAIO Pro 13", ALC286_FIXUP_SONY_MIC_NO_PRESENCE),
3922 3923 3924 3925
	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),
	SND_PCI_QUIRK_VENDOR(0x104d, "Sony VAIO", ALC269_FIXUP_SONY_VAIO),
3926
	SND_PCI_QUIRK(0x10cf, 0x1475, "Lifebook", ALC269_FIXUP_LIFEBOOK),
3927 3928 3929 3930 3931
	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),
3932
	SND_PCI_QUIRK(0x17aa, 0x21f6, "Thinkpad T530", ALC269_FIXUP_LENOVO_DOCK),
3933
	SND_PCI_QUIRK(0x17aa, 0x21fa, "Thinkpad X230", ALC269_FIXUP_LENOVO_DOCK),
3934
	SND_PCI_QUIRK(0x17aa, 0x21f3, "Thinkpad T430", ALC269_FIXUP_LENOVO_DOCK),
3935
	SND_PCI_QUIRK(0x17aa, 0x21fb, "Thinkpad T430s", ALC269_FIXUP_LENOVO_DOCK),
3936
	SND_PCI_QUIRK(0x17aa, 0x2203, "Thinkpad X230 Tablet", ALC269_FIXUP_LENOVO_DOCK),
3937
	SND_PCI_QUIRK(0x17aa, 0x2208, "Thinkpad T431s", ALC269_FIXUP_LENOVO_DOCK),
3938 3939
	SND_PCI_QUIRK(0x17aa, 0x220c, "Thinkpad", ALC269_FIXUP_LIMIT_INT_MIC_BOOST),
	SND_PCI_QUIRK(0x17aa, 0x2212, "Thinkpad", ALC269_FIXUP_LIMIT_INT_MIC_BOOST),
3940 3941 3942
	SND_PCI_QUIRK(0x17aa, 0x2214, "Thinkpad", ALC269_FIXUP_LIMIT_INT_MIC_BOOST),
	SND_PCI_QUIRK(0x17aa, 0x2215, "Thinkpad", ALC269_FIXUP_LIMIT_INT_MIC_BOOST),
	SND_PCI_QUIRK(0x17aa, 0x5013, "Thinkpad", ALC269_FIXUP_LIMIT_INT_MIC_BOOST),
3943
	SND_PCI_QUIRK(0x17aa, 0x501a, "Thinkpad", ALC283_FIXUP_INT_MIC),
3944 3945
	SND_PCI_QUIRK(0x17aa, 0x5026, "Thinkpad", ALC269_FIXUP_LIMIT_INT_MIC_BOOST),
	SND_PCI_QUIRK(0x17aa, 0x5109, "Thinkpad", ALC269_FIXUP_LIMIT_INT_MIC_BOOST),
3946
	SND_PCI_QUIRK(0x17aa, 0x3bf8, "Quanta FL1", ALC269_FIXUP_PCM_44K),
3947
	SND_PCI_QUIRK(0x17aa, 0x9e54, "LENOVO NB", ALC269_FIXUP_LENOVO_EAPD),
3948
	SND_PCI_QUIRK(0x1b7d, 0xa831, "Ordissimo EVE2 ", ALC269VB_FIXUP_ORDISSIMO_EVE2), /* Also known as Malata PC-B1303 */
3949

3950
#if 0
3951 3952 3953 3954
	/* 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.
3955
	 */
3956 3957 3958 3959 3960 3961 3962 3963 3964 3965 3966 3967 3968 3969 3970 3971 3972 3973 3974 3975 3976 3977 3978 3979 3980 3981 3982 3983 3984 3985 3986 3987 3988 3989 3990 3991 3992 3993 3994 3995 3996 3997 3998 3999 4000
	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
	{}
};

4001
static const struct hda_model_fixup alc269_fixup_models[] = {
4002 4003
	{.id = ALC269_FIXUP_AMIC, .name = "laptop-amic"},
	{.id = ALC269_FIXUP_DMIC, .name = "laptop-dmic"},
4004 4005 4006
	{.id = ALC269_FIXUP_STEREO_DMIC, .name = "alc269-dmic"},
	{.id = ALC271_FIXUP_DMIC, .name = "alc271-dmic"},
	{.id = ALC269_FIXUP_INV_DMIC, .name = "inv-dmic"},
4007
	{.id = ALC269_FIXUP_HEADSET_MIC, .name = "headset-mic"},
4008
	{.id = ALC269_FIXUP_LENOVO_DOCK, .name = "lenovo-dock"},
4009
	{.id = ALC269_FIXUP_HP_GPIO_LED, .name = "hp-gpio-led"},
4010 4011
	{.id = ALC269_FIXUP_DELL1_MIC_NO_PRESENCE, .name = "dell-headset-multi"},
	{.id = ALC269_FIXUP_DELL2_MIC_NO_PRESENCE, .name = "dell-headset-dock"},
4012
	{}
K
Kailang Yang 已提交
4013 4014 4015
};


4016
static void alc269_fill_coef(struct hda_codec *codec)
4017
{
4018
	struct alc_spec *spec = codec->spec;
4019
	int val;
4020

4021
	if (spec->codec_variant != ALC269_TYPE_ALC269VB)
4022
		return;
4023

4024
	if ((alc_get_coef0(codec) & 0x00ff) < 0x015) {
4025 4026 4027
		alc_write_coef_idx(codec, 0xf, 0x960b);
		alc_write_coef_idx(codec, 0xe, 0x8817);
	}
4028

4029
	if ((alc_get_coef0(codec) & 0x00ff) == 0x016) {
4030 4031 4032
		alc_write_coef_idx(codec, 0xf, 0x960b);
		alc_write_coef_idx(codec, 0xe, 0x8814);
	}
4033

4034
	if ((alc_get_coef0(codec) & 0x00ff) == 0x017) {
4035 4036 4037 4038
		val = alc_read_coef_idx(codec, 0x04);
		/* Power up output pin */
		alc_write_coef_idx(codec, 0x04, val | (1<<11));
	}
4039

4040
	if ((alc_get_coef0(codec) & 0x00ff) == 0x018) {
4041 4042 4043 4044 4045 4046 4047 4048 4049 4050 4051
		val = alc_read_coef_idx(codec, 0xd);
		if ((val & 0x0c00) >> 10 != 0x1) {
			/* Capless ramp up clock control */
			alc_write_coef_idx(codec, 0xd, val | (1<<10));
		}
		val = alc_read_coef_idx(codec, 0x17);
		if ((val & 0x01c0) >> 6 != 0x4) {
			/* Class D power on reset */
			alc_write_coef_idx(codec, 0x17, val | (1<<7));
		}
	}
4052

4053 4054
	val = alc_read_coef_idx(codec, 0xd); /* Class D */
	alc_write_coef_idx(codec, 0xd, val | (1<<14));
4055

4056 4057 4058
	val = alc_read_coef_idx(codec, 0x4); /* HP */
	alc_write_coef_idx(codec, 0x4, val | (1<<11));
}
4059

4060 4061 4062 4063 4064
/*
 */
static int patch_alc269(struct hda_codec *codec)
{
	struct alc_spec *spec;
4065
	int err;
4066

4067
	err = alc_alloc_spec(codec, 0x0b);
4068
	if (err < 0)
4069 4070 4071
		return err;

	spec = codec->spec;
4072
	spec->gen.shared_mic_vref_pin = 0x18;
4073

4074
	snd_hda_pick_fixup(codec, alc269_fixup_models,
4075
		       alc269_fixup_tbl, alc269_fixups);
4076
	snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE);
4077 4078 4079

	alc_auto_parse_customize_define(codec);

4080 4081 4082
	if (has_cdefine_beep(codec))
		spec->gen.beep_nid = 0x01;

4083 4084
	switch (codec->vendor_id) {
	case 0x10ec0269:
4085
		spec->codec_variant = ALC269_TYPE_ALC269VA;
4086 4087
		switch (alc_get_coef0(codec) & 0x00f0) {
		case 0x0010:
4088
			if (codec->bus->pci->subsystem_vendor == 0x1025 &&
4089
			    spec->cdefine.platform_type == 1)
4090
				err = alc_codec_rename(codec, "ALC271X");
4091
			spec->codec_variant = ALC269_TYPE_ALC269VB;
4092 4093
			break;
		case 0x0020:
4094 4095
			if (codec->bus->pci->subsystem_vendor == 0x17aa &&
			    codec->bus->pci->subsystem_device == 0x21f3)
4096
				err = alc_codec_rename(codec, "ALC3202");
4097
			spec->codec_variant = ALC269_TYPE_ALC269VC;
4098
			break;
4099 4100 4101
		case 0x0030:
			spec->codec_variant = ALC269_TYPE_ALC269VD;
			break;
4102
		default:
4103
			alc_fix_pll_init(codec, 0x20, 0x04, 15);
4104
		}
4105 4106
		if (err < 0)
			goto error;
4107
		spec->init_hook = alc269_fill_coef;
4108
		alc269_fill_coef(codec);
4109 4110 4111 4112 4113 4114 4115 4116 4117
		break;

	case 0x10ec0280:
	case 0x10ec0290:
		spec->codec_variant = ALC269_TYPE_ALC280;
		break;
	case 0x10ec0282:
		spec->codec_variant = ALC269_TYPE_ALC282;
		break;
4118 4119 4120 4121 4122 4123
	case 0x10ec0233:
	case 0x10ec0283:
		spec->codec_variant = ALC269_TYPE_ALC283;
		spec->shutup = alc283_shutup;
		spec->init_hook = alc283_init;
		break;
4124 4125 4126 4127
	case 0x10ec0284:
	case 0x10ec0292:
		spec->codec_variant = ALC269_TYPE_ALC284;
		break;
4128 4129 4130
	case 0x10ec0286:
		spec->codec_variant = ALC269_TYPE_ALC286;
		break;
4131
	}
K
Kailang Yang 已提交
4132

4133 4134 4135 4136 4137
	if (snd_hda_codec_read(codec, 0x51, 0, AC_VERB_PARAMETERS, 0) == 0x10ec5505) {
		spec->has_alc5505_dsp = true;
		spec->init_hook = alc5505_dsp_init;
	}

4138 4139
	/* automatic parse from the BIOS config */
	err = alc269_parse_auto_config(codec);
4140 4141
	if (err < 0)
		goto error;
K
Kailang Yang 已提交
4142

4143
	if (!spec->gen.no_analog && spec->gen.beep_nid)
4144
		set_beep_amp(spec, 0x0b, 0x04, HDA_INPUT);
4145

4146
	codec->patch_ops = alc_patch_ops;
4147
#ifdef CONFIG_PM
4148
	codec->patch_ops.suspend = alc269_suspend;
4149 4150
	codec->patch_ops.resume = alc269_resume;
#endif
4151 4152
	if (!spec->shutup)
		spec->shutup = alc269_shutup;
4153

4154
	snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE);
4155

4156
	return 0;
4157 4158 4159 4160

 error:
	alc_free(codec);
	return err;
4161
}
4162

4163 4164 4165
/*
 * ALC861
 */
4166

4167
static int alc861_parse_auto_config(struct hda_codec *codec)
K
Kailang Yang 已提交
4168
{
4169
	static const hda_nid_t alc861_ignore[] = { 0x1d, 0 };
4170 4171
	static const hda_nid_t alc861_ssids[] = { 0x0e, 0x0f, 0x0b, 0 };
	return alc_parse_auto_config(codec, alc861_ignore, alc861_ssids);
4172 4173
}

4174 4175
/* Pin config fixes */
enum {
4176 4177 4178 4179
	ALC861_FIXUP_FSC_AMILO_PI1505,
	ALC861_FIXUP_AMP_VREF_0F,
	ALC861_FIXUP_NO_JACK_DETECT,
	ALC861_FIXUP_ASUS_A6RP,
4180
};
4181

4182 4183
/* 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,
4184
			const struct hda_fixup *fix, int action)
4185 4186 4187 4188
{
	struct alc_spec *spec = codec->spec;
	unsigned int val;

4189
	if (action != HDA_FIXUP_ACT_INIT)
4190
		return;
4191
	val = snd_hda_codec_get_pin_target(codec, 0x0f);
4192 4193 4194
	if (!(val & (AC_PINCTL_IN_EN | AC_PINCTL_OUT_EN)))
		val |= AC_PINCTL_IN_EN;
	val |= AC_PINCTL_VREF_50;
4195
	snd_hda_set_pin_ctl(codec, 0x0f, val);
4196
	spec->gen.keep_vref_in_automute = 1;
4197 4198
}

4199 4200
/* suppress the jack-detection */
static void alc_fixup_no_jack_detect(struct hda_codec *codec,
4201
				     const struct hda_fixup *fix, int action)
4202
{
4203
	if (action == HDA_FIXUP_ACT_PRE_PROBE)
4204
		codec->no_jack_detect = 1;
4205
}
4206

4207
static const struct hda_fixup alc861_fixups[] = {
4208
	[ALC861_FIXUP_FSC_AMILO_PI1505] = {
4209 4210
		.type = HDA_FIXUP_PINS,
		.v.pins = (const struct hda_pintbl[]) {
4211 4212 4213 4214 4215
			{ 0x0b, 0x0221101f }, /* HP */
			{ 0x0f, 0x90170310 }, /* speaker */
			{ }
		}
	},
4216
	[ALC861_FIXUP_AMP_VREF_0F] = {
4217
		.type = HDA_FIXUP_FUNC,
4218
		.v.func = alc861_fixup_asus_amp_vref_0f,
4219
	},
4220
	[ALC861_FIXUP_NO_JACK_DETECT] = {
4221
		.type = HDA_FIXUP_FUNC,
4222 4223 4224
		.v.func = alc_fixup_no_jack_detect,
	},
	[ALC861_FIXUP_ASUS_A6RP] = {
4225
		.type = HDA_FIXUP_FUNC,
4226 4227 4228 4229
		.v.func = alc861_fixup_asus_amp_vref_0f,
		.chained = true,
		.chain_id = ALC861_FIXUP_NO_JACK_DETECT,
	}
4230
};
4231

4232
static const struct snd_pci_quirk alc861_fixup_tbl[] = {
4233 4234 4235 4236 4237 4238
	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),
4239 4240
	{}
};
4241

4242 4243 4244
/*
 */
static int patch_alc861(struct hda_codec *codec)
4245
{
4246 4247
	struct alc_spec *spec;
	int err;
4248

4249 4250 4251
	err = alc_alloc_spec(codec, 0x15);
	if (err < 0)
		return err;
4252

4253
	spec = codec->spec;
4254
	spec->gen.beep_nid = 0x23;
4255

4256 4257
	snd_hda_pick_fixup(codec, NULL, alc861_fixup_tbl, alc861_fixups);
	snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE);
4258

4259 4260
	/* automatic parse from the BIOS config */
	err = alc861_parse_auto_config(codec);
4261 4262
	if (err < 0)
		goto error;
4263

4264
	if (!spec->gen.no_analog)
4265
		set_beep_amp(spec, 0x23, 0, HDA_OUTPUT);
4266

4267
	codec->patch_ops = alc_patch_ops;
4268
#ifdef CONFIG_PM
4269
	spec->power_hook = alc_power_eapd;
4270 4271
#endif

4272
	snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE);
4273

4274
	return 0;
4275 4276 4277 4278

 error:
	alc_free(codec);
	return err;
4279 4280
}

4281 4282 4283 4284 4285 4286 4287 4288
/*
 * ALC861-VD support
 *
 * Based on ALC882
 *
 * In addition, an independent DAC
 */
static int alc861vd_parse_auto_config(struct hda_codec *codec)
4289
{
4290
	static const hda_nid_t alc861vd_ignore[] = { 0x1d, 0 };
4291 4292
	static const hda_nid_t alc861vd_ssids[] = { 0x15, 0x1b, 0x14, 0 };
	return alc_parse_auto_config(codec, alc861vd_ignore, alc861vd_ssids);
4293 4294
}

4295
enum {
4296 4297
	ALC660VD_FIX_ASUS_GPIO1,
	ALC861VD_FIX_DALLAS,
4298
};
4299

4300 4301
/* exclude VREF80 */
static void alc861vd_fixup_dallas(struct hda_codec *codec,
4302
				  const struct hda_fixup *fix, int action)
4303
{
4304
	if (action == HDA_FIXUP_ACT_PRE_PROBE) {
4305 4306
		snd_hda_override_pin_caps(codec, 0x18, 0x00000734);
		snd_hda_override_pin_caps(codec, 0x19, 0x0000073c);
4307 4308 4309
	}
}

4310
static const struct hda_fixup alc861vd_fixups[] = {
4311
	[ALC660VD_FIX_ASUS_GPIO1] = {
4312
		.type = HDA_FIXUP_VERBS,
4313
		.v.verbs = (const struct hda_verb[]) {
4314
			/* reset GPIO1 */
4315 4316 4317 4318 4319 4320
			{0x01, AC_VERB_SET_GPIO_MASK, 0x03},
			{0x01, AC_VERB_SET_GPIO_DIRECTION, 0x01},
			{0x01, AC_VERB_SET_GPIO_DATA, 0x01},
			{ }
		}
	},
4321
	[ALC861VD_FIX_DALLAS] = {
4322
		.type = HDA_FIXUP_FUNC,
4323 4324
		.v.func = alc861vd_fixup_dallas,
	},
4325
};
4326

4327
static const struct snd_pci_quirk alc861vd_fixup_tbl[] = {
4328
	SND_PCI_QUIRK(0x103c, 0x30bf, "HP TX1000", ALC861VD_FIX_DALLAS),
4329
	SND_PCI_QUIRK(0x1043, 0x1339, "ASUS A7-K", ALC660VD_FIX_ASUS_GPIO1),
4330
	SND_PCI_QUIRK(0x1179, 0xff31, "Toshiba L30-149", ALC861VD_FIX_DALLAS),
4331 4332
	{}
};
4333

4334 4335 4336
/*
 */
static int patch_alc861vd(struct hda_codec *codec)
4337
{
4338
	struct alc_spec *spec;
4339
	int err;
4340

4341 4342 4343
	err = alc_alloc_spec(codec, 0x0b);
	if (err < 0)
		return err;
4344

4345
	spec = codec->spec;
4346
	spec->gen.beep_nid = 0x23;
4347

4348 4349
	snd_hda_pick_fixup(codec, NULL, alc861vd_fixup_tbl, alc861vd_fixups);
	snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE);
4350

4351 4352
	/* automatic parse from the BIOS config */
	err = alc861vd_parse_auto_config(codec);
4353 4354
	if (err < 0)
		goto error;
4355

4356
	if (!spec->gen.no_analog)
4357
		set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
4358 4359 4360 4361 4362

	codec->patch_ops = alc_patch_ops;

	spec->shutup = alc_eapd_shutup;

4363
	snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE);
4364

4365
	return 0;
4366 4367 4368 4369

 error:
	alc_free(codec);
	return err;
4370 4371
}

4372 4373 4374 4375 4376 4377 4378 4379 4380 4381 4382 4383 4384 4385 4386 4387
/*
 * 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
 */

4388 4389
static int alc662_parse_auto_config(struct hda_codec *codec)
{
4390
	static const hda_nid_t alc662_ignore[] = { 0x1d, 0 };
4391 4392 4393
	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;
4394

4395
	if (codec->vendor_id == 0x10ec0272 || codec->vendor_id == 0x10ec0663 ||
4396 4397
	    codec->vendor_id == 0x10ec0665 || codec->vendor_id == 0x10ec0670 ||
	    codec->vendor_id == 0x10ec0671)
4398
		ssids = alc663_ssids;
4399
	else
4400 4401
		ssids = alc662_ssids;
	return alc_parse_auto_config(codec, alc662_ignore, ssids);
4402 4403
}

T
Todd Broch 已提交
4404
static void alc272_fixup_mario(struct hda_codec *codec,
4405
			       const struct hda_fixup *fix, int action)
4406
{
4407
	if (action != HDA_FIXUP_ACT_PRE_PROBE)
4408
		return;
T
Todd Broch 已提交
4409 4410 4411 4412 4413 4414 4415 4416 4417
	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)))
		printk(KERN_WARNING
		       "hda_codec: failed to override amp caps for NID 0x2\n");
}

4418
enum {
4419
	ALC662_FIXUP_ASPIRE,
4420
	ALC662_FIXUP_IDEAPAD,
T
Todd Broch 已提交
4421
	ALC272_FIXUP_MARIO,
4422
	ALC662_FIXUP_CZC_P10T,
4423
	ALC662_FIXUP_SKU_IGNORE,
4424
	ALC662_FIXUP_HP_RP5800,
4425 4426 4427 4428 4429 4430 4431 4432
	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,
4433
	ALC662_FIXUP_NO_JACK_DETECT,
4434
	ALC662_FIXUP_ZOTAC_Z68,
4435
	ALC662_FIXUP_INV_DMIC,
4436 4437
	ALC668_FIXUP_DELL_MIC_NO_PRESENCE,
	ALC668_FIXUP_HEADSET_MODE,
4438 4439
};

4440
static const struct hda_fixup alc662_fixups[] = {
4441
	[ALC662_FIXUP_ASPIRE] = {
4442 4443
		.type = HDA_FIXUP_PINS,
		.v.pins = (const struct hda_pintbl[]) {
4444 4445 4446 4447
			{ 0x15, 0x99130112 }, /* subwoofer */
			{ }
		}
	},
4448
	[ALC662_FIXUP_IDEAPAD] = {
4449 4450
		.type = HDA_FIXUP_PINS,
		.v.pins = (const struct hda_pintbl[]) {
4451 4452 4453 4454
			{ 0x17, 0x99130112 }, /* subwoofer */
			{ }
		}
	},
T
Todd Broch 已提交
4455
	[ALC272_FIXUP_MARIO] = {
4456
		.type = HDA_FIXUP_FUNC,
4457
		.v.func = alc272_fixup_mario,
4458 4459
	},
	[ALC662_FIXUP_CZC_P10T] = {
4460
		.type = HDA_FIXUP_VERBS,
4461 4462 4463 4464 4465
		.v.verbs = (const struct hda_verb[]) {
			{0x14, AC_VERB_SET_EAPD_BTLENABLE, 0},
			{}
		}
	},
4466
	[ALC662_FIXUP_SKU_IGNORE] = {
4467
		.type = HDA_FIXUP_FUNC,
4468
		.v.func = alc_fixup_sku_ignore,
4469
	},
4470
	[ALC662_FIXUP_HP_RP5800] = {
4471 4472
		.type = HDA_FIXUP_PINS,
		.v.pins = (const struct hda_pintbl[]) {
4473 4474 4475 4476 4477 4478
			{ 0x14, 0x0221201f }, /* HP out */
			{ }
		},
		.chained = true,
		.chain_id = ALC662_FIXUP_SKU_IGNORE
	},
4479
	[ALC662_FIXUP_ASUS_MODE1] = {
4480 4481
		.type = HDA_FIXUP_PINS,
		.v.pins = (const struct hda_pintbl[]) {
4482 4483 4484 4485 4486 4487 4488 4489 4490 4491
			{ 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] = {
4492 4493
		.type = HDA_FIXUP_PINS,
		.v.pins = (const struct hda_pintbl[]) {
4494 4495 4496 4497 4498 4499
			{ 0x14, 0x99130110 }, /* speaker */
			{ 0x18, 0x01a19820 }, /* mic */
			{ 0x19, 0x99a3092f }, /* int-mic */
			{ 0x1b, 0x0121401f }, /* HP out */
			{ }
		},
4500 4501 4502 4503
		.chained = true,
		.chain_id = ALC662_FIXUP_SKU_IGNORE
	},
	[ALC662_FIXUP_ASUS_MODE3] = {
4504 4505
		.type = HDA_FIXUP_PINS,
		.v.pins = (const struct hda_pintbl[]) {
4506 4507 4508 4509 4510 4511 4512 4513 4514 4515 4516
			{ 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] = {
4517 4518
		.type = HDA_FIXUP_PINS,
		.v.pins = (const struct hda_pintbl[]) {
4519 4520 4521 4522 4523 4524 4525 4526 4527 4528 4529
			{ 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] = {
4530 4531
		.type = HDA_FIXUP_PINS,
		.v.pins = (const struct hda_pintbl[]) {
4532 4533 4534 4535 4536 4537 4538 4539 4540 4541 4542
			{ 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] = {
4543 4544
		.type = HDA_FIXUP_PINS,
		.v.pins = (const struct hda_pintbl[]) {
4545 4546 4547 4548 4549 4550 4551 4552 4553 4554 4555
			{ 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] = {
4556 4557
		.type = HDA_FIXUP_PINS,
		.v.pins = (const struct hda_pintbl[]) {
4558 4559 4560 4561 4562 4563 4564 4565 4566 4567 4568 4569
			{ 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] = {
4570 4571
		.type = HDA_FIXUP_PINS,
		.v.pins = (const struct hda_pintbl[]) {
4572 4573 4574 4575 4576 4577 4578 4579 4580 4581
			{ 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
4582
	},
4583
	[ALC662_FIXUP_NO_JACK_DETECT] = {
4584
		.type = HDA_FIXUP_FUNC,
4585 4586
		.v.func = alc_fixup_no_jack_detect,
	},
4587
	[ALC662_FIXUP_ZOTAC_Z68] = {
4588 4589
		.type = HDA_FIXUP_PINS,
		.v.pins = (const struct hda_pintbl[]) {
4590 4591 4592 4593
			{ 0x1b, 0x02214020 }, /* Front HP */
			{ }
		}
	},
4594
	[ALC662_FIXUP_INV_DMIC] = {
4595
		.type = HDA_FIXUP_FUNC,
4596
		.v.func = alc_fixup_inv_dmic_0x12,
4597
	},
4598 4599 4600 4601 4602 4603 4604 4605 4606 4607 4608 4609 4610 4611
	[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,
	},
4612 4613
};

4614
static const struct snd_pci_quirk alc662_fixup_tbl[] = {
4615
	SND_PCI_QUIRK(0x1019, 0x9087, "ECS", ALC662_FIXUP_ASUS_MODE2),
4616
	SND_PCI_QUIRK(0x1025, 0x022f, "Acer Aspire One", ALC662_FIXUP_INV_DMIC),
4617
	SND_PCI_QUIRK(0x1025, 0x0308, "Acer Aspire 8942G", ALC662_FIXUP_ASPIRE),
4618
	SND_PCI_QUIRK(0x1025, 0x031c, "Gateway NV79", ALC662_FIXUP_SKU_IGNORE),
4619
	SND_PCI_QUIRK(0x1025, 0x0349, "eMachines eM250", ALC662_FIXUP_INV_DMIC),
4620
	SND_PCI_QUIRK(0x1025, 0x034a, "Gateway LT27", ALC662_FIXUP_INV_DMIC),
4621
	SND_PCI_QUIRK(0x1025, 0x038b, "Acer Aspire 8943G", ALC662_FIXUP_ASPIRE),
4622 4623
	SND_PCI_QUIRK(0x1028, 0x05d8, "Dell", ALC668_FIXUP_DELL_MIC_NO_PRESENCE),
	SND_PCI_QUIRK(0x1028, 0x05db, "Dell", ALC668_FIXUP_DELL_MIC_NO_PRESENCE),
4624
	SND_PCI_QUIRK(0x103c, 0x1632, "HP RP5800", ALC662_FIXUP_HP_RP5800),
4625
	SND_PCI_QUIRK(0x1043, 0x1477, "ASUS N56VZ", ALC662_FIXUP_ASUS_MODE4),
4626
	SND_PCI_QUIRK(0x1043, 0x8469, "ASUS mobo", ALC662_FIXUP_NO_JACK_DETECT),
4627
	SND_PCI_QUIRK(0x105b, 0x0cd6, "Foxconn", ALC662_FIXUP_ASUS_MODE2),
4628
	SND_PCI_QUIRK(0x144d, 0xc051, "Samsung R720", ALC662_FIXUP_IDEAPAD),
4629
	SND_PCI_QUIRK(0x17aa, 0x38af, "Lenovo Ideapad Y550P", ALC662_FIXUP_IDEAPAD),
4630
	SND_PCI_QUIRK(0x17aa, 0x3a0d, "Lenovo Ideapad Y550", ALC662_FIXUP_IDEAPAD),
4631
	SND_PCI_QUIRK(0x19da, 0xa130, "Zotac Z68", ALC662_FIXUP_ZOTAC_Z68),
4632
	SND_PCI_QUIRK(0x1b35, 0x2206, "CZC P10T", ALC662_FIXUP_CZC_P10T),
4633 4634 4635 4636 4637 4638

#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.
4639
	 */
4640 4641 4642 4643 4644 4645 4646 4647 4648 4649 4650 4651 4652 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 4681 4682 4683 4684 4685 4686 4687 4688 4689 4690
	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
4691 4692 4693
	{}
};

4694
static const struct hda_model_fixup alc662_fixup_models[] = {
T
Todd Broch 已提交
4695
	{.id = ALC272_FIXUP_MARIO, .name = "mario"},
4696 4697 4698 4699 4700 4701 4702 4703
	{.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"},
4704
	{.id = ALC662_FIXUP_INV_DMIC, .name = "inv-dmic"},
4705
	{.id = ALC668_FIXUP_DELL_MIC_NO_PRESENCE, .name = "dell-headset-multi"},
T
Todd Broch 已提交
4706 4707
	{}
};
4708

4709 4710 4711 4712 4713 4714 4715 4716 4717 4718 4719 4720 4721 4722 4723 4724 4725 4726 4727 4728 4729 4730 4731 4732 4733
static void alc662_fill_coef(struct hda_codec *codec)
{
	int val, coef;

	coef = alc_get_coef0(codec);

	switch (codec->vendor_id) {
	case 0x10ec0662:
		if ((coef & 0x00f0) == 0x0030) {
			val = alc_read_coef_idx(codec, 0x4); /* EAPD Ctrl */
			alc_write_coef_idx(codec, 0x4, val & ~(1<<10));
		}
		break;
	case 0x10ec0272:
	case 0x10ec0273:
	case 0x10ec0663:
	case 0x10ec0665:
	case 0x10ec0670:
	case 0x10ec0671:
	case 0x10ec0672:
		val = alc_read_coef_idx(codec, 0xd); /* EAPD Ctrl */
		alc_write_coef_idx(codec, 0xd, val | (1<<14));
		break;
	}
}
4734

4735 4736
/*
 */
4737 4738 4739
static int patch_alc662(struct hda_codec *codec)
{
	struct alc_spec *spec;
4740
	int err;
4741

4742 4743 4744
	err = alc_alloc_spec(codec, 0x0b);
	if (err < 0)
		return err;
4745

4746
	spec = codec->spec;
4747

4748 4749 4750
	/* handle multiple HPs as is */
	spec->parse_flags = HDA_PINCFG_NO_HP_FIXUP;

4751 4752
	alc_fix_pll_init(codec, 0x20, 0x04, 15);

4753 4754 4755
	spec->init_hook = alc662_fill_coef;
	alc662_fill_coef(codec);

4756
	snd_hda_pick_fixup(codec, alc662_fixup_models,
4757
		       alc662_fixup_tbl, alc662_fixups);
4758
	snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE);
4759 4760 4761

	alc_auto_parse_customize_define(codec);

4762 4763 4764
	if (has_cdefine_beep(codec))
		spec->gen.beep_nid = 0x01;

4765
	if ((alc_get_coef0(codec) & (1 << 14)) &&
4766 4767
	    codec->bus->pci->subsystem_vendor == 0x1025 &&
	    spec->cdefine.platform_type == 1) {
4768 4769
		err = alc_codec_rename(codec, "ALC272X");
		if (err < 0)
4770
			goto error;
4771
	}
4772

4773 4774
	/* automatic parse from the BIOS config */
	err = alc662_parse_auto_config(codec);
4775 4776
	if (err < 0)
		goto error;
4777

4778
	if (!spec->gen.no_analog && spec->gen.beep_nid) {
4779 4780 4781 4782 4783 4784 4785 4786 4787 4788 4789 4790 4791
		switch (codec->vendor_id) {
		case 0x10ec0662:
			set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
			break;
		case 0x10ec0272:
		case 0x10ec0663:
		case 0x10ec0665:
			set_beep_amp(spec, 0x0b, 0x04, HDA_INPUT);
			break;
		case 0x10ec0273:
			set_beep_amp(spec, 0x0b, 0x03, HDA_INPUT);
			break;
		}
K
Kailang Yang 已提交
4792
	}
4793

4794
	codec->patch_ops = alc_patch_ops;
4795
	spec->shutup = alc_eapd_shutup;
4796

4797
	snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE);
4798

4799
	return 0;
4800

4801 4802 4803
 error:
	alc_free(codec);
	return err;
4804 4805
}

K
Kailang Yang 已提交
4806 4807 4808 4809 4810 4811
/*
 * ALC680 support
 */

static int alc680_parse_auto_config(struct hda_codec *codec)
{
4812
	return alc_parse_auto_config(codec, NULL, NULL);
K
Kailang Yang 已提交
4813 4814 4815 4816 4817 4818 4819 4820
}

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

4821
	/* ALC680 has no aa-loopback mixer */
4822 4823 4824
	err = alc_alloc_spec(codec, 0);
	if (err < 0)
		return err;
4825

4826 4827 4828 4829 4830
	/* automatic parse from the BIOS config */
	err = alc680_parse_auto_config(codec);
	if (err < 0) {
		alc_free(codec);
		return err;
K
Kailang Yang 已提交
4831 4832 4833 4834 4835 4836 4837
	}

	codec->patch_ops = alc_patch_ops;

	return 0;
}

L
Linus Torvalds 已提交
4838 4839 4840
/*
 * patch entries
 */
4841
static const struct hda_codec_preset snd_hda_preset_realtek[] = {
4842
	{ .id = 0x10ec0221, .name = "ALC221", .patch = patch_alc269 },
4843
	{ .id = 0x10ec0233, .name = "ALC233", .patch = patch_alc269 },
L
Linus Torvalds 已提交
4844
	{ .id = 0x10ec0260, .name = "ALC260", .patch = patch_alc260 },
4845
	{ .id = 0x10ec0262, .name = "ALC262", .patch = patch_alc262 },
4846
	{ .id = 0x10ec0267, .name = "ALC267", .patch = patch_alc268 },
4847
	{ .id = 0x10ec0268, .name = "ALC268", .patch = patch_alc268 },
4848
	{ .id = 0x10ec0269, .name = "ALC269", .patch = patch_alc269 },
4849
	{ .id = 0x10ec0270, .name = "ALC270", .patch = patch_alc269 },
K
Kailang Yang 已提交
4850
	{ .id = 0x10ec0272, .name = "ALC272", .patch = patch_alc662 },
4851
	{ .id = 0x10ec0275, .name = "ALC275", .patch = patch_alc269 },
4852
	{ .id = 0x10ec0276, .name = "ALC276", .patch = patch_alc269 },
4853
	{ .id = 0x10ec0280, .name = "ALC280", .patch = patch_alc269 },
4854
	{ .id = 0x10ec0282, .name = "ALC282", .patch = patch_alc269 },
4855
	{ .id = 0x10ec0283, .name = "ALC283", .patch = patch_alc269 },
4856
	{ .id = 0x10ec0284, .name = "ALC284", .patch = patch_alc269 },
4857
	{ .id = 0x10ec0286, .name = "ALC286", .patch = patch_alc269 },
4858
	{ .id = 0x10ec0290, .name = "ALC290", .patch = patch_alc269 },
4859
	{ .id = 0x10ec0292, .name = "ALC292", .patch = patch_alc269 },
4860
	{ .id = 0x10ec0861, .rev = 0x100340, .name = "ALC660",
4861
	  .patch = patch_alc861 },
4862 4863 4864
	{ .id = 0x10ec0660, .name = "ALC660-VD", .patch = patch_alc861vd },
	{ .id = 0x10ec0861, .name = "ALC861", .patch = patch_alc861 },
	{ .id = 0x10ec0862, .name = "ALC861-VD", .patch = patch_alc861vd },
4865
	{ .id = 0x10ec0662, .rev = 0x100002, .name = "ALC662 rev2",
4866
	  .patch = patch_alc882 },
4867 4868
	{ .id = 0x10ec0662, .rev = 0x100101, .name = "ALC662 rev1",
	  .patch = patch_alc662 },
4869 4870
	{ .id = 0x10ec0662, .rev = 0x100300, .name = "ALC662 rev3",
	  .patch = patch_alc662 },
K
Kailang Yang 已提交
4871
	{ .id = 0x10ec0663, .name = "ALC663", .patch = patch_alc662 },
K
Kailang Yang 已提交
4872
	{ .id = 0x10ec0665, .name = "ALC665", .patch = patch_alc662 },
4873
	{ .id = 0x10ec0668, .name = "ALC668", .patch = patch_alc662 },
4874
	{ .id = 0x10ec0670, .name = "ALC670", .patch = patch_alc662 },
4875
	{ .id = 0x10ec0671, .name = "ALC671", .patch = patch_alc662 },
K
Kailang Yang 已提交
4876
	{ .id = 0x10ec0680, .name = "ALC680", .patch = patch_alc680 },
4877
	{ .id = 0x10ec0880, .name = "ALC880", .patch = patch_alc880 },
L
Linus Torvalds 已提交
4878
	{ .id = 0x10ec0882, .name = "ALC882", .patch = patch_alc882 },
4879
	{ .id = 0x10ec0883, .name = "ALC883", .patch = patch_alc882 },
4880
	{ .id = 0x10ec0885, .rev = 0x100101, .name = "ALC889A",
4881
	  .patch = patch_alc882 },
4882
	{ .id = 0x10ec0885, .rev = 0x100103, .name = "ALC889A",
4883
	  .patch = patch_alc882 },
4884
	{ .id = 0x10ec0885, .name = "ALC885", .patch = patch_alc882 },
4885
	{ .id = 0x10ec0887, .name = "ALC887", .patch = patch_alc882 },
K
Kailang Yang 已提交
4886
	{ .id = 0x10ec0888, .rev = 0x100101, .name = "ALC1200",
4887
	  .patch = patch_alc882 },
4888
	{ .id = 0x10ec0888, .name = "ALC888", .patch = patch_alc882 },
4889
	{ .id = 0x10ec0889, .name = "ALC889", .patch = patch_alc882 },
4890
	{ .id = 0x10ec0892, .name = "ALC892", .patch = patch_alc662 },
4891
	{ .id = 0x10ec0899, .name = "ALC898", .patch = patch_alc882 },
4892
	{ .id = 0x10ec0900, .name = "ALC1150", .patch = patch_alc882 },
L
Linus Torvalds 已提交
4893 4894
	{} /* terminator */
};
4895 4896 4897 4898 4899 4900 4901 4902 4903 4904 4905 4906 4907 4908 4909 4910 4911 4912 4913 4914 4915 4916 4917

MODULE_ALIAS("snd-hda-codec-id:10ec*");

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

static struct hda_codec_preset_list realtek_list = {
	.preset = snd_hda_preset_realtek,
	.owner = THIS_MODULE,
};

static int __init patch_realtek_init(void)
{
	return snd_hda_add_codec_preset(&realtek_list);
}

static void __exit patch_realtek_exit(void)
{
	snd_hda_delete_codec_preset(&realtek_list);
}

module_init(patch_realtek_init)
module_exit(patch_realtek_exit)