patch_realtek.c 167.2 KB
Newer Older
L
Linus Torvalds 已提交
1 2 3
/*
 * Universal Interface for Intel High Definition Audio Codec
 *
4
 * HD audio interface patch for Realtek ALC codecs
L
Linus Torvalds 已提交
5
 *
6 7
 * Copyright (c) 2004 Kailang Yang <kailang@realtek.com.tw>
 *                    PeiSen Hou <pshou@realtek.com.tw>
L
Linus Torvalds 已提交
8
 *                    Takashi Iwai <tiwai@suse.de>
9
 *                    Jonathan Woithe <jwoithe@physics.adelaide.edu.au>
L
Linus Torvalds 已提交
10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30
 *
 *  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>
#include <sound/core.h>
31
#include <sound/jack.h>
L
Linus Torvalds 已提交
32 33
#include "hda_codec.h"
#include "hda_local.h"
34
#include "hda_beep.h"
L
Linus Torvalds 已提交
35

36 37 38 39 40
/* unsol event tags */
#define ALC_FRONT_EVENT		0x01
#define ALC_DCVOL_EVENT		0x02
#define ALC_HP_EVENT		0x04
#define ALC_MIC_EVENT		0x08
41

42 43 44
/* for GPIO Poll */
#define GPIO_MASK	0x03

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

54 55 56 57 58 59 60 61 62 63
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;
64
	unsigned int  fixup:1; /* Means that this sku is set by driver, not read from hw */
65 66
};

67 68
struct alc_fixup;

69 70 71 72 73 74
struct alc_multi_io {
	hda_nid_t pin;		/* multi-io widget pin NID */
	hda_nid_t dac;		/* DAC to be connected */
	unsigned int ctl_in;	/* cached input-pin control value */
};

75
enum {
76 77 78
	ALC_AUTOMUTE_PIN,	/* change the pin control */
	ALC_AUTOMUTE_AMP,	/* mute/unmute the pin AMP */
	ALC_AUTOMUTE_MIXER,	/* mute/unmute mixer widget AMP */
79 80
};

L
Linus Torvalds 已提交
81 82
struct alc_spec {
	/* codec parameterization */
83
	const struct snd_kcontrol_new *mixers[5];	/* mixer arrays */
L
Linus Torvalds 已提交
84
	unsigned int num_mixers;
85
	const struct snd_kcontrol_new *cap_mixer;	/* capture mixer */
86
	unsigned int beep_amp;	/* beep amp value, set via set_beep_amp() */
L
Linus Torvalds 已提交
87

88
	const struct hda_verb *init_verbs[10];	/* initialization verbs
89 90
						 * don't forget NULL
						 * termination!
91 92
						 */
	unsigned int num_init_verbs;
L
Linus Torvalds 已提交
93

94
	char stream_name_analog[32];	/* analog PCM stream */
95 96 97 98
	const struct hda_pcm_stream *stream_analog_playback;
	const struct hda_pcm_stream *stream_analog_capture;
	const struct hda_pcm_stream *stream_analog_alt_playback;
	const struct hda_pcm_stream *stream_analog_alt_capture;
L
Linus Torvalds 已提交
99

100
	char stream_name_digital[32];	/* digital PCM stream */
101 102
	const struct hda_pcm_stream *stream_digital_playback;
	const struct hda_pcm_stream *stream_digital_capture;
L
Linus Torvalds 已提交
103 104

	/* playback */
105 106 107 108
	struct hda_multi_out multiout;	/* playback set-up
					 * max_channels, dacs must be set
					 * dig_out_nid and hp_nid are optional
					 */
109
	hda_nid_t alt_dac_nid;
110
	hda_nid_t slave_dig_outs[3];	/* optional - for auto-parsing */
111
	int dig_out_type;
L
Linus Torvalds 已提交
112 113 114

	/* capture */
	unsigned int num_adc_nids;
115 116
	const hda_nid_t *adc_nids;
	const hda_nid_t *capsrc_nids;
117
	hda_nid_t dig_in_nid;		/* digital-in NID; optional */
118
	hda_nid_t mixer_nid;		/* analog-mixer NID */
L
Linus Torvalds 已提交
119

120 121 122 123 124
	/* capture setup for dynamic dual-adc switch */
	hda_nid_t cur_adc;
	unsigned int cur_adc_stream_tag;
	unsigned int cur_adc_format;

L
Linus Torvalds 已提交
125
	/* capture source */
126
	unsigned int num_mux_defs;
L
Linus Torvalds 已提交
127 128
	const struct hda_input_mux *input_mux;
	unsigned int cur_mux[3];
129 130 131
	hda_nid_t ext_mic_pin;
	hda_nid_t dock_mic_pin;
	hda_nid_t int_mic_pin;
L
Linus Torvalds 已提交
132 133

	/* channel model */
134
	const struct hda_channel_mode *channel_mode;
L
Linus Torvalds 已提交
135
	int num_channel_mode;
136
	int need_dac_fix;
137 138
	int const_channel_count;
	int ext_channel_count;
L
Linus Torvalds 已提交
139 140

	/* PCM information */
141
	struct hda_pcm pcm_rec[3];	/* used in alc_build_pcms() */
142

143 144
	/* dynamic controls, init_verbs and input_mux */
	struct auto_pin_cfg autocfg;
145
	struct alc_customize_define cdefine;
146
	struct snd_array kctls;
147
	struct hda_input_mux private_imux[3];
148
	hda_nid_t private_dac_nids[AUTO_CFG_MAX_OUTS];
149 150
	hda_nid_t private_adc_nids[AUTO_CFG_MAX_OUTS];
	hda_nid_t private_capsrc_nids[AUTO_CFG_MAX_OUTS];
151 152 153
	hda_nid_t imux_pins[HDA_MAX_NUM_INPUTS];
	unsigned int dyn_adc_idx[HDA_MAX_NUM_INPUTS];
	int int_mic_idx, ext_mic_idx, dock_mic_idx; /* for auto-mic */
154

155 156 157
	/* hooks */
	void (*init_hook)(struct hda_codec *codec);
	void (*unsol_event)(struct hda_codec *codec, unsigned int res);
158
#ifdef CONFIG_SND_HDA_POWER_SAVE
159
	void (*power_hook)(struct hda_codec *codec);
160
#endif
161
	void (*shutup)(struct hda_codec *codec);
162

163 164
	/* for pin sensing */
	unsigned int jack_present: 1;
165
	unsigned int line_jack_present:1;
166
	unsigned int master_mute:1;
167
	unsigned int auto_mic:1;
168
	unsigned int auto_mic_valid_imux:1;	/* valid imux for auto-mic */
169
	unsigned int automute:1;	/* HP automute enabled */
170 171
	unsigned int detect_line:1;	/* Line-out detection enabled */
	unsigned int automute_lines:1;	/* automute line-out as well */
172
	unsigned int automute_hp_lo:1;	/* both HP and LO available */
173

174 175
	/* other flags */
	unsigned int no_analog :1; /* digital I/O only */
176
	unsigned int dyn_adc_switch:1; /* switch ADCs (for ALC275) */
177
	unsigned int single_input_src:1;
178
	unsigned int vol_in_capsrc:1; /* use capsrc volume (ADC has no vol) */
179 180 181

	/* auto-mute control */
	int automute_mode;
182
	hda_nid_t automute_mixer_nid[AUTO_CFG_MAX_OUTS];
183

184
	int init_amp;
185
	int codec_variant;	/* flag for other variants */
186

187 188
	/* for virtual master */
	hda_nid_t vmaster_nid;
189 190 191
#ifdef CONFIG_SND_HDA_POWER_SAVE
	struct hda_loopback_check loopback;
#endif
192 193 194 195

	/* for PLL fix */
	hda_nid_t pll_nid;
	unsigned int pll_coef_idx, pll_coef_bit;
196 197 198 199 200

	/* fix-up list */
	int fixup_id;
	const struct alc_fixup *fixup_list;
	const char *fixup_name;
201 202 203 204

	/* multi-io */
	int multi_ios;
	struct alc_multi_io multi_io[4];
205 206
};

207
#define ALC_MODEL_AUTO		0	/* common for all chips */
L
Linus Torvalds 已提交
208 209 210 211

/*
 * input MUX handling
 */
212 213
static int alc_mux_enum_info(struct snd_kcontrol *kcontrol,
			     struct snd_ctl_elem_info *uinfo)
L
Linus Torvalds 已提交
214 215 216
{
	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
	struct alc_spec *spec = codec->spec;
217 218 219
	unsigned int mux_idx = snd_ctl_get_ioffidx(kcontrol, &uinfo->id);
	if (mux_idx >= spec->num_mux_defs)
		mux_idx = 0;
220 221
	if (!spec->input_mux[mux_idx].num_items && mux_idx > 0)
		mux_idx = 0;
222
	return snd_hda_input_mux_info(&spec->input_mux[mux_idx], uinfo);
L
Linus Torvalds 已提交
223 224
}

225 226
static int alc_mux_enum_get(struct snd_kcontrol *kcontrol,
			    struct snd_ctl_elem_value *ucontrol)
L
Linus Torvalds 已提交
227 228 229 230 231 232 233 234 235
{
	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
	struct alc_spec *spec = codec->spec;
	unsigned int adc_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);

	ucontrol->value.enumerated.item[0] = spec->cur_mux[adc_idx];
	return 0;
}

236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255
static bool alc_dyn_adc_pcm_resetup(struct hda_codec *codec, int cur)
{
	struct alc_spec *spec = codec->spec;
	hda_nid_t new_adc = spec->adc_nids[spec->dyn_adc_idx[cur]];

	if (spec->cur_adc && spec->cur_adc != new_adc) {
		/* stream is running, let's swap the current ADC */
		__snd_hda_codec_cleanup_stream(codec, spec->cur_adc, 1);
		spec->cur_adc = new_adc;
		snd_hda_codec_setup_stream(codec, new_adc,
					   spec->cur_adc_stream_tag, 0,
					   spec->cur_adc_format);
		return true;
	}
	return false;
}

/* select the given imux item; either unmute exclusively or select the route */
static int alc_mux_select(struct hda_codec *codec, unsigned int adc_idx,
			  unsigned int idx, bool force)
L
Linus Torvalds 已提交
256 257
{
	struct alc_spec *spec = codec->spec;
258 259
	const struct hda_input_mux *imux;
	unsigned int mux_idx;
260 261
	int i, type;
	hda_nid_t nid;
L
Linus Torvalds 已提交
262

263 264
	mux_idx = adc_idx >= spec->num_mux_defs ? 0 : adc_idx;
	imux = &spec->input_mux[mux_idx];
265 266
	if (!imux->num_items && mux_idx > 0)
		imux = &spec->input_mux[0];
267

268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285
	if (idx >= imux->num_items)
		idx = imux->num_items - 1;
	if (spec->cur_mux[adc_idx] == idx && !force)
		return 0;
	spec->cur_mux[adc_idx] = idx;

	if (spec->dyn_adc_switch) {
		alc_dyn_adc_pcm_resetup(codec, idx);
		adc_idx = spec->dyn_adc_idx[idx];
	}

	nid = spec->capsrc_nids ?
		spec->capsrc_nids[adc_idx] : spec->adc_nids[adc_idx];

	/* no selection? */
	if (snd_hda_get_conn_list(codec, nid, NULL) <= 1)
		return 1;

286
	type = get_wcaps_type(get_wcaps(codec, nid));
287
	if (type == AC_WID_AUD_MIX) {
288 289 290 291 292 293 294 295 296
		/* Matrix-mixer style (e.g. ALC882) */
		for (i = 0; i < imux->num_items; i++) {
			unsigned int v = (i == idx) ? 0 : HDA_AMP_MUTE;
			snd_hda_codec_amp_stereo(codec, nid, HDA_INPUT,
						 imux->items[i].index,
						 HDA_AMP_MUTE, v);
		}
	} else {
		/* MUX style (e.g. ALC880) */
297 298 299
		snd_hda_codec_write_cache(codec, nid, 0,
					  AC_VERB_SET_CONNECT_SEL,
					  imux->items[idx].index);
300
	}
301 302 303 304 305 306 307 308 309 310
	return 1;
}

static int alc_mux_enum_put(struct snd_kcontrol *kcontrol,
			    struct snd_ctl_elem_value *ucontrol)
{
	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
	unsigned int adc_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
	return alc_mux_select(codec, adc_idx,
			      ucontrol->value.enumerated.item[0], false);
311
}
312

313 314 315 316 317 318 319 320
/*
 * set up the input pin config (depending on the given auto-pin type)
 */
static void alc_set_input_pin(struct hda_codec *codec, hda_nid_t nid,
			      int auto_pin_type)
{
	unsigned int val = PIN_IN;

321
	if (auto_pin_type == AUTO_PIN_MIC) {
322
		unsigned int pincap;
323 324 325
		unsigned int oldval;
		oldval = snd_hda_codec_read(codec, nid, 0,
					    AC_VERB_GET_PIN_WIDGET_CONTROL, 0);
T
Takashi Iwai 已提交
326
		pincap = snd_hda_query_pin_caps(codec, nid);
327
		pincap = (pincap & AC_PINCAP_VREF) >> AC_PINCAP_VREF_SHIFT;
328 329
		/* if the default pin setup is vref50, we give it priority */
		if ((pincap & AC_PINCAP_VREF_80) && oldval != PIN_VREF50)
330
			val = PIN_VREF80;
331 332 333 334 335 336
		else if (pincap & AC_PINCAP_VREF_50)
			val = PIN_VREF50;
		else if (pincap & AC_PINCAP_VREF_100)
			val = PIN_VREF100;
		else if (pincap & AC_PINCAP_VREF_GRD)
			val = PIN_VREFGRD;
337 338 339 340
	}
	snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_PIN_WIDGET_CONTROL, val);
}

341
/*
342 343 344
 * 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().
345
 */
346
static void add_mixer(struct alc_spec *spec, const struct snd_kcontrol_new *mix)
347 348 349 350 351 352 353 354 355 356 357 358 359
{
	if (snd_BUG_ON(spec->num_mixers >= ARRAY_SIZE(spec->mixers)))
		return;
	spec->mixers[spec->num_mixers++] = mix;
}

static void add_verb(struct alc_spec *spec, const struct hda_verb *verb)
{
	if (snd_BUG_ON(spec->num_init_verbs >= ARRAY_SIZE(spec->init_verbs)))
		return;
	spec->init_verbs[spec->num_init_verbs++] = verb;
}

360
/*
361
 * GPIO setup tables, used in initialization
362
 */
363
/* Enable GPIO mask and set output */
364
static const struct hda_verb alc_gpio1_init_verbs[] = {
365 366 367 368 369 370
	{0x01, AC_VERB_SET_GPIO_MASK, 0x01},
	{0x01, AC_VERB_SET_GPIO_DIRECTION, 0x01},
	{0x01, AC_VERB_SET_GPIO_DATA, 0x01},
	{ }
};

371
static const struct hda_verb alc_gpio2_init_verbs[] = {
372 373 374 375 376 377
	{0x01, AC_VERB_SET_GPIO_MASK, 0x02},
	{0x01, AC_VERB_SET_GPIO_DIRECTION, 0x02},
	{0x01, AC_VERB_SET_GPIO_DATA, 0x02},
	{ }
};

378
static const struct hda_verb alc_gpio3_init_verbs[] = {
379 380 381 382 383 384
	{0x01, AC_VERB_SET_GPIO_MASK, 0x03},
	{0x01, AC_VERB_SET_GPIO_DIRECTION, 0x03},
	{0x01, AC_VERB_SET_GPIO_DATA, 0x03},
	{ }
};

385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416
/*
 * 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);
}

417 418 419 420 421
/*
 * Jack-reporting via input-jack layer
 */

/* initialization of jacks; currently checks only a few known pins */
422 423
static int alc_init_jacks(struct hda_codec *codec)
{
424
#ifdef CONFIG_SND_HDA_INPUT_JACK
425 426 427
	struct alc_spec *spec = codec->spec;
	int err;
	unsigned int hp_nid = spec->autocfg.hp_pins[0];
428 429
	unsigned int mic_nid = spec->ext_mic_pin;
	unsigned int dock_nid = spec->dock_mic_pin;
430

431
	if (hp_nid) {
432 433
		err = snd_hda_input_jack_add(codec, hp_nid,
					     SND_JACK_HEADPHONE, NULL);
434 435
		if (err < 0)
			return err;
436
		snd_hda_input_jack_report(codec, hp_nid);
437
	}
438

439
	if (mic_nid) {
440 441
		err = snd_hda_input_jack_add(codec, mic_nid,
					     SND_JACK_MICROPHONE, NULL);
442 443
		if (err < 0)
			return err;
444
		snd_hda_input_jack_report(codec, mic_nid);
445
	}
446 447 448 449 450 451 452
	if (dock_nid) {
		err = snd_hda_input_jack_add(codec, dock_nid,
					     SND_JACK_MICROPHONE, NULL);
		if (err < 0)
			return err;
		snd_hda_input_jack_report(codec, dock_nid);
	}
453
#endif /* CONFIG_SND_HDA_INPUT_JACK */
454 455 456
	return 0;
}

457 458 459 460 461 462
/*
 * Jack detections for HP auto-mute and mic-switch
 */

/* check each pin in the given array; returns true if any of them is plugged */
static bool detect_jacks(struct hda_codec *codec, int num_pins, hda_nid_t *pins)
463
{
464
	int i, present = 0;
465

466 467
	for (i = 0; i < num_pins; i++) {
		hda_nid_t nid = pins[i];
468 469
		if (!nid)
			break;
470
		snd_hda_input_jack_report(codec, nid);
471
		present |= snd_hda_jack_detect(codec, nid);
472
	}
473 474
	return present;
}
475

476
/* standard HP/line-out auto-mute helper */
477
static void do_automute(struct hda_codec *codec, int num_pins, hda_nid_t *pins,
478
			bool mute, bool hp_out)
479 480 481
{
	struct alc_spec *spec = codec->spec;
	unsigned int mute_bits = mute ? HDA_AMP_MUTE : 0;
482
	unsigned int pin_bits = mute ? 0 : (hp_out ? PIN_HP : PIN_OUT);
483 484 485 486
	int i;

	for (i = 0; i < num_pins; i++) {
		hda_nid_t nid = pins[i];
487 488
		if (!nid)
			break;
489 490
		switch (spec->automute_mode) {
		case ALC_AUTOMUTE_PIN:
491
			snd_hda_codec_write(codec, nid, 0,
492 493
					    AC_VERB_SET_PIN_WIDGET_CONTROL,
					    pin_bits);
494 495
			break;
		case ALC_AUTOMUTE_AMP:
496
			snd_hda_codec_amp_stereo(codec, nid, HDA_OUTPUT, 0,
497
						 HDA_AMP_MUTE, mute_bits);
498 499 500 501 502 503
			break;
		case ALC_AUTOMUTE_MIXER:
			nid = spec->automute_mixer_nid[i];
			if (!nid)
				break;
			snd_hda_codec_amp_stereo(codec, nid, HDA_INPUT, 0,
504
						 HDA_AMP_MUTE, mute_bits);
505
			snd_hda_codec_amp_stereo(codec, nid, HDA_INPUT, 1,
506
						 HDA_AMP_MUTE, mute_bits);
507
			break;
508
		}
509
	}
510 511
}

512 513 514 515
/* Toggle internal speakers muting */
static void update_speakers(struct hda_codec *codec)
{
	struct alc_spec *spec = codec->spec;
516
	int on;
517

518 519 520 521 522 523 524
	/* Control HP pins/amps depending on master_mute state;
	 * in general, HP pins/amps control should be enabled in all cases,
	 * but currently set only for master_mute, just to be safe
	 */
	do_automute(codec, ARRAY_SIZE(spec->autocfg.hp_pins),
		    spec->autocfg.hp_pins, spec->master_mute, true);

525 526 527 528 529
	if (!spec->automute)
		on = 0;
	else
		on = spec->jack_present | spec->line_jack_present;
	on |= spec->master_mute;
530
	do_automute(codec, ARRAY_SIZE(spec->autocfg.speaker_pins),
531
		    spec->autocfg.speaker_pins, on, false);
532 533

	/* toggle line-out mutes if needed, too */
534 535 536
	/* if LO is a copy of either HP or Speaker, don't need to handle it */
	if (spec->autocfg.line_out_pins[0] == spec->autocfg.hp_pins[0] ||
	    spec->autocfg.line_out_pins[0] == spec->autocfg.speaker_pins[0])
537
		return;
538 539 540 541 542
	if (!spec->automute_lines || !spec->automute)
		on = 0;
	else
		on = spec->jack_present;
	on |= spec->master_mute;
543
	do_automute(codec, ARRAY_SIZE(spec->autocfg.line_out_pins),
544
		    spec->autocfg.line_out_pins, on, false);
545 546
}

547
/* standard HP-automute helper */
548 549 550 551 552 553 554 555 556 557 558 559
static void alc_hp_automute(struct hda_codec *codec)
{
	struct alc_spec *spec = codec->spec;

	if (!spec->automute)
		return;
	spec->jack_present =
		detect_jacks(codec, ARRAY_SIZE(spec->autocfg.hp_pins),
			     spec->autocfg.hp_pins);
	update_speakers(codec);
}

560
/* standard line-out-automute helper */
561 562 563 564 565 566 567 568 569 570 571 572
static void alc_line_automute(struct hda_codec *codec)
{
	struct alc_spec *spec = codec->spec;

	if (!spec->automute || !spec->detect_line)
		return;
	spec->line_jack_present =
		detect_jacks(codec, ARRAY_SIZE(spec->autocfg.line_out_pins),
			     spec->autocfg.line_out_pins);
	update_speakers(codec);
}

573 574
#define get_connection_index(codec, mux, nid) \
	snd_hda_get_conn_index(codec, mux, nid, 0)
575

576
/* standard mic auto-switch helper */
577 578 579
static void alc_mic_automute(struct hda_codec *codec)
{
	struct alc_spec *spec = codec->spec;
580
	hda_nid_t *pins = spec->imux_pins;
581

582
	if (!spec->auto_mic || !spec->auto_mic_valid_imux)
583 584 585
		return;
	if (snd_BUG_ON(!spec->adc_nids))
		return;
586
	if (snd_BUG_ON(spec->int_mic_idx < 0 || spec->ext_mic_idx < 0))
587
		return;
588

589 590 591 592 593 594 595
	if (snd_hda_jack_detect(codec, pins[spec->ext_mic_idx]))
		alc_mux_select(codec, 0, spec->ext_mic_idx, false);
	else if (spec->dock_mic_idx >= 0 &&
		   snd_hda_jack_detect(codec, pins[spec->dock_mic_idx]))
		alc_mux_select(codec, 0, spec->dock_mic_idx, false);
	else
		alc_mux_select(codec, 0, spec->int_mic_idx, false);
596

597 598 599
	snd_hda_input_jack_report(codec, pins[spec->ext_mic_idx]);
	if (spec->dock_mic_idx >= 0)
		snd_hda_input_jack_report(codec, pins[spec->dock_mic_idx]);
600 601
}

602 603 604 605 606 607 608
/* unsolicited event for HP jack sensing */
static void alc_sku_unsol_event(struct hda_codec *codec, unsigned int res)
{
	if (codec->vendor_id == 0x10ec0880)
		res >>= 28;
	else
		res >>= 26;
609
	switch (res) {
610
	case ALC_HP_EVENT:
611
		alc_hp_automute(codec);
612
		break;
613
	case ALC_FRONT_EVENT:
614 615
		alc_line_automute(codec);
		break;
616
	case ALC_MIC_EVENT:
617
		alc_mic_automute(codec);
618 619
		break;
	}
620 621
}

622
/* call init functions of standard auto-mute helpers */
623 624
static void alc_inithook(struct hda_codec *codec)
{
625
	alc_hp_automute(codec);
626
	alc_line_automute(codec);
627
	alc_mic_automute(codec);
628 629
}

630 631 632 633 634 635 636 637
/* 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);
638
	if ((tmp & 0xf0) == 0x20)
639 640 641 642 643 644 645 646 647
		/* 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);
}

648
/* additional initialization for ALC889 variants */
649 650 651 652 653 654 655 656 657 658
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);
}

659 660 661 662 663 664 665 666 667 668
/* 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);
}

669 670 671 672
/* 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 */
673 674 675 676 677 678
	static hda_nid_t pins[] = {
		0x0f, 0x10, 0x14, 0x15, 0
	};
	hda_nid_t *p;
	for (p = pins; *p; p++)
		set_eapd(codec, *p, on);
679 680
}

681 682 683 684 685 686 687 688 689
/* 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);
}

690
/* generic EAPD initialization */
691
static void alc_auto_init_amp(struct hda_codec *codec, int type)
692
{
693
	unsigned int tmp;
694

695
	alc_auto_setup_eapd(codec, true);
696 697
	switch (type) {
	case ALC_INIT_GPIO1:
698 699
		snd_hda_sequence_write(codec, alc_gpio1_init_verbs);
		break;
700
	case ALC_INIT_GPIO2:
701 702
		snd_hda_sequence_write(codec, alc_gpio2_init_verbs);
		break;
703
	case ALC_INIT_GPIO3:
704 705
		snd_hda_sequence_write(codec, alc_gpio3_init_verbs);
		break;
706
	case ALC_INIT_DEFAULT:
707 708 709 710 711 712 713 714 715 716 717 718 719 720 721 722 723
		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:
724
		case 0x10ec0887:
725
		/*case 0x10ec0889:*/ /* this causes an SPDIF problem */
726
			alc889_coef_init(codec);
727
			break;
728
		case 0x10ec0888:
729
			alc888_coef_init(codec);
730
			break;
731
#if 0 /* XXX: This may cause the silent output on speaker on some machines */
732 733 734 735 736 737 738
		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,
739
					    AC_VERB_SET_COEF_INDEX, 7);
740 741 742 743
			snd_hda_codec_write(codec, 0x20, 0,
					    AC_VERB_SET_PROC_COEF,
					    tmp | 0x3000);
			break;
744
#endif /* XXX */
745
		}
746 747 748 749
		break;
	}
}

750 751 752
/*
 * Auto-Mute mode mixer enum support
 */
753 754 755
static int alc_automute_mode_info(struct snd_kcontrol *kcontrol,
				  struct snd_ctl_elem_info *uinfo)
{
756 757 758 759 760 761
	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
	struct alc_spec *spec = codec->spec;
	static const char * const texts2[] = {
		"Disabled", "Enabled"
	};
	static const char * const texts3[] = {
762 763
		"Disabled", "Speaker Only", "Line-Out+Speaker"
	};
764
	const char * const *texts;
765 766 767

	uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
	uinfo->count = 1;
768 769 770 771 772 773 774 775 776
	if (spec->automute_hp_lo) {
		uinfo->value.enumerated.items = 3;
		texts = texts3;
	} else {
		uinfo->value.enumerated.items = 2;
		texts = texts2;
	}
	if (uinfo->value.enumerated.item >= uinfo->value.enumerated.items)
		uinfo->value.enumerated.item = uinfo->value.enumerated.items - 1;
777 778 779 780 781 782 783 784 785 786 787 788 789 790 791 792 793 794 795 796 797 798 799 800 801 802 803 804 805 806 807 808 809 810 811 812 813 814 815 816
	strcpy(uinfo->value.enumerated.name,
	       texts[uinfo->value.enumerated.item]);
	return 0;
}

static int alc_automute_mode_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;
	unsigned int val;
	if (!spec->automute)
		val = 0;
	else if (!spec->automute_lines)
		val = 1;
	else
		val = 2;
	ucontrol->value.enumerated.item[0] = val;
	return 0;
}

static int alc_automute_mode_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;

	switch (ucontrol->value.enumerated.item[0]) {
	case 0:
		if (!spec->automute)
			return 0;
		spec->automute = 0;
		break;
	case 1:
		if (spec->automute && !spec->automute_lines)
			return 0;
		spec->automute = 1;
		spec->automute_lines = 0;
		break;
	case 2:
817 818
		if (!spec->automute_hp_lo)
			return -EINVAL;
819 820 821 822 823 824 825 826 827 828 829 830
		if (spec->automute && spec->automute_lines)
			return 0;
		spec->automute = 1;
		spec->automute_lines = 1;
		break;
	default:
		return -EINVAL;
	}
	update_speakers(codec);
	return 1;
}

831
static const struct snd_kcontrol_new alc_automute_mode_enum = {
832 833 834 835 836 837 838
	.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
	.name = "Auto-Mute Mode",
	.info = alc_automute_mode_info,
	.get = alc_automute_mode_get,
	.put = alc_automute_mode_put,
};

839 840 841 842 843
static struct snd_kcontrol_new *alc_kcontrol_new(struct alc_spec *spec)
{
	snd_array_init(&spec->kctls, sizeof(struct snd_kcontrol_new), 32);
	return snd_array_new(&spec->kctls);
}
844 845 846 847 848 849 850 851 852 853 854 855 856 857 858 859

static int alc_add_automute_mode_enum(struct hda_codec *codec)
{
	struct alc_spec *spec = codec->spec;
	struct snd_kcontrol_new *knew;

	knew = alc_kcontrol_new(spec);
	if (!knew)
		return -ENOMEM;
	*knew = alc_automute_mode_enum;
	knew->name = kstrdup("Auto-Mute Mode", GFP_KERNEL);
	if (!knew->name)
		return -ENOMEM;
	return 0;
}

860 861 862 863
/*
 * Check the availability of HP/line-out auto-mute;
 * Set up appropriately if really supported
 */
864 865 866
static void alc_init_auto_hp(struct hda_codec *codec)
{
	struct alc_spec *spec = codec->spec;
867
	struct auto_pin_cfg *cfg = &spec->autocfg;
868
	int present = 0;
869
	int i;
870

871 872 873 874 875 876 877 878
	if (cfg->hp_pins[0])
		present++;
	if (cfg->line_out_pins[0])
		present++;
	if (cfg->speaker_pins[0])
		present++;
	if (present < 2) /* need two different output types */
		return;
879 880
	if (present == 3)
		spec->automute_hp_lo = 1; /* both HP and LO automute */
881

882 883 884 885 886 887 888 889 890 891
	if (!cfg->speaker_pins[0]) {
		memcpy(cfg->speaker_pins, cfg->line_out_pins,
		       sizeof(cfg->speaker_pins));
		cfg->speaker_outs = cfg->line_outs;
	}

	if (!cfg->hp_pins[0]) {
		memcpy(cfg->hp_pins, cfg->line_out_pins,
		       sizeof(cfg->hp_pins));
		cfg->hp_outs = cfg->line_outs;
892 893
	}

894
	for (i = 0; i < cfg->hp_outs; i++) {
895
		hda_nid_t nid = cfg->hp_pins[i];
896
		if (!is_jack_detectable(codec, nid))
897
			continue;
898
		snd_printdd("realtek: Enable HP auto-muting on NID 0x%x\n",
899 900
			    nid);
		snd_hda_codec_write_cache(codec, nid, 0,
901
				  AC_VERB_SET_UNSOLICITED_ENABLE,
902
				  AC_USRSP_EN | ALC_HP_EVENT);
903 904
		spec->automute = 1;
		spec->automute_mode = ALC_AUTOMUTE_PIN;
905
	}
906 907 908 909 910
	if (spec->automute && cfg->line_out_pins[0] &&
	    cfg->line_out_pins[0] != cfg->hp_pins[0] &&
	    cfg->line_out_pins[0] != cfg->speaker_pins[0]) {
		for (i = 0; i < cfg->line_outs; i++) {
			hda_nid_t nid = cfg->line_out_pins[i];
911
			if (!is_jack_detectable(codec, nid))
912 913 914 915 916
				continue;
			snd_printdd("realtek: Enable Line-Out auto-muting "
				    "on NID 0x%x\n", nid);
			snd_hda_codec_write_cache(codec, nid, 0,
					AC_VERB_SET_UNSOLICITED_ENABLE,
917
					AC_USRSP_EN | ALC_FRONT_EVENT);
918 919
			spec->detect_line = 1;
		}
920
		spec->automute_lines = spec->detect_line;
921 922 923
	}

	if (spec->automute) {
924 925
		/* create a control for automute mode */
		alc_add_automute_mode_enum(codec);
926
		spec->unsol_event = alc_sku_unsol_event;
927
	}
928 929
}

930
/* return the position of NID in the list, or -1 if not found */
931 932 933 934 935 936 937 938 939
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;
}

940 941 942 943 944 945 946 947 948 949 950 951 952 953 954 955 956 957 958 959 960 961 962 963 964 965 966 967 968 969 970 971 972 973 974 975 976 977 978 979 980
/* check whether dynamic ADC-switching is available */
static bool alc_check_dyn_adc_switch(struct hda_codec *codec)
{
	struct alc_spec *spec = codec->spec;
	struct hda_input_mux *imux = &spec->private_imux[0];
	int i, n, idx;
	hda_nid_t cap, pin;

	if (imux != spec->input_mux) /* no dynamic imux? */
		return false;

	for (n = 0; n < spec->num_adc_nids; n++) {
		cap = spec->private_capsrc_nids[n];
		for (i = 0; i < imux->num_items; i++) {
			pin = spec->imux_pins[i];
			if (!pin)
				return false;
			if (get_connection_index(codec, cap, pin) < 0)
				break;
		}
		if (i >= imux->num_items)
			return false; /* no ADC-switch is needed */
	}

	for (i = 0; i < imux->num_items; i++) {
		pin = spec->imux_pins[i];
		for (n = 0; n < spec->num_adc_nids; n++) {
			cap = spec->private_capsrc_nids[n];
			idx = get_connection_index(codec, cap, pin);
			if (idx >= 0) {
				imux->items[i].index = idx;
				spec->dyn_adc_idx[i] = n;
				break;
			}
		}
	}

	snd_printdd("realtek: enabling ADC switching\n");
	spec->dyn_adc_switch = 1;
	return true;
}
981 982 983 984 985 986 987 988 989 990 991 992 993 994 995 996 997 998 999 1000 1001 1002 1003 1004 1005 1006 1007 1008 1009 1010 1011 1012 1013 1014 1015 1016 1017 1018 1019 1020 1021 1022 1023 1024 1025 1026 1027 1028 1029 1030 1031 1032 1033 1034 1035 1036 1037 1038 1039 1040

/* rebuild imux for matching with the given auto-mic pins (if not yet) */
static bool alc_rebuild_imux_for_auto_mic(struct hda_codec *codec)
{
	struct alc_spec *spec = codec->spec;
	struct hda_input_mux *imux;
	static char * const texts[3] = {
		"Mic", "Internal Mic", "Dock Mic"
	};
	int i;

	if (!spec->auto_mic)
		return false;
	imux = &spec->private_imux[0];
	if (spec->input_mux == imux)
		return true;
	spec->imux_pins[0] = spec->ext_mic_pin;
	spec->imux_pins[1] = spec->int_mic_pin;
	spec->imux_pins[2] = spec->dock_mic_pin;
	for (i = 0; i < 3; i++) {
		strcpy(imux->items[i].label, texts[i]);
		if (spec->imux_pins[i])
			imux->num_items = i + 1;
	}
	spec->num_mux_defs = 1;
	spec->input_mux = imux;
	return true;
}

/* check whether all auto-mic pins are valid; setup indices if OK */
static bool alc_auto_mic_check_imux(struct hda_codec *codec)
{
	struct alc_spec *spec = codec->spec;
	const struct hda_input_mux *imux;

	if (!spec->auto_mic)
		return false;
	if (spec->auto_mic_valid_imux)
		return true; /* already checked */

	/* fill up imux indices */
	if (!alc_check_dyn_adc_switch(codec)) {
		spec->auto_mic = 0;
		return false;
	}

	imux = spec->input_mux;
	spec->ext_mic_idx = find_idx_in_nid_list(spec->ext_mic_pin,
					spec->imux_pins, imux->num_items);
	spec->int_mic_idx = find_idx_in_nid_list(spec->int_mic_pin,
					spec->imux_pins, imux->num_items);
	spec->dock_mic_idx = find_idx_in_nid_list(spec->dock_mic_pin,
					spec->imux_pins, imux->num_items);
	if (spec->ext_mic_idx < 0 || spec->int_mic_idx < 0) {
		spec->auto_mic = 0;
		return false; /* no corresponding imux */
	}

	snd_hda_codec_write_cache(codec, spec->ext_mic_pin, 0,
				  AC_VERB_SET_UNSOLICITED_ENABLE,
1041
				  AC_USRSP_EN | ALC_MIC_EVENT);
1042 1043 1044
	if (spec->dock_mic_pin)
		snd_hda_codec_write_cache(codec, spec->dock_mic_pin, 0,
				  AC_VERB_SET_UNSOLICITED_ENABLE,
1045
				  AC_USRSP_EN | ALC_MIC_EVENT);
1046 1047 1048 1049 1050 1051

	spec->auto_mic_valid_imux = 1;
	spec->auto_mic = 1;
	return true;
}

1052 1053 1054 1055
/*
 * Check the availability of auto-mic switch;
 * Set up if really supported
 */
1056 1057 1058 1059
static void alc_init_auto_mic(struct hda_codec *codec)
{
	struct alc_spec *spec = codec->spec;
	struct auto_pin_cfg *cfg = &spec->autocfg;
1060
	hda_nid_t fixed, ext, dock;
1061 1062
	int i;

1063 1064
	spec->ext_mic_idx = spec->int_mic_idx = spec->dock_mic_idx = -1;

1065
	fixed = ext = dock = 0;
1066 1067
	for (i = 0; i < cfg->num_inputs; i++) {
		hda_nid_t nid = cfg->inputs[i].pin;
1068 1069
		unsigned int defcfg;
		defcfg = snd_hda_codec_get_pincfg(codec, nid);
1070 1071
		switch (snd_hda_get_input_pin_attr(defcfg)) {
		case INPUT_PIN_ATTR_INT:
1072 1073
			if (fixed)
				return; /* already occupied */
1074 1075
			if (cfg->inputs[i].type != AUTO_PIN_MIC)
				return; /* invalid type */
1076 1077
			fixed = nid;
			break;
1078 1079
		case INPUT_PIN_ATTR_UNUSED:
			return; /* invalid entry */
1080 1081 1082 1083 1084 1085 1086
		case INPUT_PIN_ATTR_DOCK:
			if (dock)
				return; /* already occupied */
			if (cfg->inputs[i].type > AUTO_PIN_LINE_IN)
				return; /* invalid type */
			dock = nid;
			break;
1087
		default:
1088 1089
			if (ext)
				return; /* already occupied */
1090 1091
			if (cfg->inputs[i].type != AUTO_PIN_MIC)
				return; /* invalid type */
1092 1093 1094 1095
			ext = nid;
			break;
		}
	}
1096 1097 1098 1099
	if (!ext && dock) {
		ext = dock;
		dock = 0;
	}
1100 1101
	if (!ext || !fixed)
		return;
1102
	if (!is_jack_detectable(codec, ext))
1103
		return; /* no unsol support */
1104 1105
	if (dock && !is_jack_detectable(codec, dock))
		return; /* no unsol support */
1106 1107 1108 1109 1110 1111 1112 1113 1114 1115

	/* check imux indices */
	spec->ext_mic_pin = ext;
	spec->int_mic_pin = fixed;
	spec->dock_mic_pin = dock;

	spec->auto_mic = 1;
	if (!alc_auto_mic_check_imux(codec))
		return;

1116 1117
	snd_printdd("realtek: Enable auto-mic switch on NID 0x%x/0x%x/0x%x\n",
		    ext, fixed, dock);
1118 1119 1120
	spec->unsol_event = alc_sku_unsol_event;
}

1121 1122 1123 1124 1125 1126 1127 1128 1129 1130 1131
/* check the availabilities of auto-mute and auto-mic switches */
static void alc_auto_check_switches(struct hda_codec *codec)
{
	alc_init_auto_hp(codec);
	alc_init_auto_mic(codec);
}

/*
 * Realtek SSID verification
 */

1132 1133 1134 1135 1136
/* 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)

1137 1138 1139
static int alc_auto_parse_customize_define(struct hda_codec *codec)
{
	unsigned int ass, tmp, i;
1140
	unsigned nid = 0;
1141 1142
	struct alc_spec *spec = codec->spec;

1143 1144
	spec->cdefine.enable_pcbeep = 1; /* assume always enabled */

1145 1146 1147 1148 1149 1150 1151
	if (spec->cdefine.fixup) {
		ass = spec->cdefine.sku_cfg;
		if (ass == ALC_FIXUP_SKU_IGNORE)
			return -1;
		goto do_sku;
	}

1152
	ass = codec->subsystem_id & 0xffff;
1153
	if (ass != codec->bus->pci->subsystem_device && (ass & 1))
1154 1155 1156 1157 1158 1159 1160 1161 1162 1163 1164 1165 1166 1167 1168 1169 1170 1171 1172 1173 1174 1175 1176 1177 1178 1179 1180 1181 1182 1183 1184 1185 1186 1187 1188 1189 1190 1191 1192 1193 1194 1195 1196 1197 1198 1199 1200 1201
		goto do_sku;

	nid = 0x1d;
	if (codec->vendor_id == 0x10ec0260)
		nid = 0x17;
	ass = snd_hda_codec_get_pincfg(codec, nid);

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

	/* check sum */
	tmp = 0;
	for (i = 1; i < 16; i++) {
		if ((ass >> i) & 1)
			tmp++;
	}
	if (((ass >> 16) & 0xf) != tmp)
		return -1;

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

1202
/* return true if the given NID is found in the list */
1203 1204
static bool found_in_nid_list(hda_nid_t nid, const hda_nid_t *list, int nums)
{
1205
	return find_idx_in_nid_list(nid, list, nums) >= 0;
1206 1207
}

1208 1209 1210 1211 1212 1213 1214 1215 1216 1217 1218
/* 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,
1219
			    hda_nid_t portd, hda_nid_t porti)
1220 1221 1222 1223 1224
{
	unsigned int ass, tmp, i;
	unsigned nid;
	struct alc_spec *spec = codec->spec;

1225 1226 1227 1228 1229 1230 1231
	if (spec->cdefine.fixup) {
		ass = spec->cdefine.sku_cfg;
		if (ass == ALC_FIXUP_SKU_IGNORE)
			return 0;
		goto do_sku;
	}

1232 1233 1234 1235 1236 1237
	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 */
	/*
1238
	 * 31~30	: port connectivity
1239 1240 1241 1242 1243 1244 1245 1246 1247 1248 1249 1250
	 * 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",
1251
		   ass, nid);
1252
	if (!(ass & 1))
1253 1254 1255 1256 1257 1258 1259 1260 1261 1262 1263 1264 1265 1266 1267 1268 1269 1270 1271 1272 1273 1274 1275 1276 1277 1278 1279 1280 1281 1282 1283 1284 1285 1286
		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:
1287
	default:
1288
		spec->init_amp = ALC_INIT_DEFAULT;
1289 1290
		break;
	}
1291

1292
	/* is laptop or Desktop and enable the function "Mute internal speaker
1293 1294
	 * when the external headphone out jack is plugged"
	 */
1295
	if (!(ass & 0x8000))
1296
		return 1;
1297 1298 1299 1300 1301 1302 1303 1304
	/*
	 * 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"
	 */
	if (!spec->autocfg.hp_pins[0]) {
1305
		hda_nid_t nid;
1306 1307
		tmp = (ass >> 11) & 0x3;	/* HP to chassis */
		if (tmp == 0)
1308
			nid = porta;
1309
		else if (tmp == 1)
1310
			nid = porte;
1311
		else if (tmp == 2)
1312
			nid = portd;
1313 1314
		else if (tmp == 3)
			nid = porti;
1315
		else
1316
			return 1;
1317 1318 1319
		if (found_in_nid_list(nid, spec->autocfg.line_out_pins,
				      spec->autocfg.line_outs))
			return 1;
1320
		spec->autocfg.hp_pins[0] = nid;
1321
	}
1322 1323
	return 1;
}
1324

1325
static void alc_ssid_check(struct hda_codec *codec,
1326 1327
			   hda_nid_t porta, hda_nid_t porte,
			   hda_nid_t portd, hda_nid_t porti)
1328
{
1329
	if (!alc_subsystem_id(codec, porta, porte, portd, porti)) {
1330 1331 1332 1333 1334
		struct alc_spec *spec = codec->spec;
		snd_printd("realtek: "
			   "Enable default setup for auto mode as fallback\n");
		spec->init_amp = ALC_INIT_DEFAULT;
	}
1335
}
1336

1337
/*
1338
 * Fix-up pin default configurations and add default verbs
1339 1340 1341 1342 1343 1344 1345
 */

struct alc_pincfg {
	hda_nid_t nid;
	u32 val;
};

1346 1347 1348 1349 1350
struct alc_model_fixup {
	const int id;
	const char *name;
};

1351
struct alc_fixup {
1352
	int type;
1353 1354
	bool chained;
	int chain_id;
1355 1356 1357 1358 1359 1360 1361 1362
	union {
		unsigned int sku;
		const struct alc_pincfg *pins;
		const struct hda_verb *verbs;
		void (*func)(struct hda_codec *codec,
			     const struct alc_fixup *fix,
			     int action);
	} v;
1363 1364
};

1365 1366 1367 1368 1369 1370 1371 1372 1373 1374 1375
enum {
	ALC_FIXUP_INVALID,
	ALC_FIXUP_SKU,
	ALC_FIXUP_PINS,
	ALC_FIXUP_VERBS,
	ALC_FIXUP_FUNC,
};

enum {
	ALC_FIXUP_ACT_PRE_PROBE,
	ALC_FIXUP_ACT_PROBE,
1376
	ALC_FIXUP_ACT_INIT,
1377 1378 1379
};

static void alc_apply_fixup(struct hda_codec *codec, int action)
1380
{
1381 1382
	struct alc_spec *spec = codec->spec;
	int id = spec->fixup_id;
1383
#ifdef CONFIG_SND_DEBUG_VERBOSE
1384
	const char *modelname = spec->fixup_name;
1385
#endif
1386
	int depth = 0;
1387

1388 1389 1390 1391 1392 1393 1394 1395 1396 1397 1398 1399 1400 1401 1402 1403 1404 1405 1406 1407 1408 1409 1410 1411 1412 1413 1414 1415 1416 1417 1418 1419 1420 1421 1422 1423 1424 1425 1426 1427 1428 1429 1430 1431 1432 1433 1434 1435 1436 1437
	if (!spec->fixup_list)
		return;

	while (id >= 0) {
		const struct alc_fixup *fix = spec->fixup_list + id;
		const struct alc_pincfg *cfg;

		switch (fix->type) {
		case ALC_FIXUP_SKU:
			if (action != ALC_FIXUP_ACT_PRE_PROBE || !fix->v.sku)
				break;;
			snd_printdd(KERN_INFO "hda_codec: %s: "
				    "Apply sku override for %s\n",
				    codec->chip_name, modelname);
			spec->cdefine.sku_cfg = fix->v.sku;
			spec->cdefine.fixup = 1;
			break;
		case ALC_FIXUP_PINS:
			cfg = fix->v.pins;
			if (action != ALC_FIXUP_ACT_PRE_PROBE || !cfg)
				break;
			snd_printdd(KERN_INFO "hda_codec: %s: "
				    "Apply pincfg for %s\n",
				    codec->chip_name, modelname);
			for (; cfg->nid; cfg++)
				snd_hda_codec_set_pincfg(codec, cfg->nid,
							 cfg->val);
			break;
		case ALC_FIXUP_VERBS:
			if (action != ALC_FIXUP_ACT_PROBE || !fix->v.verbs)
				break;
			snd_printdd(KERN_INFO "hda_codec: %s: "
				    "Apply fix-verbs for %s\n",
				    codec->chip_name, modelname);
			add_verb(codec->spec, fix->v.verbs);
			break;
		case ALC_FIXUP_FUNC:
			if (!fix->v.func)
				break;
			snd_printdd(KERN_INFO "hda_codec: %s: "
				    "Apply fix-func for %s\n",
				    codec->chip_name, modelname);
			fix->v.func(codec, fix, action);
			break;
		default:
			snd_printk(KERN_ERR "hda_codec: %s: "
				   "Invalid fixup type %d\n",
				   codec->chip_name, fix->type);
			break;
		}
1438
		if (!fix->chained)
1439 1440 1441
			break;
		if (++depth > 10)
			break;
1442
		id = fix->chain_id;
1443
	}
1444 1445
}

1446
static void alc_pick_fixup(struct hda_codec *codec,
1447 1448 1449
			   const struct alc_model_fixup *models,
			   const struct snd_pci_quirk *quirk,
			   const struct alc_fixup *fixlist)
1450
{
1451 1452 1453
	struct alc_spec *spec = codec->spec;
	int id = -1;
	const char *name = NULL;
1454 1455 1456 1457

	if (codec->modelname && models) {
		while (models->name) {
			if (!strcmp(codec->modelname, models->name)) {
1458 1459
				id = models->id;
				name = models->name;
1460 1461 1462 1463
				break;
			}
			models++;
		}
1464 1465 1466 1467 1468 1469 1470 1471 1472 1473 1474 1475 1476 1477 1478
	}
	if (id < 0) {
		quirk = snd_pci_quirk_lookup(codec->bus->pci, quirk);
		if (quirk) {
			id = quirk->value;
#ifdef CONFIG_SND_DEBUG_VERBOSE
			name = quirk->name;
#endif
		}
	}

	spec->fixup_id = id;
	if (id >= 0) {
		spec->fixup_list = fixlist;
		spec->fixup_name = name;
1479
	}
1480 1481
}

1482 1483 1484
/*
 * COEF access helper functions
 */
1485 1486 1487 1488 1489 1490 1491 1492 1493 1494 1495
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;
}

1496 1497 1498 1499 1500 1501 1502 1503 1504
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);
}

1505 1506 1507 1508
/*
 * Digital I/O handling
 */

1509 1510 1511 1512 1513
/* set right pin controls for digital I/O */
static void alc_auto_init_digital(struct hda_codec *codec)
{
	struct alc_spec *spec = codec->spec;
	int i;
1514
	hda_nid_t pin, dac;
1515 1516 1517

	for (i = 0; i < spec->autocfg.dig_outs; i++) {
		pin = spec->autocfg.dig_out_pins[i];
1518 1519 1520 1521 1522 1523 1524 1525 1526 1527 1528 1529 1530
		if (!pin)
			continue;
		snd_hda_codec_write(codec, pin, 0,
				    AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT);
		if (!i)
			dac = spec->multiout.dig_out_nid;
		else
			dac = spec->slave_dig_outs[i - 1];
		if (!dac || !(get_wcaps(codec, dac) & AC_WCAP_OUT_AMP))
			continue;
		snd_hda_codec_write(codec, dac, 0,
				    AC_VERB_SET_AMP_GAIN_MUTE,
				    AMP_OUT_UNMUTE);
1531 1532 1533 1534 1535 1536 1537 1538 1539 1540 1541 1542 1543 1544 1545 1546 1547
	}
	pin = spec->autocfg.dig_in_pin;
	if (pin)
		snd_hda_codec_write(codec, pin, 0,
				    AC_VERB_SET_PIN_WIDGET_CONTROL,
				    PIN_IN);
}

/* parse digital I/Os and set up NIDs in BIOS auto-parse mode */
static void alc_auto_parse_digital(struct hda_codec *codec)
{
	struct alc_spec *spec = codec->spec;
	int i, err;
	hda_nid_t dig_nid;

	/* support multiple SPDIFs; the secondary is set up as a slave */
	for (i = 0; i < spec->autocfg.dig_outs; i++) {
1548
		hda_nid_t conn[4];
1549 1550
		err = snd_hda_get_connections(codec,
					      spec->autocfg.dig_out_pins[i],
1551
					      conn, ARRAY_SIZE(conn));
1552 1553
		if (err < 0)
			continue;
1554
		dig_nid = conn[0]; /* assume the first element is audio-out */
1555 1556 1557 1558 1559 1560 1561 1562 1563 1564 1565 1566
		if (!i) {
			spec->multiout.dig_out_nid = dig_nid;
			spec->dig_out_type = spec->autocfg.dig_out_type[0];
		} else {
			spec->multiout.slave_dig_outs = spec->slave_dig_outs;
			if (i >= ARRAY_SIZE(spec->slave_dig_outs) - 1)
				break;
			spec->slave_dig_outs[i - 1] = dig_nid;
		}
	}

	if (spec->autocfg.dig_in_pin) {
1567 1568 1569 1570 1571 1572 1573 1574 1575 1576 1577 1578 1579 1580 1581 1582
		dig_nid = codec->start_nid;
		for (i = 0; i < codec->num_nodes; i++, dig_nid++) {
			unsigned int wcaps = get_wcaps(codec, dig_nid);
			if (get_wcaps_type(wcaps) != AC_WID_AUD_IN)
				continue;
			if (!(wcaps & AC_WCAP_DIGITAL))
				continue;
			if (!(wcaps & AC_WCAP_CONN_LIST))
				continue;
			err = get_connection_index(codec, dig_nid,
						   spec->autocfg.dig_in_pin);
			if (err >= 0) {
				spec->dig_in_nid = dig_nid;
				break;
			}
		}
1583 1584 1585
	}
}

1586
/*
1587
 * capture mixer elements
1588
 */
1589 1590 1591 1592 1593
static int alc_cap_vol_info(struct snd_kcontrol *kcontrol,
			    struct snd_ctl_elem_info *uinfo)
{
	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
	struct alc_spec *spec = codec->spec;
1594
	unsigned long val;
1595
	int err;
L
Linus Torvalds 已提交
1596

1597
	mutex_lock(&codec->control_mutex);
1598 1599 1600 1601 1602
	if (spec->vol_in_capsrc)
		val = HDA_COMPOSE_AMP_VAL(spec->capsrc_nids[0], 3, 0, HDA_OUTPUT);
	else
		val = HDA_COMPOSE_AMP_VAL(spec->adc_nids[0], 3, 0, HDA_INPUT);
	kcontrol->private_value = val;
1603
	err = snd_hda_mixer_amp_volume_info(kcontrol, uinfo);
1604
	mutex_unlock(&codec->control_mutex);
1605 1606 1607 1608 1609 1610 1611 1612
	return err;
}

static int alc_cap_vol_tlv(struct snd_kcontrol *kcontrol, int op_flag,
			   unsigned int size, unsigned int __user *tlv)
{
	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
	struct alc_spec *spec = codec->spec;
1613
	unsigned long val;
1614
	int err;
L
Linus Torvalds 已提交
1615

1616
	mutex_lock(&codec->control_mutex);
1617 1618 1619 1620 1621
	if (spec->vol_in_capsrc)
		val = HDA_COMPOSE_AMP_VAL(spec->capsrc_nids[0], 3, 0, HDA_OUTPUT);
	else
		val = HDA_COMPOSE_AMP_VAL(spec->adc_nids[0], 3, 0, HDA_INPUT);
	kcontrol->private_value = val;
1622
	err = snd_hda_mixer_amp_tlv(kcontrol, op_flag, size, tlv);
1623
	mutex_unlock(&codec->control_mutex);
1624 1625 1626 1627 1628 1629 1630 1631
	return err;
}

typedef int (*getput_call_t)(struct snd_kcontrol *kcontrol,
			     struct snd_ctl_elem_value *ucontrol);

static int alc_cap_getput_caller(struct snd_kcontrol *kcontrol,
				 struct snd_ctl_elem_value *ucontrol,
1632
				 getput_call_t func, bool check_adc_switch)
1633 1634 1635
{
	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
	struct alc_spec *spec = codec->spec;
1636
	int i, err = 0;
1637

1638
	mutex_lock(&codec->control_mutex);
1639
	if (check_adc_switch && spec->dyn_adc_switch) {
1640 1641 1642 1643 1644 1645 1646 1647 1648 1649
		for (i = 0; i < spec->num_adc_nids; i++) {
			kcontrol->private_value =
				HDA_COMPOSE_AMP_VAL(spec->adc_nids[i],
						    3, 0, HDA_INPUT);
			err = func(kcontrol, ucontrol);
			if (err < 0)
				goto error;
		}
	} else {
		i = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
1650 1651 1652 1653 1654 1655
		if (spec->vol_in_capsrc)
			kcontrol->private_value =
				HDA_COMPOSE_AMP_VAL(spec->capsrc_nids[i],
						    3, 0, HDA_OUTPUT);
		else
			kcontrol->private_value =
1656 1657
				HDA_COMPOSE_AMP_VAL(spec->adc_nids[i],
						    3, 0, HDA_INPUT);
1658 1659 1660
		err = func(kcontrol, ucontrol);
	}
 error:
1661
	mutex_unlock(&codec->control_mutex);
1662 1663 1664 1665 1666 1667 1668
	return err;
}

static int alc_cap_vol_get(struct snd_kcontrol *kcontrol,
			   struct snd_ctl_elem_value *ucontrol)
{
	return alc_cap_getput_caller(kcontrol, ucontrol,
1669
				     snd_hda_mixer_amp_volume_get, false);
1670 1671 1672 1673 1674 1675
}

static int alc_cap_vol_put(struct snd_kcontrol *kcontrol,
			   struct snd_ctl_elem_value *ucontrol)
{
	return alc_cap_getput_caller(kcontrol, ucontrol,
1676
				     snd_hda_mixer_amp_volume_put, true);
1677 1678 1679 1680 1681 1682 1683 1684 1685
}

/* capture mixer elements */
#define alc_cap_sw_info		snd_ctl_boolean_stereo_info

static int alc_cap_sw_get(struct snd_kcontrol *kcontrol,
			  struct snd_ctl_elem_value *ucontrol)
{
	return alc_cap_getput_caller(kcontrol, ucontrol,
1686
				     snd_hda_mixer_amp_switch_get, false);
1687 1688 1689 1690 1691 1692
}

static int alc_cap_sw_put(struct snd_kcontrol *kcontrol,
			  struct snd_ctl_elem_value *ucontrol)
{
	return alc_cap_getput_caller(kcontrol, ucontrol,
1693
				     snd_hda_mixer_amp_switch_put, true);
1694 1695
}

1696
#define _DEFINE_CAPMIX(num) \
1697 1698 1699 1700 1701 1702 1703 1704 1705 1706 1707 1708 1709 1710 1711 1712 1713 1714 1715 1716
	{ \
		.iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
		.name = "Capture Switch", \
		.access = SNDRV_CTL_ELEM_ACCESS_READWRITE, \
		.count = num, \
		.info = alc_cap_sw_info, \
		.get = alc_cap_sw_get, \
		.put = alc_cap_sw_put, \
	}, \
	{ \
		.iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
		.name = "Capture Volume", \
		.access = (SNDRV_CTL_ELEM_ACCESS_READWRITE | \
			   SNDRV_CTL_ELEM_ACCESS_TLV_READ | \
			   SNDRV_CTL_ELEM_ACCESS_TLV_CALLBACK), \
		.count = num, \
		.info = alc_cap_vol_info, \
		.get = alc_cap_vol_get, \
		.put = alc_cap_vol_put, \
		.tlv = { .c = alc_cap_vol_tlv }, \
1717 1718 1719
	}

#define _DEFINE_CAPSRC(num) \
1720 1721 1722 1723 1724 1725 1726 1727
	{ \
		.iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
		/* .name = "Capture Source", */ \
		.name = "Input Source", \
		.count = num, \
		.info = alc_mux_enum_info, \
		.get = alc_mux_enum_get, \
		.put = alc_mux_enum_put, \
1728 1729 1730
	}

#define DEFINE_CAPMIX(num) \
1731
static const struct snd_kcontrol_new alc_capture_mixer ## num[] = { \
1732 1733 1734 1735 1736 1737
	_DEFINE_CAPMIX(num),				      \
	_DEFINE_CAPSRC(num),				      \
	{ } /* end */					      \
}

#define DEFINE_CAPMIX_NOSRC(num) \
1738
static const struct snd_kcontrol_new alc_capture_mixer_nosrc ## num[] = { \
1739 1740
	_DEFINE_CAPMIX(num),					    \
	{ } /* end */						    \
1741 1742 1743 1744 1745 1746
}

/* up to three ADCs */
DEFINE_CAPMIX(1);
DEFINE_CAPMIX(2);
DEFINE_CAPMIX(3);
1747 1748 1749
DEFINE_CAPMIX_NOSRC(1);
DEFINE_CAPMIX_NOSRC(2);
DEFINE_CAPMIX_NOSRC(3);
1750 1751

/*
1752
 * virtual master controls
1753 1754 1755
 */

/*
1756
 * slave controls for virtual master
1757
 */
1758 1759 1760 1761 1762 1763 1764 1765 1766 1767 1768
static const char * const alc_slave_vols[] = {
	"Front Playback Volume",
	"Surround Playback Volume",
	"Center Playback Volume",
	"LFE Playback Volume",
	"Side Playback Volume",
	"Headphone Playback Volume",
	"Speaker Playback Volume",
	"Mono Playback Volume",
	"Line-Out Playback Volume",
	NULL,
1769 1770
};

1771 1772 1773 1774 1775 1776 1777 1778 1779 1780 1781 1782
static const char * const alc_slave_sws[] = {
	"Front Playback Switch",
	"Surround Playback Switch",
	"Center Playback Switch",
	"LFE Playback Switch",
	"Side Playback Switch",
	"Headphone Playback Switch",
	"Speaker Playback Switch",
	"Mono Playback Switch",
	"IEC958 Playback Switch",
	"Line-Out Playback Switch",
	NULL,
1783 1784
};

1785
/*
1786
 * build control elements
1787 1788
 */

1789
#define NID_MAPPING		(-1)
1790

1791 1792 1793 1794 1795 1796
#define SUBDEV_SPEAKER_		(0 << 6)
#define SUBDEV_HP_		(1 << 6)
#define SUBDEV_LINE_		(2 << 6)
#define SUBDEV_SPEAKER(x)	(SUBDEV_SPEAKER_ | ((x) & 0x3f))
#define SUBDEV_HP(x)		(SUBDEV_HP_ | ((x) & 0x3f))
#define SUBDEV_LINE(x)		(SUBDEV_LINE_ | ((x) & 0x3f))
1797

1798
static void alc_free_kctls(struct hda_codec *codec);
1799

1800 1801 1802 1803 1804
#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),
1805 1806
	{ } /* end */
};
1807
#endif
1808

1809 1810 1811 1812 1813 1814 1815 1816
static int alc_build_controls(struct hda_codec *codec)
{
	struct alc_spec *spec = codec->spec;
	struct snd_kcontrol *kctl = NULL;
	const struct snd_kcontrol_new *knew;
	int i, j, err;
	unsigned int u;
	hda_nid_t nid;
L
Linus Torvalds 已提交
1817 1818 1819 1820 1821 1822

	for (i = 0; i < spec->num_mixers; i++) {
		err = snd_hda_add_new_ctls(codec, spec->mixers[i]);
		if (err < 0)
			return err;
	}
1823 1824 1825 1826 1827
	if (spec->cap_mixer) {
		err = snd_hda_add_new_ctls(codec, spec->cap_mixer);
		if (err < 0)
			return err;
	}
L
Linus Torvalds 已提交
1828
	if (spec->multiout.dig_out_nid) {
1829
		err = snd_hda_create_spdif_out_ctls(codec,
1830
						    spec->multiout.dig_out_nid,
1831
						    spec->multiout.dig_out_nid);
L
Linus Torvalds 已提交
1832 1833
		if (err < 0)
			return err;
1834 1835 1836 1837 1838 1839 1840
		if (!spec->no_analog) {
			err = snd_hda_create_spdif_share_sw(codec,
							    &spec->multiout);
			if (err < 0)
				return err;
			spec->multiout.share_spdif = 1;
		}
L
Linus Torvalds 已提交
1841 1842 1843 1844 1845 1846
	}
	if (spec->dig_in_nid) {
		err = snd_hda_create_spdif_in_ctls(codec, spec->dig_in_nid);
		if (err < 0)
			return err;
	}
1847

1848
#ifdef CONFIG_SND_HDA_INPUT_BEEP
1849 1850
	/* create beep controls if needed */
	if (spec->beep_amp) {
1851
		const struct snd_kcontrol_new *knew;
1852 1853 1854 1855 1856 1857
		for (knew = alc_beep_mixer; knew->name; knew++) {
			struct snd_kcontrol *kctl;
			kctl = snd_ctl_new1(knew, codec);
			if (!kctl)
				return -ENOMEM;
			kctl->private_value = spec->beep_amp;
1858
			err = snd_hda_ctl_add(codec, 0, kctl);
1859 1860 1861 1862
			if (err < 0)
				return err;
		}
	}
1863
#endif
1864

1865
	/* if we have no master control, let's create it */
1866 1867
	if (!spec->no_analog &&
	    !snd_hda_find_mixer_ctl(codec, "Master Playback Volume")) {
1868
		unsigned int vmaster_tlv[4];
1869
		snd_hda_set_vmaster_tlv(codec, spec->vmaster_nid,
1870
					HDA_OUTPUT, vmaster_tlv);
1871
		err = snd_hda_add_vmaster(codec, "Master Playback Volume",
1872
					  vmaster_tlv, alc_slave_vols);
1873 1874 1875
		if (err < 0)
			return err;
	}
1876 1877
	if (!spec->no_analog &&
	    !snd_hda_find_mixer_ctl(codec, "Master Playback Switch")) {
1878 1879 1880 1881 1882 1883
		err = snd_hda_add_vmaster(codec, "Master Playback Switch",
					  NULL, alc_slave_sws);
		if (err < 0)
			return err;
	}

1884
	/* assign Capture Source enums to NID */
1885 1886 1887 1888 1889
	if (spec->capsrc_nids || spec->adc_nids) {
		kctl = snd_hda_find_mixer_ctl(codec, "Capture Source");
		if (!kctl)
			kctl = snd_hda_find_mixer_ctl(codec, "Input Source");
		for (i = 0; kctl && i < kctl->count; i++) {
1890
			const hda_nid_t *nids = spec->capsrc_nids;
1891 1892 1893 1894 1895 1896
			if (!nids)
				nids = spec->adc_nids;
			err = snd_hda_add_nid(codec, kctl, i, nids[i]);
			if (err < 0)
				return err;
		}
1897 1898 1899 1900 1901 1902 1903 1904 1905 1906 1907 1908 1909 1910 1911 1912 1913 1914 1915 1916 1917 1918 1919 1920 1921 1922 1923 1924 1925 1926 1927 1928 1929 1930 1931 1932 1933 1934 1935 1936 1937 1938 1939 1940 1941 1942 1943 1944 1945 1946 1947 1948 1949 1950 1951 1952 1953
	}
	if (spec->cap_mixer) {
		const char *kname = kctl ? kctl->id.name : NULL;
		for (knew = spec->cap_mixer; knew->name; knew++) {
			if (kname && strcmp(knew->name, kname) == 0)
				continue;
			kctl = snd_hda_find_mixer_ctl(codec, knew->name);
			for (i = 0; kctl && i < kctl->count; i++) {
				err = snd_hda_add_nid(codec, kctl, i,
						      spec->adc_nids[i]);
				if (err < 0)
					return err;
			}
		}
	}

	/* other nid->control mapping */
	for (i = 0; i < spec->num_mixers; i++) {
		for (knew = spec->mixers[i]; knew->name; knew++) {
			if (knew->iface != NID_MAPPING)
				continue;
			kctl = snd_hda_find_mixer_ctl(codec, knew->name);
			if (kctl == NULL)
				continue;
			u = knew->subdevice;
			for (j = 0; j < 4; j++, u >>= 8) {
				nid = u & 0x3f;
				if (nid == 0)
					continue;
				switch (u & 0xc0) {
				case SUBDEV_SPEAKER_:
					nid = spec->autocfg.speaker_pins[nid];
					break;
				case SUBDEV_LINE_:
					nid = spec->autocfg.line_out_pins[nid];
					break;
				case SUBDEV_HP_:
					nid = spec->autocfg.hp_pins[nid];
					break;
				default:
					continue;
				}
				err = snd_hda_add_nid(codec, kctl, 0, nid);
				if (err < 0)
					return err;
			}
			u = knew->private_value;
			for (j = 0; j < 4; j++, u >>= 8) {
				nid = u & 0xff;
				if (nid == 0)
					continue;
				err = snd_hda_add_nid(codec, kctl, 0, nid);
				if (err < 0)
					return err;
			}
		}
	}
1954 1955 1956

	alc_free_kctls(codec); /* no longer needed */

L
Linus Torvalds 已提交
1957 1958 1959
	return 0;
}

1960

L
Linus Torvalds 已提交
1961
/*
1962
 * Common callbacks
1963
 */
L
Linus Torvalds 已提交
1964

1965
static void alc_init_special_input_src(struct hda_codec *codec);
L
Linus Torvalds 已提交
1966

1967 1968 1969 1970
static int alc_init(struct hda_codec *codec)
{
	struct alc_spec *spec = codec->spec;
	unsigned int i;
L
Linus Torvalds 已提交
1971

1972 1973
	alc_fix_pll(codec);
	alc_auto_init_amp(codec, spec->init_amp);
L
Linus Torvalds 已提交
1974

1975 1976 1977
	for (i = 0; i < spec->num_init_verbs; i++)
		snd_hda_sequence_write(codec, spec->init_verbs[i]);
	alc_init_special_input_src(codec);
T
Takashi Iwai 已提交
1978

1979 1980
	if (spec->init_hook)
		spec->init_hook(codec);
1981

1982
	alc_apply_fixup(codec, ALC_FIXUP_ACT_INIT);
1983

1984 1985 1986
	hda_call_check_power_status(codec, 0x01);
	return 0;
}
1987

1988 1989 1990
static void alc_unsol_event(struct hda_codec *codec, unsigned int res)
{
	struct alc_spec *spec = codec->spec;
1991

1992 1993 1994
	if (spec->unsol_event)
		spec->unsol_event(codec, res);
}
1995

1996 1997 1998 1999 2000 2001 2002
#ifdef CONFIG_SND_HDA_POWER_SAVE
static int alc_check_power_status(struct hda_codec *codec, hda_nid_t nid)
{
	struct alc_spec *spec = codec->spec;
	return snd_hda_check_amp_list_power(codec, &spec->loopback, nid);
}
#endif
2003 2004

/*
2005
 * Analog playback callbacks
2006
 */
2007 2008 2009
static int alc_playback_pcm_open(struct hda_pcm_stream *hinfo,
				    struct hda_codec *codec,
				    struct snd_pcm_substream *substream)
2010
{
2011 2012 2013
	struct alc_spec *spec = codec->spec;
	return snd_hda_multi_out_analog_open(codec, &spec->multiout, substream,
					     hinfo);
2014 2015
}

2016 2017 2018 2019 2020
static int alc_playback_pcm_prepare(struct hda_pcm_stream *hinfo,
				       struct hda_codec *codec,
				       unsigned int stream_tag,
				       unsigned int format,
				       struct snd_pcm_substream *substream)
2021
{
2022
	struct alc_spec *spec = codec->spec;
2023 2024
	return snd_hda_multi_out_analog_prepare(codec, &spec->multiout,
						stream_tag, format, substream);
2025 2026
}

2027 2028 2029
static int alc_playback_pcm_cleanup(struct hda_pcm_stream *hinfo,
				       struct hda_codec *codec,
				       struct snd_pcm_substream *substream)
2030
{
2031 2032
	struct alc_spec *spec = codec->spec;
	return snd_hda_multi_out_analog_cleanup(codec, &spec->multiout);
2033 2034
}

2035 2036 2037 2038 2039 2040
/*
 * Digital out
 */
static int alc_dig_playback_pcm_open(struct hda_pcm_stream *hinfo,
					struct hda_codec *codec,
					struct snd_pcm_substream *substream)
2041
{
2042 2043
	struct alc_spec *spec = codec->spec;
	return snd_hda_multi_out_dig_open(codec, &spec->multiout);
2044 2045
}

2046 2047 2048 2049 2050
static int alc_dig_playback_pcm_prepare(struct hda_pcm_stream *hinfo,
					   struct hda_codec *codec,
					   unsigned int stream_tag,
					   unsigned int format,
					   struct snd_pcm_substream *substream)
2051
{
2052
	struct alc_spec *spec = codec->spec;
2053 2054
	return snd_hda_multi_out_dig_prepare(codec, &spec->multiout,
					     stream_tag, format, substream);
2055 2056
}

2057 2058 2059
static int alc_dig_playback_pcm_cleanup(struct hda_pcm_stream *hinfo,
					   struct hda_codec *codec,
					   struct snd_pcm_substream *substream)
2060
{
2061 2062
	struct alc_spec *spec = codec->spec;
	return snd_hda_multi_out_dig_cleanup(codec, &spec->multiout);
2063
}
2064

2065 2066 2067
static int alc_dig_playback_pcm_close(struct hda_pcm_stream *hinfo,
					 struct hda_codec *codec,
					 struct snd_pcm_substream *substream)
2068
{
2069 2070
	struct alc_spec *spec = codec->spec;
	return snd_hda_multi_out_dig_close(codec, &spec->multiout);
2071 2072
}

2073
/*
2074
 * Analog capture
2075
 */
2076 2077 2078 2079 2080 2081 2082
static int alc_alt_capture_pcm_prepare(struct hda_pcm_stream *hinfo,
				      struct hda_codec *codec,
				      unsigned int stream_tag,
				      unsigned int format,
				      struct snd_pcm_substream *substream)
{
	struct alc_spec *spec = codec->spec;
L
Linus Torvalds 已提交
2083

2084
	snd_hda_codec_setup_stream(codec, spec->adc_nids[substream->number + 1],
L
Linus Torvalds 已提交
2085 2086 2087 2088
				   stream_tag, 0, format);
	return 0;
}

2089
static int alc_alt_capture_pcm_cleanup(struct hda_pcm_stream *hinfo,
L
Linus Torvalds 已提交
2090
				      struct hda_codec *codec,
2091
				      struct snd_pcm_substream *substream)
L
Linus Torvalds 已提交
2092 2093 2094
{
	struct alc_spec *spec = codec->spec;

2095 2096
	snd_hda_codec_cleanup_stream(codec,
				     spec->adc_nids[substream->number + 1]);
L
Linus Torvalds 已提交
2097 2098 2099
	return 0;
}

2100
/* analog capture with dynamic dual-adc changes */
2101
static int dyn_adc_capture_pcm_prepare(struct hda_pcm_stream *hinfo,
2102 2103 2104 2105 2106 2107
				       struct hda_codec *codec,
				       unsigned int stream_tag,
				       unsigned int format,
				       struct snd_pcm_substream *substream)
{
	struct alc_spec *spec = codec->spec;
2108
	spec->cur_adc = spec->adc_nids[spec->dyn_adc_idx[spec->cur_mux[0]]];
2109 2110 2111 2112 2113 2114
	spec->cur_adc_stream_tag = stream_tag;
	spec->cur_adc_format = format;
	snd_hda_codec_setup_stream(codec, spec->cur_adc, stream_tag, 0, format);
	return 0;
}

2115
static int dyn_adc_capture_pcm_cleanup(struct hda_pcm_stream *hinfo,
2116 2117 2118 2119 2120 2121 2122 2123 2124
				       struct hda_codec *codec,
				       struct snd_pcm_substream *substream)
{
	struct alc_spec *spec = codec->spec;
	snd_hda_codec_cleanup_stream(codec, spec->cur_adc);
	spec->cur_adc = 0;
	return 0;
}

2125
static const struct hda_pcm_stream dyn_adc_pcm_analog_capture = {
2126 2127 2128 2129 2130
	.substreams = 1,
	.channels_min = 2,
	.channels_max = 2,
	.nid = 0, /* fill later */
	.ops = {
2131 2132
		.prepare = dyn_adc_capture_pcm_prepare,
		.cleanup = dyn_adc_capture_pcm_cleanup
2133 2134
	},
};
L
Linus Torvalds 已提交
2135 2136 2137

/*
 */
2138
static const struct hda_pcm_stream alc_pcm_analog_playback = {
L
Linus Torvalds 已提交
2139 2140 2141
	.substreams = 1,
	.channels_min = 2,
	.channels_max = 8,
2142
	/* NID is set in alc_build_pcms */
L
Linus Torvalds 已提交
2143
	.ops = {
2144 2145 2146
		.open = alc_playback_pcm_open,
		.prepare = alc_playback_pcm_prepare,
		.cleanup = alc_playback_pcm_cleanup
L
Linus Torvalds 已提交
2147 2148 2149
	},
};

2150
static const struct hda_pcm_stream alc_pcm_analog_capture = {
2151 2152 2153 2154 2155 2156
	.substreams = 1,
	.channels_min = 2,
	.channels_max = 2,
	/* NID is set in alc_build_pcms */
};

2157
static const struct hda_pcm_stream alc_pcm_analog_alt_playback = {
2158 2159 2160 2161 2162 2163
	.substreams = 1,
	.channels_min = 2,
	.channels_max = 2,
	/* NID is set in alc_build_pcms */
};

2164
static const struct hda_pcm_stream alc_pcm_analog_alt_capture = {
2165
	.substreams = 2, /* can be overridden */
L
Linus Torvalds 已提交
2166 2167
	.channels_min = 2,
	.channels_max = 2,
2168
	/* NID is set in alc_build_pcms */
L
Linus Torvalds 已提交
2169
	.ops = {
2170 2171
		.prepare = alc_alt_capture_pcm_prepare,
		.cleanup = alc_alt_capture_pcm_cleanup
L
Linus Torvalds 已提交
2172 2173 2174
	},
};

2175
static const struct hda_pcm_stream alc_pcm_digital_playback = {
L
Linus Torvalds 已提交
2176 2177 2178 2179 2180
	.substreams = 1,
	.channels_min = 2,
	.channels_max = 2,
	/* NID is set in alc_build_pcms */
	.ops = {
2181 2182 2183 2184
		.open = alc_dig_playback_pcm_open,
		.close = alc_dig_playback_pcm_close,
		.prepare = alc_dig_playback_pcm_prepare,
		.cleanup = alc_dig_playback_pcm_cleanup
L
Linus Torvalds 已提交
2185 2186 2187
	},
};

2188
static const struct hda_pcm_stream alc_pcm_digital_capture = {
L
Linus Torvalds 已提交
2189 2190 2191 2192 2193 2194
	.substreams = 1,
	.channels_min = 2,
	.channels_max = 2,
	/* NID is set in alc_build_pcms */
};

2195
/* Used by alc_build_pcms to flag that a PCM has no playback stream */
2196
static const struct hda_pcm_stream alc_pcm_null_stream = {
2197 2198 2199 2200 2201
	.substreams = 0,
	.channels_min = 0,
	.channels_max = 0,
};

L
Linus Torvalds 已提交
2202 2203 2204 2205
static int alc_build_pcms(struct hda_codec *codec)
{
	struct alc_spec *spec = codec->spec;
	struct hda_pcm *info = spec->pcm_rec;
2206
	const struct hda_pcm_stream *p;
L
Linus Torvalds 已提交
2207 2208 2209 2210 2211
	int i;

	codec->num_pcms = 1;
	codec->pcm_info = info;

2212 2213 2214
	if (spec->no_analog)
		goto skip_analog;

2215 2216
	snprintf(spec->stream_name_analog, sizeof(spec->stream_name_analog),
		 "%s Analog", codec->chip_name);
L
Linus Torvalds 已提交
2217
	info->name = spec->stream_name_analog;
2218

2219 2220 2221 2222 2223
	if (spec->multiout.dac_nids > 0) {
		p = spec->stream_analog_playback;
		if (!p)
			p = &alc_pcm_analog_playback;
		info->stream[SNDRV_PCM_STREAM_PLAYBACK] = *p;
2224 2225
		info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = spec->multiout.dac_nids[0];
	}
2226 2227
	if (spec->adc_nids) {
		p = spec->stream_analog_capture;
2228 2229 2230 2231 2232 2233
		if (!p) {
			if (spec->dyn_adc_switch)
				p = &dyn_adc_pcm_analog_capture;
			else
				p = &alc_pcm_analog_capture;
		}
2234
		info->stream[SNDRV_PCM_STREAM_CAPTURE] = *p;
2235 2236 2237 2238 2239 2240 2241 2242 2243
		info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = spec->adc_nids[0];
	}

	if (spec->channel_mode) {
		info->stream[SNDRV_PCM_STREAM_PLAYBACK].channels_max = 0;
		for (i = 0; i < spec->num_channel_mode; i++) {
			if (spec->channel_mode[i].channels > info->stream[SNDRV_PCM_STREAM_PLAYBACK].channels_max) {
				info->stream[SNDRV_PCM_STREAM_PLAYBACK].channels_max = spec->channel_mode[i].channels;
			}
L
Linus Torvalds 已提交
2244 2245 2246
		}
	}

2247
 skip_analog:
2248
	/* SPDIF for stream index #1 */
L
Linus Torvalds 已提交
2249
	if (spec->multiout.dig_out_nid || spec->dig_in_nid) {
2250 2251 2252
		snprintf(spec->stream_name_digital,
			 sizeof(spec->stream_name_digital),
			 "%s Digital", codec->chip_name);
2253
		codec->num_pcms = 2;
2254
	        codec->slave_dig_outs = spec->multiout.slave_dig_outs;
2255
		info = spec->pcm_rec + 1;
L
Linus Torvalds 已提交
2256
		info->name = spec->stream_name_digital;
2257 2258 2259 2260
		if (spec->dig_out_type)
			info->pcm_type = spec->dig_out_type;
		else
			info->pcm_type = HDA_PCM_TYPE_SPDIF;
2261 2262 2263 2264 2265
		if (spec->multiout.dig_out_nid) {
			p = spec->stream_digital_playback;
			if (!p)
				p = &alc_pcm_digital_playback;
			info->stream[SNDRV_PCM_STREAM_PLAYBACK] = *p;
L
Linus Torvalds 已提交
2266 2267
			info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = spec->multiout.dig_out_nid;
		}
2268 2269 2270 2271 2272
		if (spec->dig_in_nid) {
			p = spec->stream_digital_capture;
			if (!p)
				p = &alc_pcm_digital_capture;
			info->stream[SNDRV_PCM_STREAM_CAPTURE] = *p;
L
Linus Torvalds 已提交
2273 2274
			info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = spec->dig_in_nid;
		}
2275 2276
		/* FIXME: do we need this for all Realtek codec models? */
		codec->spdif_status_reset = 1;
L
Linus Torvalds 已提交
2277 2278
	}

2279 2280 2281
	if (spec->no_analog)
		return 0;

2282 2283 2284 2285
	/* If the use of more than one ADC is requested for the current
	 * model, configure a second analog capture-only PCM.
	 */
	/* Additional Analaog capture for index #2 */
2286
	if (spec->alt_dac_nid || spec->num_adc_nids > 1) {
2287
		codec->num_pcms = 3;
2288
		info = spec->pcm_rec + 2;
2289
		info->name = spec->stream_name_analog;
2290
		if (spec->alt_dac_nid) {
2291 2292 2293 2294
			p = spec->stream_analog_alt_playback;
			if (!p)
				p = &alc_pcm_analog_alt_playback;
			info->stream[SNDRV_PCM_STREAM_PLAYBACK] = *p;
2295 2296 2297 2298 2299 2300 2301
			info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid =
				spec->alt_dac_nid;
		} else {
			info->stream[SNDRV_PCM_STREAM_PLAYBACK] =
				alc_pcm_null_stream;
			info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = 0;
		}
2302 2303 2304 2305 2306
		if (spec->num_adc_nids > 1) {
			p = spec->stream_analog_alt_capture;
			if (!p)
				p = &alc_pcm_analog_alt_capture;
			info->stream[SNDRV_PCM_STREAM_CAPTURE] = *p;
2307 2308 2309 2310 2311 2312 2313 2314
			info->stream[SNDRV_PCM_STREAM_CAPTURE].nid =
				spec->adc_nids[1];
			info->stream[SNDRV_PCM_STREAM_CAPTURE].substreams =
				spec->num_adc_nids - 1;
		} else {
			info->stream[SNDRV_PCM_STREAM_CAPTURE] =
				alc_pcm_null_stream;
			info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = 0;
2315 2316 2317
		}
	}

L
Linus Torvalds 已提交
2318 2319 2320
	return 0;
}

2321 2322
static inline void alc_shutup(struct hda_codec *codec)
{
2323 2324 2325 2326
	struct alc_spec *spec = codec->spec;

	if (spec && spec->shutup)
		spec->shutup(codec);
2327 2328 2329
	snd_hda_shutup_pins(codec);
}

2330 2331 2332 2333 2334 2335 2336 2337 2338 2339 2340 2341 2342
static void alc_free_kctls(struct hda_codec *codec)
{
	struct alc_spec *spec = codec->spec;

	if (spec->kctls.list) {
		struct snd_kcontrol_new *kctl = spec->kctls.list;
		int i;
		for (i = 0; i < spec->kctls.used; i++)
			kfree(kctl[i].name);
	}
	snd_array_free(&spec->kctls);
}

L
Linus Torvalds 已提交
2343 2344
static void alc_free(struct hda_codec *codec)
{
2345 2346
	struct alc_spec *spec = codec->spec;

2347
	if (!spec)
2348 2349
		return;

2350
	alc_shutup(codec);
2351
	snd_hda_input_jack_free(codec);
2352
	alc_free_kctls(codec);
2353
	kfree(spec);
2354
	snd_hda_detach_beep_device(codec);
L
Linus Torvalds 已提交
2355 2356
}

2357
#ifdef CONFIG_SND_HDA_POWER_SAVE
2358 2359
static void alc_power_eapd(struct hda_codec *codec)
{
2360
	alc_auto_setup_eapd(codec, false);
2361 2362
}

2363 2364 2365
static int alc_suspend(struct hda_codec *codec, pm_message_t state)
{
	struct alc_spec *spec = codec->spec;
2366
	alc_shutup(codec);
2367
	if (spec && spec->power_hook)
2368
		spec->power_hook(codec);
2369 2370 2371 2372
	return 0;
}
#endif

2373 2374 2375
#ifdef SND_HDA_NEEDS_RESUME
static int alc_resume(struct hda_codec *codec)
{
2376
	msleep(150); /* to avoid pop noise */
2377 2378 2379
	codec->patch_ops.init(codec);
	snd_hda_codec_resume_amp(codec);
	snd_hda_codec_resume_cache(codec);
2380
	hda_call_check_power_status(codec, 0x01);
2381 2382 2383 2384
	return 0;
}
#endif

L
Linus Torvalds 已提交
2385 2386
/*
 */
2387
static const struct hda_codec_ops alc_patch_ops = {
L
Linus Torvalds 已提交
2388 2389 2390 2391
	.build_controls = alc_build_controls,
	.build_pcms = alc_build_pcms,
	.init = alc_init,
	.free = alc_free,
2392
	.unsol_event = alc_unsol_event,
2393 2394 2395
#ifdef SND_HDA_NEEDS_RESUME
	.resume = alc_resume,
#endif
2396
#ifdef CONFIG_SND_HDA_POWER_SAVE
2397
	.suspend = alc_suspend,
2398 2399
	.check_power_status = alc_check_power_status,
#endif
2400
	.reboot_notify = alc_shutup,
L
Linus Torvalds 已提交
2401 2402
};

2403 2404 2405 2406 2407 2408 2409 2410 2411 2412 2413 2414
/* replace the codec chip_name with the given string */
static int alc_codec_rename(struct hda_codec *codec, const char *name)
{
	kfree(codec->chip_name);
	codec->chip_name = kstrdup(name, GFP_KERNEL);
	if (!codec->chip_name) {
		alc_free(codec);
		return -ENOMEM;
	}
	return 0;
}

2415
/*
2416
 * Automatic parse of I/O pins from the BIOS configuration
2417 2418
 */

2419 2420 2421 2422
enum {
	ALC_CTL_WIDGET_VOL,
	ALC_CTL_WIDGET_MUTE,
	ALC_CTL_BIND_MUTE,
2423
};
2424 2425 2426 2427
static const struct snd_kcontrol_new alc_control_templates[] = {
	HDA_CODEC_VOLUME(NULL, 0, 0, 0),
	HDA_CODEC_MUTE(NULL, 0, 0, 0),
	HDA_BIND_MUTE(NULL, 0, 0, 0),
2428 2429
};

2430 2431 2432
/* add dynamic controls */
static int add_control(struct alc_spec *spec, int type, const char *name,
		       int cidx, unsigned long val)
2433
{
2434
	struct snd_kcontrol_new *knew;
2435

2436
	knew = alc_kcontrol_new(spec);
2437 2438
	if (!knew)
		return -ENOMEM;
2439
	*knew = alc_control_templates[type];
2440
	knew->name = kstrdup(name, GFP_KERNEL);
2441
	if (!knew->name)
2442
		return -ENOMEM;
2443
	knew->index = cidx;
2444
	if (get_amp_nid_(val))
2445
		knew->subdevice = HDA_SUBDEV_AMP_FLAG;
2446 2447 2448 2449
	knew->private_value = val;
	return 0;
}

2450 2451
static int add_control_with_pfx(struct alc_spec *spec, int type,
				const char *pfx, const char *dir,
2452
				const char *sfx, int cidx, unsigned long val)
2453 2454 2455
{
	char name[32];
	snprintf(name, sizeof(name), "%s %s %s", pfx, dir, sfx);
2456
	return add_control(spec, type, name, cidx, val);
2457 2458
}

2459 2460 2461 2462 2463 2464 2465 2466
#define add_pb_vol_ctrl(spec, type, pfx, val)			\
	add_control_with_pfx(spec, type, pfx, "Playback", "Volume", 0, val)
#define add_pb_sw_ctrl(spec, type, pfx, val)			\
	add_control_with_pfx(spec, type, pfx, "Playback", "Switch", 0, val)
#define __add_pb_vol_ctrl(spec, type, pfx, cidx, val)			\
	add_control_with_pfx(spec, type, pfx, "Playback", "Volume", cidx, val)
#define __add_pb_sw_ctrl(spec, type, pfx, cidx, val)			\
	add_control_with_pfx(spec, type, pfx, "Playback", "Switch", cidx, val)
2467

2468 2469
static const char *alc_get_line_out_pfx(struct alc_spec *spec, int ch,
					bool can_be_master, int *index)
2470
{
2471
	struct auto_pin_cfg *cfg = &spec->autocfg;
2472 2473 2474
	static const char * const chname[4] = {
		"Front", "Surround", NULL /*CLFE*/, "Side"
	};
2475

2476
	*index = 0;
2477 2478
	if (cfg->line_outs == 1 && !spec->multi_ios &&
	    !cfg->hp_outs && !cfg->speaker_outs && can_be_master)
2479 2480 2481 2482
		return "Master";

	switch (cfg->line_out_type) {
	case AUTO_PIN_SPEAKER_OUT:
2483 2484 2485
		if (cfg->line_outs == 1)
			return "Speaker";
		break;
2486
	case AUTO_PIN_HP_OUT:
2487 2488 2489 2490
		/* for multi-io case, only the primary out */
		if (ch && spec->multi_ios)
			break;
		*index = ch;
2491 2492
		return "Headphone";
	default:
2493
		if (cfg->line_outs == 1 && !spec->multi_ios)
2494 2495 2496
			return "PCM";
		break;
	}
2497
	return chname[ch];
2498 2499
}

2500
/* create input playback/capture controls for the given pin */
2501
static int new_analog_input(struct alc_spec *spec, hda_nid_t pin,
2502
			    const char *ctlname, int ctlidx,
2503
			    int idx, hda_nid_t mix_nid)
2504
{
2505
	int err;
2506

2507
	err = __add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL, ctlname, ctlidx,
2508 2509
			  HDA_COMPOSE_AMP_VAL(mix_nid, 3, idx, HDA_INPUT));
	if (err < 0)
2510
		return err;
2511
	err = __add_pb_sw_ctrl(spec, ALC_CTL_WIDGET_MUTE, ctlname, ctlidx,
2512 2513
			  HDA_COMPOSE_AMP_VAL(mix_nid, 3, idx, HDA_INPUT));
	if (err < 0)
2514 2515 2516 2517
		return err;
	return 0;
}

2518 2519 2520 2521 2522 2523
static int alc_is_input_pin(struct hda_codec *codec, hda_nid_t nid)
{
	unsigned int pincap = snd_hda_query_pin_caps(codec, nid);
	return (pincap & AC_PINCAP_IN) != 0;
}

2524
/* Parse the codec tree and retrieve ADCs and corresponding capsrc MUXs */
2525
static int alc_auto_fill_adc_caps(struct hda_codec *codec)
2526
{
2527
	struct alc_spec *spec = codec->spec;
2528
	hda_nid_t nid;
2529 2530 2531 2532
	hda_nid_t *adc_nids = spec->private_adc_nids;
	hda_nid_t *cap_nids = spec->private_capsrc_nids;
	int max_nums = ARRAY_SIZE(spec->private_adc_nids);
	bool indep_capsrc = false;
2533 2534 2535 2536 2537 2538 2539 2540 2541 2542 2543 2544 2545 2546 2547 2548 2549 2550 2551 2552 2553
	int i, nums = 0;

	nid = codec->start_nid;
	for (i = 0; i < codec->num_nodes; i++, nid++) {
		hda_nid_t src;
		const hda_nid_t *list;
		unsigned int caps = get_wcaps(codec, nid);
		int type = get_wcaps_type(caps);

		if (type != AC_WID_AUD_IN || (caps & AC_WCAP_DIGITAL))
			continue;
		adc_nids[nums] = nid;
		cap_nids[nums] = nid;
		src = nid;
		for (;;) {
			int n;
			type = get_wcaps_type(get_wcaps(codec, src));
			if (type == AC_WID_PIN)
				break;
			if (type == AC_WID_AUD_SEL) {
				cap_nids[nums] = src;
2554
				indep_capsrc = true;
2555 2556 2557 2558 2559
				break;
			}
			n = snd_hda_get_conn_list(codec, src, &list);
			if (n > 1) {
				cap_nids[nums] = src;
2560
				indep_capsrc = true;
2561 2562 2563 2564 2565 2566 2567 2568
				break;
			} else if (n != 1)
				break;
			src = *list;
		}
		if (++nums >= max_nums)
			break;
	}
2569
	spec->adc_nids = spec->private_adc_nids;
2570
	spec->capsrc_nids = spec->private_capsrc_nids;
2571
	spec->num_adc_nids = nums;
2572 2573 2574
	return nums;
}

2575
/* create playback/capture controls for input pins */
2576
static int alc_auto_create_input_ctls(struct hda_codec *codec)
2577
{
2578
	struct alc_spec *spec = codec->spec;
2579 2580
	const struct auto_pin_cfg *cfg = &spec->autocfg;
	hda_nid_t mixer = spec->mixer_nid;
2581
	struct hda_input_mux *imux = &spec->private_imux[0];
2582 2583
	int num_adcs;
	int i, c, err, idx, type_idx = 0;
2584
	const char *prev_label = NULL;
2585

2586
	num_adcs = alc_auto_fill_adc_caps(codec);
2587 2588 2589
	if (num_adcs < 0)
		return 0;

2590
	for (i = 0; i < cfg->num_inputs; i++) {
2591
		hda_nid_t pin;
2592
		const char *label;
2593

2594
		pin = cfg->inputs[i].pin;
2595 2596 2597
		if (!alc_is_input_pin(codec, pin))
			continue;

2598 2599
		label = hda_get_autocfg_input_label(codec, cfg, i);
		if (prev_label && !strcmp(label, prev_label))
2600 2601 2602
			type_idx++;
		else
			type_idx = 0;
2603 2604
		prev_label = label;

2605 2606 2607 2608
		if (mixer) {
			idx = get_connection_index(codec, mixer, pin);
			if (idx >= 0) {
				err = new_analog_input(spec, pin,
2609 2610
						       label, type_idx,
						       idx, mixer);
2611 2612 2613 2614 2615
				if (err < 0)
					return err;
			}
		}

2616
		for (c = 0; c < num_adcs; c++) {
2617 2618 2619
			hda_nid_t cap = spec->capsrc_nids ?
				spec->capsrc_nids[c] : spec->adc_nids[c];
			idx = get_connection_index(codec, cap, pin);
2620
			if (idx >= 0) {
2621
				spec->imux_pins[imux->num_items] = pin;
2622 2623 2624 2625
				snd_hda_add_imux_item(imux, label, idx, NULL);
				break;
			}
		}
2626
	}
2627 2628 2629 2630

	spec->num_mux_defs = 1;
	spec->input_mux = imux;

2631 2632 2633
	return 0;
}

2634 2635 2636 2637 2638 2639
static void alc_set_pin_output(struct hda_codec *codec, hda_nid_t nid,
			       unsigned int pin_type)
{
	snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
			    pin_type);
	/* unmute pin */
2640 2641
	snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_AMP_GAIN_MUTE,
			    AMP_OUT_UNMUTE);
2642 2643
}

2644 2645 2646 2647 2648 2649 2650 2651
static int get_pin_type(int line_out_type)
{
	if (line_out_type == AUTO_PIN_HP_OUT)
		return PIN_HP;
	else
		return PIN_OUT;
}

2652
static void alc_auto_init_analog_input(struct hda_codec *codec)
2653 2654
{
	struct alc_spec *spec = codec->spec;
2655
	struct auto_pin_cfg *cfg = &spec->autocfg;
2656 2657
	int i;

2658 2659
	for (i = 0; i < cfg->num_inputs; i++) {
		hda_nid_t nid = cfg->inputs[i].pin;
2660
		if (alc_is_input_pin(codec, nid)) {
2661
			alc_set_input_pin(codec, nid, cfg->inputs[i].type);
2662
			if (get_wcaps(codec, nid) & AC_WCAP_OUT_AMP)
2663 2664
				snd_hda_codec_write(codec, nid, 0,
						    AC_VERB_SET_AMP_GAIN_MUTE,
2665 2666 2667
						    AMP_OUT_MUTE);
		}
	}
2668 2669 2670 2671 2672 2673 2674 2675 2676

	/* mute all loopback inputs */
	if (spec->mixer_nid) {
		int nums = snd_hda_get_conn_list(codec, spec->mixer_nid, NULL);
		for (i = 0; i < nums; i++)
			snd_hda_codec_write(codec, spec->mixer_nid, 0,
					    AC_VERB_SET_AMP_GAIN_MUTE,
					    AMP_IN_MUTE(i));
	}
2677 2678
}

2679 2680
/* convert from MIX nid to DAC */
static hda_nid_t alc_auto_mix_to_dac(struct hda_codec *codec, hda_nid_t nid)
2681
{
2682 2683
	hda_nid_t list[5];
	int i, num;
2684

2685 2686
	if (get_wcaps_type(get_wcaps(codec, nid)) == AC_WID_AUD_OUT)
		return nid;
2687 2688 2689 2690 2691 2692
	num = snd_hda_get_connections(codec, nid, list, ARRAY_SIZE(list));
	for (i = 0; i < num; i++) {
		if (get_wcaps_type(get_wcaps(codec, list[i])) == AC_WID_AUD_OUT)
			return list[i];
	}
	return 0;
2693 2694
}

2695 2696
/* go down to the selector widget before the mixer */
static hda_nid_t alc_go_down_to_selector(struct hda_codec *codec, hda_nid_t pin)
2697
{
2698 2699 2700 2701 2702 2703 2704
	hda_nid_t srcs[5];
	int num = snd_hda_get_connections(codec, pin, srcs,
					  ARRAY_SIZE(srcs));
	if (num != 1 ||
	    get_wcaps_type(get_wcaps(codec, srcs[0])) != AC_WID_AUD_SEL)
		return pin;
	return srcs[0];
2705 2706
}

2707 2708 2709
/* get MIX nid connected to the given pin targeted to DAC */
static hda_nid_t alc_auto_dac_to_mix(struct hda_codec *codec, hda_nid_t pin,
				   hda_nid_t dac)
2710
{
2711 2712 2713 2714 2715 2716 2717 2718
	hda_nid_t mix[5];
	int i, num;

	pin = alc_go_down_to_selector(codec, pin);
	num = snd_hda_get_connections(codec, pin, mix, ARRAY_SIZE(mix));
	for (i = 0; i < num; i++) {
		if (alc_auto_mix_to_dac(codec, mix[i]) == dac)
			return mix[i];
2719
	}
2720
	return 0;
2721 2722
}

2723 2724 2725
/* select the connection from pin to DAC if needed */
static int alc_auto_select_dac(struct hda_codec *codec, hda_nid_t pin,
			       hda_nid_t dac)
2726
{
2727 2728
	hda_nid_t mix[5];
	int i, num;
2729

2730 2731 2732
	pin = alc_go_down_to_selector(codec, pin);
	num = snd_hda_get_connections(codec, pin, mix, ARRAY_SIZE(mix));
	if (num < 2)
2733
		return 0;
2734 2735 2736 2737 2738 2739
	for (i = 0; i < num; i++) {
		if (alc_auto_mix_to_dac(codec, mix[i]) == dac) {
			snd_hda_codec_update_cache(codec, pin, 0,
						   AC_VERB_SET_CONNECT_SEL, i);
			return 0;
		}
2740
	}
2741
	return 0;
2742 2743
}

2744 2745
/* look for an empty DAC slot */
static hda_nid_t alc_auto_look_for_dac(struct hda_codec *codec, hda_nid_t pin)
2746 2747
{
	struct alc_spec *spec = codec->spec;
2748 2749
	hda_nid_t srcs[5];
	int i, num;
2750

2751 2752 2753 2754 2755 2756 2757 2758 2759 2760 2761 2762 2763 2764 2765 2766 2767
	pin = alc_go_down_to_selector(codec, pin);
	num = snd_hda_get_connections(codec, pin, srcs, ARRAY_SIZE(srcs));
	for (i = 0; i < num; i++) {
		hda_nid_t nid = alc_auto_mix_to_dac(codec, srcs[i]);
		if (!nid)
			continue;
		if (found_in_nid_list(nid, spec->multiout.dac_nids,
				      spec->multiout.num_dacs))
			continue;
		if (spec->multiout.hp_nid == nid)
			continue;
		if (found_in_nid_list(nid, spec->multiout.extra_out_nid,
				      ARRAY_SIZE(spec->multiout.extra_out_nid)))
		    continue;
		return nid;
	}
	return 0;
2768 2769
}

2770
static hda_nid_t get_dac_if_single(struct hda_codec *codec, hda_nid_t pin)
2771
{
2772 2773 2774 2775
	hda_nid_t sel = alc_go_down_to_selector(codec, pin);
	if (snd_hda_get_conn_list(codec, sel, NULL) == 1)
		return alc_auto_look_for_dac(codec, pin);
	return 0;
2776 2777
}

2778 2779
/* fill in the dac_nids table from the parsed pin configuration */
static int alc_auto_fill_dac_nids(struct hda_codec *codec)
2780 2781
{
	struct alc_spec *spec = codec->spec;
2782 2783 2784
	const struct auto_pin_cfg *cfg = &spec->autocfg;
	bool redone = false;
	int i;
2785

2786 2787 2788 2789 2790 2791
 again:
	spec->multiout.num_dacs = 0;
	spec->multiout.hp_nid = 0;
	spec->multiout.extra_out_nid[0] = 0;
	memset(spec->private_dac_nids, 0, sizeof(spec->private_dac_nids));
	spec->multiout.dac_nids = spec->private_dac_nids;
2792

2793 2794 2795 2796 2797 2798 2799 2800 2801 2802 2803
	/* fill hard-wired DACs first */
	if (!redone) {
		for (i = 0; i < cfg->line_outs; i++)
			spec->private_dac_nids[i] =
				get_dac_if_single(codec, cfg->line_out_pins[i]);
		if (cfg->hp_outs)
			spec->multiout.hp_nid =
				get_dac_if_single(codec, cfg->hp_pins[0]);
		if (cfg->speaker_outs)
			spec->multiout.extra_out_nid[0] =
				get_dac_if_single(codec, cfg->speaker_pins[0]);
2804 2805
	}

2806 2807 2808 2809 2810 2811 2812 2813 2814 2815 2816
	for (i = 0; i < cfg->line_outs; i++) {
		hda_nid_t pin = cfg->line_out_pins[i];
		if (spec->private_dac_nids[i])
			continue;
		spec->private_dac_nids[i] = alc_auto_look_for_dac(codec, pin);
		if (!spec->private_dac_nids[i] && !redone) {
			/* if we can't find primary DACs, re-probe without
			 * checking the hard-wired DACs
			 */
			redone = true;
			goto again;
2817 2818 2819
		}
	}

2820 2821 2822 2823 2824 2825 2826 2827 2828 2829 2830 2831 2832 2833 2834 2835 2836
	for (i = 0; i < cfg->line_outs; i++) {
		if (spec->private_dac_nids[i])
			spec->multiout.num_dacs++;
		else
			memmove(spec->private_dac_nids + i,
				spec->private_dac_nids + i + 1,
				sizeof(hda_nid_t) * (cfg->line_outs - i - 1));
	}

	if (cfg->hp_outs && !spec->multiout.hp_nid)
		spec->multiout.hp_nid =
			alc_auto_look_for_dac(codec, cfg->hp_pins[0]);
	if (cfg->speaker_outs && !spec->multiout.extra_out_nid[0])
		spec->multiout.extra_out_nid[0] =
			alc_auto_look_for_dac(codec, cfg->speaker_pins[0]);

	return 0;
2837 2838
}

2839 2840 2841
static int alc_auto_add_vol_ctl(struct hda_codec *codec,
			      const char *pfx, int cidx,
			      hda_nid_t nid, unsigned int chs)
2842
{
2843 2844
	if (!nid)
		return 0;
2845 2846 2847
	return __add_pb_vol_ctrl(codec->spec, ALC_CTL_WIDGET_VOL, pfx, cidx,
				 HDA_COMPOSE_AMP_VAL(nid, chs, 0, HDA_OUTPUT));
}
2848

2849 2850
#define alc_auto_add_stereo_vol(codec, pfx, cidx, nid)	\
	alc_auto_add_vol_ctl(codec, pfx, cidx, nid, 3)
2851

2852 2853 2854 2855 2856 2857 2858
/* create a mute-switch for the given mixer widget;
 * if it has multiple sources (e.g. DAC and loopback), create a bind-mute
 */
static int alc_auto_add_sw_ctl(struct hda_codec *codec,
			     const char *pfx, int cidx,
			     hda_nid_t nid, unsigned int chs)
{
2859
	int wid_type;
2860 2861
	int type;
	unsigned long val;
2862 2863 2864 2865 2866 2867 2868
	if (!nid)
		return 0;
	wid_type = get_wcaps_type(get_wcaps(codec, nid));
	if (wid_type == AC_WID_PIN || wid_type == AC_WID_AUD_OUT) {
		type = ALC_CTL_WIDGET_MUTE;
		val = HDA_COMPOSE_AMP_VAL(nid, chs, 0, HDA_OUTPUT);
	} else if (snd_hda_get_conn_list(codec, nid, NULL) == 1) {
2869 2870 2871 2872 2873
		type = ALC_CTL_WIDGET_MUTE;
		val = HDA_COMPOSE_AMP_VAL(nid, chs, 0, HDA_INPUT);
	} else {
		type = ALC_CTL_BIND_MUTE;
		val = HDA_COMPOSE_AMP_VAL(nid, chs, 2, HDA_INPUT);
2874
	}
2875
	return __add_pb_sw_ctrl(codec->spec, type, pfx, cidx, val);
2876 2877
}

2878 2879
#define alc_auto_add_stereo_sw(codec, pfx, cidx, nid)	\
	alc_auto_add_sw_ctl(codec, pfx, cidx, nid, 3)
2880

2881 2882 2883 2884 2885 2886 2887 2888 2889 2890 2891 2892 2893 2894 2895 2896 2897 2898 2899 2900 2901 2902 2903 2904 2905 2906 2907 2908 2909 2910 2911
#define nid_has_mute(codec, nid, dir) \
	(query_amp_caps(codec, nid, dir) & AC_AMPCAP_MUTE)
#define nid_has_volume(codec, nid, dir) \
	(query_amp_caps(codec, nid, dir) & AC_AMPCAP_NUM_STEPS)

static hda_nid_t alc_look_for_out_mute_nid(struct hda_codec *codec,
					   hda_nid_t pin, hda_nid_t dac)
{
	hda_nid_t mix = alc_auto_dac_to_mix(codec, pin, dac);
	if (nid_has_mute(codec, pin, HDA_OUTPUT))
		return pin;
	else if (mix && nid_has_mute(codec, mix, HDA_INPUT))
		return mix;
	else if (nid_has_mute(codec, dac, HDA_OUTPUT))
		return dac;
	return 0;
}

static hda_nid_t alc_look_for_out_vol_nid(struct hda_codec *codec,
					  hda_nid_t pin, hda_nid_t dac)
{
	hda_nid_t mix = alc_auto_dac_to_mix(codec, pin, dac);
	if (nid_has_volume(codec, dac, HDA_OUTPUT))
		return dac;
	else if (nid_has_volume(codec, mix, HDA_OUTPUT))
		return mix;
	else if (nid_has_volume(codec, pin, HDA_OUTPUT))
		return pin;
	return 0;
}

2912 2913 2914
/* add playback controls from the parsed DAC table */
static int alc_auto_create_multi_out_ctls(struct hda_codec *codec,
					     const struct auto_pin_cfg *cfg)
2915 2916
{
	struct alc_spec *spec = codec->spec;
2917
	int i, err, noutputs;
2918

2919 2920 2921
	noutputs = cfg->line_outs;
	if (spec->multi_ios > 0)
		noutputs += spec->multi_ios;
L
Linus Torvalds 已提交
2922

2923 2924 2925
	for (i = 0; i < noutputs; i++) {
		const char *name;
		int index;
2926 2927 2928 2929 2930
		hda_nid_t dac, pin;
		hda_nid_t sw, vol;

		dac = spec->multiout.dac_nids[i];
		if (!dac)
2931 2932 2933 2934 2935
			continue;
		if (i >= cfg->line_outs)
			pin = spec->multi_io[i - 1].pin;
		else
			pin = cfg->line_out_pins[i];
2936 2937 2938

		sw = alc_look_for_out_mute_nid(codec, pin, dac);
		vol = alc_look_for_out_vol_nid(codec, pin, dac);
2939 2940 2941
		name = alc_get_line_out_pfx(spec, i, true, &index);
		if (!name) {
			/* Center/LFE */
2942
			err = alc_auto_add_vol_ctl(codec, "Center", 0, vol, 1);
2943 2944
			if (err < 0)
				return err;
2945
			err = alc_auto_add_vol_ctl(codec, "LFE", 0, vol, 2);
2946 2947
			if (err < 0)
				return err;
2948
			err = alc_auto_add_sw_ctl(codec, "Center", 0, sw, 1);
2949 2950
			if (err < 0)
				return err;
2951
			err = alc_auto_add_sw_ctl(codec, "LFE", 0, sw, 2);
2952 2953 2954
			if (err < 0)
				return err;
		} else {
2955
			err = alc_auto_add_stereo_vol(codec, name, index, vol);
2956 2957
			if (err < 0)
				return err;
2958
			err = alc_auto_add_stereo_sw(codec, name, index, sw);
2959 2960
			if (err < 0)
				return err;
2961
		}
L
Linus Torvalds 已提交
2962
	}
2963 2964
	return 0;
}
L
Linus Torvalds 已提交
2965

2966 2967 2968 2969 2970
/* add playback controls for speaker and HP outputs */
static int alc_auto_create_extra_out(struct hda_codec *codec, hda_nid_t pin,
					hda_nid_t dac, const char *pfx)
{
	struct alc_spec *spec = codec->spec;
2971
	hda_nid_t sw, vol;
2972
	int err;
L
Linus Torvalds 已提交
2973

2974 2975 2976 2977 2978 2979 2980 2981 2982
	if (!pin)
		return 0;
	if (!dac) {
		/* the corresponding DAC is already occupied */
		if (!(get_wcaps(codec, pin) & AC_WCAP_OUT_AMP))
			return 0; /* no way */
		/* create a switch only */
		return add_pb_sw_ctrl(spec, ALC_CTL_WIDGET_MUTE, pfx,
				   HDA_COMPOSE_AMP_VAL(pin, 3, 0, HDA_OUTPUT));
2983
	}
L
Linus Torvalds 已提交
2984

2985 2986 2987
	sw = alc_look_for_out_mute_nid(codec, pin, dac);
	vol = alc_look_for_out_vol_nid(codec, pin, dac);
	err = alc_auto_add_stereo_vol(codec, pfx, 0, vol);
2988 2989
	if (err < 0)
		return err;
2990
	err = alc_auto_add_stereo_sw(codec, pfx, 0, sw);
2991 2992
	if (err < 0)
		return err;
L
Linus Torvalds 已提交
2993 2994 2995
	return 0;
}

2996
static int alc_auto_create_hp_out(struct hda_codec *codec)
2997
{
2998 2999 3000 3001
	struct alc_spec *spec = codec->spec;
	return alc_auto_create_extra_out(codec, spec->autocfg.hp_pins[0],
					 spec->multiout.hp_nid,
					 "Headphone");
3002 3003
}

3004
static int alc_auto_create_speaker_out(struct hda_codec *codec)
3005 3006
{
	struct alc_spec *spec = codec->spec;
3007 3008 3009
	return alc_auto_create_extra_out(codec, spec->autocfg.speaker_pins[0],
					 spec->multiout.extra_out_nid[0],
					 "Speaker");
3010 3011
}

3012
static void alc_auto_set_output_and_unmute(struct hda_codec *codec,
3013
					      hda_nid_t pin, int pin_type,
3014
					      hda_nid_t dac)
3015
{
3016
	int i, num;
3017
	hda_nid_t nid, mix = 0;
3018
	hda_nid_t srcs[HDA_MAX_CONNECTIONS];
3019

3020 3021
	alc_set_pin_output(codec, pin, pin_type);
	nid = alc_go_down_to_selector(codec, pin);
3022 3023 3024 3025 3026 3027 3028 3029 3030
	num = snd_hda_get_connections(codec, nid, srcs, ARRAY_SIZE(srcs));
	for (i = 0; i < num; i++) {
		if (alc_auto_mix_to_dac(codec, srcs[i]) != dac)
			continue;
		mix = srcs[i];
		break;
	}
	if (!mix)
		return;
3031

3032 3033 3034 3035
	/* need the manual connection? */
	if (num > 1)
		snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_CONNECT_SEL, i);
	/* unmute mixer widget inputs */
3036 3037
	if (nid_has_mute(codec, mix, HDA_INPUT)) {
		snd_hda_codec_write(codec, mix, 0, AC_VERB_SET_AMP_GAIN_MUTE,
3038
			    AMP_IN_UNMUTE(0));
3039
		snd_hda_codec_write(codec, mix, 0, AC_VERB_SET_AMP_GAIN_MUTE,
3040
			    AMP_IN_UNMUTE(1));
3041
	}
3042
	/* initialize volume */
3043 3044 3045 3046
	nid = alc_look_for_out_vol_nid(codec, pin, dac);
	if (nid)
		snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_AMP_GAIN_MUTE,
				    AMP_OUT_ZERO);
3047
}
3048

3049
static void alc_auto_init_multi_out(struct hda_codec *codec)
3050 3051
{
	struct alc_spec *spec = codec->spec;
3052 3053
	int pin_type = get_pin_type(spec->autocfg.line_out_type);
	int i;
3054

3055 3056 3057 3058 3059 3060
	for (i = 0; i <= HDA_SIDE; i++) {
		hda_nid_t nid = spec->autocfg.line_out_pins[i];
		if (nid)
			alc_auto_set_output_and_unmute(codec, nid, pin_type,
					spec->multiout.dac_nids[i]);
	}
3061 3062
}

3063
static void alc_auto_init_extra_out(struct hda_codec *codec)
3064 3065
{
	struct alc_spec *spec = codec->spec;
3066
	hda_nid_t pin;
3067

3068 3069 3070 3071 3072 3073 3074 3075
	pin = spec->autocfg.hp_pins[0];
	if (pin)
		alc_auto_set_output_and_unmute(codec, pin, PIN_HP,
						  spec->multiout.hp_nid);
	pin = spec->autocfg.speaker_pins[0];
	if (pin)
		alc_auto_set_output_and_unmute(codec, pin, PIN_OUT,
					spec->multiout.extra_out_nid[0]);
3076 3077
}

3078
/*
3079
 * multi-io helper
3080
 */
3081 3082
static int alc_auto_fill_multi_ios(struct hda_codec *codec,
				   unsigned int location)
3083
{
3084 3085 3086
	struct alc_spec *spec = codec->spec;
	struct auto_pin_cfg *cfg = &spec->autocfg;
	int type, i, num_pins = 0;
3087

3088 3089 3090 3091 3092 3093 3094 3095 3096 3097 3098 3099 3100 3101 3102 3103 3104 3105 3106 3107 3108 3109 3110
	for (type = AUTO_PIN_LINE_IN; type >= AUTO_PIN_MIC; type--) {
		for (i = 0; i < cfg->num_inputs; i++) {
			hda_nid_t nid = cfg->inputs[i].pin;
			hda_nid_t dac;
			unsigned int defcfg, caps;
			if (cfg->inputs[i].type != type)
				continue;
			defcfg = snd_hda_codec_get_pincfg(codec, nid);
			if (get_defcfg_connect(defcfg) != AC_JACK_PORT_COMPLEX)
				continue;
			if (location && get_defcfg_location(defcfg) != location)
				continue;
			caps = snd_hda_query_pin_caps(codec, nid);
			if (!(caps & AC_PINCAP_OUT))
				continue;
			dac = alc_auto_look_for_dac(codec, nid);
			if (!dac)
				continue;
			spec->multi_io[num_pins].pin = nid;
			spec->multi_io[num_pins].dac = dac;
			num_pins++;
			spec->private_dac_nids[spec->multiout.num_dacs++] = dac;
		}
3111
	}
3112
	spec->multiout.num_dacs = 1;
3113 3114 3115
	if (num_pins < 2)
		return 0;
	return num_pins;
3116 3117
}

3118 3119
static int alc_auto_ch_mode_info(struct snd_kcontrol *kcontrol,
				 struct snd_ctl_elem_info *uinfo)
3120
{
3121
	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3122 3123
	struct alc_spec *spec = codec->spec;

3124 3125 3126 3127 3128 3129 3130 3131 3132
	uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
	uinfo->count = 1;
	uinfo->value.enumerated.items = spec->multi_ios + 1;
	if (uinfo->value.enumerated.item > spec->multi_ios)
		uinfo->value.enumerated.item = spec->multi_ios;
	sprintf(uinfo->value.enumerated.name, "%dch",
		(uinfo->value.enumerated.item + 1) * 2);
	return 0;
}
3133

3134 3135 3136 3137 3138 3139 3140 3141
static int alc_auto_ch_mode_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.enumerated.item[0] = (spec->ext_channel_count - 1) / 2;
	return 0;
}
3142

3143 3144 3145 3146
static int alc_set_multi_io(struct hda_codec *codec, int idx, bool output)
{
	struct alc_spec *spec = codec->spec;
	hda_nid_t nid = spec->multi_io[idx].pin;
3147

3148 3149 3150 3151 3152 3153 3154 3155 3156 3157 3158 3159 3160 3161 3162 3163 3164 3165 3166
	if (!spec->multi_io[idx].ctl_in)
		spec->multi_io[idx].ctl_in =
			snd_hda_codec_read(codec, nid, 0,
					   AC_VERB_GET_PIN_WIDGET_CONTROL, 0);
	if (output) {
		snd_hda_codec_update_cache(codec, nid, 0,
					   AC_VERB_SET_PIN_WIDGET_CONTROL,
					   PIN_OUT);
		if (get_wcaps(codec, nid) & AC_WCAP_OUT_AMP)
			snd_hda_codec_amp_stereo(codec, nid, HDA_OUTPUT, 0,
						 HDA_AMP_MUTE, 0);
		alc_auto_select_dac(codec, nid, spec->multi_io[idx].dac);
	} else {
		if (get_wcaps(codec, nid) & AC_WCAP_OUT_AMP)
			snd_hda_codec_amp_stereo(codec, nid, HDA_OUTPUT, 0,
						 HDA_AMP_MUTE, HDA_AMP_MUTE);
		snd_hda_codec_update_cache(codec, nid, 0,
					   AC_VERB_SET_PIN_WIDGET_CONTROL,
					   spec->multi_io[idx].ctl_in);
3167
	}
3168
	return 0;
3169 3170
}

3171 3172
static int alc_auto_ch_mode_put(struct snd_kcontrol *kcontrol,
				struct snd_ctl_elem_value *ucontrol)
3173
{
3174
	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3175
	struct alc_spec *spec = codec->spec;
3176
	int i, ch;
3177

3178 3179 3180 3181 3182 3183 3184 3185 3186 3187 3188
	ch = ucontrol->value.enumerated.item[0];
	if (ch < 0 || ch > spec->multi_ios)
		return -EINVAL;
	if (ch == (spec->ext_channel_count - 1) / 2)
		return 0;
	spec->ext_channel_count = (ch + 1) * 2;
	for (i = 0; i < spec->multi_ios; i++)
		alc_set_multi_io(codec, i, i < ch);
	spec->multiout.max_channels = spec->ext_channel_count;
	return 1;
}
3189

3190 3191 3192 3193 3194 3195
static const struct snd_kcontrol_new alc_auto_channel_mode_enum = {
	.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
	.name = "Channel Mode",
	.info = alc_auto_ch_mode_info,
	.get = alc_auto_ch_mode_get,
	.put = alc_auto_ch_mode_put,
3196 3197
};

3198 3199
static int alc_auto_add_multi_channel_mode(struct hda_codec *codec,
					   int (*fill_dac)(struct hda_codec *))
3200
{
3201 3202 3203 3204
	struct alc_spec *spec = codec->spec;
	struct auto_pin_cfg *cfg = &spec->autocfg;
	unsigned int location, defcfg;
	int num_pins;
3205

3206 3207 3208 3209 3210 3211 3212 3213 3214 3215 3216 3217 3218 3219 3220 3221
	if (cfg->line_out_type == AUTO_PIN_SPEAKER_OUT && cfg->hp_outs == 1) {
		/* use HP as primary out */
		cfg->speaker_outs = cfg->line_outs;
		memcpy(cfg->speaker_pins, cfg->line_out_pins,
		       sizeof(cfg->speaker_pins));
		cfg->line_outs = cfg->hp_outs;
		memcpy(cfg->line_out_pins, cfg->hp_pins, sizeof(cfg->hp_pins));
		cfg->hp_outs = 0;
		memset(cfg->hp_pins, 0, sizeof(cfg->hp_pins));
		cfg->line_out_type = AUTO_PIN_HP_OUT;
		if (fill_dac)
			fill_dac(codec);
	}
	if (cfg->line_outs != 1 ||
	    cfg->line_out_type == AUTO_PIN_SPEAKER_OUT)
		return 0;
3222

3223 3224
	defcfg = snd_hda_codec_get_pincfg(codec, cfg->line_out_pins[0]);
	location = get_defcfg_location(defcfg);
3225

3226 3227 3228
	num_pins = alc_auto_fill_multi_ios(codec, location);
	if (num_pins > 0) {
		struct snd_kcontrol_new *knew;
3229

3230 3231 3232 3233 3234 3235 3236
		knew = alc_kcontrol_new(spec);
		if (!knew)
			return -ENOMEM;
		*knew = alc_auto_channel_mode_enum;
		knew->name = kstrdup("Channel Mode", GFP_KERNEL);
		if (!knew->name)
			return -ENOMEM;
3237

3238 3239 3240
		spec->multi_ios = num_pins;
		spec->ext_channel_count = 2;
		spec->multiout.num_dacs = num_pins + 1;
3241
	}
3242 3243
	return 0;
}
3244

3245 3246 3247 3248 3249 3250 3251 3252 3253 3254
/* filter out invalid adc_nids (and capsrc_nids) that don't give all
 * active input pins
 */
static void alc_remove_invalid_adc_nids(struct hda_codec *codec)
{
	struct alc_spec *spec = codec->spec;
	const struct hda_input_mux *imux;
	hda_nid_t adc_nids[ARRAY_SIZE(spec->private_adc_nids)];
	hda_nid_t capsrc_nids[ARRAY_SIZE(spec->private_adc_nids)];
	int i, n, nums;
3255

3256 3257 3258 3259 3260
	imux = spec->input_mux;
	if (!imux)
		return;
	if (spec->dyn_adc_switch)
		return;
3261

3262 3263 3264 3265 3266 3267 3268 3269 3270 3271 3272 3273 3274 3275 3276
	nums = 0;
	for (n = 0; n < spec->num_adc_nids; n++) {
		hda_nid_t cap = spec->private_capsrc_nids[n];
		int num_conns = snd_hda_get_conn_list(codec, cap, NULL);
		for (i = 0; i < imux->num_items; i++) {
			hda_nid_t pin = spec->imux_pins[i];
			if (pin) {
				if (get_connection_index(codec, cap, pin) < 0)
					break;
			} else if (num_conns <= imux->items[i].index)
				break;
		}
		if (i >= imux->num_items) {
			adc_nids[nums] = spec->private_adc_nids[n];
			capsrc_nids[nums++] = cap;
3277 3278
		}
	}
3279 3280 3281 3282 3283 3284 3285 3286 3287
	if (!nums) {
		/* check whether ADC-switch is possible */
		if (!alc_check_dyn_adc_switch(codec)) {
			printk(KERN_WARNING "hda_codec: %s: no valid ADC found;"
			       " using fallback 0x%x\n",
			       codec->chip_name, spec->private_adc_nids[0]);
			spec->num_adc_nids = 1;
			spec->auto_mic = 0;
			return;
3288
		}
3289 3290 3291 3292 3293 3294
	} else if (nums != spec->num_adc_nids) {
		memcpy(spec->private_adc_nids, adc_nids,
		       nums * sizeof(hda_nid_t));
		memcpy(spec->private_capsrc_nids, capsrc_nids,
		       nums * sizeof(hda_nid_t));
		spec->num_adc_nids = nums;
3295
	}
3296

3297 3298 3299 3300 3301 3302 3303 3304 3305 3306 3307 3308 3309 3310 3311 3312 3313 3314 3315 3316 3317
	if (spec->auto_mic)
		alc_auto_mic_check_imux(codec); /* check auto-mic setups */
	else if (spec->input_mux->num_items == 1)
		spec->num_adc_nids = 1; /* reduce to a single ADC */
}

/*
 * initialize ADC paths
 */
static void alc_auto_init_adc(struct hda_codec *codec, int adc_idx)
{
	struct alc_spec *spec = codec->spec;
	hda_nid_t nid;

	nid = spec->adc_nids[adc_idx];
	/* mute ADC */
	if (query_amp_caps(codec, nid, HDA_INPUT) & AC_AMPCAP_MUTE) {
		snd_hda_codec_write(codec, nid, 0,
				    AC_VERB_SET_AMP_GAIN_MUTE,
				    AMP_IN_MUTE(0));
		return;
3318
	}
3319 3320 3321 3322 3323 3324 3325 3326
	if (!spec->capsrc_nids)
		return;
	nid = spec->capsrc_nids[adc_idx];
	if (query_amp_caps(codec, nid, HDA_OUTPUT) & AC_AMPCAP_MUTE)
		snd_hda_codec_write(codec, nid, 0,
				    AC_VERB_SET_AMP_GAIN_MUTE,
				    AMP_OUT_MUTE);
}
3327

3328 3329 3330 3331
static void alc_auto_init_input_src(struct hda_codec *codec)
{
	struct alc_spec *spec = codec->spec;
	int c, nums;
3332

3333 3334 3335 3336 3337 3338 3339 3340 3341
	for (c = 0; c < spec->num_adc_nids; c++)
		alc_auto_init_adc(codec, c);
	if (spec->dyn_adc_switch)
		nums = 1;
	else
		nums = spec->num_adc_nids;
	for (c = 0; c < nums; c++)
		alc_mux_select(codec, 0, spec->cur_mux[c], true);
}
3342

3343 3344 3345 3346 3347 3348 3349 3350 3351
/* add mic boosts if needed */
static int alc_auto_add_mic_boost(struct hda_codec *codec)
{
	struct alc_spec *spec = codec->spec;
	struct auto_pin_cfg *cfg = &spec->autocfg;
	int i, err;
	int type_idx = 0;
	hda_nid_t nid;
	const char *prev_label = NULL;
3352

3353 3354 3355 3356 3357 3358 3359 3360 3361 3362 3363 3364 3365 3366
	for (i = 0; i < cfg->num_inputs; i++) {
		if (cfg->inputs[i].type > AUTO_PIN_MIC)
			break;
		nid = cfg->inputs[i].pin;
		if (get_wcaps(codec, nid) & AC_WCAP_IN_AMP) {
			const char *label;
			char boost_label[32];

			label = hda_get_autocfg_input_label(codec, cfg, i);
			if (prev_label && !strcmp(label, prev_label))
				type_idx++;
			else
				type_idx = 0;
			prev_label = label;
3367

3368 3369 3370 3371 3372 3373 3374 3375 3376
			snprintf(boost_label, sizeof(boost_label),
				 "%s Boost Volume", label);
			err = add_control(spec, ALC_CTL_WIDGET_VOL,
					  boost_label, type_idx,
				  HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_INPUT));
			if (err < 0)
				return err;
		}
	}
3377 3378 3379
	return 0;
}

3380 3381 3382 3383 3384 3385 3386 3387 3388 3389 3390 3391
/* select or unmute the given capsrc route */
static void select_or_unmute_capsrc(struct hda_codec *codec, hda_nid_t cap,
				    int idx)
{
	if (get_wcaps_type(get_wcaps(codec, cap)) == AC_WID_AUD_MIX) {
		snd_hda_codec_amp_stereo(codec, cap, HDA_INPUT, idx,
					 HDA_AMP_MUTE, 0);
	} else if (snd_hda_get_conn_list(codec, cap, NULL) > 1) {
		snd_hda_codec_write_cache(codec, cap, 0,
					  AC_VERB_SET_CONNECT_SEL, idx);
	}
}
3392

3393 3394 3395 3396 3397
/* set the default connection to that pin */
static int init_capsrc_for_pin(struct hda_codec *codec, hda_nid_t pin)
{
	struct alc_spec *spec = codec->spec;
	int i;
3398

3399 3400 3401 3402 3403 3404
	if (!pin)
		return 0;
	for (i = 0; i < spec->num_adc_nids; i++) {
		hda_nid_t cap = spec->capsrc_nids ?
			spec->capsrc_nids[i] : spec->adc_nids[i];
		int idx;
3405

3406 3407 3408 3409 3410 3411 3412 3413
		idx = get_connection_index(codec, cap, pin);
		if (idx < 0)
			continue;
		select_or_unmute_capsrc(codec, cap, idx);
		return i; /* return the found index */
	}
	return -1; /* not found */
}
3414

3415 3416 3417 3418 3419
/* initialize some special cases for input sources */
static void alc_init_special_input_src(struct hda_codec *codec)
{
	struct alc_spec *spec = codec->spec;
	int i;
K
Kailang Yang 已提交
3420

3421 3422 3423
	for (i = 0; i < spec->autocfg.num_inputs; i++)
		init_capsrc_for_pin(codec, spec->autocfg.inputs[i].pin);
}
K
Kailang Yang 已提交
3424

3425 3426 3427 3428 3429 3430 3431 3432 3433 3434 3435 3436
/* assign appropriate capture mixers */
static void set_capture_mixer(struct hda_codec *codec)
{
	struct alc_spec *spec = codec->spec;
	static const struct snd_kcontrol_new *caps[2][3] = {
		{ alc_capture_mixer_nosrc1,
		  alc_capture_mixer_nosrc2,
		  alc_capture_mixer_nosrc3 },
		{ alc_capture_mixer1,
		  alc_capture_mixer2,
		  alc_capture_mixer3 },
	};
3437

3438 3439 3440 3441 3442 3443 3444 3445 3446 3447
	/* check whether either of ADC or MUX has a volume control */
	if (!(query_amp_caps(codec, spec->adc_nids[0], HDA_INPUT) &
	      AC_AMPCAP_NUM_STEPS)) {
		if (!spec->capsrc_nids)
			return; /* no volume */
		if (!(query_amp_caps(codec, spec->capsrc_nids[0], HDA_OUTPUT) &
		      AC_AMPCAP_NUM_STEPS))
			return; /* no volume in capsrc, too */
		spec->vol_in_capsrc = 1;
	}
3448

3449 3450 3451
	if (spec->num_adc_nids > 0) {
		int mux = 0;
		int num_adcs = 0;
3452

3453 3454 3455 3456 3457 3458 3459 3460 3461 3462 3463 3464 3465 3466 3467 3468 3469
		if (spec->input_mux && spec->input_mux->num_items > 1)
			mux = 1;
		if (spec->auto_mic) {
			num_adcs = 1;
			mux = 0;
		} else if (spec->dyn_adc_switch)
			num_adcs = 1;
		if (!num_adcs) {
			if (spec->num_adc_nids > 3)
				spec->num_adc_nids = 3;
			else if (!spec->num_adc_nids)
				return;
			num_adcs = spec->num_adc_nids;
		}
		spec->cap_mixer = caps[mux][num_adcs - 1];
	}
}
3470

3471 3472 3473 3474 3475 3476
/*
 * 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 已提交
3477

3478 3479 3480 3481 3482 3483 3484
static const struct snd_pci_quirk beep_white_list[] = {
	SND_PCI_QUIRK(0x1043, 0x829f, "ASUS", 1),
	SND_PCI_QUIRK(0x1043, 0x83ce, "EeePC", 1),
	SND_PCI_QUIRK(0x1043, 0x831a, "EeePC", 1),
	SND_PCI_QUIRK(0x1043, 0x834a, "EeePC", 1),
	SND_PCI_QUIRK(0x8086, 0xd613, "Intel", 1),
	{}
3485 3486
};

3487 3488 3489 3490 3491 3492 3493 3494 3495 3496 3497 3498 3499
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 已提交
3500

3501 3502 3503 3504 3505 3506 3507 3508 3509
/* 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
 */
static int alc880_parse_auto_config(struct hda_codec *codec)
{
	struct alc_spec *spec = codec->spec;
	int err;
	static const hda_nid_t alc880_ignore[] = { 0x1d, 0 };
3510

3511 3512 3513 3514 3515 3516
	err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
					   alc880_ignore);
	if (err < 0)
		return err;
	if (!spec->autocfg.line_outs)
		return 0; /* can't find valid BIOS pin config */
K
Kailang Yang 已提交
3517

3518 3519 3520 3521 3522 3523 3524 3525 3526 3527 3528 3529 3530 3531 3532 3533 3534 3535
	err = alc_auto_fill_dac_nids(codec);
	if (err < 0)
		return err;
	err = alc_auto_add_multi_channel_mode(codec, alc_auto_fill_dac_nids);
	if (err < 0)
		return err;
	err = alc_auto_create_multi_out_ctls(codec, &spec->autocfg);
	if (err < 0)
		return err;
	err = alc_auto_create_hp_out(codec);
	if (err < 0)
		return err;
	err = alc_auto_create_speaker_out(codec);
	if (err < 0)
		return err;
	err = alc_auto_create_input_ctls(codec);
	if (err < 0)
		return err;
K
Kailang Yang 已提交
3536

3537
	spec->multiout.max_channels = spec->multiout.num_dacs * 2;
3538

3539
	alc_auto_parse_digital(codec);
3540

3541 3542
	if (spec->kctls.list)
		add_mixer(spec, spec->kctls.list);
3543

3544
	alc_remove_invalid_adc_nids(codec);
3545

3546 3547
	alc_ssid_check(codec, 0x15, 0x1b, 0x14, 0);
	alc_auto_check_switches(codec);
3548

3549
	return 1;
3550
}
3551

3552 3553
/* additional initialization for auto-configuration model */
static void alc880_auto_init(struct hda_codec *codec)
3554
{
3555 3556 3557 3558 3559 3560 3561 3562
	struct alc_spec *spec = codec->spec;
	alc_auto_init_multi_out(codec);
	alc_auto_init_extra_out(codec);
	alc_auto_init_analog_input(codec);
	alc_auto_init_input_src(codec);
	alc_auto_init_digital(codec);
	if (spec->unsol_event)
		alc_inithook(codec);
3563 3564
}

3565 3566 3567 3568 3569 3570 3571 3572 3573 3574
#ifdef CONFIG_SND_HDA_POWER_SAVE
static const struct hda_amp_list alc880_loopbacks[] = {
	{ 0x0b, HDA_INPUT, 0 },
	{ 0x0b, HDA_INPUT, 1 },
	{ 0x0b, HDA_INPUT, 2 },
	{ 0x0b, HDA_INPUT, 3 },
	{ 0x0b, HDA_INPUT, 4 },
	{ } /* end */
};
#endif
3575

3576 3577 3578 3579 3580 3581 3582 3583 3584 3585 3586 3587 3588 3589
/*
 * board setups
 */
#ifdef CONFIG_SND_HDA_ENABLE_REALTEK_QUIRKS
#define alc_board_config \
	snd_hda_check_board_config
#define alc_board_codec_sid_config \
	snd_hda_check_board_codec_sid_config
#include "alc_quirks.c"
#else
#define alc_board_config(codec, nums, models, tbl)	-1
#define alc_board_codec_sid_config(codec, nums, models, tbl)	-1
#define setup_preset(codec, x)	/* NOP */
#endif
3590

3591 3592 3593 3594 3595 3596
/*
 * OK, here we have finally the patch for ALC880
 */
#ifdef CONFIG_SND_HDA_ENABLE_REALTEK_QUIRKS
#include "alc880_quirks.c"
#endif
3597

3598
static int patch_alc880(struct hda_codec *codec)
3599
{
3600 3601 3602
	struct alc_spec *spec;
	int board_config;
	int err;
3603

3604 3605 3606
	spec = kzalloc(sizeof(*spec), GFP_KERNEL);
	if (spec == NULL)
		return -ENOMEM;
3607

3608
	codec->spec = spec;
3609

3610
	spec->mixer_nid = 0x0b;
3611

3612 3613 3614 3615 3616 3617 3618
	board_config = alc_board_config(codec, ALC880_MODEL_LAST,
					alc880_models, alc880_cfg_tbl);
	if (board_config < 0) {
		printk(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
		       codec->chip_name);
		board_config = ALC_MODEL_AUTO;
	}
3619

3620 3621 3622 3623 3624 3625 3626 3627 3628 3629 3630 3631 3632 3633 3634 3635
	if (board_config == ALC_MODEL_AUTO) {
		/* automatic parse from the BIOS config */
		err = alc880_parse_auto_config(codec);
		if (err < 0) {
			alc_free(codec);
			return err;
		}
#ifdef CONFIG_SND_HDA_ENABLE_REALTEK_QUIRKS
		else if (!err) {
			printk(KERN_INFO
			       "hda_codec: Cannot set up configuration "
			       "from BIOS.  Using 3-stack mode...\n");
			board_config = ALC880_3ST;
		}
#endif
	}
K
Kailang Yang 已提交
3636

3637 3638 3639 3640 3641
	err = snd_hda_attach_beep_device(codec, 0x1);
	if (err < 0) {
		alc_free(codec);
		return err;
	}
K
Kailang Yang 已提交
3642

3643 3644
	if (board_config != ALC_MODEL_AUTO)
		setup_preset(codec, &alc880_presets[board_config]);
3645

3646 3647 3648 3649 3650 3651 3652
	if (!spec->adc_nids && spec->input_mux) {
		alc_auto_fill_adc_caps(codec);
		alc_rebuild_imux_for_auto_mic(codec);
		alc_remove_invalid_adc_nids(codec);
	}
	set_capture_mixer(codec);
	set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
3653

3654
	spec->vmaster_nid = 0x0c;
K
Kailang Yang 已提交
3655

3656 3657 3658 3659 3660 3661 3662
	codec->patch_ops = alc_patch_ops;
	if (board_config == ALC_MODEL_AUTO)
		spec->init_hook = alc880_auto_init;
#ifdef CONFIG_SND_HDA_POWER_SAVE
	if (!spec->loopback.amplist)
		spec->loopback.amplist = alc880_loopbacks;
#endif
3663

3664
	return 0;
3665 3666
}

3667

3668
/*
3669
 * ALC260 support
3670 3671
 */

3672 3673 3674 3675 3676 3677 3678 3679 3680 3681
/* convert from pin to volume-mixer widget */
static hda_nid_t alc260_pin_to_vol_mix(hda_nid_t nid)
{
	if (nid >= 0x0f && nid <= 0x11)
		return nid - 0x7;
	else if (nid >= 0x12 && nid <= 0x15)
		return 0x08;
	else
		return 0;
}
K
Kailang Yang 已提交
3682

3683 3684 3685 3686 3687 3688
static int alc260_add_playback_controls(struct alc_spec *spec, hda_nid_t nid,
					const char *pfx, int *vol_bits)
{
	hda_nid_t nid_vol;
	unsigned long vol_val, sw_val;
	int chs, err;
K
Kailang Yang 已提交
3689

3690 3691 3692 3693 3694 3695 3696 3697 3698
	nid_vol = alc260_pin_to_vol_mix(nid);
	if (!nid_vol)
		return 0; /* N/A */
	if (nid == 0x11)
		chs = 2;
	else
		chs = 3;
	vol_val = HDA_COMPOSE_AMP_VAL(nid_vol, chs, 0, HDA_OUTPUT);
	sw_val = HDA_COMPOSE_AMP_VAL(nid, chs, 0, HDA_OUTPUT);
3699

3700 3701 3702 3703 3704 3705 3706 3707 3708 3709 3710 3711
	if (!(*vol_bits & (1 << nid_vol))) {
		/* first control for the volume widget */
		err = add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL, pfx, vol_val);
		if (err < 0)
			return err;
		*vol_bits |= (1 << nid_vol);
	}
	err = add_pb_sw_ctrl(spec, ALC_CTL_WIDGET_MUTE, pfx, sw_val);
	if (err < 0)
		return err;
	return 1;
}
3712

3713 3714 3715 3716 3717 3718 3719
/* add playback controls from the parsed DAC table */
static int alc260_auto_create_multi_out_ctls(struct alc_spec *spec,
					     const struct auto_pin_cfg *cfg)
{
	hda_nid_t nid;
	int err;
	int vols = 0;
3720

3721 3722 3723
	spec->multiout.num_dacs = 1;
	spec->multiout.dac_nids = spec->private_dac_nids;
	spec->private_dac_nids[0] = 0x02;
3724

3725 3726 3727 3728 3729 3730 3731 3732 3733
	nid = cfg->line_out_pins[0];
	if (nid) {
		const char *pfx;
		int index;
		pfx = alc_get_line_out_pfx(spec, 0, true, &index);
		err = alc260_add_playback_controls(spec, nid, pfx, &vols);
		if (err < 0)
			return err;
	}
3734

3735 3736 3737 3738 3739 3740 3741 3742 3743 3744 3745 3746 3747
	nid = cfg->speaker_pins[0];
	if (nid) {
		err = alc260_add_playback_controls(spec, nid, "Speaker", &vols);
		if (err < 0)
			return err;
	}

	nid = cfg->hp_pins[0];
	if (nid) {
		err = alc260_add_playback_controls(spec, nid, "Headphone",
						   &vols);
		if (err < 0)
			return err;
3748 3749 3750 3751
	}
	return 0;
}

3752 3753 3754
static void alc260_auto_set_output_and_unmute(struct hda_codec *codec,
					      hda_nid_t nid, int pin_type,
					      int sel_idx)
3755
{
3756 3757 3758 3759 3760 3761 3762 3763
	hda_nid_t mix;

	alc_set_pin_output(codec, nid, pin_type);
	/* need the manual connection? */
	if (nid >= 0x12) {
		int idx = nid - 0x12;
		snd_hda_codec_write(codec, idx + 0x0b, 0,
				    AC_VERB_SET_CONNECT_SEL, sel_idx);
3764
	}
3765 3766 3767 3768 3769 3770 3771 3772 3773 3774

	mix = alc260_pin_to_vol_mix(nid);
	if (!mix)
		return;
	snd_hda_codec_write(codec, mix, 0, AC_VERB_SET_AMP_GAIN_MUTE,
			    AMP_OUT_ZERO);
	snd_hda_codec_write(codec, mix, 0, AC_VERB_SET_AMP_GAIN_MUTE,
			    AMP_IN_UNMUTE(0));
	snd_hda_codec_write(codec, mix, 0, AC_VERB_SET_AMP_GAIN_MUTE,
			    AMP_IN_UNMUTE(1));
3775 3776
}

3777 3778 3779 3780
static void alc260_auto_init_multi_out(struct hda_codec *codec)
{
	struct alc_spec *spec = codec->spec;
	hda_nid_t nid;
3781

3782 3783 3784 3785 3786 3787 3788 3789 3790 3791 3792 3793 3794 3795 3796 3797
	nid = spec->autocfg.line_out_pins[0];
	if (nid) {
		int pin_type = get_pin_type(spec->autocfg.line_out_type);
		alc260_auto_set_output_and_unmute(codec, nid, pin_type, 0);
	}

	nid = spec->autocfg.speaker_pins[0];
	if (nid)
		alc260_auto_set_output_and_unmute(codec, nid, PIN_OUT, 0);

	nid = spec->autocfg.hp_pins[0];
	if (nid)
		alc260_auto_set_output_and_unmute(codec, nid, PIN_HP, 0);
}

static int alc260_parse_auto_config(struct hda_codec *codec)
3798 3799
{
	struct alc_spec *spec = codec->spec;
3800
	int err;
3801
	static const hda_nid_t alc260_ignore[] = { 0x17, 0 };
3802 3803

	err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
3804
					   alc260_ignore);
3805 3806
	if (err < 0)
		return err;
3807
	err = alc260_auto_create_multi_out_ctls(spec, &spec->autocfg);
3808 3809
	if (err < 0)
		return err;
3810 3811
	if (!spec->kctls.list)
		return 0; /* can't find valid BIOS pin config */
3812
	err = alc_auto_create_input_ctls(codec);
3813 3814 3815
	if (err < 0)
		return err;

3816
	spec->multiout.max_channels = 2;
3817

3818
	alc_auto_parse_digital(codec);
3819

3820
	if (spec->kctls.list)
3821
		add_mixer(spec, spec->kctls.list);
3822

3823 3824
	alc_remove_invalid_adc_nids(codec);

3825
	alc_ssid_check(codec, 0x10, 0x15, 0x0f, 0);
3826
	alc_auto_check_switches(codec);
3827

3828 3829 3830
	return 1;
}

3831 3832
/* additional initialization for auto-configuration model */
static void alc260_auto_init(struct hda_codec *codec)
3833
{
3834
	struct alc_spec *spec = codec->spec;
3835
	alc260_auto_init_multi_out(codec);
3836
	alc_auto_init_analog_input(codec);
3837
	alc_auto_init_input_src(codec);
3838
	alc_auto_init_digital(codec);
3839
	if (spec->unsol_event)
3840
		alc_inithook(codec);
3841 3842
}

3843 3844 3845 3846 3847 3848 3849 3850 3851 3852
#ifdef CONFIG_SND_HDA_POWER_SAVE
static const struct hda_amp_list alc260_loopbacks[] = {
	{ 0x07, HDA_INPUT, 0 },
	{ 0x07, HDA_INPUT, 1 },
	{ 0x07, HDA_INPUT, 2 },
	{ 0x07, HDA_INPUT, 3 },
	{ 0x07, HDA_INPUT, 4 },
	{ } /* end */
};
#endif
3853

3854 3855 3856 3857 3858 3859 3860 3861 3862 3863 3864 3865 3866 3867 3868 3869 3870 3871 3872 3873 3874 3875 3876 3877 3878 3879 3880 3881 3882
/*
 * Pin config fixes
 */
enum {
	PINFIX_HP_DC5750,
};

static const struct alc_fixup alc260_fixups[] = {
	[PINFIX_HP_DC5750] = {
		.type = ALC_FIXUP_PINS,
		.v.pins = (const struct alc_pincfg[]) {
			{ 0x11, 0x90130110 }, /* speaker */
			{ }
		}
	},
};

static const struct snd_pci_quirk alc260_fixup_tbl[] = {
	SND_PCI_QUIRK(0x103c, 0x280a, "HP dc5750", PINFIX_HP_DC5750),
	{}
};

/*
 */
#ifdef CONFIG_SND_HDA_ENABLE_REALTEK_QUIRKS
#include "alc260_quirks.c"
#endif

static int patch_alc260(struct hda_codec *codec)
3883
{
3884 3885 3886 3887 3888 3889 3890 3891 3892 3893 3894 3895 3896 3897 3898 3899 3900
	struct alc_spec *spec;
	int err, board_config;

	spec = kzalloc(sizeof(*spec), GFP_KERNEL);
	if (spec == NULL)
		return -ENOMEM;

	codec->spec = spec;

	spec->mixer_nid = 0x07;

	board_config = alc_board_config(codec, ALC260_MODEL_LAST,
					alc260_models, alc260_cfg_tbl);
	if (board_config < 0) {
		snd_printd(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
			   codec->chip_name);
		board_config = ALC_MODEL_AUTO;
3901
	}
3902

3903 3904 3905
	if (board_config == ALC_MODEL_AUTO) {
		alc_pick_fixup(codec, NULL, alc260_fixup_tbl, alc260_fixups);
		alc_apply_fixup(codec, ALC_FIXUP_ACT_PRE_PROBE);
3906 3907
	}

3908 3909 3910 3911 3912 3913 3914 3915 3916 3917 3918 3919 3920 3921 3922 3923
	if (board_config == ALC_MODEL_AUTO) {
		/* automatic parse from the BIOS config */
		err = alc260_parse_auto_config(codec);
		if (err < 0) {
			alc_free(codec);
			return err;
		}
#ifdef CONFIG_SND_HDA_ENABLE_REALTEK_QUIRKS
		else if (!err) {
			printk(KERN_INFO
			       "hda_codec: Cannot set up configuration "
			       "from BIOS.  Using base mode...\n");
			board_config = ALC260_BASIC;
		}
#endif
	}
3924

3925 3926 3927 3928
	err = snd_hda_attach_beep_device(codec, 0x1);
	if (err < 0) {
		alc_free(codec);
		return err;
3929 3930
	}

3931 3932
	if (board_config != ALC_MODEL_AUTO)
		setup_preset(codec, &alc260_presets[board_config]);
3933

3934 3935 3936 3937 3938 3939 3940
	if (!spec->adc_nids && spec->input_mux) {
		alc_auto_fill_adc_caps(codec);
		alc_rebuild_imux_for_auto_mic(codec);
		alc_remove_invalid_adc_nids(codec);
	}
	set_capture_mixer(codec);
	set_beep_amp(spec, 0x07, 0x05, HDA_INPUT);
3941

3942
	alc_apply_fixup(codec, ALC_FIXUP_ACT_PROBE);
3943

3944
	spec->vmaster_nid = 0x08;
3945

3946 3947 3948 3949 3950 3951 3952 3953
	codec->patch_ops = alc_patch_ops;
	if (board_config == ALC_MODEL_AUTO)
		spec->init_hook = alc260_auto_init;
	spec->shutup = alc_eapd_shutup;
#ifdef CONFIG_SND_HDA_POWER_SAVE
	if (!spec->loopback.amplist)
		spec->loopback.amplist = alc260_loopbacks;
#endif
3954

3955
	return 0;
3956 3957
}

3958 3959 3960 3961 3962 3963 3964 3965 3966 3967 3968 3969 3970 3971 3972 3973 3974 3975 3976

/*
 * 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).
 */
#ifdef CONFIG_SND_HDA_POWER_SAVE
#define alc882_loopbacks	alc880_loopbacks
#endif

/*
 * Pin config fixes
 */
3977
enum {
3978 3979 3980 3981
	PINFIX_ABIT_AW9D_MAX,
	PINFIX_LENOVO_Y530,
	PINFIX_PB_M5210,
	PINFIX_ACER_ASPIRE_7736,
3982 3983
};

3984 3985 3986 3987 3988 3989 3990
static const struct alc_fixup alc882_fixups[] = {
	[PINFIX_ABIT_AW9D_MAX] = {
		.type = ALC_FIXUP_PINS,
		.v.pins = (const struct alc_pincfg[]) {
			{ 0x15, 0x01080104 }, /* side */
			{ 0x16, 0x01011012 }, /* rear */
			{ 0x17, 0x01016011 }, /* clfe */
3991
			{ }
3992 3993
		}
	},
3994
	[PINFIX_LENOVO_Y530] = {
3995 3996
		.type = ALC_FIXUP_PINS,
		.v.pins = (const struct alc_pincfg[]) {
3997 3998
			{ 0x15, 0x99130112 }, /* rear int speakers */
			{ 0x16, 0x99130111 }, /* subwoofer */
3999 4000 4001
			{ }
		}
	},
4002
	[PINFIX_PB_M5210] = {
4003 4004
		.type = ALC_FIXUP_VERBS,
		.v.verbs = (const struct hda_verb[]) {
4005
			{ 0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF50 },
4006 4007 4008
			{}
		}
	},
4009 4010 4011
	[PINFIX_ACER_ASPIRE_7736] = {
		.type = ALC_FIXUP_SKU,
		.v.sku = ALC_FIXUP_SKU_IGNORE,
4012
	},
4013 4014
};

4015 4016 4017 4018 4019
static const struct snd_pci_quirk alc882_fixup_tbl[] = {
	SND_PCI_QUIRK(0x1025, 0x0155, "Packard-Bell M5120", PINFIX_PB_M5210),
	SND_PCI_QUIRK(0x17aa, 0x3a0d, "Lenovo Y530", PINFIX_LENOVO_Y530),
	SND_PCI_QUIRK(0x147b, 0x107a, "Abit AW9D-MAX", PINFIX_ABIT_AW9D_MAX),
	SND_PCI_QUIRK(0x1025, 0x0296, "Acer Aspire 7736z", PINFIX_ACER_ASPIRE_7736),
4020 4021 4022
	{}
};

4023
/*
4024
 * BIOS auto configuration
4025
 */
4026 4027 4028 4029 4030 4031
/* almost identical with ALC880 parser... */
static int alc882_parse_auto_config(struct hda_codec *codec)
{
	struct alc_spec *spec = codec->spec;
	static const hda_nid_t alc882_ignore[] = { 0x1d, 0 };
	int err;
4032

4033 4034 4035 4036 4037 4038
	err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
					   alc882_ignore);
	if (err < 0)
		return err;
	if (!spec->autocfg.line_outs)
		return 0; /* can't find valid BIOS pin config */
4039

4040 4041 4042 4043 4044 4045 4046 4047 4048 4049 4050 4051 4052 4053 4054 4055 4056 4057
	err = alc_auto_fill_dac_nids(codec);
	if (err < 0)
		return err;
	err = alc_auto_add_multi_channel_mode(codec, alc_auto_fill_dac_nids);
	if (err < 0)
		return err;
	err = alc_auto_create_multi_out_ctls(codec, &spec->autocfg);
	if (err < 0)
		return err;
	err = alc_auto_create_hp_out(codec);
	if (err < 0)
		return err;
	err = alc_auto_create_speaker_out(codec);
	if (err < 0)
		return err;
	err = alc_auto_create_input_ctls(codec);
	if (err < 0)
		return err;
4058

4059
	spec->multiout.max_channels = spec->multiout.num_dacs * 2;
4060

4061
	alc_auto_parse_digital(codec);
4062

4063 4064
	if (spec->kctls.list)
		add_mixer(spec, spec->kctls.list);
4065

4066 4067 4068
	err = alc_auto_add_mic_boost(codec);
	if (err < 0)
		return err;
4069

4070
	alc_remove_invalid_adc_nids(codec);
4071

4072 4073
	alc_ssid_check(codec, 0x15, 0x1b, 0x14, 0);
	alc_auto_check_switches(codec);
4074

4075 4076
	return 1; /* config found */
}
4077

4078 4079 4080 4081 4082 4083 4084 4085 4086 4087 4088
/* additional initialization for auto-configuration model */
static void alc882_auto_init(struct hda_codec *codec)
{
	struct alc_spec *spec = codec->spec;
	alc_auto_init_multi_out(codec);
	alc_auto_init_extra_out(codec);
	alc_auto_init_analog_input(codec);
	alc_auto_init_input_src(codec);
	alc_auto_init_digital(codec);
	if (spec->unsol_event)
		alc_inithook(codec);
4089 4090
}

4091 4092 4093 4094 4095 4096 4097
/*
 */
#ifdef CONFIG_SND_HDA_ENABLE_REALTEK_QUIRKS
#include "alc882_quirks.c"
#endif

static int patch_alc882(struct hda_codec *codec)
4098 4099
{
	struct alc_spec *spec;
4100
	int err, board_config;
4101 4102 4103 4104 4105 4106 4107

	spec = kzalloc(sizeof(*spec), GFP_KERNEL);
	if (spec == NULL)
		return -ENOMEM;

	codec->spec = spec;

4108 4109
	spec->mixer_nid = 0x0b;

4110 4111 4112 4113 4114 4115 4116 4117
	switch (codec->vendor_id) {
	case 0x10ec0882:
	case 0x10ec0885:
		break;
	default:
		/* ALC883 and variants */
		alc_fix_pll_init(codec, 0x20, 0x0a, 10);
		break;
4118
	}
4119

4120 4121 4122 4123 4124 4125
	board_config = alc_board_config(codec, ALC882_MODEL_LAST,
					alc882_models, alc882_cfg_tbl);

	if (board_config < 0)
		board_config = alc_board_codec_sid_config(codec,
			ALC882_MODEL_LAST, alc882_models, alc882_ssid_cfg_tbl);
4126 4127

	if (board_config < 0) {
4128 4129
		printk(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
		       codec->chip_name);
4130
		board_config = ALC_MODEL_AUTO;
4131 4132
	}

4133 4134
	if (board_config == ALC_MODEL_AUTO) {
		alc_pick_fixup(codec, NULL, alc882_fixup_tbl, alc882_fixups);
4135 4136
		alc_apply_fixup(codec, ALC_FIXUP_ACT_PRE_PROBE);
	}
4137

4138 4139 4140
	alc_auto_parse_customize_define(codec);

	if (board_config == ALC_MODEL_AUTO) {
4141
		/* automatic parse from the BIOS config */
4142
		err = alc882_parse_auto_config(codec);
4143 4144 4145
		if (err < 0) {
			alc_free(codec);
			return err;
4146 4147 4148
		}
#ifdef CONFIG_SND_HDA_ENABLE_REALTEK_QUIRKS
		else if (!err) {
4149 4150 4151
			printk(KERN_INFO
			       "hda_codec: Cannot set up configuration "
			       "from BIOS.  Using base mode...\n");
4152
			board_config = ALC882_3ST_DIG;
4153
		}
4154
#endif
4155 4156
	}

4157
	if (has_cdefine_beep(codec)) {
4158 4159 4160 4161 4162
		err = snd_hda_attach_beep_device(codec, 0x1);
		if (err < 0) {
			alc_free(codec);
			return err;
		}
4163 4164
	}

4165 4166
	if (board_config != ALC_MODEL_AUTO)
		setup_preset(codec, &alc882_presets[board_config]);
4167

4168
	if (!spec->adc_nids && spec->input_mux) {
4169
		alc_auto_fill_adc_caps(codec);
4170
		alc_rebuild_imux_for_auto_mic(codec);
4171
		alc_remove_invalid_adc_nids(codec);
K
Kailang Yang 已提交
4172 4173
	}

4174 4175
	set_capture_mixer(codec);

4176
	if (has_cdefine_beep(codec))
4177
		set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
4178

4179
	alc_apply_fixup(codec, ALC_FIXUP_ACT_PROBE);
4180

4181
	spec->vmaster_nid = 0x0c;
4182

4183
	codec->patch_ops = alc_patch_ops;
4184 4185
	if (board_config == ALC_MODEL_AUTO)
		spec->init_hook = alc882_auto_init;
4186 4187

	alc_init_jacks(codec);
4188 4189
#ifdef CONFIG_SND_HDA_POWER_SAVE
	if (!spec->loopback.amplist)
4190
		spec->loopback.amplist = alc882_loopbacks;
4191 4192 4193 4194 4195
#endif

	return 0;
}

4196 4197

/*
4198
 * ALC262 support
4199
 */
4200

4201 4202 4203
/* We use two mixers depending on the output pin; 0x16 is a mono output
 * and thus it's bound with a different mixer.
 * This function returns which mixer amp should be used.
4204
 */
4205
static int alc262_check_volbit(hda_nid_t nid)
4206
{
4207 4208 4209 4210 4211 4212
	if (!nid)
		return 0;
	else if (nid == 0x16)
		return 2;
	else
		return 1;
4213 4214
}

4215 4216
static int alc262_add_out_vol_ctl(struct alc_spec *spec, hda_nid_t nid,
				  const char *pfx, int *vbits, int idx)
4217
{
4218 4219
	unsigned long val;
	int vbit;
4220

4221 4222
	vbit = alc262_check_volbit(nid);
	if (!vbit)
4223
		return 0;
4224
	if (*vbits & vbit) /* a volume control for this mixer already there */
4225
		return 0;
4226 4227 4228 4229 4230 4231
	*vbits |= vbit;
	if (vbit == 2)
		val = HDA_COMPOSE_AMP_VAL(0x0e, 2, 0, HDA_OUTPUT);
	else
		val = HDA_COMPOSE_AMP_VAL(0x0c, 3, 0, HDA_OUTPUT);
	return __add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL, pfx, idx, val);
4232 4233
}

4234 4235
static int alc262_add_out_sw_ctl(struct alc_spec *spec, hda_nid_t nid,
				 const char *pfx, int idx)
4236
{
4237
	unsigned long val;
4238

4239 4240 4241 4242 4243 4244 4245
	if (!nid)
		return 0;
	if (nid == 0x16)
		val = HDA_COMPOSE_AMP_VAL(nid, 2, 0, HDA_OUTPUT);
	else
		val = HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT);
	return __add_pb_sw_ctrl(spec, ALC_CTL_WIDGET_MUTE, pfx, idx, val);
4246 4247
}

4248
/* add playback controls from the parsed DAC table */
4249
static int alc262_auto_create_multi_out_ctls(struct alc_spec *spec,
4250 4251
					     const struct auto_pin_cfg *cfg)
{
4252 4253 4254
	const char *pfx;
	int vbits;
	int i, index, err;
4255

4256 4257 4258
	spec->multiout.num_dacs = 1;	/* only use one dac */
	spec->multiout.dac_nids = spec->private_dac_nids;
	spec->private_dac_nids[0] = 2;
4259

4260 4261 4262 4263 4264 4265 4266 4267 4268 4269 4270
	for (i = 0; i < 2; i++) {
		pfx = alc_get_line_out_pfx(spec, i, true, &index);
		if (!pfx)
			pfx = "PCM";
		err = alc262_add_out_sw_ctl(spec, cfg->line_out_pins[i], pfx,
					    index);
		if (err < 0)
			return err;
		if (cfg->line_out_type != AUTO_PIN_SPEAKER_OUT) {
			err = alc262_add_out_sw_ctl(spec, cfg->speaker_pins[i],
						    "Speaker", i);
4271
			if (err < 0)
4272
				return err;
4273 4274 4275 4276
		}
		if (cfg->line_out_type != AUTO_PIN_HP_OUT) {
			err = alc262_add_out_sw_ctl(spec, cfg->hp_pins[i],
						    "Headphone", i);
4277
			if (err < 0)
4278 4279 4280 4281
				return err;
		}
	}

4282 4283 4284 4285 4286 4287 4288 4289 4290 4291 4292 4293 4294 4295 4296 4297 4298 4299 4300 4301 4302
	vbits = alc262_check_volbit(cfg->line_out_pins[0]) |
		alc262_check_volbit(cfg->speaker_pins[0]) |
		alc262_check_volbit(cfg->hp_pins[0]);
	vbits = 0;
	for (i = 0; i < 2; i++) {
		pfx = alc_get_line_out_pfx(spec, i, true, &index);
		if (!pfx)
			pfx = "PCM";
		err = alc262_add_out_vol_ctl(spec, cfg->line_out_pins[i], pfx,
					     &vbits, i);
		if (err < 0)
			return err;
		if (cfg->line_out_type != AUTO_PIN_SPEAKER_OUT) {
			err = alc262_add_out_vol_ctl(spec, cfg->speaker_pins[i],
						     "Speaker", &vbits, i);
			if (err < 0)
				return err;
		}
		if (cfg->line_out_type != AUTO_PIN_HP_OUT) {
			err = alc262_add_out_vol_ctl(spec, cfg->hp_pins[i],
						     "Headphone", &vbits, i);
4303 4304 4305
			if (err < 0)
				return err;
		}
4306 4307 4308 4309
	}
	return 0;
}

4310 4311
/*
 * BIOS auto configuration
4312
 */
4313
static int alc262_parse_auto_config(struct hda_codec *codec)
4314 4315 4316
{
	struct alc_spec *spec = codec->spec;
	int err;
4317
	static const hda_nid_t alc262_ignore[] = { 0x1d, 0 };
4318

4319
	err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
4320
					   alc262_ignore);
4321
	if (err < 0)
4322
		return err;
4323 4324 4325 4326 4327 4328
	if (!spec->autocfg.line_outs) {
		if (spec->autocfg.dig_outs || spec->autocfg.dig_in_pin) {
			spec->multiout.max_channels = 2;
			spec->no_analog = 1;
			goto dig_only;
		}
4329
		return 0; /* can't find valid BIOS pin config */
4330 4331
	}
	err = alc262_auto_create_multi_out_ctls(spec, &spec->autocfg);
4332 4333
	if (err < 0)
		return err;
4334
	err = alc_auto_create_input_ctls(codec);
4335
	if (err < 0)
4336 4337 4338 4339
		return err;

	spec->multiout.max_channels = spec->multiout.num_dacs * 2;

4340
 dig_only:
4341
	alc_auto_parse_digital(codec);
4342

4343
	if (spec->kctls.list)
4344
		add_mixer(spec, spec->kctls.list);
4345

4346 4347 4348 4349
	err = alc_auto_add_mic_boost(codec);
	if (err < 0)
		return err;

4350
	alc_remove_invalid_adc_nids(codec);
4351

4352
	alc_ssid_check(codec, 0x15, 0x1b, 0x14, 0);
4353
	alc_auto_check_switches(codec);
4354

4355 4356 4357 4358
	return 1;
}

/*
4359
 * Pin config fixes
4360
 */
4361
enum {
4362 4363
	PINFIX_FSC_H270,
	PINFIX_HP_Z200,
4364 4365
};

4366 4367
static const struct alc_fixup alc262_fixups[] = {
	[PINFIX_FSC_H270] = {
4368 4369
		.type = ALC_FIXUP_PINS,
		.v.pins = (const struct alc_pincfg[]) {
4370 4371 4372 4373 4374 4375 4376 4377 4378 4379
			{ 0x14, 0x99130110 }, /* speaker */
			{ 0x15, 0x0221142f }, /* front HP */
			{ 0x1b, 0x0121141f }, /* rear HP */
			{ }
		}
	},
	[PINFIX_HP_Z200] = {
		.type = ALC_FIXUP_PINS,
		.v.pins = (const struct alc_pincfg[]) {
			{ 0x16, 0x99130120 }, /* internal speaker */
4380 4381
			{ }
		}
4382 4383 4384
	},
};

4385 4386 4387
static const struct snd_pci_quirk alc262_fixup_tbl[] = {
	SND_PCI_QUIRK(0x103c, 0x170b, "HP Z200", PINFIX_HP_Z200),
	SND_PCI_QUIRK(0x1734, 0x1147, "FSC Celsius H270", PINFIX_FSC_H270),
4388 4389
	{}
};
4390

4391 4392 4393 4394 4395 4396 4397 4398 4399 4400 4401 4402 4403 4404 4405 4406 4407 4408 4409 4410 4411 4412 4413 4414 4415

#ifdef CONFIG_SND_HDA_POWER_SAVE
#define alc262_loopbacks	alc880_loopbacks
#endif

/* init callback for auto-configuration model -- overriding the default init */
static void alc262_auto_init(struct hda_codec *codec)
{
	struct alc_spec *spec = codec->spec;
	alc_auto_init_multi_out(codec);
	alc_auto_init_extra_out(codec);
	alc_auto_init_analog_input(codec);
	alc_auto_init_input_src(codec);
	alc_auto_init_digital(codec);
	if (spec->unsol_event)
		alc_inithook(codec);
}

/*
 */
#ifdef CONFIG_SND_HDA_ENABLE_REALTEK_QUIRKS
#include "alc262_quirks.c"
#endif

static int patch_alc262(struct hda_codec *codec)
4416 4417 4418 4419 4420
{
	struct alc_spec *spec;
	int board_config;
	int err;

4421
	spec = kzalloc(sizeof(*spec), GFP_KERNEL);
4422 4423 4424
	if (spec == NULL)
		return -ENOMEM;

4425
	codec->spec = spec;
4426

4427 4428 4429 4430 4431 4432 4433 4434 4435 4436 4437 4438 4439 4440 4441
	spec->mixer_nid = 0x0b;

#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_auto_parse_customize_define(codec);
4442

4443 4444 4445 4446
	alc_fix_pll_init(codec, 0x20, 0x0a, 10);

	board_config = alc_board_config(codec, ALC262_MODEL_LAST,
					alc262_models, alc262_cfg_tbl);
4447

4448
	if (board_config < 0) {
4449 4450
		printk(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
		       codec->chip_name);
4451
		board_config = ALC_MODEL_AUTO;
4452 4453
	}

4454 4455
	if (board_config == ALC_MODEL_AUTO) {
		alc_pick_fixup(codec, NULL, alc262_fixup_tbl, alc262_fixups);
4456 4457
		alc_apply_fixup(codec, ALC_FIXUP_ACT_PRE_PROBE);
	}
4458

4459
	if (board_config == ALC_MODEL_AUTO) {
4460
		/* automatic parse from the BIOS config */
4461
		err = alc262_parse_auto_config(codec);
4462 4463 4464
		if (err < 0) {
			alc_free(codec);
			return err;
4465 4466 4467
		}
#ifdef CONFIG_SND_HDA_ENABLE_REALTEK_QUIRKS
		else if (!err) {
4468 4469 4470
			printk(KERN_INFO
			       "hda_codec: Cannot set up configuration "
			       "from BIOS.  Using base mode...\n");
4471
			board_config = ALC262_BASIC;
4472
		}
4473
#endif
4474 4475
	}

4476 4477 4478 4479 4480 4481
	if (!spec->no_analog && has_cdefine_beep(codec)) {
		err = snd_hda_attach_beep_device(codec, 0x1);
		if (err < 0) {
			alc_free(codec);
			return err;
		}
4482 4483
	}

4484 4485
	if (board_config != ALC_MODEL_AUTO)
		setup_preset(codec, &alc262_presets[board_config]);
4486

4487
	if (!spec->adc_nids && spec->input_mux) {
4488 4489 4490 4491
		alc_auto_fill_adc_caps(codec);
		alc_rebuild_imux_for_auto_mic(codec);
		alc_remove_invalid_adc_nids(codec);
	}
4492
	if (!spec->cap_mixer && !spec->no_analog)
4493
		set_capture_mixer(codec);
4494 4495
	if (!spec->no_analog && has_cdefine_beep(codec))
		set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
4496

4497
	alc_apply_fixup(codec, ALC_FIXUP_ACT_PROBE);
4498

4499 4500
	spec->vmaster_nid = 0x0c;

4501
	codec->patch_ops = alc_patch_ops;
4502 4503 4504 4505 4506
	if (board_config == ALC_MODEL_AUTO)
		spec->init_hook = alc262_auto_init;
	spec->shutup = alc_eapd_shutup;

	alc_init_jacks(codec);
4507 4508
#ifdef CONFIG_SND_HDA_POWER_SAVE
	if (!spec->loopback.amplist)
4509
		spec->loopback.amplist = alc262_loopbacks;
4510
#endif
4511

L
Linus Torvalds 已提交
4512 4513 4514
	return 0;
}

4515
/*
4516
 *  ALC268
4517
 */
4518 4519 4520 4521 4522 4523
/* create input playback/capture controls for the given pin */
static int alc268_new_analog_output(struct alc_spec *spec, hda_nid_t nid,
				    const char *ctlname, int idx)
{
	hda_nid_t dac;
	int err;
4524

4525 4526 4527 4528 4529 4530 4531 4532 4533 4534 4535 4536 4537 4538 4539 4540 4541 4542 4543 4544 4545 4546 4547 4548 4549
	switch (nid) {
	case 0x14:
	case 0x16:
		dac = 0x02;
		break;
	case 0x15:
	case 0x1a: /* ALC259/269 only */
	case 0x1b: /* ALC259/269 only */
	case 0x21: /* ALC269vb has this pin, too */
		dac = 0x03;
		break;
	default:
		snd_printd(KERN_WARNING "hda_codec: "
			   "ignoring pin 0x%x as unknown\n", nid);
		return 0;
	}
	if (spec->multiout.dac_nids[0] != dac &&
	    spec->multiout.dac_nids[1] != dac) {
		err = add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL, ctlname,
				  HDA_COMPOSE_AMP_VAL(dac, 3, idx,
						      HDA_OUTPUT));
		if (err < 0)
			return err;
		spec->private_dac_nids[spec->multiout.num_dacs++] = dac;
	}
4550

4551 4552 4553 4554 4555 4556 4557 4558 4559 4560
	if (nid != 0x16)
		err = add_pb_sw_ctrl(spec, ALC_CTL_WIDGET_MUTE, ctlname,
			  HDA_COMPOSE_AMP_VAL(nid, 3, idx, HDA_OUTPUT));
	else /* mono */
		err = add_pb_sw_ctrl(spec, ALC_CTL_WIDGET_MUTE, ctlname,
			  HDA_COMPOSE_AMP_VAL(nid, 2, idx, HDA_OUTPUT));
	if (err < 0)
		return err;
	return 0;
}
4561

4562 4563 4564 4565 4566 4567
/* add playback controls from the parsed DAC table */
static int alc268_auto_create_multi_out_ctls(struct alc_spec *spec,
					     const struct auto_pin_cfg *cfg)
{
	hda_nid_t nid;
	int err;
4568

4569
	spec->multiout.dac_nids = spec->private_dac_nids;
4570

4571 4572 4573 4574 4575 4576 4577 4578 4579
	nid = cfg->line_out_pins[0];
	if (nid) {
		const char *name;
		int index;
		name = alc_get_line_out_pfx(spec, 0, true, &index);
		err = alc268_new_analog_output(spec, nid, name, 0);
		if (err < 0)
			return err;
	}
4580

4581 4582 4583 4584 4585 4586 4587 4588 4589 4590 4591 4592 4593 4594 4595 4596 4597
	nid = cfg->speaker_pins[0];
	if (nid == 0x1d) {
		err = add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL, "Speaker",
				  HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_INPUT));
		if (err < 0)
			return err;
	} else if (nid) {
		err = alc268_new_analog_output(spec, nid, "Speaker", 0);
		if (err < 0)
			return err;
	}
	nid = cfg->hp_pins[0];
	if (nid) {
		err = alc268_new_analog_output(spec, nid, "Headphone", 0);
		if (err < 0)
			return err;
	}
4598

4599 4600 4601 4602 4603 4604 4605 4606 4607
	nid = cfg->line_out_pins[1] | cfg->line_out_pins[2];
	if (nid == 0x16) {
		err = add_pb_sw_ctrl(spec, ALC_CTL_WIDGET_MUTE, "Mono",
				  HDA_COMPOSE_AMP_VAL(nid, 2, 0, HDA_OUTPUT));
		if (err < 0)
			return err;
	}
	return 0;
}
4608

4609 4610 4611 4612
static void alc268_auto_set_output_and_unmute(struct hda_codec *codec,
					      hda_nid_t nid, int pin_type)
{
	int idx;
4613

4614 4615 4616 4617 4618 4619 4620 4621 4622
	alc_set_pin_output(codec, nid, pin_type);
	if (snd_hda_get_conn_list(codec, nid, NULL) <= 1)
		return;
	if (nid == 0x14 || nid == 0x16)
		idx = 0;
	else
		idx = 1;
	snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_CONNECT_SEL, idx);
}
4623

4624 4625 4626 4627 4628 4629 4630
static void alc268_auto_init_dac(struct hda_codec *codec, hda_nid_t nid)
{
	if (!nid)
		return;
	snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_AMP_GAIN_MUTE,
			    AMP_OUT_ZERO);
}
4631

4632
static void alc268_auto_init_multi_out(struct hda_codec *codec)
4633
{
4634
	struct alc_spec *spec = codec->spec;
4635
	int i;
4636

4637 4638 4639 4640 4641 4642 4643 4644
	for (i = 0; i < spec->autocfg.line_outs; i++) {
		hda_nid_t nid = spec->autocfg.line_out_pins[i];
		int pin_type = get_pin_type(spec->autocfg.line_out_type);
		alc268_auto_set_output_and_unmute(codec, nid, pin_type);
	}
	/* mute DACs */
	for (i = 0; i < spec->multiout.num_dacs; i++)
		alc268_auto_init_dac(codec, spec->multiout.dac_nids[i]);
4645 4646
}

4647
static void alc268_auto_init_hp_out(struct hda_codec *codec)
4648
{
4649 4650 4651 4652 4653 4654 4655 4656 4657 4658 4659
	struct alc_spec *spec = codec->spec;
	hda_nid_t pin;
	int i;

	for (i = 0; i < spec->autocfg.hp_outs; i++) {
		pin = spec->autocfg.hp_pins[i];
		alc268_auto_set_output_and_unmute(codec, pin, PIN_HP);
	}
	for (i = 0; i < spec->autocfg.speaker_outs; i++) {
		pin = spec->autocfg.speaker_pins[i];
		alc268_auto_set_output_and_unmute(codec, pin, PIN_OUT);
4660
	}
4661 4662 4663 4664 4665 4666 4667
	if (spec->autocfg.mono_out_pin)
		snd_hda_codec_write(codec, spec->autocfg.mono_out_pin, 0,
				    AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT);
	/* mute DACs */
	alc268_auto_init_dac(codec, spec->multiout.hp_nid);
	for (i = 0; i < ARRAY_SIZE(spec->multiout.extra_out_nid); i++)
		alc268_auto_init_dac(codec, spec->multiout.extra_out_nid[i]);
4668 4669
}

4670
static void alc268_auto_init_mono_speaker_out(struct hda_codec *codec)
4671
{
4672
	struct alc_spec *spec = codec->spec;
4673 4674 4675 4676
	hda_nid_t speaker_nid = spec->autocfg.speaker_pins[0];
	hda_nid_t hp_nid = spec->autocfg.hp_pins[0];
	hda_nid_t line_nid = spec->autocfg.line_out_pins[0];
	unsigned int	dac_vol1, dac_vol2;
4677

4678 4679 4680 4681 4682 4683 4684 4685 4686 4687 4688 4689 4690 4691 4692 4693 4694
	if (line_nid == 0x1d || speaker_nid == 0x1d) {
		snd_hda_codec_write(codec, speaker_nid, 0,
				    AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT);
		/* mute mixer inputs from 0x1d */
		snd_hda_codec_write(codec, 0x0f, 0,
				    AC_VERB_SET_AMP_GAIN_MUTE,
				    AMP_IN_UNMUTE(1));
		snd_hda_codec_write(codec, 0x10, 0,
				    AC_VERB_SET_AMP_GAIN_MUTE,
				    AMP_IN_UNMUTE(1));
	} else {
		/* unmute mixer inputs from 0x1d */
		snd_hda_codec_write(codec, 0x0f, 0,
				    AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1));
		snd_hda_codec_write(codec, 0x10, 0,
				    AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1));
	}
4695

4696 4697 4698 4699 4700 4701 4702 4703 4704 4705 4706 4707 4708
	dac_vol1 = dac_vol2 = 0xb000 | 0x40;	/* set max volume  */
	if (line_nid == 0x14)
		dac_vol2 = AMP_OUT_ZERO;
	else if (line_nid == 0x15)
		dac_vol1 = AMP_OUT_ZERO;
	if (hp_nid == 0x14)
		dac_vol2 = AMP_OUT_ZERO;
	else if (hp_nid == 0x15)
		dac_vol1 = AMP_OUT_ZERO;
	if (line_nid != 0x16 || hp_nid != 0x16 ||
	    spec->autocfg.line_out_pins[1] != 0x16 ||
	    spec->autocfg.line_out_pins[2] != 0x16)
		dac_vol1 = dac_vol2 = AMP_OUT_ZERO;
4709

4710 4711 4712 4713 4714 4715 4716 4717 4718 4719 4720 4721 4722 4723
	snd_hda_codec_write(codec, 0x02, 0,
			    AC_VERB_SET_AMP_GAIN_MUTE, dac_vol1);
	snd_hda_codec_write(codec, 0x03, 0,
			    AC_VERB_SET_AMP_GAIN_MUTE, dac_vol2);
}

/* 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
	},
4724 4725
};

4726 4727 4728 4729
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),
	{ }
4730 4731
};

4732 4733 4734 4735 4736 4737
/* 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)},
	{ }
4738 4739 4740 4741 4742
};

/*
 * BIOS auto configuration
 */
4743
static int alc268_parse_auto_config(struct hda_codec *codec)
4744 4745 4746
{
	struct alc_spec *spec = codec->spec;
	int err;
4747
	static const hda_nid_t alc268_ignore[] = { 0 };
4748

4749 4750
	err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
					   alc268_ignore);
4751 4752
	if (err < 0)
		return err;
4753 4754 4755 4756 4757 4758 4759 4760 4761
	if (!spec->autocfg.line_outs) {
		if (spec->autocfg.dig_outs || spec->autocfg.dig_in_pin) {
			spec->multiout.max_channels = 2;
			spec->no_analog = 1;
			goto dig_only;
		}
		return 0; /* can't find valid BIOS pin config */
	}
	err = alc268_auto_create_multi_out_ctls(spec, &spec->autocfg);
4762 4763
	if (err < 0)
		return err;
4764
	err = alc_auto_create_input_ctls(codec);
4765
	if (err < 0)
4766 4767
		return err;

4768
	spec->multiout.max_channels = 2;
4769

4770 4771
 dig_only:
	/* digital only support output */
4772
	alc_auto_parse_digital(codec);
4773
	if (spec->kctls.list)
4774
		add_mixer(spec, spec->kctls.list);
4775

4776 4777 4778 4779
	if (!spec->no_analog && spec->autocfg.speaker_pins[0] != 0x1d) {
		add_mixer(spec, alc268_beep_mixer);
		add_verb(spec, alc268_beep_init_verbs);
	}
4780

4781 4782 4783 4784
	err = alc_auto_add_mic_boost(codec);
	if (err < 0)
		return err;

4785 4786 4787 4788 4789
	alc_remove_invalid_adc_nids(codec);

	alc_ssid_check(codec, 0x15, 0x1b, 0x14, 0);
	alc_auto_check_switches(codec);

4790 4791 4792
	return 1;
}

4793 4794
/* init callback for auto-configuration model -- overriding the default init */
static void alc268_auto_init(struct hda_codec *codec)
4795
{
4796
	struct alc_spec *spec = codec->spec;
4797 4798 4799
	alc268_auto_init_multi_out(codec);
	alc268_auto_init_hp_out(codec);
	alc268_auto_init_mono_speaker_out(codec);
4800
	alc_auto_init_analog_input(codec);
4801
	alc_auto_init_input_src(codec);
4802
	alc_auto_init_digital(codec);
4803
	if (spec->unsol_event)
4804
		alc_inithook(codec);
4805 4806
}

4807 4808 4809 4810 4811
/*
 */
#ifdef CONFIG_SND_HDA_ENABLE_REALTEK_QUIRKS
#include "alc268_quirks.c"
#endif
4812

4813
static int patch_alc268(struct hda_codec *codec)
4814 4815
{
	struct alc_spec *spec;
4816 4817
	int board_config;
	int i, has_beep, err;
4818 4819 4820 4821 4822 4823 4824

	spec = kzalloc(sizeof(*spec), GFP_KERNEL);
	if (spec == NULL)
		return -ENOMEM;

	codec->spec = spec;

4825
	/* ALC268 has no aa-loopback mixer */
4826

4827 4828
	board_config = alc_board_config(codec, ALC268_MODEL_LAST,
					alc268_models, alc268_cfg_tbl);
4829

4830 4831 4832 4833 4834
	if (board_config < 0)
		board_config = alc_board_codec_sid_config(codec,
			ALC268_MODEL_LAST, alc268_models, alc268_ssid_cfg_tbl);

	if (board_config < 0) {
4835 4836
		printk(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
		       codec->chip_name);
4837
		board_config = ALC_MODEL_AUTO;
4838
	}
4839

4840
	if (board_config == ALC_MODEL_AUTO) {
4841
		/* automatic parse from the BIOS config */
4842
		err = alc268_parse_auto_config(codec);
4843 4844 4845
		if (err < 0) {
			alc_free(codec);
			return err;
4846 4847 4848
		}
#ifdef CONFIG_SND_HDA_ENABLE_REALTEK_QUIRKS
		else if (!err) {
4849 4850 4851
			printk(KERN_INFO
			       "hda_codec: Cannot set up configuration "
			       "from BIOS.  Using base mode...\n");
4852
			board_config = ALC268_3ST;
4853
		}
4854
#endif
4855 4856
	}

4857 4858
	if (board_config != ALC_MODEL_AUTO)
		setup_preset(codec, &alc268_presets[board_config]);
4859

4860 4861 4862 4863 4864 4865 4866
	has_beep = 0;
	for (i = 0; i < spec->num_mixers; i++) {
		if (spec->mixers[i] == alc268_beep_mixer) {
			has_beep = 1;
			break;
		}
	}
4867

4868 4869 4870 4871 4872 4873 4874 4875 4876 4877 4878 4879 4880
	if (has_beep) {
		err = snd_hda_attach_beep_device(codec, 0x1);
		if (err < 0) {
			alc_free(codec);
			return err;
		}
		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));
4881 4882
	}

4883
	if (!spec->no_analog && !spec->adc_nids && spec->input_mux) {
4884
		alc_auto_fill_adc_caps(codec);
4885
		alc_rebuild_imux_for_auto_mic(codec);
4886
		alc_remove_invalid_adc_nids(codec);
4887
	}
4888

4889 4890
	if (!spec->cap_mixer && !spec->no_analog)
		set_capture_mixer(codec);
4891

4892 4893
	spec->vmaster_nid = 0x02;

4894
	codec->patch_ops = alc_patch_ops;
4895 4896
	if (board_config == ALC_MODEL_AUTO)
		spec->init_hook = alc268_auto_init;
4897
	spec->shutup = alc_eapd_shutup;
4898 4899

	alc_init_jacks(codec);
4900 4901 4902 4903

	return 0;
}

4904
/*
4905
 * ALC269
4906
 */
4907 4908
#define alc269_auto_create_multi_out_ctls \
	alc268_auto_create_multi_out_ctls
4909

4910 4911 4912
#ifdef CONFIG_SND_HDA_POWER_SAVE
#define alc269_loopbacks	alc880_loopbacks
#endif
4913

4914 4915 4916 4917 4918 4919 4920 4921 4922 4923
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 = {
		.open = alc_playback_pcm_open,
		.prepare = alc_playback_pcm_prepare,
		.cleanup = alc_playback_pcm_cleanup
4924 4925 4926
	},
};

4927 4928 4929 4930 4931 4932
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 */
4933
};
4934

4935 4936 4937 4938 4939 4940 4941 4942 4943
#ifdef CONFIG_SND_HDA_POWER_SAVE
static int alc269_mic2_for_mute_led(struct hda_codec *codec)
{
	switch (codec->subsystem_id) {
	case 0x103c1586:
		return 1;
	}
	return 0;
}
K
Kailang Yang 已提交
4944

4945 4946 4947 4948 4949 4950 4951 4952 4953 4954 4955 4956 4957 4958 4959 4960 4961 4962
static int alc269_mic2_mute_check_ps(struct hda_codec *codec, hda_nid_t nid)
{
	/* update mute-LED according to the speaker mute state */
	if (nid == 0x01 || nid == 0x14) {
		int pinval;
		if (snd_hda_codec_amp_read(codec, 0x14, 0, HDA_OUTPUT, 0) &
		    HDA_AMP_MUTE)
			pinval = 0x24;
		else
			pinval = 0x20;
		/* mic2 vref pin is used for mute LED control */
		snd_hda_codec_update_cache(codec, 0x19, 0,
					   AC_VERB_SET_PIN_WIDGET_CONTROL,
					   pinval);
	}
	return alc_check_power_status(codec, nid);
}
#endif /* CONFIG_SND_HDA_POWER_SAVE */
4963

4964 4965 4966 4967 4968
/* different alc269-variants */
enum {
	ALC269_TYPE_ALC269VA,
	ALC269_TYPE_ALC269VB,
	ALC269_TYPE_ALC269VC,
4969 4970 4971
};

/*
4972
 * BIOS auto configuration
4973
 */
4974 4975 4976 4977 4978
static int alc269_parse_auto_config(struct hda_codec *codec)
{
	struct alc_spec *spec = codec->spec;
	int err;
	static const hda_nid_t alc269_ignore[] = { 0x1d, 0 };
4979

4980 4981 4982 4983
	err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
					   alc269_ignore);
	if (err < 0)
		return err;
4984

4985 4986 4987 4988 4989 4990
	err = alc269_auto_create_multi_out_ctls(spec, &spec->autocfg);
	if (err < 0)
		return err;
	err = alc_auto_create_input_ctls(codec);
	if (err < 0)
		return err;
4991

4992
	spec->multiout.max_channels = spec->multiout.num_dacs * 2;
4993

4994
	alc_auto_parse_digital(codec);
4995

4996 4997
	if (spec->kctls.list)
		add_mixer(spec, spec->kctls.list);
4998

4999 5000 5001 5002 5003 5004 5005 5006 5007 5008 5009
	alc_remove_invalid_adc_nids(codec);

	if (spec->codec_variant != ALC269_TYPE_ALC269VA)
		alc_ssid_check(codec, 0, 0x1b, 0x14, 0x21);
	else
		alc_ssid_check(codec, 0x15, 0x1b, 0x14, 0);
	alc_auto_check_switches(codec);

	err = alc_auto_add_mic_boost(codec);
	if (err < 0)
		return err;
5010

5011 5012
	if (!spec->cap_mixer && !spec->no_analog)
		set_capture_mixer(codec);
5013

5014 5015
	return 1;
}
5016

5017 5018
#define alc269_auto_init_multi_out	alc268_auto_init_multi_out
#define alc269_auto_init_hp_out		alc268_auto_init_hp_out
5019 5020


5021 5022 5023 5024 5025 5026 5027 5028 5029 5030 5031 5032
/* init callback for auto-configuration model -- overriding the default init */
static void alc269_auto_init(struct hda_codec *codec)
{
	struct alc_spec *spec = codec->spec;
	alc269_auto_init_multi_out(codec);
	alc269_auto_init_hp_out(codec);
	alc_auto_init_analog_input(codec);
	alc_auto_init_input_src(codec);
	alc_auto_init_digital(codec);
	if (spec->unsol_event)
		alc_inithook(codec);
}
5033

5034 5035 5036 5037 5038 5039 5040 5041 5042
static void alc269_toggle_power_output(struct hda_codec *codec, int power_up)
{
	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);
}
5043

5044 5045 5046 5047 5048 5049 5050 5051 5052
static void alc269_shutup(struct hda_codec *codec)
{
	if ((alc_read_coef_idx(codec, 0) & 0x00ff) == 0x017)
		alc269_toggle_power_output(codec, 0);
	if ((alc_read_coef_idx(codec, 0) & 0x00ff) == 0x018) {
		alc269_toggle_power_output(codec, 0);
		msleep(150);
	}
}
5053

5054 5055 5056 5057 5058 5059 5060
#ifdef SND_HDA_NEEDS_RESUME
static int alc269_resume(struct hda_codec *codec)
{
	if ((alc_read_coef_idx(codec, 0) & 0x00ff) == 0x018) {
		alc269_toggle_power_output(codec, 0);
		msleep(150);
	}
5061

5062
	codec->patch_ops.init(codec);
5063

5064 5065 5066 5067
	if ((alc_read_coef_idx(codec, 0) & 0x00ff) == 0x017) {
		alc269_toggle_power_output(codec, 1);
		msleep(200);
	}
5068

5069 5070
	if ((alc_read_coef_idx(codec, 0) & 0x00ff) == 0x018)
		alc269_toggle_power_output(codec, 1);
5071

5072 5073 5074 5075 5076 5077
	snd_hda_codec_resume_amp(codec);
	snd_hda_codec_resume_cache(codec);
	hda_call_check_power_status(codec, 0x01);
	return 0;
}
#endif /* SND_HDA_NEEDS_RESUME */
5078

5079 5080 5081 5082
static void alc269_fixup_hweq(struct hda_codec *codec,
			       const struct alc_fixup *fix, int action)
{
	int coef;
5083

5084 5085 5086 5087 5088
	if (action != ALC_FIXUP_ACT_INIT)
		return;
	coef = alc_read_coef_idx(codec, 0x1e);
	alc_write_coef_idx(codec, 0x1e, coef | 0x80);
}
5089

5090 5091 5092 5093 5094 5095 5096 5097 5098
static void alc271_fixup_dmic(struct hda_codec *codec,
			      const struct alc_fixup *fix, int action)
{
	static const struct hda_verb verbs[] = {
		{0x20, AC_VERB_SET_COEF_INDEX, 0x0d},
		{0x20, AC_VERB_SET_PROC_COEF, 0x4000},
		{}
	};
	unsigned int cfg;
5099

5100 5101 5102 5103 5104 5105
	if (strcmp(codec->chip_name, "ALC271X"))
		return;
	cfg = snd_hda_codec_get_pincfg(codec, 0x12);
	if (get_defcfg_connect(cfg) == AC_JACK_PORT_FIXED)
		snd_hda_sequence_write(codec, verbs);
}
5106

5107 5108 5109 5110 5111 5112 5113 5114 5115
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,
5116 5117
};

5118 5119 5120 5121 5122 5123 5124
static const struct alc_fixup alc269_fixups[] = {
	[ALC269_FIXUP_SONY_VAIO] = {
		.type = ALC_FIXUP_VERBS,
		.v.verbs = (const struct hda_verb[]) {
			{0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREFGRD},
			{}
		}
5125
	},
5126 5127 5128 5129 5130 5131 5132 5133 5134 5135 5136 5137 5138 5139 5140 5141 5142 5143 5144 5145 5146 5147 5148 5149 5150 5151 5152 5153 5154 5155 5156 5157 5158 5159 5160 5161 5162 5163 5164 5165 5166 5167 5168 5169 5170 5171 5172
	[ALC275_FIXUP_SONY_VAIO_GPIO2] = {
		.type = ALC_FIXUP_VERBS,
		.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] = {
		.type = ALC_FIXUP_VERBS,
		.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] = {
		.type = ALC_FIXUP_SKU,
		.v.sku = ALC_FIXUP_SKU_IGNORE,
	},
	[ALC269_FIXUP_ASUS_G73JW] = {
		.type = ALC_FIXUP_PINS,
		.v.pins = (const struct alc_pincfg[]) {
			{ 0x17, 0x99130111 }, /* subwoofer */
			{ }
		}
	},
	[ALC269_FIXUP_LENOVO_EAPD] = {
		.type = ALC_FIXUP_VERBS,
		.v.verbs = (const struct hda_verb[]) {
			{0x14, AC_VERB_SET_EAPD_BTLENABLE, 0},
			{}
		}
	},
	[ALC275_FIXUP_SONY_HWEQ] = {
		.type = ALC_FIXUP_FUNC,
		.v.func = alc269_fixup_hweq,
		.chained = true,
		.chain_id = ALC275_FIXUP_SONY_VAIO_GPIO2
	},
	[ALC271_FIXUP_DMIC] = {
		.type = ALC_FIXUP_FUNC,
		.v.func = alc271_fixup_dmic,
5173 5174 5175
	},
};

5176 5177 5178 5179 5180 5181 5182 5183 5184 5185 5186 5187 5188 5189 5190
static const struct snd_pci_quirk alc269_fixup_tbl[] = {
	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),
	SND_PCI_QUIRK(0x1028, 0x0470, "Dell M101z", ALC269_FIXUP_DELL_M101Z),
	SND_PCI_QUIRK_VENDOR(0x1025, "Acer Aspire", ALC271_FIXUP_DMIC),
	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),
	SND_PCI_QUIRK(0x1043, 0x1a13, "Asus G73Jw", ALC269_FIXUP_ASUS_G73JW),
	SND_PCI_QUIRK(0x17aa, 0x9e54, "LENOVO NB", ALC269_FIXUP_LENOVO_EAPD),
	{}
K
Kailang Yang 已提交
5191 5192 5193
};


5194 5195 5196
static int alc269_fill_coef(struct hda_codec *codec)
{
	int val;
5197

5198 5199 5200 5201
	if ((alc_read_coef_idx(codec, 0) & 0x00ff) < 0x015) {
		alc_write_coef_idx(codec, 0xf, 0x960b);
		alc_write_coef_idx(codec, 0xe, 0x8817);
	}
5202

5203 5204 5205 5206
	if ((alc_read_coef_idx(codec, 0) & 0x00ff) == 0x016) {
		alc_write_coef_idx(codec, 0xf, 0x960b);
		alc_write_coef_idx(codec, 0xe, 0x8814);
	}
5207

5208 5209 5210 5211 5212
	if ((alc_read_coef_idx(codec, 0) & 0x00ff) == 0x017) {
		val = alc_read_coef_idx(codec, 0x04);
		/* Power up output pin */
		alc_write_coef_idx(codec, 0x04, val | (1<<11));
	}
5213

5214 5215 5216 5217 5218 5219 5220 5221 5222 5223 5224 5225
	if ((alc_read_coef_idx(codec, 0) & 0x00ff) == 0x018) {
		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));
		}
	}
5226

5227 5228
	val = alc_read_coef_idx(codec, 0xd); /* Class D */
	alc_write_coef_idx(codec, 0xd, val | (1<<14));
5229

5230 5231
	val = alc_read_coef_idx(codec, 0x4); /* HP */
	alc_write_coef_idx(codec, 0x4, val | (1<<11));
K
Kailang Yang 已提交
5232

5233 5234
	return 0;
}
5235

5236 5237 5238 5239 5240
/*
 */
#ifdef CONFIG_SND_HDA_ENABLE_REALTEK_QUIRKS
#include "alc269_quirks.c"
#endif
5241

5242 5243 5244 5245 5246
static int patch_alc269(struct hda_codec *codec)
{
	struct alc_spec *spec;
	int board_config, coef;
	int err;
5247

5248 5249 5250
	spec = kzalloc(sizeof(*spec), GFP_KERNEL);
	if (spec == NULL)
		return -ENOMEM;
5251

5252
	codec->spec = spec;
5253

5254
	spec->mixer_nid = 0x0b;
5255

5256
	alc_auto_parse_customize_define(codec);
5257

5258 5259 5260 5261 5262 5263 5264 5265 5266 5267 5268 5269 5270 5271 5272 5273 5274 5275 5276 5277 5278 5279 5280 5281 5282 5283 5284 5285 5286 5287 5288 5289
	if (codec->vendor_id == 0x10ec0269) {
		spec->codec_variant = ALC269_TYPE_ALC269VA;
		coef = alc_read_coef_idx(codec, 0);
		if ((coef & 0x00f0) == 0x0010) {
			if (codec->bus->pci->subsystem_vendor == 0x1025 &&
			    spec->cdefine.platform_type == 1) {
				alc_codec_rename(codec, "ALC271X");
			} else if ((coef & 0xf000) == 0x2000) {
				alc_codec_rename(codec, "ALC259");
			} else if ((coef & 0xf000) == 0x3000) {
				alc_codec_rename(codec, "ALC258");
			} else if ((coef & 0xfff0) == 0x3010) {
				alc_codec_rename(codec, "ALC277");
			} else {
				alc_codec_rename(codec, "ALC269VB");
			}
			spec->codec_variant = ALC269_TYPE_ALC269VB;
		} else if ((coef & 0x00f0) == 0x0020) {
			if (coef == 0xa023)
				alc_codec_rename(codec, "ALC259");
			else if (coef == 0x6023)
				alc_codec_rename(codec, "ALC281X");
			else if (codec->bus->pci->subsystem_vendor == 0x17aa &&
				 codec->bus->pci->subsystem_device == 0x21f3)
				alc_codec_rename(codec, "ALC3202");
			else
				alc_codec_rename(codec, "ALC269VC");
			spec->codec_variant = ALC269_TYPE_ALC269VC;
		} else
			alc_fix_pll_init(codec, 0x20, 0x04, 15);
		alc269_fill_coef(codec);
	}
K
Kailang Yang 已提交
5290

5291 5292
	board_config = alc_board_config(codec, ALC269_MODEL_LAST,
					alc269_models, alc269_cfg_tbl);
K
Kailang Yang 已提交
5293

5294 5295 5296 5297 5298
	if (board_config < 0) {
		printk(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
		       codec->chip_name);
		board_config = ALC_MODEL_AUTO;
	}
5299

5300 5301 5302 5303
	if (board_config == ALC_MODEL_AUTO) {
		alc_pick_fixup(codec, NULL, alc269_fixup_tbl, alc269_fixups);
		alc_apply_fixup(codec, ALC_FIXUP_ACT_PRE_PROBE);
	}
K
Kailang Yang 已提交
5304

5305 5306 5307 5308 5309 5310 5311 5312 5313 5314 5315 5316 5317 5318 5319 5320
	if (board_config == ALC_MODEL_AUTO) {
		/* automatic parse from the BIOS config */
		err = alc269_parse_auto_config(codec);
		if (err < 0) {
			alc_free(codec);
			return err;
		}
#ifdef CONFIG_SND_HDA_ENABLE_REALTEK_QUIRKS
		else if (!err) {
			printk(KERN_INFO
			       "hda_codec: Cannot set up configuration "
			       "from BIOS.  Using base mode...\n");
			board_config = ALC269_BASIC;
		}
#endif
	}
K
Kailang Yang 已提交
5321

5322 5323 5324 5325 5326 5327 5328
	if (has_cdefine_beep(codec)) {
		err = snd_hda_attach_beep_device(codec, 0x1);
		if (err < 0) {
			alc_free(codec);
			return err;
		}
	}
K
Kailang Yang 已提交
5329

5330 5331
	if (board_config != ALC_MODEL_AUTO)
		setup_preset(codec, &alc269_presets[board_config]);
K
Kailang Yang 已提交
5332

5333 5334 5335 5336 5337 5338 5339 5340 5341
#if 0
	if (board_config == ALC269_QUANTA_FL1) {
		/* Due to a hardware problem on Lenovo Ideadpad, we need to
		 * fix the sample rate of analog I/O to 44.1kHz
		 */
		spec->stream_analog_playback = &alc269_44k_pcm_analog_playback;
		spec->stream_analog_capture = &alc269_44k_pcm_analog_capture;
	}
#endif
K
Kailang Yang 已提交
5342

5343 5344 5345 5346 5347
	if (!spec->adc_nids) { /* wasn't filled automatically? use default */
		alc_auto_fill_adc_caps(codec);
		alc_rebuild_imux_for_auto_mic(codec);
		alc_remove_invalid_adc_nids(codec);
	}
K
Kailang Yang 已提交
5348

5349 5350 5351 5352
	if (!spec->cap_mixer)
		set_capture_mixer(codec);
	if (has_cdefine_beep(codec))
		set_beep_amp(spec, 0x0b, 0x04, HDA_INPUT);
5353

5354
	alc_apply_fixup(codec, ALC_FIXUP_ACT_PROBE);
5355

5356
	spec->vmaster_nid = 0x02;
5357

5358 5359 5360 5361 5362 5363 5364
	codec->patch_ops = alc_patch_ops;
#ifdef SND_HDA_NEEDS_RESUME
	codec->patch_ops.resume = alc269_resume;
#endif
	if (board_config == ALC_MODEL_AUTO)
		spec->init_hook = alc269_auto_init;
	spec->shutup = alc269_shutup;
5365

5366 5367 5368 5369 5370 5371 5372
	alc_init_jacks(codec);
#ifdef CONFIG_SND_HDA_POWER_SAVE
	if (!spec->loopback.amplist)
		spec->loopback.amplist = alc269_loopbacks;
	if (alc269_mic2_for_mute_led(codec))
		codec->patch_ops.check_power_status = alc269_mic2_mute_check_ps;
#endif
5373

5374 5375
	return 0;
}
5376

5377 5378 5379
/*
 * ALC861
 */
5380

5381
static hda_nid_t alc861_look_for_dac(struct hda_codec *codec, hda_nid_t pin)
5382
{
5383
	struct alc_spec *spec = codec->spec;
5384 5385
	hda_nid_t mix, srcs[5];
	int i, num;
5386

5387 5388 5389 5390 5391 5392 5393 5394 5395 5396 5397 5398 5399 5400 5401
	if (snd_hda_get_connections(codec, pin, &mix, 1) != 1)
		return 0;
	num = snd_hda_get_connections(codec, mix, srcs, ARRAY_SIZE(srcs));
	if (num < 0)
		return 0;
	for (i = 0; i < num; i++) {
		unsigned int type;
		type = get_wcaps_type(get_wcaps(codec, srcs[i]));
		if (type != AC_WID_AUD_OUT)
			continue;
		if (!found_in_nid_list(srcs[i], spec->multiout.dac_nids,
				       spec->multiout.num_dacs))
			return srcs[i];
	}
	return 0;
5402 5403
}

5404 5405
/* fill in the dac_nids table from the parsed pin configuration */
static int alc861_auto_fill_dac_nids(struct hda_codec *codec)
5406 5407
{
	struct alc_spec *spec = codec->spec;
5408 5409 5410
	const struct auto_pin_cfg *cfg = &spec->autocfg;
	int i;
	hda_nid_t nid, dac;
5411

5412 5413 5414 5415 5416 5417 5418 5419 5420
	spec->multiout.dac_nids = spec->private_dac_nids;
	for (i = 0; i < cfg->line_outs; i++) {
		nid = cfg->line_out_pins[i];
		dac = alc861_look_for_dac(codec, nid);
		if (!dac)
			continue;
		spec->private_dac_nids[spec->multiout.num_dacs++] = dac;
	}
	return 0;
5421 5422
}

5423 5424
static int __alc861_create_out_sw(struct hda_codec *codec, const char *pfx,
				  hda_nid_t nid, int idx, unsigned int chs)
5425
{
5426 5427
	return __add_pb_sw_ctrl(codec->spec, ALC_CTL_WIDGET_MUTE, pfx, idx,
			   HDA_COMPOSE_AMP_VAL(nid, chs, 0, HDA_OUTPUT));
5428 5429
}

5430 5431
#define alc861_create_out_sw(codec, pfx, nid, chs) \
	__alc861_create_out_sw(codec, pfx, nid, 0, chs)
5432

5433 5434 5435
/* add playback controls from the parsed DAC table */
static int alc861_auto_create_multi_out_ctls(struct hda_codec *codec,
					     const struct auto_pin_cfg *cfg)
5436 5437
{
	struct alc_spec *spec = codec->spec;
5438 5439 5440 5441 5442 5443 5444 5445 5446 5447 5448 5449 5450 5451 5452 5453 5454 5455 5456 5457 5458 5459 5460 5461 5462 5463 5464 5465 5466
	hda_nid_t nid;
	int i, err, noutputs;

	noutputs = cfg->line_outs;
	if (spec->multi_ios > 0)
		noutputs += spec->multi_ios;

	for (i = 0; i < noutputs; i++) {
		const char *name;
		int index;
		nid = spec->multiout.dac_nids[i];
		if (!nid)
			continue;
		name = alc_get_line_out_pfx(spec, i, true, &index);
		if (!name) {
			/* Center/LFE */
			err = alc861_create_out_sw(codec, "Center", nid, 1);
			if (err < 0)
				return err;
			err = alc861_create_out_sw(codec, "LFE", nid, 2);
			if (err < 0)
				return err;
		} else {
			err = __alc861_create_out_sw(codec, name, nid, index, 3);
			if (err < 0)
				return err;
		}
	}
	return 0;
5467 5468
}

5469
static int alc861_auto_create_hp_ctls(struct hda_codec *codec, hda_nid_t pin)
5470
{
5471
	struct alc_spec *spec = codec->spec;
5472 5473 5474 5475 5476 5477 5478 5479 5480 5481 5482 5483 5484 5485 5486 5487
	int err;
	hda_nid_t nid;

	if (!pin)
		return 0;

	if ((pin >= 0x0b && pin <= 0x10) || pin == 0x1f || pin == 0x20) {
		nid = alc861_look_for_dac(codec, pin);
		if (nid) {
			err = alc861_create_out_sw(codec, "Headphone", nid, 3);
			if (err < 0)
				return err;
			spec->multiout.hp_nid = nid;
		}
	}
	return 0;
5488 5489
}

5490 5491 5492
static void alc861_auto_set_output_and_unmute(struct hda_codec *codec,
					      hda_nid_t nid,
					      int pin_type, hda_nid_t dac)
5493
{
5494 5495
	hda_nid_t mix, srcs[5];
	int i, num;
5496

5497 5498 5499 5500 5501 5502 5503 5504 5505 5506 5507 5508 5509 5510 5511 5512 5513 5514
	snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
			    pin_type);
	snd_hda_codec_write(codec, dac, 0, AC_VERB_SET_AMP_GAIN_MUTE,
			    AMP_OUT_UNMUTE);
	if (snd_hda_get_connections(codec, nid, &mix, 1) != 1)
		return;
	num = snd_hda_get_connections(codec, mix, srcs, ARRAY_SIZE(srcs));
	if (num < 0)
		return;
	for (i = 0; i < num; i++) {
		unsigned int mute;
		if (srcs[i] == dac || srcs[i] == 0x15)
			mute = AMP_IN_UNMUTE(i);
		else
			mute = AMP_IN_MUTE(i);
		snd_hda_codec_write(codec, mix, 0, AC_VERB_SET_AMP_GAIN_MUTE,
				    mute);
	}
5515 5516
}

5517
static void alc861_auto_init_multi_out(struct hda_codec *codec)
5518
{
5519
	struct alc_spec *spec = codec->spec;
5520
	int i;
5521

5522 5523 5524 5525 5526 5527 5528
	for (i = 0; i < spec->autocfg.line_outs + spec->multi_ios; i++) {
		hda_nid_t nid = spec->autocfg.line_out_pins[i];
		int pin_type = get_pin_type(spec->autocfg.line_out_type);
		if (nid)
			alc861_auto_set_output_and_unmute(codec, nid, pin_type,
							  spec->multiout.dac_nids[i]);
	}
5529 5530
}

5531
static void alc861_auto_init_hp_out(struct hda_codec *codec)
5532
{
5533
	struct alc_spec *spec = codec->spec;
5534

5535 5536 5537 5538 5539 5540 5541 5542 5543 5544
	if (spec->autocfg.hp_outs)
		alc861_auto_set_output_and_unmute(codec,
						  spec->autocfg.hp_pins[0],
						  PIN_HP,
						  spec->multiout.hp_nid);
	if (spec->autocfg.speaker_outs)
		alc861_auto_set_output_and_unmute(codec,
						  spec->autocfg.speaker_pins[0],
						  PIN_OUT,
						  spec->multiout.dac_nids[0]);
5545 5546
}

5547 5548 5549 5550 5551
/* 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
 */
static int alc861_parse_auto_config(struct hda_codec *codec)
K
Kailang Yang 已提交
5552
{
5553
	struct alc_spec *spec = codec->spec;
5554 5555
	int err;
	static const hda_nid_t alc861_ignore[] = { 0x1d, 0 };
5556

5557 5558 5559 5560 5561 5562
	err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
					   alc861_ignore);
	if (err < 0)
		return err;
	if (!spec->autocfg.line_outs)
		return 0; /* can't find valid BIOS pin config */
5563

5564 5565 5566 5567 5568 5569 5570 5571 5572 5573 5574 5575 5576 5577 5578
	err = alc861_auto_fill_dac_nids(codec);
	if (err < 0)
		return err;
	err = alc_auto_add_multi_channel_mode(codec, alc861_auto_fill_dac_nids);
	if (err < 0)
		return err;
	err = alc861_auto_create_multi_out_ctls(codec, &spec->autocfg);
	if (err < 0)
		return err;
	err = alc861_auto_create_hp_ctls(codec, spec->autocfg.hp_pins[0]);
	if (err < 0)
		return err;
	err = alc_auto_create_input_ctls(codec);
	if (err < 0)
		return err;
5579

5580
	spec->multiout.max_channels = spec->multiout.num_dacs * 2;
5581

5582
	alc_auto_parse_digital(codec);
5583

5584 5585
	if (spec->kctls.list)
		add_mixer(spec, spec->kctls.list);
5586

5587
	alc_remove_invalid_adc_nids(codec);
5588

5589 5590
	alc_ssid_check(codec, 0x0e, 0x0f, 0x0b, 0);
	alc_auto_check_switches(codec);
5591

5592
	set_capture_mixer(codec);
5593

5594
	return 1;
5595 5596
}

5597 5598
/* additional initialization for auto-configuration model */
static void alc861_auto_init(struct hda_codec *codec)
5599
{
5600 5601 5602 5603 5604 5605 5606
	struct alc_spec *spec = codec->spec;
	alc861_auto_init_multi_out(codec);
	alc861_auto_init_hp_out(codec);
	alc_auto_init_analog_input(codec);
	alc_auto_init_digital(codec);
	if (spec->unsol_event)
		alc_inithook(codec);
5607 5608
}

5609 5610 5611 5612 5613 5614 5615 5616 5617
#ifdef CONFIG_SND_HDA_POWER_SAVE
static const struct hda_amp_list alc861_loopbacks[] = {
	{ 0x15, HDA_INPUT, 0 },
	{ 0x15, HDA_INPUT, 1 },
	{ 0x15, HDA_INPUT, 2 },
	{ 0x15, HDA_INPUT, 3 },
	{ } /* end */
};
#endif
5618 5619


5620 5621 5622 5623
/* Pin config fixes */
enum {
	PINFIX_FSC_AMILO_PI1505,
};
5624

5625 5626 5627 5628 5629 5630 5631 5632 5633 5634
static const struct alc_fixup alc861_fixups[] = {
	[PINFIX_FSC_AMILO_PI1505] = {
		.type = ALC_FIXUP_PINS,
		.v.pins = (const struct alc_pincfg[]) {
			{ 0x0b, 0x0221101f }, /* HP */
			{ 0x0f, 0x90170310 }, /* speaker */
			{ }
		}
	},
};
5635

5636 5637 5638 5639
static const struct snd_pci_quirk alc861_fixup_tbl[] = {
	SND_PCI_QUIRK(0x1734, 0x10c7, "FSC Amilo Pi1505", PINFIX_FSC_AMILO_PI1505),
	{}
};
5640

5641 5642 5643 5644 5645 5646 5647
/*
 */
#ifdef CONFIG_SND_HDA_ENABLE_REALTEK_QUIRKS
#include "alc861_quirks.c"
#endif

static int patch_alc861(struct hda_codec *codec)
5648
{
5649 5650 5651
	struct alc_spec *spec;
	int board_config;
	int err;
5652

5653 5654 5655
	spec = kzalloc(sizeof(*spec), GFP_KERNEL);
	if (spec == NULL)
		return -ENOMEM;
5656

5657 5658 5659 5660 5661 5662 5663 5664 5665 5666 5667
	codec->spec = spec;

	spec->mixer_nid = 0x15;

        board_config = alc_board_config(codec, ALC861_MODEL_LAST,
					alc861_models, alc861_cfg_tbl);

	if (board_config < 0) {
		printk(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
		       codec->chip_name);
		board_config = ALC_MODEL_AUTO;
5668 5669
	}

5670 5671 5672 5673 5674 5675 5676 5677 5678 5679 5680 5681 5682 5683 5684 5685 5686 5687
	if (board_config == ALC_MODEL_AUTO) {
		alc_pick_fixup(codec, NULL, alc861_fixup_tbl, alc861_fixups);
		alc_apply_fixup(codec, ALC_FIXUP_ACT_PRE_PROBE);
	}

	if (board_config == ALC_MODEL_AUTO) {
		/* automatic parse from the BIOS config */
		err = alc861_parse_auto_config(codec);
		if (err < 0) {
			alc_free(codec);
			return err;
		}
#ifdef CONFIG_SND_HDA_ENABLE_REALTEK_QUIRKS
		else if (!err) {
			printk(KERN_INFO
			       "hda_codec: Cannot set up configuration "
			       "from BIOS.  Using base mode...\n");
		   board_config = ALC861_3ST_DIG;
5688
		}
5689
#endif
5690 5691
	}

5692 5693 5694 5695
	err = snd_hda_attach_beep_device(codec, 0x23);
	if (err < 0) {
		alc_free(codec);
		return err;
5696
	}
5697

5698 5699
	if (board_config != ALC_MODEL_AUTO)
		setup_preset(codec, &alc861_presets[board_config]);
5700

5701 5702 5703 5704 5705
	if (!spec->adc_nids) {
		alc_auto_fill_adc_caps(codec);
		alc_rebuild_imux_for_auto_mic(codec);
		alc_remove_invalid_adc_nids(codec);
	}
5706

5707 5708 5709
	if (!spec->cap_mixer)
		set_capture_mixer(codec);
	set_beep_amp(spec, 0x23, 0, HDA_OUTPUT);
5710

5711
	spec->vmaster_nid = 0x03;
5712

5713 5714 5715 5716 5717 5718 5719 5720
	alc_apply_fixup(codec, ALC_FIXUP_ACT_PROBE);

	codec->patch_ops = alc_patch_ops;
	if (board_config == ALC_MODEL_AUTO) {
		spec->init_hook = alc861_auto_init;
#ifdef CONFIG_SND_HDA_POWER_SAVE
		spec->power_hook = alc_power_eapd;
#endif
5721
	}
5722 5723 5724 5725 5726 5727
#ifdef CONFIG_SND_HDA_POWER_SAVE
	if (!spec->loopback.amplist)
		spec->loopback.amplist = alc861_loopbacks;
#endif

	return 0;
5728 5729
}

5730 5731 5732 5733 5734 5735 5736 5737 5738 5739 5740 5741 5742 5743 5744 5745 5746 5747 5748 5749 5750 5751
/*
 * ALC861-VD support
 *
 * Based on ALC882
 *
 * In addition, an independent DAC
 */
#ifdef CONFIG_SND_HDA_POWER_SAVE
#define alc861vd_loopbacks	alc880_loopbacks
#endif

/*
 * BIOS auto configuration
 */
#define alc861vd_is_fixed_pin(nid)	((nid) >= 0x14 && (nid) <= 0x17)
#define alc861vd_fixed_pin_idx(nid)	((nid) - 0x14)
#define alc861vd_is_multi_pin(nid)	((nid) >= 0x18)
#define alc861vd_multi_pin_idx(nid)	((nid) - 0x18)
#define alc861vd_idx_to_dac(nid)		((nid) + 0x02)
#define alc861vd_dac_to_idx(nid)		((nid) - 0x02)
#define alc861vd_idx_to_mixer_vol(nid)		((nid) + 0x02)
#define alc861vd_idx_to_mixer_switch(nid)	((nid) + 0x0c)
5752

5753
/* add playback controls from the parsed DAC table */
5754 5755 5756
/* Based on ALC880 version. But ALC861VD has separate,
 * different NIDs for mute/unmute switch and volume control */
static int alc861vd_auto_create_multi_out_ctls(struct alc_spec *spec,
5757 5758
					     const struct auto_pin_cfg *cfg)
{
5759
	hda_nid_t nid_v, nid_s;
5760
	int i, err, noutputs;
5761

5762 5763 5764 5765 5766
	noutputs = cfg->line_outs;
	if (spec->multi_ios > 0)
		noutputs += spec->multi_ios;

	for (i = 0; i < noutputs; i++) {
5767 5768
		const char *name;
		int index;
5769
		if (!spec->multiout.dac_nids[i])
5770
			continue;
5771 5772 5773 5774 5775 5776 5777
		nid_v = alc861vd_idx_to_mixer_vol(
				alc861vd_dac_to_idx(
					spec->multiout.dac_nids[i]));
		nid_s = alc861vd_idx_to_mixer_switch(
				alc861vd_dac_to_idx(
					spec->multiout.dac_nids[i]));

5778 5779
		name = alc_get_line_out_pfx(spec, i, true, &index);
		if (!name) {
5780
			/* Center/LFE */
5781 5782 5783 5784
			err = add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL,
					      "Center",
					  HDA_COMPOSE_AMP_VAL(nid_v, 1, 0,
							      HDA_OUTPUT));
5785 5786
			if (err < 0)
				return err;
5787 5788 5789 5790
			err = add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL,
					      "LFE",
					  HDA_COMPOSE_AMP_VAL(nid_v, 2, 0,
							      HDA_OUTPUT));
5791 5792
			if (err < 0)
				return err;
5793 5794 5795 5796
			err = add_pb_sw_ctrl(spec, ALC_CTL_BIND_MUTE,
					     "Center",
					  HDA_COMPOSE_AMP_VAL(nid_s, 1, 2,
							      HDA_INPUT));
5797 5798
			if (err < 0)
				return err;
5799 5800 5801 5802
			err = add_pb_sw_ctrl(spec, ALC_CTL_BIND_MUTE,
					     "LFE",
					  HDA_COMPOSE_AMP_VAL(nid_s, 2, 2,
							      HDA_INPUT));
5803 5804 5805
			if (err < 0)
				return err;
		} else {
5806 5807 5808 5809
			err = __add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL,
						name, index,
					  HDA_COMPOSE_AMP_VAL(nid_v, 3, 0,
							      HDA_OUTPUT));
5810 5811
			if (err < 0)
				return err;
5812 5813 5814 5815
			err = __add_pb_sw_ctrl(spec, ALC_CTL_BIND_MUTE,
					       name, index,
					  HDA_COMPOSE_AMP_VAL(nid_s, 3, 2,
							      HDA_INPUT));
5816 5817 5818 5819 5820 5821 5822
			if (err < 0)
				return err;
		}
	}
	return 0;
}

5823 5824 5825 5826 5827 5828 5829 5830 5831 5832 5833 5834 5835 5836 5837 5838 5839 5840 5841 5842 5843 5844 5845 5846 5847 5848 5849 5850 5851 5852 5853 5854 5855 5856 5857 5858 5859 5860 5861 5862 5863 5864 5865 5866 5867 5868 5869 5870 5871 5872
/* add playback controls for speaker and HP outputs */
/* Based on ALC880 version. But ALC861VD has separate,
 * different NIDs for mute/unmute switch and volume control */
static int alc861vd_auto_create_extra_out(struct alc_spec *spec,
					hda_nid_t pin, const char *pfx)
{
	hda_nid_t nid_v, nid_s;
	int err;

	if (!pin)
		return 0;

	if (alc861vd_is_fixed_pin(pin)) {
		nid_v = alc861vd_idx_to_dac(alc861vd_fixed_pin_idx(pin));
		/* specify the DAC as the extra output */
		if (!spec->multiout.hp_nid)
			spec->multiout.hp_nid = nid_v;
		else
			spec->multiout.extra_out_nid[0] = nid_v;
		/* control HP volume/switch on the output mixer amp */
		nid_v = alc861vd_idx_to_mixer_vol(
				alc861vd_fixed_pin_idx(pin));
		nid_s = alc861vd_idx_to_mixer_switch(
				alc861vd_fixed_pin_idx(pin));

		err = add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL, pfx,
				  HDA_COMPOSE_AMP_VAL(nid_v, 3, 0, HDA_OUTPUT));
		if (err < 0)
			return err;
		err = add_pb_sw_ctrl(spec, ALC_CTL_BIND_MUTE, pfx,
				  HDA_COMPOSE_AMP_VAL(nid_s, 3, 2, HDA_INPUT));
		if (err < 0)
			return err;
	} else if (alc861vd_is_multi_pin(pin)) {
		/* set manual connection */
		/* we have only a switch on HP-out PIN */
		err = add_pb_sw_ctrl(spec, ALC_CTL_WIDGET_MUTE, pfx,
				  HDA_COMPOSE_AMP_VAL(pin, 3, 0, HDA_OUTPUT));
		if (err < 0)
			return err;
	}
	return 0;
}

/* 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
 * Based on ALC880 version - had to change it to override
 * alc880_auto_create_extra_out and alc880_auto_create_multi_out_ctls */
static int alc861vd_parse_auto_config(struct hda_codec *codec)
5873
{
5874
	struct alc_spec *spec = codec->spec;
5875
	int err;
5876
	static const hda_nid_t alc861vd_ignore[] = { 0x1d, 0 };
5877

5878 5879 5880 5881 5882 5883
	err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
					   alc861vd_ignore);
	if (err < 0)
		return err;
	if (!spec->autocfg.line_outs)
		return 0; /* can't find valid BIOS pin config */
T
Takashi Iwai 已提交
5884

5885
	err = alc_auto_fill_dac_nids(codec);
5886 5887
	if (err < 0)
		return err;
5888 5889 5890 5891 5892 5893 5894 5895 5896 5897 5898 5899 5900 5901 5902 5903 5904
	err = alc_auto_add_multi_channel_mode(codec, alc_auto_fill_dac_nids);
	if (err < 0)
		return err;
	err = alc861vd_auto_create_multi_out_ctls(spec, &spec->autocfg);
	if (err < 0)
		return err;
	err = alc861vd_auto_create_extra_out(spec,
					     spec->autocfg.speaker_pins[0],
					     "Speaker");
	if (err < 0)
		return err;
	err = alc861vd_auto_create_extra_out(spec,
					     spec->autocfg.hp_pins[0],
					     "Headphone");
	if (err < 0)
		return err;
	err = alc_auto_create_input_ctls(codec);
5905 5906
	if (err < 0)
		return err;
5907

5908
	spec->multiout.max_channels = spec->multiout.num_dacs * 2;
5909

5910
	alc_auto_parse_digital(codec);
5911

5912 5913
	if (spec->kctls.list)
		add_mixer(spec, spec->kctls.list);
5914

5915
	alc_remove_invalid_adc_nids(codec);
5916

5917 5918
	alc_ssid_check(codec, 0x15, 0x1b, 0x14, 0);
	alc_auto_check_switches(codec);
5919

5920 5921 5922
	err = alc_auto_add_mic_boost(codec);
	if (err < 0)
		return err;
5923

5924
	return 1;
5925 5926
}

5927 5928
/* additional initialization for auto-configuration model */
static void alc861vd_auto_init(struct hda_codec *codec)
5929 5930
{
	struct alc_spec *spec = codec->spec;
5931 5932 5933 5934 5935 5936 5937
	alc_auto_init_multi_out(codec);
	alc_auto_init_extra_out(codec);
	alc_auto_init_analog_input(codec);
	alc_auto_init_input_src(codec);
	alc_auto_init_digital(codec);
	if (spec->unsol_event)
		alc_inithook(codec);
5938 5939
}

5940 5941 5942
enum {
	ALC660VD_FIX_ASUS_GPIO1
};
5943

5944 5945 5946 5947 5948 5949 5950 5951 5952 5953 5954 5955
/* reset GPIO1 */
static const struct alc_fixup alc861vd_fixups[] = {
	[ALC660VD_FIX_ASUS_GPIO1] = {
		.type = ALC_FIXUP_VERBS,
		.v.verbs = (const struct hda_verb[]) {
			{0x01, AC_VERB_SET_GPIO_MASK, 0x03},
			{0x01, AC_VERB_SET_GPIO_DIRECTION, 0x01},
			{0x01, AC_VERB_SET_GPIO_DATA, 0x01},
			{ }
		}
	},
};
5956

5957 5958 5959 5960
static const struct snd_pci_quirk alc861vd_fixup_tbl[] = {
	SND_PCI_QUIRK(0x1043, 0x1339, "ASUS A7-K", ALC660VD_FIX_ASUS_GPIO1),
	{}
};
5961

5962 5963 5964 5965
static const struct hda_verb alc660vd_eapd_verbs[] = {
	{0x14, AC_VERB_SET_EAPD_BTLENABLE, 2},
	{0x15, AC_VERB_SET_EAPD_BTLENABLE, 2},
	{ }
5966 5967
};

5968 5969 5970 5971 5972 5973 5974
/*
 */
#ifdef CONFIG_SND_HDA_ENABLE_REALTEK_QUIRKS
#include "alc861vd_quirks.c"
#endif

static int patch_alc861vd(struct hda_codec *codec)
5975
{
5976 5977
	struct alc_spec *spec;
	int err, board_config;
5978

5979 5980 5981 5982 5983 5984 5985 5986 5987 5988 5989 5990 5991 5992 5993
	spec = kzalloc(sizeof(*spec), GFP_KERNEL);
	if (spec == NULL)
		return -ENOMEM;

	codec->spec = spec;

	spec->mixer_nid = 0x0b;

	board_config = alc_board_config(codec, ALC861VD_MODEL_LAST,
					alc861vd_models, alc861vd_cfg_tbl);

	if (board_config < 0) {
		printk(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
		       codec->chip_name);
		board_config = ALC_MODEL_AUTO;
5994
	}
5995

5996 5997 5998 5999
	if (board_config == ALC_MODEL_AUTO) {
		alc_pick_fixup(codec, NULL, alc861vd_fixup_tbl, alc861vd_fixups);
		alc_apply_fixup(codec, ALC_FIXUP_ACT_PRE_PROBE);
	}
6000

6001 6002 6003 6004 6005 6006 6007 6008 6009 6010 6011 6012 6013 6014 6015 6016
	if (board_config == ALC_MODEL_AUTO) {
		/* automatic parse from the BIOS config */
		err = alc861vd_parse_auto_config(codec);
		if (err < 0) {
			alc_free(codec);
			return err;
		}
#ifdef CONFIG_SND_HDA_ENABLE_REALTEK_QUIRKS
		else if (!err) {
			printk(KERN_INFO
			       "hda_codec: Cannot set up configuration "
			       "from BIOS.  Using base mode...\n");
			board_config = ALC861VD_3ST;
		}
#endif
	}
6017

6018 6019 6020 6021 6022
	err = snd_hda_attach_beep_device(codec, 0x23);
	if (err < 0) {
		alc_free(codec);
		return err;
	}
6023

6024 6025 6026 6027 6028 6029 6030 6031 6032 6033 6034 6035
	if (board_config != ALC_MODEL_AUTO)
		setup_preset(codec, &alc861vd_presets[board_config]);

	if (codec->vendor_id == 0x10ec0660) {
		/* always turn on EAPD */
		add_verb(spec, alc660vd_eapd_verbs);
	}

	if (!spec->adc_nids) {
		alc_auto_fill_adc_caps(codec);
		alc_rebuild_imux_for_auto_mic(codec);
		alc_remove_invalid_adc_nids(codec);
6036
	}
6037 6038 6039 6040 6041 6042 6043 6044 6045 6046 6047 6048 6049 6050 6051 6052 6053 6054

	set_capture_mixer(codec);
	set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);

	spec->vmaster_nid = 0x02;

	alc_apply_fixup(codec, ALC_FIXUP_ACT_PROBE);

	codec->patch_ops = alc_patch_ops;

	if (board_config == ALC_MODEL_AUTO)
		spec->init_hook = alc861vd_auto_init;
	spec->shutup = alc_eapd_shutup;
#ifdef CONFIG_SND_HDA_POWER_SAVE
	if (!spec->loopback.amplist)
		spec->loopback.amplist = alc861vd_loopbacks;
#endif

6055 6056 6057
	return 0;
}

6058 6059 6060 6061 6062 6063 6064 6065 6066 6067 6068 6069 6070 6071 6072 6073 6074 6075 6076
/*
 * 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).
 */
#ifdef CONFIG_SND_HDA_POWER_SAVE
#define alc662_loopbacks	alc880_loopbacks
#endif

/*
 * BIOS auto configuration
 */

6077 6078 6079 6080
static int alc662_parse_auto_config(struct hda_codec *codec)
{
	struct alc_spec *spec = codec->spec;
	int err;
6081
	static const hda_nid_t alc662_ignore[] = { 0x1d, 0 };
6082 6083 6084 6085 6086 6087 6088 6089

	err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
					   alc662_ignore);
	if (err < 0)
		return err;
	if (!spec->autocfg.line_outs)
		return 0; /* can't find valid BIOS pin config */

6090
	err = alc_auto_fill_dac_nids(codec);
6091 6092
	if (err < 0)
		return err;
6093
	err = alc_auto_add_multi_channel_mode(codec, alc_auto_fill_dac_nids);
6094 6095
	if (err < 0)
		return err;
6096
	err = alc_auto_create_multi_out_ctls(codec, &spec->autocfg);
6097 6098
	if (err < 0)
		return err;
6099
	err = alc_auto_create_extra_out(codec,
6100
					   spec->autocfg.speaker_pins[0],
6101
					   spec->multiout.extra_out_nid[0],
6102 6103 6104
					   "Speaker");
	if (err < 0)
		return err;
6105
	err = alc_auto_create_extra_out(codec, spec->autocfg.hp_pins[0],
6106
					   spec->multiout.hp_nid,
6107 6108 6109
					   "Headphone");
	if (err < 0)
		return err;
6110
	err = alc_auto_create_input_ctls(codec);
6111
	if (err < 0)
6112 6113 6114 6115
		return err;

	spec->multiout.max_channels = spec->multiout.num_dacs * 2;

6116
	alc_auto_parse_digital(codec);
6117

6118
	if (spec->kctls.list)
6119
		add_mixer(spec, spec->kctls.list);
6120

6121
	alc_remove_invalid_adc_nids(codec);
6122

6123 6124 6125 6126 6127
	if (codec->vendor_id == 0x10ec0272 || codec->vendor_id == 0x10ec0663 ||
	    codec->vendor_id == 0x10ec0665 || codec->vendor_id == 0x10ec0670)
	    alc_ssid_check(codec, 0x15, 0x1b, 0x14, 0x21);
	else
	    alc_ssid_check(codec, 0x15, 0x1b, 0x14, 0);
6128 6129 6130 6131 6132
	alc_auto_check_switches(codec);

	err = alc_auto_add_mic_boost(codec);
	if (err < 0)
		return err;
6133

6134
	return 1;
6135 6136 6137 6138 6139
}

/* additional initialization for auto-configuration model */
static void alc662_auto_init(struct hda_codec *codec)
{
6140
	struct alc_spec *spec = codec->spec;
6141 6142
	alc_auto_init_multi_out(codec);
	alc_auto_init_extra_out(codec);
6143
	alc_auto_init_analog_input(codec);
6144
	alc_auto_init_input_src(codec);
6145
	alc_auto_init_digital(codec);
6146
	if (spec->unsol_event)
6147
		alc_inithook(codec);
6148 6149
}

T
Todd Broch 已提交
6150
static void alc272_fixup_mario(struct hda_codec *codec,
6151
			       const struct alc_fixup *fix, int action)
6152
{
6153
	if (action != ALC_FIXUP_ACT_PROBE)
6154
		return;
T
Todd Broch 已提交
6155 6156 6157 6158 6159 6160 6161 6162 6163
	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");
}

6164
enum {
6165
	ALC662_FIXUP_ASPIRE,
6166
	ALC662_FIXUP_IDEAPAD,
T
Todd Broch 已提交
6167
	ALC272_FIXUP_MARIO,
6168
	ALC662_FIXUP_CZC_P10T,
6169
	ALC662_FIXUP_SKU_IGNORE,
6170
	ALC662_FIXUP_HP_RP5800,
6171 6172 6173
};

static const struct alc_fixup alc662_fixups[] = {
6174
	[ALC662_FIXUP_ASPIRE] = {
6175 6176
		.type = ALC_FIXUP_PINS,
		.v.pins = (const struct alc_pincfg[]) {
6177 6178 6179 6180
			{ 0x15, 0x99130112 }, /* subwoofer */
			{ }
		}
	},
6181
	[ALC662_FIXUP_IDEAPAD] = {
6182 6183
		.type = ALC_FIXUP_PINS,
		.v.pins = (const struct alc_pincfg[]) {
6184 6185 6186 6187
			{ 0x17, 0x99130112 }, /* subwoofer */
			{ }
		}
	},
T
Todd Broch 已提交
6188
	[ALC272_FIXUP_MARIO] = {
6189 6190
		.type = ALC_FIXUP_FUNC,
		.v.func = alc272_fixup_mario,
6191 6192 6193 6194 6195 6196 6197 6198
	},
	[ALC662_FIXUP_CZC_P10T] = {
		.type = ALC_FIXUP_VERBS,
		.v.verbs = (const struct hda_verb[]) {
			{0x14, AC_VERB_SET_EAPD_BTLENABLE, 0},
			{}
		}
	},
6199 6200 6201
	[ALC662_FIXUP_SKU_IGNORE] = {
		.type = ALC_FIXUP_SKU,
		.v.sku = ALC_FIXUP_SKU_IGNORE,
6202
	},
6203 6204 6205 6206 6207 6208 6209 6210 6211
	[ALC662_FIXUP_HP_RP5800] = {
		.type = ALC_FIXUP_PINS,
		.v.pins = (const struct alc_pincfg[]) {
			{ 0x14, 0x0221201f }, /* HP out */
			{ }
		},
		.chained = true,
		.chain_id = ALC662_FIXUP_SKU_IGNORE
	},
6212 6213
};

6214
static const struct snd_pci_quirk alc662_fixup_tbl[] = {
6215
	SND_PCI_QUIRK(0x1025, 0x0308, "Acer Aspire 8942G", ALC662_FIXUP_ASPIRE),
6216
	SND_PCI_QUIRK(0x1025, 0x031c, "Gateway NV79", ALC662_FIXUP_SKU_IGNORE),
6217
	SND_PCI_QUIRK(0x1025, 0x038b, "Acer Aspire 8943G", ALC662_FIXUP_ASPIRE),
6218
	SND_PCI_QUIRK(0x103c, 0x1632, "HP RP5800", ALC662_FIXUP_HP_RP5800),
6219
	SND_PCI_QUIRK(0x144d, 0xc051, "Samsung R720", ALC662_FIXUP_IDEAPAD),
6220
	SND_PCI_QUIRK(0x17aa, 0x38af, "Lenovo Ideapad Y550P", ALC662_FIXUP_IDEAPAD),
6221
	SND_PCI_QUIRK(0x17aa, 0x3a0d, "Lenovo Ideapad Y550", ALC662_FIXUP_IDEAPAD),
6222
	SND_PCI_QUIRK(0x1b35, 0x2206, "CZC P10T", ALC662_FIXUP_CZC_P10T),
6223 6224 6225
	{}
};

T
Todd Broch 已提交
6226 6227 6228 6229
static const struct alc_model_fixup alc662_fixup_models[] = {
	{.id = ALC272_FIXUP_MARIO, .name = "mario"},
	{}
};
6230 6231


6232 6233 6234 6235 6236 6237
/*
 */
#ifdef CONFIG_SND_HDA_ENABLE_REALTEK_QUIRKS
#include "alc662_quirks.c"
#endif

6238 6239 6240 6241
static int patch_alc662(struct hda_codec *codec)
{
	struct alc_spec *spec;
	int err, board_config;
6242
	int coef;
6243 6244 6245 6246 6247 6248 6249

	spec = kzalloc(sizeof(*spec), GFP_KERNEL);
	if (!spec)
		return -ENOMEM;

	codec->spec = spec;

6250 6251
	spec->mixer_nid = 0x0b;

6252 6253
	alc_auto_parse_customize_define(codec);

6254 6255
	alc_fix_pll_init(codec, 0x20, 0x04, 15);

6256 6257
	coef = alc_read_coef_idx(codec, 0);
	if (coef == 0x8020 || coef == 0x8011)
6258
		alc_codec_rename(codec, "ALC661");
6259 6260 6261
	else if (coef & (1 << 14) &&
		codec->bus->pci->subsystem_vendor == 0x1025 &&
		spec->cdefine.platform_type == 1)
6262
		alc_codec_rename(codec, "ALC272X");
6263 6264
	else if (coef == 0x4011)
		alc_codec_rename(codec, "ALC656");
6265

6266 6267
	board_config = alc_board_config(codec, ALC662_MODEL_LAST,
					alc662_models, alc662_cfg_tbl);
6268
	if (board_config < 0) {
6269 6270
		printk(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
		       codec->chip_name);
6271
		board_config = ALC_MODEL_AUTO;
6272 6273
	}

6274
	if (board_config == ALC_MODEL_AUTO) {
6275 6276 6277
		alc_pick_fixup(codec, alc662_fixup_models,
			       alc662_fixup_tbl, alc662_fixups);
		alc_apply_fixup(codec, ALC_FIXUP_ACT_PRE_PROBE);
6278 6279 6280 6281 6282
		/* automatic parse from the BIOS config */
		err = alc662_parse_auto_config(codec);
		if (err < 0) {
			alc_free(codec);
			return err;
6283 6284 6285
		}
#ifdef CONFIG_SND_HDA_ENABLE_REALTEK_QUIRKS
		else if (!err) {
6286 6287 6288 6289 6290
			printk(KERN_INFO
			       "hda_codec: Cannot set up configuration "
			       "from BIOS.  Using base mode...\n");
			board_config = ALC662_3ST_2ch_DIG;
		}
6291
#endif
6292 6293
	}

6294
	if (has_cdefine_beep(codec)) {
6295 6296 6297 6298 6299
		err = snd_hda_attach_beep_device(codec, 0x1);
		if (err < 0) {
			alc_free(codec);
			return err;
		}
6300 6301
	}

6302
	if (board_config != ALC_MODEL_AUTO)
6303
		setup_preset(codec, &alc662_presets[board_config]);
6304

6305
	if (!spec->adc_nids) {
6306
		alc_auto_fill_adc_caps(codec);
6307
		alc_rebuild_imux_for_auto_mic(codec);
6308
		alc_remove_invalid_adc_nids(codec);
6309
	}
6310

6311
	if (!spec->cap_mixer)
6312
		set_capture_mixer(codec);
K
Kailang Yang 已提交
6313

6314
	if (has_cdefine_beep(codec)) {
6315 6316 6317 6318 6319 6320 6321 6322 6323 6324 6325 6326 6327
		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 已提交
6328
	}
6329 6330
	spec->vmaster_nid = 0x02;

6331 6332
	alc_apply_fixup(codec, ALC_FIXUP_ACT_PROBE);

6333
	codec->patch_ops = alc_patch_ops;
6334
	if (board_config == ALC_MODEL_AUTO)
6335
		spec->init_hook = alc662_auto_init;
6336
	spec->shutup = alc_eapd_shutup;
6337

6338 6339
	alc_init_jacks(codec);

6340 6341 6342 6343
#ifdef CONFIG_SND_HDA_POWER_SAVE
	if (!spec->loopback.amplist)
		spec->loopback.amplist = alc662_loopbacks;
#endif
6344 6345 6346 6347

	return 0;
}

6348 6349 6350 6351
static int patch_alc888(struct hda_codec *codec)
{
	if ((alc_read_coef_idx(codec, 0) & 0x00f0)==0x0030){
		kfree(codec->chip_name);
6352 6353 6354 6355
		if (codec->vendor_id == 0x10ec0887)
			codec->chip_name = kstrdup("ALC887-VD", GFP_KERNEL);
		else
			codec->chip_name = kstrdup("ALC888-VD", GFP_KERNEL);
6356 6357
		if (!codec->chip_name) {
			alc_free(codec);
6358
			return -ENOMEM;
6359 6360
		}
		return patch_alc662(codec);
6361
	}
6362
	return patch_alc882(codec);
6363 6364
}

6365 6366 6367 6368 6369 6370 6371 6372 6373
static int patch_alc899(struct hda_codec *codec)
{
	if ((alc_read_coef_idx(codec, 0) & 0x2000) != 0x2000) {
		kfree(codec->chip_name);
		codec->chip_name = kstrdup("ALC898", GFP_KERNEL);
	}
	return patch_alc882(codec);
}

K
Kailang Yang 已提交
6374 6375 6376 6377 6378 6379 6380 6381
/*
 * ALC680 support
 */

static int alc680_parse_auto_config(struct hda_codec *codec)
{
	struct alc_spec *spec = codec->spec;
	int err;
6382
	static const hda_nid_t alc680_ignore[] = { 0 };
K
Kailang Yang 已提交
6383 6384 6385 6386 6387

	err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
					   alc680_ignore);
	if (err < 0)
		return err;
6388

K
Kailang Yang 已提交
6389 6390 6391 6392 6393 6394 6395 6396
	if (!spec->autocfg.line_outs) {
		if (spec->autocfg.dig_outs || spec->autocfg.dig_in_pin) {
			spec->multiout.max_channels = 2;
			spec->no_analog = 1;
			goto dig_only;
		}
		return 0; /* can't find valid BIOS pin config */
	}
6397 6398 6399 6400 6401 6402 6403 6404 6405 6406 6407 6408 6409 6410

	err = alc_auto_fill_dac_nids(codec);
	if (err < 0)
		return err;

	err = alc_auto_create_multi_out_ctls(codec, &spec->autocfg);
	if (err < 0)
		return err;

	err = alc_auto_create_hp_out(codec);
	if (err < 0)
		return err;

	err = alc_auto_create_speaker_out(codec);
K
Kailang Yang 已提交
6411 6412 6413
	if (err < 0)
		return err;

6414 6415 6416 6417
	err = alc_auto_create_input_ctls(codec);
	if (err < 0)
		return err;

K
Kailang Yang 已提交
6418 6419 6420 6421
	spec->multiout.max_channels = 2;

 dig_only:
	/* digital only support output */
6422
	alc_auto_parse_digital(codec);
K
Kailang Yang 已提交
6423 6424 6425
	if (spec->kctls.list)
		add_mixer(spec, spec->kctls.list);

6426 6427 6428 6429
	alc_remove_invalid_adc_nids(codec);

	alc_auto_check_switches(codec);

K
Kailang Yang 已提交
6430 6431 6432 6433 6434 6435 6436 6437 6438 6439 6440
	err = alc_auto_add_mic_boost(codec);
	if (err < 0)
		return err;

	return 1;
}

/* init callback for auto-configuration model -- overriding the default init */
static void alc680_auto_init(struct hda_codec *codec)
{
	struct alc_spec *spec = codec->spec;
6441 6442
	alc_auto_init_multi_out(codec);
	alc_auto_init_extra_out(codec);
6443
	alc_auto_init_analog_input(codec);
6444
	alc_auto_init_input_src(codec);
6445
	alc_auto_init_digital(codec);
K
Kailang Yang 已提交
6446 6447 6448 6449 6450 6451
	if (spec->unsol_event)
		alc_inithook(codec);
}

/*
 */
6452 6453 6454
#ifdef CONFIG_SND_HDA_ENABLE_REALTEK_QUIRKS
#include "alc680_quirks.c"
#endif
K
Kailang Yang 已提交
6455 6456 6457 6458 6459 6460 6461 6462 6463 6464 6465 6466 6467

static int patch_alc680(struct hda_codec *codec)
{
	struct alc_spec *spec;
	int board_config;
	int err;

	spec = kzalloc(sizeof(*spec), GFP_KERNEL);
	if (spec == NULL)
		return -ENOMEM;

	codec->spec = spec;

6468 6469
	/* ALC680 has no aa-loopback mixer */

6470 6471
	board_config = alc_board_config(codec, ALC680_MODEL_LAST,
					alc680_models, alc680_cfg_tbl);
K
Kailang Yang 已提交
6472

6473
	if (board_config < 0) {
K
Kailang Yang 已提交
6474 6475
		printk(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
		       codec->chip_name);
6476
		board_config = ALC_MODEL_AUTO;
K
Kailang Yang 已提交
6477 6478
	}

6479
	if (board_config == ALC_MODEL_AUTO) {
K
Kailang Yang 已提交
6480 6481 6482 6483 6484
		/* automatic parse from the BIOS config */
		err = alc680_parse_auto_config(codec);
		if (err < 0) {
			alc_free(codec);
			return err;
6485 6486 6487
		}
#ifdef CONFIG_SND_HDA_ENABLE_REALTEK_QUIRKS
		else if (!err) {
K
Kailang Yang 已提交
6488 6489 6490 6491 6492
			printk(KERN_INFO
			       "hda_codec: Cannot set up configuration "
			       "from BIOS.  Using base mode...\n");
			board_config = ALC680_BASE;
		}
6493
#endif
K
Kailang Yang 已提交
6494 6495
	}

6496
	if (board_config != ALC_MODEL_AUTO) {
K
Kailang Yang 已提交
6497
		setup_preset(codec, &alc680_presets[board_config]);
6498
#ifdef CONFIG_SND_HDA_ENABLE_REALTEK_QUIRKS
6499
		spec->stream_analog_capture = &alc680_pcm_analog_auto_capture;
6500
#endif
6501
	}
K
Kailang Yang 已提交
6502 6503

	if (!spec->adc_nids) {
6504
		alc_auto_fill_adc_caps(codec);
6505
		alc_rebuild_imux_for_auto_mic(codec);
6506
		alc_remove_invalid_adc_nids(codec);
K
Kailang Yang 已提交
6507 6508 6509 6510 6511 6512 6513 6514
	}

	if (!spec->cap_mixer)
		set_capture_mixer(codec);

	spec->vmaster_nid = 0x02;

	codec->patch_ops = alc_patch_ops;
6515
	if (board_config == ALC_MODEL_AUTO)
K
Kailang Yang 已提交
6516 6517 6518 6519 6520
		spec->init_hook = alc680_auto_init;

	return 0;
}

L
Linus Torvalds 已提交
6521 6522 6523
/*
 * patch entries
 */
6524
static const struct hda_codec_preset snd_hda_preset_realtek[] = {
6525
	{ .id = 0x10ec0221, .name = "ALC221", .patch = patch_alc269 },
L
Linus Torvalds 已提交
6526
	{ .id = 0x10ec0260, .name = "ALC260", .patch = patch_alc260 },
6527
	{ .id = 0x10ec0262, .name = "ALC262", .patch = patch_alc262 },
6528
	{ .id = 0x10ec0267, .name = "ALC267", .patch = patch_alc268 },
6529
	{ .id = 0x10ec0268, .name = "ALC268", .patch = patch_alc268 },
6530
	{ .id = 0x10ec0269, .name = "ALC269", .patch = patch_alc269 },
6531
	{ .id = 0x10ec0270, .name = "ALC270", .patch = patch_alc269 },
K
Kailang Yang 已提交
6532
	{ .id = 0x10ec0272, .name = "ALC272", .patch = patch_alc662 },
6533
	{ .id = 0x10ec0275, .name = "ALC275", .patch = patch_alc269 },
6534
	{ .id = 0x10ec0276, .name = "ALC276", .patch = patch_alc269 },
6535
	{ .id = 0x10ec0861, .rev = 0x100340, .name = "ALC660",
6536
	  .patch = patch_alc861 },
6537 6538 6539
	{ .id = 0x10ec0660, .name = "ALC660-VD", .patch = patch_alc861vd },
	{ .id = 0x10ec0861, .name = "ALC861", .patch = patch_alc861 },
	{ .id = 0x10ec0862, .name = "ALC861-VD", .patch = patch_alc861vd },
6540
	{ .id = 0x10ec0662, .rev = 0x100002, .name = "ALC662 rev2",
6541
	  .patch = patch_alc882 },
6542 6543
	{ .id = 0x10ec0662, .rev = 0x100101, .name = "ALC662 rev1",
	  .patch = patch_alc662 },
K
Kailang Yang 已提交
6544
	{ .id = 0x10ec0663, .name = "ALC663", .patch = patch_alc662 },
K
Kailang Yang 已提交
6545
	{ .id = 0x10ec0665, .name = "ALC665", .patch = patch_alc662 },
6546
	{ .id = 0x10ec0670, .name = "ALC670", .patch = patch_alc662 },
K
Kailang Yang 已提交
6547
	{ .id = 0x10ec0680, .name = "ALC680", .patch = patch_alc680 },
6548
	{ .id = 0x10ec0880, .name = "ALC880", .patch = patch_alc880 },
L
Linus Torvalds 已提交
6549
	{ .id = 0x10ec0882, .name = "ALC882", .patch = patch_alc882 },
6550
	{ .id = 0x10ec0883, .name = "ALC883", .patch = patch_alc882 },
6551
	{ .id = 0x10ec0885, .rev = 0x100101, .name = "ALC889A",
6552
	  .patch = patch_alc882 },
6553
	{ .id = 0x10ec0885, .rev = 0x100103, .name = "ALC889A",
6554
	  .patch = patch_alc882 },
6555
	{ .id = 0x10ec0885, .name = "ALC885", .patch = patch_alc882 },
6556
	{ .id = 0x10ec0887, .name = "ALC887", .patch = patch_alc888 },
K
Kailang Yang 已提交
6557
	{ .id = 0x10ec0888, .rev = 0x100101, .name = "ALC1200",
6558
	  .patch = patch_alc882 },
6559
	{ .id = 0x10ec0888, .name = "ALC888", .patch = patch_alc888 },
6560
	{ .id = 0x10ec0889, .name = "ALC889", .patch = patch_alc882 },
6561
	{ .id = 0x10ec0892, .name = "ALC892", .patch = patch_alc662 },
6562
	{ .id = 0x10ec0899, .name = "ALC899", .patch = patch_alc899 },
L
Linus Torvalds 已提交
6563 6564
	{} /* terminator */
};
6565 6566 6567 6568 6569 6570 6571 6572 6573 6574 6575 6576 6577 6578 6579 6580 6581 6582 6583 6584 6585 6586 6587

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)