patch_via.c 98.1 KB
Newer Older
1 2 3
/*
 * Universal Interface for Intel High Definition Audio Codec
 *
4
 * HD audio interface patch for VIA VT17xx/VT18xx/VT20xx codec
5
 *
6 7
 *  (C) 2006-2009 VIA Technology, Inc.
 *  (C) 2006-2008 Takashi Iwai <tiwai@suse.de>
8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24
 *
 *  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
 */

/* * * * * * * * * * * * * * Release History * * * * * * * * * * * * * * * * */
L
Lydia Wang 已提交
25
/*									     */
26
/* 2006-03-03  Lydia Wang  Create the basic patch to support VT1708 codec    */
L
Lydia Wang 已提交
27 28
/* 2006-03-14  Lydia Wang  Modify hard code for some pin widget nid	     */
/* 2006-08-02  Lydia Wang  Add support to VT1709 codec			     */
29
/* 2006-09-08  Lydia Wang  Fix internal loopback recording source select bug */
L
Lydia Wang 已提交
30 31
/* 2007-09-12  Lydia Wang  Add EAPD enable during driver initialization	     */
/* 2007-09-17  Lydia Wang  Add VT1708B codec support			    */
32
/* 2007-11-14  Lydia Wang  Add VT1708A codec HP and CD pin connect config    */
33
/* 2008-02-03  Lydia Wang  Fix Rear channels and Back channels inverse issue */
L
Lydia Wang 已提交
34 35 36
/* 2008-03-06  Lydia Wang  Add VT1702 codec and VT1708S codec support	     */
/* 2008-04-09  Lydia Wang  Add mute front speaker when HP plugin	     */
/* 2008-04-09  Lydia Wang  Add Independent HP feature			     */
37
/* 2008-05-28  Lydia Wang  Add second S/PDIF Out support for VT1702	     */
L
Lydia Wang 已提交
38
/* 2008-09-15  Logan Li	   Add VT1708S Mic Boost workaround/backdoor	     */
39 40 41 42 43
/* 2009-02-16  Logan Li	   Add support for VT1718S			     */
/* 2009-03-13  Logan Li	   Add support for VT1716S			     */
/* 2009-04-14  Lydai Wang  Add support for VT1828S and VT2020		     */
/* 2009-07-08  Lydia Wang  Add support for VT2002P			     */
/* 2009-07-21  Lydia Wang  Add support for VT1812			     */
44
/* 2009-09-19  Lydia Wang  Add support for VT1818S			     */
L
Lydia Wang 已提交
45
/*									     */
46 47 48 49 50 51 52
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */


#include <linux/init.h>
#include <linux/delay.h>
#include <linux/slab.h>
#include <sound/core.h>
53
#include <sound/asoundef.h>
54 55 56 57
#include "hda_codec.h"
#include "hda_local.h"

/* Pin Widget NID */
58 59
#define VT1708_HP_PIN_NID	0x20
#define VT1708_CD_PIN_NID	0x24
60

61 62 63 64 65 66 67 68
enum VIA_HDA_CODEC {
	UNKNOWN = -1,
	VT1708,
	VT1709_10CH,
	VT1709_6CH,
	VT1708B_8CH,
	VT1708B_4CH,
	VT1708S,
69
	VT1708BCE,
70
	VT1702,
L
Lydia Wang 已提交
71
	VT1718S,
L
Lydia Wang 已提交
72
	VT1716S,
L
Lydia Wang 已提交
73
	VT2002P,
L
Lydia Wang 已提交
74
	VT1812,
75
	VT1802,
76 77 78
	CODEC_TYPES,
};

79 80 81 82 83
#define VT2002P_COMPATIBLE(spec) \
	((spec)->codec_type == VT2002P ||\
	 (spec)->codec_type == VT1812 ||\
	 (spec)->codec_type == VT1802)

84 85
#define MAX_NID_PATH_DEPTH	5

86 87 88 89 90 91 92
/* output-path: DAC -> ... -> pin
 * idx[] contains the source index number of the next widget;
 * e.g. idx[0] is the index of the DAC selected by path[1] widget
 * multi[] indicates whether it's a selector widget with multi-connectors
 * (i.e. the connection selection is mandatory)
 * vol_ctl and mute_ctl contains the NIDs for the assigned mixers
 */
93 94
struct nid_path {
	int depth;
95
	hda_nid_t path[MAX_NID_PATH_DEPTH];
96 97 98 99
	unsigned char idx[MAX_NID_PATH_DEPTH];
	unsigned char multi[MAX_NID_PATH_DEPTH];
	unsigned int vol_ctl;
	unsigned int mute_ctl;
100 101
};

102 103 104 105 106 107 108 109
/* input-path */
struct via_input {
	hda_nid_t pin;	/* input-pin or aa-mix */
	int adc_idx;	/* ADC index to be used */
	int mux_idx;	/* MUX index (if any) */
	const char *label;	/* input-source label */
};

110 111
#define VIA_MAX_ADCS	3

112 113
struct via_spec {
	/* codec parameterization */
114
	const struct snd_kcontrol_new *mixers[6];
115 116
	unsigned int num_mixers;

117
	const struct hda_verb *init_verbs[5];
118 119
	unsigned int num_iverbs;

120
	char stream_name_analog[32];
121
	char stream_name_hp[32];
122 123
	const struct hda_pcm_stream *stream_analog_playback;
	const struct hda_pcm_stream *stream_analog_capture;
124

125
	char stream_name_digital[32];
126 127
	const struct hda_pcm_stream *stream_digital_playback;
	const struct hda_pcm_stream *stream_digital_capture;
128 129 130 131

	/* playback */
	struct hda_multi_out multiout;
	hda_nid_t slave_dig_outs[2];
132
	hda_nid_t hp_dac_nid;
133
	bool hp_indep_shared;	/* indep HP-DAC is shared with side ch */
134
	int num_active_streams;
135
	int dac_mixer_idx;
136

137
	struct nid_path out_path[HDA_SIDE + 1];
138 139
	struct nid_path hp_path;
	struct nid_path hp_dep_path;
140
	struct nid_path speaker_path;
141

142 143
	/* capture */
	unsigned int num_adc_nids;
144 145
	hda_nid_t adc_nids[VIA_MAX_ADCS];
	hda_nid_t mux_nids[VIA_MAX_ADCS];
146
	hda_nid_t aa_mix_nid;
147 148 149
	hda_nid_t dig_in_nid;

	/* capture source */
150 151 152
	bool dyn_adc_switch;
	int num_inputs;
	struct via_input inputs[AUTO_CFG_MAX_INS + 1];
153
	unsigned int cur_mux[VIA_MAX_ADCS];
154

155 156 157 158 159
	/* dynamic ADC switching */
	hda_nid_t cur_adc;
	unsigned int cur_adc_stream_tag;
	unsigned int cur_adc_format;

160 161 162 163 164 165 166 167 168 169
	/* PCM information */
	struct hda_pcm pcm_rec[3];

	/* dynamic controls, init_verbs and input_mux */
	struct auto_pin_cfg autocfg;
	struct snd_array kctls;
	hda_nid_t private_dac_nids[AUTO_CFG_MAX_OUTS];

	/* HP mode source */
	unsigned int hp_independent_mode;
L
Lydia Wang 已提交
170
	unsigned int dmic_enabled;
171
	unsigned int no_pin_power_ctl;
172 173
	enum VIA_HDA_CODEC codec_type;

174 175 176 177 178 179 180
	/* smart51 setup */
	unsigned int smart51_nums;
	hda_nid_t smart51_pins[2];
	int smart51_idxs[2];
	const char *smart51_labels[2];
	unsigned int smart51_enabled;

181 182 183
	/* work to check hp jack state */
	struct hda_codec *codec;
	struct delayed_work vt1708_hp_work;
184
	int vt1708_jack_detect;
185
	int vt1708_hp_present;
186 187 188

	void (*set_widgets_power_state)(struct hda_codec *codec);

189
	struct hda_loopback_check loopback;
190 191
	int num_loopbacks;
	struct hda_amp_list loopback_list[8];
192 193 194 195

	/* bind capture-volume */
	struct hda_bind_ctls *bind_cap_vol;
	struct hda_bind_ctls *bind_cap_sw;
196 197
};

198
static enum VIA_HDA_CODEC get_codec_type(struct hda_codec *codec);
199 200 201 202 203 204 205 206 207 208
static struct via_spec * via_new_spec(struct hda_codec *codec)
{
	struct via_spec *spec;

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

	codec->spec = spec;
	spec->codec = codec;
209 210 211 212
	spec->codec_type = get_codec_type(codec);
	/* VT1708BCE & VT1708S are almost same */
	if (spec->codec_type == VT1708BCE)
		spec->codec_type = VT1708S;
213 214 215
	return spec;
}

216
static enum VIA_HDA_CODEC get_codec_type(struct hda_codec *codec)
217
{
218
	u32 vendor_id = codec->vendor_id;
219 220 221 222 223 224 225 226 227 228 229 230 231
	u16 ven_id = vendor_id >> 16;
	u16 dev_id = vendor_id & 0xffff;
	enum VIA_HDA_CODEC codec_type;

	/* get codec type */
	if (ven_id != 0x1106)
		codec_type = UNKNOWN;
	else if (dev_id >= 0x1708 && dev_id <= 0x170b)
		codec_type = VT1708;
	else if (dev_id >= 0xe710 && dev_id <= 0xe713)
		codec_type = VT1709_10CH;
	else if (dev_id >= 0xe714 && dev_id <= 0xe717)
		codec_type = VT1709_6CH;
232
	else if (dev_id >= 0xe720 && dev_id <= 0xe723) {
233
		codec_type = VT1708B_8CH;
234 235 236
		if (snd_hda_param_read(codec, 0x16, AC_PAR_CONNLIST_LEN) == 0x7)
			codec_type = VT1708BCE;
	} else if (dev_id >= 0xe724 && dev_id <= 0xe727)
237 238 239 240 241 242 243
		codec_type = VT1708B_4CH;
	else if ((dev_id & 0xfff) == 0x397
		 && (dev_id >> 12) < 8)
		codec_type = VT1708S;
	else if ((dev_id & 0xfff) == 0x398
		 && (dev_id >> 12) < 8)
		codec_type = VT1702;
L
Lydia Wang 已提交
244 245 246
	else if ((dev_id & 0xfff) == 0x428
		 && (dev_id >> 12) < 8)
		codec_type = VT1718S;
L
Lydia Wang 已提交
247 248
	else if (dev_id == 0x0433 || dev_id == 0xa721)
		codec_type = VT1716S;
249 250
	else if (dev_id == 0x0441 || dev_id == 0x4441)
		codec_type = VT1718S;
L
Lydia Wang 已提交
251 252
	else if (dev_id == 0x0438 || dev_id == 0x4438)
		codec_type = VT2002P;
L
Lydia Wang 已提交
253 254
	else if (dev_id == 0x0448)
		codec_type = VT1812;
255 256
	else if (dev_id == 0x0440)
		codec_type = VT1708S;
257 258
	else if ((dev_id & 0xfff) == 0x446)
		codec_type = VT1802;
259 260 261 262 263
	else
		codec_type = UNKNOWN;
	return codec_type;
};

264
#define VIA_JACK_EVENT		0x20
265 266
#define VIA_HP_EVENT		0x01
#define VIA_GPIO_EVENT		0x02
267
#define VIA_LINE_EVENT		0x03
268

269 270 271
enum {
	VIA_CTL_WIDGET_VOL,
	VIA_CTL_WIDGET_MUTE,
272
	VIA_CTL_WIDGET_ANALOG_MUTE,
273 274
};

275 276
static void analog_low_current_mode(struct hda_codec *codec);
static bool is_aa_path_mute(struct hda_codec *codec);
277 278 279 280 281 282

static void vt1708_start_hp_work(struct via_spec *spec)
{
	if (spec->codec_type != VT1708 || spec->autocfg.hp_pins[0] == 0)
		return;
	snd_hda_codec_write(spec->codec, 0x1, 0, 0xf81,
283
			    !spec->vt1708_jack_detect);
284 285 286 287 288 289 290 291 292 293 294 295 296
	if (!delayed_work_pending(&spec->vt1708_hp_work))
		schedule_delayed_work(&spec->vt1708_hp_work,
				      msecs_to_jiffies(100));
}

static void vt1708_stop_hp_work(struct via_spec *spec)
{
	if (spec->codec_type != VT1708 || spec->autocfg.hp_pins[0] == 0)
		return;
	if (snd_hda_get_bool_hint(spec->codec, "analog_loopback_hp_detect") == 1
	    && !is_aa_path_mute(spec->codec))
		return;
	snd_hda_codec_write(spec->codec, 0x1, 0, 0xf81,
297
			    !spec->vt1708_jack_detect);
298
	cancel_delayed_work_sync(&spec->vt1708_hp_work);
299
}
300

301 302 303 304 305 306
static void set_widgets_power_state(struct hda_codec *codec)
{
	struct via_spec *spec = codec->spec;
	if (spec->set_widgets_power_state)
		spec->set_widgets_power_state(codec);
}
L
Lydia Wang 已提交
307

308 309 310 311 312 313
static int analog_input_switch_put(struct snd_kcontrol *kcontrol,
				   struct snd_ctl_elem_value *ucontrol)
{
	int change = snd_hda_mixer_amp_switch_put(kcontrol, ucontrol);
	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);

314
	set_widgets_power_state(codec);
315
	analog_low_current_mode(snd_kcontrol_chip(kcontrol));
316 317 318 319 320 321
	if (snd_hda_get_bool_hint(codec, "analog_loopback_hp_detect") == 1) {
		if (is_aa_path_mute(codec))
			vt1708_start_hp_work(codec->spec);
		else
			vt1708_stop_hp_work(codec->spec);
	}
322 323 324 325 326 327 328 329 330 331 332 333 334
	return change;
}

/* modify .put = snd_hda_mixer_amp_switch_put */
#define ANALOG_INPUT_MUTE						\
	{		.iface = SNDRV_CTL_ELEM_IFACE_MIXER,		\
			.name = NULL,					\
			.index = 0,					\
			.info = snd_hda_mixer_amp_switch_info,		\
			.get = snd_hda_mixer_amp_switch_get,		\
			.put = analog_input_switch_put,			\
			.private_value = HDA_COMPOSE_AMP_VAL(0, 3, 0, 0) }

335
static const struct snd_kcontrol_new via_control_templates[] = {
336 337
	HDA_CODEC_VOLUME(NULL, 0, 0, 0),
	HDA_CODEC_MUTE(NULL, 0, 0, 0),
338
	ANALOG_INPUT_MUTE,
339 340
};

L
Lydia Wang 已提交
341

342
/* add dynamic controls */
343 344 345
static struct snd_kcontrol_new *__via_clone_ctl(struct via_spec *spec,
				const struct snd_kcontrol_new *tmpl,
				const char *name)
346 347 348
{
	struct snd_kcontrol_new *knew;

349 350 351
	snd_array_init(&spec->kctls, sizeof(*knew), 32);
	knew = snd_array_new(&spec->kctls);
	if (!knew)
352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370
		return NULL;
	*knew = *tmpl;
	if (!name)
		name = tmpl->name;
	if (name) {
		knew->name = kstrdup(name, GFP_KERNEL);
		if (!knew->name)
			return NULL;
	}
	return knew;
}

static int __via_add_control(struct via_spec *spec, int type, const char *name,
			     int idx, unsigned long val)
{
	struct snd_kcontrol_new *knew;

	knew = __via_clone_ctl(spec, &via_control_templates[type], name);
	if (!knew)
371
		return -ENOMEM;
372
	knew->index = idx;
373
	if (get_amp_nid_(val))
374
		knew->subdevice = HDA_SUBDEV_AMP_FLAG;
375 376 377 378
	knew->private_value = val;
	return 0;
}

379 380 381
#define via_add_control(spec, type, name, val) \
	__via_add_control(spec, type, name, 0, val)

382
#define via_clone_control(spec, tmpl) __via_clone_ctl(spec, tmpl, NULL)
383

384 385 386 387 388 389 390 391 392 393 394 395 396
static void via_free_kctls(struct hda_codec *codec)
{
	struct via_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);
}

397
/* create input playback/capture controls for the given pin */
398
static int via_new_analog_input(struct via_spec *spec, const char *ctlname,
399
				int type_idx, int idx, int mix_nid)
400 401 402 403 404
{
	char name[32];
	int err;

	sprintf(name, "%s Playback Volume", ctlname);
405
	err = __via_add_control(spec, VIA_CTL_WIDGET_VOL, name, type_idx,
406 407 408 409
			      HDA_COMPOSE_AMP_VAL(mix_nid, 3, idx, HDA_INPUT));
	if (err < 0)
		return err;
	sprintf(name, "%s Playback Switch", ctlname);
410
	err = __via_add_control(spec, VIA_CTL_WIDGET_ANALOG_MUTE, name, type_idx,
411 412 413 414 415 416
			      HDA_COMPOSE_AMP_VAL(mix_nid, 3, idx, HDA_INPUT));
	if (err < 0)
		return err;
	return 0;
}

417
#define get_connection_index(codec, mux, nid) \
418
	snd_hda_get_conn_index(codec, mux, nid, 0)
419

420 421 422
static bool check_amp_caps(struct hda_codec *codec, hda_nid_t nid, int dir,
			   unsigned int mask)
{
423 424 425 426
	unsigned int caps;
	if (!nid)
		return false;
	caps = get_wcaps(codec, nid);
427 428 429 430 431 432 433 434 435 436 437
	if (dir == HDA_INPUT)
		caps &= AC_WCAP_IN_AMP;
	else
		caps &= AC_WCAP_OUT_AMP;
	if (!caps)
		return false;
	if (query_amp_caps(codec, nid, dir) & mask)
		return true;
	return false;
}

438 439
#define have_mute(codec, nid, dir) \
	check_amp_caps(codec, nid, dir, AC_AMPCAP_MUTE)
440

441 442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489
static bool is_node_in_path(struct nid_path *path, hda_nid_t nid)
{
	int i;
	if (!nid)
		return false;
	for (i = 0; i < path->depth; i++) {
		if (path->path[i] == nid)
			return true;
	}
	return false;
}

/* enable/disable the output-route mixers */
static void activate_output_mix(struct hda_codec *codec, struct nid_path *path,
				 hda_nid_t mix_nid, int aa_mix_idx, bool enable)
{
	int i, num, val;
	bool hp_path, front_path;
	struct via_spec *spec = codec->spec;

	if (!path)
		return;
	num = snd_hda_get_conn_list(codec, mix_nid, NULL);
	hp_path = is_node_in_path(path, spec->hp_dac_nid);
	front_path = is_node_in_path(path, spec->multiout.dac_nids[0]);

	for (i = 0; i < num; i++) {
		if (i == aa_mix_idx) {
			if (hp_path)
				val = enable ? AMP_IN_MUTE(i) :
				AMP_IN_UNMUTE(i);
			else if (front_path)
				val = AMP_IN_UNMUTE(i);
			else
				val = AMP_IN_MUTE(i);
		} else {
			if (hp_path)
				val = enable ? AMP_IN_UNMUTE(i) :
				AMP_IN_MUTE(i);
			else if (front_path)
				val = AMP_IN_MUTE(i);
			else
				val = AMP_IN_UNMUTE(i);
		}
		snd_hda_codec_write(codec, mix_nid, 0,
				    AC_VERB_SET_AMP_GAIN_MUTE, val);
	}
}

490 491 492
/* enable/disable the output-route */
static void activate_output_path(struct hda_codec *codec, struct nid_path *path,
				 bool enable, bool force)
493
{
494 495 496
	int i, val;
	struct via_spec *spec = codec->spec;
	hda_nid_t aa_mix_nid = spec->aa_mix_nid;
497 498 499 500 501 502 503 504 505 506 507
	for (i = 0; i < path->depth; i++) {
		hda_nid_t src, dst;
		int idx = path->idx[i];
		src = path->path[i];			
		if (i < path->depth - 1)
			dst = path->path[i + 1];
		else
			dst = 0;
		if (enable && path->multi[i])
			snd_hda_codec_write(codec, dst, 0,
					    AC_VERB_SET_CONNECT_SEL, idx);
508 509 510
		if (!force
		    && get_wcaps_type(get_wcaps(codec, src)) == AC_WID_AUD_OUT
		    && get_wcaps_type(get_wcaps(codec, dst)) == AC_WID_AUD_MIX)
511
			continue;
512
		if (have_mute(codec, dst, HDA_INPUT)) {
513 514 515 516 517 518 519 520 521 522 523 524 525
			if (dst == aa_mix_nid) {
				val = enable ? AMP_IN_UNMUTE(idx) :
					AMP_IN_MUTE(idx);
				snd_hda_codec_write(codec, dst, 0,
					AC_VERB_SET_AMP_GAIN_MUTE, val);
			} else {
				idx = get_connection_index(codec, dst,
							   aa_mix_nid);
				if (idx >= 0) {
					activate_output_mix(codec, path,
							    dst, idx, enable);
				}
			}
526 527 528 529 530 531 532 533 534
		}
		if (!force && (src == path->vol_ctl || src == path->mute_ctl))
			continue;
		if (have_mute(codec, src, HDA_OUTPUT)) {
			int val = enable ? AMP_OUT_UNMUTE : AMP_OUT_MUTE;
			snd_hda_codec_write(codec, src, 0,
					    AC_VERB_SET_AMP_GAIN_MUTE, val);
		}
	}
535 536 537 538 539 540 541 542 543 544 545 546
}

/* set the given pin as output */
static void init_output_pin(struct hda_codec *codec, hda_nid_t pin,
			    int pin_type)
{
	if (!pin)
		return;
	snd_hda_codec_write(codec, pin, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
			    pin_type);
	if (snd_hda_query_pin_caps(codec, pin) & AC_PINCAP_EAPD)
		snd_hda_codec_write(codec, pin, 0,
547
				    AC_VERB_SET_EAPD_BTLENABLE, 0x02);
548 549
}

550 551
static void via_auto_init_output(struct hda_codec *codec,
				 struct nid_path *path, int pin_type,
552
				 bool with_aa_mix, bool force)
553 554 555
{
	struct via_spec *spec = codec->spec;
	unsigned int caps;
556
	hda_nid_t pin;
557

558
	if (!path->depth)
559
		return;
560
	pin = path->path[path->depth - 1];
561 562 563 564 565 566 567 568 569 570

	init_output_pin(codec, pin, pin_type);
	caps = query_amp_caps(codec, pin, HDA_OUTPUT);
	if (caps & AC_AMPCAP_MUTE) {
		unsigned int val;
		val = (caps & AC_AMPCAP_OFFSET) >> AC_AMPCAP_OFFSET_SHIFT;
		snd_hda_codec_write(codec, pin, 0, AC_VERB_SET_AMP_GAIN_MUTE,
				    AMP_OUT_MUTE | val);
	}

571 572 573
	/* initialize the AA-path */
	if (!spec->aa_mix_nid)
		return;
574
	activate_output_path(codec, path, true, force);
575 576
}

577 578 579 580 581
static void via_auto_init_multi_out(struct hda_codec *codec)
{
	struct via_spec *spec = codec->spec;
	int i;

582
	for (i = 0; i < spec->autocfg.line_outs + spec->smart51_nums; i++)
583 584 585
		/* enable aa-mute only for the front channel */
		via_auto_init_output(codec, &spec->out_path[i], PIN_OUT,
				     i == 0, true);
586 587 588 589 590 591
}

static void via_auto_init_hp_out(struct hda_codec *codec)
{
	struct via_spec *spec = codec->spec;

592
	if (!spec->hp_dac_nid) {
593 594
		via_auto_init_output(codec, &spec->hp_dep_path, PIN_HP,
				     true, true);
595 596 597 598
		return;
	}
	if (spec->hp_independent_mode) {
		activate_output_path(codec, &spec->hp_dep_path, false, false);
599 600
		via_auto_init_output(codec, &spec->hp_path, PIN_HP,
				     true, true);
601 602
	} else {
		activate_output_path(codec, &spec->hp_path, false, false);
603 604
		via_auto_init_output(codec, &spec->hp_dep_path, PIN_HP,
				     true, true);
605
	}
606 607
}

608 609 610 611 612
static void via_auto_init_speaker_out(struct hda_codec *codec)
{
	struct via_spec *spec = codec->spec;

	if (spec->autocfg.speaker_outs)
613 614
		via_auto_init_output(codec, &spec->speaker_path, PIN_OUT,
				     true, true);
615 616
}

617
static bool is_smart51_pins(struct hda_codec *codec, hda_nid_t pin);
618
static void via_hp_automute(struct hda_codec *codec);
619

620 621 622
static void via_auto_init_analog_input(struct hda_codec *codec)
{
	struct via_spec *spec = codec->spec;
623
	const struct auto_pin_cfg *cfg = &spec->autocfg;
624
	hda_nid_t conn[HDA_MAX_CONNECTIONS];
625
	unsigned int ctl;
626 627 628 629 630 631 632 633
	int i, num_conns;

	/* init ADCs */
	for (i = 0; i < spec->num_adc_nids; i++) {
		snd_hda_codec_write(codec, spec->adc_nids[i], 0,
				    AC_VERB_SET_AMP_GAIN_MUTE,
				    AMP_IN_UNMUTE(0));
	}
634

635
	/* init pins */
636 637
	for (i = 0; i < cfg->num_inputs; i++) {
		hda_nid_t nid = cfg->inputs[i].pin;
638
		if (spec->smart51_enabled && is_smart51_pins(codec, nid))
639
			ctl = PIN_OUT;
640
		else if (cfg->inputs[i].type == AUTO_PIN_MIC)
641 642 643
			ctl = PIN_VREF50;
		else
			ctl = PIN_IN;
644
		snd_hda_codec_write(codec, nid, 0,
645
				    AC_VERB_SET_PIN_WIDGET_CONTROL, ctl);
646
	}
647 648 649

	/* init input-src */
	for (i = 0; i < spec->num_adc_nids; i++) {
650 651 652 653 654 655 656 657 658
		int adc_idx = spec->inputs[spec->cur_mux[i]].adc_idx;
		if (spec->mux_nids[adc_idx]) {
			int mux_idx = spec->inputs[spec->cur_mux[i]].mux_idx;
			snd_hda_codec_write(codec, spec->mux_nids[adc_idx], 0,
					    AC_VERB_SET_CONNECT_SEL,
					    mux_idx);
		}
		if (spec->dyn_adc_switch)
			break; /* only one input-src */
659 660 661 662 663 664 665 666 667 668 669 670 671 672
	}

	/* init aa-mixer */
	if (!spec->aa_mix_nid)
		return;
	num_conns = snd_hda_get_connections(codec, spec->aa_mix_nid, conn,
					    ARRAY_SIZE(conn));
	for (i = 0; i < num_conns; i++) {
		unsigned int caps = get_wcaps(codec, conn[i]);
		if (get_wcaps_type(caps) == AC_WID_PIN)
			snd_hda_codec_write(codec, spec->aa_mix_nid, 0,
					    AC_VERB_SET_AMP_GAIN_MUTE,
					    AMP_IN_MUTE(i));
	}
673
}
674 675 676 677 678 679 680 681 682

static void set_pin_power_state(struct hda_codec *codec, hda_nid_t nid,
				unsigned int *affected_parm)
{
	unsigned parm;
	unsigned def_conf = snd_hda_codec_get_pincfg(codec, nid);
	unsigned no_presence = (def_conf & AC_DEFCFG_MISC)
		>> AC_DEFCFG_MISC_SHIFT
		& AC_DEFCFG_MISC_NO_PRESENCE; /* do not support pin sense */
L
Lydia Wang 已提交
683
	struct via_spec *spec = codec->spec;
684 685 686 687 688
	unsigned present = 0;

	no_presence |= spec->no_pin_power_ctl;
	if (!no_presence)
		present = snd_hda_jack_detect(codec, nid);
689
	if ((spec->smart51_enabled && is_smart51_pins(codec, nid))
L
Lydia Wang 已提交
690 691
	    || ((no_presence || present)
		&& get_defcfg_connect(def_conf) != AC_JACK_PORT_NONE)) {
692 693 694 695 696 697 698 699
		*affected_parm = AC_PWRST_D0; /* if it's connected */
		parm = AC_PWRST_D0;
	} else
		parm = AC_PWRST_D3;

	snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_POWER_STATE, parm);
}

700 701 702 703 704 705 706 707 708 709 710 711 712 713 714 715 716 717 718 719 720 721 722 723 724 725 726 727 728 729 730 731 732 733 734 735 736 737 738 739 740 741 742 743 744 745 746 747 748
static int via_pin_power_ctl_info(struct snd_kcontrol *kcontrol,
				  struct snd_ctl_elem_info *uinfo)
{
	static const char * const texts[] = {
		"Disabled", "Enabled"
	};

	uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
	uinfo->count = 1;
	uinfo->value.enumerated.items = 2;
	if (uinfo->value.enumerated.item >= uinfo->value.enumerated.items)
		uinfo->value.enumerated.item = uinfo->value.enumerated.items - 1;
	strcpy(uinfo->value.enumerated.name,
	       texts[uinfo->value.enumerated.item]);
	return 0;
}

static int via_pin_power_ctl_get(struct snd_kcontrol *kcontrol,
				 struct snd_ctl_elem_value *ucontrol)
{
	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
	struct via_spec *spec = codec->spec;
	ucontrol->value.enumerated.item[0] = !spec->no_pin_power_ctl;
	return 0;
}

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

	if (val == spec->no_pin_power_ctl)
		return 0;
	spec->no_pin_power_ctl = val;
	set_widgets_power_state(codec);
	return 1;
}

static const struct snd_kcontrol_new via_pin_power_ctl_enum = {
	.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
	.name = "Dynamic Power-Control",
	.info = via_pin_power_ctl_info,
	.get = via_pin_power_ctl_get,
	.put = via_pin_power_ctl_put,
};


749 750 751
static int via_independent_hp_info(struct snd_kcontrol *kcontrol,
				   struct snd_ctl_elem_info *uinfo)
{
752 753 754 755 756 757 758 759 760 761
	static const char * const texts[] = { "OFF", "ON" };

	uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
	uinfo->count = 1;
	uinfo->value.enumerated.items = 2;
	if (uinfo->value.enumerated.item >= 2)
		uinfo->value.enumerated.item = 1;
	strcpy(uinfo->value.enumerated.name,
	       texts[uinfo->value.enumerated.item]);
	return 0;
762 763 764 765 766 767
}

static int via_independent_hp_get(struct snd_kcontrol *kcontrol,
				  struct snd_ctl_elem_value *ucontrol)
{
	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
768 769
	struct via_spec *spec = codec->spec;

770
	ucontrol->value.enumerated.item[0] = spec->hp_independent_mode;
771 772 773
	return 0;
}

774 775 776 777 778
static int via_independent_hp_put(struct snd_kcontrol *kcontrol,
				  struct snd_ctl_elem_value *ucontrol)
{
	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
	struct via_spec *spec = codec->spec;
779
	int cur;
780

781 782 783 784 785 786 787 788 789
	/* no independent-hp status change during PCM playback is running */
	if (spec->num_active_streams)
		return -EBUSY;

	cur = !!ucontrol->value.enumerated.item[0];
	if (spec->hp_independent_mode == cur)
		return 0;
	spec->hp_independent_mode = cur;
	if (cur) {
790 791
		activate_output_path(codec, &spec->hp_dep_path, false, false);
		activate_output_path(codec, &spec->hp_path, true, false);
792 793 794
		if (spec->hp_indep_shared)
			activate_output_path(codec, &spec->out_path[HDA_SIDE],
					     false, false);
795 796 797
	} else {
		activate_output_path(codec, &spec->hp_path, false, false);
		activate_output_path(codec, &spec->hp_dep_path, true, false);
798 799 800
		if (spec->hp_indep_shared)
			activate_output_path(codec, &spec->out_path[HDA_SIDE],
					     true, false);
801
	}
802

803
	/* update jack power state */
804
	set_widgets_power_state(codec);
805
	via_hp_automute(codec);
806
	return 1;
807 808
}

809 810 811 812 813 814
static const struct snd_kcontrol_new via_hp_mixer = {
	.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
	.name = "Independent HP",
	.info = via_independent_hp_info,
	.get = via_independent_hp_get,
	.put = via_independent_hp_put,
815 816
};

817
static int via_hp_build(struct hda_codec *codec)
818
{
819
	struct via_spec *spec = codec->spec;
820 821 822
	struct snd_kcontrol_new *knew;
	hda_nid_t nid;

823 824
	nid = spec->autocfg.hp_pins[0];
	knew = via_clone_control(spec, &via_hp_mixer);
825 826 827
	if (knew == NULL)
		return -ENOMEM;

828 829 830 831 832
	knew->subdevice = HDA_SUBDEV_NID_FLAG | nid;

	return 0;
}

L
Lydia Wang 已提交
833 834
static void notify_aa_path_ctls(struct hda_codec *codec)
{
835
	struct via_spec *spec = codec->spec;
L
Lydia Wang 已提交
836
	int i;
837 838 839 840 841 842 843

	for (i = 0; i < spec->smart51_nums; i++) {
		struct snd_kcontrol *ctl;
		struct snd_ctl_elem_id id;
		memset(&id, 0, sizeof(id));
		id.iface = SNDRV_CTL_ELEM_IFACE_MIXER;
		sprintf(id.name, "%s Playback Volume", spec->smart51_labels[i]);
844 845 846 847 848
		ctl = snd_hda_find_mixer_ctl(codec, id.name);
		if (ctl)
			snd_ctl_notify(codec->bus->card,
					SNDRV_CTL_EVENT_MASK_VALUE,
					&ctl->id);
L
Lydia Wang 已提交
849 850 851 852 853 854
	}
}

static void mute_aa_path(struct hda_codec *codec, int mute)
{
	struct via_spec *spec = codec->spec;
855
	int val = mute ? HDA_AMP_MUTE : HDA_AMP_UNMUTE;
L
Lydia Wang 已提交
856
	int i;
857

L
Lydia Wang 已提交
858
	/* check AA path's mute status */
859 860 861 862 863
	for (i = 0; i < spec->smart51_nums; i++) {
		if (spec->smart51_idxs[i] < 0)
			continue;
		snd_hda_codec_amp_stereo(codec, spec->aa_mix_nid,
					 HDA_INPUT, spec->smart51_idxs[i],
L
Lydia Wang 已提交
864 865 866
					 HDA_AMP_MUTE, val);
	}
}
867

868 869 870 871 872 873 874 875 876 877 878
static bool is_smart51_pins(struct hda_codec *codec, hda_nid_t pin)
{
	struct via_spec *spec = codec->spec;
	int i;

	for (i = 0; i < spec->smart51_nums; i++)
		if (spec->smart51_pins[i] == pin)
			return true;
	return false;
}

L
Lydia Wang 已提交
879 880 881 882 883 884
static int via_smart51_get(struct snd_kcontrol *kcontrol,
			   struct snd_ctl_elem_value *ucontrol)
{
	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
	struct via_spec *spec = codec->spec;

885
	*ucontrol->value.integer.value = spec->smart51_enabled;
L
Lydia Wang 已提交
886 887 888 889 890 891 892 893 894 895 896 897
	return 0;
}

static int via_smart51_put(struct snd_kcontrol *kcontrol,
			   struct snd_ctl_elem_value *ucontrol)
{
	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
	struct via_spec *spec = codec->spec;
	int out_in = *ucontrol->value.integer.value
		? AC_PINCTL_OUT_EN : AC_PINCTL_IN_EN;
	int i;

898 899
	for (i = 0; i < spec->smart51_nums; i++) {
		hda_nid_t nid = spec->smart51_pins[i];
900 901 902 903 904 905 906 907 908 909 910 911 912
		unsigned int parm;

		parm = snd_hda_codec_read(codec, nid, 0,
					  AC_VERB_GET_PIN_WIDGET_CONTROL, 0);
		parm &= ~(AC_PINCTL_IN_EN | AC_PINCTL_OUT_EN);
		parm |= out_in;
		snd_hda_codec_write(codec, nid, 0,
				    AC_VERB_SET_PIN_WIDGET_CONTROL,
				    parm);
		if (out_in == AC_PINCTL_OUT_EN) {
			mute_aa_path(codec, 1);
			notify_aa_path_ctls(codec);
		}
L
Lydia Wang 已提交
913 914
	}
	spec->smart51_enabled = *ucontrol->value.integer.value;
915
	set_widgets_power_state(codec);
L
Lydia Wang 已提交
916 917 918
	return 1;
}

919 920 921 922
static const struct snd_kcontrol_new via_smart51_mixer = {
	.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
	.name = "Smart 5.1",
	.count = 1,
923
	.info = snd_ctl_boolean_mono_info,
924 925
	.get = via_smart51_get,
	.put = via_smart51_put,
L
Lydia Wang 已提交
926 927
};

928
static int via_smart51_build(struct hda_codec *codec)
929
{
930
	struct via_spec *spec = codec->spec;
931

932
	if (!spec->smart51_nums)
933
		return 0;
934
	if (!via_clone_control(spec, &via_smart51_mixer))
935 936 937 938
		return -ENOMEM;
	return 0;
}

939 940
/* check AA path's mute status */
static bool is_aa_path_mute(struct hda_codec *codec)
941 942
{
	struct via_spec *spec = codec->spec;
943 944 945 946 947 948 949 950 951 952
	const struct hda_amp_list *p;
	int i, ch, v;

	for (i = 0; i < spec->num_loopbacks; i++) {
		p = &spec->loopback_list[i];
		for (ch = 0; ch < 2; ch++) {
			v = snd_hda_codec_amp_read(codec, p->nid, ch, p->dir,
						   p->idx);
			if (!(v & HDA_AMP_MUTE) && v > 0)
				return false;
953 954
		}
	}
955
	return true;
956 957 958
}

/* enter/exit analog low-current mode */
959
static void analog_low_current_mode(struct hda_codec *codec)
960 961
{
	struct via_spec *spec = codec->spec;
962 963 964 965
	bool enable;
	unsigned int verb, parm;

	enable = is_aa_path_mute(codec) && (spec->num_active_streams > 0);
966 967 968 969 970 971 972 973 974

	/* decide low current mode's verb & parameter */
	switch (spec->codec_type) {
	case VT1708B_8CH:
	case VT1708B_4CH:
		verb = 0xf70;
		parm = enable ? 0x02 : 0x00; /* 0x02: 2/3x, 0x00: 1x */
		break;
	case VT1708S:
L
Lydia Wang 已提交
975
	case VT1718S:
L
Lydia Wang 已提交
976
	case VT1716S:
977 978 979 980 981 982 983
		verb = 0xf73;
		parm = enable ? 0x51 : 0xe1; /* 0x51: 4/28x, 0xe1: 1x */
		break;
	case VT1702:
		verb = 0xf73;
		parm = enable ? 0x01 : 0x1d; /* 0x01: 4/40x, 0x1d: 1x */
		break;
L
Lydia Wang 已提交
984
	case VT2002P:
L
Lydia Wang 已提交
985
	case VT1812:
986
	case VT1802:
L
Lydia Wang 已提交
987 988 989
		verb = 0xf93;
		parm = enable ? 0x00 : 0xe0; /* 0x00: 4/40x, 0xe0: 1x */
		break;
990 991 992 993 994 995 996
	default:
		return;		/* other codecs are not supported */
	}
	/* send verb */
	snd_hda_codec_write(codec, codec->afg, 0, verb, parm);
}

997 998 999
/*
 * generic initialization of ADC, input mixers and output mixers
 */
1000
static const struct hda_verb vt1708_init_verbs[] = {
1001 1002
	/* power down jack detect function */
	{0x1, 0xf81, 0x1},
1003
	{ }
1004 1005
};

1006
static void set_stream_active(struct hda_codec *codec, bool active)
1007
{
1008 1009 1010 1011 1012 1013 1014
	struct via_spec *spec = codec->spec;

	if (active)
		spec->num_active_streams++;
	else
		spec->num_active_streams--;
	analog_low_current_mode(codec);
1015 1016
}

1017
static int via_playback_multi_pcm_open(struct hda_pcm_stream *hinfo,
1018 1019 1020 1021
				 struct hda_codec *codec,
				 struct snd_pcm_substream *substream)
{
	struct via_spec *spec = codec->spec;
1022
	const struct auto_pin_cfg *cfg = &spec->autocfg;
1023
	int err;
1024

1025 1026 1027 1028 1029 1030 1031 1032 1033 1034
	spec->multiout.hp_nid = 0;
	spec->multiout.num_dacs = cfg->line_outs + spec->smart51_nums;
	if (!spec->hp_independent_mode) {
		if (!spec->hp_indep_shared)
			spec->multiout.hp_nid = spec->hp_dac_nid;
	} else {
		if (spec->hp_indep_shared)
			spec->multiout.num_dacs = cfg->line_outs - 1;
	}
	spec->multiout.max_channels = spec->multiout.num_dacs * 2;
1035 1036 1037 1038 1039 1040 1041 1042 1043
	set_stream_active(codec, true);
	err = snd_hda_multi_out_analog_open(codec, &spec->multiout, substream,
					    hinfo);
	if (err < 0) {
		spec->multiout.hp_nid = 0;
		set_stream_active(codec, false);
		return err;
	}
	return 0;
1044 1045
}

1046
static int via_playback_multi_pcm_close(struct hda_pcm_stream *hinfo,
1047 1048 1049
				  struct hda_codec *codec,
				  struct snd_pcm_substream *substream)
{
1050 1051 1052
	struct via_spec *spec = codec->spec;

	spec->multiout.hp_nid = 0;
1053
	set_stream_active(codec, false);
1054 1055
	return 0;
}
1056

1057 1058 1059 1060 1061 1062
static int via_playback_hp_pcm_open(struct hda_pcm_stream *hinfo,
				    struct hda_codec *codec,
				    struct snd_pcm_substream *substream)
{
	struct via_spec *spec = codec->spec;

1063
	if (snd_BUG_ON(!spec->hp_dac_nid))
1064
		return -EINVAL;
1065 1066
	if (!spec->hp_independent_mode || spec->multiout.hp_nid)
		return -EBUSY;
1067
	set_stream_active(codec, true);
1068 1069 1070 1071 1072 1073 1074
	return 0;
}

static int via_playback_hp_pcm_close(struct hda_pcm_stream *hinfo,
				     struct hda_codec *codec,
				     struct snd_pcm_substream *substream)
{
1075
	set_stream_active(codec, false);
1076 1077 1078
	return 0;
}

1079 1080 1081 1082 1083
static int via_playback_multi_pcm_prepare(struct hda_pcm_stream *hinfo,
					  struct hda_codec *codec,
					  unsigned int stream_tag,
					  unsigned int format,
					  struct snd_pcm_substream *substream)
1084 1085
{
	struct via_spec *spec = codec->spec;
1086 1087 1088

	snd_hda_multi_out_analog_prepare(codec, &spec->multiout, stream_tag,
					 format, substream);
1089 1090
	vt1708_start_hp_work(spec);
	return 0;
1091 1092
}

1093 1094 1095 1096 1097
static int via_playback_hp_pcm_prepare(struct hda_pcm_stream *hinfo,
				       struct hda_codec *codec,
				       unsigned int stream_tag,
				       unsigned int format,
				       struct snd_pcm_substream *substream)
1098 1099 1100
{
	struct via_spec *spec = codec->spec;

1101 1102
	snd_hda_codec_setup_stream(codec, spec->hp_dac_nid,
				   stream_tag, 0, format);
1103
	vt1708_start_hp_work(spec);
1104 1105 1106 1107 1108 1109 1110 1111 1112
	return 0;
}

static int via_playback_multi_pcm_cleanup(struct hda_pcm_stream *hinfo,
				    struct hda_codec *codec,
				    struct snd_pcm_substream *substream)
{
	struct via_spec *spec = codec->spec;

1113
	snd_hda_multi_out_analog_cleanup(codec, &spec->multiout);
1114 1115 1116 1117 1118 1119 1120 1121 1122 1123
	vt1708_stop_hp_work(spec);
	return 0;
}

static int via_playback_hp_pcm_cleanup(struct hda_pcm_stream *hinfo,
				       struct hda_codec *codec,
				       struct snd_pcm_substream *substream)
{
	struct via_spec *spec = codec->spec;

1124
	snd_hda_codec_setup_stream(codec, spec->hp_dac_nid, 0, 0, 0);
1125
	vt1708_stop_hp_work(spec);
1126 1127 1128
	return 0;
}

1129 1130 1131 1132 1133 1134 1135 1136 1137 1138 1139 1140 1141 1142 1143 1144 1145 1146 1147
/*
 * Digital out
 */
static int via_dig_playback_pcm_open(struct hda_pcm_stream *hinfo,
				     struct hda_codec *codec,
				     struct snd_pcm_substream *substream)
{
	struct via_spec *spec = codec->spec;
	return snd_hda_multi_out_dig_open(codec, &spec->multiout);
}

static int via_dig_playback_pcm_close(struct hda_pcm_stream *hinfo,
				      struct hda_codec *codec,
				      struct snd_pcm_substream *substream)
{
	struct via_spec *spec = codec->spec;
	return snd_hda_multi_out_dig_close(codec, &spec->multiout);
}

1148
static int via_dig_playback_pcm_prepare(struct hda_pcm_stream *hinfo,
1149 1150 1151 1152 1153 1154
					struct hda_codec *codec,
					unsigned int stream_tag,
					unsigned int format,
					struct snd_pcm_substream *substream)
{
	struct via_spec *spec = codec->spec;
1155 1156 1157
	return snd_hda_multi_out_dig_prepare(codec, &spec->multiout,
					     stream_tag, format, substream);
}
1158

1159 1160 1161 1162 1163 1164
static int via_dig_playback_pcm_cleanup(struct hda_pcm_stream *hinfo,
					struct hda_codec *codec,
					struct snd_pcm_substream *substream)
{
	struct via_spec *spec = codec->spec;
	snd_hda_multi_out_dig_cleanup(codec, &spec->multiout);
1165 1166 1167
	return 0;
}

1168 1169 1170 1171 1172 1173 1174 1175 1176 1177 1178 1179 1180 1181 1182 1183 1184 1185 1186 1187 1188
/*
 * Analog capture
 */
static int via_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 via_spec *spec = codec->spec;

	snd_hda_codec_setup_stream(codec, spec->adc_nids[substream->number],
				   stream_tag, 0, format);
	return 0;
}

static int via_capture_pcm_cleanup(struct hda_pcm_stream *hinfo,
				   struct hda_codec *codec,
				   struct snd_pcm_substream *substream)
{
	struct via_spec *spec = codec->spec;
1189
	snd_hda_codec_cleanup_stream(codec, spec->adc_nids[substream->number]);
1190 1191 1192
	return 0;
}

1193 1194 1195 1196 1197 1198 1199 1200 1201 1202 1203 1204 1205 1206 1207 1208 1209 1210 1211 1212 1213 1214 1215 1216 1217 1218 1219 1220 1221 1222 1223 1224 1225 1226 1227 1228 1229 1230 1231 1232 1233 1234 1235 1236 1237 1238 1239
/* analog capture with dynamic ADC switching */
static int via_dyn_adc_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 via_spec *spec = codec->spec;
	int adc_idx = spec->inputs[spec->cur_mux[0]].adc_idx;

	spec->cur_adc = spec->adc_nids[adc_idx];
	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;
}

static int via_dyn_adc_capture_pcm_cleanup(struct hda_pcm_stream *hinfo,
					   struct hda_codec *codec,
					   struct snd_pcm_substream *substream)
{
	struct via_spec *spec = codec->spec;

	snd_hda_codec_cleanup_stream(codec, spec->cur_adc);
	spec->cur_adc = 0;
	return 0;
}

/* re-setup the stream if running; called from input-src put */
static bool via_dyn_adc_pcm_resetup(struct hda_codec *codec, int cur)
{
	struct via_spec *spec = codec->spec;
	int adc_idx = spec->inputs[cur].adc_idx;
	hda_nid_t adc = spec->adc_nids[adc_idx];

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

1240
static const struct hda_pcm_stream via_pcm_analog_playback = {
1241
	.substreams = 1,
1242 1243
	.channels_min = 2,
	.channels_max = 8,
1244
	/* NID is set in via_build_pcms */
1245
	.ops = {
1246 1247
		.open = via_playback_multi_pcm_open,
		.close = via_playback_multi_pcm_close,
1248 1249
		.prepare = via_playback_multi_pcm_prepare,
		.cleanup = via_playback_multi_pcm_cleanup
1250 1251 1252
	},
};

1253 1254 1255 1256 1257 1258 1259
static const struct hda_pcm_stream via_pcm_hp_playback = {
	.substreams = 1,
	.channels_min = 2,
	.channels_max = 2,
	/* NID is set in via_build_pcms */
	.ops = {
		.open = via_playback_hp_pcm_open,
1260
		.close = via_playback_hp_pcm_close,
1261 1262 1263 1264 1265
		.prepare = via_playback_hp_pcm_prepare,
		.cleanup = via_playback_hp_pcm_cleanup
	},
};

1266
static const struct hda_pcm_stream vt1708_pcm_analog_s16_playback = {
1267
	.substreams = 1,
1268 1269
	.channels_min = 2,
	.channels_max = 8,
1270
	/* NID is set in via_build_pcms */
1271 1272 1273 1274 1275 1276
	/* We got noisy outputs on the right channel on VT1708 when
	 * 24bit samples are used.  Until any workaround is found,
	 * disable the 24bit format, so far.
	 */
	.formats = SNDRV_PCM_FMTBIT_S16_LE,
	.ops = {
1277 1278
		.open = via_playback_multi_pcm_open,
		.close = via_playback_multi_pcm_close,
1279 1280
		.prepare = via_playback_multi_pcm_prepare,
		.cleanup = via_playback_multi_pcm_cleanup
1281 1282 1283
	},
};

1284
static const struct hda_pcm_stream via_pcm_analog_capture = {
1285
	.substreams = 1, /* will be changed in via_build_pcms() */
1286 1287
	.channels_min = 2,
	.channels_max = 2,
1288
	/* NID is set in via_build_pcms */
1289 1290 1291 1292 1293 1294
	.ops = {
		.prepare = via_capture_pcm_prepare,
		.cleanup = via_capture_pcm_cleanup
	},
};

1295 1296 1297 1298 1299 1300 1301 1302 1303 1304 1305
static const struct hda_pcm_stream via_pcm_dyn_adc_analog_capture = {
	.substreams = 1,
	.channels_min = 2,
	.channels_max = 2,
	/* NID is set in via_build_pcms */
	.ops = {
		.prepare = via_dyn_adc_capture_pcm_prepare,
		.cleanup = via_dyn_adc_capture_pcm_cleanup,
	},
};

1306
static const struct hda_pcm_stream via_pcm_digital_playback = {
1307 1308 1309 1310 1311 1312
	.substreams = 1,
	.channels_min = 2,
	.channels_max = 2,
	/* NID is set in via_build_pcms */
	.ops = {
		.open = via_dig_playback_pcm_open,
1313
		.close = via_dig_playback_pcm_close,
1314 1315
		.prepare = via_dig_playback_pcm_prepare,
		.cleanup = via_dig_playback_pcm_cleanup
1316 1317 1318
	},
};

1319
static const struct hda_pcm_stream via_pcm_digital_capture = {
1320 1321 1322 1323 1324
	.substreams = 1,
	.channels_min = 2,
	.channels_max = 2,
};

1325 1326 1327 1328 1329 1330 1331 1332 1333 1334 1335 1336 1337 1338 1339 1340 1341 1342 1343 1344 1345 1346 1347 1348 1349
/*
 * slave controls for virtual master
 */
static const char * const via_slave_vols[] = {
	"Front Playback Volume",
	"Surround Playback Volume",
	"Center Playback Volume",
	"LFE Playback Volume",
	"Side Playback Volume",
	"Headphone Playback Volume",
	"Speaker Playback Volume",
	NULL,
};

static const char * const via_slave_sws[] = {
	"Front Playback Switch",
	"Surround Playback Switch",
	"Center Playback Switch",
	"LFE Playback Switch",
	"Side Playback Switch",
	"Headphone Playback Switch",
	"Speaker Playback Switch",
	NULL,
};

1350 1351 1352
static int via_build_controls(struct hda_codec *codec)
{
	struct via_spec *spec = codec->spec;
1353 1354
	struct snd_kcontrol *kctl;
	int err, i;
1355

1356 1357 1358 1359
	if (spec->set_widgets_power_state)
		if (!via_clone_control(spec, &via_pin_power_ctl_enum))
			return -ENOMEM;

1360 1361 1362 1363 1364 1365 1366 1367
	for (i = 0; i < spec->num_mixers; i++) {
		err = snd_hda_add_new_ctls(codec, spec->mixers[i]);
		if (err < 0)
			return err;
	}

	if (spec->multiout.dig_out_nid) {
		err = snd_hda_create_spdif_out_ctls(codec,
1368
						    spec->multiout.dig_out_nid,
1369 1370 1371
						    spec->multiout.dig_out_nid);
		if (err < 0)
			return err;
1372 1373 1374 1375 1376
		err = snd_hda_create_spdif_share_sw(codec,
						    &spec->multiout);
		if (err < 0)
			return err;
		spec->multiout.share_spdif = 1;
1377 1378 1379 1380 1381 1382
	}
	if (spec->dig_in_nid) {
		err = snd_hda_create_spdif_in_ctls(codec, spec->dig_in_nid);
		if (err < 0)
			return err;
	}
1383

1384 1385 1386 1387 1388 1389 1390 1391 1392 1393 1394 1395 1396 1397 1398 1399 1400
	/* if we have no master control, let's create it */
	if (!snd_hda_find_mixer_ctl(codec, "Master Playback Volume")) {
		unsigned int vmaster_tlv[4];
		snd_hda_set_vmaster_tlv(codec, spec->multiout.dac_nids[0],
					HDA_OUTPUT, vmaster_tlv);
		err = snd_hda_add_vmaster(codec, "Master Playback Volume",
					  vmaster_tlv, via_slave_vols);
		if (err < 0)
			return err;
	}
	if (!snd_hda_find_mixer_ctl(codec, "Master Playback Switch")) {
		err = snd_hda_add_vmaster(codec, "Master Playback Switch",
					  NULL, via_slave_sws);
		if (err < 0)
			return err;
	}

1401 1402 1403
	/* assign Capture Source enums to NID */
	kctl = snd_hda_find_mixer_ctl(codec, "Input Source");
	for (i = 0; kctl && i < kctl->count; i++) {
1404
		err = snd_hda_add_nid(codec, kctl, i, spec->mux_nids[i]);
1405 1406 1407 1408
		if (err < 0)
			return err;
	}

1409
	/* init power states */
1410
	set_widgets_power_state(codec);
1411
	analog_low_current_mode(codec);
1412

1413
	via_free_kctls(codec); /* no longer needed */
1414 1415 1416 1417 1418 1419 1420 1421 1422 1423 1424
	return 0;
}

static int via_build_pcms(struct hda_codec *codec)
{
	struct via_spec *spec = codec->spec;
	struct hda_pcm *info = spec->pcm_rec;

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

1425 1426
	snprintf(spec->stream_name_analog, sizeof(spec->stream_name_analog),
		 "%s Analog", codec->chip_name);
1427
	info->name = spec->stream_name_analog;
1428 1429 1430

	if (!spec->stream_analog_playback)
		spec->stream_analog_playback = &via_pcm_analog_playback;
L
Lydia Wang 已提交
1431
	info->stream[SNDRV_PCM_STREAM_PLAYBACK] =
1432
		*spec->stream_analog_playback;
L
Lydia Wang 已提交
1433 1434
	info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid =
		spec->multiout.dac_nids[0];
1435 1436
	info->stream[SNDRV_PCM_STREAM_PLAYBACK].channels_max =
		spec->multiout.max_channels;
1437

1438 1439 1440 1441 1442 1443 1444
	if (!spec->stream_analog_capture) {
		if (spec->dyn_adc_switch)
			spec->stream_analog_capture =
				&via_pcm_dyn_adc_analog_capture;
		else
			spec->stream_analog_capture = &via_pcm_analog_capture;
	}
1445 1446 1447
	info->stream[SNDRV_PCM_STREAM_CAPTURE] =
		*spec->stream_analog_capture;
	info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = spec->adc_nids[0];
1448 1449 1450
	if (!spec->dyn_adc_switch)
		info->stream[SNDRV_PCM_STREAM_CAPTURE].substreams =
			spec->num_adc_nids;
1451 1452 1453 1454

	if (spec->multiout.dig_out_nid || spec->dig_in_nid) {
		codec->num_pcms++;
		info++;
1455 1456 1457
		snprintf(spec->stream_name_digital,
			 sizeof(spec->stream_name_digital),
			 "%s Digital", codec->chip_name);
1458
		info->name = spec->stream_name_digital;
1459
		info->pcm_type = HDA_PCM_TYPE_SPDIF;
1460
		if (spec->multiout.dig_out_nid) {
1461 1462 1463
			if (!spec->stream_digital_playback)
				spec->stream_digital_playback =
					&via_pcm_digital_playback;
1464
			info->stream[SNDRV_PCM_STREAM_PLAYBACK] =
1465
				*spec->stream_digital_playback;
1466 1467 1468 1469
			info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid =
				spec->multiout.dig_out_nid;
		}
		if (spec->dig_in_nid) {
1470 1471 1472
			if (!spec->stream_digital_capture)
				spec->stream_digital_capture =
					&via_pcm_digital_capture;
1473
			info->stream[SNDRV_PCM_STREAM_CAPTURE] =
1474
				*spec->stream_digital_capture;
1475 1476 1477 1478 1479
			info->stream[SNDRV_PCM_STREAM_CAPTURE].nid =
				spec->dig_in_nid;
		}
	}

1480
	if (spec->hp_dac_nid) {
1481 1482 1483 1484 1485 1486 1487
		codec->num_pcms++;
		info++;
		snprintf(spec->stream_name_hp, sizeof(spec->stream_name_hp),
			 "%s HP", codec->chip_name);
		info->name = spec->stream_name_hp;
		info->stream[SNDRV_PCM_STREAM_PLAYBACK] = via_pcm_hp_playback;
		info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid =
1488
			spec->hp_dac_nid;
1489
	}
1490 1491 1492 1493 1494 1495 1496 1497 1498 1499
	return 0;
}

static void via_free(struct hda_codec *codec)
{
	struct via_spec *spec = codec->spec;

	if (!spec)
		return;

1500
	via_free_kctls(codec);
1501
	vt1708_stop_hp_work(spec);
1502 1503 1504
	kfree(spec->bind_cap_vol);
	kfree(spec->bind_cap_sw);
	kfree(spec);
1505 1506
}

1507 1508 1509 1510 1511 1512 1513 1514 1515 1516 1517
/* mute/unmute outputs */
static void toggle_output_mutes(struct hda_codec *codec, int num_pins,
				hda_nid_t *pins, bool mute)
{
	int i;
	for (i = 0; i < num_pins; i++)
		snd_hda_codec_write(codec, pins[i], 0,
				    AC_VERB_SET_PIN_WIDGET_CONTROL,
				    mute ? 0 : PIN_OUT);
}

1518 1519
/* mute internal speaker if line-out is plugged */
static void via_line_automute(struct hda_codec *codec, int present)
1520 1521 1522
{
	struct via_spec *spec = codec->spec;

1523 1524 1525 1526 1527 1528 1529 1530
	if (!spec->autocfg.speaker_outs)
		return;
	if (!present)
		present = snd_hda_jack_detect(codec,
					      spec->autocfg.line_out_pins[0]);
	toggle_output_mutes(codec, spec->autocfg.speaker_outs,
			    spec->autocfg.speaker_pins,
			    present);
1531 1532
}

1533 1534
/* mute internal speaker if HP is plugged */
static void via_hp_automute(struct hda_codec *codec)
L
Lydia Wang 已提交
1535
{
1536
	int present = 0;
1537
	int nums;
L
Lydia Wang 已提交
1538 1539
	struct via_spec *spec = codec->spec;

1540
	if (!spec->hp_independent_mode && spec->autocfg.hp_pins[0])
1541
		present = snd_hda_jack_detect(codec, spec->autocfg.hp_pins[0]);
1542 1543 1544 1545 1546 1547 1548

	if (spec->smart51_enabled)
		nums = spec->autocfg.line_outs + spec->smart51_nums;
	else
		nums = spec->autocfg.line_outs;
	toggle_output_mutes(codec, nums, spec->autocfg.line_out_pins, present);

1549
	via_line_automute(codec, present);
L
Lydia Wang 已提交
1550 1551
}

1552 1553 1554 1555 1556 1557 1558 1559 1560 1561 1562 1563 1564 1565 1566 1567 1568 1569 1570 1571 1572 1573
static void via_gpio_control(struct hda_codec *codec)
{
	unsigned int gpio_data;
	unsigned int vol_counter;
	unsigned int vol;
	unsigned int master_vol;

	struct via_spec *spec = codec->spec;

	gpio_data = snd_hda_codec_read(codec, codec->afg, 0,
				       AC_VERB_GET_GPIO_DATA, 0) & 0x03;

	vol_counter = (snd_hda_codec_read(codec, codec->afg, 0,
					  0xF84, 0) & 0x3F0000) >> 16;

	vol = vol_counter & 0x1F;
	master_vol = snd_hda_codec_read(codec, 0x1A, 0,
					AC_VERB_GET_AMP_GAIN_MUTE,
					AC_AMP_GET_INPUT);

	if (gpio_data == 0x02) {
		/* unmute line out */
1574 1575 1576
		snd_hda_codec_write(codec, spec->autocfg.line_out_pins[0], 0,
				    AC_VERB_SET_PIN_WIDGET_CONTROL,
				    PIN_OUT);
1577 1578 1579 1580 1581 1582 1583 1584 1585 1586 1587 1588 1589 1590 1591 1592
		if (vol_counter & 0x20) {
			/* decrease volume */
			if (vol > master_vol)
				vol = master_vol;
			snd_hda_codec_amp_stereo(codec, 0x1A, HDA_INPUT,
						 0, HDA_AMP_VOLMASK,
						 master_vol-vol);
		} else {
			/* increase volume */
			snd_hda_codec_amp_stereo(codec, 0x1A, HDA_INPUT, 0,
					 HDA_AMP_VOLMASK,
					 ((master_vol+vol) > 0x2A) ? 0x2A :
					  (master_vol+vol));
		}
	} else if (!(gpio_data & 0x02)) {
		/* mute line out */
1593 1594 1595
		snd_hda_codec_write(codec, spec->autocfg.line_out_pins[0], 0,
				    AC_VERB_SET_PIN_WIDGET_CONTROL,
				    0);
1596 1597 1598 1599 1600 1601 1602 1603
	}
}

/* unsolicited event for jack sensing */
static void via_unsol_event(struct hda_codec *codec,
				  unsigned int res)
{
	res >>= 26;
1604

1605
	if (res & VIA_JACK_EVENT)
1606
		set_widgets_power_state(codec);
1607 1608 1609

	res &= ~VIA_JACK_EVENT;

1610
	if (res == VIA_HP_EVENT || res == VIA_LINE_EVENT)
1611 1612 1613
		via_hp_automute(codec);
	else if (res == VIA_GPIO_EVENT)
		via_gpio_control(codec);
1614 1615
}

1616 1617 1618 1619 1620 1621 1622 1623 1624
#ifdef SND_HDA_NEEDS_RESUME
static int via_suspend(struct hda_codec *codec, pm_message_t state)
{
	struct via_spec *spec = codec->spec;
	vt1708_stop_hp_work(spec);
	return 0;
}
#endif

1625 1626 1627 1628 1629 1630 1631 1632
#ifdef CONFIG_SND_HDA_POWER_SAVE
static int via_check_power_status(struct hda_codec *codec, hda_nid_t nid)
{
	struct via_spec *spec = codec->spec;
	return snd_hda_check_amp_list_power(codec, &spec->loopback, nid);
}
#endif

1633 1634
/*
 */
1635 1636 1637

static int via_init(struct hda_codec *codec);

1638
static const struct hda_codec_ops via_patch_ops = {
1639 1640 1641 1642
	.build_controls = via_build_controls,
	.build_pcms = via_build_pcms,
	.init = via_init,
	.free = via_free,
1643
	.unsol_event = via_unsol_event,
1644 1645 1646
#ifdef SND_HDA_NEEDS_RESUME
	.suspend = via_suspend,
#endif
1647 1648 1649
#ifdef CONFIG_SND_HDA_POWER_SAVE
	.check_power_status = via_check_power_status,
#endif
1650 1651
};

1652 1653 1654 1655 1656 1657 1658 1659 1660
static bool is_empty_dac(struct hda_codec *codec, hda_nid_t dac)
{
	struct via_spec *spec = codec->spec;
	int i;

	for (i = 0; i < spec->multiout.num_dacs; i++) {
		if (spec->multiout.dac_nids[i] == dac)
			return false;
	}
1661
	if (spec->hp_dac_nid == dac)
1662 1663 1664 1665
		return false;
	return true;
}

1666
static bool __parse_output_path(struct hda_codec *codec, hda_nid_t nid,
1667 1668 1669 1670 1671 1672 1673 1674 1675 1676
			      hda_nid_t target_dac, struct nid_path *path,
			      int depth, int wid_type)
{
	hda_nid_t conn[8];
	int i, nums;

	nums = snd_hda_get_connections(codec, nid, conn, ARRAY_SIZE(conn));
	for (i = 0; i < nums; i++) {
		if (get_wcaps_type(get_wcaps(codec, conn[i])) != AC_WID_AUD_OUT)
			continue;
1677 1678
		if (conn[i] == target_dac || is_empty_dac(codec, conn[i]))
			goto found;
1679
	}
1680
	if (depth >= MAX_NID_PATH_DEPTH)
1681 1682 1683 1684 1685 1686 1687
		return false;
	for (i = 0; i < nums; i++) {
		unsigned int type;
		type = get_wcaps_type(get_wcaps(codec, conn[i]));
		if (type == AC_WID_AUD_OUT ||
		    (wid_type != -1 && type != wid_type))
			continue;
1688
		if (__parse_output_path(codec, conn[i], target_dac,
1689 1690
				      path, depth + 1, AC_WID_AUD_SEL))
			goto found;
1691 1692
	}
	return false;
1693 1694 1695 1696 1697 1698 1699 1700

 found:
	path->path[path->depth] = conn[i];
	path->idx[path->depth] = i;
	if (nums > 1 && get_wcaps_type(get_wcaps(codec, nid)) != AC_WID_AUD_MIX)
		path->multi[path->depth] = 1;
	path->depth++;
	return true;
1701 1702
}

1703 1704 1705 1706 1707 1708 1709 1710 1711 1712 1713
static bool parse_output_path(struct hda_codec *codec, hda_nid_t nid,
			      hda_nid_t target_dac, struct nid_path *path)
{
	if (__parse_output_path(codec, nid, target_dac, path, 1, -1)) {
		path->path[path->depth] = nid;
		path->depth++;
		return true;
	}
	return false;
}

1714
static int via_auto_fill_dac_nids(struct hda_codec *codec)
1715
{
1716 1717
	struct via_spec *spec = codec->spec;
	const struct auto_pin_cfg *cfg = &spec->autocfg;
1718
	int i, dac_num;
1719 1720
	hda_nid_t nid;

1721
	spec->multiout.dac_nids = spec->private_dac_nids;
1722
	dac_num = 0;
1723 1724 1725 1726
	for (i = 0; i < cfg->line_outs; i++) {
		nid = cfg->line_out_pins[i];
		if (!nid)
			continue;
1727
		if (parse_output_path(codec, nid, 0, &spec->out_path[i])) {
1728
			spec->private_dac_nids[i] = spec->out_path[i].path[0];
1729 1730
			dac_num++;
		}
1731
	}
1732
	spec->multiout.num_dacs = dac_num;
1733 1734
	return 0;
}
1735

1736
static int create_ch_ctls(struct hda_codec *codec, const char *pfx,
1737
			  int chs, bool check_dac, struct nid_path *path)
1738 1739 1740
{
	struct via_spec *spec = codec->spec;
	char name[32];
1741 1742
	hda_nid_t dac, pin, sel, nid;
	int err;
1743

1744 1745 1746
	dac = check_dac ? path->path[0] : 0;
	pin = path->path[path->depth - 1];
	sel = path->depth > 1 ? path->path[1] : 0;
L
Lydia Wang 已提交
1747

1748
	if (dac && check_amp_caps(codec, dac, HDA_OUTPUT, AC_AMPCAP_NUM_STEPS))
1749
		nid = dac;
1750
	else if (check_amp_caps(codec, pin, HDA_OUTPUT, AC_AMPCAP_NUM_STEPS))
1751
		nid = pin;
1752 1753
	else if (check_amp_caps(codec, sel, HDA_OUTPUT, AC_AMPCAP_NUM_STEPS))
		nid = sel;
1754 1755 1756 1757 1758
	else
		nid = 0;
	if (nid) {
		sprintf(name, "%s Playback Volume", pfx);
		err = via_add_control(spec, VIA_CTL_WIDGET_VOL, name,
1759
			      HDA_COMPOSE_AMP_VAL(nid, chs, 0, HDA_OUTPUT));
1760 1761
		if (err < 0)
			return err;
1762
		path->vol_ctl = nid;
1763 1764
	}

1765
	if (dac && check_amp_caps(codec, dac, HDA_OUTPUT, AC_AMPCAP_MUTE))
1766
		nid = dac;
1767
	else if (check_amp_caps(codec, pin, HDA_OUTPUT, AC_AMPCAP_MUTE))
1768
		nid = pin;
1769 1770
	else if (check_amp_caps(codec, sel, HDA_OUTPUT, AC_AMPCAP_MUTE))
		nid = sel;
1771 1772 1773 1774 1775 1776 1777 1778
	else
		nid = 0;
	if (nid) {
		sprintf(name, "%s Playback Switch", pfx);
		err = via_add_control(spec, VIA_CTL_WIDGET_MUTE, name,
			      HDA_COMPOSE_AMP_VAL(nid, chs, 0, HDA_OUTPUT));
		if (err < 0)
			return err;
1779
		path->mute_ctl = nid;
1780
	}
1781 1782 1783
	return 0;
}

1784 1785 1786 1787
static void mangle_smart51(struct hda_codec *codec)
{
	struct via_spec *spec = codec->spec;
	struct auto_pin_cfg *cfg = &spec->autocfg;
1788 1789 1790 1791 1792 1793 1794 1795 1796 1797 1798 1799 1800 1801 1802 1803
	struct auto_pin_cfg_item *ins = cfg->inputs;
	int i, j, nums, attr;
	int pins[AUTO_CFG_MAX_INS];

	for (attr = INPUT_PIN_ATTR_REAR; attr >= INPUT_PIN_ATTR_NORMAL; attr--) {
		nums = 0;
		for (i = 0; i < cfg->num_inputs; i++) {
			unsigned int def;
			if (ins[i].type > AUTO_PIN_LINE_IN)
				continue;
			def = snd_hda_codec_get_pincfg(codec, ins[i].pin);
			if (snd_hda_get_input_pin_attr(def) != attr)
				continue;
			for (j = 0; j < nums; j++)
				if (ins[pins[j]].type < ins[i].type) {
					memmove(pins + j + 1, pins + j,
1804
						(nums - j) * sizeof(int));
1805 1806 1807
					break;
				}
			pins[j] = i;
1808
			nums++;
1809 1810
		}
		if (cfg->line_outs + nums < 3)
1811
			continue;
1812 1813 1814 1815 1816 1817 1818 1819
		for (i = 0; i < nums; i++) {
			hda_nid_t pin = ins[pins[i]].pin;
			spec->smart51_pins[spec->smart51_nums++] = pin;
			cfg->line_out_pins[cfg->line_outs++] = pin;
			if (cfg->line_outs == 3)
				break;
		}
		return;
1820 1821 1822
	}
}

1823
/* add playback controls from the parsed DAC table */
1824
static int via_auto_create_multi_out_ctls(struct hda_codec *codec)
1825
{
1826
	struct via_spec *spec = codec->spec;
1827
	struct auto_pin_cfg *cfg = &spec->autocfg;
1828 1829 1830
	static const char * const chname[4] = {
		"Front", "Surround", "C/LFE", "Side"
	};
1831
	int i, idx, err;
1832 1833 1834 1835 1836 1837
	int old_line_outs;

	/* check smart51 */
	old_line_outs = cfg->line_outs;
	if (cfg->line_outs == 1)
		mangle_smart51(codec);
1838

1839 1840 1841 1842
	err = via_auto_fill_dac_nids(codec);
	if (err < 0)
		return err;

1843 1844 1845 1846
	if (spec->multiout.num_dacs < 3) {
		spec->smart51_nums = 0;
		cfg->line_outs = old_line_outs;
	}
1847 1848 1849 1850 1851
	for (i = 0; i < cfg->line_outs; i++) {
		hda_nid_t pin, dac;
		pin = cfg->line_out_pins[i];
		dac = spec->multiout.dac_nids[i];
		if (!pin || !dac)
1852
			continue;
1853
		if (i == HDA_CLFE) {
1854 1855
			err = create_ch_ctls(codec, "Center", 1, true,
					     &spec->out_path[i]);
1856 1857
			if (err < 0)
				return err;
1858 1859
			err = create_ch_ctls(codec, "LFE", 2, true,
					     &spec->out_path[i]);
1860 1861 1862
			if (err < 0)
				return err;
		} else {
1863 1864 1865 1866
			const char *pfx = chname[i];
			if (cfg->line_out_type == AUTO_PIN_SPEAKER_OUT &&
			    cfg->line_outs == 1)
				pfx = "Speaker";
1867 1868
			err = create_ch_ctls(codec, pfx, 3, true,
					     &spec->out_path[i]);
1869 1870 1871 1872 1873
			if (err < 0)
				return err;
		}
	}

1874 1875
	idx = get_connection_index(codec, spec->aa_mix_nid,
				   spec->multiout.dac_nids[0]);
1876 1877
	if (idx < 0 && spec->dac_mixer_idx)
		idx = spec->dac_mixer_idx;
1878 1879 1880 1881 1882 1883 1884 1885 1886 1887 1888 1889 1890 1891 1892 1893
	if (idx >= 0) {
		/* add control to mixer */
		err = via_add_control(spec, VIA_CTL_WIDGET_VOL,
				      "PCM Playback Volume",
				      HDA_COMPOSE_AMP_VAL(spec->aa_mix_nid, 3,
							  idx, HDA_INPUT));
		if (err < 0)
			return err;
		err = via_add_control(spec, VIA_CTL_WIDGET_MUTE,
				      "PCM Playback Switch",
				      HDA_COMPOSE_AMP_VAL(spec->aa_mix_nid, 3,
							  idx, HDA_INPUT));
		if (err < 0)
			return err;
	}

1894 1895
	cfg->line_outs = old_line_outs;

1896 1897 1898
	return 0;
}

1899
static int via_auto_create_hp_ctls(struct hda_codec *codec, hda_nid_t pin)
1900
{
1901
	struct via_spec *spec = codec->spec;
1902
	struct nid_path *path;
1903
	bool check_dac;
1904 1905 1906 1907 1908
	int err;

	if (!pin)
		return 0;

1909
	if (parse_output_path(codec, pin, 0, &spec->hp_path))
1910
		spec->hp_dac_nid = spec->hp_path.path[0];
1911 1912 1913 1914 1915 1916
	else if (spec->multiout.dac_nids[HDA_SIDE] &&
		 parse_output_path(codec, pin,
				   spec->multiout.dac_nids[HDA_SIDE],
				   &spec->hp_path)) {
		spec->hp_dac_nid = spec->hp_path.path[0];
		spec->hp_indep_shared = true;
1917 1918 1919 1920 1921 1922
	} else if (spec->multiout.dac_nids[HDA_CLFE] &&
		 parse_output_path(codec, pin,
				   spec->multiout.dac_nids[HDA_CLFE],
				   &spec->hp_path)) {
		spec->hp_dac_nid = spec->hp_path.path[0];
		spec->hp_indep_shared = true;
1923
	}
1924

1925
	if (!parse_output_path(codec, pin, spec->multiout.dac_nids[HDA_FRONT],
1926
			       &spec->hp_dep_path) &&
1927 1928 1929
	    !spec->hp_dac_nid)
		return 0;

1930
	if (spec->hp_dac_nid && !spec->hp_indep_shared) {
1931
		path = &spec->hp_path;
1932 1933
		check_dac = true;
	} else {
1934
		path = &spec->hp_dep_path;
1935 1936 1937
		check_dac = false;
	}
	err = create_ch_ctls(codec, "Headphone", 3, check_dac, path);
1938 1939
	if (err < 0)
		return err;
1940 1941 1942 1943
	if (spec->hp_dac_nid) {
		spec->hp_dep_path.vol_ctl = spec->hp_path.vol_ctl;
		spec->hp_dep_path.mute_ctl = spec->hp_path.mute_ctl;
	}
1944 1945 1946 1947

	return 0;
}

1948 1949 1950 1951 1952 1953 1954 1955 1956
static int via_auto_create_speaker_ctls(struct hda_codec *codec)
{
	struct via_spec *spec = codec->spec;
	hda_nid_t pin, dac;

	pin = spec->autocfg.speaker_pins[0];
	if (!spec->autocfg.speaker_outs || !pin)
		return 0;

1957 1958
	if (parse_output_path(codec, pin, 0, &spec->speaker_path)) {
		dac = spec->speaker_path.path[0];
1959
		spec->multiout.extra_out_nid[0] = dac;
1960 1961
		return create_ch_ctls(codec, "Speaker", 3, true,
				      &spec->speaker_path);
1962 1963
	}
	if (parse_output_path(codec, pin, spec->multiout.dac_nids[HDA_FRONT],
1964
			      &spec->speaker_path))
1965 1966
		return create_ch_ctls(codec, "Speaker", 3, false,
				      &spec->speaker_path);
1967 1968 1969 1970

	return 0;
}

1971 1972 1973 1974 1975 1976 1977 1978 1979 1980 1981 1982 1983 1984 1985 1986 1987 1988 1989 1990 1991 1992
/* look for ADCs */
static int via_fill_adcs(struct hda_codec *codec)
{
	struct via_spec *spec = codec->spec;
	hda_nid_t nid = codec->start_nid;
	int i;

	for (i = 0; i < codec->num_nodes; i++, nid++) {
		unsigned int wcaps = get_wcaps(codec, nid);
		if (get_wcaps_type(wcaps) != AC_WID_AUD_IN)
			continue;
		if (wcaps & AC_WCAP_DIGITAL)
			continue;
		if (!(wcaps & AC_WCAP_CONN_LIST))
			continue;
		if (spec->num_adc_nids >= ARRAY_SIZE(spec->adc_nids))
			return -ENOMEM;
		spec->adc_nids[spec->num_adc_nids++] = nid;
	}
	return 0;
}

1993 1994 1995 1996 1997 1998 1999 2000 2001 2002 2003 2004 2005 2006 2007 2008 2009 2010 2011 2012 2013 2014 2015 2016 2017 2018 2019 2020 2021 2022 2023 2024 2025 2026 2027 2028 2029 2030 2031 2032 2033 2034 2035 2036 2037 2038 2039 2040 2041 2042 2043 2044 2045 2046 2047 2048 2049 2050 2051 2052 2053 2054 2055 2056 2057 2058 2059 2060
/* input-src control */
static int via_mux_enum_info(struct snd_kcontrol *kcontrol,
			     struct snd_ctl_elem_info *uinfo)
{
	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
	struct via_spec *spec = codec->spec;

	uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
	uinfo->count = 1;
	uinfo->value.enumerated.items = spec->num_inputs;
	if (uinfo->value.enumerated.item >= spec->num_inputs)
		uinfo->value.enumerated.item = spec->num_inputs - 1;
	strcpy(uinfo->value.enumerated.name,
	       spec->inputs[uinfo->value.enumerated.item].label);
	return 0;
}

static int via_mux_enum_get(struct snd_kcontrol *kcontrol,
			    struct snd_ctl_elem_value *ucontrol)
{
	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
	struct via_spec *spec = codec->spec;
	unsigned int idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);

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

static int via_mux_enum_put(struct snd_kcontrol *kcontrol,
			    struct snd_ctl_elem_value *ucontrol)
{
	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
	struct via_spec *spec = codec->spec;
	unsigned int idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
	hda_nid_t mux;
	int cur;

	cur = ucontrol->value.enumerated.item[0];
	if (cur < 0 || cur >= spec->num_inputs)
		return -EINVAL;
	if (spec->cur_mux[idx] == cur)
		return 0;
	spec->cur_mux[idx] = cur;
	if (spec->dyn_adc_switch) {
		int adc_idx = spec->inputs[cur].adc_idx;
		mux = spec->mux_nids[adc_idx];
		via_dyn_adc_pcm_resetup(codec, cur);
	} else {
		mux = spec->mux_nids[idx];
		if (snd_BUG_ON(!mux))
			return -EINVAL;
	}

	if (mux) {
		/* switch to D0 beofre change index */
		if (snd_hda_codec_read(codec, mux, 0,
			       AC_VERB_GET_POWER_STATE, 0x00) != AC_PWRST_D0)
			snd_hda_codec_write(codec, mux, 0,
				    AC_VERB_SET_POWER_STATE, AC_PWRST_D0);
		snd_hda_codec_write(codec, mux, 0,
				    AC_VERB_SET_CONNECT_SEL,
				    spec->inputs[cur].mux_idx);
	}

	/* update jack power state */
	set_widgets_power_state(codec);
	return 0;
}
2061

2062 2063 2064 2065 2066 2067 2068 2069 2070 2071 2072 2073
static const struct snd_kcontrol_new via_input_src_ctl = {
	.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
	/* The multiple "Capture Source" controls confuse alsamixer
	 * So call somewhat different..
	 */
	/* .name = "Capture Source", */
	.name = "Input Source",
	.info = via_mux_enum_info,
	.get = via_mux_enum_get,
	.put = via_mux_enum_put,
};

2074 2075 2076 2077 2078 2079 2080 2081 2082 2083 2084 2085 2086 2087 2088 2089
static int create_input_src_ctls(struct hda_codec *codec, int count)
{
	struct via_spec *spec = codec->spec;
	struct snd_kcontrol_new *knew;

	if (spec->num_inputs <= 1 || !count)
		return 0; /* no need for single src */

	knew = via_clone_control(spec, &via_input_src_ctl);
	if (!knew)
		return -ENOMEM;
	knew->count = count;
	return 0;
}

/* add the powersave loopback-list entry */
2090 2091 2092 2093 2094 2095 2096 2097 2098 2099 2100 2101 2102 2103
static void add_loopback_list(struct via_spec *spec, hda_nid_t mix, int idx)
{
	struct hda_amp_list *list;

	if (spec->num_loopbacks >= ARRAY_SIZE(spec->loopback_list) - 1)
		return;
	list = spec->loopback_list + spec->num_loopbacks;
	list->nid = mix;
	list->dir = HDA_INPUT;
	list->idx = idx;
	spec->num_loopbacks++;
	spec->loopback.amplist = spec->loopback_list;
}

2104
static bool is_reachable_nid(struct hda_codec *codec, hda_nid_t src,
2105
			     hda_nid_t dst)
2106
{
2107
	return snd_hda_get_conn_index(codec, src, dst, 1) >= 0;
2108 2109 2110 2111
}

/* add the input-route to the given pin */
static bool add_input_route(struct hda_codec *codec, hda_nid_t pin)
2112
{
2113
	struct via_spec *spec = codec->spec;
2114 2115 2116 2117 2118 2119 2120 2121 2122 2123 2124 2125
	int c, idx;

	spec->inputs[spec->num_inputs].adc_idx = -1;
	spec->inputs[spec->num_inputs].pin = pin;
	for (c = 0; c < spec->num_adc_nids; c++) {
		if (spec->mux_nids[c]) {
			idx = get_connection_index(codec, spec->mux_nids[c],
						   pin);
			if (idx < 0)
				continue;
			spec->inputs[spec->num_inputs].mux_idx = idx;
		} else {
2126
			if (!is_reachable_nid(codec, spec->adc_nids[c], pin))
2127 2128 2129 2130 2131 2132 2133 2134 2135 2136 2137 2138 2139 2140 2141 2142 2143 2144 2145 2146 2147 2148 2149
				continue;
		}
		spec->inputs[spec->num_inputs].adc_idx = c;
		/* Can primary ADC satisfy all inputs? */
		if (!spec->dyn_adc_switch &&
		    spec->num_inputs > 0 && spec->inputs[0].adc_idx != c) {
			snd_printd(KERN_INFO
				   "via: dynamic ADC switching enabled\n");
			spec->dyn_adc_switch = 1;
		}
		return true;
	}
	return false;
}

static int get_mux_nids(struct hda_codec *codec);

/* parse input-routes; fill ADCs, MUXs and input-src entries */
static int parse_analog_inputs(struct hda_codec *codec)
{
	struct via_spec *spec = codec->spec;
	const struct auto_pin_cfg *cfg = &spec->autocfg;
	int i, err;
2150 2151 2152 2153 2154 2155 2156

	err = via_fill_adcs(codec);
	if (err < 0)
		return err;
	err = get_mux_nids(codec);
	if (err < 0)
		return err;
2157

2158 2159 2160 2161 2162
	/* fill all input-routes */
	for (i = 0; i < cfg->num_inputs; i++) {
		if (add_input_route(codec, cfg->inputs[i].pin))
			spec->inputs[spec->num_inputs++].label =
				hda_get_autocfg_input_label(codec, cfg, i);
2163
	}
2164

2165 2166 2167 2168 2169 2170 2171 2172 2173 2174 2175 2176 2177 2178 2179 2180 2181 2182 2183 2184
	/* check for internal loopback recording */
	if (spec->aa_mix_nid &&
	    add_input_route(codec, spec->aa_mix_nid))
		spec->inputs[spec->num_inputs++].label = "Stereo Mixer";

	return 0;
}

/* create analog-loopback volume/switch controls */
static int create_loopback_ctls(struct hda_codec *codec)
{
	struct via_spec *spec = codec->spec;
	const struct auto_pin_cfg *cfg = &spec->autocfg;
	const char *prev_label = NULL;
	int type_idx = 0;
	int i, j, err, idx;

	if (!spec->aa_mix_nid)
		return 0;

2185
	for (i = 0; i < cfg->num_inputs; i++) {
2186 2187 2188
		hda_nid_t pin = cfg->inputs[i].pin;
		const char *label = hda_get_autocfg_input_label(codec, cfg, i);

2189
		if (prev_label && !strcmp(label, prev_label))
2190 2191 2192
			type_idx++;
		else
			type_idx = 0;
2193
		prev_label = label;
2194 2195
		idx = get_connection_index(codec, spec->aa_mix_nid, pin);
		if (idx >= 0) {
2196
			err = via_new_analog_input(spec, label, type_idx,
2197
						   idx, spec->aa_mix_nid);
2198 2199
			if (err < 0)
				return err;
2200
			add_loopback_list(spec, spec->aa_mix_nid, idx);
2201
		}
2202 2203 2204

		/* remember the label for smart51 control */
		for (j = 0; j < spec->smart51_nums; j++) {
2205
			if (spec->smart51_pins[j] == pin) {
2206 2207 2208 2209 2210
				spec->smart51_idxs[j] = idx;
				spec->smart51_labels[j] = label;
				break;
			}
		}
2211
	}
2212 2213 2214 2215 2216 2217 2218 2219 2220 2221 2222 2223 2224 2225 2226 2227 2228 2229 2230 2231 2232 2233 2234 2235 2236 2237 2238 2239 2240 2241 2242 2243 2244 2245 2246 2247
	return 0;
}

/* create mic-boost controls (if present) */
static int create_mic_boost_ctls(struct hda_codec *codec)
{
	struct via_spec *spec = codec->spec;
	const struct auto_pin_cfg *cfg = &spec->autocfg;
	int i, err;

	for (i = 0; i < cfg->num_inputs; i++) {
		hda_nid_t pin = cfg->inputs[i].pin;
		unsigned int caps;
		const char *label;
		char name[32];

		if (cfg->inputs[i].type != AUTO_PIN_MIC)
			continue;
		caps = query_amp_caps(codec, pin, HDA_INPUT);
		if (caps == -1 || !(caps & AC_AMPCAP_NUM_STEPS))
			continue;
		label = hda_get_autocfg_input_label(codec, cfg, i);
		snprintf(name, sizeof(name), "%s Boost Volume", label);
		err = via_add_control(spec, VIA_CTL_WIDGET_VOL, name,
			      HDA_COMPOSE_AMP_VAL(pin, 3, 0, HDA_INPUT));
		if (err < 0)
			return err;
	}
	return 0;
}

/* create capture and input-src controls for multiple streams */
static int create_multi_adc_ctls(struct hda_codec *codec)
{
	struct via_spec *spec = codec->spec;
	int i, err;
2248 2249 2250 2251 2252 2253 2254 2255 2256 2257 2258 2259 2260 2261 2262 2263 2264 2265 2266 2267 2268 2269

	/* create capture mixer elements */
	for (i = 0; i < spec->num_adc_nids; i++) {
		hda_nid_t adc = spec->adc_nids[i];
		err = __via_add_control(spec, VIA_CTL_WIDGET_VOL,
					"Capture Volume", i,
					HDA_COMPOSE_AMP_VAL(adc, 3, 0,
							    HDA_INPUT));
		if (err < 0)
			return err;
		err = __via_add_control(spec, VIA_CTL_WIDGET_MUTE,
					"Capture Switch", i,
					HDA_COMPOSE_AMP_VAL(adc, 3, 0,
							    HDA_INPUT));
		if (err < 0)
			return err;
	}

	/* input-source control */
	for (i = 0; i < spec->num_adc_nids; i++)
		if (!spec->mux_nids[i])
			break;
2270 2271 2272 2273 2274
	err = create_input_src_ctls(codec, i);
	if (err < 0)
		return err;
	return 0;
}
2275

2276 2277 2278 2279 2280
/* bind capture volume/switch */
static struct snd_kcontrol_new via_bind_cap_vol_ctl =
	HDA_BIND_VOL("Capture Volume", 0);
static struct snd_kcontrol_new via_bind_cap_sw_ctl =
	HDA_BIND_SW("Capture Switch", 0);
2281

2282 2283 2284 2285 2286
static int init_bind_ctl(struct via_spec *spec, struct hda_bind_ctls **ctl_ret,
			 struct hda_ctl_ops *ops)
{
	struct hda_bind_ctls *ctl;
	int i;
2287

2288 2289 2290 2291 2292 2293 2294 2295 2296 2297 2298 2299 2300 2301 2302 2303 2304 2305 2306 2307 2308 2309 2310 2311 2312 2313 2314 2315 2316 2317 2318 2319 2320 2321 2322 2323 2324 2325 2326 2327 2328 2329 2330 2331 2332 2333 2334 2335 2336 2337 2338 2339 2340 2341 2342 2343 2344 2345 2346 2347 2348 2349 2350 2351 2352
	ctl = kzalloc(sizeof(*ctl) + sizeof(long) * 4, GFP_KERNEL);
	if (!ctl)
		return -ENOMEM;
	ctl->ops = ops;
	for (i = 0; i < spec->num_adc_nids; i++)
		ctl->values[i] =
			HDA_COMPOSE_AMP_VAL(spec->adc_nids[i], 3, 0, HDA_INPUT);
	*ctl_ret = ctl;
	return 0;
}

/* create capture and input-src controls for dynamic ADC-switch case */
static int create_dyn_adc_ctls(struct hda_codec *codec)
{
	struct via_spec *spec = codec->spec;
	struct snd_kcontrol_new *knew;
	int err;

	/* set up the bind capture ctls */
	err = init_bind_ctl(spec, &spec->bind_cap_vol, &snd_hda_bind_vol);
	if (err < 0)
		return err;
	err = init_bind_ctl(spec, &spec->bind_cap_sw, &snd_hda_bind_sw);
	if (err < 0)
		return err;

	/* create capture mixer elements */
	knew = via_clone_control(spec, &via_bind_cap_vol_ctl);
	if (!knew)
		return -ENOMEM;
	knew->private_value = (long)spec->bind_cap_vol;

	knew = via_clone_control(spec, &via_bind_cap_sw_ctl);
	if (!knew)
		return -ENOMEM;
	knew->private_value = (long)spec->bind_cap_sw;

	/* input-source control */
	err = create_input_src_ctls(codec, 1);
	if (err < 0)
		return err;
	return 0;
}

/* parse and create capture-related stuff */
static int via_auto_create_analog_input_ctls(struct hda_codec *codec)
{
	struct via_spec *spec = codec->spec;
	int err;

	err = parse_analog_inputs(codec);
	if (err < 0)
		return err;
	if (spec->dyn_adc_switch)
		err = create_dyn_adc_ctls(codec);
	else
		err = create_multi_adc_ctls(codec);
	if (err < 0)
		return err;
	err = create_loopback_ctls(codec);
	if (err < 0)
		return err;
	err = create_mic_boost_ctls(codec);
	if (err < 0)
		return err;
2353 2354 2355
	return 0;
}

2356 2357 2358 2359 2360
static void vt1708_set_pinconfig_connect(struct hda_codec *codec, hda_nid_t nid)
{
	unsigned int def_conf;
	unsigned char seqassoc;

2361
	def_conf = snd_hda_codec_get_pincfg(codec, nid);
2362 2363
	seqassoc = (unsigned char) get_defcfg_association(def_conf);
	seqassoc = (seqassoc << 4) | get_defcfg_sequence(def_conf);
2364 2365 2366 2367
	if (get_defcfg_connect(def_conf) == AC_JACK_PORT_NONE
	    && (seqassoc == 0xf0 || seqassoc == 0xff)) {
		def_conf = def_conf & (~(AC_JACK_PORT_BOTH << 30));
		snd_hda_codec_set_pincfg(codec, nid, def_conf);
2368 2369 2370 2371 2372
	}

	return;
}

2373
static int vt1708_jack_detect_get(struct snd_kcontrol *kcontrol,
2374 2375 2376 2377 2378 2379 2380
				     struct snd_ctl_elem_value *ucontrol)
{
	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
	struct via_spec *spec = codec->spec;

	if (spec->codec_type != VT1708)
		return 0;
2381
	spec->vt1708_jack_detect =
2382
		!((snd_hda_codec_read(codec, 0x1, 0, 0xf84, 0) >> 8) & 0x1);
2383
	ucontrol->value.integer.value[0] = spec->vt1708_jack_detect;
2384 2385 2386
	return 0;
}

2387
static int vt1708_jack_detect_put(struct snd_kcontrol *kcontrol,
2388 2389 2390 2391 2392 2393 2394 2395
				     struct snd_ctl_elem_value *ucontrol)
{
	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
	struct via_spec *spec = codec->spec;
	int change;

	if (spec->codec_type != VT1708)
		return 0;
2396
	spec->vt1708_jack_detect = ucontrol->value.integer.value[0];
2397
	change = (0x1 & (snd_hda_codec_read(codec, 0x1, 0, 0xf84, 0) >> 8))
2398 2399
		== !spec->vt1708_jack_detect;
	if (spec->vt1708_jack_detect) {
2400 2401 2402 2403 2404 2405
		mute_aa_path(codec, 1);
		notify_aa_path_ctls(codec);
	}
	return change;
}

2406 2407 2408 2409 2410 2411 2412
static const struct snd_kcontrol_new vt1708_jack_detect_ctl = {
	.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
	.name = "Jack Detect",
	.count = 1,
	.info = snd_ctl_boolean_mono_info,
	.get = vt1708_jack_detect_get,
	.put = vt1708_jack_detect_put,
2413 2414
};

2415 2416 2417 2418
static void fill_dig_outs(struct hda_codec *codec);
static void fill_dig_in(struct hda_codec *codec);

static int via_parse_auto_config(struct hda_codec *codec)
2419 2420 2421 2422 2423 2424 2425 2426
{
	struct via_spec *spec = codec->spec;
	int err;

	err = snd_hda_parse_pin_def_config(codec, &spec->autocfg, NULL);
	if (err < 0)
		return err;
	if (!spec->autocfg.line_outs && !spec->autocfg.hp_pins[0])
2427
		return -EINVAL;
2428

2429
	err = via_auto_create_multi_out_ctls(codec);
2430 2431
	if (err < 0)
		return err;
2432
	err = via_auto_create_hp_ctls(codec, spec->autocfg.hp_pins[0]);
2433 2434 2435
	if (err < 0)
		return err;
	err = via_auto_create_speaker_ctls(codec);
2436 2437
	if (err < 0)
		return err;
2438
	err = via_auto_create_analog_input_ctls(codec);
2439 2440
	if (err < 0)
		return err;
2441 2442 2443

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

2444 2445
	fill_dig_outs(codec);
	fill_dig_in(codec);
2446

2447 2448
	if (spec->kctls.list)
		spec->mixers[spec->num_mixers++] = spec->kctls.list;
2449 2450


2451
	if (spec->hp_dac_nid && spec->hp_dep_path.depth) {
2452 2453 2454 2455
		err = via_hp_build(codec);
		if (err < 0)
			return err;
	}
2456

2457 2458 2459 2460
	err = via_smart51_build(codec);
	if (err < 0)
		return err;

2461 2462 2463 2464
	/* assign slave outs */
	if (spec->slave_dig_outs[0])
		codec->slave_dig_outs = spec->slave_dig_outs;

2465 2466 2467
	return 1;
}

2468 2469 2470 2471 2472 2473 2474 2475 2476 2477
static void via_auto_init_dig_outs(struct hda_codec *codec)
{
	struct via_spec *spec = codec->spec;
	if (spec->multiout.dig_out_nid)
		init_output_pin(codec, spec->autocfg.dig_out_pins[0], PIN_OUT);
	if (spec->slave_dig_outs[0])
		init_output_pin(codec, spec->autocfg.dig_out_pins[1], PIN_OUT);
}

static void via_auto_init_dig_in(struct hda_codec *codec)
2478
{
L
Lydia Wang 已提交
2479
	struct via_spec *spec = codec->spec;
2480 2481 2482 2483 2484 2485
	if (!spec->dig_in_nid)
		return;
	snd_hda_codec_write(codec, spec->autocfg.dig_in_pin, 0,
			    AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN);
}

2486 2487 2488 2489 2490 2491 2492 2493 2494 2495 2496 2497 2498 2499 2500 2501 2502 2503 2504 2505
/* initialize the unsolicited events */
static void via_auto_init_unsol_event(struct hda_codec *codec)
{
	struct via_spec *spec = codec->spec;
	struct auto_pin_cfg *cfg = &spec->autocfg;
	unsigned int ev;
	int i;

	if (cfg->hp_pins[0] && is_jack_detectable(codec, cfg->hp_pins[0]))
		snd_hda_codec_write(codec, cfg->hp_pins[0], 0,
				AC_VERB_SET_UNSOLICITED_ENABLE,
				AC_USRSP_EN | VIA_HP_EVENT | VIA_JACK_EVENT);

	if (cfg->speaker_pins[0])
		ev = VIA_LINE_EVENT;
	else
		ev = 0;
	for (i = 0; i < cfg->line_outs; i++) {
		if (cfg->line_out_pins[i] &&
		    is_jack_detectable(codec, cfg->line_out_pins[i]))
2506
			snd_hda_codec_write(codec, cfg->line_out_pins[i], 0,
2507 2508 2509 2510 2511 2512 2513 2514 2515 2516 2517 2518
				AC_VERB_SET_UNSOLICITED_ENABLE,
				AC_USRSP_EN | ev | VIA_JACK_EVENT);
	}

	for (i = 0; i < cfg->num_inputs; i++) {
		if (is_jack_detectable(codec, cfg->inputs[i].pin))
			snd_hda_codec_write(codec, cfg->inputs[i].pin, 0,
				AC_VERB_SET_UNSOLICITED_ENABLE,
				AC_USRSP_EN | VIA_JACK_EVENT);
	}
}

2519 2520 2521 2522 2523 2524 2525
static int via_init(struct hda_codec *codec)
{
	struct via_spec *spec = codec->spec;
	int i;

	for (i = 0; i < spec->num_iverbs; i++)
		snd_hda_sequence_write(codec, spec->init_verbs[i]);
L
Lydia Wang 已提交
2526

2527 2528
	via_auto_init_multi_out(codec);
	via_auto_init_hp_out(codec);
2529
	via_auto_init_speaker_out(codec);
2530
	via_auto_init_analog_input(codec);
2531 2532
	via_auto_init_dig_outs(codec);
	via_auto_init_dig_in(codec);
2533

2534 2535 2536
	via_auto_init_unsol_event(codec);

	via_hp_automute(codec);
L
Lydia Wang 已提交
2537

2538 2539 2540
	return 0;
}

2541 2542 2543 2544 2545 2546 2547 2548
static void vt1708_update_hp_jack_state(struct work_struct *work)
{
	struct via_spec *spec = container_of(work, struct via_spec,
					     vt1708_hp_work.work);
	if (spec->codec_type != VT1708)
		return;
	/* if jack state toggled */
	if (spec->vt1708_hp_present
2549
	    != snd_hda_jack_detect(spec->codec, spec->autocfg.hp_pins[0])) {
2550 2551 2552 2553 2554 2555
		spec->vt1708_hp_present ^= 1;
		via_hp_automute(spec->codec);
	}
	vt1708_start_hp_work(spec);
}

2556 2557 2558 2559 2560 2561 2562 2563 2564 2565
static int get_mux_nids(struct hda_codec *codec)
{
	struct via_spec *spec = codec->spec;
	hda_nid_t nid, conn[8];
	unsigned int type;
	int i, n;

	for (i = 0; i < spec->num_adc_nids; i++) {
		nid = spec->adc_nids[i];
		while (nid) {
2566
			type = get_wcaps_type(get_wcaps(codec, nid));
2567 2568
			if (type == AC_WID_PIN)
				break;
2569 2570 2571 2572 2573 2574 2575 2576 2577 2578 2579
			n = snd_hda_get_connections(codec, nid, conn,
						    ARRAY_SIZE(conn));
			if (n <= 0)
				break;
			if (n > 1) {
				spec->mux_nids[i] = nid;
				break;
			}
			nid = conn[0];
		}
	}
2580
	return 0;
2581 2582
}

2583 2584 2585 2586 2587 2588
static int patch_vt1708(struct hda_codec *codec)
{
	struct via_spec *spec;
	int err;

	/* create a codec specific record */
2589
	spec = via_new_spec(codec);
2590 2591 2592
	if (spec == NULL)
		return -ENOMEM;

2593 2594
	spec->aa_mix_nid = 0x17;

2595 2596 2597 2598
	/* Add HP and CD pin config connect bit re-config action */
	vt1708_set_pinconfig_connect(codec, VT1708_HP_PIN_NID);
	vt1708_set_pinconfig_connect(codec, VT1708_CD_PIN_NID);

2599
	/* automatic parse from the BIOS config */
2600
	err = via_parse_auto_config(codec);
2601 2602 2603 2604 2605
	if (err < 0) {
		via_free(codec);
		return err;
	}

2606 2607 2608 2609
	/* add jack detect on/off control */
	if (!via_clone_control(spec, &vt1708_jack_detect_ctl))
		return -ENOMEM;

2610 2611 2612
	/* disable 32bit format on VT1708 */
	if (codec->vendor_id == 0x11061708)
		spec->stream_analog_playback = &vt1708_pcm_analog_s16_playback;
2613

2614 2615
	spec->init_verbs[spec->num_iverbs++] = vt1708_init_verbs;

2616 2617
	codec->patch_ops = via_patch_ops;

2618
	INIT_DELAYED_WORK(&spec->vt1708_hp_work, vt1708_update_hp_jack_state);
2619 2620 2621
	return 0;
}

2622
static int patch_vt1709(struct hda_codec *codec)
2623 2624 2625 2626 2627
{
	struct via_spec *spec;
	int err;

	/* create a codec specific record */
2628
	spec = via_new_spec(codec);
2629 2630 2631
	if (spec == NULL)
		return -ENOMEM;

2632 2633
	spec->aa_mix_nid = 0x18;

2634
	err = via_parse_auto_config(codec);
2635 2636 2637 2638 2639 2640 2641
	if (err < 0) {
		via_free(codec);
		return err;
	}

	codec->patch_ops = via_patch_ops;

2642 2643 2644
	return 0;
}

2645 2646 2647 2648 2649 2650
static void set_widgets_power_state_vt1708B(struct hda_codec *codec)
{
	struct via_spec *spec = codec->spec;
	int imux_is_smixer;
	unsigned int parm;
	int is_8ch = 0;
2651 2652
	if ((spec->codec_type != VT1708B_4CH) &&
	    (codec->vendor_id != 0x11064397))
2653 2654 2655 2656 2657 2658 2659 2660 2661 2662 2663 2664 2665 2666 2667 2668 2669 2670 2671 2672 2673 2674 2675 2676 2677 2678 2679 2680 2681 2682 2683 2684 2685 2686 2687 2688 2689 2690
		is_8ch = 1;

	/* SW0 (17h) = stereo mixer */
	imux_is_smixer =
	(snd_hda_codec_read(codec, 0x17, 0, AC_VERB_GET_CONNECT_SEL, 0x00)
	 == ((spec->codec_type == VT1708S) ? 5 : 0));
	/* inputs */
	/* PW 1/2/5 (1ah/1bh/1eh) */
	parm = AC_PWRST_D3;
	set_pin_power_state(codec, 0x1a, &parm);
	set_pin_power_state(codec, 0x1b, &parm);
	set_pin_power_state(codec, 0x1e, &parm);
	if (imux_is_smixer)
		parm = AC_PWRST_D0;
	/* SW0 (17h), AIW 0/1 (13h/14h) */
	snd_hda_codec_write(codec, 0x17, 0, AC_VERB_SET_POWER_STATE, parm);
	snd_hda_codec_write(codec, 0x13, 0, AC_VERB_SET_POWER_STATE, parm);
	snd_hda_codec_write(codec, 0x14, 0, AC_VERB_SET_POWER_STATE, parm);

	/* outputs */
	/* PW0 (19h), SW1 (18h), AOW1 (11h) */
	parm = AC_PWRST_D3;
	set_pin_power_state(codec, 0x19, &parm);
	if (spec->smart51_enabled)
		set_pin_power_state(codec, 0x1b, &parm);
	snd_hda_codec_write(codec, 0x18, 0, AC_VERB_SET_POWER_STATE, parm);
	snd_hda_codec_write(codec, 0x11, 0, AC_VERB_SET_POWER_STATE, parm);

	/* PW6 (22h), SW2 (26h), AOW2 (24h) */
	if (is_8ch) {
		parm = AC_PWRST_D3;
		set_pin_power_state(codec, 0x22, &parm);
		if (spec->smart51_enabled)
			set_pin_power_state(codec, 0x1a, &parm);
		snd_hda_codec_write(codec, 0x26, 0,
				    AC_VERB_SET_POWER_STATE, parm);
		snd_hda_codec_write(codec, 0x24, 0,
				    AC_VERB_SET_POWER_STATE, parm);
2691 2692 2693 2694 2695 2696 2697 2698 2699 2700
	} else if (codec->vendor_id == 0x11064397) {
		/* PW7(23h), SW2(27h), AOW2(25h) */
		parm = AC_PWRST_D3;
		set_pin_power_state(codec, 0x23, &parm);
		if (spec->smart51_enabled)
			set_pin_power_state(codec, 0x1a, &parm);
		snd_hda_codec_write(codec, 0x27, 0,
				    AC_VERB_SET_POWER_STATE, parm);
		snd_hda_codec_write(codec, 0x25, 0,
				    AC_VERB_SET_POWER_STATE, parm);
2701 2702 2703 2704 2705 2706 2707 2708 2709 2710 2711 2712 2713 2714 2715 2716 2717 2718 2719
	}

	/* PW 3/4/7 (1ch/1dh/23h) */
	parm = AC_PWRST_D3;
	/* force to D0 for internal Speaker */
	set_pin_power_state(codec, 0x1c, &parm);
	set_pin_power_state(codec, 0x1d, &parm);
	if (is_8ch)
		set_pin_power_state(codec, 0x23, &parm);

	/* MW0 (16h), Sw3 (27h), AOW 0/3 (10h/25h) */
	snd_hda_codec_write(codec, 0x16, 0, AC_VERB_SET_POWER_STATE,
			    imux_is_smixer ? AC_PWRST_D0 : parm);
	snd_hda_codec_write(codec, 0x10, 0, AC_VERB_SET_POWER_STATE, parm);
	if (is_8ch) {
		snd_hda_codec_write(codec, 0x25, 0,
				    AC_VERB_SET_POWER_STATE, parm);
		snd_hda_codec_write(codec, 0x27, 0,
				    AC_VERB_SET_POWER_STATE, parm);
2720 2721 2722
	} else if (codec->vendor_id == 0x11064397 && spec->hp_independent_mode)
		snd_hda_codec_write(codec, 0x25, 0,
				    AC_VERB_SET_POWER_STATE, parm);
2723 2724
}

2725
static int patch_vt1708S(struct hda_codec *codec);
2726
static int patch_vt1708B(struct hda_codec *codec)
2727 2728 2729 2730
{
	struct via_spec *spec;
	int err;

2731 2732
	if (get_codec_type(codec) == VT1708BCE)
		return patch_vt1708S(codec);
2733

2734
	/* create a codec specific record */
2735
	spec = via_new_spec(codec);
2736 2737 2738
	if (spec == NULL)
		return -ENOMEM;

2739 2740
	spec->aa_mix_nid = 0x16;

2741
	/* automatic parse from the BIOS config */
2742
	err = via_parse_auto_config(codec);
2743 2744 2745 2746 2747 2748 2749
	if (err < 0) {
		via_free(codec);
		return err;
	}

	codec->patch_ops = via_patch_ops;

2750 2751
	spec->set_widgets_power_state =  set_widgets_power_state_vt1708B;

2752 2753 2754
	return 0;
}

2755
/* Patch for VT1708S */
2756
static const struct hda_verb vt1708S_init_verbs[] = {
2757 2758
	/* Enable Mic Boost Volume backdoor */
	{0x1, 0xf98, 0x1},
2759 2760
	/* don't bybass mixer */
	{0x1, 0xf88, 0xc0},
2761 2762 2763
	{ }
};

2764 2765
/* fill out digital output widgets; one for master and one for slave outputs */
static void fill_dig_outs(struct hda_codec *codec)
2766
{
2767
	struct via_spec *spec = codec->spec;
2768 2769
	int i;

2770 2771 2772
	for (i = 0; i < spec->autocfg.dig_outs; i++) {
		hda_nid_t nid;
		int conn;
2773 2774 2775 2776 2777 2778 2779 2780 2781 2782 2783 2784 2785 2786 2787 2788

		nid = spec->autocfg.dig_out_pins[i];
		if (!nid)
			continue;
		conn = snd_hda_get_connections(codec, nid, &nid, 1);
		if (conn < 1)
			continue;
		if (!spec->multiout.dig_out_nid)
			spec->multiout.dig_out_nid = nid;
		else {
			spec->slave_dig_outs[0] = nid;
			break; /* at most two dig outs */
		}
	}
}

2789
static void fill_dig_in(struct hda_codec *codec)
2790 2791
{
	struct via_spec *spec = codec->spec;
2792 2793
	hda_nid_t dig_nid;
	int i, err;
2794

2795 2796
	if (!spec->autocfg.dig_in_pin)
		return;
2797

2798 2799 2800 2801 2802 2803 2804 2805 2806 2807 2808 2809 2810 2811 2812 2813
	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;
		}
	}
2814 2815
}

2816 2817 2818 2819 2820 2821 2822 2823 2824 2825
static void override_mic_boost(struct hda_codec *codec, hda_nid_t pin,
			       int offset, int num_steps, int step_size)
{
	snd_hda_override_amp_caps(codec, pin, HDA_INPUT,
				  (offset << AC_AMPCAP_OFFSET_SHIFT) |
				  (num_steps << AC_AMPCAP_NUM_STEPS_SHIFT) |
				  (step_size << AC_AMPCAP_STEP_SIZE_SHIFT) |
				  (0 << AC_AMPCAP_MUTE_SHIFT));
}

2826 2827 2828 2829 2830 2831
static int patch_vt1708S(struct hda_codec *codec)
{
	struct via_spec *spec;
	int err;

	/* create a codec specific record */
2832
	spec = via_new_spec(codec);
2833 2834 2835
	if (spec == NULL)
		return -ENOMEM;

2836
	spec->aa_mix_nid = 0x16;
2837 2838
	override_mic_boost(codec, 0x1a, 0, 3, 40);
	override_mic_boost(codec, 0x1e, 0, 3, 40);
2839

2840
	/* automatic parse from the BIOS config */
2841
	err = via_parse_auto_config(codec);
2842 2843 2844 2845 2846
	if (err < 0) {
		via_free(codec);
		return err;
	}

2847
	spec->init_verbs[spec->num_iverbs++] = vt1708S_init_verbs;
2848 2849 2850

	codec->patch_ops = via_patch_ops;

2851 2852 2853 2854 2855 2856 2857
	/* correct names for VT1708BCE */
	if (get_codec_type(codec) == VT1708BCE)	{
		kfree(codec->chip_name);
		codec->chip_name = kstrdup("VT1708BCE", GFP_KERNEL);
		snprintf(codec->bus->card->mixername,
			 sizeof(codec->bus->card->mixername),
			 "%s %s", codec->vendor_name, codec->chip_name);
2858
	}
2859 2860 2861 2862 2863 2864 2865 2866
	/* correct names for VT1705 */
	if (codec->vendor_id == 0x11064397)	{
		kfree(codec->chip_name);
		codec->chip_name = kstrdup("VT1705", GFP_KERNEL);
		snprintf(codec->bus->card->mixername,
			 sizeof(codec->bus->card->mixername),
			 "%s %s", codec->vendor_name, codec->chip_name);
	}
2867
	spec->set_widgets_power_state =  set_widgets_power_state_vt1708B;
2868 2869 2870 2871 2872
	return 0;
}

/* Patch for VT1702 */

2873
static const struct hda_verb vt1702_init_verbs[] = {
2874 2875 2876 2877
	/* mixer enable */
	{0x1, 0xF88, 0x3},
	/* GPIO 0~2 */
	{0x1, 0xF82, 0x3F},
2878 2879 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
static void set_widgets_power_state_vt1702(struct hda_codec *codec)
{
	int imux_is_smixer =
	snd_hda_codec_read(codec, 0x13, 0, AC_VERB_GET_CONNECT_SEL, 0x00) == 3;
	unsigned int parm;
	/* inputs */
	/* PW 1/2/5 (14h/15h/18h) */
	parm = AC_PWRST_D3;
	set_pin_power_state(codec, 0x14, &parm);
	set_pin_power_state(codec, 0x15, &parm);
	set_pin_power_state(codec, 0x18, &parm);
	if (imux_is_smixer)
		parm = AC_PWRST_D0; /* SW0 (13h) = stereo mixer (idx 3) */
	/* SW0 (13h), AIW 0/1/2 (12h/1fh/20h) */
	snd_hda_codec_write(codec, 0x13, 0, AC_VERB_SET_POWER_STATE, parm);
	snd_hda_codec_write(codec, 0x12, 0, AC_VERB_SET_POWER_STATE, parm);
	snd_hda_codec_write(codec, 0x1f, 0, AC_VERB_SET_POWER_STATE, parm);
	snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_POWER_STATE, parm);

	/* outputs */
	/* PW 3/4 (16h/17h) */
	parm = AC_PWRST_D3;
	set_pin_power_state(codec, 0x17, &parm);
	set_pin_power_state(codec, 0x16, &parm);
	/* MW0 (1ah), AOW 0/1 (10h/1dh) */
	snd_hda_codec_write(codec, 0x1a, 0, AC_VERB_SET_POWER_STATE,
			    imux_is_smixer ? AC_PWRST_D0 : parm);
	snd_hda_codec_write(codec, 0x10, 0, AC_VERB_SET_POWER_STATE, parm);
	snd_hda_codec_write(codec, 0x1d, 0, AC_VERB_SET_POWER_STATE, parm);
}

2912 2913 2914 2915 2916 2917
static int patch_vt1702(struct hda_codec *codec)
{
	struct via_spec *spec;
	int err;

	/* create a codec specific record */
2918
	spec = via_new_spec(codec);
2919 2920 2921
	if (spec == NULL)
		return -ENOMEM;

2922 2923
	spec->aa_mix_nid = 0x1a;

2924 2925 2926 2927 2928 2929 2930
	/* limit AA path volume to 0 dB */
	snd_hda_override_amp_caps(codec, 0x1A, HDA_INPUT,
				  (0x17 << AC_AMPCAP_OFFSET_SHIFT) |
				  (0x17 << AC_AMPCAP_NUM_STEPS_SHIFT) |
				  (0x5 << AC_AMPCAP_STEP_SIZE_SHIFT) |
				  (1 << AC_AMPCAP_MUTE_SHIFT));

2931
	/* automatic parse from the BIOS config */
2932
	err = via_parse_auto_config(codec);
2933 2934 2935 2936 2937
	if (err < 0) {
		via_free(codec);
		return err;
	}

2938
	spec->init_verbs[spec->num_iverbs++] = vt1702_init_verbs;
2939 2940 2941

	codec->patch_ops = via_patch_ops;

2942
	spec->set_widgets_power_state =  set_widgets_power_state_vt1702;
2943 2944 2945
	return 0;
}

L
Lydia Wang 已提交
2946 2947
/* Patch for VT1718S */

2948
static const struct hda_verb vt1718S_init_verbs[] = {
2949 2950
	/* Enable MW0 adjust Gain 5 */
	{0x1, 0xfb2, 0x10},
L
Lydia Wang 已提交
2951 2952
	/* Enable Boost Volume backdoor */
	{0x1, 0xf88, 0x8},
2953

L
Lydia Wang 已提交
2954 2955 2956
	{ }
};

2957 2958 2959 2960 2961 2962 2963 2964 2965 2966 2967 2968 2969 2970 2971 2972 2973 2974 2975 2976 2977 2978 2979 2980 2981 2982 2983 2984 2985 2986 2987 2988 2989 2990 2991 2992 2993 2994 2995 2996 2997 2998 2999 3000 3001 3002 3003 3004 3005 3006 3007 3008 3009 3010 3011 3012 3013 3014 3015 3016 3017 3018 3019 3020 3021 3022
static void set_widgets_power_state_vt1718S(struct hda_codec *codec)
{
	struct via_spec *spec = codec->spec;
	int imux_is_smixer;
	unsigned int parm;
	/* MUX6 (1eh) = stereo mixer */
	imux_is_smixer =
	snd_hda_codec_read(codec, 0x1e, 0, AC_VERB_GET_CONNECT_SEL, 0x00) == 5;
	/* inputs */
	/* PW 5/6/7 (29h/2ah/2bh) */
	parm = AC_PWRST_D3;
	set_pin_power_state(codec, 0x29, &parm);
	set_pin_power_state(codec, 0x2a, &parm);
	set_pin_power_state(codec, 0x2b, &parm);
	if (imux_is_smixer)
		parm = AC_PWRST_D0;
	/* MUX6/7 (1eh/1fh), AIW 0/1 (10h/11h) */
	snd_hda_codec_write(codec, 0x1e, 0, AC_VERB_SET_POWER_STATE, parm);
	snd_hda_codec_write(codec, 0x1f, 0, AC_VERB_SET_POWER_STATE, parm);
	snd_hda_codec_write(codec, 0x10, 0, AC_VERB_SET_POWER_STATE, parm);
	snd_hda_codec_write(codec, 0x11, 0, AC_VERB_SET_POWER_STATE, parm);

	/* outputs */
	/* PW3 (27h), MW2 (1ah), AOW3 (bh) */
	parm = AC_PWRST_D3;
	set_pin_power_state(codec, 0x27, &parm);
	snd_hda_codec_write(codec, 0x1a, 0, AC_VERB_SET_POWER_STATE, parm);
	snd_hda_codec_write(codec, 0xb, 0, AC_VERB_SET_POWER_STATE, parm);

	/* PW2 (26h), AOW2 (ah) */
	parm = AC_PWRST_D3;
	set_pin_power_state(codec, 0x26, &parm);
	if (spec->smart51_enabled)
		set_pin_power_state(codec, 0x2b, &parm);
	snd_hda_codec_write(codec, 0xa, 0, AC_VERB_SET_POWER_STATE, parm);

	/* PW0 (24h), AOW0 (8h) */
	parm = AC_PWRST_D3;
	set_pin_power_state(codec, 0x24, &parm);
	if (!spec->hp_independent_mode) /* check for redirected HP */
		set_pin_power_state(codec, 0x28, &parm);
	snd_hda_codec_write(codec, 0x8, 0, AC_VERB_SET_POWER_STATE, parm);
	/* MW9 (21h), Mw2 (1ah), AOW0 (8h) */
	snd_hda_codec_write(codec, 0x21, 0, AC_VERB_SET_POWER_STATE,
			    imux_is_smixer ? AC_PWRST_D0 : parm);

	/* PW1 (25h), AOW1 (9h) */
	parm = AC_PWRST_D3;
	set_pin_power_state(codec, 0x25, &parm);
	if (spec->smart51_enabled)
		set_pin_power_state(codec, 0x2a, &parm);
	snd_hda_codec_write(codec, 0x9, 0, AC_VERB_SET_POWER_STATE, parm);

	if (spec->hp_independent_mode) {
		/* PW4 (28h), MW3 (1bh), MUX1(34h), AOW4 (ch) */
		parm = AC_PWRST_D3;
		set_pin_power_state(codec, 0x28, &parm);
		snd_hda_codec_write(codec, 0x1b, 0,
				    AC_VERB_SET_POWER_STATE, parm);
		snd_hda_codec_write(codec, 0x34, 0,
				    AC_VERB_SET_POWER_STATE, parm);
		snd_hda_codec_write(codec, 0xc, 0,
				    AC_VERB_SET_POWER_STATE, parm);
	}
}

L
Lydia Wang 已提交
3023 3024 3025 3026 3027 3028
static int patch_vt1718S(struct hda_codec *codec)
{
	struct via_spec *spec;
	int err;

	/* create a codec specific record */
3029
	spec = via_new_spec(codec);
L
Lydia Wang 已提交
3030 3031 3032
	if (spec == NULL)
		return -ENOMEM;

3033
	spec->aa_mix_nid = 0x21;
3034 3035
	override_mic_boost(codec, 0x2b, 0, 3, 40);
	override_mic_boost(codec, 0x29, 0, 3, 40);
3036
	spec->dac_mixer_idx = 5;
3037

L
Lydia Wang 已提交
3038
	/* automatic parse from the BIOS config */
3039
	err = via_parse_auto_config(codec);
L
Lydia Wang 已提交
3040 3041 3042 3043 3044
	if (err < 0) {
		via_free(codec);
		return err;
	}

3045
	spec->init_verbs[spec->num_iverbs++] = vt1718S_init_verbs;
L
Lydia Wang 已提交
3046 3047 3048

	codec->patch_ops = via_patch_ops;

3049 3050
	spec->set_widgets_power_state =  set_widgets_power_state_vt1718S;

L
Lydia Wang 已提交
3051 3052
	return 0;
}
L
Lydia Wang 已提交
3053 3054 3055 3056 3057 3058 3059 3060 3061 3062 3063 3064 3065 3066 3067 3068 3069 3070 3071 3072 3073 3074 3075 3076 3077 3078 3079 3080 3081 3082 3083 3084 3085 3086 3087 3088 3089

/* Patch for VT1716S */

static int vt1716s_dmic_info(struct snd_kcontrol *kcontrol,
			    struct snd_ctl_elem_info *uinfo)
{
	uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN;
	uinfo->count = 1;
	uinfo->value.integer.min = 0;
	uinfo->value.integer.max = 1;
	return 0;
}

static int vt1716s_dmic_get(struct snd_kcontrol *kcontrol,
			   struct snd_ctl_elem_value *ucontrol)
{
	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
	int index = 0;

	index = snd_hda_codec_read(codec, 0x26, 0,
					       AC_VERB_GET_CONNECT_SEL, 0);
	if (index != -1)
		*ucontrol->value.integer.value = index;

	return 0;
}

static int vt1716s_dmic_put(struct snd_kcontrol *kcontrol,
			   struct snd_ctl_elem_value *ucontrol)
{
	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
	struct via_spec *spec = codec->spec;
	int index = *ucontrol->value.integer.value;

	snd_hda_codec_write(codec, 0x26, 0,
					       AC_VERB_SET_CONNECT_SEL, index);
	spec->dmic_enabled = index;
3090
	set_widgets_power_state(codec);
L
Lydia Wang 已提交
3091 3092 3093
	return 1;
}

3094
static const struct snd_kcontrol_new vt1716s_dmic_mixer[] = {
L
Lydia Wang 已提交
3095 3096 3097 3098
	HDA_CODEC_VOLUME("Digital Mic Capture Volume", 0x22, 0x0, HDA_INPUT),
	{
	 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
	 .name = "Digital Mic Capture Switch",
3099
	 .subdevice = HDA_SUBDEV_NID_FLAG | 0x26,
L
Lydia Wang 已提交
3100 3101 3102 3103 3104 3105 3106 3107 3108 3109
	 .count = 1,
	 .info = vt1716s_dmic_info,
	 .get = vt1716s_dmic_get,
	 .put = vt1716s_dmic_put,
	 },
	{}			/* end */
};


/* mono-out mixer elements */
3110
static const struct snd_kcontrol_new vt1716S_mono_out_mixer[] = {
L
Lydia Wang 已提交
3111 3112 3113 3114
	HDA_CODEC_MUTE("Mono Playback Switch", 0x2a, 0x0, HDA_OUTPUT),
	{ } /* end */
};

3115
static const struct hda_verb vt1716S_init_verbs[] = {
L
Lydia Wang 已提交
3116 3117 3118 3119 3120 3121 3122 3123 3124
	/* Enable Boost Volume backdoor */
	{0x1, 0xf8a, 0x80},
	/* don't bybass mixer */
	{0x1, 0xf88, 0xc0},
	/* Enable mono output */
	{0x1, 0xf90, 0x08},
	{ }
};

3125 3126 3127 3128 3129 3130 3131 3132 3133 3134 3135 3136 3137 3138 3139 3140 3141 3142 3143 3144 3145 3146 3147 3148 3149 3150 3151 3152 3153 3154 3155 3156 3157 3158 3159 3160 3161 3162 3163 3164 3165 3166 3167 3168 3169 3170 3171 3172 3173 3174 3175 3176 3177 3178 3179 3180 3181 3182 3183 3184 3185 3186 3187 3188 3189 3190 3191 3192 3193 3194 3195 3196 3197 3198 3199 3200 3201 3202 3203 3204 3205 3206 3207 3208 3209 3210 3211 3212 3213 3214 3215 3216 3217
static void set_widgets_power_state_vt1716S(struct hda_codec *codec)
{
	struct via_spec *spec = codec->spec;
	int imux_is_smixer;
	unsigned int parm;
	unsigned int mono_out, present;
	/* SW0 (17h) = stereo mixer */
	imux_is_smixer =
	(snd_hda_codec_read(codec, 0x17, 0,
			    AC_VERB_GET_CONNECT_SEL, 0x00) ==  5);
	/* inputs */
	/* PW 1/2/5 (1ah/1bh/1eh) */
	parm = AC_PWRST_D3;
	set_pin_power_state(codec, 0x1a, &parm);
	set_pin_power_state(codec, 0x1b, &parm);
	set_pin_power_state(codec, 0x1e, &parm);
	if (imux_is_smixer)
		parm = AC_PWRST_D0;
	/* SW0 (17h), AIW0(13h) */
	snd_hda_codec_write(codec, 0x17, 0, AC_VERB_SET_POWER_STATE, parm);
	snd_hda_codec_write(codec, 0x13, 0, AC_VERB_SET_POWER_STATE, parm);

	parm = AC_PWRST_D3;
	set_pin_power_state(codec, 0x1e, &parm);
	/* PW11 (22h) */
	if (spec->dmic_enabled)
		set_pin_power_state(codec, 0x22, &parm);
	else
		snd_hda_codec_write(codec, 0x22, 0,
				    AC_VERB_SET_POWER_STATE, AC_PWRST_D3);

	/* SW2(26h), AIW1(14h) */
	snd_hda_codec_write(codec, 0x26, 0, AC_VERB_SET_POWER_STATE, parm);
	snd_hda_codec_write(codec, 0x14, 0, AC_VERB_SET_POWER_STATE, parm);

	/* outputs */
	/* PW0 (19h), SW1 (18h), AOW1 (11h) */
	parm = AC_PWRST_D3;
	set_pin_power_state(codec, 0x19, &parm);
	/* Smart 5.1 PW2(1bh) */
	if (spec->smart51_enabled)
		set_pin_power_state(codec, 0x1b, &parm);
	snd_hda_codec_write(codec, 0x18, 0, AC_VERB_SET_POWER_STATE, parm);
	snd_hda_codec_write(codec, 0x11, 0, AC_VERB_SET_POWER_STATE, parm);

	/* PW7 (23h), SW3 (27h), AOW3 (25h) */
	parm = AC_PWRST_D3;
	set_pin_power_state(codec, 0x23, &parm);
	/* Smart 5.1 PW1(1ah) */
	if (spec->smart51_enabled)
		set_pin_power_state(codec, 0x1a, &parm);
	snd_hda_codec_write(codec, 0x27, 0, AC_VERB_SET_POWER_STATE, parm);

	/* Smart 5.1 PW5(1eh) */
	if (spec->smart51_enabled)
		set_pin_power_state(codec, 0x1e, &parm);
	snd_hda_codec_write(codec, 0x25, 0, AC_VERB_SET_POWER_STATE, parm);

	/* Mono out */
	/* SW4(28h)->MW1(29h)-> PW12 (2ah)*/
	present = snd_hda_jack_detect(codec, 0x1c);

	if (present)
		mono_out = 0;
	else {
		present = snd_hda_jack_detect(codec, 0x1d);
		if (!spec->hp_independent_mode && present)
			mono_out = 0;
		else
			mono_out = 1;
	}
	parm = mono_out ? AC_PWRST_D0 : AC_PWRST_D3;
	snd_hda_codec_write(codec, 0x28, 0, AC_VERB_SET_POWER_STATE, parm);
	snd_hda_codec_write(codec, 0x29, 0, AC_VERB_SET_POWER_STATE, parm);
	snd_hda_codec_write(codec, 0x2a, 0, AC_VERB_SET_POWER_STATE, parm);

	/* PW 3/4 (1ch/1dh) */
	parm = AC_PWRST_D3;
	set_pin_power_state(codec, 0x1c, &parm);
	set_pin_power_state(codec, 0x1d, &parm);
	/* HP Independent Mode, power on AOW3 */
	if (spec->hp_independent_mode)
		snd_hda_codec_write(codec, 0x25, 0,
				    AC_VERB_SET_POWER_STATE, parm);

	/* force to D0 for internal Speaker */
	/* MW0 (16h), AOW0 (10h) */
	snd_hda_codec_write(codec, 0x16, 0, AC_VERB_SET_POWER_STATE,
			    imux_is_smixer ? AC_PWRST_D0 : parm);
	snd_hda_codec_write(codec, 0x10, 0, AC_VERB_SET_POWER_STATE,
			    mono_out ? AC_PWRST_D0 : parm);
}

L
Lydia Wang 已提交
3218 3219 3220 3221 3222 3223
static int patch_vt1716S(struct hda_codec *codec)
{
	struct via_spec *spec;
	int err;

	/* create a codec specific record */
3224
	spec = via_new_spec(codec);
L
Lydia Wang 已提交
3225 3226 3227
	if (spec == NULL)
		return -ENOMEM;

3228
	spec->aa_mix_nid = 0x16;
3229 3230
	override_mic_boost(codec, 0x1a, 0, 3, 40);
	override_mic_boost(codec, 0x1e, 0, 3, 40);
3231

L
Lydia Wang 已提交
3232
	/* automatic parse from the BIOS config */
3233
	err = via_parse_auto_config(codec);
L
Lydia Wang 已提交
3234 3235 3236 3237 3238
	if (err < 0) {
		via_free(codec);
		return err;
	}

3239
	spec->init_verbs[spec->num_iverbs++]  = vt1716S_init_verbs;
L
Lydia Wang 已提交
3240 3241 3242 3243 3244 3245 3246 3247

	spec->mixers[spec->num_mixers] = vt1716s_dmic_mixer;
	spec->num_mixers++;

	spec->mixers[spec->num_mixers++] = vt1716S_mono_out_mixer;

	codec->patch_ops = via_patch_ops;

3248
	spec->set_widgets_power_state = set_widgets_power_state_vt1716S;
L
Lydia Wang 已提交
3249 3250
	return 0;
}
L
Lydia Wang 已提交
3251 3252 3253

/* for vt2002P */

3254
static const struct hda_verb vt2002P_init_verbs[] = {
3255 3256 3257 3258
	/* Class-D speaker related verbs */
	{0x1, 0xfe0, 0x4},
	{0x1, 0xfe9, 0x80},
	{0x1, 0xfe2, 0x22},
L
Lydia Wang 已提交
3259 3260 3261 3262 3263 3264
	/* Enable Boost Volume backdoor */
	{0x1, 0xfb9, 0x24},
	/* Enable AOW0 to MW9 */
	{0x1, 0xfb8, 0x88},
	{ }
};
3265

3266
static const struct hda_verb vt1802_init_verbs[] = {
3267 3268 3269 3270 3271 3272
	/* Enable Boost Volume backdoor */
	{0x1, 0xfb9, 0x24},
	/* Enable AOW0 to MW9 */
	{0x1, 0xfb8, 0x88},
	{ }
};
L
Lydia Wang 已提交
3273

3274 3275 3276 3277 3278 3279 3280 3281 3282 3283 3284 3285 3286 3287 3288 3289 3290 3291 3292 3293 3294 3295 3296 3297 3298 3299
static void set_widgets_power_state_vt2002P(struct hda_codec *codec)
{
	struct via_spec *spec = codec->spec;
	int imux_is_smixer;
	unsigned int parm;
	unsigned int present;
	/* MUX9 (1eh) = stereo mixer */
	imux_is_smixer =
	snd_hda_codec_read(codec, 0x1e, 0, AC_VERB_GET_CONNECT_SEL, 0x00) == 3;
	/* inputs */
	/* PW 5/6/7 (29h/2ah/2bh) */
	parm = AC_PWRST_D3;
	set_pin_power_state(codec, 0x29, &parm);
	set_pin_power_state(codec, 0x2a, &parm);
	set_pin_power_state(codec, 0x2b, &parm);
	parm = AC_PWRST_D0;
	/* MUX9/10 (1eh/1fh), AIW 0/1 (10h/11h) */
	snd_hda_codec_write(codec, 0x1e, 0, AC_VERB_SET_POWER_STATE, parm);
	snd_hda_codec_write(codec, 0x1f, 0, AC_VERB_SET_POWER_STATE, parm);
	snd_hda_codec_write(codec, 0x10, 0, AC_VERB_SET_POWER_STATE, parm);
	snd_hda_codec_write(codec, 0x11, 0, AC_VERB_SET_POWER_STATE, parm);

	/* outputs */
	/* AOW0 (8h)*/
	snd_hda_codec_write(codec, 0x8, 0, AC_VERB_SET_POWER_STATE, parm);

3300 3301 3302 3303 3304 3305 3306 3307 3308 3309 3310 3311 3312 3313 3314 3315 3316
	if (spec->codec_type == VT1802) {
		/* PW4 (28h), MW4 (18h), MUX4(38h) */
		parm = AC_PWRST_D3;
		set_pin_power_state(codec, 0x28, &parm);
		snd_hda_codec_write(codec, 0x18, 0,
				    AC_VERB_SET_POWER_STATE, parm);
		snd_hda_codec_write(codec, 0x38, 0,
				    AC_VERB_SET_POWER_STATE, parm);
	} else {
		/* PW4 (26h), MW4 (1ch), MUX4(37h) */
		parm = AC_PWRST_D3;
		set_pin_power_state(codec, 0x26, &parm);
		snd_hda_codec_write(codec, 0x1c, 0,
				    AC_VERB_SET_POWER_STATE, parm);
		snd_hda_codec_write(codec, 0x37, 0,
				    AC_VERB_SET_POWER_STATE, parm);
	}
3317

3318 3319 3320 3321 3322 3323 3324 3325 3326 3327 3328 3329 3330 3331 3332 3333 3334
	if (spec->codec_type == VT1802) {
		/* PW1 (25h), MW1 (15h), MUX1(35h), AOW1 (9h) */
		parm = AC_PWRST_D3;
		set_pin_power_state(codec, 0x25, &parm);
		snd_hda_codec_write(codec, 0x15, 0,
				    AC_VERB_SET_POWER_STATE, parm);
		snd_hda_codec_write(codec, 0x35, 0,
				    AC_VERB_SET_POWER_STATE, parm);
	} else {
		/* PW1 (25h), MW1 (19h), MUX1(35h), AOW1 (9h) */
		parm = AC_PWRST_D3;
		set_pin_power_state(codec, 0x25, &parm);
		snd_hda_codec_write(codec, 0x19, 0,
				    AC_VERB_SET_POWER_STATE, parm);
		snd_hda_codec_write(codec, 0x35, 0,
				    AC_VERB_SET_POWER_STATE, parm);
	}
3335 3336 3337 3338 3339 3340 3341 3342 3343 3344 3345 3346

	if (spec->hp_independent_mode)
		snd_hda_codec_write(codec, 0x9, 0,
				    AC_VERB_SET_POWER_STATE, AC_PWRST_D0);

	/* Class-D */
	/* PW0 (24h), MW0(18h/14h), MUX0(34h) */
	present = snd_hda_jack_detect(codec, 0x25);

	parm = AC_PWRST_D3;
	set_pin_power_state(codec, 0x24, &parm);
	parm = present ? AC_PWRST_D3 : AC_PWRST_D0;
3347 3348 3349 3350 3351 3352
	if (spec->codec_type == VT1802)
		snd_hda_codec_write(codec, 0x14, 0,
				    AC_VERB_SET_POWER_STATE, parm);
	else
		snd_hda_codec_write(codec, 0x18, 0,
				    AC_VERB_SET_POWER_STATE, parm);
3353 3354 3355 3356 3357 3358
	snd_hda_codec_write(codec, 0x34, 0, AC_VERB_SET_POWER_STATE, parm);

	/* Mono Out */
	present = snd_hda_jack_detect(codec, 0x26);

	parm = present ? AC_PWRST_D3 : AC_PWRST_D0;
3359 3360 3361 3362 3363 3364 3365 3366 3367 3368 3369 3370 3371 3372 3373 3374 3375
	if (spec->codec_type == VT1802) {
		/* PW15 (33h), MW8(1ch), MUX8(3ch) */
		snd_hda_codec_write(codec, 0x33, 0,
				    AC_VERB_SET_POWER_STATE, parm);
		snd_hda_codec_write(codec, 0x1c, 0,
				    AC_VERB_SET_POWER_STATE, parm);
		snd_hda_codec_write(codec, 0x3c, 0,
				    AC_VERB_SET_POWER_STATE, parm);
	} else {
		/* PW15 (31h), MW8(17h), MUX8(3bh) */
		snd_hda_codec_write(codec, 0x31, 0,
				    AC_VERB_SET_POWER_STATE, parm);
		snd_hda_codec_write(codec, 0x17, 0,
				    AC_VERB_SET_POWER_STATE, parm);
		snd_hda_codec_write(codec, 0x3b, 0,
				    AC_VERB_SET_POWER_STATE, parm);
	}
3376 3377 3378 3379 3380 3381 3382 3383
	/* MW9 (21h) */
	if (imux_is_smixer || !is_aa_path_mute(codec))
		snd_hda_codec_write(codec, 0x21, 0,
				    AC_VERB_SET_POWER_STATE, AC_PWRST_D0);
	else
		snd_hda_codec_write(codec, 0x21, 0,
				    AC_VERB_SET_POWER_STATE, AC_PWRST_D3);
}
L
Lydia Wang 已提交
3384 3385 3386 3387 3388 3389 3390 3391

/* patch for vt2002P */
static int patch_vt2002P(struct hda_codec *codec)
{
	struct via_spec *spec;
	int err;

	/* create a codec specific record */
3392
	spec = via_new_spec(codec);
L
Lydia Wang 已提交
3393 3394 3395
	if (spec == NULL)
		return -ENOMEM;

3396
	spec->aa_mix_nid = 0x21;
3397
	spec->dac_mixer_idx = 3;
3398 3399
	override_mic_boost(codec, 0x2b, 0, 3, 40);
	override_mic_boost(codec, 0x29, 0, 3, 40);
3400

L
Lydia Wang 已提交
3401
	/* automatic parse from the BIOS config */
3402
	err = via_parse_auto_config(codec);
L
Lydia Wang 已提交
3403 3404 3405 3406 3407
	if (err < 0) {
		via_free(codec);
		return err;
	}

3408
	if (spec->codec_type == VT1802)
3409
		spec->init_verbs[spec->num_iverbs++] = vt1802_init_verbs;
3410
	else
3411
		spec->init_verbs[spec->num_iverbs++] = vt2002P_init_verbs;
3412

L
Lydia Wang 已提交
3413 3414
	codec->patch_ops = via_patch_ops;

3415
	spec->set_widgets_power_state =  set_widgets_power_state_vt2002P;
L
Lydia Wang 已提交
3416 3417
	return 0;
}
L
Lydia Wang 已提交
3418 3419 3420

/* for vt1812 */

3421
static const struct hda_verb vt1812_init_verbs[] = {
L
Lydia Wang 已提交
3422 3423 3424 3425 3426 3427 3428
	/* Enable Boost Volume backdoor */
	{0x1, 0xfb9, 0x24},
	/* Enable AOW0 to MW9 */
	{0x1, 0xfb8, 0xa8},
	{ }
};

3429 3430 3431 3432 3433 3434 3435 3436 3437 3438 3439 3440 3441 3442 3443 3444 3445 3446 3447 3448 3449 3450 3451 3452 3453 3454 3455 3456 3457 3458 3459 3460 3461 3462 3463 3464 3465 3466 3467 3468 3469 3470 3471 3472 3473 3474 3475 3476 3477 3478 3479 3480 3481 3482 3483 3484 3485 3486 3487 3488 3489 3490 3491 3492 3493 3494 3495 3496 3497 3498 3499 3500 3501 3502 3503 3504 3505 3506 3507 3508 3509 3510 3511 3512 3513 3514 3515 3516 3517 3518 3519
static void set_widgets_power_state_vt1812(struct hda_codec *codec)
{
	struct via_spec *spec = codec->spec;
	int imux_is_smixer =
	snd_hda_codec_read(codec, 0x13, 0, AC_VERB_GET_CONNECT_SEL, 0x00) == 3;
	unsigned int parm;
	unsigned int present;
	/* MUX10 (1eh) = stereo mixer */
	imux_is_smixer =
	snd_hda_codec_read(codec, 0x1e, 0, AC_VERB_GET_CONNECT_SEL, 0x00) == 5;
	/* inputs */
	/* PW 5/6/7 (29h/2ah/2bh) */
	parm = AC_PWRST_D3;
	set_pin_power_state(codec, 0x29, &parm);
	set_pin_power_state(codec, 0x2a, &parm);
	set_pin_power_state(codec, 0x2b, &parm);
	parm = AC_PWRST_D0;
	/* MUX10/11 (1eh/1fh), AIW 0/1 (10h/11h) */
	snd_hda_codec_write(codec, 0x1e, 0, AC_VERB_SET_POWER_STATE, parm);
	snd_hda_codec_write(codec, 0x1f, 0, AC_VERB_SET_POWER_STATE, parm);
	snd_hda_codec_write(codec, 0x10, 0, AC_VERB_SET_POWER_STATE, parm);
	snd_hda_codec_write(codec, 0x11, 0, AC_VERB_SET_POWER_STATE, parm);

	/* outputs */
	/* AOW0 (8h)*/
	snd_hda_codec_write(codec, 0x8, 0,
			    AC_VERB_SET_POWER_STATE, AC_PWRST_D0);

	/* PW4 (28h), MW4 (18h), MUX4(38h) */
	parm = AC_PWRST_D3;
	set_pin_power_state(codec, 0x28, &parm);
	snd_hda_codec_write(codec, 0x18, 0, AC_VERB_SET_POWER_STATE, parm);
	snd_hda_codec_write(codec, 0x38, 0, AC_VERB_SET_POWER_STATE, parm);

	/* PW1 (25h), MW1 (15h), MUX1(35h), AOW1 (9h) */
	parm = AC_PWRST_D3;
	set_pin_power_state(codec, 0x25, &parm);
	snd_hda_codec_write(codec, 0x15, 0, AC_VERB_SET_POWER_STATE, parm);
	snd_hda_codec_write(codec, 0x35, 0, AC_VERB_SET_POWER_STATE, parm);
	if (spec->hp_independent_mode)
		snd_hda_codec_write(codec, 0x9, 0,
				    AC_VERB_SET_POWER_STATE, AC_PWRST_D0);

	/* Internal Speaker */
	/* PW0 (24h), MW0(14h), MUX0(34h) */
	present = snd_hda_jack_detect(codec, 0x25);

	parm = AC_PWRST_D3;
	set_pin_power_state(codec, 0x24, &parm);
	if (present) {
		snd_hda_codec_write(codec, 0x14, 0,
				    AC_VERB_SET_POWER_STATE, AC_PWRST_D3);
		snd_hda_codec_write(codec, 0x34, 0,
				    AC_VERB_SET_POWER_STATE, AC_PWRST_D3);
	} else {
		snd_hda_codec_write(codec, 0x14, 0,
				    AC_VERB_SET_POWER_STATE, AC_PWRST_D0);
		snd_hda_codec_write(codec, 0x34, 0,
				    AC_VERB_SET_POWER_STATE, AC_PWRST_D0);
	}


	/* Mono Out */
	/* PW13 (31h), MW13(1ch), MUX13(3ch), MW14(3eh) */
	present = snd_hda_jack_detect(codec, 0x28);

	parm = AC_PWRST_D3;
	set_pin_power_state(codec, 0x31, &parm);
	if (present) {
		snd_hda_codec_write(codec, 0x1c, 0,
				    AC_VERB_SET_POWER_STATE, AC_PWRST_D3);
		snd_hda_codec_write(codec, 0x3c, 0,
				    AC_VERB_SET_POWER_STATE, AC_PWRST_D3);
		snd_hda_codec_write(codec, 0x3e, 0,
				    AC_VERB_SET_POWER_STATE, AC_PWRST_D3);
	} else {
		snd_hda_codec_write(codec, 0x1c, 0,
				    AC_VERB_SET_POWER_STATE, AC_PWRST_D0);
		snd_hda_codec_write(codec, 0x3c, 0,
				    AC_VERB_SET_POWER_STATE, AC_PWRST_D0);
		snd_hda_codec_write(codec, 0x3e, 0,
				    AC_VERB_SET_POWER_STATE, AC_PWRST_D0);
	}

	/* PW15 (33h), MW15 (1dh), MUX15(3dh) */
	parm = AC_PWRST_D3;
	set_pin_power_state(codec, 0x33, &parm);
	snd_hda_codec_write(codec, 0x1d, 0, AC_VERB_SET_POWER_STATE, parm);
	snd_hda_codec_write(codec, 0x3d, 0, AC_VERB_SET_POWER_STATE, parm);

}
L
Lydia Wang 已提交
3520 3521 3522 3523 3524 3525 3526 3527

/* patch for vt1812 */
static int patch_vt1812(struct hda_codec *codec)
{
	struct via_spec *spec;
	int err;

	/* create a codec specific record */
3528
	spec = via_new_spec(codec);
L
Lydia Wang 已提交
3529 3530 3531
	if (spec == NULL)
		return -ENOMEM;

3532
	spec->aa_mix_nid = 0x21;
3533 3534
	override_mic_boost(codec, 0x2b, 0, 3, 40);
	override_mic_boost(codec, 0x29, 0, 3, 40);
3535
	spec->dac_mixer_idx = 5;
3536

L
Lydia Wang 已提交
3537
	/* automatic parse from the BIOS config */
3538
	err = via_parse_auto_config(codec);
L
Lydia Wang 已提交
3539 3540 3541 3542 3543
	if (err < 0) {
		via_free(codec);
		return err;
	}

3544
	spec->init_verbs[spec->num_iverbs++]  = vt1812_init_verbs;
L
Lydia Wang 已提交
3545 3546 3547

	codec->patch_ops = via_patch_ops;

3548
	spec->set_widgets_power_state =  set_widgets_power_state_vt1812;
L
Lydia Wang 已提交
3549 3550 3551
	return 0;
}

3552 3553 3554
/*
 * patch entries
 */
3555
static const struct hda_codec_preset snd_hda_preset_via[] = {
3556 3557 3558 3559 3560
	{ .id = 0x11061708, .name = "VT1708", .patch = patch_vt1708},
	{ .id = 0x11061709, .name = "VT1708", .patch = patch_vt1708},
	{ .id = 0x1106170a, .name = "VT1708", .patch = patch_vt1708},
	{ .id = 0x1106170b, .name = "VT1708", .patch = patch_vt1708},
	{ .id = 0x1106e710, .name = "VT1709 10-Ch",
3561
	  .patch = patch_vt1709},
3562
	{ .id = 0x1106e711, .name = "VT1709 10-Ch",
3563
	  .patch = patch_vt1709},
3564
	{ .id = 0x1106e712, .name = "VT1709 10-Ch",
3565
	  .patch = patch_vt1709},
3566
	{ .id = 0x1106e713, .name = "VT1709 10-Ch",
3567
	  .patch = patch_vt1709},
3568
	{ .id = 0x1106e714, .name = "VT1709 6-Ch",
3569
	  .patch = patch_vt1709},
3570
	{ .id = 0x1106e715, .name = "VT1709 6-Ch",
3571
	  .patch = patch_vt1709},
3572
	{ .id = 0x1106e716, .name = "VT1709 6-Ch",
3573
	  .patch = patch_vt1709},
3574
	{ .id = 0x1106e717, .name = "VT1709 6-Ch",
3575
	  .patch = patch_vt1709},
3576
	{ .id = 0x1106e720, .name = "VT1708B 8-Ch",
3577
	  .patch = patch_vt1708B},
3578
	{ .id = 0x1106e721, .name = "VT1708B 8-Ch",
3579
	  .patch = patch_vt1708B},
3580
	{ .id = 0x1106e722, .name = "VT1708B 8-Ch",
3581
	  .patch = patch_vt1708B},
3582
	{ .id = 0x1106e723, .name = "VT1708B 8-Ch",
3583
	  .patch = patch_vt1708B},
3584
	{ .id = 0x1106e724, .name = "VT1708B 4-Ch",
3585
	  .patch = patch_vt1708B},
3586
	{ .id = 0x1106e725, .name = "VT1708B 4-Ch",
3587
	  .patch = patch_vt1708B},
3588
	{ .id = 0x1106e726, .name = "VT1708B 4-Ch",
3589
	  .patch = patch_vt1708B},
3590
	{ .id = 0x1106e727, .name = "VT1708B 4-Ch",
3591
	  .patch = patch_vt1708B},
3592
	{ .id = 0x11060397, .name = "VT1708S",
3593
	  .patch = patch_vt1708S},
3594
	{ .id = 0x11061397, .name = "VT1708S",
3595
	  .patch = patch_vt1708S},
3596
	{ .id = 0x11062397, .name = "VT1708S",
3597
	  .patch = patch_vt1708S},
3598
	{ .id = 0x11063397, .name = "VT1708S",
3599
	  .patch = patch_vt1708S},
3600
	{ .id = 0x11064397, .name = "VT1705",
3601
	  .patch = patch_vt1708S},
3602
	{ .id = 0x11065397, .name = "VT1708S",
3603
	  .patch = patch_vt1708S},
3604
	{ .id = 0x11066397, .name = "VT1708S",
3605
	  .patch = patch_vt1708S},
3606
	{ .id = 0x11067397, .name = "VT1708S",
3607
	  .patch = patch_vt1708S},
3608
	{ .id = 0x11060398, .name = "VT1702",
3609
	  .patch = patch_vt1702},
3610
	{ .id = 0x11061398, .name = "VT1702",
3611
	  .patch = patch_vt1702},
3612
	{ .id = 0x11062398, .name = "VT1702",
3613
	  .patch = patch_vt1702},
3614
	{ .id = 0x11063398, .name = "VT1702",
3615
	  .patch = patch_vt1702},
3616
	{ .id = 0x11064398, .name = "VT1702",
3617
	  .patch = patch_vt1702},
3618
	{ .id = 0x11065398, .name = "VT1702",
3619
	  .patch = patch_vt1702},
3620
	{ .id = 0x11066398, .name = "VT1702",
3621
	  .patch = patch_vt1702},
3622
	{ .id = 0x11067398, .name = "VT1702",
3623
	  .patch = patch_vt1702},
L
Lydia Wang 已提交
3624 3625 3626 3627
	{ .id = 0x11060428, .name = "VT1718S",
	  .patch = patch_vt1718S},
	{ .id = 0x11064428, .name = "VT1718S",
	  .patch = patch_vt1718S},
3628 3629 3630 3631
	{ .id = 0x11060441, .name = "VT2020",
	  .patch = patch_vt1718S},
	{ .id = 0x11064441, .name = "VT1828S",
	  .patch = patch_vt1718S},
L
Lydia Wang 已提交
3632 3633 3634 3635
	{ .id = 0x11060433, .name = "VT1716S",
	  .patch = patch_vt1716S},
	{ .id = 0x1106a721, .name = "VT1716S",
	  .patch = patch_vt1716S},
L
Lydia Wang 已提交
3636 3637
	{ .id = 0x11060438, .name = "VT2002P", .patch = patch_vt2002P},
	{ .id = 0x11064438, .name = "VT2002P", .patch = patch_vt2002P},
L
Lydia Wang 已提交
3638
	{ .id = 0x11060448, .name = "VT1812", .patch = patch_vt1812},
3639 3640
	{ .id = 0x11060440, .name = "VT1818S",
	  .patch = patch_vt1708S},
3641 3642 3643 3644
	{ .id = 0x11060446, .name = "VT1802",
		.patch = patch_vt2002P},
	{ .id = 0x11068446, .name = "VT1802",
		.patch = patch_vt2002P},
3645 3646
	{} /* terminator */
};
3647 3648 3649 3650 3651 3652 3653 3654 3655 3656 3657 3658 3659 3660 3661 3662 3663 3664 3665 3666 3667 3668 3669

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

static struct hda_codec_preset_list via_list = {
	.preset = snd_hda_preset_via,
	.owner = THIS_MODULE,
};

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

static int __init patch_via_init(void)
{
	return snd_hda_add_codec_preset(&via_list);
}

static void __exit patch_via_exit(void)
{
	snd_hda_delete_codec_preset(&via_list);
}

module_init(patch_via_init)
module_exit(patch_via_exit)